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