X-Git-Url: https://git.lttng.org/?p=lttngtop.git;a=blobdiff_plain;f=src%2Fcommon.c;h=f6c20c9c8dee3487dd480bfa37d6bb0cb570d2b4;hp=3051f7e3b62b0ab7ac0d5c8cf6d74d291bfc48fa;hb=c8d75a13bc5c025053b0c2c14fa1a7dfdaa1b448;hpb=928f18a6c02cf1eaafb7b60cb72860ed68d7456b diff --git a/src/common.c b/src/common.c index 3051f7e..f6c20c9 100644 --- a/src/common.c +++ b/src/common.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 Julien Desfossez + * Copyright (C) 2011-2012 Julien Desfossez * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License Version 2 as @@ -23,7 +23,7 @@ uint64_t get_cpu_id(const struct bt_ctf_event *event) { - const struct definition *scope; + const struct bt_definition *scope; uint64_t cpu_id; scope = bt_ctf_get_top_level_scope(event, BT_STREAM_PACKET_CONTEXT); @@ -38,7 +38,7 @@ uint64_t get_cpu_id(const struct bt_ctf_event *event) uint64_t get_context_tid(const struct bt_ctf_event *event) { - const struct definition *scope; + const struct bt_definition *scope; uint64_t tid; scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); @@ -54,7 +54,7 @@ uint64_t get_context_tid(const struct bt_ctf_event *event) uint64_t get_context_pid(const struct bt_ctf_event *event) { - const struct definition *scope; + const struct bt_definition *scope; uint64_t pid; scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); @@ -70,7 +70,7 @@ uint64_t get_context_pid(const struct bt_ctf_event *event) uint64_t get_context_ppid(const struct bt_ctf_event *event) { - const struct definition *scope; + const struct bt_definition *scope; uint64_t ppid; scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); @@ -84,9 +84,54 @@ uint64_t get_context_ppid(const struct bt_ctf_event *event) return ppid; } -char *get_context_comm(const struct bt_ctf_event *event) +uint64_t get_context_vtid(const struct bt_ctf_event *event) +{ + const struct definition *scope; + uint64_t vtid; + + scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); + vtid = bt_ctf_get_int64(bt_ctf_get_field(event, + scope, "_vtid")); + if (bt_ctf_field_get_error()) { + return -1ULL; + } + + return vtid; +} + +uint64_t get_context_vpid(const struct bt_ctf_event *event) +{ + const struct definition *scope; + uint64_t vpid; + + scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); + vpid = bt_ctf_get_int64(bt_ctf_get_field(event, + scope, "_vpid")); + if (bt_ctf_field_get_error()) { + return -1ULL; + } + + return vpid; +} + +uint64_t get_context_vppid(const struct bt_ctf_event *event) { const struct definition *scope; + uint64_t vppid; + + scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); + vppid = bt_ctf_get_int64(bt_ctf_get_field(event, + scope, "_vppid")); + if (bt_ctf_field_get_error()) { + return -1ULL; + } + + return vppid; +} + +char *get_context_comm(const struct bt_ctf_event *event) +{ + const struct bt_definition *scope; char *comm; scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); @@ -100,23 +145,33 @@ char *get_context_comm(const struct bt_ctf_event *event) return comm; } +char *get_context_hostname(const struct bt_ctf_event *event) +{ + const struct definition *scope; + char *hostname; + + scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); + hostname = bt_ctf_get_char_array(bt_ctf_get_field(event, + scope, "_hostname")); + if (bt_ctf_field_get_error()) { + return NULL; + } + + return hostname; +} + /* * To get the parent process, put the pid in the tid field * because the parent process gets pid = tid - * - * FIXME : char *comm useful ??? */ struct processtop *find_process_tid(struct lttngtop *ctx, int tid, char *comm) { - gint i; struct processtop *tmp; - for (i = 0; i < ctx->process_table->len; i++) { - tmp = g_ptr_array_index(ctx->process_table, i); - if (tmp && tmp->tid == tid) - return tmp; - } - return NULL; + tmp = g_hash_table_lookup(ctx->process_hash_table, + (gconstpointer) (unsigned long) tid); + + return tmp; } struct processtop* add_proc(struct lttngtop *ctx, int tid, char *comm, @@ -127,6 +182,7 @@ struct processtop* add_proc(struct lttngtop *ctx, int tid, char *comm, /* if the PID already exists, we just rename the process */ /* FIXME : need to integrate with clone/fork/exit to be accurate */ newproc = find_process_tid(ctx, tid, comm); + if (!newproc) { newproc = g_new0(struct processtop, 1); newproc->tid = tid; @@ -142,6 +198,8 @@ struct processtop* add_proc(struct lttngtop *ctx, int tid, char *comm, newproc->threads = g_ptr_array_new(); newproc->perf = g_hash_table_new(g_str_hash, g_str_equal); g_ptr_array_add(ctx->process_table, newproc); + g_hash_table_insert(ctx->process_hash_table, + (gpointer) (unsigned long) tid, newproc); ctx->nbnewthreads++; ctx->nbthreads++; @@ -152,16 +210,25 @@ struct processtop* add_proc(struct lttngtop *ctx, int tid, char *comm, } struct processtop* update_proc(struct processtop* proc, int pid, int tid, - int ppid, char *comm) + int ppid, int vpid, int vtid, int vppid, char *comm, char *hostname) { if (proc) { proc->pid = pid; proc->tid = tid; proc->ppid = ppid; + proc->vpid = vpid; + proc->vtid = vtid; + proc->vppid = vppid; if (strcmp(proc->comm, comm) != 0) { free(proc->comm); proc->comm = strdup(comm); } + if (hostname) { + if (proc->hostname && strcmp(proc->hostname, hostname) != 0) { + free(proc->hostname); + } + proc->hostname = strdup(hostname); + } } return proc; } @@ -175,6 +242,9 @@ void death_proc(struct lttngtop *ctx, int tid, char *comm, { struct processtop *tmp; tmp = find_process_tid(ctx, tid, comm); + + g_hash_table_remove(ctx->process_hash_table, + (gpointer) (unsigned long) tid); if (tmp && strcmp(tmp->comm, comm) == 0) { tmp->death = timestamp; ctx->nbdeadthreads++; @@ -207,6 +277,9 @@ void add_thread(struct processtop *parent, struct processtop *thread) gint i; struct processtop *tmp; + if (!parent) + return; + for (i = 0; i < parent->threads->len; i++) { tmp = g_ptr_array_index(parent->threads, i); if (tmp == thread) @@ -283,6 +356,11 @@ void copy_perf_counter(gpointer key, gpointer value, gpointer new_table) g_hash_table_insert((GHashTable *) new_table, strdup(key), newperf); } +void copy_process_table(gpointer key, gpointer value, gpointer new_table) +{ + g_hash_table_insert((GHashTable *) new_table, key, value); +} + void rotate_perfcounter() { int i; struct processtop *tmp; @@ -360,11 +438,12 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end) dst->process_table = g_ptr_array_new(); dst->files_table = g_ptr_array_new(); dst->cpu_table = g_ptr_array_new(); - dst->perf_list = g_hash_table_new(g_str_hash, g_str_equal); + dst->process_hash_table = g_hash_table_new(g_direct_hash, g_direct_equal); + g_hash_table_foreach(lttngtop.process_hash_table, copy_process_table, + dst->process_hash_table); rotate_cputime(end); - g_hash_table_foreach(lttngtop.perf_list, copy_perf_counter, dst->perf_list); for (i = 0; i < lttngtop.process_table->len; i++) { tmp = g_ptr_array_index(lttngtop.process_table, i); new = g_new0(struct processtop, 1); @@ -466,10 +545,10 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end) enum bt_cb_ret handle_statedump_process_state(struct bt_ctf_event *call_data, void *private_data) { - const struct definition *scope; + const struct bt_definition *scope; struct processtop *proc; unsigned long timestamp; - int64_t pid, tid; + int64_t pid, tid, ppid, vtid, vpid, vppid; char *procname; timestamp = bt_ctf_get_timestamp(call_data); @@ -484,23 +563,37 @@ enum bt_cb_ret handle_statedump_process_state(struct bt_ctf_event *call_data, fprintf(stderr, "Missing pid context info\n"); goto error; } - - scope = bt_ctf_get_top_level_scope(call_data, - BT_EVENT_FIELDS); + ppid = bt_ctf_get_int64(bt_ctf_get_field(call_data, + scope, "_ppid")); + if (bt_ctf_field_get_error()) { + fprintf(stderr, "Missing ppid context info\n"); + goto error; + } tid = bt_ctf_get_int64(bt_ctf_get_field(call_data, scope, "_tid")); if (bt_ctf_field_get_error()) { fprintf(stderr, "Missing tid context info\n"); goto error; } + vtid = bt_ctf_get_int64(bt_ctf_get_field(call_data, + scope, "_vtid")); + if (bt_ctf_field_get_error()) { + fprintf(stderr, "Missing vtid context info\n"); + goto error; + } + vpid = bt_ctf_get_int64(bt_ctf_get_field(call_data, + scope, "_vpid")); + if (bt_ctf_field_get_error()) { + fprintf(stderr, "Missing vpid context info\n"); + goto error; + } + vppid = bt_ctf_get_int64(bt_ctf_get_field(call_data, + scope, "_vppid")); + if (bt_ctf_field_get_error()) { + fprintf(stderr, "Missing vppid context info\n"); + goto error; + } - /* - * FIXME - * I first tried with bt_ctf_get_string but doesn`t work at all - * It couldn`t find the field _name because it is an integer in - * the metadata and not a string like _filename for the - * statedump_file_descriptor - */ scope = bt_ctf_get_top_level_scope(call_data, BT_EVENT_FIELDS); procname = bt_ctf_get_char_array(bt_ctf_get_field(call_data, @@ -513,21 +606,46 @@ enum bt_cb_ret handle_statedump_process_state(struct bt_ctf_event *call_data, proc = find_process_tid(<tngtop, tid, procname); if (proc == NULL) proc = add_proc(<tngtop, tid, procname, timestamp); + update_proc(proc, pid, tid, ppid, vpid, vtid, vppid, procname, NULL); - free(proc->comm); - proc->comm = strdup(procname); - proc->pid = pid; - - /* - * FIXME - * I would like to free procname because it is duplicated - * when the process is created but it segfaults... - * - * free(procname); - */ + if (proc) { + free(proc->comm); + proc->comm = strdup(procname); + proc->pid = pid; + } return BT_CB_OK; error: return BT_CB_ERROR_STOP; } + +struct tm format_timestamp(uint64_t timestamp) +{ + struct tm tm; + uint64_t ts_sec = 0, ts_nsec; + time_t time_s; + + ts_nsec = timestamp; + ts_sec += ts_nsec / NSEC_PER_SEC; + ts_nsec = ts_nsec % NSEC_PER_SEC; + + time_s = (time_t) ts_sec; + + localtime_r(&time_s, &tm); + + return tm; +} + +int *lookup_tid_list(int tid) +{ + return g_hash_table_lookup(tid_list, (gpointer) &tid); +} + +char *lookup_hostname_list(const char *hostname) +{ + if (!hostname) + return NULL; + + return g_hash_table_lookup(hostname_list, (gpointer) hostname); +}