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