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