7fbbcd68f4f216388aedc661f8b2cef4951c0778
[lttng-tools.git] / lttng / lttng.c
1 /*
2 * Copyright (c) 2011 David Goulet <david.goulet@polymtl.ca>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
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 <errno.h>
21 #include <fcntl.h>
22 #include <getopt.h>
23 #include <grp.h>
24 #include <limits.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <sys/stat.h>
29 #include <sys/types.h>
30 #include <sys/wait.h>
31 #include <unistd.h>
32
33 #include <lttng/lttng.h>
34
35 #include "lttng.h"
36 #include "lttngerr.h"
37
38 /* Variables */
39 static char *progname;
40 static char *session_name;
41 static uuid_t current_uuid;
42 static int auto_session;
43 static int auto_trace;
44
45 /* Prototypes */
46 static int process_client_opt(void);
47 static int process_opt_list_apps(void);
48 static int process_opt_list_sessions(void);
49 static int process_opt_list_traces(void);
50 static int process_opt_create_session(void);
51 static int process_kernel_create_trace(void);
52 static int process_opt_kernel_event(void);
53 static int process_kernel_start_trace(void);
54 static int set_session_uuid(void);
55 static void sighandler(int sig);
56 static int set_signal_handler(void);
57 static int validate_options(void);
58 static char *get_cmdline_by_pid(pid_t pid);
59 static void set_opt_session_info(void);
60
61 /*
62 * start_client
63 *
64 * Process client request from the command line
65 * options. Every tracing action is done by the
66 * liblttngctl API.
67 */
68 static int process_client_opt(void)
69 {
70 int ret;
71
72 set_opt_session_info();
73
74 if (opt_list_apps) {
75 ret = process_opt_list_apps();
76 if (ret < 0) {
77 goto end;
78 }
79 goto error;
80 }
81
82 if (opt_list_session) {
83 ret = process_opt_list_sessions();
84 if (ret < 0) {
85 goto end;
86 }
87 goto error;
88 }
89
90 /* Session creation or auto session set on */
91 if (auto_session || opt_create_session) {
92 DBG("Creating a new session");
93 ret = process_opt_create_session();
94 if (ret < 0) {
95 goto end;
96 }
97 }
98
99 ret = set_session_uuid();
100 if (ret < 0) {
101 ERR("Session %s not found", opt_session_name);
102 goto error;
103 }
104
105 if (opt_destroy_session) {
106 ret = lttng_destroy_session(&current_uuid);
107 if (ret < 0) {
108 goto end;
109 }
110 MSG("Session %s destroyed.", opt_session_name);
111 }
112
113 if (opt_list_traces) {
114 ret = process_opt_list_traces();
115 if (ret < 0) {
116 goto end;
117 }
118 }
119
120 /*
121 * Action on traces (kernel or/and userspace).
122 */
123
124 if (opt_trace_kernel) {
125 if (auto_trace || opt_create_trace) {
126 DBG("Creating a kernel trace");
127 ret = process_kernel_create_trace();
128 if (ret < 0) {
129 goto end;
130 }
131 }
132
133 if (opt_event_list != NULL) {
134 ret = process_opt_kernel_event();
135 if (ret < 0) {
136 goto end;
137 }
138 } else {
139 // Enable all events
140 }
141
142 if (auto_trace || opt_start_trace) {
143 DBG("Starting kernel tracing");
144 ret = process_kernel_start_trace();
145 if (ret < 0) {
146 goto end;
147 }
148 }
149
150 if (opt_stop_trace) {
151 DBG("Stopping kernel tracing");
152 ret = lttng_kernel_stop_tracing();
153 if (ret < 0) {
154 goto end;
155 }
156 }
157 }
158
159 if (opt_trace_pid != 0) {
160 if (auto_trace || opt_create_trace) {
161 DBG("Create a userspace trace for pid %d", opt_trace_pid);
162 ret = lttng_ust_create_trace(opt_trace_pid);
163 if (ret < 0) {
164 goto end;
165 }
166 MSG("Trace created successfully!");
167 }
168
169 if (auto_trace || opt_start_trace) {
170 DBG("Start trace for pid %d", opt_trace_pid);
171 ret = lttng_ust_start_trace(opt_trace_pid);
172 if (ret < 0) {
173 goto end;
174 }
175 MSG("Trace started successfully!");
176 } else if (opt_stop_trace) {
177 DBG("Stop trace for pid %d", opt_trace_pid);
178 ret = lttng_ust_stop_trace(opt_trace_pid);
179 if (ret < 0) {
180 goto end;
181 }
182 MSG("Trace stopped successfully!");
183 }
184
185 }
186
187 return 0;
188
189 end:
190 ERR("%s", lttng_get_readable_code(ret));
191 error: /* fall through */
192 return ret;
193 }
194
195 /*
196 * process_kernel_start_trace
197 *
198 * Start a kernel trace.
199 */
200 static int process_kernel_start_trace(void)
201 {
202 int ret;
203
204 ret = lttng_kernel_create_stream();
205 if (ret < 0) {
206 goto error;
207 }
208
209 ret = lttng_kernel_start_tracing();
210 if (ret < 0) {
211 goto error;
212 }
213
214 MSG("Kernel tracing started");
215
216 return 0;
217
218 error:
219 return ret;
220 }
221
222 /*
223 * process_kernel_create_trace
224 *
225 * Create a kernel trace.
226 */
227 static int process_kernel_create_trace(void)
228 {
229 int ret;
230
231 /* Setup kernel session */
232 ret = lttng_kernel_create_session();
233 if (ret < 0) {
234 goto error;
235 }
236
237 /* Create an empty channel (with no event) */
238 ret = lttng_kernel_create_channel();
239 if (ret < 0) {
240 goto error;
241 }
242
243 /* Opening metadata for session */
244 ret = lttng_kernel_open_metadata();
245 if (ret < 0) {
246 goto error;
247 }
248
249 return 0;
250
251 error:
252 return ret;
253 }
254
255 /*
256 * process_kernel_event
257 *
258 * Enable kernel event from the command line list given.
259 */
260 static int process_opt_kernel_event(void)
261 {
262 int ret;
263 char *event_name;
264
265 event_name = strtok(opt_event_list, ",");
266 while (event_name != NULL) {
267 DBG("Enabling kernel event %s", event_name);
268 ret = lttng_kernel_enable_event(event_name);
269 if (ret < 0) {
270 ERR("%s %s", lttng_get_readable_code(ret), event_name);
271 } else {
272 MSG("Kernel event %s enabled.", event_name);
273 }
274 /* Next event */
275 event_name = strtok(NULL, ",");
276 }
277
278 return 0;
279 }
280
281 /*
282 * set_opt_session_info
283 *
284 * Setup session_name, current_uuid, short_str_uuid and
285 * long_str_uuid using the command line options.
286 */
287 static void set_opt_session_info(void)
288 {
289 if (opt_session_name != NULL) {
290 session_name = strndup(opt_session_name, NAME_MAX);
291 DBG("Session name set to %s", session_name);
292 }
293 }
294
295 /*
296 * set_session_uuid
297 *
298 * Set current session uuid to the current flow of command(s) using the
299 * session_name.
300 */
301 static int set_session_uuid(void)
302 {
303 int ret, count, i, found = 0;
304 struct lttng_session *sessions;
305
306 if (!uuid_is_null(current_uuid)) {
307 lttng_set_current_session_uuid(&current_uuid);
308 goto end;
309 }
310
311 count = lttng_list_sessions(&sessions);
312 if (count < 0) {
313 ret = count;
314 goto error;
315 }
316
317 for (i = 0; i < count; i++) {
318 if (strncmp(sessions[i].name, session_name, NAME_MAX) == 0) {
319 lttng_set_current_session_uuid(&sessions[i].uuid);
320 uuid_copy(current_uuid, sessions[i].uuid);
321 found = 1;
322 break;
323 }
324 }
325
326 free(sessions);
327
328 if (!found) {
329 return -1;
330 }
331
332 end:
333 DBG("Session UUID set");
334 return 0;
335
336 error:
337 return ret;
338 }
339
340 /*
341 * process_opt_list_traces
342 *
343 * Get list of all traces for a specific session uuid.
344 */
345 static int process_opt_list_traces(void)
346 {
347 int ret, i;
348 struct lttng_trace *traces;
349
350 ret = lttng_list_traces(&current_uuid, &traces);
351 DBG("Number of traces to list %d", ret);
352 if (ret < 0) {
353 goto error;
354 }
355
356 /* No traces */
357 if (ret == 0) {
358 MSG("No traces found.");
359 goto error;
360 }
361
362 MSG("Userspace traces:");
363 for (i = 0; i < ret; i++) {
364 if (traces[i].type == USERSPACE) {
365 MSG("\t%d) %s (pid: %d): %s",
366 i, traces[i].name, traces[i].pid,
367 get_cmdline_by_pid(traces[i].pid));
368 } else {
369 break;
370 }
371 }
372
373 MSG("Kernel traces:");
374 for (;i < ret; i++) {
375 if (traces[i].type == KERNEL) {
376 MSG("\t%d) %s", i, traces[i].name);
377 }
378 }
379
380 free(traces);
381
382 error:
383 return ret;
384 }
385
386 /*
387 * process_opt_create_session
388 *
389 * Create a new session using the name pass
390 * to the command line.
391 */
392 static int process_opt_create_session(void)
393 {
394 int ret;
395 char name[NAME_MAX];
396 time_t rawtime;
397 struct tm *timeinfo;
398
399 /* Auto session name creation */
400 if (opt_session_name == NULL) {
401 time(&rawtime);
402 timeinfo = localtime(&rawtime);
403 strftime(name, sizeof(name), "auto-%Y%m%d-%H%M%S", timeinfo);
404 session_name = strndup(name, sizeof(name));
405 DBG("Auto session name set to %s", session_name);
406 }
407
408 ret = lttng_create_session(session_name);
409 if (ret < 0) {
410 goto error;
411 }
412
413 MSG("Session created: %s", session_name);
414
415 error:
416 return ret;
417 }
418
419 /*
420 * process_opt_list_sessions
421 *
422 * Get the list of available sessions from
423 * the session daemon and print it to user.
424 */
425 static int process_opt_list_sessions(void)
426 {
427 int ret, count, i;
428 struct lttng_session *sessions;
429
430 count = lttng_list_sessions(&sessions);
431 DBG("Session count %d", count);
432 if (count < 0) {
433 ret = count;
434 goto error;
435 }
436
437 MSG("Available sessions (UUIDs):");
438 for (i = 0; i < count; i++) {
439 MSG(" %d) %s", i+1, sessions[i].name);
440 }
441
442 free(sessions);
443 MSG("\nTo select a session, use -s, --session UUID.");
444
445 return 0;
446
447 error:
448 return ret;
449 }
450
451 /*
452 * process_opt_list_apps
453 *
454 * Get the UST traceable pid list and print
455 * them to the user.
456 */
457 static int process_opt_list_apps(void)
458 {
459 int i, ret, count;
460 pid_t *pids;
461 char *cmdline;
462
463 count = lttng_ust_list_apps(&pids);
464 if (count < 0) {
465 ret = count;
466 goto error;
467 }
468
469 MSG("LTTng UST traceable application [name (pid)]:");
470 for (i=0; i < count; i++) {
471 cmdline = get_cmdline_by_pid(pids[i]);
472 if (cmdline == NULL) {
473 MSG("\t(not running) (%d)", pids[i]);
474 continue;
475 }
476 MSG("\t%s (%d)", cmdline, pids[i]);
477 free(cmdline);
478 }
479
480 /* Allocated by lttng_ust_list_apps() */
481 free(pids);
482
483 return 0;
484
485 error:
486 return ret;
487 }
488
489 /*
490 * get_cmdline_by_pid
491 *
492 * Get command line from /proc for a specific pid.
493 *
494 * On success, return an allocated string pointer pointing to
495 * the proc cmdline.
496 * On error, return NULL.
497 */
498 static char *get_cmdline_by_pid(pid_t pid)
499 {
500 int ret;
501 FILE *fp;
502 char *cmdline = NULL;
503 char path[24]; /* Can't go bigger than /proc/65535/cmdline */
504
505 snprintf(path, sizeof(path), "/proc/%d/cmdline", pid);
506 fp = fopen(path, "r");
507 if (fp == NULL) {
508 goto end;
509 }
510
511 /* Caller must free() *cmdline */
512 cmdline = malloc(PATH_MAX);
513 ret = fread(cmdline, 1, PATH_MAX, fp);
514 fclose(fp);
515
516 end:
517 return cmdline;
518 }
519
520 /*
521 * validate_options
522 *
523 * Make sure that all options passed to the command line are compatible with
524 * each others.
525 *
526 * On error, return -1
527 * On success, return 0
528 */
529 static int validate_options(void)
530 {
531 /* If listing options, jump validation */
532 if (opt_list_apps || opt_list_session) {
533 goto end;
534 }
535 /* Conflicting command */
536 if (opt_start_trace && opt_stop_trace) {
537 ERR("Can't use --start and --stop together.");
538 goto error;
539 /* If no PID specified and trace_kernel is off */
540 } else if ((opt_trace_pid == 0 && !opt_trace_kernel) &&
541 (opt_create_trace || opt_start_trace || opt_stop_trace || opt_destroy_trace)) {
542 ERR("Please specify for which tracer (-k or -p PID).");
543 goto error;
544 /* List traces, we need a session name */
545 } else if (opt_list_traces && opt_session_name == NULL) {
546 ERR("Can't use -t without -s, --session option.");
547 goto error;
548 /* Can't set event for both kernel and userspace at the same time */
549 } else if (opt_event_list != NULL && (opt_trace_kernel && opt_trace_pid)) {
550 ERR("Please don't use --event for both kernel and userspace.\nOne at a time to enable events.");
551 goto error;
552 /* Don't need a trace name for kernel tracig */
553 } else if (opt_trace_name != NULL && opt_trace_kernel) {
554 ERR("For action on a kernel trace, please don't specify a trace name.");
555 goto error;
556 } else if (opt_destroy_trace && opt_session_name == NULL) {
557 ERR("Please specify a session in order to destroy a trace");
558 goto error;
559 } else if (opt_create_trace || opt_destroy_trace) {
560 /* Both kernel and user-space are denied for these options */
561 if (opt_trace_pid != 0 && opt_trace_kernel) {
562 ERR("Kernel and user-space trace creation and destruction can't be used together.");
563 goto error;
564 /* Need a trace name for user-space tracing */
565 } else if (opt_trace_name == NULL && opt_trace_pid != 0) {
566 ERR("Please specify a trace name for user-space tracing");
567 goto error;
568 }
569 } else if (opt_stop_trace && opt_trace_pid != 0 && opt_trace_name == NULL) {
570 ERR("Please specify a trace name for user-space tracing");
571 goto error;
572 }
573
574 /* If start trace, auto start tracing */
575 if (opt_start_trace || opt_event_list != NULL) {
576 DBG("Requesting auto tracing");
577 auto_trace = 1;
578 }
579
580 /* If no session, auto create one */
581 if (opt_session_name == NULL) {
582 DBG("Requesting an auto session creation");
583 auto_session = 1;
584 }
585
586 end:
587 return 0;
588
589 error:
590 return -1;
591 }
592
593 /*
594 * spawn_sessiond
595 *
596 * Spawn a session daemon by forking and execv.
597 */
598 static int spawn_sessiond(char *pathname)
599 {
600 int ret = 0;
601 pid_t pid;
602
603 MSG("Spawning session daemon");
604 pid = fork();
605 if (pid == 0) {
606 /*
607 * Spawn session daemon and tell
608 * it to signal us when ready.
609 */
610 execlp(pathname, "ltt-sessiond", "--sig-parent", "--quiet", NULL);
611 /* execlp only returns if error happened */
612 if (errno == ENOENT) {
613 ERR("No session daemon found. Use --sessiond-path.");
614 } else {
615 perror("execlp");
616 }
617 kill(getppid(), SIGTERM); /* unpause parent */
618 exit(EXIT_FAILURE);
619 } else if (pid > 0) {
620 /* Wait for ltt-sessiond to start */
621 pause();
622 goto end;
623 } else {
624 perror("fork");
625 ret = -1;
626 goto end;
627 }
628
629 end:
630 return ret;
631 }
632
633 /*
634 * check_ltt_sessiond
635 *
636 * Check if the session daemon is available using
637 * the liblttngctl API for the check. If not, try to
638 * spawn a daemon.
639 */
640 static int check_ltt_sessiond(void)
641 {
642 int ret;
643 char *pathname = NULL, *alloc_pathname = NULL;
644
645 ret = lttng_check_session_daemon();
646 if (ret < 0) {
647 /* Try command line option path */
648 if (opt_sessiond_path != NULL) {
649 ret = access(opt_sessiond_path, F_OK | X_OK);
650 if (ret < 0) {
651 ERR("No such file: %s", opt_sessiond_path);
652 goto end;
653 }
654 pathname = opt_sessiond_path;
655 } else {
656 /* Try LTTNG_SESSIOND_PATH env variable */
657 pathname = getenv(LTTNG_SESSIOND_PATH_ENV);
658 }
659
660 /* Let's rock and roll */
661 if (pathname == NULL) {
662 ret = asprintf(&alloc_pathname, "ltt-sessiond");
663 if (ret < 0) {
664 goto end;
665 }
666 pathname = alloc_pathname;
667 }
668
669 ret = spawn_sessiond(pathname);
670 free(alloc_pathname);
671 if (ret < 0) {
672 ERR("Problem occurs when starting %s", pathname);
673 goto end;
674 }
675 }
676
677 end:
678 return ret;
679 }
680
681 /*
682 * set_signal_handler
683 *
684 * Setup signal handler for SIGCHLD and SIGTERM.
685 */
686 static int set_signal_handler(void)
687 {
688 int ret = 0;
689 struct sigaction sa;
690 sigset_t sigset;
691
692 if ((ret = sigemptyset(&sigset)) < 0) {
693 perror("sigemptyset");
694 goto end;
695 }
696
697 sa.sa_handler = sighandler;
698 sa.sa_mask = sigset;
699 sa.sa_flags = 0;
700 if ((ret = sigaction(SIGCHLD, &sa, NULL)) < 0) {
701 perror("sigaction");
702 goto end;
703 }
704
705 if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
706 perror("sigaction");
707 goto end;
708 }
709
710 end:
711 return ret;
712 }
713
714 /*
715 * sighandler
716 *
717 * Signal handler for the daemon
718 */
719 static void sighandler(int sig)
720 {
721 switch (sig) {
722 case SIGTERM:
723 DBG("SIGTERM catched");
724 clean_exit(EXIT_FAILURE);
725 break;
726 case SIGCHLD:
727 /* Notify is done */
728 DBG("SIGCHLD catched");
729 break;
730 default:
731 DBG("Unknown signal %d catched", sig);
732 break;
733 }
734
735 return;
736 }
737
738 /*
739 * clean_exit
740 */
741 void clean_exit(int code)
742 {
743 DBG("Clean exit");
744 if (session_name) {
745 free(session_name);
746 }
747
748 exit(code);
749 }
750
751 /*
752 * main
753 */
754 int main(int argc, char *argv[])
755 {
756 int ret;
757
758 progname = argv[0] ? argv[0] : "lttng";
759
760 /* For Mathieu Desnoyers aka Dr Tracing */
761 if (strncmp(progname, "drtrace", 7) == 0) {
762 MSG("%c[%d;%dmWelcome back Dr Tracing!%c[%dm\n\n", 27,1,33,27,0);
763 }
764
765 ret = parse_args(argc, (const char **) argv);
766 if (ret < 0) {
767 clean_exit(EXIT_FAILURE);
768 }
769
770 ret = validate_options();
771 if (ret < 0) {
772 return EXIT_FAILURE;
773 }
774
775 ret = set_signal_handler();
776 if (ret < 0) {
777 clean_exit(ret);
778 }
779
780 if (opt_tracing_group != NULL) {
781 DBG("Set tracing group to '%s'", opt_tracing_group);
782 lttng_set_tracing_group(opt_tracing_group);
783 }
784
785 /* If ask for kernel tracing, need root perms */
786 if (opt_trace_kernel) {
787 DBG("Kernel tracing activated");
788 if (getuid() != 0) {
789 ERR("%s must be setuid root", progname);
790 clean_exit(-EPERM);
791 }
792 }
793
794 /* Check if the lttng session daemon is running.
795 * If no, a daemon will be spawned.
796 */
797 if (opt_no_sessiond == 0 && (check_ltt_sessiond() < 0)) {
798 clean_exit(EXIT_FAILURE);
799 }
800
801 ret = process_client_opt();
802 if (ret < 0) {
803 clean_exit(ret);
804 }
805
806 clean_exit(0);
807
808 return 0;
809 }
This page took 0.072994 seconds and 3 git commands to generate.