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