lttng-sessiond/ust-app.c

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