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