374f3e90c8d578ec71d6502f53438fd2d194c5c6
[lttngtop.git] / src / lttngtop.c
1 /*
2 * Copyright (C) 2013 Julien Desfossez
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 Version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 */
17
18 #define _GNU_SOURCE
19 #include <config.h>
20 #include <stdio.h>
21 #include <stdint.h>
22 #include <babeltrace/babeltrace.h>
23 #include <babeltrace/ctf/events.h>
24 #include <babeltrace/ctf/callbacks.h>
25 #include <babeltrace/ctf/iterator.h>
26 #include <fcntl.h>
27 #include <pthread.h>
28 #include <popt.h>
29 #include <stdlib.h>
30 #include <ftw.h>
31 #include <dirent.h>
32 #include <ctype.h>
33 #include <sys/stat.h>
34 #include <unistd.h>
35 #include <string.h>
36 #include <errno.h>
37 #include <sys/types.h>
38 #include <fts.h>
39 #include <assert.h>
40 #include <sys/mman.h>
41 #include <lttng/lttng.h>
42 #ifdef LTTNGTOP_MMAP_LIVE
43 #include <lttng/lttngtop-helper.h>
44 #include <babeltrace/lttngtopmmappacketseek.h>
45 #include "mmap-live.h"
46 #endif /* LTTNGTOP_MMAP_LIVE */
47
48 #include "lttngtoptypes.h"
49 #include "cputop.h"
50 #include "iostreamtop.h"
51 #include "cursesdisplay.h"
52 #include "common.h"
53 #include "network-live.h"
54
55 #define NET_URL_PREFIX "net://"
56 #define NET4_URL_PREFIX "net4://"
57 #define NET6_URL_PREFIX "net6://"
58
59 #define DEFAULT_FILE_ARRAY_SIZE 1
60
61 const char *opt_input_path;
62 int opt_textdump;
63 int opt_child;
64 int opt_begin;
65
66 int quit = 0;
67
68 struct lttngtop *copy;
69 pthread_t display_thread;
70 pthread_t timer_thread;
71
72 unsigned long refresh_display = 1 * NSEC_PER_SEC;
73 unsigned long last_display_update = 0;
74 unsigned long last_event_ts = 0;
75
76 /* list of FDs available for being read with snapshots */
77 struct bt_mmap_stream_list mmap_list;
78 GPtrArray *lttng_consumer_stream_array;
79 int sessiond_metadata, consumerd_metadata;
80 struct lttng_consumer_local_data *ctx = NULL;
81 /* list of snapshots currently not consumed */
82 GPtrArray *available_snapshots;
83 sem_t metadata_available;
84 int reload_trace = 0;
85
86 int last_textdump_print_newline = 1;
87
88 enum {
89 OPT_NONE = 0,
90 OPT_HELP,
91 OPT_TEXTDUMP,
92 OPT_PID,
93 OPT_CHILD,
94 OPT_HOSTNAME,
95 OPT_RELAY_HOSTNAME,
96 OPT_KPROBES,
97 OPT_BEGIN,
98 };
99
100 static struct poptOption long_options[] = {
101 /* longName, shortName, argInfo, argPtr, value, descrip, argDesc */
102 { "help", 'h', POPT_ARG_NONE, NULL, OPT_HELP, NULL, NULL },
103 { "textdump", 't', POPT_ARG_NONE, NULL, OPT_TEXTDUMP, NULL, NULL },
104 { "child", 'f', POPT_ARG_NONE, NULL, OPT_CHILD, NULL, NULL },
105 { "begin", 'b', POPT_ARG_NONE, NULL, OPT_BEGIN, NULL, NULL },
106 { "pid", 'p', POPT_ARG_STRING, &opt_tid, OPT_PID, NULL, NULL },
107 { "hostname", 'n', POPT_ARG_STRING, &opt_hostname, OPT_HOSTNAME, NULL, NULL },
108 { "relay-hostname", 'r', POPT_ARG_STRING, &opt_relay_hostname,
109 OPT_RELAY_HOSTNAME, NULL, NULL },
110 { "kprobes", 'k', POPT_ARG_STRING, &opt_kprobes, OPT_KPROBES, NULL, NULL },
111 { NULL, 0, 0, NULL, 0, NULL, NULL },
112 };
113
114 #ifdef LTTNGTOP_MMAP_LIVE
115 static void handle_textdump_sigterm(int signal)
116 {
117 quit = 1;
118 lttng_destroy_session("test");
119 }
120 #endif
121
122 void *refresh_thread(void *p)
123 {
124 while (1) {
125 if (quit) {
126 sem_post(&pause_sem);
127 sem_post(&timer);
128 sem_post(&end_trace_sem);
129 sem_post(&goodtodisplay);
130 sem_post(&goodtoupdate);
131 pthread_exit(0);
132 }
133 if (!opt_input_path) {
134 #ifdef LTTNGTOP_MMAP_LIVE
135 mmap_live_flush(mmap_list);
136 #endif
137 }
138 sem_wait(&pause_sem);
139 sem_post(&pause_sem);
140 sem_post(&timer);
141 sleep(refresh_display/NSEC_PER_SEC);
142 }
143 }
144
145 void *ncurses_display(void *p)
146 {
147 unsigned int current_display_index = 0;
148
149 sem_wait(&bootstrap);
150 /*
151 * Prevent the 1 second delay when we hit ESC
152 */
153 ESCDELAY = 0;
154 init_ncurses();
155
156 while (1) {
157 sem_wait(&timer);
158 sem_wait(&goodtodisplay);
159 sem_wait(&pause_sem);
160
161 if (quit) {
162 sem_post(&pause_sem);
163 sem_post(&timer);
164 reset_ncurses();
165 pthread_exit(0);
166 }
167
168 copy = g_ptr_array_index(copies, current_display_index);
169 assert(copy);
170 display(current_display_index++);
171
172 sem_post(&goodtoupdate);
173 sem_post(&pause_sem);
174 }
175 }
176
177 void print_fields(struct bt_ctf_event *event)
178 {
179 unsigned int cnt, i;
180 const struct bt_definition *const * list;
181 const struct bt_declaration *l;
182 const struct bt_definition *scope;
183 enum ctf_type_id type;
184 const char *str;
185
186 scope = bt_ctf_get_top_level_scope(event, BT_EVENT_FIELDS);
187
188 bt_ctf_get_field_list(event, scope, &list, &cnt);
189 for (i = 0; i < cnt; i++) {
190 if (i != 0)
191 printf(", ");
192 printf("%s = ", bt_ctf_field_name(list[i]));
193 l = bt_ctf_get_decl_from_def(list[i]);
194 type = bt_ctf_field_type(l);
195 if (type == CTF_TYPE_INTEGER) {
196 if (bt_ctf_get_int_signedness(l) == 0)
197 printf("%" PRIu64 "", bt_ctf_get_uint64(list[i]));
198 else
199 printf("%" PRId64 "", bt_ctf_get_int64(list[i]));
200 } else if (type == CTF_TYPE_STRING) {
201 printf("%s", bt_ctf_get_string(list[i]));
202 } else if (type == CTF_TYPE_ARRAY) {
203 str = bt_ctf_get_char_array(list[i]);
204 if (!bt_ctf_field_get_error() && str)
205 printf("%s", str);
206 }
207 }
208 }
209
210 /*
211 * hook on each event to check the timestamp and refresh the display if
212 * necessary
213 */
214 enum bt_cb_ret print_timestamp(struct bt_ctf_event *call_data, void *private_data)
215 {
216 unsigned long timestamp;
217 struct tm start;
218 uint64_t ts_nsec_start;
219 int pid, cpu_id;
220 int64_t syscall_ret;
221 const struct bt_definition *scope;
222 const char *hostname, *procname;
223
224 timestamp = bt_ctf_get_timestamp(call_data);
225
226 /* can happen in network live when tracing is idle */
227 if (timestamp < last_event_ts)
228 goto end_stop;
229
230 last_event_ts = timestamp;
231
232 start = format_timestamp(timestamp);
233 ts_nsec_start = timestamp % NSEC_PER_SEC;
234
235 pid = get_context_pid(call_data);
236 if (pid == -1ULL && opt_tid) {
237 goto error;
238 }
239
240 hostname = get_context_hostname(call_data);
241 if (opt_tid || opt_hostname)
242 if (!lookup_filter_tid_list(pid))
243 goto end;
244
245 cpu_id = get_cpu_id(call_data);
246 procname = get_context_comm(call_data);
247
248 if ((strcmp(bt_ctf_event_name(call_data), "exit_syscall") == 0) &&
249 !last_textdump_print_newline) {
250 scope = bt_ctf_get_top_level_scope(call_data,
251 BT_EVENT_FIELDS);
252 syscall_ret = bt_ctf_get_int64(bt_ctf_get_field(call_data,
253 scope, "_ret"));
254 printf("= %ld\n", syscall_ret);
255 last_textdump_print_newline = 1;
256 } else {
257 /* we might have lost the exit_syscall event, so need to
258 * print the newline in this case */
259 if (last_textdump_print_newline == 0)
260 printf("\n");
261 printf("%02d:%02d:%02d.%09" PRIu64 " (%s) (cpu %d) [%s (%d)] %s (",
262 start.tm_hour, start.tm_min, start.tm_sec,
263 ts_nsec_start, hostname, cpu_id, procname, pid,
264 bt_ctf_event_name(call_data));
265 print_fields(call_data);
266 printf(") ");
267 if (strncmp(bt_ctf_event_name(call_data), "sys_", 4) != 0) {
268 printf("\n");
269 last_textdump_print_newline = 1;
270 } else {
271 last_textdump_print_newline = 0;
272 }
273 }
274
275 end:
276 return BT_CB_OK;
277 error:
278 return BT_CB_ERROR_STOP;
279 end_stop:
280 return BT_CB_OK_STOP;
281 }
282
283 enum bt_cb_ret handle_kprobes(struct bt_ctf_event *call_data, void *private_data)
284 {
285 int i;
286 struct kprobes *kprobe;
287
288 /* for kprobes */
289 for (i = 0; i < lttngtop.kprobes_table->len; i++) {
290 kprobe = g_ptr_array_index(lttngtop.kprobes_table, i);
291 if (strcmp(bt_ctf_event_name(call_data), kprobe->probe_name) == 0) {
292 kprobe->count++;
293 }
294 }
295
296 return BT_CB_OK;
297 }
298
299 /*
300 * hook on each event to check the timestamp and refresh the display if
301 * necessary
302 */
303 enum bt_cb_ret check_timestamp(struct bt_ctf_event *call_data, void *private_data)
304 {
305 unsigned long timestamp;
306
307 timestamp = bt_ctf_get_timestamp(call_data);
308 if (timestamp == -1ULL)
309 goto error;
310
311 /* can happen in network live when tracing is idle */
312 if (timestamp < last_event_ts)
313 goto end_stop;
314
315 last_event_ts = timestamp;
316
317 if (last_display_update == 0)
318 last_display_update = timestamp;
319
320 if (timestamp - last_display_update >= refresh_display) {
321 sem_wait(&goodtoupdate);
322 g_ptr_array_add(copies, get_copy_lttngtop(last_display_update,
323 timestamp));
324 sem_post(&goodtodisplay);
325 sem_post(&bootstrap);
326 last_display_update = timestamp;
327 }
328 return BT_CB_OK;
329
330 error:
331 fprintf(stderr, "check_timestamp callback error\n");
332 return BT_CB_ERROR_STOP;
333
334 end_stop:
335 return BT_CB_OK_STOP;
336 }
337
338 /*
339 * get_perf_counter : get or create and return a perf_counter struct for
340 * either a process or a cpu (only one of the 2 parameters mandatory)
341 */
342 struct perfcounter *get_perf_counter(const char *name, struct processtop *proc,
343 struct cputime *cpu)
344 {
345 struct perfcounter *ret;
346 GHashTable *table;
347
348 if (proc)
349 table = proc->perf;
350 else if (cpu)
351 table = cpu->perf;
352 else
353 goto error;
354
355 ret = g_hash_table_lookup(table, (gpointer) name);
356 if (ret)
357 goto end;
358
359 ret = g_new0(struct perfcounter, 1);
360 /* by default, make it visible in the UI */
361 ret->visible = 1;
362 g_hash_table_insert(table, (gpointer) strdup(name), ret);
363
364 end:
365 return ret;
366
367 error:
368 return NULL;
369 }
370
371 void update_perf_value(struct processtop *proc, struct cputime *cpu,
372 const char *name, int value)
373 {
374 struct perfcounter *cpu_perf, *process_perf;
375
376 cpu_perf = get_perf_counter(name, NULL, cpu);
377 if (cpu_perf->count < value) {
378 process_perf = get_perf_counter(name, proc, NULL);
379 process_perf->count += value - cpu_perf->count;
380 cpu_perf->count = value;
381 }
382 }
383
384 void extract_perf_counter_scope(const struct bt_ctf_event *event,
385 const struct bt_definition *scope,
386 struct processtop *proc,
387 struct cputime *cpu)
388 {
389 struct bt_definition const * const *list = NULL;
390 const struct bt_definition *field;
391 unsigned int count;
392 struct perfcounter *perfcounter;
393 GHashTableIter iter;
394 gpointer key;
395 int ret;
396
397 if (!scope)
398 goto end;
399
400 ret = bt_ctf_get_field_list(event, scope, &list, &count);
401 if (ret < 0)
402 goto end;
403
404 if (count == 0)
405 goto end;
406
407 g_hash_table_iter_init(&iter, global_perf_liszt);
408 while (g_hash_table_iter_next (&iter, &key, (gpointer) &perfcounter)) {
409 field = bt_ctf_get_field(event, scope, (char *) key);
410 if (field) {
411 int value = bt_ctf_get_uint64(field);
412 if (bt_ctf_field_get_error())
413 continue;
414 update_perf_value(proc, cpu, (char *) key, value);
415 }
416 }
417
418 end:
419 return;
420 }
421
422 void update_perf_counter(struct processtop *proc, const struct bt_ctf_event *event)
423 {
424 struct cputime *cpu;
425 const struct bt_definition *scope;
426
427 cpu = get_cpu(get_cpu_id(event));
428
429 scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT);
430 extract_perf_counter_scope(event, scope, proc, cpu);
431
432 scope = bt_ctf_get_top_level_scope(event, BT_STREAM_PACKET_CONTEXT);
433 extract_perf_counter_scope(event, scope, proc, cpu);
434
435 scope = bt_ctf_get_top_level_scope(event, BT_EVENT_CONTEXT);
436 extract_perf_counter_scope(event, scope, proc, cpu);
437 }
438
439 enum bt_cb_ret fix_process_table(struct bt_ctf_event *call_data,
440 void *private_data)
441 {
442 int pid, tid, ppid, vpid, vtid, vppid;
443 char *comm, *hostname;
444 struct processtop *parent, *child;
445 unsigned long timestamp;
446
447 timestamp = bt_ctf_get_timestamp(call_data);
448 if (timestamp == -1ULL)
449 goto error;
450
451 pid = get_context_pid(call_data);
452 if (pid == -1ULL) {
453 goto error;
454 }
455
456 tid = get_context_tid(call_data);
457 if (tid == -1ULL) {
458 goto error;
459 }
460 ppid = get_context_ppid(call_data);
461 if (ppid == -1ULL) {
462 goto error;
463 }
464 vpid = get_context_vpid(call_data);
465 if (pid == -1ULL) {
466 vpid = -1;
467 }
468 vtid = get_context_vtid(call_data);
469 if (tid == -1ULL) {
470 vtid = -1;
471 }
472 vppid = get_context_vppid(call_data);
473 if (ppid == -1ULL) {
474 vppid = -1;
475 }
476 comm = get_context_comm(call_data);
477 if (!comm) {
478 goto error;
479 }
480 /* optional */
481 hostname = get_context_hostname(call_data);
482
483 /* find or create the current process */
484 child = find_process_tid(&lttngtop, tid, comm);
485 if (!child)
486 child = add_proc(&lttngtop, tid, comm, timestamp, hostname);
487 if (!child)
488 goto end;
489 update_proc(child, pid, tid, ppid, vpid, vtid, vppid, comm, hostname);
490
491 if (pid != tid) {
492 /* find or create the parent */
493 parent = find_process_tid(&lttngtop, pid, comm);
494 if (!parent) {
495 parent = add_proc(&lttngtop, pid, comm, timestamp, hostname);
496 if (parent)
497 parent->pid = pid;
498 }
499
500 /* attach the parent to the current process */
501 child->threadparent = parent;
502 add_thread(parent, child);
503 }
504
505 update_perf_counter(child, call_data);
506
507 end:
508 return BT_CB_OK;
509
510 error:
511 return BT_CB_ERROR_STOP;
512 }
513
514 void init_lttngtop()
515 {
516 copies = g_ptr_array_new();
517 global_perf_liszt = g_hash_table_new(g_str_hash, g_str_equal);
518 global_filter_list = g_hash_table_new(g_str_hash, g_str_equal);
519 global_host_list = g_hash_table_new(g_str_hash, g_str_equal);
520
521 sem_init(&goodtodisplay, 0, 0);
522 sem_init(&goodtoupdate, 0, 1);
523 sem_init(&timer, 0, 1);
524 sem_init(&bootstrap, 0, 0);
525 sem_init(&pause_sem, 0, 1);
526 sem_init(&end_trace_sem, 0, 0);
527
528 reset_global_counters();
529 lttngtop.nbproc = 0;
530 lttngtop.nbthreads = 0;
531 lttngtop.nbfiles = 0;
532
533 lttngtop.process_hash_table = g_hash_table_new(g_direct_hash,
534 g_direct_equal);
535 lttngtop.process_table = g_ptr_array_new();
536 lttngtop.files_table = g_ptr_array_new();
537 lttngtop.cpu_table = g_ptr_array_new();
538
539 toggle_filter = -1;
540 }
541
542 void usage(FILE *fp)
543 {
544 fprintf(fp, "LTTngTop %s\n\n", VERSION);
545 fprintf(fp, "Usage : lttngtop [OPTIONS] TRACE\n");
546 fprintf(fp, " TRACE Path to the trace to analyse (-r for network live tracing, nothing for mmap live streaming)\n");
547 fprintf(fp, " -h, --help This help message\n");
548 fprintf(fp, " -t, --textdump Display live events in text-only\n");
549 fprintf(fp, " -p, --pid Comma-separated list of PIDs to display\n");
550 fprintf(fp, " -f, --child Follow threads associated with selected PIDs\n");
551 fprintf(fp, " -n, --hostname Comma-separated list of hostnames to display (require hostname context in trace)\n");
552 fprintf(fp, " -k, --kprobes Comma-separated list of kprobes to insert (same format as lttng enable-event)\n");
553 fprintf(fp, " -r, --relay-hostname Network live streaming : hostname of the lttng-relayd (default port)\n");
554 fprintf(fp, " -b, --begin Network live streaming : read the trace for the beginning of the recording\n");
555 }
556
557 /*
558 * Parse probe options.
559 * Shamelessly stolen from lttng-tools :
560 * src/bin/lttng/commands/enable_events.c
561 */
562 static struct kprobes *parse_probe_opts(char *opt)
563 {
564 char s_hex[19];
565 char name[LTTNG_SYMBOL_NAME_LEN];
566 struct kprobes *kprobe;
567 int ret;
568
569 /*
570 kprobe->probe_addr = 0;
571 kprobe->probe_offset = 0;
572 asprintf(&kprobe->probe_name, "probe_sys_open");
573 asprintf(&kprobe->symbol_name, "sys_open");
574 */
575
576 if (opt == NULL) {
577 kprobe = NULL;
578 goto end;
579 }
580
581 kprobe = g_new0(struct kprobes, 1);
582
583 /* Check for symbol+offset */
584 ret = sscanf(opt, "%[^'+']+%s", name, s_hex);
585 if (ret == 2) {
586 ret = asprintf(&kprobe->probe_name, "probe_%s", name);
587 ret = asprintf(&kprobe->symbol_name, "%s", name);
588
589 if (strlen(s_hex) == 0) {
590 fprintf(stderr, "Invalid probe offset %s", s_hex);
591 ret = -1;
592 goto end;
593 }
594 kprobe->probe_offset = strtoul(s_hex, NULL, 0);
595 kprobe->probe_addr = 0;
596 goto end;
597 }
598
599 /* Check for symbol */
600 if (isalpha(name[0])) {
601 ret = sscanf(opt, "%s", name);
602 if (ret == 1) {
603 ret = asprintf(&kprobe->probe_name, "probe_%s", name);
604 ret = asprintf(&kprobe->symbol_name, "%s", name);
605 kprobe->probe_offset = 0;
606 kprobe->probe_addr = 0;
607 goto end;
608 }
609 }
610
611 /* Check for address */
612 ret = sscanf(opt, "%s", s_hex);
613 if (ret > 0) {
614 if (strlen(s_hex) == 0) {
615 fprintf(stderr, "Invalid probe address %s", s_hex);
616 ret = -1;
617 goto end;
618 }
619 ret = asprintf(&kprobe->probe_name, "probe_%s", s_hex);
620 kprobe->probe_offset = 0;
621 kprobe->probe_addr = strtoul(s_hex, NULL, 0);
622 goto end;
623 }
624
625 /* No match */
626 kprobe = NULL;
627
628 end:
629 return kprobe;
630 }
631
632 /*
633 * Return 0 if caller should continue, < 0 if caller should return
634 * error, > 0 if caller should exit without reporting error.
635 */
636 static int parse_options(int argc, char **argv)
637 {
638 poptContext pc;
639 int opt, ret = 0;
640 char *tmp_str;
641 int *tid;
642
643 remote_live = 0;
644
645 pc = poptGetContext(NULL, argc, (const char **) argv, long_options, 0);
646 poptReadDefaultConfig(pc, 0);
647
648 while ((opt = poptGetNextOpt(pc)) != -1) {
649 switch (opt) {
650 case OPT_HELP:
651 usage(stdout);
652 ret = 1; /* exit cleanly */
653 goto end;
654 case OPT_TEXTDUMP:
655 opt_textdump = 1;
656 break;
657 case OPT_CHILD:
658 opt_textdump = 1;
659 opt_child = 1;
660 break;
661 case OPT_PID:
662 toggle_filter = 1;
663 tid_filter_list = g_hash_table_new(g_str_hash,
664 g_str_equal);
665 tmp_str = strtok(opt_tid, ",");
666 while (tmp_str) {
667 tid = malloc(sizeof(int));
668 *tid = atoi(tmp_str);
669 g_hash_table_insert(tid_filter_list,
670 (gpointer) tid, tid);
671 tmp_str = strtok(NULL, ",");
672 }
673 break;
674 case OPT_BEGIN:
675 /* start reading the live trace from the beginning */
676 opt_begin = 1;
677 break;
678 case OPT_HOSTNAME:
679 toggle_filter = 1;
680 tmp_str = strtok(opt_hostname, ",");
681 while (tmp_str) {
682 add_hostname_list(tmp_str, 1);
683 tmp_str = strtok(NULL, ",");
684 }
685 break;
686 case OPT_RELAY_HOSTNAME:
687 remote_live = 1;
688 break;
689 case OPT_KPROBES:
690 lttngtop.kprobes_table = g_ptr_array_new();
691 tmp_str = strtok(opt_kprobes, ",");
692 while (tmp_str) {
693 struct kprobes *kprobe;
694
695 kprobe = parse_probe_opts(tmp_str);
696 if (kprobe) {
697 g_ptr_array_add(
698 lttngtop.kprobes_table,
699 kprobe);
700 } else {
701 ret = -EINVAL;
702 goto end;
703 }
704 tmp_str = strtok(NULL, ",");
705 }
706 break;
707 default:
708 ret = -EINVAL;
709 goto end;
710 }
711 }
712
713 opt_input_path = poptGetArg(pc);
714
715 end:
716 if (pc) {
717 poptFreeContext(pc);
718 }
719 return ret;
720 }
721
722 void iter_trace(struct bt_context *bt_ctx)
723 {
724 struct bt_ctf_iter *iter;
725 struct bt_iter_pos begin_pos;
726 struct kprobes *kprobe;
727 const struct bt_ctf_event *event;
728 int i;
729 int ret = 0;
730
731 begin_pos.type = BT_SEEK_BEGIN;
732 iter = bt_ctf_iter_create(bt_ctx, &begin_pos, NULL);
733
734 /* at each event, verify the status of the process table */
735 bt_ctf_iter_add_callback(iter, 0, NULL, 0,
736 fix_process_table,
737 NULL, NULL, NULL);
738 if (opt_textdump) {
739 bt_ctf_iter_add_callback(iter, 0, NULL, 0,
740 print_timestamp,
741 NULL, NULL, NULL);
742 } else {
743 /* at each event check if we need to refresh */
744 bt_ctf_iter_add_callback(iter, 0, NULL, 0,
745 check_timestamp,
746 NULL, NULL, NULL);
747 /* to handle the scheduling events */
748 bt_ctf_iter_add_callback(iter,
749 g_quark_from_static_string("sched_switch"),
750 NULL, 0, handle_sched_switch, NULL, NULL, NULL);
751 /* to clean up the process table */
752 bt_ctf_iter_add_callback(iter,
753 g_quark_from_static_string("sched_process_free"),
754 NULL, 0, handle_sched_process_free, NULL, NULL, NULL);
755 /* to get all the process from the statedumps */
756 bt_ctf_iter_add_callback(iter,
757 g_quark_from_static_string(
758 "lttng_statedump_process_state"),
759 NULL, 0, handle_statedump_process_state,
760 NULL, NULL, NULL);
761
762 /* for IO top */
763 bt_ctf_iter_add_callback(iter,
764 g_quark_from_static_string("exit_syscall"),
765 NULL, 0, handle_exit_syscall, NULL, NULL, NULL);
766 bt_ctf_iter_add_callback(iter,
767 g_quark_from_static_string("sys_write"),
768 NULL, 0, handle_sys_write, NULL, NULL, NULL);
769 bt_ctf_iter_add_callback(iter,
770 g_quark_from_static_string("sys_read"),
771 NULL, 0, handle_sys_read, NULL, NULL, NULL);
772 bt_ctf_iter_add_callback(iter,
773 g_quark_from_static_string("sys_open"),
774 NULL, 0, handle_sys_open, NULL, NULL, NULL);
775 bt_ctf_iter_add_callback(iter,
776 g_quark_from_static_string("sys_close"),
777 NULL, 0, handle_sys_close, NULL, NULL, NULL);
778 bt_ctf_iter_add_callback(iter,
779 g_quark_from_static_string(
780 "lttng_statedump_file_descriptor"),
781 NULL, 0, handle_statedump_file_descriptor,
782 NULL, NULL, NULL);
783
784 /* for kprobes */
785 if (lttngtop.kprobes_table) {
786 for (i = 0; i < lttngtop.kprobes_table->len; i++) {
787 kprobe = g_ptr_array_index(lttngtop.kprobes_table, i);
788 bt_ctf_iter_add_callback(iter,
789 g_quark_from_static_string(
790 kprobe->probe_name),
791 NULL, 0, handle_kprobes,
792 NULL, NULL, NULL);
793 }
794 }
795 }
796
797 while ((event = bt_ctf_iter_read_event(iter)) != NULL) {
798 if (quit || reload_trace)
799 goto end_iter;
800 ret = bt_iter_next(bt_ctf_get_iter(iter));
801 if (ret < 0)
802 goto end_iter;
803 }
804
805 /* block until quit, we reached the end of the trace */
806 sem_wait(&end_trace_sem);
807
808 end_iter:
809 bt_ctf_iter_destroy(iter);
810 }
811
812 /*
813 * bt_context_add_traces_recursive: Open a trace recursively
814 * (copied from BSD code in converter/babeltrace.c)
815 *
816 * Find each trace present in the subdirectory starting from the given
817 * path, and add them to the context. The packet_seek parameter can be
818 * NULL: this specify to use the default format packet_seek.
819 *
820 * Return: 0 on success, nonzero on failure.
821 * Unable to open toplevel: failure.
822 * Unable to open some subdirectory or file: warn and continue;
823 */
824 int bt_context_add_traces_recursive(struct bt_context *ctx, const char *path,
825 const char *format_str,
826 void (*packet_seek)(struct bt_stream_pos *pos,
827 size_t offset, int whence))
828 {
829 FTS *tree;
830 FTSENT *node;
831 GArray *trace_ids;
832 char lpath[PATH_MAX];
833 char * const paths[2] = { lpath, NULL };
834 int ret = -1;
835
836 if ((strncmp(path, NET4_URL_PREFIX, sizeof(NET4_URL_PREFIX) - 1)) == 0 ||
837 (strncmp(path, NET6_URL_PREFIX, sizeof(NET6_URL_PREFIX) - 1)) == 0 ||
838 (strncmp(path, NET_URL_PREFIX, sizeof(NET_URL_PREFIX) - 1)) == 0) {
839 ret = bt_context_add_trace(ctx,
840 path, format_str, packet_seek, NULL, NULL);
841 if (ret < 0) {
842 fprintf(stderr, "[warning] [Context] cannot open trace \"%s\" "
843 "for reading.\n", path);
844 /* Allow to skip erroneous traces. */
845 ret = 1; /* partial error */
846 }
847 return ret;
848 }
849 /*
850 * Need to copy path, because fts_open can change it.
851 * It is the pointer array, not the strings, that are constant.
852 */
853 strncpy(lpath, path, PATH_MAX);
854 lpath[PATH_MAX - 1] = '\0';
855
856 tree = fts_open(paths, FTS_NOCHDIR | FTS_LOGICAL, 0);
857 if (tree == NULL) {
858 fprintf(stderr, "[error] [Context] Cannot traverse \"%s\" for reading.\n",
859 path);
860 return -EINVAL;
861 }
862
863 trace_ids = g_array_new(FALSE, TRUE, sizeof(int));
864
865 while ((node = fts_read(tree))) {
866 int dirfd, metafd;
867
868 if (!(node->fts_info & FTS_D))
869 continue;
870
871 dirfd = open(node->fts_accpath, 0);
872 if (dirfd < 0) {
873 fprintf(stderr, "[error] [Context] Unable to open trace "
874 "directory file descriptor.\n");
875 ret = dirfd;
876 goto error;
877 }
878 metafd = openat(dirfd, "metadata", O_RDONLY);
879 if (metafd < 0) {
880 close(dirfd);
881 continue;
882 } else {
883 int trace_id;
884
885 ret = close(metafd);
886 if (ret < 0) {
887 perror("close");
888 goto error;
889 }
890 ret = close(dirfd);
891 if (ret < 0) {
892 perror("close");
893 goto error;
894 }
895
896 trace_id = bt_context_add_trace(ctx,
897 node->fts_accpath, format_str,
898 packet_seek, NULL, NULL);
899 if (trace_id < 0) {
900 fprintf(stderr, "[warning] [Context] opening trace \"%s\" from %s "
901 "for reading.\n", node->fts_accpath, path);
902 /* Allow to skip erroneous traces. */
903 continue;
904 }
905 g_array_append_val(trace_ids, trace_id);
906 }
907 }
908
909 g_array_free(trace_ids, TRUE);
910 return ret;
911
912 error:
913 return ret;
914 }
915
916 static int check_field_requirements(const struct bt_ctf_field_decl *const * field_list,
917 int field_cnt, int *tid_check, int *pid_check,
918 int *procname_check, int *ppid_check)
919 {
920 int j;
921 struct perfcounter *global;
922 const char *name;
923
924 for (j = 0; j < field_cnt; j++) {
925 name = bt_ctf_get_decl_field_name(field_list[j]);
926 if (*tid_check == 0) {
927 if (strncmp(name, "tid", 3) == 0)
928 (*tid_check)++;
929 }
930 if (*pid_check == 0) {
931 if (strncmp(name, "pid", 3) == 0)
932 (*pid_check)++;
933 }
934 if (*ppid_check == 0) {
935 if (strncmp(name, "ppid", 4) == 0)
936 (*ppid_check)++;
937 }
938 if (*procname_check == 0) {
939 if (strncmp(name, "procname", 8) == 0)
940 (*procname_check)++;
941 }
942 if (strncmp(name, "perf_", 5) == 0) {
943 global = g_hash_table_lookup(global_perf_liszt, (gpointer) name);
944 if (!global) {
945 global = g_new0(struct perfcounter, 1);
946 /* by default, sort on the first perf context */
947 if (g_hash_table_size(global_perf_liszt) == 0)
948 global->sort = 1;
949 global->visible = 1;
950 g_hash_table_insert(global_perf_liszt, (gpointer) strdup(name), global);
951 }
952 }
953 }
954
955 if (*tid_check == 1 && *pid_check == 1 && *ppid_check == 1 &&
956 *procname_check == 1)
957 return 0;
958
959 return -1;
960 }
961
962 /*
963 * check_requirements: check if the required context informations are available
964 *
965 * If each mandatory context information is available for at least in one
966 * event, return 0 otherwise return -1.
967 */
968 int check_requirements(struct bt_context *ctx)
969 {
970 unsigned int i, evt_cnt, field_cnt;
971 struct bt_ctf_event_decl *const * evt_list;
972 const struct bt_ctf_field_decl *const * field_list;
973 int tid_check = 0;
974 int pid_check = 0;
975 int procname_check = 0;
976 int ppid_check = 0;
977 int ret = 0;
978
979 ret = bt_ctf_get_event_decl_list(0, ctx, &evt_list, &evt_cnt);
980 if (ret < 0) {
981 goto end;
982 }
983
984 for (i = 0; i < evt_cnt; i++) {
985 bt_ctf_get_decl_fields(evt_list[i], BT_STREAM_EVENT_CONTEXT,
986 &field_list, &field_cnt);
987 ret = check_field_requirements(field_list, field_cnt,
988 &tid_check, &pid_check, &procname_check,
989 &ppid_check);
990
991 bt_ctf_get_decl_fields(evt_list[i], BT_EVENT_CONTEXT,
992 &field_list, &field_cnt);
993 ret = check_field_requirements(field_list, field_cnt,
994 &tid_check, &pid_check, &procname_check,
995 &ppid_check);
996
997 bt_ctf_get_decl_fields(evt_list[i], BT_STREAM_PACKET_CONTEXT,
998 &field_list, &field_cnt);
999 ret = check_field_requirements(field_list, field_cnt,
1000 &tid_check, &pid_check, &procname_check,
1001 &ppid_check);
1002 }
1003
1004 if (tid_check == 0) {
1005 ret = -1;
1006 fprintf(stderr, "[error] missing tid context information\n");
1007 }
1008 if (pid_check == 0) {
1009 ret = -1;
1010 fprintf(stderr, "[error] missing pid context information\n");
1011 }
1012 if (ppid_check == 0) {
1013 ret = -1;
1014 fprintf(stderr, "[error] missing ppid context information\n");
1015 }
1016 if (procname_check == 0) {
1017 ret = -1;
1018 fprintf(stderr, "[error] missing procname context information\n");
1019 }
1020
1021 end:
1022 return ret;
1023 }
1024
1025 int main(int argc, char **argv)
1026 {
1027 int ret;
1028 struct bt_context *bt_ctx = NULL;
1029
1030 init_lttngtop();
1031 ret = parse_options(argc, argv);
1032 if (ret < 0) {
1033 fprintf(stdout, "Error parsing options.\n\n");
1034 usage(stdout);
1035 exit(EXIT_FAILURE);
1036 } else if (ret > 0) {
1037 exit(EXIT_SUCCESS);
1038 }
1039
1040 if (!opt_input_path && !remote_live) {
1041 /* mmap live */
1042 #ifdef LTTNGTOP_MMAP_LIVE
1043 if (opt_textdump) {
1044 signal(SIGTERM, handle_textdump_sigterm);
1045 signal(SIGINT, handle_textdump_sigterm);
1046 }
1047 mmap_live_loop(bt_ctx);
1048 pthread_join(timer_thread, NULL);
1049 quit = 1;
1050 pthread_join(display_thread, NULL);
1051
1052 lttng_stop_tracing("test");
1053 lttng_destroy_session("test");
1054
1055 goto end;
1056 #else
1057 fprintf(stderr, "[ERROR] Mmap live support not compiled, specify a "
1058 "trace directory or -r <relayd hostname/IP>\n");
1059 usage(stdout);
1060 ret = -1;
1061 goto end;
1062 #endif /* LTTNGTOP_MMAP_LIVE */
1063 } else if (!opt_input_path && remote_live) {
1064 /* network live */
1065 #if 0
1066 ret = setup_network_live(opt_relay_hostname, opt_begin);
1067 if (ret < 0) {
1068 goto end;
1069 }
1070
1071 ret = open_trace(&bt_ctx);
1072 if (ret < 0) {
1073 goto end;
1074 }
1075 #endif
1076
1077 bt_ctx = bt_context_create();
1078 ret = bt_context_add_traces_recursive(bt_ctx, opt_relay_hostname,
1079 "lttng-live", NULL);
1080 if (ret < 0) {
1081 fprintf(stderr, "[error] Opening the trace\n");
1082 goto end;
1083 }
1084 } else {
1085 //init_lttngtop();
1086
1087 bt_ctx = bt_context_create();
1088 ret = bt_context_add_traces_recursive(bt_ctx, opt_input_path, "ctf", NULL);
1089 if (ret < 0) {
1090 fprintf(stderr, "[error] Opening the trace\n");
1091 goto end;
1092 }
1093
1094 ret = check_requirements(bt_ctx);
1095 if (ret < 0) {
1096 fprintf(stderr, "[error] some mandatory contexts "
1097 "were missing, exiting.\n");
1098 goto end;
1099 }
1100
1101 if (!opt_textdump) {
1102 pthread_create(&display_thread, NULL, ncurses_display,
1103 (void *) NULL);
1104 pthread_create(&timer_thread, NULL, refresh_thread,
1105 (void *) NULL);
1106 }
1107
1108 iter_trace(bt_ctx);
1109 }
1110
1111
1112 pthread_join(display_thread, NULL);
1113 quit = 1;
1114 pthread_join(timer_thread, NULL);
1115
1116 ret = 0;
1117
1118 end:
1119 if (bt_ctx)
1120 bt_context_put(bt_ctx);
1121
1122 return ret;
1123 }
This page took 0.081482 seconds and 3 git commands to generate.