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