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  * Return pointer to traceable apps list.
 241  */
 242 struct cds_lfht *ust_app_get_ht(void)
 243 {
 244         return ust_app_ht;
 245 }
 246
 247 /*
 248  * Return ust app pointer or NULL if not found.
 249  */
 250 struct ust_app *ust_app_find_by_pid(pid_t pid)
 251 {
 252         struct cds_lfht_node *node;
 253         struct cds_lfht_iter iter;
 254
 255         rcu_read_lock();
 256         node = hashtable_lookup(ust_app_ht,
 257                         (void *)((unsigned long) pid), sizeof(void *), &iter);
 258         if (node == NULL) {
 259                 DBG2("UST app no found with pid %d", pid);
 260                 goto error;
 261         }
 262         rcu_read_unlock();
 263
 264         DBG2("Found UST app by pid %d", pid);
 265
 266         return caa_container_of(node, struct ust_app, node);
 267
 268 error:
 269         rcu_read_unlock();
 270         return NULL;
 271 }
 272
 273 /*
 274  * Using pid and uid (of the app), allocate a new ust_app struct and
 275  * add it to the global traceable app list.
 276  *
 277  * On success, return 0, else return malloc ENOMEM.
 278  */
 279 int ust_app_register(struct ust_register_msg *msg, int sock)
 280 {
 281         struct ust_app *lta;
 282
 283         lta = zmalloc(sizeof(struct ust_app));
 284         if (lta == NULL) {
 285                 PERROR("malloc");
 286                 return -ENOMEM;
 287         }
 288
 289         lta->ppid = msg->ppid;
 290         lta->uid = msg->uid;
 291         lta->gid = msg->gid;
 292         lta->v_major = msg->major;
 293         lta->v_minor = msg->minor;
 294         strncpy(lta->name, msg->name, sizeof(lta->name));
 295         lta->name[16] = '\0';
 296         lta->sessions = hashtable_new(0);
 297
 298         /* Set key map */
 299         lta->key.pid = msg->pid;
 300         hashtable_node_init(&lta->node, (void *)((unsigned long)lta->key.pid),
 301                         sizeof(void *));
 302         lta->key.sock = sock;
 303         hashtable_node_init(&lta->key.node, (void *)((unsigned long)lta->key.sock),
 304                         sizeof(void *));
 305
 306         rcu_read_lock();
 307         hashtable_add_unique(ust_app_sock_key_map, &lta->key.node);
 308         hashtable_add_unique(ust_app_ht, &lta->node);
 309         rcu_read_unlock();
 310
 311         DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s"
 312                         " (version %d.%d)", lta->key.pid, lta->ppid, lta->uid, lta->gid,
 313                         lta->key.sock, lta->name, lta->v_major, lta->v_minor);
 314
 315         return 0;
 316 }
 317
 318 /*
 319  * Unregister app by removing it from the global traceable app list and freeing
 320  * the data struct.
 321  *
 322  * The socket is already closed at this point so no close to sock.
 323  */
 324 void ust_app_unregister(int sock)
 325 {
 326         struct ust_app *lta;
 327         struct cds_lfht_node *node;
 328         struct cds_lfht_iter iter;
 329
 330         rcu_read_lock();
 331         lta = find_app_by_sock(sock);
 332         if (lta == NULL) {
 333                 ERR("Unregister app sock %d not found!", sock);
 334                 goto error;
 335         }
 336
 337         DBG("PID %d unregistering with sock %d", lta->key.pid, sock);
 338
 339         /* Get the node reference for a call_rcu */
 340         node = hashtable_lookup(ust_app_ht,
 341                         (void *)((unsigned long) lta->key.pid), sizeof(void *), &iter);
 342         if (node == NULL) {
 343                 ERR("Unable to find app sock %d by pid %d", sock, lta->key.pid);
 344                 goto error;
 345         }
 346
 347         /* We got called because the socket was closed on the remote end. */
 348         close(sock);
 349         /* Using a flag because we still need "sock" as a key. */
 350         lta->sock_closed = 1;
 351         hashtable_del(ust_app_ht, &iter);
 352         call_rcu(&node->head, delete_ust_app_rcu);
 353 error:
 354         rcu_read_unlock();
 355         return;
 356 }
 357
 358 /*
 359  * Return traceable_app_count
 360  */
 361 unsigned long ust_app_list_count(void)
 362 {
 363         unsigned long count;
 364
 365         rcu_read_lock();
 366         count = hashtable_get_count(ust_app_ht);
 367         rcu_read_unlock();
 368
 369         return count;
 370 }
 371
 372 /*
 373  * Fill events array with all events name of all registered apps.
 374  */
 375 int ust_app_list_events(struct lttng_event **events)
 376 {
 377         int ret, handle;
 378         size_t nbmem, count = 0;
 379         struct cds_lfht_iter iter;
 380         struct ust_app *app;
 381         struct lttng_event *tmp;
 382
 383         nbmem = UST_APP_EVENT_LIST_SIZE;
 384         tmp = zmalloc(nbmem * sizeof(struct lttng_event));
 385         if (tmp == NULL) {
 386                 PERROR("zmalloc ust app events");
 387                 ret = -ENOMEM;
 388                 goto error;
 389         }
 390
 391         rcu_read_lock();
 392
 393         cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
 394                 handle = ustctl_tracepoint_list(app->key.sock);
 395                 if (handle < 0) {
 396                         ERR("UST app list events getting handle failed for app pid %d",
 397                                         app->key.pid);
 398                         continue;
 399                 }
 400
 401                 while ((ret = ustctl_tracepoint_list_get(app->key.sock, handle,
 402                                                 tmp[count].name)) != -ENOENT) {
 403                         if (count > nbmem) {
 404                                 DBG2("Reallocating event list from %zu to %zu bytes", nbmem,
 405                                                 nbmem + UST_APP_EVENT_LIST_SIZE);
 406                                 nbmem += UST_APP_EVENT_LIST_SIZE;
 407                                 tmp = realloc(tmp, nbmem);
 408                                 if (tmp == NULL) {
 409                                         PERROR("realloc ust app events");
 410                                         ret = -ENOMEM;
 411                                         goto rcu_error;
 412                                 }
 413                         }
 414
 415                         tmp[count].type = LTTNG_UST_TRACEPOINT;
 416                         tmp[count].pid = app->key.pid;
 417                         tmp[count].enabled = -1;
 418                         count++;
 419                 }
 420         }
 421
 422         ret = count;
 423         *events = tmp;
 424
 425         DBG2("UST app list events done (%zu events)", count);
 426
 427 rcu_error:
 428         rcu_read_unlock();
 429 error:
 430         return ret;
 431 }
 432
 433 /*
 434  * Free and clean all traceable apps of the global list.
 435  */
 436 void ust_app_clean_list(void)
 437 {
 438         int ret;
 439         struct cds_lfht_node *node;
 440         struct cds_lfht_iter iter;
 441         struct ust_app *app;
 442
 443         DBG2("UST app cleaning registered apps hash table");
 444
 445         rcu_read_lock();
 446
 447         cds_lfht_for_each(ust_app_ht, &iter, node) {
 448                 app = caa_container_of(node, struct ust_app, node);
 449                 close(app->key.sock);
 450                 app->sock_closed = 1;
 451
 452                 ret = hashtable_del(ust_app_ht, &iter);
 453                 if (!ret) {
 454                         call_rcu(&node->head, delete_ust_app_rcu);
 455                 }
 456         }
 457
 458         hashtable_destroy(ust_app_ht);
 459         hashtable_destroy(ust_app_sock_key_map);
 460
 461         rcu_read_unlock();
 462 }
 463
 464 /*
 465  * Init UST app hash table.
 466  */
 467 void ust_app_ht_alloc(void)
 468 {
 469         ust_app_ht = hashtable_new(0);
 470         ust_app_sock_key_map = hashtable_new(0);
 471 }
 472
 473 /*
 474  * Alloc new UST app session.
 475  */
 476 static struct ust_app_session *alloc_ust_app_session(void)
 477 {
 478         struct ust_app_session *ua_sess;
 479
 480         /* Init most of the default value by allocating and zeroing */
 481         ua_sess = zmalloc(sizeof(struct ust_app_session));
 482         if (ua_sess == NULL) {
 483                 PERROR("malloc");
 484                 goto error;
 485         }
 486
 487         ua_sess->handle = -1;
 488         ua_sess->channels = hashtable_new_str(0);
 489
 490         return ua_sess;
 491
 492 error:
 493         return NULL;
 494 }
 495
 496 /*
 497  * Alloc new UST app channel.
 498  */
 499 static struct ust_app_channel *alloc_ust_app_channel(char *name,
 500                 struct lttng_ust_channel *attr)
 501 {
 502         struct ust_app_channel *ua_chan;
 503
 504         /* Init most of the default value by allocating and zeroing */
 505         ua_chan = zmalloc(sizeof(struct ust_app_channel));
 506         if (ua_chan == NULL) {
 507                 PERROR("malloc");
 508                 goto error;
 509         }
 510
 511         /* Setup channel name */
 512         strncpy(ua_chan->name, name, sizeof(ua_chan->name));
 513         ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
 514
 515         ua_chan->handle = -1;
 516         ua_chan->ctx = hashtable_new(0);
 517         ua_chan->events = hashtable_new_str(0);
 518         hashtable_node_init(&ua_chan->node, (void *) ua_chan->name,
 519                         strlen(ua_chan->name));
 520
 521         CDS_INIT_LIST_HEAD(&ua_chan->streams.head);
 522
 523         /* Copy attributes */
 524         if (attr) {
 525                 memcpy(&ua_chan->attr, attr, sizeof(ua_chan->attr));
 526         }
 527
 528         DBG3("UST app channel %s allocated", ua_chan->name);
 529
 530         return ua_chan;
 531
 532 error:
 533         return NULL;
 534 }
 535
 536 /*
 537  * Alloc new UST app event.
 538  */
 539 static struct ust_app_event *alloc_ust_app_event(char *name,
 540                 struct lttng_ust_event *attr)
 541 {
 542         struct ust_app_event *ua_event;
 543
 544         /* Init most of the default value by allocating and zeroing */
 545         ua_event = zmalloc(sizeof(struct ust_app_event));
 546         if (ua_event == NULL) {
 547                 PERROR("malloc");
 548                 goto error;
 549         }
 550
 551         strncpy(ua_event->name, name, sizeof(ua_event->name));
 552         ua_event->name[sizeof(ua_event->name) - 1] = '\0';
 553         ua_event->ctx = hashtable_new(0);
 554         hashtable_node_init(&ua_event->node, (void *) ua_event->name,
 555                         strlen(ua_event->name));
 556
 557         /* Copy attributes */
 558         if (attr) {
 559                 memcpy(&ua_event->attr, attr, sizeof(ua_event->attr));
 560         }
 561
 562         DBG3("UST app event %s allocated", ua_event->name);
 563
 564         return ua_event;
 565
 566 error:
 567         return NULL;
 568 }
 569
 570 static void shadow_copy_event(struct ust_app_event *ua_event,
 571                 struct ltt_ust_event *uevent)
 572 {
 573         strncpy(ua_event->name, uevent->attr.name, sizeof(ua_event->name));
 574         ua_event->name[sizeof(ua_event->name) - 1] = '\0';
 575
 576         /* TODO: support copy context */
 577 }
 578
 579 static void shadow_copy_channel(struct ust_app_channel *ua_chan,
 580                 struct ltt_ust_channel *uchan)
 581 {
 582         struct cds_lfht_iter iter;
 583         struct cds_lfht_node *node, *ua_event_node;
 584         struct ltt_ust_event *uevent;
 585         struct ust_app_event *ua_event;
 586
 587         DBG2("Shadow copy of UST app channel %s", ua_chan->name);
 588
 589         strncpy(ua_chan->name, uchan->name, sizeof(ua_chan->name));
 590         ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
 591
 592         /* TODO: support copy context */
 593
 594         /* Copy all events from ltt ust channel to ust app channel */
 595         hashtable_get_first(uchan->events, &iter);
 596         while ((node = hashtable_iter_get_node(&iter)) != NULL) {
 597                 uevent = caa_container_of(node, struct ltt_ust_event, node);
 598
 599                 ua_event_node = hashtable_lookup(ua_chan->events,
 600                                 (void *) uevent->attr.name, strlen(uevent->attr.name), &iter);
 601                 if (ua_event_node == NULL) {
 602                         DBG2("UST event %s not found on shadow copy channel",
 603                                         uevent->attr.name);
 604                         ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
 605                         if (ua_event == NULL) {
 606                                 goto next;
 607                         }
 608                         shadow_copy_event(ua_event, uevent);
 609                         hashtable_add_unique(ua_chan->events, &ua_event->node);
 610                 }
 611
 612 next:
 613                 /* Get next UST events */
 614                 hashtable_get_next(uchan->events, &iter);
 615         }
 616
 617         DBG3("Shadow copy channel done");
 618 }
 619
 620 static void shadow_copy_session(struct ust_app_session *ua_sess,
 621                 struct ltt_ust_session *usess)
 622 {
 623         struct cds_lfht_node *node, *ua_chan_node;
 624         struct cds_lfht_iter iter;
 625         struct ltt_ust_channel *uchan;
 626         struct ust_app_channel *ua_chan;
 627
 628         DBG2("Shadow copy of session handle %d", ua_sess->handle);
 629
 630         ua_sess->uid = usess->uid;
 631
 632         /* TODO: support all UST domain */
 633
 634         /* Iterate over all channels in global domain. */
 635         hashtable_get_first(usess->domain_global.channels, &iter);
 636         while ((node = hashtable_iter_get_node(&iter)) != NULL) {
 637                 uchan = caa_container_of(node, struct ltt_ust_channel, node);
 638
 639                 ua_chan_node = hashtable_lookup(ua_sess->channels,
 640                                 (void *)uchan->name, strlen(uchan->name), &iter);
 641                 if (ua_chan_node == NULL) {
 642                         DBG2("Channel %s not found on shadow session copy, creating it",
 643                                         uchan->name);
 644                         ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
 645                         if (ua_chan == NULL) {
 646                                 /* malloc failed... continuing */
 647                                 goto next;
 648                         }
 649
 650                         shadow_copy_channel(ua_chan, uchan);
 651                         hashtable_add_unique(ua_sess->channels, &ua_chan->node);
 652                 }
 653
 654 next:
 655                 /* Next item in hash table */
 656                 hashtable_get_next(usess->domain_global.channels, &iter);
 657         }
 658 }
 659
 660 /*
 661  * Return ust app session from the app session hashtable using the UST session
 662  * uid.
 663  */
 664 static struct ust_app_session *lookup_session_by_app(
 665                 struct ltt_ust_session *usess, struct ust_app *app)
 666 {
 667         struct cds_lfht_iter iter;
 668         struct cds_lfht_node *node;
 669
 670         /* Get right UST app session from app */
 671         node = hashtable_lookup(app->sessions,
 672                         (void *) ((unsigned long) usess->uid), sizeof(void *), &iter);
 673         if (node == NULL) {
 674                 goto error;
 675         }
 676
 677         return caa_container_of(node, struct ust_app_session, node);
 678
 679 error:
 680         return NULL;
 681 }
 682
 683 /*
 684  * Create a UST session onto the tracer of app and add it the session
 685  * hashtable.
 686  *
 687  * Return ust app session or NULL on error.
 688  */
 689 static struct ust_app_session *create_ust_app_session(
 690                 struct ltt_ust_session *usess, struct ust_app *app)
 691 {
 692         int ret;
 693         struct ust_app_session *ua_sess;
 694
 695         ua_sess = lookup_session_by_app(usess, app);
 696         if (ua_sess == NULL) {
 697                 DBG2("UST app pid: %d session uid %d not found, creating it",
 698                                 app->key.pid, usess->uid);
 699                 ua_sess = alloc_ust_app_session();
 700                 if (ua_sess == NULL) {
 701                         /* Only malloc can failed so something is really wrong */
 702                         goto error;
 703                 }
 704                 shadow_copy_session(ua_sess, usess);
 705         }
 706
 707         if (ua_sess->handle == -1) {
 708                 ret = ustctl_create_session(app->key.sock);
 709                 if (ret < 0) {
 710                         ERR("Error creating session for app pid %d, sock %d",
 711                                         app->key.pid, app->key.sock);
 712                         /* TODO: free() ua_sess */
 713                         goto error;
 714                 }
 715
 716                 DBG2("UST app ustctl create session handle %d", ret);
 717                 ua_sess->handle = ret;
 718
 719                 /* Add ust app session to app's HT */
 720                 hashtable_node_init(&ua_sess->node,
 721                                 (void *)((unsigned long) ua_sess->uid), sizeof(void *));
 722                 hashtable_add_unique(app->sessions, &ua_sess->node);
 723
 724                 DBG2("UST app session created successfully with handle %d", ret);
 725         }
 726
 727         return ua_sess;
 728
 729 error:
 730         return NULL;
 731 }
 732
 733 /*
 734  * Create the specified channel onto the UST tracer for a UST session.
 735  */
 736 static int create_ust_channel(struct ust_app *app,
 737                 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
 738 {
 739         int ret;
 740
 741         /* TODO: remove cast and use lttng-ust-abi.h */
 742         ret = ustctl_create_channel(app->key.sock, ua_sess->handle,
 743                         (struct lttng_ust_channel_attr *)&ua_chan->attr, &ua_chan->obj);
 744         if (ret < 0) {
 745                 DBG("Error creating channel %s for app (pid: %d, sock: %d) "
 746                                 "and session handle %d with ret %d",
 747                                 ua_chan->name, app->key.pid, app->key.sock,
 748                                 ua_sess->handle, ret);
 749                 goto error;
 750         }
 751
 752         ua_chan->handle = ua_chan->obj->handle;
 753         ua_chan->attr.shm_fd = ua_chan->obj->shm_fd;
 754         ua_chan->attr.wait_fd = ua_chan->obj->wait_fd;
 755         ua_chan->attr.memory_map_size = ua_chan->obj->memory_map_size;
 756
 757         DBG2("UST app channel %s created successfully for pid:%d and sock:%d",
 758                         ua_chan->name, app->key.pid, app->key.sock);
 759
 760 error:
 761         return ret;
 762 }
 763
 764 /*
 765  * Create the specified event onto the UST tracer for a UST session.
 766  */
 767 static int create_ust_event(struct ust_app *app,
 768                 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan,
 769                 struct ust_app_event *ua_event)
 770 {
 771         int ret = 0;
 772
 773         /* Create UST event on tracer */
 774         ret = ustctl_create_event(app->key.sock, &ua_event->attr, ua_chan->obj,
 775                         &ua_event->obj);
 776         if (ret < 0) {
 777                 ERR("Error ustctl create event %s for app pid: %d with ret %d",
 778                                 ua_event->attr.name, app->key.pid, ret);
 779                 goto error;
 780         }
 781
 782         ua_event->handle = ua_event->obj->handle;
 783         ua_event->enabled = 1;
 784
 785         DBG2("UST app event %s created successfully for pid:%d",
 786                         ua_event->attr.name, app->key.pid);
 787
 788 error:
 789         return ret;
 790 }
 791
 792 static struct ust_app_channel *create_ust_app_channel(
 793                 struct ust_app_session *ua_sess, struct ltt_ust_channel *uchan,
 794                 struct ust_app *app)
 795 {
 796         int ret = 0;
 797         struct cds_lfht_iter iter;
 798         struct cds_lfht_node *ua_chan_node;
 799         struct ust_app_channel *ua_chan;
 800
 801         /* Lookup channel in the ust app session */
 802         ua_chan_node = hashtable_lookup(ua_sess->channels,
 803                         (void *)uchan->name, strlen(uchan->name), &iter);
 804         if (ua_chan_node == NULL) {
 805                 DBG2("Unable to find channel %s in ust session uid %u",
 806                                 uchan->name, ua_sess->uid);
 807                 ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
 808                 if (ua_chan == NULL) {
 809                         goto error;
 810                 }
 811                 shadow_copy_channel(ua_chan, uchan);
 812
 813                 hashtable_add_unique(ua_sess->channels, &ua_chan->node);
 814         } else {
 815                 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
 816         }
 817
 818         ret = create_ust_channel(app, ua_sess, ua_chan);
 819         if (ret < 0) {
 820                 goto error;
 821         }
 822
 823         return ua_chan;
 824
 825 error:
 826         return NULL;
 827 }
 828
 829 static struct ust_app_event *create_ust_app_event(
 830                 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan,
 831                 struct ltt_ust_event *uevent, struct ust_app *app)
 832 {
 833         int ret;
 834         struct cds_lfht_iter iter;
 835         struct cds_lfht_node *ua_event_node;
 836         struct ust_app_event *ua_event;
 837
 838         /* Get event node */
 839         ua_event_node = hashtable_lookup(ua_chan->events,
 840                         (void *)uevent->attr.name, strlen(uevent->attr.name), &iter);
 841         if (ua_event_node == NULL) {
 842                 DBG2("UST app event %s not found, creating it", uevent->attr.name);
 843                 /* Does not exist so create one */
 844                 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
 845                 if (ua_event == NULL) {
 846                         /* Only malloc can failed so something is really wrong */
 847                         goto error;
 848                 }
 849                 shadow_copy_event(ua_event, uevent);
 850
 851                 hashtable_add_unique(ua_chan->events, &ua_event->node);
 852         } else {
 853                 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
 854         }
 855
 856         ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
 857         if (ret < 0) {
 858                 goto error;
 859         }
 860
 861         return ua_event;
 862
 863 error:
 864         return NULL;
 865 }
 866
 867 static int create_ust_app_metadata(struct ust_app_session *ua_sess,
 868                 char *pathname, struct ust_app *app)
 869 {
 870         int ret = 0;
 871         struct lttng_ust_channel_attr uattr;
 872
 873         if (ua_sess->metadata == NULL) {
 874                 /* Allocate UST metadata */
 875                 ua_sess->metadata = trace_ust_create_metadata(pathname);
 876                 if (ua_sess->metadata == NULL) {
 877                         ERR("UST app session %d creating metadata failed",
 878                                         ua_sess->handle);
 879                         goto error;
 880                 }
 881
 882                 uattr.overwrite = ua_sess->metadata->attr.overwrite;
 883                 uattr.subbuf_size = ua_sess->metadata->attr.subbuf_size;
 884                 uattr.num_subbuf = ua_sess->metadata->attr.num_subbuf;
 885                 uattr.switch_timer_interval =
 886                         ua_sess->metadata->attr.switch_timer_interval;
 887                 uattr.read_timer_interval =
 888                         ua_sess->metadata->attr.read_timer_interval;
 889                 uattr.output = ua_sess->metadata->attr.output;
 890
 891                 /* UST tracer metadata creation */
 892                 ret = ustctl_open_metadata(app->key.sock, ua_sess->handle, &uattr,
 893                                 &ua_sess->metadata->obj);
 894                 if (ret < 0) {
 895                         ERR("UST app open metadata failed for app pid:%d",
 896                                         app->key.pid);
 897                         goto error;
 898                 }
 899
 900                 DBG2("UST metadata opened for app pid %d", app->key.pid);
 901         }
 902
 903         /* Open UST metadata stream */
 904         if (ua_sess->metadata->stream_obj == NULL) {
 905                 ret = ustctl_create_stream(app->key.sock, ua_sess->metadata->obj,
 906                                 &ua_sess->metadata->stream_obj);
 907                 if (ret < 0) {
 908                         ERR("UST create metadata stream failed");
 909                         goto error;
 910                 }
 911
 912                 ret = snprintf(ua_sess->metadata->pathname, PATH_MAX, "%s/%s-%d",
 913                                 pathname, app->name, app->key.pid);
 914                 if (ret < 0) {
 915                         PERROR("asprintf UST create stream");
 916                         goto error;
 917                 }
 918
 919                 ret = mkdir(ua_sess->metadata->pathname, S_IRWXU | S_IRWXG);
 920                 if (ret < 0) {
 921                         PERROR("mkdir UST metadata");
 922                         goto error;
 923                 }
 924
 925                 ret = snprintf(ua_sess->metadata->pathname, PATH_MAX, "%s/%s-%d/metadata",
 926                                 pathname, app->name, app->key.pid);
 927                 if (ret < 0) {
 928                         PERROR("asprintf UST create stream");
 929                         goto error;
 930                 }
 931
 932                 DBG2("UST metadata stream object created for app pid %d",
 933                                 app->key.pid);
 934         }
 935
 936         return 0;
 937
 938 error:
 939         return -1;
 940 }
 941
 942 /*
 943  * Add channel to all ust app session.
 944  */
 945 int ust_app_add_channel_all(struct ltt_ust_session *usess,
 946                 struct ltt_ust_channel *uchan)
 947 {
 948         int ret = 0;
 949         struct cds_lfht_iter iter;
 950         struct cds_lfht_node *node;
 951         struct ust_app *app;
 952         struct ust_app_session *ua_sess;
 953         struct ust_app_channel *ua_chan;
 954
 955         if (usess == NULL || uchan == NULL) {
 956                 ERR("Adding UST global channel to NULL values");
 957                 ret = -1;
 958                 goto error;
 959         }
 960
 961         DBG2("UST app adding channel %s to global domain for session uid %d",
 962                         uchan->name, usess->uid);
 963
 964         rcu_read_lock();
 965
 966         /* For every UST applications registered */
 967         hashtable_get_first(ust_app_ht, &iter);
 968         while ((node = hashtable_iter_get_node(&iter)) != NULL) {
 969                 app = caa_container_of(node, struct ust_app, node);
 970
 971                 /* Create session on the tracer side and add it to app session HT */
 972                 ua_sess = create_ust_app_session(usess, app);
 973                 if (ua_sess == NULL) {
 974                         goto next;
 975                 }
 976
 977                 /* Create channel onto application */
 978                 ua_chan = create_ust_app_channel(ua_sess, uchan, app);
 979                 if (ua_chan == NULL) {
 980                         goto next;
 981                 }
 982
 983 next:
 984                 /* Next applications */
 985                 hashtable_get_next(ust_app_ht, &iter);
 986         }
 987         rcu_read_unlock();
 988
 989 error:
 990         return ret;
 991 }
 992
 993 int ust_app_add_event_all(struct ltt_ust_session *usess,
 994                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
 995 {
 996         int ret = 0;
 997         struct cds_lfht_iter iter;
 998         struct cds_lfht_node *node, *ua_chan_node;
 999         struct ust_app *app;
1000         struct ust_app_session *ua_sess;
1001         struct ust_app_channel *ua_chan;
1002         struct ust_app_event *ua_event;
1003
1004         DBG("UST app creating event %s for all apps for session uid %d",
1005                         uevent->attr.name, usess->uid);
1006
1007         rcu_read_lock();
1008
1009         /* For all registered applications */
1010         hashtable_get_first(ust_app_ht, &iter);
1011         while ((node = hashtable_iter_get_node(&iter)) != NULL) {
1012                 app = caa_container_of(node, struct ust_app, node);
1013
1014                 /* Create session on the tracer side and add it to app session HT */
1015                 ua_sess = create_ust_app_session(usess, app);
1016                 if (ua_sess == NULL) {
1017                         goto next;
1018                 }
1019
1020                 /* Lookup channel in the ust app session */
1021                 ua_chan_node = hashtable_lookup(ua_sess->channels,
1022                                 (void *)uchan->name, strlen(uchan->name), &iter);
1023                 if (ua_chan_node == NULL) {
1024                         ERR("Channel %s not found in session uid %d. Skipping",
1025                                         uchan->name, usess->uid);
1026                         goto next;
1027                 }
1028                 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1029
1030                 ua_event = create_ust_app_event(ua_sess, ua_chan, uevent, app);
1031                 if (ua_event == NULL) {
1032                         goto next;
1033                 }
1034
1035 next:
1036                 /* Next applications */
1037                 hashtable_get_next(ust_app_ht, &iter);
1038         }
1039         rcu_read_unlock();
1040
1041         return ret;
1042 }
1043
1044 int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
1045 {
1046         int ret = 0;
1047         struct cds_lfht_iter iter;
1048         struct cds_lfht_node *node;
1049         struct ust_app_session *ua_sess;
1050         struct ust_app_channel *ua_chan;
1051
1052         DBG("Starting tracing for ust app pid %d", app->key.pid);
1053
1054         rcu_read_lock();
1055
1056         ua_sess = lookup_session_by_app(usess, app);
1057         if (ua_sess == NULL) {
1058                 /* Only malloc can failed so something is really wrong */
1059                 goto error_rcu_unlock;
1060         }
1061
1062         ret = create_ust_app_metadata(ua_sess, usess->pathname, app);
1063         if (ret < 0) {
1064                 goto error_rcu_unlock;
1065         }
1066
1067         /* For each channel */
1068         hashtable_get_first(ua_sess->channels, &iter);
1069         while ((node = hashtable_iter_get_node(&iter)) != NULL) {
1070                 ua_chan = caa_container_of(node, struct ust_app_channel, node);
1071
1072                 /* Create all streams */
1073                 while (1) {
1074                         struct ltt_ust_stream *ustream;
1075
1076                         ustream = zmalloc(sizeof(*ustream));
1077                         if (ustream == NULL) {
1078                                 PERROR("zmalloc ust stream");
1079                                 goto error_rcu_unlock;
1080                         }
1081
1082                         ret = ustctl_create_stream(app->key.sock, ua_chan->obj,
1083                                         &ustream->obj);
1084                         if (ret < 0) {
1085                                 /* Got all streams */
1086                                 break;
1087                         }
1088                         ustream->handle = ustream->obj->handle;
1089
1090                         /* Order is important */
1091                         cds_list_add_tail(&ustream->list, &ua_chan->streams.head);
1092                         ret = snprintf(ustream->pathname, PATH_MAX, "%s/%s-%d/%s_%u",
1093                                         usess->pathname, app->name, app->key.pid,
1094                                         ua_chan->name, ua_chan->streams.count++);
1095                         if (ret < 0) {
1096                                 PERROR("asprintf UST create stream");
1097                                 continue;
1098                         }
1099                         DBG2("UST stream %d ready at %s", ua_chan->streams.count,
1100                                         ustream->pathname);
1101                 }
1102
1103                 /* Next applications */
1104                 hashtable_get_next(ua_sess->channels, &iter);
1105         }
1106
1107         /* Setup UST consumer socket and send fds to it */
1108         ret = ust_consumer_send_session(usess->consumer_fd, ua_sess);
1109         if (ret < 0) {
1110                 goto error_rcu_unlock;
1111         }
1112
1113         /* This start the UST tracing */
1114         ret = ustctl_start_session(app->key.sock, ua_sess->handle);
1115         if (ret < 0) {
1116                 ERR("Error starting tracing for app pid: %d", app->key.pid);
1117                 goto error_rcu_unlock;
1118         }
1119         rcu_read_unlock();
1120
1121         /* Quiescent wait after starting trace */
1122         ustctl_wait_quiescent(app->key.sock);
1123
1124         return 0;
1125
1126 error_rcu_unlock:
1127         rcu_read_unlock();
1128         return -1;
1129 }
1130
1131 int ust_app_start_trace_all(struct ltt_ust_session *usess)
1132 {
1133         int ret = 0;
1134         struct cds_lfht_iter iter;
1135         struct cds_lfht_node *node;
1136         struct ust_app *app;
1137
1138         DBG("Starting all UST traces");
1139
1140         rcu_read_lock();
1141         hashtable_get_first(ust_app_ht, &iter);
1142         while ((node = hashtable_iter_get_node(&iter)) != NULL) {
1143                 app = caa_container_of(node, struct ust_app, node);
1144
1145                 ret = ust_app_start_trace(usess, app);
1146                 if (ret < 0) {
1147                         goto next;
1148                 }
1149
1150 next:
1151                 /* Next applications */
1152                 hashtable_get_next(ust_app_ht, &iter);
1153         }
1154         rcu_read_unlock();
1155
1156         return 0;
1157 }
1158
1159 void ust_app_global_update(struct ltt_ust_session *usess, int sock)
1160 {
1161         int ret = 0;
1162         struct cds_lfht_iter iter;
1163         struct ust_app *app;
1164         struct ust_app_session *ua_sess;
1165         struct ust_app_channel *ua_chan;
1166         struct ust_app_event *ua_event;
1167
1168         if (usess == NULL) {
1169                 DBG2("No UST session on global update. Returning");
1170                 goto error;
1171         }
1172
1173         DBG2("UST app global update for app sock %d for session uid %d", sock,
1174                         usess->uid);
1175
1176         rcu_read_lock();
1177
1178         app = find_app_by_sock(sock);
1179         if (app == NULL) {
1180                 ERR("Failed to update app sock %d", sock);
1181                 goto error;
1182         }
1183
1184         ua_sess = create_ust_app_session(usess, app);
1185         if (ua_sess == NULL) {
1186                 goto error;
1187         }
1188
1189         /*
1190          * We can iterate safely here over all UST app session sicne the create ust
1191          * app session above made a shadow copy of the UST global domain from the
1192          * ltt ust session.
1193          */
1194         cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
1195                 ret = create_ust_channel(app, ua_sess, ua_chan);
1196                 if (ret < 0) {
1197                         /* FIXME: Should we quit here or continue... */
1198                         continue;
1199                 }
1200
1201                 /* For each events */
1202                 cds_lfht_for_each_entry(ua_chan->events, &iter, ua_event, node) {
1203                         ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
1204                         if (ret < 0) {
1205                                 /* FIXME: Should we quit here or continue... */
1206                                 continue;
1207                         }
1208                 }
1209         }
1210
1211         if (usess->start_trace) {
1212                 ret = ust_app_start_trace(usess, app);
1213                 if (ret < 0) {
1214                         goto error;
1215                 }
1216
1217                 DBG2("UST trace started for app pid %d", app->key.pid);
1218         }
1219
1220 error:
1221         rcu_read_unlock();
1222         return;
1223 }