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