Fix possible NULL pointer dereference
[lttng-tools.git] / 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 *
54d01ffb
DG
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the Free
7 * Software Foundation; only version 2 of the License.
91d76f53 8 *
54d01ffb
DG
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
91d76f53 13 *
54d01ffb
DG
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
16 * Place - Suite 330, Boston, MA 02111-1307, USA.
fac6795d
DG
17 */
18
19#define _GNU_SOURCE
20#include <fcntl.h>
21#include <getopt.h>
22#include <grp.h>
23#include <limits.h>
24#include <pthread.h>
8c0faa1d 25#include <semaphore.h>
fac6795d
DG
26#include <signal.h>
27#include <stdio.h>
28#include <stdlib.h>
29#include <string.h>
0fdd1e2c 30#include <sys/mman.h>
b73401da 31#include <sys/mount.h>
1e307fab 32#include <sys/resource.h>
fac6795d
DG
33#include <sys/socket.h>
34#include <sys/stat.h>
35#include <sys/types.h>
0fdd1e2c
DG
36#include <sys/wait.h>
37#include <urcu/futex.h>
fac6795d 38#include <unistd.h>
3bd1e081 39#include <config.h>
fac6795d 40
3bd1e081 41#include <lttng-consumerd.h>
e88129fc 42#include <lttng-sessiond-comm.h>
3bd1e081 43#include <lttng/lttng-consumer.h>
2bdd86d4 44
1e307fab 45#include <lttngerr.h>
fac6795d 46
54d01ffb 47#include "channel.h"
5eb91c98 48#include "compat/poll.h"
099e26bd 49#include "context.h"
54d01ffb 50#include "event.h"
099e26bd 51#include "futex.h"
f6a9efaa 52#include "hashtable.h"
20fe2104 53#include "kernel-ctl.h"
32258573 54#include "lttng-sessiond.h"
0fdd1e2c 55#include "shm.h"
56fff090 56#include "ust-app.h"
1e307fab 57#include "ust-ctl.h"
8e68d1c8 58#include "utils.h"
fac6795d 59
3bd1e081
MD
60struct consumer_data {
61 enum lttng_consumer_type type;
62
63 pthread_t thread; /* Worker thread interacting with the consumer */
64 sem_t sem;
65
66 /* Mutex to control consumerd pid assignation */
67 pthread_mutex_t pid_mutex;
68 pid_t pid;
69
70 int err_sock;
71 int cmd_sock;
72
73 /* consumer error and command Unix socket path */
74 char err_unix_sock_path[PATH_MAX];
75 char cmd_unix_sock_path[PATH_MAX];
76};
77
75462a81 78/* Const values */
686204ab 79const char default_home_dir[] = DEFAULT_HOME_DIR;
64a23ac4 80const char default_tracing_group[] = LTTNG_DEFAULT_TRACING_GROUP;
686204ab
MD
81const char default_ust_sock_dir[] = DEFAULT_UST_SOCK_DIR;
82const char default_global_apps_pipe[] = DEFAULT_GLOBAL_APPS_PIPE;
83
fac6795d 84/* Variables */
1d4b027a 85int opt_verbose; /* Not static for lttngerr.h */
3bd1e081 86int opt_verbose_consumer; /* Not static for lttngerr.h */
1d4b027a 87int opt_quiet; /* Not static for lttngerr.h */
d063d709 88
fac6795d
DG
89const char *progname;
90const char *opt_tracing_group;
5b8719f5 91static int opt_sig_parent;
fac6795d
DG
92static int opt_daemon;
93static int is_root; /* Set to 1 if the daemon is running as root */
1d4b027a 94static pid_t ppid; /* Parent PID for --sig-parent option */
3bd1e081
MD
95
96/* Consumer daemon specific control data */
97static struct consumer_data kconsumer_data = {
98 .type = LTTNG_CONSUMER_KERNEL,
99};
100static struct consumer_data ustconsumer_data = {
101 .type = LTTNG_CONSUMER_UST,
102};
103
099e26bd 104static int dispatch_thread_exit;
fac6795d 105
54d01ffb
DG
106/* Global application Unix socket path */
107static char apps_unix_sock_path[PATH_MAX];
108/* Global client Unix socket path */
109static char client_unix_sock_path[PATH_MAX];
54d01ffb
DG
110/* global wait shm path for UST */
111static char wait_shm_path[PATH_MAX];
fac6795d 112
1d4b027a 113/* Sockets and FDs */
d6f42150
DG
114static int client_sock;
115static int apps_sock;
20fe2104 116static int kernel_tracer_fd;
7a485870 117static int kernel_poll_pipe[2];
1d4b027a 118
273ea72c
DG
119/*
120 * Quit pipe for all threads. This permits a single cancellation point
121 * for all threads when receiving an event on the pipe.
122 */
123static int thread_quit_pipe[2];
124
099e26bd
DG
125/*
126 * This pipe is used to inform the thread managing application communication
127 * that a command is queued and ready to be processed.
128 */
129static int apps_cmd_pipe[2];
130
1d4b027a 131/* Pthread, Mutexes and Semaphores */
1d4b027a 132static pthread_t apps_thread;
099e26bd 133static pthread_t reg_apps_thread;
1d4b027a 134static pthread_t client_thread;
7a485870 135static pthread_t kernel_thread;
099e26bd 136static pthread_t dispatch_thread;
5eb91c98 137
fac6795d 138
099e26bd
DG
139/*
140 * UST registration command queue. This queue is tied with a futex and uses a N
141 * wakers / 1 waiter implemented and detailed in futex.c/.h
142 *
143 * The thread_manage_apps and thread_dispatch_ust_registration interact with
144 * this queue and the wait/wake scheme.
145 */
146static struct ust_cmd_queue ust_cmd_queue;
147
b5541356
DG
148/*
149 * Pointer initialized before thread creation.
150 *
151 * This points to the tracing session list containing the session count and a
152 * mutex lock. The lock MUST be taken if you iterate over the list. The lock
153 * MUST NOT be taken if you call a public function in session.c.
04ea676f 154 *
d063d709 155 * The lock is nested inside the structure: session_list_ptr->lock. Please use
54d01ffb 156 * session_lock_list and session_unlock_list for lock acquisition.
b5541356
DG
157 */
158static struct ltt_session_list *session_list_ptr;
159
5eb91c98
DG
160/*
161 * Create a poll set with O_CLOEXEC and add the thread quit pipe to the set.
162 */
163static int create_thread_poll_set(struct lttng_poll_event *events,
164 unsigned int size)
165{
166 int ret;
167
168 if (events == NULL || size == 0) {
169 ret = -1;
170 goto error;
171 }
172
173 ret = lttng_poll_create(events, size, LTTNG_CLOEXEC);
174 if (ret < 0) {
175 goto error;
176 }
177
178 /* Add quit pipe */
179 ret = lttng_poll_add(events, thread_quit_pipe[0], LPOLLIN);
180 if (ret < 0) {
181 goto error;
182 }
183
184 return 0;
185
186error:
187 return ret;
188}
189
190/*
191 * Check if the thread quit pipe was triggered.
192 *
193 * Return 1 if it was triggered else 0;
194 */
195static int check_thread_quit_pipe(int fd, uint32_t events)
196{
197 if (fd == thread_quit_pipe[0] && (events & LPOLLIN)) {
198 return 1;
199 }
200
201 return 0;
202}
203
0fdd1e2c
DG
204/*
205 * Remove modules in reverse load order.
206 */
207static int modprobe_remove_kernel_modules(void)
208{
209 int ret = 0, i;
210 char modprobe[256];
211
212 for (i = ARRAY_SIZE(kernel_modules_list) - 1; i >= 0; i--) {
213 ret = snprintf(modprobe, sizeof(modprobe),
24b487b8 214 "/sbin/modprobe -r -q %s",
0fdd1e2c
DG
215 kernel_modules_list[i].name);
216 if (ret < 0) {
24b487b8 217 perror("snprintf modprobe -r");
0fdd1e2c
DG
218 goto error;
219 }
220 modprobe[sizeof(modprobe) - 1] = '\0';
221 ret = system(modprobe);
222 if (ret == -1) {
24b487b8 223 ERR("Unable to launch modprobe -r for module %s",
0fdd1e2c
DG
224 kernel_modules_list[i].name);
225 } else if (kernel_modules_list[i].required
226 && WEXITSTATUS(ret) != 0) {
227 ERR("Unable to remove module %s",
228 kernel_modules_list[i].name);
229 } else {
230 DBG("Modprobe removal successful %s",
231 kernel_modules_list[i].name);
232 }
233 }
234
235error:
236 return ret;
237}
238
239/*
240 * Return group ID of the tracing group or -1 if not found.
241 */
996b65c8
MD
242static gid_t allowed_group(void)
243{
244 struct group *grp;
245
274e143b
MD
246 if (opt_tracing_group) {
247 grp = getgrnam(opt_tracing_group);
248 } else {
249 grp = getgrnam(default_tracing_group);
250 }
996b65c8
MD
251 if (!grp) {
252 return -1;
253 } else {
254 return grp->gr_gid;
255 }
256}
257
273ea72c 258/*
5eb91c98 259 * Init thread quit pipe.
273ea72c
DG
260 *
261 * Return -1 on error or 0 if all pipes are created.
262 */
263static int init_thread_quit_pipe(void)
264{
265 int ret;
266
267 ret = pipe2(thread_quit_pipe, O_CLOEXEC);
268 if (ret < 0) {
269 perror("thread quit pipe");
270 goto error;
271 }
272
273error:
274 return ret;
275}
276
fac6795d 277/*
d063d709
DG
278 * Complete teardown of a kernel session. This free all data structure related
279 * to a kernel session and update counter.
fac6795d 280 */
1d4b027a 281static void teardown_kernel_session(struct ltt_session *session)
fac6795d 282{
1d4b027a
DG
283 if (session->kernel_session != NULL) {
284 DBG("Tearing down kernel session");
d9800920
DG
285
286 /*
287 * If a custom kernel consumer was registered, close the socket before
288 * tearing down the complete kernel session structure
289 */
3bd1e081 290 if (session->kernel_session->consumer_fd != kconsumer_data.cmd_sock) {
d9800920
DG
291 lttcomm_close_unix_sock(session->kernel_session->consumer_fd);
292 }
293
62499ad6 294 trace_kernel_destroy_session(session->kernel_session);
1d4b027a
DG
295 /* Extra precaution */
296 session->kernel_session = NULL;
fac6795d 297 }
fac6795d
DG
298}
299
f6a9efaa
DG
300/*
301 * Complete teardown of all UST sessions. This will free everything on his path
302 * and destroy the core essence of all ust sessions :)
303 */
304static void teardown_ust_session(struct ltt_session *session)
305{
306 DBG("Tearing down UST session(s)");
307
308 trace_ust_destroy_session(session->ust_session);
309}
310
099e26bd
DG
311/*
312 * Stop all threads by closing the thread quit pipe.
313 */
cf3af59e
MD
314static void stop_threads(void)
315{
5eb91c98
DG
316 int ret;
317
cf3af59e
MD
318 /* Stopping all threads */
319 DBG("Terminating all threads");
54d01ffb 320 ret = notify_thread_pipe(thread_quit_pipe[1]);
5eb91c98
DG
321 if (ret < 0) {
322 ERR("write error on thread quit pipe");
323 }
324
099e26bd
DG
325 /* Dispatch thread */
326 dispatch_thread_exit = 1;
327 futex_nto1_wake(&ust_cmd_queue.futex);
cf3af59e
MD
328}
329
fac6795d 330/*
d063d709 331 * Cleanup the daemon
fac6795d 332 */
cf3af59e 333static void cleanup(void)
fac6795d 334{
1d4b027a
DG
335 int ret;
336 char *cmd;
af9737e9 337 struct ltt_session *sess, *stmp;
fac6795d 338
1d4b027a 339 DBG("Cleaning up");
e07ae692 340
1d4b027a 341 /* <fun> */
2f50c8a3 342 MSG("%c[%d;%dm*** assert failed *** ==> %c[%dm%c[%d;%dm"
273ea72c
DG
343 "Matthew, BEET driven development works!%c[%dm",
344 27, 1, 31, 27, 0, 27, 1, 33, 27, 0);
1d4b027a 345 /* </fun> */
fac6795d 346
5eb91c98
DG
347 if (is_root) {
348 DBG("Removing %s directory", LTTNG_RUNDIR);
349 ret = asprintf(&cmd, "rm -rf " LTTNG_RUNDIR);
350 if (ret < 0) {
351 ERR("asprintf failed. Something is really wrong!");
352 }
5461b305 353
5eb91c98
DG
354 /* Remove lttng run directory */
355 ret = system(cmd);
356 if (ret < 0) {
357 ERR("Unable to clean " LTTNG_RUNDIR);
358 }
1d4b027a 359 }
5461b305 360
1d4b027a 361 DBG("Cleaning up all session");
fac6795d 362
b5541356 363 /* Destroy session list mutex */
273ea72c
DG
364 if (session_list_ptr != NULL) {
365 pthread_mutex_destroy(&session_list_ptr->lock);
366
367 /* Cleanup ALL session */
54d01ffb
DG
368 cds_list_for_each_entry_safe(sess, stmp,
369 &session_list_ptr->head, list) {
273ea72c 370 teardown_kernel_session(sess);
f6a9efaa
DG
371 teardown_ust_session(sess);
372 free(sess);
273ea72c
DG
373 }
374 }
375
099e26bd 376 DBG("Closing all UST sockets");
56fff090 377 ust_app_clean_list();
099e26bd 378
3bd1e081 379 pthread_mutex_destroy(&kconsumer_data.pid_mutex);
b5541356 380
f3ed775e 381 DBG("Closing kernel fd");
1d4b027a 382 close(kernel_tracer_fd);
ab147185 383
2f50c8a3
DG
384 if (is_root) {
385 DBG("Unloading kernel modules");
386 modprobe_remove_kernel_modules();
387 }
5eb91c98
DG
388
389 close(thread_quit_pipe[0]);
390 close(thread_quit_pipe[1]);
fac6795d
DG
391}
392
e065084a 393/*
d063d709 394 * Send data on a unix socket using the liblttsessiondcomm API.
e065084a 395 *
d063d709 396 * Return lttcomm error code.
e065084a
DG
397 */
398static int send_unix_sock(int sock, void *buf, size_t len)
399{
400 /* Check valid length */
401 if (len <= 0) {
402 return -1;
403 }
404
405 return lttcomm_send_unix_sock(sock, buf, len);
406}
407
5461b305 408/*
d063d709 409 * Free memory of a command context structure.
5461b305 410 */
a2fb29a5 411static void clean_command_ctx(struct command_ctx **cmd_ctx)
5461b305 412{
a2fb29a5
DG
413 DBG("Clean command context structure");
414 if (*cmd_ctx) {
415 if ((*cmd_ctx)->llm) {
416 free((*cmd_ctx)->llm);
5461b305 417 }
a2fb29a5
DG
418 if ((*cmd_ctx)->lsm) {
419 free((*cmd_ctx)->lsm);
5461b305 420 }
a2fb29a5
DG
421 free(*cmd_ctx);
422 *cmd_ctx = NULL;
5461b305
DG
423 }
424}
425
f3ed775e 426/*
d063d709 427 * Send all stream fds of kernel channel to the consumer.
f3ed775e 428 */
2bdd86d4 429static int send_kconsumer_channel_streams(struct consumer_data *consumer_data,
3bd1e081 430 int sock, struct ltt_kernel_channel *channel)
f3ed775e
DG
431{
432 int ret;
f3ed775e 433 struct ltt_kernel_stream *stream;
3bd1e081 434 struct lttcomm_consumer_msg lkm;
f3ed775e 435
3bd1e081 436 DBG("Sending streams of channel %s to kernel consumer",
54d01ffb 437 channel->channel->name);
f3ed775e 438
3bd1e081
MD
439 /* Send channel */
440 lkm.cmd_type = LTTNG_CONSUMER_ADD_CHANNEL;
441 lkm.u.channel.channel_key = channel->fd;
442 lkm.u.channel.max_sb_size = channel->channel->attr.subbuf_size;
443 lkm.u.channel.mmap_len = 0; /* for kernel */
2bdd86d4 444 DBG("Sending channel %d to consumer", lkm.u.channel.channel_key);
3bd1e081 445 ret = lttcomm_send_unix_sock(sock, &lkm, sizeof(lkm));
f3ed775e 446 if (ret < 0) {
3bd1e081 447 perror("send consumer channel");
f3ed775e
DG
448 goto error;
449 }
450
3bd1e081 451 /* Send streams */
7a485870 452 cds_list_for_each_entry(stream, &channel->stream_list.head, list) {
3bd1e081
MD
453 if (!stream->fd) {
454 continue;
455 }
456 lkm.cmd_type = LTTNG_CONSUMER_ADD_STREAM;
457 lkm.u.stream.channel_key = channel->fd;
458 lkm.u.stream.stream_key = stream->fd;
459 lkm.u.stream.state = stream->state;
460 lkm.u.stream.output = channel->channel->attr.output;
461 lkm.u.stream.mmap_len = 0; /* for kernel */
462 strncpy(lkm.u.stream.path_name, stream->pathname, PATH_MAX - 1);
463 lkm.u.stream.path_name[PATH_MAX - 1] = '\0';
464 DBG("Sending stream %d to consumer", lkm.u.stream.stream_key);
465 ret = lttcomm_send_unix_sock(sock, &lkm, sizeof(lkm));
466 if (ret < 0) {
467 perror("send consumer stream");
468 goto error;
469 }
470 ret = lttcomm_send_fds_unix_sock(sock, &stream->fd, 1);
471 if (ret < 0) {
472 perror("send consumer stream ancillary data");
473 goto error;
f3ed775e
DG
474 }
475 }
476
3bd1e081 477 DBG("consumer channel streams sent");
f3ed775e
DG
478
479 return 0;
480
481error:
482 return ret;
483}
484
485/*
d063d709 486 * Send all stream fds of the kernel session to the consumer.
f3ed775e 487 */
2bdd86d4 488static int send_kconsumer_session_streams(struct consumer_data *consumer_data,
3bd1e081 489 struct ltt_kernel_session *session)
f3ed775e
DG
490{
491 int ret;
492 struct ltt_kernel_channel *chan;
3bd1e081
MD
493 struct lttcomm_consumer_msg lkm;
494 int sock = session->consumer_fd;
7a485870
DG
495
496 DBG("Sending metadata stream fd");
497
2bdd86d4 498 /* Extra protection. It's NOT supposed to be set to 0 at this point */
d9800920 499 if (session->consumer_fd == 0) {
3bd1e081 500 session->consumer_fd = consumer_data->cmd_sock;
d9800920
DG
501 }
502
7a485870 503 if (session->metadata_stream_fd != 0) {
3bd1e081
MD
504 /* Send metadata channel fd */
505 lkm.cmd_type = LTTNG_CONSUMER_ADD_CHANNEL;
506 lkm.u.channel.channel_key = session->metadata->fd;
507 lkm.u.channel.max_sb_size = session->metadata->conf->attr.subbuf_size;
508 lkm.u.channel.mmap_len = 0; /* for kernel */
509 DBG("Sending metadata channel %d to consumer", lkm.u.stream.stream_key);
510 ret = lttcomm_send_unix_sock(sock, &lkm, sizeof(lkm));
511 if (ret < 0) {
512 perror("send consumer channel");
513 goto error;
514 }
515
516 /* Send metadata stream fd */
517 lkm.cmd_type = LTTNG_CONSUMER_ADD_STREAM;
518 lkm.u.stream.channel_key = session->metadata->fd;
519 lkm.u.stream.stream_key = session->metadata_stream_fd;
520 lkm.u.stream.state = LTTNG_CONSUMER_ACTIVE_STREAM;
521 lkm.u.stream.output = DEFAULT_KERNEL_CHANNEL_OUTPUT;
522 lkm.u.stream.mmap_len = 0; /* for kernel */
523 strncpy(lkm.u.stream.path_name, session->metadata->pathname, PATH_MAX - 1);
524 lkm.u.stream.path_name[PATH_MAX - 1] = '\0';
525 DBG("Sending metadata stream %d to consumer", lkm.u.stream.stream_key);
526 ret = lttcomm_send_unix_sock(sock, &lkm, sizeof(lkm));
527 if (ret < 0) {
528 perror("send consumer stream");
529 goto error;
530 }
531 ret = lttcomm_send_fds_unix_sock(sock, &session->metadata_stream_fd, 1);
7a485870 532 if (ret < 0) {
3bd1e081 533 perror("send consumer stream");
7a485870
DG
534 goto error;
535 }
536 }
f3ed775e 537
f3ed775e 538 cds_list_for_each_entry(chan, &session->channel_list.head, list) {
2bdd86d4
MD
539 ret = send_kconsumer_channel_streams(consumer_data, sock, chan);
540 if (ret < 0) {
541 goto error;
542 }
543 }
544
545 DBG("consumer fds (metadata and channel streams) sent");
546
547 return 0;
548
549error:
550 return ret;
551}
552
fac6795d 553/*
0fdd1e2c 554 * Notify UST applications using the shm mmap futex.
fac6795d 555 */
0fdd1e2c 556static int notify_ust_apps(int active)
fac6795d 557{
0fdd1e2c 558 char *wait_shm_mmap;
fac6795d 559
0fdd1e2c 560 DBG("Notifying applications of session daemon state: %d", active);
e07ae692 561
0fdd1e2c
DG
562 /* See shm.c for this call implying mmap, shm and futex calls */
563 wait_shm_mmap = shm_ust_get_mmap(wait_shm_path, is_root);
564 if (wait_shm_mmap == NULL) {
fac6795d
DG
565 goto error;
566 }
567
0fdd1e2c
DG
568 /* Wake waiting process */
569 futex_wait_update((int32_t *) wait_shm_mmap, active);
570
571 /* Apps notified successfully */
572 return 0;
fac6795d
DG
573
574error:
0fdd1e2c 575 return -1;
fac6795d
DG
576}
577
e065084a 578/*
d063d709
DG
579 * Setup the outgoing data buffer for the response (llm) by allocating the
580 * right amount of memory and copying the original information from the lsm
581 * structure.
ca95a216 582 *
d063d709 583 * Return total size of the buffer pointed by buf.
ca95a216 584 */
5461b305 585static int setup_lttng_msg(struct command_ctx *cmd_ctx, size_t size)
ca95a216 586{
f3ed775e 587 int ret, buf_size;
ca95a216 588
f3ed775e 589 buf_size = size;
5461b305
DG
590
591 cmd_ctx->llm = malloc(sizeof(struct lttcomm_lttng_msg) + buf_size);
592 if (cmd_ctx->llm == NULL) {
ca95a216 593 perror("malloc");
5461b305 594 ret = -ENOMEM;
ca95a216
DG
595 goto error;
596 }
597
5461b305
DG
598 /* Copy common data */
599 cmd_ctx->llm->cmd_type = cmd_ctx->lsm->cmd_type;
9f19cc17 600 cmd_ctx->llm->pid = cmd_ctx->lsm->domain.attr.pid;
5461b305 601
5461b305
DG
602 cmd_ctx->llm->data_size = size;
603 cmd_ctx->lttng_msg_size = sizeof(struct lttcomm_lttng_msg) + buf_size;
604
ca95a216
DG
605 return buf_size;
606
607error:
608 return ret;
609}
610
7a485870 611/*
5eb91c98 612 * Update the kernel poll set of all channel fd available over all tracing
d063d709 613 * session. Add the wakeup pipe at the end of the set.
7a485870 614 */
5eb91c98 615static int update_kernel_poll(struct lttng_poll_event *events)
7a485870 616{
5eb91c98 617 int ret;
7a485870
DG
618 struct ltt_session *session;
619 struct ltt_kernel_channel *channel;
620
5eb91c98 621 DBG("Updating kernel poll set");
7a485870 622
54d01ffb 623 session_lock_list();
b5541356 624 cds_list_for_each_entry(session, &session_list_ptr->head, list) {
54d01ffb 625 session_lock(session);
7a485870 626 if (session->kernel_session == NULL) {
54d01ffb 627 session_unlock(session);
7a485870
DG
628 continue;
629 }
7a485870 630
54d01ffb
DG
631 cds_list_for_each_entry(channel,
632 &session->kernel_session->channel_list.head, list) {
5eb91c98
DG
633 /* Add channel fd to the kernel poll set */
634 ret = lttng_poll_add(events, channel->fd, LPOLLIN | LPOLLRDNORM);
635 if (ret < 0) {
54d01ffb 636 session_unlock(session);
5eb91c98
DG
637 goto error;
638 }
639 DBG("Channel fd %d added to kernel set", channel->fd);
7a485870 640 }
54d01ffb 641 session_unlock(session);
7a485870 642 }
54d01ffb 643 session_unlock_list();
7a485870 644
5eb91c98 645 return 0;
7a485870
DG
646
647error:
54d01ffb 648 session_unlock_list();
7a485870
DG
649 return -1;
650}
651
652/*
54d01ffb 653 * Find the channel fd from 'fd' over all tracing session. When found, check
d063d709 654 * for new channel stream and send those stream fds to the kernel consumer.
7a485870 655 *
d063d709 656 * Useful for CPU hotplug feature.
7a485870 657 */
2bdd86d4 658static int update_kernel_stream(struct consumer_data *consumer_data, int fd)
7a485870
DG
659{
660 int ret = 0;
661 struct ltt_session *session;
662 struct ltt_kernel_channel *channel;
663
664 DBG("Updating kernel streams for channel fd %d", fd);
665
54d01ffb 666 session_lock_list();
b5541356 667 cds_list_for_each_entry(session, &session_list_ptr->head, list) {
54d01ffb 668 session_lock(session);
7a485870 669 if (session->kernel_session == NULL) {
54d01ffb 670 session_unlock(session);
7a485870
DG
671 continue;
672 }
d9800920
DG
673
674 /* This is not suppose to be 0 but this is an extra security check */
675 if (session->kernel_session->consumer_fd == 0) {
3bd1e081 676 session->kernel_session->consumer_fd = consumer_data->cmd_sock;
d9800920
DG
677 }
678
5eb91c98
DG
679 cds_list_for_each_entry(channel,
680 &session->kernel_session->channel_list.head, list) {
7a485870
DG
681 if (channel->fd == fd) {
682 DBG("Channel found, updating kernel streams");
683 ret = kernel_open_channel_stream(channel);
684 if (ret < 0) {
b3c750d2 685 goto error;
7a485870 686 }
d9800920 687
7a485870 688 /*
5eb91c98
DG
689 * Have we already sent fds to the consumer? If yes, it means
690 * that tracing is started so it is safe to send our updated
691 * stream fds.
7a485870 692 */
3bd1e081 693 if (session->kernel_session->consumer_fds_sent == 1) {
2bdd86d4 694 ret = send_kconsumer_channel_streams(consumer_data,
5eb91c98 695 session->kernel_session->consumer_fd, channel);
7a485870 696 if (ret < 0) {
b3c750d2 697 goto error;
7a485870
DG
698 }
699 }
b3c750d2 700 goto error;
7a485870
DG
701 }
702 }
54d01ffb 703 session_unlock(session);
7a485870 704 }
54d01ffb 705 session_unlock_list();
b3c750d2 706 return ret;
7a485870 707
b3c750d2 708error:
54d01ffb
DG
709 session_unlock(session);
710 session_unlock_list();
7a485870
DG
711 return ret;
712}
713
487cf67c
DG
714/*
715 * For each tracing session, update newly registered apps.
716 */
717static void update_ust_app(int app_sock)
718{
719 struct ltt_session *sess, *stmp;
720
721 /* For all tracing session(s) */
722 cds_list_for_each_entry_safe(sess, stmp, &session_list_ptr->head, list) {
723 ust_app_global_update(sess->ust_session, app_sock);
724 }
725}
726
7a485870 727/*
d063d709 728 * This thread manage event coming from the kernel.
7a485870 729 *
d063d709
DG
730 * Features supported in this thread:
731 * -) CPU Hotplug
7a485870
DG
732 */
733static void *thread_manage_kernel(void *data)
734{
5eb91c98
DG
735 int ret, i, pollfd, update_poll_flag = 1;
736 uint32_t revents, nb_fd;
7a485870 737 char tmp;
5eb91c98 738 struct lttng_poll_event events;
7a485870
DG
739
740 DBG("Thread manage kernel started");
741
5eb91c98
DG
742 ret = create_thread_poll_set(&events, 2);
743 if (ret < 0) {
744 goto error;
745 }
746
747 ret = lttng_poll_add(&events, kernel_poll_pipe[0], LPOLLIN);
748 if (ret < 0) {
749 goto error;
750 }
751
7a485870
DG
752 while (1) {
753 if (update_poll_flag == 1) {
5f822d0a
DG
754 /*
755 * Reset number of fd in the poll set. Always 2 since there is the thread
756 * quit pipe and the kernel pipe.
757 */
758 events.nb_fd = 2;
759
5eb91c98
DG
760 ret = update_kernel_poll(&events);
761 if (ret < 0) {
7a485870
DG
762 goto error;
763 }
764 update_poll_flag = 0;
765 }
766
5eb91c98
DG
767 nb_fd = LTTNG_POLL_GETNB(&events);
768
769 DBG("Thread kernel polling on %d fds", nb_fd);
770
771 /* Zeroed the poll events */
772 lttng_poll_reset(&events);
7a485870
DG
773
774 /* Poll infinite value of time */
5eb91c98 775 ret = lttng_poll_wait(&events, -1);
7a485870 776 if (ret < 0) {
7a485870
DG
777 goto error;
778 } else if (ret == 0) {
779 /* Should not happen since timeout is infinite */
85611738
DG
780 ERR("Return value of poll is 0 with an infinite timeout.\n"
781 "This should not have happened! Continuing...");
7a485870
DG
782 continue;
783 }
784
5eb91c98
DG
785 for (i = 0; i < nb_fd; i++) {
786 /* Fetch once the poll data */
787 revents = LTTNG_POLL_GETEV(&events, i);
788 pollfd = LTTNG_POLL_GETFD(&events, i);
7a485870 789
5eb91c98
DG
790 /* Thread quit pipe has been closed. Killing thread. */
791 ret = check_thread_quit_pipe(pollfd, revents);
792 if (ret) {
793 goto error;
794 }
7a485870 795
5eb91c98
DG
796 /* Check for data on kernel pipe */
797 if (pollfd == kernel_poll_pipe[0] && (revents & LPOLLIN)) {
798 ret = read(kernel_poll_pipe[0], &tmp, 1);
799 update_poll_flag = 1;
800 continue;
801 } else {
802 /*
803 * New CPU detected by the kernel. Adding kernel stream to
804 * kernel session and updating the kernel consumer
805 */
806 if (revents & LPOLLIN) {
2bdd86d4 807 ret = update_kernel_stream(&kconsumer_data, pollfd);
5eb91c98
DG
808 if (ret < 0) {
809 continue;
810 }
811 break;
812 /*
813 * TODO: We might want to handle the LPOLLERR | LPOLLHUP
814 * and unregister kernel stream at this point.
815 */
7a485870 816 }
7a485870
DG
817 }
818 }
819 }
820
821error:
822 DBG("Kernel thread dying");
273ea72c
DG
823 close(kernel_poll_pipe[0]);
824 close(kernel_poll_pipe[1]);
5eb91c98
DG
825
826 lttng_poll_clean(&events);
827
7a485870
DG
828 return NULL;
829}
830
1d4b027a 831/*
3bd1e081 832 * This thread manage the consumer error sent back to the session daemon.
1d4b027a 833 */
3bd1e081 834static void *thread_manage_consumer(void *data)
1d4b027a 835{
5eb91c98
DG
836 int sock = 0, i, ret, pollfd;
837 uint32_t revents, nb_fd;
1d4b027a 838 enum lttcomm_return_code code;
5eb91c98 839 struct lttng_poll_event events;
3bd1e081 840 struct consumer_data *consumer_data = data;
1d4b027a 841
3bd1e081 842 DBG("[thread] Manage consumer started");
1d4b027a 843
3bd1e081 844 ret = lttcomm_listen_unix_sock(consumer_data->err_sock);
1d4b027a
DG
845 if (ret < 0) {
846 goto error;
847 }
848
5eb91c98
DG
849 /*
850 * Pass 2 as size here for the thread quit pipe and kconsumerd_err_sock.
851 * Nothing more will be added to this poll set.
852 */
853 ret = create_thread_poll_set(&events, 2);
854 if (ret < 0) {
855 goto error;
856 }
273ea72c 857
3bd1e081 858 ret = lttng_poll_add(&events, consumer_data->err_sock, LPOLLIN | LPOLLRDHUP);
5eb91c98
DG
859 if (ret < 0) {
860 goto error;
861 }
862
863 nb_fd = LTTNG_POLL_GETNB(&events);
273ea72c
DG
864
865 /* Inifinite blocking call, waiting for transmission */
5eb91c98 866 ret = lttng_poll_wait(&events, -1);
273ea72c 867 if (ret < 0) {
273ea72c
DG
868 goto error;
869 }
870
5eb91c98
DG
871 for (i = 0; i < nb_fd; i++) {
872 /* Fetch once the poll data */
873 revents = LTTNG_POLL_GETEV(&events, i);
874 pollfd = LTTNG_POLL_GETFD(&events, i);
875
876 /* Thread quit pipe has been closed. Killing thread. */
877 ret = check_thread_quit_pipe(pollfd, revents);
878 if (ret) {
879 goto error;
880 }
881
882 /* Event on the registration socket */
3bd1e081 883 if (pollfd == consumer_data->err_sock) {
5eb91c98 884 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
3bd1e081 885 ERR("consumer err socket poll error");
5eb91c98
DG
886 goto error;
887 }
888 }
273ea72c
DG
889 }
890
3bd1e081 891 sock = lttcomm_accept_unix_sock(consumer_data->err_sock);
1d4b027a
DG
892 if (sock < 0) {
893 goto error;
894 }
895
3bd1e081 896 DBG2("Receiving code from consumer err_sock");
ee0b0061 897
712ea556 898 /* Getting status code from kconsumerd */
54d01ffb
DG
899 ret = lttcomm_recv_unix_sock(sock, &code,
900 sizeof(enum lttcomm_return_code));
1d4b027a
DG
901 if (ret <= 0) {
902 goto error;
903 }
904
3bd1e081
MD
905 if (code == CONSUMERD_COMMAND_SOCK_READY) {
906 consumer_data->cmd_sock =
907 lttcomm_connect_unix_sock(consumer_data->cmd_unix_sock_path);
908 if (consumer_data->cmd_sock < 0) {
909 sem_post(&consumer_data->sem);
48842b30 910 PERROR("consumer connect");
1d4b027a
DG
911 goto error;
912 }
913 /* Signal condition to tell that the kconsumerd is ready */
3bd1e081
MD
914 sem_post(&consumer_data->sem);
915 DBG("consumer command socket ready");
1d4b027a 916 } else {
3bd1e081 917 ERR("consumer error when waiting for SOCK_READY : %s",
1d4b027a
DG
918 lttcomm_get_readable_code(-code));
919 goto error;
920 }
921
54d01ffb 922 /* Remove the kconsumerd error sock since we've established a connexion */
3bd1e081 923 ret = lttng_poll_del(&events, consumer_data->err_sock);
72079cae 924 if (ret < 0) {
72079cae
DG
925 goto error;
926 }
927
5eb91c98
DG
928 ret = lttng_poll_add(&events, sock, LPOLLIN | LPOLLRDHUP);
929 if (ret < 0) {
72079cae 930 goto error;
5eb91c98
DG
931 }
932
933 /* Update number of fd */
934 nb_fd = LTTNG_POLL_GETNB(&events);
935
936 /* Inifinite blocking call, waiting for transmission */
937 ret = lttng_poll_wait(&events, -1);
938 if (ret < 0) {
72079cae
DG
939 goto error;
940 }
941
5eb91c98
DG
942 for (i = 0; i < nb_fd; i++) {
943 /* Fetch once the poll data */
944 revents = LTTNG_POLL_GETEV(&events, i);
945 pollfd = LTTNG_POLL_GETFD(&events, i);
946
947 /* Thread quit pipe has been closed. Killing thread. */
948 ret = check_thread_quit_pipe(pollfd, revents);
949 if (ret) {
950 goto error;
951 }
952
953 /* Event on the kconsumerd socket */
954 if (pollfd == sock) {
955 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
3bd1e081 956 ERR("consumer err socket second poll error");
5eb91c98
DG
957 goto error;
958 }
959 }
960 }
961
712ea556 962 /* Wait for any kconsumerd error */
54d01ffb
DG
963 ret = lttcomm_recv_unix_sock(sock, &code,
964 sizeof(enum lttcomm_return_code));
712ea556 965 if (ret <= 0) {
3bd1e081 966 ERR("consumer closed the command socket");
712ea556 967 goto error;
6f61d021 968 }
1d4b027a 969
3bd1e081 970 ERR("consumer return code : %s", lttcomm_get_readable_code(-code));
712ea556 971
1d4b027a 972error:
3bd1e081
MD
973 DBG("consumer thread dying");
974 close(consumer_data->err_sock);
975 close(consumer_data->cmd_sock);
5eb91c98 976 close(sock);
273ea72c 977
3bd1e081
MD
978 unlink(consumer_data->err_unix_sock_path);
979 unlink(consumer_data->cmd_unix_sock_path);
980 consumer_data->pid = 0;
1d4b027a 981
5eb91c98 982 lttng_poll_clean(&events);
0177d773 983
5eb91c98 984 return NULL;
099e26bd
DG
985}
986
099e26bd
DG
987/*
988 * This thread manage application communication.
1d4b027a
DG
989 */
990static void *thread_manage_apps(void *data)
099e26bd 991{
5eb91c98
DG
992 int i, ret, pollfd;
993 uint32_t revents, nb_fd;
099e26bd 994 struct ust_command ust_cmd;
5eb91c98 995 struct lttng_poll_event events;
099e26bd
DG
996
997 DBG("[thread] Manage application started");
998
f6a9efaa
DG
999 rcu_register_thread();
1000 rcu_thread_online();
1001
5eb91c98
DG
1002 ret = create_thread_poll_set(&events, 2);
1003 if (ret < 0) {
1004 goto error;
1005 }
099e26bd 1006
5eb91c98
DG
1007 ret = lttng_poll_add(&events, apps_cmd_pipe[0], LPOLLIN | LPOLLRDHUP);
1008 if (ret < 0) {
1009 goto error;
1010 }
099e26bd 1011
5eb91c98
DG
1012 while (1) {
1013 /* Zeroed the events structure */
1014 lttng_poll_reset(&events);
0177d773 1015
5eb91c98 1016 nb_fd = LTTNG_POLL_GETNB(&events);
099e26bd
DG
1017
1018 DBG("Apps thread polling on %d fds", nb_fd);
1019
1020 /* Inifinite blocking call, waiting for transmission */
5eb91c98 1021 ret = lttng_poll_wait(&events, -1);
099e26bd 1022 if (ret < 0) {
099e26bd
DG
1023 goto error;
1024 }
1025
5eb91c98
DG
1026 for (i = 0; i < nb_fd; i++) {
1027 /* Fetch once the poll data */
1028 revents = LTTNG_POLL_GETEV(&events, i);
1029 pollfd = LTTNG_POLL_GETFD(&events, i);
1030
1031 /* Thread quit pipe has been closed. Killing thread. */
1032 ret = check_thread_quit_pipe(pollfd, revents);
1033 if (ret) {
099e26bd 1034 goto error;
5eb91c98 1035 }
099e26bd 1036
5eb91c98
DG
1037 /* Inspect the apps cmd pipe */
1038 if (pollfd == apps_cmd_pipe[0]) {
1039 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
1040 ERR("Apps command pipe error");
0177d773 1041 goto error;
5eb91c98
DG
1042 } else if (revents & LPOLLIN) {
1043 /* Empty pipe */
1044 ret = read(apps_cmd_pipe[0], &ust_cmd, sizeof(ust_cmd));
1045 if (ret < 0 || ret < sizeof(ust_cmd)) {
1046 perror("read apps cmd pipe");
1047 goto error;
1048 }
099e26bd 1049
5eb91c98 1050 /* Register applicaton to the session daemon */
56fff090 1051 ret = ust_app_register(&ust_cmd.reg_msg,
54d01ffb 1052 ust_cmd.sock);
5eb91c98
DG
1053 if (ret < 0) {
1054 /* Only critical ENOMEM error can be returned here */
1055 goto error;
1056 }
1057
1058 ret = ustctl_register_done(ust_cmd.sock);
1059 if (ret < 0) {
1060 /*
1061 * If the registration is not possible, we simply
1062 * unregister the apps and continue
1063 */
56fff090 1064 ust_app_unregister(ust_cmd.sock);
5eb91c98
DG
1065 } else {
1066 /*
1067 * We just need here to monitor the close of the UST
1068 * socket and poll set monitor those by default.
1069 */
1070 ret = lttng_poll_add(&events, ust_cmd.sock, 0);
1071 if (ret < 0) {
1072 goto error;
1073 }
1074
54d01ffb
DG
1075 DBG("Apps with sock %d added to poll set",
1076 ust_cmd.sock);
5eb91c98 1077 }
487cf67c
DG
1078
1079 /*
1080 * Add channel(s) and event(s) to newly registered apps
1081 * from lttng global UST domain.
1082 */
1083 update_ust_app(ust_cmd.sock);
5eb91c98 1084 break;
0177d773 1085 }
5eb91c98
DG
1086 } else {
1087 /*
54d01ffb
DG
1088 * At this point, we know that a registered application made
1089 * the event at poll_wait.
5eb91c98
DG
1090 */
1091 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
1092 /* Removing from the poll set */
1093 ret = lttng_poll_del(&events, pollfd);
1094 if (ret < 0) {
1095 goto error;
1096 }
099e26bd 1097
5eb91c98 1098 /* Socket closed */
56fff090 1099 ust_app_unregister(pollfd);
5eb91c98
DG
1100 break;
1101 }
099e26bd
DG
1102 }
1103 }
099e26bd
DG
1104 }
1105
1106error:
1107 DBG("Application communication apps dying");
1108 close(apps_cmd_pipe[0]);
1109 close(apps_cmd_pipe[1]);
1110
5eb91c98 1111 lttng_poll_clean(&events);
099e26bd 1112
f6a9efaa
DG
1113 rcu_thread_offline();
1114 rcu_unregister_thread();
099e26bd
DG
1115 return NULL;
1116}
1117
1118/*
1119 * Dispatch request from the registration threads to the application
1120 * communication thread.
1121 */
1122static void *thread_dispatch_ust_registration(void *data)
1123{
1124 int ret;
1125 struct cds_wfq_node *node;
1126 struct ust_command *ust_cmd = NULL;
1127
1128 DBG("[thread] Dispatch UST command started");
1129
1130 while (!dispatch_thread_exit) {
1131 /* Atomically prepare the queue futex */
1132 futex_nto1_prepare(&ust_cmd_queue.futex);
1133
1134 do {
1135 /* Dequeue command for registration */
1136 node = cds_wfq_dequeue_blocking(&ust_cmd_queue.queue);
1137 if (node == NULL) {
00a17c97 1138 DBG("Woken up but nothing in the UST command queue");
099e26bd
DG
1139 /* Continue thread execution */
1140 break;
1141 }
1142
1143 ust_cmd = caa_container_of(node, struct ust_command, node);
1144
2f50c8a3
DG
1145 DBG("Dispatching UST registration pid:%d ppid:%d uid:%d"
1146 " gid:%d sock:%d name:%s (version %d.%d)",
1147 ust_cmd->reg_msg.pid, ust_cmd->reg_msg.ppid,
1148 ust_cmd->reg_msg.uid, ust_cmd->reg_msg.gid,
1149 ust_cmd->sock, ust_cmd->reg_msg.name,
1150 ust_cmd->reg_msg.major, ust_cmd->reg_msg.minor);
099e26bd
DG
1151 /*
1152 * Inform apps thread of the new application registration. This
1153 * call is blocking so we can be assured that the data will be read
1154 * at some point in time or wait to the end of the world :)
1155 */
1156 ret = write(apps_cmd_pipe[1], ust_cmd,
1157 sizeof(struct ust_command));
1158 if (ret < 0) {
1159 perror("write apps cmd pipe");
1160 if (errno == EBADF) {
1161 /*
1162 * We can't inform the application thread to process
1163 * registration. We will exit or else application
1164 * registration will not occur and tracing will never
1165 * start.
1166 */
1167 goto error;
1168 }
1169 }
1170 free(ust_cmd);
1171 } while (node != NULL);
1172
1173 /* Futex wait on queue. Blocking call on futex() */
1174 futex_nto1_wait(&ust_cmd_queue.futex);
1175 }
1176
1177error:
1178 DBG("Dispatch thread dying");
1179 return NULL;
1180}
1181
1182/*
1183 * This thread manage application registration.
1184 */
1185static void *thread_registration_apps(void *data)
1d4b027a 1186{
5eb91c98
DG
1187 int sock = 0, i, ret, pollfd;
1188 uint32_t revents, nb_fd;
1189 struct lttng_poll_event events;
099e26bd
DG
1190 /*
1191 * Get allocated in this thread, enqueued to a global queue, dequeued and
1192 * freed in the manage apps thread.
1193 */
1194 struct ust_command *ust_cmd = NULL;
1d4b027a 1195
099e26bd 1196 DBG("[thread] Manage application registration started");
1d4b027a
DG
1197
1198 ret = lttcomm_listen_unix_sock(apps_sock);
1199 if (ret < 0) {
1200 goto error;
1201 }
1202
5eb91c98
DG
1203 /*
1204 * Pass 2 as size here for the thread quit pipe and apps socket. Nothing
1205 * more will be added to this poll set.
1206 */
1207 ret = create_thread_poll_set(&events, 2);
1208 if (ret < 0) {
1209 goto error;
1210 }
273ea72c 1211
5eb91c98
DG
1212 /* Add the application registration socket */
1213 ret = lttng_poll_add(&events, apps_sock, LPOLLIN | LPOLLRDHUP);
1214 if (ret < 0) {
1215 goto error;
1216 }
273ea72c 1217
1d4b027a 1218 /* Notify all applications to register */
0fdd1e2c
DG
1219 ret = notify_ust_apps(1);
1220 if (ret < 0) {
1221 ERR("Failed to notify applications or create the wait shared memory.\n"
54d01ffb
DG
1222 "Execution continues but there might be problem for already\n"
1223 "running applications that wishes to register.");
0fdd1e2c 1224 }
1d4b027a
DG
1225
1226 while (1) {
1227 DBG("Accepting application registration");
273ea72c 1228
5eb91c98
DG
1229 nb_fd = LTTNG_POLL_GETNB(&events);
1230
273ea72c 1231 /* Inifinite blocking call, waiting for transmission */
5eb91c98 1232 ret = lttng_poll_wait(&events, -1);
273ea72c 1233 if (ret < 0) {
273ea72c
DG
1234 goto error;
1235 }
1236
5eb91c98
DG
1237 for (i = 0; i < nb_fd; i++) {
1238 /* Fetch once the poll data */
1239 revents = LTTNG_POLL_GETEV(&events, i);
1240 pollfd = LTTNG_POLL_GETFD(&events, i);
273ea72c 1241
5eb91c98
DG
1242 /* Thread quit pipe has been closed. Killing thread. */
1243 ret = check_thread_quit_pipe(pollfd, revents);
1244 if (ret) {
90014c57
DG
1245 goto error;
1246 }
1d4b027a 1247
5eb91c98
DG
1248 /* Event on the registration socket */
1249 if (pollfd == apps_sock) {
1250 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
1251 ERR("Register apps socket poll error");
1252 goto error;
1253 } else if (revents & LPOLLIN) {
1254 sock = lttcomm_accept_unix_sock(apps_sock);
1255 if (sock < 0) {
1256 goto error;
1257 }
099e26bd 1258
5eb91c98
DG
1259 /* Create UST registration command for enqueuing */
1260 ust_cmd = malloc(sizeof(struct ust_command));
1261 if (ust_cmd == NULL) {
1262 perror("ust command malloc");
1263 goto error;
1264 }
1d4b027a 1265
5eb91c98
DG
1266 /*
1267 * Using message-based transmissions to ensure we don't
1268 * have to deal with partially received messages.
1269 */
1270 ret = lttcomm_recv_unix_sock(sock, &ust_cmd->reg_msg,
1271 sizeof(struct ust_register_msg));
1272 if (ret < 0 || ret < sizeof(struct ust_register_msg)) {
1273 if (ret < 0) {
1274 perror("lttcomm_recv_unix_sock register apps");
1275 } else {
1276 ERR("Wrong size received on apps register");
1277 }
1278 free(ust_cmd);
1279 close(sock);
1280 continue;
1281 }
099e26bd 1282
5eb91c98 1283 ust_cmd->sock = sock;
099e26bd 1284
5eb91c98
DG
1285 DBG("UST registration received with pid:%d ppid:%d uid:%d"
1286 " gid:%d sock:%d name:%s (version %d.%d)",
1287 ust_cmd->reg_msg.pid, ust_cmd->reg_msg.ppid,
1288 ust_cmd->reg_msg.uid, ust_cmd->reg_msg.gid,
1289 ust_cmd->sock, ust_cmd->reg_msg.name,
1290 ust_cmd->reg_msg.major, ust_cmd->reg_msg.minor);
54d01ffb 1291
5eb91c98
DG
1292 /*
1293 * Lock free enqueue the registration request. The red pill
54d01ffb 1294 * has been taken! This apps will be part of the *system*.
5eb91c98
DG
1295 */
1296 cds_wfq_enqueue(&ust_cmd_queue.queue, &ust_cmd->node);
1297
1298 /*
1299 * Wake the registration queue futex. Implicit memory
1300 * barrier with the exchange in cds_wfq_enqueue.
1301 */
1302 futex_nto1_wake(&ust_cmd_queue.futex);
1303 }
1304 }
90014c57 1305 }
1d4b027a
DG
1306 }
1307
1308error:
0fdd1e2c
DG
1309 DBG("UST Registration thread dying");
1310
1311 /* Notify that the registration thread is gone */
1312 notify_ust_apps(0);
1313
1314 close(apps_sock);
1315 close(sock);
273ea72c 1316 unlink(apps_unix_sock_path);
0fdd1e2c 1317
5eb91c98
DG
1318 lttng_poll_clean(&events);
1319
1d4b027a
DG
1320 return NULL;
1321}
1322
8c0faa1d 1323/*
3bd1e081 1324 * Start the thread_manage_consumer. This must be done after a lttng-consumerd
d063d709 1325 * exec or it will fails.
8c0faa1d 1326 */
3bd1e081 1327static int spawn_consumer_thread(struct consumer_data *consumer_data)
8c0faa1d
DG
1328{
1329 int ret;
ee0b0061
DG
1330 struct timespec timeout;
1331
1332 timeout.tv_sec = DEFAULT_SEM_WAIT_TIMEOUT;
1333 timeout.tv_nsec = 0;
8c0faa1d
DG
1334
1335 /* Setup semaphore */
3bd1e081 1336 ret = sem_init(&consumer_data->sem, 0, 0);
ee0b0061 1337 if (ret < 0) {
3bd1e081 1338 PERROR("sem_init consumer semaphore");
ee0b0061
DG
1339 goto error;
1340 }
8c0faa1d 1341
3bd1e081
MD
1342 ret = pthread_create(&consumer_data->thread, NULL,
1343 thread_manage_consumer, consumer_data);
8c0faa1d 1344 if (ret != 0) {
3bd1e081 1345 PERROR("pthread_create consumer");
ee0b0061 1346 ret = -1;
8c0faa1d
DG
1347 goto error;
1348 }
1349
ee0b0061
DG
1350 /* Get time for sem_timedwait absolute timeout */
1351 ret = clock_gettime(CLOCK_REALTIME, &timeout);
1352 if (ret < 0) {
3bd1e081 1353 PERROR("clock_gettime spawn consumer");
ee0b0061 1354 /* Infinite wait for the kconsumerd thread to be ready */
3bd1e081 1355 ret = sem_wait(&consumer_data->sem);
ee0b0061
DG
1356 } else {
1357 /* Normal timeout if the gettime was successful */
1358 timeout.tv_sec += DEFAULT_SEM_WAIT_TIMEOUT;
3bd1e081 1359 ret = sem_timedwait(&consumer_data->sem, &timeout);
ee0b0061 1360 }
8c0faa1d 1361
ee0b0061
DG
1362 if (ret < 0) {
1363 if (errno == ETIMEDOUT) {
1364 /*
1365 * Call has timed out so we kill the kconsumerd_thread and return
1366 * an error.
1367 */
3bd1e081
MD
1368 ERR("The consumer thread was never ready. Killing it");
1369 ret = pthread_cancel(consumer_data->thread);
ee0b0061 1370 if (ret < 0) {
3bd1e081 1371 PERROR("pthread_cancel consumer thread");
ee0b0061
DG
1372 }
1373 } else {
3bd1e081 1374 PERROR("semaphore wait failed consumer thread");
ee0b0061
DG
1375 }
1376 goto error;
1377 }
1378
3bd1e081
MD
1379 pthread_mutex_lock(&consumer_data->pid_mutex);
1380 if (consumer_data->pid == 0) {
712ea556 1381 ERR("Kconsumerd did not start");
3bd1e081 1382 pthread_mutex_unlock(&consumer_data->pid_mutex);
712ea556
DG
1383 goto error;
1384 }
3bd1e081 1385 pthread_mutex_unlock(&consumer_data->pid_mutex);
712ea556 1386
8c0faa1d
DG
1387 return 0;
1388
1389error:
1390 return ret;
1391}
1392
d9800920 1393/*
3bd1e081 1394 * Join consumer thread
d9800920 1395 */
3bd1e081 1396static int join_consumer_thread(struct consumer_data *consumer_data)
cf3af59e
MD
1397{
1398 void *status;
1399 int ret;
1400
3bd1e081
MD
1401 if (consumer_data->pid != 0) {
1402 ret = kill(consumer_data->pid, SIGTERM);
cf3af59e 1403 if (ret) {
3bd1e081 1404 ERR("Error killing consumer daemon");
cf3af59e
MD
1405 return ret;
1406 }
3bd1e081 1407 return pthread_join(consumer_data->thread, &status);
cf3af59e
MD
1408 } else {
1409 return 0;
1410 }
1411}
1412
8c0faa1d 1413/*
3bd1e081 1414 * Fork and exec a consumer daemon (consumerd).
8c0faa1d 1415 *
d063d709 1416 * Return pid if successful else -1.
8c0faa1d 1417 */
3bd1e081 1418static pid_t spawn_consumerd(struct consumer_data *consumer_data)
8c0faa1d
DG
1419{
1420 int ret;
1421 pid_t pid;
53086306 1422 const char *verbosity;
8c0faa1d 1423
3bd1e081 1424 DBG("Spawning consumerd");
c49dc785 1425
8c0faa1d
DG
1426 pid = fork();
1427 if (pid == 0) {
1428 /*
3bd1e081 1429 * Exec consumerd.
8c0faa1d 1430 */
3bd1e081 1431 if (opt_verbose > 1 || opt_verbose_consumer) {
53086306
DG
1432 verbosity = "--verbose";
1433 } else {
1434 verbosity = "--quiet";
1435 }
3bd1e081
MD
1436 switch (consumer_data->type) {
1437 case LTTNG_CONSUMER_KERNEL:
1438 execl(INSTALL_BIN_PATH "/lttng-consumerd",
1439 "lttng-consumerd", verbosity, "-k", NULL);
1440 break;
1441 case LTTNG_CONSUMER_UST:
1442 execl(INSTALL_BIN_PATH "/lttng-consumerd",
1443 "lttng-consumerd", verbosity, "-u", NULL);
1444 break;
1445 default:
1446 perror("unknown consumer type");
1447 exit(EXIT_FAILURE);
1448 }
8c0faa1d
DG
1449 if (errno != 0) {
1450 perror("kernel start consumer exec");
1451 }
1452 exit(EXIT_FAILURE);
1453 } else if (pid > 0) {
1454 ret = pid;
8c0faa1d 1455 } else {
3bd1e081 1456 perror("start consumer fork");
8c0faa1d 1457 ret = -errno;
8c0faa1d 1458 }
8c0faa1d
DG
1459 return ret;
1460}
1461
693bd40b 1462/*
3bd1e081 1463 * Spawn the consumerd daemon and session daemon thread.
693bd40b 1464 */
3bd1e081 1465static int start_consumerd(struct consumer_data *consumer_data)
693bd40b
DG
1466{
1467 int ret;
1468
3bd1e081
MD
1469 pthread_mutex_lock(&consumer_data->pid_mutex);
1470 if (consumer_data->pid != 0) {
1471 pthread_mutex_unlock(&consumer_data->pid_mutex);
c49dc785
DG
1472 goto end;
1473 }
693bd40b 1474
3bd1e081 1475 ret = spawn_consumerd(consumer_data);
c49dc785 1476 if (ret < 0) {
3bd1e081
MD
1477 ERR("Spawning consumerd failed");
1478 pthread_mutex_unlock(&consumer_data->pid_mutex);
c49dc785 1479 goto error;
693bd40b 1480 }
c49dc785 1481
3bd1e081
MD
1482 /* Setting up the consumer_data pid */
1483 consumer_data->pid = ret;
48842b30 1484 DBG2("Consumer pid %d", consumer_data->pid);
3bd1e081 1485 pthread_mutex_unlock(&consumer_data->pid_mutex);
693bd40b 1486
3bd1e081
MD
1487 DBG2("Spawning consumer control thread");
1488 ret = spawn_consumer_thread(consumer_data);
693bd40b 1489 if (ret < 0) {
3bd1e081 1490 ERR("Fatal error spawning consumer control thread");
693bd40b
DG
1491 goto error;
1492 }
1493
c49dc785 1494end:
693bd40b
DG
1495 return 0;
1496
1497error:
1498 return ret;
1499}
1500
b73401da 1501/*
d063d709 1502 * modprobe_kernel_modules
b73401da
DG
1503 */
1504static int modprobe_kernel_modules(void)
1505{
ab147185 1506 int ret = 0, i;
b73401da
DG
1507 char modprobe[256];
1508
ab147185
MD
1509 for (i = 0; i < ARRAY_SIZE(kernel_modules_list); i++) {
1510 ret = snprintf(modprobe, sizeof(modprobe),
1511 "/sbin/modprobe %s%s",
24b487b8 1512 kernel_modules_list[i].required ? "" : "-q ",
ab147185 1513 kernel_modules_list[i].name);
b73401da
DG
1514 if (ret < 0) {
1515 perror("snprintf modprobe");
1516 goto error;
1517 }
ab147185 1518 modprobe[sizeof(modprobe) - 1] = '\0';
b73401da 1519 ret = system(modprobe);
ab147185
MD
1520 if (ret == -1) {
1521 ERR("Unable to launch modprobe for module %s",
1522 kernel_modules_list[i].name);
1523 } else if (kernel_modules_list[i].required
d9800920 1524 && WEXITSTATUS(ret) != 0) {
ab147185
MD
1525 ERR("Unable to load module %s",
1526 kernel_modules_list[i].name);
1527 } else {
1528 DBG("Modprobe successfully %s",
1529 kernel_modules_list[i].name);
1530 }
1531 }
1532
1533error:
1534 return ret;
1535}
1536
b73401da 1537/*
d063d709 1538 * mount_debugfs
b73401da
DG
1539 */
1540static int mount_debugfs(char *path)
1541{
1542 int ret;
1543 char *type = "debugfs";
1544
996b65c8 1545 ret = mkdir_recursive(path, S_IRWXU | S_IRWXG, geteuid(), getegid());
b73401da 1546 if (ret < 0) {
7272acf5 1547 PERROR("Cannot create debugfs path");
b73401da
DG
1548 goto error;
1549 }
1550
1551 ret = mount(type, path, type, 0, NULL);
1552 if (ret < 0) {
7272acf5 1553 PERROR("Cannot mount debugfs");
b73401da
DG
1554 goto error;
1555 }
1556
1557 DBG("Mounted debugfs successfully at %s", path);
1558
1559error:
1560 return ret;
1561}
1562
8c0faa1d 1563/*
d063d709 1564 * Setup necessary data for kernel tracer action.
8c0faa1d 1565 */
f3ed775e 1566static void init_kernel_tracer(void)
8c0faa1d 1567{
b73401da
DG
1568 int ret;
1569 char *proc_mounts = "/proc/mounts";
1570 char line[256];
684d34d2 1571 char *debugfs_path = NULL, *lttng_path = NULL;
b73401da
DG
1572 FILE *fp;
1573
1574 /* Detect debugfs */
1575 fp = fopen(proc_mounts, "r");
1576 if (fp == NULL) {
1577 ERR("Unable to probe %s", proc_mounts);
1578 goto error;
1579 }
1580
1581 while (fgets(line, sizeof(line), fp) != NULL) {
1582 if (strstr(line, "debugfs") != NULL) {
1583 /* Remove first string */
1584 strtok(line, " ");
1585 /* Dup string here so we can reuse line later on */
1586 debugfs_path = strdup(strtok(NULL, " "));
1587 DBG("Got debugfs path : %s", debugfs_path);
1588 break;
1589 }
1590 }
1591
1592 fclose(fp);
1593
1594 /* Mount debugfs if needded */
1595 if (debugfs_path == NULL) {
1596 ret = asprintf(&debugfs_path, "/mnt/debugfs");
1597 if (ret < 0) {
1598 perror("asprintf debugfs path");
1599 goto error;
1600 }
1601 ret = mount_debugfs(debugfs_path);
1602 if (ret < 0) {
7272acf5 1603 perror("Cannot mount debugfs");
b73401da
DG
1604 goto error;
1605 }
1606 }
1607
1608 /* Modprobe lttng kernel modules */
1609 ret = modprobe_kernel_modules();
1610 if (ret < 0) {
1611 goto error;
1612 }
1613
1614 /* Setup lttng kernel path */
1615 ret = asprintf(&lttng_path, "%s/lttng", debugfs_path);
1616 if (ret < 0) {
1617 perror("asprintf lttng path");
1618 goto error;
1619 }
1620
1621 /* Open debugfs lttng */
1622 kernel_tracer_fd = open(lttng_path, O_RDWR);
f3ed775e 1623 if (kernel_tracer_fd < 0) {
b73401da
DG
1624 DBG("Failed to open %s", lttng_path);
1625 goto error;
8c0faa1d
DG
1626 }
1627
b73401da
DG
1628 free(lttng_path);
1629 free(debugfs_path);
f3ed775e 1630 DBG("Kernel tracer fd %d", kernel_tracer_fd);
b73401da
DG
1631 return;
1632
1633error:
1634 if (lttng_path) {
1635 free(lttng_path);
1636 }
1637 if (debugfs_path) {
1638 free(debugfs_path);
1639 }
1640 WARN("No kernel tracer available");
1641 kernel_tracer_fd = 0;
1642 return;
f3ed775e 1643}
33a2b854 1644
f3ed775e 1645/*
54d01ffb 1646 * Init tracing by creating trace directory and sending fds kernel consumer.
f3ed775e 1647 */
54d01ffb 1648static int init_kernel_tracing(struct ltt_kernel_session *session)
f3ed775e 1649{
f40799e8 1650 int ret = 0;
8c0faa1d 1651
3bd1e081 1652 if (session->consumer_fds_sent == 0) {
d9800920 1653 /*
54d01ffb
DG
1654 * Assign default kernel consumer socket if no consumer assigned to the
1655 * kernel session. At this point, it's NOT suppose to be 0 but this is
1656 * an extra security check.
d9800920
DG
1657 */
1658 if (session->consumer_fd == 0) {
3bd1e081 1659 session->consumer_fd = kconsumer_data.cmd_sock;
d9800920
DG
1660 }
1661
2bdd86d4 1662 ret = send_kconsumer_session_streams(&kconsumer_data, session);
f3ed775e 1663 if (ret < 0) {
f3ed775e
DG
1664 ret = LTTCOMM_KERN_CONSUMER_FAIL;
1665 goto error;
1666 }
1d4b027a 1667
3bd1e081 1668 session->consumer_fds_sent = 1;
f3ed775e 1669 }
1d4b027a
DG
1670
1671error:
1672 return ret;
8c0faa1d
DG
1673}
1674
0177d773
DG
1675/*
1676 * Create an UST session and add it to the session ust list.
1677 */
44d3bd01
DG
1678static int create_ust_session(struct ltt_session *session,
1679 struct lttng_domain *domain)
0177d773 1680{
44d3bd01 1681 int ret;
48842b30 1682 unsigned int uid;
13384287 1683 struct ltt_ust_session *lus = NULL;
44d3bd01
DG
1684
1685 switch (domain->type) {
48842b30 1686 case LTTNG_DOMAIN_UST:
44d3bd01
DG
1687 break;
1688 default:
13384287 1689 ret = LTTCOMM_UNKNOWN_DOMAIN;
44d3bd01
DG
1690 goto error;
1691 }
0177d773
DG
1692
1693 DBG("Creating UST session");
1694
48842b30
DG
1695 session_lock_list();
1696 uid = session_list_ptr->count;
1697 session_unlock_list();
1698
1699 lus = trace_ust_create_session(session->path, uid, domain);
0177d773 1700 if (lus == NULL) {
44d3bd01 1701 ret = LTTCOMM_UST_SESS_FAIL;
0177d773
DG
1702 goto error;
1703 }
1704
48842b30 1705 ret = mkdir_recursive(lus->pathname, S_IRWXU | S_IRWXG,
0177d773
DG
1706 geteuid(), allowed_group());
1707 if (ret < 0) {
1708 if (ret != -EEXIST) {
1709 ERR("Trace directory creation error");
44d3bd01 1710 ret = LTTCOMM_UST_SESS_FAIL;
0177d773
DG
1711 goto error;
1712 }
1713 }
1714
f6a9efaa
DG
1715 /* The domain type dictate different actions on session creation */
1716 switch (domain->type) {
48842b30
DG
1717 case LTTNG_DOMAIN_UST:
1718 /* No ustctl for the global UST domain */
1719 break;
1720 default:
36dc12cc 1721 ERR("Unknown UST domain on create session %d", domain->type);
48842b30 1722 goto error;
0177d773 1723 }
f6a9efaa 1724 session->ust_session = lus;
44d3bd01
DG
1725
1726 return LTTCOMM_OK;
0177d773
DG
1727
1728error:
1729 free(lus);
1730 return ret;
1731}
1732
333f285e 1733/*
d063d709 1734 * Create a kernel tracer session then create the default channel.
333f285e 1735 */
f3ed775e 1736static int create_kernel_session(struct ltt_session *session)
333f285e 1737{
f3ed775e 1738 int ret;
f3ed775e
DG
1739
1740 DBG("Creating kernel session");
1741
1742 ret = kernel_create_session(session, kernel_tracer_fd);
1743 if (ret < 0) {
1744 ret = LTTCOMM_KERN_SESS_FAIL;
1745 goto error;
333f285e
DG
1746 }
1747
d9800920 1748 /* Set kernel consumer socket fd */
3bd1e081
MD
1749 if (kconsumer_data.cmd_sock) {
1750 session->kernel_session->consumer_fd = kconsumer_data.cmd_sock;
d9800920
DG
1751 }
1752
63053e7c
DG
1753 ret = mkdir_recursive(session->kernel_session->trace_path,
1754 S_IRWXU | S_IRWXG, geteuid(), allowed_group());
7a485870 1755 if (ret < 0) {
996b65c8 1756 if (ret != -EEXIST) {
7a485870
DG
1757 ERR("Trace directory creation error");
1758 goto error;
1759 }
1760 }
1761
f3ed775e
DG
1762error:
1763 return ret;
333f285e
DG
1764}
1765
6c9cc2ab
DG
1766/*
1767 * Using the session list, filled a lttng_session array to send back to the
1768 * client for session listing.
1769 *
1770 * The session list lock MUST be acquired before calling this function. Use
54d01ffb 1771 * session_lock_list() and session_unlock_list().
6c9cc2ab
DG
1772 */
1773static void list_lttng_sessions(struct lttng_session *sessions)
1774{
1775 int i = 0;
1776 struct ltt_session *session;
1777
1778 DBG("Getting all available session");
1779 /*
1780 * Iterate over session list and append data after the control struct in
1781 * the buffer.
1782 */
1783 cds_list_for_each_entry(session, &session_list_ptr->head, list) {
1784 strncpy(sessions[i].path, session->path, PATH_MAX);
99497cd0 1785 sessions[i].path[PATH_MAX - 1] = '\0';
6c9cc2ab 1786 strncpy(sessions[i].name, session->name, NAME_MAX);
99497cd0 1787 sessions[i].name[NAME_MAX - 1] = '\0';
6c9cc2ab
DG
1788 i++;
1789 }
1790}
1791
9f19cc17
DG
1792/*
1793 * Fill lttng_channel array of all channels.
1794 */
1795static void list_lttng_channels(struct ltt_session *session,
1796 struct lttng_channel *channels)
1797{
1798 int i = 0;
1799 struct ltt_kernel_channel *kchan;
1800
1801 DBG("Listing channels for session %s", session->name);
1802
1803 /* Kernel channels */
1804 if (session->kernel_session != NULL) {
54d01ffb
DG
1805 cds_list_for_each_entry(kchan,
1806 &session->kernel_session->channel_list.head, list) {
9f19cc17
DG
1807 /* Copy lttng_channel struct to array */
1808 memcpy(&channels[i], kchan->channel, sizeof(struct lttng_channel));
1809 channels[i].enabled = kchan->enabled;
1810 i++;
1811 }
1812 }
1813
1814 /* TODO: Missing UST listing */
1815}
1816
1817/*
1818 * Fill lttng_event array of all events in the channel.
1819 */
1820static void list_lttng_events(struct ltt_kernel_channel *kchan,
1821 struct lttng_event *events)
1822{
1823 /*
1824 * TODO: This is ONLY kernel. Need UST support.
1825 */
1826 int i = 0;
1827 struct ltt_kernel_event *event;
1828
1829 DBG("Listing events for channel %s", kchan->channel->name);
1830
1831 /* Kernel channels */
1832 cds_list_for_each_entry(event, &kchan->events_list.head , list) {
1833 strncpy(events[i].name, event->event->name, LTTNG_SYMBOL_NAME_LEN);
99497cd0 1834 events[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
9f19cc17
DG
1835 events[i].enabled = event->enabled;
1836 switch (event->event->instrumentation) {
1837 case LTTNG_KERNEL_TRACEPOINT:
1838 events[i].type = LTTNG_EVENT_TRACEPOINT;
1839 break;
1840 case LTTNG_KERNEL_KPROBE:
1841 case LTTNG_KERNEL_KRETPROBE:
1842 events[i].type = LTTNG_EVENT_PROBE;
1843 memcpy(&events[i].attr.probe, &event->event->u.kprobe,
1844 sizeof(struct lttng_kernel_kprobe));
1845 break;
1846 case LTTNG_KERNEL_FUNCTION:
1847 events[i].type = LTTNG_EVENT_FUNCTION;
1848 memcpy(&events[i].attr.ftrace, &event->event->u.ftrace,
1849 sizeof(struct lttng_kernel_function));
1850 break;
0133c199
MD
1851 case LTTNG_KERNEL_NOOP:
1852 events[i].type = LTTNG_EVENT_NOOP;
1853 break;
a54bd42d
MD
1854 case LTTNG_KERNEL_SYSCALL:
1855 events[i].type = LTTNG_EVENT_SYSCALL;
0133c199 1856 break;
7a3d1328
MD
1857 case LTTNG_KERNEL_ALL:
1858 assert(0);
1859 break;
9f19cc17
DG
1860 }
1861 i++;
1862 }
1863}
1864
fac6795d 1865/*
54d01ffb 1866 * Command LTTNG_DISABLE_CHANNEL processed by the client thread.
fac6795d 1867 */
54d01ffb
DG
1868static int cmd_disable_channel(struct ltt_session *session,
1869 int domain, char *channel_name)
fac6795d 1870{
54d01ffb 1871 int ret;
379473d2 1872
54d01ffb
DG
1873 switch (domain) {
1874 case LTTNG_DOMAIN_KERNEL:
1875 ret = channel_kernel_disable(session->kernel_session,
1876 channel_name);
1877 if (ret != LTTCOMM_OK) {
333f285e
DG
1878 goto error;
1879 }
54d01ffb
DG
1880
1881 kernel_wait_quiescent(kernel_tracer_fd);
d0254c7c 1882 break;
44d3bd01
DG
1883 case LTTNG_DOMAIN_UST_PID:
1884 break;
d0254c7c 1885 default:
44d3bd01 1886 ret = LTTCOMM_UNKNOWN_DOMAIN;
54d01ffb 1887 goto error;
20fe2104
DG
1888 }
1889
54d01ffb 1890 ret = LTTCOMM_OK;
d65106b1 1891
54d01ffb
DG
1892error:
1893 return ret;
1894}
1895
56fff090
DG
1896/*
1897 * Copy channel from attributes and set it in the application channel list.
1898 */
f6a9efaa 1899/*
56fff090
DG
1900static int copy_ust_channel_to_app(struct ltt_ust_session *usess,
1901 struct lttng_channel *attr, struct ust_app *app)
1902{
1903 int ret;
1904 struct ltt_ust_channel *uchan, *new_chan;
1905
f6a9efaa 1906 uchan = trace_ust_get_channel_by_key(usess->channels, attr->name);
56fff090
DG
1907 if (uchan == NULL) {
1908 ret = LTTCOMM_FATAL;
1909 goto error;
1910 }
1911
1912 new_chan = trace_ust_create_channel(attr, usess->path);
1913 if (new_chan == NULL) {
1914 PERROR("malloc ltt_ust_channel");
1915 ret = LTTCOMM_FATAL;
1916 goto error;
1917 }
1918
1919 ret = channel_ust_copy(new_chan, uchan);
1920 if (ret < 0) {
1921 ret = LTTCOMM_FATAL;
1922 goto error;
1923 }
1924
56fff090
DG
1925error:
1926 return ret;
1927}
f6a9efaa 1928*/
56fff090 1929
54d01ffb
DG
1930/*
1931 * Command LTTNG_ENABLE_CHANNEL processed by the client thread.
1932 */
44d3bd01
DG
1933static int cmd_enable_channel(struct ltt_session *session,
1934 struct lttng_domain *domain, struct lttng_channel *attr)
54d01ffb
DG
1935{
1936 int ret;
f6a9efaa
DG
1937 struct ltt_ust_session *usess = session->ust_session;
1938
1939 DBG("Enabling channel %s for session %s", session->name, attr->name);
d65106b1 1940
44d3bd01
DG
1941 switch (domain->type) {
1942 case LTTNG_DOMAIN_KERNEL:
1943 {
1944 struct ltt_kernel_channel *kchan;
54d01ffb 1945
44d3bd01
DG
1946 kchan = trace_kernel_get_channel_by_name(attr->name,
1947 session->kernel_session);
1948 if (kchan == NULL) {
1949 ret = channel_kernel_create(session->kernel_session,
1950 attr, kernel_poll_pipe[1]);
1951 } else {
1952 ret = channel_kernel_enable(session->kernel_session, kchan);
1953 }
1954
1955 if (ret != LTTCOMM_OK) {
1956 goto error;
1957 }
1958
1959 kernel_wait_quiescent(kernel_tracer_fd);
1960 break;
1961 }
f6a9efaa
DG
1962 case LTTNG_DOMAIN_UST:
1963 {
1964 struct ltt_ust_channel *uchan;
1965
48842b30 1966 DBG2("Enabling channel for LTTNG_DOMAIN_UST");
f6a9efaa 1967
48842b30 1968 /* Get channel in global UST domain HT */
f6a9efaa
DG
1969 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
1970 attr->name);
1971 if (uchan == NULL) {
48842b30 1972 uchan = trace_ust_create_channel(attr, usess->pathname);
f6a9efaa
DG
1973 if (uchan == NULL) {
1974 ret = LTTCOMM_UST_CHAN_FAIL;
1975 goto error;
1976 }
1977 rcu_read_lock();
1978 hashtable_add_unique(usess->domain_global.channels, &uchan->node);
1979 rcu_read_unlock();
48842b30 1980 DBG2("UST channel %s added to global domain HT", attr->name);
f6a9efaa
DG
1981 } else {
1982 ret = LTTCOMM_UST_CHAN_EXIST;
1983 goto error;
1984 }
1985
48842b30
DG
1986 ret = ust_app_add_channel(usess, uchan);
1987 if (ret != LTTCOMM_OK) {
1988 goto error;
1989 }
f6a9efaa
DG
1990
1991 break;
1992 }
44d3bd01
DG
1993 case LTTNG_DOMAIN_UST_PID:
1994 {
f6a9efaa 1995 /*
56fff090
DG
1996 int sock;
1997 struct ltt_ust_channel *uchan;
44d3bd01 1998 struct ltt_ust_session *usess;
56fff090 1999 struct ust_app *app;
44d3bd01
DG
2000
2001 usess = trace_ust_get_session_by_pid(&session->ust_session_list,
2002 domain->attr.pid);
2003 if (usess == NULL) {
2004 ret = LTTCOMM_UST_CHAN_NOT_FOUND;
2005 goto error;
2006 }
2007
56fff090 2008 app = ust_app_get_by_pid(domain->attr.pid);
44d3bd01
DG
2009 if (app == NULL) {
2010 ret = LTTCOMM_APP_NOT_FOUND;
2011 goto error;
2012 }
56fff090 2013 sock = app->sock;
44d3bd01
DG
2014
2015 uchan = trace_ust_get_channel_by_name(attr->name, usess);
2016 if (uchan == NULL) {
56fff090 2017 ret = channel_ust_create(usess, attr, sock);
44d3bd01 2018 } else {
56fff090 2019 ret = channel_ust_enable(usess, uchan, sock);
44d3bd01
DG
2020 }
2021
2022 if (ret != LTTCOMM_OK) {
2023 goto error;
2024 }
2025
56fff090
DG
2026 ret = copy_ust_channel_to_app(usess, attr, app);
2027 if (ret != LTTCOMM_OK) {
44d3bd01
DG
2028 goto error;
2029 }
2030
44d3bd01
DG
2031 DBG("UST channel %s created for app sock %d with pid %d",
2032 attr->name, app->sock, domain->attr.pid);
f6a9efaa
DG
2033 */
2034 ret = LTTCOMM_NOT_IMPLEMENTED;
2035 goto error;
44d3bd01
DG
2036 }
2037 default:
2038 ret = LTTCOMM_UNKNOWN_DOMAIN;
2039 goto error;
54d01ffb
DG
2040 }
2041
2042 ret = LTTCOMM_OK;
2043
2044error:
2045 return ret;
2046}
2047
2048/*
2049 * Command LTTNG_DISABLE_EVENT processed by the client thread.
2050 */
2051static int cmd_disable_event(struct ltt_session *session, int domain,
2052 char *channel_name, char *event_name)
2053{
2054 int ret;
54d01ffb
DG
2055
2056 switch (domain) {
2057 case LTTNG_DOMAIN_KERNEL:
2bdd86d4
MD
2058 {
2059 struct ltt_kernel_channel *kchan;
2060
54d01ffb
DG
2061 kchan = trace_kernel_get_channel_by_name(channel_name,
2062 session->kernel_session);
2063 if (kchan == NULL) {
2064 ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
2065 goto error;
d65106b1
DG
2066 }
2067
7a3d1328 2068 ret = event_kernel_disable_tracepoint(session->kernel_session, kchan, event_name);
54d01ffb
DG
2069 if (ret != LTTCOMM_OK) {
2070 goto error;
2071 }
2072
2073 kernel_wait_quiescent(kernel_tracer_fd);
d65106b1 2074 break;
2bdd86d4
MD
2075 }
2076 case LTTNG_DOMAIN_UST:
2bdd86d4
MD
2077 case LTTNG_DOMAIN_UST_EXEC_NAME:
2078 case LTTNG_DOMAIN_UST_PID:
2079 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
54d01ffb 2080 default:
2bdd86d4 2081 /* TODO: Other UST domains */
54d01ffb
DG
2082 ret = LTTCOMM_NOT_IMPLEMENTED;
2083 goto error;
d65106b1 2084 }
26cc6b4e 2085
54d01ffb
DG
2086 ret = LTTCOMM_OK;
2087
2088error:
2089 return ret;
2090}
2091
2092/*
2093 * Command LTTNG_DISABLE_ALL_EVENT processed by the client thread.
2094 */
2095static int cmd_disable_event_all(struct ltt_session *session, int domain,
2096 char *channel_name)
2097{
2098 int ret;
2099 struct ltt_kernel_channel *kchan;
2100
2101 switch (domain) {
2102 case LTTNG_DOMAIN_KERNEL:
2103 kchan = trace_kernel_get_channel_by_name(channel_name,
2104 session->kernel_session);
2105 if (kchan == NULL) {
2106 ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
2107 goto error;
26cc6b4e
DG
2108 }
2109
54d01ffb
DG
2110 ret = event_kernel_disable_all(session->kernel_session, kchan);
2111 if (ret != LTTCOMM_OK) {
0b97ec54 2112 goto error;
26cc6b4e
DG
2113 }
2114
54d01ffb 2115 kernel_wait_quiescent(kernel_tracer_fd);
26cc6b4e 2116 break;
54d01ffb
DG
2117 default:
2118 /* TODO: Userspace tracing */
2119 ret = LTTCOMM_NOT_IMPLEMENTED;
2120 goto error;
26cc6b4e 2121 }
e953ef25 2122
54d01ffb 2123 ret = LTTCOMM_OK;
e953ef25 2124
54d01ffb
DG
2125error:
2126 return ret;
2127}
f5177a38 2128
54d01ffb
DG
2129/*
2130 * Command LTTNG_ADD_CONTEXT processed by the client thread.
2131 */
2132static int cmd_add_context(struct ltt_session *session, int domain,
2133 char *channel_name, char *event_name, struct lttng_event_context *ctx)
2134{
2135 int ret;
f5177a38 2136
54d01ffb
DG
2137 switch (domain) {
2138 case LTTNG_DOMAIN_KERNEL:
2139 /* Add kernel context to kernel tracer */
2140 ret = context_kernel_add(session->kernel_session, ctx,
2141 event_name, channel_name);
2142 if (ret != LTTCOMM_OK) {
f5177a38 2143 goto error;
e953ef25 2144 }
2bdd86d4
MD
2145 break;
2146 case LTTNG_DOMAIN_UST:
2147 {
48842b30
DG
2148 /*
2149 struct ltt_ust_session *usess;
e953ef25 2150
48842b30
DG
2151 cds_list_for_each_entry(usess, &session->ust_session_list.head, list) {
2152 ret = context_ust_add(usess, ctx,
2153 event_name, channel_name, domain);
2bdd86d4
MD
2154 if (ret != LTTCOMM_OK) {
2155 goto error;
2156 }
2157 }
e953ef25 2158 break;
48842b30 2159 */
2bdd86d4 2160 }
54d01ffb 2161 default:
2bdd86d4 2162 /* TODO: UST other domains */
54d01ffb
DG
2163 ret = LTTCOMM_NOT_IMPLEMENTED;
2164 goto error;
e953ef25 2165 }
950131af 2166
54d01ffb 2167 ret = LTTCOMM_OK;
950131af 2168
54d01ffb
DG
2169error:
2170 return ret;
2171}
2172
2173/*
2174 * Command LTTNG_ENABLE_EVENT processed by the client thread.
2175 */
2176static int cmd_enable_event(struct ltt_session *session, int domain,
2177 char *channel_name, struct lttng_event *event)
2178{
2179 int ret;
f6cd6b0f 2180 struct lttng_channel *attr;
48842b30 2181 struct ltt_ust_session *usess = session->ust_session;
54d01ffb
DG
2182
2183 switch (domain) {
2184 case LTTNG_DOMAIN_KERNEL:
2bdd86d4
MD
2185 {
2186 struct ltt_kernel_channel *kchan;
2187
54d01ffb
DG
2188 kchan = trace_kernel_get_channel_by_name(channel_name,
2189 session->kernel_session);
2190 if (kchan == NULL) {
f6cd6b0f
DG
2191 attr = channel_new_default_attr(domain);
2192 if (attr == NULL) {
2193 ret = LTTCOMM_FATAL;
2194 goto error;
2195 }
2196 snprintf(attr->name, NAME_MAX, "%s", channel_name);
2197
54d01ffb 2198 /* This call will notify the kernel thread */
44d3bd01 2199 ret = channel_kernel_create(session->kernel_session,
f6cd6b0f 2200 attr, kernel_poll_pipe[1]);
54d01ffb 2201 if (ret != LTTCOMM_OK) {
f5177a38
DG
2202 goto error;
2203 }
54d01ffb 2204 }
950131af 2205
54d01ffb
DG
2206 /* Get the newly created kernel channel pointer */
2207 kchan = trace_kernel_get_channel_by_name(channel_name,
2208 session->kernel_session);
2209 if (kchan == NULL) {
2210 /* This sould not happen... */
2211 ret = LTTCOMM_FATAL;
2212 goto error;
2213 }
f5177a38 2214
48842b30
DG
2215 ret = event_kernel_enable_tracepoint(session->kernel_session, kchan,
2216 event);
54d01ffb 2217 if (ret != LTTCOMM_OK) {
f5177a38 2218 goto error;
950131af
DG
2219 }
2220
54d01ffb 2221 kernel_wait_quiescent(kernel_tracer_fd);
950131af 2222 break;
2bdd86d4
MD
2223 }
2224 case LTTNG_DOMAIN_UST:
2225 {
48842b30
DG
2226 struct ltt_ust_channel *uchan;
2227 struct ltt_ust_event *uevent;
2bdd86d4 2228
48842b30
DG
2229 uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
2230 channel_name);
2231 if (uchan == NULL) {
2232 /* TODO: Create default channel */
2233 ret = LTTCOMM_UST_CHAN_NOT_FOUND;
2234 goto error;
2235 }
2bdd86d4 2236
48842b30
DG
2237 uevent = trace_ust_find_event_by_name(uchan->events, event->name);
2238 if (uevent == NULL) {
2239 uevent = trace_ust_create_event(event);
2240 if (uevent == NULL) {
2bdd86d4
MD
2241 ret = LTTCOMM_FATAL;
2242 goto error;
2243 }
48842b30 2244 }
2bdd86d4 2245
48842b30
DG
2246 ret = ust_app_add_event(usess, uchan, uevent);
2247 if (ret < 0) {
2248 ret = LTTCOMM_UST_ENABLE_FAIL;
2249 goto error;
2bdd86d4 2250 }
487cf67c
DG
2251
2252 rcu_read_lock();
2253 hashtable_add_unique(uchan->events, &uevent->node);
2254 rcu_read_unlock();
2bdd86d4
MD
2255 break;
2256 }
2257 case LTTNG_DOMAIN_UST_EXEC_NAME:
2258 case LTTNG_DOMAIN_UST_PID:
2259 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
54d01ffb 2260 default:
54d01ffb
DG
2261 ret = LTTCOMM_NOT_IMPLEMENTED;
2262 goto error;
950131af 2263 }
d36b8583 2264
54d01ffb 2265 ret = LTTCOMM_OK;
d36b8583 2266
54d01ffb
DG
2267error:
2268 return ret;
2269}
7d29a247 2270
54d01ffb
DG
2271/*
2272 * Command LTTNG_ENABLE_ALL_EVENT processed by the client thread.
2273 */
2274static int cmd_enable_event_all(struct ltt_session *session, int domain,
8c9ae521 2275 char *channel_name, int event_type)
54d01ffb
DG
2276{
2277 int ret;
2278 struct ltt_kernel_channel *kchan;
7d29a247 2279
54d01ffb
DG
2280 switch (domain) {
2281 case LTTNG_DOMAIN_KERNEL:
2282 kchan = trace_kernel_get_channel_by_name(channel_name,
2283 session->kernel_session);
2284 if (kchan == NULL) {
2285 /* This call will notify the kernel thread */
44d3bd01
DG
2286 ret = channel_kernel_create(session->kernel_session, NULL,
2287 kernel_poll_pipe[1]);
54d01ffb
DG
2288 if (ret != LTTCOMM_OK) {
2289 goto error;
d36b8583 2290 }
54d01ffb 2291 }
0d0c377a 2292
54d01ffb
DG
2293 /* Get the newly created kernel channel pointer */
2294 kchan = trace_kernel_get_channel_by_name(channel_name,
2295 session->kernel_session);
2296 if (kchan == NULL) {
2297 /* This sould not happen... */
2298 ret = LTTCOMM_FATAL;
2299 goto error;
2300 }
0fdd1e2c 2301
7a3d1328
MD
2302 switch (event_type) {
2303 case LTTNG_KERNEL_SYSCALL:
2304 ret = event_kernel_enable_all_syscalls(session->kernel_session,
8c9ae521 2305 kchan, kernel_tracer_fd);
7a3d1328
MD
2306 break;
2307 case LTTNG_KERNEL_TRACEPOINT:
8c9ae521 2308 /*
7a3d1328
MD
2309 * This call enables all LTTNG_KERNEL_TRACEPOINTS and
2310 * events already registered to the channel.
8c9ae521 2311 */
7a3d1328
MD
2312 ret = event_kernel_enable_all_tracepoints(session->kernel_session,
2313 kchan, kernel_tracer_fd);
2314 break;
2315 case LTTNG_KERNEL_ALL:
2316 /* Enable syscalls and tracepoints */
8c9ae521
DG
2317 ret = event_kernel_enable_all(session->kernel_session,
2318 kchan, kernel_tracer_fd);
7a3d1328
MD
2319 break;
2320 default:
2321 ret = LTTCOMM_KERN_ENABLE_FAIL;
2322 goto error;
8c9ae521 2323 }
54d01ffb 2324 if (ret != LTTCOMM_OK) {
0d0c377a 2325 goto error;
d36b8583
DG
2326 }
2327
54d01ffb 2328 kernel_wait_quiescent(kernel_tracer_fd);
d36b8583 2329 break;
54d01ffb
DG
2330 default:
2331 /* TODO: Userspace tracing */
2332 ret = LTTCOMM_NOT_IMPLEMENTED;
2333 goto error;
d36b8583 2334 }
f3ed775e 2335
54d01ffb
DG
2336 ret = LTTCOMM_OK;
2337
2338error:
2339 return ret;
2340}
2341
2342/*
2343 * Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
2344 */
2345static ssize_t cmd_list_tracepoints(int domain, struct lttng_event **events)
2346{
2347 int ret;
2348 ssize_t nb_events = 0;
2349
2350 switch (domain) {
2351 case LTTNG_DOMAIN_KERNEL:
2352 nb_events = kernel_list_events(kernel_tracer_fd, events);
2353 if (nb_events < 0) {
2354 ret = LTTCOMM_KERN_LIST_FAIL;
2355 goto error;
894be886 2356 }
54d01ffb
DG
2357 break;
2358 default:
2359 /* TODO: Userspace listing */
2360 ret = LTTCOMM_NOT_IMPLEMENTED;
2361 goto error;
2362 }
894be886 2363
54d01ffb 2364 return nb_events;
7d29a247 2365
54d01ffb
DG
2366error:
2367 /* Return negative value to differentiate return code */
2368 return -ret;
2369}
b389abbe 2370
54d01ffb
DG
2371/*
2372 * Command LTTNG_START_TRACE processed by the client thread.
2373 */
2374static int cmd_start_trace(struct ltt_session *session)
2375{
2376 int ret;
54d01ffb 2377 struct ltt_kernel_session *ksession;
48842b30 2378 struct ltt_ust_session *usess = session->ust_session;
b389abbe 2379
54d01ffb
DG
2380 /* Short cut */
2381 ksession = session->kernel_session;
5eb91c98 2382
54d01ffb
DG
2383 /* Kernel tracing */
2384 if (ksession != NULL) {
2bdd86d4
MD
2385 struct ltt_kernel_channel *kchan;
2386
54d01ffb
DG
2387 /* Open kernel metadata */
2388 if (ksession->metadata == NULL) {
2389 ret = kernel_open_metadata(ksession, ksession->trace_path);
2390 if (ret < 0) {
2391 ret = LTTCOMM_KERN_META_FAIL;
2392 goto error;
b389abbe 2393 }
54d01ffb 2394 }
7d29a247 2395
54d01ffb
DG
2396 /* Open kernel metadata stream */
2397 if (ksession->metadata_stream_fd == 0) {
2398 ret = kernel_open_metadata_stream(ksession);
2399 if (ret < 0) {
2400 ERR("Kernel create metadata stream failed");
2401 ret = LTTCOMM_KERN_STREAM_FAIL;
2402 goto error;
2403 }
2404 }
2405
2406 /* For each channel */
2407 cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
2408 if (kchan->stream_count == 0) {
2409 ret = kernel_open_channel_stream(kchan);
2410 if (ret < 0) {
2411 ret = LTTCOMM_KERN_STREAM_FAIL;
7d29a247
DG
2412 goto error;
2413 }
54d01ffb
DG
2414 /* Update the stream global counter */
2415 ksession->stream_count_global += ret;
7d29a247 2416 }
54d01ffb
DG
2417 }
2418
2419 /* Setup kernel consumer socket and send fds to it */
2420 ret = init_kernel_tracing(ksession);
2421 if (ret < 0) {
2422 ret = LTTCOMM_KERN_START_FAIL;
2423 goto error;
2424 }
2425
2426 /* This start the kernel tracing */
2427 ret = kernel_start_session(ksession);
2428 if (ret < 0) {
2429 ret = LTTCOMM_KERN_START_FAIL;
2430 goto error;
2431 }
2432
2433 /* Quiescent wait after starting trace */
2434 kernel_wait_quiescent(kernel_tracer_fd);
2435 }
2436
36dc12cc
DG
2437 /* Flag session that trace should start automatically */
2438 usess->start_trace = 1;
2439
48842b30
DG
2440 ret = ust_app_start_trace(usess);
2441 if (ret < 0) {
2442 ret = LTTCOMM_UST_START_FAIL;
2443 goto error;
2bdd86d4 2444 }
54d01ffb
DG
2445
2446 ret = LTTCOMM_OK;
2447
2448error:
2449 return ret;
2450}
2451
2452/*
2453 * Command LTTNG_STOP_TRACE processed by the client thread.
2454 */
2455static int cmd_stop_trace(struct ltt_session *session)
2456{
2457 int ret;
2458 struct ltt_kernel_channel *kchan;
2459 struct ltt_kernel_session *ksession;
48842b30
DG
2460 //struct ltt_ust_session *usess;
2461 //struct ltt_ust_channel *ustchan;
54d01ffb
DG
2462
2463 /* Short cut */
2464 ksession = session->kernel_session;
2465
2466 /* Kernel tracer */
2467 if (ksession != NULL) {
2468 DBG("Stop kernel tracing");
2469
2470 /* Flush all buffers before stopping */
2471 ret = kernel_metadata_flush_buffer(ksession->metadata_stream_fd);
2472 if (ret < 0) {
2473 ERR("Kernel metadata flush failed");
2474 }
f34daff7 2475
54d01ffb
DG
2476 cds_list_for_each_entry(kchan, &ksession->channel_list.head, list) {
2477 ret = kernel_flush_buffer(kchan);
0d0c377a 2478 if (ret < 0) {
54d01ffb 2479 ERR("Kernel flush buffer error");
7d29a247 2480 }
54d01ffb 2481 }
19e70852 2482
54d01ffb
DG
2483 ret = kernel_stop_session(ksession);
2484 if (ret < 0) {
2485 ret = LTTCOMM_KERN_STOP_FAIL;
19e70852 2486 goto error;
f3ed775e 2487 }
54d01ffb
DG
2488
2489 kernel_wait_quiescent(kernel_tracer_fd);
894be886 2490 }
54d01ffb 2491
48842b30 2492#ifdef DISABLE
2bdd86d4
MD
2493 /* Stop each UST session */
2494 DBG("Stop UST tracing");
48842b30 2495 cds_list_for_each_entry(usess, &session->ust_session_list.head, list) {
2bdd86d4 2496 /* Flush all buffers before stopping */
48842b30 2497 ret = ustctl_flush_buffer(usess->sock, usess->metadata->obj);
2bdd86d4
MD
2498 if (ret < 0) {
2499 ERR("UST metadata flush failed");
2500 }
2501
48842b30
DG
2502 cds_list_for_each_entry(ustchan, &usess->channels.head, list) {
2503 ret = ustctl_flush_buffer(usess->sock, ustchan->obj);
2bdd86d4
MD
2504 if (ret < 0) {
2505 ERR("UST flush buffer error");
2506 }
2507 }
2508
48842b30 2509 ret = ustctl_stop_session(usess->sock, usess->handle);
2bdd86d4
MD
2510 if (ret < 0) {
2511 ret = LTTCOMM_KERN_STOP_FAIL;
2512 goto error;
2513 }
2514
48842b30 2515 ustctl_wait_quiescent(usess->sock);
2bdd86d4 2516 }
48842b30 2517#endif
54d01ffb
DG
2518
2519 ret = LTTCOMM_OK;
2520
2521error:
2522 return ret;
2523}
2524
2525/*
2526 * Command LTTNG_CREATE_SESSION processed by the client thread.
2527 */
2528static int cmd_create_session(char *name, char *path)
2529{
2530 int ret;
2531
2532 ret = session_create(name, path);
2533 if (ret != LTTCOMM_OK) {
2534 goto error;
2535 }
2536
2537 ret = LTTCOMM_OK;
2538
2539error:
2540 return ret;
2541}
2542
2543/*
2544 * Command LTTNG_DESTROY_SESSION processed by the client thread.
2545 */
2546static int cmd_destroy_session(struct ltt_session *session, char *name)
2547{
2548 int ret;
2549
2550 /* Clean kernel session teardown */
2551 teardown_kernel_session(session);
2552
2553 /*
2554 * Must notify the kernel thread here to update it's poll setin order
2555 * to remove the channel(s)' fd just destroyed.
2556 */
2557 ret = notify_thread_pipe(kernel_poll_pipe[1]);
2558 if (ret < 0) {
2559 perror("write kernel poll pipe");
2560 }
2561
271933a4 2562 ret = session_destroy(session);
54d01ffb
DG
2563
2564 return ret;
2565}
2566
2567/*
2568 * Command LTTNG_CALIBRATE processed by the client thread.
2569 */
2570static int cmd_calibrate(int domain, struct lttng_calibrate *calibrate)
2571{
2572 int ret;
2573
2574 switch (domain) {
2575 case LTTNG_DOMAIN_KERNEL:
33a2b854 2576 {
54d01ffb 2577 struct lttng_kernel_calibrate kcalibrate;
33a2b854 2578
54d01ffb
DG
2579 kcalibrate.type = calibrate->type;
2580 ret = kernel_calibrate(kernel_tracer_fd, &kcalibrate);
33a2b854 2581 if (ret < 0) {
54d01ffb
DG
2582 ret = LTTCOMM_KERN_ENABLE_FAIL;
2583 goto error;
33a2b854 2584 }
54d01ffb
DG
2585 break;
2586 }
2587 default:
2588 /* TODO: Userspace tracing */
2589 ret = LTTCOMM_NOT_IMPLEMENTED;
2590 goto error;
2591 }
33a2b854 2592
54d01ffb 2593 ret = LTTCOMM_OK;
33a2b854 2594
54d01ffb
DG
2595error:
2596 return ret;
2597}
7d29a247 2598
54d01ffb
DG
2599/*
2600 * Command LTTNG_REGISTER_CONSUMER processed by the client thread.
2601 */
2602static int cmd_register_consumer(struct ltt_session *session, int domain,
2603 char *sock_path)
2604{
2605 int ret, sock;
b389abbe 2606
54d01ffb
DG
2607 switch (domain) {
2608 case LTTNG_DOMAIN_KERNEL:
2609 /* Can't register a consumer if there is already one */
2610 if (session->kernel_session->consumer_fd != 0) {
2611 ret = LTTCOMM_KERN_CONSUMER_FAIL;
2612 goto error;
2613 }
2614
2615 sock = lttcomm_connect_unix_sock(sock_path);
2616 if (sock < 0) {
2617 ret = LTTCOMM_CONNECT_FAIL;
2618 goto error;
2619 }
2620
2621 session->kernel_session->consumer_fd = sock;
2622 break;
2623 default:
2624 /* TODO: Userspace tracing */
2625 ret = LTTCOMM_NOT_IMPLEMENTED;
2626 goto error;
2627 }
2628
2629 ret = LTTCOMM_OK;
2630
2631error:
2632 return ret;
2633}
2634
2635/*
2636 * Command LTTNG_LIST_DOMAINS processed by the client thread.
2637 */
2638static ssize_t cmd_list_domains(struct ltt_session *session,
2639 struct lttng_domain **domains)
2640{
2641 int ret;
2642 ssize_t nb_dom = 0;
2643
2644 if (session->kernel_session != NULL) {
2645 nb_dom++;
2646 }
2647
f6a9efaa 2648 /* TODO: User-space tracer domain support */
54d01ffb
DG
2649
2650 *domains = malloc(nb_dom * sizeof(struct lttng_domain));
2651 if (*domains == NULL) {
2652 ret = -LTTCOMM_FATAL;
2653 goto error;
2654 }
2655
2656 (*domains)[0].type = LTTNG_DOMAIN_KERNEL;
2657
54d01ffb
DG
2658 return nb_dom;
2659
2660error:
2661 return ret;
2662}
2663
2664/*
2665 * Command LTTNG_LIST_CHANNELS processed by the client thread.
2666 */
2667static ssize_t cmd_list_channels(struct ltt_session *session,
2668 struct lttng_channel **channels)
2669{
2670 int ret;
2671 ssize_t nb_chan = 0;
2672
2673 if (session->kernel_session != NULL) {
2674 nb_chan += session->kernel_session->channel_count;
2675 }
2676
2677 *channels = malloc(nb_chan * sizeof(struct lttng_channel));
2678 if (*channels == NULL) {
2679 ret = -LTTCOMM_FATAL;
2680 goto error;
2681 }
2682
2683 list_lttng_channels(session, *channels);
2684
2bdd86d4
MD
2685 /* TODO UST support */
2686
54d01ffb
DG
2687 return nb_chan;
2688
2689error:
2690 return ret;
2691}
2692
2693/*
2694 * Command LTTNG_LIST_EVENTS processed by the client thread.
2695 */
2696static ssize_t cmd_list_events(struct ltt_session *session,
2697 char *channel_name, struct lttng_event **events)
2698{
2699 int ret;
2700 ssize_t nb_event = 0;
2701 struct ltt_kernel_channel *kchan = NULL;
2702
2703 if (session->kernel_session != NULL) {
2704 kchan = trace_kernel_get_channel_by_name(channel_name,
2705 session->kernel_session);
2706 if (kchan == NULL) {
2707 ret = -LTTCOMM_KERN_CHAN_NOT_FOUND;
2708 goto error;
2709 }
2710 nb_event += kchan->event_count;
2711 }
2712
2713 *events = malloc(nb_event * sizeof(struct lttng_event));
2714 if (*events == NULL) {
2715 ret = -LTTCOMM_FATAL;
2716 goto error;
2717 }
2718
2719 list_lttng_events(kchan, *events);
2720
2721 /* TODO: User-space tracer support */
2722
2723 return nb_event;
2724
2725error:
2726 return ret;
2727}
2728
2729/*
2730 * Process the command requested by the lttng client within the command
2731 * context structure. This function make sure that the return structure (llm)
2732 * is set and ready for transmission before returning.
2733 *
2734 * Return any error encountered or 0 for success.
2735 */
2736static int process_client_msg(struct command_ctx *cmd_ctx)
2737{
2738 int ret = LTTCOMM_OK;
44d3bd01 2739 int need_tracing_session = 1;
54d01ffb
DG
2740
2741 DBG("Processing client command %d", cmd_ctx->lsm->cmd_type);
2742
2743 /*
2744 * Check for command that don't needs to allocate a returned payload. We do
44d3bd01 2745 * this here so we don't have to make the call for no payload at each
54d01ffb
DG
2746 * command.
2747 */
2748 switch(cmd_ctx->lsm->cmd_type) {
2749 case LTTNG_LIST_SESSIONS:
2750 case LTTNG_LIST_TRACEPOINTS:
2751 case LTTNG_LIST_DOMAINS:
2752 case LTTNG_LIST_CHANNELS:
2753 case LTTNG_LIST_EVENTS:
2754 break;
2755 default:
2756 /* Setup lttng message with no payload */
2757 ret = setup_lttng_msg(cmd_ctx, 0);
2758 if (ret < 0) {
2759 /* This label does not try to unlock the session */
2760 goto init_setup_error;
2761 }
2762 }
2763
2764 /* Commands that DO NOT need a session. */
2765 switch (cmd_ctx->lsm->cmd_type) {
2766 case LTTNG_CALIBRATE:
2767 case LTTNG_CREATE_SESSION:
2768 case LTTNG_LIST_SESSIONS:
2769 case LTTNG_LIST_TRACEPOINTS:
44d3bd01 2770 need_tracing_session = 0;
54d01ffb
DG
2771 break;
2772 default:
2773 DBG("Getting session %s by name", cmd_ctx->lsm->session.name);
74babd95 2774 session_lock_list();
54d01ffb 2775 cmd_ctx->session = session_find_by_name(cmd_ctx->lsm->session.name);
74babd95 2776 session_unlock_list();
54d01ffb
DG
2777 if (cmd_ctx->session == NULL) {
2778 if (cmd_ctx->lsm->session.name != NULL) {
2779 ret = LTTCOMM_SESS_NOT_FOUND;
2780 } else {
2781 /* If no session name specified */
2782 ret = LTTCOMM_SELECT_SESS;
2783 }
2784 goto error;
2785 } else {
2786 /* Acquire lock for the session */
2787 session_lock(cmd_ctx->session);
2788 }
2789 break;
2790 }
b389abbe 2791
54d01ffb
DG
2792 /*
2793 * Check domain type for specific "pre-action".
2794 */
2795 switch (cmd_ctx->lsm->domain.type) {
2796 case LTTNG_DOMAIN_KERNEL:
2797 /* Kernel tracer check */
2798 if (kernel_tracer_fd == 0) {
2799 /* Basically, load kernel tracer modules */
2800 init_kernel_tracer();
2801 if (kernel_tracer_fd == 0) {
2802 ret = LTTCOMM_KERN_NA;
2803 goto error;
2804 }
2805 }
5eb91c98 2806
54d01ffb 2807 /* Need a session for kernel command */
44d3bd01 2808 if (need_tracing_session) {
54d01ffb
DG
2809 if (cmd_ctx->session->kernel_session == NULL) {
2810 ret = create_kernel_session(cmd_ctx->session);
5eb91c98 2811 if (ret < 0) {
54d01ffb 2812 ret = LTTCOMM_KERN_SESS_FAIL;
5eb91c98
DG
2813 goto error;
2814 }
b389abbe 2815 }
7d29a247 2816
54d01ffb 2817 /* Start the kernel consumer daemon */
3bd1e081
MD
2818 pthread_mutex_lock(&kconsumer_data.pid_mutex);
2819 if (kconsumer_data.pid == 0 &&
54d01ffb 2820 cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) {
3bd1e081
MD
2821 pthread_mutex_unlock(&kconsumer_data.pid_mutex);
2822 ret = start_consumerd(&kconsumer_data);
7d29a247 2823 if (ret < 0) {
54d01ffb
DG
2824 ret = LTTCOMM_KERN_CONSUMER_FAIL;
2825 goto error;
950131af 2826 }
33a2b854 2827 }
3bd1e081 2828 pthread_mutex_unlock(&kconsumer_data.pid_mutex);
0d0c377a 2829 }
54d01ffb 2830 break;
2bdd86d4 2831 case LTTNG_DOMAIN_UST:
44d3bd01 2832 {
44d3bd01 2833 if (need_tracing_session) {
f6a9efaa 2834 if (cmd_ctx->session->ust_session == NULL) {
44d3bd01
DG
2835 ret = create_ust_session(cmd_ctx->session,
2836 &cmd_ctx->lsm->domain);
2837 if (ret != LTTCOMM_OK) {
2838 goto error;
2839 }
2840 }
2bdd86d4
MD
2841 /* Start the kernel consumer daemon */
2842 pthread_mutex_lock(&ustconsumer_data.pid_mutex);
2843 if (ustconsumer_data.pid == 0 &&
2844 cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) {
2845 pthread_mutex_unlock(&ustconsumer_data.pid_mutex);
2846 ret = start_consumerd(&ustconsumer_data);
2847 if (ret < 0) {
2848 ret = LTTCOMM_KERN_CONSUMER_FAIL;
2849 goto error;
2850 }
48842b30
DG
2851
2852 cmd_ctx->session->ust_session->consumer_fd =
2853 ustconsumer_data.cmd_sock;
2bdd86d4
MD
2854 }
2855 pthread_mutex_unlock(&ustconsumer_data.pid_mutex);
44d3bd01
DG
2856 }
2857 break;
48842b30 2858 }
54d01ffb 2859 default:
54d01ffb
DG
2860 break;
2861 }
33a2b854 2862
54d01ffb
DG
2863 /* Process by command type */
2864 switch (cmd_ctx->lsm->cmd_type) {
2865 case LTTNG_ADD_CONTEXT:
2866 {
2867 ret = cmd_add_context(cmd_ctx->session, cmd_ctx->lsm->domain.type,
2868 cmd_ctx->lsm->u.context.channel_name,
2869 cmd_ctx->lsm->u.context.event_name,
2870 &cmd_ctx->lsm->u.context.ctx);
2871 break;
2872 }
2873 case LTTNG_DISABLE_CHANNEL:
2874 {
2875 ret = cmd_disable_channel(cmd_ctx->session, cmd_ctx->lsm->domain.type,
2876 cmd_ctx->lsm->u.disable.channel_name);
2877 break;
2878 }
2879 case LTTNG_DISABLE_EVENT:
2880 {
2881 ret = cmd_disable_event(cmd_ctx->session, cmd_ctx->lsm->domain.type,
2882 cmd_ctx->lsm->u.disable.channel_name,
2883 cmd_ctx->lsm->u.disable.name);
33a2b854
DG
2884 ret = LTTCOMM_OK;
2885 break;
2886 }
54d01ffb
DG
2887 case LTTNG_DISABLE_ALL_EVENT:
2888 {
2bdd86d4 2889 DBG("Disabling all events");
54d01ffb
DG
2890
2891 ret = cmd_disable_event_all(cmd_ctx->session, cmd_ctx->lsm->domain.type,
2892 cmd_ctx->lsm->u.disable.channel_name);
2893 break;
2894 }
2895 case LTTNG_ENABLE_CHANNEL:
2896 {
44d3bd01 2897 ret = cmd_enable_channel(cmd_ctx->session, &cmd_ctx->lsm->domain,
54d01ffb
DG
2898 &cmd_ctx->lsm->u.channel.chan);
2899 break;
2900 }
2901 case LTTNG_ENABLE_EVENT:
2902 {
2903 ret = cmd_enable_event(cmd_ctx->session, cmd_ctx->lsm->domain.type,
2904 cmd_ctx->lsm->u.enable.channel_name,
2905 &cmd_ctx->lsm->u.enable.event);
2906 break;
2907 }
2908 case LTTNG_ENABLE_ALL_EVENT:
2909 {
2bdd86d4 2910 DBG("Enabling all events");
54d01ffb
DG
2911
2912 ret = cmd_enable_event_all(cmd_ctx->session, cmd_ctx->lsm->domain.type,
8c9ae521
DG
2913 cmd_ctx->lsm->u.enable.channel_name,
2914 cmd_ctx->lsm->u.enable.event.type);
54d01ffb
DG
2915 break;
2916 }
052da939 2917 case LTTNG_LIST_TRACEPOINTS:
2ef84c95 2918 {
9f19cc17 2919 struct lttng_event *events;
54d01ffb 2920 ssize_t nb_events;
052da939 2921
54d01ffb
DG
2922 nb_events = cmd_list_tracepoints(cmd_ctx->lsm->domain.type, &events);
2923 if (nb_events < 0) {
2924 ret = -nb_events;
2925 goto error;
2ef84c95
DG
2926 }
2927
2928 /*
2929 * Setup lttng message with payload size set to the event list size in
2930 * bytes and then copy list into the llm payload.
2931 */
052da939 2932 ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_event) * nb_events);
2ef84c95 2933 if (ret < 0) {
052da939 2934 free(events);
2ef84c95
DG
2935 goto setup_error;
2936 }
2937
2938 /* Copy event list into message payload */
9f19cc17 2939 memcpy(cmd_ctx->llm->payload, events,
052da939 2940 sizeof(struct lttng_event) * nb_events);
2ef84c95 2941
9f19cc17 2942 free(events);
2ef84c95
DG
2943
2944 ret = LTTCOMM_OK;
2945 break;
2946 }
f3ed775e 2947 case LTTNG_START_TRACE:
8c0faa1d 2948 {
54d01ffb 2949 ret = cmd_start_trace(cmd_ctx->session);
8c0faa1d
DG
2950 break;
2951 }
f3ed775e 2952 case LTTNG_STOP_TRACE:
8c0faa1d 2953 {
54d01ffb 2954 ret = cmd_stop_trace(cmd_ctx->session);
8c0faa1d
DG
2955 break;
2956 }
5e16da05
MD
2957 case LTTNG_CREATE_SESSION:
2958 {
54d01ffb
DG
2959 ret = cmd_create_session(cmd_ctx->lsm->session.name,
2960 cmd_ctx->lsm->session.path);
5e16da05
MD
2961 break;
2962 }
2963 case LTTNG_DESTROY_SESSION:
2964 {
54d01ffb
DG
2965 ret = cmd_destroy_session(cmd_ctx->session,
2966 cmd_ctx->lsm->session.name);
5461b305 2967 break;
5e16da05 2968 }
9f19cc17 2969 case LTTNG_LIST_DOMAINS:
5e16da05 2970 {
54d01ffb
DG
2971 ssize_t nb_dom;
2972 struct lttng_domain *domains;
5461b305 2973
54d01ffb
DG
2974 nb_dom = cmd_list_domains(cmd_ctx->session, &domains);
2975 if (nb_dom < 0) {
2976 ret = -nb_dom;
2977 goto error;
ce3d728c 2978 }
520ff687 2979
54d01ffb 2980 ret = setup_lttng_msg(cmd_ctx, nb_dom * sizeof(struct lttng_domain));
5461b305
DG
2981 if (ret < 0) {
2982 goto setup_error;
520ff687 2983 }
57167058 2984
54d01ffb
DG
2985 /* Copy event list into message payload */
2986 memcpy(cmd_ctx->llm->payload, domains,
2987 nb_dom * sizeof(struct lttng_domain));
2988
2989 free(domains);
5e16da05 2990
5461b305 2991 ret = LTTCOMM_OK;
5e16da05
MD
2992 break;
2993 }
9f19cc17 2994 case LTTNG_LIST_CHANNELS:
5e16da05 2995 {
54d01ffb
DG
2996 size_t nb_chan;
2997 struct lttng_channel *channels;
2998
2999 nb_chan = cmd_list_channels(cmd_ctx->session, &channels);
3000 if (nb_chan < 0) {
3001 ret = -nb_chan;
3002 goto error;
5461b305 3003 }
ca95a216 3004
54d01ffb 3005 ret = setup_lttng_msg(cmd_ctx, nb_chan * sizeof(struct lttng_channel));
5461b305
DG
3006 if (ret < 0) {
3007 goto setup_error;
3008 }
9f19cc17 3009
54d01ffb
DG
3010 /* Copy event list into message payload */
3011 memcpy(cmd_ctx->llm->payload, channels,
3012 nb_chan * sizeof(struct lttng_channel));
3013
3014 free(channels);
9f19cc17
DG
3015
3016 ret = LTTCOMM_OK;
5461b305 3017 break;
5e16da05 3018 }
9f19cc17 3019 case LTTNG_LIST_EVENTS:
5e16da05 3020 {
54d01ffb 3021 size_t nb_event;
684d34d2 3022 struct lttng_event *events = NULL;
9f19cc17 3023
54d01ffb
DG
3024 nb_event = cmd_list_events(cmd_ctx->session,
3025 cmd_ctx->lsm->u.list.channel_name, &events);
3026 if (nb_event < 0) {
3027 ret = -nb_event;
3028 goto error;
5461b305 3029 }
ca95a216 3030
54d01ffb 3031 ret = setup_lttng_msg(cmd_ctx, nb_event * sizeof(struct lttng_event));
5461b305
DG
3032 if (ret < 0) {
3033 goto setup_error;
3034 }
9f19cc17 3035
54d01ffb
DG
3036 /* Copy event list into message payload */
3037 memcpy(cmd_ctx->llm->payload, events,
3038 nb_event * sizeof(struct lttng_event));
9f19cc17 3039
54d01ffb 3040 free(events);
9f19cc17
DG
3041
3042 ret = LTTCOMM_OK;
5461b305 3043 break;
5e16da05
MD
3044 }
3045 case LTTNG_LIST_SESSIONS:
3046 {
54d01ffb 3047 session_lock_list();
5461b305 3048
6c9cc2ab 3049 if (session_list_ptr->count == 0) {
f3ed775e 3050 ret = LTTCOMM_NO_SESSION;
54d01ffb 3051 session_unlock_list();
5461b305 3052 goto error;
57167058 3053 }
5e16da05 3054
6c9cc2ab
DG
3055 ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_session) *
3056 session_list_ptr->count);
5461b305 3057 if (ret < 0) {
54d01ffb 3058 session_unlock_list();
5461b305 3059 goto setup_error;
e065084a 3060 }
5e16da05 3061
6c9cc2ab
DG
3062 /* Filled the session array */
3063 list_lttng_sessions((struct lttng_session *)(cmd_ctx->llm->payload));
3064
54d01ffb 3065 session_unlock_list();
5e16da05 3066
5461b305 3067 ret = LTTCOMM_OK;
5e16da05
MD
3068 break;
3069 }
d0254c7c
MD
3070 case LTTNG_CALIBRATE:
3071 {
54d01ffb
DG
3072 ret = cmd_calibrate(cmd_ctx->lsm->domain.type,
3073 &cmd_ctx->lsm->u.calibrate);
d0254c7c
MD
3074 break;
3075 }
d9800920
DG
3076 case LTTNG_REGISTER_CONSUMER:
3077 {
54d01ffb
DG
3078 ret = cmd_register_consumer(cmd_ctx->session, cmd_ctx->lsm->domain.type,
3079 cmd_ctx->lsm->u.reg.path);
d9800920
DG
3080 break;
3081 }
5e16da05 3082 default:
5e16da05 3083 ret = LTTCOMM_UND;
5461b305 3084 break;
fac6795d
DG
3085 }
3086
5461b305 3087error:
5461b305
DG
3088 if (cmd_ctx->llm == NULL) {
3089 DBG("Missing llm structure. Allocating one.");
894be886 3090 if (setup_lttng_msg(cmd_ctx, 0) < 0) {
5461b305
DG
3091 goto setup_error;
3092 }
3093 }
54d01ffb 3094 /* Set return code */
5461b305 3095 cmd_ctx->llm->ret_code = ret;
5461b305 3096setup_error:
b5541356 3097 if (cmd_ctx->session) {
54d01ffb 3098 session_unlock(cmd_ctx->session);
b5541356 3099 }
54d01ffb 3100init_setup_error:
8028d920 3101 return ret;
fac6795d
DG
3102}
3103
1d4b027a 3104/*
d063d709
DG
3105 * This thread manage all clients request using the unix client socket for
3106 * communication.
1d4b027a
DG
3107 */
3108static void *thread_manage_clients(void *data)
3109{
5eb91c98
DG
3110 int sock = 0, ret, i, pollfd;
3111 uint32_t revents, nb_fd;
273ea72c 3112 struct command_ctx *cmd_ctx = NULL;
5eb91c98 3113 struct lttng_poll_event events;
1d4b027a
DG
3114
3115 DBG("[thread] Manage client started");
3116
f6a9efaa
DG
3117 rcu_register_thread();
3118
1d4b027a
DG
3119 ret = lttcomm_listen_unix_sock(client_sock);
3120 if (ret < 0) {
3121 goto error;
3122 }
3123
5eb91c98
DG
3124 /*
3125 * Pass 2 as size here for the thread quit pipe and client_sock. Nothing
3126 * more will be added to this poll set.
3127 */
3128 ret = create_thread_poll_set(&events, 2);
3129 if (ret < 0) {
3130 goto error;
3131 }
273ea72c 3132
5eb91c98
DG
3133 /* Add the application registration socket */
3134 ret = lttng_poll_add(&events, client_sock, LPOLLIN | LPOLLPRI);
3135 if (ret < 0) {
3136 goto error;
3137 }
273ea72c 3138
bbd973c2
DG
3139 /*
3140 * Notify parent pid that we are ready to accept command for client side.
1d4b027a
DG
3141 */
3142 if (opt_sig_parent) {
3143 kill(ppid, SIGCHLD);
3144 }
3145
3146 while (1) {
1d4b027a 3147 DBG("Accepting client command ...");
273ea72c 3148
5eb91c98
DG
3149 nb_fd = LTTNG_POLL_GETNB(&events);
3150
273ea72c 3151 /* Inifinite blocking call, waiting for transmission */
5eb91c98 3152 ret = lttng_poll_wait(&events, -1);
273ea72c 3153 if (ret < 0) {
273ea72c
DG
3154 goto error;
3155 }
3156
5eb91c98
DG
3157 for (i = 0; i < nb_fd; i++) {
3158 /* Fetch once the poll data */
3159 revents = LTTNG_POLL_GETEV(&events, i);
3160 pollfd = LTTNG_POLL_GETFD(&events, i);
3161
3162 /* Thread quit pipe has been closed. Killing thread. */
3163 ret = check_thread_quit_pipe(pollfd, revents);
3164 if (ret) {
3165 goto error;
3166 }
3167
3168 /* Event on the registration socket */
3169 if (pollfd == client_sock) {
3170 if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
3171 ERR("Client socket poll error");
3172 goto error;
3173 }
3174 }
3175 }
3176
3177 DBG("Wait for client response");
3178
3179 sock = lttcomm_accept_unix_sock(client_sock);
3180 if (sock < 0) {
273ea72c 3181 goto error;
273ea72c
DG
3182 }
3183
5eb91c98
DG
3184 /* Allocate context command to process the client request */
3185 cmd_ctx = malloc(sizeof(struct command_ctx));
3186 if (cmd_ctx == NULL) {
3187 perror("malloc cmd_ctx");
1d4b027a 3188 goto error;
5eb91c98 3189 }
1d4b027a 3190
5eb91c98
DG
3191 /* Allocate data buffer for reception */
3192 cmd_ctx->lsm = malloc(sizeof(struct lttcomm_session_msg));
3193 if (cmd_ctx->lsm == NULL) {
3194 perror("malloc cmd_ctx->lsm");
3195 goto error;
3196 }
1d4b027a 3197
5eb91c98
DG
3198 cmd_ctx->llm = NULL;
3199 cmd_ctx->session = NULL;
1d4b027a 3200
5eb91c98
DG
3201 /*
3202 * Data is received from the lttng client. The struct
3203 * lttcomm_session_msg (lsm) contains the command and data request of
3204 * the client.
3205 */
3206 DBG("Receiving data from client ...");
3207 ret = lttcomm_recv_unix_sock(sock, cmd_ctx->lsm,
3208 sizeof(struct lttcomm_session_msg));
3209 if (ret <= 0) {
3210 DBG("Nothing recv() from client... continuing");
3211 close(sock);
3212 free(cmd_ctx);
3213 continue;
3214 }
1d4b027a 3215
5eb91c98
DG
3216 // TODO: Validate cmd_ctx including sanity check for
3217 // security purpose.
f7776ea7 3218
f6a9efaa 3219 rcu_thread_online();
5eb91c98
DG
3220 /*
3221 * This function dispatch the work to the kernel or userspace tracer
3222 * libs and fill the lttcomm_lttng_msg data structure of all the needed
3223 * informations for the client. The command context struct contains
3224 * everything this function may needs.
3225 */
3226 ret = process_client_msg(cmd_ctx);
f6a9efaa 3227 rcu_thread_offline();
5eb91c98 3228 if (ret < 0) {
bbd973c2 3229 /*
5eb91c98
DG
3230 * TODO: Inform client somehow of the fatal error. At
3231 * this point, ret < 0 means that a malloc failed
3232 * (ENOMEM). Error detected but still accept command.
bbd973c2 3233 */
bbd973c2 3234 clean_command_ctx(&cmd_ctx);
5eb91c98
DG
3235 continue;
3236 }
d6e4fca4 3237
54d01ffb
DG
3238 DBG("Sending response (size: %d, retcode: %s)",
3239 cmd_ctx->lttng_msg_size,
9a745bc7 3240 lttng_strerror(-cmd_ctx->llm->ret_code));
54d01ffb 3241 ret = send_unix_sock(sock, cmd_ctx->llm, cmd_ctx->lttng_msg_size);
5eb91c98
DG
3242 if (ret < 0) {
3243 ERR("Failed to send data back to client");
bbd973c2 3244 }
1d4b027a 3245
5eb91c98
DG
3246 clean_command_ctx(&cmd_ctx);
3247
3248 /* End of transmission */
273ea72c
DG
3249 close(sock);
3250 }
3251
5eb91c98
DG
3252error:
3253 DBG("Client thread dying");
273ea72c 3254 unlink(client_unix_sock_path);
5eb91c98
DG
3255 close(client_sock);
3256 close(sock);
273ea72c 3257
5eb91c98 3258 lttng_poll_clean(&events);
a2fb29a5 3259 clean_command_ctx(&cmd_ctx);
f6a9efaa
DG
3260
3261 rcu_unregister_thread();
1d4b027a
DG
3262 return NULL;
3263}
3264
3265
fac6795d
DG
3266/*
3267 * usage function on stderr
3268 */
3269static void usage(void)
3270{
b716ce68 3271 fprintf(stderr, "Usage: %s OPTIONS\n\nOptions:\n", progname);
d6f42150
DG
3272 fprintf(stderr, " -h, --help Display this usage.\n");
3273 fprintf(stderr, " -c, --client-sock PATH Specify path for the client unix socket\n");
3274 fprintf(stderr, " -a, --apps-sock PATH Specify path for apps unix socket\n");
3275 fprintf(stderr, " --kconsumerd-err-sock PATH Specify path for the kernel consumer error socket\n");
3276 fprintf(stderr, " --kconsumerd-cmd-sock PATH Specify path for the kernel consumer command socket\n");
3bd1e081
MD
3277 fprintf(stderr, " --ustconsumerd-err-sock PATH Specify path for the UST consumer error socket\n");
3278 fprintf(stderr, " --ustconsumerd-cmd-sock PATH Specify path for the UST consumer command socket\n");
d6f42150
DG
3279 fprintf(stderr, " -d, --daemonize Start as a daemon.\n");
3280 fprintf(stderr, " -g, --group NAME Specify the tracing group name. (default: tracing)\n");
3281 fprintf(stderr, " -V, --version Show version number.\n");
3282 fprintf(stderr, " -S, --sig-parent Send SIGCHLD to parent pid to notify readiness.\n");
3283 fprintf(stderr, " -q, --quiet No output at all.\n");
3284 fprintf(stderr, " -v, --verbose Verbose mode. Activate DBG() macro.\n");
3bd1e081 3285 fprintf(stderr, " --verbose-consumer Verbose mode for consumer. Activate DBG() macro.\n");
fac6795d
DG
3286}
3287
3288/*
3289 * daemon argument parsing
3290 */
3291static int parse_args(int argc, char **argv)
3292{
3293 int c;
3294
3295 static struct option long_options[] = {
3296 { "client-sock", 1, 0, 'c' },
3297 { "apps-sock", 1, 0, 'a' },
3bd1e081
MD
3298 { "kconsumerd-cmd-sock", 1, 0, 'C' },
3299 { "kconsumerd-err-sock", 1, 0, 'E' },
3300 { "ustconsumerd-cmd-sock", 1, 0, 'D' },
3301 { "ustconsumerd-err-sock", 1, 0, 'F' },
fac6795d 3302 { "daemonize", 0, 0, 'd' },
5b8719f5 3303 { "sig-parent", 0, 0, 'S' },
fac6795d
DG
3304 { "help", 0, 0, 'h' },
3305 { "group", 1, 0, 'g' },
3306 { "version", 0, 0, 'V' },
75462a81 3307 { "quiet", 0, 0, 'q' },
3f9947db 3308 { "verbose", 0, 0, 'v' },
3bd1e081 3309 { "verbose-consumer", 0, 0, 'Z' },
fac6795d
DG
3310 { NULL, 0, 0, 0 }
3311 };
3312
3313 while (1) {
3314 int option_index = 0;
3bd1e081 3315 c = getopt_long(argc, argv, "dhqvVS" "a:c:g:s:C:E:D:F:Z",
54d01ffb 3316 long_options, &option_index);
fac6795d
DG
3317 if (c == -1) {
3318 break;
3319 }
3320
3321 switch (c) {
3322 case 0:
3323 fprintf(stderr, "option %s", long_options[option_index].name);
3324 if (optarg) {
3325 fprintf(stderr, " with arg %s\n", optarg);
3326 }
3327 break;
b716ce68 3328 case 'c':
fac6795d
DG
3329 snprintf(client_unix_sock_path, PATH_MAX, "%s", optarg);
3330 break;
3331 case 'a':
3332 snprintf(apps_unix_sock_path, PATH_MAX, "%s", optarg);
3333 break;
3334 case 'd':
3335 opt_daemon = 1;
3336 break;
3337 case 'g':
3338 opt_tracing_group = strdup(optarg);
3339 break;
3340 case 'h':
3341 usage();
3342 exit(EXIT_FAILURE);
3343 case 'V':
3344 fprintf(stdout, "%s\n", VERSION);
3345 exit(EXIT_SUCCESS);
5b8719f5
DG
3346 case 'S':
3347 opt_sig_parent = 1;
3348 break;
d6f42150 3349 case 'E':
3bd1e081 3350 snprintf(kconsumer_data.err_unix_sock_path, PATH_MAX, "%s", optarg);
d6f42150
DG
3351 break;
3352 case 'C':
3bd1e081
MD
3353 snprintf(kconsumer_data.cmd_unix_sock_path, PATH_MAX, "%s", optarg);
3354 break;
3355 case 'F':
3356 snprintf(ustconsumer_data.err_unix_sock_path, PATH_MAX, "%s", optarg);
3357 break;
3358 case 'D':
3359 snprintf(ustconsumer_data.cmd_unix_sock_path, PATH_MAX, "%s", optarg);
d6f42150 3360 break;
75462a81
DG
3361 case 'q':
3362 opt_quiet = 1;
3363 break;
3f9947db 3364 case 'v':
53086306
DG
3365 /* Verbose level can increase using multiple -v */
3366 opt_verbose += 1;
3f9947db 3367 break;
31f73cc9 3368 case 'Z':
3bd1e081 3369 opt_verbose_consumer += 1;
31f73cc9 3370 break;
fac6795d
DG
3371 default:
3372 /* Unknown option or other error.
3373 * Error is printed by getopt, just return */
3374 return -1;
3375 }
3376 }
3377
3378 return 0;
3379}
3380
3381/*
d063d709 3382 * Creates the two needed socket by the daemon.
d6f42150
DG
3383 * apps_sock - The communication socket for all UST apps.
3384 * client_sock - The communication of the cli tool (lttng).
fac6795d 3385 */
cf3af59e 3386static int init_daemon_socket(void)
fac6795d
DG
3387{
3388 int ret = 0;
3389 mode_t old_umask;
3390
3391 old_umask = umask(0);
3392
3393 /* Create client tool unix socket */
d6f42150
DG
3394 client_sock = lttcomm_create_unix_sock(client_unix_sock_path);
3395 if (client_sock < 0) {
3396 ERR("Create unix sock failed: %s", client_unix_sock_path);
fac6795d
DG
3397 ret = -1;
3398 goto end;
3399 }
3400
3401 /* File permission MUST be 660 */
3402 ret = chmod(client_unix_sock_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
3403 if (ret < 0) {
d6f42150 3404 ERR("Set file permissions failed: %s", client_unix_sock_path);
fac6795d
DG
3405 perror("chmod");
3406 goto end;
3407 }
3408
3409 /* Create the application unix socket */
d6f42150
DG
3410 apps_sock = lttcomm_create_unix_sock(apps_unix_sock_path);
3411 if (apps_sock < 0) {
3412 ERR("Create unix sock failed: %s", apps_unix_sock_path);
fac6795d
DG
3413 ret = -1;
3414 goto end;
3415 }
3416
d6f42150 3417 /* File permission MUST be 666 */
54d01ffb
DG
3418 ret = chmod(apps_unix_sock_path,
3419 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
fac6795d 3420 if (ret < 0) {
d6f42150 3421 ERR("Set file permissions failed: %s", apps_unix_sock_path);
fac6795d
DG
3422 perror("chmod");
3423 goto end;
3424 }
3425
3426end:
3427 umask(old_umask);
3428 return ret;
3429}
3430
3431/*
54d01ffb
DG
3432 * Check if the global socket is available, and if a daemon is answering at the
3433 * other side. If yes, error is returned.
fac6795d 3434 */
cf3af59e 3435static int check_existing_daemon(void)
fac6795d 3436{
7d8234d9 3437 if (access(client_unix_sock_path, F_OK) < 0 &&
099e26bd 3438 access(apps_unix_sock_path, F_OK) < 0) {
7d8234d9 3439 return 0;
099e26bd 3440 }
54d01ffb 3441
7d8234d9 3442 /* Is there anybody out there ? */
099e26bd 3443 if (lttng_session_daemon_alive()) {
7d8234d9 3444 return -EEXIST;
099e26bd 3445 } else {
7d8234d9 3446 return 0;
099e26bd 3447 }
fac6795d
DG
3448}
3449
fac6795d 3450/*
d063d709 3451 * Set the tracing group gid onto the client socket.
5e16da05 3452 *
d063d709
DG
3453 * Race window between mkdir and chown is OK because we are going from more
3454 * permissive (root.root) to les permissive (root.tracing).
fac6795d 3455 */
d6f42150 3456static int set_permissions(void)
fac6795d
DG
3457{
3458 int ret;
996b65c8 3459 gid_t gid;
fac6795d 3460
996b65c8
MD
3461 gid = allowed_group();
3462 if (gid < 0) {
a463f419
DG
3463 if (is_root) {
3464 WARN("No tracing group detected");
3465 ret = 0;
3466 } else {
3467 ERR("Missing tracing group. Aborting execution.");
3468 ret = -1;
3469 }
fac6795d
DG
3470 goto end;
3471 }
3472
d6f42150 3473 /* Set lttng run dir */
996b65c8 3474 ret = chown(LTTNG_RUNDIR, 0, gid);
d6f42150
DG
3475 if (ret < 0) {
3476 ERR("Unable to set group on " LTTNG_RUNDIR);
3477 perror("chown");
3478 }
3479
3480 /* lttng client socket path */
996b65c8 3481 ret = chown(client_unix_sock_path, 0, gid);
fac6795d 3482 if (ret < 0) {
d6f42150
DG
3483 ERR("Unable to set group on %s", client_unix_sock_path);
3484 perror("chown");
3485 }
3486
3bd1e081
MD
3487 /* kconsumer error socket path */
3488 ret = chown(kconsumer_data.err_unix_sock_path, 0, gid);
d6f42150 3489 if (ret < 0) {
3bd1e081
MD
3490 ERR("Unable to set group on %s", kconsumer_data.err_unix_sock_path);
3491 perror("chown");
3492 }
3493
3494 /* ustconsumer error socket path */
3495 ret = chown(ustconsumer_data.err_unix_sock_path, 0, gid);
3496 if (ret < 0) {
3497 ERR("Unable to set group on %s", ustconsumer_data.err_unix_sock_path);
fac6795d
DG
3498 perror("chown");
3499 }
3500
d6f42150 3501 DBG("All permissions are set");
e07ae692 3502
fac6795d
DG
3503end:
3504 return ret;
3505}
3506
7a485870 3507/*
d063d709 3508 * Create the pipe used to wake up the kernel thread.
7a485870
DG
3509 */
3510static int create_kernel_poll_pipe(void)
3511{
3512 return pipe2(kernel_poll_pipe, O_CLOEXEC);
3513}
3514
099e26bd
DG
3515/*
3516 * Create the application command pipe to wake thread_manage_apps.
3517 */
3518static int create_apps_cmd_pipe(void)
3519{
3520 return pipe2(apps_cmd_pipe, O_CLOEXEC);
3521}
3522
d6f42150 3523/*
d063d709 3524 * Create the lttng run directory needed for all global sockets and pipe.
d6f42150
DG
3525 */
3526static int create_lttng_rundir(void)
3527{
3528 int ret;
3529
3530 ret = mkdir(LTTNG_RUNDIR, S_IRWXU | S_IRWXG );
3531 if (ret < 0) {
b1f11e69
DG
3532 if (errno != EEXIST) {
3533 ERR("Unable to create " LTTNG_RUNDIR);
3534 goto error;
3535 } else {
3536 ret = 0;
3537 }
d6f42150
DG
3538 }
3539
3540error:
3541 return ret;
3542}
3543
3544/*
d063d709
DG
3545 * Setup sockets and directory needed by the kconsumerd communication with the
3546 * session daemon.
d6f42150 3547 */
3bd1e081 3548static int set_consumer_sockets(struct consumer_data *consumer_data)
d6f42150
DG
3549{
3550 int ret;
3bd1e081
MD
3551 const char *path = consumer_data->type == LTTNG_CONSUMER_KERNEL ?
3552 KCONSUMERD_PATH : USTCONSUMERD_PATH;
d6f42150 3553
3bd1e081
MD
3554 if (strlen(consumer_data->err_unix_sock_path) == 0) {
3555 snprintf(consumer_data->err_unix_sock_path, PATH_MAX,
3556 consumer_data->type == LTTNG_CONSUMER_KERNEL ?
3557 KCONSUMERD_ERR_SOCK_PATH :
3558 USTCONSUMERD_ERR_SOCK_PATH);
d6f42150
DG
3559 }
3560
3bd1e081
MD
3561 if (strlen(consumer_data->cmd_unix_sock_path) == 0) {
3562 snprintf(consumer_data->cmd_unix_sock_path, PATH_MAX,
3563 consumer_data->type == LTTNG_CONSUMER_KERNEL ?
3564 KCONSUMERD_CMD_SOCK_PATH :
3565 USTCONSUMERD_CMD_SOCK_PATH);
d6f42150
DG
3566 }
3567
3bd1e081 3568 ret = mkdir(path, S_IRWXU | S_IRWXG);
d6f42150 3569 if (ret < 0) {
6beb2242 3570 if (errno != EEXIST) {
3bd1e081 3571 ERR("Failed to create %s", path);
6beb2242
DG
3572 goto error;
3573 }
3574 ret = 0;
d6f42150
DG
3575 }
3576
3577 /* Create the kconsumerd error unix socket */
3bd1e081
MD
3578 consumer_data->err_sock =
3579 lttcomm_create_unix_sock(consumer_data->err_unix_sock_path);
3580 if (consumer_data->err_sock < 0) {
3581 ERR("Create unix sock failed: %s", consumer_data->err_unix_sock_path);
d6f42150
DG
3582 ret = -1;
3583 goto error;
3584 }
3585
3586 /* File permission MUST be 660 */
3bd1e081 3587 ret = chmod(consumer_data->err_unix_sock_path,
54d01ffb 3588 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
d6f42150 3589 if (ret < 0) {
3bd1e081 3590 ERR("Set file permissions failed: %s", consumer_data->err_unix_sock_path);
d6f42150
DG
3591 perror("chmod");
3592 goto error;
3593 }
3594
3595error:
3596 return ret;
3597}
3598
fac6795d 3599/*
d063d709 3600 * Signal handler for the daemon
cf3af59e 3601 *
54d01ffb
DG
3602 * Simply stop all worker threads, leaving main() return gracefully after
3603 * joining all threads and calling cleanup().
fac6795d
DG
3604 */
3605static void sighandler(int sig)
3606{
3607 switch (sig) {
cf3af59e
MD
3608 case SIGPIPE:
3609 DBG("SIGPIPE catched");
3610 return;
3611 case SIGINT:
3612 DBG("SIGINT catched");
3613 stop_threads();
3614 break;
3615 case SIGTERM:
3616 DBG("SIGTERM catched");
3617 stop_threads();
3618 break;
3619 default:
3620 break;
fac6795d 3621 }
fac6795d
DG
3622}
3623
3624/*
d063d709 3625 * Setup signal handler for :
1d4b027a 3626 * SIGINT, SIGTERM, SIGPIPE
fac6795d 3627 */
1d4b027a 3628static int set_signal_handler(void)
fac6795d 3629{
1d4b027a
DG
3630 int ret = 0;
3631 struct sigaction sa;
3632 sigset_t sigset;
fac6795d 3633
1d4b027a
DG
3634 if ((ret = sigemptyset(&sigset)) < 0) {
3635 perror("sigemptyset");
3636 return ret;
3637 }
d6f42150 3638
1d4b027a
DG
3639 sa.sa_handler = sighandler;
3640 sa.sa_mask = sigset;
3641 sa.sa_flags = 0;
3642 if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
3643 perror("sigaction");
3644 return ret;
d6f42150
DG
3645 }
3646
1d4b027a
DG
3647 if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
3648 perror("sigaction");
3649 return ret;
d6f42150 3650 }
aaf26714 3651
1d4b027a
DG
3652 if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
3653 perror("sigaction");
3654 return ret;
8c0faa1d
DG
3655 }
3656
1d4b027a
DG
3657 DBG("Signal handler set for SIGTERM, SIGPIPE and SIGINT");
3658
3659 return ret;
fac6795d
DG
3660}
3661
f3ed775e 3662/*
d063d709
DG
3663 * Set open files limit to unlimited. This daemon can open a large number of
3664 * file descriptors in order to consumer multiple kernel traces.
f3ed775e
DG
3665 */
3666static void set_ulimit(void)
3667{
3668 int ret;
3669 struct rlimit lim;
3670
a88df331 3671 /* The kernel does not allowed an infinite limit for open files */
f3ed775e
DG
3672 lim.rlim_cur = 65535;
3673 lim.rlim_max = 65535;
3674
3675 ret = setrlimit(RLIMIT_NOFILE, &lim);
3676 if (ret < 0) {
3677 perror("failed to set open files limit");
3678 }
3679}
3680
fac6795d
DG
3681/*
3682 * main
3683 */
3684int main(int argc, char **argv)
3685{
fac6795d
DG
3686 int ret = 0;
3687 void *status;
b082db07 3688 const char *home_path;
fac6795d 3689
f6a9efaa
DG
3690 rcu_register_thread();
3691
273ea72c 3692 /* Create thread quit pipe */
cf3af59e
MD
3693 if ((ret = init_thread_quit_pipe()) < 0) {
3694 goto error;
273ea72c
DG
3695 }
3696
fac6795d
DG
3697 /* Parse arguments */
3698 progname = argv[0];
3699 if ((ret = parse_args(argc, argv) < 0)) {
cf3af59e 3700 goto error;
fac6795d
DG
3701 }
3702
3703 /* Daemonize */
3704 if (opt_daemon) {
53094c05
DG
3705 ret = daemon(0, 0);
3706 if (ret < 0) {
3707 perror("daemon");
cf3af59e 3708 goto error;
53094c05 3709 }
fac6795d
DG
3710 }
3711
3712 /* Check if daemon is UID = 0 */
3713 is_root = !getuid();
3714
fac6795d 3715 if (is_root) {
d6f42150
DG
3716 ret = create_lttng_rundir();
3717 if (ret < 0) {
cf3af59e 3718 goto error;
d6f42150
DG
3719 }
3720
fac6795d 3721 if (strlen(apps_unix_sock_path) == 0) {
d6f42150
DG
3722 snprintf(apps_unix_sock_path, PATH_MAX,
3723 DEFAULT_GLOBAL_APPS_UNIX_SOCK);
fac6795d
DG
3724 }
3725
3726 if (strlen(client_unix_sock_path) == 0) {
d6f42150
DG
3727 snprintf(client_unix_sock_path, PATH_MAX,
3728 DEFAULT_GLOBAL_CLIENT_UNIX_SOCK);
3729 }
0fdd1e2c
DG
3730
3731 /* Set global SHM for ust */
3732 if (strlen(wait_shm_path) == 0) {
3733 snprintf(wait_shm_path, PATH_MAX,
3734 DEFAULT_GLOBAL_APPS_WAIT_SHM_PATH);
3735 }
fac6795d 3736 } else {
b082db07
DG
3737 home_path = get_home_dir();
3738 if (home_path == NULL) {
273ea72c
DG
3739 /* TODO: Add --socket PATH option */
3740 ERR("Can't get HOME directory for sockets creation.");
cf3af59e
MD
3741 ret = -EPERM;
3742 goto error;
b082db07
DG
3743 }
3744
fac6795d 3745 if (strlen(apps_unix_sock_path) == 0) {
d6f42150 3746 snprintf(apps_unix_sock_path, PATH_MAX,
b082db07 3747 DEFAULT_HOME_APPS_UNIX_SOCK, home_path);
fac6795d
DG
3748 }
3749
3750 /* Set the cli tool unix socket path */
3751 if (strlen(client_unix_sock_path) == 0) {
d6f42150 3752 snprintf(client_unix_sock_path, PATH_MAX,
b082db07 3753 DEFAULT_HOME_CLIENT_UNIX_SOCK, home_path);
fac6795d 3754 }
0fdd1e2c
DG
3755
3756 /* Set global SHM for ust */
3757 if (strlen(wait_shm_path) == 0) {
3758 snprintf(wait_shm_path, PATH_MAX,
3759 DEFAULT_HOME_APPS_WAIT_SHM_PATH, geteuid());
3760 }
fac6795d
DG
3761 }
3762
847177cd
DG
3763 DBG("Client socket path %s", client_unix_sock_path);
3764 DBG("Application socket path %s", apps_unix_sock_path);
3765
273ea72c 3766 /*
7d8234d9 3767 * See if daemon already exist.
fac6795d 3768 */
7d8234d9 3769 if ((ret = check_existing_daemon()) < 0) {
75462a81 3770 ERR("Already running daemon.\n");
273ea72c 3771 /*
cf3af59e
MD
3772 * We do not goto exit because we must not cleanup()
3773 * because a daemon is already running.
ab118b20 3774 */
cf3af59e 3775 goto error;
a88df331
DG
3776 }
3777
54d01ffb 3778 /* After this point, we can safely call cleanup() with "goto exit" */
a88df331
DG
3779
3780 /*
3781 * These actions must be executed as root. We do that *after* setting up
3782 * the sockets path because we MUST make the check for another daemon using
3783 * those paths *before* trying to set the kernel consumer sockets and init
3784 * kernel tracer.
3785 */
3786 if (is_root) {
3bd1e081
MD
3787 ret = set_consumer_sockets(&kconsumer_data);
3788 if (ret < 0) {
3789 goto exit;
3790 }
48842b30 3791
3bd1e081 3792 ret = set_consumer_sockets(&ustconsumer_data);
a88df331 3793 if (ret < 0) {
cf3af59e 3794 goto exit;
a88df331 3795 }
a88df331
DG
3796 /* Setup kernel tracer */
3797 init_kernel_tracer();
3798
3799 /* Set ulimit for open files */
3800 set_ulimit();
fac6795d
DG
3801 }
3802
cf3af59e
MD
3803 if ((ret = set_signal_handler()) < 0) {
3804 goto exit;
fac6795d
DG
3805 }
3806
d6f42150 3807 /* Setup the needed unix socket */
cf3af59e
MD
3808 if ((ret = init_daemon_socket()) < 0) {
3809 goto exit;
fac6795d
DG
3810 }
3811
3812 /* Set credentials to socket */
cf3af59e
MD
3813 if (is_root && ((ret = set_permissions()) < 0)) {
3814 goto exit;
fac6795d
DG
3815 }
3816
5b8719f5
DG
3817 /* Get parent pid if -S, --sig-parent is specified. */
3818 if (opt_sig_parent) {
3819 ppid = getppid();
3820 }
3821
7a485870 3822 /* Setup the kernel pipe for waking up the kernel thread */
cf3af59e
MD
3823 if ((ret = create_kernel_poll_pipe()) < 0) {
3824 goto exit;
7a485870
DG
3825 }
3826
099e26bd
DG
3827 /* Setup the thread apps communication pipe. */
3828 if ((ret = create_apps_cmd_pipe()) < 0) {
3829 goto exit;
3830 }
3831
3832 /* Init UST command queue. */
3833 cds_wfq_init(&ust_cmd_queue.queue);
3834
f6a9efaa
DG
3835 /* Init UST app hash table */
3836 ust_app_ht_alloc();
3837
273ea72c 3838 /*
54d01ffb
DG
3839 * Get session list pointer. This pointer MUST NOT be free(). This list is
3840 * statically declared in session.c
273ea72c 3841 */
54d01ffb 3842 session_list_ptr = session_get_list();
b5541356 3843
5eb91c98
DG
3844 /* Set up max poll set size */
3845 lttng_poll_set_max_size();
3846
cf3af59e 3847 /* Create thread to manage the client socket */
099e26bd
DG
3848 ret = pthread_create(&client_thread, NULL,
3849 thread_manage_clients, (void *) NULL);
cf3af59e 3850 if (ret != 0) {
099e26bd 3851 perror("pthread_create clients");
cf3af59e
MD
3852 goto exit_client;
3853 }
fac6795d 3854
099e26bd
DG
3855 /* Create thread to dispatch registration */
3856 ret = pthread_create(&dispatch_thread, NULL,
3857 thread_dispatch_ust_registration, (void *) NULL);
3858 if (ret != 0) {
3859 perror("pthread_create dispatch");
3860 goto exit_dispatch;
3861 }
3862
3863 /* Create thread to manage application registration. */
3864 ret = pthread_create(&reg_apps_thread, NULL,
3865 thread_registration_apps, (void *) NULL);
3866 if (ret != 0) {
3867 perror("pthread_create registration");
3868 goto exit_reg_apps;
3869 }
3870
cf3af59e 3871 /* Create thread to manage application socket */
54d01ffb
DG
3872 ret = pthread_create(&apps_thread, NULL,
3873 thread_manage_apps, (void *) NULL);
cf3af59e 3874 if (ret != 0) {
099e26bd 3875 perror("pthread_create apps");
cf3af59e
MD
3876 goto exit_apps;
3877 }
fac6795d 3878
cf3af59e 3879 /* Create kernel thread to manage kernel event */
54d01ffb
DG
3880 ret = pthread_create(&kernel_thread, NULL,
3881 thread_manage_kernel, (void *) NULL);
cf3af59e 3882 if (ret != 0) {
099e26bd 3883 perror("pthread_create kernel");
cf3af59e
MD
3884 goto exit_kernel;
3885 }
7a485870 3886
cf3af59e
MD
3887 ret = pthread_join(kernel_thread, &status);
3888 if (ret != 0) {
3889 perror("pthread_join");
3890 goto error; /* join error, exit without cleanup */
fac6795d
DG
3891 }
3892
cf3af59e
MD
3893exit_kernel:
3894 ret = pthread_join(apps_thread, &status);
3895 if (ret != 0) {
3896 perror("pthread_join");
3897 goto error; /* join error, exit without cleanup */
3898 }
fac6795d 3899
cf3af59e 3900exit_apps:
099e26bd
DG
3901 ret = pthread_join(reg_apps_thread, &status);
3902 if (ret != 0) {
3903 perror("pthread_join");
3904 goto error; /* join error, exit without cleanup */
3905 }
3906
3907exit_reg_apps:
3908 ret = pthread_join(dispatch_thread, &status);
3909 if (ret != 0) {
3910 perror("pthread_join");
3911 goto error; /* join error, exit without cleanup */
3912 }
3913
3914exit_dispatch:
cf3af59e
MD
3915 ret = pthread_join(client_thread, &status);
3916 if (ret != 0) {
3917 perror("pthread_join");
3918 goto error; /* join error, exit without cleanup */
3919 }
3920
3bd1e081 3921 ret = join_consumer_thread(&kconsumer_data);
cf3af59e 3922 if (ret != 0) {
3bd1e081 3923 perror("join_consumer");
cf3af59e
MD
3924 goto error; /* join error, exit without cleanup */
3925 }
a88df331 3926
cf3af59e 3927exit_client:
a88df331 3928exit:
cf3af59e
MD
3929 /*
3930 * cleanup() is called when no other thread is running.
3931 */
f6a9efaa 3932 rcu_thread_online();
cf3af59e 3933 cleanup();
f6a9efaa
DG
3934 rcu_thread_offline();
3935 rcu_unregister_thread();
cf3af59e
MD
3936 if (!ret)
3937 exit(EXIT_SUCCESS);
3938error:
5e16da05 3939 exit(EXIT_FAILURE);
fac6795d 3940}
This page took 0.243127 seconds and 4 git commands to generate.