Fix: buffer overflow warning in python bindings
[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"
b3530820
JG
74#include "notification-thread.h"
75#include "notification-thread-commands.h"
834978fd 76#include "syscall.h"
7c1d2758 77#include "agent.h"
5e97de00 78#include "ht-cleanup.h"
fac6795d 79
ebaeda94
MD
80#define CONSUMERD_FILE "lttng-consumerd"
81
4fc83d94
PP
82static const char *help_msg =
83#ifdef LTTNG_EMBED_HELP
84#include <lttng-sessiond.8.h>
85#else
86NULL
87#endif
88;
89
fac6795d 90const char *progname;
b3530820 91const char *tracing_group_name = DEFAULT_TRACING_GROUP;
26296c48
JG
92static int tracing_group_name_override;
93static char *opt_pidfile;
5b8719f5 94static int opt_sig_parent;
97e19046 95static int opt_verbose_consumer;
72dd7491 96static int opt_daemon, opt_background;
4fba7219 97static int opt_no_kernel;
ef367a93 98static char *opt_load_session_path;
1d4b027a 99static pid_t ppid; /* Parent PID for --sig-parent option */
0bb7724a 100static pid_t child_ppid; /* Internal parent PID use with daemonize. */
67e40797 101static char *rundir;
c9cb3e7d 102static int lockfile_fd = -1;
3bd1e081 103
0bb7724a
DG
104/* Set to 1 when a SIGUSR1 signal is received. */
105static int recv_child_signal;
106
a23ec3a7
DG
107/*
108 * Consumer daemon specific control data. Every value not initialized here is
109 * set to 0 by the static definition.
110 */
3bd1e081
MD
111static struct consumer_data kconsumer_data = {
112 .type = LTTNG_CONSUMER_KERNEL,
60922cb0
DG
113 .err_unix_sock_path = DEFAULT_KCONSUMERD_ERR_SOCK_PATH,
114 .cmd_unix_sock_path = DEFAULT_KCONSUMERD_CMD_SOCK_PATH,
03550b58
MD
115 .err_sock = -1,
116 .cmd_sock = -1,
b3530820 117 .channel_monitor_pipe = -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,
3bd1e081 122};
7753dea8
MD
123static struct consumer_data ustconsumer64_data = {
124 .type = LTTNG_CONSUMER64_UST,
60922cb0
DG
125 .err_unix_sock_path = DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH,
126 .cmd_unix_sock_path = DEFAULT_USTCONSUMERD64_CMD_SOCK_PATH,
03550b58
MD
127 .err_sock = -1,
128 .cmd_sock = -1,
b3530820 129 .channel_monitor_pipe = -1,
173af62f
DG
130 .pid_mutex = PTHREAD_MUTEX_INITIALIZER,
131 .lock = PTHREAD_MUTEX_INITIALIZER,
a23ec3a7
DG
132 .cond = PTHREAD_COND_INITIALIZER,
133 .cond_mutex = PTHREAD_MUTEX_INITIALIZER,
7753dea8
MD
134};
135static struct consumer_data ustconsumer32_data = {
136 .type = LTTNG_CONSUMER32_UST,
60922cb0
DG
137 .err_unix_sock_path = DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH,
138 .cmd_unix_sock_path = DEFAULT_USTCONSUMERD32_CMD_SOCK_PATH,
03550b58
MD
139 .err_sock = -1,
140 .cmd_sock = -1,
b3530820 141 .channel_monitor_pipe = -1,
173af62f
DG
142 .pid_mutex = PTHREAD_MUTEX_INITIALIZER,
143 .lock = PTHREAD_MUTEX_INITIALIZER,
a23ec3a7
DG
144 .cond = PTHREAD_COND_INITIALIZER,
145 .cond_mutex = PTHREAD_MUTEX_INITIALIZER,
3bd1e081
MD
146};
147
26296c48
JG
148/* Command line options */
149static const struct option long_options[] = {
0f5ea17c
JG
150 { "client-sock", required_argument, 0, 'c' },
151 { "apps-sock", required_argument, 0, 'a' },
152 { "kconsumerd-cmd-sock", required_argument, 0, '\0' },
153 { "kconsumerd-err-sock", required_argument, 0, '\0' },
154 { "ustconsumerd32-cmd-sock", required_argument, 0, '\0' },
155 { "ustconsumerd32-err-sock", required_argument, 0, '\0' },
156 { "ustconsumerd64-cmd-sock", required_argument, 0, '\0' },
157 { "ustconsumerd64-err-sock", required_argument, 0, '\0' },
158 { "consumerd32-path", required_argument, 0, '\0' },
159 { "consumerd32-libdir", required_argument, 0, '\0' },
160 { "consumerd64-path", required_argument, 0, '\0' },
161 { "consumerd64-libdir", required_argument, 0, '\0' },
162 { "daemonize", no_argument, 0, 'd' },
163 { "background", no_argument, 0, 'b' },
164 { "sig-parent", no_argument, 0, 'S' },
165 { "help", no_argument, 0, 'h' },
166 { "group", required_argument, 0, 'g' },
167 { "version", no_argument, 0, 'V' },
168 { "quiet", no_argument, 0, 'q' },
169 { "verbose", no_argument, 0, 'v' },
170 { "verbose-consumer", no_argument, 0, '\0' },
171 { "no-kernel", no_argument, 0, '\0' },
172 { "pidfile", required_argument, 0, 'p' },
173 { "agent-tcp-port", required_argument, 0, '\0' },
174 { "config", required_argument, 0, 'f' },
175 { "load", required_argument, 0, 'l' },
176 { "kmod-probes", required_argument, 0, '\0' },
177 { "extra-kmod-probes", required_argument, 0, '\0' },
26296c48
JG
178 { NULL, 0, 0, 0 }
179};
180
181/* Command line options to ignore from configuration file */
182static const char *config_ignore_options[] = { "help", "version", "config" };
183
26c9d55e 184/* Shared between threads */
099e26bd 185static int dispatch_thread_exit;
fac6795d 186
54d01ffb
DG
187/* Global application Unix socket path */
188static char apps_unix_sock_path[PATH_MAX];
189/* Global client Unix socket path */
190static char client_unix_sock_path[PATH_MAX];
54d01ffb
DG
191/* global wait shm path for UST */
192static char wait_shm_path[PATH_MAX];
44a5e5eb
DG
193/* Global health check unix path */
194static char health_unix_sock_path[PATH_MAX];
fac6795d 195
1d4b027a 196/* Sockets and FDs */
a4b35e07
MD
197static int client_sock = -1;
198static int apps_sock = -1;
2f77fc4b 199int kernel_tracer_fd = -1;
76d7553f 200static int kernel_poll_pipe[2] = { -1, -1 };
1d4b027a 201
273ea72c
DG
202/*
203 * Quit pipe for all threads. This permits a single cancellation point
204 * for all threads when receiving an event on the pipe.
205 */
76d7553f 206static int thread_quit_pipe[2] = { -1, -1 };
273ea72c 207
099e26bd
DG
208/*
209 * This pipe is used to inform the thread managing application communication
210 * that a command is queued and ready to be processed.
211 */
76d7553f 212static int apps_cmd_pipe[2] = { -1, -1 };
099e26bd 213
d0b96690
DG
214int apps_cmd_notify_pipe[2] = { -1, -1 };
215
1d4b027a 216/* Pthread, Mutexes and Semaphores */
1d4b027a 217static pthread_t apps_thread;
d0b96690 218static pthread_t apps_notify_thread;
099e26bd 219static pthread_t reg_apps_thread;
1d4b027a 220static pthread_t client_thread;
7a485870 221static pthread_t kernel_thread;
099e26bd 222static pthread_t dispatch_thread;
44a5e5eb 223static pthread_t health_thread;
0b2dc8df 224static pthread_t ht_cleanup_thread;
022d91ba 225static pthread_t agent_reg_thread;
ef367a93 226static pthread_t load_session_thread;
b3530820 227static pthread_t notification_thread;
5eb91c98 228
099e26bd
DG
229/*
230 * UST registration command queue. This queue is tied with a futex and uses a N
231 * wakers / 1 waiter implemented and detailed in futex.c/.h
232 *
b22c5da8
DG
233 * The thread_registration_apps and thread_dispatch_ust_registration uses this
234 * queue along with the wait/wake scheme. The thread_manage_apps receives down
235 * the line new application socket and monitors it for any I/O error or clean
236 * close that triggers an unregistration of the application.
099e26bd
DG
237 */
238static struct ust_cmd_queue ust_cmd_queue;
239
b5541356
DG
240/*
241 * Pointer initialized before thread creation.
242 *
243 * This points to the tracing session list containing the session count and a
244 * mutex lock. The lock MUST be taken if you iterate over the list. The lock
245 * MUST NOT be taken if you call a public function in session.c.
04ea676f 246 *
d063d709 247 * The lock is nested inside the structure: session_list_ptr->lock. Please use
54d01ffb 248 * session_lock_list and session_unlock_list for lock acquisition.
b5541356
DG
249 */
250static struct ltt_session_list *session_list_ptr;
251
7753dea8
MD
252int ust_consumerd64_fd = -1;
253int ust_consumerd32_fd = -1;
254
fb6f1fa2
YB
255static const char *consumerd32_bin = CONFIG_CONSUMERD32_BIN;
256static const char *consumerd64_bin = CONFIG_CONSUMERD64_BIN;
257static const char *consumerd32_libdir = CONFIG_CONSUMERD32_LIBDIR;
258static const char *consumerd64_libdir = CONFIG_CONSUMERD64_LIBDIR;
26296c48
JG
259static int consumerd32_bin_override;
260static int consumerd64_bin_override;
261static int consumerd32_libdir_override;
262static int consumerd64_libdir_override;
fb09408a 263
2f77fc4b
DG
264static const char *module_proc_lttng = "/proc/lttng";
265
5c827ce0
DG
266/*
267 * Consumer daemon state which is changed when spawning it, killing it or in
268 * case of a fatal error.
269 */
270enum consumerd_state {
271 CONSUMER_STARTED = 1,
272 CONSUMER_STOPPED = 2,
273 CONSUMER_ERROR = 3,
274};
275
276/*
277 * This consumer daemon state is used to validate if a client command will be
278 * able to reach the consumer. If not, the client is informed. For instance,
279 * doing a "lttng start" when the consumer state is set to ERROR will return an
280 * error to the client.
281 *
282 * The following example shows a possible race condition of this scheme:
283 *
284 * consumer thread error happens
285 * client cmd arrives
286 * client cmd checks state -> still OK
287 * consumer thread exit, sets error
288 * client cmd try to talk to consumer
289 * ...
290 *
291 * However, since the consumer is a different daemon, we have no way of making
292 * sure the command will reach it safely even with this state flag. This is why
293 * we consider that up to the state validation during command processing, the
294 * command is safe. After that, we can not guarantee the correctness of the
295 * client request vis-a-vis the consumer.
296 */
297static enum consumerd_state ust_consumerd_state;
298static enum consumerd_state kernel_consumerd_state;
299
ae9e45b3
DG
300/*
301 * Socket timeout for receiving and sending in seconds.
302 */
303static int app_socket_timeout;
304
12744796
DG
305/* Set in main() with the current page size. */
306long page_size;
307
8782cc74
MD
308/* Application health monitoring */
309struct health_app *health_sessiond;
310
022d91ba
DG
311/* Agent TCP port for registration. Used by the agent thread. */
312unsigned int agent_tcp_port = DEFAULT_AGENT_TCP_PORT;
4d076222 313
f43f95a9
DG
314/* Am I root or not. */
315int is_root; /* Set to 1 if the daemon is running as root */
316
26296c48
JG
317const char * const config_section_name = "sessiond";
318
ef367a93
JG
319/* Load session thread information to operate. */
320struct load_session_thread_data *load_info;
321
b3530820
JG
322/* Notification thread handle. */
323struct notification_thread_handle *notification_thread_handle;
324
7c1d2758
JG
325/* Global hash tables */
326struct lttng_ht *agent_apps_ht_by_sock = NULL;
327
97bc1426 328/*
b3530820
JG
329 * Whether sessiond is ready for commands/notification channel/health check
330 * requests.
97bc1426 331 * NR_LTTNG_SESSIOND_READY must match the number of calls to
ef367a93 332 * sessiond_notify_ready().
97bc1426 333 */
b3530820 334#define NR_LTTNG_SESSIOND_READY 4
97bc1426
MD
335int lttng_sessiond_ready = NR_LTTNG_SESSIOND_READY;
336
5e97de00
JG
337int sessiond_check_thread_quit_pipe(int fd, uint32_t events)
338{
339 return (fd == thread_quit_pipe[0] && (events & LPOLLIN)) ? 1 : 0;
340}
341
97bc1426 342/* Notify parents that we are ready for cmd and health check */
ef367a93
JG
343LTTNG_HIDDEN
344void sessiond_notify_ready(void)
97bc1426
MD
345{
346 if (uatomic_sub_return(&lttng_sessiond_ready, 1) == 0) {
347 /*
348 * Notify parent pid that we are ready to accept command
349 * for client side. This ppid is the one from the
350 * external process that spawned us.
351 */
352 if (opt_sig_parent) {
353 kill(ppid, SIGUSR1);
354 }
355
356 /*
357 * Notify the parent of the fork() process that we are
358 * ready.
359 */
72dd7491 360 if (opt_daemon || opt_background) {
97bc1426
MD
361 kill(child_ppid, SIGUSR1);
362 }
363 }
364}
365
fb09408a 366static
7753dea8 367void setup_consumerd_path(void)
fb09408a 368{
fc7a59ce 369 const char *bin, *libdir;
fb09408a 370
7753dea8
MD
371 /*
372 * Allow INSTALL_BIN_PATH to be used as a target path for the
ebaeda94
MD
373 * native architecture size consumer if CONFIG_CONSUMER*_PATH
374 * has not been defined.
7753dea8 375 */
ebaeda94 376#if (CAA_BITS_PER_LONG == 32)
fc7a59ce
AM
377 if (!consumerd32_bin[0]) {
378 consumerd32_bin = INSTALL_BIN_PATH "/" CONSUMERD_FILE;
ebaeda94
MD
379 }
380 if (!consumerd32_libdir[0]) {
381 consumerd32_libdir = INSTALL_LIB_PATH;
382 }
383#elif (CAA_BITS_PER_LONG == 64)
fc7a59ce
AM
384 if (!consumerd64_bin[0]) {
385 consumerd64_bin = INSTALL_BIN_PATH "/" CONSUMERD_FILE;
7753dea8 386 }
ebaeda94
MD
387 if (!consumerd64_libdir[0]) {
388 consumerd64_libdir = INSTALL_LIB_PATH;
7753dea8
MD
389 }
390#else
391#error "Unknown bitness"
392#endif
393
fb09408a
MD
394 /*
395 * runtime env. var. overrides the build default.
396 */
e8fa9fb0 397 bin = lttng_secure_getenv("LTTNG_CONSUMERD32_BIN");
fc7a59ce
AM
398 if (bin) {
399 consumerd32_bin = bin;
7753dea8 400 }
e8fa9fb0 401 bin = lttng_secure_getenv("LTTNG_CONSUMERD64_BIN");
fc7a59ce
AM
402 if (bin) {
403 consumerd64_bin = bin;
ebaeda94 404 }
e8fa9fb0 405 libdir = lttng_secure_getenv("LTTNG_CONSUMERD32_LIBDIR");
ebaeda94
MD
406 if (libdir) {
407 consumerd32_libdir = libdir;
408 }
e8fa9fb0 409 libdir = lttng_secure_getenv("LTTNG_CONSUMERD64_LIBDIR");
ebaeda94
MD
410 if (libdir) {
411 consumerd64_libdir = libdir;
fb09408a
MD
412 }
413}
414
4a15001e
MD
415static
416int __sessiond_set_thread_pollset(struct lttng_poll_event *events, size_t size,
417 int *a_pipe)
5eb91c98
DG
418{
419 int ret;
420
d0b96690 421 assert(events);
5eb91c98
DG
422
423 ret = lttng_poll_create(events, size, LTTNG_CLOEXEC);
424 if (ret < 0) {
425 goto error;
426 }
427
428 /* Add quit pipe */
4a15001e 429 ret = lttng_poll_add(events, a_pipe[0], LPOLLIN | LPOLLERR);
5eb91c98
DG
430 if (ret < 0) {
431 goto error;
432 }
433
434 return 0;
435
436error:
437 return ret;
438}
439
4a15001e
MD
440/*
441 * Create a poll set with O_CLOEXEC and add the thread quit pipe to the set.
442 */
443int sessiond_set_thread_pollset(struct lttng_poll_event *events, size_t size)
444{
445 return __sessiond_set_thread_pollset(events, size, thread_quit_pipe);
446}
447
273ea72c 448/*
5eb91c98 449 * Init thread quit pipe.
273ea72c
DG
450 *
451 * Return -1 on error or 0 if all pipes are created.
452 */
4a15001e 453static int __init_thread_quit_pipe(int *a_pipe)
273ea72c 454{
730389d9 455 int ret, i;
273ea72c 456
4a15001e 457 ret = pipe(a_pipe);
273ea72c 458 if (ret < 0) {
730389d9 459 PERROR("thread quit pipe");
273ea72c
DG
460 goto error;
461 }
462
730389d9 463 for (i = 0; i < 2; i++) {
4a15001e 464 ret = fcntl(a_pipe[i], F_SETFD, FD_CLOEXEC);
730389d9
DG
465 if (ret < 0) {
466 PERROR("fcntl");
467 goto error;
468 }
469 }
470
273ea72c
DG
471error:
472 return ret;
473}
474
4a15001e
MD
475static int init_thread_quit_pipe(void)
476{
477 return __init_thread_quit_pipe(thread_quit_pipe);
478}
479
099e26bd
DG
480/*
481 * Stop all threads by closing the thread quit pipe.
482 */
cf3af59e
MD
483static void stop_threads(void)
484{
5eb91c98
DG
485 int ret;
486
cf3af59e
MD
487 /* Stopping all threads */
488 DBG("Terminating all threads");
54d01ffb 489 ret = notify_thread_pipe(thread_quit_pipe[1]);
5eb91c98
DG
490 if (ret < 0) {
491 ERR("write error on thread quit pipe");
492 }
493
099e26bd 494 /* Dispatch thread */
26c9d55e 495 CMM_STORE_SHARED(dispatch_thread_exit, 1);
099e26bd 496 futex_nto1_wake(&ust_cmd_queue.futex);
cf3af59e
MD
497}
498
e975f9f8
DG
499/*
500 * Close every consumer sockets.
501 */
502static void close_consumer_sockets(void)
503{
504 int ret;
505
506 if (kconsumer_data.err_sock >= 0) {
507 ret = close(kconsumer_data.err_sock);
508 if (ret < 0) {
509 PERROR("kernel consumer err_sock close");
510 }
511 }
512 if (ustconsumer32_data.err_sock >= 0) {
513 ret = close(ustconsumer32_data.err_sock);
514 if (ret < 0) {
a76cbd9f 515 PERROR("UST consumerd32 err_sock close");
e975f9f8
DG
516 }
517 }
518 if (ustconsumer64_data.err_sock >= 0) {
519 ret = close(ustconsumer64_data.err_sock);
520 if (ret < 0) {
a76cbd9f 521 PERROR("UST consumerd64 err_sock close");
e975f9f8
DG
522 }
523 }
524 if (kconsumer_data.cmd_sock >= 0) {
525 ret = close(kconsumer_data.cmd_sock);
526 if (ret < 0) {
527 PERROR("kernel consumer cmd_sock close");
528 }
529 }
530 if (ustconsumer32_data.cmd_sock >= 0) {
531 ret = close(ustconsumer32_data.cmd_sock);
532 if (ret < 0) {
a76cbd9f 533 PERROR("UST consumerd32 cmd_sock close");
e975f9f8
DG
534 }
535 }
536 if (ustconsumer64_data.cmd_sock >= 0) {
537 ret = close(ustconsumer64_data.cmd_sock);
538 if (ret < 0) {
a76cbd9f 539 PERROR("UST consumerd64 cmd_sock close");
e975f9f8
DG
540 }
541 }
b3530820
JG
542 if (kconsumer_data.channel_monitor_pipe >= 0) {
543 ret = close(kconsumer_data.channel_monitor_pipe);
544 if (ret < 0) {
545 PERROR("kernel consumer channel monitor pipe close");
546 }
547 }
548 if (ustconsumer32_data.channel_monitor_pipe >= 0) {
549 ret = close(ustconsumer32_data.channel_monitor_pipe);
550 if (ret < 0) {
551 PERROR("UST consumerd32 channel monitor pipe close");
552 }
553 }
554 if (ustconsumer64_data.channel_monitor_pipe >= 0) {
555 ret = close(ustconsumer64_data.channel_monitor_pipe);
556 if (ret < 0) {
557 PERROR("UST consumerd64 channel monitor pipe close");
558 }
559 }
e975f9f8
DG
560}
561
c9cb3e7d
JG
562/*
563 * Generate the full lock file path using the rundir.
564 *
565 * Return the snprintf() return value thus a negative value is an error.
566 */
567static int generate_lock_file_path(char *path, size_t len)
568{
569 int ret;
570
571 assert(path);
572 assert(rundir);
573
574 /* Build lockfile path from rundir. */
575 ret = snprintf(path, len, "%s/" DEFAULT_LTTNG_SESSIOND_LOCKFILE, rundir);
576 if (ret < 0) {
577 PERROR("snprintf lockfile path");
578 }
579
580 return ret;
581}
582
4e4714cb
JR
583/*
584 * Wait on consumer process termination.
585 *
586 * Need to be called with the consumer data lock held or from a context
587 * ensuring no concurrent access to data (e.g: cleanup).
588 */
589static void wait_consumer(struct consumer_data *consumer_data)
590{
591 pid_t ret;
592 int status;
593
594 if (consumer_data->pid <= 0) {
595 return;
596 }
597
598 DBG("Waiting for complete teardown of consumerd (PID: %d)",
599 consumer_data->pid);
600 ret = waitpid(consumer_data->pid, &status, 0);
601 if (ret == -1) {
602 PERROR("consumerd waitpid pid: %d", consumer_data->pid)
1640c24c 603 } else if (!WIFEXITED(status)) {
4e4714cb
JR
604 ERR("consumerd termination with error: %d",
605 WEXITSTATUS(ret));
606 }
607 consumer_data->pid = 0;
608}
609
fac6795d 610/*
4a15001e 611 * Cleanup the session daemon's data structures.
fac6795d 612 */
4a15001e 613static void sessiond_cleanup(void)
fac6795d 614{
ef599319 615 int ret;
af9737e9 616 struct ltt_session *sess, *stmp;
8c6c56c2 617 char path[PATH_MAX];
fac6795d 618
4a15001e 619 DBG("Cleanup sessiond");
e07ae692 620
4e449f3f
MD
621 /*
622 * Close the thread quit pipe. It has already done its job,
623 * since we are now called.
624 */
2f77fc4b
DG
625 utils_close_pipe(thread_quit_pipe);
626
35f90c40
DG
627 /*
628 * If opt_pidfile is undefined, the default file will be wiped when
629 * removing the rundir.
630 */
631 if (opt_pidfile) {
632 ret = remove(opt_pidfile);
633 if (ret < 0) {
634 PERROR("remove pidfile %s", opt_pidfile);
635 }
636 }
637
8c6c56c2
MD
638 DBG("Removing sessiond and consumerd content of directory %s", rundir);
639
640 /* sessiond */
641 snprintf(path, PATH_MAX,
642 "%s/%s",
643 rundir, DEFAULT_LTTNG_SESSIOND_PIDFILE);
644 DBG("Removing %s", path);
645 (void) unlink(path);
646
cd9290dd 647 snprintf(path, PATH_MAX, "%s/%s", rundir,
022d91ba 648 DEFAULT_LTTNG_SESSIOND_AGENTPORT_FILE);
cd9290dd
DG
649 DBG("Removing %s", path);
650 (void) unlink(path);
651
8c6c56c2
MD
652 /* kconsumerd */
653 snprintf(path, PATH_MAX,
654 DEFAULT_KCONSUMERD_ERR_SOCK_PATH,
655 rundir);
656 DBG("Removing %s", path);
657 (void) unlink(path);
658
659 snprintf(path, PATH_MAX,
660 DEFAULT_KCONSUMERD_PATH,
661 rundir);
662 DBG("Removing directory %s", path);
663 (void) rmdir(path);
664
665 /* ust consumerd 32 */
666 snprintf(path, PATH_MAX,
667 DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH,
668 rundir);
669 DBG("Removing %s", path);
670 (void) unlink(path);
671
672 snprintf(path, PATH_MAX,
673 DEFAULT_USTCONSUMERD32_PATH,
674 rundir);
675 DBG("Removing directory %s", path);
676 (void) rmdir(path);
677
678 /* ust consumerd 64 */
679 snprintf(path, PATH_MAX,
680 DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH,
681 rundir);
682 DBG("Removing %s", path);
683 (void) unlink(path);
684
685 snprintf(path, PATH_MAX,
686 DEFAULT_USTCONSUMERD64_PATH,
687 rundir);
688 DBG("Removing directory %s", path);
689 (void) rmdir(path);
5461b305 690
99bab54f 691 DBG("Cleaning up all sessions");
fac6795d 692
b5541356 693 /* Destroy session list mutex */
273ea72c
DG
694 if (session_list_ptr != NULL) {
695 pthread_mutex_destroy(&session_list_ptr->lock);
696
697 /* Cleanup ALL session */
54d01ffb
DG
698 cds_list_for_each_entry_safe(sess, stmp,
699 &session_list_ptr->head, list) {
2f77fc4b 700 cmd_destroy_session(sess, kernel_poll_pipe[1]);
273ea72c
DG
701 }
702 }
703
4e4714cb
JR
704 wait_consumer(&kconsumer_data);
705 wait_consumer(&ustconsumer64_data);
706 wait_consumer(&ustconsumer32_data);
707
6a4e4039
JG
708 DBG("Cleaning up all agent apps");
709 agent_app_ht_clean();
710
099e26bd 711 DBG("Closing all UST sockets");
56fff090 712 ust_app_clean_list();
7972aab2 713 buffer_reg_destroy_registries();
099e26bd 714
4fba7219
DG
715 if (is_root && !opt_no_kernel) {
716 DBG2("Closing kernel fd");
a4b35e07 717 if (kernel_tracer_fd >= 0) {
76d7553f
MD
718 ret = close(kernel_tracer_fd);
719 if (ret) {
720 PERROR("close");
721 }
a4b35e07 722 }
2f50c8a3 723 DBG("Unloading kernel modules");
096102bd 724 modprobe_remove_lttng_all();
834978fd 725 free(syscall_table);
2f50c8a3 726 }
2f77fc4b 727
e975f9f8
DG
728 close_consumer_sockets();
729
ef367a93
JG
730 if (load_info) {
731 load_session_destroy_data(load_info);
732 free(load_info);
733 }
734
c9cb3e7d
JG
735 /*
736 * Cleanup lock file by deleting it and finaly closing it which will
737 * release the file system lock.
738 */
739 if (lockfile_fd >= 0) {
740 char lockfile_path[PATH_MAX];
741
4a15001e
MD
742 ret = generate_lock_file_path(lockfile_path,
743 sizeof(lockfile_path));
c9cb3e7d
JG
744 if (ret > 0) {
745 ret = remove(lockfile_path);
746 if (ret < 0) {
747 PERROR("remove lock file");
748 }
749 ret = close(lockfile_fd);
750 if (ret < 0) {
751 PERROR("close lock file");
752 }
753 }
754 }
755
756 /*
757 * We do NOT rmdir rundir because there are other processes
758 * using it, for instance lttng-relayd, which can start in
759 * parallel with this teardown.
760 */
761
762 free(rundir);
4a15001e
MD
763}
764
765/*
766 * Cleanup the daemon's option data structures.
767 */
768static void sessiond_cleanup_options(void)
769{
770 DBG("Cleaning up options");
771
772 /*
773 * If the override option is set, the pointer points to a *non* const
774 * thus freeing it even though the variable type is set to const.
775 */
776 if (tracing_group_name_override) {
777 free((void *) tracing_group_name);
778 }
779 if (consumerd32_bin_override) {
780 free((void *) consumerd32_bin);
781 }
782 if (consumerd64_bin_override) {
783 free((void *) consumerd64_bin);
784 }
785 if (consumerd32_libdir_override) {
786 free((void *) consumerd32_libdir);
787 }
788 if (consumerd64_libdir_override) {
789 free((void *) consumerd64_libdir);
790 }
791
792 free(opt_pidfile);
793 free(opt_load_session_path);
794 free(kmod_probes_list);
795 free(kmod_extra_probes_list);
c9cb3e7d 796
7567352f 797 run_as_destroy_worker();
fac6795d
DG
798}
799
e065084a 800/*
d063d709 801 * Send data on a unix socket using the liblttsessiondcomm API.
e065084a 802 *
d063d709 803 * Return lttcomm error code.
e065084a
DG
804 */
805static int send_unix_sock(int sock, void *buf, size_t len)
806{
807 /* Check valid length */
c617c0c6 808 if (len == 0) {
e065084a
DG
809 return -1;
810 }
811
812 return lttcomm_send_unix_sock(sock, buf, len);
813}
814
5461b305 815/*
d063d709 816 * Free memory of a command context structure.
5461b305 817 */
a2fb29a5 818static void clean_command_ctx(struct command_ctx **cmd_ctx)
5461b305 819{
a2fb29a5
DG
820 DBG("Clean command context structure");
821 if (*cmd_ctx) {
822 if ((*cmd_ctx)->llm) {
823 free((*cmd_ctx)->llm);
5461b305 824 }
a2fb29a5
DG
825 if ((*cmd_ctx)->lsm) {
826 free((*cmd_ctx)->lsm);
5461b305 827 }
a2fb29a5
DG
828 free(*cmd_ctx);
829 *cmd_ctx = NULL;
5461b305
DG
830 }
831}
832
fac6795d 833/*
0fdd1e2c 834 * Notify UST applications using the shm mmap futex.
fac6795d 835 */
0fdd1e2c 836static int notify_ust_apps(int active)
fac6795d 837{
0fdd1e2c 838 char *wait_shm_mmap;
fac6795d 839
0fdd1e2c 840 DBG("Notifying applications of session daemon state: %d", active);
e07ae692 841
0fdd1e2c
DG
842 /* See shm.c for this call implying mmap, shm and futex calls */
843 wait_shm_mmap = shm_ust_get_mmap(wait_shm_path, is_root);
844 if (wait_shm_mmap == NULL) {
fac6795d
DG
845 goto error;
846 }
847
0fdd1e2c
DG
848 /* Wake waiting process */
849 futex_wait_update((int32_t *) wait_shm_mmap, active);
850
851 /* Apps notified successfully */
852 return 0;
fac6795d
DG
853
854error:
0fdd1e2c 855 return -1;
fac6795d
DG
856}
857
e065084a 858/*
d063d709
DG
859 * Setup the outgoing data buffer for the response (llm) by allocating the
860 * right amount of memory and copying the original information from the lsm
861 * structure.
ca95a216 862 *
6e10c9b9 863 * Return 0 on success, negative value on error.
ca95a216 864 */
6e10c9b9
PP
865static int setup_lttng_msg(struct command_ctx *cmd_ctx,
866 const void *payload_buf, size_t payload_len,
867 const void *cmd_header_buf, size_t cmd_header_len)
ca95a216 868{
6e10c9b9
PP
869 int ret = 0;
870 const size_t header_len = sizeof(struct lttcomm_lttng_msg);
871 const size_t cmd_header_offset = header_len;
872 const size_t payload_offset = cmd_header_offset + cmd_header_len;
873 const size_t total_msg_size = header_len + cmd_header_len + payload_len;
ca95a216 874
6e10c9b9 875 cmd_ctx->llm = zmalloc(total_msg_size);
5461b305 876
5461b305 877 if (cmd_ctx->llm == NULL) {
76d7553f 878 PERROR("zmalloc");
5461b305 879 ret = -ENOMEM;
6e10c9b9 880 goto end;
ca95a216
DG
881 }
882
5461b305
DG
883 /* Copy common data */
884 cmd_ctx->llm->cmd_type = cmd_ctx->lsm->cmd_type;
9f19cc17 885 cmd_ctx->llm->pid = cmd_ctx->lsm->domain.attr.pid;
6e10c9b9
PP
886 cmd_ctx->llm->cmd_header_size = cmd_header_len;
887 cmd_ctx->llm->data_size = payload_len;
888 cmd_ctx->lttng_msg_size = total_msg_size;
5461b305 889
6e10c9b9 890 /* Copy command header */
b4e3ceb9
PP
891 if (cmd_header_len) {
892 memcpy(((uint8_t *) cmd_ctx->llm) + cmd_header_offset, cmd_header_buf,
893 cmd_header_len);
894 }
5461b305 895
6e10c9b9 896 /* Copy payload */
b4e3ceb9
PP
897 if (payload_len) {
898 memcpy(((uint8_t *) cmd_ctx->llm) + payload_offset, payload_buf,
899 payload_len);
900 }
ca95a216 901
6e10c9b9 902end:
ca95a216
DG
903 return ret;
904}
905
6e10c9b9
PP
906/*
907 * Version of setup_lttng_msg() without command header.
908 */
909static int setup_lttng_msg_no_cmd_header(struct command_ctx *cmd_ctx,
910 void *payload_buf, size_t payload_len)
911{
912 return setup_lttng_msg(cmd_ctx, payload_buf, payload_len, NULL, 0);
913}
7a485870 914/*
5eb91c98 915 * Update the kernel poll set of all channel fd available over all tracing
d063d709 916 * session. Add the wakeup pipe at the end of the set.
7a485870 917 */
5eb91c98 918static int update_kernel_poll(struct lttng_poll_event *events)
7a485870 919{
5eb91c98 920 int ret;
7a485870
DG
921 struct ltt_session *session;
922 struct ltt_kernel_channel *channel;
923
5eb91c98 924 DBG("Updating kernel poll set");
7a485870 925
54d01ffb 926 session_lock_list();
b5541356 927 cds_list_for_each_entry(session, &session_list_ptr->head, list) {
54d01ffb 928 session_lock(session);
7a485870 929 if (session->kernel_session == NULL) {
54d01ffb 930 session_unlock(session);
7a485870
DG
931 continue;
932 }
7a485870 933
54d01ffb
DG
934 cds_list_for_each_entry(channel,
935 &session->kernel_session->channel_list.head, list) {
5eb91c98
DG
936 /* Add channel fd to the kernel poll set */
937 ret = lttng_poll_add(events, channel->fd, LPOLLIN | LPOLLRDNORM);
938 if (ret < 0) {
54d01ffb 939 session_unlock(session);
5eb91c98
DG
940 goto error;
941 }
942 DBG("Channel fd %d added to kernel set", channel->fd);
7a485870 943 }
54d01ffb 944 session_unlock(session);
7a485870 945 }
54d01ffb 946 session_unlock_list();
7a485870 947
5eb91c98 948 return 0;
7a485870
DG
949
950error:
54d01ffb 951 session_unlock_list();
7a485870
DG
952 return -1;
953}
954
955/*
54d01ffb 956 * Find the channel fd from 'fd' over all tracing session. When found, check
d063d709 957 * for new channel stream and send those stream fds to the kernel consumer.
7a485870 958 *
d063d709 959 * Useful for CPU hotplug feature.
7a485870 960 */
2bdd86d4 961static int update_kernel_stream(struct consumer_data *consumer_data, int fd)
7a485870
DG
962{
963 int ret = 0;
964 struct ltt_session *session;
173af62f 965 struct ltt_kernel_session *ksess;
7a485870
DG
966 struct ltt_kernel_channel *channel;
967
968 DBG("Updating kernel streams for channel fd %d", fd);
969
54d01ffb 970 session_lock_list();
b5541356 971 cds_list_for_each_entry(session, &session_list_ptr->head, list) {
54d01ffb 972 session_lock(session);
7a485870 973 if (session->kernel_session == NULL) {
54d01ffb 974 session_unlock(session);
7a485870
DG
975 continue;
976 }
173af62f 977 ksess = session->kernel_session;
d9800920 978
4a15001e
MD
979 cds_list_for_each_entry(channel,
980 &ksess->channel_list.head, list) {
981 struct lttng_ht_iter iter;
982 struct consumer_socket *socket;
d9800920 983
4a15001e
MD
984 if (channel->fd != fd) {
985 continue;
986 }
987 DBG("Channel found, updating kernel streams");
988 ret = kernel_open_channel_stream(channel);
989 if (ret < 0) {
990 goto error;
991 }
992 /* Update the stream global counter */
993 ksess->stream_count_global += ret;
994
995 /*
996 * Have we already sent fds to the consumer? If yes, it
997 * means that tracing is started so it is safe to send
998 * our updated stream fds.
999 */
1000 if (ksess->consumer_fds_sent != 1
1001 || ksess->consumer == NULL) {
1002 ret = -1;
1003 goto error;
1004 }
1005
1006 rcu_read_lock();
1007 cds_lfht_for_each_entry(ksess->consumer->socks->ht,
1008 &iter.iter, socket, node.node) {
1009 pthread_mutex_lock(socket->lock);
1010 ret = kernel_consumer_send_channel_stream(socket,
1011 channel, ksess,
1012 session->output_traces ? 1 : 0);
1013 pthread_mutex_unlock(socket->lock);
1014 if (ret < 0) {
e7fe706f 1015 rcu_read_unlock();
4a15001e 1016 goto error;
7a485870 1017 }
7a485870 1018 }
4a15001e 1019 rcu_read_unlock();
7a485870 1020 }
54d01ffb 1021 session_unlock(session);
7a485870 1022 }
54d01ffb 1023 session_unlock_list();
b3c750d2 1024 return ret;
7a485870 1025
b3c750d2 1026error:
54d01ffb
DG
1027 session_unlock(session);
1028 session_unlock_list();
7a485870
DG
1029 return ret;
1030}
1031
487cf67c 1032/*
ffe60014
DG
1033 * For each tracing session, update newly registered apps. The session list
1034 * lock MUST be acquired before calling this.
487cf67c
DG
1035 */
1036static void update_ust_app(int app_sock)
1037{
1038 struct ltt_session *sess, *stmp;
1039
fdadac08
DG
1040 /* Consumer is in an ERROR state. Stop any application update. */
1041 if (uatomic_read(&ust_consumerd_state) == CONSUMER_ERROR) {
1042 /* Stop the update process since the consumer is dead. */
1043 return;
1044 }
1045
487cf67c
DG
1046 /* For all tracing session(s) */
1047 cds_list_for_each_entry_safe(sess, stmp, &session_list_ptr->head, list) {
a9ad0c8f
MD
1048 struct ust_app *app;
1049
4ee14516 1050 session_lock(sess);
a9ad0c8f
MD
1051 if (!sess->ust_session) {
1052 goto unlock_session;
1053 }
1054
1055 rcu_read_lock();
1056 assert(app_sock >= 0);
1057 app = ust_app_find_by_sock(app_sock);
1058 if (app == NULL) {
1059 /*
1060 * Application can be unregistered before so
1061 * this is possible hence simply stopping the
1062 * update.
1063 */
1064 DBG3("UST app update failed to find app sock %d",
1065 app_sock);
1066 goto unlock_rcu;
421cb601 1067 }
a9ad0c8f
MD
1068 ust_app_global_update(sess->ust_session, app);
1069 unlock_rcu:
1070 rcu_read_unlock();
1071 unlock_session:
4ee14516 1072 session_unlock(sess);
487cf67c
DG
1073 }
1074}
1075
7a485870 1076/*
d063d709 1077 * This thread manage event coming from the kernel.
7a485870 1078 *
d063d709
DG
1079 * Features supported in this thread:
1080 * -) CPU Hotplug
7a485870
DG
1081 */
1082static void *thread_manage_kernel(void *data)
1083{
139ac872 1084 int ret, i, pollfd, update_poll_flag = 1, err = -1;
5eb91c98 1085 uint32_t revents, nb_fd;
7a485870 1086 char tmp;
5eb91c98 1087 struct lttng_poll_event events;
7a485870 1088
6993eeb3 1089 DBG("[thread] Thread manage kernel started");
7a485870 1090
6c71277b 1091 health_register(health_sessiond, HEALTH_SESSIOND_TYPE_KERNEL);
927ca06a 1092
d5d63bf1
DG
1093 /*
1094 * This first step of the while is to clean this structure which could free
6d737ce4 1095 * non NULL pointers so initialize it before the loop.
d5d63bf1 1096 */
6d737ce4 1097 lttng_poll_init(&events);
d5d63bf1 1098
e547b070 1099 if (testpoint(sessiond_thread_manage_kernel)) {
6993eeb3
CB
1100 goto error_testpoint;
1101 }
8ac94142 1102
840cb59c 1103 health_code_update();
44a5e5eb 1104
e547b070 1105 if (testpoint(sessiond_thread_manage_kernel_before_loop)) {
d21b0d71 1106 goto error_testpoint;
6993eeb3
CB
1107 }
1108
7a485870 1109 while (1) {
840cb59c 1110 health_code_update();
44a5e5eb 1111
7a485870 1112 if (update_poll_flag == 1) {
d21b0d71
DG
1113 /* Clean events object. We are about to populate it again. */
1114 lttng_poll_clean(&events);
1115
d0b96690 1116 ret = sessiond_set_thread_pollset(&events, 2);
d21b0d71
DG
1117 if (ret < 0) {
1118 goto error_poll_create;
1119 }
1120
1121 ret = lttng_poll_add(&events, kernel_poll_pipe[0], LPOLLIN);
1122 if (ret < 0) {
1123 goto error;
1124 }
5f822d0a 1125
d21b0d71 1126 /* This will add the available kernel channel if any. */
5eb91c98
DG
1127 ret = update_kernel_poll(&events);
1128 if (ret < 0) {
7a485870
DG
1129 goto error;
1130 }
1131 update_poll_flag = 0;
1132 }
1133
7fa2082e 1134 DBG("Thread kernel polling");
7a485870
DG
1135
1136 /* Poll infinite value of time */
88f2b785 1137 restart:
a78af745 1138 health_poll_entry();
5eb91c98 1139 ret = lttng_poll_wait(&events, -1);
7fa2082e
MD
1140 DBG("Thread kernel return from poll on %d fds",
1141 LTTNG_POLL_GETNB(&events));
a78af745 1142 health_poll_exit();
7a485870 1143 if (ret < 0) {
88f2b785
MD
1144 /*
1145 * Restart interrupted system call.
1146 */
1147 if (errno == EINTR) {
1148 goto restart;
1149 }
7a485870
DG
1150 goto error;
1151 } else if (ret == 0) {
1152 /* Should not happen since timeout is infinite */
85611738
DG
1153 ERR("Return value of poll is 0 with an infinite timeout.\n"
1154 "This should not have happened! Continuing...");
7a485870
DG
1155 continue;
1156 }
1157
0d9c5d77
DG
1158 nb_fd = ret;
1159
5eb91c98
DG
1160 for (i = 0; i < nb_fd; i++) {
1161 /* Fetch once the poll data */
1162 revents = LTTNG_POLL_GETEV(&events, i);
1163 pollfd = LTTNG_POLL_GETFD(&events, i);
7a485870 1164
840cb59c 1165 health_code_update();
44a5e5eb 1166
fd20dac9
MD
1167 if (!revents) {
1168 /* No activity for this FD (poll implementation). */
1169 continue;
1170 }
1171
5eb91c98 1172 /* Thread quit pipe has been closed. Killing thread. */
d0b96690 1173 ret = sessiond_check_thread_quit_pipe(pollfd, revents);
5eb91c98 1174 if (ret) {
139ac872
MD
1175 err = 0;
1176 goto exit;
5eb91c98 1177 }
7a485870 1178
5eb91c98 1179 /* Check for data on kernel pipe */
03e43155
MD
1180 if (revents & LPOLLIN) {
1181 if (pollfd == kernel_poll_pipe[0]) {
1182 (void) lttng_read(kernel_poll_pipe[0],
1183 &tmp, 1);
1184 /*
1185 * Ret value is useless here, if this pipe gets any actions an
1186 * update is required anyway.
1187 */
1188 update_poll_flag = 1;
1189 continue;
1190 } else {
1191 /*
1192 * New CPU detected by the kernel. Adding kernel stream to
1193 * kernel session and updating the kernel consumer
1194 */
2bdd86d4 1195 ret = update_kernel_stream(&kconsumer_data, pollfd);
5eb91c98
DG
1196 if (ret < 0) {
1197 continue;
1198 }
1199 break;
7a485870 1200 }
03e43155
MD
1201 } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
1202 update_poll_flag = 1;
1203 continue;
1204 } else {
1205 ERR("Unexpected poll events %u for sock %d", revents, pollfd);
1206 goto error;
7a485870
DG
1207 }
1208 }
1209 }
1210
139ac872 1211exit:
7a485870 1212error:
5eb91c98 1213 lttng_poll_clean(&events);
76d7553f 1214error_poll_create:
6993eeb3 1215error_testpoint:
6620da75
DG
1216 utils_close_pipe(kernel_poll_pipe);
1217 kernel_poll_pipe[0] = kernel_poll_pipe[1] = -1;
139ac872 1218 if (err) {
840cb59c 1219 health_error();
139ac872 1220 ERR("Health error occurred in %s", __func__);
6620da75
DG
1221 WARN("Kernel thread died unexpectedly. "
1222 "Kernel tracing can continue but CPU hotplug is disabled.");
139ac872 1223 }
8782cc74 1224 health_unregister(health_sessiond);
76d7553f 1225 DBG("Kernel thread dying");
7a485870
DG
1226 return NULL;
1227}
1228
a23ec3a7
DG
1229/*
1230 * Signal pthread condition of the consumer data that the thread.
1231 */
1232static void signal_consumer_condition(struct consumer_data *data, int state)
1233{
1234 pthread_mutex_lock(&data->cond_mutex);
1235
1236 /*
1237 * The state is set before signaling. It can be any value, it's the waiter
1238 * job to correctly interpret this condition variable associated to the
1239 * consumer pthread_cond.
1240 *
1241 * A value of 0 means that the corresponding thread of the consumer data
1242 * was not started. 1 indicates that the thread has started and is ready
1243 * for action. A negative value means that there was an error during the
1244 * thread bootstrap.
1245 */
1246 data->consumer_thread_is_ready = state;
1247 (void) pthread_cond_signal(&data->cond);
1248
1249 pthread_mutex_unlock(&data->cond_mutex);
1250}
1251
1d4b027a 1252/*
3bd1e081 1253 * This thread manage the consumer error sent back to the session daemon.
1d4b027a 1254 */
3bd1e081 1255static void *thread_manage_consumer(void *data)
1d4b027a 1256{
42fc1d0b 1257 int sock = -1, i, ret, pollfd, err = -1, should_quit = 0;
5eb91c98 1258 uint32_t revents, nb_fd;
1d4b027a 1259 enum lttcomm_return_code code;
5eb91c98 1260 struct lttng_poll_event events;
3bd1e081 1261 struct consumer_data *consumer_data = data;
b3530820 1262 struct consumer_socket *cmd_socket_wrapper = NULL;
1d4b027a 1263
3bd1e081 1264 DBG("[thread] Manage consumer started");
1d4b027a 1265
34c1e15a
MD
1266 rcu_register_thread();
1267 rcu_thread_online();
1268
6c71277b 1269 health_register(health_sessiond, HEALTH_SESSIOND_TYPE_CONSUMER);
927ca06a 1270
855060f8 1271 health_code_update();
9449cc75 1272
5eb91c98 1273 /*
331744e3
JD
1274 * Pass 3 as size here for the thread quit pipe, consumerd_err_sock and the
1275 * metadata_sock. Nothing more will be added to this poll set.
5eb91c98 1276 */
331744e3 1277 ret = sessiond_set_thread_pollset(&events, 3);
5eb91c98 1278 if (ret < 0) {
76d7553f 1279 goto error_poll;
5eb91c98 1280 }
273ea72c 1281
edb8b045
DG
1282 /*
1283 * The error socket here is already in a listening state which was done
1284 * just before spawning this thread to avoid a race between the consumer
1285 * daemon exec trying to connect and the listen() call.
1286 */
3bd1e081 1287 ret = lttng_poll_add(&events, consumer_data->err_sock, LPOLLIN | LPOLLRDHUP);
5eb91c98
DG
1288 if (ret < 0) {
1289 goto error;
1290 }
1291
840cb59c 1292 health_code_update();
44a5e5eb 1293
331744e3 1294 /* Infinite blocking call, waiting for transmission */
88f2b785 1295restart:
a78af745 1296 health_poll_entry();
8ac94142 1297
e547b070 1298 if (testpoint(sessiond_thread_manage_consumer)) {
6993eeb3
CB
1299 goto error;
1300 }
8ac94142 1301
5eb91c98 1302 ret = lttng_poll_wait(&events, -1);
a78af745 1303 health_poll_exit();
273ea72c 1304 if (ret < 0) {
88f2b785
MD
1305 /*
1306 * Restart interrupted system call.
1307 */
1308 if (errno == EINTR) {
1309 goto restart;
1310 }
273ea72c
DG
1311 goto error;
1312 }
1313
0d9c5d77
DG
1314 nb_fd = ret;
1315
5eb91c98
DG
1316 for (i = 0; i < nb_fd; i++) {
1317 /* Fetch once the poll data */
1318 revents = LTTNG_POLL_GETEV(&events, i);
1319 pollfd = LTTNG_POLL_GETFD(&events, i);
1320
840cb59c 1321 health_code_update();
44a5e5eb 1322
fd20dac9
MD
1323 if (!revents) {
1324 /* No activity for this FD (poll implementation). */
1325 continue;
1326 }
1327
5eb91c98 1328 /* Thread quit pipe has been closed. Killing thread. */
d0b96690 1329 ret = sessiond_check_thread_quit_pipe(pollfd, revents);
5eb91c98 1330 if (ret) {
139ac872
MD
1331 err = 0;
1332 goto exit;
5eb91c98
DG
1333 }
1334
1335 /* Event on the registration socket */
3bd1e081 1336 if (pollfd == consumer_data->err_sock) {
03e43155
MD
1337 if (revents & LPOLLIN) {
1338 continue;
1339 } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
3bd1e081 1340 ERR("consumer err socket poll error");
5eb91c98 1341 goto error;
03e43155
MD
1342 } else {
1343 ERR("Unexpected poll events %u for sock %d", revents, pollfd);
1344 goto error;
5eb91c98
DG
1345 }
1346 }
273ea72c
DG
1347 }
1348
3bd1e081 1349 sock = lttcomm_accept_unix_sock(consumer_data->err_sock);
1d4b027a
DG
1350 if (sock < 0) {
1351 goto error;
1352 }
1353
b662582b
DG
1354 /*
1355 * Set the CLOEXEC flag. Return code is useless because either way, the
1356 * show must go on.
1357 */
1358 (void) utils_set_fd_cloexec(sock);
1359
840cb59c 1360 health_code_update();
44a5e5eb 1361
3bd1e081 1362 DBG2("Receiving code from consumer err_sock");
ee0b0061 1363
712ea556 1364 /* Getting status code from kconsumerd */
54d01ffb
DG
1365 ret = lttcomm_recv_unix_sock(sock, &code,
1366 sizeof(enum lttcomm_return_code));
1d4b027a
DG
1367 if (ret <= 0) {
1368 goto error;
1369 }
1370
840cb59c 1371 health_code_update();
b3530820 1372 if (code != LTTCOMM_CONSUMERD_COMMAND_SOCK_READY) {
3bd1e081 1373 ERR("consumer error when waiting for SOCK_READY : %s",
1d4b027a
DG
1374 lttcomm_get_readable_code(-code));
1375 goto error;
1376 }
1377
b3530820
JG
1378 /* Connect both command and metadata sockets. */
1379 consumer_data->cmd_sock =
1380 lttcomm_connect_unix_sock(
1381 consumer_data->cmd_unix_sock_path);
1382 consumer_data->metadata_fd =
1383 lttcomm_connect_unix_sock(
1384 consumer_data->cmd_unix_sock_path);
1385 if (consumer_data->cmd_sock < 0 || consumer_data->metadata_fd < 0) {
1386 PERROR("consumer connect cmd socket");
1387 /* On error, signal condition and quit. */
1388 signal_consumer_condition(consumer_data, -1);
1389 goto error;
1390 }
1391
1392 consumer_data->metadata_sock.fd_ptr = &consumer_data->metadata_fd;
1393
1394 /* Create metadata socket lock. */
1395 consumer_data->metadata_sock.lock = zmalloc(sizeof(pthread_mutex_t));
1396 if (consumer_data->metadata_sock.lock == NULL) {
1397 PERROR("zmalloc pthread mutex");
1398 goto error;
1399 }
1400 pthread_mutex_init(consumer_data->metadata_sock.lock, NULL);
1401
1402 DBG("Consumer command socket ready (fd: %d", consumer_data->cmd_sock);
1403 DBG("Consumer metadata socket ready (fd: %d)",
1404 consumer_data->metadata_fd);
1405
1406 /*
1407 * Remove the consumerd error sock since we've established a connection.
1408 */
3bd1e081 1409 ret = lttng_poll_del(&events, consumer_data->err_sock);
72079cae 1410 if (ret < 0) {
72079cae
DG
1411 goto error;
1412 }
1413
331744e3 1414 /* Add new accepted error socket. */
5eb91c98
DG
1415 ret = lttng_poll_add(&events, sock, LPOLLIN | LPOLLRDHUP);
1416 if (ret < 0) {
72079cae 1417 goto error;
5eb91c98
DG
1418 }
1419
331744e3 1420 /* Add metadata socket that is successfully connected. */
4ce514c4 1421 ret = lttng_poll_add(&events, consumer_data->metadata_fd,
331744e3
JD
1422 LPOLLIN | LPOLLRDHUP);
1423 if (ret < 0) {
1424 goto error;
1425 }
1426
840cb59c 1427 health_code_update();
44a5e5eb 1428
b3530820
JG
1429 /*
1430 * Transfer the write-end of the channel monitoring pipe to the
1431 * by issuing a SET_CHANNEL_MONITOR_PIPE command.
1432 */
1433 cmd_socket_wrapper = consumer_allocate_socket(&consumer_data->cmd_sock);
1434 if (!cmd_socket_wrapper) {
1435 goto error;
1436 }
1437
1438 ret = consumer_send_channel_monitor_pipe(cmd_socket_wrapper,
1439 consumer_data->channel_monitor_pipe);
1440 if (ret) {
1441 goto error;
1442 }
1443 /* Discard the socket wrapper as it is no longer needed. */
1444 consumer_destroy_socket(cmd_socket_wrapper);
1445 cmd_socket_wrapper = NULL;
1446
1447 /* The thread is completely initialized, signal that it is ready. */
1448 signal_consumer_condition(consumer_data, 1);
1449
331744e3 1450 /* Infinite blocking call, waiting for transmission */
88f2b785 1451restart_poll:
331744e3 1452 while (1) {
42fc1d0b
DG
1453 health_code_update();
1454
1455 /* Exit the thread because the thread quit pipe has been triggered. */
1456 if (should_quit) {
1457 /* Not a health error. */
1458 err = 0;
1459 goto exit;
1460 }
1461
331744e3
JD
1462 health_poll_entry();
1463 ret = lttng_poll_wait(&events, -1);
1464 health_poll_exit();
1465 if (ret < 0) {
1466 /*
1467 * Restart interrupted system call.
1468 */
1469 if (errno == EINTR) {
1470 goto restart_poll;
1471 }
1472 goto error;
88f2b785 1473 }
72079cae 1474
331744e3 1475 nb_fd = ret;
0d9c5d77 1476
331744e3
JD
1477 for (i = 0; i < nb_fd; i++) {
1478 /* Fetch once the poll data */
1479 revents = LTTNG_POLL_GETEV(&events, i);
1480 pollfd = LTTNG_POLL_GETFD(&events, i);
5eb91c98 1481
331744e3 1482 health_code_update();
44a5e5eb 1483
fd20dac9
MD
1484 if (!revents) {
1485 /* No activity for this FD (poll implementation). */
1486 continue;
1487 }
1488
42fc1d0b
DG
1489 /*
1490 * Thread quit pipe has been triggered, flag that we should stop
1491 * but continue the current loop to handle potential data from
1492 * consumer.
1493 */
1494 should_quit = sessiond_check_thread_quit_pipe(pollfd, revents);
5eb91c98 1495
331744e3
JD
1496 if (pollfd == sock) {
1497 /* Event on the consumerd socket */
03e43155
MD
1498 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)
1499 && !(revents & LPOLLIN)) {
331744e3
JD
1500 ERR("consumer err socket second poll error");
1501 goto error;
1502 }
1503 health_code_update();
1504 /* Wait for any kconsumerd error */
1505 ret = lttcomm_recv_unix_sock(sock, &code,
1506 sizeof(enum lttcomm_return_code));
1507 if (ret <= 0) {
1508 ERR("consumer closed the command socket");
1509 goto error;
1510 }
1511
1512 ERR("consumer return code : %s",
1513 lttcomm_get_readable_code(-code));
1514
1515 goto exit;
4ce514c4 1516 } else if (pollfd == consumer_data->metadata_fd) {
03e43155
MD
1517 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)
1518 && !(revents & LPOLLIN)) {
1519 ERR("consumer err metadata socket second poll error");
1520 goto error;
1521 }
331744e3
JD
1522 /* UST metadata requests */
1523 ret = ust_consumer_metadata_request(
1524 &consumer_data->metadata_sock);
1525 if (ret < 0) {
1526 ERR("Handling metadata request");
1527 goto error;
1528 }
5eb91c98 1529 }
42fc1d0b 1530 /* No need for an else branch all FDs are tested prior. */
5eb91c98 1531 }
331744e3 1532 health_code_update();
5eb91c98
DG
1533 }
1534
139ac872 1535exit:
1d4b027a 1536error:
fdadac08
DG
1537 /*
1538 * We lock here because we are about to close the sockets and some other
92db7cdc
DG
1539 * thread might be using them so get exclusive access which will abort all
1540 * other consumer command by other threads.
fdadac08
DG
1541 */
1542 pthread_mutex_lock(&consumer_data->lock);
1543
5c827ce0
DG
1544 /* Immediately set the consumerd state to stopped */
1545 if (consumer_data->type == LTTNG_CONSUMER_KERNEL) {
1546 uatomic_set(&kernel_consumerd_state, CONSUMER_ERROR);
1547 } else if (consumer_data->type == LTTNG_CONSUMER64_UST ||
1548 consumer_data->type == LTTNG_CONSUMER32_UST) {
1549 uatomic_set(&ust_consumerd_state, CONSUMER_ERROR);
1550 } else {
1551 /* Code flow error... */
1552 assert(0);
1553 }
1554
76d7553f
MD
1555 if (consumer_data->err_sock >= 0) {
1556 ret = close(consumer_data->err_sock);
1557 if (ret) {
1558 PERROR("close");
1559 }
a76cbd9f 1560 consumer_data->err_sock = -1;
76d7553f
MD
1561 }
1562 if (consumer_data->cmd_sock >= 0) {
1563 ret = close(consumer_data->cmd_sock);
1564 if (ret) {
1565 PERROR("close");
1566 }
a76cbd9f 1567 consumer_data->cmd_sock = -1;
76d7553f 1568 }
96544455
SS
1569 if (consumer_data->metadata_sock.fd_ptr &&
1570 *consumer_data->metadata_sock.fd_ptr >= 0) {
9363801e 1571 ret = close(*consumer_data->metadata_sock.fd_ptr);
331744e3
JD
1572 if (ret) {
1573 PERROR("close");
1574 }
1575 }
76d7553f
MD
1576 if (sock >= 0) {
1577 ret = close(sock);
1578 if (ret) {
1579 PERROR("close");
1580 }
1581 }
273ea72c 1582
3bd1e081
MD
1583 unlink(consumer_data->err_unix_sock_path);
1584 unlink(consumer_data->cmd_unix_sock_path);
fdadac08 1585 pthread_mutex_unlock(&consumer_data->lock);
92db7cdc 1586
fdadac08 1587 /* Cleanup metadata socket mutex. */
96544455
SS
1588 if (consumer_data->metadata_sock.lock) {
1589 pthread_mutex_destroy(consumer_data->metadata_sock.lock);
1590 free(consumer_data->metadata_sock.lock);
1591 }
5eb91c98 1592 lttng_poll_clean(&events);
b3530820
JG
1593
1594 if (cmd_socket_wrapper) {
1595 consumer_destroy_socket(cmd_socket_wrapper);
1596 }
76d7553f 1597error_poll:
139ac872 1598 if (err) {
840cb59c 1599 health_error();
139ac872
MD
1600 ERR("Health error occurred in %s", __func__);
1601 }
8782cc74 1602 health_unregister(health_sessiond);
76d7553f 1603 DBG("consumer thread cleanup completed");
0177d773 1604
34c1e15a
MD
1605 rcu_thread_offline();
1606 rcu_unregister_thread();
1607
5eb91c98 1608 return NULL;
099e26bd
DG
1609}
1610
099e26bd
DG
1611/*
1612 * This thread manage application communication.
1d4b027a
DG
1613 */
1614static void *thread_manage_apps(void *data)
099e26bd 1615{
139ac872 1616 int i, ret, pollfd, err = -1;
6cd525e8 1617 ssize_t size_ret;
5eb91c98 1618 uint32_t revents, nb_fd;
5eb91c98 1619 struct lttng_poll_event events;
099e26bd
DG
1620
1621 DBG("[thread] Manage application started");
1622
f6a9efaa
DG
1623 rcu_register_thread();
1624 rcu_thread_online();
1625
6c71277b 1626 health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_MANAGE);
927ca06a 1627
e547b070 1628 if (testpoint(sessiond_thread_manage_apps)) {
6993eeb3
CB
1629 goto error_testpoint;
1630 }
1631
840cb59c 1632 health_code_update();
44a5e5eb 1633
d0b96690 1634 ret = sessiond_set_thread_pollset(&events, 2);
5eb91c98 1635 if (ret < 0) {
76d7553f 1636 goto error_poll_create;
5eb91c98 1637 }
099e26bd 1638
5eb91c98
DG
1639 ret = lttng_poll_add(&events, apps_cmd_pipe[0], LPOLLIN | LPOLLRDHUP);
1640 if (ret < 0) {
1641 goto error;
1642 }
099e26bd 1643
e547b070 1644 if (testpoint(sessiond_thread_manage_apps_before_loop)) {
6993eeb3
CB
1645 goto error;
1646 }
8ac94142 1647
840cb59c 1648 health_code_update();
44a5e5eb 1649
5eb91c98 1650 while (1) {
7fa2082e 1651 DBG("Apps thread polling");
099e26bd
DG
1652
1653 /* Inifinite blocking call, waiting for transmission */
88f2b785 1654 restart:
a78af745 1655 health_poll_entry();
5eb91c98 1656 ret = lttng_poll_wait(&events, -1);
7fa2082e
MD
1657 DBG("Apps thread return from poll on %d fds",
1658 LTTNG_POLL_GETNB(&events));
a78af745 1659 health_poll_exit();
099e26bd 1660 if (ret < 0) {
88f2b785
MD
1661 /*
1662 * Restart interrupted system call.
1663 */
1664 if (errno == EINTR) {
1665 goto restart;
1666 }
099e26bd
DG
1667 goto error;
1668 }
1669
0d9c5d77
DG
1670 nb_fd = ret;
1671
5eb91c98
DG
1672 for (i = 0; i < nb_fd; i++) {
1673 /* Fetch once the poll data */
1674 revents = LTTNG_POLL_GETEV(&events, i);
1675 pollfd = LTTNG_POLL_GETFD(&events, i);
1676
840cb59c 1677 health_code_update();
44a5e5eb 1678
fd20dac9
MD
1679 if (!revents) {
1680 /* No activity for this FD (poll implementation). */
1681 continue;
1682 }
1683
5eb91c98 1684 /* Thread quit pipe has been closed. Killing thread. */
d0b96690 1685 ret = sessiond_check_thread_quit_pipe(pollfd, revents);
5eb91c98 1686 if (ret) {
139ac872
MD
1687 err = 0;
1688 goto exit;
5eb91c98 1689 }
099e26bd 1690
5eb91c98
DG
1691 /* Inspect the apps cmd pipe */
1692 if (pollfd == apps_cmd_pipe[0]) {
03e43155 1693 if (revents & LPOLLIN) {
d0b96690
DG
1694 int sock;
1695
5eb91c98 1696 /* Empty pipe */
6cd525e8
MD
1697 size_ret = lttng_read(apps_cmd_pipe[0], &sock, sizeof(sock));
1698 if (size_ret < sizeof(sock)) {
76d7553f 1699 PERROR("read apps cmd pipe");
5eb91c98
DG
1700 goto error;
1701 }
099e26bd 1702
840cb59c 1703 health_code_update();
44a5e5eb 1704
ffe60014 1705 /*
03e43155
MD
1706 * Since this is a command socket (write then read),
1707 * we only monitor the error events of the socket.
ffe60014 1708 */
d0b96690
DG
1709 ret = lttng_poll_add(&events, sock,
1710 LPOLLERR | LPOLLHUP | LPOLLRDHUP);
1711 if (ret < 0) {
5eb91c98 1712 goto error;
e0c7ec2b 1713 }
acc7b41b 1714
d0b96690 1715 DBG("Apps with sock %d added to poll set", sock);
03e43155
MD
1716 } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
1717 ERR("Apps command pipe error");
1718 goto error;
1719 } else {
1720 ERR("Unknown poll events %u for sock %d", revents, pollfd);
1721 goto error;
0177d773 1722 }
5eb91c98
DG
1723 } else {
1724 /*
54d01ffb
DG
1725 * At this point, we know that a registered application made
1726 * the event at poll_wait.
5eb91c98
DG
1727 */
1728 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
1729 /* Removing from the poll set */
1730 ret = lttng_poll_del(&events, pollfd);
1731 if (ret < 0) {
1732 goto error;
1733 }
099e26bd 1734
b9d9b220 1735 /* Socket closed on remote end. */
56fff090 1736 ust_app_unregister(pollfd);
03e43155
MD
1737 } else {
1738 ERR("Unexpected poll events %u for sock %d", revents, pollfd);
1739 goto error;
5eb91c98 1740 }
099e26bd 1741 }
44a5e5eb 1742
840cb59c 1743 health_code_update();
099e26bd 1744 }
099e26bd
DG
1745 }
1746
139ac872 1747exit:
099e26bd 1748error:
5eb91c98 1749 lttng_poll_clean(&events);
76d7553f 1750error_poll_create:
6993eeb3 1751error_testpoint:
6620da75
DG
1752 utils_close_pipe(apps_cmd_pipe);
1753 apps_cmd_pipe[0] = apps_cmd_pipe[1] = -1;
1754
1755 /*
1756 * We don't clean the UST app hash table here since already registered
1757 * applications can still be controlled so let them be until the session
1758 * daemon dies or the applications stop.
1759 */
1760
139ac872 1761 if (err) {
840cb59c 1762 health_error();
139ac872
MD
1763 ERR("Health error occurred in %s", __func__);
1764 }
8782cc74 1765 health_unregister(health_sessiond);
76d7553f 1766 DBG("Application communication apps thread cleanup complete");
f6a9efaa
DG
1767 rcu_thread_offline();
1768 rcu_unregister_thread();
099e26bd
DG
1769 return NULL;
1770}
1771
d0b96690 1772/*
d88aee68
DG
1773 * Send a socket to a thread This is called from the dispatch UST registration
1774 * thread once all sockets are set for the application.
d0b96690 1775 *
b85dc84c
DG
1776 * The sock value can be invalid, we don't really care, the thread will handle
1777 * it and make the necessary cleanup if so.
1778 *
d0b96690
DG
1779 * On success, return 0 else a negative value being the errno message of the
1780 * write().
1781 */
d88aee68 1782static int send_socket_to_thread(int fd, int sock)
d0b96690 1783{
6cd525e8 1784 ssize_t ret;
d0b96690 1785
b85dc84c
DG
1786 /*
1787 * It's possible that the FD is set as invalid with -1 concurrently just
1788 * before calling this function being a shutdown state of the thread.
1789 */
1790 if (fd < 0) {
1791 ret = -EBADF;
1792 goto error;
1793 }
d0b96690 1794
6cd525e8
MD
1795 ret = lttng_write(fd, &sock, sizeof(sock));
1796 if (ret < sizeof(sock)) {
d88aee68 1797 PERROR("write apps pipe %d", fd);
d0b96690
DG
1798 if (ret < 0) {
1799 ret = -errno;
1800 }
1801 goto error;
1802 }
1803
1804 /* All good. Don't send back the write positive ret value. */
1805 ret = 0;
1806error:
6cd525e8 1807 return (int) ret;
d0b96690
DG
1808}
1809
f45e313d
DG
1810/*
1811 * Sanitize the wait queue of the dispatch registration thread meaning removing
1812 * invalid nodes from it. This is to avoid memory leaks for the case the UST
1813 * notify socket is never received.
1814 */
1815static void sanitize_wait_queue(struct ust_reg_wait_queue *wait_queue)
1816{
1817 int ret, nb_fd = 0, i;
1818 unsigned int fd_added = 0;
1819 struct lttng_poll_event events;
1820 struct ust_reg_wait_node *wait_node = NULL, *tmp_wait_node;
1821
1822 assert(wait_queue);
1823
1824 lttng_poll_init(&events);
1825
1826 /* Just skip everything for an empty queue. */
1827 if (!wait_queue->count) {
1828 goto end;
1829 }
1830
1831 ret = lttng_poll_create(&events, wait_queue->count, LTTNG_CLOEXEC);
1832 if (ret < 0) {
1833 goto error_create;
1834 }
1835
1836 cds_list_for_each_entry_safe(wait_node, tmp_wait_node,
1837 &wait_queue->head, head) {
1838 assert(wait_node->app);
1839 ret = lttng_poll_add(&events, wait_node->app->sock,
1840 LPOLLHUP | LPOLLERR);
1841 if (ret < 0) {
1842 goto error;
1843 }
1844
1845 fd_added = 1;
1846 }
1847
1848 if (!fd_added) {
1849 goto end;
1850 }
1851
1852 /*
1853 * Poll but don't block so we can quickly identify the faulty events and
1854 * clean them afterwards from the wait queue.
1855 */
1856 ret = lttng_poll_wait(&events, 0);
1857 if (ret < 0) {
1858 goto error;
1859 }
1860 nb_fd = ret;
1861
1862 for (i = 0; i < nb_fd; i++) {
1863 /* Get faulty FD. */
1864 uint32_t revents = LTTNG_POLL_GETEV(&events, i);
1865 int pollfd = LTTNG_POLL_GETFD(&events, i);
1866
fd20dac9
MD
1867 if (!revents) {
1868 /* No activity for this FD (poll implementation). */
1869 continue;
1870 }
1871
f45e313d
DG
1872 cds_list_for_each_entry_safe(wait_node, tmp_wait_node,
1873 &wait_queue->head, head) {
1874 if (pollfd == wait_node->app->sock &&
1875 (revents & (LPOLLHUP | LPOLLERR))) {
1876 cds_list_del(&wait_node->head);
1877 wait_queue->count--;
1878 ust_app_destroy(wait_node->app);
1879 free(wait_node);
48b40bcf
JG
1880 /*
1881 * Silence warning of use-after-free in
1882 * cds_list_for_each_entry_safe which uses
1883 * __typeof__(*wait_node).
1884 */
1885 wait_node = NULL;
f45e313d 1886 break;
03e43155
MD
1887 } else {
1888 ERR("Unexpected poll events %u for sock %d", revents, pollfd);
1889 goto error;
f45e313d
DG
1890 }
1891 }
1892 }
1893
1894 if (nb_fd > 0) {
1895 DBG("Wait queue sanitized, %d node were cleaned up", nb_fd);
1896 }
1897
1898end:
1899 lttng_poll_clean(&events);
1900 return;
1901
1902error:
1903 lttng_poll_clean(&events);
1904error_create:
1905 ERR("Unable to sanitize wait queue");
1906 return;
1907}
1908
099e26bd
DG
1909/*
1910 * Dispatch request from the registration threads to the application
1911 * communication thread.
1912 */
1913static void *thread_dispatch_ust_registration(void *data)
1914{
12e2b881 1915 int ret, err = -1;
8bdee6e2 1916 struct cds_wfcq_node *node;
099e26bd 1917 struct ust_command *ust_cmd = NULL;
f45e313d
DG
1918 struct ust_reg_wait_node *wait_node = NULL, *tmp_wait_node;
1919 struct ust_reg_wait_queue wait_queue = {
1920 .count = 0,
1921 };
d0b96690 1922
967e3668
MD
1923 rcu_register_thread();
1924
6c71277b 1925 health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_REG_DISPATCH);
12e2b881 1926
9ad42ec1
MD
1927 if (testpoint(sessiond_thread_app_reg_dispatch)) {
1928 goto error_testpoint;
1929 }
1930
12e2b881
MD
1931 health_code_update();
1932
f45e313d 1933 CDS_INIT_LIST_HEAD(&wait_queue.head);
099e26bd
DG
1934
1935 DBG("[thread] Dispatch UST command started");
1936
0ed3b1a8 1937 for (;;) {
12e2b881
MD
1938 health_code_update();
1939
099e26bd
DG
1940 /* Atomically prepare the queue futex */
1941 futex_nto1_prepare(&ust_cmd_queue.futex);
1942
0ed3b1a8
MD
1943 if (CMM_LOAD_SHARED(dispatch_thread_exit)) {
1944 break;
1945 }
1946
099e26bd 1947 do {
d0b96690 1948 struct ust_app *app = NULL;
7972aab2 1949 ust_cmd = NULL;
d0b96690 1950
f45e313d
DG
1951 /*
1952 * Make sure we don't have node(s) that have hung up before receiving
1953 * the notify socket. This is to clean the list in order to avoid
1954 * memory leaks from notify socket that are never seen.
1955 */
1956 sanitize_wait_queue(&wait_queue);
1957
12e2b881 1958 health_code_update();
099e26bd 1959 /* Dequeue command for registration */
8bdee6e2 1960 node = cds_wfcq_dequeue_blocking(&ust_cmd_queue.head, &ust_cmd_queue.tail);
099e26bd 1961 if (node == NULL) {
00a17c97 1962 DBG("Woken up but nothing in the UST command queue");
099e26bd
DG
1963 /* Continue thread execution */
1964 break;
1965 }
1966
1967 ust_cmd = caa_container_of(node, struct ust_command, node);
1968
2f50c8a3
DG
1969 DBG("Dispatching UST registration pid:%d ppid:%d uid:%d"
1970 " gid:%d sock:%d name:%s (version %d.%d)",
1971 ust_cmd->reg_msg.pid, ust_cmd->reg_msg.ppid,
1972 ust_cmd->reg_msg.uid, ust_cmd->reg_msg.gid,
1973 ust_cmd->sock, ust_cmd->reg_msg.name,
1974 ust_cmd->reg_msg.major, ust_cmd->reg_msg.minor);
d0b96690
DG
1975
1976 if (ust_cmd->reg_msg.type == USTCTL_SOCKET_CMD) {
1977 wait_node = zmalloc(sizeof(*wait_node));
1978 if (!wait_node) {
1979 PERROR("zmalloc wait_node dispatch");
020d7f60
DG
1980 ret = close(ust_cmd->sock);
1981 if (ret < 0) {
1982 PERROR("close ust sock dispatch %d", ust_cmd->sock);
1983 }
51dec90d 1984 lttng_fd_put(LTTNG_FD_APPS, 1);
7972aab2 1985 free(ust_cmd);
d0b96690
DG
1986 goto error;
1987 }
1988 CDS_INIT_LIST_HEAD(&wait_node->head);
1989
1990 /* Create application object if socket is CMD. */
1991 wait_node->app = ust_app_create(&ust_cmd->reg_msg,
1992 ust_cmd->sock);
1993 if (!wait_node->app) {
1994 ret = close(ust_cmd->sock);
1995 if (ret < 0) {
1996 PERROR("close ust sock dispatch %d", ust_cmd->sock);
6620da75 1997 }
51dec90d 1998 lttng_fd_put(LTTNG_FD_APPS, 1);
d88aee68 1999 free(wait_node);
7972aab2 2000 free(ust_cmd);
d0b96690
DG
2001 continue;
2002 }
2003 /*
2004 * Add application to the wait queue so we can set the notify
2005 * socket before putting this object in the global ht.
2006 */
f45e313d
DG
2007 cds_list_add(&wait_node->head, &wait_queue.head);
2008 wait_queue.count++;
d0b96690 2009
7972aab2 2010 free(ust_cmd);
d0b96690
DG
2011 /*
2012 * We have to continue here since we don't have the notify
2013 * socket and the application MUST be added to the hash table
2014 * only at that moment.
2015 */
2016 continue;
2017 } else {
2018 /*
2019 * Look for the application in the local wait queue and set the
2020 * notify socket if found.
2021 */
d88aee68 2022 cds_list_for_each_entry_safe(wait_node, tmp_wait_node,
f45e313d 2023 &wait_queue.head, head) {
12e2b881 2024 health_code_update();
d0b96690
DG
2025 if (wait_node->app->pid == ust_cmd->reg_msg.pid) {
2026 wait_node->app->notify_sock = ust_cmd->sock;
2027 cds_list_del(&wait_node->head);
f45e313d 2028 wait_queue.count--;
d0b96690
DG
2029 app = wait_node->app;
2030 free(wait_node);
2031 DBG3("UST app notify socket %d is set", ust_cmd->sock);
2032 break;
2033 }
2034 }
020d7f60
DG
2035
2036 /*
2037 * With no application at this stage the received socket is
2038 * basically useless so close it before we free the cmd data
2039 * structure for good.
2040 */
2041 if (!app) {
2042 ret = close(ust_cmd->sock);
2043 if (ret < 0) {
2044 PERROR("close ust sock dispatch %d", ust_cmd->sock);
2045 }
51dec90d 2046 lttng_fd_put(LTTNG_FD_APPS, 1);
020d7f60 2047 }
7972aab2 2048 free(ust_cmd);
d0b96690
DG
2049 }
2050
2051 if (app) {
d0b96690
DG
2052 /*
2053 * @session_lock_list
2054 *
2055 * Lock the global session list so from the register up to the
2056 * registration done message, no thread can see the application
2057 * and change its state.
2058 */
2059 session_lock_list();
2060 rcu_read_lock();
d88aee68 2061
d0b96690
DG
2062 /*
2063 * Add application to the global hash table. This needs to be
2064 * done before the update to the UST registry can locate the
2065 * application.
2066 */
2067 ust_app_add(app);
d88aee68
DG
2068
2069 /* Set app version. This call will print an error if needed. */
2070 (void) ust_app_version(app);
2071
2072 /* Send notify socket through the notify pipe. */
2073 ret = send_socket_to_thread(apps_cmd_notify_pipe[1],
2074 app->notify_sock);
2075 if (ret < 0) {
2076 rcu_read_unlock();
2077 session_unlock_list();
b85dc84c
DG
2078 /*
2079 * No notify thread, stop the UST tracing. However, this is
2080 * not an internal error of the this thread thus setting
2081 * the health error code to a normal exit.
2082 */
2083 err = 0;
d88aee68 2084 goto error;
6620da75 2085 }
d88aee68 2086
d0b96690
DG
2087 /*
2088 * Update newly registered application with the tracing
2089 * registry info already enabled information.
2090 */
2091 update_ust_app(app->sock);
d88aee68
DG
2092
2093 /*
2094 * Don't care about return value. Let the manage apps threads
2095 * handle app unregistration upon socket close.
2096 */
fb45065e 2097 (void) ust_app_register_done(app);
d88aee68
DG
2098
2099 /*
2100 * Even if the application socket has been closed, send the app
2101 * to the thread and unregistration will take place at that
2102 * place.
2103 */
2104 ret = send_socket_to_thread(apps_cmd_pipe[1], app->sock);
d0b96690 2105 if (ret < 0) {
d88aee68
DG
2106 rcu_read_unlock();
2107 session_unlock_list();
b85dc84c
DG
2108 /*
2109 * No apps. thread, stop the UST tracing. However, this is
2110 * not an internal error of the this thread thus setting
2111 * the health error code to a normal exit.
2112 */
2113 err = 0;
d88aee68 2114 goto error;
d0b96690 2115 }
d88aee68 2116
d0b96690
DG
2117 rcu_read_unlock();
2118 session_unlock_list();
099e26bd 2119 }
099e26bd
DG
2120 } while (node != NULL);
2121
12e2b881 2122 health_poll_entry();
099e26bd
DG
2123 /* Futex wait on queue. Blocking call on futex() */
2124 futex_nto1_wait(&ust_cmd_queue.futex);
12e2b881 2125 health_poll_exit();
099e26bd 2126 }
12e2b881
MD
2127 /* Normal exit, no error */
2128 err = 0;
099e26bd
DG
2129
2130error:
d88aee68
DG
2131 /* Clean up wait queue. */
2132 cds_list_for_each_entry_safe(wait_node, tmp_wait_node,
f45e313d 2133 &wait_queue.head, head) {
d88aee68 2134 cds_list_del(&wait_node->head);
f45e313d 2135 wait_queue.count--;
d88aee68
DG
2136 free(wait_node);
2137 }
2138
772b8f4d
MD
2139 /* Empty command queue. */
2140 for (;;) {
2141 /* Dequeue command for registration */
2142 node = cds_wfcq_dequeue_blocking(&ust_cmd_queue.head, &ust_cmd_queue.tail);
2143 if (node == NULL) {
2144 break;
2145 }
2146 ust_cmd = caa_container_of(node, struct ust_command, node);
2147 ret = close(ust_cmd->sock);
2148 if (ret < 0) {
2149 PERROR("close ust sock exit dispatch %d", ust_cmd->sock);
2150 }
2151 lttng_fd_put(LTTNG_FD_APPS, 1);
2152 free(ust_cmd);
2153 }
2154
9ad42ec1 2155error_testpoint:
099e26bd 2156 DBG("Dispatch thread dying");
12e2b881
MD
2157 if (err) {
2158 health_error();
2159 ERR("Health error occurred in %s", __func__);
2160 }
8782cc74 2161 health_unregister(health_sessiond);
967e3668 2162 rcu_unregister_thread();
099e26bd
DG
2163 return NULL;
2164}
2165
2166/*
2167 * This thread manage application registration.
2168 */
2169static void *thread_registration_apps(void *data)
1d4b027a 2170{
139ac872 2171 int sock = -1, i, ret, pollfd, err = -1;
5eb91c98
DG
2172 uint32_t revents, nb_fd;
2173 struct lttng_poll_event events;
099e26bd
DG
2174 /*
2175 * Get allocated in this thread, enqueued to a global queue, dequeued and
2176 * freed in the manage apps thread.
2177 */
2178 struct ust_command *ust_cmd = NULL;
1d4b027a 2179
099e26bd 2180 DBG("[thread] Manage application registration started");
1d4b027a 2181
6c71277b 2182 health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_REG);
927ca06a 2183
e547b070 2184 if (testpoint(sessiond_thread_registration_apps)) {
6993eeb3
CB
2185 goto error_testpoint;
2186 }
8ac94142 2187
1d4b027a
DG
2188 ret = lttcomm_listen_unix_sock(apps_sock);
2189 if (ret < 0) {
76d7553f 2190 goto error_listen;
1d4b027a
DG
2191 }
2192
5eb91c98
DG
2193 /*
2194 * Pass 2 as size here for the thread quit pipe and apps socket. Nothing
2195 * more will be added to this poll set.
2196 */
d0b96690 2197 ret = sessiond_set_thread_pollset(&events, 2);
5eb91c98 2198 if (ret < 0) {
76d7553f 2199 goto error_create_poll;
5eb91c98 2200 }
273ea72c 2201
5eb91c98
DG
2202 /* Add the application registration socket */
2203 ret = lttng_poll_add(&events, apps_sock, LPOLLIN | LPOLLRDHUP);
2204 if (ret < 0) {
76d7553f 2205 goto error_poll_add;
5eb91c98 2206 }
273ea72c 2207
1d4b027a 2208 /* Notify all applications to register */
0fdd1e2c
DG
2209 ret = notify_ust_apps(1);
2210 if (ret < 0) {
2211 ERR("Failed to notify applications or create the wait shared memory.\n"
54d01ffb
DG
2212 "Execution continues but there might be problem for already\n"
2213 "running applications that wishes to register.");
0fdd1e2c 2214 }
1d4b027a
DG
2215
2216 while (1) {
2217 DBG("Accepting application registration");
273ea72c
DG
2218
2219 /* Inifinite blocking call, waiting for transmission */
88f2b785 2220 restart:
a78af745 2221 health_poll_entry();
5eb91c98 2222 ret = lttng_poll_wait(&events, -1);
a78af745 2223 health_poll_exit();
273ea72c 2224 if (ret < 0) {
88f2b785
MD
2225 /*
2226 * Restart interrupted system call.
2227 */
2228 if (errno == EINTR) {
2229 goto restart;
2230 }
273ea72c
DG
2231 goto error;
2232 }
2233
0d9c5d77
DG
2234 nb_fd = ret;
2235
5eb91c98 2236 for (i = 0; i < nb_fd; i++) {
840cb59c 2237 health_code_update();
139ac872 2238
5eb91c98
DG
2239 /* Fetch once the poll data */
2240 revents = LTTNG_POLL_GETEV(&events, i);
2241 pollfd = LTTNG_POLL_GETFD(&events, i);
273ea72c 2242
fd20dac9
MD
2243 if (!revents) {
2244 /* No activity for this FD (poll implementation). */
2245 continue;
2246 }
2247
5eb91c98 2248 /* Thread quit pipe has been closed. Killing thread. */
d0b96690 2249 ret = sessiond_check_thread_quit_pipe(pollfd, revents);
5eb91c98 2250 if (ret) {
139ac872
MD
2251 err = 0;
2252 goto exit;
90014c57 2253 }
1d4b027a 2254
5eb91c98
DG
2255 /* Event on the registration socket */
2256 if (pollfd == apps_sock) {
03e43155 2257 if (revents & LPOLLIN) {
5eb91c98
DG
2258 sock = lttcomm_accept_unix_sock(apps_sock);
2259 if (sock < 0) {
2260 goto error;
2261 }
099e26bd 2262
16c5c8fa
DG
2263 /*
2264 * Set socket timeout for both receiving and ending.
2265 * app_socket_timeout is in seconds, whereas
2266 * lttcomm_setsockopt_rcv_timeout and
2267 * lttcomm_setsockopt_snd_timeout expect msec as
2268 * parameter.
2269 */
28ce0ff2
JG
2270 if (app_socket_timeout >= 0) {
2271 (void) lttcomm_setsockopt_rcv_timeout(sock,
2272 app_socket_timeout * 1000);
2273 (void) lttcomm_setsockopt_snd_timeout(sock,
2274 app_socket_timeout * 1000);
2275 }
16c5c8fa 2276
b662582b
DG
2277 /*
2278 * Set the CLOEXEC flag. Return code is useless because
2279 * either way, the show must go on.
2280 */
2281 (void) utils_set_fd_cloexec(sock);
2282
5eb91c98 2283 /* Create UST registration command for enqueuing */
ba7f0ae5 2284 ust_cmd = zmalloc(sizeof(struct ust_command));
5eb91c98 2285 if (ust_cmd == NULL) {
76d7553f 2286 PERROR("ust command zmalloc");
41ed8e47
MD
2287 ret = close(sock);
2288 if (ret) {
2289 PERROR("close");
2290 }
5eb91c98
DG
2291 goto error;
2292 }
1d4b027a 2293
5eb91c98
DG
2294 /*
2295 * Using message-based transmissions to ensure we don't
2296 * have to deal with partially received messages.
2297 */
4063050c
MD
2298 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
2299 if (ret < 0) {
2300 ERR("Exhausted file descriptors allowed for applications.");
2301 free(ust_cmd);
2302 ret = close(sock);
2303 if (ret) {
2304 PERROR("close");
2305 }
2306 sock = -1;
2307 continue;
2308 }
d88aee68 2309
840cb59c 2310 health_code_update();
d0b96690
DG
2311 ret = ust_app_recv_registration(sock, &ust_cmd->reg_msg);
2312 if (ret < 0) {
5eb91c98 2313 free(ust_cmd);
d0b96690 2314 /* Close socket of the application. */
76d7553f
MD
2315 ret = close(sock);
2316 if (ret) {
2317 PERROR("close");
2318 }
4063050c 2319 lttng_fd_put(LTTNG_FD_APPS, 1);
76d7553f 2320 sock = -1;
5eb91c98
DG
2321 continue;
2322 }
840cb59c 2323 health_code_update();
099e26bd 2324
5eb91c98 2325 ust_cmd->sock = sock;
34a2494f 2326 sock = -1;
099e26bd 2327
5eb91c98
DG
2328 DBG("UST registration received with pid:%d ppid:%d uid:%d"
2329 " gid:%d sock:%d name:%s (version %d.%d)",
2330 ust_cmd->reg_msg.pid, ust_cmd->reg_msg.ppid,
2331 ust_cmd->reg_msg.uid, ust_cmd->reg_msg.gid,
2332 ust_cmd->sock, ust_cmd->reg_msg.name,
2333 ust_cmd->reg_msg.major, ust_cmd->reg_msg.minor);
54d01ffb 2334
5eb91c98
DG
2335 /*
2336 * Lock free enqueue the registration request. The red pill
54d01ffb 2337 * has been taken! This apps will be part of the *system*.
5eb91c98 2338 */
8bdee6e2 2339 cds_wfcq_enqueue(&ust_cmd_queue.head, &ust_cmd_queue.tail, &ust_cmd->node);
5eb91c98
DG
2340
2341 /*
2342 * Wake the registration queue futex. Implicit memory
8bdee6e2 2343 * barrier with the exchange in cds_wfcq_enqueue.
5eb91c98
DG
2344 */
2345 futex_nto1_wake(&ust_cmd_queue.futex);
03e43155
MD
2346 } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
2347 ERR("Register apps socket poll error");
2348 goto error;
2349 } else {
2350 ERR("Unexpected poll events %u for sock %d", revents, pollfd);
2351 goto error;
5eb91c98
DG
2352 }
2353 }
90014c57 2354 }
1d4b027a
DG
2355 }
2356
139ac872 2357exit:
1d4b027a 2358error:
0fdd1e2c
DG
2359 /* Notify that the registration thread is gone */
2360 notify_ust_apps(0);
2361
a4b35e07 2362 if (apps_sock >= 0) {
76d7553f
MD
2363 ret = close(apps_sock);
2364 if (ret) {
2365 PERROR("close");
2366 }
a4b35e07 2367 }
46c3f085 2368 if (sock >= 0) {
76d7553f
MD
2369 ret = close(sock);
2370 if (ret) {
2371 PERROR("close");
2372 }
4063050c 2373 lttng_fd_put(LTTNG_FD_APPS, 1);
a4b35e07 2374 }
273ea72c 2375 unlink(apps_unix_sock_path);
0fdd1e2c 2376
76d7553f 2377error_poll_add:
5eb91c98 2378 lttng_poll_clean(&events);
76d7553f
MD
2379error_listen:
2380error_create_poll:
6993eeb3 2381error_testpoint:
76d7553f 2382 DBG("UST Registration thread cleanup complete");
9ad42ec1
MD
2383 if (err) {
2384 health_error();
2385 ERR("Health error occurred in %s", __func__);
2386 }
8782cc74 2387 health_unregister(health_sessiond);
5eb91c98 2388
1d4b027a
DG
2389 return NULL;
2390}
2391
8c0faa1d 2392/*
3bd1e081 2393 * Start the thread_manage_consumer. This must be done after a lttng-consumerd
d063d709 2394 * exec or it will fails.
8c0faa1d 2395 */
3bd1e081 2396static int spawn_consumer_thread(struct consumer_data *consumer_data)
8c0faa1d 2397{
a23ec3a7 2398 int ret, clock_ret;
ee0b0061
DG
2399 struct timespec timeout;
2400
13a7bce3
JG
2401 /*
2402 * Make sure we set the readiness flag to 0 because we are NOT ready.
2403 * This access to consumer_thread_is_ready does not need to be
2404 * protected by consumer_data.cond_mutex (yet) since the consumer
2405 * management thread has not been started at this point.
2406 */
a23ec3a7 2407 consumer_data->consumer_thread_is_ready = 0;
8c0faa1d 2408
a23ec3a7
DG
2409 /* Setup pthread condition */
2410 ret = pthread_condattr_init(&consumer_data->condattr);
4a15001e 2411 if (ret) {
a23ec3a7
DG
2412 errno = ret;
2413 PERROR("pthread_condattr_init consumer data");
2414 goto error;
2415 }
2416
2417 /*
2418 * Set the monotonic clock in order to make sure we DO NOT jump in time
2419 * between the clock_gettime() call and the timedwait call. See bug #324
2420 * for a more details and how we noticed it.
2421 */
2422 ret = pthread_condattr_setclock(&consumer_data->condattr, CLOCK_MONOTONIC);
4a15001e 2423 if (ret) {
a23ec3a7
DG
2424 errno = ret;
2425 PERROR("pthread_condattr_setclock consumer data");
ee0b0061
DG
2426 goto error;
2427 }
8c0faa1d 2428
a23ec3a7 2429 ret = pthread_cond_init(&consumer_data->cond, &consumer_data->condattr);
4a15001e 2430 if (ret) {
a23ec3a7
DG
2431 errno = ret;
2432 PERROR("pthread_cond_init consumer data");
2433 goto error;
2434 }
2435
1a1a34b4
MJ
2436 ret = pthread_create(&consumer_data->thread, default_pthread_attr(),
2437 thread_manage_consumer, consumer_data);
4a15001e
MD
2438 if (ret) {
2439 errno = ret;
3bd1e081 2440 PERROR("pthread_create consumer");
ee0b0061 2441 ret = -1;
8c0faa1d
DG
2442 goto error;
2443 }
2444
a23ec3a7
DG
2445 /* We are about to wait on a pthread condition */
2446 pthread_mutex_lock(&consumer_data->cond_mutex);
2447
ee0b0061 2448 /* Get time for sem_timedwait absolute timeout */
389fbf04 2449 clock_ret = lttng_clock_gettime(CLOCK_MONOTONIC, &timeout);
a23ec3a7
DG
2450 /*
2451 * Set the timeout for the condition timed wait even if the clock gettime
2452 * call fails since we might loop on that call and we want to avoid to
2453 * increment the timeout too many times.
2454 */
2455 timeout.tv_sec += DEFAULT_SEM_WAIT_TIMEOUT;
2456
2457 /*
2458 * The following loop COULD be skipped in some conditions so this is why we
2459 * set ret to 0 in order to make sure at least one round of the loop is
2460 * done.
2461 */
2462 ret = 0;
2463
2464 /*
2465 * Loop until the condition is reached or when a timeout is reached. Note
2466 * that the pthread_cond_timedwait(P) man page specifies that EINTR can NOT
2467 * be returned but the pthread_cond(3), from the glibc-doc, says that it is
2468 * possible. This loop does not take any chances and works with both of
2469 * them.
2470 */
2471 while (!consumer_data->consumer_thread_is_ready && ret != ETIMEDOUT) {
2472 if (clock_ret < 0) {
2473 PERROR("clock_gettime spawn consumer");
2474 /* Infinite wait for the consumerd thread to be ready */
2475 ret = pthread_cond_wait(&consumer_data->cond,
2476 &consumer_data->cond_mutex);
2477 } else {
2478 ret = pthread_cond_timedwait(&consumer_data->cond,
2479 &consumer_data->cond_mutex, &timeout);
2480 }
ee0b0061 2481 }
8c0faa1d 2482
a23ec3a7
DG
2483 /* Release the pthread condition */
2484 pthread_mutex_unlock(&consumer_data->cond_mutex);
2485
2486 if (ret != 0) {
2487 errno = ret;
2488 if (ret == ETIMEDOUT) {
4282f9a3
DG
2489 int pth_ret;
2490
ee0b0061
DG
2491 /*
2492 * Call has timed out so we kill the kconsumerd_thread and return
2493 * an error.
2494 */
a23ec3a7
DG
2495 ERR("Condition timed out. The consumer thread was never ready."
2496 " Killing it");
4282f9a3
DG
2497 pth_ret = pthread_cancel(consumer_data->thread);
2498 if (pth_ret < 0) {
3bd1e081 2499 PERROR("pthread_cancel consumer thread");
ee0b0061
DG
2500 }
2501 } else {
a23ec3a7 2502 PERROR("pthread_cond_wait failed consumer thread");
ee0b0061 2503 }
4282f9a3
DG
2504 /* Caller is expecting a negative value on failure. */
2505 ret = -1;
ee0b0061
DG
2506 goto error;
2507 }
2508
3bd1e081
MD
2509 pthread_mutex_lock(&consumer_data->pid_mutex);
2510 if (consumer_data->pid == 0) {
a23ec3a7 2511 ERR("Consumerd did not start");
3bd1e081 2512 pthread_mutex_unlock(&consumer_data->pid_mutex);
712ea556
DG
2513 goto error;
2514 }
3bd1e081 2515 pthread_mutex_unlock(&consumer_data->pid_mutex);
712ea556 2516
8c0faa1d
DG
2517 return 0;
2518
2519error:
2520 return ret;
2521}
2522
d9800920 2523/*
3bd1e081 2524 * Join consumer thread
d9800920 2525 */
3bd1e081 2526static int join_consumer_thread(struct consumer_data *consumer_data)
cf3af59e
MD
2527{
2528 void *status;
cf3af59e 2529
e8209f6b
DG
2530 /* Consumer pid must be a real one. */
2531 if (consumer_data->pid > 0) {
c617c0c6 2532 int ret;
3bd1e081 2533 ret = kill(consumer_data->pid, SIGTERM);
cf3af59e 2534 if (ret) {
4a15001e 2535 PERROR("Error killing consumer daemon");
cf3af59e
MD
2536 return ret;
2537 }
3bd1e081 2538 return pthread_join(consumer_data->thread, &status);
cf3af59e
MD
2539 } else {
2540 return 0;
2541 }
2542}
2543
8c0faa1d 2544/*
3bd1e081 2545 * Fork and exec a consumer daemon (consumerd).
8c0faa1d 2546 *
d063d709 2547 * Return pid if successful else -1.
8c0faa1d 2548 */
3bd1e081 2549static pid_t spawn_consumerd(struct consumer_data *consumer_data)
8c0faa1d
DG
2550{
2551 int ret;
2552 pid_t pid;
94c55f17 2553 const char *consumer_to_use;
53086306 2554 const char *verbosity;
94c55f17 2555 struct stat st;
8c0faa1d 2556
3bd1e081 2557 DBG("Spawning consumerd");
c49dc785 2558
8c0faa1d
DG
2559 pid = fork();
2560 if (pid == 0) {
2561 /*
3bd1e081 2562 * Exec consumerd.
8c0faa1d 2563 */
daee5345 2564 if (opt_verbose_consumer) {
53086306 2565 verbosity = "--verbose";
4421f712 2566 } else if (lttng_opt_quiet) {
53086306 2567 verbosity = "--quiet";
4421f712
DG
2568 } else {
2569 verbosity = "";
53086306 2570 }
4421f712 2571
3bd1e081
MD
2572 switch (consumer_data->type) {
2573 case LTTNG_CONSUMER_KERNEL:
94c55f17 2574 /*
c7704d57
DG
2575 * Find out which consumerd to execute. We will first try the
2576 * 64-bit path, then the sessiond's installation directory, and
2577 * fallback on the 32-bit one,
94c55f17 2578 */
63a799e8
AM
2579 DBG3("Looking for a kernel consumer at these locations:");
2580 DBG3(" 1) %s", consumerd64_bin);
2581 DBG3(" 2) %s/%s", INSTALL_BIN_PATH, CONSUMERD_FILE);
2582 DBG3(" 3) %s", consumerd32_bin);
94c55f17 2583 if (stat(consumerd64_bin, &st) == 0) {
63a799e8 2584 DBG3("Found location #1");
94c55f17 2585 consumer_to_use = consumerd64_bin;
94c55f17 2586 } else if (stat(INSTALL_BIN_PATH "/" CONSUMERD_FILE, &st) == 0) {
63a799e8 2587 DBG3("Found location #2");
94c55f17 2588 consumer_to_use = INSTALL_BIN_PATH "/" CONSUMERD_FILE;
eb1e0bd4 2589 } else if (stat(consumerd32_bin, &st) == 0) {
63a799e8 2590 DBG3("Found location #3");
eb1e0bd4 2591 consumer_to_use = consumerd32_bin;
94c55f17 2592 } else {
63a799e8 2593 DBG("Could not find any valid consumerd executable");
4282f9a3 2594 ret = -EINVAL;
3d678709 2595 goto error;
94c55f17
AM
2596 }
2597 DBG("Using kernel consumer at: %s", consumer_to_use);
6e2cc8d8 2598 (void) execl(consumer_to_use,
94c55f17
AM
2599 "lttng-consumerd", verbosity, "-k",
2600 "--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
2601 "--consumerd-err-sock", consumer_data->err_unix_sock_path,
6c71277b 2602 "--group", tracing_group_name,
94c55f17 2603 NULL);
3bd1e081 2604 break;
7753dea8
MD
2605 case LTTNG_CONSUMER64_UST:
2606 {
b1e0b6b6 2607 char *tmpnew = NULL;
8f4905da
MD
2608
2609 if (consumerd64_libdir[0] != '\0') {
2610 char *tmp;
2611 size_t tmplen;
2612
e8fa9fb0 2613 tmp = lttng_secure_getenv("LD_LIBRARY_PATH");
8f4905da
MD
2614 if (!tmp) {
2615 tmp = "";
2616 }
2617 tmplen = strlen("LD_LIBRARY_PATH=")
2618 + strlen(consumerd64_libdir) + 1 /* : */ + strlen(tmp);
2619 tmpnew = zmalloc(tmplen + 1 /* \0 */);
2620 if (!tmpnew) {
2621 ret = -ENOMEM;
2622 goto error;
2623 }
2624 strcpy(tmpnew, "LD_LIBRARY_PATH=");
2625 strcat(tmpnew, consumerd64_libdir);
2626 if (tmp[0] != '\0') {
2627 strcat(tmpnew, ":");
2628 strcat(tmpnew, tmp);
2629 }
2630 ret = putenv(tmpnew);
2631 if (ret) {
2632 ret = -errno;
c6f76da9 2633 free(tmpnew);
8f4905da
MD
2634 goto error;
2635 }
2636 }
94c55f17 2637 DBG("Using 64-bit UST consumer at: %s", consumerd64_bin);
6e2cc8d8 2638 (void) execl(consumerd64_bin, "lttng-consumerd", verbosity, "-u",
7753dea8
MD
2639 "--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
2640 "--consumerd-err-sock", consumer_data->err_unix_sock_path,
6c71277b 2641 "--group", tracing_group_name,
7753dea8 2642 NULL);
8f4905da
MD
2643 if (consumerd64_libdir[0] != '\0') {
2644 free(tmpnew);
2645 }
3bd1e081 2646 break;
7753dea8
MD
2647 }
2648 case LTTNG_CONSUMER32_UST:
2649 {
937dde8e 2650 char *tmpnew = NULL;
8f4905da
MD
2651
2652 if (consumerd32_libdir[0] != '\0') {
2653 char *tmp;
2654 size_t tmplen;
2655
e8fa9fb0 2656 tmp = lttng_secure_getenv("LD_LIBRARY_PATH");
8f4905da
MD
2657 if (!tmp) {
2658 tmp = "";
2659 }
2660 tmplen = strlen("LD_LIBRARY_PATH=")
2661 + strlen(consumerd32_libdir) + 1 /* : */ + strlen(tmp);
2662 tmpnew = zmalloc(tmplen + 1 /* \0 */);
2663 if (!tmpnew) {
2664 ret = -ENOMEM;
2665 goto error;
2666 }
2667 strcpy(tmpnew, "LD_LIBRARY_PATH=");
2668 strcat(tmpnew, consumerd32_libdir);
2669 if (tmp[0] != '\0') {
2670 strcat(tmpnew, ":");
2671 strcat(tmpnew, tmp);
2672 }
2673 ret = putenv(tmpnew);
2674 if (ret) {
2675 ret = -errno;
c6f76da9 2676 free(tmpnew);
8f4905da
MD
2677 goto error;
2678 }
2679 }
94c55f17 2680 DBG("Using 32-bit UST consumer at: %s", consumerd32_bin);
6e2cc8d8 2681 (void) execl(consumerd32_bin, "lttng-consumerd", verbosity, "-u",
7753dea8
MD
2682 "--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
2683 "--consumerd-err-sock", consumer_data->err_unix_sock_path,
6c71277b 2684 "--group", tracing_group_name,
7753dea8 2685 NULL);
8f4905da
MD
2686 if (consumerd32_libdir[0] != '\0') {
2687 free(tmpnew);
2688 }
7753dea8
MD
2689 break;
2690 }
3bd1e081 2691 default:
76d7553f 2692 PERROR("unknown consumer type");
3bd1e081
MD
2693 exit(EXIT_FAILURE);
2694 }
8c0faa1d 2695 if (errno != 0) {
4282f9a3 2696 PERROR("Consumer execl()");
8c0faa1d 2697 }
4282f9a3 2698 /* Reaching this point, we got a failure on our execl(). */
8c0faa1d
DG
2699 exit(EXIT_FAILURE);
2700 } else if (pid > 0) {
2701 ret = pid;
8c0faa1d 2702 } else {
76d7553f 2703 PERROR("start consumer fork");
8c0faa1d 2704 ret = -errno;
8c0faa1d 2705 }
8f4905da 2706error:
8c0faa1d
DG
2707 return ret;
2708}
2709
693bd40b 2710/*
3bd1e081 2711 * Spawn the consumerd daemon and session daemon thread.
693bd40b 2712 */
3bd1e081 2713static int start_consumerd(struct consumer_data *consumer_data)
693bd40b 2714{
c617c0c6 2715 int ret;
edb8b045
DG
2716
2717 /*
2718 * Set the listen() state on the socket since there is a possible race
2719 * between the exec() of the consumer daemon and this call if place in the
2720 * consumer thread. See bug #366 for more details.
2721 */
2722 ret = lttcomm_listen_unix_sock(consumer_data->err_sock);
2723 if (ret < 0) {
2724 goto error;
2725 }
693bd40b 2726
3bd1e081
MD
2727 pthread_mutex_lock(&consumer_data->pid_mutex);
2728 if (consumer_data->pid != 0) {
2729 pthread_mutex_unlock(&consumer_data->pid_mutex);
c49dc785
DG
2730 goto end;
2731 }
693bd40b 2732
3bd1e081 2733 ret = spawn_consumerd(consumer_data);
c49dc785 2734 if (ret < 0) {
3bd1e081
MD
2735 ERR("Spawning consumerd failed");
2736 pthread_mutex_unlock(&consumer_data->pid_mutex);
c49dc785 2737 goto error;
693bd40b 2738 }
c49dc785 2739
3bd1e081
MD
2740 /* Setting up the consumer_data pid */
2741 consumer_data->pid = ret;
48842b30 2742 DBG2("Consumer pid %d", consumer_data->pid);
3bd1e081 2743 pthread_mutex_unlock(&consumer_data->pid_mutex);
693bd40b 2744
3bd1e081
MD
2745 DBG2("Spawning consumer control thread");
2746 ret = spawn_consumer_thread(consumer_data);
693bd40b 2747 if (ret < 0) {
3bd1e081 2748 ERR("Fatal error spawning consumer control thread");
693bd40b
DG
2749 goto error;
2750 }
2751
c49dc785 2752end:
693bd40b
DG
2753 return 0;
2754
2755error:
331744e3 2756 /* Cleanup already created sockets on error. */
edb8b045 2757 if (consumer_data->err_sock >= 0) {
c617c0c6
MD
2758 int err;
2759
edb8b045
DG
2760 err = close(consumer_data->err_sock);
2761 if (err < 0) {
2762 PERROR("close consumer data error socket");
2763 }
2764 }
693bd40b
DG
2765 return ret;
2766}
2767
b73401da 2768/*
096102bd 2769 * Setup necessary data for kernel tracer action.
b73401da 2770 */
096102bd 2771static int init_kernel_tracer(void)
b73401da
DG
2772{
2773 int ret;
b73401da 2774
096102bd
DG
2775 /* Modprobe lttng kernel modules */
2776 ret = modprobe_lttng_control();
b73401da 2777 if (ret < 0) {
b73401da
DG
2778 goto error;
2779 }
2780
096102bd
DG
2781 /* Open debugfs lttng */
2782 kernel_tracer_fd = open(module_proc_lttng, O_RDWR);
2783 if (kernel_tracer_fd < 0) {
2784 DBG("Failed to open %s", module_proc_lttng);
2f77fc4b 2785 goto error_open;
54d01ffb
DG
2786 }
2787
2f77fc4b
DG
2788 /* Validate kernel version */
2789 ret = kernel_validate_version(kernel_tracer_fd);
2790 if (ret < 0) {
2791 goto error_version;
b551a063 2792 }
54d01ffb 2793
2f77fc4b
DG
2794 ret = modprobe_lttng_data();
2795 if (ret < 0) {
2796 goto error_modules;
54d01ffb
DG
2797 }
2798
6e21424e
JR
2799 ret = kernel_supports_ring_buffer_snapshot_sample_positions(
2800 kernel_tracer_fd);
2801 if (ret < 0) {
2802 goto error_modules;
2803 }
2804
2805 if (ret < 1) {
2806 WARN("Kernel tracer does not support buffer monitoring. "
2807 "The monitoring timer of channels in the kernel domain "
2808 "will be set to 0 (disabled).");
2809 }
2810
2f77fc4b
DG
2811 DBG("Kernel tracer fd %d", kernel_tracer_fd);
2812 return 0;
2813
2814error_version:
2815 modprobe_remove_lttng_control();
2816 ret = close(kernel_tracer_fd);
2817 if (ret) {
2818 PERROR("close");
b551a063 2819 }
2f77fc4b 2820 kernel_tracer_fd = -1;
f73fabfd 2821 return LTTNG_ERR_KERN_VERSION;
b551a063 2822
2f77fc4b
DG
2823error_modules:
2824 ret = close(kernel_tracer_fd);
2825 if (ret) {
2826 PERROR("close");
b551a063 2827 }
54d01ffb 2828
2f77fc4b
DG
2829error_open:
2830 modprobe_remove_lttng_control();
54d01ffb
DG
2831
2832error:
2f77fc4b
DG
2833 WARN("No kernel tracer available");
2834 kernel_tracer_fd = -1;
2835 if (!is_root) {
f73fabfd 2836 return LTTNG_ERR_NEED_ROOT_SESSIOND;
2f77fc4b 2837 } else {
f73fabfd 2838 return LTTNG_ERR_KERN_NA;
2f77fc4b 2839 }
54d01ffb
DG
2840}
2841
2f77fc4b 2842
54d01ffb 2843/*
2f77fc4b
DG
2844 * Copy consumer output from the tracing session to the domain session. The
2845 * function also applies the right modification on a per domain basis for the
2846 * trace files destination directory.
36b588ed
MD
2847 *
2848 * Should *NOT* be called with RCU read-side lock held.
54d01ffb 2849 */
2f77fc4b 2850static int copy_session_consumer(int domain, struct ltt_session *session)
54d01ffb
DG
2851{
2852 int ret;
2f77fc4b
DG
2853 const char *dir_name;
2854 struct consumer_output *consumer;
2855
2856 assert(session);
2857 assert(session->consumer);
54d01ffb 2858
b551a063
DG
2859 switch (domain) {
2860 case LTTNG_DOMAIN_KERNEL:
2f77fc4b 2861 DBG3("Copying tracing session consumer output in kernel session");
09a90bcd
DG
2862 /*
2863 * XXX: We should audit the session creation and what this function
2864 * does "extra" in order to avoid a destroy since this function is used
2865 * in the domain session creation (kernel and ust) only. Same for UST
2866 * domain.
2867 */
2868 if (session->kernel_session->consumer) {
6addfa37 2869 consumer_output_put(session->kernel_session->consumer);
09a90bcd 2870 }
2f77fc4b
DG
2871 session->kernel_session->consumer =
2872 consumer_copy_output(session->consumer);
2873 /* Ease our life a bit for the next part */
2874 consumer = session->kernel_session->consumer;
2875 dir_name = DEFAULT_KERNEL_TRACE_DIR;
b551a063 2876 break;
f20baf8e 2877 case LTTNG_DOMAIN_JUL:
5cdb6027 2878 case LTTNG_DOMAIN_LOG4J:
0e115563 2879 case LTTNG_DOMAIN_PYTHON:
b551a063 2880 case LTTNG_DOMAIN_UST:
2f77fc4b 2881 DBG3("Copying tracing session consumer output in UST session");
09a90bcd 2882 if (session->ust_session->consumer) {
6addfa37 2883 consumer_output_put(session->ust_session->consumer);
09a90bcd 2884 }
2f77fc4b
DG
2885 session->ust_session->consumer =
2886 consumer_copy_output(session->consumer);
2887 /* Ease our life a bit for the next part */
2888 consumer = session->ust_session->consumer;
2889 dir_name = DEFAULT_UST_TRACE_DIR;
b551a063
DG
2890 break;
2891 default:
f73fabfd 2892 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
54d01ffb
DG
2893 goto error;
2894 }
2895
2f77fc4b 2896 /* Append correct directory to subdir */
c30ce0b3
CB
2897 strncat(consumer->subdir, dir_name,
2898 sizeof(consumer->subdir) - strlen(consumer->subdir) - 1);
2f77fc4b
DG
2899 DBG3("Copy session consumer subdir %s", consumer->subdir);
2900
f73fabfd 2901 ret = LTTNG_OK;
54d01ffb
DG
2902
2903error:
2904 return ret;
2905}
2906
00e2e675 2907/*
2f77fc4b 2908 * Create an UST session and add it to the session ust list.
36b588ed
MD
2909 *
2910 * Should *NOT* be called with RCU read-side lock held.
00e2e675 2911 */
2f77fc4b
DG
2912static int create_ust_session(struct ltt_session *session,
2913 struct lttng_domain *domain)
00e2e675
DG
2914{
2915 int ret;
2f77fc4b 2916 struct ltt_ust_session *lus = NULL;
00e2e675 2917
a4b92340 2918 assert(session);
2f77fc4b
DG
2919 assert(domain);
2920 assert(session->consumer);
a4b92340 2921
2f77fc4b 2922 switch (domain->type) {
f20baf8e 2923 case LTTNG_DOMAIN_JUL:
5cdb6027 2924 case LTTNG_DOMAIN_LOG4J:
0e115563 2925 case LTTNG_DOMAIN_PYTHON:
2f77fc4b
DG
2926 case LTTNG_DOMAIN_UST:
2927 break;
2928 default:
2929 ERR("Unknown UST domain on create session %d", domain->type);
f73fabfd 2930 ret = LTTNG_ERR_UNKNOWN_DOMAIN;
00e2e675
DG
2931 goto error;
2932 }
2933
2f77fc4b
DG
2934 DBG("Creating UST session");
2935
dec56f6c 2936 lus = trace_ust_create_session(session->id);
2f77fc4b 2937 if (lus == NULL) {
f73fabfd 2938 ret = LTTNG_ERR_UST_SESS_FAIL;
a4b92340
DG
2939 goto error;
2940 }
2941
2f77fc4b
DG
2942 lus->uid = session->uid;
2943 lus->gid = session->gid;
2bba9e53 2944 lus->output_traces = session->output_traces;
27babd3a 2945 lus->snapshot_mode = session->snapshot_mode;
ecc48a90 2946 lus->live_timer_interval = session->live_timer;
2f77fc4b 2947 session->ust_session = lus;
d7ba1388 2948 if (session->shm_path[0]) {
3d071855
MD
2949 strncpy(lus->root_shm_path, session->shm_path,
2950 sizeof(lus->root_shm_path));
2951 lus->root_shm_path[sizeof(lus->root_shm_path) - 1] = '\0';
d7ba1388
MD
2952 strncpy(lus->shm_path, session->shm_path,
2953 sizeof(lus->shm_path));
2954 lus->shm_path[sizeof(lus->shm_path) - 1] = '\0';
2955 strncat(lus->shm_path, "/ust",
2956 sizeof(lus->shm_path) - strlen(lus->shm_path) - 1);
2957 }
2f77fc4b
DG
2958 /* Copy session output to the newly created UST session */
2959 ret = copy_session_consumer(domain->type, session);
f73fabfd 2960 if (ret != LTTNG_OK) {
00e2e675
DG
2961 goto error;
2962 }
2963
f73fabfd 2964 return LTTNG_OK;
00e2e675
DG
2965
2966error:
2f77fc4b
DG
2967 free(lus);
2968 session->ust_session = NULL;
00e2e675
DG
2969 return ret;
2970}
2971
2972/*
2f77fc4b 2973 * Create a kernel tracer session then create the default channel.
00e2e675 2974 */
2f77fc4b 2975static int create_kernel_session(struct ltt_session *session)
00e2e675
DG
2976{
2977 int ret;
a4b92340 2978
2f77fc4b 2979 DBG("Creating kernel session");
00e2e675 2980
2f77fc4b
DG
2981 ret = kernel_create_session(session, kernel_tracer_fd);
2982 if (ret < 0) {
f73fabfd 2983 ret = LTTNG_ERR_KERN_SESS_FAIL;
00e2e675
DG
2984 goto error;
2985 }
2986
2f77fc4b
DG
2987 /* Code flow safety */
2988 assert(session->kernel_session);
2989
2990 /* Copy session output to the newly created Kernel session */
2991 ret = copy_session_consumer(LTTNG_DOMAIN_KERNEL, session);
f73fabfd 2992 if (ret != LTTNG_OK) {
a4b92340
DG
2993 goto error;
2994 }
2995
2f77fc4b
DG
2996 /* Create directory(ies) on local filesystem. */
2997 if (session->kernel_session->consumer->type == CONSUMER_DST_LOCAL &&
2998 strlen(session->kernel_session->consumer->dst.trace_path) > 0) {
2999 ret = run_as_mkdir_recursive(
3000 session->kernel_session->consumer->dst.trace_path,
3001 S_IRWXU | S_IRWXG, session->uid, session->gid);
3002 if (ret < 0) {
df5b86c8 3003 if (errno != EEXIST) {
2f77fc4b 3004 ERR("Trace directory creation error");
00e2e675
DG
3005 goto error;
3006 }
00e2e675 3007 }
2f77fc4b 3008 }
00e2e675 3009
2f77fc4b
DG
3010 session->kernel_session->uid = session->uid;
3011 session->kernel_session->gid = session->gid;
2bba9e53 3012 session->kernel_session->output_traces = session->output_traces;
27babd3a 3013 session->kernel_session->snapshot_mode = session->snapshot_mode;
00e2e675 3014
f73fabfd 3015 return LTTNG_OK;
00e2e675 3016
2f77fc4b
DG
3017error:
3018 trace_kernel_destroy_session(session->kernel_session);
3019 session->kernel_session = NULL;
3020 return ret;
3021}
00e2e675 3022
2f77fc4b
DG
3023/*
3024 * Count number of session permitted by uid/gid.
3025 */
3026static unsigned int lttng_sessions_count(uid_t uid, gid_t gid)
3027{
3028 unsigned int i = 0;
3029 struct ltt_session *session;
07424f16 3030
2f77fc4b
DG
3031 DBG("Counting number of available session for UID %d GID %d",
3032 uid, gid);
3033 cds_list_for_each_entry(session, &session_list_ptr->head, list) {
00e2e675 3034 /*
2f77fc4b 3035 * Only list the sessions the user can control.
00e2e675 3036 */
2f77fc4b
DG
3037 if (!session_access_ok(session, uid, gid)) {
3038 continue;
3039 }
3040 i++;
a4b92340 3041 }
2f77fc4b 3042 return i;
00e2e675
DG
3043}
3044
54d01ffb
DG
3045/*
3046 * Process the command requested by the lttng client within the command
3047 * context structure. This function make sure that the return structure (llm)
3048 * is set and ready for transmission before returning.
3049 *
3050 * Return any error encountered or 0 for success.
53a80697
MD
3051 *
3052 * "sock" is only used for special-case var. len data.
36b588ed
MD
3053 *
3054 * Should *NOT* be called with RCU read-side lock held.
54d01ffb 3055 */
53a80697
MD
3056static int process_client_msg(struct command_ctx *cmd_ctx, int sock,
3057 int *sock_error)
54d01ffb 3058{
f73fabfd 3059 int ret = LTTNG_OK;
44d3bd01 3060 int need_tracing_session = 1;
2e09ba09 3061 int need_domain;
54d01ffb
DG
3062
3063 DBG("Processing client command %d", cmd_ctx->lsm->cmd_type);
3064
3745d315
MD
3065 assert(!rcu_read_ongoing());
3066
53a80697
MD
3067 *sock_error = 0;
3068
2e09ba09
MD
3069 switch (cmd_ctx->lsm->cmd_type) {
3070 case LTTNG_CREATE_SESSION:
27babd3a 3071 case LTTNG_CREATE_SESSION_SNAPSHOT:
ecc48a90 3072 case LTTNG_CREATE_SESSION_LIVE:
2e09ba09
MD
3073 case LTTNG_DESTROY_SESSION:
3074 case LTTNG_LIST_SESSIONS:
3075 case LTTNG_LIST_DOMAINS:
3076 case LTTNG_START_TRACE:
3077 case LTTNG_STOP_TRACE:
6d805429 3078 case LTTNG_DATA_PENDING:
da3c9ec1
DG
3079 case LTTNG_SNAPSHOT_ADD_OUTPUT:
3080 case LTTNG_SNAPSHOT_DEL_OUTPUT:
3081 case LTTNG_SNAPSHOT_LIST_OUTPUT:
3082 case LTTNG_SNAPSHOT_RECORD:
fb198a11 3083 case LTTNG_SAVE_SESSION:
d7ba1388 3084 case LTTNG_SET_SESSION_SHM_PATH:
eded6438 3085 case LTTNG_REGENERATE_METADATA:
c2561365 3086 case LTTNG_REGENERATE_STATEDUMP:
b3530820
JG
3087 case LTTNG_REGISTER_TRIGGER:
3088 case LTTNG_UNREGISTER_TRIGGER:
2e09ba09 3089 need_domain = 0;
3aace903 3090 break;
2e09ba09
MD
3091 default:
3092 need_domain = 1;
3093 }
3094
3095 if (opt_no_kernel && need_domain
3096 && cmd_ctx->lsm->domain.type == LTTNG_DOMAIN_KERNEL) {
531d29f9 3097 if (!is_root) {
f73fabfd 3098 ret = LTTNG_ERR_NEED_ROOT_SESSIOND;
531d29f9 3099 } else {
f73fabfd 3100 ret = LTTNG_ERR_KERN_NA;
531d29f9 3101 }
4fba7219
DG
3102 goto error;
3103 }
3104
8d3113b2
DG
3105 /* Deny register consumer if we already have a spawned consumer. */
3106 if (cmd_ctx->lsm->cmd_type == LTTNG_REGISTER_CONSUMER) {
3107 pthread_mutex_lock(&kconsumer_data.pid_mutex);
3108 if (kconsumer_data.pid > 0) {
f73fabfd 3109 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
fa317f24 3110 pthread_mutex_unlock(&kconsumer_data.pid_mutex);
8d3113b2
DG
3111 goto error;
3112 }
3113 pthread_mutex_unlock(&kconsumer_data.pid_mutex);
3114 }
3115
54d01ffb
DG
3116 /*
3117 * Check for command that don't needs to allocate a returned payload. We do
44d3bd01 3118 * this here so we don't have to make the call for no payload at each