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