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                 ua_event_node = hashtable_lookup(ua_chan->events,
 483                                 (void *) uevent->attr.name, strlen(uevent->attr.name), &iter);
 484                 if (ua_event_node == NULL) {
 485                         DBG2("UST event %s not found on shadow copy channel",
 486                                         uevent->attr.name);
 487                         ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
 488                         if (ua_event == NULL) {
 489                                 continue;
 490                         }
 491                         shadow_copy_event(ua_event, uevent);
 492                         hashtable_add_unique(ua_chan->events, &ua_event->node);
 493                 }
 494         }
 495
 496         DBG3("Shadow copy channel done");
 497 }
 498
 499 /*
 500  * Copy data between a UST app session and a regular LTT session.
 501  */
 502 static void shadow_copy_session(struct ust_app_session *ua_sess,
 503                 struct ltt_ust_session *usess)
 504 {
 505         struct cds_lfht_node *ua_chan_node;
 506         struct cds_lfht_iter iter;
 507         struct ltt_ust_channel *uchan;
 508         struct ust_app_channel *ua_chan;
 509
 510         DBG2("Shadow copy of session handle %d", ua_sess->handle);
 511
 512         ua_sess->uid = usess->uid;
 513
 514         /* TODO: support all UST domain */
 515
 516         /* Iterate over all channels in global domain. */
 517         cds_lfht_for_each_entry(usess->domain_global.channels, &iter,
 518                         uchan, node) {
 519                 ua_chan_node = hashtable_lookup(ua_sess->channels,
 520                                 (void *)uchan->name, strlen(uchan->name), &iter);
 521                 if (ua_chan_node != NULL) {
 522                         continue;
 523                 }
 524
 525                 DBG2("Channel %s not found on shadow session copy, creating it",
 526                                 uchan->name);
 527                 ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
 528                 if (ua_chan == NULL) {
 529                         /* malloc failed... continuing */
 530                         continue;
 531                 }
 532
 533                 shadow_copy_channel(ua_chan, uchan);
 534                 hashtable_add_unique(ua_sess->channels, &ua_chan->node);
 535         }
 536 }
 537
 538 /*
 539  * Return ust app session from the app session hashtable using the UST session
 540  * uid.
 541  */
 542 static struct ust_app_session *lookup_session_by_app(
 543                 struct ltt_ust_session *usess, struct ust_app *app)
 544 {
 545         struct cds_lfht_iter iter;
 546         struct cds_lfht_node *node;
 547
 548         /* Get right UST app session from app */
 549         node = hashtable_lookup(app->sessions,
 550                         (void *) ((unsigned long) usess->uid), sizeof(void *), &iter);
 551         if (node == NULL) {
 552                 goto error;
 553         }
 554
 555         return caa_container_of(node, struct ust_app_session, node);
 556
 557 error:
 558         return NULL;
 559 }
 560
 561 /*
 562  * Create a UST session onto the tracer of app and add it the session
 563  * hashtable.
 564  *
 565  * Return ust app session or NULL on error.
 566  */
 567 static struct ust_app_session *create_ust_app_session(
 568                 struct ltt_ust_session *usess, struct ust_app *app)
 569 {
 570         int ret;
 571         struct ust_app_session *ua_sess;
 572
 573         ua_sess = lookup_session_by_app(usess, app);
 574         if (ua_sess == NULL) {
 575                 DBG2("UST app pid: %d session uid %d not found, creating it",
 576                                 app->key.pid, usess->uid);
 577                 ua_sess = alloc_ust_app_session();
 578                 if (ua_sess == NULL) {
 579                         /* Only malloc can failed so something is really wrong */
 580                         goto error;
 581                 }
 582                 shadow_copy_session(ua_sess, usess);
 583         }
 584
 585         if (ua_sess->handle == -1) {
 586                 ret = ustctl_create_session(app->key.sock);
 587                 if (ret < 0) {
 588                         ERR("Error creating session for app pid %d, sock %d",
 589                                         app->key.pid, app->key.sock);
 590                         /* TODO: free() ua_sess */
 591                         goto error;
 592                 }
 593
 594                 DBG2("UST app ustctl create session handle %d", ret);
 595                 ua_sess->handle = ret;
 596
 597                 /* Add ust app session to app's HT */
 598                 hashtable_node_init(&ua_sess->node,
 599                                 (void *)((unsigned long) ua_sess->uid), sizeof(void *));
 600                 hashtable_add_unique(app->sessions, &ua_sess->node);
 601
 602                 DBG2("UST app session created successfully with handle %d", ret);
 603         }
 604
 605         return ua_sess;
 606
 607 error:
 608         return NULL;
 609 }
 610
 611 /*
 612  * Create UST app channel and create it on the tracer.
 613  */
 614 static struct ust_app_channel *create_ust_app_channel(
 615                 struct ust_app_session *ua_sess, struct ltt_ust_channel *uchan,
 616                 struct ust_app *app)
 617 {
 618         int ret = 0;
 619         struct cds_lfht_iter iter;
 620         struct cds_lfht_node *ua_chan_node;
 621         struct ust_app_channel *ua_chan;
 622
 623         /* Lookup channel in the ust app session */
 624         ua_chan_node = hashtable_lookup(ua_sess->channels,
 625                         (void *)uchan->name, strlen(uchan->name), &iter);
 626         if (ua_chan_node == NULL) {
 627                 DBG2("Unable to find channel %s in ust session uid %u",
 628                                 uchan->name, ua_sess->uid);
 629                 ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
 630                 if (ua_chan == NULL) {
 631                         goto error;
 632                 }
 633                 shadow_copy_channel(ua_chan, uchan);
 634
 635                 hashtable_add_unique(ua_sess->channels, &ua_chan->node);
 636         } else {
 637                 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
 638         }
 639
 640         ret = create_ust_channel(app, ua_sess, ua_chan);
 641         if (ret < 0) {
 642                 goto error;
 643         }
 644
 645         return ua_chan;
 646
 647 error:
 648         return NULL;
 649 }
 650
 651 /*
 652  * Create UST app event and create it on the tracer side.
 653  */
 654 static struct ust_app_event *create_ust_app_event(
 655                 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan,
 656                 struct ltt_ust_event *uevent, struct ust_app *app)
 657 {
 658         int ret;
 659         struct cds_lfht_iter iter;
 660         struct cds_lfht_node *ua_event_node;
 661         struct ust_app_event *ua_event;
 662
 663         /* Get event node */
 664         ua_event_node = hashtable_lookup(ua_chan->events,
 665                         (void *)uevent->attr.name, strlen(uevent->attr.name), &iter);
 666         if (ua_event_node == NULL) {
 667                 DBG2("UST app event %s not found, creating it", uevent->attr.name);
 668                 /* Does not exist so create one */
 669                 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
 670                 if (ua_event == NULL) {
 671                         /* Only malloc can failed so something is really wrong */
 672                         goto error;
 673                 }
 674                 shadow_copy_event(ua_event, uevent);
 675
 676                 hashtable_add_unique(ua_chan->events, &ua_event->node);
 677         } else {
 678                 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
 679         }
 680
 681         ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
 682         if (ret < 0) {
 683                 goto error;
 684         }
 685
 686         return ua_event;
 687
 688 error:
 689         return NULL;
 690 }
 691
 692 /*
 693  * Create UST metadata and open it on the tracer side.
 694  */
 695 static int create_ust_app_metadata(struct ust_app_session *ua_sess,
 696                 char *pathname, struct ust_app *app)
 697 {
 698         int ret = 0;
 699
 700         if (ua_sess->metadata == NULL) {
 701                 /* Allocate UST metadata */
 702                 ua_sess->metadata = trace_ust_create_metadata(pathname);
 703                 if (ua_sess->metadata == NULL) {
 704                         ERR("UST app session %d creating metadata failed",
 705                                         ua_sess->handle);
 706                         goto error;
 707                 }
 708
 709                 ret = open_ust_metadata(app, ua_sess);
 710                 if (ret < 0) {
 711                         goto error;
 712                 }
 713
 714                 DBG2("UST metadata opened for app pid %d", app->key.pid);
 715         }
 716
 717         /* Open UST metadata stream */
 718         if (ua_sess->metadata->stream_obj == NULL) {
 719                 ret = create_ust_stream(app, ua_sess);
 720                 if (ret < 0) {
 721                         goto error;
 722                 }
 723
 724                 ret = snprintf(ua_sess->metadata->pathname, PATH_MAX, "%s/%s-%d",
 725                                 pathname, app->name, app->key.pid);
 726                 if (ret < 0) {
 727                         PERROR("asprintf UST create stream");
 728                         goto error;
 729                 }
 730
 731                 ret = mkdir(ua_sess->metadata->pathname, S_IRWXU | S_IRWXG);
 732                 if (ret < 0) {
 733                         PERROR("mkdir UST metadata");
 734                         goto error;
 735                 }
 736
 737                 ret = snprintf(ua_sess->metadata->pathname, PATH_MAX, "%s/%s-%d/metadata",
 738                                 pathname, app->name, app->key.pid);
 739                 if (ret < 0) {
 740                         PERROR("asprintf UST create stream");
 741                         goto error;
 742                 }
 743
 744                 DBG2("UST metadata stream object created for app pid %d",
 745                                 app->key.pid);
 746         } else {
 747                 ERR("Attempting to create stream without metadata opened");
 748                 goto error;
 749         }
 750
 751         return 0;
 752
 753 error:
 754         return -1;
 755 }
 756
 757 /*
 758  * Return pointer to traceable apps list.
 759  */
 760 struct cds_lfht *ust_app_get_ht(void)
 761 {
 762         return ust_app_ht;
 763 }
 764
 765 /*
 766  * Return ust app pointer or NULL if not found.
 767  */
 768 struct ust_app *ust_app_find_by_pid(pid_t pid)
 769 {
 770         struct cds_lfht_node *node;
 771         struct cds_lfht_iter iter;
 772
 773         rcu_read_lock();
 774         node = hashtable_lookup(ust_app_ht,
 775                         (void *)((unsigned long) pid), sizeof(void *), &iter);
 776         if (node == NULL) {
 777                 DBG2("UST app no found with pid %d", pid);
 778                 goto error;
 779         }
 780         rcu_read_unlock();
 781
 782         DBG2("Found UST app by pid %d", pid);
 783
 784         return caa_container_of(node, struct ust_app, node);
 785
 786 error:
 787         rcu_read_unlock();
 788         return NULL;
 789 }
 790
 791 /*
 792  * Using pid and uid (of the app), allocate a new ust_app struct and
 793  * add it to the global traceable app list.
 794  *
 795  * On success, return 0, else return malloc ENOMEM.
 796  */
 797 int ust_app_register(struct ust_register_msg *msg, int sock)
 798 {
 799         struct ust_app *lta;
 800
 801         lta = zmalloc(sizeof(struct ust_app));
 802         if (lta == NULL) {
 803                 PERROR("malloc");
 804                 return -ENOMEM;
 805         }
 806
 807         lta->ppid = msg->ppid;
 808         lta->uid = msg->uid;
 809         lta->gid = msg->gid;
 810         lta->v_major = msg->major;
 811         lta->v_minor = msg->minor;
 812         strncpy(lta->name, msg->name, sizeof(lta->name));
 813         lta->name[16] = '\0';
 814         lta->sessions = hashtable_new(0);
 815
 816         /* Set key map */
 817         lta->key.pid = msg->pid;
 818         hashtable_node_init(&lta->node, (void *)((unsigned long)lta->key.pid),
 819                         sizeof(void *));
 820         lta->key.sock = sock;
 821         hashtable_node_init(&lta->key.node, (void *)((unsigned long)lta->key.sock),
 822                         sizeof(void *));
 823
 824         rcu_read_lock();
 825         hashtable_add_unique(ust_app_sock_key_map, &lta->key.node);
 826         hashtable_add_unique(ust_app_ht, &lta->node);
 827         rcu_read_unlock();
 828
 829         DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s"
 830                         " (version %d.%d)", lta->key.pid, lta->ppid, lta->uid, lta->gid,
 831                         lta->key.sock, lta->name, lta->v_major, lta->v_minor);
 832
 833         return 0;
 834 }
 835
 836 /*
 837  * Unregister app by removing it from the global traceable app list and freeing
 838  * the data struct.
 839  *
 840  * The socket is already closed at this point so no close to sock.
 841  */
 842 void ust_app_unregister(int sock)
 843 {
 844         struct ust_app *lta;
 845         struct cds_lfht_node *node;
 846         struct cds_lfht_iter iter;
 847
 848         rcu_read_lock();
 849         lta = find_app_by_sock(sock);
 850         if (lta == NULL) {
 851                 ERR("Unregister app sock %d not found!", sock);
 852                 goto error;
 853         }
 854
 855         DBG("PID %d unregistering with sock %d", lta->key.pid, sock);
 856
 857         /* Get the node reference for a call_rcu */
 858         node = hashtable_lookup(ust_app_ht,
 859                         (void *)((unsigned long) lta->key.pid), sizeof(void *), &iter);
 860         if (node == NULL) {
 861                 ERR("Unable to find app sock %d by pid %d", sock, lta->key.pid);
 862                 goto error;
 863         }
 864
 865         /* We got called because the socket was closed on the remote end. */
 866         close(sock);
 867         /* Using a flag because we still need "sock" as a key. */
 868         lta->sock_closed = 1;
 869         hashtable_del(ust_app_ht, &iter);
 870         call_rcu(&node->head, delete_ust_app_rcu);
 871 error:
 872         rcu_read_unlock();
 873         return;
 874 }
 875
 876 /*
 877  * Return traceable_app_count
 878  */
 879 unsigned long ust_app_list_count(void)
 880 {
 881         unsigned long count;
 882
 883         rcu_read_lock();
 884         count = hashtable_get_count(ust_app_ht);
 885         rcu_read_unlock();
 886
 887         return count;
 888 }
 889
 890 /*
 891  * Fill events array with all events name of all registered apps.
 892  */
 893 int ust_app_list_events(struct lttng_event **events)
 894 {
 895         int ret, handle;
 896         size_t nbmem, count = 0;
 897         struct cds_lfht_iter iter;
 898         struct ust_app *app;
 899         struct lttng_event *tmp;
 900
 901         nbmem = UST_APP_EVENT_LIST_SIZE;
 902         tmp = zmalloc(nbmem * sizeof(struct lttng_event));
 903         if (tmp == NULL) {
 904                 PERROR("zmalloc ust app events");
 905                 ret = -ENOMEM;
 906                 goto error;
 907         }
 908
 909         rcu_read_lock();
 910
 911         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
 912                 handle = ustctl_tracepoint_list(app->key.sock);
 913                 if (handle < 0) {
 914                         ERR("UST app list events getting handle failed for app pid %d",
 915                                         app->key.pid);
 916                         continue;
 917                 }
 918
 919                 while ((ret = ustctl_tracepoint_list_get(app->key.sock, handle,
 920                                                 tmp[count].name)) != -ENOENT) {
 921                         if (count > nbmem) {
 922                                 DBG2("Reallocating event list from %zu to %zu bytes", nbmem,
 923                                                 nbmem + UST_APP_EVENT_LIST_SIZE);
 924                                 nbmem += UST_APP_EVENT_LIST_SIZE;
 925                                 tmp = realloc(tmp, nbmem);
 926                                 if (tmp == NULL) {
 927                                         PERROR("realloc ust app events");
 928                                         ret = -ENOMEM;
 929                                         goto rcu_error;
 930                                 }
 931                         }
 932
 933                         tmp[count].type = LTTNG_UST_TRACEPOINT;
 934                         tmp[count].pid = app->key.pid;
 935                         tmp[count].enabled = -1;
 936                         count++;
 937                 }
 938         }
 939
 940         ret = count;
 941         *events = tmp;
 942
 943         DBG2("UST app list events done (%zu events)", count);
 944
 945 rcu_error:
 946         rcu_read_unlock();
 947 error:
 948         return ret;
 949 }
 950
 951 /*
 952  * Free and clean all traceable apps of the global list.
 953  */
 954 void ust_app_clean_list(void)
 955 {
 956         int ret;
 957         struct cds_lfht_node *node;
 958         struct cds_lfht_iter iter;
 959         struct ust_app *app;
 960
 961         DBG2("UST app cleaning registered apps hash table");
 962
 963         rcu_read_lock();
 964
 965         cds_lfht_for_each(ust_app_ht, &iter, node) {
 966                 app = caa_container_of(node, struct ust_app, node);
 967                 close(app->key.sock);
 968                 app->sock_closed = 1;
 969
 970                 ret = hashtable_del(ust_app_ht, &iter);
 971                 if (!ret) {
 972                         call_rcu(&node->head, delete_ust_app_rcu);
 973                 }
 974         }
 975
 976         hashtable_destroy(ust_app_ht);
 977         hashtable_destroy(ust_app_sock_key_map);
 978
 979         rcu_read_unlock();
 980 }
 981
 982 /*
 983  * Init UST app hash table.
 984  */
 985 void ust_app_ht_alloc(void)
 986 {
 987         ust_app_ht = hashtable_new(0);
 988         ust_app_sock_key_map = hashtable_new(0);
 989 }
 990
 991 /*
 992  * For a specific UST session, create the channel for all registered apps.
 993  */
 994 int ust_app_create_channel_all(struct ltt_ust_session *usess,
 995                 struct ltt_ust_channel *uchan)
 996 {
 997         int ret = 0;
 998         struct cds_lfht_iter iter;
 999         struct ust_app *app;
1000         struct ust_app_session *ua_sess;
1001         struct ust_app_channel *ua_chan;
1002
1003         if (usess == NULL || uchan == NULL) {
1004                 ERR("Adding UST global channel to NULL values");
1005                 ret = -1;
1006                 goto error;
1007         }
1008
1009         DBG2("UST app adding channel %s to global domain for session uid %d",
1010                         uchan->name, usess->uid);
1011
1012         rcu_read_lock();
1013
1014         /* For every registered applications */
1015         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1016                 /* Create session on the tracer side and add it to app session HT */
1017                 ua_sess = create_ust_app_session(usess, app);
1018                 if (ua_sess == NULL) {
1019                         continue;
1020                 }
1021
1022                 /* Create channel onto application */
1023                 ua_chan = create_ust_app_channel(ua_sess, uchan, app);
1024                 if (ua_chan == NULL) {
1025                         continue;
1026                 }
1027         }
1028
1029         rcu_read_unlock();
1030
1031 error:
1032         return ret;
1033 }
1034
1035 /*
1036  * For a specific UST session and UST channel, create the event for all
1037  * registered apps.
1038  */
1039 int ust_app_create_event_all(struct ltt_ust_session *usess,
1040                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
1041 {
1042         int ret = 0;
1043         struct cds_lfht_iter iter;
1044         struct cds_lfht_node *ua_chan_node;
1045         struct ust_app *app;
1046         struct ust_app_session *ua_sess;
1047         struct ust_app_channel *ua_chan;
1048         struct ust_app_event *ua_event;
1049
1050         DBG("UST app creating event %s for all apps for session uid %d",
1051                         uevent->attr.name, usess->uid);
1052
1053         rcu_read_lock();
1054
1055         /* For all registered applications */
1056         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1057                 /* Create session on the tracer side and add it to app session HT */
1058                 ua_sess = create_ust_app_session(usess, app);
1059                 if (ua_sess == NULL) {
1060                         continue;
1061                 }
1062
1063                 /* Lookup channel in the ust app session */
1064                 ua_chan_node = hashtable_lookup(ua_sess->channels,
1065                                 (void *)uchan->name, strlen(uchan->name), &iter);
1066                 if (ua_chan_node == NULL) {
1067                         ERR("Channel %s not found in session uid %d. Skipping",
1068                                         uchan->name, usess->uid);
1069                         continue;
1070                 }
1071                 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1072
1073                 ua_event = create_ust_app_event(ua_sess, ua_chan, uevent, app);
1074                 if (ua_event == NULL) {
1075                         continue;
1076                 }
1077         }
1078
1079         rcu_read_unlock();
1080
1081         return ret;
1082 }
1083
1084 /*
1085  * Start tracing for a specific UST session and app.
1086  */
1087 int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
1088 {
1089         int ret = 0;
1090         struct cds_lfht_iter iter;
1091         struct ust_app_session *ua_sess;
1092         struct ust_app_channel *ua_chan;
1093         struct ltt_ust_stream *ustream;
1094
1095         DBG("Starting tracing for ust app pid %d", app->key.pid);
1096
1097         rcu_read_lock();
1098
1099         ua_sess = lookup_session_by_app(usess, app);
1100         if (ua_sess == NULL) {
1101                 /* Only malloc can failed so something is really wrong */
1102                 goto error_rcu_unlock;
1103         }
1104
1105         ret = create_ust_app_metadata(ua_sess, usess->pathname, app);
1106         if (ret < 0) {
1107                 goto error_rcu_unlock;
1108         }
1109
1110         /* For each channel */
1111         cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
1112                 /* Create all streams */
1113                 while (1) {
1114                         /* Create UST stream */
1115                         ustream = zmalloc(sizeof(*ustream));
1116                         if (ustream == NULL) {
1117                                 PERROR("zmalloc ust stream");
1118                                 goto error_rcu_unlock;
1119                         }
1120
1121                         ret = ustctl_create_stream(app->key.sock, ua_chan->obj,
1122                                         &ustream->obj);
1123                         if (ret < 0) {
1124                                 /* Got all streams */
1125                                 break;
1126                         }
1127                         ustream->handle = ustream->obj->handle;
1128
1129                         /* Order is important */
1130                         cds_list_add_tail(&ustream->list, &ua_chan->streams.head);
1131                         ret = snprintf(ustream->pathname, PATH_MAX, "%s/%s-%d/%s_%u",
1132                                         usess->pathname, app->name, app->key.pid,
1133                                         ua_chan->name, ua_chan->streams.count++);
1134                         if (ret < 0) {
1135                                 PERROR("asprintf UST create stream");
1136                                 continue;
1137                         }
1138                         DBG2("UST stream %d ready at %s", ua_chan->streams.count,
1139                                         ustream->pathname);
1140                 }
1141         }
1142
1143         /* Setup UST consumer socket and send fds to it */
1144         ret = ust_consumer_send_session(ust_consumer_fd, ua_sess);
1145         if (ret < 0) {
1146                 goto error_rcu_unlock;
1147         }
1148
1149         /* This start the UST tracing */
1150         ret = ustctl_start_session(app->key.sock, ua_sess->handle);
1151         if (ret < 0) {
1152                 ERR("Error starting tracing for app pid: %d", app->key.pid);
1153                 goto error_rcu_unlock;
1154         }
1155
1156         rcu_read_unlock();
1157
1158         /* Quiescent wait after starting trace */
1159         ustctl_wait_quiescent(app->key.sock);
1160
1161         return 0;
1162
1163 error_rcu_unlock:
1164         rcu_read_unlock();
1165         return -1;
1166 }
1167
1168 /*
1169  * Start tracing for the UST session.
1170  */
1171 int ust_app_start_trace_all(struct ltt_ust_session *usess)
1172 {
1173         int ret = 0;
1174         struct cds_lfht_iter iter;
1175         struct ust_app *app;
1176
1177         DBG("Starting all UST traces");
1178
1179         rcu_read_lock();
1180
1181         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1182                 ret = ust_app_start_trace(usess, app);
1183                 if (ret < 0) {
1184                         /* Continue to next apps even on error */
1185                         continue;
1186                 }
1187         }
1188
1189         rcu_read_unlock();
1190
1191         return 0;
1192 }
1193
1194 /*
1195  * Add channels/events from UST global domain to registered apps at sock.
1196  */
1197 void ust_app_global_update(struct ltt_ust_session *usess, int sock)
1198 {
1199         int ret = 0;
1200         struct cds_lfht_iter iter;
1201         struct ust_app *app;
1202         struct ust_app_session *ua_sess;
1203         struct ust_app_channel *ua_chan;
1204         struct ust_app_event *ua_event;
1205
1206         if (usess == NULL) {
1207                 ERR("No UST session on global update. Returning");
1208                 goto error;
1209         }
1210
1211         DBG2("UST app global update for app sock %d for session uid %d", sock,
1212                         usess->uid);
1213
1214         rcu_read_lock();
1215
1216         app = find_app_by_sock(sock);
1217         if (app == NULL) {
1218                 ERR("Failed to update app sock %d", sock);
1219                 goto error;
1220         }
1221
1222         ua_sess = create_ust_app_session(usess, app);
1223         if (ua_sess == NULL) {
1224                 goto error;
1225         }
1226
1227         /*
1228          * We can iterate safely here over all UST app session sicne the create ust
1229          * app session above made a shadow copy of the UST global domain from the
1230          * ltt ust session.
1231          */
1232         cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
1233                 ret = create_ust_channel(app, ua_sess, ua_chan);
1234                 if (ret < 0) {
1235                         /* FIXME: Should we quit here or continue... */
1236                         continue;
1237                 }
1238
1239                 /* For each events */
1240                 cds_lfht_for_each_entry(ua_chan->events, &iter, ua_event, node) {
1241                         ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
1242                         if (ret < 0) {
1243                                 /* FIXME: Should we quit here or continue... */
1244                                 continue;
1245                         }
1246                 }
1247         }
1248
1249         if (usess->start_trace) {
1250                 ret = ust_app_start_trace(usess, app);
1251                 if (ret < 0) {
1252                         goto error;
1253                 }
1254
1255                 DBG2("UST trace started for app pid %d", app->key.pid);
1256         }
1257
1258 error:
1259         rcu_read_unlock();
1260         return;
1261 }