X-Git-Url: https://git.lttng.org/?p=lttngtop.git;a=blobdiff_plain;f=src%2Fcommon.c;h=5cc9bca14aff3342fa33baefb88f26599acaafb0;hp=d9ec95b33281f07628cece74325414109647fac5;hb=094632060f50c0a268794c70e0650167c5c51fb8;hpb=1dec520a9e8e0654fa7fab2310a0191b2836d424 diff --git a/src/common.c b/src/common.c index d9ec95b..5cc9bca 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 @@ -10,20 +10,20 @@ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, - * MA 02111-1307, USA. + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include #include +#include #include #include "common.h" -uint64_t get_cpu_id(struct bt_ctf_event *event) +uint64_t get_cpu_id(const struct bt_ctf_event *event) { - struct definition *scope; + const struct definition *scope; uint64_t cpu_id; scope = bt_ctf_get_top_level_scope(event, BT_STREAM_PACKET_CONTEXT); @@ -36,9 +36,9 @@ uint64_t get_cpu_id(struct bt_ctf_event *event) return cpu_id; } -uint64_t get_context_tid(struct bt_ctf_event *event) +uint64_t get_context_tid(const struct bt_ctf_event *event) { - struct definition *scope; + const struct definition *scope; uint64_t tid; scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); @@ -52,9 +52,9 @@ uint64_t get_context_tid(struct bt_ctf_event *event) return tid; } -uint64_t get_context_pid(struct bt_ctf_event *event) +uint64_t get_context_pid(const struct bt_ctf_event *event) { - struct definition *scope; + const struct definition *scope; uint64_t pid; scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); @@ -68,9 +68,9 @@ uint64_t get_context_pid(struct bt_ctf_event *event) return pid; } -uint64_t get_context_ppid(struct bt_ctf_event *event) +uint64_t get_context_ppid(const struct bt_ctf_event *event) { - struct definition *scope; + const struct definition *scope; uint64_t ppid; scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); @@ -84,9 +84,9 @@ uint64_t get_context_ppid(struct bt_ctf_event *event) return ppid; } -char *get_context_comm(struct bt_ctf_event *event) +char *get_context_comm(const struct bt_ctf_event *event) { - struct definition *scope; + const struct definition *scope; char *comm; scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT); @@ -100,6 +100,12 @@ char *get_context_comm(struct bt_ctf_event *event) return comm; } +/* + * 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; @@ -126,16 +132,19 @@ struct processtop* add_proc(struct lttngtop *ctx, int tid, char *comm, newproc->tid = tid; newproc->birth = timestamp; newproc->process_files_table = g_ptr_array_new(); - newproc->files_history = g_new0(struct file_history, 1); - newproc->files_history->next = NULL; + newproc->files_history = NULL; newproc->totalfileread = 0; newproc->totalfilewrite = 0; newproc->fileread = 0; newproc->filewrite = 0; newproc->syscall_info = NULL; + newproc->threadparent = NULL; 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); + + ctx->nbnewthreads++; + ctx->nbthreads++; } newproc->comm = strdup(comm); @@ -166,8 +175,11 @@ void death_proc(struct lttngtop *ctx, int tid, char *comm, { struct processtop *tmp; tmp = find_process_tid(ctx, tid, comm); - if (tmp && strcmp(tmp->comm, comm) == 0) + if (tmp && strcmp(tmp->comm, comm) == 0) { tmp->death = timestamp; + ctx->nbdeadthreads++; + ctx->nbthreads--; + } } struct processtop* get_proc(struct lttngtop *ctx, int tid, char *comm, @@ -180,6 +192,16 @@ struct processtop* get_proc(struct lttngtop *ctx, int tid, char *comm, return add_proc(ctx, tid, comm, timestamp); } +struct processtop *get_proc_pid(struct lttngtop *ctx, int tid, int pid, + unsigned long timestamp) +{ + struct processtop *tmp; + tmp = find_process_tid(ctx, tid, NULL); + if (tmp && tmp->pid == pid) + return tmp; + return add_proc(ctx, tid, "Unknown", timestamp); +} + void add_thread(struct processtop *parent, struct processtop *thread) { gint i; @@ -253,7 +275,7 @@ void reset_perf_counter(gpointer key, gpointer value, gpointer user_data) void copy_perf_counter(gpointer key, gpointer value, gpointer new_table) { struct perfcounter *newperf; - + newperf = g_new0(struct perfcounter, 1); newperf->count = ((struct perfcounter *) value)->count; newperf->visible = ((struct perfcounter *) value)->visible; @@ -288,11 +310,40 @@ void cleanup_processtop() if (tmpf != NULL) { tmpf->read = 0; tmpf->write = 0; + + if (tmpf->flag == __NR_close) + g_ptr_array_index( + tmp->process_files_table, j + ) = NULL; } } } } +void reset_global_counters() +{ + lttngtop.nbnewproc = 0; + lttngtop.nbdeadproc = 0; + lttngtop.nbnewthreads = 0; + lttngtop.nbdeadthreads = 0; + lttngtop.nbnewfiles = 0; + lttngtop.nbclosedfiles = 0; +} + +void copy_global_counters(struct lttngtop *dst) +{ + dst->nbproc = lttngtop.nbproc; + dst->nbnewproc = lttngtop.nbnewproc; + dst->nbdeadproc = lttngtop.nbdeadproc; + dst->nbthreads = lttngtop.nbthreads; + dst->nbnewthreads = lttngtop.nbnewthreads; + dst->nbdeadthreads = lttngtop.nbdeadthreads; + dst->nbfiles = lttngtop.nbfiles; + dst->nbnewfiles = lttngtop.nbnewfiles; + dst->nbclosedfiles = lttngtop.nbclosedfiles; + reset_global_counters(); +} + struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end) { gint i, j; @@ -305,14 +356,13 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end) dst = g_new0(struct lttngtop, 1); dst->start = start; dst->end = end; + copy_global_counters(dst); 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); 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); @@ -321,6 +371,7 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end) new->threads = g_ptr_array_new(); new->comm = strdup(tmp->comm); new->process_files_table = g_ptr_array_new(); + new->files_history = tmp->files_history; new->perf = g_hash_table_new(g_str_hash, g_str_equal); g_hash_table_foreach(tmp->perf, copy_perf_counter, new->perf); @@ -352,6 +403,7 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end) * files associated with if after the copy */ if (tmp->death > 0 && tmp->death < end) { + /* FIXME : close the files before */ g_ptr_array_remove(tmp->process_files_table, tmpfile); g_free(tmpfile); } @@ -408,3 +460,72 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end) return dst; } + +enum bt_cb_ret handle_statedump_process_state(struct bt_ctf_event *call_data, + void *private_data) +{ + const struct definition *scope; + struct processtop *proc; + unsigned long timestamp; + int64_t pid, tid; + char *procname; + + timestamp = bt_ctf_get_real_timestamp(call_data); + if (timestamp == -1ULL) + goto error; + + scope = bt_ctf_get_top_level_scope(call_data, + BT_EVENT_FIELDS); + pid = bt_ctf_get_int64(bt_ctf_get_field(call_data, + scope, "_pid")); + if (bt_ctf_field_get_error()) { + fprintf(stderr, "Missing pid context info\n"); + goto error; + } + + scope = bt_ctf_get_top_level_scope(call_data, + BT_EVENT_FIELDS); + 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; + } + + /* + * 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, + scope, "_name")); + if (bt_ctf_field_get_error()) { + fprintf(stderr, "Missing process name context info\n"); + goto error; + } + + proc = find_process_tid(<tngtop, tid, procname); + if (proc == NULL) + proc = add_proc(<tngtop, tid, procname, timestamp); + + 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); + */ + + return BT_CB_OK; + +error: + return BT_CB_ERROR_STOP; +}