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