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