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 context safely. RCU read lock must be held before calling
  40  * this function.
  41  */
  42 static
  43 void delete_ust_app_ctx(int sock, struct ust_app_ctx *ua_ctx)
  44 {
  45         if (ua_ctx->obj) {
  46                 ustctl_release_object(sock, ua_ctx->obj);
  47                 free(ua_ctx->obj);
  48         }
  49         free(ua_ctx);
  50 }
  51
  52 /*
  53  * Delete ust app event safely. RCU read lock must be held before calling
  54  * this function.
  55  */
  56 static
  57 void delete_ust_app_event(int sock, struct ust_app_event *ua_event)
  58 {
  59         int ret;
  60         struct cds_lfht_iter iter;
  61         struct ust_app_ctx *ua_ctx;
  62
  63         cds_lfht_for_each_entry(ua_event->ctx, &iter, ua_ctx, node) {
  64                 ret = hashtable_del(ua_event->ctx, &iter);
  65                 assert(!ret);
  66                 delete_ust_app_ctx(sock, ua_ctx);
  67         }
  68         ret = hashtable_destroy(ua_event->ctx);
  69         assert(!ret);
  70
  71         if (ua_event->obj != NULL) {
  72                 ustctl_release_object(sock, ua_event->obj);
  73                 free(ua_event->obj);
  74         }
  75         free(ua_event);
  76 }
  77
  78 /*
  79  * Delete ust app stream safely. RCU read lock must be held before calling
  80  * this function.
  81  */
  82 static
  83 void delete_ust_app_stream(int sock, struct ltt_ust_stream *stream)
  84 {
  85         if (stream->obj) {
  86                 ustctl_release_object(sock, stream->obj);
  87                 free(stream->obj);
  88         }
  89         free(stream);
  90 }
  91
  92 /*
  93  * Delete ust app channel safely. RCU read lock must be held before calling
  94  * this function.
  95  */
  96 static
  97 void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan)
  98 {
  99         int ret;
 100         struct cds_lfht_iter iter;
 101         struct ust_app_event *ua_event;
 102         struct ust_app_ctx *ua_ctx;
 103         struct ltt_ust_stream *stream, *stmp;
 104
 105         /* Wipe stream */
 106         cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
 107                 cds_list_del(&stream->list);
 108                 delete_ust_app_stream(sock, stream);
 109         }
 110
 111         /* Wipe context */
 112         cds_lfht_for_each_entry(ua_chan->ctx, &iter, ua_ctx, node) {
 113                 ret = hashtable_del(ua_chan->ctx, &iter);
 114                 assert(!ret);
 115                 delete_ust_app_ctx(sock, ua_ctx);
 116         }
 117         ret = hashtable_destroy(ua_chan->ctx);
 118         assert(!ret);
 119
 120         /* Wipe events */
 121         cds_lfht_for_each_entry(ua_chan->events, &iter, ua_event, node) {
 122                 ret = hashtable_del(ua_chan->events, &iter);
 123                 assert(!ret);
 124                 delete_ust_app_event(sock, ua_event);
 125         }
 126         ret = hashtable_destroy(ua_chan->events);
 127         assert(!ret);
 128
 129         if (ua_chan->obj != NULL) {
 130                 ustctl_release_object(sock, ua_chan->obj);
 131                 free(ua_chan->obj);
 132         }
 133         free(ua_chan);
 134 }
 135
 136 /*
 137  * Delete ust app session safely. RCU read lock must be held before calling
 138  * this function.
 139  */
 140 static
 141 void delete_ust_app_session(int sock, struct ust_app_session *ua_sess)
 142 {
 143         int ret;
 144         struct cds_lfht_iter iter;
 145         struct ust_app_channel *ua_chan;
 146
 147         if (ua_sess->metadata) {
 148                 if (ua_sess->metadata->stream_obj) {
 149                         ustctl_release_object(sock, ua_sess->metadata->stream_obj);
 150                         free(ua_sess->metadata->stream_obj);
 151                 }
 152                 if (ua_sess->metadata->obj) {
 153                         ustctl_release_object(sock, ua_sess->metadata->obj);
 154                         free(ua_sess->metadata->obj);
 155                 }
 156         }
 157
 158         cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
 159                 ret = hashtable_del(ua_sess->channels, &iter);
 160                 assert(!ret);
 161                 delete_ust_app_channel(sock, ua_chan);
 162         }
 163         ret = hashtable_destroy(ua_sess->channels);
 164         assert(!ret);
 165
 166         free(ua_sess);
 167 }
 168
 169 /*
 170  * Delete a traceable application structure from the global list. Never call
 171  * this function outside of a call_rcu call.
 172  */
 173 static
 174 void delete_ust_app(struct ust_app *app)
 175 {
 176         int ret, sock;
 177         struct cds_lfht_node *node;
 178         struct cds_lfht_iter iter;
 179         struct ust_app_session *ua_sess;
 180
 181         rcu_read_lock();
 182
 183         /* Remove from key hash table */
 184         node = hashtable_lookup(ust_app_sock_key_map,
 185                         (void *) ((unsigned long) app->key.sock), sizeof(void *), &iter);
 186         if (node == NULL) {
 187                 /* Not suppose to happen */
 188                 ERR("UST app key %d not found in key hash table", app->key.sock);
 189                 goto end;
 190         }
 191
 192         ret = hashtable_del(ust_app_sock_key_map, &iter);
 193         if (ret) {
 194                 ERR("UST app unable to delete app sock %d from key hash table",
 195                                 app->key.sock);
 196         } else {
 197                 DBG2("UST app pair sock %d key %d deleted",
 198                                 app->key.sock, app->key.pid);
 199         }
 200
 201         /* Socket is already closed at this point */
 202
 203         /* Delete ust app sessions info */
 204         sock = app->key.sock;
 205         app->key.sock = -1;
 206
 207         /* Wipe sessions */
 208         cds_lfht_for_each_entry(app->sessions, &iter, ua_sess, node) {
 209                 ret = hashtable_del(app->sessions, &iter);
 210                 assert(!ret);
 211                 delete_ust_app_session(app->key.sock, ua_sess);
 212         }
 213         ret = hashtable_destroy(app->sessions);
 214         assert(!ret);
 215
 216         /*
 217          * Wait until we have removed the key from the sock hash table
 218          * before closing this socket, otherwise an application could
 219          * re-use the socket ID and race with the teardown, using the
 220          * same hash table entry.
 221          */
 222         close(sock);
 223
 224         DBG2("UST app pid %d deleted", app->key.pid);
 225         free(app);
 226 end:
 227         rcu_read_unlock();
 228 }
 229
 230 /*
 231  * URCU intermediate call to delete an UST app.
 232  */
 233 static
 234 void delete_ust_app_rcu(struct rcu_head *head)
 235 {
 236         struct cds_lfht_node *node =
 237                 caa_container_of(head, struct cds_lfht_node, head);
 238         struct ust_app *app =
 239                 caa_container_of(node, struct ust_app, node);
 240
 241         delete_ust_app(app);
 242 }
 243
 244 /*
 245  * Alloc new UST app session.
 246  */
 247 static
 248 struct ust_app_session *alloc_ust_app_session(void)
 249 {
 250         struct ust_app_session *ua_sess;
 251
 252         /* Init most of the default value by allocating and zeroing */
 253         ua_sess = zmalloc(sizeof(struct ust_app_session));
 254         if (ua_sess == NULL) {
 255                 PERROR("malloc");
 256                 goto error;
 257         }
 258
 259         ua_sess->handle = -1;
 260         ua_sess->channels = hashtable_new_str(0);
 261
 262         return ua_sess;
 263
 264 error:
 265         return NULL;
 266 }
 267
 268 /*
 269  * Alloc new UST app channel.
 270  */
 271 static
 272 struct ust_app_channel *alloc_ust_app_channel(char *name,
 273                 struct lttng_ust_channel *attr)
 274 {
 275         struct ust_app_channel *ua_chan;
 276
 277         /* Init most of the default value by allocating and zeroing */
 278         ua_chan = zmalloc(sizeof(struct ust_app_channel));
 279         if (ua_chan == NULL) {
 280                 PERROR("malloc");
 281                 goto error;
 282         }
 283
 284         /* Setup channel name */
 285         strncpy(ua_chan->name, name, sizeof(ua_chan->name));
 286         ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
 287
 288         ua_chan->enabled = 1;
 289         ua_chan->handle = -1;
 290         ua_chan->ctx = hashtable_new(0);
 291         ua_chan->events = hashtable_new_str(0);
 292         hashtable_node_init(&ua_chan->node, (void *) ua_chan->name,
 293                         strlen(ua_chan->name));
 294
 295         CDS_INIT_LIST_HEAD(&ua_chan->streams.head);
 296
 297         /* Copy attributes */
 298         if (attr) {
 299                 memcpy(&ua_chan->attr, attr, sizeof(ua_chan->attr));
 300         }
 301
 302         DBG3("UST app channel %s allocated", ua_chan->name);
 303
 304         return ua_chan;
 305
 306 error:
 307         return NULL;
 308 }
 309
 310 /*
 311  * Alloc new UST app event.
 312  */
 313 static
 314 struct ust_app_event *alloc_ust_app_event(char *name,
 315                 struct lttng_ust_event *attr)
 316 {
 317         struct ust_app_event *ua_event;
 318
 319         /* Init most of the default value by allocating and zeroing */
 320         ua_event = zmalloc(sizeof(struct ust_app_event));
 321         if (ua_event == NULL) {
 322                 PERROR("malloc");
 323                 goto error;
 324         }
 325
 326         ua_event->enabled = 1;
 327         strncpy(ua_event->name, name, sizeof(ua_event->name));
 328         ua_event->name[sizeof(ua_event->name) - 1] = '\0';
 329         ua_event->ctx = hashtable_new(0);
 330         hashtable_node_init(&ua_event->node, (void *) ua_event->name,
 331                         strlen(ua_event->name));
 332
 333         /* Copy attributes */
 334         if (attr) {
 335                 memcpy(&ua_event->attr, attr, sizeof(ua_event->attr));
 336         }
 337
 338         DBG3("UST app event %s allocated", ua_event->name);
 339
 340         return ua_event;
 341
 342 error:
 343         return NULL;
 344 }
 345
 346 /*
 347  * Alloc new UST app context.
 348  */
 349 static
 350 struct ust_app_ctx *alloc_ust_app_ctx(struct lttng_ust_context *uctx)
 351 {
 352         struct ust_app_ctx *ua_ctx;
 353
 354         ua_ctx = zmalloc(sizeof(struct ust_app_ctx));
 355         if (ua_ctx == NULL) {
 356                 goto error;
 357         }
 358
 359         if (uctx) {
 360                 memcpy(&ua_ctx->ctx, uctx, sizeof(ua_ctx->ctx));
 361         }
 362
 363         DBG3("UST app context %d allocated", ua_ctx->ctx.ctx);
 364
 365 error:
 366         return ua_ctx;
 367 }
 368
 369 /*
 370  * Find an ust_app using the sock and return it. RCU read side lock must be
 371  * held before calling this helper function.
 372  */
 373 static
 374 struct ust_app *find_app_by_sock(int sock)
 375 {
 376         struct cds_lfht_node *node;
 377         struct ust_app_key *key;
 378         struct cds_lfht_iter iter;
 379
 380         node = hashtable_lookup(ust_app_sock_key_map,
 381                         (void *)((unsigned long) sock), sizeof(void *), &iter);
 382         if (node == NULL) {
 383                 DBG2("UST app find by sock %d key not found", sock);
 384                 goto error;
 385         }
 386
 387         key = caa_container_of(node, struct ust_app_key, node);
 388
 389         node = hashtable_lookup(ust_app_ht,
 390                         (void *)((unsigned long) key->pid), sizeof(void *), &iter);
 391         if (node == NULL) {
 392                 DBG2("UST app find by sock %d not found", sock);
 393                 goto error;
 394         }
 395         return caa_container_of(node, struct ust_app, node);
 396
 397 error:
 398         return NULL;
 399 }
 400
 401 /*
 402  * Create the channel context on the tracer.
 403  */
 404 static
 405 int create_ust_channel_context(struct ust_app_channel *ua_chan,
 406                 struct ust_app_ctx *ua_ctx, struct ust_app *app)
 407 {
 408         int ret;
 409
 410         ret = ustctl_add_context(app->key.sock, &ua_ctx->ctx,
 411                         ua_chan->obj, &ua_ctx->obj);
 412         if (ret < 0) {
 413                 goto error;
 414         }
 415
 416         ua_ctx->handle = ua_ctx->obj->handle;
 417
 418         DBG2("UST app context added to channel %s successfully", ua_chan->name);
 419
 420 error:
 421         return ret;
 422 }
 423
 424 /*
 425  * Create the event context on the tracer.
 426  */
 427 static
 428 int create_ust_event_context(struct ust_app_event *ua_event,
 429                 struct ust_app_ctx *ua_ctx, struct ust_app *app)
 430 {
 431         int ret;
 432
 433         ret = ustctl_add_context(app->key.sock, &ua_ctx->ctx,
 434                         ua_event->obj, &ua_ctx->obj);
 435         if (ret < 0) {
 436                 goto error;
 437         }
 438
 439         ua_ctx->handle = ua_ctx->obj->handle;
 440
 441         DBG2("UST app context added to event %s successfully", ua_event->name);
 442
 443 error:
 444         return ret;
 445 }
 446
 447 /*
 448  * Disable the specified event on to UST tracer for the UST session.
 449  */
 450 static int disable_ust_event(struct ust_app *app,
 451                 struct ust_app_session *ua_sess, struct ust_app_event *ua_event)
 452 {
 453         int ret;
 454
 455         ret = ustctl_disable(app->key.sock, ua_event->obj);
 456         if (ret < 0) {
 457                 ERR("UST app event %s disable failed for app (pid: %d) "
 458                                 "and session handle %d with ret %d",
 459                                 ua_event->attr.name, app->key.pid, ua_sess->handle, ret);
 460                 goto error;
 461         }
 462
 463         DBG2("UST app event %s disabled successfully for app (pid: %d)",
 464                         ua_event->attr.name, app->key.pid);
 465
 466 error:
 467         return ret;
 468 }
 469
 470 /*
 471  * Disable the specified channel on to UST tracer for the UST session.
 472  */
 473 static int disable_ust_channel(struct ust_app *app,
 474                 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
 475 {
 476         int ret;
 477
 478         ret = ustctl_disable(app->key.sock, ua_chan->obj);
 479         if (ret < 0) {
 480                 ERR("UST app channel %s disable failed for app (pid: %d) "
 481                                 "and session handle %d with ret %d",
 482                                 ua_chan->name, app->key.pid, ua_sess->handle, ret);
 483                 goto error;
 484         }
 485
 486         DBG2("UST app channel %s disabled successfully for app (pid: %d)",
 487                         ua_chan->name, app->key.pid);
 488
 489 error:
 490         return ret;
 491 }
 492
 493 /*
 494  * Enable the specified channel on to UST tracer for the UST session.
 495  */
 496 static int enable_ust_channel(struct ust_app *app,
 497                 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
 498 {
 499         int ret;
 500
 501         ret = ustctl_enable(app->key.sock, ua_chan->obj);
 502         if (ret < 0) {
 503                 ERR("UST app channel %s enable failed for app (pid: %d) "
 504                                 "and session handle %d with ret %d",
 505                                 ua_chan->name, app->key.pid, ua_sess->handle, ret);
 506                 goto error;
 507         }
 508
 509         ua_chan->enabled = 1;
 510
 511         DBG2("UST app channel %s enabled successfully for app (pid: %d)",
 512                         ua_chan->name, app->key.pid);
 513
 514 error:
 515         return ret;
 516 }
 517
 518 /*
 519  * Enable the specified event on to UST tracer for the UST session.
 520  */
 521 static int enable_ust_event(struct ust_app *app,
 522                 struct ust_app_session *ua_sess, struct ust_app_event *ua_event)
 523 {
 524         int ret;
 525
 526         ret = ustctl_enable(app->key.sock, ua_event->obj);
 527         if (ret < 0) {
 528                 ERR("UST app event %s enable failed for app (pid: %d) "
 529                                 "and session handle %d with ret %d",
 530                                 ua_event->attr.name, app->key.pid, ua_sess->handle, ret);
 531                 goto error;
 532         }
 533
 534         DBG2("UST app event %s enabled successfully for app (pid: %d)",
 535                         ua_event->attr.name, app->key.pid);
 536
 537 error:
 538         return ret;
 539 }
 540
 541 /*
 542  * Open metadata onto the UST tracer for a UST session.
 543  */
 544 static int open_ust_metadata(struct ust_app *app,
 545                 struct ust_app_session *ua_sess)
 546 {
 547         int ret;
 548         struct lttng_ust_channel_attr uattr;
 549
 550         uattr.overwrite = ua_sess->metadata->attr.overwrite;
 551         uattr.subbuf_size = ua_sess->metadata->attr.subbuf_size;
 552         uattr.num_subbuf = ua_sess->metadata->attr.num_subbuf;
 553         uattr.switch_timer_interval =
 554                 ua_sess->metadata->attr.switch_timer_interval;
 555         uattr.read_timer_interval =
 556                 ua_sess->metadata->attr.read_timer_interval;
 557         uattr.output = ua_sess->metadata->attr.output;
 558
 559         /* UST tracer metadata creation */
 560         ret = ustctl_open_metadata(app->key.sock, ua_sess->handle, &uattr,
 561                         &ua_sess->metadata->obj);
 562         if (ret < 0) {
 563                 ERR("UST app open metadata failed for app pid:%d",
 564                                 app->key.pid);
 565                 goto error;
 566         }
 567
 568         ua_sess->metadata->handle = ua_sess->metadata->obj->handle;
 569
 570 error:
 571         return ret;
 572 }
 573
 574 /*
 575  * Create stream onto the UST tracer for a UST session.
 576  */
 577 static int create_ust_stream(struct ust_app *app,
 578                 struct ust_app_session *ua_sess)
 579 {
 580         int ret;
 581
 582         ret = ustctl_create_stream(app->key.sock, ua_sess->metadata->obj,
 583                         &ua_sess->metadata->stream_obj);
 584         if (ret < 0) {
 585                 ERR("UST create metadata stream failed");
 586                 goto error;
 587         }
 588
 589 error:
 590         return ret;
 591 }
 592
 593 /*
 594  * Create the specified channel onto the UST tracer for a UST session.
 595  */
 596 static int create_ust_channel(struct ust_app *app,
 597                 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
 598 {
 599         int ret;
 600
 601         /* TODO: remove cast and use lttng-ust-abi.h */
 602         ret = ustctl_create_channel(app->key.sock, ua_sess->handle,
 603                         (struct lttng_ust_channel_attr *)&ua_chan->attr, &ua_chan->obj);
 604         if (ret < 0) {
 605                 DBG("Error creating channel %s for app (pid: %d, sock: %d) "
 606                                 "and session handle %d with ret %d",
 607                                 ua_chan->name, app->key.pid, app->key.sock,
 608                                 ua_sess->handle, ret);
 609                 goto error;
 610         }
 611
 612         ua_chan->handle = ua_chan->obj->handle;
 613         ua_chan->attr.shm_fd = ua_chan->obj->shm_fd;
 614         ua_chan->attr.wait_fd = ua_chan->obj->wait_fd;
 615         ua_chan->attr.memory_map_size = ua_chan->obj->memory_map_size;
 616
 617         DBG2("UST app channel %s created successfully for pid:%d and sock:%d",
 618                         ua_chan->name, app->key.pid, app->key.sock);
 619
 620         /* If channel is not enabled, disable it on the tracer */
 621         if (!ua_chan->enabled) {
 622                 ret = disable_ust_channel(app, ua_sess, ua_chan);
 623                 if (ret < 0) {
 624                         goto error;
 625                 }
 626         }
 627
 628 error:
 629         return ret;
 630 }
 631
 632 /*
 633  * Create the specified event onto the UST tracer for a UST session.
 634  */
 635 static
 636 int create_ust_event(struct ust_app *app, struct ust_app_session *ua_sess,
 637                 struct ust_app_channel *ua_chan, struct ust_app_event *ua_event)
 638 {
 639         int ret = 0;
 640
 641         /* Create UST event on tracer */
 642         ret = ustctl_create_event(app->key.sock, &ua_event->attr, ua_chan->obj,
 643                         &ua_event->obj);
 644         if (ret < 0) {
 645                 ERR("Error ustctl create event %s for app pid: %d with ret %d",
 646                                 ua_event->attr.name, app->key.pid, ret);
 647                 goto error;
 648         }
 649
 650         ua_event->handle = ua_event->obj->handle;
 651
 652         DBG2("UST app event %s created successfully for pid:%d",
 653                         ua_event->attr.name, app->key.pid);
 654
 655         /* If event not enabled, disable it on the tracer */
 656         if (!ua_event->enabled) {
 657                 ret = disable_ust_event(app, ua_sess, ua_event);
 658                 if (ret < 0) {
 659                         goto error;
 660                 }
 661         }
 662
 663 error:
 664         return ret;
 665 }
 666
 667 /*
 668  * Copy data between an UST app event and a LTT event.
 669  */
 670 static void shadow_copy_event(struct ust_app_event *ua_event,
 671                 struct ltt_ust_event *uevent)
 672 {
 673         struct cds_lfht_iter iter;
 674         struct ltt_ust_context *uctx;
 675         struct ust_app_ctx *ua_ctx;
 676
 677         strncpy(ua_event->name, uevent->attr.name, sizeof(ua_event->name));
 678         ua_event->name[sizeof(ua_event->name) - 1] = '\0';
 679
 680         /* Copy event attributes */
 681         memcpy(&ua_event->attr, &uevent->attr, sizeof(ua_event->attr));
 682
 683         cds_lfht_for_each_entry(uevent->ctx, &iter, uctx, node) {
 684                 ua_ctx = alloc_ust_app_ctx(&uctx->ctx);
 685                 if (ua_ctx == NULL) {
 686                         continue;
 687                 }
 688                 hashtable_node_init(&ua_ctx->node,
 689                                 (void *)((unsigned long) ua_ctx->ctx.ctx), sizeof(void *));
 690                 hashtable_add_unique(ua_event->ctx, &ua_ctx->node);
 691         }
 692 }
 693
 694 /*
 695  * Copy data between an UST app channel and a LTT channel.
 696  */
 697 static void shadow_copy_channel(struct ust_app_channel *ua_chan,
 698                 struct ltt_ust_channel *uchan)
 699 {
 700         struct cds_lfht_iter iter;
 701         struct cds_lfht_node *ua_event_node;
 702         struct ltt_ust_event *uevent;
 703         struct ltt_ust_context *uctx;
 704         struct ust_app_event *ua_event;
 705         struct ust_app_ctx *ua_ctx;
 706
 707         DBG2("Shadow copy of UST app channel %s", ua_chan->name);
 708
 709         strncpy(ua_chan->name, uchan->name, sizeof(ua_chan->name));
 710         ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
 711         /* Copy event attributes */
 712         memcpy(&ua_chan->attr, &uchan->attr, sizeof(ua_chan->attr));
 713
 714         cds_lfht_for_each_entry(uchan->ctx, &iter, uctx, node) {
 715                 ua_ctx = alloc_ust_app_ctx(&uctx->ctx);
 716                 if (ua_ctx == NULL) {
 717                         continue;
 718                 }
 719                 hashtable_node_init(&ua_ctx->node,
 720                                 (void *)((unsigned long) ua_ctx->ctx.ctx), sizeof(void *));
 721                 hashtable_add_unique(ua_chan->ctx, &ua_ctx->node);
 722         }
 723
 724         /* Copy all events from ltt ust channel to ust app channel */
 725         cds_lfht_for_each_entry(uchan->events, &iter, uevent, node) {
 726                 struct cds_lfht_iter uiter;
 727
 728                 ua_event_node = hashtable_lookup(ua_chan->events,
 729                                 (void *) uevent->attr.name, strlen(uevent->attr.name),
 730                                 &uiter);
 731                 if (ua_event_node == NULL) {
 732                         DBG2("UST event %s not found on shadow copy channel",
 733                                         uevent->attr.name);
 734                         ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
 735                         if (ua_event == NULL) {
 736                                 continue;
 737                         }
 738                         shadow_copy_event(ua_event, uevent);
 739                         hashtable_add_unique(ua_chan->events, &ua_event->node);
 740                 }
 741         }
 742
 743         DBG3("Shadow copy channel done");
 744 }
 745
 746 /*
 747  * Copy data between a UST app session and a regular LTT session.
 748  */
 749 static void shadow_copy_session(struct ust_app_session *ua_sess,
 750                 struct ltt_ust_session *usess,
 751                 struct ust_app *app)
 752 {
 753         struct cds_lfht_node *ua_chan_node;
 754         struct cds_lfht_iter iter;
 755         struct ltt_ust_channel *uchan;
 756         struct ust_app_channel *ua_chan;
 757         time_t rawtime;
 758         struct tm *timeinfo;
 759         char datetime[16];
 760         int ret;
 761
 762         /* Get date and time for unique app path */
 763         time(&rawtime);
 764         timeinfo = localtime(&rawtime);
 765         strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S", timeinfo);
 766
 767         DBG2("Shadow copy of session handle %d", ua_sess->handle);
 768
 769         ua_sess->uid = usess->uid;
 770
 771         ret = snprintf(ua_sess->path, PATH_MAX,
 772                         "%s/%s-%d-%s",
 773                         usess->pathname, app->name, app->key.pid,
 774                         datetime);
 775         if (ret < 0) {
 776                 PERROR("asprintf UST shadow copy session");
 777                 /* TODO: We cannot return an error from here.. */
 778                 assert(0);
 779         }
 780
 781         /* TODO: support all UST domain */
 782
 783         /* Iterate over all channels in global domain. */
 784         cds_lfht_for_each_entry(usess->domain_global.channels, &iter,
 785                         uchan, node) {
 786                 struct cds_lfht_iter uiter;
 787
 788                 ua_chan_node = hashtable_lookup(ua_sess->channels,
 789                                 (void *)uchan->name, strlen(uchan->name),
 790                                 &uiter);
 791                 if (ua_chan_node != NULL) {
 792                         continue;
 793                 }
 794
 795                 DBG2("Channel %s not found on shadow session copy, creating it",
 796                                 uchan->name);
 797                 ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
 798                 if (ua_chan == NULL) {
 799                         /* malloc failed... continuing */
 800                         continue;
 801                 }
 802
 803                 shadow_copy_channel(ua_chan, uchan);
 804                 hashtable_add_unique(ua_sess->channels, &ua_chan->node);
 805         }
 806 }
 807
 808 /*
 809  * Lookup sesison wrapper.
 810  */
 811 static
 812 void __lookup_session_by_app(struct ltt_ust_session *usess,
 813                         struct ust_app *app, struct cds_lfht_iter *iter)
 814 {
 815         /* Get right UST app session from app */
 816         (void) hashtable_lookup(app->sessions,
 817                         (void *) ((unsigned long) usess->uid), sizeof(void *),
 818                         iter);
 819 }
 820
 821 /*
 822  * Return ust app session from the app session hashtable using the UST session
 823  * uid.
 824  */
 825 static struct ust_app_session *lookup_session_by_app(
 826                 struct ltt_ust_session *usess, struct ust_app *app)
 827 {
 828         struct cds_lfht_iter iter;
 829         struct cds_lfht_node *node;
 830
 831         __lookup_session_by_app(usess, app, &iter);
 832         node = hashtable_iter_get_node(&iter);
 833         if (node == NULL) {
 834                 goto error;
 835         }
 836
 837         return caa_container_of(node, struct ust_app_session, node);
 838
 839 error:
 840         return NULL;
 841 }
 842
 843 /*
 844  * Create a UST session onto the tracer of app and add it the session
 845  * hashtable.
 846  *
 847  * Return ust app session or NULL on error.
 848  */
 849 static struct ust_app_session *create_ust_app_session(
 850                 struct ltt_ust_session *usess, struct ust_app *app)
 851 {
 852         int ret;
 853         struct ust_app_session *ua_sess;
 854
 855         ua_sess = lookup_session_by_app(usess, app);
 856         if (ua_sess == NULL) {
 857                 DBG2("UST app pid: %d session uid %d not found, creating it",
 858                                 app->key.pid, usess->uid);
 859                 ua_sess = alloc_ust_app_session();
 860                 if (ua_sess == NULL) {
 861                         /* Only malloc can failed so something is really wrong */
 862                         goto error;
 863                 }
 864                 shadow_copy_session(ua_sess, usess, app);
 865         }
 866
 867         if (ua_sess->handle == -1) {
 868                 ret = ustctl_create_session(app->key.sock);
 869                 if (ret < 0) {
 870                         ERR("Error creating session for app pid %d, sock %d",
 871                                         app->key.pid, app->key.sock);
 872                         /* TODO: free() ua_sess */
 873                         goto error;
 874                 }
 875
 876                 DBG2("UST app ustctl create session handle %d", ret);
 877                 ua_sess->handle = ret;
 878
 879                 /* Add ust app session to app's HT */
 880                 hashtable_node_init(&ua_sess->node,
 881                                 (void *)((unsigned long) ua_sess->uid), sizeof(void *));
 882                 hashtable_add_unique(app->sessions, &ua_sess->node);
 883
 884                 DBG2("UST app session created successfully with handle %d", ret);
 885         }
 886
 887         return ua_sess;
 888
 889 error:
 890         return NULL;
 891 }
 892
 893 /*
 894  * Create a context for the channel on the tracer.
 895  */
 896 static
 897 int create_ust_app_channel_context(struct ust_app_session *ua_sess,
 898                 struct ust_app_channel *ua_chan, struct lttng_ust_context *uctx,
 899                 struct ust_app *app)
 900 {
 901         int ret = 0;
 902         struct cds_lfht_iter iter;
 903         struct cds_lfht_node *node;
 904         struct ust_app_ctx *ua_ctx;
 905
 906         DBG2("UST app adding context to channel %s", ua_chan->name);
 907
 908         node = hashtable_lookup(ua_chan->ctx, (void *)((unsigned long)uctx->ctx),
 909                         sizeof(void *), &iter);
 910         if (node != NULL) {
 911                 ret = -EEXIST;
 912                 goto error;
 913         }
 914
 915         ua_ctx = alloc_ust_app_ctx(uctx);
 916         if (ua_ctx == NULL) {
 917                 /* malloc failed */
 918                 ret = -1;
 919                 goto error;
 920         }
 921
 922         hashtable_node_init(&ua_ctx->node,
 923                         (void *)((unsigned long) ua_ctx->ctx.ctx), sizeof(void *));
 924         hashtable_add_unique(ua_chan->ctx, &ua_ctx->node);
 925
 926         ret = create_ust_channel_context(ua_chan, ua_ctx, app);
 927         if (ret < 0) {
 928                 goto error;
 929         }
 930
 931 error:
 932         return ret;
 933 }
 934
 935 /*
 936  * Create an UST context and enable it for the event on the tracer.
 937  */
 938 static
 939 int create_ust_app_event_context(struct ust_app_session *ua_sess,
 940                 struct ust_app_event *ua_event, struct lttng_ust_context *uctx,
 941                 struct ust_app *app)
 942 {
 943         int ret = 0;
 944         struct cds_lfht_iter iter;
 945         struct cds_lfht_node *node;
 946         struct ust_app_ctx *ua_ctx;
 947
 948         DBG2("UST app adding context to event %s", ua_event->name);
 949
 950         node = hashtable_lookup(ua_event->ctx, (void *)((unsigned long)uctx->ctx),
 951                         sizeof(void *), &iter);
 952         if (node != NULL) {
 953                 ret = -EEXIST;
 954                 goto error;
 955         }
 956
 957         ua_ctx = alloc_ust_app_ctx(uctx);
 958         if (ua_ctx == NULL) {
 959                 /* malloc failed */
 960                 ret = -1;
 961                 goto error;
 962         }
 963
 964         hashtable_node_init(&ua_ctx->node,
 965                         (void *)((unsigned long) ua_ctx->ctx.ctx), sizeof(void *));
 966         hashtable_add_unique(ua_event->ctx, &ua_ctx->node);
 967
 968         ret = create_ust_event_context(ua_event, ua_ctx, app);
 969         if (ret < 0) {
 970                 goto error;
 971         }
 972
 973 error:
 974         return ret;
 975 }
 976
 977 /*
 978  * Enable on the tracer side a ust app event for the session and channel.
 979  */
 980 static
 981 int enable_ust_app_event(struct ust_app_session *ua_sess,
 982                 struct ust_app_event *ua_event, struct ust_app *app)
 983 {
 984         int ret;
 985
 986         ret = enable_ust_event(app, ua_sess, ua_event);
 987         if (ret < 0) {
 988                 goto error;
 989         }
 990
 991         ua_event->enabled = 1;
 992
 993 error:
 994         return ret;
 995 }
 996
 997 /*
 998  * Disable on the tracer side a ust app event for the session and channel.
 999  */
1000 static int disable_ust_app_event(struct ust_app_session *ua_sess,
1001                 struct ust_app_event *ua_event, struct ust_app *app)
1002 {
1003         int ret;
1004
1005         ret = disable_ust_event(app, ua_sess, ua_event);
1006         if (ret < 0) {
1007                 goto error;
1008         }
1009
1010         ua_event->enabled = 0;
1011
1012 error:
1013         return ret;
1014 }
1015
1016 /*
1017  * Lookup ust app channel for session and disable it on the tracer side.
1018  */
1019 static
1020 int disable_ust_app_channel(struct ust_app_session *ua_sess,
1021                 struct ust_app_channel *ua_chan, struct ust_app *app)
1022 {
1023         int ret;
1024
1025         ret = disable_ust_channel(app, ua_sess, ua_chan);
1026         if (ret < 0) {
1027                 goto error;
1028         }
1029
1030         ua_chan->enabled = 0;
1031
1032 error:
1033         return ret;
1034 }
1035
1036 /*
1037  * Lookup ust app channel for session and enable it on the tracer side.
1038  */
1039 static int enable_ust_app_channel(struct ust_app_session *ua_sess,
1040                 struct ltt_ust_channel *uchan, struct ust_app *app)
1041 {
1042         int ret = 0;
1043         struct cds_lfht_iter iter;
1044         struct cds_lfht_node *ua_chan_node;
1045         struct ust_app_channel *ua_chan;
1046
1047         ua_chan_node = hashtable_lookup(ua_sess->channels,
1048                         (void *)uchan->name, strlen(uchan->name), &iter);
1049         if (ua_chan_node == NULL) {
1050                 DBG2("Unable to find channel %s in ust session uid %u",
1051                                 uchan->name, ua_sess->uid);
1052                 goto error;
1053         }
1054
1055         ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1056
1057         ret = enable_ust_channel(app, ua_sess, ua_chan);
1058         if (ret < 0) {
1059                 goto error;
1060         }
1061
1062 error:
1063         return ret;
1064 }
1065
1066 /*
1067  * Create UST app channel and create it on the tracer.
1068  */
1069 static struct ust_app_channel *create_ust_app_channel(
1070                 struct ust_app_session *ua_sess, struct ltt_ust_channel *uchan,
1071                 struct ust_app *app)
1072 {
1073         int ret = 0;
1074         struct cds_lfht_iter iter;
1075         struct cds_lfht_node *ua_chan_node;
1076         struct ust_app_channel *ua_chan;
1077
1078         /* Lookup channel in the ust app session */
1079         ua_chan_node = hashtable_lookup(ua_sess->channels,
1080                         (void *)uchan->name, strlen(uchan->name), &iter);
1081         if (ua_chan_node == NULL) {
1082                 DBG2("Unable to find channel %s in ust session uid %u",
1083                                 uchan->name, ua_sess->uid);
1084                 ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
1085                 if (ua_chan == NULL) {
1086                         goto error;
1087                 }
1088                 shadow_copy_channel(ua_chan, uchan);
1089
1090                 hashtable_add_unique(ua_sess->channels, &ua_chan->node);
1091         } else {
1092                 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1093         }
1094
1095         ret = create_ust_channel(app, ua_sess, ua_chan);
1096         if (ret < 0) {
1097                 goto error;
1098         }
1099
1100         return ua_chan;
1101
1102 error:
1103         return NULL;
1104 }
1105
1106 /*
1107  * Create UST app event and create it on the tracer side.
1108  */
1109 static
1110 int create_ust_app_event(struct ust_app_session *ua_sess,
1111                 struct ust_app_channel *ua_chan, struct ltt_ust_event *uevent,
1112                 struct ust_app *app)
1113 {
1114         int ret = 0;
1115         struct cds_lfht_iter iter;
1116         struct cds_lfht_node *ua_event_node;
1117         struct ust_app_event *ua_event;
1118
1119         /* Get event node */
1120         ua_event_node = hashtable_lookup(ua_chan->events,
1121                         (void *)uevent->attr.name, strlen(uevent->attr.name), &iter);
1122         if (ua_event_node != NULL) {
1123                 ERR("UST app event %s already exist. Stopping creation.",
1124                                 uevent->attr.name);
1125                 goto end;
1126         }
1127
1128         /* Does not exist so create one */
1129         ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
1130         if (ua_event == NULL) {
1131                 /* Only malloc can failed so something is really wrong */
1132                 ret = -ENOMEM;
1133                 goto error;
1134         }
1135         shadow_copy_event(ua_event, uevent);
1136
1137         /* Create it on the tracer side */
1138         ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
1139         if (ret < 0) {
1140                 rcu_read_lock();
1141                 delete_ust_app_event(app->key.sock, ua_event);
1142                 rcu_read_unlock();
1143                 goto error;
1144         }
1145
1146         ua_event->enabled = 1;
1147
1148         hashtable_add_unique(ua_chan->events, &ua_event->node);
1149
1150         DBG2("UST app create event %s for PID %d completed",
1151                         ua_event->name, app->key.pid);
1152
1153 end:
1154 error:
1155         return ret;
1156 }
1157
1158 /*
1159  * Create UST metadata and open it on the tracer side.
1160  */
1161 static int create_ust_app_metadata(struct ust_app_session *ua_sess,
1162                 char *pathname, struct ust_app *app)
1163 {
1164         int ret = 0;
1165         mode_t old_umask;
1166
1167         if (ua_sess->metadata == NULL) {
1168                 /* Allocate UST metadata */
1169                 ua_sess->metadata = trace_ust_create_metadata(pathname);
1170                 if (ua_sess->metadata == NULL) {
1171                         ERR("UST app session %d creating metadata failed",
1172                                         ua_sess->handle);
1173                         goto error;
1174                 }
1175
1176                 ret = open_ust_metadata(app, ua_sess);
1177                 if (ret < 0) {
1178                         goto error;
1179                 }
1180
1181                 DBG2("UST metadata opened for app pid %d", app->key.pid);
1182         }
1183
1184         /* Open UST metadata stream */
1185         if (ua_sess->metadata->stream_obj == NULL) {
1186                 ret = create_ust_stream(app, ua_sess);
1187                 if (ret < 0) {
1188                         goto error;
1189                 }
1190
1191                 old_umask = umask(0);
1192                 ret = mkdir(ua_sess->path, S_IRWXU | S_IRWXG);
1193                 if (ret < 0) {
1194                         PERROR("mkdir UST metadata");
1195                         goto error;
1196                 }
1197                 umask(old_umask);
1198
1199                 ret = snprintf(ua_sess->metadata->pathname, PATH_MAX,
1200                                 "%s/metadata", ua_sess->path);
1201                 if (ret < 0) {
1202                         PERROR("asprintf UST create stream");
1203                         goto error;
1204                 }
1205
1206                 DBG2("UST metadata stream object created for app pid %d",
1207                                 app->key.pid);
1208         } else {
1209                 ERR("Attempting to create stream without metadata opened");
1210                 goto error;
1211         }
1212
1213         return 0;
1214
1215 error:
1216         return -1;
1217 }
1218
1219 /*
1220  * Return pointer to traceable apps list.
1221  */
1222 struct cds_lfht *ust_app_get_ht(void)
1223 {
1224         return ust_app_ht;
1225 }
1226
1227 /*
1228  * Return ust app pointer or NULL if not found.
1229  */
1230 struct ust_app *ust_app_find_by_pid(pid_t pid)
1231 {
1232         struct cds_lfht_node *node;
1233         struct cds_lfht_iter iter;
1234
1235         rcu_read_lock();
1236         node = hashtable_lookup(ust_app_ht,
1237                         (void *)((unsigned long) pid), sizeof(void *), &iter);
1238         if (node == NULL) {
1239                 DBG2("UST app no found with pid %d", pid);
1240                 goto error;
1241         }
1242         rcu_read_unlock();
1243
1244         DBG2("Found UST app by pid %d", pid);
1245
1246         return caa_container_of(node, struct ust_app, node);
1247
1248 error:
1249         rcu_read_unlock();
1250         return NULL;
1251 }
1252
1253 /*
1254  * Using pid and uid (of the app), allocate a new ust_app struct and
1255  * add it to the global traceable app list.
1256  *
1257  * On success, return 0, else return malloc -ENOMEM, or -EINVAL if app
1258  * bitness is not supported.
1259  */
1260 int ust_app_register(struct ust_register_msg *msg, int sock)
1261 {
1262         struct ust_app *lta;
1263
1264         if ((msg->bits_per_long == 64 && ust_consumerd64_fd == -EINVAL)
1265                         || (msg->bits_per_long == 32 && ust_consumerd32_fd == -EINVAL)) {
1266                 ERR("Registration failed: application \"%s\" (pid: %d) has "
1267                         "%d-bit long, but no consumerd for this long size is available.\n",
1268                         msg->name, msg->pid, msg->bits_per_long);
1269                 close(sock);
1270                 return -EINVAL;
1271         }
1272         lta = zmalloc(sizeof(struct ust_app));
1273         if (lta == NULL) {
1274                 PERROR("malloc");
1275                 return -ENOMEM;
1276         }
1277
1278         lta->ppid = msg->ppid;
1279         lta->uid = msg->uid;
1280         lta->gid = msg->gid;
1281         lta->bits_per_long = msg->bits_per_long;
1282         lta->v_major = msg->major;
1283         lta->v_minor = msg->minor;
1284         strncpy(lta->name, msg->name, sizeof(lta->name));
1285         lta->name[16] = '\0';
1286         lta->sessions = hashtable_new(0);
1287
1288         /* Set key map */
1289         lta->key.pid = msg->pid;
1290         hashtable_node_init(&lta->node, (void *)((unsigned long)lta->key.pid),
1291                         sizeof(void *));
1292         lta->key.sock = sock;
1293         hashtable_node_init(&lta->key.node, (void *)((unsigned long)lta->key.sock),
1294                         sizeof(void *));
1295
1296         rcu_read_lock();
1297         hashtable_add_unique(ust_app_sock_key_map, &lta->key.node);
1298         hashtable_add_unique(ust_app_ht, &lta->node);
1299         rcu_read_unlock();
1300
1301         DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s"
1302                         " (version %d.%d)", lta->key.pid, lta->ppid, lta->uid, lta->gid,
1303                         lta->key.sock, lta->name, lta->v_major, lta->v_minor);
1304
1305         return 0;
1306 }
1307
1308 /*
1309  * Unregister app by removing it from the global traceable app list and freeing
1310  * the data struct.
1311  *
1312  * The socket is already closed at this point so no close to sock.
1313  */
1314 void ust_app_unregister(int sock)
1315 {
1316         struct ust_app *lta;
1317         struct cds_lfht_node *node;
1318         struct cds_lfht_iter iter;
1319         int ret;
1320
1321         rcu_read_lock();
1322         lta = find_app_by_sock(sock);
1323         if (lta == NULL) {
1324                 ERR("Unregister app sock %d not found!", sock);
1325                 goto error;
1326         }
1327
1328         DBG("PID %d unregistering with sock %d", lta->key.pid, sock);
1329
1330         /* Get the node reference for a call_rcu */
1331         node = hashtable_lookup(ust_app_ht,
1332                         (void *)((unsigned long) lta->key.pid), sizeof(void *), &iter);
1333         if (node == NULL) {
1334                 ERR("Unable to find app sock %d by pid %d", sock, lta->key.pid);
1335                 goto error;
1336         }
1337
1338         ret = hashtable_del(ust_app_ht, &iter);
1339         assert(!ret);
1340         call_rcu(&node->head, delete_ust_app_rcu);
1341 error:
1342         rcu_read_unlock();
1343         return;
1344 }
1345
1346 /*
1347  * Return traceable_app_count
1348  */
1349 unsigned long ust_app_list_count(void)
1350 {
1351         unsigned long count;
1352
1353         rcu_read_lock();
1354         count = hashtable_get_count(ust_app_ht);
1355         rcu_read_unlock();
1356
1357         return count;
1358 }
1359
1360 /*
1361  * Fill events array with all events name of all registered apps.
1362  */
1363 int ust_app_list_events(struct lttng_event **events)
1364 {
1365         int ret, handle;
1366         size_t nbmem, count = 0;
1367         struct cds_lfht_iter iter;
1368         struct ust_app *app;
1369         struct lttng_event *tmp;
1370
1371         nbmem = UST_APP_EVENT_LIST_SIZE;
1372         tmp = zmalloc(nbmem * sizeof(struct lttng_event));
1373         if (tmp == NULL) {
1374                 PERROR("zmalloc ust app events");
1375                 ret = -ENOMEM;
1376                 goto error;
1377         }
1378
1379         rcu_read_lock();
1380
1381         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1382                 struct lttng_ust_tracepoint_iter iter;
1383
1384                 handle = ustctl_tracepoint_list(app->key.sock);
1385                 if (handle < 0) {
1386                         ERR("UST app list events getting handle failed for app pid %d",
1387                                         app->key.pid);
1388                         continue;
1389                 }
1390
1391                 while ((ret = ustctl_tracepoint_list_get(app->key.sock, handle,
1392                                                 &iter)) != -ENOENT) {
1393                         if (count >= nbmem) {
1394                                 DBG2("Reallocating event list from %zu to %zu entries", nbmem,
1395                                                 2 * nbmem);
1396                                 nbmem *= 2;
1397                                 tmp = realloc(tmp, nbmem * sizeof(struct lttng_event));
1398                                 if (tmp == NULL) {
1399                                         PERROR("realloc ust app events");
1400                                         ret = -ENOMEM;
1401                                         goto rcu_error;
1402                                 }
1403                         }
1404                         memcpy(tmp[count].name, iter.name, LTTNG_UST_SYM_NAME_LEN);
1405                         memcpy(tmp[count].loglevel, iter.loglevel, LTTNG_UST_SYM_NAME_LEN);
1406                         tmp[count].loglevel_value = iter.loglevel_value;
1407                         tmp[count].type = LTTNG_UST_TRACEPOINT;
1408                         tmp[count].pid = app->key.pid;
1409                         tmp[count].enabled = -1;
1410                         count++;
1411                 }
1412         }
1413
1414         ret = count;
1415         *events = tmp;
1416
1417         DBG2("UST app list events done (%zu events)", count);
1418
1419 rcu_error:
1420         rcu_read_unlock();
1421 error:
1422         return ret;
1423 }
1424
1425 /*
1426  * Free and clean all traceable apps of the global list.
1427  */
1428 void ust_app_clean_list(void)
1429 {
1430         int ret;
1431         struct cds_lfht_iter iter;
1432         struct ust_app *app;
1433
1434         DBG2("UST app cleaning registered apps hash table");
1435
1436         rcu_read_lock();
1437
1438         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1439                 ret = hashtable_del(ust_app_ht, &iter);
1440                 assert(!ret);
1441                 call_rcu(&iter.node->head, delete_ust_app_rcu);
1442         }
1443
1444         hashtable_destroy(ust_app_ht);
1445         hashtable_destroy(ust_app_sock_key_map);
1446
1447         rcu_read_unlock();
1448 }
1449
1450 /*
1451  * Init UST app hash table.
1452  */
1453 void ust_app_ht_alloc(void)
1454 {
1455         ust_app_ht = hashtable_new(0);
1456         ust_app_sock_key_map = hashtable_new(0);
1457 }
1458
1459 /*
1460  * For a specific UST session, disable the channel for all registered apps.
1461  */
1462 int ust_app_disable_channel_glb(struct ltt_ust_session *usess,
1463                 struct ltt_ust_channel *uchan)
1464 {
1465         int ret = 0;
1466         struct cds_lfht_iter iter;
1467         struct cds_lfht_node *ua_chan_node;
1468         struct ust_app *app;
1469         struct ust_app_session *ua_sess;
1470         struct ust_app_channel *ua_chan;
1471
1472         if (usess == NULL || uchan == NULL) {
1473                 ERR("Disabling UST global channel with NULL values");
1474                 ret = -1;
1475                 goto error;
1476         }
1477
1478         DBG2("UST app disabling channel %s from global domain for session uid %d",
1479                         uchan->name, usess->uid);
1480
1481         rcu_read_lock();
1482
1483         /* For every registered applications */
1484         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1485                 ua_sess = lookup_session_by_app(usess, app);
1486                 if (ua_sess == NULL) {
1487                         continue;
1488                 }
1489
1490                 /* Get channel */
1491                 ua_chan_node = hashtable_lookup(ua_sess->channels,
1492                                 (void *)uchan->name, strlen(uchan->name), &iter);
1493                 /* If the session if found for the app, the channel must be there */
1494                 assert(ua_chan_node);
1495
1496                 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1497                 /* The channel must not be already disabled */
1498                 assert(ua_chan->enabled == 1);
1499
1500                 /* Disable channel onto application */
1501                 ret = disable_ust_app_channel(ua_sess, ua_chan, app);
1502                 if (ret < 0) {
1503                         /* XXX: We might want to report this error at some point... */
1504                         continue;
1505                 }
1506         }
1507
1508         rcu_read_unlock();
1509
1510 error:
1511         return ret;
1512 }
1513
1514 /*
1515  * For a specific UST session, enable the channel for all registered apps.
1516  */
1517 int ust_app_enable_channel_glb(struct ltt_ust_session *usess,
1518                 struct ltt_ust_channel *uchan)
1519 {
1520         int ret = 0;
1521         struct cds_lfht_iter iter;
1522         struct ust_app *app;
1523         struct ust_app_session *ua_sess;
1524
1525         if (usess == NULL || uchan == NULL) {
1526                 ERR("Adding UST global channel to NULL values");
1527                 ret = -1;
1528                 goto error;
1529         }
1530
1531         DBG2("UST app enabling channel %s to global domain for session uid %d",
1532                         uchan->name, usess->uid);
1533
1534         rcu_read_lock();
1535
1536         /* For every registered applications */
1537         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1538                 ua_sess = lookup_session_by_app(usess, app);
1539                 if (ua_sess == NULL) {
1540                         continue;
1541                 }
1542
1543                 /* Enable channel onto application */
1544                 ret = enable_ust_app_channel(ua_sess, uchan, app);
1545                 if (ret < 0) {
1546                         /* XXX: We might want to report this error at some point... */
1547                         continue;
1548                 }
1549         }
1550
1551         rcu_read_unlock();
1552
1553 error:
1554         return ret;
1555 }
1556
1557 /*
1558  * Disable an event in a channel and for a specific session.
1559  */
1560 int ust_app_disable_event_glb(struct ltt_ust_session *usess,
1561                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
1562 {
1563         int ret = 0;
1564         struct cds_lfht_iter iter, uiter;
1565         struct cds_lfht_node *ua_chan_node, *ua_event_node;
1566         struct ust_app *app;
1567         struct ust_app_session *ua_sess;
1568         struct ust_app_channel *ua_chan;
1569         struct ust_app_event *ua_event;
1570
1571         DBG("UST app disabling event %s for all apps in channel "
1572                         "%s for session uid %d", uevent->attr.name, uchan->name, usess->uid);
1573
1574         rcu_read_lock();
1575
1576         /* For all registered applications */
1577         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1578                 ua_sess = lookup_session_by_app(usess, app);
1579                 if (ua_sess == NULL) {
1580                         /* Next app */
1581                         continue;
1582                 }
1583
1584                 /* Lookup channel in the ust app session */
1585                 ua_chan_node = hashtable_lookup(ua_sess->channels,
1586                                 (void *)uchan->name, strlen(uchan->name), &uiter);
1587                 if (ua_chan_node == NULL) {
1588                         DBG2("Channel %s not found in session uid %d for app pid %d."
1589                                         "Skipping", uchan->name, usess->uid, app->key.pid);
1590                         continue;
1591                 }
1592                 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1593
1594                 ua_event_node = hashtable_lookup(ua_chan->events,
1595                                 (void *)uevent->attr.name, strlen(uevent->attr.name), &uiter);
1596                 if (ua_event_node == NULL) {
1597                         DBG2("Event %s not found in channel %s for app pid %d."
1598                                         "Skipping", uevent->attr.name, uchan->name, app->key.pid);
1599                         continue;
1600                 }
1601                 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
1602
1603                 ret = disable_ust_app_event(ua_sess, ua_event, app);
1604                 if (ret < 0) {
1605                         /* XXX: Report error someday... */
1606                         continue;
1607                 }
1608         }
1609
1610         rcu_read_unlock();
1611
1612         return ret;
1613 }
1614
1615 /*
1616  * For a specific UST session and UST channel, the event for all
1617  * registered apps.
1618  */
1619 int ust_app_disable_all_event_glb(struct ltt_ust_session *usess,
1620                 struct ltt_ust_channel *uchan)
1621 {
1622         int ret = 0;
1623         struct cds_lfht_iter iter, uiter;
1624         struct cds_lfht_node *ua_chan_node;
1625         struct ust_app *app;
1626         struct ust_app_session *ua_sess;
1627         struct ust_app_channel *ua_chan;
1628         struct ust_app_event *ua_event;
1629
1630         DBG("UST app disabling all event for all apps in channel "
1631                         "%s for session uid %d", uchan->name, usess->uid);
1632
1633         rcu_read_lock();
1634
1635         /* For all registered applications */
1636         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1637                 ua_sess = lookup_session_by_app(usess, app);
1638                 /* If ua_sess is NULL, there is a code flow error */
1639                 assert(ua_sess);
1640
1641                 /* Lookup channel in the ust app session */
1642                 ua_chan_node = hashtable_lookup(ua_sess->channels, (void *)uchan->name,
1643                                 strlen(uchan->name), &uiter);
1644                 /* If the channel is not found, there is a code flow error */
1645                 assert(ua_chan_node);
1646
1647                 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1648
1649                 /* Disable each events of channel */
1650                 cds_lfht_for_each_entry(ua_chan->events, &uiter, ua_event, node) {
1651                         ret = disable_ust_app_event(ua_sess, ua_event, app);
1652                         if (ret < 0) {
1653                                 /* XXX: Report error someday... */
1654                                 continue;
1655                         }
1656                 }
1657         }
1658
1659         rcu_read_unlock();
1660
1661         return ret;
1662 }
1663
1664 /*
1665  * For a specific UST session, create the channel for all registered apps.
1666  */
1667 int ust_app_create_channel_glb(struct ltt_ust_session *usess,
1668                 struct ltt_ust_channel *uchan)
1669 {
1670         int ret = 0;
1671         struct cds_lfht_iter iter;
1672         struct ust_app *app;
1673         struct ust_app_session *ua_sess;
1674         struct ust_app_channel *ua_chan;
1675
1676         if (usess == NULL || uchan == NULL) {
1677                 ERR("Adding UST global channel to NULL values");
1678                 ret = -1;
1679                 goto error;
1680         }
1681
1682         DBG2("UST app adding channel %s to global domain for session uid %d",
1683                         uchan->name, usess->uid);
1684
1685         rcu_read_lock();
1686
1687         /* For every registered applications */
1688         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1689                 /*
1690                  * Create session on the tracer side and add it to app session HT. Note
1691                  * that if session exist, it will simply return a pointer to the ust
1692                  * app session.
1693                  */
1694                 ua_sess = create_ust_app_session(usess, app);
1695                 if (ua_sess == NULL) {
1696                         continue;
1697                 }
1698
1699                 /* Create channel onto application */
1700                 ua_chan = create_ust_app_channel(ua_sess, uchan, app);
1701                 if (ua_chan == NULL) {
1702                         continue;
1703                 }
1704         }
1705
1706         rcu_read_unlock();
1707
1708 error:
1709         return ret;
1710 }
1711
1712 /*
1713  * Enable event for a specific session and channel on the tracer.
1714  */
1715 int ust_app_enable_event_glb(struct ltt_ust_session *usess,
1716                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
1717 {
1718         int ret = 0;
1719         struct cds_lfht_iter iter, uiter;
1720         struct cds_lfht_node *ua_chan_node, *ua_event_node;
1721         struct ust_app *app;
1722         struct ust_app_session *ua_sess;
1723         struct ust_app_channel *ua_chan;
1724         struct ust_app_event *ua_event;
1725
1726         DBG("UST app enabling event %s for all apps for session uid %d",
1727                         uevent->attr.name, usess->uid);
1728
1729         /*
1730          * NOTE: At this point, this function is called only if the session and
1731          * channel passed are already created for all apps. and enabled on the
1732          * tracer also.
1733          */
1734
1735         rcu_read_lock();
1736
1737         /* For all registered applications */
1738         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1739                 ua_sess = lookup_session_by_app(usess, app);
1740                 /* If ua_sess is NULL, there is a code flow error */
1741                 assert(ua_sess);
1742
1743                 /* Lookup channel in the ust app session */
1744                 ua_chan_node = hashtable_lookup(ua_sess->channels, (void *)uchan->name,
1745                                 strlen(uchan->name), &uiter);
1746                 /* If the channel is not found, there is a code flow error */
1747                 assert(ua_chan_node);
1748
1749                 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1750
1751                 ua_event_node = hashtable_lookup(ua_chan->events,
1752                                 (void*)uevent->attr.name, strlen(uevent->attr.name), &uiter);
1753                 if (ua_event_node == NULL) {
1754                         DBG3("UST app enable event %s not found for app PID %d."
1755                                         "Skipping app", uevent->attr.name, app->key.pid);
1756                         continue;
1757                 }
1758                 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
1759
1760                 ret = enable_ust_app_event(ua_sess, ua_event, app);
1761                 if (ret < 0) {
1762                         goto error;
1763                 }
1764         }
1765
1766 error:
1767         rcu_read_unlock();
1768         return ret;
1769 }
1770
1771 /*
1772  * For a specific existing UST session and UST channel, creates the event for
1773  * all registered apps.
1774  */
1775 int ust_app_create_event_glb(struct ltt_ust_session *usess,
1776                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
1777 {
1778         int ret = 0;
1779         struct cds_lfht_iter iter, uiter;
1780         struct cds_lfht_node *ua_chan_node;
1781         struct ust_app *app;
1782         struct ust_app_session *ua_sess;
1783         struct ust_app_channel *ua_chan;
1784
1785         DBG("UST app creating event %s for all apps for session uid %d",
1786                         uevent->attr.name, usess->uid);
1787
1788         /*
1789          * NOTE: At this point, this function is called only if the session and
1790          * channel passed are already created for all apps. and enabled on the
1791          * tracer also.
1792          */
1793
1794         rcu_read_lock();
1795
1796         /* For all registered applications */
1797         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1798                 ua_sess = lookup_session_by_app(usess, app);
1799                 /* If ua_sess is NULL, there is a code flow error */
1800                 assert(ua_sess);
1801
1802                 /* Lookup channel in the ust app session */
1803                 ua_chan_node = hashtable_lookup(ua_sess->channels, (void *)uchan->name,
1804                                 strlen(uchan->name), &uiter);
1805                 /* If the channel is not found, there is a code flow error */
1806                 assert(ua_chan_node);
1807
1808                 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1809
1810                 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
1811                 if (ret < 0) {
1812                         continue;
1813                 }
1814         }
1815
1816         rcu_read_unlock();
1817
1818         return ret;
1819 }
1820
1821 /*
1822  * Start tracing for a specific UST session and app.
1823  */
1824 int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
1825 {
1826         int ret = 0;
1827         struct cds_lfht_iter iter;
1828         struct ust_app_session *ua_sess;
1829         struct ust_app_channel *ua_chan;
1830         struct ltt_ust_stream *ustream;
1831         int consumerd_fd;
1832
1833         DBG("Starting tracing for ust app pid %d", app->key.pid);
1834
1835         rcu_read_lock();
1836
1837         ua_sess = lookup_session_by_app(usess, app);
1838         if (ua_sess == NULL) {
1839                 goto error_rcu_unlock;
1840         }
1841
1842         /* Upon restart, we skip the setup, already done */
1843         if (ua_sess->started) {
1844                 goto skip_setup;
1845         }
1846
1847         ret = create_ust_app_metadata(ua_sess, usess->pathname, app);
1848         if (ret < 0) {
1849                 goto error_rcu_unlock;
1850         }
1851
1852         /* For each channel */
1853         cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
1854                 /* Create all streams */
1855                 while (1) {
1856                         /* Create UST stream */
1857                         ustream = zmalloc(sizeof(*ustream));
1858                         if (ustream == NULL) {
1859                                 PERROR("zmalloc ust stream");
1860                                 goto error_rcu_unlock;
1861                         }
1862
1863                         ret = ustctl_create_stream(app->key.sock, ua_chan->obj,
1864                                         &ustream->obj);
1865                         if (ret < 0) {
1866                                 /* Got all streams */
1867                                 break;
1868                         }
1869                         ustream->handle = ustream->obj->handle;
1870
1871                         /* Order is important */
1872                         cds_list_add_tail(&ustream->list, &ua_chan->streams.head);
1873                         ret = snprintf(ustream->pathname, PATH_MAX, "%s/%s_%u",
1874                                         ua_sess->path, ua_chan->name,
1875                                         ua_chan->streams.count++);
1876                         if (ret < 0) {
1877                                 PERROR("asprintf UST create stream");
1878                                 continue;
1879                         }
1880                         DBG2("UST stream %d ready at %s", ua_chan->streams.count,
1881                                         ustream->pathname);
1882                 }
1883         }
1884
1885         switch (app->bits_per_long) {
1886         case 64:
1887                 consumerd_fd = ust_consumerd64_fd;
1888                 break;
1889         case 32:
1890                 consumerd_fd = ust_consumerd32_fd;
1891                 break;
1892         default:
1893                 ret = -EINVAL;
1894                 goto error_rcu_unlock;
1895         }
1896
1897         /* Setup UST consumer socket and send fds to it */
1898         ret = ust_consumer_send_session(consumerd_fd, ua_sess);
1899         if (ret < 0) {
1900                 goto error_rcu_unlock;
1901         }
1902         ua_sess->started = 1;
1903
1904 skip_setup:
1905         /* This start the UST tracing */
1906         ret = ustctl_start_session(app->key.sock, ua_sess->handle);
1907         if (ret < 0) {
1908                 ERR("Error starting tracing for app pid: %d", app->key.pid);
1909                 goto error_rcu_unlock;
1910         }
1911
1912         rcu_read_unlock();
1913
1914         /* Quiescent wait after starting trace */
1915         ustctl_wait_quiescent(app->key.sock);
1916
1917         return 0;
1918
1919 error_rcu_unlock:
1920         rcu_read_unlock();
1921         return -1;
1922 }
1923
1924 /*
1925  * Stop tracing for a specific UST session and app.
1926  */
1927 int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app)
1928 {
1929         int ret = 0;
1930         struct cds_lfht_iter iter;
1931         struct ust_app_session *ua_sess;
1932         struct ust_app_channel *ua_chan;
1933
1934         DBG("Stopping tracing for ust app pid %d", app->key.pid);
1935
1936         rcu_read_lock();
1937
1938         ua_sess = lookup_session_by_app(usess, app);
1939         if (ua_sess == NULL) {
1940                 /* Only malloc can failed so something is really wrong */
1941                 goto error_rcu_unlock;
1942         }
1943
1944         /* Flush all buffers before stopping */
1945         ret = ustctl_sock_flush_buffer(app->key.sock, ua_sess->metadata->obj);
1946         if (ret < 0) {
1947                 ERR("UST app PID %d metadata flush failed", app->key.pid);
1948                 ERR("Ended with ret %d", ret);
1949         }
1950
1951         cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
1952                 ret = ustctl_sock_flush_buffer(app->key.sock, ua_chan->obj);
1953                 if (ret < 0) {
1954                         ERR("UST app PID %d channel %s flush failed",
1955                                         app->key.pid, ua_chan->name);
1956                         ERR("Ended with ret %d", ret);
1957                         /* Continuing flushing all buffers */
1958                         continue;
1959                 }
1960         }
1961
1962         /* This inhibits UST tracing */
1963         ret = ustctl_stop_session(app->key.sock, ua_sess->handle);
1964         if (ret < 0) {
1965                 ERR("Error stopping tracing for app pid: %d", app->key.pid);
1966                 goto error_rcu_unlock;
1967         }
1968
1969         rcu_read_unlock();
1970
1971         /* Quiescent wait after stopping trace */
1972         ustctl_wait_quiescent(app->key.sock);
1973
1974         return 0;
1975
1976 error_rcu_unlock:
1977         rcu_read_unlock();
1978         return -1;
1979 }
1980
1981 /*
1982  * Destroy a specific UST session in apps.
1983  */
1984 int ust_app_destroy_trace(struct ltt_ust_session *usess, struct ust_app *app)
1985 {
1986         struct ust_app_session *ua_sess;
1987         struct lttng_ust_object_data obj;
1988         struct cds_lfht_iter iter;
1989         struct cds_lfht_node *node;
1990         int ret;
1991
1992         DBG("Destroy tracing for ust app pid %d", app->key.pid);
1993
1994         rcu_read_lock();
1995
1996         __lookup_session_by_app(usess, app, &iter);
1997         node = hashtable_iter_get_node(&iter);
1998         if (node == NULL) {
1999                 /* Only malloc can failed so something is really wrong */
2000                 goto error_rcu_unlock;
2001         }
2002         ua_sess = caa_container_of(node, struct ust_app_session, node);
2003         ret = hashtable_del(app->sessions, &iter);
2004         assert(!ret);
2005         delete_ust_app_session(app->key.sock, ua_sess);
2006         obj.handle = ua_sess->handle;
2007         obj.shm_fd = -1;
2008         obj.wait_fd = -1;
2009         obj.memory_map_size = 0;
2010         ustctl_release_object(app->key.sock, &obj);
2011
2012         rcu_read_unlock();
2013
2014         /* Quiescent wait after stopping trace */
2015         ustctl_wait_quiescent(app->key.sock);
2016
2017         return 0;
2018
2019 error_rcu_unlock:
2020         rcu_read_unlock();
2021         return -1;
2022 }
2023
2024 /*
2025  * Start tracing for the UST session.
2026  */
2027 int ust_app_start_trace_all(struct ltt_ust_session *usess)
2028 {
2029         int ret = 0;
2030         struct cds_lfht_iter iter;
2031         struct ust_app *app;
2032
2033         DBG("Starting all UST traces");
2034
2035         rcu_read_lock();
2036
2037         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
2038                 ret = ust_app_start_trace(usess, app);
2039                 if (ret < 0) {
2040                         /* Continue to next apps even on error */
2041                         continue;
2042                 }
2043         }
2044
2045         rcu_read_unlock();
2046
2047         return 0;
2048 }
2049
2050 /*
2051  * Start tracing for the UST session.
2052  */
2053 int ust_app_stop_trace_all(struct ltt_ust_session *usess)
2054 {
2055         int ret = 0;
2056         struct cds_lfht_iter iter;
2057         struct ust_app *app;
2058
2059         DBG("Stopping all UST traces");
2060
2061         rcu_read_lock();
2062
2063         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
2064                 ret = ust_app_stop_trace(usess, app);
2065                 if (ret < 0) {
2066                         /* Continue to next apps even on error */
2067                         continue;
2068                 }
2069         }
2070
2071         rcu_read_unlock();
2072
2073         return 0;
2074 }
2075
2076 /*
2077  * Destroy app UST session.
2078  */
2079 int ust_app_destroy_trace_all(struct ltt_ust_session *usess)
2080 {
2081         int ret = 0;
2082         struct cds_lfht_iter iter;
2083         struct ust_app *app;
2084
2085         DBG("Destroy all UST traces");
2086
2087         rcu_read_lock();
2088
2089         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
2090                 ret = ust_app_destroy_trace(usess, app);
2091                 if (ret < 0) {
2092                         /* Continue to next apps even on error */
2093                         continue;
2094                 }
2095         }
2096
2097         rcu_read_unlock();
2098
2099         return 0;
2100 }
2101
2102 /*
2103  * Add channels/events from UST global domain to registered apps at sock.
2104  */
2105 void ust_app_global_update(struct ltt_ust_session *usess, int sock)
2106 {
2107         int ret = 0;
2108         struct cds_lfht_iter iter;
2109         struct ust_app *app;
2110         struct ust_app_session *ua_sess;
2111         struct ust_app_channel *ua_chan;
2112         struct ust_app_event *ua_event;
2113
2114         if (usess == NULL) {
2115                 ERR("No UST session on global update. Returning");
2116                 goto error;
2117         }
2118
2119         DBG2("UST app global update for app sock %d for session uid %d", sock,
2120                         usess->uid);
2121
2122         rcu_read_lock();
2123
2124         app = find_app_by_sock(sock);
2125         if (app == NULL) {
2126                 ERR("Failed to update app sock %d", sock);
2127                 goto error;
2128         }
2129
2130         ua_sess = create_ust_app_session(usess, app);
2131         if (ua_sess == NULL) {
2132                 goto error;
2133         }
2134
2135         /*
2136          * We can iterate safely here over all UST app session sicne the create ust
2137          * app session above made a shadow copy of the UST global domain from the
2138          * ltt ust session.
2139          */
2140         cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
2141                 ret = create_ust_channel(app, ua_sess, ua_chan);
2142                 if (ret < 0) {
2143                         /* FIXME: Should we quit here or continue... */
2144                         continue;
2145                 }
2146
2147                 /* For each events */
2148                 cds_lfht_for_each_entry(ua_chan->events, &iter, ua_event, node) {
2149                         ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
2150                         if (ret < 0) {
2151                                 /* FIXME: Should we quit here or continue... */
2152                                 continue;
2153                         }
2154                 }
2155         }
2156
2157         if (usess->start_trace) {
2158                 ret = ust_app_start_trace(usess, app);
2159                 if (ret < 0) {
2160                         goto error;
2161                 }
2162
2163                 DBG2("UST trace started for app pid %d", app->key.pid);
2164         }
2165
2166 error:
2167         rcu_read_unlock();
2168         return;
2169 }
2170
2171 /*
2172  * Add context to a specific channel for global UST domain.
2173  */
2174 int ust_app_add_ctx_channel_glb(struct ltt_ust_session *usess,
2175                 struct ltt_ust_channel *uchan, struct ltt_ust_context *uctx)
2176 {
2177         int ret = 0;
2178         struct cds_lfht_node *ua_chan_node;
2179         struct cds_lfht_iter iter, uiter;
2180         struct ust_app_channel *ua_chan = NULL;
2181         struct ust_app_session *ua_sess;
2182         struct ust_app *app;
2183
2184         rcu_read_lock();
2185
2186         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
2187                 ua_sess = lookup_session_by_app(usess, app);
2188                 if (ua_sess == NULL) {
2189                         continue;
2190                 }
2191
2192                 /* Lookup channel in the ust app session */
2193                 ua_chan_node = hashtable_lookup(ua_sess->channels,
2194                                 (void *)uchan->name, strlen(uchan->name), &uiter);
2195                 if (ua_chan_node == NULL) {
2196                         continue;
2197                 }
2198                 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel,
2199                                 node);
2200
2201                 ret = create_ust_app_channel_context(ua_sess, ua_chan, &uctx->ctx, app);
2202                 if (ret < 0) {
2203                         continue;
2204                 }
2205         }
2206
2207         rcu_read_unlock();
2208         return ret;
2209 }
2210
2211 /*
2212  * Add context to a specific event in a channel for global UST domain.
2213  */
2214 int ust_app_add_ctx_event_glb(struct ltt_ust_session *usess,
2215                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent,
2216                 struct ltt_ust_context *uctx)
2217 {
2218         int ret = 0;
2219         struct cds_lfht_node *ua_chan_node, *ua_event_node;
2220         struct cds_lfht_iter iter, uiter;
2221         struct ust_app_session *ua_sess;
2222         struct ust_app_event *ua_event;
2223         struct ust_app_channel *ua_chan = NULL;
2224         struct ust_app *app;
2225
2226         rcu_read_lock();
2227
2228         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
2229                 ua_sess = lookup_session_by_app(usess, app);
2230                 if (ua_sess == NULL) {
2231                         continue;
2232                 }
2233
2234                 /* Lookup channel in the ust app session */
2235                 ua_chan_node = hashtable_lookup(ua_sess->channels,
2236                                 (void *)uchan->name, strlen(uchan->name), &uiter);
2237                 if (ua_chan_node == NULL) {
2238                         continue;
2239                 }
2240                 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel,
2241                                 node);
2242
2243                 ua_event_node = hashtable_lookup(ua_chan->events,
2244                                 (void *)uevent->attr.name, strlen(uevent->attr.name), &uiter);
2245                 if (ua_event_node == NULL) {
2246                         continue;
2247                 }
2248                 ua_event = caa_container_of(ua_event_node, struct ust_app_event,
2249                                 node);
2250
2251                 ret = create_ust_app_event_context(ua_sess, ua_event, &uctx->ctx, app);
2252                 if (ret < 0) {
2253                         continue;
2254                 }
2255         }
2256
2257         rcu_read_unlock();
2258         return ret;
2259 }
2260
2261 /*
2262  * Enable event for a channel from a UST session for a specific PID.
2263  */
2264 int ust_app_enable_event_pid(struct ltt_ust_session *usess,
2265                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
2266 {
2267         int ret = 0;
2268         struct cds_lfht_iter iter;
2269         struct cds_lfht_node *ua_chan_node, *ua_event_node;
2270         struct ust_app *app;
2271         struct ust_app_session *ua_sess;
2272         struct ust_app_channel *ua_chan;
2273         struct ust_app_event *ua_event;
2274
2275         DBG("UST app enabling event %s for PID %d", uevent->attr.name, pid);
2276
2277         rcu_read_lock();
2278
2279         app = ust_app_find_by_pid(pid);
2280         if (app == NULL) {
2281                 ERR("UST app enable event per PID %d not found", pid);
2282                 ret = -1;
2283                 goto error;
2284         }
2285
2286         ua_sess = lookup_session_by_app(usess, app);
2287         /* If ua_sess is NULL, there is a code flow error */
2288         assert(ua_sess);
2289
2290         /* Lookup channel in the ust app session */
2291         ua_chan_node = hashtable_lookup(ua_sess->channels, (void *)uchan->name,
2292                         strlen(uchan->name), &iter);
2293         /* If the channel is not found, there is a code flow error */
2294         assert(ua_chan_node);
2295
2296         ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
2297
2298         ua_event_node = hashtable_lookup(ua_chan->events,
2299                         (void*)uevent->attr.name, strlen(uevent->attr.name), &iter);
2300         if (ua_event_node == NULL) {
2301                 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
2302                 if (ret < 0) {
2303                         goto error;
2304                 }
2305         } else {
2306                 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
2307
2308                 ret = enable_ust_app_event(ua_sess, ua_event, app);
2309                 if (ret < 0) {
2310                         goto error;
2311                 }
2312         }
2313
2314 error:
2315         rcu_read_unlock();
2316         return ret;
2317 }
2318
2319 /*
2320  * Disable event for a channel from a UST session for a specific PID.
2321  */
2322 int ust_app_disable_event_pid(struct ltt_ust_session *usess,
2323                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
2324 {
2325         int ret = 0;
2326         struct cds_lfht_iter iter;
2327         struct cds_lfht_node *ua_chan_node, *ua_event_node;
2328         struct ust_app *app;
2329         struct ust_app_session *ua_sess;
2330         struct ust_app_channel *ua_chan;
2331         struct ust_app_event *ua_event;
2332
2333         DBG("UST app disabling event %s for PID %d", uevent->attr.name, pid);
2334
2335         rcu_read_lock();
2336
2337         app = ust_app_find_by_pid(pid);
2338         if (app == NULL) {
2339                 ERR("UST app disable event per PID %d not found", pid);
2340                 ret = -1;
2341                 goto error;
2342         }
2343
2344         ua_sess = lookup_session_by_app(usess, app);
2345         /* If ua_sess is NULL, there is a code flow error */
2346         assert(ua_sess);
2347
2348         /* Lookup channel in the ust app session */
2349         ua_chan_node = hashtable_lookup(ua_sess->channels, (void *)uchan->name,
2350                         strlen(uchan->name), &iter);
2351         if (ua_chan_node == NULL) {
2352                 /* Channel does not exist, skip disabling */
2353                 goto error;
2354         }
2355         ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
2356
2357         ua_event_node = hashtable_lookup(ua_chan->events,
2358                         (void*)uevent->attr.name, strlen(uevent->attr.name), &iter);
2359         if (ua_event_node == NULL) {
2360                 /* Event does not exist, skip disabling */
2361                 goto error;
2362         }
2363         ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
2364
2365         ret = disable_ust_app_event(ua_sess, ua_event, app);
2366         if (ret < 0) {
2367                 goto error;
2368         }
2369
2370 error:
2371         rcu_read_unlock();
2372         return ret;
2373 }