Cleanup: rename session list count to "next_uuid"
[lttng-tools.git] / src / bin / lttng-sessiond / main.c
CommitLineData
826d496d
MD
1/*
2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
0fdd1e2c 3 * Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
fac6795d 4 *
d14d33bf
AM
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License, version 2 only,
7 * as published by the Free Software Foundation.
91d76f53 8 *
d14d33bf
AM
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
91d76f53 13 *
d14d33bf
AM
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
fac6795d
DG
17 */
18
19#define _GNU_SOURCE
fac6795d
DG
20#include <getopt.h>
21#include <grp.h>
22#include <limits.h>
23#include <pthread.h>
8c0faa1d 24#include <semaphore.h>
fac6795d
DG
25#include <signal.h>
26#include <stdio.h>
27#include <stdlib.h>
28#include <string.h>
0fdd1e2c 29#include <sys/mman.h>
b73401da 30#include <sys/mount.h>
1e307fab 31#include <sys/resource.h>
fac6795d
DG
32#include <sys/socket.h>
33#include <sys/stat.h>
34#include <sys/types.h>
0fdd1e2c 35#include <sys/wait.h>
5c827ce0 36#include <urcu/uatomic.h>
fac6795d 37#include <unistd.h>
3bd1e081 38#include <config.h>
fac6795d 39
990570ed 40#include <common/common.h>
0ba98ebc 41#include <common/compat/poll.h>
d27c42b8 42#include <common/compat/socket.h>
db758600
DG
43#include <common/defaults.h>
44#include <common/kernel-consumer/kernel-consumer.h>
50c8f484 45#include <common/futex.h>
00e2e675 46#include <common/relayd/relayd.h>
fac6795d 47
10a8a223 48#include "lttng-sessiond.h"
54d01ffb 49#include "channel.h"
00e2e675 50#include "consumer.h"
099e26bd 51#include "context.h"
54d01ffb 52#include "event.h"
4771f025 53#include "kernel.h"
f1e16794 54#include "kernel-consumer.h"
096102bd 55#include "modprobe.h"
0fdd1e2c 56#include "shm.h"
1e307fab 57#include "ust-ctl.h"
00e2e675 58#include "ust-consumer.h"
8e68d1c8 59#include "utils.h"
4063050c 60#include "fd-limit.h"
53a80697 61#include "filter.h"
fac6795d 62
ebaeda94
MD
63#define CONSUMERD_FILE "lttng-consumerd"
64
75462a81 65/* Const values */
686204ab 66const char default_home_dir[] = DEFAULT_HOME_DIR;
bbccc3d2 67const char default_tracing_group[] = DEFAULT_TRACING_GROUP;
686204ab
MD
68const char default_ust_sock_dir[] = DEFAULT_UST_SOCK_DIR;
69const char default_global_apps_pipe[] = DEFAULT_GLOBAL_APPS_PIPE;
70
fac6795d
DG
71const char *progname;
72const char *opt_tracing_group;
5b8719f5 73static int opt_sig_parent;
97e19046 74static int opt_verbose_consumer;
fac6795d 75static int opt_daemon;
4fba7219 76static int opt_no_kernel;
fac6795d 77static int is_root; /* Set to 1 if the daemon is running as root */
1d4b027a 78static pid_t ppid; /* Parent PID for --sig-parent option */
67e40797 79static char *rundir;
3bd1e081
MD
80
81/* Consumer daemon specific control data */
82static struct consumer_data kconsumer_data = {
83 .type = LTTNG_CONSUMER_KERNEL,
60922cb0
DG
84 .err_unix_sock_path = DEFAULT_KCONSUMERD_ERR_SOCK_PATH,
85 .cmd_unix_sock_path = DEFAULT_KCONSUMERD_CMD_SOCK_PATH,
03550b58
MD
86 .err_sock = -1,
87 .cmd_sock = -1,
3bd1e081 88};
7753dea8
MD
89static struct consumer_data ustconsumer64_data = {
90 .type = LTTNG_CONSUMER64_UST,
60922cb0
DG
91 .err_unix_sock_path = DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH,
92 .cmd_unix_sock_path = DEFAULT_USTCONSUMERD64_CMD_SOCK_PATH,
03550b58
MD
93 .err_sock = -1,
94 .cmd_sock = -1,
7753dea8
MD
95};
96static struct consumer_data ustconsumer32_data = {
97 .type = LTTNG_CONSUMER32_UST,
60922cb0
DG
98 .err_unix_sock_path = DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH,
99 .cmd_unix_sock_path = DEFAULT_USTCONSUMERD32_CMD_SOCK_PATH,
03550b58
MD
100 .err_sock = -1,
101 .cmd_sock = -1,
3bd1e081
MD
102};
103
099e26bd 104static int dispatch_thread_exit;
fac6795d 105
54d01ffb
DG
106/* Global application Unix socket path */
107static char apps_unix_sock_path[PATH_MAX];
108/* Global client Unix socket path */
109static char client_unix_sock_path[PATH_MAX];
54d01ffb
DG
110/* global wait shm path for UST */
111static char wait_shm_path[PATH_MAX];
fac6795d 112
1d4b027a 113/* Sockets and FDs */
a4b35e07
MD
114static int client_sock = -1;
115static int apps_sock = -1;
116static int kernel_tracer_fd = -1;
76d7553f 117static int kernel_poll_pipe[2] = { -1, -1 };
1d4b027a 118
273ea72c
DG
119/*
120 * Quit pipe for all threads. This permits a single cancellation point
121 * for all threads when receiving an event on the pipe.
122 */
76d7553f 123static int thread_quit_pipe[2] = { -1, -1 };
273ea72c 124
099e26bd
DG
125/*
126 * This pipe is used to inform the thread managing application communication
127 * that a command is queued and ready to be processed.
128 */
76d7553f 129static int apps_cmd_pipe[2] = { -1, -1 };
099e26bd 130
1d4b027a 131/* Pthread, Mutexes and Semaphores */
1d4b027a 132static pthread_t apps_thread;
099e26bd 133static pthread_t reg_apps_thread;
1d4b027a 134static pthread_t client_thread;
7a485870 135static pthread_t kernel_thread;
099e26bd 136static pthread_t dispatch_thread;
5eb91c98 137
099e26bd
DG
138/*
139 * UST registration command queue. This queue is tied with a futex and uses a N
140 * wakers / 1 waiter implemented and detailed in futex.c/.h
141 *
142 * The thread_manage_apps and thread_dispatch_ust_registration interact with
143 * this queue and the wait/wake scheme.
144 */
145static struct ust_cmd_queue ust_cmd_queue;
146
b5541356
DG
147/*
148 * Pointer initialized before thread creation.
149 *
150 * This points to the tracing session list containing the session count and a
151 * mutex lock. The lock MUST be taken if you iterate over the list. The lock
152 * MUST NOT be taken if you call a public function in session.c.
04ea676f 153 *
d063d709 154 * The lock is nested inside the structure: session_list_ptr->lock. Please use
54d01ffb 155 * session_lock_list and session_unlock_list for lock acquisition.
b5541356
DG
156 */
157static struct ltt_session_list *session_list_ptr;
158
7753dea8
MD
159int ust_consumerd64_fd = -1;
160int ust_consumerd32_fd = -1;
161
fb6f1fa2
YB
162static const char *consumerd32_bin = CONFIG_CONSUMERD32_BIN;
163static const char *consumerd64_bin = CONFIG_CONSUMERD64_BIN;
164static const char *consumerd32_libdir = CONFIG_CONSUMERD32_LIBDIR;
165static const char *consumerd64_libdir = CONFIG_CONSUMERD64_LIBDIR;
fb09408a 166
5c827ce0
DG
167/*
168 * Consumer daemon state which is changed when spawning it, killing it or in
169 * case of a fatal error.
170 */
171enum consumerd_state {
172 CONSUMER_STARTED = 1,
173 CONSUMER_STOPPED = 2,
174 CONSUMER_ERROR = 3,
175};
176
177/*
178 * This consumer daemon state is used to validate if a client command will be
179 * able to reach the consumer. If not, the client is informed. For instance,
180 * doing a "lttng start" when the consumer state is set to ERROR will return an
181 * error to the client.
182 *
183 * The following example shows a possible race condition of this scheme:
184 *
185 * consumer thread error happens
186 * client cmd arrives
187 * client cmd checks state -> still OK
188 * consumer thread exit, sets error
189 * client cmd try to talk to consumer
190 * ...
191 *
192 * However, since the consumer is a different daemon, we have no way of making
193 * sure the command will reach it safely even with this state flag. This is why
194 * we consider that up to the state validation during command processing, the
195 * command is safe. After that, we can not guarantee the correctness of the
196 * client request vis-a-vis the consumer.
197 */
198static enum consumerd_state ust_consumerd_state;
199static enum consumerd_state kernel_consumerd_state;
200
00e2e675
DG
201/*
202 * Used to keep a unique index for each relayd socket created where this value
203 * is associated with streams on the consumer so it can match the right relayd
204 * to send to.
205 *
206 * This value should be incremented atomically for safety purposes and future
207 * possible concurrent access.
208 */
209static unsigned int relayd_net_seq_idx;
210
fb09408a 211static
7753dea8 212void setup_consumerd_path(void)
fb09408a 213{
fc7a59ce 214 const char *bin, *libdir;
fb09408a 215
7753dea8
MD
216 /*
217 * Allow INSTALL_BIN_PATH to be used as a target path for the
ebaeda94
MD
218 * native architecture size consumer if CONFIG_CONSUMER*_PATH
219 * has not been defined.
7753dea8 220 */
ebaeda94 221#if (CAA_BITS_PER_LONG == 32)
fc7a59ce
AM
222 if (!consumerd32_bin[0]) {
223 consumerd32_bin = INSTALL_BIN_PATH "/" CONSUMERD_FILE;
ebaeda94
MD
224 }
225 if (!consumerd32_libdir[0]) {
226 consumerd32_libdir = INSTALL_LIB_PATH;
227 }
228#elif (CAA_BITS_PER_LONG == 64)
fc7a59ce
AM
229 if (!consumerd64_bin[0]) {
230 consumerd64_bin = INSTALL_BIN_PATH "/" CONSUMERD_FILE;
7753dea8 231 }
ebaeda94
MD
232 if (!consumerd64_libdir[0]) {
233 consumerd64_libdir = INSTALL_LIB_PATH;
7753dea8
MD
234 }
235#else
236#error "Unknown bitness"
237#endif
238
fb09408a
MD
239 /*
240 * runtime env. var. overrides the build default.
241 */
fc7a59ce
AM
242 bin = getenv("LTTNG_CONSUMERD32_BIN");
243 if (bin) {
244 consumerd32_bin = bin;
7753dea8 245 }
fc7a59ce
AM
246 bin = getenv("LTTNG_CONSUMERD64_BIN");
247 if (bin) {
248 consumerd64_bin = bin;
ebaeda94 249 }
72f579ee 250 libdir = getenv("LTTNG_CONSUMERD32_LIBDIR");
ebaeda94
MD
251 if (libdir) {
252 consumerd32_libdir = libdir;
253 }
72f579ee 254 libdir = getenv("LTTNG_CONSUMERD64_LIBDIR");
ebaeda94
MD
255 if (libdir) {
256 consumerd64_libdir = libdir;
fb09408a
MD
257 }
258}
259
5eb91c98
DG
260/*
261 * Create a poll set with O_CLOEXEC and add the thread quit pipe to the set.
262 */
263static int create_thread_poll_set(struct lttng_poll_event *events,
264 unsigned int size)
265{
266 int ret;
267
268 if (events == NULL || size == 0) {
269 ret = -1;
270 goto error;
271 }
272
273 ret = lttng_poll_create(events, size, LTTNG_CLOEXEC);
274 if (ret < 0) {
275 goto error;
276 }
277
278 /* Add quit pipe */
279 ret = lttng_poll_add(events, thread_quit_pipe[0], LPOLLIN);
280 if (ret < 0) {
281 goto error;
282 }
283
284 return 0;
285
286error:
287 return ret;
288}
289
290/*
291 * Check if the thread quit pipe was triggered.
292 *
293 * Return 1 if it was triggered else 0;
294 */
295static int check_thread_quit_pipe(int fd, uint32_t events)
296{
297 if (fd == thread_quit_pipe[0] && (events & LPOLLIN)) {
298 return 1;
299 }
300
301 return 0;
302}
303
0fdd1e2c
DG
304/*
305 * Return group ID of the tracing group or -1 if not found.
306 */
996b65c8
MD
307static gid_t allowed_group(void)
308{
309 struct group *grp;
310
274e143b
MD
311 if (opt_tracing_group) {
312 grp = getgrnam(opt_tracing_group);
313 } else {
314 grp = getgrnam(default_tracing_group);
315 }
996b65c8
MD
316 if (!grp) {
317 return -1;
318 } else {
319 return grp->gr_gid;
320 }
321}
322
273ea72c 323/*
5eb91c98 324 * Init thread quit pipe.
273ea72c
DG
325 *
326 * Return -1 on error or 0 if all pipes are created.
327 */
328static int init_thread_quit_pipe(void)
329{
730389d9 330 int ret, i;
273ea72c 331
730389d9 332 ret = pipe(thread_quit_pipe);
273ea72c 333 if (ret < 0) {
730389d9 334 PERROR("thread quit pipe");
273ea72c
DG
335 goto error;
336 }
337
730389d9
DG
338 for (i = 0; i < 2; i++) {
339 ret = fcntl(thread_quit_pipe[i], F_SETFD, FD_CLOEXEC);
340 if (ret < 0) {
341 PERROR("fcntl");
342 goto error;
343 }
344 }
345
273ea72c
DG
346error:
347 return ret;
348}
349
fac6795d 350/*
d063d709
DG
351 * Complete teardown of a kernel session. This free all data structure related
352 * to a kernel session and update counter.
fac6795d 353 */
1d4b027a 354static void teardown_kernel_session(struct ltt_session *session)
fac6795d 355{
8f7a84dd 356 if (!session->kernel_session) {
99bab54f 357 DBG3("No kernel session when tearing down session");
84ea9c99 358 return;
8f7a84dd
DG
359 }
360
84ea9c99 361 DBG("Tearing down kernel session");
d9800920 362
84ea9c99
MD
363 /*
364 * If a custom kernel consumer was registered, close the socket before
365 * tearing down the complete kernel session structure
366 */
03550b58
MD
367 if (kconsumer_data.cmd_sock >= 0 &&
368 session->kernel_session->consumer_fd != kconsumer_data.cmd_sock) {
84ea9c99 369 lttcomm_close_unix_sock(session->kernel_session->consumer_fd);
fac6795d 370 }
84ea9c99
MD
371
372 trace_kernel_destroy_session(session->kernel_session);
fac6795d
DG
373}
374
f6a9efaa
DG
375/*
376 * Complete teardown of all UST sessions. This will free everything on his path
377 * and destroy the core essence of all ust sessions :)
378 */
379static void teardown_ust_session(struct ltt_session *session)
380{
84cd17c6
MD
381 int ret;
382
8f7a84dd 383 if (!session->ust_session) {
99bab54f 384 DBG3("No UST session when tearing down session");
f470a390 385 return;
8f7a84dd
DG
386 }
387
84ea9c99 388 DBG("Tearing down UST session(s)");
8f7a84dd 389
84cd17c6
MD
390 ret = ust_app_destroy_trace_all(session->ust_session);
391 if (ret) {
392 ERR("Error in ust_app_destroy_trace_all");
393 }
8f7a84dd 394
f6a9efaa
DG
395 trace_ust_destroy_session(session->ust_session);
396}
397
099e26bd
DG
398/*
399 * Stop all threads by closing the thread quit pipe.
400 */
cf3af59e
MD
401static void stop_threads(void)
402{
5eb91c98
DG
403 int ret;
404
cf3af59e
MD
405 /* Stopping all threads */
406 DBG("Terminating all threads");
54d01ffb 407 ret = notify_thread_pipe(thread_quit_pipe[1]);
5eb91c98
DG
408 if (ret < 0) {
409 ERR("write error on thread quit pipe");
410 }
411
099e26bd
DG
412 /* Dispatch thread */
413 dispatch_thread_exit = 1;
414 futex_nto1_wake(&ust_cmd_queue.futex);
cf3af59e
MD
415}
416
fac6795d 417/*
d063d709 418 * Cleanup the daemon
fac6795d 419 */
cf3af59e 420static void cleanup(void)
fac6795d 421{
ef599319 422 int ret;
1d4b027a 423 char *cmd;
af9737e9 424 struct ltt_session *sess, *stmp;
fac6795d 425
1d4b027a 426 DBG("Cleaning up");
e07ae692 427
67e40797
DG
428 DBG("Removing %s directory", rundir);
429 ret = asprintf(&cmd, "rm -rf %s", rundir);
430 if (ret < 0) {
431 ERR("asprintf failed. Something is really wrong!");
432 }
5461b305 433
67e40797
DG
434 /* Remove lttng run directory */
435 ret = system(cmd);
436 if (ret < 0) {
437 ERR("Unable to clean %s", rundir);
1d4b027a 438 }
67e40797 439 free(cmd);
5461b305 440
99bab54f 441 DBG("Cleaning up all sessions");
fac6795d 442
b5541356 443 /* Destroy session list mutex */
273ea72c
DG
444 if (session_list_ptr != NULL) {
445 pthread_mutex_destroy(&session_list_ptr->lock);
446
447 /* Cleanup ALL session */
54d01ffb
DG
448 cds_list_for_each_entry_safe(sess, stmp,
449 &session_list_ptr->head, list) {
273ea72c 450 teardown_kernel_session(sess);
f6a9efaa
DG
451 teardown_ust_session(sess);
452 free(sess);
273ea72c
DG
453 }
454 }
455
099e26bd 456 DBG("Closing all UST sockets");
56fff090 457 ust_app_clean_list();
099e26bd 458
3bd1e081 459 pthread_mutex_destroy(&kconsumer_data.pid_mutex);
b5541356 460
4fba7219
DG
461 if (is_root && !opt_no_kernel) {
462 DBG2("Closing kernel fd");
a4b35e07 463 if (kernel_tracer_fd >= 0) {
76d7553f
MD
464 ret = close(kernel_tracer_fd);
465 if (ret) {
466 PERROR("close");
467 }
a4b35e07 468 }
2f50c8a3 469 DBG("Unloading kernel modules");
096102bd 470 modprobe_remove_lttng_all();
2f50c8a3 471 }
ef599319
DG
472 utils_close_pipe(kernel_poll_pipe);
473 utils_close_pipe(thread_quit_pipe);
474 utils_close_pipe(apps_cmd_pipe);
421cb601
DG
475
476 /* <fun> */
f56a39af 477 DBG("%c[%d;%dm*** assert failed :-) *** ==> %c[%dm%c[%d;%dm"
421cb601
DG
478 "Matthew, BEET driven development works!%c[%dm",
479 27, 1, 31, 27, 0, 27, 1, 33, 27, 0);
480 /* </fun> */
fac6795d
DG
481}
482
e065084a 483/*
d063d709 484 * Send data on a unix socket using the liblttsessiondcomm API.
e065084a 485 *
d063d709 486 * Return lttcomm error code.
e065084a
DG
487 */
488static int send_unix_sock(int sock, void *buf, size_t len)
489{
490 /* Check valid length */
491 if (len <= 0) {
492 return -1;
493 }
494
495 return lttcomm_send_unix_sock(sock, buf, len);
496}
497
5461b305 498/*
d063d709 499 * Free memory of a command context structure.
5461b305 500 */
a2fb29a5 501static void clean_command_ctx(struct command_ctx **cmd_ctx)
5461b305 502{
a2fb29a5
DG
503 DBG("Clean command context structure");
504 if (*cmd_ctx) {
505 if ((*cmd_ctx)->llm) {
506 free((*cmd_ctx)->llm);
5461b305 507 }
a2fb29a5
DG
508 if ((*cmd_ctx)->lsm) {
509 free((*cmd_ctx)->lsm);
5461b305 510 }
a2fb29a5
DG
511 free(*cmd_ctx);
512 *cmd_ctx = NULL;
5461b305
DG
513 }
514}
515
fac6795d 516/*
0fdd1e2c 517 * Notify UST applications using the shm mmap futex.
fac6795d 518 */
0fdd1e2c 519static int notify_ust_apps(int active)
fac6795d 520{
0fdd1e2c 521 char *wait_shm_mmap;
fac6795d 522
0fdd1e2c 523 DBG("Notifying applications of session daemon state: %d", active);
e07ae692 524
0fdd1e2c
DG
525 /* See shm.c for this call implying mmap, shm and futex calls */
526 wait_shm_mmap = shm_ust_get_mmap(wait_shm_path, is_root);
527 if (wait_shm_mmap == NULL) {
fac6795d
DG
528 goto error;
529 }
530
0fdd1e2c
DG
531 /* Wake waiting process */
532 futex_wait_update((int32_t *) wait_shm_mmap, active);
533
534 /* Apps notified successfully */
535 return 0;
fac6795d
DG
536
537error:
0fdd1e2c 538 return -1;
fac6795d
DG
539}
540
e065084a 541/*
d063d709
DG
542 * Setup the outgoing data buffer for the response (llm) by allocating the
543 * right amount of memory and copying the original information from the lsm
544 * structure.
ca95a216 545 *
d063d709 546 * Return total size of the buffer pointed by buf.
ca95a216 547 */
5461b305 548static int setup_lttng_msg(struct command_ctx *cmd_ctx, size_t size)
ca95a216 549{
f3ed775e 550 int ret, buf_size;
ca95a216 551
f3ed775e 552 buf_size = size;
5461b305 553
ba7f0ae5 554 cmd_ctx->llm = zmalloc(sizeof(struct lttcomm_lttng_msg) + buf_size);
5461b305 555 if (cmd_ctx->llm == NULL) {
76d7553f 556 PERROR("zmalloc");
5461b305 557 ret = -ENOMEM;
ca95a216
DG
558 goto error;
559 }
560
5461b305
DG
561 /* Copy common data */
562 cmd_ctx->llm->cmd_type = cmd_ctx->lsm->cmd_type;
9f19cc17 563 cmd_ctx->llm->pid = cmd_ctx->lsm->domain.attr.pid;
5461b305 564
5461b305
DG
565 cmd_ctx->llm->data_size = size;
566 cmd_ctx->lttng_msg_size = sizeof(struct lttcomm_lttng_msg) + buf_size;
567
ca95a216
DG
568 return buf_size;
569
570error:
571 return ret;
572}
573
7a485870 574/*
5eb91c98 575 * Update the kernel poll set of all channel fd available over all tracing
d063d709 576 * session. Add the wakeup pipe at the end of the set.
7a485870 577 */
5eb91c98 578static int update_kernel_poll(struct lttng_poll_event *events)
7a485870 579{
5eb91c98 580 int ret;
7a485870
DG
581 struct ltt_session *session;
582 struct ltt_kernel_channel *channel;
583
5eb91c98 584 DBG("Updating kernel poll set");
7a485870 585
54d01ffb 586 session_lock_list();
b5541356 587 cds_list_for_each_entry(session, &session_list_ptr->head, list) {
54d01ffb 588 session_lock(session);
7a485870 589 if (session->kernel_session == NULL) {
54d01ffb 590 session_unlock(session);
7a485870
DG
591 continue;
592 }
7a485870 593
54d01ffb
DG
594 cds_list_for_each_entry(channel,
595 &session->kernel_session->channel_list.head, list) {
5eb91c98
DG
596 /* Add channel fd to the kernel poll set */
597 ret = lttng_poll_add(events, channel->fd, LPOLLIN | LPOLLRDNORM);
598 if (ret < 0) {
54d01ffb 599 session_unlock(session);
5eb91c98
DG
600 goto error;
601 }
602 DBG("Channel fd %d added to kernel set", channel->fd);
7a485870 603 }
54d01ffb 604 session_unlock(session);
7a485870 605 }
54d01ffb 606 session_unlock_list();
7a485870 607
5eb91c98 608 return 0;
7a485870
DG
609
610error:
54d01ffb 611 session_unlock_list();
7a485870
DG
612 return -1;
613}
614
615/*
54d01ffb 616 * Find the channel fd from 'fd' over all tracing session. When found, check
d063d709 617 * for new channel stream and send those stream fds to the kernel consumer.
7a485870 618 *
d063d709 619 * Useful for CPU hotplug feature.
7a485870 620 */
2bdd86d4 621static int update_kernel_stream(struct consumer_data *consumer_data, int fd)
7a485870
DG
622{
623 int ret = 0;
624 struct ltt_session *session;
625 struct ltt_kernel_channel *channel;
626
627 DBG("Updating kernel streams for channel fd %d", fd);
628
54d01ffb 629 session_lock_list();
b5541356 630 cds_list_for_each_entry(session, &session_list_ptr->head, list) {
54d01ffb 631 session_lock(session);
7a485870 632 if (session->kernel_session == NULL) {
54d01ffb 633 session_unlock(session);
7a485870
DG
634 continue;
635 }
d9800920 636
03550b58
MD
637 /* This is not suppose to be -1 but this is an extra security check */
638 if (session->kernel_session->consumer_fd < 0) {
3bd1e081 639 session->kernel_session->consumer_fd = consumer_data->cmd_sock;
d9800920
DG
640 }
641
5eb91c98
DG
642 cds_list_for_each_entry(channel,
643 &session->kernel_session->channel_list.head, list) {
7a485870
DG
644 if (channel->fd == fd) {
645 DBG("Channel found, updating kernel streams");
646 ret = kernel_open_channel_stream(channel);
647 if (ret < 0) {
b3c750d2 648 goto error;
7a485870 649 }
d9800920 650
7a485870 651 /*
5eb91c98
DG
652 * Have we already sent fds to the consumer? If yes, it means
653 * that tracing is started so it is safe to send our updated
654 * stream fds.
7a485870 655 */
00e2e675
DG
656 if (session->kernel_session->consumer_fds_sent == 1 &&
657 session->kernel_session->consumer != NULL) {
658 ret = kernel_consumer_send_channel_stream(
659 session->kernel_session->consumer_fd, channel,
660 session->kernel_session);
7a485870 661 if (ret < 0) {
b3c750d2 662 goto error;
7a485870
DG
663 }
664 }
b3c750d2 665 goto error;
7a485870
DG
666 }
667 }
54d01ffb 668 session_unlock(session);
7a485870 669 }
54d01ffb 670 session_unlock_list();
b3c750d2 671 return ret;
7a485870 672
b3c750d2 673error:
54d01ffb
DG
674 session_unlock(session);
675 session_unlock_list();
7a485870
DG
676 return ret;
677}
678
487cf67c
DG
679/*
680 * For each tracing session, update newly registered apps.
681 */
682static void update_ust_app(int app_sock)
683{
684 struct ltt_session *sess, *stmp;
685
4ee14516
DG
686 session_lock_list();
687
487cf67c
DG
688 /* For all tracing session(s) */
689 cds_list_for_each_entry_safe(sess, stmp, &session_list_ptr->head, list) {
4ee14516 690 session_lock(sess);
421cb601
DG
691 if (sess->ust_session) {
692 ust_app_global_update(sess->ust_session, app_sock);
693 }
4ee14516 694 session_unlock(sess);
487cf67c 695 }
4ee14516
DG
696
697 session_unlock_list();
487cf67c
DG
698}
699
7a485870 700/*
d063d709 701 * This thread manage event coming from the kernel.
7a485870 702 *
d063d709
DG
703 * Features supported in this thread:
704 * -) CPU Hotplug
7a485870
DG
705 */
706static void *thread_manage_kernel(void *data)
707{
5eb91c98
DG
708 int ret, i, pollfd, update_poll_flag = 1;
709 uint32_t revents, nb_fd;
7a485870 710 char tmp;
5eb91c98 711 struct lttng_poll_event events;
7a485870
DG
712
713 DBG("Thread manage kernel started");
714
5eb91c98
DG
715 ret = create_thread_poll_set(&events, 2);
716 if (ret < 0) {
76d7553f 717 goto error_poll_create;
5eb91c98
DG
718 }
719
720 ret = lttng_poll_add(&events, kernel_poll_pipe[0], LPOLLIN);
721 if (ret < 0) {
722 goto error;
723 }
724
7a485870
DG
725 while (1) {
726 if (update_poll_flag == 1) {
5f822d0a
DG
727 /*
728 * Reset number of fd in the poll set. Always 2 since there is the thread
729 * quit pipe and the kernel pipe.
730 */
731 events.nb_fd = 2;
732
5eb91c98
DG
733 ret = update_kernel_poll(&events);
734 if (ret < 0) {
7a485870
DG
735 goto error;
736 }
737 update_poll_flag = 0;
738 }
739
5eb91c98
DG
740 nb_fd = LTTNG_POLL_GETNB(&events);
741
742 DBG("Thread kernel polling on %d fds", nb_fd);
743
744 /* Zeroed the poll events */
745 lttng_poll_reset(&events);
7a485870
DG
746
747 /* Poll infinite value of time */
88f2b785 748 restart:
5eb91c98 749 ret = lttng_poll_wait(&events, -1);
7a485870 750 if (ret < 0) {
88f2b785
MD
751 /*
752 * Restart interrupted system call.
753 */
754 if (errno == EINTR) {
755 goto restart;
756 }
7a485870
DG
757 goto error;
758 } else if (ret == 0) {
759 /* Should not happen since timeout is infinite */
85611738
DG
760 ERR("Return value of poll is 0 with an infinite timeout.\n"
761 "This should not have happened! Continuing...");
7a485870
DG
762 continue;
763 }
764
5eb91c98
DG
765 for (i = 0; i < nb_fd; i++) {
766 /* Fetch once the poll data */
767 revents = LTTNG_POLL_GETEV(&events, i);
768 pollfd = LTTNG_POLL_GETFD(&events, i);
7a485870 769
5eb91c98
DG
770 /* Thread quit pipe has been closed. Killing thread. */
771 ret = check_thread_quit_pipe(pollfd, revents);
772 if (ret) {
773 goto error;
774 }
7a485870 775
5eb91c98
DG
776 /* Check for data on kernel pipe */
777 if (pollfd == kernel_poll_pipe[0] && (revents & LPOLLIN)) {
778 ret = read(kernel_poll_pipe[0], &tmp, 1);
779 update_poll_flag = 1;
780 continue;
781 } else {
782 /*
783 * New CPU detected by the kernel. Adding kernel stream to
784 * kernel session and updating the kernel consumer
785 */
786 if (revents & LPOLLIN) {
2bdd86d4 787 ret = update_kernel_stream(&kconsumer_data, pollfd);
5eb91c98
DG
788 if (ret < 0) {
789 continue;
790 }
791 break;
792 /*
793 * TODO: We might want to handle the LPOLLERR | LPOLLHUP
794 * and unregister kernel stream at this point.
795 */
7a485870 796 }
7a485870
DG
797 }
798 }
799 }
800
801error:
5eb91c98 802 lttng_poll_clean(&events);
76d7553f
MD
803error_poll_create:
804 DBG("Kernel thread dying");
7a485870
DG
805 return NULL;
806}
807
1d4b027a 808/*
3bd1e081 809 * This thread manage the consumer error sent back to the session daemon.
1d4b027a 810 */
3bd1e081 811static void *thread_manage_consumer(void *data)
1d4b027a 812{
76d7553f 813 int sock = -1, i, ret, pollfd;
5eb91c98 814 uint32_t revents, nb_fd;
1d4b027a 815 enum lttcomm_return_code code;
5eb91c98 816 struct lttng_poll_event events;
3bd1e081 817 struct consumer_data *consumer_data = data;
1d4b027a 818
3bd1e081 819 DBG("[thread] Manage consumer started");
1d4b027a 820
3bd1e081 821 ret = lttcomm_listen_unix_sock(consumer_data->err_sock);
1d4b027a 822 if (ret < 0) {
76d7553f 823 goto error_listen;
1d4b027a
DG
824 }
825
5eb91c98
DG
826 /*
827 * Pass 2 as size here for the thread quit pipe and kconsumerd_err_sock.
828 * Nothing more will be added to this poll set.
829 */
830 ret = create_thread_poll_set(&events, 2);
831 if (ret < 0) {
76d7553f 832 goto error_poll;
5eb91c98 833 }
273ea72c 834
3bd1e081 835 ret = lttng_poll_add(&events, consumer_data->err_sock, LPOLLIN | LPOLLRDHUP);
5eb91c98
DG
836 if (ret < 0) {
837 goto error;
838 }
839
840 nb_fd = LTTNG_POLL_GETNB(&events);
273ea72c
DG
841
842 /* Inifinite blocking call, waiting for transmission */
88f2b785 843restart:
5eb91c98 844 ret = lttng_poll_wait(&events, -1);
273ea72c 845 if (ret < 0) {
88f2b785
MD
846 /*
847 * Restart interrupted system call.
848 */
849 if (errno == EINTR) {
850 goto restart;
851 }
273ea72c
DG
852 goto error;
853 }
854
5eb91c98
DG
855 for (i = 0; i < nb_fd; i++) {
856 /* Fetch once the poll data */
857 revents = LTTNG_POLL_GETEV(&events, i);
858 pollfd = LTTNG_POLL_GETFD(&events, i);
859
860 /* Thread quit pipe has been closed. Killing thread. */
861 ret = check_thread_quit_pipe(pollfd, revents);
862 if (ret) {
863 goto error;
864 }
865
866 /* Event on the registration socket */
3bd1e081 867 if (pollfd == consumer_data->err_sock) {
5eb91c98 868 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
3bd1e081 869 ERR("consumer err socket poll error");
5eb91c98
DG
870 goto error;
871 }
872 }
273ea72c
DG
873 }
874
3bd1e081 875 sock = lttcomm_accept_unix_sock(consumer_data->err_sock);
1d4b027a
DG
876 if (sock < 0) {
877 goto error;
878 }
879
3bd1e081 880 DBG2("Receiving code from consumer err_sock");
ee0b0061 881
712ea556 882 /* Getting status code from kconsumerd */
54d01ffb
DG
883 ret = lttcomm_recv_unix_sock(sock, &code,
884 sizeof(enum lttcomm_return_code));
1d4b027a
DG
885 if (ret <= 0) {
886 goto error;
887 }
888
3bd1e081
MD
889 if (code == CONSUMERD_COMMAND_SOCK_READY) {
890 consumer_data->cmd_sock =
891 lttcomm_connect_unix_sock(consumer_data->cmd_unix_sock_path);
892 if (consumer_data->cmd_sock < 0) {
893 sem_post(&consumer_data->sem);
48842b30 894 PERROR("consumer connect");
1d4b027a
DG
895 goto error;
896 }
897 /* Signal condition to tell that the kconsumerd is ready */
3bd1e081
MD
898 sem_post(&consumer_data->sem);
899 DBG("consumer command socket ready");
1d4b027a 900 } else {
3bd1e081 901 ERR("consumer error when waiting for SOCK_READY : %s",
1d4b027a
DG
902 lttcomm_get_readable_code(-code));
903 goto error;
904 }
905
54d01ffb 906 /* Remove the kconsumerd error sock since we've established a connexion */
3bd1e081 907 ret = lttng_poll_del(&events, consumer_data->err_sock);
72079cae 908 if (ret < 0) {
72079cae
DG
909 goto error;
910 }
911
5eb91c98
DG
912 ret = lttng_poll_add(&events, sock, LPOLLIN | LPOLLRDHUP);
913 if (ret < 0) {
72079cae 914 goto error;
5eb91c98
DG
915 }
916
917 /* Update number of fd */
918 nb_fd = LTTNG_POLL_GETNB(&events);
919
920 /* Inifinite blocking call, waiting for transmission */
88f2b785 921restart_poll:
5eb91c98
DG
922 ret = lttng_poll_wait(&events, -1);
923 if (ret < 0) {
88f2b785
MD
924 /*
925 * Restart interrupted system call.
926 */
927 if (errno == EINTR) {
928 goto restart_poll;
929 }
72079cae
DG
930 goto error;
931 }
932
5eb91c98
DG
933 for (i = 0; i < nb_fd; i++) {
934 /* Fetch once the poll data */
935 revents = LTTNG_POLL_GETEV(&events, i);
936 pollfd = LTTNG_POLL_GETFD(&events, i);
937
938 /* Thread quit pipe has been closed. Killing thread. */
939 ret = check_thread_quit_pipe(pollfd, revents);
940 if (ret) {
941 goto error;
942 }
943
944 /* Event on the kconsumerd socket */
945 if (pollfd == sock) {
946 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
3bd1e081 947 ERR("consumer err socket second poll error");
5eb91c98
DG
948 goto error;
949 }
950 }
951 }
952
712ea556 953 /* Wait for any kconsumerd error */
54d01ffb
DG
954 ret = lttcomm_recv_unix_sock(sock, &code,
955 sizeof(enum lttcomm_return_code));
712ea556 956 if (ret <= 0) {
3bd1e081 957 ERR("consumer closed the command socket");
712ea556 958 goto error;
6f61d021 959 }
1d4b027a 960
3bd1e081 961 ERR("consumer return code : %s", lttcomm_get_readable_code(-code));
712ea556 962
1d4b027a 963error:
5c827ce0
DG
964 /* Immediately set the consumerd state to stopped */
965 if (consumer_data->type == LTTNG_CONSUMER_KERNEL) {
966 uatomic_set(&kernel_consumerd_state, CONSUMER_ERROR);
967 } else if (consumer_data->type == LTTNG_CONSUMER64_UST ||
968 consumer_data->type == LTTNG_CONSUMER32_UST) {
969 uatomic_set(&ust_consumerd_state, CONSUMER_ERROR);
970 } else {
971 /* Code flow error... */
972 assert(0);
973 }
974
76d7553f
MD
975 if (consumer_data->err_sock >= 0) {
976 ret = close(consumer_data->err_sock);
977 if (ret) {
978 PERROR("close");
979 }
980 }
981 if (consumer_data->cmd_sock >= 0) {
982 ret = close(consumer_data->cmd_sock);
983 if (ret) {
984 PERROR("close");
985 }
986 }
987 if (sock >= 0) {
988 ret = close(sock);
989 if (ret) {
990 PERROR("close");
991 }
992 }
273ea72c 993
3bd1e081
MD
994 unlink(consumer_data->err_unix_sock_path);
995 unlink(consumer_data->cmd_unix_sock_path);
996 consumer_data->pid = 0;
1d4b027a 997
5eb91c98 998 lttng_poll_clean(&events);
76d7553f
MD
999error_poll:
1000error_listen:
1001 DBG("consumer thread cleanup completed");
0177d773 1002
5eb91c98 1003 return NULL;
099e26bd
DG
1004}
1005
099e26bd
DG
1006/*
1007 * This thread manage application communication.
1d4b027a
DG
1008 */
1009static void *thread_manage_apps(void *data)
099e26bd 1010{
5eb91c98
DG
1011 int i, ret, pollfd;
1012 uint32_t revents, nb_fd;
099e26bd 1013 struct ust_command ust_cmd;
5eb91c98 1014 struct lttng_poll_event events;
099e26bd
DG
1015
1016 DBG("[thread] Manage application started");
1017
f6a9efaa
DG
1018 rcu_register_thread();
1019 rcu_thread_online();
1020
5eb91c98
DG
1021 ret = create_thread_poll_set(&events, 2);
1022 if (ret < 0) {
76d7553f 1023 goto error_poll_create;
5eb91c98 1024 }
099e26bd 1025
5eb91c98
DG
1026 ret = lttng_poll_add(&events, apps_cmd_pipe[0], LPOLLIN | LPOLLRDHUP);
1027 if (ret < 0) {
1028 goto error;
1029 }
099e26bd 1030
5eb91c98
DG
1031 while (1) {
1032 /* Zeroed the events structure */
1033 lttng_poll_reset(&events);
0177d773 1034
5eb91c98 1035 nb_fd = LTTNG_POLL_GETNB(&events);
099e26bd
DG
1036
1037 DBG("Apps thread polling on %d fds", nb_fd);
1038
1039 /* Inifinite blocking call, waiting for transmission */
88f2b785 1040 restart:
5eb91c98 1041 ret = lttng_poll_wait(&events, -1);
099e26bd 1042 if (ret < 0) {
88f2b785
MD
1043 /*
1044 * Restart interrupted system call.
1045 */
1046 if (errno == EINTR) {
1047 goto restart;
1048 }
099e26bd
DG
1049 goto error;
1050 }
1051
5eb91c98
DG
1052 for (i = 0; i < nb_fd; i++) {
1053 /* Fetch once the poll data */
1054 revents = LTTNG_POLL_GETEV(&events, i);
1055 pollfd = LTTNG_POLL_GETFD(&events, i);
1056
1057 /* Thread quit pipe has been closed. Killing thread. */
1058 ret = check_thread_quit_pipe(pollfd, revents);
1059 if (ret) {
099e26bd 1060 goto error;
5eb91c98 1061 }
099e26bd 1062
5eb91c98
DG
1063 /* Inspect the apps cmd pipe */
1064 if (pollfd == apps_cmd_pipe[0]) {
1065 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
1066 ERR("Apps command pipe error");
0177d773 1067 goto error;
5eb91c98
DG
1068 } else if (revents & LPOLLIN) {
1069 /* Empty pipe */
1070 ret = read(apps_cmd_pipe[0], &ust_cmd, sizeof(ust_cmd));
1071 if (ret < 0 || ret < sizeof(ust_cmd)) {
76d7553f 1072 PERROR("read apps cmd pipe");
5eb91c98
DG
1073 goto error;
1074 }
099e26bd 1075
5eb91c98 1076 /* Register applicaton to the session daemon */
56fff090 1077 ret = ust_app_register(&ust_cmd.reg_msg,
54d01ffb 1078 ust_cmd.sock);
88ff5b7f 1079 if (ret == -ENOMEM) {
5eb91c98 1080 goto error;
88ff5b7f
MD
1081 } else if (ret < 0) {
1082 break;
5eb91c98
DG
1083 }
1084
acc7b41b 1085 /*
e0c7ec2b 1086 * Validate UST version compatibility.
acc7b41b 1087 */
e0c7ec2b
DG
1088 ret = ust_app_validate_version(ust_cmd.sock);
1089 if (ret >= 0) {
1090 /*
1091 * Add channel(s) and event(s) to newly registered apps
1092 * from lttng global UST domain.
1093 */
1094 update_ust_app(ust_cmd.sock);
1095 }
acc7b41b 1096
f2ca2e25 1097 ret = ust_app_register_done(ust_cmd.sock);
5eb91c98
DG
1098 if (ret < 0) {
1099 /*
1100 * If the registration is not possible, we simply
1101 * unregister the apps and continue
1102 */
56fff090 1103 ust_app_unregister(ust_cmd.sock);
5eb91c98
DG
1104 } else {
1105 /*
1106 * We just need here to monitor the close of the UST
1107 * socket and poll set monitor those by default.
a9ade966
MD
1108 * Listen on POLLIN (even if we never expect any
1109 * data) to ensure that hangup wakes us.
5eb91c98 1110 */
a9ade966 1111 ret = lttng_poll_add(&events, ust_cmd.sock, LPOLLIN);
5eb91c98
DG
1112 if (ret < 0) {
1113 goto error;
1114 }
1115
54d01ffb
DG
1116 DBG("Apps with sock %d added to poll set",
1117 ust_cmd.sock);
5eb91c98 1118 }
487cf67c 1119
5eb91c98 1120 break;
0177d773 1121 }
5eb91c98
DG
1122 } else {
1123 /*
54d01ffb
DG
1124 * At this point, we know that a registered application made
1125 * the event at poll_wait.
5eb91c98
DG
1126 */
1127 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
1128 /* Removing from the poll set */
1129 ret = lttng_poll_del(&events, pollfd);
1130 if (ret < 0) {
1131 goto error;
1132 }
099e26bd 1133
b9d9b220 1134 /* Socket closed on remote end. */
56fff090 1135 ust_app_unregister(pollfd);
5eb91c98
DG
1136 break;
1137 }
099e26bd
DG
1138 }
1139 }
099e26bd
DG
1140 }
1141
1142error:
5eb91c98 1143 lttng_poll_clean(&events);
76d7553f
MD
1144error_poll_create:
1145 DBG("Application communication apps thread cleanup complete");
f6a9efaa
DG
1146 rcu_thread_offline();
1147 rcu_unregister_thread();
099e26bd
DG
1148 return NULL;
1149}
1150
1151/*
1152 * Dispatch request from the registration threads to the application
1153 * communication thread.
1154 */
1155static void *thread_dispatch_ust_registration(void *data)
1156{
1157 int ret;
1158 struct cds_wfq_node *node;
1159 struct ust_command *ust_cmd = NULL;
1160
1161 DBG("[thread] Dispatch UST command started");
1162
1163 while (!dispatch_thread_exit) {
1164 /* Atomically prepare the queue futex */
1165 futex_nto1_prepare(&ust_cmd_queue.futex);
1166
1167 do {
1168 /* Dequeue command for registration */
1169 node = cds_wfq_dequeue_blocking(&ust_cmd_queue.queue);
1170 if (node == NULL) {
00a17c97 1171 DBG("Woken up but nothing in the UST command queue");
099e26bd
DG
1172 /* Continue thread execution */
1173 break;
1174 }
1175
1176 ust_cmd = caa_container_of(node, struct ust_command, node);
1177
2f50c8a3
DG
1178 DBG("Dispatching UST registration pid:%d ppid:%d uid:%d"
1179 " gid:%d sock:%d name:%s (version %d.%d)",
1180 ust_cmd->reg_msg.pid, ust_cmd->reg_msg.ppid,
1181 ust_cmd->reg_msg.uid, ust_cmd->reg_msg.gid,
1182 ust_cmd->sock, ust_cmd->reg_msg.name,
1183 ust_cmd->reg_msg.major, ust_cmd->reg_msg.minor);
099e26bd
DG
1184 /*
1185 * Inform apps thread of the new application registration. This
1186 * call is blocking so we can be assured that the data will be read
1187 * at some point in time or wait to the end of the world :)
1188 */
1189 ret = write(apps_cmd_pipe[1], ust_cmd,
1190 sizeof(struct ust_command));
1191 if (ret < 0) {
76d7553f 1192 PERROR("write apps cmd pipe");
099e26bd
DG
1193 if (errno == EBADF) {
1194 /*
1195 * We can't inform the application thread to process
1196 * registration. We will exit or else application
1197 * registration will not occur and tracing will never
1198 * start.
1199 */
1200 goto error;
1201 }
1202 }
1203 free(ust_cmd);
1204 } while (node != NULL);
1205
1206 /* Futex wait on queue. Blocking call on futex() */
1207 futex_nto1_wait(&ust_cmd_queue.futex);
1208 }
1209
1210error:
1211 DBG("Dispatch thread dying");
1212 return NULL;
1213}
1214
1215/*
1216 * This thread manage application registration.
1217 */
1218static void *thread_registration_apps(void *data)
1d4b027a 1219{
a4b35e07 1220 int sock = -1, i, ret, pollfd;
5eb91c98
DG
1221 uint32_t revents, nb_fd;
1222 struct lttng_poll_event events;
099e26bd
DG
1223 /*
1224 * Get allocated in this thread, enqueued to a global queue, dequeued and
1225 * freed in the manage apps thread.
1226 */
1227 struct ust_command *ust_cmd = NULL;
1d4b027a 1228
099e26bd 1229 DBG("[thread] Manage application registration started");
1d4b027a
DG
1230
1231 ret = lttcomm_listen_unix_sock(apps_sock);
1232 if (ret < 0) {
76d7553f 1233 goto error_listen;
1d4b027a
DG
1234 }
1235
5eb91c98
DG
1236 /*
1237 * Pass 2 as size here for the thread quit pipe and apps socket. Nothing
1238 * more will be added to this poll set.
1239 */
1240 ret = create_thread_poll_set(&events, 2);
1241 if (ret < 0) {
76d7553f 1242 goto error_create_poll;
5eb91c98 1243 }
273ea72c 1244
5eb91c98
DG
1245 /* Add the application registration socket */
1246 ret = lttng_poll_add(&events, apps_sock, LPOLLIN | LPOLLRDHUP);
1247 if (ret < 0) {
76d7553f 1248 goto error_poll_add;
5eb91c98 1249 }
273ea72c 1250
1d4b027a 1251 /* Notify all applications to register */
0fdd1e2c
DG
1252 ret = notify_ust_apps(1);
1253 if (ret < 0) {
1254 ERR("Failed to notify applications or create the wait shared memory.\n"
54d01ffb
DG
1255 "Execution continues but there might be problem for already\n"
1256 "running applications that wishes to register.");
0fdd1e2c 1257 }
1d4b027a
DG
1258
1259 while (1) {
1260 DBG("Accepting application registration");
273ea72c 1261
5eb91c98
DG
1262 nb_fd = LTTNG_POLL_GETNB(&events);
1263
273ea72c 1264 /* Inifinite blocking call, waiting for transmission */
88f2b785 1265 restart:
5eb91c98 1266 ret = lttng_poll_wait(&events, -1);
273ea72c 1267 if (ret < 0) {
88f2b785
MD
1268 /*
1269 * Restart interrupted system call.
1270 */
1271 if (errno == EINTR) {
1272 goto restart;
1273 }
273ea72c
DG
1274 goto error;
1275 }
1276
5eb91c98
DG
1277 for (i = 0; i < nb_fd; i++) {
1278 /* Fetch once the poll data */
1279 revents = LTTNG_POLL_GETEV(&events, i);
1280 pollfd = LTTNG_POLL_GETFD(&events, i);
273ea72c 1281
5eb91c98
DG
1282 /* Thread quit pipe has been closed. Killing thread. */
1283 ret = check_thread_quit_pipe(pollfd, revents);
1284 if (ret) {
90014c57
DG
1285 goto error;
1286 }
1d4b027a 1287
5eb91c98
DG
1288 /* Event on the registration socket */
1289 if (pollfd == apps_sock) {
1290 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
1291 ERR("Register apps socket poll error");
1292 goto error;
1293 } else if (revents & LPOLLIN) {
1294 sock = lttcomm_accept_unix_sock(apps_sock);
1295 if (sock < 0) {
1296 goto error;
1297 }
099e26bd 1298
5eb91c98 1299 /* Create UST registration command for enqueuing */
ba7f0ae5 1300 ust_cmd = zmalloc(sizeof(struct ust_command));
5eb91c98 1301 if (ust_cmd == NULL) {
76d7553f 1302 PERROR("ust command zmalloc");
5eb91c98
DG
1303 goto error;
1304 }
1d4b027a 1305
5eb91c98
DG
1306 /*
1307 * Using message-based transmissions to ensure we don't
1308 * have to deal with partially received messages.
1309 */
4063050c
MD
1310 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
1311 if (ret < 0) {
1312 ERR("Exhausted file descriptors allowed for applications.");
1313 free(ust_cmd);
1314 ret = close(sock);
1315 if (ret) {
1316 PERROR("close");
1317 }
1318 sock = -1;
1319 continue;
1320 }
5eb91c98
DG
1321 ret = lttcomm_recv_unix_sock(sock, &ust_cmd->reg_msg,
1322 sizeof(struct ust_register_msg));
1323 if (ret < 0 || ret < sizeof(struct ust_register_msg)) {
1324 if (ret < 0) {
76d7553f 1325 PERROR("lttcomm_recv_unix_sock register apps");
5eb91c98
DG
1326 } else {
1327 ERR("Wrong size received on apps register");
1328 }
1329 free(ust_cmd);
76d7553f
MD
1330 ret = close(sock);
1331 if (ret) {
1332 PERROR("close");
1333 }
4063050c 1334 lttng_fd_put(LTTNG_FD_APPS, 1);
76d7553f 1335 sock = -1;
5eb91c98
DG
1336 continue;
1337 }
099e26bd 1338
5eb91c98 1339 ust_cmd->sock = sock;
34a2494f 1340 sock = -1;
099e26bd 1341
5eb91c98
DG
1342 DBG("UST registration received with pid:%d ppid:%d uid:%d"
1343 " gid:%d sock:%d name:%s (version %d.%d)",
1344 ust_cmd->reg_msg.pid, ust_cmd->reg_msg.ppid,
1345 ust_cmd->reg_msg.uid, ust_cmd->reg_msg.gid,
1346 ust_cmd->sock, ust_cmd->reg_msg.name,
1347 ust_cmd->reg_msg.major, ust_cmd->reg_msg.minor);
54d01ffb 1348
5eb91c98
DG
1349 /*
1350 * Lock free enqueue the registration request. The red pill
54d01ffb 1351 * has been taken! This apps will be part of the *system*.
5eb91c98
DG
1352 */
1353 cds_wfq_enqueue(&ust_cmd_queue.queue, &ust_cmd->node);
1354
1355 /*
1356 * Wake the registration queue futex. Implicit memory
1357 * barrier with the exchange in cds_wfq_enqueue.
1358 */
1359 futex_nto1_wake(&ust_cmd_queue.futex);
1360 }
1361 }
90014c57 1362 }
1d4b027a
DG
1363 }
1364
1365error:
0fdd1e2c
DG
1366 /* Notify that the registration thread is gone */
1367 notify_ust_apps(0);
1368
a4b35e07 1369 if (apps_sock >= 0) {
76d7553f
MD
1370 ret = close(apps_sock);
1371 if (ret) {
1372 PERROR("close");
1373 }
a4b35e07 1374 }
46c3f085 1375 if (sock >= 0) {
76d7553f
MD
1376 ret = close(sock);
1377 if (ret) {
1378 PERROR("close");
1379 }
4063050c 1380 lttng_fd_put(LTTNG_FD_APPS, 1);
a4b35e07 1381 }
273ea72c 1382 unlink(apps_unix_sock_path);
0fdd1e2c 1383
76d7553f 1384error_poll_add:
5eb91c98 1385 lttng_poll_clean(&events);
76d7553f
MD
1386error_listen:
1387error_create_poll:
1388 DBG("UST Registration thread cleanup complete");
5eb91c98 1389
1d4b027a
DG
1390 return NULL;
1391}
1392
8c0faa1d 1393/*
3bd1e081 1394 * Start the thread_manage_consumer. This must be done after a lttng-consumerd
d063d709 1395 * exec or it will fails.
8c0faa1d 1396 */
3bd1e081 1397static int spawn_consumer_thread(struct consumer_data *consumer_data)
8c0faa1d
DG
1398{
1399 int ret;
ee0b0061
DG
1400 struct timespec timeout;
1401
1402 timeout.tv_sec = DEFAULT_SEM_WAIT_TIMEOUT;
1403 timeout.tv_nsec = 0;
8c0faa1d
DG
1404
1405 /* Setup semaphore */
3bd1e081 1406 ret = sem_init(&consumer_data->sem, 0, 0);
ee0b0061 1407 if (ret < 0) {
3bd1e081 1408 PERROR("sem_init consumer semaphore");
ee0b0061
DG
1409 goto error;
1410 }
8c0faa1d 1411
3bd1e081
MD
1412 ret = pthread_create(&consumer_data->thread, NULL,
1413 thread_manage_consumer, consumer_data);
8c0faa1d 1414 if (ret != 0) {
3bd1e081 1415 PERROR("pthread_create consumer");
ee0b0061 1416 ret = -1;
8c0faa1d
DG
1417 goto error;
1418 }
1419
ee0b0061
DG
1420 /* Get time for sem_timedwait absolute timeout */
1421 ret = clock_gettime(CLOCK_REALTIME, &timeout);
1422 if (ret < 0) {
3bd1e081 1423 PERROR("clock_gettime spawn consumer");
ee0b0061 1424 /* Infinite wait for the kconsumerd thread to be ready */
3bd1e081 1425 ret = sem_wait(&consumer_data->sem);
ee0b0061
DG
1426 } else {
1427 /* Normal timeout if the gettime was successful */
1428 timeout.tv_sec += DEFAULT_SEM_WAIT_TIMEOUT;
3bd1e081 1429 ret = sem_timedwait(&consumer_data->sem, &timeout);
ee0b0061 1430 }
8c0faa1d 1431
ee0b0061
DG
1432 if (ret < 0) {
1433 if (errno == ETIMEDOUT) {
1434 /*
1435 * Call has timed out so we kill the kconsumerd_thread and return
1436 * an error.
1437 */
3bd1e081
MD
1438 ERR("The consumer thread was never ready. Killing it");
1439 ret = pthread_cancel(consumer_data->thread);
ee0b0061 1440 if (ret < 0) {
3bd1e081 1441 PERROR("pthread_cancel consumer thread");
ee0b0061
DG
1442 }
1443 } else {
3bd1e081 1444 PERROR("semaphore wait failed consumer thread");
ee0b0061
DG
1445 }
1446 goto error;
1447 }
1448
3bd1e081
MD
1449 pthread_mutex_lock(&consumer_data->pid_mutex);
1450 if (consumer_data->pid == 0) {
712ea556 1451 ERR("Kconsumerd did not start");
3bd1e081 1452 pthread_mutex_unlock(&consumer_data->pid_mutex);
712ea556
DG
1453 goto error;
1454 }
3bd1e081 1455 pthread_mutex_unlock(&consumer_data->pid_mutex);
712ea556 1456
8c0faa1d
DG
1457 return 0;
1458
1459error:
1460 return ret;
1461}
1462
d9800920 1463/*
3bd1e081 1464 * Join consumer thread
d9800920 1465 */
3bd1e081 1466static int join_consumer_thread(struct consumer_data *consumer_data)
cf3af59e
MD
1467{
1468 void *status;
1469 int ret;
1470
3bd1e081
MD
1471 if (consumer_data->pid != 0) {
1472 ret = kill(consumer_data->pid, SIGTERM);
cf3af59e 1473 if (ret) {
3bd1e081 1474 ERR("Error killing consumer daemon");
cf3af59e
MD
1475 return ret;
1476 }
3bd1e081 1477 return pthread_join(consumer_data->thread, &status);
cf3af59e
MD
1478 } else {
1479 return 0;
1480 }
1481}
1482
8c0faa1d 1483/*
3bd1e081 1484 * Fork and exec a consumer daemon (consumerd).
8c0faa1d 1485 *
d063d709 1486 * Return pid if successful else -1.
8c0faa1d 1487 */
3bd1e081 1488static pid_t spawn_consumerd(struct consumer_data *consumer_data)
8c0faa1d
DG
1489{
1490 int ret;
1491 pid_t pid;
94c55f17 1492 const char *consumer_to_use;
53086306 1493 const char *verbosity;
94c55f17 1494 struct stat st;
8c0faa1d 1495
3bd1e081 1496 DBG("Spawning consumerd");
c49dc785 1497
8c0faa1d
DG
1498 pid = fork();
1499 if (pid == 0) {
1500 /*
3bd1e081 1501 * Exec consumerd.
8c0faa1d 1502 */
daee5345 1503 if (opt_verbose_consumer) {
53086306
DG
1504 verbosity = "--verbose";
1505 } else {
1506 verbosity = "--quiet";
1507 }
3bd1e081
MD
1508 switch (consumer_data->type) {
1509 case LTTNG_CONSUMER_KERNEL:
94c55f17 1510 /*
c7704d57
DG
1511 * Find out which consumerd to execute. We will first try the
1512 * 64-bit path, then the sessiond's installation directory, and
1513 * fallback on the 32-bit one,
94c55f17 1514 */
63a799e8
AM
1515 DBG3("Looking for a kernel consumer at these locations:");
1516 DBG3(" 1) %s", consumerd64_bin);
1517 DBG3(" 2) %s/%s", INSTALL_BIN_PATH, CONSUMERD_FILE);
1518 DBG3(" 3) %s", consumerd32_bin);
94c55f17 1519 if (stat(consumerd64_bin, &st) == 0) {
63a799e8 1520 DBG3("Found location #1");
94c55f17 1521 consumer_to_use = consumerd64_bin;
94c55f17 1522 } else if (stat(INSTALL_BIN_PATH "/" CONSUMERD_FILE, &st) == 0) {
63a799e8 1523 DBG3("Found location #2");
94c55f17 1524 consumer_to_use = INSTALL_BIN_PATH "/" CONSUMERD_FILE;
eb1e0bd4 1525 } else if (stat(consumerd32_bin, &st) == 0) {
63a799e8 1526 DBG3("Found location #3");
eb1e0bd4 1527 consumer_to_use = consumerd32_bin;
94c55f17 1528 } else {
63a799e8 1529 DBG("Could not find any valid consumerd executable");
94c55f17
AM
1530 break;
1531 }
1532 DBG("Using kernel consumer at: %s", consumer_to_use);
1533 execl(consumer_to_use,
1534 "lttng-consumerd", verbosity, "-k",
1535 "--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
1536 "--consumerd-err-sock", consumer_data->err_unix_sock_path,
1537 NULL);
3bd1e081 1538 break;
7753dea8
MD
1539 case LTTNG_CONSUMER64_UST:
1540 {
b1e0b6b6 1541 char *tmpnew = NULL;
8f4905da
MD
1542
1543 if (consumerd64_libdir[0] != '\0') {
1544 char *tmp;
1545 size_t tmplen;
1546
1547 tmp = getenv("LD_LIBRARY_PATH");
1548 if (!tmp) {
1549 tmp = "";
1550 }
1551 tmplen = strlen("LD_LIBRARY_PATH=")
1552 + strlen(consumerd64_libdir) + 1 /* : */ + strlen(tmp);
1553 tmpnew = zmalloc(tmplen + 1 /* \0 */);
1554 if (!tmpnew) {
1555 ret = -ENOMEM;
1556 goto error;
1557 }
1558 strcpy(tmpnew, "LD_LIBRARY_PATH=");
1559 strcat(tmpnew, consumerd64_libdir);
1560 if (tmp[0] != '\0') {
1561 strcat(tmpnew, ":");
1562 strcat(tmpnew, tmp);
1563 }
1564 ret = putenv(tmpnew);
1565 if (ret) {
1566 ret = -errno;
1567 goto error;
1568 }
1569 }
94c55f17 1570 DBG("Using 64-bit UST consumer at: %s", consumerd64_bin);
a5a6aff3 1571 ret = execl(consumerd64_bin, "lttng-consumerd", verbosity, "-u",
7753dea8
MD
1572 "--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
1573 "--consumerd-err-sock", consumer_data->err_unix_sock_path,
1574 NULL);
8f4905da
MD
1575 if (consumerd64_libdir[0] != '\0') {
1576 free(tmpnew);
1577 }
1578 if (ret) {
1579 goto error;
1580 }
3bd1e081 1581 break;
7753dea8
MD
1582 }
1583 case LTTNG_CONSUMER32_UST:
1584 {
937dde8e 1585 char *tmpnew = NULL;
8f4905da
MD
1586
1587 if (consumerd32_libdir[0] != '\0') {
1588 char *tmp;
1589 size_t tmplen;
1590
1591 tmp = getenv("LD_LIBRARY_PATH");
1592 if (!tmp) {
1593 tmp = "";
1594 }
1595 tmplen = strlen("LD_LIBRARY_PATH=")
1596 + strlen(consumerd32_libdir) + 1 /* : */ + strlen(tmp);
1597 tmpnew = zmalloc(tmplen + 1 /* \0 */);
1598 if (!tmpnew) {
1599 ret = -ENOMEM;
1600 goto error;
1601 }
1602 strcpy(tmpnew, "LD_LIBRARY_PATH=");
1603 strcat(tmpnew, consumerd32_libdir);
1604 if (tmp[0] != '\0') {
1605 strcat(tmpnew, ":");
1606 strcat(tmpnew, tmp);
1607 }
1608 ret = putenv(tmpnew);
1609 if (ret) {
1610 ret = -errno;
1611 goto error;
1612 }
1613 }
94c55f17 1614 DBG("Using 32-bit UST consumer at: %s", consumerd32_bin);
a5a6aff3 1615 ret = execl(consumerd32_bin, "lttng-consumerd", verbosity, "-u",
7753dea8
MD
1616 "--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
1617 "--consumerd-err-sock", consumer_data->err_unix_sock_path,
1618 NULL);
8f4905da
MD
1619 if (consumerd32_libdir[0] != '\0') {
1620 free(tmpnew);
1621 }
1622 if (ret) {
1623 goto error;
1624 }
7753dea8
MD
1625 break;
1626 }
3bd1e081 1627 default:
76d7553f 1628 PERROR("unknown consumer type");
3bd1e081
MD
1629 exit(EXIT_FAILURE);
1630 }
8c0faa1d 1631 if (errno != 0) {
76d7553f 1632 PERROR("kernel start consumer exec");
8c0faa1d
DG
1633 }
1634 exit(EXIT_FAILURE);
1635 } else if (pid > 0) {
1636 ret = pid;
8c0faa1d 1637 } else {
76d7553f 1638 PERROR("start consumer fork");
8c0faa1d 1639 ret = -errno;
8c0faa1d 1640 }
8f4905da 1641error:
8c0faa1d
DG
1642 return ret;
1643}
1644
693bd40b 1645/*
3bd1e081 1646 * Spawn the consumerd daemon and session daemon thread.
693bd40b 1647 */
3bd1e081 1648static int start_consumerd(struct consumer_data *consumer_data)
693bd40b
DG
1649{
1650 int ret;
1651
3bd1e081
MD
1652 pthread_mutex_lock(&consumer_data->pid_mutex);
1653 if (consumer_data->pid != 0) {
1654 pthread_mutex_unlock(&consumer_data->pid_mutex);
c49dc785
DG
1655 goto end;
1656 }
693bd40b 1657
3bd1e081 1658 ret = spawn_consumerd(consumer_data);
c49dc785 1659 if (ret < 0) {
3bd1e081
MD
1660 ERR("Spawning consumerd failed");
1661 pthread_mutex_unlock(&consumer_data->pid_mutex);
c49dc785 1662 goto error;
693bd40b 1663 }
c49dc785 1664
3bd1e081
MD
1665 /* Setting up the consumer_data pid */
1666 consumer_data->pid = ret;
48842b30 1667 DBG2("Consumer pid %d", consumer_data->pid);
3bd1e081 1668 pthread_mutex_unlock(&consumer_data->pid_mutex);
693bd40b 1669
3bd1e081
MD
1670 DBG2("Spawning consumer control thread");
1671 ret = spawn_consumer_thread(consumer_data);
693bd40b 1672 if (ret < 0) {
3bd1e081 1673 ERR("Fatal error spawning consumer control thread");
693bd40b
DG
1674 goto error;
1675 }
1676
c49dc785 1677end:
693bd40b
DG
1678 return 0;
1679
1680error:
1681 return ret;
1682}
1683
b73401da 1684/*
096102bd 1685 * Check version of the lttng-modules.
b73401da 1686 */
096102bd 1687static int validate_lttng_modules_version(void)
b73401da 1688{
096102bd 1689 return kernel_validate_version(kernel_tracer_fd);
ab147185
MD
1690}
1691
b73401da 1692/*
096102bd 1693 * Setup necessary data for kernel tracer action.
b73401da 1694 */
096102bd 1695static int init_kernel_tracer(void)
b73401da
DG
1696{
1697 int ret;
b73401da 1698
096102bd
DG
1699 /* Modprobe lttng kernel modules */
1700 ret = modprobe_lttng_control();
b73401da 1701 if (ret < 0) {
b73401da
DG
1702 goto error;
1703 }
1704
096102bd
DG
1705 /* Open debugfs lttng */
1706 kernel_tracer_fd = open(module_proc_lttng, O_RDWR);
1707 if (kernel_tracer_fd < 0) {
1708 DBG("Failed to open %s", module_proc_lttng);
1709 ret = -1;
1710 goto error_open;
b73401da
DG
1711 }
1712
096102bd
DG
1713 /* Validate kernel version */
1714 ret = validate_lttng_modules_version();
b73401da 1715 if (ret < 0) {
096102bd 1716 goto error_version;
b73401da
DG
1717 }
1718
096102bd 1719 ret = modprobe_lttng_data();
b73401da 1720 if (ret < 0) {
096102bd 1721 goto error_modules;
8c0faa1d
DG
1722 }
1723
f3ed775e 1724 DBG("Kernel tracer fd %d", kernel_tracer_fd);
096102bd
DG
1725 return 0;
1726
1727error_version:
1728 modprobe_remove_lttng_control();
76d7553f
MD
1729 ret = close(kernel_tracer_fd);
1730 if (ret) {
1731 PERROR("close");
1732 }
1733 kernel_tracer_fd = -1;
096102bd
DG
1734 return LTTCOMM_KERN_VERSION;
1735
1736error_modules:
76d7553f
MD
1737 ret = close(kernel_tracer_fd);
1738 if (ret) {
1739 PERROR("close");
1740 }
096102bd
DG
1741
1742error_open:
1743 modprobe_remove_lttng_control();
b73401da
DG
1744
1745error:
b73401da 1746 WARN("No kernel tracer available");
a4b35e07 1747 kernel_tracer_fd = -1;
531d29f9
MD
1748 if (!is_root) {
1749 return LTTCOMM_NEED_ROOT_SESSIOND;
1750 } else {
1751 return LTTCOMM_KERN_NA;
1752 }
f3ed775e 1753}
33a2b854 1754
f3ed775e 1755/*
54d01ffb 1756 * Init tracing by creating trace directory and sending fds kernel consumer.
f3ed775e 1757 */
54d01ffb 1758static int init_kernel_tracing(struct ltt_kernel_session *session)
f3ed775e 1759{
f40799e8 1760 int ret = 0;
8c0faa1d 1761
00e2e675 1762 if (session->consumer_fds_sent == 0 && session->consumer != NULL) {
d9800920 1763 /*
54d01ffb 1764 * Assign default kernel consumer socket if no consumer assigned to the
03550b58 1765 * kernel session. At this point, it's NOT supposed to be -1 but this is
54d01ffb 1766 * an extra security check.
d9800920 1767 */
03550b58 1768 if (session->consumer_fd < 0) {
3bd1e081 1769 session->consumer_fd = kconsumer_data.cmd_sock;
d9800920
DG
1770 }
1771
00e2e675 1772 ret = kernel_consumer_send_session(session->consumer_fd, session);
f3ed775e 1773 if (ret < 0) {
f3ed775e
DG
1774 ret = LTTCOMM_KERN_CONSUMER_FAIL;
1775 goto error;
1776 }
00e2e675 1777 }
1d4b027a 1778
00e2e675
DG
1779error:
1780 return ret;
1781}
1782
1783/*
1784 * Create a socket to the relayd using the URI.
1785 *
1786 * On success, the relayd_sock pointer is set to the created socket.
1787 * Else, it is untouched and an lttcomm error code is returned.
1788 */
1789static int create_connect_relayd(struct consumer_output *output,
1790 const char *session_name, struct lttng_uri *uri,
1791 struct lttcomm_sock **relayd_sock)
1792{
1793 int ret;
1794 struct lttcomm_sock *sock;
1795
1796 /* Create socket object from URI */
1797 sock = lttcomm_alloc_sock_from_uri(uri);
1798 if (sock == NULL) {
1799 ret = LTTCOMM_FATAL;
1800 goto error;
1801 }
1802
1803 ret = lttcomm_create_sock(sock);
1804 if (ret < 0) {
1805 ret = LTTCOMM_FATAL;
1806 goto error;
1807 }
1808
1809 /* Connect to relayd so we can proceed with a session creation. */
1810 ret = relayd_connect(sock);
1811 if (ret < 0) {
1812 ERR("Unable to reach lttng-relayd");
1813 ret = LTTCOMM_RELAYD_SESSION_FAIL;
1814 goto free_sock;
f3ed775e 1815 }
1d4b027a 1816
00e2e675
DG
1817 /* Create socket for control stream. */
1818 if (uri->stype == LTTNG_STREAM_CONTROL) {
1819 DBG3("Creating relayd stream socket from URI");
1820
1821 /* Check relayd version */
1822 ret = relayd_version_check(sock, LTTNG_UST_COMM_MAJOR, 0);
1823 if (ret < 0) {
1824 ret = LTTCOMM_RELAYD_VERSION_FAIL;
1825 goto close_sock;
1826 }
1827 } else if (uri->stype == LTTNG_STREAM_DATA) {
1828 DBG3("Creating relayd data socket from URI");
1829 } else {
1830 /* Command is not valid */
1831 ERR("Relayd invalid stream type: %d", uri->stype);
1832 ret = LTTCOMM_INVALID;
1833 goto close_sock;
1834 }
1835
1836 *relayd_sock = sock;
1837
1838 return LTTCOMM_OK;
1839
1840close_sock:
1841 if (sock) {
1842 (void) relayd_close(sock);
1843 }
1844free_sock:
1845 if (sock) {
1846 lttcomm_destroy_sock(sock);
1847 }
1848error:
1849 return ret;
1850}
1851
1852/*
1853 * Connect to the relayd using URI and send the socket to the right consumer.
1854 */
1855static int send_socket_relayd_consumer(int domain, struct ltt_session *session,
1856 struct lttng_uri *relayd_uri, struct consumer_output *consumer,
1857 int consumer_fd)
1858{
1859 int ret;
1860 struct lttcomm_sock *sock = NULL;
1861
1862 /* Set the network sequence index if not set. */
1863 if (consumer->net_seq_index == -1) {
1864 /*
1865 * Increment net_seq_idx because we are about to transfer the
1866 * new relayd socket to the consumer.
1867 */
1868 uatomic_inc(&relayd_net_seq_idx);
1869 /* Assign unique key so the consumer can match streams */
1870 consumer->net_seq_index = uatomic_read(&relayd_net_seq_idx);
1871 }
1872
1873 /* Connect to relayd and make version check if uri is the control. */
1874 ret = create_connect_relayd(consumer, session->name, relayd_uri, &sock);
1875 if (ret != LTTCOMM_OK) {
1876 goto close_sock;
1877 }
1878
1879 /* If the control socket is connected, network session is ready */
1880 if (relayd_uri->stype == LTTNG_STREAM_CONTROL) {
1881 session->net_handle = 1;
1882 }
1883
1884 switch (domain) {
1885 case LTTNG_DOMAIN_KERNEL:
1886 /* Send relayd socket to consumer. */
1887 ret = kernel_consumer_send_relayd_socket(consumer_fd, sock,
1888 consumer, relayd_uri->stype);
1889 if (ret < 0) {
1890 ret = LTTCOMM_ENABLE_CONSUMER_FAIL;
1891 goto close_sock;
1892 }
1893 break;
1894 case LTTNG_DOMAIN_UST:
1895 /* Send relayd socket to consumer. */
1896 ret = ust_consumer_send_relayd_socket(consumer_fd, sock,
1897 consumer, relayd_uri->stype);
1898 if (ret < 0) {
1899 ret = LTTCOMM_ENABLE_CONSUMER_FAIL;
1900 goto close_sock;
1901 }
1902 break;
1903 }
1904
1905 ret = LTTCOMM_OK;
1906
1907 /*
1908 * Close socket which was dup on the consumer side. The session daemon does
1909 * NOT keep track of the relayd socket(s) once transfer to the consumer.
1910 */
1911
1912close_sock:
1913 if (sock) {
1914 (void) relayd_close(sock);
1915 lttcomm_destroy_sock(sock);
1916 }
1917
1918 return ret;
1919}
1920
1921/*
1922 * Send both relayd sockets to a specific consumer and domain. This is a
1923 * helper function to facilitate sending the information to the consumer for a
1924 * session.
1925 */
1926static int send_sockets_relayd_consumer(int domain,
1927 struct ltt_session *session, struct consumer_output *consumer, int fd)
1928{
1929 int ret;
1930
1931 /* Sending control relayd socket. */
1932 ret = send_socket_relayd_consumer(domain, session,
1933 &consumer->dst.net.control, consumer, fd);
1934 if (ret != LTTCOMM_OK) {
1935 goto error;
1936 }
1937
1938 /* Sending data relayd socket. */
1939 ret = send_socket_relayd_consumer(domain, session,
1940 &consumer->dst.net.data, consumer, fd);
1941 if (ret != LTTCOMM_OK) {
1942 goto error;
1943 }
1944
1945error:
1946 return ret;
1947}
1948
1949/*
1950 * Setup relayd connections for a tracing session. First creates the socket to
1951 * the relayd and send them to the right domain consumer. Consumer type MUST be
1952 * network.
1953 */
1954static int setup_relayd(struct ltt_session *session)
1955{
1956 int ret = LTTCOMM_OK;
1957 struct ltt_ust_session *usess;
1958 struct ltt_kernel_session *ksess;
1959
1960 assert(session);
1961
1962 usess = session->ust_session;
1963 ksess = session->kernel_session;
1964
1965 DBG2("Setting relayd for session %s", session->name);
1966
1967 if (usess && usess->consumer->sock == -1 &&
1968 usess->consumer->type == CONSUMER_DST_NET &&
1969 usess->consumer->enabled) {
1970 /* Setup relayd for 64 bits consumer */
1971 if (ust_consumerd64_fd >= 0) {
1972 send_sockets_relayd_consumer(LTTNG_DOMAIN_UST, session,
1973 usess->consumer, ust_consumerd64_fd);
1974 if (ret != LTTCOMM_OK) {
1975 goto error;
1976 }
1977 }
1978
1979 /* Setup relayd for 32 bits consumer */
1980 if (ust_consumerd32_fd >= 0) {
1981 send_sockets_relayd_consumer(LTTNG_DOMAIN_UST, session,
1982 usess->consumer, ust_consumerd32_fd);
1983 if (ret != LTTCOMM_OK) {
1984 goto error;
1985 }
1986 }
1987 } else if (ksess && ksess->consumer->sock == -1 &&
1988 ksess->consumer->type == CONSUMER_DST_NET &&
1989 ksess->consumer->enabled) {
1990 send_sockets_relayd_consumer(LTTNG_DOMAIN_KERNEL, session,
1991 ksess->consumer, ksess->consumer_fd);
1992 if (ret != LTTCOMM_OK) {
1993 goto error;
1994 }
1995 }
1996
1997error:
1998 return ret;
1999}
2000
2001/*
2002 * Copy consumer output from the tracing session to the domain session. The
2003 * function also applies the right modification on a per domain basis for the
2004 * trace files destination directory.
2005 */
2006static int copy_session_consumer(int domain, struct ltt_session *session)
2007{
2008 int ret;
2009 const char *dir_name;
2010 struct consumer_output *consumer;
2011
2012 switch (domain) {
2013 case LTTNG_DOMAIN_KERNEL:
2014 DBG3("Copying tracing session consumer output in kernel session");
2015 session->kernel_session->consumer =
2016 consumer_copy_output(session->consumer);
2017 /* Ease our life a bit for the next part */
2018 consumer = session->kernel_session->consumer;
2019 dir_name = DEFAULT_KERNEL_TRACE_DIR;
2020 break;
2021 case LTTNG_DOMAIN_UST:
2022 DBG3("Copying tracing session consumer output in UST session");
2023 session->ust_session->consumer =
2024 consumer_copy_output(session->consumer);
2025 /* Ease our life a bit for the next part */
2026 consumer = session->ust_session->consumer;
2027 dir_name = DEFAULT_UST_TRACE_DIR;
2028 break;
2029 default:
2030 ret = LTTCOMM_UNKNOWN_DOMAIN;
2031 goto error;
2032 }
2033
2034 /* Append correct directory to subdir */
2035 strncat(consumer->subdir, dir_name, sizeof(consumer->subdir));
2036 DBG3("Copy session consumer subdir %s", consumer->subdir);
2037
2038 /* Add default trace directory name */
2039 if (consumer->type == CONSUMER_DST_LOCAL) {
2040 strncat(consumer->dst.trace_path, dir_name,
2041 sizeof(consumer->dst.trace_path));
2042 }
2043
2044 ret = LTTCOMM_OK;
2045
1d4b027a
DG
2046error:
2047 return ret;
8c0faa1d
DG
2048}
2049
0177d773
DG
2050/*
2051 * Create an UST session and add it to the session ust list.
2052 */
44d3bd01 2053static int create_ust_session(struct ltt_session *session,
6df2e2c9 2054 struct lttng_domain *domain)
0177d773 2055{
6df2e2c9 2056 int ret;
00e2e675
DG
2057 struct ltt_ust_session *lus = NULL;
2058
2059 assert(session);
2060 assert(session->consumer);
44d3bd01
DG
2061
2062 switch (domain->type) {
48842b30 2063 case LTTNG_DOMAIN_UST:
44d3bd01
DG
2064 break;
2065 default:
00e2e675 2066 ERR("Unknown UST domain on create session %d", domain->type);
13384287 2067 ret = LTTCOMM_UNKNOWN_DOMAIN;
44d3bd01
DG
2068 goto error;
2069 }
0177d773
DG
2070
2071 DBG("Creating UST session");
2072
a991f516 2073 lus = trace_ust_create_session(session->path, session->id, domain);
0177d773 2074 if (lus == NULL) {
44d3bd01 2075 ret = LTTCOMM_UST_SESS_FAIL;
0177d773
DG
2076 goto error;
2077 }
2078
00e2e675
DG
2079 if (session->consumer->type == CONSUMER_DST_LOCAL) {
2080 ret = run_as_mkdir_recursive(lus->pathname, S_IRWXU | S_IRWXG,
2081 session->uid, session->gid);
2082 if (ret < 0) {
2083 if (ret != -EEXIST) {
2084 ERR("Trace directory creation error");
2085 ret = LTTCOMM_UST_SESS_FAIL;
2086 goto error;
2087 }
0177d773
DG
2088 }
2089 }
2090
6df2e2c9
MD
2091 lus->uid = session->uid;
2092 lus->gid = session->gid;
f6a9efaa 2093 session->ust_session = lus;
44d3bd01 2094
00e2e675
DG
2095 /* Copy session output to the newly created UST session */
2096 ret = copy_session_consumer(domain->type, session);
2097 if (ret != LTTCOMM_OK) {
2098 goto error;
2099 }
2100
44d3bd01 2101 return LTTCOMM_OK;
0177d773
DG
2102
2103error:
2104 free(lus);
00e2e675 2105 session->ust_session = NULL;
0177d773
DG
2106 return ret;
2107}
2108
333f285e 2109/*
d063d709 2110 * Create a kernel tracer session then create the default channel.
333f285e 2111 */
6df2e2c9 2112static int create_kernel_session(struct ltt_session *session)
333f285e 2113{
f3ed775e 2114 int ret;
f3ed775e
DG
2115
2116 DBG("Creating kernel session");
2117
2118 ret = kernel_create_session(session, kernel_tracer_fd);
2119 if (ret < 0) {
2120 ret = LTTCOMM_KERN_SESS_FAIL;
2121 goto error;
333f285e
DG
2122 }
2123
d9800920 2124 /* Set kernel consumer socket fd */
03550b58 2125 if (kconsumer_data.cmd_sock >= 0) {
3bd1e081 2126 session->kernel_session->consumer_fd = kconsumer_data.cmd_sock;
d9800920
DG
2127 }
2128
00e2e675
DG
2129 /* Copy session output to the newly created Kernel session */
2130 ret = copy_session_consumer(LTTNG_DOMAIN_KERNEL, session);
2131 if (ret != LTTCOMM_OK) {
2132 goto error;
2133 }
2134
2135 /* Create directory(ies) on local filesystem. */
2136 if (session->consumer->type == CONSUMER_DST_LOCAL) {
2137 ret = run_as_mkdir_recursive(
2138 session->kernel_session->consumer->dst.trace_path,
2139 S_IRWXU | S_IRWXG, session->uid, session->gid);
2140 if (ret < 0) {
2141 if (ret != -EEXIST) {
2142 ERR("Trace directory creation error");
2143 goto error;
2144 }
7a485870
DG
2145 }
2146 }
00e2e675 2147
6df2e2c9
MD
2148 session->kernel_session->uid = session->uid;
2149 session->kernel_session->gid = session->gid;
7a485870 2150
00e2e675
DG
2151 return LTTCOMM_OK;
2152
f3ed775e 2153error:
00e2e675
DG
2154 trace_kernel_destroy_session(session->kernel_session);
2155 session->kernel_session = NULL;
f3ed775e 2156 return ret;
333f285e
DG
2157}
2158
8e0af1b4 2159/*
c7704d57
DG
2160 * Check if the UID or GID match the session. Root user has access to all
2161 * sessions.
8e0af1b4 2162 */
c7704d57 2163static int session_access_ok(struct ltt_session *session, uid_t uid, gid_t gid)
8e0af1b4 2164{
c7704d57 2165 if (uid != session->uid && gid != session->gid && uid != 0) {
8e0af1b4
MD
2166 return 0;
2167 } else {
2168 return 1;
2169 }
2170}
2171
00e2e675
DG
2172/*
2173 * Count number of session permitted by uid/gid.
2174 */
8e0af1b4
MD
2175static unsigned int lttng_sessions_count(uid_t uid, gid_t gid)
2176{
2177 unsigned int i = 0;
2178 struct ltt_session *session;
2179
2180 DBG("Counting number of available session for UID %d GID %d",
2181 uid, gid);
2182 cds_list_for_each_entry(session, &session_list_ptr->head, list) {
2183 /*
2184 * Only list the sessions the user can control.
2185 */
2186 if (!session_access_ok(session, uid, gid)) {
2187 continue;
2188 }
2189 i++;
2190 }
2191 return i;
2192}
2193
6c9cc2ab
DG
2194/*
2195 * Using the session list, filled a lttng_session array to send back to the
2196 * client for session listing.
2197 *
2198 * The session list lock MUST be acquired before calling this function. Use
54d01ffb 2199 * session_lock_list() and session_unlock_list().
6c9cc2ab 2200 */
c7704d57
DG
2201static void list_lttng_sessions(struct lttng_session *sessions, uid_t uid,
2202 gid_t gid)
6c9cc2ab 2203{
8e0af1b4 2204 unsigned int i = 0;
6c9cc2ab
DG
2205 struct ltt_session *session;
2206
8e0af1b4
MD
2207 DBG("Getting all available session for UID %d GID %d",
2208 uid, gid);
6c9cc2ab
DG
2209 /*
2210 * Iterate over session list and append data after the control struct in
2211 * the buffer.
2212 */
2213 cds_list_for_each_entry(session, &session_list_ptr->head, list) {
8e0af1b4
MD
2214 /*
2215 * Only list the sessions the user can control.
2216 */
2217 if (!session_access_ok(session, uid, gid)) {
2218 continue;
2219 }
6c9cc2ab 2220 strncpy(sessions[i].path, session->path, PATH_MAX);
99497cd0 2221 sessions[i].path[PATH_MAX - 1] = '\0';
6c9cc2ab 2222 strncpy(sessions[i].name, session->name, NAME_MAX);
99497cd0 2223 sessions[i].name[NAME_MAX - 1] = '\0';
464dd62d 2224 sessions[i].enabled = session->enabled;
6c9cc2ab
DG
2225 i++;
2226 }
2227}
2228
9f19cc17
DG
2229/*
2230 * Fill lttng_channel array of all channels.
2231 */
b551a063 2232static void list_lttng_channels(int domain, struct ltt_session *session,
9f19cc17
DG
2233 struct lttng_channel *channels)
2234{
2235 int i = 0;
2236 struct ltt_kernel_channel *kchan;
2237
2238 DBG("Listing channels for session %s", session->name);
2239
b551a063
DG
2240 switch (domain) {
2241 case LTTNG_DOMAIN_KERNEL:
2242 /* Kernel channels */
2243 if (session->kernel_session != NULL) {
2244 cds_list_for_each_entry(kchan,
2245 &session->kernel_session->channel_list.head, list) {
2246 /* Copy lttng_channel struct to array */
2247 memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel));
2248 channels[i].enabled = kchan->enabled;
2249 i++;
2250 }
2251 }
2252 break;
2253 case LTTNG_DOMAIN_UST:
2254 {
bec39940 2255 struct lttng_ht_iter iter;
b551a063
DG
2256 struct ltt_ust_channel *uchan;
2257
bec39940
DG
2258 cds_lfht_for_each_entry(session->ust_session->domain_global.channels->ht,
2259 &iter.iter, uchan, node.node) {
b551a063
DG
2260 strncpy(channels[i].name, uchan->name, LTTNG_SYMBOL_NAME_LEN);
2261 channels[i].attr.overwrite = uchan->attr.overwrite;
2262 channels[i].attr.subbuf_size = uchan->attr.subbuf_size;
2263 channels[i].attr.num_subbuf = uchan->attr.num_subbuf;
2264 channels[i].attr.switch_timer_interval =
2265 uchan->attr.switch_timer_interval;
2266 channels[i].attr.read_timer_interval =
2267 uchan->attr.read_timer_interval;
aea829b3 2268 channels[i].enabled = uchan->enabled;
5edd7e09
DG
2269 switch (uchan->attr.output) {
2270 case LTTNG_UST_MMAP:
2271 default:
2272 channels[i].attr.output = LTTNG_EVENT_MMAP;
2273 break;
2274 }
befe0905 2275 i++;
b551a063
DG
2276 }
2277 break;
2278 }
2279 default:
2280 break;
2281 }
2282}
2283
2284/*
2285 * Create a list of ust global domain events.
2286 */
2287static int list_lttng_ust_global_events(char *channel_name,
2288 struct ltt_ust_domain_global *ust_global, struct lttng_event **events)
2289{
2290 int i = 0, ret = 0;
2291 unsigned int nb_event = 0;
bec39940
DG
2292 struct lttng_ht_iter iter;
2293 struct lttng_ht_node_str *node;
b551a063
DG
2294 struct ltt_ust_channel *uchan;
2295 struct ltt_ust_event *uevent;
2296 struct lttng_event *tmp;
2297
2298 DBG("Listing UST global events for channel %s", channel_name);
2299
2300 rcu_read_lock();
2301
bec39940
DG
2302 lttng_ht_lookup(ust_global->channels, (void *)channel_name, &iter);
2303 node = lttng_ht_iter_get_node_str(&iter);
d7b75b30
DG
2304 if (node == NULL) {
2305 ret = -LTTCOMM_UST_CHAN_NOT_FOUND;
2306 goto error;
b551a063
DG
2307 }
2308
bec39940 2309 uchan = caa_container_of(&node->node, struct ltt_ust_channel, node.node);
d7b75b30 2310
bec39940 2311 nb_event += lttng_ht_get_count(uchan->events);
d7b75b30 2312
b551a063
DG
2313 if (nb_event == 0) {
2314 ret = nb_event;
2315 goto error;
2316 }
2317
2318 DBG3("Listing UST global %d events", nb_event);
2319
2320 tmp = zmalloc(nb_event * sizeof(struct lttng_event));
2321 if (tmp == NULL) {
2322 ret = -LTTCOMM_FATAL;
2323 goto error;
2324 }
2325
bec39940 2326 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
d7b75b30
DG
2327 strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN);
2328 tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
2329 tmp[i].enabled = uevent->enabled;
2330 switch (uevent->attr.instrumentation) {
2331 case LTTNG_UST_TRACEPOINT:
2332 tmp[i].type = LTTNG_EVENT_TRACEPOINT;
2333 break;
2334 case LTTNG_UST_PROBE:
2335 tmp[i].type = LTTNG_EVENT_PROBE;
2336 break;
2337 case LTTNG_UST_FUNCTION:
2338 tmp[i].type = LTTNG_EVENT_FUNCTION;
2339 break;
0cda4f28 2340 }
8005f29a 2341 tmp[i].loglevel = uevent->attr.loglevel;
0cda4f28 2342 switch (uevent->attr.loglevel_type) {
8005f29a 2343 case LTTNG_UST_LOGLEVEL_ALL:
22e25b71 2344 tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
0cda4f28 2345 break;
8005f29a 2346 case LTTNG_UST_LOGLEVEL_RANGE:
22e25b71 2347 tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
8005f29a
MD
2348 break;
2349 case LTTNG_UST_LOGLEVEL_SINGLE:
22e25b71 2350 tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
ac3bd9c0 2351 break;
9f19cc17 2352 }
fceb65df
MD
2353 if (uevent->filter) {
2354 tmp[i].filter = 1;
2355 }
d7b75b30 2356 i++;
9f19cc17
DG
2357 }
2358
b551a063
DG
2359 ret = nb_event;
2360 *events = tmp;
2361
2362error:
2363 rcu_read_unlock();
2364 return ret;
9f19cc17
DG
2365}
2366
2367/*
b551a063 2368 * Fill lttng_event array of all kernel events in the channel.
9f19cc17 2369 */
b551a063
DG
2370static int list_lttng_kernel_events(char *channel_name,
2371 struct ltt_kernel_session *kernel_session, struct lttng_event **events)
9f19cc17 2372{
b551a063
DG
2373 int i = 0, ret;
2374 unsigned int nb_event;
9f19cc17 2375 struct ltt_kernel_event *event;
b551a063
DG
2376 struct ltt_kernel_channel *kchan;
2377
2378 kchan = trace_kernel_get_channel_by_name(channel_name, kernel_session);
2379 if (kchan == NULL) {
2380 ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
2381 goto error;
2382 }
2383
2384 nb_event = kchan->event_count;
9f19cc17
DG
2385
2386 DBG("Listing events for channel %s", kchan->channel->name);
2387
b551a063
DG
2388 if (nb_event == 0) {
2389 ret = nb_event;
2390 goto error;
2391 }
2392
2393 *events = zmalloc(nb_event * sizeof(struct lttng_event));
2394 if (*events == NULL) {
2395 ret = LTTCOMM_FATAL;
2396 goto error;
2397 }
2398
9f19cc17
DG
2399 /* Kernel channels */
2400 cds_list_for_each_entry(event, &kchan->events_list.head , list) {
b551a063
DG
2401 strncpy((*events)[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN);
2402 (*events)[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
2403 (*events)[i].enabled = event->enabled;
9f19cc17
DG
2404 switch (event->event->instrumentation) {
2405 case LTTNG_KERNEL_TRACEPOINT:
b551a063 2406 (*events)[i].type = LTTNG_EVENT_TRACEPOINT;
9f19cc17
DG
2407 break;
2408 case LTTNG_KERNEL_KPROBE:
2409 case LTTNG_KERNEL_KRETPROBE:
b551a063
DG
2410 (*events)[i].type = LTTNG_EVENT_PROBE;
2411 memcpy(&(*events)[i].attr.probe, &event->event->u.kprobe,
9f19cc17
DG
2412 sizeof(struct lttng_kernel_kprobe));
2413 break;
2414 case LTTNG_KERNEL_FUNCTION:
b551a063
DG
2415 (*events)[i].type = LTTNG_EVENT_FUNCTION;
2416 memcpy(&((*events)[i].attr.ftrace), &event->event->u.ftrace,
9f19cc17
DG
2417 sizeof(struct lttng_kernel_function));
2418 break;
0133c199 2419 case LTTNG_KERNEL_NOOP:
b551a063 2420 (*events)[i].type = LTTNG_EVENT_NOOP;
0133c199 2421 break;
a54bd42d 2422 case LTTNG_KERNEL_SYSCALL:
b551a063 2423 (*events)[i].type = LTTNG_EVENT_SYSCALL;
0133c199 2424 break;
7a3d1328
MD
2425 case LTTNG_KERNEL_ALL:
2426 assert(0);
2427 break;
9f19cc17
DG
2428 }
2429 i++;
2430 }
b551a063
DG
2431
2432 return nb_event;
2433
2434error:
2435 return ret;
9f19cc17
DG
2436}
2437
fac6795d 2438/*
54d01ffb 2439 * Command LTTNG_DISABLE_CHANNEL processed by the client thread.
fac6795d 2440 */
54d01ffb
DG
2441static int cmd_disable_channel(struct ltt_session *session,
2442 int domain, char *channel_name)
fac6795d 2443{
54d01ffb 2444 int ret;
78f0bacd
DG
2445 struct ltt_ust_session *usess;
2446
2447 usess = session->ust_session;
379473d2 2448
54d01ffb 2449 switch (domain) {
78f0bacd
DG
2450 case LTTNG_DOMAIN_KERNEL:
2451 {
2452 ret = channel_kernel_disable(session->kernel_session,
2453 channel_name);
2454 if (ret != LTTCOMM_OK) {
2455 goto error;
2456 }
54d01ffb 2457
78f0bacd
DG
2458 kernel_wait_quiescent(kernel_tracer_fd);
2459 break;
2460 }
2461 case LTTNG_DOMAIN_UST:
2462 {
2463 struct ltt_ust_channel *uchan;
bec39940 2464 struct lttng_ht *chan_ht;
78f0bacd 2465
7885e399
DG
2466 chan_ht = usess->domain_global.channels;
2467
2468 uchan = trace_ust_find_channel_by_name(chan_ht, channel_name);
78f0bacd
DG
2469 if (uchan == NULL) {
2470 ret = LTTCOMM_UST_CHAN_NOT_FOUND;
54d01ffb 2471 goto error;
78f0bacd
DG
2472 }
2473
7885e399
DG
2474 ret = channel_ust_disable(usess, domain, uchan);
2475 if (ret != LTTCOMM_OK) {
78f0bacd
DG
2476 goto error;
2477 }
78f0bacd
DG
2478 break;
2479 }
d78d6610 2480#if 0
78f0bacd
DG
2481 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
2482 case LTTNG_DOMAIN_UST_EXEC_NAME:
2483 case LTTNG_DOMAIN_UST_PID:
d78d6610 2484#endif
78f0bacd
DG
2485 default:
2486 ret = LTTCOMM_UNKNOWN_DOMAIN;
2487 goto error;
20fe2104
DG
2488 }
2489
54d01ffb 2490 ret = LTTCOMM_OK;
d65106b1 2491
54d01ffb
DG
2492error:
2493 return ret;
2494}
2495
2496/*
2497 * Command LTTNG_ENABLE_CHANNEL processed by the client thread.
2498 */
44d3bd01 2499static int cmd_enable_channel(struct ltt_session *session,
aea829b3 2500 int domain, struct lttng_channel *attr)
54d01ffb
DG
2501{
2502 int ret;
f6a9efaa 2503 struct ltt_ust_session *usess = session->ust_session;
bec39940 2504 struct lttng_ht *chan_ht;
f6a9efaa 2505
5d56b5aa 2506 DBG("Enabling channel %s for session %s", attr->name, session->name);
d65106b1 2507
aea829b3 2508 switch (domain) {
44d3bd01
DG
2509 case LTTNG_DOMAIN_KERNEL:
2510 {
2511 struct ltt_kernel_channel *kchan;
54d01ffb 2512
44d3bd01
DG
2513 kchan = trace_kernel_get_channel_by_name(attr->name,
2514 session->kernel_session);
2515 if (kchan == NULL) {
2516 ret = channel_kernel_create(session->kernel_session,
2517 attr, kernel_poll_pipe[1]);
2518 } else {
2519 ret = channel_kernel_enable(session->kernel_session, kchan);
2520 }
2521
2522 if (ret != LTTCOMM_OK) {
2523 goto error;
2524 }
2525
2526 kernel_wait_quiescent(kernel_tracer_fd);
2527 break;
2528 }
f6a9efaa
DG
2529 case LTTNG_DOMAIN_UST:
2530 {
2531 struct ltt_ust_channel *uchan;
2532
7885e399 2533 chan_ht = usess->domain_global.channels;
f6a9efaa 2534
7885e399 2535 uchan = trace_ust_find_channel_by_name(chan_ht, attr->name);
f6a9efaa 2536 if (uchan == NULL) {
7885e399 2537 ret = channel_ust_create(usess, domain, attr);
f6a9efaa 2538 } else {
7885e399 2539 ret = channel_ust_enable(usess, domain, uchan);
48842b30 2540 }
f6a9efaa
DG
2541 break;
2542 }
d78d6610 2543#if 0
78f0bacd
DG
2544 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
2545 case LTTNG_DOMAIN_UST_EXEC_NAME:
44d3bd01 2546 case LTTNG_DOMAIN_UST_PID:
d78d6610 2547#endif
44d3bd01
DG
2548 default:
2549 ret = LTTCOMM_UNKNOWN_DOMAIN;
2550 goto error;
54d01ffb
DG
2551 }
2552
54d01ffb
DG
2553error:
2554 return ret;
2555}
2556
2557/*
2558 * Command LTTNG_DISABLE_EVENT processed by the client thread.
2559 */
2560static int cmd_disable_event(struct ltt_session *session, int domain,
2561 char *channel_name, char *event_name)
2562{
2563 int ret;
54d01ffb
DG
2564
2565 switch (domain) {
2566 case LTTNG_DOMAIN_KERNEL:
2bdd86d4
MD
2567 {
2568 struct ltt_kernel_channel *kchan;
b0a40d28 2569 struct ltt_kernel_session *ksess;
2bdd86d4 2570
b0a40d28
DG
2571 ksess = session->kernel_session;
2572
2573 kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
54d01ffb
DG
2574 if (kchan == NULL) {
2575 ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
2576 goto error;
d65106b1
DG
2577 }
2578
b0a40d28 2579 ret = event_kernel_disable_tracepoint(ksess, kchan, event_name);
54d01ffb
DG
2580 if (ret != LTTCOMM_OK) {
2581 goto error;
2582 }
2583
2584 kernel_wait_quiescent(kernel_tracer_fd);
d65106b1 2585 break;
2bdd86d4
MD
2586 }
2587 case LTTNG_DOMAIN_UST:
b0a40d28 2588 {
b0a40d28 2589 struct ltt_ust_channel *uchan;
7f79d3a1 2590 struct ltt_ust_session *usess;
b0a40d28
DG
2591
2592 usess = session->ust_session;
2593
2594 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
2595 channel_name);
2596 if (uchan == NULL) {
2597 ret = LTTCOMM_UST_CHAN_NOT_FOUND;
2598 goto error;
2599 }
2600
7f79d3a1
DG
2601 ret = event_ust_disable_tracepoint(usess, domain, uchan, event_name);
2602 if (ret != LTTCOMM_OK) {
b0a40d28
DG
2603 goto error;
2604 }
2605
7f79d3a1 2606 DBG3("Disable UST event %s in channel %s completed", event_name,
b0a40d28 2607 channel_name);
b0a40d28
DG
2608 break;
2609 }
d78d6610 2610#if 0
2bdd86d4
MD
2611 case LTTNG_DOMAIN_UST_EXEC_NAME:
2612 case LTTNG_DOMAIN_UST_PID:
2613 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
d78d6610 2614#endif
54d01ffb 2615 default:
1ab1ea0b 2616 ret = LTTCOMM_UND;
54d01ffb 2617 goto error;
d65106b1 2618 }
26cc6b4e 2619
54d01ffb
DG
2620 ret = LTTCOMM_OK;
2621
2622error:
2623 return ret;
2624}
2625
2626/*
2627 * Command LTTNG_DISABLE_ALL_EVENT processed by the client thread.
2628 */
2629static int cmd_disable_event_all(struct ltt_session *session, int domain,
2630 char *channel_name)
2631{
2632 int ret;
54d01ffb
DG
2633
2634 switch (domain) {
2635 case LTTNG_DOMAIN_KERNEL:
9730260e
DG
2636 {
2637 struct ltt_kernel_session *ksess;
2638 struct ltt_kernel_channel *kchan;
2639
2640 ksess = session->kernel_session;
2641
2642 kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
54d01ffb
DG
2643 if (kchan == NULL) {
2644 ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
2645 goto error;
26cc6b4e
DG
2646 }
2647
9730260e 2648 ret = event_kernel_disable_all(ksess, kchan);
54d01ffb 2649 if (ret != LTTCOMM_OK) {
0b97ec54 2650 goto error;
26cc6b4e
DG
2651 }
2652
54d01ffb 2653 kernel_wait_quiescent(kernel_tracer_fd);
26cc6b4e 2654 break;
9730260e
DG
2655 }
2656 case LTTNG_DOMAIN_UST:
2657 {
2658 struct ltt_ust_session *usess;
2659 struct ltt_ust_channel *uchan;
2660
2661 usess = session->ust_session;
2662
2663 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
2664 channel_name);
2665 if (uchan == NULL) {
2666 ret = LTTCOMM_UST_CHAN_NOT_FOUND;
2667 goto error;
2668 }
2669
7f79d3a1
DG
2670 ret = event_ust_disable_all_tracepoints(usess, domain, uchan);
2671 if (ret != 0) {
9730260e
DG
2672 goto error;
2673 }
2674
7f79d3a1 2675 DBG3("Disable all UST events in channel %s completed", channel_name);
9730260e
DG
2676
2677 break;
2678 }
d78d6610 2679#if 0
9730260e
DG
2680 case LTTNG_DOMAIN_UST_EXEC_NAME:
2681 case LTTNG_DOMAIN_UST_PID:
2682 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
d78d6610 2683#endif
54d01ffb 2684 default:
1ab1ea0b 2685 ret = LTTCOMM_UND;
54d01ffb 2686 goto error;
26cc6b4e 2687 }
e953ef25 2688
54d01ffb 2689 ret = LTTCOMM_OK;
e953ef25 2690
54d01ffb
DG
2691error:
2692 return ret;
2693}
f5177a38 2694
54d01ffb
DG
2695/*
2696 * Command LTTNG_ADD_CONTEXT processed by the client thread.
2697 */
2698static int cmd_add_context(struct ltt_session *session, int domain,
2699 char *channel_name, char *event_name, struct lttng_event_context *ctx)
2700{
2701 int ret;
f5177a38 2702
54d01ffb
DG
2703 switch (domain) {
2704 case LTTNG_DOMAIN_KERNEL:
2705 /* Add kernel context to kernel tracer */
2706 ret = context_kernel_add(session->kernel_session, ctx,
2707 event_name, channel_name);
2708 if (ret != LTTCOMM_OK) {
f5177a38 2709 goto error;
e953ef25 2710 }
2bdd86d4
MD
2711 break;
2712 case LTTNG_DOMAIN_UST:
2713 {
55cc08a6 2714 struct ltt_ust_session *usess = session->ust_session;
e953ef25 2715
55cc08a6
DG
2716 ret = context_ust_add(usess, domain, ctx, event_name, channel_name);
2717 if (ret != LTTCOMM_OK) {
2718 goto error;
2bdd86d4 2719 }
e953ef25 2720 break;
2bdd86d4 2721 }
d78d6610 2722#if 0
55cc08a6
DG
2723 case LTTNG_DOMAIN_UST_EXEC_NAME:
2724 case LTTNG_DOMAIN_UST_PID:
2725 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
d78d6610 2726#endif
54d01ffb 2727 default:
1ab1ea0b 2728 ret = LTTCOMM_UND;
54d01ffb 2729 goto error;
e953ef25 2730 }
950131af 2731
54d01ffb 2732 ret = LTTCOMM_OK;
950131af 2733
54d01ffb
DG
2734error:
2735 return ret;
2736}
2737
53a80697
MD
2738/*
2739 * Command LTTNG_SET_FILTER processed by the client thread.
2740 */
2741static int cmd_set_filter(struct ltt_session *session, int domain,
2742 char *channel_name, char *event_name,
2743 struct lttng_filter_bytecode *bytecode)
2744{
2745 int ret;
2746
2747 switch (domain) {
2748 case LTTNG_DOMAIN_KERNEL:
2749 ret = LTTCOMM_FATAL;
2750 break;
2751 case LTTNG_DOMAIN_UST:
2752 {
2753 struct ltt_ust_session *usess = session->ust_session;
2754
2755 ret = filter_ust_set(usess, domain, bytecode, event_name, channel_name);
2756 if (ret != LTTCOMM_OK) {
2757 goto error;
2758 }
2759 break;
2760 }
2761#if 0
2762 case LTTNG_DOMAIN_UST_EXEC_NAME:
2763 case LTTNG_DOMAIN_UST_PID:
2764 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
2765#endif
2766 default:
2767 ret = LTTCOMM_UND;
2768 goto error;
2769 }
2770
2771 ret = LTTCOMM_OK;
2772
2773error:
2774 return ret;
2775
2776}
2777
54d01ffb
DG
2778/*
2779 * Command LTTNG_ENABLE_EVENT processed by the client thread.
2780 */
2781static int cmd_enable_event(struct ltt_session *session, int domain,
2782 char *channel_name, struct lttng_event *event)
2783{
2784 int ret;
f6cd6b0f 2785 struct lttng_channel *attr;
48842b30 2786 struct ltt_ust_session *usess = session->ust_session;
54d01ffb
DG
2787
2788 switch (domain) {
2789 case LTTNG_DOMAIN_KERNEL:
2bdd86d4
MD
2790 {
2791 struct ltt_kernel_channel *kchan;
2792
54d01ffb
DG
2793 kchan = trace_kernel_get_channel_by_name(channel_name,
2794 session->kernel_session);
2795 if (kchan == NULL) {
f6cd6b0f
DG
2796 attr = channel_new_default_attr(domain);
2797 if (attr == NULL) {
2798 ret = LTTCOMM_FATAL;
2799 goto error;
2800 }
2801 snprintf(attr->name, NAME_MAX, "%s", channel_name);
2802
54d01ffb 2803 /* This call will notify the kernel thread */
44d3bd01 2804 ret = channel_kernel_create(session->kernel_session,
f6cd6b0f 2805 attr, kernel_poll_pipe[1]);
54d01ffb 2806 if (ret != LTTCOMM_OK) {
ff4d74e6 2807 free(attr);
f5177a38
DG
2808 goto error;
2809 }
ff4d74e6 2810 free(attr);
54d01ffb 2811 }
950131af 2812
54d01ffb
DG
2813 /* Get the newly created kernel channel pointer */
2814 kchan = trace_kernel_get_channel_by_name(channel_name,
2815 session->kernel_session);
2816 if (kchan == NULL) {
2817 /* This sould not happen... */
2818 ret = LTTCOMM_FATAL;
2819 goto error;
2820 }
f5177a38 2821
48842b30
DG
2822 ret = event_kernel_enable_tracepoint(session->kernel_session, kchan,
2823 event);
54d01ffb 2824 if (ret != LTTCOMM_OK) {
f5177a38 2825 goto error;
950131af
DG
2826 }
2827
54d01ffb 2828 kernel_wait_quiescent(kernel_tracer_fd);
950131af 2829 break;
2bdd86d4
MD
2830 }
2831 case LTTNG_DOMAIN_UST:
2832 {
aea829b3 2833 struct lttng_channel *attr;
edb67388 2834 struct ltt_ust_channel *uchan;
2bdd86d4 2835
edb67388 2836 /* Get channel from global UST domain */
48842b30
DG
2837 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
2838 channel_name);
2839 if (uchan == NULL) {
aea829b3
DG
2840 /* Create default channel */
2841 attr = channel_new_default_attr(domain);
2842 if (attr == NULL) {
2843 ret = LTTCOMM_FATAL;
2844 goto error;
2845 }
596219f7 2846 snprintf(attr->name, NAME_MAX, "%s", channel_name);
edb67388 2847 attr->name[NAME_MAX - 1] = '\0';
aea829b3 2848
7885e399 2849 ret = channel_ust_create(usess, domain, attr);
edb67388 2850 if (ret != LTTCOMM_OK) {
ff4d74e6 2851 free(attr);
aea829b3
DG
2852 goto error;
2853 }
aea829b3
DG
2854 free(attr);
2855
2856 /* Get the newly created channel reference back */
2857 uchan = trace_ust_find_channel_by_name(
2858 usess->domain_global.channels, channel_name);
2859 if (uchan == NULL) {
2860 /* Something is really wrong */
2861 ret = LTTCOMM_FATAL;
2862 goto error;
2863 }
48842b30 2864 }
2bdd86d4 2865
edb67388 2866 /* At this point, the session and channel exist on the tracer */
edb67388
DG
2867 ret = event_ust_enable_tracepoint(usess, domain, uchan, event);
2868 if (ret != LTTCOMM_OK) {
48842b30 2869 goto error;
2bdd86d4
MD
2870 }
2871 break;
2872 }
d78d6610 2873#if 0
2bdd86d4
MD
2874 case LTTNG_DOMAIN_UST_EXEC_NAME:
2875 case LTTNG_DOMAIN_UST_PID:
2876 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
d78d6610 2877#endif
54d01ffb 2878 default:
1ab1ea0b 2879 ret = LTTCOMM_UND;
54d01ffb 2880 goto error;
950131af 2881 }
d36b8583 2882
54d01ffb 2883 ret = LTTCOMM_OK;
d36b8583 2884
54d01ffb
DG
2885error:
2886 return ret;
2887}
7d29a247 2888
54d01ffb
DG
2889/*
2890 * Command LTTNG_ENABLE_ALL_EVENT processed by the client thread.
2891 */
2892static int cmd_enable_event_all(struct ltt_session *session, int domain,
8c9ae521 2893 char *channel_name, int event_type)
54d01ffb
DG
2894{
2895 int ret;
2896 struct ltt_kernel_channel *kchan;
7d29a247 2897
54d01ffb
DG
2898 switch (domain) {
2899 case LTTNG_DOMAIN_KERNEL:
2900 kchan = trace_kernel_get_channel_by_name(channel_name,
2901 session->kernel_session);
2902 if (kchan == NULL) {
2903 /* This call will notify the kernel thread */
44d3bd01
DG
2904 ret = channel_kernel_create(session->kernel_session, NULL,
2905 kernel_poll_pipe[1]);
54d01ffb
DG
2906 if (ret != LTTCOMM_OK) {
2907 goto error;
d36b8583 2908 }
0d0c377a 2909
8f69e5eb
DG
2910 /* Get the newly created kernel channel pointer */
2911 kchan = trace_kernel_get_channel_by_name(channel_name,
2912 session->kernel_session);
2913 if (kchan == NULL) {
2914 /* This sould not happen... */
2915 ret = LTTCOMM_FATAL;
2916 goto error;
2917 }
2918
54d01ffb 2919 }
0fdd1e2c 2920
7a3d1328 2921 switch (event_type) {
76d45b40 2922 case LTTNG_EVENT_SYSCALL:
7a3d1328 2923 ret = event_kernel_enable_all_syscalls(session->kernel_session,
8c9ae521 2924 kchan, kernel_tracer_fd);
7a3d1328 2925 break;
76d45b40 2926 case LTTNG_EVENT_TRACEPOINT:
8c9ae521 2927 /*
7a3d1328
MD
2928 * This call enables all LTTNG_KERNEL_TRACEPOINTS and
2929 * events already registered to the channel.
8c9ae521 2930 */
7a3d1328
MD
2931 ret = event_kernel_enable_all_tracepoints(session->kernel_session,
2932 kchan, kernel_tracer_fd);
2933 break;
76d45b40 2934 case LTTNG_EVENT_ALL:
7a3d1328 2935 /* Enable syscalls and tracepoints */
8c9ae521
DG
2936 ret = event_kernel_enable_all(session->kernel_session,
2937 kchan, kernel_tracer_fd);
7a3d1328
MD
2938 break;
2939 default:
2940 ret = LTTCOMM_KERN_ENABLE_FAIL;
2941 goto error;
8c9ae521 2942 }
8f69e5eb
DG
2943
2944 /* Manage return value */
54d01ffb 2945 if (ret != LTTCOMM_OK) {
0d0c377a 2946 goto error;
d36b8583
DG
2947 }
2948
54d01ffb 2949 kernel_wait_quiescent(kernel_tracer_fd);
d36b8583 2950 break;
76d45b40
DG
2951 case LTTNG_DOMAIN_UST:
2952 {
2953 struct lttng_channel *attr;
2954 struct ltt_ust_channel *uchan;
2955 struct ltt_ust_session *usess = session->ust_session;
2956
2957 /* Get channel from global UST domain */
2958 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
2959 channel_name);
2960 if (uchan == NULL) {
2961 /* Create default channel */
2962 attr = channel_new_default_attr(domain);
2963 if (attr == NULL) {
2964 ret = LTTCOMM_FATAL;
2965 goto error;
2966 }
2967 snprintf(attr->name, NAME_MAX, "%s", channel_name);
2968 attr->name[NAME_MAX - 1] = '\0';
2969
2970 /* Use the internal command enable channel */
7885e399 2971 ret = channel_ust_create(usess, domain, attr);
76d45b40
DG
2972 if (ret != LTTCOMM_OK) {
2973 free(attr);
2974 goto error;
2975 }
2976 free(attr);
2977
2978 /* Get the newly created channel reference back */
2979 uchan = trace_ust_find_channel_by_name(
2980 usess->domain_global.channels, channel_name);
2981 if (uchan == NULL) {
2982 /* Something is really wrong */
2983 ret = LTTCOMM_FATAL;
2984 goto error;
2985 }
2986 }
2987
2988 /* At this point, the session and channel exist on the tracer */
2989
2990 switch (event_type) {
2991 case LTTNG_EVENT_ALL:
2992 case LTTNG_EVENT_TRACEPOINT:
2993 ret = event_ust_enable_all_tracepoints(usess, domain, uchan);
2994 if (ret != LTTCOMM_OK) {
2995 goto error;
2996 }
2997 break;
2998 default:
2999 ret = LTTCOMM_UST_ENABLE_FAIL;
3000 goto error;
3001 }
3002
3003 /* Manage return value */
3004 if (ret != LTTCOMM_OK) {
3005 goto error;
3006 }
3007
3008 break;
3009 }
d78d6610 3010#if 0
76d45b40
DG
3011 case LTTNG_DOMAIN_UST_EXEC_NAME:
3012 case LTTNG_DOMAIN_UST_PID:
3013 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
d78d6610 3014#endif
54d01ffb 3015 default:
1ab1ea0b 3016 ret = LTTCOMM_UND;
54d01ffb 3017 goto error;
d36b8583 3018 }
f3ed775e 3019
54d01ffb
DG
3020 ret = LTTCOMM_OK;
3021
3022error:
3023 return ret;
3024}
3025
3026/*
3027 * Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
3028 */
3029static ssize_t cmd_list_tracepoints(int domain, struct lttng_event **events)
3030{
3031 int ret;
3032 ssize_t nb_events = 0;
3033
3034 switch (domain) {
3035 case LTTNG_DOMAIN_KERNEL:
3036 nb_events = kernel_list_events(kernel_tracer_fd, events);
3037 if (nb_events < 0) {
3038 ret = LTTCOMM_KERN_LIST_FAIL;
3039 goto error;
894be886 3040 }
54d01ffb 3041 break;
b551a063
DG
3042 case LTTNG_DOMAIN_UST:
3043 nb_events = ust_app_list_events(events);
3044 if (nb_events < 0) {
3045 ret = LTTCOMM_UST_LIST_FAIL;
3046 goto error;
3047 }
3048 break;
54d01ffb 3049 default:
1ab1ea0b 3050 ret = LTTCOMM_UND;
54d01ffb
DG
3051 goto error;
3052 }
894be886 3053
54d01ffb 3054 return nb_events;
7d29a247 3055
54d01ffb
DG
3056error:
3057 /* Return negative value to differentiate return code */
3058 return -ret;
3059}
b389abbe 3060
f37d259d
MD
3061/*
3062 * Command LTTNG_LIST_TRACEPOINT_FIELDS processed by the client thread.
3063 */
3064static ssize_t cmd_list_tracepoint_fields(int domain,
3065 struct lttng_event_field **fields)
3066{
3067 int ret;
3068 ssize_t nb_fields = 0;
3069
3070 switch (domain) {
3071 case LTTNG_DOMAIN_UST:
3072 nb_fields = ust_app_list_event_fields(fields);
3073 if (nb_fields < 0) {
3074 ret = LTTCOMM_UST_LIST_FAIL;
3075 goto error;
3076 }
3077 break;
3078 case LTTNG_DOMAIN_KERNEL:
3079 default: /* fall-through */
3080 ret = LTTCOMM_UND;
3081 goto error;
3082 }
3083
3084 return nb_fields;
3085
3086error:
3087 /* Return negative value to differentiate return code */
3088 return -ret;
3089}
3090
54d01ffb
DG
3091/*
3092 * Command LTTNG_START_TRACE processed by the client thread.
3093 */
3094static int cmd_start_trace(struct ltt_session *session)
3095{
3096 int ret;
54d01ffb 3097 struct ltt_kernel_session *ksession;
b9d9b220 3098 struct ltt_ust_session *usess;
00e2e675 3099 struct ltt_kernel_channel *kchan;
b389abbe 3100
00e2e675 3101 /* Ease our life a bit ;) */
54d01ffb 3102 ksession = session->kernel_session;
b9d9b220 3103 usess = session->ust_session;
5eb91c98 3104
b9ef1c83 3105 if (session->enabled) {
80e327fa
DG
3106 /* Already started. */
3107 ret = LTTCOMM_TRACE_ALREADY_STARTED;
b9ef1c83
DG
3108 goto error;
3109 }
3110
464dd62d
MD
3111 session->enabled = 1;
3112
00e2e675
DG
3113 ret = setup_relayd(session);
3114 if (ret != LTTCOMM_OK) {
3115 ERR("Error setting up relayd for session %s", session->name);
3116 goto error;
3117 }
3118
54d01ffb
DG
3119 /* Kernel tracing */
3120 if (ksession != NULL) {
3121 /* Open kernel metadata */
3122 if (ksession->metadata == NULL) {
00e2e675
DG
3123 ret = kernel_open_metadata(ksession,
3124 ksession->consumer->dst.trace_path);
54d01ffb
DG
3125 if (ret < 0) {
3126 ret = LTTCOMM_KERN_META_FAIL;
3127 goto error;
b389abbe 3128 }
54d01ffb 3129 }
7d29a247 3130
54d01ffb 3131 /* Open kernel metadata stream */
03550b58 3132 if (ksession->metadata_stream_fd < 0) {
54d01ffb
DG
3133 ret = kernel_open_metadata_stream(ksession);
3134 if (ret < 0) {
3135 ERR("Kernel create metadata stream failed");
3136 ret = LTTCOMM_KERN_STREAM_FAIL;
3137 goto error;
3138 }
3139 }
3140
3141 /* For each channel */
3142 cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
3143 if (kchan->stream_count == 0) {
3144 ret = kernel_open_channel_stream(kchan);
3145 if (ret < 0) {
3146 ret = LTTCOMM_KERN_STREAM_FAIL;
7d29a247
DG
3147 goto error;
3148 }
54d01ffb
DG
3149 /* Update the stream global counter */
3150 ksession->stream_count_global += ret;
7d29a247 3151 }
54d01ffb
DG
3152 }
3153
3154 /* Setup kernel consumer socket and send fds to it */
3155 ret = init_kernel_tracing(ksession);
3156 if (ret < 0) {
3157 ret = LTTCOMM_KERN_START_FAIL;
3158 goto error;
3159 }
3160
3161 /* This start the kernel tracing */
3162 ret = kernel_start_session(ksession);
3163 if (ret < 0) {
3164 ret = LTTCOMM_KERN_START_FAIL;
3165 goto error;
3166 }
3167
3168 /* Quiescent wait after starting trace */
3169 kernel_wait_quiescent(kernel_tracer_fd);
3170 }
3171
36dc12cc 3172 /* Flag session that trace should start automatically */
b9d9b220
DG
3173 if (usess) {
3174 usess->start_trace = 1;
36dc12cc 3175
b9d9b220
DG
3176 ret = ust_app_start_trace_all(usess);
3177 if (ret < 0) {
3178 ret = LTTCOMM_UST_START_FAIL;
3179 goto error;
3180 }
2bdd86d4 3181 }
54d01ffb
DG
3182
3183 ret = LTTCOMM_OK;
3184
3185error:
3186 return ret;
3187}
3188
3189/*
3190 * Command LTTNG_STOP_TRACE processed by the client thread.
3191 */
3192static int cmd_stop_trace(struct ltt_session *session)
3193{
3194 int ret;
3195 struct ltt_kernel_channel *kchan;
3196 struct ltt_kernel_session *ksession;
8be98f9a 3197 struct ltt_ust_session *usess;
54d01ffb
DG
3198
3199 /* Short cut */
3200 ksession = session->kernel_session;
8be98f9a 3201 usess = session->ust_session;
54d01ffb 3202
b9ef1c83 3203 if (!session->enabled) {
80e327fa 3204 ret = LTTCOMM_TRACE_ALREADY_STOPPED;
b9ef1c83
DG
3205 goto error;
3206 }
3207
464dd62d
MD
3208 session->enabled = 0;
3209
54d01ffb
DG
3210 /* Kernel tracer */
3211 if (ksession != NULL) {
3212 DBG("Stop kernel tracing");
3213
00e2e675
DG
3214 /* Flush metadata if exist */
3215 if (ksession->metadata_stream_fd >= 0) {
3216 ret = kernel_metadata_flush_buffer(ksession->metadata_stream_fd);
3217 if (ret < 0) {
3218 ERR("Kernel metadata flush failed");
3219 }
54d01ffb 3220 }
f34daff7 3221
00e2e675 3222 /* Flush all buffers before stopping */
54d01ffb
DG
3223 cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
3224 ret = kernel_flush_buffer(kchan);
0d0c377a 3225 if (ret < 0) {
54d01ffb 3226 ERR("Kernel flush buffer error");
7d29a247 3227 }
54d01ffb 3228 }
19e70852 3229
54d01ffb
DG
3230 ret = kernel_stop_session(ksession);
3231 if (ret < 0) {
3232 ret = LTTCOMM_KERN_STOP_FAIL;
19e70852 3233 goto error;
f3ed775e 3234 }
54d01ffb
DG
3235
3236 kernel_wait_quiescent(kernel_tracer_fd);
894be886 3237 }
54d01ffb 3238
8be98f9a
MD
3239 if (usess) {
3240 usess->start_trace = 0;
2bdd86d4 3241
8be98f9a 3242 ret = ust_app_stop_trace_all(usess);
2bdd86d4 3243 if (ret < 0) {
190df5ac 3244 ret = LTTCOMM_UST_STOP_FAIL;
2bdd86d4
MD
3245 goto error;
3246 }
2bdd86d4 3247 }
54d01ffb
DG
3248
3249 ret = LTTCOMM_OK;
3250
3251error:
3252 return ret;
3253}
3254