Fix: syscall list ioctl number conflict
[lttng-tools.git] / src / bin / lttng-sessiond / main.c
1 /*
2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 * Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
4 * 2013 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License, version 2 only,
8 * as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 #define _GNU_SOURCE
21 #include <getopt.h>
22 #include <grp.h>
23 #include <limits.h>
24 #include <paths.h>
25 #include <pthread.h>
26 #include <signal.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <inttypes.h>
31 #include <sys/mman.h>
32 #include <sys/mount.h>
33 #include <sys/resource.h>
34 #include <sys/socket.h>
35 #include <sys/stat.h>
36 #include <sys/types.h>
37 #include <sys/wait.h>
38 #include <urcu/uatomic.h>
39 #include <unistd.h>
40 #include <config.h>
41
42 #include <common/common.h>
43 #include <common/compat/socket.h>
44 #include <common/defaults.h>
45 #include <common/kernel-consumer/kernel-consumer.h>
46 #include <common/futex.h>
47 #include <common/relayd/relayd.h>
48 #include <common/utils.h>
49 #include <common/daemonize.h>
50 #include <common/config/config.h>
51
52 #include "lttng-sessiond.h"
53 #include "buffer-registry.h"
54 #include "channel.h"
55 #include "cmd.h"
56 #include "consumer.h"
57 #include "context.h"
58 #include "event.h"
59 #include "kernel.h"
60 #include "kernel-consumer.h"
61 #include "modprobe.h"
62 #include "shm.h"
63 #include "ust-ctl.h"
64 #include "ust-consumer.h"
65 #include "utils.h"
66 #include "fd-limit.h"
67 #include "health-sessiond.h"
68 #include "testpoint.h"
69 #include "ust-thread.h"
70 #include "agent-thread.h"
71 #include "save.h"
72 #include "load-session-thread.h"
73 #include "syscall.h"
74
75 #define CONSUMERD_FILE "lttng-consumerd"
76
77 const char *progname;
78 static const char *tracing_group_name = DEFAULT_TRACING_GROUP;
79 static int tracing_group_name_override;
80 static char *opt_pidfile;
81 static int opt_sig_parent;
82 static int opt_verbose_consumer;
83 static int opt_daemon, opt_background;
84 static int opt_no_kernel;
85 static char *opt_load_session_path;
86 static pid_t ppid; /* Parent PID for --sig-parent option */
87 static pid_t child_ppid; /* Internal parent PID use with daemonize. */
88 static char *rundir;
89 static int lockfile_fd = -1;
90
91 /* Set to 1 when a SIGUSR1 signal is received. */
92 static int recv_child_signal;
93
94 /*
95 * Consumer daemon specific control data. Every value not initialized here is
96 * set to 0 by the static definition.
97 */
98 static struct consumer_data kconsumer_data = {
99 .type = LTTNG_CONSUMER_KERNEL,
100 .err_unix_sock_path = DEFAULT_KCONSUMERD_ERR_SOCK_PATH,
101 .cmd_unix_sock_path = DEFAULT_KCONSUMERD_CMD_SOCK_PATH,
102 .err_sock = -1,
103 .cmd_sock = -1,
104 .pid_mutex = PTHREAD_MUTEX_INITIALIZER,
105 .lock = PTHREAD_MUTEX_INITIALIZER,
106 .cond = PTHREAD_COND_INITIALIZER,
107 .cond_mutex = PTHREAD_MUTEX_INITIALIZER,
108 };
109 static struct consumer_data ustconsumer64_data = {
110 .type = LTTNG_CONSUMER64_UST,
111 .err_unix_sock_path = DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH,
112 .cmd_unix_sock_path = DEFAULT_USTCONSUMERD64_CMD_SOCK_PATH,
113 .err_sock = -1,
114 .cmd_sock = -1,
115 .pid_mutex = PTHREAD_MUTEX_INITIALIZER,
116 .lock = PTHREAD_MUTEX_INITIALIZER,
117 .cond = PTHREAD_COND_INITIALIZER,
118 .cond_mutex = PTHREAD_MUTEX_INITIALIZER,
119 };
120 static struct consumer_data ustconsumer32_data = {
121 .type = LTTNG_CONSUMER32_UST,
122 .err_unix_sock_path = DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH,
123 .cmd_unix_sock_path = DEFAULT_USTCONSUMERD32_CMD_SOCK_PATH,
124 .err_sock = -1,
125 .cmd_sock = -1,
126 .pid_mutex = PTHREAD_MUTEX_INITIALIZER,
127 .lock = PTHREAD_MUTEX_INITIALIZER,
128 .cond = PTHREAD_COND_INITIALIZER,
129 .cond_mutex = PTHREAD_MUTEX_INITIALIZER,
130 };
131
132 /* Command line options */
133 static const struct option long_options[] = {
134 { "client-sock", 1, 0, 'c' },
135 { "apps-sock", 1, 0, 'a' },
136 { "kconsumerd-cmd-sock", 1, 0, 'C' },
137 { "kconsumerd-err-sock", 1, 0, 'E' },
138 { "ustconsumerd32-cmd-sock", 1, 0, 'G' },
139 { "ustconsumerd32-err-sock", 1, 0, 'H' },
140 { "ustconsumerd64-cmd-sock", 1, 0, 'D' },
141 { "ustconsumerd64-err-sock", 1, 0, 'F' },
142 { "consumerd32-path", 1, 0, 'u' },
143 { "consumerd32-libdir", 1, 0, 'U' },
144 { "consumerd64-path", 1, 0, 't' },
145 { "consumerd64-libdir", 1, 0, 'T' },
146 { "daemonize", 0, 0, 'd' },
147 { "background", 0, 0, 'b' },
148 { "sig-parent", 0, 0, 'S' },
149 { "help", 0, 0, 'h' },
150 { "group", 1, 0, 'g' },
151 { "version", 0, 0, 'V' },
152 { "quiet", 0, 0, 'q' },
153 { "verbose", 0, 0, 'v' },
154 { "verbose-consumer", 0, 0, 'Z' },
155 { "no-kernel", 0, 0, 'N' },
156 { "pidfile", 1, 0, 'p' },
157 { "agent-tcp-port", 1, 0, 'J' },
158 { "config", 1, 0, 'f' },
159 { "load", 1, 0, 'l' },
160 { "kmod-probes", 1, 0, 'P' },
161 { "extra-kmod-probes", 1, 0, 'e' },
162 { NULL, 0, 0, 0 }
163 };
164
165 /* Command line options to ignore from configuration file */
166 static const char *config_ignore_options[] = { "help", "version", "config" };
167
168 /* Shared between threads */
169 static int dispatch_thread_exit;
170
171 /* Global application Unix socket path */
172 static char apps_unix_sock_path[PATH_MAX];
173 /* Global client Unix socket path */
174 static char client_unix_sock_path[PATH_MAX];
175 /* global wait shm path for UST */
176 static char wait_shm_path[PATH_MAX];
177 /* Global health check unix path */
178 static char health_unix_sock_path[PATH_MAX];
179
180 /* Sockets and FDs */
181 static int client_sock = -1;
182 static int apps_sock = -1;
183 int kernel_tracer_fd = -1;
184 static int kernel_poll_pipe[2] = { -1, -1 };
185
186 /*
187 * Quit pipe for all threads. This permits a single cancellation point
188 * for all threads when receiving an event on the pipe.
189 */
190 static int thread_quit_pipe[2] = { -1, -1 };
191
192 /*
193 * This pipe is used to inform the thread managing application communication
194 * that a command is queued and ready to be processed.
195 */
196 static int apps_cmd_pipe[2] = { -1, -1 };
197
198 int apps_cmd_notify_pipe[2] = { -1, -1 };
199
200 /* Pthread, Mutexes and Semaphores */
201 static pthread_t apps_thread;
202 static pthread_t apps_notify_thread;
203 static pthread_t reg_apps_thread;
204 static pthread_t client_thread;
205 static pthread_t kernel_thread;
206 static pthread_t dispatch_thread;
207 static pthread_t health_thread;
208 static pthread_t ht_cleanup_thread;
209 static pthread_t agent_reg_thread;
210 static pthread_t load_session_thread;
211
212 /*
213 * UST registration command queue. This queue is tied with a futex and uses a N
214 * wakers / 1 waiter implemented and detailed in futex.c/.h
215 *
216 * The thread_registration_apps and thread_dispatch_ust_registration uses this
217 * queue along with the wait/wake scheme. The thread_manage_apps receives down
218 * the line new application socket and monitors it for any I/O error or clean
219 * close that triggers an unregistration of the application.
220 */
221 static struct ust_cmd_queue ust_cmd_queue;
222
223 /*
224 * Pointer initialized before thread creation.
225 *
226 * This points to the tracing session list containing the session count and a
227 * mutex lock. The lock MUST be taken if you iterate over the list. The lock
228 * MUST NOT be taken if you call a public function in session.c.
229 *
230 * The lock is nested inside the structure: session_list_ptr->lock. Please use
231 * session_lock_list and session_unlock_list for lock acquisition.
232 */
233 static struct ltt_session_list *session_list_ptr;
234
235 int ust_consumerd64_fd = -1;
236 int ust_consumerd32_fd = -1;
237
238 static const char *consumerd32_bin = CONFIG_CONSUMERD32_BIN;
239 static const char *consumerd64_bin = CONFIG_CONSUMERD64_BIN;
240 static const char *consumerd32_libdir = CONFIG_CONSUMERD32_LIBDIR;
241 static const char *consumerd64_libdir = CONFIG_CONSUMERD64_LIBDIR;
242 static int consumerd32_bin_override;
243 static int consumerd64_bin_override;
244 static int consumerd32_libdir_override;
245 static int consumerd64_libdir_override;
246
247 static const char *module_proc_lttng = "/proc/lttng";
248
249 /*
250 * Consumer daemon state which is changed when spawning it, killing it or in
251 * case of a fatal error.
252 */
253 enum consumerd_state {
254 CONSUMER_STARTED = 1,
255 CONSUMER_STOPPED = 2,
256 CONSUMER_ERROR = 3,
257 };
258
259 /*
260 * This consumer daemon state is used to validate if a client command will be
261 * able to reach the consumer. If not, the client is informed. For instance,
262 * doing a "lttng start" when the consumer state is set to ERROR will return an
263 * error to the client.
264 *
265 * The following example shows a possible race condition of this scheme:
266 *
267 * consumer thread error happens
268 * client cmd arrives
269 * client cmd checks state -> still OK
270 * consumer thread exit, sets error
271 * client cmd try to talk to consumer
272 * ...
273 *
274 * However, since the consumer is a different daemon, we have no way of making
275 * sure the command will reach it safely even with this state flag. This is why
276 * we consider that up to the state validation during command processing, the
277 * command is safe. After that, we can not guarantee the correctness of the
278 * client request vis-a-vis the consumer.
279 */
280 static enum consumerd_state ust_consumerd_state;
281 static enum consumerd_state kernel_consumerd_state;
282
283 /*
284 * Socket timeout for receiving and sending in seconds.
285 */
286 static int app_socket_timeout;
287
288 /* Set in main() with the current page size. */
289 long page_size;
290
291 /* Application health monitoring */
292 struct health_app *health_sessiond;
293
294 /* Agent TCP port for registration. Used by the agent thread. */
295 unsigned int agent_tcp_port = DEFAULT_AGENT_TCP_PORT;
296
297 /* Am I root or not. */
298 int is_root; /* Set to 1 if the daemon is running as root */
299
300 const char * const config_section_name = "sessiond";
301
302 /* Load session thread information to operate. */
303 struct load_session_thread_data *load_info;
304
305 /*
306 * Whether sessiond is ready for commands/health check requests.
307 * NR_LTTNG_SESSIOND_READY must match the number of calls to
308 * sessiond_notify_ready().
309 */
310 #define NR_LTTNG_SESSIOND_READY 3
311 int lttng_sessiond_ready = NR_LTTNG_SESSIOND_READY;
312
313 /* Notify parents that we are ready for cmd and health check */
314 LTTNG_HIDDEN
315 void sessiond_notify_ready(void)
316 {
317 if (uatomic_sub_return(&lttng_sessiond_ready, 1) == 0) {
318 /*
319 * Notify parent pid that we are ready to accept command
320 * for client side. This ppid is the one from the
321 * external process that spawned us.
322 */
323 if (opt_sig_parent) {
324 kill(ppid, SIGUSR1);
325 }
326
327 /*
328 * Notify the parent of the fork() process that we are
329 * ready.
330 */
331 if (opt_daemon || opt_background) {
332 kill(child_ppid, SIGUSR1);
333 }
334 }
335 }
336
337 static
338 void setup_consumerd_path(void)
339 {
340 const char *bin, *libdir;
341
342 /*
343 * Allow INSTALL_BIN_PATH to be used as a target path for the
344 * native architecture size consumer if CONFIG_CONSUMER*_PATH
345 * has not been defined.
346 */
347 #if (CAA_BITS_PER_LONG == 32)
348 if (!consumerd32_bin[0]) {
349 consumerd32_bin = INSTALL_BIN_PATH "/" CONSUMERD_FILE;
350 }
351 if (!consumerd32_libdir[0]) {
352 consumerd32_libdir = INSTALL_LIB_PATH;
353 }
354 #elif (CAA_BITS_PER_LONG == 64)
355 if (!consumerd64_bin[0]) {
356 consumerd64_bin = INSTALL_BIN_PATH "/" CONSUMERD_FILE;
357 }
358 if (!consumerd64_libdir[0]) {
359 consumerd64_libdir = INSTALL_LIB_PATH;
360 }
361 #else
362 #error "Unknown bitness"
363 #endif
364
365 /*
366 * runtime env. var. overrides the build default.
367 */
368 bin = getenv("LTTNG_CONSUMERD32_BIN");
369 if (bin) {
370 consumerd32_bin = bin;
371 }
372 bin = getenv("LTTNG_CONSUMERD64_BIN");
373 if (bin) {
374 consumerd64_bin = bin;
375 }
376 libdir = getenv("LTTNG_CONSUMERD32_LIBDIR");
377 if (libdir) {
378 consumerd32_libdir = libdir;
379 }
380 libdir = getenv("LTTNG_CONSUMERD64_LIBDIR");
381 if (libdir) {
382 consumerd64_libdir = libdir;
383 }
384 }
385
386 /*
387 * Create a poll set with O_CLOEXEC and add the thread quit pipe to the set.
388 */
389 int sessiond_set_thread_pollset(struct lttng_poll_event *events, size_t size)
390 {
391 int ret;
392
393 assert(events);
394
395 ret = lttng_poll_create(events, size, LTTNG_CLOEXEC);
396 if (ret < 0) {
397 goto error;
398 }
399
400 /* Add quit pipe */
401 ret = lttng_poll_add(events, thread_quit_pipe[0], LPOLLIN | LPOLLERR);
402 if (ret < 0) {
403 goto error;
404 }
405
406 return 0;
407
408 error:
409 return ret;
410 }
411
412 /*
413 * Check if the thread quit pipe was triggered.
414 *
415 * Return 1 if it was triggered else 0;
416 */
417 int sessiond_check_thread_quit_pipe(int fd, uint32_t events)
418 {
419 if (fd == thread_quit_pipe[0] && (events & LPOLLIN)) {
420 return 1;
421 }
422
423 return 0;
424 }
425
426 /*
427 * Init thread quit pipe.
428 *
429 * Return -1 on error or 0 if all pipes are created.
430 */
431 static int init_thread_quit_pipe(void)
432 {
433 int ret, i;
434
435 ret = pipe(thread_quit_pipe);
436 if (ret < 0) {
437 PERROR("thread quit pipe");
438 goto error;
439 }
440
441 for (i = 0; i < 2; i++) {
442 ret = fcntl(thread_quit_pipe[i], F_SETFD, FD_CLOEXEC);
443 if (ret < 0) {
444 PERROR("fcntl");
445 goto error;
446 }
447 }
448
449 error:
450 return ret;
451 }
452
453 /*
454 * Stop all threads by closing the thread quit pipe.
455 */
456 static void stop_threads(void)
457 {
458 int ret;
459
460 /* Stopping all threads */
461 DBG("Terminating all threads");
462 ret = notify_thread_pipe(thread_quit_pipe[1]);
463 if (ret < 0) {
464 ERR("write error on thread quit pipe");
465 }
466
467 /* Dispatch thread */
468 CMM_STORE_SHARED(dispatch_thread_exit, 1);
469 futex_nto1_wake(&ust_cmd_queue.futex);
470 }
471
472 /*
473 * Close every consumer sockets.
474 */
475 static void close_consumer_sockets(void)
476 {
477 int ret;
478
479 if (kconsumer_data.err_sock >= 0) {
480 ret = close(kconsumer_data.err_sock);
481 if (ret < 0) {
482 PERROR("kernel consumer err_sock close");
483 }
484 }
485 if (ustconsumer32_data.err_sock >= 0) {
486 ret = close(ustconsumer32_data.err_sock);
487 if (ret < 0) {
488 PERROR("UST consumerd32 err_sock close");
489 }
490 }
491 if (ustconsumer64_data.err_sock >= 0) {
492 ret = close(ustconsumer64_data.err_sock);
493 if (ret < 0) {
494 PERROR("UST consumerd64 err_sock close");
495 }
496 }
497 if (kconsumer_data.cmd_sock >= 0) {
498 ret = close(kconsumer_data.cmd_sock);
499 if (ret < 0) {
500 PERROR("kernel consumer cmd_sock close");
501 }
502 }
503 if (ustconsumer32_data.cmd_sock >= 0) {
504 ret = close(ustconsumer32_data.cmd_sock);
505 if (ret < 0) {
506 PERROR("UST consumerd32 cmd_sock close");
507 }
508 }
509 if (ustconsumer64_data.cmd_sock >= 0) {
510 ret = close(ustconsumer64_data.cmd_sock);
511 if (ret < 0) {
512 PERROR("UST consumerd64 cmd_sock close");
513 }
514 }
515 }
516
517 /*
518 * Generate the full lock file path using the rundir.
519 *
520 * Return the snprintf() return value thus a negative value is an error.
521 */
522 static int generate_lock_file_path(char *path, size_t len)
523 {
524 int ret;
525
526 assert(path);
527 assert(rundir);
528
529 /* Build lockfile path from rundir. */
530 ret = snprintf(path, len, "%s/" DEFAULT_LTTNG_SESSIOND_LOCKFILE, rundir);
531 if (ret < 0) {
532 PERROR("snprintf lockfile path");
533 }
534
535 return ret;
536 }
537
538 /*
539 * Cleanup the daemon
540 */
541 static void cleanup(void)
542 {
543 int ret;
544 struct ltt_session *sess, *stmp;
545 char path[PATH_MAX];
546
547 DBG("Cleaning up");
548
549 /*
550 * Close the thread quit pipe. It has already done its job,
551 * since we are now called.
552 */
553 utils_close_pipe(thread_quit_pipe);
554
555 /*
556 * If opt_pidfile is undefined, the default file will be wiped when
557 * removing the rundir.
558 */
559 if (opt_pidfile) {
560 ret = remove(opt_pidfile);
561 if (ret < 0) {
562 PERROR("remove pidfile %s", opt_pidfile);
563 }
564 }
565
566 DBG("Removing sessiond and consumerd content of directory %s", rundir);
567
568 /* sessiond */
569 snprintf(path, PATH_MAX,
570 "%s/%s",
571 rundir, DEFAULT_LTTNG_SESSIOND_PIDFILE);
572 DBG("Removing %s", path);
573 (void) unlink(path);
574
575 snprintf(path, PATH_MAX, "%s/%s", rundir,
576 DEFAULT_LTTNG_SESSIOND_AGENTPORT_FILE);
577 DBG("Removing %s", path);
578 (void) unlink(path);
579
580 /* kconsumerd */
581 snprintf(path, PATH_MAX,
582 DEFAULT_KCONSUMERD_ERR_SOCK_PATH,
583 rundir);
584 DBG("Removing %s", path);
585 (void) unlink(path);
586
587 snprintf(path, PATH_MAX,
588 DEFAULT_KCONSUMERD_PATH,
589 rundir);
590 DBG("Removing directory %s", path);
591 (void) rmdir(path);
592
593 /* ust consumerd 32 */
594 snprintf(path, PATH_MAX,
595 DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH,
596 rundir);
597 DBG("Removing %s", path);
598 (void) unlink(path);
599
600 snprintf(path, PATH_MAX,
601 DEFAULT_USTCONSUMERD32_PATH,
602 rundir);
603 DBG("Removing directory %s", path);
604 (void) rmdir(path);
605
606 /* ust consumerd 64 */
607 snprintf(path, PATH_MAX,
608 DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH,
609 rundir);
610 DBG("Removing %s", path);
611 (void) unlink(path);
612
613 snprintf(path, PATH_MAX,
614 DEFAULT_USTCONSUMERD64_PATH,
615 rundir);
616 DBG("Removing directory %s", path);
617 (void) rmdir(path);
618
619 DBG("Cleaning up all sessions");
620
621 /* Destroy session list mutex */
622 if (session_list_ptr != NULL) {
623 pthread_mutex_destroy(&session_list_ptr->lock);
624
625 /* Cleanup ALL session */
626 cds_list_for_each_entry_safe(sess, stmp,
627 &session_list_ptr->head, list) {
628 cmd_destroy_session(sess, kernel_poll_pipe[1]);
629 }
630 }
631
632 DBG("Closing all UST sockets");
633 ust_app_clean_list();
634 buffer_reg_destroy_registries();
635
636 if (is_root && !opt_no_kernel) {
637 DBG2("Closing kernel fd");
638 if (kernel_tracer_fd >= 0) {
639 ret = close(kernel_tracer_fd);
640 if (ret) {
641 PERROR("close");
642 }
643 }
644 DBG("Unloading kernel modules");
645 modprobe_remove_lttng_all();
646 free(syscall_table);
647 }
648
649 close_consumer_sockets();
650
651 /*
652 * If the override option is set, the pointer points to a *non* const thus
653 * freeing it even though the variable type is set to const.
654 */
655 if (tracing_group_name_override) {
656 free((void *) tracing_group_name);
657 }
658 if (consumerd32_bin_override) {
659 free((void *) consumerd32_bin);
660 }
661 if (consumerd64_bin_override) {
662 free((void *) consumerd64_bin);
663 }
664 if (consumerd32_libdir_override) {
665 free((void *) consumerd32_libdir);
666 }
667 if (consumerd64_libdir_override) {
668 free((void *) consumerd64_libdir);
669 }
670
671 if (opt_pidfile) {
672 free(opt_pidfile);
673 }
674
675 if (opt_load_session_path) {
676 free(opt_load_session_path);
677 }
678
679 if (load_info) {
680 load_session_destroy_data(load_info);
681 free(load_info);
682 }
683
684 /*
685 * Cleanup lock file by deleting it and finaly closing it which will
686 * release the file system lock.
687 */
688 if (lockfile_fd >= 0) {
689 char lockfile_path[PATH_MAX];
690
691 ret = generate_lock_file_path(lockfile_path, sizeof(lockfile_path));
692 if (ret > 0) {
693 ret = remove(lockfile_path);
694 if (ret < 0) {
695 PERROR("remove lock file");
696 }
697 ret = close(lockfile_fd);
698 if (ret < 0) {
699 PERROR("close lock file");
700 }
701 }
702 }
703
704 /*
705 * We do NOT rmdir rundir because there are other processes
706 * using it, for instance lttng-relayd, which can start in
707 * parallel with this teardown.
708 */
709
710 free(rundir);
711
712 /* <fun> */
713 DBG("%c[%d;%dm*** assert failed :-) *** ==> %c[%dm%c[%d;%dm"
714 "Matthew, BEET driven development works!%c[%dm",
715 27, 1, 31, 27, 0, 27, 1, 33, 27, 0);
716 /* </fun> */
717 }
718
719 /*
720 * Send data on a unix socket using the liblttsessiondcomm API.
721 *
722 * Return lttcomm error code.
723 */
724 static int send_unix_sock(int sock, void *buf, size_t len)
725 {
726 /* Check valid length */
727 if (len == 0) {
728 return -1;
729 }
730
731 return lttcomm_send_unix_sock(sock, buf, len);
732 }
733
734 /*
735 * Free memory of a command context structure.
736 */
737 static void clean_command_ctx(struct command_ctx **cmd_ctx)
738 {
739 DBG("Clean command context structure");
740 if (*cmd_ctx) {
741 if ((*cmd_ctx)->llm) {
742 free((*cmd_ctx)->llm);
743 }
744 if ((*cmd_ctx)->lsm) {
745 free((*cmd_ctx)->lsm);
746 }
747 free(*cmd_ctx);
748 *cmd_ctx = NULL;
749 }
750 }
751
752 /*
753 * Notify UST applications using the shm mmap futex.
754 */
755 static int notify_ust_apps(int active)
756 {
757 char *wait_shm_mmap;
758
759 DBG("Notifying applications of session daemon state: %d", active);
760
761 /* See shm.c for this call implying mmap, shm and futex calls */
762 wait_shm_mmap = shm_ust_get_mmap(wait_shm_path, is_root);
763 if (wait_shm_mmap == NULL) {
764 goto error;
765 }
766
767 /* Wake waiting process */
768 futex_wait_update((int32_t *) wait_shm_mmap, active);
769
770 /* Apps notified successfully */
771 return 0;
772
773 error:
774 return -1;
775 }
776
777 /*
778 * Setup the outgoing data buffer for the response (llm) by allocating the
779 * right amount of memory and copying the original information from the lsm
780 * structure.
781 *
782 * Return total size of the buffer pointed by buf.
783 */
784 static int setup_lttng_msg(struct command_ctx *cmd_ctx, size_t size)
785 {
786 int ret, buf_size;
787
788 buf_size = size;
789
790 cmd_ctx->llm = zmalloc(sizeof(struct lttcomm_lttng_msg) + buf_size);
791 if (cmd_ctx->llm == NULL) {
792 PERROR("zmalloc");
793 ret = -ENOMEM;
794 goto error;
795 }
796
797 /* Copy common data */
798 cmd_ctx->llm->cmd_type = cmd_ctx->lsm->cmd_type;
799 cmd_ctx->llm->pid = cmd_ctx->lsm->domain.attr.pid;
800
801 cmd_ctx->llm->data_size = size;
802 cmd_ctx->lttng_msg_size = sizeof(struct lttcomm_lttng_msg) + buf_size;
803
804 return buf_size;
805
806 error:
807 return ret;
808 }
809
810 /*
811 * Update the kernel poll set of all channel fd available over all tracing
812 * session. Add the wakeup pipe at the end of the set.
813 */
814 static int update_kernel_poll(struct lttng_poll_event *events)
815 {
816 int ret;
817 struct ltt_session *session;
818 struct ltt_kernel_channel *channel;
819
820 DBG("Updating kernel poll set");
821
822 session_lock_list();
823 cds_list_for_each_entry(session, &session_list_ptr->head, list) {
824 session_lock(session);
825 if (session->kernel_session == NULL) {
826 session_unlock(session);
827 continue;
828 }
829
830 cds_list_for_each_entry(channel,
831 &session->kernel_session->channel_list.head, list) {
832 /* Add channel fd to the kernel poll set */
833 ret = lttng_poll_add(events, channel->fd, LPOLLIN | LPOLLRDNORM);
834 if (ret < 0) {
835 session_unlock(session);
836 goto error;
837 }
838 DBG("Channel fd %d added to kernel set", channel->fd);
839 }
840 session_unlock(session);
841 }
842 session_unlock_list();
843
844 return 0;
845
846 error:
847 session_unlock_list();
848 return -1;
849 }
850
851 /*
852 * Find the channel fd from 'fd' over all tracing session. When found, check
853 * for new channel stream and send those stream fds to the kernel consumer.
854 *
855 * Useful for CPU hotplug feature.
856 */
857 static int update_kernel_stream(struct consumer_data *consumer_data, int fd)
858 {
859 int ret = 0;
860 struct ltt_session *session;
861 struct ltt_kernel_session *ksess;
862 struct ltt_kernel_channel *channel;
863
864 DBG("Updating kernel streams for channel fd %d", fd);
865
866 session_lock_list();
867 cds_list_for_each_entry(session, &session_list_ptr->head, list) {
868 session_lock(session);
869 if (session->kernel_session == NULL) {
870 session_unlock(session);
871 continue;
872 }
873 ksess = session->kernel_session;
874
875 cds_list_for_each_entry(channel, &ksess->channel_list.head, list) {
876 if (channel->fd == fd) {
877 DBG("Channel found, updating kernel streams");
878 ret = kernel_open_channel_stream(channel);
879 if (ret < 0) {
880 goto error;
881 }
882 /* Update the stream global counter */
883 ksess->stream_count_global += ret;
884
885 /*
886 * Have we already sent fds to the consumer? If yes, it means
887 * that tracing is started so it is safe to send our updated
888 * stream fds.
889 */
890 if (ksess->consumer_fds_sent == 1 && ksess->consumer != NULL) {
891 struct lttng_ht_iter iter;
892 struct consumer_socket *socket;
893
894 rcu_read_lock();
895 cds_lfht_for_each_entry(ksess->consumer->socks->ht,
896 &iter.iter, socket, node.node) {
897 pthread_mutex_lock(socket->lock);
898 ret = kernel_consumer_send_channel_stream(socket,
899 channel, ksess,
900 session->output_traces ? 1 : 0);
901 pthread_mutex_unlock(socket->lock);
902 if (ret < 0) {
903 rcu_read_unlock();
904 goto error;
905 }
906 }
907 rcu_read_unlock();
908 }
909 goto error;
910 }
911 }
912 session_unlock(session);
913 }
914 session_unlock_list();
915 return ret;
916
917 error:
918 session_unlock(session);
919 session_unlock_list();
920 return ret;
921 }
922
923 /*
924 * For each tracing session, update newly registered apps. The session list
925 * lock MUST be acquired before calling this.
926 */
927 static void update_ust_app(int app_sock)
928 {
929 struct ltt_session *sess, *stmp;
930
931 /* Consumer is in an ERROR state. Stop any application update. */
932 if (uatomic_read(&ust_consumerd_state) == CONSUMER_ERROR) {
933 /* Stop the update process since the consumer is dead. */
934 return;
935 }
936
937 /* For all tracing session(s) */
938 cds_list_for_each_entry_safe(sess, stmp, &session_list_ptr->head, list) {
939 session_lock(sess);
940 if (sess->ust_session) {
941 ust_app_global_update(sess->ust_session, app_sock);
942 }
943 session_unlock(sess);
944 }
945 }
946
947 /*
948 * This thread manage event coming from the kernel.
949 *
950 * Features supported in this thread:
951 * -) CPU Hotplug
952 */
953 static void *thread_manage_kernel(void *data)
954 {
955 int ret, i, pollfd, update_poll_flag = 1, err = -1;
956 uint32_t revents, nb_fd;
957 char tmp;
958 struct lttng_poll_event events;
959
960 DBG("[thread] Thread manage kernel started");
961
962 health_register(health_sessiond, HEALTH_SESSIOND_TYPE_KERNEL);
963
964 /*
965 * This first step of the while is to clean this structure which could free
966 * non NULL pointers so initialize it before the loop.
967 */
968 lttng_poll_init(&events);
969
970 if (testpoint(sessiond_thread_manage_kernel)) {
971 goto error_testpoint;
972 }
973
974 health_code_update();
975
976 if (testpoint(sessiond_thread_manage_kernel_before_loop)) {
977 goto error_testpoint;
978 }
979
980 while (1) {
981 health_code_update();
982
983 if (update_poll_flag == 1) {
984 /* Clean events object. We are about to populate it again. */
985 lttng_poll_clean(&events);
986
987 ret = sessiond_set_thread_pollset(&events, 2);
988 if (ret < 0) {
989 goto error_poll_create;
990 }
991
992 ret = lttng_poll_add(&events, kernel_poll_pipe[0], LPOLLIN);
993 if (ret < 0) {
994 goto error;
995 }
996
997 /* This will add the available kernel channel if any. */
998 ret = update_kernel_poll(&events);
999 if (ret < 0) {
1000 goto error;
1001 }
1002 update_poll_flag = 0;
1003 }
1004
1005 DBG("Thread kernel polling on %d fds", LTTNG_POLL_GETNB(&events));
1006
1007 /* Poll infinite value of time */
1008 restart:
1009 health_poll_entry();
1010 ret = lttng_poll_wait(&events, -1);
1011 health_poll_exit();
1012 if (ret < 0) {
1013 /*
1014 * Restart interrupted system call.
1015 */
1016 if (errno == EINTR) {
1017 goto restart;
1018 }
1019 goto error;
1020 } else if (ret == 0) {
1021 /* Should not happen since timeout is infinite */
1022 ERR("Return value of poll is 0 with an infinite timeout.\n"
1023 "This should not have happened! Continuing...");
1024 continue;
1025 }
1026
1027 nb_fd = ret;
1028
1029 for (i = 0; i < nb_fd; i++) {
1030 /* Fetch once the poll data */
1031 revents = LTTNG_POLL_GETEV(&events, i);
1032 pollfd = LTTNG_POLL_GETFD(&events, i);
1033
1034 health_code_update();
1035
1036 /* Thread quit pipe has been closed. Killing thread. */
1037 ret = sessiond_check_thread_quit_pipe(pollfd, revents);
1038 if (ret) {
1039 err = 0;
1040 goto exit;
1041 }
1042
1043 /* Check for data on kernel pipe */
1044 if (pollfd == kernel_poll_pipe[0] && (revents & LPOLLIN)) {
1045 (void) lttng_read(kernel_poll_pipe[0],
1046 &tmp, 1);
1047 /*
1048 * Ret value is useless here, if this pipe gets any actions an
1049 * update is required anyway.
1050 */
1051 update_poll_flag = 1;
1052 continue;
1053 } else {
1054 /*
1055 * New CPU detected by the kernel. Adding kernel stream to
1056 * kernel session and updating the kernel consumer
1057 */
1058 if (revents & LPOLLIN) {
1059 ret = update_kernel_stream(&kconsumer_data, pollfd);
1060 if (ret < 0) {
1061 continue;
1062 }
1063 break;
1064 /*
1065 * TODO: We might want to handle the LPOLLERR | LPOLLHUP
1066 * and unregister kernel stream at this point.
1067 */
1068 }
1069 }
1070 }
1071 }
1072
1073 exit:
1074 error:
1075 lttng_poll_clean(&events);
1076 error_poll_create:
1077 error_testpoint:
1078 utils_close_pipe(kernel_poll_pipe);
1079 kernel_poll_pipe[0] = kernel_poll_pipe[1] = -1;
1080 if (err) {
1081 health_error();
1082 ERR("Health error occurred in %s", __func__);
1083 WARN("Kernel thread died unexpectedly. "
1084 "Kernel tracing can continue but CPU hotplug is disabled.");
1085 }
1086 health_unregister(health_sessiond);
1087 DBG("Kernel thread dying");
1088 return NULL;
1089 }
1090
1091 /*
1092 * Signal pthread condition of the consumer data that the thread.
1093 */
1094 static void signal_consumer_condition(struct consumer_data *data, int state)
1095 {
1096 pthread_mutex_lock(&data->cond_mutex);
1097
1098 /*
1099 * The state is set before signaling. It can be any value, it's the waiter
1100 * job to correctly interpret this condition variable associated to the
1101 * consumer pthread_cond.
1102 *
1103 * A value of 0 means that the corresponding thread of the consumer data
1104 * was not started. 1 indicates that the thread has started and is ready
1105 * for action. A negative value means that there was an error during the
1106 * thread bootstrap.
1107 */
1108 data->consumer_thread_is_ready = state;
1109 (void) pthread_cond_signal(&data->cond);
1110
1111 pthread_mutex_unlock(&data->cond_mutex);
1112 }
1113
1114 /*
1115 * This thread manage the consumer error sent back to the session daemon.
1116 */
1117 static void *thread_manage_consumer(void *data)
1118 {
1119 int sock = -1, i, ret, pollfd, err = -1, should_quit = 0;
1120 uint32_t revents, nb_fd;
1121 enum lttcomm_return_code code;
1122 struct lttng_poll_event events;
1123 struct consumer_data *consumer_data = data;
1124
1125 DBG("[thread] Manage consumer started");
1126
1127 health_register(health_sessiond, HEALTH_SESSIOND_TYPE_CONSUMER);
1128
1129 health_code_update();
1130
1131 /*
1132 * Pass 3 as size here for the thread quit pipe, consumerd_err_sock and the
1133 * metadata_sock. Nothing more will be added to this poll set.
1134 */
1135 ret = sessiond_set_thread_pollset(&events, 3);
1136 if (ret < 0) {
1137 goto error_poll;
1138 }
1139
1140 /*
1141 * The error socket here is already in a listening state which was done
1142 * just before spawning this thread to avoid a race between the consumer
1143 * daemon exec trying to connect and the listen() call.
1144 */
1145 ret = lttng_poll_add(&events, consumer_data->err_sock, LPOLLIN | LPOLLRDHUP);
1146 if (ret < 0) {
1147 goto error;
1148 }
1149
1150 health_code_update();
1151
1152 /* Infinite blocking call, waiting for transmission */
1153 restart:
1154 health_poll_entry();
1155
1156 if (testpoint(sessiond_thread_manage_consumer)) {
1157 goto error;
1158 }
1159
1160 ret = lttng_poll_wait(&events, -1);
1161 health_poll_exit();
1162 if (ret < 0) {
1163 /*
1164 * Restart interrupted system call.
1165 */
1166 if (errno == EINTR) {
1167 goto restart;
1168 }
1169 goto error;
1170 }
1171
1172 nb_fd = ret;
1173
1174 for (i = 0; i < nb_fd; i++) {
1175 /* Fetch once the poll data */
1176 revents = LTTNG_POLL_GETEV(&events, i);
1177 pollfd = LTTNG_POLL_GETFD(&events, i);
1178
1179 health_code_update();
1180
1181 /* Thread quit pipe has been closed. Killing thread. */
1182 ret = sessiond_check_thread_quit_pipe(pollfd, revents);
1183 if (ret) {
1184 err = 0;
1185 goto exit;
1186 }
1187
1188 /* Event on the registration socket */
1189 if (pollfd == consumer_data->err_sock) {
1190 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
1191 ERR("consumer err socket poll error");
1192 goto error;
1193 }
1194 }
1195 }
1196
1197 sock = lttcomm_accept_unix_sock(consumer_data->err_sock);
1198 if (sock < 0) {
1199 goto error;
1200 }
1201
1202 /*
1203 * Set the CLOEXEC flag. Return code is useless because either way, the
1204 * show must go on.
1205 */
1206 (void) utils_set_fd_cloexec(sock);
1207
1208 health_code_update();
1209
1210 DBG2("Receiving code from consumer err_sock");
1211
1212 /* Getting status code from kconsumerd */
1213 ret = lttcomm_recv_unix_sock(sock, &code,
1214 sizeof(enum lttcomm_return_code));
1215 if (ret <= 0) {
1216 goto error;
1217 }
1218
1219 health_code_update();
1220 if (code == LTTCOMM_CONSUMERD_COMMAND_SOCK_READY) {
1221 /* Connect both socket, command and metadata. */
1222 consumer_data->cmd_sock =
1223 lttcomm_connect_unix_sock(consumer_data->cmd_unix_sock_path);
1224 consumer_data->metadata_fd =
1225 lttcomm_connect_unix_sock(consumer_data->cmd_unix_sock_path);
1226 if (consumer_data->cmd_sock < 0
1227 || consumer_data->metadata_fd < 0) {
1228 PERROR("consumer connect cmd socket");
1229 /* On error, signal condition and quit. */
1230 signal_consumer_condition(consumer_data, -1);
1231 goto error;
1232 }
1233 consumer_data->metadata_sock.fd_ptr = &consumer_data->metadata_fd;
1234 /* Create metadata socket lock. */
1235 consumer_data->metadata_sock.lock = zmalloc(sizeof(pthread_mutex_t));
1236 if (consumer_data->metadata_sock.lock == NULL) {
1237 PERROR("zmalloc pthread mutex");
1238 ret = -1;
1239 goto error;
1240 }
1241 pthread_mutex_init(consumer_data->metadata_sock.lock, NULL);
1242
1243 signal_consumer_condition(consumer_data, 1);
1244 DBG("Consumer command socket ready (fd: %d", consumer_data->cmd_sock);
1245 DBG("Consumer metadata socket ready (fd: %d)",
1246 consumer_data->metadata_fd);
1247 } else {
1248 ERR("consumer error when waiting for SOCK_READY : %s",
1249 lttcomm_get_readable_code(-code));
1250 goto error;
1251 }
1252
1253 /* Remove the consumerd error sock since we've established a connexion */
1254 ret = lttng_poll_del(&events, consumer_data->err_sock);
1255 if (ret < 0) {
1256 goto error;
1257 }
1258
1259 /* Add new accepted error socket. */
1260 ret = lttng_poll_add(&events, sock, LPOLLIN | LPOLLRDHUP);
1261 if (ret < 0) {
1262 goto error;
1263 }
1264
1265 /* Add metadata socket that is successfully connected. */
1266 ret = lttng_poll_add(&events, consumer_data->metadata_fd,
1267 LPOLLIN | LPOLLRDHUP);
1268 if (ret < 0) {
1269 goto error;
1270 }
1271
1272 health_code_update();
1273
1274 /* Infinite blocking call, waiting for transmission */
1275 restart_poll:
1276 while (1) {
1277 health_code_update();
1278
1279 /* Exit the thread because the thread quit pipe has been triggered. */
1280 if (should_quit) {
1281 /* Not a health error. */
1282 err = 0;
1283 goto exit;
1284 }
1285
1286 health_poll_entry();
1287 ret = lttng_poll_wait(&events, -1);
1288 health_poll_exit();
1289 if (ret < 0) {
1290 /*
1291 * Restart interrupted system call.
1292 */
1293 if (errno == EINTR) {
1294 goto restart_poll;
1295 }
1296 goto error;
1297 }
1298
1299 nb_fd = ret;
1300
1301 for (i = 0; i < nb_fd; i++) {
1302 /* Fetch once the poll data */
1303 revents = LTTNG_POLL_GETEV(&events, i);
1304 pollfd = LTTNG_POLL_GETFD(&events, i);
1305
1306 health_code_update();
1307
1308 /*
1309 * Thread quit pipe has been triggered, flag that we should stop
1310 * but continue the current loop to handle potential data from
1311 * consumer.
1312 */
1313 should_quit = sessiond_check_thread_quit_pipe(pollfd, revents);
1314
1315 if (pollfd == sock) {
1316 /* Event on the consumerd socket */
1317 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
1318 ERR("consumer err socket second poll error");
1319 goto error;
1320 }
1321 health_code_update();
1322 /* Wait for any kconsumerd error */
1323 ret = lttcomm_recv_unix_sock(sock, &code,
1324 sizeof(enum lttcomm_return_code));
1325 if (ret <= 0) {
1326 ERR("consumer closed the command socket");
1327 goto error;
1328 }
1329
1330 ERR("consumer return code : %s",
1331 lttcomm_get_readable_code(-code));
1332
1333 goto exit;
1334 } else if (pollfd == consumer_data->metadata_fd) {
1335 /* UST metadata requests */
1336 ret = ust_consumer_metadata_request(
1337 &consumer_data->metadata_sock);
1338 if (ret < 0) {
1339 ERR("Handling metadata request");
1340 goto error;
1341 }
1342 }
1343 /* No need for an else branch all FDs are tested prior. */
1344 }
1345 health_code_update();
1346 }
1347
1348 exit:
1349 error:
1350 /*
1351 * We lock here because we are about to close the sockets and some other
1352 * thread might be using them so get exclusive access which will abort all
1353 * other consumer command by other threads.
1354 */
1355 pthread_mutex_lock(&consumer_data->lock);
1356
1357 /* Immediately set the consumerd state to stopped */
1358 if (consumer_data->type == LTTNG_CONSUMER_KERNEL) {
1359 uatomic_set(&kernel_consumerd_state, CONSUMER_ERROR);
1360 } else if (consumer_data->type == LTTNG_CONSUMER64_UST ||
1361 consumer_data->type == LTTNG_CONSUMER32_UST) {
1362 uatomic_set(&ust_consumerd_state, CONSUMER_ERROR);
1363 } else {
1364 /* Code flow error... */
1365 assert(0);
1366 }
1367
1368 if (consumer_data->err_sock >= 0) {
1369 ret = close(consumer_data->err_sock);
1370 if (ret) {
1371 PERROR("close");
1372 }
1373 consumer_data->err_sock = -1;
1374 }
1375 if (consumer_data->cmd_sock >= 0) {
1376 ret = close(consumer_data->cmd_sock);
1377 if (ret) {
1378 PERROR("close");
1379 }
1380 consumer_data->cmd_sock = -1;
1381 }
1382 if (consumer_data->metadata_sock.fd_ptr &&
1383 *consumer_data->metadata_sock.fd_ptr >= 0) {
1384 ret = close(*consumer_data->metadata_sock.fd_ptr);
1385 if (ret) {
1386 PERROR("close");
1387 }
1388 }
1389 if (sock >= 0) {
1390 ret = close(sock);
1391 if (ret) {
1392 PERROR("close");
1393 }
1394 }
1395
1396 unlink(consumer_data->err_unix_sock_path);
1397 unlink(consumer_data->cmd_unix_sock_path);
1398 consumer_data->pid = 0;
1399 pthread_mutex_unlock(&consumer_data->lock);
1400
1401 /* Cleanup metadata socket mutex. */
1402 if (consumer_data->metadata_sock.lock) {
1403 pthread_mutex_destroy(consumer_data->metadata_sock.lock);
1404 free(consumer_data->metadata_sock.lock);
1405 }
1406 lttng_poll_clean(&events);
1407 error_poll:
1408 if (err) {
1409 health_error();
1410 ERR("Health error occurred in %s", __func__);
1411 }
1412 health_unregister(health_sessiond);
1413 DBG("consumer thread cleanup completed");
1414
1415 return NULL;
1416 }
1417
1418 /*
1419 * This thread manage application communication.
1420 */
1421 static void *thread_manage_apps(void *data)
1422 {
1423 int i, ret, pollfd, err = -1;
1424 ssize_t size_ret;
1425 uint32_t revents, nb_fd;
1426 struct lttng_poll_event events;
1427
1428 DBG("[thread] Manage application started");
1429
1430 rcu_register_thread();
1431 rcu_thread_online();
1432
1433 health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_MANAGE);
1434
1435 if (testpoint(sessiond_thread_manage_apps)) {
1436 goto error_testpoint;
1437 }
1438
1439 health_code_update();
1440
1441 ret = sessiond_set_thread_pollset(&events, 2);
1442 if (ret < 0) {
1443 goto error_poll_create;
1444 }
1445
1446 ret = lttng_poll_add(&events, apps_cmd_pipe[0], LPOLLIN | LPOLLRDHUP);
1447 if (ret < 0) {
1448 goto error;
1449 }
1450
1451 if (testpoint(sessiond_thread_manage_apps_before_loop)) {
1452 goto error;
1453 }
1454
1455 health_code_update();
1456
1457 while (1) {
1458 DBG("Apps thread polling on %d fds", LTTNG_POLL_GETNB(&events));
1459
1460 /* Inifinite blocking call, waiting for transmission */
1461 restart:
1462 health_poll_entry();
1463 ret = lttng_poll_wait(&events, -1);
1464 health_poll_exit();
1465 if (ret < 0) {
1466 /*
1467 * Restart interrupted system call.
1468 */
1469 if (errno == EINTR) {
1470 goto restart;
1471 }
1472 goto error;
1473 }
1474
1475 nb_fd = ret;
1476
1477 for (i = 0; i < nb_fd; i++) {
1478 /* Fetch once the poll data */
1479 revents = LTTNG_POLL_GETEV(&events, i);
1480 pollfd = LTTNG_POLL_GETFD(&events, i);
1481
1482 health_code_update();
1483
1484 /* Thread quit pipe has been closed. Killing thread. */
1485 ret = sessiond_check_thread_quit_pipe(pollfd, revents);
1486 if (ret) {
1487 err = 0;
1488 goto exit;
1489 }
1490
1491 /* Inspect the apps cmd pipe */
1492 if (pollfd == apps_cmd_pipe[0]) {
1493 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
1494 ERR("Apps command pipe error");
1495 goto error;
1496 } else if (revents & LPOLLIN) {
1497 int sock;
1498
1499 /* Empty pipe */
1500 size_ret = lttng_read(apps_cmd_pipe[0], &sock, sizeof(sock));
1501 if (size_ret < sizeof(sock)) {
1502 PERROR("read apps cmd pipe");
1503 goto error;
1504 }
1505
1506 health_code_update();
1507
1508 /*
1509 * We only monitor the error events of the socket. This
1510 * thread does not handle any incoming data from UST
1511 * (POLLIN).
1512 */
1513 ret = lttng_poll_add(&events, sock,
1514 LPOLLERR | LPOLLHUP | LPOLLRDHUP);
1515 if (ret < 0) {
1516 goto error;
1517 }
1518
1519 DBG("Apps with sock %d added to poll set", sock);
1520 }
1521 } else {
1522 /*
1523 * At this point, we know that a registered application made
1524 * the event at poll_wait.
1525 */
1526 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
1527 /* Removing from the poll set */
1528 ret = lttng_poll_del(&events, pollfd);
1529 if (ret < 0) {
1530 goto error;
1531 }
1532
1533 /* Socket closed on remote end. */
1534 ust_app_unregister(pollfd);
1535 }
1536 }
1537
1538 health_code_update();
1539 }
1540 }
1541
1542 exit:
1543 error:
1544 lttng_poll_clean(&events);
1545 error_poll_create:
1546 error_testpoint:
1547 utils_close_pipe(apps_cmd_pipe);
1548 apps_cmd_pipe[0] = apps_cmd_pipe[1] = -1;
1549
1550 /*
1551 * We don't clean the UST app hash table here since already registered
1552 * applications can still be controlled so let them be until the session
1553 * daemon dies or the applications stop.
1554 */
1555
1556 if (err) {
1557 health_error();
1558 ERR("Health error occurred in %s", __func__);
1559 }
1560 health_unregister(health_sessiond);
1561 DBG("Application communication apps thread cleanup complete");
1562 rcu_thread_offline();
1563 rcu_unregister_thread();
1564 return NULL;
1565 }
1566
1567 /*
1568 * Send a socket to a thread This is called from the dispatch UST registration
1569 * thread once all sockets are set for the application.
1570 *
1571 * The sock value can be invalid, we don't really care, the thread will handle
1572 * it and make the necessary cleanup if so.
1573 *
1574 * On success, return 0 else a negative value being the errno message of the
1575 * write().
1576 */
1577 static int send_socket_to_thread(int fd, int sock)
1578 {
1579 ssize_t ret;
1580
1581 /*
1582 * It's possible that the FD is set as invalid with -1 concurrently just
1583 * before calling this function being a shutdown state of the thread.
1584 */
1585 if (fd < 0) {
1586 ret = -EBADF;
1587 goto error;
1588 }
1589
1590 ret = lttng_write(fd, &sock, sizeof(sock));
1591 if (ret < sizeof(sock)) {
1592 PERROR("write apps pipe %d", fd);
1593 if (ret < 0) {
1594 ret = -errno;
1595 }
1596 goto error;
1597 }
1598
1599 /* All good. Don't send back the write positive ret value. */
1600 ret = 0;
1601 error:
1602 return (int) ret;
1603 }
1604
1605 /*
1606 * Sanitize the wait queue of the dispatch registration thread meaning removing
1607 * invalid nodes from it. This is to avoid memory leaks for the case the UST
1608 * notify socket is never received.
1609 */
1610 static void sanitize_wait_queue(struct ust_reg_wait_queue *wait_queue)
1611 {
1612 int ret, nb_fd = 0, i;
1613 unsigned int fd_added = 0;
1614 struct lttng_poll_event events;
1615 struct ust_reg_wait_node *wait_node = NULL, *tmp_wait_node;
1616
1617 assert(wait_queue);
1618
1619 lttng_poll_init(&events);
1620
1621 /* Just skip everything for an empty queue. */
1622 if (!wait_queue->count) {
1623 goto end;
1624 }
1625
1626 ret = lttng_poll_create(&events, wait_queue->count, LTTNG_CLOEXEC);
1627 if (ret < 0) {
1628 goto error_create;
1629 }
1630
1631 cds_list_for_each_entry_safe(wait_node, tmp_wait_node,
1632 &wait_queue->head, head) {
1633 assert(wait_node->app);
1634 ret = lttng_poll_add(&events, wait_node->app->sock,
1635 LPOLLHUP | LPOLLERR);
1636 if (ret < 0) {
1637 goto error;
1638 }
1639
1640 fd_added = 1;
1641 }
1642
1643 if (!fd_added) {
1644 goto end;
1645 }
1646
1647 /*
1648 * Poll but don't block so we can quickly identify the faulty events and
1649 * clean them afterwards from the wait queue.
1650 */
1651 ret = lttng_poll_wait(&events, 0);
1652 if (ret < 0) {
1653 goto error;
1654 }
1655 nb_fd = ret;
1656
1657 for (i = 0; i < nb_fd; i++) {
1658 /* Get faulty FD. */
1659 uint32_t revents = LTTNG_POLL_GETEV(&events, i);
1660 int pollfd = LTTNG_POLL_GETFD(&events, i);
1661
1662 cds_list_for_each_entry_safe(wait_node, tmp_wait_node,
1663 &wait_queue->head, head) {
1664 if (pollfd == wait_node->app->sock &&
1665 (revents & (LPOLLHUP | LPOLLERR))) {
1666 cds_list_del(&wait_node->head);
1667 wait_queue->count--;
1668 ust_app_destroy(wait_node->app);
1669 free(wait_node);
1670 break;
1671 }
1672 }
1673 }
1674
1675 if (nb_fd > 0) {
1676 DBG("Wait queue sanitized, %d node were cleaned up", nb_fd);
1677 }
1678
1679 end:
1680 lttng_poll_clean(&events);
1681 return;
1682
1683 error:
1684 lttng_poll_clean(&events);
1685 error_create:
1686 ERR("Unable to sanitize wait queue");
1687 return;
1688 }
1689
1690 /*
1691 * Dispatch request from the registration threads to the application
1692 * communication thread.
1693 */
1694 static void *thread_dispatch_ust_registration(void *data)
1695 {
1696 int ret, err = -1;
1697 struct cds_wfcq_node *node;
1698 struct ust_command *ust_cmd = NULL;
1699 struct ust_reg_wait_node *wait_node = NULL, *tmp_wait_node;
1700 struct ust_reg_wait_queue wait_queue = {
1701 .count = 0,
1702 };
1703
1704 health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_REG_DISPATCH);
1705
1706 if (testpoint(sessiond_thread_app_reg_dispatch)) {
1707 goto error_testpoint;
1708 }
1709
1710 health_code_update();
1711
1712 CDS_INIT_LIST_HEAD(&wait_queue.head);
1713
1714 DBG("[thread] Dispatch UST command started");
1715
1716 while (!CMM_LOAD_SHARED(dispatch_thread_exit)) {
1717 health_code_update();
1718
1719 /* Atomically prepare the queue futex */
1720 futex_nto1_prepare(&ust_cmd_queue.futex);
1721
1722 do {
1723 struct ust_app *app = NULL;
1724 ust_cmd = NULL;
1725
1726 /*
1727 * Make sure we don't have node(s) that have hung up before receiving
1728 * the notify socket. This is to clean the list in order to avoid
1729 * memory leaks from notify socket that are never seen.
1730 */
1731 sanitize_wait_queue(&wait_queue);
1732
1733 health_code_update();
1734 /* Dequeue command for registration */
1735 node = cds_wfcq_dequeue_blocking(&ust_cmd_queue.head, &ust_cmd_queue.tail);
1736 if (node == NULL) {
1737 DBG("Woken up but nothing in the UST command queue");
1738 /* Continue thread execution */
1739 break;
1740 }
1741
1742 ust_cmd = caa_container_of(node, struct ust_command, node);
1743
1744 DBG("Dispatching UST registration pid:%d ppid:%d uid:%d"
1745 " gid:%d sock:%d name:%s (version %d.%d)",
1746 ust_cmd->reg_msg.pid, ust_cmd->reg_msg.ppid,
1747 ust_cmd->reg_msg.uid, ust_cmd->reg_msg.gid,
1748 ust_cmd->sock, ust_cmd->reg_msg.name,
1749 ust_cmd->reg_msg.major, ust_cmd->reg_msg.minor);
1750
1751 if (ust_cmd->reg_msg.type == USTCTL_SOCKET_CMD) {
1752 wait_node = zmalloc(sizeof(*wait_node));
1753 if (!wait_node) {
1754 PERROR("zmalloc wait_node dispatch");
1755 ret = close(ust_cmd->sock);
1756 if (ret < 0) {
1757 PERROR("close ust sock dispatch %d", ust_cmd->sock);
1758 }
1759 lttng_fd_put(LTTNG_FD_APPS, 1);
1760 free(ust_cmd);
1761 goto error;
1762 }
1763 CDS_INIT_LIST_HEAD(&wait_node->head);
1764
1765 /* Create application object if socket is CMD. */
1766 wait_node->app = ust_app_create(&ust_cmd->reg_msg,
1767 ust_cmd->sock);
1768 if (!wait_node->app) {
1769 ret = close(ust_cmd->sock);
1770 if (ret < 0) {
1771 PERROR("close ust sock dispatch %d", ust_cmd->sock);
1772 }
1773 lttng_fd_put(LTTNG_FD_APPS, 1);
1774 free(wait_node);
1775 free(ust_cmd);
1776 continue;
1777 }
1778 /*
1779 * Add application to the wait queue so we can set the notify
1780 * socket before putting this object in the global ht.
1781 */
1782 cds_list_add(&wait_node->head, &wait_queue.head);
1783 wait_queue.count++;
1784
1785 free(ust_cmd);
1786 /*
1787 * We have to continue here since we don't have the notify
1788 * socket and the application MUST be added to the hash table
1789 * only at that moment.
1790 */
1791 continue;
1792 } else {
1793 /*
1794 * Look for the application in the local wait queue and set the
1795 * notify socket if found.
1796 */
1797 cds_list_for_each_entry_safe(wait_node, tmp_wait_node,
1798 &wait_queue.head, head) {
1799 health_code_update();
1800 if (wait_node->app->pid == ust_cmd->reg_msg.pid) {
1801 wait_node->app->notify_sock = ust_cmd->sock;
1802 cds_list_del(&wait_node->head);
1803 wait_queue.count--;
1804 app = wait_node->app;
1805 free(wait_node);
1806 DBG3("UST app notify socket %d is set", ust_cmd->sock);
1807 break;
1808 }
1809 }
1810
1811 /*
1812 * With no application at this stage the received socket is
1813 * basically useless so close it before we free the cmd data
1814 * structure for good.
1815 */
1816 if (!app) {
1817 ret = close(ust_cmd->sock);
1818 if (ret < 0) {
1819 PERROR("close ust sock dispatch %d", ust_cmd->sock);
1820 }
1821 lttng_fd_put(LTTNG_FD_APPS, 1);
1822 }
1823 free(ust_cmd);
1824 }
1825
1826 if (app) {
1827 /*
1828 * @session_lock_list
1829 *
1830 * Lock the global session list so from the register up to the
1831 * registration done message, no thread can see the application
1832 * and change its state.
1833 */
1834 session_lock_list();
1835 rcu_read_lock();
1836
1837 /*
1838 * Add application to the global hash table. This needs to be
1839 * done before the update to the UST registry can locate the
1840 * application.
1841 */
1842 ust_app_add(app);
1843
1844 /* Set app version. This call will print an error if needed. */
1845 (void) ust_app_version(app);
1846
1847 /* Send notify socket through the notify pipe. */
1848 ret = send_socket_to_thread(apps_cmd_notify_pipe[1],
1849 app->notify_sock);
1850 if (ret < 0) {
1851 rcu_read_unlock();
1852 session_unlock_list();
1853 /*
1854 * No notify thread, stop the UST tracing. However, this is
1855 * not an internal error of the this thread thus setting
1856 * the health error code to a normal exit.
1857 */
1858 err = 0;
1859 goto error;
1860 }
1861
1862 /*
1863 * Update newly registered application with the tracing
1864 * registry info already enabled information.
1865 */
1866 update_ust_app(app->sock);
1867
1868 /*
1869 * Don't care about return value. Let the manage apps threads
1870 * handle app unregistration upon socket close.
1871 */
1872 (void) ust_app_register_done(app->sock);
1873
1874 /*
1875 * Even if the application socket has been closed, send the app
1876 * to the thread and unregistration will take place at that
1877 * place.
1878 */
1879 ret = send_socket_to_thread(apps_cmd_pipe[1], app->sock);
1880 if (ret < 0) {
1881 rcu_read_unlock();
1882 session_unlock_list();
1883 /*
1884 * No apps. thread, stop the UST tracing. However, this is
1885 * not an internal error of the this thread thus setting
1886 * the health error code to a normal exit.
1887 */
1888 err = 0;
1889 goto error;
1890 }
1891
1892 rcu_read_unlock();
1893 session_unlock_list();
1894 }
1895 } while (node != NULL);
1896
1897 health_poll_entry();
1898 /* Futex wait on queue. Blocking call on futex() */
1899 futex_nto1_wait(&ust_cmd_queue.futex);
1900 health_poll_exit();
1901 }
1902 /* Normal exit, no error */
1903 err = 0;
1904
1905 error:
1906 /* Clean up wait queue. */
1907 cds_list_for_each_entry_safe(wait_node, tmp_wait_node,
1908 &wait_queue.head, head) {
1909 cds_list_del(&wait_node->head);
1910 wait_queue.count--;
1911 free(wait_node);
1912 }
1913
1914 error_testpoint:
1915 DBG("Dispatch thread dying");
1916 if (err) {
1917 health_error();
1918 ERR("Health error occurred in %s", __func__);
1919 }
1920 health_unregister(health_sessiond);
1921 return NULL;
1922 }
1923
1924 /*
1925 * This thread manage application registration.
1926 */
1927 static void *thread_registration_apps(void *data)
1928 {
1929 int sock = -1, i, ret, pollfd, err = -1;
1930 uint32_t revents, nb_fd;
1931 struct lttng_poll_event events;
1932 /*
1933 * Get allocated in this thread, enqueued to a global queue, dequeued and
1934 * freed in the manage apps thread.
1935 */
1936 struct ust_command *ust_cmd = NULL;
1937
1938 DBG("[thread] Manage application registration started");
1939
1940 health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_REG);
1941
1942 if (testpoint(sessiond_thread_registration_apps)) {
1943 goto error_testpoint;
1944 }
1945
1946 ret = lttcomm_listen_unix_sock(apps_sock);
1947 if (ret < 0) {
1948 goto error_listen;
1949 }
1950
1951 /*
1952 * Pass 2 as size here for the thread quit pipe and apps socket. Nothing
1953 * more will be added to this poll set.
1954 */
1955 ret = sessiond_set_thread_pollset(&events, 2);
1956 if (ret < 0) {
1957 goto error_create_poll;
1958 }
1959
1960 /* Add the application registration socket */
1961 ret = lttng_poll_add(&events, apps_sock, LPOLLIN | LPOLLRDHUP);
1962 if (ret < 0) {
1963 goto error_poll_add;
1964 }
1965
1966 /* Notify all applications to register */
1967 ret = notify_ust_apps(1);
1968 if (ret < 0) {
1969 ERR("Failed to notify applications or create the wait shared memory.\n"
1970 "Execution continues but there might be problem for already\n"
1971 "running applications that wishes to register.");
1972 }
1973
1974 while (1) {
1975 DBG("Accepting application registration");
1976
1977 /* Inifinite blocking call, waiting for transmission */
1978 restart:
1979 health_poll_entry();
1980 ret = lttng_poll_wait(&events, -1);
1981 health_poll_exit();
1982 if (ret < 0) {
1983 /*
1984 * Restart interrupted system call.
1985 */
1986 if (errno == EINTR) {
1987 goto restart;
1988 }
1989 goto error;
1990 }
1991
1992 nb_fd = ret;
1993
1994 for (i = 0; i < nb_fd; i++) {
1995 health_code_update();
1996
1997 /* Fetch once the poll data */
1998 revents = LTTNG_POLL_GETEV(&events, i);
1999 pollfd = LTTNG_POLL_GETFD(&events, i);
2000
2001 /* Thread quit pipe has been closed. Killing thread. */
2002 ret = sessiond_check_thread_quit_pipe(pollfd, revents);
2003 if (ret) {
2004 err = 0;
2005 goto exit;
2006 }
2007
2008 /* Event on the registration socket */
2009 if (pollfd == apps_sock) {
2010 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
2011 ERR("Register apps socket poll error");
2012 goto error;
2013 } else if (revents & LPOLLIN) {
2014 sock = lttcomm_accept_unix_sock(apps_sock);
2015 if (sock < 0) {
2016 goto error;
2017 }
2018
2019 /*
2020 * Set socket timeout for both receiving and ending.
2021 * app_socket_timeout is in seconds, whereas
2022 * lttcomm_setsockopt_rcv_timeout and
2023 * lttcomm_setsockopt_snd_timeout expect msec as
2024 * parameter.
2025 */
2026 (void) lttcomm_setsockopt_rcv_timeout(sock,
2027 app_socket_timeout * 1000);
2028 (void) lttcomm_setsockopt_snd_timeout(sock,
2029 app_socket_timeout * 1000);
2030
2031 /*
2032 * Set the CLOEXEC flag. Return code is useless because
2033 * either way, the show must go on.
2034 */
2035 (void) utils_set_fd_cloexec(sock);
2036
2037 /* Create UST registration command for enqueuing */
2038 ust_cmd = zmalloc(sizeof(struct ust_command));
2039 if (ust_cmd == NULL) {
2040 PERROR("ust command zmalloc");
2041 goto error;
2042 }
2043
2044 /*
2045 * Using message-based transmissions to ensure we don't
2046 * have to deal with partially received messages.
2047 */
2048 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
2049 if (ret < 0) {
2050 ERR("Exhausted file descriptors allowed for applications.");
2051 free(ust_cmd);
2052 ret = close(sock);
2053 if (ret) {
2054 PERROR("close");
2055 }
2056 sock = -1;
2057 continue;
2058 }
2059
2060 health_code_update();
2061 ret = ust_app_recv_registration(sock, &ust_cmd->reg_msg);
2062 if (ret < 0) {
2063 free(ust_cmd);
2064 /* Close socket of the application. */
2065 ret = close(sock);
2066 if (ret) {
2067 PERROR("close");
2068 }
2069 lttng_fd_put(LTTNG_FD_APPS, 1);
2070 sock = -1;
2071 continue;
2072 }
2073 health_code_update();
2074
2075 ust_cmd->sock = sock;
2076 sock = -1;
2077
2078 DBG("UST registration received with pid:%d ppid:%d uid:%d"
2079 " gid:%d sock:%d name:%s (version %d.%d)",
2080 ust_cmd->reg_msg.pid, ust_cmd->reg_msg.ppid,
2081 ust_cmd->reg_msg.uid, ust_cmd->reg_msg.gid,
2082 ust_cmd->sock, ust_cmd->reg_msg.name,
2083 ust_cmd->reg_msg.major, ust_cmd->reg_msg.minor);
2084
2085 /*
2086 * Lock free enqueue the registration request. The red pill
2087 * has been taken! This apps will be part of the *system*.
2088 */
2089 cds_wfcq_enqueue(&ust_cmd_queue.head, &ust_cmd_queue.tail, &ust_cmd->node);
2090
2091 /*
2092 * Wake the registration queue futex. Implicit memory
2093 * barrier with the exchange in cds_wfcq_enqueue.
2094 */
2095 futex_nto1_wake(&ust_cmd_queue.futex);
2096 }
2097 }
2098 }
2099 }
2100
2101 exit:
2102 error:
2103 /* Notify that the registration thread is gone */
2104 notify_ust_apps(0);
2105
2106 if (apps_sock >= 0) {
2107 ret = close(apps_sock);
2108 if (ret) {
2109 PERROR("close");
2110 }
2111 }
2112 if (sock >= 0) {
2113 ret = close(sock);
2114 if (ret) {
2115 PERROR("close");
2116 }
2117 lttng_fd_put(LTTNG_FD_APPS, 1);
2118 }
2119 unlink(apps_unix_sock_path);
2120
2121 error_poll_add:
2122 lttng_poll_clean(&events);
2123 error_listen:
2124 error_create_poll:
2125 error_testpoint:
2126 DBG("UST Registration thread cleanup complete");
2127 if (err) {
2128 health_error();
2129 ERR("Health error occurred in %s", __func__);
2130 }
2131 health_unregister(health_sessiond);
2132
2133 return NULL;
2134 }
2135
2136 /*
2137 * Start the thread_manage_consumer. This must be done after a lttng-consumerd
2138 * exec or it will fails.
2139 */
2140 static int spawn_consumer_thread(struct consumer_data *consumer_data)
2141 {
2142 int ret, clock_ret;
2143 struct timespec timeout;
2144
2145 /* Make sure we set the readiness flag to 0 because we are NOT ready */
2146 consumer_data->consumer_thread_is_ready = 0;
2147
2148 /* Setup pthread condition */
2149 ret = pthread_condattr_init(&consumer_data->condattr);
2150 if (ret != 0) {
2151 errno = ret;
2152 PERROR("pthread_condattr_init consumer data");
2153 goto error;
2154 }
2155
2156 /*
2157 * Set the monotonic clock in order to make sure we DO NOT jump in time
2158 * between the clock_gettime() call and the timedwait call. See bug #324
2159 * for a more details and how we noticed it.
2160 */
2161 ret = pthread_condattr_setclock(&consumer_data->condattr, CLOCK_MONOTONIC);
2162 if (ret != 0) {
2163 errno = ret;
2164 PERROR("pthread_condattr_setclock consumer data");
2165 goto error;
2166 }
2167
2168 ret = pthread_cond_init(&consumer_data->cond, &consumer_data->condattr);
2169 if (ret != 0) {
2170 errno = ret;
2171 PERROR("pthread_cond_init consumer data");
2172 goto error;
2173 }
2174
2175 ret = pthread_create(&consumer_data->thread, NULL, thread_manage_consumer,
2176 consumer_data);
2177 if (ret != 0) {
2178 PERROR("pthread_create consumer");
2179 ret = -1;
2180 goto error;
2181 }
2182
2183 /* We are about to wait on a pthread condition */
2184 pthread_mutex_lock(&consumer_data->cond_mutex);
2185
2186 /* Get time for sem_timedwait absolute timeout */
2187 clock_ret = clock_gettime(CLOCK_MONOTONIC, &timeout);
2188 /*
2189 * Set the timeout for the condition timed wait even if the clock gettime
2190 * call fails since we might loop on that call and we want to avoid to
2191 * increment the timeout too many times.
2192 */
2193 timeout.tv_sec += DEFAULT_SEM_WAIT_TIMEOUT;
2194
2195 /*
2196 * The following loop COULD be skipped in some conditions so this is why we
2197 * set ret to 0 in order to make sure at least one round of the loop is
2198 * done.
2199 */
2200 ret = 0;
2201
2202 /*
2203 * Loop until the condition is reached or when a timeout is reached. Note
2204 * that the pthread_cond_timedwait(P) man page specifies that EINTR can NOT
2205 * be returned but the pthread_cond(3), from the glibc-doc, says that it is
2206 * possible. This loop does not take any chances and works with both of
2207 * them.
2208 */
2209 while (!consumer_data->consumer_thread_is_ready && ret != ETIMEDOUT) {
2210 if (clock_ret < 0) {
2211 PERROR("clock_gettime spawn consumer");
2212 /* Infinite wait for the consumerd thread to be ready */
2213 ret = pthread_cond_wait(&consumer_data->cond,
2214 &consumer_data->cond_mutex);
2215 } else {
2216 ret = pthread_cond_timedwait(&consumer_data->cond,
2217 &consumer_data->cond_mutex, &timeout);
2218 }
2219 }
2220
2221 /* Release the pthread condition */
2222 pthread_mutex_unlock(&consumer_data->cond_mutex);
2223
2224 if (ret != 0) {
2225 errno = ret;
2226 if (ret == ETIMEDOUT) {
2227 int pth_ret;
2228
2229 /*
2230 * Call has timed out so we kill the kconsumerd_thread and return
2231 * an error.
2232 */
2233 ERR("Condition timed out. The consumer thread was never ready."
2234 " Killing it");
2235 pth_ret = pthread_cancel(consumer_data->thread);
2236 if (pth_ret < 0) {
2237 PERROR("pthread_cancel consumer thread");
2238 }
2239 } else {
2240 PERROR("pthread_cond_wait failed consumer thread");
2241 }
2242 /* Caller is expecting a negative value on failure. */
2243 ret = -1;
2244 goto error;
2245 }
2246
2247 pthread_mutex_lock(&consumer_data->pid_mutex);
2248 if (consumer_data->pid == 0) {
2249 ERR("Consumerd did not start");
2250 pthread_mutex_unlock(&consumer_data->pid_mutex);
2251 goto error;
2252 }
2253 pthread_mutex_unlock(&consumer_data->pid_mutex);
2254
2255 return 0;
2256
2257 error:
2258 return ret;
2259 }
2260
2261 /*
2262 * Join consumer thread
2263 */
2264 static int join_consumer_thread(struct consumer_data *consumer_data)
2265 {
2266 void *status;
2267
2268 /* Consumer pid must be a real one. */
2269 if (consumer_data->pid > 0) {
2270 int ret;
2271 ret = kill(consumer_data->pid, SIGTERM);
2272 if (ret) {
2273 ERR("Error killing consumer daemon");
2274 return ret;
2275 }
2276 return pthread_join(consumer_data->thread, &status);
2277 } else {
2278 return 0;
2279 }
2280 }
2281
2282 /*
2283 * Fork and exec a consumer daemon (consumerd).
2284 *
2285 * Return pid if successful else -1.
2286 */
2287 static pid_t spawn_consumerd(struct consumer_data *consumer_data)
2288 {
2289 int ret;
2290 pid_t pid;
2291 const char *consumer_to_use;
2292 const char *verbosity;
2293 struct stat st;
2294
2295 DBG("Spawning consumerd");
2296
2297 pid = fork();
2298 if (pid == 0) {
2299 /*
2300 * Exec consumerd.
2301 */
2302 if (opt_verbose_consumer) {
2303 verbosity = "--verbose";
2304 } else if (lttng_opt_quiet) {
2305 verbosity = "--quiet";
2306 } else {
2307 verbosity = "";
2308 }
2309
2310 switch (consumer_data->type) {
2311 case LTTNG_CONSUMER_KERNEL:
2312 /*
2313 * Find out which consumerd to execute. We will first try the
2314 * 64-bit path, then the sessiond's installation directory, and
2315 * fallback on the 32-bit one,
2316 */
2317 DBG3("Looking for a kernel consumer at these locations:");
2318 DBG3(" 1) %s", consumerd64_bin);
2319 DBG3(" 2) %s/%s", INSTALL_BIN_PATH, CONSUMERD_FILE);
2320 DBG3(" 3) %s", consumerd32_bin);
2321 if (stat(consumerd64_bin, &st) == 0) {
2322 DBG3("Found location #1");
2323 consumer_to_use = consumerd64_bin;
2324 } else if (stat(INSTALL_BIN_PATH "/" CONSUMERD_FILE, &st) == 0) {
2325 DBG3("Found location #2");
2326 consumer_to_use = INSTALL_BIN_PATH "/" CONSUMERD_FILE;
2327 } else if (stat(consumerd32_bin, &st) == 0) {
2328 DBG3("Found location #3");
2329 consumer_to_use = consumerd32_bin;
2330 } else {
2331 DBG("Could not find any valid consumerd executable");
2332 ret = -EINVAL;
2333 break;
2334 }
2335 DBG("Using kernel consumer at: %s", consumer_to_use);
2336 ret = execl(consumer_to_use,
2337 "lttng-consumerd", verbosity, "-k",
2338 "--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
2339 "--consumerd-err-sock", consumer_data->err_unix_sock_path,
2340 "--group", tracing_group_name,
2341 NULL);
2342 break;
2343 case LTTNG_CONSUMER64_UST:
2344 {
2345 char *tmpnew = NULL;
2346
2347 if (consumerd64_libdir[0] != '\0') {
2348 char *tmp;
2349 size_t tmplen;
2350
2351 tmp = getenv("LD_LIBRARY_PATH");
2352 if (!tmp) {
2353 tmp = "";
2354 }
2355 tmplen = strlen("LD_LIBRARY_PATH=")
2356 + strlen(consumerd64_libdir) + 1 /* : */ + strlen(tmp);
2357 tmpnew = zmalloc(tmplen + 1 /* \0 */);
2358 if (!tmpnew) {
2359 ret = -ENOMEM;
2360 goto error;
2361 }
2362 strcpy(tmpnew, "LD_LIBRARY_PATH=");
2363 strcat(tmpnew, consumerd64_libdir);
2364 if (tmp[0] != '\0') {
2365 strcat(tmpnew, ":");
2366 strcat(tmpnew, tmp);
2367 }
2368 ret = putenv(tmpnew);
2369 if (ret) {
2370 ret = -errno;
2371 free(tmpnew);
2372 goto error;
2373 }
2374 }
2375 DBG("Using 64-bit UST consumer at: %s", consumerd64_bin);
2376 ret = execl(consumerd64_bin, "lttng-consumerd", verbosity, "-u",
2377 "--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
2378 "--consumerd-err-sock", consumer_data->err_unix_sock_path,
2379 "--group", tracing_group_name,
2380 NULL);
2381 if (consumerd64_libdir[0] != '\0') {
2382 free(tmpnew);
2383 }
2384 break;
2385 }
2386 case LTTNG_CONSUMER32_UST:
2387 {
2388 char *tmpnew = NULL;
2389
2390 if (consumerd32_libdir[0] != '\0') {
2391 char *tmp;
2392 size_t tmplen;
2393
2394 tmp = getenv("LD_LIBRARY_PATH");
2395 if (!tmp) {
2396 tmp = "";
2397 }
2398 tmplen = strlen("LD_LIBRARY_PATH=")
2399 + strlen(consumerd32_libdir) + 1 /* : */ + strlen(tmp);
2400 tmpnew = zmalloc(tmplen + 1 /* \0 */);
2401 if (!tmpnew) {
2402 ret = -ENOMEM;
2403 goto error;
2404 }
2405 strcpy(tmpnew, "LD_LIBRARY_PATH=");
2406 strcat(tmpnew, consumerd32_libdir);
2407 if (tmp[0] != '\0') {
2408 strcat(tmpnew, ":");
2409 strcat(tmpnew, tmp);
2410 }
2411 ret = putenv(tmpnew);
2412 if (ret) {
2413 ret = -errno;
2414 free(tmpnew);
2415 goto error;
2416 }
2417 }
2418 DBG("Using 32-bit UST consumer at: %s", consumerd32_bin);
2419 ret = execl(consumerd32_bin, "lttng-consumerd", verbosity, "-u",
2420 "--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
2421 "--consumerd-err-sock", consumer_data->err_unix_sock_path,
2422 "--group", tracing_group_name,
2423 NULL);
2424 if (consumerd32_libdir[0] != '\0') {
2425 free(tmpnew);
2426 }
2427 break;
2428 }
2429 default:
2430 PERROR("unknown consumer type");
2431 exit(EXIT_FAILURE);
2432 }
2433 if (errno != 0) {
2434 PERROR("Consumer execl()");
2435 }
2436 /* Reaching this point, we got a failure on our execl(). */
2437 exit(EXIT_FAILURE);
2438 } else if (pid > 0) {
2439 ret = pid;
2440 } else {
2441 PERROR("start consumer fork");
2442 ret = -errno;
2443 }
2444 error:
2445 return ret;
2446 }
2447
2448 /*
2449 * Spawn the consumerd daemon and session daemon thread.
2450 */
2451 static int start_consumerd(struct consumer_data *consumer_data)
2452 {
2453 int ret;
2454
2455 /*
2456 * Set the listen() state on the socket since there is a possible race
2457 * between the exec() of the consumer daemon and this call if place in the
2458 * consumer thread. See bug #366 for more details.
2459 */
2460 ret = lttcomm_listen_unix_sock(consumer_data->err_sock);
2461 if (ret < 0) {
2462 goto error;
2463 }
2464
2465 pthread_mutex_lock(&consumer_data->pid_mutex);
2466 if (consumer_data->pid != 0) {
2467 pthread_mutex_unlock(&consumer_data->pid_mutex);
2468 goto end;
2469 }
2470
2471 ret = spawn_consumerd(consumer_data);
2472 if (ret < 0) {
2473 ERR("Spawning consumerd failed");
2474 pthread_mutex_unlock(&consumer_data->pid_mutex);
2475 goto error;
2476 }
2477
2478 /* Setting up the consumer_data pid */
2479 consumer_data->pid = ret;
2480 DBG2("Consumer pid %d", consumer_data->pid);
2481 pthread_mutex_unlock(&consumer_data->pid_mutex);
2482
2483 DBG2("Spawning consumer control thread");
2484 ret = spawn_consumer_thread(consumer_data);
2485 if (ret < 0) {
2486 ERR("Fatal error spawning consumer control thread");
2487 goto error;
2488 }
2489
2490 end:
2491 return 0;
2492
2493 error:
2494 /* Cleanup already created sockets on error. */
2495 if (consumer_data->err_sock >= 0) {
2496 int err;
2497
2498 err = close(consumer_data->err_sock);
2499 if (err < 0) {
2500 PERROR("close consumer data error socket");
2501 }
2502 }
2503 return ret;
2504 }
2505
2506 /*
2507 * Setup necessary data for kernel tracer action.
2508 */
2509 static int init_kernel_tracer(void)
2510 {
2511 int ret;
2512
2513 /* Modprobe lttng kernel modules */
2514 ret = modprobe_lttng_control();
2515 if (ret < 0) {
2516 goto error;
2517 }
2518
2519 /* Open debugfs lttng */
2520 kernel_tracer_fd = open(module_proc_lttng, O_RDWR);
2521 if (kernel_tracer_fd < 0) {
2522 DBG("Failed to open %s", module_proc_lttng);
2523 ret = -1;
2524 goto error_open;
2525 }
2526
2527 /* Validate kernel version */
2528 ret = kernel_validate_version(kernel_tracer_fd);
2529 if (ret < 0) {
2530 goto error_version;
2531 }
2532
2533 ret = modprobe_lttng_data();
2534 if (ret < 0) {
2535 goto error_modules;
2536 }
2537
2538 DBG("Kernel tracer fd %d", kernel_tracer_fd);
2539 return 0;
2540
2541 error_version:
2542 modprobe_remove_lttng_control();
2543 ret = close(kernel_tracer_fd);
2544 if (ret) {
2545 PERROR("close");
2546 }
2547 kernel_tracer_fd = -1;
2548 return LTTNG_ERR_KERN_VERSION;
2549
2550 error_modules:
2551 ret = close(kernel_tracer_fd);
2552 if (ret) {
2553 PERROR("close");
2554 }
2555
2556 error_open:
2557 modprobe_remove_lttng_control();
2558
2559 error:
2560 WARN("No kernel tracer available");
2561 kernel_tracer_fd = -1;
2562 if (!is_root) {
2563 return LTTNG_ERR_NEED_ROOT_SESSIOND;
2564 } else {
2565 return LTTNG_ERR_KERN_NA;
2566 }
2567 }
2568
2569
2570 /*
2571 * Copy consumer output from the tracing session to the domain session. The
2572 * function also applies the right modification on a per domain basis for the
2573 * trace files destination directory.
2574 *
2575 * Should *NOT* be called with RCU read-side lock held.
2576 */
2577 static int copy_session_consumer(int domain, struct ltt_session *session)
2578 {
2579 int ret;
2580 const char *dir_name;
2581 struct consumer_output *consumer;
2582
2583 assert(session);
2584 assert(session->consumer);
2585
2586 switch (domain) {
2587 case LTTNG_DOMAIN_KERNEL:
2588 DBG3("Copying tracing session consumer output in kernel session");
2589 /*
2590 * XXX: We should audit the session creation and what this function
2591 * does "extra" in order to avoid a destroy since this function is used
2592 * in the domain session creation (kernel and ust) only. Same for UST
2593 * domain.
2594 */
2595 if (session->kernel_session->consumer) {
2596 consumer_destroy_output(session->kernel_session->consumer);
2597 }
2598 session->kernel_session->consumer =
2599 consumer_copy_output(session->consumer);
2600 /* Ease our life a bit for the next part */
2601 consumer = session->kernel_session->consumer;
2602 dir_name = DEFAULT_KERNEL_TRACE_DIR;
2603 break;
2604 case LTTNG_DOMAIN_JUL:
2605 case LTTNG_DOMAIN_LOG4J:
2606 case LTTNG_DOMAIN_UST:
2607 DBG3("Copying tracing session consumer output in UST session");
2608 if (session->ust_session->consumer) {
2609 consumer_destroy_output(session->ust_session->consumer);
2610 }
2611 session->ust_session->consumer =
2612 consumer_copy_output(session->consumer);
2613 /* Ease our life a bit for the next part */
2614 consumer = session->ust_session->consumer;
2615 dir_name = DEFAULT_UST_TRACE_DIR;
2616 break;
2617 default:
2618 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
2619 goto error;
2620 }
2621
2622 /* Append correct directory to subdir */
2623 strncat(consumer->subdir, dir_name,
2624 sizeof(consumer->subdir) - strlen(consumer->subdir) - 1);
2625 DBG3("Copy session consumer subdir %s", consumer->subdir);
2626
2627 ret = LTTNG_OK;
2628
2629 error:
2630 return ret;
2631 }
2632
2633 /*
2634 * Create an UST session and add it to the session ust list.
2635 *
2636 * Should *NOT* be called with RCU read-side lock held.
2637 */
2638 static int create_ust_session(struct ltt_session *session,
2639 struct lttng_domain *domain)
2640 {
2641 int ret;
2642 struct ltt_ust_session *lus = NULL;
2643
2644 assert(session);
2645 assert(domain);
2646 assert(session->consumer);
2647
2648 switch (domain->type) {
2649 case LTTNG_DOMAIN_JUL:
2650 case LTTNG_DOMAIN_LOG4J:
2651 case LTTNG_DOMAIN_UST:
2652 break;
2653 default:
2654 ERR("Unknown UST domain on create session %d", domain->type);
2655 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
2656 goto error;
2657 }
2658
2659 DBG("Creating UST session");
2660
2661 lus = trace_ust_create_session(session->id);
2662 if (lus == NULL) {
2663 ret = LTTNG_ERR_UST_SESS_FAIL;
2664 goto error;
2665 }
2666
2667 lus->uid = session->uid;
2668 lus->gid = session->gid;
2669 lus->output_traces = session->output_traces;
2670 lus->snapshot_mode = session->snapshot_mode;
2671 lus->live_timer_interval = session->live_timer;
2672 session->ust_session = lus;
2673
2674 /* Copy session output to the newly created UST session */
2675 ret = copy_session_consumer(domain->type, session);
2676 if (ret != LTTNG_OK) {
2677 goto error;
2678 }
2679
2680 return LTTNG_OK;
2681
2682 error:
2683 free(lus);
2684 session->ust_session = NULL;
2685 return ret;
2686 }
2687
2688 /*
2689 * Create a kernel tracer session then create the default channel.
2690 */
2691 static int create_kernel_session(struct ltt_session *session)
2692 {
2693 int ret;
2694
2695 DBG("Creating kernel session");
2696
2697 ret = kernel_create_session(session, kernel_tracer_fd);
2698 if (ret < 0) {
2699 ret = LTTNG_ERR_KERN_SESS_FAIL;
2700 goto error;
2701 }
2702
2703 /* Code flow safety */
2704 assert(session->kernel_session);
2705
2706 /* Copy session output to the newly created Kernel session */
2707 ret = copy_session_consumer(LTTNG_DOMAIN_KERNEL, session);
2708 if (ret != LTTNG_OK) {
2709 goto error;
2710 }
2711
2712 /* Create directory(ies) on local filesystem. */
2713 if (session->kernel_session->consumer->type == CONSUMER_DST_LOCAL &&
2714 strlen(session->kernel_session->consumer->dst.trace_path) > 0) {
2715 ret = run_as_mkdir_recursive(
2716 session->kernel_session->consumer->dst.trace_path,
2717 S_IRWXU | S_IRWXG, session->uid, session->gid);
2718 if (ret < 0) {
2719 if (ret != -EEXIST) {
2720 ERR("Trace directory creation error");
2721 goto error;
2722 }
2723 }
2724 }
2725
2726 session->kernel_session->uid = session->uid;
2727 session->kernel_session->gid = session->gid;
2728 session->kernel_session->output_traces = session->output_traces;
2729 session->kernel_session->snapshot_mode = session->snapshot_mode;
2730
2731 return LTTNG_OK;
2732
2733 error:
2734 trace_kernel_destroy_session(session->kernel_session);
2735 session->kernel_session = NULL;
2736 return ret;
2737 }
2738
2739 /*
2740 * Count number of session permitted by uid/gid.
2741 */
2742 static unsigned int lttng_sessions_count(uid_t uid, gid_t gid)
2743 {
2744 unsigned int i = 0;
2745 struct ltt_session *session;
2746
2747 DBG("Counting number of available session for UID %d GID %d",
2748 uid, gid);
2749 cds_list_for_each_entry(session, &session_list_ptr->head, list) {
2750 /*
2751 * Only list the sessions the user can control.
2752 */
2753 if (!session_access_ok(session, uid, gid)) {
2754 continue;
2755 }
2756 i++;
2757 }
2758 return i;
2759 }
2760
2761 /*
2762 * Process the command requested by the lttng client within the command
2763 * context structure. This function make sure that the return structure (llm)
2764 * is set and ready for transmission before returning.
2765 *
2766 * Return any error encountered or 0 for success.
2767 *
2768 * "sock" is only used for special-case var. len data.
2769 *
2770 * Should *NOT* be called with RCU read-side lock held.
2771 */
2772 static int process_client_msg(struct command_ctx *cmd_ctx, int sock,
2773 int *sock_error)
2774 {
2775 int ret = LTTNG_OK;
2776 int need_tracing_session = 1;
2777 int need_domain;
2778
2779 DBG("Processing client command %d", cmd_ctx->lsm->cmd_type);
2780
2781 *sock_error = 0;
2782
2783 switch (cmd_ctx->lsm->cmd_type) {
2784 case LTTNG_CREATE_SESSION:
2785 case LTTNG_CREATE_SESSION_SNAPSHOT:
2786 case LTTNG_CREATE_SESSION_LIVE:
2787 case LTTNG_DESTROY_SESSION:
2788 case LTTNG_LIST_SESSIONS:
2789 case LTTNG_LIST_DOMAINS:
2790 case LTTNG_START_TRACE:
2791 case LTTNG_STOP_TRACE:
2792 case LTTNG_DATA_PENDING:
2793 case LTTNG_SNAPSHOT_ADD_OUTPUT:
2794 case LTTNG_SNAPSHOT_DEL_OUTPUT:
2795 case LTTNG_SNAPSHOT_LIST_OUTPUT:
2796 case LTTNG_SNAPSHOT_RECORD:
2797 case LTTNG_SAVE_SESSION:
2798 need_domain = 0;
2799 break;
2800 default:
2801 need_domain = 1;
2802 }
2803
2804 if (opt_no_kernel && need_domain
2805 && cmd_ctx->lsm->domain.type == LTTNG_DOMAIN_KERNEL) {
2806 if (!is_root) {
2807 ret = LTTNG_ERR_NEED_ROOT_SESSIOND;
2808 } else {
2809 ret = LTTNG_ERR_KERN_NA;
2810 }
2811 goto error;
2812 }
2813
2814 /* Deny register consumer if we already have a spawned consumer. */
2815 if (cmd_ctx->lsm->cmd_type == LTTNG_REGISTER_CONSUMER) {
2816 pthread_mutex_lock(&kconsumer_data.pid_mutex);
2817 if (kconsumer_data.pid > 0) {
2818 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
2819 pthread_mutex_unlock(&kconsumer_data.pid_mutex);
2820 goto error;
2821 }
2822 pthread_mutex_unlock(&kconsumer_data.pid_mutex);
2823 }
2824
2825 /*
2826 * Check for command that don't needs to allocate a returned payload. We do
2827 * this here so we don't have to make the call for no payload at each
2828 * command.
2829 */
2830 switch(cmd_ctx->lsm->cmd_type) {
2831 case LTTNG_LIST_SESSIONS:
2832 case LTTNG_LIST_TRACEPOINTS:
2833 case LTTNG_LIST_TRACEPOINT_FIELDS:
2834 case LTTNG_LIST_DOMAINS:
2835 case LTTNG_LIST_CHANNELS:
2836 case LTTNG_LIST_EVENTS:
2837 case LTTNG_LIST_SYSCALLS:
2838 break;
2839 default:
2840 /* Setup lttng message with no payload */
2841 ret = setup_lttng_msg(cmd_ctx, 0);
2842 if (ret < 0) {
2843 /* This label does not try to unlock the session */
2844 goto init_setup_error;
2845 }
2846 }
2847
2848 /* Commands that DO NOT need a session. */
2849 switch (cmd_ctx->lsm->cmd_type) {
2850 case LTTNG_CREATE_SESSION:
2851 case LTTNG_CREATE_SESSION_SNAPSHOT:
2852 case LTTNG_CREATE_SESSION_LIVE:
2853 case LTTNG_CALIBRATE:
2854 case LTTNG_LIST_SESSIONS:
2855 case LTTNG_LIST_TRACEPOINTS:
2856 case LTTNG_LIST_SYSCALLS:
2857 case LTTNG_LIST_TRACEPOINT_FIELDS:
2858 case LTTNG_SAVE_SESSION:
2859 need_tracing_session = 0;
2860 break;
2861 default:
2862 DBG("Getting session %s by name", cmd_ctx->lsm->session.name);
2863 /*
2864 * We keep the session list lock across _all_ commands
2865 * for now, because the per-session lock does not
2866 * handle teardown properly.
2867 */
2868 session_lock_list();
2869 cmd_ctx->session = session_find_by_name(cmd_ctx->lsm->session.name);
2870 if (cmd_ctx->session == NULL) {
2871 ret = LTTNG_ERR_SESS_NOT_FOUND;
2872 goto error;
2873 } else {
2874 /* Acquire lock for the session */
2875 session_lock(cmd_ctx->session);
2876 }
2877 break;
2878 }
2879
2880 /*
2881 * Commands that need a valid session but should NOT create one if none
2882 * exists. Instead of creating one and destroying it when the command is
2883 * handled, process that right before so we save some round trip in useless
2884 * code path.
2885 */
2886 switch (cmd_ctx->lsm->cmd_type) {
2887 case LTTNG_DISABLE_CHANNEL:
2888 case LTTNG_DISABLE_EVENT:
2889 switch (cmd_ctx->lsm->domain.type) {
2890 case LTTNG_DOMAIN_KERNEL:
2891 if (!cmd_ctx->session->kernel_session) {
2892 ret = LTTNG_ERR_NO_CHANNEL;
2893 goto error;
2894 }
2895 break;
2896 case LTTNG_DOMAIN_JUL:
2897 case LTTNG_DOMAIN_LOG4J:
2898 case LTTNG_DOMAIN_UST:
2899 if (!cmd_ctx->session->ust_session) {
2900 ret = LTTNG_ERR_NO_CHANNEL;
2901 goto error;
2902 }
2903 break;
2904 default:
2905 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
2906 goto error;
2907 }
2908 default:
2909 break;
2910 }
2911
2912 if (!need_domain) {
2913 goto skip_domain;
2914 }
2915
2916 /*
2917 * Check domain type for specific "pre-action".
2918 */
2919 switch (cmd_ctx->lsm->domain.type) {
2920 case LTTNG_DOMAIN_KERNEL:
2921 if (!is_root) {
2922 ret = LTTNG_ERR_NEED_ROOT_SESSIOND;
2923 goto error;
2924 }
2925
2926 /* Kernel tracer check */
2927 if (kernel_tracer_fd == -1) {
2928 /* Basically, load kernel tracer modules */
2929 ret = init_kernel_tracer();
2930 if (ret != 0) {
2931 goto error;
2932 }
2933 }
2934
2935 /* Consumer is in an ERROR state. Report back to client */
2936 if (uatomic_read(&kernel_consumerd_state) == CONSUMER_ERROR) {
2937 ret = LTTNG_ERR_NO_KERNCONSUMERD;
2938 goto error;
2939 }
2940
2941 /* Need a session for kernel command */
2942 if (need_tracing_session) {
2943 if (cmd_ctx->session->kernel_session == NULL) {
2944 ret = create_kernel_session(cmd_ctx->session);
2945 if (ret < 0) {
2946 ret = LTTNG_ERR_KERN_SESS_FAIL;
2947 goto error;
2948 }
2949 }
2950
2951 /* Start the kernel consumer daemon */
2952 pthread_mutex_lock(&kconsumer_data.pid_mutex);
2953 if (kconsumer_data.pid == 0 &&
2954 cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) {
2955 pthread_mutex_unlock(&kconsumer_data.pid_mutex);
2956 ret = start_consumerd(&kconsumer_data);
2957 if (ret < 0) {
2958 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
2959 goto error;
2960 }
2961 uatomic_set(&kernel_consumerd_state, CONSUMER_STARTED);
2962 } else {
2963 pthread_mutex_unlock(&kconsumer_data.pid_mutex);
2964 }
2965
2966 /*
2967 * The consumer was just spawned so we need to add the socket to
2968 * the consumer output of the session if exist.
2969 */
2970 ret = consumer_create_socket(&kconsumer_data,
2971 cmd_ctx->session->kernel_session->consumer);
2972 if (ret < 0) {
2973 goto error;
2974 }
2975 }
2976
2977 break;
2978 case LTTNG_DOMAIN_JUL:
2979 case LTTNG_DOMAIN_LOG4J:
2980 case LTTNG_DOMAIN_UST:
2981 {
2982 if (!ust_app_supported()) {
2983 ret = LTTNG_ERR_NO_UST;
2984 goto error;
2985 }
2986 /* Consumer is in an ERROR state. Report back to client */
2987 if (uatomic_read(&ust_consumerd_state) == CONSUMER_ERROR) {
2988 ret = LTTNG_ERR_NO_USTCONSUMERD;
2989 goto error;
2990 }
2991
2992 if (need_tracing_session) {
2993 /* Create UST session if none exist. */
2994 if (cmd_ctx->session->ust_session == NULL) {
2995 ret = create_ust_session(cmd_ctx->session,
2996 &cmd_ctx->lsm->domain);
2997 if (ret != LTTNG_OK) {
2998 goto error;
2999 }
3000 }
3001
3002 /* Start the UST consumer daemons */
3003 /* 64-bit */
3004 pthread_mutex_lock(&ustconsumer64_data.pid_mutex);
3005 if (consumerd64_bin[0] != '\0' &&
3006 ustconsumer64_data.pid == 0 &&
3007 cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) {
3008 pthread_mutex_unlock(&ustconsumer64_data.pid_mutex);
3009 ret = start_consumerd(&ustconsumer64_data);
3010 if (ret < 0) {
3011 ret = LTTNG_ERR_UST_CONSUMER64_FAIL;
3012 uatomic_set(&ust_consumerd64_fd, -EINVAL);
3013 goto error;
3014 }
3015
3016 uatomic_set(&ust_consumerd64_fd, ustconsumer64_data.cmd_sock);
3017 uatomic_set(&ust_consumerd_state, CONSUMER_STARTED);
3018 } else {
3019 pthread_mutex_unlock(&ustconsumer64_data.pid_mutex);
3020 }
3021
3022 /*
3023 * Setup socket for consumer 64 bit. No need for atomic access
3024 * since it was set above and can ONLY be set in this thread.
3025 */
3026 ret = consumer_create_socket(&ustconsumer64_data,
3027 cmd_ctx->session->ust_session->consumer);
3028 if (ret < 0) {
3029 goto error;
3030 }
3031
3032 /* 32-bit */
3033 pthread_mutex_lock(&ustconsumer32_data.pid_mutex);
3034 if (consumerd32_bin[0] != '\0' &&
3035 ustconsumer32_data.pid == 0 &&
3036 cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) {
3037 pthread_mutex_unlock(&ustconsumer32_data.pid_mutex);
3038 ret = start_consumerd(&ustconsumer32_data);
3039 if (ret < 0) {
3040 ret = LTTNG_ERR_UST_CONSUMER32_FAIL;
3041 uatomic_set(&ust_consumerd32_fd, -EINVAL);
3042 goto error;
3043 }
3044
3045 uatomic_set(&ust_consumerd32_fd, ustconsumer32_data.cmd_sock);
3046 uatomic_set(&ust_consumerd_state, CONSUMER_STARTED);
3047 } else {
3048 pthread_mutex_unlock(&ustconsumer32_data.pid_mutex);
3049 }
3050
3051 /*
3052 * Setup socket for consumer 64 bit. No need for atomic access
3053 * since it was set above and can ONLY be set in this thread.
3054 */
3055 ret = consumer_create_socket(&ustconsumer32_data,
3056 cmd_ctx->session->ust_session->consumer);
3057 if (ret < 0) {
3058 goto error;
3059 }
3060 }
3061 break;
3062 }
3063 default:
3064 break;
3065 }
3066 skip_domain:
3067
3068 /* Validate consumer daemon state when start/stop trace command */
3069 if (cmd_ctx->lsm->cmd_type == LTTNG_START_TRACE ||
3070 cmd_ctx->lsm->cmd_type == LTTNG_STOP_TRACE) {
3071 switch (cmd_ctx->lsm->domain.type) {
3072 case LTTNG_DOMAIN_JUL:
3073 case LTTNG_DOMAIN_LOG4J:
3074 case LTTNG_DOMAIN_UST:
3075 if (uatomic_read(&ust_consumerd_state) != CONSUMER_STARTED) {
3076 ret = LTTNG_ERR_NO_USTCONSUMERD;
3077 goto error;
3078 }
3079 break;
3080 case LTTNG_DOMAIN_KERNEL:
3081 if (uatomic_read(&kernel_consumerd_state) != CONSUMER_STARTED) {
3082 ret = LTTNG_ERR_NO_KERNCONSUMERD;
3083 goto error;
3084 }
3085 break;
3086 }
3087 }
3088
3089 /*
3090 * Check that the UID or GID match that of the tracing session.
3091 * The root user can interact with all sessions.
3092 */
3093 if (need_tracing_session) {
3094 if (!session_access_ok(cmd_ctx->session,
3095 LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
3096 LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds))) {
3097 ret = LTTNG_ERR_EPERM;
3098 goto error;
3099 }
3100 }
3101
3102 /*
3103 * Send relayd information to consumer as soon as we have a domain and a
3104 * session defined.
3105 */
3106 if (cmd_ctx->session && need_domain) {
3107 /*
3108 * Setup relayd if not done yet. If the relayd information was already
3109 * sent to the consumer, this call will gracefully return.
3110 */
3111 ret = cmd_setup_relayd(cmd_ctx->session);
3112 if (ret != LTTNG_OK) {
3113 goto error;
3114 }
3115 }
3116
3117 /* Process by command type */
3118 switch (cmd_ctx->lsm->cmd_type) {
3119 case LTTNG_ADD_CONTEXT:
3120 {
3121 ret = cmd_add_context(cmd_ctx->session, cmd_ctx->lsm->domain.type,
3122 cmd_ctx->lsm->u.context.channel_name,
3123 &cmd_ctx->lsm->u.context.ctx, kernel_poll_pipe[1]);
3124 break;
3125 }
3126 case LTTNG_DISABLE_CHANNEL:
3127 {
3128 ret = cmd_disable_channel(cmd_ctx->session, cmd_ctx->lsm->domain.type,
3129 cmd_ctx->lsm->u.disable.channel_name);
3130 break;
3131 }
3132 case LTTNG_DISABLE_EVENT:
3133 {
3134 /* FIXME: passing packed structure to non-packed pointer */
3135 /* TODO: handle filter */
3136 ret = cmd_disable_event(cmd_ctx->session, cmd_ctx->lsm->domain.type,
3137 cmd_ctx->lsm->u.disable.channel_name,
3138 &cmd_ctx->lsm->u.disable.event);
3139 break;
3140 }
3141 case LTTNG_ENABLE_CHANNEL:
3142 {
3143 ret = cmd_enable_channel(cmd_ctx->session, &cmd_ctx->lsm->domain,
3144 &cmd_ctx->lsm->u.channel.chan, kernel_poll_pipe[1]);
3145 break;
3146 }
3147 case LTTNG_ENABLE_EVENT:
3148 {
3149 struct lttng_event_exclusion *exclusion = NULL;
3150 struct lttng_filter_bytecode *bytecode = NULL;
3151 char *filter_expression = NULL;
3152
3153 /* Handle exclusion events and receive it from the client. */
3154 if (cmd_ctx->lsm->u.enable.exclusion_count > 0) {
3155 size_t count = cmd_ctx->lsm->u.enable.exclusion_count;
3156
3157 exclusion = zmalloc(sizeof(struct lttng_event_exclusion) +
3158 (count * LTTNG_SYMBOL_NAME_LEN));
3159 if (!exclusion) {
3160 ret = LTTNG_ERR_EXCLUSION_NOMEM;
3161 goto error;
3162 }
3163
3164 DBG("Receiving var len exclusion event list from client ...");
3165 exclusion->count = count;
3166 ret = lttcomm_recv_unix_sock(sock, exclusion->names,
3167 count * LTTNG_SYMBOL_NAME_LEN);
3168 if (ret <= 0) {
3169 DBG("Nothing recv() from client var len data... continuing");
3170 *sock_error = 1;
3171 free(exclusion);
3172 ret = LTTNG_ERR_EXCLUSION_INVAL;
3173 goto error;
3174 }
3175 }
3176
3177 /* Get filter expression from client. */
3178 if (cmd_ctx->lsm->u.enable.expression_len > 0) {
3179 size_t expression_len =
3180 cmd_ctx->lsm->u.enable.expression_len;
3181
3182 if (expression_len > LTTNG_FILTER_MAX_LEN) {
3183 ret = LTTNG_ERR_FILTER_INVAL;
3184 free(exclusion);
3185 goto error;
3186 }
3187
3188 filter_expression = zmalloc(expression_len);
3189 if (!filter_expression) {
3190 free(exclusion);
3191 ret = LTTNG_ERR_FILTER_NOMEM;
3192 goto error;
3193 }
3194
3195 /* Receive var. len. data */
3196 DBG("Receiving var len filter's expression from client ...");
3197 ret = lttcomm_recv_unix_sock(sock, filter_expression,
3198 expression_len);
3199 if (ret <= 0) {
3200 DBG("Nothing recv() from client car len data... continuing");
3201 *sock_error = 1;
3202 free(filter_expression);
3203 free(exclusion);
3204 ret = LTTNG_ERR_FILTER_INVAL;
3205 goto error;
3206 }
3207 }
3208
3209 /* Handle filter and get bytecode from client. */
3210 if (cmd_ctx->lsm->u.enable.bytecode_len > 0) {
3211 size_t bytecode_len = cmd_ctx->lsm->u.enable.bytecode_len;
3212
3213 if (bytecode_len > LTTNG_FILTER_MAX_LEN) {
3214 ret = LTTNG_ERR_FILTER_INVAL;
3215 free(exclusion);
3216 goto error;
3217 }
3218
3219 bytecode = zmalloc(bytecode_len);
3220 if (!bytecode) {
3221 free(exclusion);
3222 ret = LTTNG_ERR_FILTER_NOMEM;
3223 goto error;
3224 }
3225
3226 /* Receive var. len. data */
3227 DBG("Receiving var len filter's bytecode from client ...");
3228 ret = lttcomm_recv_unix_sock(sock, bytecode, bytecode_len);
3229 if (ret <= 0) {
3230 DBG("Nothing recv() from client car len data... continuing");
3231 *sock_error = 1;
3232 free(bytecode);
3233 free(exclusion);
3234 ret = LTTNG_ERR_FILTER_INVAL;
3235 goto error;
3236 }
3237
3238 if ((bytecode->len + sizeof(*bytecode)) != bytecode_len) {
3239 free(bytecode);
3240 free(exclusion);
3241 ret = LTTNG_ERR_FILTER_INVAL;
3242 goto error;
3243 }
3244 }
3245
3246 ret = cmd_enable_event(cmd_ctx->session, &cmd_ctx->lsm->domain,
3247 cmd_ctx->lsm->u.enable.channel_name,
3248 &cmd_ctx->lsm->u.enable.event,
3249 filter_expression, bytecode, exclusion,
3250 kernel_poll_pipe[1]);
3251 break;
3252 }
3253 case LTTNG_LIST_TRACEPOINTS:
3254 {
3255 struct lttng_event *events;
3256 ssize_t nb_events;
3257
3258 session_lock_list();
3259 nb_events = cmd_list_tracepoints(cmd_ctx->lsm->domain.type, &events);
3260 session_unlock_list();
3261 if (nb_events < 0) {
3262 /* Return value is a negative lttng_error_code. */
3263 ret = -nb_events;
3264 goto error;
3265 }
3266
3267 /*
3268 * Setup lttng message with payload size set to the event list size in
3269 * bytes and then copy list into the llm payload.
3270 */
3271 ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_event) * nb_events);
3272 if (ret < 0) {
3273 free(events);
3274 goto setup_error;
3275 }
3276
3277 /* Copy event list into message payload */
3278 memcpy(cmd_ctx->llm->payload, events,
3279 sizeof(struct lttng_event) * nb_events);
3280
3281 free(events);
3282
3283 ret = LTTNG_OK;
3284 break;
3285 }
3286 case LTTNG_LIST_TRACEPOINT_FIELDS:
3287 {
3288 struct lttng_event_field *fields;
3289 ssize_t nb_fields;
3290
3291 session_lock_list();
3292 nb_fields = cmd_list_tracepoint_fields(cmd_ctx->lsm->domain.type,
3293 &fields);
3294 session_unlock_list();
3295 if (nb_fields < 0) {
3296 /* Return value is a negative lttng_error_code. */
3297 ret = -nb_fields;
3298 goto error;
3299 }
3300
3301 /*
3302 * Setup lttng message with payload size set to the event list size in
3303 * bytes and then copy list into the llm payload.
3304 */
3305 ret = setup_lttng_msg(cmd_ctx,
3306 sizeof(struct lttng_event_field) * nb_fields);
3307 if (ret < 0) {
3308 free(fields);
3309 goto setup_error;
3310 }
3311
3312 /* Copy event list into message payload */
3313 memcpy(cmd_ctx->llm->payload, fields,
3314 sizeof(struct lttng_event_field) * nb_fields);
3315
3316 free(fields);
3317
3318 ret = LTTNG_OK;
3319 break;
3320 }
3321 case LTTNG_LIST_SYSCALLS:
3322 {
3323 struct lttng_event *events;
3324 ssize_t nb_events;
3325
3326 nb_events = cmd_list_syscalls(&events);
3327 if (nb_events < 0) {
3328 /* Return value is a negative lttng_error_code. */
3329 ret = -nb_events;
3330 goto error;
3331 }
3332
3333 /*
3334 * Setup lttng message with payload size set to the event list size in
3335 * bytes and then copy list into the llm payload.
3336 */
3337 ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_event) * nb_events);
3338 if (ret < 0) {
3339 free(events);
3340 goto setup_error;
3341 }
3342
3343 /* Copy event list into message payload */
3344 memcpy(cmd_ctx->llm->payload, events,
3345 sizeof(struct lttng_event) * nb_events);
3346
3347 free(events);
3348
3349 ret = LTTNG_OK;
3350 break;
3351 }
3352 case LTTNG_SET_CONSUMER_URI:
3353 {
3354 size_t nb_uri, len;
3355 struct lttng_uri *uris;
3356
3357 nb_uri = cmd_ctx->lsm->u.uri.size;
3358 len = nb_uri * sizeof(struct lttng_uri);
3359
3360 if (nb_uri == 0) {
3361 ret = LTTNG_ERR_INVALID;
3362 goto error;
3363 }
3364
3365 uris = zmalloc(len);
3366 if (uris == NULL) {
3367 ret = LTTNG_ERR_FATAL;
3368 goto error;
3369 }
3370
3371 /* Receive variable len data */
3372 DBG("Receiving %zu URI(s) from client ...", nb_uri);
3373 ret = lttcomm_recv_unix_sock(sock, uris, len);
3374 if (ret <= 0) {
3375 DBG("No URIs received from client... continuing");
3376 *sock_error = 1;
3377 ret = LTTNG_ERR_SESSION_FAIL;
3378 free(uris);
3379 goto error;
3380 }
3381
3382 ret = cmd_set_consumer_uri(cmd_ctx->lsm->domain.type, cmd_ctx->session,
3383 nb_uri, uris);
3384 if (ret != LTTNG_OK) {
3385 free(uris);
3386 goto error;
3387 }
3388
3389 /*
3390 * XXX: 0 means that this URI should be applied on the session. Should
3391 * be a DOMAIN enuam.
3392 */
3393 if (cmd_ctx->lsm->domain.type == 0) {
3394 /* Add the URI for the UST session if a consumer is present. */
3395 if (cmd_ctx->session->ust_session &&
3396 cmd_ctx->session->ust_session->consumer) {
3397 ret = cmd_set_consumer_uri(LTTNG_DOMAIN_UST, cmd_ctx->session,
3398 nb_uri, uris);
3399 } else if (cmd_ctx->session->kernel_session &&
3400 cmd_ctx->session->kernel_session->consumer) {
3401 ret = cmd_set_consumer_uri(LTTNG_DOMAIN_KERNEL,
3402 cmd_ctx->session, nb_uri, uris);
3403 }
3404 }
3405
3406 free(uris);
3407
3408 break;
3409 }
3410 case LTTNG_START_TRACE:
3411 {
3412 ret = cmd_start_trace(cmd_ctx->session);
3413 break;
3414 }
3415 case LTTNG_STOP_TRACE:
3416 {
3417 ret = cmd_stop_trace(cmd_ctx->session);
3418 break;
3419 }
3420 case LTTNG_CREATE_SESSION:
3421 {
3422 size_t nb_uri, len;
3423 struct lttng_uri *uris = NULL;
3424
3425 nb_uri = cmd_ctx->lsm->u.uri.size;
3426 len = nb_uri * sizeof(struct lttng_uri);
3427
3428 if (nb_uri > 0) {
3429 uris = zmalloc(len);
3430 if (uris == NULL) {
3431 ret = LTTNG_ERR_FATAL;
3432 goto error;
3433 }
3434
3435 /* Receive variable len data */
3436 DBG("Waiting for %zu URIs from client ...", nb_uri);
3437 ret = lttcomm_recv_unix_sock(sock, uris, len);
3438 if (ret <= 0) {
3439 DBG("No URIs received from client... continuing");
3440 *sock_error = 1;
3441 ret = LTTNG_ERR_SESSION_FAIL;
3442 free(uris);
3443 goto error;
3444 }
3445
3446 if (nb_uri == 1 && uris[0].dtype != LTTNG_DST_PATH) {
3447 DBG("Creating session with ONE network URI is a bad call");
3448 ret = LTTNG_ERR_SESSION_FAIL;
3449 free(uris);
3450 goto error;
3451 }
3452 }
3453
3454 ret = cmd_create_session_uri(cmd_ctx->lsm->session.name, uris, nb_uri,
3455 &cmd_ctx->creds, 0);
3456
3457 free(uris);
3458
3459 break;
3460 }
3461 case LTTNG_DESTROY_SESSION:
3462 {
3463 ret = cmd_destroy_session(cmd_ctx->session, kernel_poll_pipe[1]);
3464
3465 /* Set session to NULL so we do not unlock it after free. */
3466 cmd_ctx->session = NULL;
3467 break;
3468 }
3469 case LTTNG_LIST_DOMAINS:
3470 {
3471 ssize_t nb_dom;
3472 struct lttng_domain *domains;
3473
3474 nb_dom = cmd_list_domains(cmd_ctx->session, &domains);
3475 if (nb_dom < 0) {
3476 /* Return value is a negative lttng_error_code. */
3477 ret = -nb_dom;
3478 goto error;
3479 }
3480
3481 ret = setup_lttng_msg(cmd_ctx, nb_dom * sizeof(struct lttng_domain));
3482 if (ret < 0) {
3483 free(domains);
3484 goto setup_error;
3485 }
3486
3487 /* Copy event list into message payload */
3488 memcpy(cmd_ctx->llm->payload, domains,
3489 nb_dom * sizeof(struct lttng_domain));
3490
3491 free(domains);
3492
3493 ret = LTTNG_OK;
3494 break;
3495 }
3496 case LTTNG_LIST_CHANNELS:
3497 {
3498 int nb_chan;
3499 struct lttng_channel *channels;
3500
3501 nb_chan = cmd_list_channels(cmd_ctx->lsm->domain.type,
3502 cmd_ctx->session, &channels);
3503 if (nb_chan < 0) {
3504 /* Return value is a negative lttng_error_code. */
3505 ret = -nb_chan;
3506 goto error;
3507 }
3508
3509 ret = setup_lttng_msg(cmd_ctx, nb_chan * sizeof(struct lttng_channel));
3510 if (ret < 0) {
3511 free(channels);
3512 goto setup_error;
3513 }
3514
3515 /* Copy event list into message payload */
3516 memcpy(cmd_ctx->llm->payload, channels,
3517 nb_chan * sizeof(struct lttng_channel));
3518
3519 free(channels);
3520
3521 ret = LTTNG_OK;
3522 break;
3523 }
3524 case LTTNG_LIST_EVENTS:
3525 {
3526 ssize_t nb_event;
3527 struct lttng_event *events = NULL;
3528
3529 nb_event = cmd_list_events(cmd_ctx->lsm->domain.type, cmd_ctx->session,
3530 cmd_ctx->lsm->u.list.channel_name, &events);
3531 if (nb_event < 0) {
3532 /* Return value is a negative lttng_error_code. */
3533 ret = -nb_event;
3534 goto error;
3535 }
3536
3537 ret = setup_lttng_msg(cmd_ctx, nb_event * sizeof(struct lttng_event));
3538 if (ret < 0) {
3539 free(events);
3540 goto setup_error;
3541 }
3542
3543 /* Copy event list into message payload */
3544 memcpy(cmd_ctx->llm->payload, events,
3545 nb_event * sizeof(struct lttng_event));
3546
3547 free(events);
3548
3549 ret = LTTNG_OK;
3550 break;
3551 }
3552 case LTTNG_LIST_SESSIONS:
3553 {
3554 unsigned int nr_sessions;
3555
3556 session_lock_list();
3557 nr_sessions = lttng_sessions_count(
3558 LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
3559 LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds));
3560
3561 ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_session) * nr_sessions);
3562 if (ret < 0) {
3563 session_unlock_list();
3564 goto setup_error;
3565 }
3566
3567 /* Filled the session array */
3568 cmd_list_lttng_sessions((struct lttng_session *)(cmd_ctx->llm->payload),
3569 LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
3570 LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds));
3571
3572 session_unlock_list();
3573
3574 ret = LTTNG_OK;
3575 break;
3576 }
3577 case LTTNG_CALIBRATE:
3578 {
3579 ret = cmd_calibrate(cmd_ctx->lsm->domain.type,
3580 &cmd_ctx->lsm->u.calibrate);
3581 break;
3582 }
3583 case LTTNG_REGISTER_CONSUMER:
3584 {
3585 struct consumer_data *cdata;
3586
3587 switch (cmd_ctx->lsm->domain.type) {
3588 case LTTNG_DOMAIN_KERNEL:
3589 cdata = &kconsumer_data;
3590 break;
3591 default:
3592 ret = LTTNG_ERR_UND;
3593 goto error;
3594 }
3595
3596 ret = cmd_register_consumer(cmd_ctx->session, cmd_ctx->lsm->domain.type,
3597 cmd_ctx->lsm->u.reg.path, cdata);
3598 break;
3599 }
3600 case LTTNG_DATA_PENDING:
3601 {
3602 ret = cmd_data_pending(cmd_ctx->session);
3603 break;
3604 }
3605 case LTTNG_SNAPSHOT_ADD_OUTPUT:
3606 {
3607 struct lttcomm_lttng_output_id reply;
3608
3609 ret = cmd_snapshot_add_output(cmd_ctx->session,
3610 &cmd_ctx->lsm->u.snapshot_output.output, &reply.id);
3611 if (ret != LTTNG_OK) {
3612 goto error;
3613 }
3614
3615 ret = setup_lttng_msg(cmd_ctx, sizeof(reply));
3616 if (ret < 0) {
3617 goto setup_error;
3618 }
3619
3620 /* Copy output list into message payload */
3621 memcpy(cmd_ctx->llm->payload, &reply, sizeof(reply));
3622 ret = LTTNG_OK;
3623 break;
3624 }
3625 case LTTNG_SNAPSHOT_DEL_OUTPUT:
3626 {
3627 ret = cmd_snapshot_del_output(cmd_ctx->session,
3628 &cmd_ctx->lsm->u.snapshot_output.output);
3629 break;
3630 }
3631 case LTTNG_SNAPSHOT_LIST_OUTPUT:
3632 {
3633 ssize_t nb_output;
3634 struct lttng_snapshot_output *outputs = NULL;
3635
3636 nb_output = cmd_snapshot_list_outputs(cmd_ctx->session, &outputs);
3637 if (nb_output < 0) {
3638 ret = -nb_output;
3639 goto error;
3640 }
3641
3642 ret = setup_lttng_msg(cmd_ctx,
3643 nb_output * sizeof(struct lttng_snapshot_output));
3644 if (ret < 0) {
3645 free(outputs);
3646 goto setup_error;
3647 }
3648
3649 if (outputs) {
3650 /* Copy output list into message payload */
3651 memcpy(cmd_ctx->llm->payload, outputs,
3652 nb_output * sizeof(struct lttng_snapshot_output));
3653 free(outputs);
3654 }
3655
3656 ret = LTTNG_OK;
3657 break;
3658 }
3659 case LTTNG_SNAPSHOT_RECORD:
3660 {
3661 ret = cmd_snapshot_record(cmd_ctx->session,
3662 &cmd_ctx->lsm->u.snapshot_record.output,
3663 cmd_ctx->lsm->u.snapshot_record.wait);
3664 break;
3665 }
3666 case LTTNG_CREATE_SESSION_SNAPSHOT:
3667 {
3668 size_t nb_uri, len;
3669 struct lttng_uri *uris = NULL;
3670
3671 nb_uri = cmd_ctx->lsm->u.uri.size;
3672 len = nb_uri * sizeof(struct lttng_uri);
3673
3674 if (nb_uri > 0) {
3675 uris = zmalloc(len);
3676 if (uris == NULL) {
3677 ret = LTTNG_ERR_FATAL;
3678 goto error;
3679 }
3680
3681 /* Receive variable len data */
3682 DBG("Waiting for %zu URIs from client ...", nb_uri);
3683 ret = lttcomm_recv_unix_sock(sock, uris, len);
3684 if (ret <= 0) {
3685 DBG("No URIs received from client... continuing");
3686 *sock_error = 1;
3687 ret = LTTNG_ERR_SESSION_FAIL;
3688 free(uris);
3689 goto error;
3690 }
3691
3692 if (nb_uri == 1 && uris[0].dtype != LTTNG_DST_PATH) {
3693 DBG("Creating session with ONE network URI is a bad call");
3694 ret = LTTNG_ERR_SESSION_FAIL;
3695 free(uris);
3696 goto error;
3697 }
3698 }
3699
3700 ret = cmd_create_session_snapshot(cmd_ctx->lsm->session.name, uris,
3701 nb_uri, &cmd_ctx->creds);
3702 free(uris);
3703 break;
3704 }
3705 case LTTNG_CREATE_SESSION_LIVE:
3706 {
3707 size_t nb_uri, len;
3708 struct lttng_uri *uris = NULL;
3709
3710 nb_uri = cmd_ctx->lsm->u.uri.size;
3711 len = nb_uri * sizeof(struct lttng_uri);
3712
3713 if (nb_uri > 0) {
3714 uris = zmalloc(len);
3715 if (uris == NULL) {
3716 ret = LTTNG_ERR_FATAL;
3717 goto error;
3718 }
3719
3720 /* Receive variable len data */
3721 DBG("Waiting for %zu URIs from client ...", nb_uri);
3722 ret = lttcomm_recv_unix_sock(sock, uris, len);
3723 if (ret <= 0) {
3724 DBG("No URIs received from client... continuing");
3725 *sock_error = 1;
3726 ret = LTTNG_ERR_SESSION_FAIL;
3727 free(uris);
3728 goto error;
3729 }
3730
3731 if (nb_uri == 1 && uris[0].dtype != LTTNG_DST_PATH) {
3732 DBG("Creating session with ONE network URI is a bad call");
3733 ret = LTTNG_ERR_SESSION_FAIL;
3734 free(uris);
3735 goto error;
3736 }
3737 }
3738
3739 ret = cmd_create_session_uri(cmd_ctx->lsm->session.name, uris,
3740 nb_uri, &cmd_ctx->creds, cmd_ctx->lsm->u.session_live.timer_interval);
3741 free(uris);
3742 break;
3743 }
3744 case LTTNG_SAVE_SESSION:
3745 {
3746 ret = cmd_save_sessions(&cmd_ctx->lsm->u.save_session.attr,
3747 &cmd_ctx->creds);
3748 break;
3749 }
3750 default:
3751 ret = LTTNG_ERR_UND;
3752 break;
3753 }
3754
3755 error:
3756 if (cmd_ctx->llm == NULL) {
3757 DBG("Missing llm structure. Allocating one.");
3758 if (setup_lttng_msg(cmd_ctx, 0) < 0) {
3759 goto setup_error;
3760 }
3761 }
3762 /* Set return code */
3763 cmd_ctx->llm->ret_code = ret;
3764 setup_error:
3765 if (cmd_ctx->session) {
3766 session_unlock(cmd_ctx->session);
3767 }
3768 if (need_tracing_session) {
3769 session_unlock_list();
3770 }
3771 init_setup_error:
3772 return ret;
3773 }
3774
3775 /*
3776 * Thread managing health check socket.
3777 */
3778 static void *thread_manage_health(void *data)
3779 {
3780 int sock = -1, new_sock = -1, ret, i, pollfd, err = -1;
3781 uint32_t revents, nb_fd;
3782 struct lttng_poll_event events;
3783 struct health_comm_msg msg;
3784 struct health_comm_reply reply;
3785
3786 DBG("[thread] Manage health check started");
3787
3788 rcu_register_thread();
3789
3790 /* We might hit an error path before this is created. */
3791 lttng_poll_init(&events);
3792
3793 /* Create unix socket */
3794 sock = lttcomm_create_unix_sock(health_unix_sock_path);
3795 if (sock < 0) {
3796 ERR("Unable to create health check Unix socket");
3797 ret = -1;
3798 goto error;
3799 }
3800
3801 if (is_root) {
3802 /* lttng health client socket path permissions */
3803 ret = chown(health_unix_sock_path, 0,
3804 utils_get_group_id(tracing_group_name));
3805 if (ret < 0) {
3806 ERR("Unable to set group on %s", health_unix_sock_path);
3807 PERROR("chown");
3808 ret = -1;
3809 goto error;
3810 }
3811
3812 ret = chmod(health_unix_sock_path,
3813 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
3814 if (ret < 0) {
3815 ERR("Unable to set permissions on %s", health_unix_sock_path);
3816 PERROR("chmod");
3817 ret = -1;
3818 goto error;
3819 }
3820 }
3821
3822 /*
3823 * Set the CLOEXEC flag. Return code is useless because either way, the
3824 * show must go on.
3825 */
3826 (void) utils_set_fd_cloexec(sock);
3827
3828 ret = lttcomm_listen_unix_sock(sock);
3829 if (ret < 0) {
3830 goto error;
3831 }
3832
3833 /*
3834 * Pass 2 as size here for the thread quit pipe and client_sock. Nothing
3835 * more will be added to this poll set.
3836 */
3837 ret = sessiond_set_thread_pollset(&events, 2);
3838 if (ret < 0) {
3839 goto error;
3840 }
3841
3842 /* Add the application registration socket */
3843 ret = lttng_poll_add(&events, sock, LPOLLIN | LPOLLPRI);
3844 if (ret < 0) {
3845 goto error;
3846 }
3847
3848 sessiond_notify_ready();
3849
3850 while (1) {
3851 DBG("Health check ready");
3852
3853 /* Inifinite blocking call, waiting for transmission */
3854 restart:
3855 ret = lttng_poll_wait(&events, -1);
3856 if (ret < 0) {
3857 /*
3858 * Restart interrupted system call.
3859 */
3860 if (errno == EINTR) {
3861 goto restart;
3862 }
3863 goto error;
3864 }
3865
3866 nb_fd = ret;
3867
3868 for (i = 0; i < nb_fd; i++) {
3869 /* Fetch once the poll data */
3870 revents = LTTNG_POLL_GETEV(&events, i);
3871 pollfd = LTTNG_POLL_GETFD(&events, i);
3872
3873 /* Thread quit pipe has been closed. Killing thread. */
3874 ret = sessiond_check_thread_quit_pipe(pollfd, revents);
3875 if (ret) {
3876 err = 0;
3877 goto exit;
3878 }
3879
3880 /* Event on the registration socket */
3881 if (pollfd == sock) {
3882 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
3883 ERR("Health socket poll error");
3884 goto error;
3885 }
3886 }
3887 }
3888
3889 new_sock = lttcomm_accept_unix_sock(sock);
3890 if (new_sock < 0) {
3891 goto error;
3892 }
3893
3894 /*
3895 * Set the CLOEXEC flag. Return code is useless because either way, the
3896 * show must go on.
3897 */
3898 (void) utils_set_fd_cloexec(new_sock);
3899
3900 DBG("Receiving data from client for health...");
3901 ret = lttcomm_recv_unix_sock(new_sock, (void *)&msg, sizeof(msg));
3902 if (ret <= 0) {
3903 DBG("Nothing recv() from client... continuing");
3904 ret = close(new_sock);
3905 if (ret) {
3906 PERROR("close");
3907 }
3908 new_sock = -1;
3909 continue;
3910 }
3911
3912 rcu_thread_online();
3913
3914 memset(&reply, 0, sizeof(reply));
3915 for (i = 0; i < NR_HEALTH_SESSIOND_TYPES; i++) {
3916 /*
3917 * health_check_state returns 0 if health is
3918 * bad.
3919 */
3920 if (!health_check_state(health_sessiond, i)) {
3921 reply.ret_code |= 1ULL << i;
3922 }
3923 }
3924
3925 DBG2("Health check return value %" PRIx64, reply.ret_code);
3926
3927 ret = send_unix_sock(new_sock, (void *) &reply, sizeof(reply));
3928 if (ret < 0) {
3929 ERR("Failed to send health data back to client");
3930 }
3931
3932 /* End of transmission */
3933 ret = close(new_sock);
3934 if (ret) {
3935 PERROR("close");
3936 }
3937 new_sock = -1;
3938 }
3939
3940 exit:
3941 error:
3942 if (err) {
3943 ERR("Health error occurred in %s", __func__);
3944 }
3945 DBG("Health check thread dying");
3946 unlink(health_unix_sock_path);
3947 if (sock >= 0) {
3948 ret = close(sock);
3949 if (ret) {
3950 PERROR("close");
3951 }
3952 }
3953
3954 lttng_poll_clean(&events);
3955
3956 rcu_unregister_thread();
3957 return NULL;
3958 }
3959
3960 /*
3961 * This thread manage all clients request using the unix client socket for
3962 * communication.
3963 */
3964 static void *thread_manage_clients(void *data)
3965 {
3966 int sock = -1, ret, i, pollfd, err = -1;
3967 int sock_error;
3968 uint32_t revents, nb_fd;
3969 struct command_ctx *cmd_ctx = NULL;
3970 struct lttng_poll_event events;
3971
3972 DBG("[thread] Manage client started");
3973
3974 rcu_register_thread();
3975
3976 health_register(health_sessiond, HEALTH_SESSIOND_TYPE_CMD);
3977
3978 health_code_update();
3979
3980 ret = lttcomm_listen_unix_sock(client_sock);
3981 if (ret < 0) {
3982 goto error_listen;
3983 }
3984
3985 /*
3986 * Pass 2 as size here for the thread quit pipe and client_sock. Nothing
3987 * more will be added to this poll set.
3988 */
3989 ret = sessiond_set_thread_pollset(&events, 2);
3990 if (ret < 0) {
3991 goto error_create_poll;
3992 }
3993
3994 /* Add the application registration socket */
3995 ret = lttng_poll_add(&events, client_sock, LPOLLIN | LPOLLPRI);
3996 if (ret < 0) {
3997 goto error;
3998 }
3999
4000 sessiond_notify_ready();
4001 ret = sem_post(&load_info->message_thread_ready);
4002 if (ret) {
4003 PERROR("sem_post message_thread_ready");
4004 goto error;
4005 }
4006
4007 /* This testpoint is after we signal readiness to the parent. */
4008 if (testpoint(sessiond_thread_manage_clients)) {
4009 goto error;
4010 }
4011
4012 if (testpoint(sessiond_thread_manage_clients_before_loop)) {
4013 goto error;
4014 }
4015
4016 health_code_update();
4017
4018 while (1) {
4019 DBG("Accepting client command ...");
4020
4021 /* Inifinite blocking call, waiting for transmission */
4022 restart:
4023 health_poll_entry();
4024 ret = lttng_poll_wait(&events, -1);
4025 health_poll_exit();
4026 if (ret < 0) {
4027 /*
4028 * Restart interrupted system call.
4029 */
4030 if (errno == EINTR) {
4031 goto restart;
4032 }
4033 goto error;
4034 }
4035
4036 nb_fd = ret;
4037
4038 for (i = 0; i < nb_fd; i++) {
4039 /* Fetch once the poll data */
4040 revents = LTTNG_POLL_GETEV(&events, i);
4041 pollfd = LTTNG_POLL_GETFD(&events, i);
4042
4043 health_code_update();
4044
4045 /* Thread quit pipe has been closed. Killing thread. */
4046 ret = sessiond_check_thread_quit_pipe(pollfd, revents);
4047 if (ret) {
4048 err = 0;
4049 goto exit;
4050 }
4051
4052 /* Event on the registration socket */
4053 if (pollfd == client_sock) {
4054 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
4055 ERR("Client socket poll error");
4056 goto error;
4057 }
4058 }
4059 }
4060
4061 DBG("Wait for client response");
4062
4063 health_code_update();
4064
4065 sock = lttcomm_accept_unix_sock(client_sock);
4066 if (sock < 0) {
4067 goto error;
4068 }
4069
4070 /*
4071 * Set the CLOEXEC flag. Return code is useless because either way, the
4072 * show must go on.
4073 */
4074 (void) utils_set_fd_cloexec(sock);
4075
4076 /* Set socket option for credentials retrieval */
4077 ret = lttcomm_setsockopt_creds_unix_sock(sock);
4078 if (ret < 0) {
4079 goto error;
4080 }
4081
4082 /* Allocate context command to process the client request */
4083 cmd_ctx = zmalloc(sizeof(struct command_ctx));
4084 if (cmd_ctx == NULL) {
4085 PERROR("zmalloc cmd_ctx");
4086 goto error;
4087 }
4088
4089 /* Allocate data buffer for reception */
4090 cmd_ctx->lsm = zmalloc(sizeof(struct lttcomm_session_msg));
4091 if (cmd_ctx->lsm == NULL) {
4092 PERROR("zmalloc cmd_ctx->lsm");
4093 goto error;
4094 }
4095
4096 cmd_ctx->llm = NULL;
4097 cmd_ctx->session = NULL;
4098
4099 health_code_update();
4100
4101 /*
4102 * Data is received from the lttng client. The struct
4103 * lttcomm_session_msg (lsm) contains the command and data request of
4104 * the client.
4105 */
4106 DBG("Receiving data from client ...");
4107 ret = lttcomm_recv_creds_unix_sock(sock, cmd_ctx->lsm,
4108 sizeof(struct lttcomm_session_msg), &cmd_ctx->creds);
4109 if (ret <= 0) {
4110 DBG("Nothing recv() from client... continuing");
4111 ret = close(sock);
4112 if (ret) {
4113 PERROR("close");
4114 }
4115 sock = -1;
4116 clean_command_ctx(&cmd_ctx);
4117 continue;
4118 }
4119
4120 health_code_update();
4121
4122 // TODO: Validate cmd_ctx including sanity check for
4123 // security purpose.
4124
4125 rcu_thread_online();
4126 /*
4127 * This function dispatch the work to the kernel or userspace tracer
4128 * libs and fill the lttcomm_lttng_msg data structure of all the needed
4129 * informations for the client. The command context struct contains
4130 * everything this function may needs.
4131 */
4132 ret = process_client_msg(cmd_ctx, sock, &sock_error);
4133 rcu_thread_offline();
4134 if (ret < 0) {
4135 ret = close(sock);
4136 if (ret) {
4137 PERROR("close");
4138 }
4139 sock = -1;
4140 /*
4141 * TODO: Inform client somehow of the fatal error. At
4142 * this point, ret < 0 means that a zmalloc failed
4143 * (ENOMEM). Error detected but still accept
4144 * command, unless a socket error has been
4145 * detected.
4146 */
4147 clean_command_ctx(&cmd_ctx);
4148 continue;
4149 }
4150
4151 health_code_update();
4152
4153 DBG("Sending response (size: %d, retcode: %s)",
4154 cmd_ctx->lttng_msg_size,
4155 lttng_strerror(-cmd_ctx->llm->ret_code));
4156 ret = send_unix_sock(sock, cmd_ctx->llm, cmd_ctx->lttng_msg_size);
4157 if (ret < 0) {
4158 ERR("Failed to send data back to client");
4159 }
4160
4161 /* End of transmission */
4162 ret = close(sock);
4163 if (ret) {
4164 PERROR("close");
4165 }
4166 sock = -1;
4167
4168 clean_command_ctx(&cmd_ctx);
4169
4170 health_code_update();
4171 }
4172
4173 exit:
4174 error:
4175 if (sock >= 0) {
4176 ret = close(sock);
4177 if (ret) {
4178 PERROR("close");
4179 }
4180 }
4181
4182 lttng_poll_clean(&events);
4183 clean_command_ctx(&cmd_ctx);
4184
4185 error_listen:
4186 error_create_poll:
4187 unlink(client_unix_sock_path);
4188 if (client_sock >= 0) {
4189 ret = close(client_sock);
4190 if (ret) {
4191 PERROR("close");
4192 }
4193 }
4194
4195 if (err) {
4196 health_error();
4197 ERR("Health error occurred in %s", __func__);
4198 }
4199
4200 health_unregister(health_sessiond);
4201
4202 DBG("Client thread dying");
4203
4204 rcu_unregister_thread();
4205 return NULL;
4206 }
4207
4208
4209 /*
4210 * usage function on stderr
4211 */
4212 static void usage(void)
4213 {
4214 fprintf(stderr, "Usage: %s OPTIONS\n\nOptions:\n", progname);
4215 fprintf(stderr, " -h, --help Display this usage.\n");
4216 fprintf(stderr, " -c, --client-sock PATH Specify path for the client unix socket\n");
4217 fprintf(stderr, " -a, --apps-sock PATH Specify path for apps unix socket\n");
4218 fprintf(stderr, " --kconsumerd-err-sock PATH Specify path for the kernel consumer error socket\n");
4219 fprintf(stderr, " --kconsumerd-cmd-sock PATH Specify path for the kernel consumer command socket\n");
4220 fprintf(stderr, " --ustconsumerd32-err-sock PATH Specify path for the 32-bit UST consumer error socket\n");
4221 fprintf(stderr, " --ustconsumerd64-err-sock PATH Specify path for the 64-bit UST consumer error socket\n");
4222 fprintf(stderr, " --ustconsumerd32-cmd-sock PATH Specify path for the 32-bit UST consumer command socket\n");
4223 fprintf(stderr, " --ustconsumerd64-cmd-sock PATH Specify path for the 64-bit UST consumer command socket\n");
4224 fprintf(stderr, " --consumerd32-path PATH Specify path for the 32-bit UST consumer daemon binary\n");
4225 fprintf(stderr, " --consumerd32-libdir PATH Specify path for the 32-bit UST consumer daemon libraries\n");
4226 fprintf(stderr, " --consumerd64-path PATH Specify path for the 64-bit UST consumer daemon binary\n");
4227 fprintf(stderr, " --consumerd64-libdir PATH Specify path for the 64-bit UST consumer daemon libraries\n");
4228 fprintf(stderr, " -d, --daemonize Start as a daemon.\n");
4229 fprintf(stderr, " -b, --background Start as a daemon, keeping console open.\n");
4230 fprintf(stderr, " -g, --group NAME Specify the tracing group name. (default: tracing)\n");
4231 fprintf(stderr, " -V, --version Show version number.\n");
4232 fprintf(stderr, " -S, --sig-parent Send SIGUSR1 to parent pid to notify readiness.\n");
4233 fprintf(stderr, " -q, --quiet No output at all.\n");
4234 fprintf(stderr, " -v, --verbose Verbose mode. Activate DBG() macro.\n");
4235 fprintf(stderr, " -p, --pidfile FILE Write a pid to FILE name overriding the default value.\n");
4236 fprintf(stderr, " --verbose-consumer Verbose mode for consumer. Activate DBG() macro.\n");
4237 fprintf(stderr, " --no-kernel Disable kernel tracer\n");
4238 fprintf(stderr, " --agent-tcp-port Agent registration TCP port\n");
4239 fprintf(stderr, " -f --config Load daemon configuration file\n");
4240 fprintf(stderr, " -l --load PATH Load session configuration\n");
4241 fprintf(stderr, " --kmod-probes Specify kernel module probes to load\n");
4242 fprintf(stderr, " --extra-kmod-probes Specify extra kernel module probes to load\n");
4243 }
4244
4245 /*
4246 * Take an option from the getopt output and set it in the right variable to be
4247 * used later.
4248 *
4249 * Return 0 on success else a negative value.
4250 */
4251 static int set_option(int opt, const char *arg, const char *optname)
4252 {
4253 int ret = 0;
4254
4255 switch (opt) {
4256 case 0:
4257 fprintf(stderr, "option %s", optname);
4258 if (arg) {
4259 fprintf(stderr, " with arg %s\n", arg);
4260 }
4261 break;
4262 case 'c':
4263 snprintf(client_unix_sock_path, PATH_MAX, "%s", arg);
4264 break;
4265 case 'a':
4266 snprintf(apps_unix_sock_path, PATH_MAX, "%s", arg);
4267 break;
4268 case 'd':
4269 opt_daemon = 1;
4270 break;
4271 case 'b':
4272 opt_background = 1;
4273 break;
4274 case 'g':
4275 /*
4276 * If the override option is set, the pointer points to a
4277 * *non* const thus freeing it even though the variable type is
4278 * set to const.
4279 */
4280 if (tracing_group_name_override) {
4281 free((void *) tracing_group_name);
4282 }
4283 tracing_group_name = strdup(arg);
4284 if (!tracing_group_name) {
4285 perror("strdup");
4286 ret = -ENOMEM;
4287 }
4288 tracing_group_name_override = 1;
4289 break;
4290 case 'h':
4291 usage();
4292 exit(EXIT_FAILURE);
4293 case 'V':
4294 fprintf(stdout, "%s\n", VERSION);
4295 exit(EXIT_SUCCESS);
4296 case 'S':
4297 opt_sig_parent = 1;
4298 break;
4299 case 'E':
4300 snprintf(kconsumer_data.err_unix_sock_path, PATH_MAX, "%s", arg);
4301 break;
4302 case 'C':
4303 snprintf(kconsumer_data.cmd_unix_sock_path, PATH_MAX, "%s", arg);
4304 break;
4305 case 'F':
4306 snprintf(ustconsumer64_data.err_unix_sock_path, PATH_MAX, "%s", arg);
4307 break;
4308 case 'D':
4309 snprintf(ustconsumer64_data.cmd_unix_sock_path, PATH_MAX, "%s", arg);
4310 break;
4311 case 'H':
4312 snprintf(ustconsumer32_data.err_unix_sock_path, PATH_MAX, "%s", arg);
4313 break;
4314 case 'G':
4315 snprintf(ustconsumer32_data.cmd_unix_sock_path, PATH_MAX, "%s", arg);
4316 break;
4317 case 'N':
4318 opt_no_kernel = 1;
4319 break;
4320 case 'q':
4321 lttng_opt_quiet = 1;
4322 break;
4323 case 'v':
4324 /* Verbose level can increase using multiple -v */
4325 if (arg) {
4326 /* Value obtained from config file */
4327 lttng_opt_verbose = config_parse_value(arg);
4328 } else {
4329 /* -v used on command line */
4330 lttng_opt_verbose++;
4331 }
4332 /* Clamp value to [0, 3] */
4333 lttng_opt_verbose = lttng_opt_verbose < 0 ? 0 :
4334 (lttng_opt_verbose <= 3 ? lttng_opt_verbose : 3);
4335 break;
4336 case 'Z':
4337 if (arg) {
4338 opt_verbose_consumer = config_parse_value(arg);
4339 } else {
4340 opt_verbose_consumer += 1;
4341 }
4342 break;
4343 case 'u':
4344 if (consumerd32_bin_override) {
4345 free((void *) consumerd32_bin);
4346 }
4347 consumerd32_bin = strdup(arg);
4348 if (!consumerd32_bin) {
4349 perror("strdup");
4350 ret = -ENOMEM;
4351 }
4352 consumerd32_bin_override = 1;
4353 break;
4354 case 'U':
4355 if (consumerd32_libdir_override) {
4356 free((void *) consumerd32_libdir);
4357 }
4358 consumerd32_libdir = strdup(arg);
4359 if (!consumerd32_libdir) {
4360 perror("strdup");
4361 ret = -ENOMEM;
4362 }
4363 consumerd32_libdir_override = 1;
4364 break;
4365 case 't':
4366 if (consumerd64_bin_override) {
4367 free((void *) consumerd64_bin);
4368 }
4369 consumerd64_bin = strdup(arg);
4370 if (!consumerd64_bin) {
4371 perror("strdup");
4372 ret = -ENOMEM;
4373 }
4374 consumerd64_bin_override = 1;
4375 break;
4376 case 'T':
4377 if (consumerd64_libdir_override) {
4378 free((void *) consumerd64_libdir);
4379 }
4380 consumerd64_libdir = strdup(arg);
4381 if (!consumerd64_libdir) {
4382 perror("strdup");
4383 ret = -ENOMEM;
4384 }
4385 consumerd64_libdir_override = 1;
4386 break;
4387 case 'p':
4388 free(opt_pidfile);
4389 opt_pidfile = strdup(arg);
4390 if (!opt_pidfile) {
4391 perror("strdup");
4392 ret = -ENOMEM;
4393 }
4394 break;
4395 case 'J': /* Agent TCP port. */
4396 {
4397 unsigned long v;
4398
4399 errno = 0;
4400 v = strtoul(arg, NULL, 0);
4401 if (errno != 0 || !isdigit(arg[0])) {
4402 ERR("Wrong value in --agent-tcp-port parameter: %s", arg);
4403 return -1;
4404 }
4405 if (v == 0 || v >= 65535) {
4406 ERR("Port overflow in --agent-tcp-port parameter: %s", arg);
4407 return -1;
4408 }
4409 agent_tcp_port = (uint32_t) v;
4410 DBG3("Agent TCP port set to non default: %u", agent_tcp_port);
4411 break;
4412 }
4413 case 'l':
4414 free(opt_load_session_path);
4415 opt_load_session_path = strdup(arg);
4416 if (!opt_load_session_path) {
4417 perror("strdup");
4418 ret = -ENOMEM;
4419 }
4420 break;
4421 case 'P': /* probe modules list */
4422 free(kmod_probes_list);
4423 kmod_probes_list = strdup(arg);
4424 if (!kmod_probes_list) {
4425 perror("strdup");
4426 ret = -ENOMEM;
4427 }
4428 break;
4429 case 'e':
4430 free(kmod_extra_probes_list);
4431 kmod_extra_probes_list = strdup(arg);
4432 if (!kmod_extra_probes_list) {
4433 perror("strdup");
4434 ret = -ENOMEM;
4435 }
4436 break;
4437 case 'f':
4438 /* This is handled in set_options() thus silent break. */
4439 break;
4440 default:
4441 /* Unknown option or other error.
4442 * Error is printed by getopt, just return */
4443 ret = -1;
4444 }
4445
4446 return ret;
4447 }
4448
4449 /*
4450 * config_entry_handler_cb used to handle options read from a config file.
4451 * See config_entry_handler_cb comment in common/config/config.h for the
4452 * return value conventions.
4453 */
4454 static int config_entry_handler(const struct config_entry *entry, void *unused)
4455 {
4456 int ret = 0, i;
4457
4458 if (!entry || !entry->name || !entry->value) {
4459 ret = -EINVAL;
4460 goto end;
4461 }
4462
4463 /* Check if the option is to be ignored */
4464 for (i = 0; i < sizeof(config_ignore_options) / sizeof(char *); i++) {
4465 if (!strcmp(entry->name, config_ignore_options[i])) {
4466 goto end;
4467 }
4468 }
4469
4470 for (i = 0; i < (sizeof(long_options) / sizeof(struct option)) - 1;
4471 i++) {
4472
4473 /* Ignore if not fully matched. */
4474 if (strcmp(entry->name, long_options[i].name)) {
4475 continue;
4476 }
4477
4478 /*
4479 * If the option takes no argument on the command line, we have to
4480 * check if the value is "true". We support non-zero numeric values,
4481 * true, on and yes.
4482 */
4483 if (!long_options[i].has_arg) {
4484 ret = config_parse_value(entry->value);
4485 if (ret <= 0) {
4486 if (ret) {
4487 WARN("Invalid configuration value \"%s\" for option %s",
4488 entry->value, entry->name);
4489 }
4490 /* False, skip boolean config option. */
4491 goto end;
4492 }
4493 }
4494
4495 ret = set_option(long_options[i].val, entry->value, entry->name);
4496 goto end;
4497 }
4498
4499 WARN("Unrecognized option \"%s\" in daemon configuration file.", entry->name);
4500
4501 end:
4502 return ret;
4503 }
4504
4505 /*
4506 * daemon configuration loading and argument parsing
4507 */
4508 static int set_options(int argc, char **argv)
4509 {
4510 int ret = 0, c = 0, option_index = 0;
4511 int orig_optopt = optopt, orig_optind = optind;
4512 char *optstring;
4513 const char *config_path = NULL;
4514
4515 optstring = utils_generate_optstring(long_options,
4516 sizeof(long_options) / sizeof(struct option));
4517 if (!optstring) {
4518 ret = -ENOMEM;
4519 goto end;
4520 }
4521
4522 /* Check for the --config option */
4523 while ((c = getopt_long(argc, argv, optstring, long_options,
4524 &option_index)) != -1) {
4525 if (c == '?') {
4526 ret = -EINVAL;
4527 goto end;
4528 } else if (c != 'f') {
4529 /* if not equal to --config option. */
4530 continue;
4531 }
4532
4533 config_path = utils_expand_path(optarg);
4534 if (!config_path) {
4535 ERR("Failed to resolve path: %s", optarg);
4536 }
4537 }
4538
4539 ret = config_get_section_entries(config_path, config_section_name,
4540 config_entry_handler, NULL);
4541 if (ret) {
4542 if (ret > 0) {
4543 ERR("Invalid configuration option at line %i", ret);
4544 ret = -1;
4545 }
4546 goto end;
4547 }
4548
4549 /* Reset getopt's global state */
4550 optopt = orig_optopt;
4551 optind = orig_optind;
4552 while (1) {
4553 c = getopt_long(argc, argv, optstring, long_options, &option_index);
4554 if (c == -1) {
4555 break;
4556 }
4557
4558 ret = set_option(c, optarg, long_options[option_index].name);
4559 if (ret < 0) {
4560 break;
4561 }
4562 }
4563
4564 end:
4565 free(optstring);
4566 return ret;
4567 }
4568
4569 /*
4570 * Creates the two needed socket by the daemon.
4571 * apps_sock - The communication socket for all UST apps.
4572 * client_sock - The communication of the cli tool (lttng).
4573 */
4574 static int init_daemon_socket(void)
4575 {
4576 int ret = 0;
4577 mode_t old_umask;
4578
4579 old_umask = umask(0);
4580
4581 /* Create client tool unix socket */
4582 client_sock = lttcomm_create_unix_sock(client_unix_sock_path);
4583 if (client_sock < 0) {
4584 ERR("Create unix sock failed: %s", client_unix_sock_path);
4585 ret = -1;
4586 goto end;
4587 }
4588
4589 /* Set the cloexec flag */
4590 ret = utils_set_fd_cloexec(client_sock);
4591 if (ret < 0) {
4592 ERR("Unable to set CLOEXEC flag to the client Unix socket (fd: %d). "
4593 "Continuing but note that the consumer daemon will have a "
4594 "reference to this socket on exec()", client_sock);
4595 }
4596
4597 /* File permission MUST be 660 */
4598 ret = chmod(client_unix_sock_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
4599 if (ret < 0) {
4600 ERR("Set file permissions failed: %s", client_unix_sock_path);
4601 PERROR("chmod");
4602 goto end;
4603 }
4604
4605 /* Create the application unix socket */
4606 apps_sock = lttcomm_create_unix_sock(apps_unix_sock_path);
4607 if (apps_sock < 0) {
4608 ERR("Create unix sock failed: %s", apps_unix_sock_path);
4609 ret = -1;
4610 goto end;
4611 }
4612
4613 /* Set the cloexec flag */
4614 ret = utils_set_fd_cloexec(apps_sock);
4615 if (ret < 0) {
4616 ERR("Unable to set CLOEXEC flag to the app Unix socket (fd: %d). "
4617 "Continuing but note that the consumer daemon will have a "
4618 "reference to this socket on exec()", apps_sock);
4619 }
4620
4621 /* File permission MUST be 666 */
4622 ret = chmod(apps_unix_sock_path,
4623 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
4624 if (ret < 0) {
4625 ERR("Set file permissions failed: %s", apps_unix_sock_path);
4626 PERROR("chmod");
4627 goto end;
4628 }
4629
4630 DBG3("Session daemon client socket %d and application socket %d created",
4631 client_sock, apps_sock);
4632
4633 end:
4634 umask(old_umask);
4635 return ret;
4636 }
4637
4638 /*
4639 * Check if the global socket is available, and if a daemon is answering at the
4640 * other side. If yes, error is returned.
4641 */
4642 static int check_existing_daemon(void)
4643 {
4644 /* Is there anybody out there ? */
4645 if (lttng_session_daemon_alive()) {
4646 return -EEXIST;
4647 }
4648
4649 return 0;
4650 }
4651
4652 /*
4653 * Set the tracing group gid onto the client socket.
4654 *
4655 * Race window between mkdir and chown is OK because we are going from more
4656 * permissive (root.root) to less permissive (root.tracing).
4657 */
4658 static int set_permissions(char *rundir)
4659 {
4660 int ret;
4661 gid_t gid;
4662
4663 gid = utils_get_group_id(tracing_group_name);
4664
4665 /* Set lttng run dir */
4666 ret = chown(rundir, 0, gid);
4667 if (ret < 0) {
4668 ERR("Unable to set group on %s", rundir);
4669 PERROR("chown");
4670 }
4671
4672 /*
4673 * Ensure all applications and tracing group can search the run
4674 * dir. Allow everyone to read the directory, since it does not
4675 * buy us anything to hide its content.
4676 */
4677 ret = chmod(rundir, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
4678 if (ret < 0) {
4679 ERR("Unable to set permissions on %s", rundir);
4680 PERROR("chmod");
4681 }
4682
4683 /* lttng client socket path */
4684 ret = chown(client_unix_sock_path, 0, gid);
4685 if (ret < 0) {
4686 ERR("Unable to set group on %s", client_unix_sock_path);
4687 PERROR("chown");
4688 }
4689
4690 /* kconsumer error socket path */
4691 ret = chown(kconsumer_data.err_unix_sock_path, 0, 0);
4692 if (ret < 0) {
4693 ERR("Unable to set group on %s", kconsumer_data.err_unix_sock_path);
4694 PERROR("chown");
4695 }
4696
4697 /* 64-bit ustconsumer error socket path */
4698 ret = chown(ustconsumer64_data.err_unix_sock_path, 0, 0);
4699 if (ret < 0) {
4700 ERR("Unable to set group on %s", ustconsumer64_data.err_unix_sock_path);
4701 PERROR("chown");
4702 }
4703
4704 /* 32-bit ustconsumer compat32 error socket path */
4705 ret = chown(ustconsumer32_data.err_unix_sock_path, 0, 0);
4706 if (ret < 0) {
4707 ERR("Unable to set group on %s", ustconsumer32_data.err_unix_sock_path);
4708 PERROR("chown");
4709 }
4710
4711 DBG("All permissions are set");
4712
4713 return ret;
4714 }
4715
4716 /*
4717 * Create the lttng run directory needed for all global sockets and pipe.
4718 */
4719 static int create_lttng_rundir(const char *rundir)
4720 {
4721 int ret;
4722
4723 DBG3("Creating LTTng run directory: %s", rundir);
4724
4725 ret = mkdir(rundir, S_IRWXU);
4726 if (ret < 0) {
4727 if (errno != EEXIST) {
4728 ERR("Unable to create %s", rundir);
4729 goto error;
4730 } else {
4731 ret = 0;
4732 }
4733 }
4734
4735 error:
4736 return ret;
4737 }
4738
4739 /*
4740 * Setup sockets and directory needed by the kconsumerd communication with the
4741 * session daemon.
4742 */
4743 static int set_consumer_sockets(struct consumer_data *consumer_data,
4744 const char *rundir)
4745 {
4746 int ret;
4747 char path[PATH_MAX];
4748
4749 switch (consumer_data->type) {
4750 case LTTNG_CONSUMER_KERNEL:
4751 snprintf(path, PATH_MAX, DEFAULT_KCONSUMERD_PATH, rundir);
4752 break;
4753 case LTTNG_CONSUMER64_UST:
4754 snprintf(path, PATH_MAX, DEFAULT_USTCONSUMERD64_PATH, rundir);
4755 break;
4756 case LTTNG_CONSUMER32_UST:
4757 snprintf(path, PATH_MAX, DEFAULT_USTCONSUMERD32_PATH, rundir);
4758 break;
4759 default:
4760 ERR("Consumer type unknown");
4761 ret = -EINVAL;
4762 goto error;
4763 }
4764
4765 DBG2("Creating consumer directory: %s", path);
4766
4767 ret = mkdir(path, S_IRWXU | S_IRGRP | S_IXGRP);
4768 if (ret < 0) {
4769 if (errno != EEXIST) {
4770 PERROR("mkdir");
4771 ERR("Failed to create %s", path);
4772 goto error;
4773 }
4774 ret = -1;
4775 }
4776 if (is_root) {
4777 ret = chown(path, 0, utils_get_group_id(tracing_group_name));
4778 if (ret < 0) {
4779 ERR("Unable to set group on %s", path);
4780 PERROR("chown");
4781 goto error;
4782 }
4783 }
4784
4785 /* Create the kconsumerd error unix socket */
4786 consumer_data->err_sock =
4787 lttcomm_create_unix_sock(consumer_data->err_unix_sock_path);
4788 if (consumer_data->err_sock < 0) {
4789 ERR("Create unix sock failed: %s", consumer_data->err_unix_sock_path);
4790 ret = -1;
4791 goto error;
4792 }
4793
4794 /*
4795 * Set the CLOEXEC flag. Return code is useless because either way, the
4796 * show must go on.
4797 */
4798 ret = utils_set_fd_cloexec(consumer_data->err_sock);
4799 if (ret < 0) {
4800 PERROR("utils_set_fd_cloexec");
4801 /* continue anyway */
4802 }
4803
4804 /* File permission MUST be 660 */
4805 ret = chmod(consumer_data->err_unix_sock_path,
4806 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
4807 if (ret < 0) {
4808 ERR("Set file permissions failed: %s", consumer_data->err_unix_sock_path);
4809 PERROR("chmod");
4810 goto error;
4811 }
4812
4813 error:
4814 return ret;
4815 }
4816
4817 /*
4818 * Signal handler for the daemon
4819 *
4820 * Simply stop all worker threads, leaving main() return gracefully after
4821 * joining all threads and calling cleanup().
4822 */
4823 static void sighandler(int sig)
4824 {
4825 switch (sig) {
4826 case SIGPIPE:
4827 DBG("SIGPIPE caught");
4828 return;
4829 case SIGINT:
4830 DBG("SIGINT caught");
4831 stop_threads();
4832 break;
4833 case SIGTERM:
4834 DBG("SIGTERM caught");
4835 stop_threads();
4836 break;
4837 case SIGUSR1:
4838 CMM_STORE_SHARED(recv_child_signal, 1);
4839 break;
4840 default:
4841 break;
4842 }
4843 }
4844
4845 /*
4846 * Setup signal handler for :
4847 * SIGINT, SIGTERM, SIGPIPE
4848 */
4849 static int set_signal_handler(void)
4850 {
4851 int ret = 0;
4852 struct sigaction sa;
4853 sigset_t sigset;
4854
4855 if ((ret = sigemptyset(&sigset)) < 0) {
4856 PERROR("sigemptyset");
4857 return ret;
4858 }
4859
4860 sa.sa_handler = sighandler;
4861 sa.sa_mask = sigset;
4862 sa.sa_flags = 0;
4863 if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
4864 PERROR("sigaction");
4865 return ret;
4866 }
4867
4868 if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
4869 PERROR("sigaction");
4870 return ret;
4871 }
4872
4873 if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
4874 PERROR("sigaction");
4875 return ret;
4876 }
4877
4878 if ((ret = sigaction(SIGUSR1, &sa, NULL)) < 0) {
4879 PERROR("sigaction");
4880 return ret;
4881 }
4882
4883 DBG("Signal handler set for SIGTERM, SIGUSR1, SIGPIPE and SIGINT");
4884
4885 return ret;
4886 }
4887
4888 /*
4889 * Set open files limit to unlimited. This daemon can open a large number of
4890 * file descriptors in order to consumer multiple kernel traces.
4891 */
4892 static void set_ulimit(void)
4893 {
4894 int ret;
4895 struct rlimit lim;
4896
4897 /* The kernel does not allowed an infinite limit for open files */
4898 lim.rlim_cur = 65535;
4899 lim.rlim_max = 65535;
4900
4901 ret = setrlimit(RLIMIT_NOFILE, &lim);
4902 if (ret < 0) {
4903 PERROR("failed to set open files limit");
4904 }
4905 }
4906
4907 /*
4908 * Write pidfile using the rundir and opt_pidfile.
4909 */
4910 static void write_pidfile(void)
4911 {
4912 int ret;
4913 char pidfile_path[PATH_MAX];
4914
4915 assert(rundir);
4916
4917 if (opt_pidfile) {
4918 strncpy(pidfile_path, opt_pidfile, sizeof(pidfile_path));
4919 } else {
4920 /* Build pidfile path from rundir and opt_pidfile. */
4921 ret = snprintf(pidfile_path, sizeof(pidfile_path), "%s/"
4922 DEFAULT_LTTNG_SESSIOND_PIDFILE, rundir);
4923 if (ret < 0) {
4924 PERROR("snprintf pidfile path");
4925 goto error;
4926 }
4927 }
4928
4929 /*
4930 * Create pid file in rundir. Return value is of no importance. The
4931 * execution will continue even though we are not able to write the file.
4932 */
4933 (void) utils_create_pid_file(getpid(), pidfile_path);
4934
4935 error:
4936 return;
4937 }
4938
4939 /*
4940 * Create lockfile using the rundir and return its fd.
4941 */
4942 static int create_lockfile(void)
4943 {
4944 int ret;
4945 char lockfile_path[PATH_MAX];
4946
4947 ret = generate_lock_file_path(lockfile_path, sizeof(lockfile_path));
4948 if (ret < 0) {
4949 goto error;
4950 }
4951
4952 ret = utils_create_lock_file(lockfile_path);
4953 error:
4954 return ret;
4955 }
4956
4957 /*
4958 * Write agent TCP port using the rundir.
4959 */
4960 static void write_agent_port(void)
4961 {
4962 int ret;
4963 char path[PATH_MAX];
4964
4965 assert(rundir);
4966
4967 ret = snprintf(path, sizeof(path), "%s/"
4968 DEFAULT_LTTNG_SESSIOND_AGENTPORT_FILE, rundir);
4969 if (ret < 0) {
4970 PERROR("snprintf agent port path");
4971 goto error;
4972 }
4973
4974 /*
4975 * Create TCP agent port file in rundir. Return value is of no importance.
4976 * The execution will continue even though we are not able to write the
4977 * file.
4978 */
4979 (void) utils_create_pid_file(agent_tcp_port, path);
4980
4981 error:
4982 return;
4983 }
4984
4985 /*
4986 * Start the load session thread and dettach from it so the main thread can
4987 * continue. This does not return a value since whatever the outcome, the main
4988 * thread will continue.
4989 */
4990 static void start_load_session_thread(void)
4991 {
4992 int ret;
4993
4994 /* Create session loading thread. */
4995 ret = pthread_create(&load_session_thread, NULL, thread_load_session,
4996 load_info);
4997 if (ret != 0) {
4998 PERROR("pthread_create load_session_thread");
4999 goto error_create;
5000 }
5001
5002 ret = pthread_detach(load_session_thread);
5003 if (ret != 0) {
5004 PERROR("pthread_detach load_session_thread");
5005 }
5006
5007 /* Everything went well so don't cleanup anything. */
5008
5009 error_create:
5010 /* The cleanup() function will destroy the load_info data. */
5011 return;
5012 }
5013
5014 /*
5015 * main
5016 */
5017 int main(int argc, char **argv)
5018 {
5019 int ret = 0;
5020 void *status;
5021 const char *home_path, *env_app_timeout;
5022
5023 init_kernel_workarounds();
5024
5025 rcu_register_thread();
5026
5027 if ((ret = set_signal_handler()) < 0) {
5028 goto error;
5029 }
5030
5031 setup_consumerd_path();
5032
5033 page_size = sysconf(_SC_PAGESIZE);
5034 if (page_size < 0) {
5035 PERROR("sysconf _SC_PAGESIZE");
5036 page_size = LONG_MAX;
5037 WARN("Fallback page size to %ld", page_size);
5038 }
5039
5040 /* Parse arguments and load the daemon configuration file */
5041 progname = argv[0];
5042 if ((ret = set_options(argc, argv)) < 0) {
5043 goto error;
5044 }
5045
5046 /* Daemonize */
5047 if (opt_daemon || opt_background) {
5048 int i;
5049
5050 ret = lttng_daemonize(&child_ppid, &recv_child_signal,
5051 !opt_background);
5052 if (ret < 0) {
5053 goto error;
5054 }
5055
5056 /*
5057 * We are in the child. Make sure all other file descriptors are
5058 * closed, in case we are called with more opened file descriptors than
5059 * the standard ones.
5060 */
5061 for (i = 3; i < sysconf(_SC_OPEN_MAX); i++) {
5062 (void) close(i);
5063 }
5064 }
5065
5066 /* Create thread quit pipe */
5067 if ((ret = init_thread_quit_pipe()) < 0) {
5068 goto error;
5069 }
5070
5071 /* Check if daemon is UID = 0 */
5072 is_root = !getuid();
5073
5074 if (is_root) {
5075 rundir = strdup(DEFAULT_LTTNG_RUNDIR);
5076
5077 /* Create global run dir with root access */
5078 ret = create_lttng_rundir(rundir);
5079 if (ret < 0) {
5080 goto error;
5081 }
5082
5083 if (strlen(apps_unix_sock_path) == 0) {
5084 snprintf(apps_unix_sock_path, PATH_MAX,
5085 DEFAULT_GLOBAL_APPS_UNIX_SOCK);
5086 }
5087
5088 if (strlen(client_unix_sock_path) == 0) {
5089 snprintf(client_unix_sock_path, PATH_MAX,
5090 DEFAULT_GLOBAL_CLIENT_UNIX_SOCK);
5091 }
5092
5093 /* Set global SHM for ust */
5094 if (strlen(wait_shm_path) == 0) {
5095 snprintf(wait_shm_path, PATH_MAX,
5096 DEFAULT_GLOBAL_APPS_WAIT_SHM_PATH);
5097 }
5098
5099 if (strlen(health_unix_sock_path) == 0) {
5100 snprintf(health_unix_sock_path, sizeof(health_unix_sock_path),
5101 DEFAULT_GLOBAL_HEALTH_UNIX_SOCK);
5102 }
5103
5104 /* Setup kernel consumerd path */
5105 snprintf(kconsumer_data.err_unix_sock_path, PATH_MAX,
5106 DEFAULT_KCONSUMERD_ERR_SOCK_PATH, rundir);
5107 snprintf(kconsumer_data.cmd_unix_sock_path, PATH_MAX,
5108 DEFAULT_KCONSUMERD_CMD_SOCK_PATH, rundir);
5109
5110 DBG2("Kernel consumer err path: %s",
5111 kconsumer_data.err_unix_sock_path);
5112 DBG2("Kernel consumer cmd path: %s",
5113 kconsumer_data.cmd_unix_sock_path);
5114 } else {
5115 home_path = utils_get_home_dir();
5116 if (home_path == NULL) {
5117 /* TODO: Add --socket PATH option */
5118 ERR("Can't get HOME directory for sockets creation.");
5119 ret = -EPERM;
5120 goto error;
5121 }
5122
5123 /*
5124 * Create rundir from home path. This will create something like
5125 * $HOME/.lttng
5126 */
5127 ret = asprintf(&rundir, DEFAULT_LTTNG_HOME_RUNDIR, home_path);
5128 if (ret < 0) {
5129 ret = -ENOMEM;
5130 goto error;
5131 }
5132
5133 ret = create_lttng_rundir(rundir);
5134 if (ret < 0) {
5135 goto error;
5136 }
5137
5138 if (strlen(apps_unix_sock_path) == 0) {
5139 snprintf(apps_unix_sock_path, PATH_MAX,
5140 DEFAULT_HOME_APPS_UNIX_SOCK, home_path);
5141 }
5142
5143 /* Set the cli tool unix socket path */
5144 if (strlen(client_unix_sock_path) == 0) {
5145 snprintf(client_unix_sock_path, PATH_MAX,
5146 DEFAULT_HOME_CLIENT_UNIX_SOCK, home_path);
5147 }
5148
5149 /* Set global SHM for ust */
5150 if (strlen(wait_shm_path) == 0) {
5151 snprintf(wait_shm_path, PATH_MAX,
5152 DEFAULT_HOME_APPS_WAIT_SHM_PATH, getuid());
5153 }
5154
5155 /* Set health check Unix path */
5156 if (strlen(health_unix_sock_path) == 0) {
5157 snprintf(health_unix_sock_path, sizeof(health_unix_sock_path),
5158 DEFAULT_HOME_HEALTH_UNIX_SOCK, home_path);
5159 }
5160 }
5161
5162 lockfile_fd = create_lockfile();
5163 if (lockfile_fd < 0) {
5164 goto error;
5165 }
5166
5167 /* Set consumer initial state */
5168 kernel_consumerd_state = CONSUMER_STOPPED;
5169 ust_consumerd_state = CONSUMER_STOPPED;
5170
5171 DBG("Client socket path %s", client_unix_sock_path);
5172 DBG("Application socket path %s", apps_unix_sock_path);
5173 DBG("Application wait path %s", wait_shm_path);
5174 DBG("LTTng run directory path: %s", rundir);
5175
5176 /* 32 bits consumerd path setup */
5177 snprintf(ustconsumer32_data.err_unix_sock_path, PATH_MAX,
5178 DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH, rundir);
5179 snprintf(ustconsumer32_data.cmd_unix_sock_path, PATH_MAX,
5180 DEFAULT_USTCONSUMERD32_CMD_SOCK_PATH, rundir);
5181
5182 DBG2("UST consumer 32 bits err path: %s",
5183 ustconsumer32_data.err_unix_sock_path);
5184 DBG2("UST consumer 32 bits cmd path: %s",
5185 ustconsumer32_data.cmd_unix_sock_path);
5186
5187 /* 64 bits consumerd path setup */
5188 snprintf(ustconsumer64_data.err_unix_sock_path, PATH_MAX,
5189 DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH, rundir);
5190 snprintf(ustconsumer64_data.cmd_unix_sock_path, PATH_MAX,
5191 DEFAULT_USTCONSUMERD64_CMD_SOCK_PATH, rundir);
5192
5193 DBG2("UST consumer 64 bits err path: %s",
5194 ustconsumer64_data.err_unix_sock_path);
5195 DBG2("UST consumer 64 bits cmd path: %s",
5196 ustconsumer64_data.cmd_unix_sock_path);
5197
5198 /*
5199 * See if daemon already exist.
5200 */
5201 if ((ret = check_existing_daemon()) < 0) {
5202 ERR("Already running daemon.\n");
5203 /*
5204 * We do not goto exit because we must not cleanup()
5205 * because a daemon is already running.
5206 */
5207 goto error;
5208 }
5209
5210 /*
5211 * Init UST app hash table. Alloc hash table before this point since
5212 * cleanup() can get called after that point.
5213 */
5214 ust_app_ht_alloc();
5215
5216 /* Initialize agent domain subsystem. */
5217 if ((ret = agent_setup()) < 0) {
5218 /* ENOMEM at this point. */
5219 goto error;
5220 }
5221
5222 /* After this point, we can safely call cleanup() with "goto exit" */
5223
5224 /*
5225 * These actions must be executed as root. We do that *after* setting up
5226 * the sockets path because we MUST make the check for another daemon using
5227 * those paths *before* trying to set the kernel consumer sockets and init
5228 * kernel tracer.
5229 */
5230 if (is_root) {
5231 ret = set_consumer_sockets(&kconsumer_data, rundir);
5232 if (ret < 0) {
5233 goto exit;
5234 }
5235
5236 /* Setup kernel tracer */
5237 if (!opt_no_kernel) {
5238 init_kernel_tracer();
5239 if (kernel_tracer_fd >= 0) {
5240 ret = syscall_init_table();
5241 if (ret < 0) {
5242 ERR("Unable to populate syscall table. Syscall tracing"
5243 " won't work for this session daemon.");
5244 }
5245 }
5246 }
5247
5248 /* Set ulimit for open files */
5249 set_ulimit();
5250 }
5251 /* init lttng_fd tracking must be done after set_ulimit. */
5252 lttng_fd_init();
5253
5254 ret = set_consumer_sockets(&ustconsumer64_data, rundir);
5255 if (ret < 0) {
5256 goto exit;
5257 }
5258
5259 ret = set_consumer_sockets(&ustconsumer32_data, rundir);
5260 if (ret < 0) {
5261 goto exit;
5262 }
5263
5264 /* Setup the needed unix socket */
5265 if ((ret = init_daemon_socket()) < 0) {
5266 goto exit;
5267 }
5268
5269 /* Set credentials to socket */
5270 if (is_root && ((ret = set_permissions(rundir)) < 0)) {
5271 goto exit;
5272 }
5273
5274 /* Get parent pid if -S, --sig-parent is specified. */
5275 if (opt_sig_parent) {
5276 ppid = getppid();
5277 }
5278
5279 /* Setup the kernel pipe for waking up the kernel thread */
5280 if (is_root && !opt_no_kernel) {
5281 if ((ret = utils_create_pipe_cloexec(kernel_poll_pipe)) < 0) {
5282 goto exit;
5283 }
5284 }
5285
5286 /* Setup the thread ht_cleanup communication pipe. */
5287 if (utils_create_pipe_cloexec(ht_cleanup_pipe) < 0) {
5288 goto exit;
5289 }
5290
5291 /* Setup the thread apps communication pipe. */
5292 if ((ret = utils_create_pipe_cloexec(apps_cmd_pipe)) < 0) {
5293 goto exit;
5294 }
5295
5296 /* Setup the thread apps notify communication pipe. */
5297 if (utils_create_pipe_cloexec(apps_cmd_notify_pipe) < 0) {
5298 goto exit;
5299 }
5300
5301 /* Initialize global buffer per UID and PID registry. */
5302 buffer_reg_init_uid_registry();
5303 buffer_reg_init_pid_registry();
5304
5305 /* Init UST command queue. */
5306 cds_wfcq_init(&ust_cmd_queue.head, &ust_cmd_queue.tail);
5307
5308 /*
5309 * Get session list pointer. This pointer MUST NOT be free(). This list is
5310 * statically declared in session.c
5311 */
5312 session_list_ptr = session_get_list();
5313
5314 /* Set up max poll set size */
5315 lttng_poll_set_max_size();
5316
5317 cmd_init();
5318
5319 /* Check for the application socket timeout env variable. */
5320 env_app_timeout = getenv(DEFAULT_APP_SOCKET_TIMEOUT_ENV);
5321 if (env_app_timeout) {
5322 app_socket_timeout = atoi(env_app_timeout);
5323 } else {
5324 app_socket_timeout = DEFAULT_APP_SOCKET_RW_TIMEOUT;
5325 }
5326
5327 write_pidfile();
5328 write_agent_port();
5329
5330 /* Initialize communication library */
5331 lttcomm_init();
5332 /* This is to get the TCP timeout value. */
5333 lttcomm_inet_init();
5334
5335 if (load_session_init_data(&load_info) < 0) {
5336 goto exit;
5337 }
5338 load_info->path = opt_load_session_path;
5339
5340 /*
5341 * Initialize the health check subsystem. This call should set the
5342 * appropriate time values.
5343 */
5344 health_sessiond = health_app_create(NR_HEALTH_SESSIOND_TYPES);
5345 if (!health_sessiond) {
5346 PERROR("health_app_create error");
5347 goto exit_health_sessiond_cleanup;
5348 }
5349
5350 /* Create thread to clean up RCU hash tables */
5351 ret = pthread_create(&ht_cleanup_thread, NULL,
5352 thread_ht_cleanup, (void *) NULL);
5353 if (ret != 0) {
5354 PERROR("pthread_create ht_cleanup");
5355 goto exit_ht_cleanup;
5356 }
5357
5358 /* Create health-check thread */
5359 ret = pthread_create(&health_thread, NULL,
5360 thread_manage_health, (void *) NULL);
5361 if (ret != 0) {
5362 PERROR("pthread_create health");
5363 goto exit_health;
5364 }
5365
5366 /* Create thread to manage the client socket */
5367 ret = pthread_create(&client_thread, NULL,
5368 thread_manage_clients, (void *) NULL);
5369 if (ret != 0) {
5370 PERROR("pthread_create clients");
5371 goto exit_client;
5372 }
5373
5374 /* Create thread to dispatch registration */
5375 ret = pthread_create(&dispatch_thread, NULL,
5376 thread_dispatch_ust_registration, (void *) NULL);
5377 if (ret != 0) {
5378 PERROR("pthread_create dispatch");
5379 goto exit_dispatch;
5380 }
5381
5382 /* Create thread to manage application registration. */
5383 ret = pthread_create(&reg_apps_thread, NULL,
5384 thread_registration_apps, (void *) NULL);
5385 if (ret != 0) {
5386 PERROR("pthread_create registration");
5387 goto exit_reg_apps;
5388 }
5389
5390 /* Create thread to manage application socket */
5391 ret = pthread_create(&apps_thread, NULL,
5392 thread_manage_apps, (void *) NULL);
5393 if (ret != 0) {
5394 PERROR("pthread_create apps");
5395 goto exit_apps;
5396 }
5397
5398 /* Create thread to manage application notify socket */
5399 ret = pthread_create(&apps_notify_thread, NULL,
5400 ust_thread_manage_notify, (void *) NULL);
5401 if (ret != 0) {
5402 PERROR("pthread_create notify");
5403 goto exit_apps_notify;
5404 }
5405
5406 /* Create agent registration thread. */
5407 ret = pthread_create(&agent_reg_thread, NULL,
5408 agent_thread_manage_registration, (void *) NULL);
5409 if (ret != 0) {
5410 PERROR("pthread_create agent");
5411 goto exit_agent_reg;
5412 }
5413
5414 /* Don't start this thread if kernel tracing is not requested nor root */
5415 if (is_root && !opt_no_kernel) {
5416 /* Create kernel thread to manage kernel event */
5417 ret = pthread_create(&kernel_thread, NULL,
5418 thread_manage_kernel, (void *) NULL);
5419 if (ret != 0) {
5420 PERROR("pthread_create kernel");
5421 goto exit_kernel;
5422 }
5423 }
5424
5425 /* Load possible session(s). */
5426 start_load_session_thread();
5427
5428 if (is_root && !opt_no_kernel) {
5429 ret = pthread_join(kernel_thread, &status);
5430 if (ret != 0) {
5431 PERROR("pthread_join");
5432 goto error; /* join error, exit without cleanup */
5433 }
5434 }
5435
5436 exit_kernel:
5437 ret = pthread_join(agent_reg_thread, &status);
5438 if (ret != 0) {
5439 PERROR("pthread_join agent");
5440 goto error; /* join error, exit without cleanup */
5441 }
5442
5443 exit_agent_reg:
5444 ret = pthread_join(apps_notify_thread, &status);
5445 if (ret != 0) {
5446 PERROR("pthread_join apps notify");
5447 goto error; /* join error, exit without cleanup */
5448 }
5449
5450 exit_apps_notify:
5451 ret = pthread_join(apps_thread, &status);
5452 if (ret != 0) {
5453 PERROR("pthread_join apps");
5454 goto error; /* join error, exit without cleanup */
5455 }
5456
5457
5458 exit_apps:
5459 ret = pthread_join(reg_apps_thread, &status);
5460 if (ret != 0) {
5461 PERROR("pthread_join");
5462 goto error; /* join error, exit without cleanup */
5463 }
5464
5465 exit_reg_apps:
5466 ret = pthread_join(dispatch_thread, &status);
5467 if (ret != 0) {
5468 PERROR("pthread_join");
5469 goto error; /* join error, exit without cleanup */
5470 }
5471
5472 exit_dispatch:
5473 ret = pthread_join(client_thread, &status);
5474 if (ret != 0) {
5475 PERROR("pthread_join");
5476 goto error; /* join error, exit without cleanup */
5477 }
5478
5479 ret = join_consumer_thread(&kconsumer_data);
5480 if (ret != 0) {
5481 PERROR("join_consumer");
5482 goto error; /* join error, exit without cleanup */
5483 }
5484
5485 ret = join_consumer_thread(&ustconsumer32_data);
5486 if (ret != 0) {
5487 PERROR("join_consumer ust32");
5488 goto error; /* join error, exit without cleanup */
5489 }
5490
5491 ret = join_consumer_thread(&ustconsumer64_data);
5492 if (ret != 0) {
5493 PERROR("join_consumer ust64");
5494 goto error; /* join error, exit without cleanup */
5495 }
5496
5497 exit_client:
5498 ret = pthread_join(health_thread, &status);
5499 if (ret != 0) {
5500 PERROR("pthread_join health thread");
5501 goto error; /* join error, exit without cleanup */
5502 }
5503
5504 exit_health:
5505 ret = pthread_join(ht_cleanup_thread, &status);
5506 if (ret != 0) {
5507 PERROR("pthread_join ht cleanup thread");
5508 goto error; /* join error, exit without cleanup */
5509 }
5510 exit_ht_cleanup:
5511 health_app_destroy(health_sessiond);
5512 exit_health_sessiond_cleanup:
5513 exit:
5514 /*
5515 * cleanup() is called when no other thread is running.
5516 */
5517 rcu_thread_online();
5518 cleanup();
5519 rcu_thread_offline();
5520 rcu_unregister_thread();
5521 if (!ret) {
5522 exit(EXIT_SUCCESS);
5523 }
5524 error:
5525 exit(EXIT_FAILURE);
5526 }
This page took 0.14857 seconds and 5 git commands to generate.