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