src/bin/lttng-sessiond/cmd.c

   1 /*
   2  * Copyright (C) 2012 - David Goulet <dgoulet@efficios.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License, version 2 only, as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 51
  15  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17
  18 #define _GNU_SOURCE
  19 #include <assert.h>
  20 #include <urcu/list.h>
  21 #include <urcu/uatomic.h>
  22
  23 #include <common/defaults.h>
  24 #include <common/common.h>
  25 #include <common/sessiond-comm/sessiond-comm.h>
  26 #include <common/relayd/relayd.h>
  27
  28 #include "channel.h"
  29 #include "consumer.h"
  30 #include "event.h"
  31 #include "kernel.h"
  32 #include "kernel-consumer.h"
  33 #include "lttng-sessiond.h"
  34 #include "utils.h"
  35
  36 #include "cmd.h"
  37
  38 /*
  39  * Used to keep a unique index for each relayd socket created where this value
  40  * is associated with streams on the consumer so it can match the right relayd
  41  * to send to.
  42  *
  43  * This value should be incremented atomically for safety purposes and future
  44  * possible concurrent access.
  45  */
  46 static unsigned int relayd_net_seq_idx;
  47
  48 /*
  49  * Create a session path used by list_lttng_sessions for the case that the
  50  * session consumer is on the network.
  51  */
  52 static int build_network_session_path(char *dst, size_t size,
  53                 struct ltt_session *session)
  54 {
  55         int ret, kdata_port, udata_port;
  56         struct lttng_uri *kuri = NULL, *uuri = NULL, *uri = NULL;
  57         char tmp_uurl[PATH_MAX], tmp_urls[PATH_MAX];
  58
  59         assert(session);
  60         assert(dst);
  61
  62         memset(tmp_urls, 0, sizeof(tmp_urls));
  63         memset(tmp_uurl, 0, sizeof(tmp_uurl));
  64
  65         kdata_port = udata_port = DEFAULT_NETWORK_DATA_PORT;
  66
  67         if (session->kernel_session && session->kernel_session->consumer) {
  68                 kuri = &session->kernel_session->consumer->dst.net.control;
  69                 kdata_port = session->kernel_session->consumer->dst.net.data.port;
  70         }
  71
  72         if (session->ust_session && session->ust_session->consumer) {
  73                 uuri = &session->ust_session->consumer->dst.net.control;
  74                 udata_port = session->ust_session->consumer->dst.net.data.port;
  75         }
  76
  77         if (uuri == NULL && kuri == NULL) {
  78                 uri = &session->consumer->dst.net.control;
  79                 kdata_port = session->consumer->dst.net.data.port;
  80         } else if (kuri && uuri) {
  81                 ret = uri_compare(kuri, uuri);
  82                 if (ret) {
  83                         /* Not Equal */
  84                         uri = kuri;
  85                         /* Build uuri URL string */
  86                         ret = uri_to_str_url(uuri, tmp_uurl, sizeof(tmp_uurl));
  87                         if (ret < 0) {
  88                                 goto error;
  89                         }
  90                 } else {
  91                         uri = kuri;
  92                 }
  93         } else if (kuri && uuri == NULL) {
  94                 uri = kuri;
  95         } else if (uuri && kuri == NULL) {
  96                 uri = uuri;
  97         }
  98
  99         ret = uri_to_str_url(uri, tmp_urls, sizeof(tmp_urls));
 100         if (ret < 0) {
 101                 goto error;
 102         }
 103
 104         if (strlen(tmp_uurl) > 0) {
 105                 ret = snprintf(dst, size, "[K]: %s [data: %d] -- [U]: %s [data: %d]",
 106                                 tmp_urls, kdata_port, tmp_uurl, udata_port);
 107         } else {
 108                 ret = snprintf(dst, size, "%s [data: %d]", tmp_urls, kdata_port);
 109         }
 110
 111 error:
 112         return ret;
 113 }
 114
 115 /*
 116  * Fill lttng_channel array of all channels.
 117  */
 118 static void list_lttng_channels(int domain, struct ltt_session *session,
 119                 struct lttng_channel *channels)
 120 {
 121         int i = 0;
 122         struct ltt_kernel_channel *kchan;
 123
 124         DBG("Listing channels for session %s", session->name);
 125
 126         switch (domain) {
 127         case LTTNG_DOMAIN_KERNEL:
 128                 /* Kernel channels */
 129                 if (session->kernel_session != NULL) {
 130                         cds_list_for_each_entry(kchan,
 131                                         &session->kernel_session->channel_list.head, list) {
 132                                 /* Copy lttng_channel struct to array */
 133                                 memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel));
 134                                 channels[i].enabled = kchan->enabled;
 135                                 i++;
 136                         }
 137                 }
 138                 break;
 139         case LTTNG_DOMAIN_UST:
 140         {
 141                 struct lttng_ht_iter iter;
 142                 struct ltt_ust_channel *uchan;
 143
 144                 cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht,
 145                                 &iter.iter, uchan, node.node) {
 146                         strncpy(channels[i].name, uchan->name, LTTNG_SYMBOL_NAME_LEN);
 147                         channels[i].attr.overwrite = uchan->attr.overwrite;
 148                         channels[i].attr.subbuf_size = uchan->attr.subbuf_size;
 149                         channels[i].attr.num_subbuf = uchan->attr.num_subbuf;
 150                         channels[i].attr.switch_timer_interval =
 151                                 uchan->attr.switch_timer_interval;
 152                         channels[i].attr.read_timer_interval =
 153                                 uchan->attr.read_timer_interval;
 154                         channels[i].enabled = uchan->enabled;
 155                         switch (uchan->attr.output) {
 156                         case LTTNG_UST_MMAP:
 157                         default:
 158                                 channels[i].attr.output = LTTNG_EVENT_MMAP;
 159                                 break;
 160                         }
 161                         i++;
 162                 }
 163                 break;
 164         }
 165         default:
 166                 break;
 167         }
 168 }
 169
 170 /*
 171  * Create a list of ust global domain events.
 172  */
 173 static int list_lttng_ust_global_events(char *channel_name,
 174                 struct ltt_ust_domain_global *ust_global, struct lttng_event **events)
 175 {
 176         int i = 0, ret = 0;
 177         unsigned int nb_event = 0;
 178         struct lttng_ht_iter iter;
 179         struct lttng_ht_node_str *node;
 180         struct ltt_ust_channel *uchan;
 181         struct ltt_ust_event *uevent;
 182         struct lttng_event *tmp;
 183
 184         DBG("Listing UST global events for channel %s", channel_name);
 185
 186         rcu_read_lock();
 187
 188         lttng_ht_lookup(ust_global->channels, (void *)channel_name, &iter);
 189         node = lttng_ht_iter_get_node_str(&iter);
 190         if (node == NULL) {
 191                 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
 192                 goto error;
 193         }
 194
 195         uchan = caa_container_of(&node->node, struct ltt_ust_channel, node.node);
 196
 197         nb_event += lttng_ht_get_count(uchan->events);
 198
 199         if (nb_event == 0) {
 200                 ret = nb_event;
 201                 goto error;
 202         }
 203
 204         DBG3("Listing UST global %d events", nb_event);
 205
 206         tmp = zmalloc(nb_event * sizeof(struct lttng_event));
 207         if (tmp == NULL) {
 208                 ret = LTTNG_ERR_FATAL;
 209                 goto error;
 210         }
 211
 212         cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
 213                 strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN);
 214                 tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 215                 tmp[i].enabled = uevent->enabled;
 216
 217                 switch (uevent->attr.instrumentation) {
 218                 case LTTNG_UST_TRACEPOINT:
 219                         tmp[i].type = LTTNG_EVENT_TRACEPOINT;
 220                         break;
 221                 case LTTNG_UST_PROBE:
 222                         tmp[i].type = LTTNG_EVENT_PROBE;
 223                         break;
 224                 case LTTNG_UST_FUNCTION:
 225                         tmp[i].type = LTTNG_EVENT_FUNCTION;
 226                         break;
 227                 }
 228
 229                 tmp[i].loglevel = uevent->attr.loglevel;
 230                 switch (uevent->attr.loglevel_type) {
 231                 case LTTNG_UST_LOGLEVEL_ALL:
 232                         tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
 233                         break;
 234                 case LTTNG_UST_LOGLEVEL_RANGE:
 235                         tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
 236                         break;
 237                 case LTTNG_UST_LOGLEVEL_SINGLE:
 238                         tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
 239                         break;
 240                 }
 241                 if (uevent->filter) {
 242                         tmp[i].filter = 1;
 243                 }
 244                 i++;
 245         }
 246
 247         ret = nb_event;
 248         *events = tmp;
 249
 250 error:
 251         rcu_read_unlock();
 252         return ret;
 253 }
 254
 255 /*
 256  * Fill lttng_event array of all kernel events in the channel.
 257  */
 258 static int list_lttng_kernel_events(char *channel_name,
 259                 struct ltt_kernel_session *kernel_session, struct lttng_event **events)
 260 {
 261         int i = 0, ret;
 262         unsigned int nb_event;
 263         struct ltt_kernel_event *event;
 264         struct ltt_kernel_channel *kchan;
 265
 266         kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session);
 267         if (kchan == NULL) {
 268                 ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
 269                 goto error;
 270         }
 271
 272         nb_event = kchan->event_count;
 273
 274         DBG("Listing events for channel %s", kchan->channel->name);
 275
 276         if (nb_event == 0) {
 277                 goto end;
 278         }
 279
 280         *events = zmalloc(nb_event * sizeof(struct lttng_event));
 281         if (*events == NULL) {
 282                 ret = LTTNG_ERR_FATAL;
 283                 goto error;
 284         }
 285
 286         /* Kernel channels */
 287         cds_list_for_each_entry(event, &kchan->events_list.head , list) {
 288                 strncpy((*events)[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN);
 289                 (*events)[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 290                 (*events)[i].enabled = event->enabled;
 291
 292                 switch (event->event->instrumentation) {
 293                 case LTTNG_KERNEL_TRACEPOINT:
 294                         (*events)[i].type = LTTNG_EVENT_TRACEPOINT;
 295                         break;
 296                 case LTTNG_KERNEL_KPROBE:
 297                 case LTTNG_KERNEL_KRETPROBE:
 298                         (*events)[i].type = LTTNG_EVENT_PROBE;
 299                         memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe,
 300                                         sizeof(struct lttng_kernel_kprobe));
 301                         break;
 302                 case LTTNG_KERNEL_FUNCTION:
 303                         (*events)[i].type = LTTNG_EVENT_FUNCTION;
 304                         memcpy(&((*events)[i].attr.ftrace), &event->event->u.ftrace,
 305                                         sizeof(struct lttng_kernel_function));
 306                         break;
 307                 case LTTNG_KERNEL_NOOP:
 308                         (*events)[i].type = LTTNG_EVENT_NOOP;
 309                         break;
 310                 case LTTNG_KERNEL_SYSCALL:
 311                         (*events)[i].type = LTTNG_EVENT_SYSCALL;
 312                         break;
 313                 case LTTNG_KERNEL_ALL:
 314                         assert(0);
 315                         break;
 316                 }
 317                 i++;
 318         }
 319
 320 end:
 321         return nb_event;
 322
 323 error:
 324         /* Negate the error code to differentiate the size from an error */
 325         return -ret;
 326 }
 327
 328 /*
 329  * Add URI so the consumer output object. Set the correct path depending on the
 330  * domain adding the default trace directory.
 331  */
 332 static int add_uri_to_consumer(struct consumer_output *consumer,
 333                 struct lttng_uri *uri, int domain, const char *session_name)
 334 {
 335         int ret = LTTNG_OK;
 336         const char *default_trace_dir;
 337
 338         assert(uri);
 339
 340         if (consumer == NULL) {
 341                 DBG("No consumer detected. Don't add URI. Stopping.");
 342                 ret = LTTNG_ERR_NO_CONSUMER;
 343                 goto error;
 344         }
 345
 346         switch (domain) {
 347         case LTTNG_DOMAIN_KERNEL:
 348                 default_trace_dir = DEFAULT_KERNEL_TRACE_DIR;
 349                 break;
 350         case LTTNG_DOMAIN_UST:
 351                 default_trace_dir = DEFAULT_UST_TRACE_DIR;
 352                 break;
 353         default:
 354                 /*
 355                  * This case is possible is we try to add the URI to the global tracing
 356                  * session consumer object which in this case there is no subdir.
 357                  */
 358                 default_trace_dir = "";
 359         }
 360
 361         switch (uri->dtype) {
 362         case LTTNG_DST_IPV4:
 363         case LTTNG_DST_IPV6:
 364                 DBG2("Setting network URI to consumer");
 365
 366                 /* Set URI into consumer output object */
 367                 ret = consumer_set_network_uri(consumer, uri);
 368                 if (ret < 0) {
 369                         ret = LTTNG_ERR_FATAL;
 370                         goto error;
 371                 } else if (ret == 1) {
 372                         /*
 373                          * URI was the same in the consumer so we do not append the subdir
 374                          * again so to not duplicate output dir.
 375                          */
 376                         goto error;
 377                 }
 378
 379                 if (uri->stype == LTTNG_STREAM_CONTROL && strlen(uri->subdir) == 0) {
 380                         ret = consumer_set_subdir(consumer, session_name);
 381                         if (ret < 0) {
 382                                 ret = LTTNG_ERR_FATAL;
 383                                 goto error;
 384                         }
 385                 }
 386
 387                 if (uri->stype == LTTNG_STREAM_CONTROL) {
 388                         /* On a new subdir, reappend the default trace dir. */
 389                         strncat(consumer->subdir, default_trace_dir,
 390                                         sizeof(consumer->subdir) - strlen(consumer->subdir) - 1);
 391                         DBG3("Append domain trace name to subdir %s", consumer->subdir);
 392                 }
 393
 394                 break;
 395         case LTTNG_DST_PATH:
 396                 DBG2("Setting trace directory path from URI to %s", uri->dst.path);
 397                 memset(consumer->dst.trace_path, 0,
 398                                 sizeof(consumer->dst.trace_path));
 399                 strncpy(consumer->dst.trace_path, uri->dst.path,
 400                                 sizeof(consumer->dst.trace_path));
 401                 /* Append default trace dir */
 402                 strncat(consumer->dst.trace_path, default_trace_dir,
 403                                 sizeof(consumer->dst.trace_path) -
 404                                 strlen(consumer->dst.trace_path) - 1);
 405                 /* Flag consumer as local. */
 406                 consumer->type = CONSUMER_DST_LOCAL;
 407                 break;
 408         }
 409
 410 error:
 411         return ret;
 412 }
 413
 414 /*
 415  * Init tracing by creating trace directory and sending fds kernel consumer.
 416  */
 417 static int init_kernel_tracing(struct ltt_kernel_session *session)
 418 {
 419         int ret = 0;
 420         struct lttng_ht_iter iter;
 421         struct consumer_socket *socket;
 422
 423         assert(session);
 424
 425         if (session->consumer_fds_sent == 0 && session->consumer != NULL) {
 426                 cds_lfht_for_each_entry(session->consumer->socks->ht, &iter.iter,
 427                                 socket, node.node) {
 428                         /* Code flow error */
 429                         assert(socket->fd >= 0);
 430
 431                         pthread_mutex_lock(socket->lock);
 432                         ret = kernel_consumer_send_session(socket->fd, session);
 433                         pthread_mutex_unlock(socket->lock);
 434                         if (ret < 0) {
 435                                 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
 436                                 goto error;
 437                         }
 438                 }
 439         }
 440
 441 error:
 442         return ret;
 443 }
 444
 445 /*
 446  * Create a socket to the relayd using the URI.
 447  *
 448  * On success, the relayd_sock pointer is set to the created socket.
 449  * Else, it's stays untouched and a lttcomm error code is returned.
 450  */
 451 static int create_connect_relayd(struct consumer_output *output,
 452                 const char *session_name, struct lttng_uri *uri,
 453                 struct lttcomm_sock **relayd_sock)
 454 {
 455         int ret;
 456         struct lttcomm_sock *sock;
 457
 458         /* Create socket object from URI */
 459         sock = lttcomm_alloc_sock_from_uri(uri);
 460         if (sock == NULL) {
 461                 ret = LTTNG_ERR_FATAL;
 462                 goto error;
 463         }
 464
 465         ret = lttcomm_create_sock(sock);
 466         if (ret < 0) {
 467                 ret = LTTNG_ERR_FATAL;
 468                 goto error;
 469         }
 470
 471         /* Connect to relayd so we can proceed with a session creation. */
 472         ret = relayd_connect(sock);
 473         if (ret < 0) {
 474                 ERR("Unable to reach lttng-relayd");
 475                 ret = LTTNG_ERR_RELAYD_CONNECT_FAIL;
 476                 goto free_sock;
 477         }
 478
 479         /* Create socket for control stream. */
 480         if (uri->stype == LTTNG_STREAM_CONTROL) {
 481                 DBG3("Creating relayd stream socket from URI");
 482
 483                 /* Check relayd version */
 484                 ret = relayd_version_check(sock, RELAYD_VERSION_COMM_MAJOR,
 485                                 RELAYD_VERSION_COMM_MINOR);
 486                 if (ret < 0) {
 487                         ret = LTTNG_ERR_RELAYD_VERSION_FAIL;
 488                         goto close_sock;
 489                 }
 490         } else if (uri->stype == LTTNG_STREAM_DATA) {
 491                 DBG3("Creating relayd data socket from URI");
 492         } else {
 493                 /* Command is not valid */
 494                 ERR("Relayd invalid stream type: %d", uri->stype);
 495                 ret = LTTNG_ERR_INVALID;
 496                 goto close_sock;
 497         }
 498
 499         *relayd_sock = sock;
 500
 501         return LTTNG_OK;
 502
 503 close_sock:
 504         if (sock) {
 505                 (void) relayd_close(sock);
 506         }
 507 free_sock:
 508         if (sock) {
 509                 lttcomm_destroy_sock(sock);
 510         }
 511 error:
 512         return ret;
 513 }
 514
 515 /*
 516  * Connect to the relayd using URI and send the socket to the right consumer.
 517  */
 518 static int send_consumer_relayd_socket(int domain, struct ltt_session *session,
 519                 struct lttng_uri *relayd_uri, struct consumer_output *consumer,
 520                 int consumer_fd)
 521 {
 522         int ret;
 523         struct lttcomm_sock *sock = NULL;
 524
 525         /* Set the network sequence index if not set. */
 526         if (consumer->net_seq_index == -1) {
 527                 /*
 528                  * Increment net_seq_idx because we are about to transfer the
 529                  * new relayd socket to the consumer.
 530                  */
 531                 uatomic_inc(&relayd_net_seq_idx);
 532                 /* Assign unique key so the consumer can match streams */
 533                 uatomic_set(&consumer->net_seq_index,
 534                                 uatomic_read(&relayd_net_seq_idx));
 535         }
 536
 537         /* Connect to relayd and make version check if uri is the control. */
 538         ret = create_connect_relayd(consumer, session->name, relayd_uri, &sock);
 539         if (ret != LTTNG_OK) {
 540                 goto close_sock;
 541         }
 542
 543         /* If the control socket is connected, network session is ready */
 544         if (relayd_uri->stype == LTTNG_STREAM_CONTROL) {
 545                 session->net_handle = 1;
 546         }
 547
 548         /* Send relayd socket to consumer. */
 549         ret = consumer_send_relayd_socket(consumer_fd, sock,
 550                         consumer, relayd_uri->stype);
 551         if (ret < 0) {
 552                 ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
 553                 goto close_sock;
 554         }
 555
 556         /* Flag that the corresponding socket was sent. */
 557         if (relayd_uri->stype == LTTNG_STREAM_CONTROL) {
 558                 consumer->dst.net.control_sock_sent = 1;
 559         } else if (relayd_uri->stype == LTTNG_STREAM_DATA) {
 560                 consumer->dst.net.data_sock_sent = 1;
 561         }
 562
 563         ret = LTTNG_OK;
 564
 565         /*
 566          * Close socket which was dup on the consumer side. The session daemon does
 567          * NOT keep track of the relayd socket(s) once transfer to the consumer.
 568          */
 569
 570 close_sock:
 571         if (sock) {
 572                 (void) relayd_close(sock);
 573                 lttcomm_destroy_sock(sock);
 574         }
 575
 576         return ret;
 577 }
 578
 579 /*
 580  * Send both relayd sockets to a specific consumer and domain.  This is a
 581  * helper function to facilitate sending the information to the consumer for a
 582  * session.
 583  */
 584 static int send_consumer_relayd_sockets(int domain,
 585                 struct ltt_session *session, struct consumer_output *consumer, int fd)
 586 {
 587         int ret = LTTNG_OK;
 588
 589         assert(session);
 590         assert(consumer);
 591
 592         /* Sending control relayd socket. */
 593         if (!consumer->dst.net.control_sock_sent) {
 594                 ret = send_consumer_relayd_socket(domain, session,
 595                                 &consumer->dst.net.control, consumer, fd);
 596                 if (ret != LTTNG_OK) {
 597                         goto error;
 598                 }
 599         }
 600
 601         /* Sending data relayd socket. */
 602         if (!consumer->dst.net.data_sock_sent) {
 603                 ret = send_consumer_relayd_socket(domain, session,
 604                                 &consumer->dst.net.data, consumer, fd);
 605                 if (ret != LTTNG_OK) {
 606                         goto error;
 607                 }
 608         }
 609
 610 error:
 611         return ret;
 612 }
 613
 614 /*
 615  * Setup relayd connections for a tracing session. First creates the socket to
 616  * the relayd and send them to the right domain consumer. Consumer type MUST be
 617  * network.
 618  */
 619 static int setup_relayd(struct ltt_session *session)
 620 {
 621         int ret = LTTNG_OK;
 622         struct ltt_ust_session *usess;
 623         struct ltt_kernel_session *ksess;
 624         struct consumer_socket *socket;
 625         struct lttng_ht_iter iter;
 626
 627         assert(session);
 628
 629         usess = session->ust_session;
 630         ksess = session->kernel_session;
 631
 632         DBG2("Setting relayd for session %s", session->name);
 633
 634         if (usess && usess->consumer && usess->consumer->type == CONSUMER_DST_NET
 635                         && usess->consumer->enabled) {
 636                 /* For each consumer socket, send relayd sockets */
 637                 cds_lfht_for_each_entry(usess->consumer->socks->ht, &iter.iter,
 638                                 socket, node.node) {
 639                         /* Code flow error */
 640                         assert(socket->fd >= 0);
 641
 642                         pthread_mutex_lock(socket->lock);
 643                         ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_UST, session,
 644                                         usess->consumer, socket->fd);
 645                         pthread_mutex_unlock(socket->lock);
 646                         if (ret != LTTNG_OK) {
 647                                 goto error;
 648                         }
 649                 }
 650         }
 651
 652         if (ksess && ksess->consumer && ksess->consumer->type == CONSUMER_DST_NET
 653                         && ksess->consumer->enabled) {
 654                 cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
 655                                 socket, node.node) {
 656                         /* Code flow error */
 657                         assert(socket->fd >= 0);
 658
 659                         pthread_mutex_lock(socket->lock);
 660                         ret = send_consumer_relayd_sockets(LTTNG_DOMAIN_KERNEL, session,
 661                                         ksess->consumer, socket->fd);
 662                         pthread_mutex_unlock(socket->lock);
 663                         if (ret != LTTNG_OK) {
 664                                 goto error;
 665                         }
 666                 }
 667         }
 668
 669 error:
 670         return ret;
 671 }
 672
 673 /*
 674  * Command LTTNG_DISABLE_CHANNEL processed by the client thread.
 675  */
 676 int cmd_disable_channel(struct ltt_session *session, int domain,
 677                 char *channel_name)
 678 {
 679         int ret;
 680         struct ltt_ust_session *usess;
 681
 682         usess = session->ust_session;
 683
 684         switch (domain) {
 685         case LTTNG_DOMAIN_KERNEL:
 686         {
 687                 ret = channel_kernel_disable(session->kernel_session,
 688                                 channel_name);
 689                 if (ret != LTTNG_OK) {
 690                         goto error;
 691                 }
 692
 693                 kernel_wait_quiescent(kernel_tracer_fd);
 694                 break;
 695         }
 696         case LTTNG_DOMAIN_UST:
 697         {
 698                 struct ltt_ust_channel *uchan;
 699                 struct lttng_ht *chan_ht;
 700
 701                 chan_ht = usess->domain_global.channels;
 702
 703                 uchan = trace_ust_find_channel_by_name(chan_ht, channel_name);
 704                 if (uchan == NULL) {
 705                         ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
 706                         goto error;
 707                 }
 708
 709                 ret = channel_ust_disable(usess, domain, uchan);
 710                 if (ret != LTTNG_OK) {
 711                         goto error;
 712                 }
 713                 break;
 714         }
 715 #if 0
 716         case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
 717         case LTTNG_DOMAIN_UST_EXEC_NAME:
 718         case LTTNG_DOMAIN_UST_PID:
 719 #endif
 720         default:
 721                 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
 722                 goto error;
 723         }
 724
 725         ret = LTTNG_OK;
 726
 727 error:
 728         return ret;
 729 }
 730
 731 /*
 732  * Command LTTNG_ENABLE_CHANNEL processed by the client thread.
 733  *
 734  * The wpipe arguments is used as a notifier for the kernel thread.
 735  */
 736 int cmd_enable_channel(struct ltt_session *session,
 737                 int domain, struct lttng_channel *attr, int wpipe)
 738 {
 739         int ret;
 740         struct ltt_ust_session *usess = session->ust_session;
 741         struct lttng_ht *chan_ht;
 742
 743         assert(session);
 744         assert(attr);
 745
 746         DBG("Enabling channel %s for session %s", attr->name, session->name);
 747
 748         switch (domain) {
 749         case LTTNG_DOMAIN_KERNEL:
 750         {
 751                 struct ltt_kernel_channel *kchan;
 752
 753                 /* Mandatory for a kernel channel. */
 754                 assert(wpipe > 0);
 755
 756                 kchan = trace_kernel_get_channel_by_name(attr->name,
 757                                 session->kernel_session);
 758                 if (kchan == NULL) {
 759                         ret = channel_kernel_create(session->kernel_session, attr, wpipe);
 760                 } else {
 761                         ret = channel_kernel_enable(session->kernel_session, kchan);
 762                 }
 763
 764                 if (ret != LTTNG_OK) {
 765                         goto error;
 766                 }
 767
 768                 kernel_wait_quiescent(kernel_tracer_fd);
 769                 break;
 770         }
 771         case LTTNG_DOMAIN_UST:
 772         {
 773                 struct ltt_ust_channel *uchan;
 774
 775                 chan_ht = usess->domain_global.channels;
 776
 777                 uchan = trace_ust_find_channel_by_name(chan_ht, attr->name);
 778                 if (uchan == NULL) {
 779                         ret = channel_ust_create(usess, domain, attr);
 780                 } else {
 781                         ret = channel_ust_enable(usess, domain, uchan);
 782                 }
 783                 break;
 784         }
 785 #if 0
 786         case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
 787         case LTTNG_DOMAIN_UST_EXEC_NAME:
 788         case LTTNG_DOMAIN_UST_PID:
 789 #endif
 790         default:
 791                 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
 792                 goto error;
 793         }
 794
 795 error:
 796         return ret;
 797 }
 798
 799
 800 /*
 801  * Command LTTNG_DISABLE_EVENT processed by the client thread.
 802  */
 803 int cmd_disable_event(struct ltt_session *session, int domain,
 804                 char *channel_name, char *event_name)
 805 {
 806         int ret;
 807
 808         switch (domain) {
 809         case LTTNG_DOMAIN_KERNEL:
 810         {
 811                 struct ltt_kernel_channel *kchan;
 812                 struct ltt_kernel_session *ksess;
 813
 814                 ksess = session->kernel_session;
 815
 816                 kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
 817                 if (kchan == NULL) {
 818                         ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
 819                         goto error;
 820                 }
 821
 822                 ret = event_kernel_disable_tracepoint(ksess, kchan, event_name);
 823                 if (ret != LTTNG_OK) {
 824                         goto error;
 825                 }
 826
 827                 kernel_wait_quiescent(kernel_tracer_fd);
 828                 break;
 829         }
 830         case LTTNG_DOMAIN_UST:
 831         {
 832                 struct ltt_ust_channel *uchan;
 833                 struct ltt_ust_session *usess;
 834
 835                 usess = session->ust_session;
 836
 837                 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
 838                                 channel_name);
 839                 if (uchan == NULL) {
 840                         ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
 841                         goto error;
 842                 }
 843
 844                 ret = event_ust_disable_tracepoint(usess, domain, uchan, event_name);
 845                 if (ret != LTTNG_OK) {
 846                         goto error;
 847                 }
 848
 849                 DBG3("Disable UST event %s in channel %s completed", event_name,
 850                                 channel_name);
 851                 break;
 852         }
 853 #if 0
 854         case LTTNG_DOMAIN_UST_EXEC_NAME:
 855         case LTTNG_DOMAIN_UST_PID:
 856         case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
 857 #endif
 858         default:
 859                 ret = LTTNG_ERR_UND;
 860                 goto error;
 861         }
 862
 863         ret = LTTNG_OK;
 864
 865 error:
 866         return ret;
 867 }
 868
 869 /*
 870  * Command LTTNG_DISABLE_ALL_EVENT processed by the client thread.
 871  */
 872 int cmd_disable_event_all(struct ltt_session *session, int domain,
 873                 char *channel_name)
 874 {
 875         int ret;
 876
 877         switch (domain) {
 878         case LTTNG_DOMAIN_KERNEL:
 879         {
 880                 struct ltt_kernel_session *ksess;
 881                 struct ltt_kernel_channel *kchan;
 882
 883                 ksess = session->kernel_session;
 884
 885                 kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
 886                 if (kchan == NULL) {
 887                         ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
 888                         goto error;
 889                 }
 890
 891                 ret = event_kernel_disable_all(ksess, kchan);
 892                 if (ret != LTTNG_OK) {
 893                         goto error;
 894                 }
 895
 896                 kernel_wait_quiescent(kernel_tracer_fd);
 897                 break;
 898         }
 899         case LTTNG_DOMAIN_UST:
 900         {
 901                 struct ltt_ust_session *usess;
 902                 struct ltt_ust_channel *uchan;
 903
 904                 usess = session->ust_session;
 905
 906                 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
 907                                 channel_name);
 908                 if (uchan == NULL) {
 909                         ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
 910                         goto error;
 911                 }
 912
 913                 ret = event_ust_disable_all_tracepoints(usess, domain, uchan);
 914                 if (ret != 0) {
 915                         goto error;
 916                 }
 917
 918                 DBG3("Disable all UST events in channel %s completed", channel_name);
 919
 920                 break;
 921         }
 922 #if 0
 923         case LTTNG_DOMAIN_UST_EXEC_NAME:
 924         case LTTNG_DOMAIN_UST_PID:
 925         case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
 926 #endif
 927         default:
 928                 ret = LTTNG_ERR_UND;
 929                 goto error;
 930         }
 931
 932         ret = LTTNG_OK;
 933
 934 error:
 935         return ret;
 936 }
 937
 938 /*
 939  * Command LTTNG_ADD_CONTEXT processed by the client thread.
 940  */
 941 int cmd_add_context(struct ltt_session *session, int domain,
 942                 char *channel_name, char *event_name, struct lttng_event_context *ctx)
 943 {
 944         int ret;
 945
 946         switch (domain) {
 947         case LTTNG_DOMAIN_KERNEL:
 948                 /* Add kernel context to kernel tracer */
 949                 ret = context_kernel_add(session->kernel_session, ctx,
 950                                 event_name, channel_name);
 951                 if (ret != LTTNG_OK) {
 952                         goto error;
 953                 }
 954                 break;
 955         case LTTNG_DOMAIN_UST:
 956         {
 957                 struct ltt_ust_session *usess = session->ust_session;
 958
 959                 assert(usess);
 960
 961                 ret = context_ust_add(usess, domain, ctx, event_name, channel_name);
 962                 if (ret != LTTNG_OK) {
 963                         goto error;
 964                 }
 965                 break;
 966         }
 967 #if 0
 968         case LTTNG_DOMAIN_UST_EXEC_NAME:
 969         case LTTNG_DOMAIN_UST_PID:
 970         case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
 971 #endif
 972         default:
 973                 ret = LTTNG_ERR_UND;
 974                 goto error;
 975         }
 976
 977         ret = LTTNG_OK;
 978
 979 error:
 980         return ret;
 981 }
 982
 983 /*
 984  * Command LTTNG_SET_FILTER processed by the client thread.
 985  */
 986 int cmd_set_filter(struct ltt_session *session, int domain,
 987                 char *channel_name, char *event_name,
 988                 struct lttng_filter_bytecode *bytecode)
 989 {
 990         int ret;
 991
 992         switch (domain) {
 993         case LTTNG_DOMAIN_KERNEL:
 994                 ret = LTTNG_ERR_FATAL;
 995                 break;
 996         case LTTNG_DOMAIN_UST:
 997         {
 998                 struct ltt_ust_session *usess = session->ust_session;
 999
1000                 ret = filter_ust_set(usess, domain, bytecode, event_name, channel_name);
1001                 if (ret != LTTNG_OK) {
1002                         goto error;
1003                 }
1004                 break;
1005         }
1006 #if 0
1007         case LTTNG_DOMAIN_UST_EXEC_NAME:
1008         case LTTNG_DOMAIN_UST_PID:
1009         case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
1010 #endif
1011         default:
1012                 ret = LTTNG_ERR_UND;
1013                 goto error;
1014         }
1015
1016         ret = LTTNG_OK;
1017
1018 error:
1019         return ret;
1020
1021 }
1022
1023
1024 /*
1025  * Command LTTNG_ENABLE_EVENT processed by the client thread.
1026  */
1027 int cmd_enable_event(struct ltt_session *session, int domain,
1028                 char *channel_name, struct lttng_event *event, int wpipe)
1029 {
1030         int ret;
1031         struct lttng_channel *attr;
1032
1033         assert(session);
1034         assert(event);
1035         assert(channel_name);
1036
1037         switch (domain) {
1038         case LTTNG_DOMAIN_KERNEL:
1039         {
1040                 struct ltt_kernel_channel *kchan;
1041
1042                 kchan = trace_kernel_get_channel_by_name(channel_name,
1043                                 session->kernel_session);
1044                 if (kchan == NULL) {
1045                         attr = channel_new_default_attr(domain);
1046                         if (attr == NULL) {
1047                                 ret = LTTNG_ERR_FATAL;
1048                                 goto error;
1049                         }
1050                         strncpy(attr->name, channel_name, sizeof(attr->name));
1051
1052                         ret = cmd_enable_channel(session, domain, attr, wpipe);
1053                         if (ret != LTTNG_OK) {
1054                                 free(attr);
1055                                 goto error;
1056                         }
1057                         free(attr);
1058                 }
1059
1060                 /* Get the newly created kernel channel pointer */
1061                 kchan = trace_kernel_get_channel_by_name(channel_name,
1062                                 session->kernel_session);
1063                 if (kchan == NULL) {
1064                         /* This sould not happen... */
1065                         ret = LTTNG_ERR_FATAL;
1066                         goto error;
1067                 }
1068
1069                 ret = event_kernel_enable_tracepoint(session->kernel_session, kchan,
1070                                 event);
1071                 if (ret != LTTNG_OK) {
1072                         goto error;
1073                 }
1074
1075                 kernel_wait_quiescent(kernel_tracer_fd);
1076                 break;
1077         }
1078         case LTTNG_DOMAIN_UST:
1079         {
1080                 struct ltt_ust_channel *uchan;
1081                 struct ltt_ust_session *usess = session->ust_session;
1082
1083                 assert(usess);
1084
1085                 /* Get channel from global UST domain */
1086                 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
1087                                 channel_name);
1088                 if (uchan == NULL) {
1089                         /* Create default channel */
1090                         attr = channel_new_default_attr(domain);
1091                         if (attr == NULL) {
1092                                 ret = LTTNG_ERR_FATAL;
1093                                 goto error;
1094                         }
1095                         strncpy(attr->name, channel_name, sizeof(attr->name));
1096
1097                         ret = cmd_enable_channel(session, domain, attr, wpipe);
1098                         if (ret != LTTNG_OK) {
1099                                 free(attr);
1100                                 goto error;
1101                         }
1102                         free(attr);
1103
1104                         /* Get the newly created channel reference back */
1105                         uchan = trace_ust_find_channel_by_name(
1106                                         usess->domain_global.channels, channel_name);
1107                         assert(uchan);
1108                 }
1109
1110                 /* At this point, the session and channel exist on the tracer */
1111                 ret = event_ust_enable_tracepoint(usess, domain, uchan, event);
1112                 if (ret != LTTNG_OK) {
1113                         goto error;
1114                 }
1115                 break;
1116         }
1117 #if 0
1118         case LTTNG_DOMAIN_UST_EXEC_NAME:
1119         case LTTNG_DOMAIN_UST_PID:
1120         case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
1121 #endif
1122         default:
1123                 ret = LTTNG_ERR_UND;
1124                 goto error;
1125         }
1126
1127         ret = LTTNG_OK;
1128
1129 error:
1130         return ret;
1131 }
1132
1133 /*
1134  * Command LTTNG_ENABLE_ALL_EVENT processed by the client thread.
1135  */
1136 int cmd_enable_event_all(struct ltt_session *session, int domain,
1137                 char *channel_name, int event_type, int wpipe)
1138 {
1139         int ret;
1140         struct lttng_channel *attr;
1141
1142         assert(session);
1143         assert(channel_name);
1144
1145         switch (domain) {
1146         case LTTNG_DOMAIN_KERNEL:
1147         {
1148                 struct ltt_kernel_channel *kchan;
1149
1150                 assert(session->kernel_session);
1151
1152                 kchan = trace_kernel_get_channel_by_name(channel_name,
1153                                 session->kernel_session);
1154                 if (kchan == NULL) {
1155                         /* Create default channel */
1156                         attr = channel_new_default_attr(domain);
1157                         if (attr == NULL) {
1158                                 ret = LTTNG_ERR_FATAL;
1159                                 goto error;
1160                         }
1161                         strncpy(attr->name, channel_name, sizeof(attr->name));
1162
1163                         ret = cmd_enable_channel(session, domain, attr, wpipe);
1164                         if (ret != LTTNG_OK) {
1165                                 free(attr);
1166                                 goto error;
1167                         }
1168                         free(attr);
1169
1170                         /* Get the newly created kernel channel pointer */
1171                         kchan = trace_kernel_get_channel_by_name(channel_name,
1172                                         session->kernel_session);
1173                         assert(kchan);
1174                 }
1175
1176                 switch (event_type) {
1177                 case LTTNG_EVENT_SYSCALL:
1178                         ret = event_kernel_enable_all_syscalls(session->kernel_session,
1179                                         kchan, kernel_tracer_fd);
1180                         break;
1181                 case LTTNG_EVENT_TRACEPOINT:
1182                         /*
1183                          * This call enables all LTTNG_KERNEL_TRACEPOINTS and
1184                          * events already registered to the channel.
1185                          */
1186                         ret = event_kernel_enable_all_tracepoints(session->kernel_session,
1187                                         kchan, kernel_tracer_fd);
1188                         break;
1189                 case LTTNG_EVENT_ALL:
1190                         /* Enable syscalls and tracepoints */
1191                         ret = event_kernel_enable_all(session->kernel_session,
1192                                         kchan, kernel_tracer_fd);
1193                         break;
1194                 default:
1195                         ret = LTTNG_ERR_KERN_ENABLE_FAIL;
1196                         goto error;
1197                 }
1198
1199                 /* Manage return value */
1200                 if (ret != LTTNG_OK) {
1201                         goto error;
1202                 }
1203
1204                 kernel_wait_quiescent(kernel_tracer_fd);
1205                 break;
1206         }
1207         case LTTNG_DOMAIN_UST:
1208         {
1209                 struct ltt_ust_channel *uchan;
1210                 struct ltt_ust_session *usess = session->ust_session;
1211
1212                 assert(usess);
1213
1214                 /* Get channel from global UST domain */
1215                 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
1216                                 channel_name);
1217                 if (uchan == NULL) {
1218                         /* Create default channel */
1219                         attr = channel_new_default_attr(domain);
1220                         if (attr == NULL) {
1221                                 ret = LTTNG_ERR_FATAL;
1222                                 goto error;
1223                         }
1224                         strncpy(attr->name, channel_name, sizeof(attr->name));
1225
1226                         ret = cmd_enable_channel(session, domain, attr, wpipe);
1227                         if (ret != LTTNG_OK) {
1228                                 free(attr);
1229                                 goto error;
1230                         }
1231                         free(attr);
1232
1233                         /* Get the newly created channel reference back */
1234                         uchan = trace_ust_find_channel_by_name(
1235                                         usess->domain_global.channels, channel_name);
1236                         assert(uchan);
1237                 }
1238
1239                 /* At this point, the session and channel exist on the tracer */
1240
1241                 switch (event_type) {
1242                 case LTTNG_EVENT_ALL:
1243                 case LTTNG_EVENT_TRACEPOINT:
1244                         ret = event_ust_enable_all_tracepoints(usess, domain, uchan);
1245                         if (ret != LTTNG_OK) {
1246                                 goto error;
1247                         }
1248                         break;
1249                 default:
1250                         ret = LTTNG_ERR_UST_ENABLE_FAIL;
1251                         goto error;
1252                 }
1253
1254                 /* Manage return value */
1255                 if (ret != LTTNG_OK) {
1256                         goto error;
1257                 }
1258
1259                 break;
1260         }
1261 #if 0
1262         case LTTNG_DOMAIN_UST_EXEC_NAME:
1263         case LTTNG_DOMAIN_UST_PID:
1264         case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
1265 #endif
1266         default:
1267                 ret = LTTNG_ERR_UND;
1268                 goto error;
1269         }
1270
1271         ret = LTTNG_OK;
1272
1273 error:
1274         return ret;
1275 }
1276
1277
1278 /*
1279  * Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
1280  */
1281 ssize_t cmd_list_tracepoints(int domain, struct lttng_event **events)
1282 {
1283         int ret;
1284         ssize_t nb_events = 0;
1285
1286         switch (domain) {
1287         case LTTNG_DOMAIN_KERNEL:
1288                 nb_events = kernel_list_events(kernel_tracer_fd, events);
1289                 if (nb_events < 0) {
1290                         ret = LTTNG_ERR_KERN_LIST_FAIL;
1291                         goto error;
1292                 }
1293                 break;
1294         case LTTNG_DOMAIN_UST:
1295                 nb_events = ust_app_list_events(events);
1296                 if (nb_events < 0) {
1297                         ret = LTTNG_ERR_UST_LIST_FAIL;
1298                         goto error;
1299                 }
1300                 break;
1301         default:
1302                 ret = LTTNG_ERR_UND;
1303                 goto error;
1304         }
1305
1306         return nb_events;
1307
1308 error:
1309         /* Return negative value to differentiate return code */
1310         return -ret;
1311 }
1312
1313 /*
1314  * Command LTTNG_LIST_TRACEPOINT_FIELDS processed by the client thread.
1315  */
1316 ssize_t cmd_list_tracepoint_fields(int domain,
1317                 struct lttng_event_field **fields)
1318 {
1319         int ret;
1320         ssize_t nb_fields = 0;
1321
1322         switch (domain) {
1323         case LTTNG_DOMAIN_UST:
1324                 nb_fields = ust_app_list_event_fields(fields);
1325                 if (nb_fields < 0) {
1326                         ret = LTTNG_ERR_UST_LIST_FAIL;
1327                         goto error;
1328                 }
1329                 break;
1330         case LTTNG_DOMAIN_KERNEL:
1331         default:        /* fall-through */
1332                 ret = LTTNG_ERR_UND;
1333                 goto error;
1334         }
1335
1336         return nb_fields;
1337
1338 error:
1339         /* Return negative value to differentiate return code */
1340         return -ret;
1341 }
1342
1343 /*
1344  * Command LTTNG_START_TRACE processed by the client thread.
1345  */
1346 int cmd_start_trace(struct ltt_session *session)
1347 {
1348         int ret;
1349         struct ltt_kernel_session *ksession;
1350         struct ltt_ust_session *usess;
1351         struct ltt_kernel_channel *kchan;
1352
1353         assert(session);
1354
1355         /* Ease our life a bit ;) */
1356         ksession = session->kernel_session;
1357         usess = session->ust_session;
1358
1359         if (session->enabled) {
1360                 /* Already started. */
1361                 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
1362                 goto error;
1363         }
1364
1365         session->enabled = 1;
1366
1367         ret = setup_relayd(session);
1368         if (ret != LTTNG_OK) {
1369                 ERR("Error setting up relayd for session %s", session->name);
1370                 goto error;
1371         }
1372
1373         /* Kernel tracing */
1374         if (ksession != NULL) {
1375                 /* Open kernel metadata */
1376                 if (ksession->metadata == NULL) {
1377                         ret = kernel_open_metadata(ksession);
1378                         if (ret < 0) {
1379                                 ret = LTTNG_ERR_KERN_META_FAIL;
1380                                 goto error;
1381                         }
1382                 }
1383
1384                 /* Open kernel metadata stream */
1385                 if (ksession->metadata_stream_fd < 0) {
1386                         ret = kernel_open_metadata_stream(ksession);
1387                         if (ret < 0) {
1388                                 ERR("Kernel create metadata stream failed");
1389                                 ret = LTTNG_ERR_KERN_STREAM_FAIL;
1390                                 goto error;
1391                         }
1392                 }
1393
1394                 /* For each channel */
1395                 cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
1396                         if (kchan->stream_count == 0) {
1397                                 ret = kernel_open_channel_stream(kchan);
1398                                 if (ret < 0) {
1399                                         ret = LTTNG_ERR_KERN_STREAM_FAIL;
1400                                         goto error;
1401                                 }
1402                                 /* Update the stream global counter */
1403                                 ksession->stream_count_global += ret;
1404                         }
1405                 }
1406
1407                 /* Setup kernel consumer socket and send fds to it */
1408                 ret = init_kernel_tracing(ksession);
1409                 if (ret < 0) {
1410                         ret = LTTNG_ERR_KERN_START_FAIL;
1411                         goto error;
1412                 }
1413
1414                 /* This start the kernel tracing */
1415                 ret = kernel_start_session(ksession);
1416                 if (ret < 0) {
1417                         ret = LTTNG_ERR_KERN_START_FAIL;
1418                         goto error;
1419                 }
1420
1421                 /* Quiescent wait after starting trace */
1422                 kernel_wait_quiescent(kernel_tracer_fd);
1423         }
1424
1425         /* Flag session that trace should start automatically */
1426         if (usess) {
1427                 usess->start_trace = 1;
1428
1429                 ret = ust_app_start_trace_all(usess);
1430                 if (ret < 0) {
1431                         ret = LTTNG_ERR_UST_START_FAIL;
1432                         goto error;
1433                 }
1434         }
1435
1436         ret = LTTNG_OK;
1437
1438 error:
1439         return ret;
1440 }
1441
1442 /*
1443  * Command LTTNG_STOP_TRACE processed by the client thread.
1444  */
1445 int cmd_stop_trace(struct ltt_session *session)
1446 {
1447         int ret;
1448         struct ltt_kernel_channel *kchan;
1449         struct ltt_kernel_session *ksession;
1450         struct ltt_ust_session *usess;
1451
1452         assert(session);
1453
1454         /* Short cut */
1455         ksession = session->kernel_session;
1456         usess = session->ust_session;
1457
1458         if (!session->enabled) {
1459                 ret = LTTNG_ERR_TRACE_ALREADY_STOPPED;
1460                 goto error;
1461         }
1462
1463         session->enabled = 0;
1464
1465         /* Kernel tracer */
1466         if (ksession) {
1467                 DBG("Stop kernel tracing");
1468
1469                 /* Flush metadata if exist */
1470                 if (ksession->metadata_stream_fd >= 0) {
1471                         ret = kernel_metadata_flush_buffer(ksession->metadata_stream_fd);
1472                         if (ret < 0) {
1473                                 ERR("Kernel metadata flush failed");
1474                         }
1475                 }
1476
1477                 /* Flush all buffers before stopping */
1478                 cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
1479                         ret = kernel_flush_buffer(kchan);
1480                         if (ret < 0) {
1481                                 ERR("Kernel flush buffer error");
1482                         }
1483                 }
1484
1485                 ret = kernel_stop_session(ksession);
1486                 if (ret < 0) {
1487                         ret = LTTNG_ERR_KERN_STOP_FAIL;
1488                         goto error;
1489                 }
1490
1491                 kernel_wait_quiescent(kernel_tracer_fd);
1492         }
1493
1494         if (usess) {
1495                 usess->start_trace = 0;
1496
1497                 ret = ust_app_stop_trace_all(usess);
1498                 if (ret < 0) {
1499                         ret = LTTNG_ERR_UST_STOP_FAIL;
1500                         goto error;
1501                 }
1502         }
1503
1504         ret = LTTNG_OK;
1505
1506 error:
1507         return ret;
1508 }
1509
1510 /*
1511  * Command LTTNG_SET_CONSUMER_URI processed by the client thread.
1512  */
1513 int cmd_set_consumer_uri(int domain, struct ltt_session *session,
1514                 size_t nb_uri, struct lttng_uri *uris)
1515 {
1516         int ret, i;
1517         struct ltt_kernel_session *ksess = session->kernel_session;
1518         struct ltt_ust_session *usess = session->ust_session;
1519         struct consumer_output *consumer = NULL;
1520
1521         assert(session);
1522         assert(uris);
1523         assert(nb_uri > 0);
1524
1525         /* Can't enable consumer after session started. */
1526         if (session->enabled) {
1527                 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
1528                 goto error;
1529         }
1530
1531         /*
1532          * This case switch makes sure the domain session has a temporary consumer
1533          * so the URL can be set.
1534          */
1535         switch (domain) {
1536         case 0:
1537                 /* Code flow error. A session MUST always have a consumer object */
1538                 assert(session->consumer);
1539                 /*
1540                  * The URL will be added to the tracing session consumer instead of a
1541                  * specific domain consumer.
1542                  */
1543                 consumer = session->consumer;
1544                 break;
1545         case LTTNG_DOMAIN_KERNEL:
1546                 /* Code flow error if we don't have a kernel session here. */
1547                 assert(ksess);
1548
1549                 /* Create consumer output if none exists */
1550                 consumer = ksess->tmp_consumer;
1551                 if (consumer == NULL) {
1552                         consumer = consumer_copy_output(ksess->consumer);
1553                         if (consumer == NULL) {
1554                                 ret = LTTNG_ERR_FATAL;
1555                                 goto error;
1556                         }
1557                         /* Trash the consumer subdir, we are about to set a new one. */
1558                         memset(consumer->subdir, 0, sizeof(consumer->subdir));
1559                         ksess->tmp_consumer = consumer;
1560                 }
1561
1562                 break;
1563         case LTTNG_DOMAIN_UST:
1564                 /* Code flow error if we don't have a kernel session here. */
1565                 assert(usess);
1566
1567                 /* Create consumer output if none exists */
1568                 consumer = usess->tmp_consumer;
1569                 if (consumer == NULL) {
1570                         consumer = consumer_copy_output(usess->consumer);
1571                         if (consumer == NULL) {
1572                                 ret = LTTNG_ERR_FATAL;
1573                                 goto error;
1574                         }
1575                         /* Trash the consumer subdir, we are about to set a new one. */
1576                         memset(consumer->subdir, 0, sizeof(consumer->subdir));
1577                         usess->tmp_consumer = consumer;
1578                 }
1579
1580                 break;
1581         }
1582
1583         for (i = 0; i < nb_uri; i++) {
1584                 struct consumer_socket *socket;
1585                 struct lttng_ht_iter iter;
1586
1587                 ret = add_uri_to_consumer(consumer, &uris[i], domain, session->name);
1588                 if (ret < 0) {
1589                         goto error;
1590                 }
1591
1592                 /*
1593                  * Don't send relayd socket if URI is NOT remote or if the relayd
1594                  * socket for the session was already sent.
1595                  */
1596                 if (uris[i].dtype == LTTNG_DST_PATH ||
1597                                 (uris[i].stype == LTTNG_STREAM_CONTROL &&
1598                                 consumer->dst.net.control_sock_sent) ||
1599                                 (uris[i].stype == LTTNG_STREAM_DATA &&
1600                                 consumer->dst.net.data_sock_sent)) {
1601                         continue;
1602                 }
1603
1604                 /* Try to send relayd URI to the consumer if exist. */
1605                 rcu_read_lock();
1606                 cds_lfht_for_each_entry(consumer->socks->ht, &iter.iter,
1607                                 socket, node.node) {
1608
1609                         /* A socket in the HT should never have a negative fd */
1610                         assert(socket->fd >= 0);
1611
1612                         pthread_mutex_lock(socket->lock);
1613                         ret = send_consumer_relayd_socket(domain, session, &uris[i],
1614                                         consumer, socket->fd);
1615                         pthread_mutex_unlock(socket->lock);
1616                         if (ret != LTTNG_OK) {
1617                                 rcu_read_unlock();
1618                                 goto error;
1619                         }
1620                 }
1621                 rcu_read_unlock();
1622         }
1623
1624         /* All good! */
1625         ret = LTTNG_OK;
1626
1627 error:
1628         return ret;
1629 }
1630
1631 /*
1632  * Command LTTNG_CREATE_SESSION processed by the client thread.
1633  */
1634 int cmd_create_session_uri(char *name, struct lttng_uri *uris,
1635                 size_t nb_uri, lttng_sock_cred *creds)
1636 {
1637         int ret;
1638         char *path = NULL;
1639         struct ltt_session *session;
1640
1641         assert(name);
1642
1643         /*
1644          * Verify if the session already exist
1645          *
1646          * XXX: There is no need for the session lock list here since the caller
1647          * (process_client_msg) is holding it. We might want to change that so a
1648          * single command does not lock the entire session list.
1649          */
1650         session = session_find_by_name(name);
1651         if (session != NULL) {
1652                 ret = LTTNG_ERR_EXIST_SESS;
1653                 goto find_error;
1654         }
1655
1656         /* Create tracing session in the registry */
1657         ret = session_create(name, path, LTTNG_SOCK_GET_UID_CRED(creds),
1658                         LTTNG_SOCK_GET_GID_CRED(creds));
1659         if (ret != LTTNG_OK) {
1660                 goto session_error;
1661         }
1662
1663         /*
1664          * Get the newly created session pointer back
1665          *
1666          * XXX: There is no need for the session lock list here since the caller
1667          * (process_client_msg) is holding it. We might want to change that so a
1668          * single command does not lock the entire session list.
1669          */
1670         session = session_find_by_name(name);
1671         assert(session);
1672
1673         /* Create default consumer output for the session not yet created. */
1674         session->consumer = consumer_create_output(CONSUMER_DST_LOCAL);
1675         if (session->consumer == NULL) {
1676                 ret = LTTNG_ERR_FATAL;
1677                 goto consumer_error;
1678         }
1679
1680         /*
1681          * This means that the lttng_create_session call was called with the _path_
1682          * argument set to NULL.
1683          */
1684         if (uris == NULL) {
1685                 /*
1686                  * At this point, we'll skip the consumer URI setup and create a
1687                  * session with a NULL path which will flag the session to NOT spawn a
1688                  * consumer.
1689                  */
1690                 DBG("Create session %s with NO uri, skipping consumer setup", name);
1691                 goto end;
1692         }
1693
1694         session->start_consumer = 1;
1695
1696         ret = cmd_set_consumer_uri(0, session, nb_uri, uris);
1697         if (ret != LTTNG_OK) {
1698                 goto consumer_error;
1699         }
1700
1701         session->consumer->enabled = 1;
1702
1703 end:
1704         return LTTNG_OK;
1705
1706 consumer_error:
1707         session_destroy(session);
1708 session_error:
1709 find_error:
1710         return ret;
1711 }
1712
1713 /*
1714  * Command LTTNG_DESTROY_SESSION processed by the client thread.
1715  */
1716 int cmd_destroy_session(struct ltt_session *session, int wpipe)
1717 {
1718         int ret;
1719         struct ltt_ust_session *usess;
1720         struct ltt_kernel_session *ksess;
1721
1722         /* Safety net */
1723         assert(session);
1724
1725         usess = session->ust_session;
1726         ksess = session->kernel_session;
1727
1728         /* Clean kernel session teardown */
1729         kernel_destroy_session(ksess);
1730
1731         /* UST session teardown */
1732         if (usess) {
1733                 /* Close any relayd session */
1734                 consumer_output_send_destroy_relayd(usess->consumer);
1735
1736                 /* Destroy every UST application related to this session. */
1737                 ret = ust_app_destroy_trace_all(usess);
1738                 if (ret) {
1739                         ERR("Error in ust_app_destroy_trace_all");
1740                 }
1741
1742                 /* Clean up the rest. */
1743                 trace_ust_destroy_session(usess);
1744         }
1745
1746         /*
1747          * Must notify the kernel thread here to update it's poll set in order to
1748          * remove the channel(s)' fd just destroyed.
1749          */
1750         ret = notify_thread_pipe(wpipe);
1751         if (ret < 0) {
1752                 PERROR("write kernel poll pipe");
1753         }
1754
1755         ret = session_destroy(session);
1756
1757         return ret;
1758 }
1759
1760 /*
1761  * Command LTTNG_CALIBRATE processed by the client thread.
1762  */
1763 int cmd_calibrate(int domain, struct lttng_calibrate *calibrate)
1764 {
1765         int ret;
1766
1767         switch (domain) {
1768         case LTTNG_DOMAIN_KERNEL:
1769         {
1770                 struct lttng_kernel_calibrate kcalibrate;
1771
1772                 kcalibrate.type = calibrate->type;
1773                 ret = kernel_calibrate(kernel_tracer_fd, &kcalibrate);
1774                 if (ret < 0) {
1775                         ret = LTTNG_ERR_KERN_ENABLE_FAIL;
1776                         goto error;
1777                 }
1778                 break;
1779         }
1780         case LTTNG_DOMAIN_UST:
1781         {
1782                 struct lttng_ust_calibrate ucalibrate;
1783
1784                 ucalibrate.type = calibrate->type;
1785                 ret = ust_app_calibrate_glb(&ucalibrate);
1786                 if (ret < 0) {
1787                         ret = LTTNG_ERR_UST_CALIBRATE_FAIL;
1788                         goto error;
1789                 }
1790                 break;
1791         }
1792         default:
1793                 ret = LTTNG_ERR_UND;
1794                 goto error;
1795         }
1796
1797         ret = LTTNG_OK;
1798
1799 error:
1800         return ret;
1801 }
1802
1803 /*
1804  * Command LTTNG_REGISTER_CONSUMER processed by the client thread.
1805  */
1806 int cmd_register_consumer(struct ltt_session *session, int domain,
1807                 const char *sock_path, struct consumer_data *cdata)
1808 {
1809         int ret, sock;
1810         struct consumer_socket *socket;
1811
1812         assert(session);
1813         assert(cdata);
1814         assert(sock_path);
1815
1816         switch (domain) {
1817         case LTTNG_DOMAIN_KERNEL:
1818         {
1819                 struct ltt_kernel_session *ksess = session->kernel_session;
1820
1821                 assert(ksess);
1822
1823                 /* Can't register a consumer if there is already one */
1824                 if (ksess->consumer_fds_sent != 0) {
1825                         ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
1826                         goto error;
1827                 }
1828
1829                 sock = lttcomm_connect_unix_sock(sock_path);
1830                 if (sock < 0) {
1831                         ret = LTTNG_ERR_CONNECT_FAIL;
1832                         goto error;
1833                 }
1834
1835                 socket = consumer_allocate_socket(sock);
1836                 if (socket == NULL) {
1837                         ret = LTTNG_ERR_FATAL;
1838                         close(sock);
1839                         goto error;
1840                 }
1841
1842                 socket->lock = zmalloc(sizeof(pthread_mutex_t));
1843                 if (socket->lock == NULL) {
1844                         PERROR("zmalloc pthread mutex");
1845                         ret = LTTNG_ERR_FATAL;
1846                         goto error;
1847                 }
1848                 pthread_mutex_init(socket->lock, NULL);
1849                 socket->registered = 1;
1850
1851                 rcu_read_lock();
1852                 consumer_add_socket(socket, ksess->consumer);
1853                 rcu_read_unlock();
1854
1855                 pthread_mutex_lock(&cdata->pid_mutex);
1856                 cdata->pid = -1;
1857                 pthread_mutex_unlock(&cdata->pid_mutex);
1858
1859                 break;
1860         }
1861         default:
1862                 /* TODO: Userspace tracing */
1863                 ret = LTTNG_ERR_UND;
1864                 goto error;
1865         }
1866
1867         ret = LTTNG_OK;
1868
1869 error:
1870         return ret;
1871 }
1872
1873 /*
1874  * Command LTTNG_LIST_DOMAINS processed by the client thread.
1875  */
1876 ssize_t cmd_list_domains(struct ltt_session *session,
1877                 struct lttng_domain **domains)
1878 {
1879         int ret, index = 0;
1880         ssize_t nb_dom = 0;
1881
1882         if (session->kernel_session != NULL) {
1883                 DBG3("Listing domains found kernel domain");
1884                 nb_dom++;
1885         }
1886
1887         if (session->ust_session != NULL) {
1888                 DBG3("Listing domains found UST global domain");
1889                 nb_dom++;
1890         }
1891
1892         *domains = zmalloc(nb_dom * sizeof(struct lttng_domain));
1893         if (*domains == NULL) {
1894                 ret = LTTNG_ERR_FATAL;
1895                 goto error;
1896         }
1897
1898         if (session->kernel_session != NULL) {
1899                 (*domains)[index].type = LTTNG_DOMAIN_KERNEL;
1900                 index++;
1901         }
1902
1903         if (session->ust_session != NULL) {
1904                 (*domains)[index].type = LTTNG_DOMAIN_UST;
1905                 index++;
1906         }
1907
1908         return nb_dom;
1909
1910 error:
1911         /* Return negative value to differentiate return code */
1912         return -ret;
1913 }
1914
1915
1916 /*
1917  * Command LTTNG_LIST_CHANNELS processed by the client thread.
1918  */
1919 ssize_t cmd_list_channels(int domain, struct ltt_session *session,
1920                 struct lttng_channel **channels)
1921 {
1922         int ret;
1923         ssize_t nb_chan = 0;
1924
1925         switch (domain) {
1926         case LTTNG_DOMAIN_KERNEL:
1927                 if (session->kernel_session != NULL) {
1928                         nb_chan = session->kernel_session->channel_count;
1929                 }
1930                 DBG3("Number of kernel channels %zd", nb_chan);
1931                 if (nb_chan <= 0) {
1932                         ret = LTTNG_ERR_KERN_CHAN_NOT_FOUND;
1933                 }
1934                 break;
1935         case LTTNG_DOMAIN_UST:
1936                 if (session->ust_session != NULL) {
1937                         nb_chan = lttng_ht_get_count(
1938                                         session->ust_session->domain_global.channels);
1939                 }
1940                 DBG3("Number of UST global channels %zd", nb_chan);
1941                 if (nb_chan <= 0) {
1942                         ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
1943                 }
1944                 break;
1945         default:
1946                 *channels = NULL;
1947                 ret = LTTNG_ERR_UND;
1948                 goto error;
1949         }
1950
1951         if (nb_chan > 0) {
1952                 *channels = zmalloc(nb_chan * sizeof(struct lttng_channel));
1953                 if (*channels == NULL) {
1954                         ret = LTTNG_ERR_FATAL;
1955                         goto error;
1956                 }
1957
1958                 list_lttng_channels(domain, session, *channels);
1959         } else {
1960                 *channels = NULL;
1961                 /* Ret value was set in the domain switch case */
1962                 goto error;
1963         }
1964
1965         return nb_chan;
1966
1967 error:
1968         /* Return negative value to differentiate return code */
1969         return -ret;
1970 }
1971
1972 /*
1973  * Command LTTNG_LIST_EVENTS processed by the client thread.
1974  */
1975 ssize_t cmd_list_events(int domain, struct ltt_session *session,
1976                 char *channel_name, struct lttng_event **events)
1977 {
1978         int ret = 0;
1979         ssize_t nb_event = 0;
1980
1981         switch (domain) {
1982         case LTTNG_DOMAIN_KERNEL:
1983                 if (session->kernel_session != NULL) {
1984                         nb_event = list_lttng_kernel_events(channel_name,
1985                                         session->kernel_session, events);
1986                 }
1987                 break;
1988         case LTTNG_DOMAIN_UST:
1989         {
1990                 if (session->ust_session != NULL) {
1991                         nb_event = list_lttng_ust_global_events(channel_name,
1992                                         &session->ust_session->domain_global, events);
1993                 }
1994                 break;
1995         }
1996         default:
1997                 ret = LTTNG_ERR_UND;
1998                 goto error;
1999         }
2000
2001         return nb_event;
2002
2003 error:
2004         /* Return negative value to differentiate return code */
2005         return -ret;
2006 }
2007
2008 /*
2009  * Using the session list, filled a lttng_session array to send back to the
2010  * client for session listing.
2011  *
2012  * The session list lock MUST be acquired before calling this function. Use
2013  * session_lock_list() and session_unlock_list().
2014  */
2015 void cmd_list_lttng_sessions(struct lttng_session *sessions, uid_t uid,
2016                 gid_t gid)
2017 {
2018         int ret;
2019         unsigned int i = 0;
2020         struct ltt_session *session;
2021         struct ltt_session_list *list = session_get_list();
2022
2023         DBG("Getting all available session for UID %d GID %d",
2024                         uid, gid);
2025         /*
2026          * Iterate over session list and append data after the control struct in
2027          * the buffer.
2028          */
2029         cds_list_for_each_entry(session, &list->head, list) {
2030                 /*
2031                  * Only list the sessions the user can control.
2032                  */
2033                 if (!session_access_ok(session, uid, gid)) {
2034                         continue;
2035                 }
2036
2037                 struct ltt_kernel_session *ksess = session->kernel_session;
2038                 struct ltt_ust_session *usess = session->ust_session;
2039
2040                 if (session->consumer->type == CONSUMER_DST_NET ||
2041                                 (ksess && ksess->consumer->type == CONSUMER_DST_NET) ||
2042                                 (usess && usess->consumer->type == CONSUMER_DST_NET)) {
2043                         ret = build_network_session_path(sessions[i].path,
2044                                         sizeof(session[i].path), session);
2045                 } else {
2046                         ret = snprintf(sessions[i].path, sizeof(session[i].path), "%s",
2047                                         session->consumer->dst.trace_path);
2048                 }
2049                 if (ret < 0) {
2050                         PERROR("snprintf session path");
2051                         continue;
2052                 }
2053
2054                 strncpy(sessions[i].name, session->name, NAME_MAX);
2055                 sessions[i].name[NAME_MAX - 1] = '\0';
2056                 sessions[i].enabled = session->enabled;
2057                 i++;
2058         }
2059 }
2060
2061 /*
2062  * Command LTTNG_DISABLE_CONSUMER processed by the client thread.
2063  */
2064 int cmd_disable_consumer(int domain, struct ltt_session *session)
2065 {
2066         int ret;
2067         struct ltt_kernel_session *ksess = session->kernel_session;
2068         struct ltt_ust_session *usess = session->ust_session;
2069         struct consumer_output *consumer;
2070
2071         assert(session);
2072
2073         if (session->enabled) {
2074                 /* Can't disable consumer on an already started session */
2075                 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
2076                 goto error;
2077         }
2078
2079         if (!session->start_consumer) {
2080                 ret = LTTNG_ERR_NO_CONSUMER;
2081                 goto error;
2082         }
2083
2084         switch (domain) {
2085         case 0:
2086                 DBG("Disable tracing session %s consumer", session->name);
2087                 consumer = session->consumer;
2088                 break;
2089         case LTTNG_DOMAIN_KERNEL:
2090                 /* Code flow error if we don't have a kernel session here. */
2091                 assert(ksess);
2092
2093                 DBG("Disabling kernel consumer");
2094                 consumer = ksess->consumer;
2095
2096                 break;
2097         case LTTNG_DOMAIN_UST:
2098                 /* Code flow error if we don't have a UST session here. */
2099                 assert(usess);
2100
2101                 DBG("Disabling UST consumer");
2102                 consumer = usess->consumer;
2103
2104                 break;
2105         default:
2106                 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
2107                 goto error;
2108         }
2109
2110         if (consumer) {
2111                 consumer->enabled = 0;
2112                 /* Success at this point */
2113                 ret = LTTNG_OK;
2114         } else {
2115                 ret = LTTNG_ERR_NO_CONSUMER;
2116         }
2117
2118 error:
2119         return ret;
2120 }
2121
2122 /*
2123  * Command LTTNG_ENABLE_CONSUMER processed by the client thread.
2124  */
2125 int cmd_enable_consumer(int domain, struct ltt_session *session)
2126 {
2127         int ret;
2128         struct ltt_kernel_session *ksess = session->kernel_session;
2129         struct ltt_ust_session *usess = session->ust_session;
2130         struct consumer_output *consumer = NULL;
2131
2132         assert(session);
2133
2134         /* Can't enable consumer after session started. */
2135         if (session->enabled) {
2136                 ret = LTTNG_ERR_TRACE_ALREADY_STARTED;
2137                 goto error;
2138         }
2139
2140         switch (domain) {
2141         case 0:
2142                 assert(session->consumer);
2143                 consumer = session->consumer;
2144                 break;
2145         case LTTNG_DOMAIN_KERNEL:
2146                 /* Code flow error if we don't have a kernel session here. */
2147                 assert(ksess);
2148
2149                 /*
2150                  * Check if we have already sent fds to the consumer. In that case,
2151                  * the enable-consumer command can't be used because a start trace
2152                  * had previously occured.
2153                  */
2154                 if (ksess->consumer_fds_sent) {
2155                         ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
2156                         goto error;
2157                 }
2158
2159                 consumer = ksess->tmp_consumer;
2160                 if (consumer == NULL) {
2161                         ret = LTTNG_OK;
2162                         /* No temp. consumer output exists. Using the current one. */
2163                         DBG3("No temporary consumer. Using default");
2164                         consumer = ksess->consumer;
2165                         goto error;
2166                 }
2167
2168                 switch (consumer->type) {
2169                 case CONSUMER_DST_LOCAL:
2170                         DBG2("Consumer output is local. Creating directory(ies)");
2171
2172                         /* Create directory(ies) */
2173                         ret = run_as_mkdir_recursive(consumer->dst.trace_path,
2174                                         S_IRWXU | S_IRWXG, session->uid, session->gid);
2175                         if (ret < 0) {
2176                                 if (ret != -EEXIST) {
2177                                         ERR("Trace directory creation error");
2178                                         ret = LTTNG_ERR_FATAL;
2179                                         goto error;
2180                                 }
2181                         }
2182                         break;
2183                 case CONSUMER_DST_NET:
2184                         DBG2("Consumer output is network. Validating URIs");
2185                         /* Validate if we have both control and data path set. */
2186                         if (!consumer->dst.net.control_isset) {
2187                                 ret = LTTNG_ERR_URL_CTRL_MISS;
2188                                 goto error;
2189                         }
2190
2191                         if (!consumer->dst.net.data_isset) {
2192                                 ret = LTTNG_ERR_URL_DATA_MISS;
2193                                 goto error;
2194                         }
2195
2196                         /* Check established network session state */
2197                         if (session->net_handle == 0) {
2198                                 ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
2199                                 ERR("Session network handle is not set on enable-consumer");
2200                                 goto error;
2201                         }
2202
2203                         break;
2204                 }
2205
2206                 /*
2207                  * @session-lock
2208                  * This is race free for now since the session lock is acquired before
2209                  * ending up in this function. No other threads can access this kernel
2210                  * session without this lock hence freeing the consumer output object
2211                  * is valid.
2212                  */
2213                 rcu_read_lock();
2214                 /* Destroy current consumer. We are about to replace it */
2215                 consumer_destroy_output(ksess->consumer);
2216                 rcu_read_unlock();
2217                 ksess->consumer = consumer;
2218                 ksess->tmp_consumer = NULL;
2219
2220                 break;
2221         case LTTNG_DOMAIN_UST:
2222                 /* Code flow error if we don't have a UST session here. */
2223                 assert(usess);
2224
2225                 /*
2226                  * Check if we have already sent fds to the consumer. In that case,
2227                  * the enable-consumer command can't be used because a start trace
2228                  * had previously occured.
2229                  */
2230                 if (usess->start_trace) {
2231                         ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
2232                         goto error;
2233                 }
2234
2235                 consumer = usess->tmp_consumer;
2236                 if (consumer == NULL) {
2237                         ret = LTTNG_OK;
2238                         /* No temp. consumer output exists. Using the current one. */
2239                         DBG3("No temporary consumer. Using default");
2240                         consumer = usess->consumer;
2241                         goto error;
2242                 }
2243
2244                 switch (consumer->type) {
2245                 case CONSUMER_DST_LOCAL:
2246                         DBG2("Consumer output is local. Creating directory(ies)");
2247
2248                         /* Create directory(ies) */
2249                         ret = run_as_mkdir_recursive(consumer->dst.trace_path,
2250                                         S_IRWXU | S_IRWXG, session->uid, session->gid);
2251                         if (ret < 0) {
2252                                 if (ret != -EEXIST) {
2253                                         ERR("Trace directory creation error");
2254                                         ret = LTTNG_ERR_FATAL;
2255                                         goto error;
2256                                 }
2257                         }
2258                         break;
2259                 case CONSUMER_DST_NET:
2260                         DBG2("Consumer output is network. Validating URIs");
2261                         /* Validate if we have both control and data path set. */
2262                         if (!consumer->dst.net.control_isset) {
2263                                 ret = LTTNG_ERR_URL_CTRL_MISS;
2264                                 goto error;
2265                         }
2266
2267                         if (!consumer->dst.net.data_isset) {
2268                                 ret = LTTNG_ERR_URL_DATA_MISS;
2269                                 goto error;
2270                         }
2271
2272                         /* Check established network session state */
2273                         if (session->net_handle == 0) {
2274                                 ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
2275                                 DBG2("Session network handle is not set on enable-consumer");
2276                                 goto error;
2277                         }
2278
2279                         if (consumer->net_seq_index == -1) {
2280                                 ret = LTTNG_ERR_ENABLE_CONSUMER_FAIL;
2281                                 DBG2("Network index is not set on the consumer");
2282                                 goto error;
2283                         }
2284
2285                         break;
2286                 }
2287
2288                 /*
2289                  * @session-lock
2290                  * This is race free for now since the session lock is acquired before
2291                  * ending up in this function. No other threads can access this kernel
2292                  * session without this lock hence freeing the consumer output object
2293                  * is valid.
2294                  */
2295                 rcu_read_lock();
2296                 /* Destroy current consumer. We are about to replace it */
2297                 consumer_destroy_output(usess->consumer);
2298                 rcu_read_unlock();
2299                 usess->consumer = consumer;
2300                 usess->tmp_consumer = NULL;
2301
2302                 break;
2303         }
2304
2305         session->start_consumer = 1;
2306
2307         /* Enable it */
2308         if (consumer) {
2309                 consumer->enabled = 1;
2310                 /* Success at this point */
2311                 ret = LTTNG_OK;
2312         } else {
2313                 /* Should not really happend... */
2314                 ret = LTTNG_ERR_NO_CONSUMER;
2315         }
2316
2317 error:
2318         return ret;
2319 }
2320
2321 /*
2322  * Command LTTNG_DATA_AVAILABLE returning 0 if the data is NOT ready to be read
2323  * or else 1 if the data is available for trace analysis.
2324  */
2325 int cmd_data_available(struct ltt_session *session)
2326 {
2327         int ret;
2328         struct ltt_kernel_session *ksess = session->kernel_session;
2329         struct ltt_ust_session *usess = session->ust_session;
2330
2331         assert(session);
2332
2333         /* Session MUST be stopped to ask for data availability. */
2334         if (session->enabled) {
2335                 ret = LTTNG_ERR_SESSION_STARTED;
2336                 goto error;
2337         }
2338
2339         if (ksess && ksess->consumer) {
2340                 ret = consumer_is_data_available(ksess->id, ksess->consumer);
2341                 if (ret == 0) {
2342                         /* Data is still being extracted for the kernel. */
2343                         goto error;
2344                 }
2345         }
2346
2347         if (usess && usess->consumer) {
2348                 ret = consumer_is_data_available(usess->id, usess->consumer);
2349                 if (ret == 0) {
2350                         /* Data is still being extracted for the kernel. */
2351                         goto error;
2352                 }
2353         }
2354
2355         /* Data is ready to be read by a viewer */
2356         ret = 1;
2357
2358 error:
2359         return ret;
2360 }
2361
2362 /*
2363  * Init command subsystem.
2364  */
2365 void cmd_init(void)
2366 {
2367         /*
2368          * Set network sequence index to 1 for streams to match a relayd socket on
2369          * the consumer side.
2370          */
2371         uatomic_set(&relayd_net_seq_idx, 1);
2372
2373         DBG("Command subsystem initialized");
2374 }