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