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