lttng-sessiond/ust-app.c

   1 /*
   2  * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; only version 2
   7  * of the License.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19 #define _GNU_SOURCE
  20 #include <errno.h>
  21 #include <pthread.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <sys/stat.h>
  26 #include <sys/types.h>
  27 #include <unistd.h>
  28
  29 #include <urcu/compiler.h>
  30 #include <lttngerr.h>
  31 #include <lttng-share.h>
  32
  33 #include "hashtable.h"
  34 #include "ust-app.h"
  35 #include "ust-consumer.h"
  36 #include "ust-ctl.h"
  37
  38 /*
  39  * Delete ust app event safely. RCU read lock must be held before calling
  40  * this function.
  41  */
  42 static void delete_ust_app_event(int sock, struct ust_app_event *ua_event)
  43 {
  44         /* TODO : remove context */
  45         //struct ust_app_ctx *ltctx;
  46         //cds_lfht_for_each_entry(lte->ctx, &iter, ltctx, node) {
  47         //      delete_ust_app_ctx(sock, ltctx);
  48         //}
  49
  50         ustctl_release_object(sock, ua_event->obj);
  51         free(ua_event->obj);
  52         free(ua_event);
  53 }
  54
  55 /*
  56  * Delete ust app stream safely. RCU read lock must be held before calling
  57  * this function.
  58  */
  59 static void delete_ust_app_stream(int sock, struct ltt_ust_stream *stream)
  60 {
  61         ustctl_release_object(sock, stream->obj);
  62         free(stream->obj);
  63         free(stream);
  64 }
  65
  66 /*
  67  * Delete ust app channel safely. RCU read lock must be held before calling
  68  * this function.
  69  */
  70 static void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan)
  71 {
  72         int ret;
  73         struct cds_lfht_iter iter;
  74         struct ust_app_event *ua_event;
  75         struct ltt_ust_stream *stream, *stmp;
  76
  77         cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
  78                 cds_list_del(&stream->list);
  79                 delete_ust_app_stream(sock, stream);
  80         }
  81
  82         /* TODO : remove channel context */
  83         //cds_lfht_for_each_entry(ltc->ctx, &iter, ltctx, node) {
  84         //      hashtable_del(ltc->ctx, &iter);
  85         //      delete_ust_app_ctx(sock, ltctx);
  86         //}
  87         //ret = hashtable_destroy(ltc->ctx);
  88
  89         cds_lfht_for_each_entry(ua_chan->events, &iter, ua_event, node) {
  90                 hashtable_del(ua_chan->events, &iter);
  91                 delete_ust_app_event(sock, ua_event);
  92         }
  93
  94         ret = hashtable_destroy(ua_chan->events);
  95         if (ret < 0) {
  96                 ERR("UST app destroy session hashtable failed");
  97                 goto error;
  98         }
  99         ustctl_release_object(sock, ua_chan->obj);
 100         free(ua_chan->obj);
 101         free(ua_chan);
 102
 103 error:
 104         return;
 105 }
 106
 107 /*
 108  * Delete ust app session safely. RCU read lock must be held before calling
 109  * this function.
 110  */
 111 static void delete_ust_app_session(int sock,
 112                 struct ust_app_session *ua_sess)
 113 {
 114         int ret;
 115         struct cds_lfht_iter iter;
 116         struct ust_app_channel *ua_chan;
 117
 118         if (ua_sess->metadata) {
 119                 ustctl_release_object(sock, ua_sess->metadata->stream_obj);
 120                 free(ua_sess->metadata->stream_obj);
 121                 ustctl_release_object(sock, ua_sess->metadata->obj);
 122                 free(ua_sess->metadata->obj);
 123         }
 124
 125         cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
 126                 hashtable_del(ua_sess->channels, &iter);
 127                 delete_ust_app_channel(sock, ua_chan);
 128         }
 129
 130         ret = hashtable_destroy(ua_sess->channels);
 131         if (ret < 0) {
 132                 ERR("UST app destroy session hashtable failed");
 133                 goto error;
 134         }
 135
 136 error:
 137         return;
 138 }
 139
 140 /*
 141  * Delete a traceable application structure from the global list. Never call
 142  * this function outside of a call_rcu call.
 143  */
 144 static void delete_ust_app(struct ust_app *app)
 145 {
 146         int ret;
 147         struct cds_lfht_node *node;
 148         struct cds_lfht_iter iter;
 149         struct ust_app_session *ua_sess;
 150         int sock;
 151
 152         rcu_read_lock();
 153
 154         /* Remove from key hash table */
 155         node = hashtable_lookup(ust_app_sock_key_map,
 156                         (void *) ((unsigned long) app->key.sock), sizeof(void *), &iter);
 157         if (node == NULL) {
 158                 /* Not suppose to happen */
 159                 ERR("UST app key %d not found in key hash table", app->key.sock);
 160                 goto end;
 161         }
 162
 163         ret = hashtable_del(ust_app_sock_key_map, &iter);
 164         if (ret) {
 165                 ERR("UST app unable to delete app sock %d from key hash table",
 166                                 app->key.sock);
 167         } else {
 168                 DBG2("UST app pair sock %d key %d deleted",
 169                                 app->key.sock, app->key.pid);
 170         }
 171
 172         /* Socket is already closed at this point */
 173
 174         /* Delete ust app sessions info */
 175         sock = app->key.sock;
 176         app->key.sock = -1;
 177
 178         cds_lfht_for_each_entry(app->sessions, &iter, ua_sess, node) {
 179                 hashtable_del(app->sessions, &iter);
 180                 delete_ust_app_session(app->key.sock, ua_sess);
 181         }
 182
 183         ret = hashtable_destroy(app->sessions);
 184         if (ret < 0) {
 185                 ERR("UST app destroy session hashtable failed");
 186                 goto end;
 187         }
 188
 189         /*
 190          * Wait until we have removed the key from the sock hash table
 191          * before closing this socket, otherwise an application could
 192          * re-use the socket ID and race with the teardown, using the
 193          * same hash table entry.
 194          */
 195         close(sock);
 196
 197         DBG2("UST app pid %d deleted", app->key.pid);
 198         free(app);
 199 end:
 200         rcu_read_unlock();
 201 }
 202
 203 /*
 204  * URCU intermediate call to delete an UST app.
 205  */
 206 static void delete_ust_app_rcu(struct rcu_head *head)
 207 {
 208         struct cds_lfht_node *node =
 209                 caa_container_of(head, struct cds_lfht_node, head);
 210         struct ust_app *app =
 211                 caa_container_of(node, struct ust_app, node);
 212
 213         delete_ust_app(app);
 214 }
 215
 216 /*
 217  * Find an ust_app using the sock and return it. RCU read side lock must be
 218  * held before calling this helper function.
 219  */
 220 static struct ust_app *find_app_by_sock(int sock)
 221 {
 222         struct cds_lfht_node *node;
 223         struct ust_app_key *key;
 224         struct cds_lfht_iter iter;
 225
 226         node = hashtable_lookup(ust_app_sock_key_map,
 227                         (void *)((unsigned long) sock), sizeof(void *), &iter);
 228         if (node == NULL) {
 229                 DBG2("UST app find by sock %d key not found", sock);
 230                 goto error;
 231         }
 232
 233         key = caa_container_of(node, struct ust_app_key, node);
 234
 235         node = hashtable_lookup(ust_app_ht,
 236                         (void *)((unsigned long) key->pid), sizeof(void *), &iter);
 237         if (node == NULL) {
 238                 DBG2("UST app find by sock %d not found", sock);
 239                 goto error;
 240         }
 241         return caa_container_of(node, struct ust_app, node);
 242
 243 error:
 244         return NULL;
 245 }
 246
 247 /*
 248  * Open metadata onto the UST tracer for a UST session.
 249  */
 250 static int open_ust_metadata(struct ust_app *app,
 251                 struct ust_app_session *ua_sess)
 252 {
 253         int ret;
 254         struct lttng_ust_channel_attr uattr;
 255
 256         uattr.overwrite = ua_sess->metadata->attr.overwrite;
 257         uattr.subbuf_size = ua_sess->metadata->attr.subbuf_size;
 258         uattr.num_subbuf = ua_sess->metadata->attr.num_subbuf;
 259         uattr.switch_timer_interval =
 260                 ua_sess->metadata->attr.switch_timer_interval;
 261         uattr.read_timer_interval =
 262                 ua_sess->metadata->attr.read_timer_interval;
 263         uattr.output = ua_sess->metadata->attr.output;
 264
 265         /* UST tracer metadata creation */
 266         ret = ustctl_open_metadata(app->key.sock, ua_sess->handle, &uattr,
 267                         &ua_sess->metadata->obj);
 268         if (ret < 0) {
 269                 ERR("UST app open metadata failed for app pid:%d",
 270                                 app->key.pid);
 271                 goto error;
 272         }
 273
 274 error:
 275         return ret;
 276 }
 277
 278 /*
 279  * Create stream onto the UST tracer for a UST session.
 280  */
 281 static int create_ust_stream(struct ust_app *app,
 282                 struct ust_app_session *ua_sess)
 283 {
 284         int ret;
 285
 286         ret = ustctl_create_stream(app->key.sock, ua_sess->metadata->obj,
 287                         &ua_sess->metadata->stream_obj);
 288         if (ret < 0) {
 289                 ERR("UST create metadata stream failed");
 290                 goto error;
 291         }
 292
 293 error:
 294         return ret;
 295 }
 296
 297 /*
 298  * Create the specified channel onto the UST tracer for a UST session.
 299  */
 300 static int create_ust_channel(struct ust_app *app,
 301                 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
 302 {
 303         int ret;
 304
 305         /* TODO: remove cast and use lttng-ust-abi.h */
 306         ret = ustctl_create_channel(app->key.sock, ua_sess->handle,
 307                         (struct lttng_ust_channel_attr *)&ua_chan->attr, &ua_chan->obj);
 308         if (ret < 0) {
 309                 DBG("Error creating channel %s for app (pid: %d, sock: %d) "
 310                                 "and session handle %d with ret %d",
 311                                 ua_chan->name, app->key.pid, app->key.sock,
 312                                 ua_sess->handle, ret);
 313                 goto error;
 314         }
 315
 316         ua_chan->handle = ua_chan->obj->handle;
 317         ua_chan->attr.shm_fd = ua_chan->obj->shm_fd;
 318         ua_chan->attr.wait_fd = ua_chan->obj->wait_fd;
 319         ua_chan->attr.memory_map_size = ua_chan->obj->memory_map_size;
 320
 321         DBG2("UST app channel %s created successfully for pid:%d and sock:%d",
 322                         ua_chan->name, app->key.pid, app->key.sock);
 323
 324 error:
 325         return ret;
 326 }
 327
 328 /*
 329  * Create the specified event onto the UST tracer for a UST session.
 330  */
 331 static int create_ust_event(struct ust_app *app,
 332                 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan,
 333                 struct ust_app_event *ua_event)
 334 {
 335         int ret = 0;
 336
 337         /* Create UST event on tracer */
 338         ret = ustctl_create_event(app->key.sock, &ua_event->attr, ua_chan->obj,
 339                         &ua_event->obj);
 340         if (ret < 0) {
 341                 ERR("Error ustctl create event %s for app pid: %d with ret %d",
 342                                 ua_event->attr.name, app->key.pid, ret);
 343                 goto error;
 344         }
 345
 346         ua_event->handle = ua_event->obj->handle;
 347         ua_event->enabled = 1;
 348
 349         DBG2("UST app event %s created successfully for pid:%d",
 350                         ua_event->attr.name, app->key.pid);
 351
 352 error:
 353         return ret;
 354 }
 355
 356 /*
 357  * Alloc new UST app session.
 358  */
 359 static struct ust_app_session *alloc_ust_app_session(void)
 360 {
 361         struct ust_app_session *ua_sess;
 362
 363         /* Init most of the default value by allocating and zeroing */
 364         ua_sess = zmalloc(sizeof(struct ust_app_session));
 365         if (ua_sess == NULL) {
 366                 PERROR("malloc");
 367                 goto error;
 368         }
 369
 370         ua_sess->handle = -1;
 371         ua_sess->channels = hashtable_new_str(0);
 372
 373         return ua_sess;
 374
 375 error:
 376         return NULL;
 377 }
 378
 379 /*
 380  * Alloc new UST app channel.
 381  */
 382 static struct ust_app_channel *alloc_ust_app_channel(char *name,
 383                 struct lttng_ust_channel *attr)
 384 {
 385         struct ust_app_channel *ua_chan;
 386
 387         /* Init most of the default value by allocating and zeroing */
 388         ua_chan = zmalloc(sizeof(struct ust_app_channel));
 389         if (ua_chan == NULL) {
 390                 PERROR("malloc");
 391                 goto error;
 392         }
 393
 394         /* Setup channel name */
 395         strncpy(ua_chan->name, name, sizeof(ua_chan->name));
 396         ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
 397
 398         ua_chan->handle = -1;
 399         ua_chan->ctx = hashtable_new(0);
 400         ua_chan->events = hashtable_new_str(0);
 401         hashtable_node_init(&ua_chan->node, (void *) ua_chan->name,
 402                         strlen(ua_chan->name));
 403
 404         CDS_INIT_LIST_HEAD(&ua_chan->streams.head);
 405
 406         /* Copy attributes */
 407         if (attr) {
 408                 memcpy(&ua_chan->attr, attr, sizeof(ua_chan->attr));
 409         }
 410
 411         DBG3("UST app channel %s allocated", ua_chan->name);
 412
 413         return ua_chan;
 414
 415 error:
 416         return NULL;
 417 }
 418
 419 /*
 420  * Alloc new UST app event.
 421  */
 422 static struct ust_app_event *alloc_ust_app_event(char *name,
 423                 struct lttng_ust_event *attr)
 424 {
 425         struct ust_app_event *ua_event;
 426
 427         /* Init most of the default value by allocating and zeroing */
 428         ua_event = zmalloc(sizeof(struct ust_app_event));
 429         if (ua_event == NULL) {
 430                 PERROR("malloc");
 431                 goto error;
 432         }
 433
 434         strncpy(ua_event->name, name, sizeof(ua_event->name));
 435         ua_event->name[sizeof(ua_event->name) - 1] = '\0';
 436         ua_event->ctx = hashtable_new(0);
 437         hashtable_node_init(&ua_event->node, (void *) ua_event->name,
 438                         strlen(ua_event->name));
 439
 440         /* Copy attributes */
 441         if (attr) {
 442                 memcpy(&ua_event->attr, attr, sizeof(ua_event->attr));
 443         }
 444
 445         DBG3("UST app event %s allocated", ua_event->name);
 446
 447         return ua_event;
 448
 449 error:
 450         return NULL;
 451 }
 452
 453 /*
 454  * Copy data between an UST app event and a LTT event.
 455  */
 456 static void shadow_copy_event(struct ust_app_event *ua_event,
 457                 struct ltt_ust_event *uevent)
 458 {
 459         strncpy(ua_event->name, uevent->attr.name, sizeof(ua_event->name));
 460         ua_event->name[sizeof(ua_event->name) - 1] = '\0';
 461
 462         /* Copy event attributes */
 463         memcpy(&ua_event->attr, &uevent->attr, sizeof(ua_event->attr));
 464
 465         /* TODO: support copy context */
 466 }
 467
 468 /*
 469  * Copy data between an UST app channel and a LTT channel.
 470  */
 471 static void shadow_copy_channel(struct ust_app_channel *ua_chan,
 472                 struct ltt_ust_channel *uchan)
 473 {
 474         struct cds_lfht_iter iter;
 475         struct cds_lfht_node *ua_event_node;
 476         struct ltt_ust_event *uevent;
 477         struct ust_app_event *ua_event;
 478
 479         DBG2("Shadow copy of UST app channel %s", ua_chan->name);
 480
 481         strncpy(ua_chan->name, uchan->name, sizeof(ua_chan->name));
 482         ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
 483         /* Copy event attributes */
 484         memcpy(&ua_chan->attr, &uchan->attr, sizeof(ua_chan->attr));
 485
 486         /* TODO: support copy context */
 487
 488         /* Copy all events from ltt ust channel to ust app channel */
 489         cds_lfht_for_each_entry(uchan->events, &iter, uevent, node) {
 490                 struct cds_lfht_iter uiter;
 491
 492                 ua_event_node = hashtable_lookup(ua_chan->events,
 493                                 (void *) uevent->attr.name, strlen(uevent->attr.name),
 494                                 &uiter);
 495                 if (ua_event_node == NULL) {
 496                         DBG2("UST event %s not found on shadow copy channel",
 497                                         uevent->attr.name);
 498                         ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
 499                         if (ua_event == NULL) {
 500                                 continue;
 501                         }
 502                         shadow_copy_event(ua_event, uevent);
 503                         hashtable_add_unique(ua_chan->events, &ua_event->node);
 504                 }
 505         }
 506
 507         DBG3("Shadow copy channel done");
 508 }
 509
 510 /*
 511  * Copy data between a UST app session and a regular LTT session.
 512  */
 513 static void shadow_copy_session(struct ust_app_session *ua_sess,
 514                 struct ltt_ust_session *usess,
 515                 struct ust_app *app)
 516 {
 517         struct cds_lfht_node *ua_chan_node;
 518         struct cds_lfht_iter iter;
 519         struct ltt_ust_channel *uchan;
 520         struct ust_app_channel *ua_chan;
 521         time_t rawtime;
 522         struct tm *timeinfo;
 523         char datetime[16];
 524         int ret;
 525
 526         /* Get date and time for unique app path */
 527         time(&rawtime);
 528         timeinfo = localtime(&rawtime);
 529         strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S", timeinfo);
 530
 531         DBG2("Shadow copy of session handle %d", ua_sess->handle);
 532
 533         ua_sess->uid = usess->uid;
 534
 535         ret = snprintf(ua_sess->path, PATH_MAX,
 536                         "%s/%s-%d-%s",
 537                         usess->pathname, app->name, app->key.pid,
 538                         datetime);
 539         if (ret < 0) {
 540                 PERROR("asprintf UST shadow copy session");
 541                 /* TODO: We cannot return an error from here.. */
 542                 assert(0);
 543         }
 544
 545         /* TODO: support all UST domain */
 546
 547         /* Iterate over all channels in global domain. */
 548         cds_lfht_for_each_entry(usess->domain_global.channels, &iter,
 549                         uchan, node) {
 550                 struct cds_lfht_iter uiter;
 551
 552                 ua_chan_node = hashtable_lookup(ua_sess->channels,
 553                                 (void *)uchan->name, strlen(uchan->name),
 554                                 &uiter);
 555                 if (ua_chan_node != NULL) {
 556                         continue;
 557                 }
 558
 559                 DBG2("Channel %s not found on shadow session copy, creating it",
 560                                 uchan->name);
 561                 ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
 562                 if (ua_chan == NULL) {
 563                         /* malloc failed... continuing */
 564                         continue;
 565                 }
 566
 567                 shadow_copy_channel(ua_chan, uchan);
 568                 hashtable_add_unique(ua_sess->channels, &ua_chan->node);
 569         }
 570 }
 571
 572 static
 573 void __lookup_session_by_app(struct ltt_ust_session *usess,
 574                         struct ust_app *app, struct cds_lfht_iter *iter)
 575 {
 576         /* Get right UST app session from app */
 577         (void) hashtable_lookup(app->sessions,
 578                         (void *) ((unsigned long) usess->uid), sizeof(void *),
 579                         iter);
 580 }
 581
 582 /*
 583  * Return ust app session from the app session hashtable using the UST session
 584  * uid.
 585  */
 586 static struct ust_app_session *lookup_session_by_app(
 587                 struct ltt_ust_session *usess, struct ust_app *app)
 588 {
 589         struct cds_lfht_iter iter;
 590         struct cds_lfht_node *node;
 591
 592         __lookup_session_by_app(usess, app, &iter);
 593         node = hashtable_iter_get_node(&iter);
 594         if (node == NULL) {
 595                 goto error;
 596         }
 597
 598         return caa_container_of(node, struct ust_app_session, node);
 599
 600 error:
 601         return NULL;
 602 }
 603
 604 /*
 605  * Create a UST session onto the tracer of app and add it the session
 606  * hashtable.
 607  *
 608  * Return ust app session or NULL on error.
 609  */
 610 static struct ust_app_session *create_ust_app_session(
 611                 struct ltt_ust_session *usess, struct ust_app *app)
 612 {
 613         int ret;
 614         struct ust_app_session *ua_sess;
 615
 616         ua_sess = lookup_session_by_app(usess, app);
 617         if (ua_sess == NULL) {
 618                 DBG2("UST app pid: %d session uid %d not found, creating it",
 619                                 app->key.pid, usess->uid);
 620                 ua_sess = alloc_ust_app_session();
 621                 if (ua_sess == NULL) {
 622                         /* Only malloc can failed so something is really wrong */
 623                         goto error;
 624                 }
 625                 shadow_copy_session(ua_sess, usess, app);
 626         }
 627
 628         if (ua_sess->handle == -1) {
 629                 ret = ustctl_create_session(app->key.sock);
 630                 if (ret < 0) {
 631                         ERR("Error creating session for app pid %d, sock %d",
 632                                         app->key.pid, app->key.sock);
 633                         /* TODO: free() ua_sess */
 634                         goto error;
 635                 }
 636
 637                 DBG2("UST app ustctl create session handle %d", ret);
 638                 ua_sess->handle = ret;
 639
 640                 /* Add ust app session to app's HT */
 641                 hashtable_node_init(&ua_sess->node,
 642                                 (void *)((unsigned long) ua_sess->uid), sizeof(void *));
 643                 hashtable_add_unique(app->sessions, &ua_sess->node);
 644
 645                 DBG2("UST app session created successfully with handle %d", ret);
 646         }
 647
 648         return ua_sess;
 649
 650 error:
 651         return NULL;
 652 }
 653
 654 /*
 655  * Create UST app channel and create it on the tracer.
 656  */
 657 static struct ust_app_channel *create_ust_app_channel(
 658                 struct ust_app_session *ua_sess, struct ltt_ust_channel *uchan,
 659                 struct ust_app *app)
 660 {
 661         int ret = 0;
 662         struct cds_lfht_iter iter;
 663         struct cds_lfht_node *ua_chan_node;
 664         struct ust_app_channel *ua_chan;
 665
 666         /* Lookup channel in the ust app session */
 667         ua_chan_node = hashtable_lookup(ua_sess->channels,
 668                         (void *)uchan->name, strlen(uchan->name), &iter);
 669         if (ua_chan_node == NULL) {
 670                 DBG2("Unable to find channel %s in ust session uid %u",
 671                                 uchan->name, ua_sess->uid);
 672                 ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
 673                 if (ua_chan == NULL) {
 674                         goto error;
 675                 }
 676                 shadow_copy_channel(ua_chan, uchan);
 677
 678                 hashtable_add_unique(ua_sess->channels, &ua_chan->node);
 679         } else {
 680                 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
 681         }
 682
 683         ret = create_ust_channel(app, ua_sess, ua_chan);
 684         if (ret < 0) {
 685                 goto error;
 686         }
 687
 688         return ua_chan;
 689
 690 error:
 691         return NULL;
 692 }
 693
 694 /*
 695  * Create UST app event and create it on the tracer side.
 696  */
 697 static struct ust_app_event *create_ust_app_event(
 698                 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan,
 699                 struct ltt_ust_event *uevent, struct ust_app *app)
 700 {
 701         int ret;
 702         struct cds_lfht_iter iter;
 703         struct cds_lfht_node *ua_event_node;
 704         struct ust_app_event *ua_event;
 705
 706         /* Get event node */
 707         ua_event_node = hashtable_lookup(ua_chan->events,
 708                         (void *)uevent->attr.name, strlen(uevent->attr.name), &iter);
 709         if (ua_event_node == NULL) {
 710                 DBG2("UST app event %s not found, creating it", uevent->attr.name);
 711                 /* Does not exist so create one */
 712                 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
 713                 if (ua_event == NULL) {
 714                         /* Only malloc can failed so something is really wrong */
 715                         goto error;
 716                 }
 717                 shadow_copy_event(ua_event, uevent);
 718
 719                 hashtable_add_unique(ua_chan->events, &ua_event->node);
 720         } else {
 721                 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
 722         }
 723
 724         ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
 725         if (ret < 0) {
 726                 goto error;
 727         }
 728
 729         return ua_event;
 730
 731 error:
 732         return NULL;
 733 }
 734
 735 /*
 736  * Create UST metadata and open it on the tracer side.
 737  */
 738 static int create_ust_app_metadata(struct ust_app_session *ua_sess,
 739                 char *pathname, struct ust_app *app)
 740 {
 741         int ret = 0;
 742
 743         if (ua_sess->metadata == NULL) {
 744                 /* Allocate UST metadata */
 745                 ua_sess->metadata = trace_ust_create_metadata(pathname);
 746                 if (ua_sess->metadata == NULL) {
 747                         ERR("UST app session %d creating metadata failed",
 748                                         ua_sess->handle);
 749                         goto error;
 750                 }
 751
 752                 ret = open_ust_metadata(app, ua_sess);
 753                 if (ret < 0) {
 754                         goto error;
 755                 }
 756
 757                 DBG2("UST metadata opened for app pid %d", app->key.pid);
 758         }
 759
 760         /* Open UST metadata stream */
 761         if (ua_sess->metadata->stream_obj == NULL) {
 762                 ret = create_ust_stream(app, ua_sess);
 763                 if (ret < 0) {
 764                         goto error;
 765                 }
 766
 767                 ret = mkdir(ua_sess->path, S_IRWXU | S_IRWXG);
 768                 if (ret < 0) {
 769                         PERROR("mkdir UST metadata");
 770                         goto error;
 771                 }
 772
 773                 ret = snprintf(ua_sess->metadata->pathname, PATH_MAX,
 774                                 "%s/metadata", ua_sess->path);
 775                 if (ret < 0) {
 776                         PERROR("asprintf UST create stream");
 777                         goto error;
 778                 }
 779
 780                 DBG2("UST metadata stream object created for app pid %d",
 781                                 app->key.pid);
 782         } else {
 783                 ERR("Attempting to create stream without metadata opened");
 784                 goto error;
 785         }
 786
 787         return 0;
 788
 789 error:
 790         return -1;
 791 }
 792
 793 /*
 794  * Return pointer to traceable apps list.
 795  */
 796 struct cds_lfht *ust_app_get_ht(void)
 797 {
 798         return ust_app_ht;
 799 }
 800
 801 /*
 802  * Return ust app pointer or NULL if not found.
 803  */
 804 struct ust_app *ust_app_find_by_pid(pid_t pid)
 805 {
 806         struct cds_lfht_node *node;
 807         struct cds_lfht_iter iter;
 808
 809         rcu_read_lock();
 810         node = hashtable_lookup(ust_app_ht,
 811                         (void *)((unsigned long) pid), sizeof(void *), &iter);
 812         if (node == NULL) {
 813                 DBG2("UST app no found with pid %d", pid);
 814                 goto error;
 815         }
 816         rcu_read_unlock();
 817
 818         DBG2("Found UST app by pid %d", pid);
 819
 820         return caa_container_of(node, struct ust_app, node);
 821
 822 error:
 823         rcu_read_unlock();
 824         return NULL;
 825 }
 826
 827 /*
 828  * Using pid and uid (of the app), allocate a new ust_app struct and
 829  * add it to the global traceable app list.
 830  *
 831  * On success, return 0, else return malloc -ENOMEM, or -EINVAL if app
 832  * bitness is not supported.
 833  */
 834 int ust_app_register(struct ust_register_msg *msg, int sock)
 835 {
 836         struct ust_app *lta;
 837
 838         /*
 839          * Currently support only tracing of application which share the
 840          * same bitness as the consumer. Eventually implement dispatch
 841          * to specific compat32 consumer.
 842          */
 843         if (msg->bits_per_long != CAA_BITS_PER_LONG) {
 844                 ERR("Registration failed: application %s (pid: %d) has "
 845                         "%d-bit long, but only "
 846                         "%d-bit lttng-consumerd is available.\n",
 847                         msg->name, msg->pid, msg->bits_per_long,
 848                         CAA_BITS_PER_LONG);
 849                 return -EINVAL;
 850         }
 851
 852         lta = zmalloc(sizeof(struct ust_app));
 853         if (lta == NULL) {
 854                 PERROR("malloc");
 855                 return -ENOMEM;
 856         }
 857
 858         lta->ppid = msg->ppid;
 859         lta->uid = msg->uid;
 860         lta->gid = msg->gid;
 861         lta->v_major = msg->major;
 862         lta->v_minor = msg->minor;
 863         strncpy(lta->name, msg->name, sizeof(lta->name));
 864         lta->name[16] = '\0';
 865         lta->sessions = hashtable_new(0);
 866
 867         /* Set key map */
 868         lta->key.pid = msg->pid;
 869         hashtable_node_init(&lta->node, (void *)((unsigned long)lta->key.pid),
 870                         sizeof(void *));
 871         lta->key.sock = sock;
 872         hashtable_node_init(&lta->key.node, (void *)((unsigned long)lta->key.sock),
 873                         sizeof(void *));
 874
 875         rcu_read_lock();
 876         hashtable_add_unique(ust_app_sock_key_map, &lta->key.node);
 877         hashtable_add_unique(ust_app_ht, &lta->node);
 878         rcu_read_unlock();
 879
 880         DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s"
 881                         " (version %d.%d)", lta->key.pid, lta->ppid, lta->uid, lta->gid,
 882                         lta->key.sock, lta->name, lta->v_major, lta->v_minor);
 883
 884         return 0;
 885 }
 886
 887 /*
 888  * Unregister app by removing it from the global traceable app list and freeing
 889  * the data struct.
 890  *
 891  * The socket is already closed at this point so no close to sock.
 892  */
 893 void ust_app_unregister(int sock)
 894 {
 895         struct ust_app *lta;
 896         struct cds_lfht_node *node;
 897         struct cds_lfht_iter iter;
 898
 899         rcu_read_lock();
 900         lta = find_app_by_sock(sock);
 901         if (lta == NULL) {
 902                 ERR("Unregister app sock %d not found!", sock);
 903                 goto error;
 904         }
 905
 906         DBG("PID %d unregistering with sock %d", lta->key.pid, sock);
 907
 908         /* Get the node reference for a call_rcu */
 909         node = hashtable_lookup(ust_app_ht,
 910                         (void *)((unsigned long) lta->key.pid), sizeof(void *), &iter);
 911         if (node == NULL) {
 912                 ERR("Unable to find app sock %d by pid %d", sock, lta->key.pid);
 913                 goto error;
 914         }
 915
 916         hashtable_del(ust_app_ht, &iter);
 917         call_rcu(&node->head, delete_ust_app_rcu);
 918 error:
 919         rcu_read_unlock();
 920         return;
 921 }
 922
 923 /*
 924  * Return traceable_app_count
 925  */
 926 unsigned long ust_app_list_count(void)
 927 {
 928         unsigned long count;
 929
 930         rcu_read_lock();
 931         count = hashtable_get_count(ust_app_ht);
 932         rcu_read_unlock();
 933
 934         return count;
 935 }
 936
 937 /*
 938  * Fill events array with all events name of all registered apps.
 939  */
 940 int ust_app_list_events(struct lttng_event **events)
 941 {
 942         int ret, handle;
 943         size_t nbmem, count = 0;
 944         struct cds_lfht_iter iter;
 945         struct ust_app *app;
 946         struct lttng_event *tmp;
 947
 948         nbmem = UST_APP_EVENT_LIST_SIZE;
 949         tmp = zmalloc(nbmem * sizeof(struct lttng_event));
 950         if (tmp == NULL) {
 951                 PERROR("zmalloc ust app events");
 952                 ret = -ENOMEM;
 953                 goto error;
 954         }
 955
 956         rcu_read_lock();
 957
 958         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
 959                 handle = ustctl_tracepoint_list(app->key.sock);
 960                 if (handle < 0) {
 961                         ERR("UST app list events getting handle failed for app pid %d",
 962                                         app->key.pid);
 963                         continue;
 964                 }
 965
 966                 while ((ret = ustctl_tracepoint_list_get(app->key.sock, handle,
 967                                                 tmp[count].name)) != -ENOENT) {
 968                         if (count > nbmem) {
 969                                 DBG2("Reallocating event list from %zu to %zu bytes", nbmem,
 970                                                 nbmem + UST_APP_EVENT_LIST_SIZE);
 971                                 nbmem += UST_APP_EVENT_LIST_SIZE;
 972                                 tmp = realloc(tmp, nbmem);
 973                                 if (tmp == NULL) {
 974                                         PERROR("realloc ust app events");
 975                                         ret = -ENOMEM;
 976                                         goto rcu_error;
 977                                 }
 978                         }
 979
 980                         tmp[count].type = LTTNG_UST_TRACEPOINT;
 981                         tmp[count].pid = app->key.pid;
 982                         tmp[count].enabled = -1;
 983                         count++;
 984                 }
 985         }
 986
 987         ret = count;
 988         *events = tmp;
 989
 990         DBG2("UST app list events done (%zu events)", count);
 991
 992 rcu_error:
 993         rcu_read_unlock();
 994 error:
 995         return ret;
 996 }
 997
 998 /*
 999  * Free and clean all traceable apps of the global list.
1000  */
1001 void ust_app_clean_list(void)
1002 {
1003         int ret;
1004         struct cds_lfht_node *node;
1005         struct cds_lfht_iter iter;
1006         struct ust_app *app;
1007
1008         DBG2("UST app cleaning registered apps hash table");
1009
1010         rcu_read_lock();
1011
1012         cds_lfht_for_each(ust_app_ht, &iter, node) {
1013                 app = caa_container_of(node, struct ust_app, node);
1014
1015                 ret = hashtable_del(ust_app_ht, &iter);
1016                 if (!ret) {
1017                         call_rcu(&node->head, delete_ust_app_rcu);
1018                 }
1019         }
1020
1021         hashtable_destroy(ust_app_ht);
1022         hashtable_destroy(ust_app_sock_key_map);
1023
1024         rcu_read_unlock();
1025 }
1026
1027 /*
1028  * Init UST app hash table.
1029  */
1030 void ust_app_ht_alloc(void)
1031 {
1032         ust_app_ht = hashtable_new(0);
1033         ust_app_sock_key_map = hashtable_new(0);
1034 }
1035
1036 /*
1037  * For a specific UST session, create the channel for all registered apps.
1038  */
1039 int ust_app_create_channel_all(struct ltt_ust_session *usess,
1040                 struct ltt_ust_channel *uchan)
1041 {
1042         int ret = 0;
1043         struct cds_lfht_iter iter;
1044         struct ust_app *app;
1045         struct ust_app_session *ua_sess;
1046         struct ust_app_channel *ua_chan;
1047
1048         if (usess == NULL || uchan == NULL) {
1049                 ERR("Adding UST global channel to NULL values");
1050                 ret = -1;
1051                 goto error;
1052         }
1053
1054         DBG2("UST app adding channel %s to global domain for session uid %d",
1055                         uchan->name, usess->uid);
1056
1057         rcu_read_lock();
1058
1059         /* For every registered applications */
1060         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1061                 /* Create session on the tracer side and add it to app session HT */
1062                 ua_sess = create_ust_app_session(usess, app);
1063                 if (ua_sess == NULL) {
1064                         continue;
1065                 }
1066
1067                 /* Create channel onto application */
1068                 ua_chan = create_ust_app_channel(ua_sess, uchan, app);
1069                 if (ua_chan == NULL) {
1070                         continue;
1071                 }
1072         }
1073
1074         rcu_read_unlock();
1075
1076 error:
1077         return ret;
1078 }
1079
1080 /*
1081  * For a specific UST session and UST channel, create the event for all
1082  * registered apps.
1083  */
1084 int ust_app_create_event_all(struct ltt_ust_session *usess,
1085                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
1086 {
1087         int ret = 0;
1088         struct cds_lfht_iter iter;
1089         struct cds_lfht_node *ua_chan_node;
1090         struct ust_app *app;
1091         struct ust_app_session *ua_sess;
1092         struct ust_app_channel *ua_chan;
1093         struct ust_app_event *ua_event;
1094
1095         DBG("UST app creating event %s for all apps for session uid %d",
1096                         uevent->attr.name, usess->uid);
1097
1098         rcu_read_lock();
1099
1100         /* For all registered applications */
1101         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1102                 struct cds_lfht_iter uiter;
1103
1104                 /* Create session on the tracer side and add it to app session HT */
1105                 ua_sess = create_ust_app_session(usess, app);
1106                 if (ua_sess == NULL) {
1107                         continue;
1108                 }
1109
1110                 /* Lookup channel in the ust app session */
1111                 ua_chan_node = hashtable_lookup(ua_sess->channels,
1112                                 (void *)uchan->name, strlen(uchan->name),
1113                                 &uiter);
1114                 if (ua_chan_node == NULL) {
1115                         ERR("Channel %s not found in session uid %d. Skipping",
1116                                         uchan->name, usess->uid);
1117                         continue;
1118                 }
1119                 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1120
1121                 ua_event = create_ust_app_event(ua_sess, ua_chan, uevent, app);
1122                 if (ua_event == NULL) {
1123                         continue;
1124                 }
1125         }
1126
1127         rcu_read_unlock();
1128
1129         return ret;
1130 }
1131
1132 /*
1133  * Start tracing for a specific UST session and app.
1134  */
1135 int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
1136 {
1137         int ret = 0;
1138         struct cds_lfht_iter iter;
1139         struct ust_app_session *ua_sess;
1140         struct ust_app_channel *ua_chan;
1141         struct ltt_ust_stream *ustream;
1142
1143         DBG("Starting tracing for ust app pid %d", app->key.pid);
1144
1145         rcu_read_lock();
1146
1147         ua_sess = lookup_session_by_app(usess, app);
1148         if (ua_sess == NULL) {
1149                 /* Only malloc can failed so something is really wrong */
1150                 goto error_rcu_unlock;
1151         }
1152
1153         /* upon restart, we skip the setup, already done */
1154         if (ua_sess->started)
1155                 goto skip_setup;
1156
1157         ret = create_ust_app_metadata(ua_sess, usess->pathname, app);
1158         if (ret < 0) {
1159                 goto error_rcu_unlock;
1160         }
1161
1162         /* For each channel */
1163         cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
1164                 /* Create all streams */
1165                 while (1) {
1166                         /* Create UST stream */
1167                         ustream = zmalloc(sizeof(*ustream));
1168                         if (ustream == NULL) {
1169                                 PERROR("zmalloc ust stream");
1170                                 goto error_rcu_unlock;
1171                         }
1172
1173                         ret = ustctl_create_stream(app->key.sock, ua_chan->obj,
1174                                         &ustream->obj);
1175                         if (ret < 0) {
1176                                 /* Got all streams */
1177                                 break;
1178                         }
1179                         ustream->handle = ustream->obj->handle;
1180
1181                         /* Order is important */
1182                         cds_list_add_tail(&ustream->list, &ua_chan->streams.head);
1183                         ret = snprintf(ustream->pathname, PATH_MAX, "%s/%s_%u",
1184                                         ua_sess->path, ua_chan->name,
1185                                         ua_chan->streams.count++);
1186                         if (ret < 0) {
1187                                 PERROR("asprintf UST create stream");
1188                                 continue;
1189                         }
1190                         DBG2("UST stream %d ready at %s", ua_chan->streams.count,
1191                                         ustream->pathname);
1192                 }
1193         }
1194
1195         /* Setup UST consumer socket and send fds to it */
1196         ret = ust_consumer_send_session(ust_consumer_fd, ua_sess);
1197         if (ret < 0) {
1198                 goto error_rcu_unlock;
1199         }
1200         ua_sess->started = 1;
1201
1202 skip_setup:
1203         /* This start the UST tracing */
1204         ret = ustctl_start_session(app->key.sock, ua_sess->handle);
1205         if (ret < 0) {
1206                 ERR("Error starting tracing for app pid: %d", app->key.pid);
1207                 goto error_rcu_unlock;
1208         }
1209
1210         rcu_read_unlock();
1211
1212         /* Quiescent wait after starting trace */
1213         ustctl_wait_quiescent(app->key.sock);
1214
1215         return 0;
1216
1217 error_rcu_unlock:
1218         rcu_read_unlock();
1219         return -1;
1220 }
1221
1222 /*
1223  * Stop tracing for a specific UST session and app.
1224  */
1225 int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app)
1226 {
1227         int ret = 0;
1228         struct ust_app_session *ua_sess;
1229
1230         DBG("Stopping tracing for ust app pid %d", app->key.pid);
1231
1232         rcu_read_lock();
1233
1234         ua_sess = lookup_session_by_app(usess, app);
1235         if (ua_sess == NULL) {
1236                 /* Only malloc can failed so something is really wrong */
1237                 goto error_rcu_unlock;
1238         }
1239
1240 #if 0   /* only useful when periodical flush will be supported */
1241         /* need to keep a handle on shm in session for this. */
1242         /* Flush all buffers before stopping */
1243         ret = ustctl_flush_buffer(usess->sock, usess->metadata->obj);
1244         if (ret < 0) {
1245                 ERR("UST metadata flush failed");
1246         }
1247
1248         cds_list_for_each_entry(ustchan, &usess->channels.head, list) {
1249                 ret = ustctl_flush_buffer(usess->sock, ustchan->obj);
1250                 if (ret < 0) {
1251                         ERR("UST flush buffer error");
1252                 }
1253         }
1254 #endif
1255
1256         /* This inhibits UST tracing */
1257         ret = ustctl_stop_session(app->key.sock, ua_sess->handle);
1258         if (ret < 0) {
1259                 ERR("Error stopping tracing for app pid: %d", app->key.pid);
1260                 goto error_rcu_unlock;
1261         }
1262
1263         rcu_read_unlock();
1264
1265         /* Quiescent wait after stopping trace */
1266         ustctl_wait_quiescent(app->key.sock);
1267
1268         return 0;
1269
1270 error_rcu_unlock:
1271         rcu_read_unlock();
1272         return -1;
1273 }
1274
1275 /*
1276  * Destroy a specific UST session in apps.
1277  */
1278 int ust_app_destroy_trace(struct ltt_ust_session *usess, struct ust_app *app)
1279 {
1280         struct ust_app_session *ua_sess;
1281         struct lttng_ust_object_data obj;
1282         struct cds_lfht_iter iter;
1283         struct cds_lfht_node *node;
1284
1285         DBG("Destroy tracing for ust app pid %d", app->key.pid);
1286
1287         rcu_read_lock();
1288
1289         __lookup_session_by_app(usess, app, &iter);
1290         node = hashtable_iter_get_node(&iter);
1291         if (node == NULL) {
1292                 /* Only malloc can failed so something is really wrong */
1293                 goto error_rcu_unlock;
1294         }
1295         ua_sess = caa_container_of(node, struct ust_app_session, node);
1296         hashtable_del(app->sessions, &iter);
1297         delete_ust_app_session(app->key.sock, ua_sess);
1298         obj.handle = ua_sess->handle;
1299         obj.shm_fd = -1;
1300         obj.wait_fd = -1;
1301         obj.memory_map_size = 0;
1302         ustctl_release_object(app->key.sock, &obj);
1303
1304         rcu_read_unlock();
1305
1306         /* Quiescent wait after stopping trace */
1307         ustctl_wait_quiescent(app->key.sock);
1308
1309         return 0;
1310
1311 error_rcu_unlock:
1312         rcu_read_unlock();
1313         return -1;
1314 }
1315
1316 /*
1317  * Start tracing for the UST session.
1318  */
1319 int ust_app_start_trace_all(struct ltt_ust_session *usess)
1320 {
1321         int ret = 0;
1322         struct cds_lfht_iter iter;
1323         struct ust_app *app;
1324
1325         DBG("Starting all UST traces");
1326
1327         rcu_read_lock();
1328
1329         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1330                 ret = ust_app_start_trace(usess, app);
1331                 if (ret < 0) {
1332                         /* Continue to next apps even on error */
1333                         continue;
1334                 }
1335         }
1336
1337         rcu_read_unlock();
1338
1339         return 0;
1340 }
1341
1342 /*
1343  * Start tracing for the UST session.
1344  */
1345 int ust_app_stop_trace_all(struct ltt_ust_session *usess)
1346 {
1347         int ret = 0;
1348         struct cds_lfht_iter iter;
1349         struct ust_app *app;
1350
1351         DBG("Stopping all UST traces");
1352
1353         rcu_read_lock();
1354
1355         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1356                 ret = ust_app_stop_trace(usess, app);
1357                 if (ret < 0) {
1358                         /* Continue to next apps even on error */
1359                         continue;
1360                 }
1361         }
1362
1363         rcu_read_unlock();
1364
1365         return 0;
1366 }
1367
1368 /*
1369  * Destroy app UST session.
1370  */
1371 int ust_app_destroy_trace_all(struct ltt_ust_session *usess)
1372 {
1373         int ret = 0;
1374         struct cds_lfht_iter iter;
1375         struct ust_app *app;
1376
1377         DBG("Destroy all UST traces");
1378
1379         rcu_read_lock();
1380
1381         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1382                 ret = ust_app_destroy_trace(usess, app);
1383                 if (ret < 0) {
1384                         /* Continue to next apps even on error */
1385                         continue;
1386                 }
1387         }
1388
1389         rcu_read_unlock();
1390
1391         return 0;
1392 }
1393
1394 /*
1395  * Add channels/events from UST global domain to registered apps at sock.
1396  */
1397 void ust_app_global_update(struct ltt_ust_session *usess, int sock)
1398 {
1399         int ret = 0;
1400         struct cds_lfht_iter iter;
1401         struct ust_app *app;
1402         struct ust_app_session *ua_sess;
1403         struct ust_app_channel *ua_chan;
1404         struct ust_app_event *ua_event;
1405
1406         if (usess == NULL) {
1407                 ERR("No UST session on global update. Returning");
1408                 goto error;
1409         }
1410
1411         DBG2("UST app global update for app sock %d for session uid %d", sock,
1412                         usess->uid);
1413
1414         rcu_read_lock();
1415
1416         app = find_app_by_sock(sock);
1417         if (app == NULL) {
1418                 ERR("Failed to update app sock %d", sock);
1419                 goto error;
1420         }
1421
1422         ua_sess = create_ust_app_session(usess, app);
1423         if (ua_sess == NULL) {
1424                 goto error;
1425         }
1426
1427         /*
1428          * We can iterate safely here over all UST app session sicne the create ust
1429          * app session above made a shadow copy of the UST global domain from the
1430          * ltt ust session.
1431          */
1432         cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
1433                 ret = create_ust_channel(app, ua_sess, ua_chan);
1434                 if (ret < 0) {
1435                         /* FIXME: Should we quit here or continue... */
1436                         continue;
1437                 }
1438
1439                 /* For each events */
1440                 cds_lfht_for_each_entry(ua_chan->events, &iter, ua_event, node) {
1441                         ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
1442                         if (ret < 0) {
1443                                 /* FIXME: Should we quit here or continue... */
1444                                 continue;
1445                         }
1446                 }
1447         }
1448
1449         if (usess->start_trace) {
1450                 ret = ust_app_start_trace(usess, app);
1451                 if (ret < 0) {
1452                         goto error;
1453                 }
1454
1455                 DBG2("UST trace started for app pid %d", app->key.pid);
1456         }
1457
1458 error:
1459         rcu_read_unlock();
1460         return;
1461 }