-
- nb_fd = ret;
-
- for (i = 0; i < nb_fd; i++) {
- /* Fetch once the poll data */
- revents = LTTNG_POLL_GETEV(&events, i);
- pollfd = LTTNG_POLL_GETFD(&events, i);
-
- health_code_update(&health_thread_kernel);
-
- /* Thread quit pipe has been closed. Killing thread. */
- ret = check_thread_quit_pipe(pollfd, revents);
- if (ret) {
- err = 0;
- goto exit;
- }
-
- /* Check for data on kernel pipe */
- if (pollfd == kernel_poll_pipe[0] && (revents & LPOLLIN)) {
- do {
- ret = read(kernel_poll_pipe[0], &tmp, 1);
- } while (ret < 0 && errno == EINTR);
- /*
- * Ret value is useless here, if this pipe gets any actions an
- * update is required anyway.
- */
- update_poll_flag = 1;
- continue;
- } else {
- /*
- * New CPU detected by the kernel. Adding kernel stream to
- * kernel session and updating the kernel consumer
- */
- if (revents & LPOLLIN) {
- ret = update_kernel_stream(&kconsumer_data, pollfd);
- if (ret < 0) {
- continue;
- }
- break;
- /*
- * TODO: We might want to handle the LPOLLERR | LPOLLHUP
- * and unregister kernel stream at this point.
- */
- }
- }
- }
- }
-
-exit:
-error:
- lttng_poll_clean(&events);
-error_poll_create:
-error_testpoint:
- utils_close_pipe(kernel_poll_pipe);
- kernel_poll_pipe[0] = kernel_poll_pipe[1] = -1;
- if (err) {
- health_error(&health_thread_kernel);
- ERR("Health error occurred in %s", __func__);
- WARN("Kernel thread died unexpectedly. "
- "Kernel tracing can continue but CPU hotplug is disabled.");
- }
- health_exit(&health_thread_kernel);
- DBG("Kernel thread dying");
- return NULL;
-}
-
-/*
- * Signal pthread condition of the consumer data that the thread.
- */
-static void signal_consumer_condition(struct consumer_data *data, int state)
-{
- pthread_mutex_lock(&data->cond_mutex);
-
- /*
- * The state is set before signaling. It can be any value, it's the waiter
- * job to correctly interpret this condition variable associated to the
- * consumer pthread_cond.
- *
- * A value of 0 means that the corresponding thread of the consumer data
- * was not started. 1 indicates that the thread has started and is ready
- * for action. A negative value means that there was an error during the
- * thread bootstrap.
- */
- data->consumer_thread_is_ready = state;
- (void) pthread_cond_signal(&data->cond);
-
- pthread_mutex_unlock(&data->cond_mutex);
-}
-
-/*
- * This thread manage the consumer error sent back to the session daemon.
- */
-static void *thread_manage_consumer(void *data)
-{
- int sock = -1, i, ret, pollfd, err = -1;
- uint32_t revents, nb_fd;
- enum lttcomm_return_code code;
- struct lttng_poll_event events;
- struct consumer_data *consumer_data = data;
-
- DBG("[thread] Manage consumer started");
-
- /*
- * Since the consumer thread can be spawned at any moment in time, we init
- * the health to a poll status (1, which is a valid health over time).
- * When the thread starts, we update here the health to a "code" path being
- * an even value so this thread, when reaching a poll wait, does not
- * trigger an error with an even value.
- *
- * Here is the use case we avoid.
- *
- * +1: the first poll update during initialization (main())
- * +2 * x: multiple code update once in this thread.
- * +1: poll wait in this thread (being a good health state).
- * == even number which after the wait period shows as a bad health.
- *
- * In a nutshell, the following poll update to the health state brings back
- * the state to an even value meaning a code path.
- */
- health_poll_update(&consumer_data->health);
-
- /*
- * Pass 2 as size here for the thread quit pipe and kconsumerd_err_sock.
- * Nothing more will be added to this poll set.
- */
- ret = create_thread_poll_set(&events, 2);
- if (ret < 0) {
- goto error_poll;
- }
-
- /*
- * The error socket here is already in a listening state which was done
- * just before spawning this thread to avoid a race between the consumer
- * daemon exec trying to connect and the listen() call.
- */
- ret = lttng_poll_add(&events, consumer_data->err_sock, LPOLLIN | LPOLLRDHUP);
- if (ret < 0) {
- goto error;
- }
-
- health_code_update(&consumer_data->health);
-
- /* Inifinite blocking call, waiting for transmission */
-restart:
- health_poll_update(&consumer_data->health);
-
- if (testpoint(thread_manage_consumer)) {
- goto error;
- }
-
- ret = lttng_poll_wait(&events, -1);
- health_poll_update(&consumer_data->health);
- if (ret < 0) {
- /*
- * Restart interrupted system call.
- */
- if (errno == EINTR) {
- goto restart;
- }
- goto error;
- }
-
- nb_fd = ret;
-
- for (i = 0; i < nb_fd; i++) {
- /* Fetch once the poll data */
- revents = LTTNG_POLL_GETEV(&events, i);
- pollfd = LTTNG_POLL_GETFD(&events, i);
-
- health_code_update(&consumer_data->health);
-
- /* Thread quit pipe has been closed. Killing thread. */
- ret = check_thread_quit_pipe(pollfd, revents);
- if (ret) {
- err = 0;
- goto exit;
- }
-
- /* Event on the registration socket */
- if (pollfd == consumer_data->err_sock) {
- if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
- ERR("consumer err socket poll error");
- goto error;
- }
- }
- }
-
- sock = lttcomm_accept_unix_sock(consumer_data->err_sock);
- if (sock < 0) {
- goto error;
- }
-
- /*
- * Set the CLOEXEC flag. Return code is useless because either way, the
- * show must go on.
- */
- (void) utils_set_fd_cloexec(sock);
-
- health_code_update(&consumer_data->health);
-
- DBG2("Receiving code from consumer err_sock");
-
- /* Getting status code from kconsumerd */
- ret = lttcomm_recv_unix_sock(sock, &code,
- sizeof(enum lttcomm_return_code));
- if (ret <= 0) {
- goto error;
- }
-
- health_code_update(&consumer_data->health);
-
- if (code == LTTCOMM_CONSUMERD_COMMAND_SOCK_READY) {
- consumer_data->cmd_sock =
- lttcomm_connect_unix_sock(consumer_data->cmd_unix_sock_path);
- if (consumer_data->cmd_sock < 0) {
- /* On error, signal condition and quit. */
- signal_consumer_condition(consumer_data, -1);
- PERROR("consumer connect");
- goto error;
- }
- signal_consumer_condition(consumer_data, 1);
- DBG("Consumer command socket ready");
- } else {
- ERR("consumer error when waiting for SOCK_READY : %s",
- lttcomm_get_readable_code(-code));
- goto error;
- }
-
- /* Remove the kconsumerd error sock since we've established a connexion */
- ret = lttng_poll_del(&events, consumer_data->err_sock);
- if (ret < 0) {
- goto error;
- }
-
- ret = lttng_poll_add(&events, sock, LPOLLIN | LPOLLRDHUP);
- if (ret < 0) {
- goto error;
- }
-
- health_code_update(&consumer_data->health);
-
- /* Inifinite blocking call, waiting for transmission */
-restart_poll:
- health_poll_update(&consumer_data->health);
- ret = lttng_poll_wait(&events, -1);
- health_poll_update(&consumer_data->health);
- if (ret < 0) {
- /*
- * Restart interrupted system call.
- */
- if (errno == EINTR) {
- goto restart_poll;
- }
- goto error;
- }
-
- nb_fd = ret;
-
- for (i = 0; i < nb_fd; i++) {
- /* Fetch once the poll data */
- revents = LTTNG_POLL_GETEV(&events, i);
- pollfd = LTTNG_POLL_GETFD(&events, i);
-
- health_code_update(&consumer_data->health);
-
- /* Thread quit pipe has been closed. Killing thread. */
- ret = check_thread_quit_pipe(pollfd, revents);
- if (ret) {
- err = 0;
- goto exit;
- }
-
- /* Event on the kconsumerd socket */
- if (pollfd == sock) {
- if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
- ERR("consumer err socket second poll error");
- goto error;
- }
- }
- }
-
- health_code_update(&consumer_data->health);
-
- /* Wait for any kconsumerd error */
- ret = lttcomm_recv_unix_sock(sock, &code,
- sizeof(enum lttcomm_return_code));
- if (ret <= 0) {
- ERR("consumer closed the command socket");
- goto error;
- }
-
- ERR("consumer return code : %s", lttcomm_get_readable_code(-code));
-
-exit:
-error:
- /* Immediately set the consumerd state to stopped */
- if (consumer_data->type == LTTNG_CONSUMER_KERNEL) {
- uatomic_set(&kernel_consumerd_state, CONSUMER_ERROR);
- } else if (consumer_data->type == LTTNG_CONSUMER64_UST ||
- consumer_data->type == LTTNG_CONSUMER32_UST) {
- uatomic_set(&ust_consumerd_state, CONSUMER_ERROR);
- } else {
- /* Code flow error... */
- assert(0);
- }
-
- if (consumer_data->err_sock >= 0) {
- ret = close(consumer_data->err_sock);
- if (ret) {
- PERROR("close");
- }
- }
- if (consumer_data->cmd_sock >= 0) {
- ret = close(consumer_data->cmd_sock);
- if (ret) {
- PERROR("close");
- }
- }
- if (sock >= 0) {
- ret = close(sock);
- if (ret) {
- PERROR("close");
- }
- }
-
- unlink(consumer_data->err_unix_sock_path);
- unlink(consumer_data->cmd_unix_sock_path);
- consumer_data->pid = 0;
-
- lttng_poll_clean(&events);
-error_poll:
- if (err) {
- health_error(&consumer_data->health);
- ERR("Health error occurred in %s", __func__);
- }
- health_exit(&consumer_data->health);
- DBG("consumer thread cleanup completed");
-
- return NULL;
-}
-
-/*
- * This thread manage application communication.
- */
-static void *thread_manage_apps(void *data)
-{
- int i, ret, pollfd, err = -1;
- uint32_t revents, nb_fd;
- struct ust_command ust_cmd;
- struct lttng_poll_event events;
-
- DBG("[thread] Manage application started");
-
- rcu_register_thread();
- rcu_thread_online();
-
- if (testpoint(thread_manage_apps)) {
- goto error_testpoint;
- }
-
- health_code_update(&health_thread_app_manage);
-
- ret = create_thread_poll_set(&events, 2);
- if (ret < 0) {
- goto error_poll_create;
- }
-
- ret = lttng_poll_add(&events, apps_cmd_pipe[0], LPOLLIN | LPOLLRDHUP);
- if (ret < 0) {
- goto error;
- }
-
- if (testpoint(thread_manage_apps_before_loop)) {
- goto error;
- }
-
- health_code_update(&health_thread_app_manage);
-
- while (1) {
- DBG("Apps thread polling on %d fds", LTTNG_POLL_GETNB(&events));
-
- /* Inifinite blocking call, waiting for transmission */
- restart:
- health_poll_update(&health_thread_app_manage);
- ret = lttng_poll_wait(&events, -1);
- health_poll_update(&health_thread_app_manage);
- if (ret < 0) {
- /*
- * Restart interrupted system call.
- */
- if (errno == EINTR) {
- goto restart;
- }
- goto error;
- }
-
- nb_fd = ret;
-
- for (i = 0; i < nb_fd; i++) {
- /* Fetch once the poll data */
- revents = LTTNG_POLL_GETEV(&events, i);
- pollfd = LTTNG_POLL_GETFD(&events, i);
-
- health_code_update(&health_thread_app_manage);
-
- /* Thread quit pipe has been closed. Killing thread. */
- ret = check_thread_quit_pipe(pollfd, revents);
- if (ret) {
- err = 0;
- goto exit;
- }
-
- /* Inspect the apps cmd pipe */
- if (pollfd == apps_cmd_pipe[0]) {
- if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
- ERR("Apps command pipe error");
- goto error;
- } else if (revents & LPOLLIN) {
- /* Empty pipe */
- do {
- ret = read(apps_cmd_pipe[0], &ust_cmd, sizeof(ust_cmd));
- } while (ret < 0 && errno == EINTR);
- if (ret < 0 || ret < sizeof(ust_cmd)) {
- PERROR("read apps cmd pipe");
- goto error;
- }
-
- health_code_update(&health_thread_app_manage);
-
- /* Register applicaton to the session daemon */
- ret = ust_app_register(&ust_cmd.reg_msg,
- ust_cmd.sock);
- if (ret == -ENOMEM) {
- goto error;
- } else if (ret < 0) {
- break;
- }
-
- health_code_update(&health_thread_app_manage);
-
- /*
- * Validate UST version compatibility.
- */
- ret = ust_app_validate_version(ust_cmd.sock);
- if (ret >= 0) {
- /*
- * Add channel(s) and event(s) to newly registered apps
- * from lttng global UST domain.
- */
- update_ust_app(ust_cmd.sock);
- }
-
- health_code_update(&health_thread_app_manage);
-
- ret = ust_app_register_done(ust_cmd.sock);
- if (ret < 0) {
- /*
- * If the registration is not possible, we simply
- * unregister the apps and continue
- */
- ust_app_unregister(ust_cmd.sock);
- } else {
- /*
- * We only monitor the error events of the socket. This
- * thread does not handle any incoming data from UST
- * (POLLIN).
- */
- ret = lttng_poll_add(&events, ust_cmd.sock,
- LPOLLERR & LPOLLHUP & LPOLLRDHUP);
- if (ret < 0) {
- goto error;
- }
-
- /* Set socket timeout for both receiving and ending */
- (void) lttcomm_setsockopt_rcv_timeout(ust_cmd.sock,
- app_socket_timeout);
- (void) lttcomm_setsockopt_snd_timeout(ust_cmd.sock,
- app_socket_timeout);
-
- DBG("Apps with sock %d added to poll set",
- ust_cmd.sock);
- }
-
- health_code_update(&health_thread_app_manage);
-
- break;
- }
- } else {
- /*
- * At this point, we know that a registered application made
- * the event at poll_wait.
- */
- if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
- /* Removing from the poll set */
- ret = lttng_poll_del(&events, pollfd);
- if (ret < 0) {
- goto error;
- }
-
- /* Socket closed on remote end. */
- ust_app_unregister(pollfd);
- break;
- }
- }
-
- health_code_update(&health_thread_app_manage);
- }
- }
-
-exit:
-error:
- lttng_poll_clean(&events);
-error_poll_create:
-error_testpoint:
- utils_close_pipe(apps_cmd_pipe);
- apps_cmd_pipe[0] = apps_cmd_pipe[1] = -1;
-
- /*
- * We don't clean the UST app hash table here since already registered
- * applications can still be controlled so let them be until the session
- * daemon dies or the applications stop.
- */
-
- if (err) {
- health_error(&health_thread_app_manage);
- ERR("Health error occurred in %s", __func__);
- }
- health_exit(&health_thread_app_manage);
- DBG("Application communication apps thread cleanup complete");
- rcu_thread_offline();
- rcu_unregister_thread();
- return NULL;
-}
-
-/*
- * Dispatch request from the registration threads to the application
- * communication thread.
- */
-static void *thread_dispatch_ust_registration(void *data)
-{
- int ret;
- struct cds_wfq_node *node;
- struct ust_command *ust_cmd = NULL;
-
- DBG("[thread] Dispatch UST command started");
-
- while (!CMM_LOAD_SHARED(dispatch_thread_exit)) {
- /* Atomically prepare the queue futex */
- futex_nto1_prepare(&ust_cmd_queue.futex);
-
- do {
- /* Dequeue command for registration */
- node = cds_wfq_dequeue_blocking(&ust_cmd_queue.queue);
- if (node == NULL) {
- DBG("Woken up but nothing in the UST command queue");
- /* Continue thread execution */
- break;
- }
-
- ust_cmd = caa_container_of(node, struct ust_command, node);
-
- DBG("Dispatching UST registration pid:%d ppid:%d uid:%d"
- " gid:%d sock:%d name:%s (version %d.%d)",
- ust_cmd->reg_msg.pid, ust_cmd->reg_msg.ppid,
- ust_cmd->reg_msg.uid, ust_cmd->reg_msg.gid,
- ust_cmd->sock, ust_cmd->reg_msg.name,
- ust_cmd->reg_msg.major, ust_cmd->reg_msg.minor);
- /*
- * Inform apps thread of the new application registration. This
- * call is blocking so we can be assured that the data will be read
- * at some point in time or wait to the end of the world :)
- */
- if (apps_cmd_pipe[1] >= 0) {
- ret = write(apps_cmd_pipe[1], ust_cmd,
- sizeof(struct ust_command));
- if (ret < 0) {
- PERROR("write apps cmd pipe");
- if (errno == EBADF) {
- /*
- * We can't inform the application thread to process
- * registration. We will exit or else application
- * registration will not occur and tracing will never
- * start.
- */
- goto error;
- }
- }
- } else {
- /* Application manager thread is not available. */
- ret = close(ust_cmd->sock);
- if (ret < 0) {
- PERROR("close ust_cmd sock");
- }
- }
- free(ust_cmd);
- } while (node != NULL);
-
- /* Futex wait on queue. Blocking call on futex() */
- futex_nto1_wait(&ust_cmd_queue.futex);
- }
-
-error:
- DBG("Dispatch thread dying");
- return NULL;
-}
-
-/*
- * This thread manage application registration.
- */
-static void *thread_registration_apps(void *data)
-{
- int sock = -1, i, ret, pollfd, err = -1;
- uint32_t revents, nb_fd;
- struct lttng_poll_event events;
- /*
- * Get allocated in this thread, enqueued to a global queue, dequeued and
- * freed in the manage apps thread.
- */
- struct ust_command *ust_cmd = NULL;
-
- DBG("[thread] Manage application registration started");
-
- if (testpoint(thread_registration_apps)) {
- goto error_testpoint;
- }
-
- ret = lttcomm_listen_unix_sock(apps_sock);
- if (ret < 0) {
- goto error_listen;
- }
-
- /*
- * Pass 2 as size here for the thread quit pipe and apps socket. Nothing
- * more will be added to this poll set.
- */
- ret = create_thread_poll_set(&events, 2);
- if (ret < 0) {
- goto error_create_poll;
- }
-
- /* Add the application registration socket */
- ret = lttng_poll_add(&events, apps_sock, LPOLLIN | LPOLLRDHUP);
- if (ret < 0) {
- goto error_poll_add;
- }
-
- /* Notify all applications to register */
- ret = notify_ust_apps(1);
- if (ret < 0) {
- ERR("Failed to notify applications or create the wait shared memory.\n"
- "Execution continues but there might be problem for already\n"
- "running applications that wishes to register.");
- }
-
- while (1) {
- DBG("Accepting application registration");
-
- /* Inifinite blocking call, waiting for transmission */
- restart:
- health_poll_update(&health_thread_app_reg);
- ret = lttng_poll_wait(&events, -1);
- health_poll_update(&health_thread_app_reg);
- if (ret < 0) {
- /*
- * Restart interrupted system call.
- */
- if (errno == EINTR) {
- goto restart;
- }
- goto error;
- }
-
- nb_fd = ret;
-
- for (i = 0; i < nb_fd; i++) {
- health_code_update(&health_thread_app_reg);
-
- /* Fetch once the poll data */
- revents = LTTNG_POLL_GETEV(&events, i);
- pollfd = LTTNG_POLL_GETFD(&events, i);
-
- /* Thread quit pipe has been closed. Killing thread. */
- ret = check_thread_quit_pipe(pollfd, revents);
- if (ret) {
- err = 0;
- goto exit;
- }
-
- /* Event on the registration socket */
- if (pollfd == apps_sock) {
- if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
- ERR("Register apps socket poll error");
- goto error;
- } else if (revents & LPOLLIN) {
- sock = lttcomm_accept_unix_sock(apps_sock);
- if (sock < 0) {
- goto error;
- }
-
- /*
- * Set the CLOEXEC flag. Return code is useless because
- * either way, the show must go on.
- */
- (void) utils_set_fd_cloexec(sock);
-
- /* Create UST registration command for enqueuing */
- ust_cmd = zmalloc(sizeof(struct ust_command));
- if (ust_cmd == NULL) {
- PERROR("ust command zmalloc");
- goto error;
- }
-
- /*
- * Using message-based transmissions to ensure we don't
- * have to deal with partially received messages.
- */
- ret = lttng_fd_get(LTTNG_FD_APPS, 1);
- if (ret < 0) {
- ERR("Exhausted file descriptors allowed for applications.");
- free(ust_cmd);
- ret = close(sock);
- if (ret) {
- PERROR("close");
- }
- sock = -1;
- continue;
- }
- health_code_update(&health_thread_app_reg);
- ret = lttcomm_recv_unix_sock(sock, &ust_cmd->reg_msg,
- sizeof(struct ust_register_msg));
- if (ret < 0 || ret < sizeof(struct ust_register_msg)) {
- if (ret < 0) {
- PERROR("lttcomm_recv_unix_sock register apps");
- } else {
- ERR("Wrong size received on apps register");
- }
- free(ust_cmd);
- ret = close(sock);
- if (ret) {
- PERROR("close");
- }
- lttng_fd_put(LTTNG_FD_APPS, 1);
- sock = -1;
- continue;
- }
- health_code_update(&health_thread_app_reg);
-
- ust_cmd->sock = sock;
- sock = -1;
-
- DBG("UST registration received with pid:%d ppid:%d uid:%d"
- " gid:%d sock:%d name:%s (version %d.%d)",
- ust_cmd->reg_msg.pid, ust_cmd->reg_msg.ppid,
- ust_cmd->reg_msg.uid, ust_cmd->reg_msg.gid,
- ust_cmd->sock, ust_cmd->reg_msg.name,
- ust_cmd->reg_msg.major, ust_cmd->reg_msg.minor);
-
- /*
- * Lock free enqueue the registration request. The red pill
- * has been taken! This apps will be part of the *system*.
- */
- cds_wfq_enqueue(&ust_cmd_queue.queue, &ust_cmd->node);
-
- /*
- * Wake the registration queue futex. Implicit memory
- * barrier with the exchange in cds_wfq_enqueue.
- */
- futex_nto1_wake(&ust_cmd_queue.futex);
- }
- }
- }
- }
-
-exit:
-error:
- if (err) {
- health_error(&health_thread_app_reg);
- ERR("Health error occurred in %s", __func__);
- }
-
- /* Notify that the registration thread is gone */
- notify_ust_apps(0);
-
- if (apps_sock >= 0) {
- ret = close(apps_sock);
- if (ret) {
- PERROR("close");
- }
- }
- if (sock >= 0) {
- ret = close(sock);
- if (ret) {
- PERROR("close");
- }
- lttng_fd_put(LTTNG_FD_APPS, 1);
- }
- unlink(apps_unix_sock_path);
-
-error_poll_add:
- lttng_poll_clean(&events);
-error_listen:
-error_create_poll:
-error_testpoint:
- DBG("UST Registration thread cleanup complete");
- health_exit(&health_thread_app_reg);
-
- return NULL;
-}
-
-/*
- * Start the thread_manage_consumer. This must be done after a lttng-consumerd
- * exec or it will fails.
- */
-static int spawn_consumer_thread(struct consumer_data *consumer_data)
-{
- int ret, clock_ret;
- struct timespec timeout;
-
- /* Make sure we set the readiness flag to 0 because we are NOT ready */
- consumer_data->consumer_thread_is_ready = 0;
-
- /* Setup pthread condition */
- ret = pthread_condattr_init(&consumer_data->condattr);
- if (ret != 0) {
- errno = ret;
- PERROR("pthread_condattr_init consumer data");
- goto error;
- }
-
- /*
- * Set the monotonic clock in order to make sure we DO NOT jump in time
- * between the clock_gettime() call and the timedwait call. See bug #324
- * for a more details and how we noticed it.
- */
- ret = pthread_condattr_setclock(&consumer_data->condattr, CLOCK_MONOTONIC);
- if (ret != 0) {
- errno = ret;
- PERROR("pthread_condattr_setclock consumer data");
- goto error;
- }
-
- ret = pthread_cond_init(&consumer_data->cond, &consumer_data->condattr);
- if (ret != 0) {
- errno = ret;
- PERROR("pthread_cond_init consumer data");
- goto error;
- }
-
- ret = pthread_create(&consumer_data->thread, NULL, thread_manage_consumer,
- consumer_data);
- if (ret != 0) {
- PERROR("pthread_create consumer");
- ret = -1;
- goto error;
- }
-
- /* We are about to wait on a pthread condition */
- pthread_mutex_lock(&consumer_data->cond_mutex);
-
- /* Get time for sem_timedwait absolute timeout */
- clock_ret = clock_gettime(CLOCK_MONOTONIC, &timeout);
- /*
- * Set the timeout for the condition timed wait even if the clock gettime
- * call fails since we might loop on that call and we want to avoid to
- * increment the timeout too many times.
- */
- timeout.tv_sec += DEFAULT_SEM_WAIT_TIMEOUT;
-
- /*
- * The following loop COULD be skipped in some conditions so this is why we
- * set ret to 0 in order to make sure at least one round of the loop is
- * done.
- */
- ret = 0;
-
- /*
- * Loop until the condition is reached or when a timeout is reached. Note
- * that the pthread_cond_timedwait(P) man page specifies that EINTR can NOT
- * be returned but the pthread_cond(3), from the glibc-doc, says that it is
- * possible. This loop does not take any chances and works with both of
- * them.
- */
- while (!consumer_data->consumer_thread_is_ready && ret != ETIMEDOUT) {
- if (clock_ret < 0) {
- PERROR("clock_gettime spawn consumer");
- /* Infinite wait for the consumerd thread to be ready */
- ret = pthread_cond_wait(&consumer_data->cond,
- &consumer_data->cond_mutex);
- } else {
- ret = pthread_cond_timedwait(&consumer_data->cond,
- &consumer_data->cond_mutex, &timeout);
- }
- }
-
- /* Release the pthread condition */
- pthread_mutex_unlock(&consumer_data->cond_mutex);
-
- if (ret != 0) {
- errno = ret;
- if (ret == ETIMEDOUT) {
- /*
- * Call has timed out so we kill the kconsumerd_thread and return
- * an error.
- */
- ERR("Condition timed out. The consumer thread was never ready."
- " Killing it");
- ret = pthread_cancel(consumer_data->thread);
- if (ret < 0) {
- PERROR("pthread_cancel consumer thread");
- }
- } else {
- PERROR("pthread_cond_wait failed consumer thread");
- }
- goto error;
- }
-
- pthread_mutex_lock(&consumer_data->pid_mutex);
- if (consumer_data->pid == 0) {
- ERR("Consumerd did not start");
- pthread_mutex_unlock(&consumer_data->pid_mutex);
- goto error;
- }
- pthread_mutex_unlock(&consumer_data->pid_mutex);
-
- return 0;
-
-error:
- return ret;
-}
-
-/*
- * Join consumer thread
- */
-static int join_consumer_thread(struct consumer_data *consumer_data)
-{
- void *status;
-
- /* Consumer pid must be a real one. */
- if (consumer_data->pid > 0) {
- int ret;
- ret = kill(consumer_data->pid, SIGTERM);
- if (ret) {
- ERR("Error killing consumer daemon");
- return ret;
- }
- return pthread_join(consumer_data->thread, &status);
- } else {
- return 0;
- }
-}
-
-/*
- * Fork and exec a consumer daemon (consumerd).
- *
- * Return pid if successful else -1.
- */
-static pid_t spawn_consumerd(struct consumer_data *consumer_data)
-{
- int ret;
- pid_t pid;
- const char *consumer_to_use;
- const char *verbosity;
- struct stat st;
-
- DBG("Spawning consumerd");
-
- pid = fork();
- if (pid == 0) {
- /*
- * Exec consumerd.
- */
- if (opt_verbose_consumer) {
- verbosity = "--verbose";
- } else {
- verbosity = "--quiet";
- }
- switch (consumer_data->type) {
- case LTTNG_CONSUMER_KERNEL:
- /*
- * Find out which consumerd to execute. We will first try the
- * 64-bit path, then the sessiond's installation directory, and
- * fallback on the 32-bit one,
- */
- DBG3("Looking for a kernel consumer at these locations:");
- DBG3(" 1) %s", consumerd64_bin);
- DBG3(" 2) %s/%s", INSTALL_BIN_PATH, CONSUMERD_FILE);
- DBG3(" 3) %s", consumerd32_bin);
- if (stat(consumerd64_bin, &st) == 0) {
- DBG3("Found location #1");
- consumer_to_use = consumerd64_bin;
- } else if (stat(INSTALL_BIN_PATH "/" CONSUMERD_FILE, &st) == 0) {
- DBG3("Found location #2");
- consumer_to_use = INSTALL_BIN_PATH "/" CONSUMERD_FILE;
- } else if (stat(consumerd32_bin, &st) == 0) {
- DBG3("Found location #3");
- consumer_to_use = consumerd32_bin;
- } else {
- DBG("Could not find any valid consumerd executable");
- break;
- }
- DBG("Using kernel consumer at: %s", consumer_to_use);
- execl(consumer_to_use,
- "lttng-consumerd", verbosity, "-k",
- "--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
- "--consumerd-err-sock", consumer_data->err_unix_sock_path,
- NULL);
- break;
- case LTTNG_CONSUMER64_UST:
- {
- char *tmpnew = NULL;
-
- if (consumerd64_libdir[0] != '\0') {
- char *tmp;
- size_t tmplen;
-
- tmp = getenv("LD_LIBRARY_PATH");
- if (!tmp) {
- tmp = "";
- }
- tmplen = strlen("LD_LIBRARY_PATH=")
- + strlen(consumerd64_libdir) + 1 /* : */ + strlen(tmp);
- tmpnew = zmalloc(tmplen + 1 /* \0 */);
- if (!tmpnew) {
- ret = -ENOMEM;
- goto error;
- }
- strcpy(tmpnew, "LD_LIBRARY_PATH=");
- strcat(tmpnew, consumerd64_libdir);
- if (tmp[0] != '\0') {
- strcat(tmpnew, ":");
- strcat(tmpnew, tmp);
- }
- ret = putenv(tmpnew);
- if (ret) {
- ret = -errno;
- goto error;
- }
- }
- DBG("Using 64-bit UST consumer at: %s", consumerd64_bin);
- ret = execl(consumerd64_bin, "lttng-consumerd", verbosity, "-u",
- "--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
- "--consumerd-err-sock", consumer_data->err_unix_sock_path,
- NULL);
- if (consumerd64_libdir[0] != '\0') {
- free(tmpnew);
- }
- if (ret) {
- goto error;
- }
- break;
- }
- case LTTNG_CONSUMER32_UST:
- {
- char *tmpnew = NULL;
-
- if (consumerd32_libdir[0] != '\0') {
- char *tmp;
- size_t tmplen;
-
- tmp = getenv("LD_LIBRARY_PATH");
- if (!tmp) {
- tmp = "";
- }
- tmplen = strlen("LD_LIBRARY_PATH=")
- + strlen(consumerd32_libdir) + 1 /* : */ + strlen(tmp);
- tmpnew = zmalloc(tmplen + 1 /* \0 */);
- if (!tmpnew) {
- ret = -ENOMEM;
- goto error;
- }
- strcpy(tmpnew, "LD_LIBRARY_PATH=");
- strcat(tmpnew, consumerd32_libdir);
- if (tmp[0] != '\0') {
- strcat(tmpnew, ":");
- strcat(tmpnew, tmp);
- }
- ret = putenv(tmpnew);
- if (ret) {
- ret = -errno;
- goto error;
- }
- }
- DBG("Using 32-bit UST consumer at: %s", consumerd32_bin);
- ret = execl(consumerd32_bin, "lttng-consumerd", verbosity, "-u",
- "--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
- "--consumerd-err-sock", consumer_data->err_unix_sock_path,
- NULL);
- if (consumerd32_libdir[0] != '\0') {
- free(tmpnew);
- }
- if (ret) {
- goto error;
- }
- break;
- }
- default:
- PERROR("unknown consumer type");
- exit(EXIT_FAILURE);
- }
- if (errno != 0) {
- PERROR("kernel start consumer exec");
- }
- exit(EXIT_FAILURE);
- } else if (pid > 0) {
- ret = pid;
- } else {
- PERROR("start consumer fork");
- ret = -errno;
- }
-error:
- return ret;
-}
-
-/*
- * Spawn the consumerd daemon and session daemon thread.
- */
-static int start_consumerd(struct consumer_data *consumer_data)
-{
- int ret;
-
- /*
- * Set the listen() state on the socket since there is a possible race
- * between the exec() of the consumer daemon and this call if place in the
- * consumer thread. See bug #366 for more details.
- */
- ret = lttcomm_listen_unix_sock(consumer_data->err_sock);
- if (ret < 0) {
- goto error;
- }
-
- pthread_mutex_lock(&consumer_data->pid_mutex);
- if (consumer_data->pid != 0) {
- pthread_mutex_unlock(&consumer_data->pid_mutex);
- goto end;
- }
-
- ret = spawn_consumerd(consumer_data);
- if (ret < 0) {
- ERR("Spawning consumerd failed");
- pthread_mutex_unlock(&consumer_data->pid_mutex);
- goto error;
- }
-
- /* Setting up the consumer_data pid */
- consumer_data->pid = ret;
- DBG2("Consumer pid %d", consumer_data->pid);
- pthread_mutex_unlock(&consumer_data->pid_mutex);
-
- DBG2("Spawning consumer control thread");
- ret = spawn_consumer_thread(consumer_data);
- if (ret < 0) {
- ERR("Fatal error spawning consumer control thread");
- goto error;
- }
-
-end:
- return 0;
-
-error:
- /* Cleanup already created socket on error. */
- if (consumer_data->err_sock >= 0) {
- int err;
-
- err = close(consumer_data->err_sock);
- if (err < 0) {
- PERROR("close consumer data error socket");
- }
- }
- return ret;
-}
-
-/*
- * Compute health status of each consumer. If one of them is zero (bad
- * state), we return 0.
- */
-static int check_consumer_health(void)
-{
- int ret;
-
- ret = health_check_state(&kconsumer_data.health) &&
- health_check_state(&ustconsumer32_data.health) &&
- health_check_state(&ustconsumer64_data.health);
-
- DBG3("Health consumer check %d", ret);
-
- return ret;
-}
-
-/*
- * Setup necessary data for kernel tracer action.
- */
-static int init_kernel_tracer(void)
-{
- int ret;
-
- /* Modprobe lttng kernel modules */
- ret = modprobe_lttng_control();
- if (ret < 0) {
- goto error;
- }
-
- /* Open debugfs lttng */
- kernel_tracer_fd = open(module_proc_lttng, O_RDWR);
- if (kernel_tracer_fd < 0) {
- DBG("Failed to open %s", module_proc_lttng);
- ret = -1;
- goto error_open;
- }
-
- /* Validate kernel version */
- ret = kernel_validate_version(kernel_tracer_fd);
- if (ret < 0) {
- goto error_version;
- }
-
- ret = modprobe_lttng_data();
- if (ret < 0) {
- goto error_modules;
- }
-
- DBG("Kernel tracer fd %d", kernel_tracer_fd);
- return 0;
-
-error_version:
- modprobe_remove_lttng_control();
- ret = close(kernel_tracer_fd);
- if (ret) {
- PERROR("close");
- }
- kernel_tracer_fd = -1;
- return LTTNG_ERR_KERN_VERSION;
-
-error_modules:
- ret = close(kernel_tracer_fd);
- if (ret) {
- PERROR("close");
- }
-
-error_open:
- modprobe_remove_lttng_control();
-
-error:
- WARN("No kernel tracer available");
- kernel_tracer_fd = -1;
- if (!is_root) {
- return LTTNG_ERR_NEED_ROOT_SESSIOND;
- } else {
- return LTTNG_ERR_KERN_NA;
- }
-}
-
-
-/*
- * Copy consumer output from the tracing session to the domain session. The
- * function also applies the right modification on a per domain basis for the
- * trace files destination directory.
- */
-static int copy_session_consumer(int domain, struct ltt_session *session)
-{
- int ret;
- const char *dir_name;
- struct consumer_output *consumer;
-
- assert(session);
- assert(session->consumer);
-
- switch (domain) {
- case LTTNG_DOMAIN_KERNEL:
- DBG3("Copying tracing session consumer output in kernel session");
- /*
- * XXX: We should audit the session creation and what this function
- * does "extra" in order to avoid a destroy since this function is used
- * in the domain session creation (kernel and ust) only. Same for UST
- * domain.
- */
- if (session->kernel_session->consumer) {
- consumer_destroy_output(session->kernel_session->consumer);
- }
- session->kernel_session->consumer =
- consumer_copy_output(session->consumer);
- /* Ease our life a bit for the next part */
- consumer = session->kernel_session->consumer;
- dir_name = DEFAULT_KERNEL_TRACE_DIR;
- break;
- case LTTNG_DOMAIN_UST:
- DBG3("Copying tracing session consumer output in UST session");
- if (session->ust_session->consumer) {
- consumer_destroy_output(session->ust_session->consumer);
- }
- session->ust_session->consumer =
- consumer_copy_output(session->consumer);
- /* Ease our life a bit for the next part */
- consumer = session->ust_session->consumer;
- dir_name = DEFAULT_UST_TRACE_DIR;
- break;
- default:
- ret = LTTNG_ERR_UNKNOWN_DOMAIN;
- goto error;
- }
-
- /* Append correct directory to subdir */
- strncat(consumer->subdir, dir_name,
- sizeof(consumer->subdir) - strlen(consumer->subdir) - 1);
- DBG3("Copy session consumer subdir %s", consumer->subdir);
-
- ret = LTTNG_OK;
-
-error:
- return ret;
-}
-
-/*
- * Create an UST session and add it to the session ust list.
- */
-static int create_ust_session(struct ltt_session *session,
- struct lttng_domain *domain)
-{
- int ret;
- struct ltt_ust_session *lus = NULL;
-
- assert(session);
- assert(domain);
- assert(session->consumer);
-
- switch (domain->type) {
- case LTTNG_DOMAIN_UST:
- break;
- default:
- ERR("Unknown UST domain on create session %d", domain->type);
- ret = LTTNG_ERR_UNKNOWN_DOMAIN;
- goto error;
- }
-
- DBG("Creating UST session");
-
- lus = trace_ust_create_session(session->path, session->id, domain);
- if (lus == NULL) {
- ret = LTTNG_ERR_UST_SESS_FAIL;
- goto error;
- }
-
- lus->uid = session->uid;
- lus->gid = session->gid;
- session->ust_session = lus;
-
- /* Copy session output to the newly created UST session */
- ret = copy_session_consumer(domain->type, session);
- if (ret != LTTNG_OK) {
- goto error;
- }
-
- return LTTNG_OK;
-
-error:
- free(lus);
- session->ust_session = NULL;
- return ret;
-}
-
-/*
- * Create a kernel tracer session then create the default channel.
- */
-static int create_kernel_session(struct ltt_session *session)
-{
- int ret;
-
- DBG("Creating kernel session");
-
- ret = kernel_create_session(session, kernel_tracer_fd);
- if (ret < 0) {
- ret = LTTNG_ERR_KERN_SESS_FAIL;
- goto error;
- }
-
- /* Code flow safety */
- assert(session->kernel_session);
-
- /* Copy session output to the newly created Kernel session */
- ret = copy_session_consumer(LTTNG_DOMAIN_KERNEL, session);
- if (ret != LTTNG_OK) {
- goto error;
- }
-
- /* Create directory(ies) on local filesystem. */
- if (session->kernel_session->consumer->type == CONSUMER_DST_LOCAL &&
- strlen(session->kernel_session->consumer->dst.trace_path) > 0) {
- ret = run_as_mkdir_recursive(
- session->kernel_session->consumer->dst.trace_path,
- S_IRWXU | S_IRWXG, session->uid, session->gid);
- if (ret < 0) {
- if (ret != -EEXIST) {
- ERR("Trace directory creation error");
- goto error;
- }
- }
- }
-
- session->kernel_session->uid = session->uid;
- session->kernel_session->gid = session->gid;
-
- return LTTNG_OK;
-
-error:
- trace_kernel_destroy_session(session->kernel_session);
- session->kernel_session = NULL;
- return ret;
-}
-
-/*
- * Count number of session permitted by uid/gid.
- */
-static unsigned int lttng_sessions_count(uid_t uid, gid_t gid)
-{
- unsigned int i = 0;
- struct ltt_session *session;
-
- DBG("Counting number of available session for UID %d GID %d",
- uid, gid);
- cds_list_for_each_entry(session, &session_list_ptr->head, list) {
- /*
- * Only list the sessions the user can control.
- */
- if (!session_access_ok(session, uid, gid)) {
- continue;
- }
- i++;
- }
- return i;
-}
-
-/*
- * Process the command requested by the lttng client within the command
- * context structure. This function make sure that the return structure (llm)
- * is set and ready for transmission before returning.
- *
- * Return any error encountered or 0 for success.
- *
- * "sock" is only used for special-case var. len data.
- */
-static int process_client_msg(struct command_ctx *cmd_ctx, int sock,
- int *sock_error)
-{
- int ret = LTTNG_OK;
- int need_tracing_session = 1;
- int need_domain;
-
- DBG("Processing client command %d", cmd_ctx->lsm->cmd_type);
-
- *sock_error = 0;
-
- switch (cmd_ctx->lsm->cmd_type) {
- case LTTNG_CREATE_SESSION:
- case LTTNG_DESTROY_SESSION:
- case LTTNG_LIST_SESSIONS:
- case LTTNG_LIST_DOMAINS:
- case LTTNG_START_TRACE:
- case LTTNG_STOP_TRACE:
- case LTTNG_DATA_PENDING:
- need_domain = 0;
- break;
- default:
- need_domain = 1;
- }
-
- if (opt_no_kernel && need_domain
- && cmd_ctx->lsm->domain.type == LTTNG_DOMAIN_KERNEL) {
- if (!is_root) {
- ret = LTTNG_ERR_NEED_ROOT_SESSIOND;
- } else {
- ret = LTTNG_ERR_KERN_NA;
- }
- goto error;
- }
-
- /* Deny register consumer if we already have a spawned consumer. */
- if (cmd_ctx->lsm->cmd_type == LTTNG_REGISTER_CONSUMER) {
- pthread_mutex_lock(&kconsumer_data.pid_mutex);
- if (kconsumer_data.pid > 0) {
- ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
- pthread_mutex_unlock(&kconsumer_data.pid_mutex);
- goto error;
- }
- pthread_mutex_unlock(&kconsumer_data.pid_mutex);
- }
-
- /*
- * Check for command that don't needs to allocate a returned payload. We do
- * this here so we don't have to make the call for no payload at each
- * command.
- */
- switch(cmd_ctx->lsm->cmd_type) {
- case LTTNG_LIST_SESSIONS:
- case LTTNG_LIST_TRACEPOINTS:
- case LTTNG_LIST_TRACEPOINT_FIELDS:
- case LTTNG_LIST_DOMAINS:
- case LTTNG_LIST_CHANNELS:
- case LTTNG_LIST_EVENTS:
- break;
- default:
- /* Setup lttng message with no payload */
- ret = setup_lttng_msg(cmd_ctx, 0);
- if (ret < 0) {
- /* This label does not try to unlock the session */
- goto init_setup_error;
- }
- }
-
- /* Commands that DO NOT need a session. */
- switch (cmd_ctx->lsm->cmd_type) {
- case LTTNG_CREATE_SESSION:
- case LTTNG_CALIBRATE:
- case LTTNG_LIST_SESSIONS:
- case LTTNG_LIST_TRACEPOINTS:
- case LTTNG_LIST_TRACEPOINT_FIELDS:
- need_tracing_session = 0;
- break;
- default:
- DBG("Getting session %s by name", cmd_ctx->lsm->session.name);
- /*
- * We keep the session list lock across _all_ commands
- * for now, because the per-session lock does not
- * handle teardown properly.
- */
- session_lock_list();
- cmd_ctx->session = session_find_by_name(cmd_ctx->lsm->session.name);
- if (cmd_ctx->session == NULL) {
- if (cmd_ctx->lsm->session.name != NULL) {
- ret = LTTNG_ERR_SESS_NOT_FOUND;
- } else {
- /* If no session name specified */
- ret = LTTNG_ERR_SELECT_SESS;
- }
- goto error;
- } else {
- /* Acquire lock for the session */
- session_lock(cmd_ctx->session);
- }
- break;
- }
-
- if (!need_domain) {
- goto skip_domain;
- }
-
- /*
- * Check domain type for specific "pre-action".
- */
- switch (cmd_ctx->lsm->domain.type) {
- case LTTNG_DOMAIN_KERNEL:
- if (!is_root) {
- ret = LTTNG_ERR_NEED_ROOT_SESSIOND;
- goto error;
- }
-
- /* Kernel tracer check */
- if (kernel_tracer_fd == -1) {
- /* Basically, load kernel tracer modules */
- ret = init_kernel_tracer();
- if (ret != 0) {
- goto error;
- }
- }
-
- /* Consumer is in an ERROR state. Report back to client */
- if (uatomic_read(&kernel_consumerd_state) == CONSUMER_ERROR) {
- ret = LTTNG_ERR_NO_KERNCONSUMERD;
- goto error;
- }
-
- /* Need a session for kernel command */
- if (need_tracing_session) {
- if (cmd_ctx->session->kernel_session == NULL) {
- ret = create_kernel_session(cmd_ctx->session);
- if (ret < 0) {
- ret = LTTNG_ERR_KERN_SESS_FAIL;
- goto error;
- }
- }
-
- /* Start the kernel consumer daemon */
- pthread_mutex_lock(&kconsumer_data.pid_mutex);
- if (kconsumer_data.pid == 0 &&
- cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER &&
- cmd_ctx->session->start_consumer) {
- pthread_mutex_unlock(&kconsumer_data.pid_mutex);
- ret = start_consumerd(&kconsumer_data);
- if (ret < 0) {
- ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
- goto error;
- }
- uatomic_set(&kernel_consumerd_state, CONSUMER_STARTED);
- } else {
- pthread_mutex_unlock(&kconsumer_data.pid_mutex);
- }
-
- /*
- * The consumer was just spawned so we need to add the socket to
- * the consumer output of the session if exist.
- */
- ret = consumer_create_socket(&kconsumer_data,
- cmd_ctx->session->kernel_session->consumer);
- if (ret < 0) {
- goto error;
- }
- }
-
- break;
- case LTTNG_DOMAIN_UST:
- {
- /* Consumer is in an ERROR state. Report back to client */
- if (uatomic_read(&ust_consumerd_state) == CONSUMER_ERROR) {
- ret = LTTNG_ERR_NO_USTCONSUMERD;
- goto error;
- }
-
- if (need_tracing_session) {
- /* Create UST session if none exist. */
- if (cmd_ctx->session->ust_session == NULL) {
- ret = create_ust_session(cmd_ctx->session,
- &cmd_ctx->lsm->domain);
- if (ret != LTTNG_OK) {
- goto error;
- }
- }
-
- /* Start the UST consumer daemons */
- /* 64-bit */
- pthread_mutex_lock(&ustconsumer64_data.pid_mutex);
- if (consumerd64_bin[0] != '\0' &&
- ustconsumer64_data.pid == 0 &&
- cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER &&
- cmd_ctx->session->start_consumer) {
- pthread_mutex_unlock(&ustconsumer64_data.pid_mutex);
- ret = start_consumerd(&ustconsumer64_data);
- if (ret < 0) {
- ret = LTTNG_ERR_UST_CONSUMER64_FAIL;
- uatomic_set(&ust_consumerd64_fd, -EINVAL);
- goto error;
- }
-
- uatomic_set(&ust_consumerd64_fd, ustconsumer64_data.cmd_sock);
- uatomic_set(&ust_consumerd_state, CONSUMER_STARTED);
- } else {
- pthread_mutex_unlock(&ustconsumer64_data.pid_mutex);
- }
-
- /*
- * Setup socket for consumer 64 bit. No need for atomic access
- * since it was set above and can ONLY be set in this thread.
- */
- ret = consumer_create_socket(&ustconsumer64_data,
- cmd_ctx->session->ust_session->consumer);
- if (ret < 0) {
- goto error;
- }
-
- /* 32-bit */
- if (consumerd32_bin[0] != '\0' &&
- ustconsumer32_data.pid == 0 &&
- cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER &&
- cmd_ctx->session->start_consumer) {
- pthread_mutex_unlock(&ustconsumer32_data.pid_mutex);
- ret = start_consumerd(&ustconsumer32_data);
- if (ret < 0) {
- ret = LTTNG_ERR_UST_CONSUMER32_FAIL;
- uatomic_set(&ust_consumerd32_fd, -EINVAL);
- goto error;
- }
-
- uatomic_set(&ust_consumerd32_fd, ustconsumer32_data.cmd_sock);
- uatomic_set(&ust_consumerd_state, CONSUMER_STARTED);
- } else {
- pthread_mutex_unlock(&ustconsumer32_data.pid_mutex);
- }
-
- /*
- * Setup socket for consumer 64 bit. No need for atomic access
- * since it was set above and can ONLY be set in this thread.
- */
- ret = consumer_create_socket(&ustconsumer32_data,
- cmd_ctx->session->ust_session->consumer);
- if (ret < 0) {
- goto error;
- }