{
unsigned int cnt, i;
const struct definition *const * list;
+ const struct declaration *l;
const struct definition *scope;
enum ctf_type_id type;
const char *str;
if (i != 0)
printf(", ");
printf("%s = ", bt_ctf_field_name(list[i]));
- type = bt_ctf_field_type(list[i]);
+ l = bt_ctf_get_decl_from_def(list[i]);
+ type = bt_ctf_field_type(l);
if (type == CTF_TYPE_INTEGER) {
- if (bt_ctf_get_int_signedness(list[i]) == 0)
+ if (bt_ctf_get_int_signedness(l) == 0)
printf("%" PRIu64 "", bt_ctf_get_uint64(list[i]));
else
printf("%" PRId64 "", bt_ctf_get_int64(list[i]));
}
hostname = get_context_hostname(call_data);
- if (!opt_tid && (opt_hostname && !lookup_hostname_list(hostname)))
- goto end;
- if (!opt_hostname && (opt_tid && !lookup_tid_list(pid)))
- goto end;
- if ((opt_tid && !lookup_tid_list(pid)) &&
- (opt_hostname && !lookup_hostname_list(hostname)))
- goto end;
+ if (opt_tid || opt_hostname)
+ if (!lookup_filter_tid_list(pid))
+ goto end;
cpu_id = get_cpu_id(call_data);
procname = get_context_comm(call_data);
}
void extract_perf_counter_scope(const struct bt_ctf_event *event,
- const struct definition *scope,
+ const struct bt_definition *scope,
struct processtop *proc,
struct cputime *cpu)
{
- struct definition const * const *list = NULL;
- const struct definition *field;
+ struct bt_definition const * const *list = NULL;
+ const struct bt_definition *field;
unsigned int count;
struct perfcounter *perfcounter;
GHashTableIter iter;
void update_perf_counter(struct processtop *proc, const struct bt_ctf_event *event)
{
struct cputime *cpu;
- const struct definition *scope;
+ const struct bt_definition *scope;
cpu = get_cpu(get_cpu_id(event));
/* find or create the current process */
child = find_process_tid(<tngtop, tid, comm);
if (!child)
- child = add_proc(<tngtop, tid, comm, timestamp);
+ child = add_proc(<tngtop, tid, comm, timestamp, hostname);
if (!child)
goto end;
update_proc(child, pid, tid, ppid, vpid, vtid, vppid, comm, hostname);
/* find or create the parent */
parent = find_process_tid(<tngtop, pid, comm);
if (!parent) {
- parent = add_proc(<tngtop, pid, comm, timestamp);
+ parent = add_proc(<tngtop, pid, comm, timestamp, hostname);
if (parent)
parent->pid = pid;
}
{
copies = g_ptr_array_new();
global_perf_liszt = g_hash_table_new(g_str_hash, g_str_equal);
+ global_filter_list = g_hash_table_new(g_str_hash, g_str_equal);
+ global_host_list = g_hash_table_new(g_str_hash, g_str_equal);
sem_init(&goodtodisplay, 0, 0);
sem_init(&goodtoupdate, 0, 1);
lttngtop.process_table = g_ptr_array_new();
lttngtop.files_table = g_ptr_array_new();
lttngtop.cpu_table = g_ptr_array_new();
+
+ toggle_filter = -1;
}
void usage(FILE *fp)
fprintf(fp, " -p, --pid Comma-separated list of PIDs to display\n");
fprintf(fp, " -f, --child Follow threads associated with selected PIDs\n");
fprintf(fp, " -n, --hostname Comma-separated list of hostnames to display (require hostname context in trace)\n");
+ fprintf(fp, " -k, --kprobes Comma-separated list of kprobes to insert (same format as lttng enable-event)\n");
}
/*
opt_child = 1;
break;
case OPT_PID:
- tid_list = g_hash_table_new(g_str_hash,
+ toggle_filter = 1;
+ tid_filter_list = g_hash_table_new(g_str_hash,
g_str_equal);
tmp_str = strtok(opt_tid, ",");
while (tmp_str) {
tid = malloc(sizeof(int));
*tid = atoi(tmp_str);
- g_hash_table_insert(tid_list,
+ g_hash_table_insert(tid_filter_list,
(gpointer) tid, tid);
tmp_str = strtok(NULL, ",");
}
break;
case OPT_HOSTNAME:
- hostname_list = g_hash_table_new(g_str_hash,
- g_str_equal);
+ toggle_filter = 1;
tmp_str = strtok(opt_hostname, ",");
while (tmp_str) {
- char *new_str = strdup(tmp_str);
- g_hash_table_insert(hostname_list,
- (gpointer) new_str,
- (gpointer) new_str);
+ add_hostname_list(tmp_str, 1);
tmp_str = strtok(NULL, ",");
}
break;
begin_pos.type = BT_SEEK_BEGIN;
iter = bt_ctf_iter_create(bt_ctx, &begin_pos, NULL);
+ /* at each event, verify the status of the process table */
+ bt_ctf_iter_add_callback(iter, 0, NULL, 0,
+ fix_process_table,
+ NULL, NULL, NULL);
if (opt_textdump) {
bt_ctf_iter_add_callback(iter, 0, NULL, 0,
print_timestamp,
bt_ctf_iter_add_callback(iter, 0, NULL, 0,
check_timestamp,
NULL, NULL, NULL);
- /* at each event, verify the status of the process table */
- bt_ctf_iter_add_callback(iter, 0, NULL, 0,
- fix_process_table,
- NULL, NULL, NULL);
/* to handle the scheduling events */
bt_ctf_iter_add_callback(iter,
g_quark_from_static_string("sched_switch"),
NULL, NULL, NULL);
/* for kprobes */
- for (i = 0; i < lttngtop.kprobes_table->len; i++) {
- kprobe = g_ptr_array_index(lttngtop.kprobes_table, i);
- bt_ctf_iter_add_callback(iter,
- g_quark_from_static_string(
- kprobe->probe_name),
- NULL, 0, handle_kprobes,
- NULL, NULL, NULL);
+ if (lttngtop.kprobes_table) {
+ for (i = 0; i < lttngtop.kprobes_table->len; i++) {
+ kprobe = g_ptr_array_index(lttngtop.kprobes_table, i);
+ bt_ctf_iter_add_callback(iter,
+ g_quark_from_static_string(
+ kprobe->probe_name),
+ NULL, 0, handle_kprobes,
+ NULL, NULL, NULL);
+ }
}
}
*/
int bt_context_add_traces_recursive(struct bt_context *ctx, const char *path,
const char *format_str,
- void (*packet_seek)(struct stream_pos *pos,
+ void (*packet_seek)(struct bt_stream_pos *pos,
size_t offset, int whence))
{
FTS *tree;
(*tid_check)++;
}
if (*pid_check == 0) {
- if (strncmp(name, "tid", 3) == 0)
+ if (strncmp(name, "pid", 3) == 0)
(*pid_check)++;
}
if (*ppid_check == 0) {
}
/* splice the subbuffer to the tracefile */
- ret = helper_lttng_consumer_on_read_subbuffer_splice(ctx, kconsumerd_fd, len);
+ ret = helper_lttng_consumer_on_read_subbuffer_splice(ctx, kconsumerd_fd, len, 0);
if (ret < 0) {
/*
* display the error but continue processing to try
helper_lttng_consumer_init();
/* Create the thread to manage the receive of fd */
- ret = pthread_create(&threads[0], NULL, helper_lttng_consumer_thread_receive_fds,
+ ret = pthread_create(&threads[0], NULL, helper_lttng_consumer_thread_sessiond_poll,
(void *) ctx);
if (ret != 0) {
perror("pthread_create receive fd");
goto end;
}
/* Create thread to manage the polling/writing of traces */
- ret = pthread_create(&threads[1], NULL, helper_lttng_consumer_thread_poll_fds,
+ ret = pthread_create(&threads[1], NULL, helper_lttng_consumer_thread_metadata_poll,
(void *) ctx);
if (ret != 0) {
perror("pthread_create poll fd");
int ret = 0;
char *command_sock_path = "/tmp/consumerd_sock";
static pthread_t threads[2]; /* recv_fd, poll */
- struct lttng_event_context kctxpid, kctxcomm, kctxppid, kctxtid;
+ struct lttng_event_context kctxpid, kctxcomm, kctxppid, kctxtid,
+ kctxperf1, kctxperf2;
struct lttng_handle *handle;
chan.attr.subbuf_size = 32768;
chan.attr.num_subbuf = 8;
} else {
- chan.attr.subbuf_size = 1048576; /* 1MB */
+ //chan.attr.subbuf_size = 1048576; /* 1MB */
+ chan.attr.subbuf_size = 2097152; /* 1MB */
chan.attr.num_subbuf = 4;
}
chan.attr.switch_timer_interval = 0;
}
memset(&ev, '\0', sizeof(struct lttng_event));
- //sprintf(ev.name, "sched_switch");
ev.type = LTTNG_EVENT_TRACEPOINT;
+ sprintf(ev.name, "sched_switch");
if ((ret = lttng_enable_event(handle, &ev, channel_name)) < 0) {
- fprintf(stderr,"error enabling event : %s\n",
+ fprintf(stderr,"error enabling event %s : %s\n",
+ ev.name,
+ helper_lttcomm_get_readable_code(ret));
+ goto error_session;
+ }
+ sprintf(ev.name, "sched_process_free");
+ if ((ret = lttng_enable_event(handle, &ev, channel_name)) < 0) {
+ fprintf(stderr,"error enabling event %s : %s\n",
+ ev.name,
+ helper_lttcomm_get_readable_code(ret));
+ goto error_session;
+ }
+ sprintf(ev.name, "lttng_statedump_process_state");
+ if ((ret = lttng_enable_event(handle, &ev, channel_name)) < 0) {
+ fprintf(stderr,"error enabling event %s : %s\n",
+ ev.name,
+ helper_lttcomm_get_readable_code(ret));
+ goto error_session;
+ }
+ sprintf(ev.name, "lttng_statedump_file_descriptor");
+ if ((ret = lttng_enable_event(handle, &ev, channel_name)) < 0) {
+ fprintf(stderr,"error enabling event %s : %s\n",
+ ev.name,
helper_lttcomm_get_readable_code(ret));
goto error_session;
}
goto error_session;
}
- ret = enable_kprobes(handle, channel_name);
+ if (lttngtop.kprobes_table) {
+ ret = enable_kprobes(handle, channel_name);
+ if (ret < 0) {
+ goto error_session;
+ }
+ }
+
+ kctxperf1.ctx = LTTNG_EVENT_CONTEXT_PERF_COUNTER;
+ kctxperf1.u.perf_counter.type = 0; /* PERF_TYPE_HARDWARE */
+ kctxperf1.u.perf_counter.config = 5; /* PERF_COUNT_HW_BRANCH_MISSES */
+ sprintf(kctxperf1.u.perf_counter.name, "perf_branch_misses");
+ ret = lttng_add_context(handle, &kctxperf1, NULL, NULL);
if (ret < 0) {
- goto error_session;
+ fprintf(stderr, "error enabling context %s\n",
+ kctxtid.u.perf_counter.name);
+ }
+
+ kctxperf2.ctx = LTTNG_EVENT_CONTEXT_PERF_COUNTER;
+ kctxperf2.u.perf_counter.type = 1; /* PERF_TYPE_SOFTWARE */
+ kctxperf2.u.perf_counter.config = 6; /* PERF_COUNT_SW_PAGE_FAULTS_MAJ */
+ sprintf(kctxperf2.u.perf_counter.name, "perf_major_faults");
+ ret = lttng_add_context(handle, &kctxperf2, NULL, NULL);
+ if (ret < 0) {
+ fprintf(stderr, "error enabling context %s\n",
+ kctxtid.u.perf_counter.name);
}
kctxpid.ctx = LTTNG_EVENT_CONTEXT_PID;
kctxtid.ctx = LTTNG_EVENT_CONTEXT_HOSTNAME;
lttng_add_context(handle, &kctxtid, NULL, NULL);
+
if ((ret = lttng_start_tracing("test")) < 0) {
fprintf(stderr,"error starting tracing : %s\n",
helper_lttcomm_get_readable_code(ret));
struct mmap_stream *mmap_info;
unsigned long mmap_len;
+ init_lttngtop();
ret = parse_options(argc, argv);
if (ret < 0) {
fprintf(stdout, "Error parsing options.\n\n");
signal(SIGTERM, handle_textdump_sigterm);
signal(SIGINT, handle_textdump_sigterm);
}
- init_lttngtop();
ret = setup_live_tracing();
if (ret < 0) {
goto end;
while (!quit) {
reload_trace = 0;
live_consume(&bt_ctx);
+ ret = check_requirements(bt_ctx);
+ if (ret < 0) {
+ fprintf(stderr, "[error] some mandatory contexts were missing, exiting.\n");
+ goto end;
+ }
iter_trace(bt_ctx);
+ /*
+ * FIXME : pb with cleanup in libbabeltrace
ret = bt_context_remove_trace(bt_ctx, 0);
- if (ret != 0)
+ if (ret != 0) {
fprintf(stderr, "error removing trace\n");
+ goto error;
+ }
+ */
if (bt_ctx) {
bt_context_put(bt_ctx);
}
goto end;
} else {
- init_lttngtop();
+ //init_lttngtop();
bt_ctx = bt_context_create();
ret = bt_context_add_traces_recursive(bt_ctx, opt_input_path, "ctf", NULL);
bt_context_put(bt_ctx);
return 0;
+
+error:
+ return -1;
}