2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 * Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License, version 2 only,
7 * as published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License along
15 * with this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 #include <semaphore.h>
30 #include <sys/mount.h>
31 #include <sys/resource.h>
32 #include <sys/socket.h>
34 #include <sys/types.h>
36 #include <urcu/uatomic.h>
40 #include <common/common.h>
41 #include <common/compat/poll.h>
42 #include <common/compat/socket.h>
43 #include <common/defaults.h>
44 #include <common/kernel-consumer/kernel-consumer.h>
45 #include <common/ust-consumer/ust-consumer.h>
46 #include <common/futex.h>
48 #include "lttng-sessiond.h"
53 #include "kernel-consumer.h"
60 #define CONSUMERD_FILE "lttng-consumerd"
63 const char default_home_dir
[] = DEFAULT_HOME_DIR
;
64 const char default_tracing_group
[] = DEFAULT_TRACING_GROUP
;
65 const char default_ust_sock_dir
[] = DEFAULT_UST_SOCK_DIR
;
66 const char default_global_apps_pipe
[] = DEFAULT_GLOBAL_APPS_PIPE
;
69 const char *opt_tracing_group
;
70 static int opt_sig_parent
;
71 static int opt_verbose_consumer
;
72 static int opt_daemon
;
73 static int opt_no_kernel
;
74 static int is_root
; /* Set to 1 if the daemon is running as root */
75 static pid_t ppid
; /* Parent PID for --sig-parent option */
78 /* Consumer daemon specific control data */
79 static struct consumer_data kconsumer_data
= {
80 .type
= LTTNG_CONSUMER_KERNEL
,
81 .err_unix_sock_path
= DEFAULT_KCONSUMERD_ERR_SOCK_PATH
,
82 .cmd_unix_sock_path
= DEFAULT_KCONSUMERD_CMD_SOCK_PATH
,
86 static struct consumer_data ustconsumer64_data
= {
87 .type
= LTTNG_CONSUMER64_UST
,
88 .err_unix_sock_path
= DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH
,
89 .cmd_unix_sock_path
= DEFAULT_USTCONSUMERD64_CMD_SOCK_PATH
,
93 static struct consumer_data ustconsumer32_data
= {
94 .type
= LTTNG_CONSUMER32_UST
,
95 .err_unix_sock_path
= DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH
,
96 .cmd_unix_sock_path
= DEFAULT_USTCONSUMERD32_CMD_SOCK_PATH
,
101 static int dispatch_thread_exit
;
103 /* Global application Unix socket path */
104 static char apps_unix_sock_path
[PATH_MAX
];
105 /* Global client Unix socket path */
106 static char client_unix_sock_path
[PATH_MAX
];
107 /* global wait shm path for UST */
108 static char wait_shm_path
[PATH_MAX
];
110 /* Sockets and FDs */
111 static int client_sock
= -1;
112 static int apps_sock
= -1;
113 static int kernel_tracer_fd
= -1;
114 static int kernel_poll_pipe
[2] = { -1, -1 };
117 * Quit pipe for all threads. This permits a single cancellation point
118 * for all threads when receiving an event on the pipe.
120 static int thread_quit_pipe
[2] = { -1, -1 };
123 * This pipe is used to inform the thread managing application communication
124 * that a command is queued and ready to be processed.
126 static int apps_cmd_pipe
[2] = { -1, -1 };
128 /* Pthread, Mutexes and Semaphores */
129 static pthread_t apps_thread
;
130 static pthread_t reg_apps_thread
;
131 static pthread_t client_thread
;
132 static pthread_t kernel_thread
;
133 static pthread_t dispatch_thread
;
137 * UST registration command queue. This queue is tied with a futex and uses a N
138 * wakers / 1 waiter implemented and detailed in futex.c/.h
140 * The thread_manage_apps and thread_dispatch_ust_registration interact with
141 * this queue and the wait/wake scheme.
143 static struct ust_cmd_queue ust_cmd_queue
;
146 * Pointer initialized before thread creation.
148 * This points to the tracing session list containing the session count and a
149 * mutex lock. The lock MUST be taken if you iterate over the list. The lock
150 * MUST NOT be taken if you call a public function in session.c.
152 * The lock is nested inside the structure: session_list_ptr->lock. Please use
153 * session_lock_list and session_unlock_list for lock acquisition.
155 static struct ltt_session_list
*session_list_ptr
;
157 int ust_consumerd64_fd
= -1;
158 int ust_consumerd32_fd
= -1;
160 static const char *consumerd32_bin
= CONFIG_CONSUMERD32_BIN
;
161 static const char *consumerd64_bin
= CONFIG_CONSUMERD64_BIN
;
162 static const char *consumerd32_libdir
= CONFIG_CONSUMERD32_LIBDIR
;
163 static const char *consumerd64_libdir
= CONFIG_CONSUMERD64_LIBDIR
;
166 * Consumer daemon state which is changed when spawning it, killing it or in
167 * case of a fatal error.
169 enum consumerd_state
{
170 CONSUMER_STARTED
= 1,
171 CONSUMER_STOPPED
= 2,
176 * This consumer daemon state is used to validate if a client command will be
177 * able to reach the consumer. If not, the client is informed. For instance,
178 * doing a "lttng start" when the consumer state is set to ERROR will return an
179 * error to the client.
181 * The following example shows a possible race condition of this scheme:
183 * consumer thread error happens
185 * client cmd checks state -> still OK
186 * consumer thread exit, sets error
187 * client cmd try to talk to consumer
190 * However, since the consumer is a different daemon, we have no way of making
191 * sure the command will reach it safely even with this state flag. This is why
192 * we consider that up to the state validation during command processing, the
193 * command is safe. After that, we can not guarantee the correctness of the
194 * client request vis-a-vis the consumer.
196 static enum consumerd_state ust_consumerd_state
;
197 static enum consumerd_state kernel_consumerd_state
;
200 void setup_consumerd_path(void)
202 const char *bin
, *libdir
;
205 * Allow INSTALL_BIN_PATH to be used as a target path for the
206 * native architecture size consumer if CONFIG_CONSUMER*_PATH
207 * has not been defined.
209 #if (CAA_BITS_PER_LONG == 32)
210 if (!consumerd32_bin
[0]) {
211 consumerd32_bin
= INSTALL_BIN_PATH
"/" CONSUMERD_FILE
;
213 if (!consumerd32_libdir
[0]) {
214 consumerd32_libdir
= INSTALL_LIB_PATH
;
216 #elif (CAA_BITS_PER_LONG == 64)
217 if (!consumerd64_bin
[0]) {
218 consumerd64_bin
= INSTALL_BIN_PATH
"/" CONSUMERD_FILE
;
220 if (!consumerd64_libdir
[0]) {
221 consumerd64_libdir
= INSTALL_LIB_PATH
;
224 #error "Unknown bitness"
228 * runtime env. var. overrides the build default.
230 bin
= getenv("LTTNG_CONSUMERD32_BIN");
232 consumerd32_bin
= bin
;
234 bin
= getenv("LTTNG_CONSUMERD64_BIN");
236 consumerd64_bin
= bin
;
238 libdir
= getenv("LTTNG_CONSUMERD32_LIBDIR");
240 consumerd32_libdir
= libdir
;
242 libdir
= getenv("LTTNG_CONSUMERD64_LIBDIR");
244 consumerd64_libdir
= libdir
;
249 * Create a poll set with O_CLOEXEC and add the thread quit pipe to the set.
251 static int create_thread_poll_set(struct lttng_poll_event
*events
,
256 if (events
== NULL
|| size
== 0) {
261 ret
= lttng_poll_create(events
, size
, LTTNG_CLOEXEC
);
267 ret
= lttng_poll_add(events
, thread_quit_pipe
[0], LPOLLIN
);
279 * Check if the thread quit pipe was triggered.
281 * Return 1 if it was triggered else 0;
283 static int check_thread_quit_pipe(int fd
, uint32_t events
)
285 if (fd
== thread_quit_pipe
[0] && (events
& LPOLLIN
)) {
293 * Return group ID of the tracing group or -1 if not found.
295 static gid_t
allowed_group(void)
299 if (opt_tracing_group
) {
300 grp
= getgrnam(opt_tracing_group
);
302 grp
= getgrnam(default_tracing_group
);
312 * Init thread quit pipe.
314 * Return -1 on error or 0 if all pipes are created.
316 static int init_thread_quit_pipe(void)
320 ret
= pipe(thread_quit_pipe
);
322 PERROR("thread quit pipe");
326 for (i
= 0; i
< 2; i
++) {
327 ret
= fcntl(thread_quit_pipe
[i
], F_SETFD
, FD_CLOEXEC
);
339 * Complete teardown of a kernel session. This free all data structure related
340 * to a kernel session and update counter.
342 static void teardown_kernel_session(struct ltt_session
*session
)
344 if (!session
->kernel_session
) {
345 DBG3("No kernel session when tearing down session");
349 DBG("Tearing down kernel session");
352 * If a custom kernel consumer was registered, close the socket before
353 * tearing down the complete kernel session structure
355 if (kconsumer_data
.cmd_sock
>= 0 &&
356 session
->kernel_session
->consumer_fd
!= kconsumer_data
.cmd_sock
) {
357 lttcomm_close_unix_sock(session
->kernel_session
->consumer_fd
);
360 trace_kernel_destroy_session(session
->kernel_session
);
364 * Complete teardown of all UST sessions. This will free everything on his path
365 * and destroy the core essence of all ust sessions :)
367 static void teardown_ust_session(struct ltt_session
*session
)
371 if (!session
->ust_session
) {
372 DBG3("No UST session when tearing down session");
376 DBG("Tearing down UST session(s)");
378 ret
= ust_app_destroy_trace_all(session
->ust_session
);
380 ERR("Error in ust_app_destroy_trace_all");
383 trace_ust_destroy_session(session
->ust_session
);
387 * Stop all threads by closing the thread quit pipe.
389 static void stop_threads(void)
393 /* Stopping all threads */
394 DBG("Terminating all threads");
395 ret
= notify_thread_pipe(thread_quit_pipe
[1]);
397 ERR("write error on thread quit pipe");
400 /* Dispatch thread */
401 dispatch_thread_exit
= 1;
402 futex_nto1_wake(&ust_cmd_queue
.futex
);
408 static void cleanup(void)
412 struct ltt_session
*sess
, *stmp
;
416 DBG("Removing %s directory", rundir
);
417 ret
= asprintf(&cmd
, "rm -rf %s", rundir
);
419 ERR("asprintf failed. Something is really wrong!");
422 /* Remove lttng run directory */
425 ERR("Unable to clean %s", rundir
);
429 DBG("Cleaning up all sessions");
431 /* Destroy session list mutex */
432 if (session_list_ptr
!= NULL
) {
433 pthread_mutex_destroy(&session_list_ptr
->lock
);
435 /* Cleanup ALL session */
436 cds_list_for_each_entry_safe(sess
, stmp
,
437 &session_list_ptr
->head
, list
) {
438 teardown_kernel_session(sess
);
439 teardown_ust_session(sess
);
444 DBG("Closing all UST sockets");
445 ust_app_clean_list();
447 pthread_mutex_destroy(&kconsumer_data
.pid_mutex
);
449 if (is_root
&& !opt_no_kernel
) {
450 DBG2("Closing kernel fd");
451 if (kernel_tracer_fd
>= 0) {
452 ret
= close(kernel_tracer_fd
);
457 DBG("Unloading kernel modules");
458 modprobe_remove_lttng_all();
462 * Closing all pipes used for communication between threads.
464 for (i
= 0; i
< 2; i
++) {
465 if (kernel_poll_pipe
[i
] >= 0) {
466 ret
= close(kernel_poll_pipe
[i
]);
472 for (i
= 0; i
< 2; i
++) {
473 if (thread_quit_pipe
[i
] >= 0) {
474 ret
= close(thread_quit_pipe
[i
]);
480 for (i
= 0; i
< 2; i
++) {
481 if (apps_cmd_pipe
[i
] >= 0) {
482 ret
= close(apps_cmd_pipe
[i
]);
490 DBG("%c[%d;%dm*** assert failed :-) *** ==> %c[%dm%c[%d;%dm"
491 "Matthew, BEET driven development works!%c[%dm",
492 27, 1, 31, 27, 0, 27, 1, 33, 27, 0);
497 * Send data on a unix socket using the liblttsessiondcomm API.
499 * Return lttcomm error code.
501 static int send_unix_sock(int sock
, void *buf
, size_t len
)
503 /* Check valid length */
508 return lttcomm_send_unix_sock(sock
, buf
, len
);
512 * Free memory of a command context structure.
514 static void clean_command_ctx(struct command_ctx
**cmd_ctx
)
516 DBG("Clean command context structure");
518 if ((*cmd_ctx
)->llm
) {
519 free((*cmd_ctx
)->llm
);
521 if ((*cmd_ctx
)->lsm
) {
522 free((*cmd_ctx
)->lsm
);
530 * Notify UST applications using the shm mmap futex.
532 static int notify_ust_apps(int active
)
536 DBG("Notifying applications of session daemon state: %d", active
);
538 /* See shm.c for this call implying mmap, shm and futex calls */
539 wait_shm_mmap
= shm_ust_get_mmap(wait_shm_path
, is_root
);
540 if (wait_shm_mmap
== NULL
) {
544 /* Wake waiting process */
545 futex_wait_update((int32_t *) wait_shm_mmap
, active
);
547 /* Apps notified successfully */
555 * Setup the outgoing data buffer for the response (llm) by allocating the
556 * right amount of memory and copying the original information from the lsm
559 * Return total size of the buffer pointed by buf.
561 static int setup_lttng_msg(struct command_ctx
*cmd_ctx
, size_t size
)
567 cmd_ctx
->llm
= zmalloc(sizeof(struct lttcomm_lttng_msg
) + buf_size
);
568 if (cmd_ctx
->llm
== NULL
) {
574 /* Copy common data */
575 cmd_ctx
->llm
->cmd_type
= cmd_ctx
->lsm
->cmd_type
;
576 cmd_ctx
->llm
->pid
= cmd_ctx
->lsm
->domain
.attr
.pid
;
578 cmd_ctx
->llm
->data_size
= size
;
579 cmd_ctx
->lttng_msg_size
= sizeof(struct lttcomm_lttng_msg
) + buf_size
;
588 * Update the kernel poll set of all channel fd available over all tracing
589 * session. Add the wakeup pipe at the end of the set.
591 static int update_kernel_poll(struct lttng_poll_event
*events
)
594 struct ltt_session
*session
;
595 struct ltt_kernel_channel
*channel
;
597 DBG("Updating kernel poll set");
600 cds_list_for_each_entry(session
, &session_list_ptr
->head
, list
) {
601 session_lock(session
);
602 if (session
->kernel_session
== NULL
) {
603 session_unlock(session
);
607 cds_list_for_each_entry(channel
,
608 &session
->kernel_session
->channel_list
.head
, list
) {
609 /* Add channel fd to the kernel poll set */
610 ret
= lttng_poll_add(events
, channel
->fd
, LPOLLIN
| LPOLLRDNORM
);
612 session_unlock(session
);
615 DBG("Channel fd %d added to kernel set", channel
->fd
);
617 session_unlock(session
);
619 session_unlock_list();
624 session_unlock_list();
629 * Find the channel fd from 'fd' over all tracing session. When found, check
630 * for new channel stream and send those stream fds to the kernel consumer.
632 * Useful for CPU hotplug feature.
634 static int update_kernel_stream(struct consumer_data
*consumer_data
, int fd
)
637 struct ltt_session
*session
;
638 struct ltt_kernel_channel
*channel
;
640 DBG("Updating kernel streams for channel fd %d", fd
);
643 cds_list_for_each_entry(session
, &session_list_ptr
->head
, list
) {
644 session_lock(session
);
645 if (session
->kernel_session
== NULL
) {
646 session_unlock(session
);
650 /* This is not suppose to be -1 but this is an extra security check */
651 if (session
->kernel_session
->consumer_fd
< 0) {
652 session
->kernel_session
->consumer_fd
= consumer_data
->cmd_sock
;
655 cds_list_for_each_entry(channel
,
656 &session
->kernel_session
->channel_list
.head
, list
) {
657 if (channel
->fd
== fd
) {
658 DBG("Channel found, updating kernel streams");
659 ret
= kernel_open_channel_stream(channel
);
665 * Have we already sent fds to the consumer? If yes, it means
666 * that tracing is started so it is safe to send our updated
669 if (session
->kernel_session
->consumer_fds_sent
== 1) {
670 ret
= kernel_consumer_send_channel_stream(consumer_data
,
671 session
->kernel_session
->consumer_fd
, channel
,
672 session
->uid
, session
->gid
);
680 session_unlock(session
);
682 session_unlock_list();
686 session_unlock(session
);
687 session_unlock_list();
692 * For each tracing session, update newly registered apps.
694 static void update_ust_app(int app_sock
)
696 struct ltt_session
*sess
, *stmp
;
700 /* For all tracing session(s) */
701 cds_list_for_each_entry_safe(sess
, stmp
, &session_list_ptr
->head
, list
) {
703 if (sess
->ust_session
) {
704 ust_app_global_update(sess
->ust_session
, app_sock
);
706 session_unlock(sess
);
709 session_unlock_list();
713 * This thread manage event coming from the kernel.
715 * Features supported in this thread:
718 static void *thread_manage_kernel(void *data
)
720 int ret
, i
, pollfd
, update_poll_flag
= 1;
721 uint32_t revents
, nb_fd
;
723 struct lttng_poll_event events
;
725 DBG("Thread manage kernel started");
727 ret
= create_thread_poll_set(&events
, 2);
729 goto error_poll_create
;
732 ret
= lttng_poll_add(&events
, kernel_poll_pipe
[0], LPOLLIN
);
738 if (update_poll_flag
== 1) {
740 * Reset number of fd in the poll set. Always 2 since there is the thread
741 * quit pipe and the kernel pipe.
745 ret
= update_kernel_poll(&events
);
749 update_poll_flag
= 0;
752 nb_fd
= LTTNG_POLL_GETNB(&events
);
754 DBG("Thread kernel polling on %d fds", nb_fd
);
756 /* Zeroed the poll events */
757 lttng_poll_reset(&events
);
759 /* Poll infinite value of time */
761 ret
= lttng_poll_wait(&events
, -1);
764 * Restart interrupted system call.
766 if (errno
== EINTR
) {
770 } else if (ret
== 0) {
771 /* Should not happen since timeout is infinite */
772 ERR("Return value of poll is 0 with an infinite timeout.\n"
773 "This should not have happened! Continuing...");
777 for (i
= 0; i
< nb_fd
; i
++) {
778 /* Fetch once the poll data */
779 revents
= LTTNG_POLL_GETEV(&events
, i
);
780 pollfd
= LTTNG_POLL_GETFD(&events
, i
);
782 /* Thread quit pipe has been closed. Killing thread. */
783 ret
= check_thread_quit_pipe(pollfd
, revents
);
788 /* Check for data on kernel pipe */
789 if (pollfd
== kernel_poll_pipe
[0] && (revents
& LPOLLIN
)) {
790 ret
= read(kernel_poll_pipe
[0], &tmp
, 1);
791 update_poll_flag
= 1;
795 * New CPU detected by the kernel. Adding kernel stream to
796 * kernel session and updating the kernel consumer
798 if (revents
& LPOLLIN
) {
799 ret
= update_kernel_stream(&kconsumer_data
, pollfd
);
805 * TODO: We might want to handle the LPOLLERR | LPOLLHUP
806 * and unregister kernel stream at this point.
814 lttng_poll_clean(&events
);
816 DBG("Kernel thread dying");
821 * This thread manage the consumer error sent back to the session daemon.
823 static void *thread_manage_consumer(void *data
)
825 int sock
= -1, i
, ret
, pollfd
;
826 uint32_t revents
, nb_fd
;
827 enum lttcomm_return_code code
;
828 struct lttng_poll_event events
;
829 struct consumer_data
*consumer_data
= data
;
831 DBG("[thread] Manage consumer started");
833 ret
= lttcomm_listen_unix_sock(consumer_data
->err_sock
);
839 * Pass 2 as size here for the thread quit pipe and kconsumerd_err_sock.
840 * Nothing more will be added to this poll set.
842 ret
= create_thread_poll_set(&events
, 2);
847 ret
= lttng_poll_add(&events
, consumer_data
->err_sock
, LPOLLIN
| LPOLLRDHUP
);
852 nb_fd
= LTTNG_POLL_GETNB(&events
);
854 /* Inifinite blocking call, waiting for transmission */
856 ret
= lttng_poll_wait(&events
, -1);
859 * Restart interrupted system call.
861 if (errno
== EINTR
) {
867 for (i
= 0; i
< nb_fd
; i
++) {
868 /* Fetch once the poll data */
869 revents
= LTTNG_POLL_GETEV(&events
, i
);
870 pollfd
= LTTNG_POLL_GETFD(&events
, i
);
872 /* Thread quit pipe has been closed. Killing thread. */
873 ret
= check_thread_quit_pipe(pollfd
, revents
);
878 /* Event on the registration socket */
879 if (pollfd
== consumer_data
->err_sock
) {
880 if (revents
& (LPOLLERR
| LPOLLHUP
| LPOLLRDHUP
)) {
881 ERR("consumer err socket poll error");
887 sock
= lttcomm_accept_unix_sock(consumer_data
->err_sock
);
892 DBG2("Receiving code from consumer err_sock");
894 /* Getting status code from kconsumerd */
895 ret
= lttcomm_recv_unix_sock(sock
, &code
,
896 sizeof(enum lttcomm_return_code
));
901 if (code
== CONSUMERD_COMMAND_SOCK_READY
) {
902 consumer_data
->cmd_sock
=
903 lttcomm_connect_unix_sock(consumer_data
->cmd_unix_sock_path
);
904 if (consumer_data
->cmd_sock
< 0) {
905 sem_post(&consumer_data
->sem
);
906 PERROR("consumer connect");
909 /* Signal condition to tell that the kconsumerd is ready */
910 sem_post(&consumer_data
->sem
);
911 DBG("consumer command socket ready");
913 ERR("consumer error when waiting for SOCK_READY : %s",
914 lttcomm_get_readable_code(-code
));
918 /* Remove the kconsumerd error sock since we've established a connexion */
919 ret
= lttng_poll_del(&events
, consumer_data
->err_sock
);
924 ret
= lttng_poll_add(&events
, sock
, LPOLLIN
| LPOLLRDHUP
);
929 /* Update number of fd */
930 nb_fd
= LTTNG_POLL_GETNB(&events
);
932 /* Inifinite blocking call, waiting for transmission */
934 ret
= lttng_poll_wait(&events
, -1);
937 * Restart interrupted system call.
939 if (errno
== EINTR
) {
945 for (i
= 0; i
< nb_fd
; i
++) {
946 /* Fetch once the poll data */
947 revents
= LTTNG_POLL_GETEV(&events
, i
);
948 pollfd
= LTTNG_POLL_GETFD(&events
, i
);
950 /* Thread quit pipe has been closed. Killing thread. */
951 ret
= check_thread_quit_pipe(pollfd
, revents
);
956 /* Event on the kconsumerd socket */
957 if (pollfd
== sock
) {
958 if (revents
& (LPOLLERR
| LPOLLHUP
| LPOLLRDHUP
)) {
959 ERR("consumer err socket second poll error");
965 /* Wait for any kconsumerd error */
966 ret
= lttcomm_recv_unix_sock(sock
, &code
,
967 sizeof(enum lttcomm_return_code
));
969 ERR("consumer closed the command socket");
973 ERR("consumer return code : %s", lttcomm_get_readable_code(-code
));
976 /* Immediately set the consumerd state to stopped */
977 if (consumer_data
->type
== LTTNG_CONSUMER_KERNEL
) {
978 uatomic_set(&kernel_consumerd_state
, CONSUMER_ERROR
);
979 } else if (consumer_data
->type
== LTTNG_CONSUMER64_UST
||
980 consumer_data
->type
== LTTNG_CONSUMER32_UST
) {
981 uatomic_set(&ust_consumerd_state
, CONSUMER_ERROR
);
983 /* Code flow error... */
987 if (consumer_data
->err_sock
>= 0) {
988 ret
= close(consumer_data
->err_sock
);
993 if (consumer_data
->cmd_sock
>= 0) {
994 ret
= close(consumer_data
->cmd_sock
);
1006 unlink(consumer_data
->err_unix_sock_path
);
1007 unlink(consumer_data
->cmd_unix_sock_path
);
1008 consumer_data
->pid
= 0;
1010 lttng_poll_clean(&events
);
1013 DBG("consumer thread cleanup completed");
1019 * This thread manage application communication.
1021 static void *thread_manage_apps(void *data
)
1024 uint32_t revents
, nb_fd
;
1025 struct ust_command ust_cmd
;
1026 struct lttng_poll_event events
;
1028 DBG("[thread] Manage application started");
1030 rcu_register_thread();
1031 rcu_thread_online();
1033 ret
= create_thread_poll_set(&events
, 2);
1035 goto error_poll_create
;
1038 ret
= lttng_poll_add(&events
, apps_cmd_pipe
[0], LPOLLIN
| LPOLLRDHUP
);
1044 /* Zeroed the events structure */
1045 lttng_poll_reset(&events
);
1047 nb_fd
= LTTNG_POLL_GETNB(&events
);
1049 DBG("Apps thread polling on %d fds", nb_fd
);
1051 /* Inifinite blocking call, waiting for transmission */
1053 ret
= lttng_poll_wait(&events
, -1);
1056 * Restart interrupted system call.
1058 if (errno
== EINTR
) {
1064 for (i
= 0; i
< nb_fd
; i
++) {
1065 /* Fetch once the poll data */
1066 revents
= LTTNG_POLL_GETEV(&events
, i
);
1067 pollfd
= LTTNG_POLL_GETFD(&events
, i
);
1069 /* Thread quit pipe has been closed. Killing thread. */
1070 ret
= check_thread_quit_pipe(pollfd
, revents
);
1075 /* Inspect the apps cmd pipe */
1076 if (pollfd
== apps_cmd_pipe
[0]) {
1077 if (revents
& (LPOLLERR
| LPOLLHUP
| LPOLLRDHUP
)) {
1078 ERR("Apps command pipe error");
1080 } else if (revents
& LPOLLIN
) {
1082 ret
= read(apps_cmd_pipe
[0], &ust_cmd
, sizeof(ust_cmd
));
1083 if (ret
< 0 || ret
< sizeof(ust_cmd
)) {
1084 PERROR("read apps cmd pipe");
1088 /* Register applicaton to the session daemon */
1089 ret
= ust_app_register(&ust_cmd
.reg_msg
,
1091 if (ret
== -ENOMEM
) {
1093 } else if (ret
< 0) {
1098 * Validate UST version compatibility.
1100 ret
= ust_app_validate_version(ust_cmd
.sock
);
1103 * Add channel(s) and event(s) to newly registered apps
1104 * from lttng global UST domain.
1106 update_ust_app(ust_cmd
.sock
);
1109 ret
= ust_app_register_done(ust_cmd
.sock
);
1112 * If the registration is not possible, we simply
1113 * unregister the apps and continue
1115 ust_app_unregister(ust_cmd
.sock
);
1118 * We just need here to monitor the close of the UST
1119 * socket and poll set monitor those by default.
1120 * Listen on POLLIN (even if we never expect any
1121 * data) to ensure that hangup wakes us.
1123 ret
= lttng_poll_add(&events
, ust_cmd
.sock
, LPOLLIN
);
1128 DBG("Apps with sock %d added to poll set",
1136 * At this point, we know that a registered application made
1137 * the event at poll_wait.
1139 if (revents
& (LPOLLERR
| LPOLLHUP
| LPOLLRDHUP
)) {
1140 /* Removing from the poll set */
1141 ret
= lttng_poll_del(&events
, pollfd
);
1146 /* Socket closed on remote end. */
1147 ust_app_unregister(pollfd
);
1155 lttng_poll_clean(&events
);
1157 DBG("Application communication apps thread cleanup complete");
1158 rcu_thread_offline();
1159 rcu_unregister_thread();
1164 * Dispatch request from the registration threads to the application
1165 * communication thread.
1167 static void *thread_dispatch_ust_registration(void *data
)
1170 struct cds_wfq_node
*node
;
1171 struct ust_command
*ust_cmd
= NULL
;
1173 DBG("[thread] Dispatch UST command started");
1175 while (!dispatch_thread_exit
) {
1176 /* Atomically prepare the queue futex */
1177 futex_nto1_prepare(&ust_cmd_queue
.futex
);
1180 /* Dequeue command for registration */
1181 node
= cds_wfq_dequeue_blocking(&ust_cmd_queue
.queue
);
1183 DBG("Woken up but nothing in the UST command queue");
1184 /* Continue thread execution */
1188 ust_cmd
= caa_container_of(node
, struct ust_command
, node
);
1190 DBG("Dispatching UST registration pid:%d ppid:%d uid:%d"
1191 " gid:%d sock:%d name:%s (version %d.%d)",
1192 ust_cmd
->reg_msg
.pid
, ust_cmd
->reg_msg
.ppid
,
1193 ust_cmd
->reg_msg
.uid
, ust_cmd
->reg_msg
.gid
,
1194 ust_cmd
->sock
, ust_cmd
->reg_msg
.name
,
1195 ust_cmd
->reg_msg
.major
, ust_cmd
->reg_msg
.minor
);
1197 * Inform apps thread of the new application registration. This
1198 * call is blocking so we can be assured that the data will be read
1199 * at some point in time or wait to the end of the world :)
1201 ret
= write(apps_cmd_pipe
[1], ust_cmd
,
1202 sizeof(struct ust_command
));
1204 PERROR("write apps cmd pipe");
1205 if (errno
== EBADF
) {
1207 * We can't inform the application thread to process
1208 * registration. We will exit or else application
1209 * registration will not occur and tracing will never
1216 } while (node
!= NULL
);
1218 /* Futex wait on queue. Blocking call on futex() */
1219 futex_nto1_wait(&ust_cmd_queue
.futex
);
1223 DBG("Dispatch thread dying");
1228 * This thread manage application registration.
1230 static void *thread_registration_apps(void *data
)
1232 int sock
= -1, i
, ret
, pollfd
;
1233 uint32_t revents
, nb_fd
;
1234 struct lttng_poll_event events
;
1236 * Get allocated in this thread, enqueued to a global queue, dequeued and
1237 * freed in the manage apps thread.
1239 struct ust_command
*ust_cmd
= NULL
;
1241 DBG("[thread] Manage application registration started");
1243 ret
= lttcomm_listen_unix_sock(apps_sock
);
1249 * Pass 2 as size here for the thread quit pipe and apps socket. Nothing
1250 * more will be added to this poll set.
1252 ret
= create_thread_poll_set(&events
, 2);
1254 goto error_create_poll
;
1257 /* Add the application registration socket */
1258 ret
= lttng_poll_add(&events
, apps_sock
, LPOLLIN
| LPOLLRDHUP
);
1260 goto error_poll_add
;
1263 /* Notify all applications to register */
1264 ret
= notify_ust_apps(1);
1266 ERR("Failed to notify applications or create the wait shared memory.\n"
1267 "Execution continues but there might be problem for already\n"
1268 "running applications that wishes to register.");
1272 DBG("Accepting application registration");
1274 nb_fd
= LTTNG_POLL_GETNB(&events
);
1276 /* Inifinite blocking call, waiting for transmission */
1278 ret
= lttng_poll_wait(&events
, -1);
1281 * Restart interrupted system call.
1283 if (errno
== EINTR
) {
1289 for (i
= 0; i
< nb_fd
; i
++) {
1290 /* Fetch once the poll data */
1291 revents
= LTTNG_POLL_GETEV(&events
, i
);
1292 pollfd
= LTTNG_POLL_GETFD(&events
, i
);
1294 /* Thread quit pipe has been closed. Killing thread. */
1295 ret
= check_thread_quit_pipe(pollfd
, revents
);
1300 /* Event on the registration socket */
1301 if (pollfd
== apps_sock
) {
1302 if (revents
& (LPOLLERR
| LPOLLHUP
| LPOLLRDHUP
)) {
1303 ERR("Register apps socket poll error");
1305 } else if (revents
& LPOLLIN
) {
1306 sock
= lttcomm_accept_unix_sock(apps_sock
);
1311 /* Create UST registration command for enqueuing */
1312 ust_cmd
= zmalloc(sizeof(struct ust_command
));
1313 if (ust_cmd
== NULL
) {
1314 PERROR("ust command zmalloc");
1319 * Using message-based transmissions to ensure we don't
1320 * have to deal with partially received messages.
1322 ret
= lttng_fd_get(LTTNG_FD_APPS
, 1);
1324 ERR("Exhausted file descriptors allowed for applications.");
1333 ret
= lttcomm_recv_unix_sock(sock
, &ust_cmd
->reg_msg
,
1334 sizeof(struct ust_register_msg
));
1335 if (ret
< 0 || ret
< sizeof(struct ust_register_msg
)) {
1337 PERROR("lttcomm_recv_unix_sock register apps");
1339 ERR("Wrong size received on apps register");
1346 lttng_fd_put(LTTNG_FD_APPS
, 1);
1351 ust_cmd
->sock
= sock
;
1354 DBG("UST registration received with pid:%d ppid:%d uid:%d"
1355 " gid:%d sock:%d name:%s (version %d.%d)",
1356 ust_cmd
->reg_msg
.pid
, ust_cmd
->reg_msg
.ppid
,
1357 ust_cmd
->reg_msg
.uid
, ust_cmd
->reg_msg
.gid
,
1358 ust_cmd
->sock
, ust_cmd
->reg_msg
.name
,
1359 ust_cmd
->reg_msg
.major
, ust_cmd
->reg_msg
.minor
);
1362 * Lock free enqueue the registration request. The red pill
1363 * has been taken! This apps will be part of the *system*.
1365 cds_wfq_enqueue(&ust_cmd_queue
.queue
, &ust_cmd
->node
);
1368 * Wake the registration queue futex. Implicit memory
1369 * barrier with the exchange in cds_wfq_enqueue.
1371 futex_nto1_wake(&ust_cmd_queue
.futex
);
1378 /* Notify that the registration thread is gone */
1381 if (apps_sock
>= 0) {
1382 ret
= close(apps_sock
);
1392 lttng_fd_put(LTTNG_FD_APPS
, 1);
1394 unlink(apps_unix_sock_path
);
1397 lttng_poll_clean(&events
);
1400 DBG("UST Registration thread cleanup complete");
1406 * Start the thread_manage_consumer. This must be done after a lttng-consumerd
1407 * exec or it will fails.
1409 static int spawn_consumer_thread(struct consumer_data
*consumer_data
)
1412 struct timespec timeout
;
1414 timeout
.tv_sec
= DEFAULT_SEM_WAIT_TIMEOUT
;
1415 timeout
.tv_nsec
= 0;
1417 /* Setup semaphore */
1418 ret
= sem_init(&consumer_data
->sem
, 0, 0);
1420 PERROR("sem_init consumer semaphore");
1424 ret
= pthread_create(&consumer_data
->thread
, NULL
,
1425 thread_manage_consumer
, consumer_data
);
1427 PERROR("pthread_create consumer");
1432 /* Get time for sem_timedwait absolute timeout */
1433 ret
= clock_gettime(CLOCK_REALTIME
, &timeout
);
1435 PERROR("clock_gettime spawn consumer");
1436 /* Infinite wait for the kconsumerd thread to be ready */
1437 ret
= sem_wait(&consumer_data
->sem
);
1439 /* Normal timeout if the gettime was successful */
1440 timeout
.tv_sec
+= DEFAULT_SEM_WAIT_TIMEOUT
;
1441 ret
= sem_timedwait(&consumer_data
->sem
, &timeout
);
1445 if (errno
== ETIMEDOUT
) {
1447 * Call has timed out so we kill the kconsumerd_thread and return
1450 ERR("The consumer thread was never ready. Killing it");
1451 ret
= pthread_cancel(consumer_data
->thread
);
1453 PERROR("pthread_cancel consumer thread");
1456 PERROR("semaphore wait failed consumer thread");
1461 pthread_mutex_lock(&consumer_data
->pid_mutex
);
1462 if (consumer_data
->pid
== 0) {
1463 ERR("Kconsumerd did not start");
1464 pthread_mutex_unlock(&consumer_data
->pid_mutex
);
1467 pthread_mutex_unlock(&consumer_data
->pid_mutex
);
1476 * Join consumer thread
1478 static int join_consumer_thread(struct consumer_data
*consumer_data
)
1483 if (consumer_data
->pid
!= 0) {
1484 ret
= kill(consumer_data
->pid
, SIGTERM
);
1486 ERR("Error killing consumer daemon");
1489 return pthread_join(consumer_data
->thread
, &status
);
1496 * Fork and exec a consumer daemon (consumerd).
1498 * Return pid if successful else -1.
1500 static pid_t
spawn_consumerd(struct consumer_data
*consumer_data
)
1504 const char *consumer_to_use
;
1505 const char *verbosity
;
1508 DBG("Spawning consumerd");
1515 if (opt_verbose_consumer
) {
1516 verbosity
= "--verbose";
1518 verbosity
= "--quiet";
1520 switch (consumer_data
->type
) {
1521 case LTTNG_CONSUMER_KERNEL
:
1523 * Find out which consumerd to execute. We will first try the
1524 * 64-bit path, then the sessiond's installation directory, and
1525 * fallback on the 32-bit one,
1527 DBG3("Looking for a kernel consumer at these locations:");
1528 DBG3(" 1) %s", consumerd64_bin
);
1529 DBG3(" 2) %s/%s", INSTALL_BIN_PATH
, CONSUMERD_FILE
);
1530 DBG3(" 3) %s", consumerd32_bin
);
1531 if (stat(consumerd64_bin
, &st
) == 0) {
1532 DBG3("Found location #1");
1533 consumer_to_use
= consumerd64_bin
;
1534 } else if (stat(INSTALL_BIN_PATH
"/" CONSUMERD_FILE
, &st
) == 0) {
1535 DBG3("Found location #2");
1536 consumer_to_use
= INSTALL_BIN_PATH
"/" CONSUMERD_FILE
;
1537 } else if (stat(consumerd32_bin
, &st
) == 0) {
1538 DBG3("Found location #3");
1539 consumer_to_use
= consumerd32_bin
;
1541 DBG("Could not find any valid consumerd executable");
1544 DBG("Using kernel consumer at: %s", consumer_to_use
);
1545 execl(consumer_to_use
,
1546 "lttng-consumerd", verbosity
, "-k",
1547 "--consumerd-cmd-sock", consumer_data
->cmd_unix_sock_path
,
1548 "--consumerd-err-sock", consumer_data
->err_unix_sock_path
,
1551 case LTTNG_CONSUMER64_UST
:
1553 char *tmpnew
= NULL
;
1555 if (consumerd64_libdir
[0] != '\0') {
1559 tmp
= getenv("LD_LIBRARY_PATH");
1563 tmplen
= strlen("LD_LIBRARY_PATH=")
1564 + strlen(consumerd64_libdir
) + 1 /* : */ + strlen(tmp
);
1565 tmpnew
= zmalloc(tmplen
+ 1 /* \0 */);
1570 strcpy(tmpnew
, "LD_LIBRARY_PATH=");
1571 strcat(tmpnew
, consumerd64_libdir
);
1572 if (tmp
[0] != '\0') {
1573 strcat(tmpnew
, ":");
1574 strcat(tmpnew
, tmp
);
1576 ret
= putenv(tmpnew
);
1582 DBG("Using 64-bit UST consumer at: %s", consumerd64_bin
);
1583 ret
= execl(consumerd64_bin
, "lttng-consumerd", verbosity
, "-u",
1584 "--consumerd-cmd-sock", consumer_data
->cmd_unix_sock_path
,
1585 "--consumerd-err-sock", consumer_data
->err_unix_sock_path
,
1587 if (consumerd64_libdir
[0] != '\0') {
1595 case LTTNG_CONSUMER32_UST
:
1597 char *tmpnew
= NULL
;
1599 if (consumerd32_libdir
[0] != '\0') {
1603 tmp
= getenv("LD_LIBRARY_PATH");
1607 tmplen
= strlen("LD_LIBRARY_PATH=")
1608 + strlen(consumerd32_libdir
) + 1 /* : */ + strlen(tmp
);
1609 tmpnew
= zmalloc(tmplen
+ 1 /* \0 */);
1614 strcpy(tmpnew
, "LD_LIBRARY_PATH=");
1615 strcat(tmpnew
, consumerd32_libdir
);
1616 if (tmp
[0] != '\0') {
1617 strcat(tmpnew
, ":");
1618 strcat(tmpnew
, tmp
);
1620 ret
= putenv(tmpnew
);
1626 DBG("Using 32-bit UST consumer at: %s", consumerd32_bin
);
1627 ret
= execl(consumerd32_bin
, "lttng-consumerd", verbosity
, "-u",
1628 "--consumerd-cmd-sock", consumer_data
->cmd_unix_sock_path
,
1629 "--consumerd-err-sock", consumer_data
->err_unix_sock_path
,
1631 if (consumerd32_libdir
[0] != '\0') {
1640 PERROR("unknown consumer type");
1644 PERROR("kernel start consumer exec");
1647 } else if (pid
> 0) {
1650 PERROR("start consumer fork");
1658 * Spawn the consumerd daemon and session daemon thread.
1660 static int start_consumerd(struct consumer_data
*consumer_data
)
1664 pthread_mutex_lock(&consumer_data
->pid_mutex
);
1665 if (consumer_data
->pid
!= 0) {
1666 pthread_mutex_unlock(&consumer_data
->pid_mutex
);
1670 ret
= spawn_consumerd(consumer_data
);
1672 ERR("Spawning consumerd failed");
1673 pthread_mutex_unlock(&consumer_data
->pid_mutex
);
1677 /* Setting up the consumer_data pid */
1678 consumer_data
->pid
= ret
;
1679 DBG2("Consumer pid %d", consumer_data
->pid
);
1680 pthread_mutex_unlock(&consumer_data
->pid_mutex
);
1682 DBG2("Spawning consumer control thread");
1683 ret
= spawn_consumer_thread(consumer_data
);
1685 ERR("Fatal error spawning consumer control thread");
1697 * Check version of the lttng-modules.
1699 static int validate_lttng_modules_version(void)
1701 return kernel_validate_version(kernel_tracer_fd
);
1705 * Setup necessary data for kernel tracer action.
1707 static int init_kernel_tracer(void)
1711 /* Modprobe lttng kernel modules */
1712 ret
= modprobe_lttng_control();
1717 /* Open debugfs lttng */
1718 kernel_tracer_fd
= open(module_proc_lttng
, O_RDWR
);
1719 if (kernel_tracer_fd
< 0) {
1720 DBG("Failed to open %s", module_proc_lttng
);
1725 /* Validate kernel version */
1726 ret
= validate_lttng_modules_version();
1731 ret
= modprobe_lttng_data();
1736 DBG("Kernel tracer fd %d", kernel_tracer_fd
);
1740 modprobe_remove_lttng_control();
1741 ret
= close(kernel_tracer_fd
);
1745 kernel_tracer_fd
= -1;
1746 return LTTCOMM_KERN_VERSION
;
1749 ret
= close(kernel_tracer_fd
);
1755 modprobe_remove_lttng_control();
1758 WARN("No kernel tracer available");
1759 kernel_tracer_fd
= -1;
1761 return LTTCOMM_NEED_ROOT_SESSIOND
;
1763 return LTTCOMM_KERN_NA
;
1768 * Init tracing by creating trace directory and sending fds kernel consumer.
1770 static int init_kernel_tracing(struct ltt_kernel_session
*session
)
1774 if (session
->consumer_fds_sent
== 0) {
1776 * Assign default kernel consumer socket if no consumer assigned to the
1777 * kernel session. At this point, it's NOT supposed to be -1 but this is
1778 * an extra security check.
1780 if (session
->consumer_fd
< 0) {
1781 session
->consumer_fd
= kconsumer_data
.cmd_sock
;
1784 ret
= kernel_consumer_send_session(&kconsumer_data
, session
);
1786 ret
= LTTCOMM_KERN_CONSUMER_FAIL
;
1790 session
->consumer_fds_sent
= 1;
1798 * Create an UST session and add it to the session ust list.
1800 static int create_ust_session(struct ltt_session
*session
,
1801 struct lttng_domain
*domain
)
1803 struct ltt_ust_session
*lus
= NULL
;
1806 switch (domain
->type
) {
1807 case LTTNG_DOMAIN_UST
:
1810 ret
= LTTCOMM_UNKNOWN_DOMAIN
;
1814 DBG("Creating UST session");
1816 lus
= trace_ust_create_session(session
->path
, session
->id
, domain
);
1818 ret
= LTTCOMM_UST_SESS_FAIL
;
1822 ret
= run_as_mkdir_recursive(lus
->pathname
, S_IRWXU
| S_IRWXG
,
1823 session
->uid
, session
->gid
);
1825 if (ret
!= -EEXIST
) {
1826 ERR("Trace directory creation error");
1827 ret
= LTTCOMM_UST_SESS_FAIL
;
1832 /* The domain type dictate different actions on session creation */
1833 switch (domain
->type
) {
1834 case LTTNG_DOMAIN_UST
:
1835 /* No ustctl for the global UST domain */
1838 ERR("Unknown UST domain on create session %d", domain
->type
);
1841 lus
->uid
= session
->uid
;
1842 lus
->gid
= session
->gid
;
1843 session
->ust_session
= lus
;
1853 * Create a kernel tracer session then create the default channel.
1855 static int create_kernel_session(struct ltt_session
*session
)
1859 DBG("Creating kernel session");
1861 ret
= kernel_create_session(session
, kernel_tracer_fd
);
1863 ret
= LTTCOMM_KERN_SESS_FAIL
;
1867 /* Set kernel consumer socket fd */
1868 if (kconsumer_data
.cmd_sock
>= 0) {
1869 session
->kernel_session
->consumer_fd
= kconsumer_data
.cmd_sock
;
1872 ret
= run_as_mkdir_recursive(session
->kernel_session
->trace_path
,
1873 S_IRWXU
| S_IRWXG
, session
->uid
, session
->gid
);
1875 if (ret
!= -EEXIST
) {
1876 ERR("Trace directory creation error");
1880 session
->kernel_session
->uid
= session
->uid
;
1881 session
->kernel_session
->gid
= session
->gid
;
1888 * Check if the UID or GID match the session. Root user has access to all
1891 static int session_access_ok(struct ltt_session
*session
, uid_t uid
, gid_t gid
)
1893 if (uid
!= session
->uid
&& gid
!= session
->gid
&& uid
!= 0) {
1900 static unsigned int lttng_sessions_count(uid_t uid
, gid_t gid
)
1903 struct ltt_session
*session
;
1905 DBG("Counting number of available session for UID %d GID %d",
1907 cds_list_for_each_entry(session
, &session_list_ptr
->head
, list
) {
1909 * Only list the sessions the user can control.
1911 if (!session_access_ok(session
, uid
, gid
)) {
1920 * Using the session list, filled a lttng_session array to send back to the
1921 * client for session listing.
1923 * The session list lock MUST be acquired before calling this function. Use
1924 * session_lock_list() and session_unlock_list().
1926 static void list_lttng_sessions(struct lttng_session
*sessions
, uid_t uid
,
1930 struct ltt_session
*session
;
1932 DBG("Getting all available session for UID %d GID %d",
1935 * Iterate over session list and append data after the control struct in
1938 cds_list_for_each_entry(session
, &session_list_ptr
->head
, list
) {
1940 * Only list the sessions the user can control.
1942 if (!session_access_ok(session
, uid
, gid
)) {
1945 strncpy(sessions
[i
].path
, session
->path
, PATH_MAX
);
1946 sessions
[i
].path
[PATH_MAX
- 1] = '\0';
1947 strncpy(sessions
[i
].name
, session
->name
, NAME_MAX
);
1948 sessions
[i
].name
[NAME_MAX
- 1] = '\0';
1949 sessions
[i
].enabled
= session
->enabled
;
1955 * Fill lttng_channel array of all channels.
1957 static void list_lttng_channels(int domain
, struct ltt_session
*session
,
1958 struct lttng_channel
*channels
)
1961 struct ltt_kernel_channel
*kchan
;
1963 DBG("Listing channels for session %s", session
->name
);
1966 case LTTNG_DOMAIN_KERNEL
:
1967 /* Kernel channels */
1968 if (session
->kernel_session
!= NULL
) {
1969 cds_list_for_each_entry(kchan
,
1970 &session
->kernel_session
->channel_list
.head
, list
) {
1971 /* Copy lttng_channel struct to array */
1972 memcpy(&channels
[i
], kchan
->channel
, sizeof(struct lttng_channel
));
1973 channels
[i
].enabled
= kchan
->enabled
;
1978 case LTTNG_DOMAIN_UST
:
1980 struct lttng_ht_iter iter
;
1981 struct ltt_ust_channel
*uchan
;
1983 cds_lfht_for_each_entry(session
->ust_session
->domain_global
.channels
->ht
,
1984 &iter
.iter
, uchan
, node
.node
) {
1985 strncpy(channels
[i
].name
, uchan
->name
, LTTNG_SYMBOL_NAME_LEN
);
1986 channels
[i
].attr
.overwrite
= uchan
->attr
.overwrite
;
1987 channels
[i
].attr
.subbuf_size
= uchan
->attr
.subbuf_size
;
1988 channels
[i
].attr
.num_subbuf
= uchan
->attr
.num_subbuf
;
1989 channels
[i
].attr
.switch_timer_interval
=
1990 uchan
->attr
.switch_timer_interval
;
1991 channels
[i
].attr
.read_timer_interval
=
1992 uchan
->attr
.read_timer_interval
;
1993 channels
[i
].enabled
= uchan
->enabled
;
1994 switch (uchan
->attr
.output
) {
1995 case LTTNG_UST_MMAP
:
1997 channels
[i
].attr
.output
= LTTNG_EVENT_MMAP
;
2010 * Create a list of ust global domain events.
2012 static int list_lttng_ust_global_events(char *channel_name
,
2013 struct ltt_ust_domain_global
*ust_global
, struct lttng_event
**events
)
2016 unsigned int nb_event
= 0;
2017 struct lttng_ht_iter iter
;
2018 struct lttng_ht_node_str
*node
;
2019 struct ltt_ust_channel
*uchan
;
2020 struct ltt_ust_event
*uevent
;
2021 struct lttng_event
*tmp
;
2023 DBG("Listing UST global events for channel %s", channel_name
);
2027 lttng_ht_lookup(ust_global
->channels
, (void *)channel_name
, &iter
);
2028 node
= lttng_ht_iter_get_node_str(&iter
);
2030 ret
= -LTTCOMM_UST_CHAN_NOT_FOUND
;
2034 uchan
= caa_container_of(&node
->node
, struct ltt_ust_channel
, node
.node
);
2036 nb_event
+= lttng_ht_get_count(uchan
->events
);
2038 if (nb_event
== 0) {
2043 DBG3("Listing UST global %d events", nb_event
);
2045 tmp
= zmalloc(nb_event
* sizeof(struct lttng_event
));
2047 ret
= -LTTCOMM_FATAL
;
2051 cds_lfht_for_each_entry(uchan
->events
->ht
, &iter
.iter
, uevent
, node
.node
) {
2052 strncpy(tmp
[i
].name
, uevent
->attr
.name
, LTTNG_SYMBOL_NAME_LEN
);
2053 tmp
[i
].name
[LTTNG_SYMBOL_NAME_LEN
- 1] = '\0';
2054 tmp
[i
].enabled
= uevent
->enabled
;
2055 switch (uevent
->attr
.instrumentation
) {
2056 case LTTNG_UST_TRACEPOINT
:
2057 tmp
[i
].type
= LTTNG_EVENT_TRACEPOINT
;
2059 case LTTNG_UST_PROBE
:
2060 tmp
[i
].type
= LTTNG_EVENT_PROBE
;
2062 case LTTNG_UST_FUNCTION
:
2063 tmp
[i
].type
= LTTNG_EVENT_FUNCTION
;
2066 tmp
[i
].loglevel
= uevent
->attr
.loglevel
;
2067 switch (uevent
->attr
.loglevel_type
) {
2068 case LTTNG_UST_LOGLEVEL_ALL
:
2069 tmp
[i
].loglevel_type
= LTTNG_EVENT_LOGLEVEL_ALL
;
2071 case LTTNG_UST_LOGLEVEL_RANGE
:
2072 tmp
[i
].loglevel_type
= LTTNG_EVENT_LOGLEVEL_RANGE
;
2074 case LTTNG_UST_LOGLEVEL_SINGLE
:
2075 tmp
[i
].loglevel_type
= LTTNG_EVENT_LOGLEVEL_SINGLE
;
2090 * Fill lttng_event array of all kernel events in the channel.
2092 static int list_lttng_kernel_events(char *channel_name
,
2093 struct ltt_kernel_session
*kernel_session
, struct lttng_event
**events
)
2096 unsigned int nb_event
;
2097 struct ltt_kernel_event
*event
;
2098 struct ltt_kernel_channel
*kchan
;
2100 kchan
= trace_kernel_get_channel_by_name(channel_name
, kernel_session
);
2101 if (kchan
== NULL
) {
2102 ret
= LTTCOMM_KERN_CHAN_NOT_FOUND
;
2106 nb_event
= kchan
->event_count
;
2108 DBG("Listing events for channel %s", kchan
->channel
->name
);
2110 if (nb_event
== 0) {
2115 *events
= zmalloc(nb_event
* sizeof(struct lttng_event
));
2116 if (*events
== NULL
) {
2117 ret
= LTTCOMM_FATAL
;
2121 /* Kernel channels */
2122 cds_list_for_each_entry(event
, &kchan
->events_list
.head
, list
) {
2123 strncpy((*events
)[i
].name
, event
->event
->name
, LTTNG_SYMBOL_NAME_LEN
);
2124 (*events
)[i
].name
[LTTNG_SYMBOL_NAME_LEN
- 1] = '\0';
2125 (*events
)[i
].enabled
= event
->enabled
;
2126 switch (event
->event
->instrumentation
) {
2127 case LTTNG_KERNEL_TRACEPOINT
:
2128 (*events
)[i
].type
= LTTNG_EVENT_TRACEPOINT
;
2130 case LTTNG_KERNEL_KPROBE
:
2131 case LTTNG_KERNEL_KRETPROBE
:
2132 (*events
)[i
].type
= LTTNG_EVENT_PROBE
;
2133 memcpy(&(*events
)[i
].attr
.probe
, &event
->event
->u
.kprobe
,
2134 sizeof(struct lttng_kernel_kprobe
));
2136 case LTTNG_KERNEL_FUNCTION
:
2137 (*events
)[i
].type
= LTTNG_EVENT_FUNCTION
;
2138 memcpy(&((*events
)[i
].attr
.ftrace
), &event
->event
->u
.ftrace
,
2139 sizeof(struct lttng_kernel_function
));
2141 case LTTNG_KERNEL_NOOP
:
2142 (*events
)[i
].type
= LTTNG_EVENT_NOOP
;
2144 case LTTNG_KERNEL_SYSCALL
:
2145 (*events
)[i
].type
= LTTNG_EVENT_SYSCALL
;
2147 case LTTNG_KERNEL_ALL
:
2161 * Command LTTNG_DISABLE_CHANNEL processed by the client thread.
2163 static int cmd_disable_channel(struct ltt_session
*session
,
2164 int domain
, char *channel_name
)
2167 struct ltt_ust_session
*usess
;
2169 usess
= session
->ust_session
;
2172 case LTTNG_DOMAIN_KERNEL
:
2174 ret
= channel_kernel_disable(session
->kernel_session
,
2176 if (ret
!= LTTCOMM_OK
) {
2180 kernel_wait_quiescent(kernel_tracer_fd
);
2183 case LTTNG_DOMAIN_UST
:
2185 struct ltt_ust_channel
*uchan
;
2186 struct lttng_ht
*chan_ht
;
2188 chan_ht
= usess
->domain_global
.channels
;
2190 uchan
= trace_ust_find_channel_by_name(chan_ht
, channel_name
);
2191 if (uchan
== NULL
) {
2192 ret
= LTTCOMM_UST_CHAN_NOT_FOUND
;
2196 ret
= channel_ust_disable(usess
, domain
, uchan
);
2197 if (ret
!= LTTCOMM_OK
) {
2203 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
:
2204 case LTTNG_DOMAIN_UST_EXEC_NAME
:
2205 case LTTNG_DOMAIN_UST_PID
:
2208 ret
= LTTCOMM_UNKNOWN_DOMAIN
;
2219 * Command LTTNG_ENABLE_CHANNEL processed by the client thread.
2221 static int cmd_enable_channel(struct ltt_session
*session
,
2222 int domain
, struct lttng_channel
*attr
)
2225 struct ltt_ust_session
*usess
= session
->ust_session
;
2226 struct lttng_ht
*chan_ht
;
2228 DBG("Enabling channel %s for session %s", attr
->name
, session
->name
);
2231 case LTTNG_DOMAIN_KERNEL
:
2233 struct ltt_kernel_channel
*kchan
;
2235 kchan
= trace_kernel_get_channel_by_name(attr
->name
,
2236 session
->kernel_session
);
2237 if (kchan
== NULL
) {
2238 ret
= channel_kernel_create(session
->kernel_session
,
2239 attr
, kernel_poll_pipe
[1]);
2241 ret
= channel_kernel_enable(session
->kernel_session
, kchan
);
2244 if (ret
!= LTTCOMM_OK
) {
2248 kernel_wait_quiescent(kernel_tracer_fd
);
2251 case LTTNG_DOMAIN_UST
:
2253 struct ltt_ust_channel
*uchan
;
2255 chan_ht
= usess
->domain_global
.channels
;
2257 uchan
= trace_ust_find_channel_by_name(chan_ht
, attr
->name
);
2258 if (uchan
== NULL
) {
2259 ret
= channel_ust_create(usess
, domain
, attr
);
2261 ret
= channel_ust_enable(usess
, domain
, uchan
);
2266 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
:
2267 case LTTNG_DOMAIN_UST_EXEC_NAME
:
2268 case LTTNG_DOMAIN_UST_PID
:
2271 ret
= LTTCOMM_UNKNOWN_DOMAIN
;
2280 * Command LTTNG_DISABLE_EVENT processed by the client thread.
2282 static int cmd_disable_event(struct ltt_session
*session
, int domain
,
2283 char *channel_name
, char *event_name
)
2288 case LTTNG_DOMAIN_KERNEL
:
2290 struct ltt_kernel_channel
*kchan
;
2291 struct ltt_kernel_session
*ksess
;
2293 ksess
= session
->kernel_session
;
2295 kchan
= trace_kernel_get_channel_by_name(channel_name
, ksess
);
2296 if (kchan
== NULL
) {
2297 ret
= LTTCOMM_KERN_CHAN_NOT_FOUND
;
2301 ret
= event_kernel_disable_tracepoint(ksess
, kchan
, event_name
);
2302 if (ret
!= LTTCOMM_OK
) {
2306 kernel_wait_quiescent(kernel_tracer_fd
);
2309 case LTTNG_DOMAIN_UST
:
2311 struct ltt_ust_channel
*uchan
;
2312 struct ltt_ust_session
*usess
;
2314 usess
= session
->ust_session
;
2316 uchan
= trace_ust_find_channel_by_name(usess
->domain_global
.channels
,
2318 if (uchan
== NULL
) {
2319 ret
= LTTCOMM_UST_CHAN_NOT_FOUND
;
2323 ret
= event_ust_disable_tracepoint(usess
, domain
, uchan
, event_name
);
2324 if (ret
!= LTTCOMM_OK
) {
2328 DBG3("Disable UST event %s in channel %s completed", event_name
,
2333 case LTTNG_DOMAIN_UST_EXEC_NAME
:
2334 case LTTNG_DOMAIN_UST_PID
:
2335 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
:
2349 * Command LTTNG_DISABLE_ALL_EVENT processed by the client thread.
2351 static int cmd_disable_event_all(struct ltt_session
*session
, int domain
,
2357 case LTTNG_DOMAIN_KERNEL
:
2359 struct ltt_kernel_session
*ksess
;
2360 struct ltt_kernel_channel
*kchan
;
2362 ksess
= session
->kernel_session
;
2364 kchan
= trace_kernel_get_channel_by_name(channel_name
, ksess
);
2365 if (kchan
== NULL
) {
2366 ret
= LTTCOMM_KERN_CHAN_NOT_FOUND
;
2370 ret
= event_kernel_disable_all(ksess
, kchan
);
2371 if (ret
!= LTTCOMM_OK
) {
2375 kernel_wait_quiescent(kernel_tracer_fd
);
2378 case LTTNG_DOMAIN_UST
:
2380 struct ltt_ust_session
*usess
;
2381 struct ltt_ust_channel
*uchan
;
2383 usess
= session
->ust_session
;
2385 uchan
= trace_ust_find_channel_by_name(usess
->domain_global
.channels
,
2387 if (uchan
== NULL
) {
2388 ret
= LTTCOMM_UST_CHAN_NOT_FOUND
;
2392 ret
= event_ust_disable_all_tracepoints(usess
, domain
, uchan
);
2397 DBG3("Disable all UST events in channel %s completed", channel_name
);
2402 case LTTNG_DOMAIN_UST_EXEC_NAME
:
2403 case LTTNG_DOMAIN_UST_PID
:
2404 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
:
2418 * Command LTTNG_ADD_CONTEXT processed by the client thread.
2420 static int cmd_add_context(struct ltt_session
*session
, int domain
,
2421 char *channel_name
, char *event_name
, struct lttng_event_context
*ctx
)
2426 case LTTNG_DOMAIN_KERNEL
:
2427 /* Add kernel context to kernel tracer */
2428 ret
= context_kernel_add(session
->kernel_session
, ctx
,
2429 event_name
, channel_name
);
2430 if (ret
!= LTTCOMM_OK
) {
2434 case LTTNG_DOMAIN_UST
:
2436 struct ltt_ust_session
*usess
= session
->ust_session
;
2438 ret
= context_ust_add(usess
, domain
, ctx
, event_name
, channel_name
);
2439 if (ret
!= LTTCOMM_OK
) {
2445 case LTTNG_DOMAIN_UST_EXEC_NAME
:
2446 case LTTNG_DOMAIN_UST_PID
:
2447 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
:
2461 * Command LTTNG_ENABLE_EVENT processed by the client thread.
2463 static int cmd_enable_event(struct ltt_session
*session
, int domain
,
2464 char *channel_name
, struct lttng_event
*event
)
2467 struct lttng_channel
*attr
;
2468 struct ltt_ust_session
*usess
= session
->ust_session
;
2471 case LTTNG_DOMAIN_KERNEL
:
2473 struct ltt_kernel_channel
*kchan
;
2475 kchan
= trace_kernel_get_channel_by_name(channel_name
,
2476 session
->kernel_session
);
2477 if (kchan
== NULL
) {
2478 attr
= channel_new_default_attr(domain
);
2480 ret
= LTTCOMM_FATAL
;
2483 snprintf(attr
->name
, NAME_MAX
, "%s", channel_name
);
2485 /* This call will notify the kernel thread */
2486 ret
= channel_kernel_create(session
->kernel_session
,
2487 attr
, kernel_poll_pipe
[1]);
2488 if (ret
!= LTTCOMM_OK
) {
2495 /* Get the newly created kernel channel pointer */
2496 kchan
= trace_kernel_get_channel_by_name(channel_name
,
2497 session
->kernel_session
);
2498 if (kchan
== NULL
) {
2499 /* This sould not happen... */
2500 ret
= LTTCOMM_FATAL
;
2504 ret
= event_kernel_enable_tracepoint(session
->kernel_session
, kchan
,
2506 if (ret
!= LTTCOMM_OK
) {
2510 kernel_wait_quiescent(kernel_tracer_fd
);
2513 case LTTNG_DOMAIN_UST
:
2515 struct lttng_channel
*attr
;
2516 struct ltt_ust_channel
*uchan
;
2518 /* Get channel from global UST domain */
2519 uchan
= trace_ust_find_channel_by_name(usess
->domain_global
.channels
,
2521 if (uchan
== NULL
) {
2522 /* Create default channel */
2523 attr
= channel_new_default_attr(domain
);
2525 ret
= LTTCOMM_FATAL
;
2528 snprintf(attr
->name
, NAME_MAX
, "%s", channel_name
);
2529 attr
->name
[NAME_MAX
- 1] = '\0';
2531 ret
= channel_ust_create(usess
, domain
, attr
);
2532 if (ret
!= LTTCOMM_OK
) {
2538 /* Get the newly created channel reference back */
2539 uchan
= trace_ust_find_channel_by_name(
2540 usess
->domain_global
.channels
, channel_name
);
2541 if (uchan
== NULL
) {
2542 /* Something is really wrong */
2543 ret
= LTTCOMM_FATAL
;
2548 /* At this point, the session and channel exist on the tracer */
2549 ret
= event_ust_enable_tracepoint(usess
, domain
, uchan
, event
);
2550 if (ret
!= LTTCOMM_OK
) {
2556 case LTTNG_DOMAIN_UST_EXEC_NAME
:
2557 case LTTNG_DOMAIN_UST_PID
:
2558 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
:
2572 * Command LTTNG_ENABLE_ALL_EVENT processed by the client thread.
2574 static int cmd_enable_event_all(struct ltt_session
*session
, int domain
,
2575 char *channel_name
, int event_type
)
2578 struct ltt_kernel_channel
*kchan
;
2581 case LTTNG_DOMAIN_KERNEL
:
2582 kchan
= trace_kernel_get_channel_by_name(channel_name
,
2583 session
->kernel_session
);
2584 if (kchan
== NULL
) {
2585 /* This call will notify the kernel thread */
2586 ret
= channel_kernel_create(session
->kernel_session
, NULL
,
2587 kernel_poll_pipe
[1]);
2588 if (ret
!= LTTCOMM_OK
) {
2592 /* Get the newly created kernel channel pointer */
2593 kchan
= trace_kernel_get_channel_by_name(channel_name
,
2594 session
->kernel_session
);
2595 if (kchan
== NULL
) {
2596 /* This sould not happen... */
2597 ret
= LTTCOMM_FATAL
;
2603 switch (event_type
) {
2604 case LTTNG_EVENT_SYSCALL
:
2605 ret
= event_kernel_enable_all_syscalls(session
->kernel_session
,
2606 kchan
, kernel_tracer_fd
);
2608 case LTTNG_EVENT_TRACEPOINT
:
2610 * This call enables all LTTNG_KERNEL_TRACEPOINTS and
2611 * events already registered to the channel.
2613 ret
= event_kernel_enable_all_tracepoints(session
->kernel_session
,
2614 kchan
, kernel_tracer_fd
);
2616 case LTTNG_EVENT_ALL
:
2617 /* Enable syscalls and tracepoints */
2618 ret
= event_kernel_enable_all(session
->kernel_session
,
2619 kchan
, kernel_tracer_fd
);
2622 ret
= LTTCOMM_KERN_ENABLE_FAIL
;
2626 /* Manage return value */
2627 if (ret
!= LTTCOMM_OK
) {
2631 kernel_wait_quiescent(kernel_tracer_fd
);
2633 case LTTNG_DOMAIN_UST
:
2635 struct lttng_channel
*attr
;
2636 struct ltt_ust_channel
*uchan
;
2637 struct ltt_ust_session
*usess
= session
->ust_session
;
2639 /* Get channel from global UST domain */
2640 uchan
= trace_ust_find_channel_by_name(usess
->domain_global
.channels
,
2642 if (uchan
== NULL
) {
2643 /* Create default channel */
2644 attr
= channel_new_default_attr(domain
);
2646 ret
= LTTCOMM_FATAL
;
2649 snprintf(attr
->name
, NAME_MAX
, "%s", channel_name
);
2650 attr
->name
[NAME_MAX
- 1] = '\0';
2652 /* Use the internal command enable channel */
2653 ret
= channel_ust_create(usess
, domain
, attr
);
2654 if (ret
!= LTTCOMM_OK
) {
2660 /* Get the newly created channel reference back */
2661 uchan
= trace_ust_find_channel_by_name(
2662 usess
->domain_global
.channels
, channel_name
);
2663 if (uchan
== NULL
) {
2664 /* Something is really wrong */
2665 ret
= LTTCOMM_FATAL
;
2670 /* At this point, the session and channel exist on the tracer */
2672 switch (event_type
) {
2673 case LTTNG_EVENT_ALL
:
2674 case LTTNG_EVENT_TRACEPOINT
:
2675 ret
= event_ust_enable_all_tracepoints(usess
, domain
, uchan
);
2676 if (ret
!= LTTCOMM_OK
) {
2681 ret
= LTTCOMM_UST_ENABLE_FAIL
;
2685 /* Manage return value */
2686 if (ret
!= LTTCOMM_OK
) {
2693 case LTTNG_DOMAIN_UST_EXEC_NAME
:
2694 case LTTNG_DOMAIN_UST_PID
:
2695 case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN
:
2709 * Command LTTNG_LIST_TRACEPOINTS processed by the client thread.
2711 static ssize_t
cmd_list_tracepoints(int domain
, struct lttng_event
**events
)
2714 ssize_t nb_events
= 0;
2717 case LTTNG_DOMAIN_KERNEL
:
2718 nb_events
= kernel_list_events(kernel_tracer_fd
, events
);
2719 if (nb_events
< 0) {
2720 ret
= LTTCOMM_KERN_LIST_FAIL
;
2724 case LTTNG_DOMAIN_UST
:
2725 nb_events
= ust_app_list_events(events
);
2726 if (nb_events
< 0) {
2727 ret
= LTTCOMM_UST_LIST_FAIL
;
2739 /* Return negative value to differentiate return code */
2744 * Command LTTNG_LIST_TRACEPOINT_FIELDS processed by the client thread.
2746 static ssize_t
cmd_list_tracepoint_fields(int domain
,
2747 struct lttng_event_field
**fields
)
2750 ssize_t nb_fields
= 0;
2753 case LTTNG_DOMAIN_UST
:
2754 nb_fields
= ust_app_list_event_fields(fields
);
2755 if (nb_fields
< 0) {
2756 ret
= LTTCOMM_UST_LIST_FAIL
;
2760 case LTTNG_DOMAIN_KERNEL
:
2761 default: /* fall-through */
2769 /* Return negative value to differentiate return code */
2774 * Command LTTNG_START_TRACE processed by the client thread.
2776 static int cmd_start_trace(struct ltt_session
*session
)
2779 struct ltt_kernel_session
*ksession
;
2780 struct ltt_ust_session
*usess
;
2783 ksession
= session
->kernel_session
;
2784 usess
= session
->ust_session
;
2786 if (session
->enabled
) {
2787 /* Already started. */
2788 ret
= LTTCOMM_TRACE_ALREADY_STARTED
;
2792 session
->enabled
= 1;
2794 /* Kernel tracing */
2795 if (ksession
!= NULL
) {
2796 struct ltt_kernel_channel
*kchan
;
2798 /* Open kernel metadata */
2799 if (ksession
->metadata
== NULL
) {
2800 ret
= kernel_open_metadata(ksession
, ksession
->trace_path
);
2802 ret
= LTTCOMM_KERN_META_FAIL
;
2807 /* Open kernel metadata stream */
2808 if (ksession
->metadata_stream_fd
< 0) {
2809 ret
= kernel_open_metadata_stream(ksession
);
2811 ERR("Kernel create metadata stream failed");
2812 ret
= LTTCOMM_KERN_STREAM_FAIL
;
2817 /* For each channel */
2818 cds_list_for_each_entry(kchan
, &ksession
->channel_list
.head
, list
) {
2819 if (kchan
->stream_count
== 0) {
2820 ret
= kernel_open_channel_stream(kchan
);
2822 ret
= LTTCOMM_KERN_STREAM_FAIL
;
2825 /* Update the stream global counter */
2826 ksession
->stream_count_global
+= ret
;
2830 /* Setup kernel consumer socket and send fds to it */
2831 ret
= init_kernel_tracing(ksession
);
2833 ret
= LTTCOMM_KERN_START_FAIL
;
2837 /* This start the kernel tracing */
2838 ret
= kernel_start_session(ksession
);
2840 ret
= LTTCOMM_KERN_START_FAIL
;
2844 /* Quiescent wait after starting trace */
2845 kernel_wait_quiescent(kernel_tracer_fd
);
2848 /* Flag session that trace should start automatically */
2850 usess
->start_trace
= 1;
2852 ret
= ust_app_start_trace_all(usess
);
2854 ret
= LTTCOMM_UST_START_FAIL
;
2866 * Command LTTNG_STOP_TRACE processed by the client thread.
2868 static int cmd_stop_trace(struct ltt_session
*session
)
2871 struct ltt_kernel_channel
*kchan
;
2872 struct ltt_kernel_session
*ksession
;
2873 struct ltt_ust_session
*usess
;
2876 ksession
= session
->kernel_session
;
2877 usess
= session
->ust_session
;
2879 if (!session
->enabled
) {
2880 ret
= LTTCOMM_TRACE_ALREADY_STOPPED
;
2884 session
->enabled
= 0;
2887 if (ksession
!= NULL
) {
2888 DBG("Stop kernel tracing");
2890 /* Flush all buffers before stopping */
2891 ret
= kernel_metadata_flush_buffer(ksession
->metadata_stream_fd
);
2893 ERR("Kernel metadata flush failed");
2896 cds_list_for_each_entry(kchan
, &ksession
->channel_list
.head
, list
) {
2897 ret
= kernel_flush_buffer(kchan
);
2899 ERR("Kernel flush buffer error");
2903 ret
= kernel_stop_session(ksession
);
2905 ret
= LTTCOMM_KERN_STOP_FAIL
;
2909 kernel_wait_quiescent(kernel_tracer_fd
);
2913 usess
->start_trace
= 0;
2915 ret
= ust_app_stop_trace_all(usess
);
2917 ret
= LTTCOMM_UST_STOP_FAIL
;
2929 * Command LTTNG_CREATE_SESSION processed by the client thread.
2931 static int cmd_create_session(char *name
, char *path
, lttng_sock_cred
*creds
)
2935 ret
= session_create(name
, path
, LTTNG_SOCK_GET_UID_CRED(creds
),
2936 LTTNG_SOCK_GET_GID_CRED(creds
));
2937 if (ret
!= LTTCOMM_OK
) {
2948 * Command LTTNG_DESTROY_SESSION processed by the client thread.
2950 static int cmd_destroy_session(struct ltt_session
*session
, char *name
)
2954 /* Clean kernel session teardown */
2955 teardown_kernel_session(session
);
2956 /* UST session teardown */
2957 teardown_ust_session(session
);
2960 * Must notify the kernel thread here to update it's poll setin order
2961 * to remove the channel(s)' fd just destroyed.
2963 ret
= notify_thread_pipe(kernel_poll_pipe
[1]);
2965 PERROR("write kernel poll pipe");
2968 ret
= session_destroy(session
);
2974 * Command LTTNG_CALIBRATE processed by the client thread.
2976 static int cmd_calibrate(int domain
, struct lttng_calibrate
*calibrate
)
2981 case LTTNG_DOMAIN_KERNEL
:
2983 struct lttng_kernel_calibrate kcalibrate
;
2985 kcalibrate
.type
= calibrate
->type
;
2986 ret
= kernel_calibrate(kernel_tracer_fd
, &kcalibrate
);
2988 ret
= LTTCOMM_KERN_ENABLE_FAIL
;
2993 case LTTNG_DOMAIN_UST
:
2995 struct lttng_ust_calibrate ucalibrate
;
2997 ucalibrate
.type
= calibrate
->type
;
2998 ret
= ust_app_calibrate_glb(&ucalibrate
);
3000 ret
= LTTCOMM_UST_CALIBRATE_FAIL
;
3017 * Command LTTNG_REGISTER_CONSUMER processed by the client thread.
3019 static int cmd_register_consumer(struct ltt_session
*session
, int domain
,
3025 case LTTNG_DOMAIN_KERNEL
:
3026 /* Can't register a consumer if there is already one */
3027 if (session
->kernel_session
->consumer_fds_sent
!= 0) {
3028 ret
= LTTCOMM_KERN_CONSUMER_FAIL
;
3032 sock
= lttcomm_connect_unix_sock(sock_path
);
3034 ret
= LTTCOMM_CONNECT_FAIL
;
3038 session
->kernel_session
->consumer_fd
= sock
;
3041 /* TODO: Userspace tracing */
3053 * Command LTTNG_LIST_DOMAINS processed by the client thread.
3055 static ssize_t
cmd_list_domains(struct ltt_session
*session
,
3056 struct lttng_domain
**domains
)
3061 if (session
->kernel_session
!= NULL
) {
3062 DBG3("Listing domains found kernel domain");
3066 if (session
->ust_session
!= NULL
) {
3067 DBG3("Listing domains found UST global domain");
3071 *domains
= zmalloc(nb_dom
* sizeof(struct lttng_domain
));
3072 if (*domains
== NULL
) {
3073 ret
= -LTTCOMM_FATAL
;
3077 if (session
->kernel_session
!= NULL
) {
3078 (*domains
)[index
].type
= LTTNG_DOMAIN_KERNEL
;
3082 if (session
->ust_session
!= NULL
) {
3083 (*domains
)[index
].type
= LTTNG_DOMAIN_UST
;
3094 * Command LTTNG_LIST_CHANNELS processed by the client thread.
3096 static ssize_t
cmd_list_channels(int domain
, struct ltt_session
*session
,
3097 struct lttng_channel
**channels
)
3100 ssize_t nb_chan
= 0;
3103 case LTTNG_DOMAIN_KERNEL
:
3104 if (session
->kernel_session
!= NULL
) {
3105 nb_chan
= session
->kernel_session
->channel_count
;
3107 DBG3("Number of kernel channels %zd", nb_chan
);
3109 case LTTNG_DOMAIN_UST
:
3110 if (session
->ust_session
!= NULL
) {
3111 nb_chan
= lttng_ht_get_count(
3112 session
->ust_session
->domain_global
.channels
);
3114 DBG3("Number of UST global channels %zd", nb_chan
);
3123 *channels
= zmalloc(nb_chan
* sizeof(struct lttng_channel
));
3124 if (*channels
== NULL
) {
3125 ret
= -LTTCOMM_FATAL
;
3129 list_lttng_channels(domain
, session
, *channels
);
3141 * Command LTTNG_LIST_EVENTS processed by the client thread.
3143 static ssize_t
cmd_list_events(int domain
, struct ltt_session
*session
,
3144 char *channel_name
, struct lttng_event
**events
)
3147 ssize_t nb_event
= 0;
3150 case LTTNG_DOMAIN_KERNEL
:
3151 if (session
->kernel_session
!= NULL
) {
3152 nb_event
= list_lttng_kernel_events(channel_name
,
3153 session
->kernel_session
, events
);
3156 case LTTNG_DOMAIN_UST
:
3158 if (session
->ust_session
!= NULL
) {
3159 nb_event
= list_lttng_ust_global_events(channel_name
,
3160 &session
->ust_session
->domain_global
, events
);
3176 * Process the command requested by the lttng client within the command
3177 * context structure. This function make sure that the return structure (llm)
3178 * is set and ready for transmission before returning.
3180 * Return any error encountered or 0 for success.
3182 static int process_client_msg(struct command_ctx
*cmd_ctx
)
3184 int ret
= LTTCOMM_OK
;
3185 int need_tracing_session
= 1;
3188 DBG("Processing client command %d", cmd_ctx
->lsm
->cmd_type
);
3190 switch (cmd_ctx
->lsm
->cmd_type
) {
3191 case LTTNG_CREATE_SESSION
:
3192 case LTTNG_DESTROY_SESSION
:
3193 case LTTNG_LIST_SESSIONS
:
3194 case LTTNG_LIST_DOMAINS
:
3195 case LTTNG_START_TRACE
:
3196 case LTTNG_STOP_TRACE
:
3203 if (opt_no_kernel
&& need_domain
3204 && cmd_ctx
->lsm
->domain
.type
== LTTNG_DOMAIN_KERNEL
) {
3206 ret
= LTTCOMM_NEED_ROOT_SESSIOND
;
3208 ret
= LTTCOMM_KERN_NA
;
3214 * Check for command that don't needs to allocate a returned payload. We do
3215 * this here so we don't have to make the call for no payload at each
3218 switch(cmd_ctx
->lsm
->cmd_type
) {
3219 case LTTNG_LIST_SESSIONS
:
3220 case LTTNG_LIST_TRACEPOINTS
:
3221 case LTTNG_LIST_TRACEPOINT_FIELDS
:
3222 case LTTNG_LIST_DOMAINS
:
3223 case LTTNG_LIST_CHANNELS
:
3224 case LTTNG_LIST_EVENTS
:
3227 /* Setup lttng message with no payload */
3228 ret
= setup_lttng_msg(cmd_ctx
, 0);
3230 /* This label does not try to unlock the session */
3231 goto init_setup_error
;
3235 /* Commands that DO NOT need a session. */
3236 switch (cmd_ctx
->lsm
->cmd_type
) {
3237 case LTTNG_CREATE_SESSION
:
3238 case LTTNG_CALIBRATE
:
3239 case LTTNG_LIST_SESSIONS
:
3240 case LTTNG_LIST_TRACEPOINTS
:
3241 case LTTNG_LIST_TRACEPOINT_FIELDS
:
3242 need_tracing_session
= 0;
3245 DBG("Getting session %s by name", cmd_ctx
->lsm
->session
.name
);
3247 * We keep the session list lock across _all_ commands
3248 * for now, because the per-session lock does not
3249 * handle teardown properly.
3251 session_lock_list();
3252 cmd_ctx
->session
= session_find_by_name(cmd_ctx
->lsm
->session
.name
);
3253 if (cmd_ctx
->session
== NULL
) {
3254 if (cmd_ctx
->lsm
->session
.name
!= NULL
) {
3255 ret
= LTTCOMM_SESS_NOT_FOUND
;
3257 /* If no session name specified */
3258 ret
= LTTCOMM_SELECT_SESS
;
3262 /* Acquire lock for the session */
3263 session_lock(cmd_ctx
->session
);
3272 * Check domain type for specific "pre-action".
3274 switch (cmd_ctx
->lsm
->domain
.type
) {
3275 case LTTNG_DOMAIN_KERNEL
:
3277 ret
= LTTCOMM_NEED_ROOT_SESSIOND
;
3281 /* Kernel tracer check */
3282 if (kernel_tracer_fd
== -1) {
3283 /* Basically, load kernel tracer modules */
3284 ret
= init_kernel_tracer();
3290 /* Consumer is in an ERROR state. Report back to client */
3291 if (uatomic_read(&kernel_consumerd_state
) == CONSUMER_ERROR
) {
3292 ret
= LTTCOMM_NO_KERNCONSUMERD
;
3296 /* Need a session for kernel command */
3297 if (need_tracing_session
) {
3298 if (cmd_ctx
->session
->kernel_session
== NULL
) {
3299 ret
= create_kernel_session(cmd_ctx
->session
);
3301 ret
= LTTCOMM_KERN_SESS_FAIL
;
3306 /* Start the kernel consumer daemon */
3307 pthread_mutex_lock(&kconsumer_data
.pid_mutex
);
3308 if (kconsumer_data
.pid
== 0 &&
3309 cmd_ctx
->lsm
->cmd_type
!= LTTNG_REGISTER_CONSUMER
) {
3310 pthread_mutex_unlock(&kconsumer_data
.pid_mutex
);
3311 ret
= start_consumerd(&kconsumer_data
);
3313 ret
= LTTCOMM_KERN_CONSUMER_FAIL
;
3316 uatomic_set(&kernel_consumerd_state
, CONSUMER_STARTED
);
3318 pthread_mutex_unlock(&kconsumer_data
.pid_mutex
);
3323 case LTTNG_DOMAIN_UST
:
3325 /* Consumer is in an ERROR state. Report back to client */
3326 if (uatomic_read(&ust_consumerd_state
) == CONSUMER_ERROR
) {
3327 ret
= LTTCOMM_NO_USTCONSUMERD
;
3331 if (need_tracing_session
) {
3332 if (cmd_ctx
->session
->ust_session
== NULL
) {
3333 ret
= create_ust_session(cmd_ctx
->session
,
3334 &cmd_ctx
->lsm
->domain
);
3335 if (ret
!= LTTCOMM_OK
) {
3339 /* Start the UST consumer daemons */
3341 pthread_mutex_lock(&ustconsumer64_data
.pid_mutex
);
3342 if (consumerd64_bin
[0] != '\0' &&
3343 ustconsumer64_data
.pid
== 0 &&
3344 cmd_ctx
->lsm
->cmd_type
!= LTTNG_REGISTER_CONSUMER
) {
3345 pthread_mutex_unlock(&ustconsumer64_data
.pid_mutex
);
3346 ret
= start_consumerd(&ustconsumer64_data
);
3348 ret
= LTTCOMM_UST_CONSUMER64_FAIL
;
3349 ust_consumerd64_fd
= -EINVAL
;
3353 ust_consumerd64_fd
= ustconsumer64_data
.cmd_sock
;
3354 uatomic_set(&ust_consumerd_state
, CONSUMER_STARTED
);
3356 pthread_mutex_unlock(&ustconsumer64_data
.pid_mutex
);
3359 if (consumerd32_bin
[0] != '\0' &&
3360 ustconsumer32_data
.pid
== 0 &&
3361 cmd_ctx
->lsm
->cmd_type
!= LTTNG_REGISTER_CONSUMER
) {
3362 pthread_mutex_unlock(&ustconsumer32_data
.pid_mutex
);
3363 ret
= start_consumerd(&ustconsumer32_data
);
3365 ret
= LTTCOMM_UST_CONSUMER32_FAIL
;
3366 ust_consumerd32_fd
= -EINVAL
;
3370 ust_consumerd32_fd
= ustconsumer32_data
.cmd_sock
;
3371 uatomic_set(&ust_consumerd_state
, CONSUMER_STARTED
);
3373 pthread_mutex_unlock(&ustconsumer32_data
.pid_mutex
);
3383 /* Validate consumer daemon state when start/stop trace command */
3384 if (cmd_ctx
->lsm
->cmd_type
== LTTNG_START_TRACE
||
3385 cmd_ctx
->lsm
->cmd_type
== LTTNG_STOP_TRACE
) {
3386 switch (cmd_ctx
->lsm
->domain
.type
) {
3387 case LTTNG_DOMAIN_UST
:
3388 if (uatomic_read(&ust_consumerd_state
) != CONSUMER_STARTED
) {
3389 ret
= LTTCOMM_NO_USTCONSUMERD
;
3393 case LTTNG_DOMAIN_KERNEL
:
3394 if (uatomic_read(&kernel_consumerd_state
) != CONSUMER_STARTED
) {
3395 ret
= LTTCOMM_NO_KERNCONSUMERD
;
3403 * Check that the UID or GID match that of the tracing session.
3404 * The root user can interact with all sessions.
3406 if (need_tracing_session
) {
3407 if (!session_access_ok(cmd_ctx
->session
,
3408 LTTNG_SOCK_GET_UID_CRED(&cmd_ctx
->creds
),
3409 LTTNG_SOCK_GET_GID_CRED(&cmd_ctx
->creds
))) {
3410 ret
= LTTCOMM_EPERM
;
3415 /* Process by command type */
3416 switch (cmd_ctx
->lsm
->cmd_type
) {
3417 case LTTNG_ADD_CONTEXT
:
3419 ret
= cmd_add_context(cmd_ctx
->session
, cmd_ctx
->lsm
->domain
.type
,
3420 cmd_ctx
->lsm
->u
.context
.channel_name
,
3421 cmd_ctx
->lsm
->u
.context
.event_name
,
3422 &cmd_ctx
->lsm
->u
.context
.ctx
);
3425 case LTTNG_DISABLE_CHANNEL
:
3427 ret
= cmd_disable_channel(cmd_ctx
->session
, cmd_ctx
->lsm
->domain
.type
,
3428 cmd_ctx
->lsm
->u
.disable
.channel_name
);
3431 case LTTNG_DISABLE_EVENT
:
3433 ret
= cmd_disable_event(cmd_ctx
->session
, cmd_ctx
->lsm
->domain
.type
,
3434 cmd_ctx
->lsm
->u
.disable
.channel_name
,
3435 cmd_ctx
->lsm
->u
.disable
.name
);
3438 case LTTNG_DISABLE_ALL_EVENT
:
3440 DBG("Disabling all events");
3442 ret
= cmd_disable_event_all(cmd_ctx
->session
, cmd_ctx
->lsm
->domain
.type
,
3443 cmd_ctx
->lsm
->u
.disable
.channel_name
);
3446 case LTTNG_ENABLE_CHANNEL
:
3448 ret
= cmd_enable_channel(cmd_ctx
->session
, cmd_ctx
->lsm
->domain
.type
,
3449 &cmd_ctx
->lsm
->u
.channel
.chan
);
3452 case LTTNG_ENABLE_EVENT
:
3454 ret
= cmd_enable_event(cmd_ctx
->session
, cmd_ctx
->lsm
->domain
.type
,
3455 cmd_ctx
->lsm
->u
.enable
.channel_name
,
3456 &cmd_ctx
->lsm
->u
.enable
.event
);
3459 case LTTNG_ENABLE_ALL_EVENT
:
3461 DBG("Enabling all events");
3463 ret
= cmd_enable_event_all(cmd_ctx
->session
, cmd_ctx
->lsm
->domain
.type
,
3464 cmd_ctx
->lsm
->u
.enable
.channel_name
,
3465 cmd_ctx
->lsm
->u
.enable
.event
.type
);
3468 case LTTNG_LIST_TRACEPOINTS
:
3470 struct lttng_event
*events
;
3473 nb_events
= cmd_list_tracepoints(cmd_ctx
->lsm
->domain
.type
, &events
);
3474 if (nb_events
< 0) {
3480 * Setup lttng message with payload size set to the event list size in
3481 * bytes and then copy list into the llm payload.
3483 ret
= setup_lttng_msg(cmd_ctx
, sizeof(struct lttng_event
) * nb_events
);
3489 /* Copy event list into message payload */
3490 memcpy(cmd_ctx
->llm
->payload
, events
,
3491 sizeof(struct lttng_event
) * nb_events
);
3498 case LTTNG_LIST_TRACEPOINT_FIELDS
:
3500 struct lttng_event_field
*fields
;
3503 nb_fields
= cmd_list_tracepoint_fields(cmd_ctx
->lsm
->domain
.type
, &fields
);
3504 if (nb_fields
< 0) {
3510 * Setup lttng message with payload size set to the event list size in
3511 * bytes and then copy list into the llm payload.
3513 ret
= setup_lttng_msg(cmd_ctx
, sizeof(struct lttng_event_field
) * nb_fields
);
3519 /* Copy event list into message payload */
3520 memcpy(cmd_ctx
->llm
->payload
, fields
,
3521 sizeof(struct lttng_event_field
) * nb_fields
);
3529 case LTTNG_START_TRACE
:
3531 ret
= cmd_start_trace(cmd_ctx
->session
);
3534 case LTTNG_STOP_TRACE
:
3536 ret
= cmd_stop_trace(cmd_ctx
->session
);
3539 case LTTNG_CREATE_SESSION
:
3541 ret
= cmd_create_session(cmd_ctx
->lsm
->session
.name
,
3542 cmd_ctx
->lsm
->session
.path
, &cmd_ctx
->creds
);
3545 case LTTNG_DESTROY_SESSION
:
3547 ret
= cmd_destroy_session(cmd_ctx
->session
,
3548 cmd_ctx
->lsm
->session
.name
);
3550 * Set session to NULL so we do not unlock it after
3553 cmd_ctx
->session
= NULL
;
3556 case LTTNG_LIST_DOMAINS
:
3559 struct lttng_domain
*domains
;
3561 nb_dom
= cmd_list_domains(cmd_ctx
->session
, &domains
);
3567 ret
= setup_lttng_msg(cmd_ctx
, nb_dom
* sizeof(struct lttng_domain
));
3572 /* Copy event list into message payload */
3573 memcpy(cmd_ctx
->llm
->payload
, domains
,
3574 nb_dom
* sizeof(struct lttng_domain
));
3581 case LTTNG_LIST_CHANNELS
:
3584 struct lttng_channel
*channels
;
3586 nb_chan
= cmd_list_channels(cmd_ctx
->lsm
->domain
.type
,
3587 cmd_ctx
->session
, &channels
);
3593 ret
= setup_lttng_msg(cmd_ctx
, nb_chan
* sizeof(struct lttng_channel
));
3598 /* Copy event list into message payload */
3599 memcpy(cmd_ctx
->llm
->payload
, channels
,
3600 nb_chan
* sizeof(struct lttng_channel
));
3607 case LTTNG_LIST_EVENTS
:
3610 struct lttng_event
*events
= NULL
;
3612 nb_event
= cmd_list_events(cmd_ctx
->lsm
->domain
.type
, cmd_ctx
->session
,
3613 cmd_ctx
->lsm
->u
.list
.channel_name
, &events
);
3619 ret
= setup_lttng_msg(cmd_ctx
, nb_event
* sizeof(struct lttng_event
));
3624 /* Copy event list into message payload */
3625 memcpy(cmd_ctx
->llm
->payload
, events
,
3626 nb_event
* sizeof(struct lttng_event
));
3633 case LTTNG_LIST_SESSIONS
:
3635 unsigned int nr_sessions
;
3637 session_lock_list();
3638 nr_sessions
= lttng_sessions_count(
3639 LTTNG_SOCK_GET_UID_CRED(&cmd_ctx
->creds
),
3640 LTTNG_SOCK_GET_GID_CRED(&cmd_ctx
->creds
));
3642 ret
= setup_lttng_msg(cmd_ctx
, sizeof(struct lttng_session
) * nr_sessions
);
3644 session_unlock_list();
3648 /* Filled the session array */
3649 list_lttng_sessions((struct lttng_session
*)(cmd_ctx
->llm
->payload
),
3650 LTTNG_SOCK_GET_UID_CRED(&cmd_ctx
->creds
),
3651 LTTNG_SOCK_GET_GID_CRED(&cmd_ctx
->creds
));
3653 session_unlock_list();
3658 case LTTNG_CALIBRATE
:
3660 ret
= cmd_calibrate(cmd_ctx
->lsm
->domain
.type
,
3661 &cmd_ctx
->lsm
->u
.calibrate
);
3664 case LTTNG_REGISTER_CONSUMER
:
3666 ret
= cmd_register_consumer(cmd_ctx
->session
, cmd_ctx
->lsm
->domain
.type
,
3667 cmd_ctx
->lsm
->u
.reg
.path
);
3676 if (cmd_ctx
->llm
== NULL
) {
3677 DBG("Missing llm structure. Allocating one.");
3678 if (setup_lttng_msg(cmd_ctx
, 0) < 0) {
3682 /* Set return code */
3683 cmd_ctx
->llm
->ret_code
= ret
;
3685 if (cmd_ctx
->session
) {
3686 session_unlock(cmd_ctx
->session
);
3688 if (need_tracing_session
) {
3689 session_unlock_list();
3696 * This thread manage all clients request using the unix client socket for
3699 static void *thread_manage_clients(void *data
)
3701 int sock
= -1, ret
, i
, pollfd
;
3702 uint32_t revents
, nb_fd
;
3703 struct command_ctx
*cmd_ctx
= NULL
;
3704 struct lttng_poll_event events
;
3706 DBG("[thread] Manage client started");
3708 rcu_register_thread();
3710 ret
= lttcomm_listen_unix_sock(client_sock
);
3716 * Pass 2 as size here for the thread quit pipe and client_sock. Nothing
3717 * more will be added to this poll set.
3719 ret
= create_thread_poll_set(&events
, 2);
3724 /* Add the application registration socket */
3725 ret
= lttng_poll_add(&events
, client_sock
, LPOLLIN
| LPOLLPRI
);
3731 * Notify parent pid that we are ready to accept command for client side.
3733 if (opt_sig_parent
) {
3734 kill(ppid
, SIGUSR1
);
3738 DBG("Accepting client command ...");
3740 nb_fd
= LTTNG_POLL_GETNB(&events
);
3742 /* Inifinite blocking call, waiting for transmission */
3744 ret
= lttng_poll_wait(&events
, -1);
3747 * Restart interrupted system call.
3749 if (errno
== EINTR
) {
3755 for (i
= 0; i
< nb_fd
; i
++) {
3756 /* Fetch once the poll data */
3757 revents
= LTTNG_POLL_GETEV(&events
, i
);
3758 pollfd
= LTTNG_POLL_GETFD(&events
, i
);
3760 /* Thread quit pipe has been closed. Killing thread. */
3761 ret
= check_thread_quit_pipe(pollfd
, revents
);
3766 /* Event on the registration socket */
3767 if (pollfd
== client_sock
) {
3768 if (revents
& (LPOLLERR
| LPOLLHUP
| LPOLLRDHUP
)) {
3769 ERR("Client socket poll error");
3775 DBG("Wait for client response");
3777 sock
= lttcomm_accept_unix_sock(client_sock
);
3782 /* Set socket option for credentials retrieval */
3783 ret
= lttcomm_setsockopt_creds_unix_sock(sock
);
3788 /* Allocate context command to process the client request */
3789 cmd_ctx
= zmalloc(sizeof(struct command_ctx
));
3790 if (cmd_ctx
== NULL
) {
3791 PERROR("zmalloc cmd_ctx");
3795 /* Allocate data buffer for reception */
3796 cmd_ctx
->lsm
= zmalloc(sizeof(struct lttcomm_session_msg
));
3797 if (cmd_ctx
->lsm
== NULL
) {
3798 PERROR("zmalloc cmd_ctx->lsm");
3802 cmd_ctx
->llm
= NULL
;
3803 cmd_ctx
->session
= NULL
;
3806 * Data is received from the lttng client. The struct
3807 * lttcomm_session_msg (lsm) contains the command and data request of
3810 DBG("Receiving data from client ...");
3811 ret
= lttcomm_recv_creds_unix_sock(sock
, cmd_ctx
->lsm
,
3812 sizeof(struct lttcomm_session_msg
), &cmd_ctx
->creds
);
3814 DBG("Nothing recv() from client... continuing");
3820 clean_command_ctx(&cmd_ctx
);
3824 // TODO: Validate cmd_ctx including sanity check for
3825 // security purpose.
3827 rcu_thread_online();
3829 * This function dispatch the work to the kernel or userspace tracer
3830 * libs and fill the lttcomm_lttng_msg data structure of all the needed
3831 * informations for the client. The command context struct contains
3832 * everything this function may needs.
3834 ret
= process_client_msg(cmd_ctx
);
3835 rcu_thread_offline();
3838 * TODO: Inform client somehow of the fatal error. At
3839 * this point, ret < 0 means that a zmalloc failed
3840 * (ENOMEM). Error detected but still accept command.
3842 clean_command_ctx(&cmd_ctx
);
3846 DBG("Sending response (size: %d, retcode: %s)",
3847 cmd_ctx
->lttng_msg_size
,
3848 lttng_strerror(-cmd_ctx
->llm
->ret_code
));
3849 ret
= send_unix_sock(sock
, cmd_ctx
->llm
, cmd_ctx
->lttng_msg_size
);
3851 ERR("Failed to send data back to client");
3854 /* End of transmission */
3861 clean_command_ctx(&cmd_ctx
);
3865 DBG("Client thread dying");
3866 unlink(client_unix_sock_path
);
3867 if (client_sock
>= 0) {
3868 ret
= close(client_sock
);
3880 lttng_poll_clean(&events
);
3881 clean_command_ctx(&cmd_ctx
);
3883 rcu_unregister_thread();
3889 * usage function on stderr
3891 static void usage(void)
3893 fprintf(stderr
, "Usage: %s OPTIONS\n\nOptions:\n", progname
);
3894 fprintf(stderr
, " -h, --help Display this usage.\n");
3895 fprintf(stderr
, " -c, --client-sock PATH Specify path for the client unix socket\n");
3896 fprintf(stderr
, " -a, --apps-sock PATH Specify path for apps unix socket\n");
3897 fprintf(stderr
, " --kconsumerd-err-sock PATH Specify path for the kernel consumer error socket\n");
3898 fprintf(stderr
, " --kconsumerd-cmd-sock PATH Specify path for the kernel consumer command socket\n");
3899 fprintf(stderr
, " --ustconsumerd32-err-sock PATH Specify path for the 32-bit UST consumer error socket\n");
3900 fprintf(stderr
, " --ustconsumerd64-err-sock PATH Specify path for the 64-bit UST consumer error socket\n");
3901 fprintf(stderr
, " --ustconsumerd32-cmd-sock PATH Specify path for the 32-bit UST consumer command socket\n");
3902 fprintf(stderr
, " --ustconsumerd64-cmd-sock PATH Specify path for the 64-bit UST consumer command socket\n");
3903 fprintf(stderr
, " --consumerd32-path PATH Specify path for the 32-bit UST consumer daemon binary\n");
3904 fprintf(stderr
, " --consumerd32-libdir PATH Specify path for the 32-bit UST consumer daemon libraries\n");
3905 fprintf(stderr
, " --consumerd64-path PATH Specify path for the 64-bit UST consumer daemon binary\n");
3906 fprintf(stderr
, " --consumerd64-libdir PATH Specify path for the 64-bit UST consumer daemon libraries\n");
3907 fprintf(stderr
, " -d, --daemonize Start as a daemon.\n");
3908 fprintf(stderr
, " -g, --group NAME Specify the tracing group name. (default: tracing)\n");
3909 fprintf(stderr
, " -V, --version Show version number.\n");
3910 fprintf(stderr
, " -S, --sig-parent Send SIGCHLD to parent pid to notify readiness.\n");
3911 fprintf(stderr
, " -q, --quiet No output at all.\n");
3912 fprintf(stderr
, " -v, --verbose Verbose mode. Activate DBG() macro.\n");
3913 fprintf(stderr
, " --verbose-consumer Verbose mode for consumer. Activate DBG() macro.\n");
3914 fprintf(stderr
, " --no-kernel Disable kernel tracer\n");
3918 * daemon argument parsing
3920 static int parse_args(int argc
, char **argv
)
3924 static struct option long_options
[] = {
3925 { "client-sock", 1, 0, 'c' },
3926 { "apps-sock", 1, 0, 'a' },
3927 { "kconsumerd-cmd-sock", 1, 0, 'C' },
3928 { "kconsumerd-err-sock", 1, 0, 'E' },
3929 { "ustconsumerd32-cmd-sock", 1, 0, 'G' },
3930 { "ustconsumerd32-err-sock", 1, 0, 'H' },
3931 { "ustconsumerd64-cmd-sock", 1, 0, 'D' },
3932 { "ustconsumerd64-err-sock", 1, 0, 'F' },
3933 { "consumerd32-path", 1, 0, 'u' },
3934 { "consumerd32-libdir", 1, 0, 'U' },
3935 { "consumerd64-path", 1, 0, 't' },
3936 { "consumerd64-libdir", 1, 0, 'T' },
3937 { "daemonize", 0, 0, 'd' },
3938 { "sig-parent", 0, 0, 'S' },
3939 { "help", 0, 0, 'h' },
3940 { "group", 1, 0, 'g' },
3941 { "version", 0, 0, 'V' },
3942 { "quiet", 0, 0, 'q' },
3943 { "verbose", 0, 0, 'v' },
3944 { "verbose-consumer", 0, 0, 'Z' },
3945 { "no-kernel", 0, 0, 'N' },
3950 int option_index
= 0;
3951 c
= getopt_long(argc
, argv
, "dhqvVSN" "a:c:g:s:C:E:D:F:Z:u:t",
3952 long_options
, &option_index
);
3959 fprintf(stderr
, "option %s", long_options
[option_index
].name
);
3961 fprintf(stderr
, " with arg %s\n", optarg
);
3965 snprintf(client_unix_sock_path
, PATH_MAX
, "%s", optarg
);
3968 snprintf(apps_unix_sock_path
, PATH_MAX
, "%s", optarg
);
3974 opt_tracing_group
= optarg
;
3980 fprintf(stdout
, "%s\n", VERSION
);
3986 snprintf(kconsumer_data
.err_unix_sock_path
, PATH_MAX
, "%s", optarg
);
3989 snprintf(kconsumer_data
.cmd_unix_sock_path
, PATH_MAX
, "%s", optarg
);
3992 snprintf(ustconsumer64_data
.err_unix_sock_path
, PATH_MAX
, "%s", optarg
);
3995 snprintf(ustconsumer64_data
.cmd_unix_sock_path
, PATH_MAX
, "%s", optarg
);
3998 snprintf(ustconsumer32_data
.err_unix_sock_path
, PATH_MAX
, "%s", optarg
);
4001 snprintf(ustconsumer32_data
.cmd_unix_sock_path
, PATH_MAX
, "%s", optarg
);
4007 lttng_opt_quiet
= 1;
4010 /* Verbose level can increase using multiple -v */
4011 lttng_opt_verbose
+= 1;
4014 opt_verbose_consumer
+= 1;
4017 consumerd32_bin
= optarg
;
4020 consumerd32_libdir
= optarg
;
4023 consumerd64_bin
= optarg
;
4026 consumerd64_libdir
= optarg
;
4029 /* Unknown option or other error.
4030 * Error is printed by getopt, just return */
4039 * Creates the two needed socket by the daemon.
4040 * apps_sock - The communication socket for all UST apps.
4041 * client_sock - The communication of the cli tool (lttng).
4043 static int init_daemon_socket(void)
4048 old_umask
= umask(0);
4050 /* Create client tool unix socket */
4051 client_sock
= lttcomm_create_unix_sock(client_unix_sock_path
);
4052 if (client_sock
< 0) {
4053 ERR("Create unix sock failed: %s", client_unix_sock_path
);
4058 /* File permission MUST be 660 */
4059 ret
= chmod(client_unix_sock_path
, S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
);
4061 ERR("Set file permissions failed: %s", client_unix_sock_path
);
4066 /* Create the application unix socket */
4067 apps_sock
= lttcomm_create_unix_sock(apps_unix_sock_path
);
4068 if (apps_sock
< 0) {
4069 ERR("Create unix sock failed: %s", apps_unix_sock_path
);
4074 /* File permission MUST be 666 */
4075 ret
= chmod(apps_unix_sock_path
,
4076 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
| S_IROTH
| S_IWOTH
);
4078 ERR("Set file permissions failed: %s", apps_unix_sock_path
);
4089 * Check if the global socket is available, and if a daemon is answering at the
4090 * other side. If yes, error is returned.
4092 static int check_existing_daemon(void)
4094 /* Is there anybody out there ? */
4095 if (lttng_session_daemon_alive()) {
4103 * Set the tracing group gid onto the client socket.
4105 * Race window between mkdir and chown is OK because we are going from more
4106 * permissive (root.root) to less permissive (root.tracing).
4108 static int set_permissions(char *rundir
)
4113 ret
= allowed_group();
4115 WARN("No tracing group detected");
4122 /* Set lttng run dir */
4123 ret
= chown(rundir
, 0, gid
);
4125 ERR("Unable to set group on %s", rundir
);
4129 /* Ensure tracing group can search the run dir */
4130 ret
= chmod(rundir
, S_IRWXU
| S_IXGRP
| S_IXOTH
);
4132 ERR("Unable to set permissions on %s", rundir
);
4136 /* lttng client socket path */
4137 ret
= chown(client_unix_sock_path
, 0, gid
);
4139 ERR("Unable to set group on %s", client_unix_sock_path
);
4143 /* kconsumer error socket path */
4144 ret
= chown(kconsumer_data
.err_unix_sock_path
, 0, gid
);
4146 ERR("Unable to set group on %s", kconsumer_data
.err_unix_sock_path
);
4150 /* 64-bit ustconsumer error socket path */
4151 ret
= chown(ustconsumer64_data
.err_unix_sock_path
, 0, gid
);
4153 ERR("Unable to set group on %s", ustconsumer64_data
.err_unix_sock_path
);
4157 /* 32-bit ustconsumer compat32 error socket path */
4158 ret
= chown(ustconsumer32_data
.err_unix_sock_path
, 0, gid
);
4160 ERR("Unable to set group on %s", ustconsumer32_data
.err_unix_sock_path
);
4164 DBG("All permissions are set");
4171 * Create the pipe used to wake up the kernel thread.
4172 * Closed in cleanup().
4174 static int create_kernel_poll_pipe(void)
4178 ret
= pipe(kernel_poll_pipe
);
4180 PERROR("kernel poll pipe");
4184 for (i
= 0; i
< 2; i
++) {
4185 ret
= fcntl(kernel_poll_pipe
[i
], F_SETFD
, FD_CLOEXEC
);
4187 PERROR("fcntl kernel_poll_pipe");
4197 * Create the application command pipe to wake thread_manage_apps.
4198 * Closed in cleanup().
4200 static int create_apps_cmd_pipe(void)
4204 ret
= pipe(apps_cmd_pipe
);
4206 PERROR("apps cmd pipe");
4210 for (i
= 0; i
< 2; i
++) {
4211 ret
= fcntl(apps_cmd_pipe
[i
], F_SETFD
, FD_CLOEXEC
);
4213 PERROR("fcntl apps_cmd_pipe");
4223 * Create the lttng run directory needed for all global sockets and pipe.
4225 static int create_lttng_rundir(const char *rundir
)
4229 DBG3("Creating LTTng run directory: %s", rundir
);
4231 ret
= mkdir(rundir
, S_IRWXU
);
4233 if (errno
!= EEXIST
) {
4234 ERR("Unable to create %s", rundir
);
4246 * Setup sockets and directory needed by the kconsumerd communication with the
4249 static int set_consumer_sockets(struct consumer_data
*consumer_data
,
4253 char path
[PATH_MAX
];
4255 switch (consumer_data
->type
) {
4256 case LTTNG_CONSUMER_KERNEL
:
4257 snprintf(path
, PATH_MAX
, DEFAULT_KCONSUMERD_PATH
, rundir
);
4259 case LTTNG_CONSUMER64_UST
:
4260 snprintf(path
, PATH_MAX
, DEFAULT_USTCONSUMERD64_PATH
, rundir
);
4262 case LTTNG_CONSUMER32_UST
:
4263 snprintf(path
, PATH_MAX
, DEFAULT_USTCONSUMERD32_PATH
, rundir
);
4266 ERR("Consumer type unknown");
4271 DBG2("Creating consumer directory: %s", path
);
4273 ret
= mkdir(path
, S_IRWXU
);
4275 if (errno
!= EEXIST
) {
4277 ERR("Failed to create %s", path
);
4283 /* Create the kconsumerd error unix socket */
4284 consumer_data
->err_sock
=
4285 lttcomm_create_unix_sock(consumer_data
->err_unix_sock_path
);
4286 if (consumer_data
->err_sock
< 0) {
4287 ERR("Create unix sock failed: %s", consumer_data
->err_unix_sock_path
);
4292 /* File permission MUST be 660 */
4293 ret
= chmod(consumer_data
->err_unix_sock_path
,
4294 S_IRUSR
| S_IWUSR
| S_IRGRP
| S_IWGRP
);
4296 ERR("Set file permissions failed: %s", consumer_data
->err_unix_sock_path
);
4306 * Signal handler for the daemon
4308 * Simply stop all worker threads, leaving main() return gracefully after
4309 * joining all threads and calling cleanup().
4311 static void sighandler(int sig
)
4315 DBG("SIGPIPE caught");
4318 DBG("SIGINT caught");
4322 DBG("SIGTERM caught");
4331 * Setup signal handler for :
4332 * SIGINT, SIGTERM, SIGPIPE
4334 static int set_signal_handler(void)
4337 struct sigaction sa
;
4340 if ((ret
= sigemptyset(&sigset
)) < 0) {
4341 PERROR("sigemptyset");
4345 sa
.sa_handler
= sighandler
;
4346 sa
.sa_mask
= sigset
;
4348 if ((ret
= sigaction(SIGTERM
, &sa
, NULL
)) < 0) {
4349 PERROR("sigaction");
4353 if ((ret
= sigaction(SIGINT
, &sa
, NULL
)) < 0) {
4354 PERROR("sigaction");
4358 if ((ret
= sigaction(SIGPIPE
, &sa
, NULL
)) < 0) {
4359 PERROR("sigaction");
4363 DBG("Signal handler set for SIGTERM, SIGPIPE and SIGINT");
4369 * Set open files limit to unlimited. This daemon can open a large number of
4370 * file descriptors in order to consumer multiple kernel traces.
4372 static void set_ulimit(void)
4377 /* The kernel does not allowed an infinite limit for open files */
4378 lim
.rlim_cur
= 65535;
4379 lim
.rlim_max
= 65535;
4381 ret
= setrlimit(RLIMIT_NOFILE
, &lim
);
4383 PERROR("failed to set open files limit");
4390 int main(int argc
, char **argv
)
4394 const char *home_path
;
4396 init_kernel_workarounds();
4398 rcu_register_thread();
4400 setup_consumerd_path();
4402 /* Parse arguments */
4404 if ((ret
= parse_args(argc
, argv
) < 0)) {
4414 * child: setsid, close FD 0, 1, 2, chdir /
4415 * parent: exit (if fork is successful)
4423 * We are in the child. Make sure all other file
4424 * descriptors are closed, in case we are called with
4425 * more opened file descriptors than the standard ones.
4427 for (i
= 3; i
< sysconf(_SC_OPEN_MAX
); i
++) {
4432 /* Create thread quit pipe */
4433 if ((ret
= init_thread_quit_pipe()) < 0) {
4437 /* Check if daemon is UID = 0 */
4438 is_root
= !getuid();
4441 rundir
= strdup(DEFAULT_LTTNG_RUNDIR
);
4443 /* Create global run dir with root access */
4444 ret
= create_lttng_rundir(rundir
);
4449 if (strlen(apps_unix_sock_path
) == 0) {
4450 snprintf(apps_unix_sock_path
, PATH_MAX
,
4451 DEFAULT_GLOBAL_APPS_UNIX_SOCK
);
4454 if (strlen(client_unix_sock_path
) == 0) {
4455 snprintf(client_unix_sock_path
, PATH_MAX
,
4456 DEFAULT_GLOBAL_CLIENT_UNIX_SOCK
);
4459 /* Set global SHM for ust */
4460 if (strlen(wait_shm_path
) == 0) {
4461 snprintf(wait_shm_path
, PATH_MAX
,
4462 DEFAULT_GLOBAL_APPS_WAIT_SHM_PATH
);
4465 /* Setup kernel consumerd path */
4466 snprintf(kconsumer_data
.err_unix_sock_path
, PATH_MAX
,
4467 DEFAULT_KCONSUMERD_ERR_SOCK_PATH
, rundir
);
4468 snprintf(kconsumer_data
.cmd_unix_sock_path
, PATH_MAX
,
4469 DEFAULT_KCONSUMERD_CMD_SOCK_PATH
, rundir
);
4471 DBG2("Kernel consumer err path: %s",
4472 kconsumer_data
.err_unix_sock_path
);
4473 DBG2("Kernel consumer cmd path: %s",
4474 kconsumer_data
.cmd_unix_sock_path
);
4476 home_path
= get_home_dir();
4477 if (home_path
== NULL
) {
4478 /* TODO: Add --socket PATH option */
4479 ERR("Can't get HOME directory for sockets creation.");
4485 * Create rundir from home path. This will create something like
4488 ret
= asprintf(&rundir
, DEFAULT_LTTNG_HOME_RUNDIR
, home_path
);
4494 ret
= create_lttng_rundir(rundir
);
4499 if (strlen(apps_unix_sock_path
) == 0) {
4500 snprintf(apps_unix_sock_path
, PATH_MAX
,
4501 DEFAULT_HOME_APPS_UNIX_SOCK
, home_path
);
4504 /* Set the cli tool unix socket path */
4505 if (strlen(client_unix_sock_path
) == 0) {
4506 snprintf(client_unix_sock_path
, PATH_MAX
,
4507 DEFAULT_HOME_CLIENT_UNIX_SOCK
, home_path
);
4510 /* Set global SHM for ust */
4511 if (strlen(wait_shm_path
) == 0) {
4512 snprintf(wait_shm_path
, PATH_MAX
,
4513 DEFAULT_HOME_APPS_WAIT_SHM_PATH
, geteuid());
4517 /* Set consumer initial state */
4518 kernel_consumerd_state
= CONSUMER_STOPPED
;
4519 ust_consumerd_state
= CONSUMER_STOPPED
;
4521 DBG("Client socket path %s", client_unix_sock_path
);
4522 DBG("Application socket path %s", apps_unix_sock_path
);
4523 DBG("LTTng run directory path: %s", rundir
);
4525 /* 32 bits consumerd path setup */
4526 snprintf(ustconsumer32_data
.err_unix_sock_path
, PATH_MAX
,
4527 DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH
, rundir
);
4528 snprintf(ustconsumer32_data
.cmd_unix_sock_path
, PATH_MAX
,
4529 DEFAULT_USTCONSUMERD32_CMD_SOCK_PATH
, rundir
);
4531 DBG2("UST consumer 32 bits err path: %s",
4532 ustconsumer32_data
.err_unix_sock_path
);
4533 DBG2("UST consumer 32 bits cmd path: %s",
4534 ustconsumer32_data
.cmd_unix_sock_path
);
4536 /* 64 bits consumerd path setup */
4537 snprintf(ustconsumer64_data
.err_unix_sock_path
, PATH_MAX
,
4538 DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH
, rundir
);
4539 snprintf(ustconsumer64_data
.cmd_unix_sock_path
, PATH_MAX
,
4540 DEFAULT_USTCONSUMERD64_CMD_SOCK_PATH
, rundir
);
4542 DBG2("UST consumer 64 bits err path: %s",
4543 ustconsumer64_data
.err_unix_sock_path
);
4544 DBG2("UST consumer 64 bits cmd path: %s",
4545 ustconsumer64_data
.cmd_unix_sock_path
);
4548 * See if daemon already exist.
4550 if ((ret
= check_existing_daemon()) < 0) {
4551 ERR("Already running daemon.\n");
4553 * We do not goto exit because we must not cleanup()
4554 * because a daemon is already running.
4560 * Init UST app hash table. Alloc hash table before this point since
4561 * cleanup() can get called after that point.
4565 /* After this point, we can safely call cleanup() with "goto exit" */
4568 * These actions must be executed as root. We do that *after* setting up
4569 * the sockets path because we MUST make the check for another daemon using
4570 * those paths *before* trying to set the kernel consumer sockets and init
4574 ret
= set_consumer_sockets(&kconsumer_data
, rundir
);
4579 /* Setup kernel tracer */
4580 if (!opt_no_kernel
) {
4581 init_kernel_tracer();
4584 /* Set ulimit for open files */
4587 /* init lttng_fd tracking must be done after set_ulimit. */
4590 ret
= set_consumer_sockets(&ustconsumer64_data
, rundir
);
4595 ret
= set_consumer_sockets(&ustconsumer32_data
, rundir
);
4600 if ((ret
= set_signal_handler()) < 0) {
4604 /* Setup the needed unix socket */
4605 if ((ret
= init_daemon_socket()) < 0) {
4609 /* Set credentials to socket */
4610 if (is_root
&& ((ret
= set_permissions(rundir
)) < 0)) {
4614 /* Get parent pid if -S, --sig-parent is specified. */
4615 if (opt_sig_parent
) {
4619 /* Setup the kernel pipe for waking up the kernel thread */
4620 if ((ret
= create_kernel_poll_pipe()) < 0) {
4624 /* Setup the thread apps communication pipe. */
4625 if ((ret
= create_apps_cmd_pipe()) < 0) {
4629 /* Init UST command queue. */
4630 cds_wfq_init(&ust_cmd_queue
.queue
);
4633 * Get session list pointer. This pointer MUST NOT be free(). This list is
4634 * statically declared in session.c
4636 session_list_ptr
= session_get_list();
4638 /* Set up max poll set size */
4639 lttng_poll_set_max_size();
4641 /* Create thread to manage the client socket */
4642 ret
= pthread_create(&client_thread
, NULL
,
4643 thread_manage_clients
, (void *) NULL
);
4645 PERROR("pthread_create clients");
4649 /* Create thread to dispatch registration */
4650 ret
= pthread_create(&dispatch_thread
, NULL
,
4651 thread_dispatch_ust_registration
, (void *) NULL
);
4653 PERROR("pthread_create dispatch");
4657 /* Create thread to manage application registration. */
4658 ret
= pthread_create(®_apps_thread
, NULL
,
4659 thread_registration_apps
, (void *) NULL
);
4661 PERROR("pthread_create registration");
4665 /* Create thread to manage application socket */
4666 ret
= pthread_create(&apps_thread
, NULL
,
4667 thread_manage_apps
, (void *) NULL
);
4669 PERROR("pthread_create apps");
4673 /* Create kernel thread to manage kernel event */
4674 ret
= pthread_create(&kernel_thread
, NULL
,
4675 thread_manage_kernel
, (void *) NULL
);
4677 PERROR("pthread_create kernel");
4681 ret
= pthread_join(kernel_thread
, &status
);
4683 PERROR("pthread_join");
4684 goto error
; /* join error, exit without cleanup */
4688 ret
= pthread_join(apps_thread
, &status
);
4690 PERROR("pthread_join");
4691 goto error
; /* join error, exit without cleanup */
4695 ret
= pthread_join(reg_apps_thread
, &status
);
4697 PERROR("pthread_join");
4698 goto error
; /* join error, exit without cleanup */
4702 ret
= pthread_join(dispatch_thread
, &status
);
4704 PERROR("pthread_join");
4705 goto error
; /* join error, exit without cleanup */
4709 ret
= pthread_join(client_thread
, &status
);
4711 PERROR("pthread_join");
4712 goto error
; /* join error, exit without cleanup */
4715 ret
= join_consumer_thread(&kconsumer_data
);
4717 PERROR("join_consumer");
4718 goto error
; /* join error, exit without cleanup */
4724 * cleanup() is called when no other thread is running.
4726 rcu_thread_online();
4728 rcu_thread_offline();
4729 rcu_unregister_thread();