lttng-sessiond/ust-app.c

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