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