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