prepare the 0.3 release

[lttngtop.git] / src / common.c

diff --git a/src/common.c b/src/common.c
index 021f2f1217b2316bd383e1a1ec146df492b70fd4..a6c2e4c3cfa17a24d833dce601947e14761969a1 100644 (file)
--- a/src/common.c
+++ b/src/common.c
@@ -45,8 +45,12 @@ uint64_t get_context_tid(const struct bt_ctf_event *event)
        tid = bt_ctf_get_int64(bt_ctf_get_field(event,
                                scope, "_tid"));
        if (bt_ctf_field_get_error()) {
-               fprintf(stderr, "Missing tid context info\n");
-               return -1ULL;
+               tid = bt_ctf_get_int64(bt_ctf_get_field(event,
+                                       scope, "_vtid"));
+               if (bt_ctf_field_get_error()) {
+                       fprintf(stderr, "Missing tid context info\n");
+                       return -1ULL;
+               }
        }
 
        return tid;
@@ -61,8 +65,13 @@ uint64_t get_context_pid(const struct bt_ctf_event *event)
        pid = bt_ctf_get_int64(bt_ctf_get_field(event,
                                scope, "_pid"));
        if (bt_ctf_field_get_error()) {
-               fprintf(stderr, "Missing pid context info\n");
-               return -1ULL;
+               /* Try UST pid */
+               pid = bt_ctf_get_int64(bt_ctf_get_field(event,
+                                       scope, "_vpid"));
+               if (bt_ctf_field_get_error()) {
+                       fprintf(stderr, "Missing pid context info\n");
+                       return -1ULL;
+               }
        }
 
        return pid;
@@ -77,7 +86,6 @@ uint64_t get_context_ppid(const struct bt_ctf_event *event)
        ppid = bt_ctf_get_int64(bt_ctf_get_field(event,
                                scope, "_ppid"));
        if (bt_ctf_field_get_error()) {
-               fprintf(stderr, "Missing ppid context info\n");
                return -1ULL;
        }
 
@@ -86,7 +94,7 @@ uint64_t get_context_ppid(const struct bt_ctf_event *event)
 
 uint64_t get_context_vtid(const struct bt_ctf_event *event)
 {
-       const struct definition *scope;
+       const struct bt_definition *scope;
        uint64_t vtid;
 
        scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT);
@@ -101,7 +109,7 @@ uint64_t get_context_vtid(const struct bt_ctf_event *event)
 
 uint64_t get_context_vpid(const struct bt_ctf_event *event)
 {
-       const struct definition *scope;
+       const struct bt_definition *scope;
        uint64_t vpid;
 
        scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT);
@@ -116,7 +124,7 @@ uint64_t get_context_vpid(const struct bt_ctf_event *event)
 
 uint64_t get_context_vppid(const struct bt_ctf_event *event)
 {
-       const struct definition *scope;
+       const struct bt_definition *scope;
        uint64_t vppid;
 
        scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT);
@@ -147,7 +155,7 @@ char *get_context_comm(const struct bt_ctf_event *event)
 
 char *get_context_hostname(const struct bt_ctf_event *event)
 {
-       const struct definition *scope;
+       const struct bt_definition *scope;
        char *hostname;
 
        scope = bt_ctf_get_top_level_scope(event, BT_STREAM_EVENT_CONTEXT);
@@ -164,7 +172,7 @@ char *get_context_hostname(const struct bt_ctf_event *event)
  * To get the parent process, put the pid in the tid field
  * because the parent process gets pid = tid
  */
-struct processtop *find_process_tid(struct lttngtop *ctx, int tid, char *comm)
+struct processtop *find_process_tid(struct lttngtop *ctx, int tid, const char *comm)
 {
        struct processtop *tmp;
 
@@ -178,6 +186,7 @@ struct processtop* add_proc(struct lttngtop *ctx, int tid, char *comm,
                unsigned long timestamp, char *hostname)
 {
        struct processtop *newproc;
+       struct host *host;
 
        /* if the PID already exists, we just rename the process */
        /* FIXME : need to integrate with clone/fork/exit to be accurate */
@@ -201,19 +210,20 @@ struct processtop* add_proc(struct lttngtop *ctx, int tid, char *comm,
                g_hash_table_insert(ctx->process_hash_table,
                                (gpointer) (unsigned long) tid, newproc);
                if (lookup_tid_list(tid)) {
-                       add_filter_tid_list(tid, newproc);
+                       add_filter_tid_list(newproc);
                }
                ctx->nbnewthreads++;
                ctx->nbthreads++;
        }
        newproc->comm = strdup(comm);
        if (hostname) {
-               if (newproc->hostname && strcmp(newproc->hostname, hostname) != 0) {
-                       free(newproc->hostname);
-               }
-               newproc->hostname = strdup(hostname);
-               if (lookup_hostname_list(hostname)) {
-                       add_filter_tid_list(tid, newproc);
+               host = lookup_hostname_list(hostname);
+               if (!host)
+                       host = add_hostname_list(hostname, 0);
+               if (!newproc->host || (newproc->host != host))
+                       newproc->host = host;
+               if (is_hostname_filtered(hostname)) {
+                       add_filter_tid_list(newproc);
                }
        }
 
@@ -223,6 +233,8 @@ struct processtop* add_proc(struct lttngtop *ctx, int tid, char *comm,
 struct processtop* update_proc(struct processtop* proc, int pid, int tid,
                int ppid, int vpid, int vtid, int vppid, char *comm, char *hostname)
 {
+       struct host *host;
+
        if (proc) {
                proc->pid = pid;
                proc->tid = tid;
@@ -234,10 +246,14 @@ struct processtop* update_proc(struct processtop* proc, int pid, int tid,
                        free(proc->comm);
                        proc->comm = strdup(comm);
                }
-               if (hostname && !proc->hostname) {
-                       proc->hostname = strdup(hostname);
-                       if (lookup_hostname_list(hostname)) {
-                               add_filter_tid_list(tid, proc);
+               if (hostname && !proc->host) {
+                       host = lookup_hostname_list(hostname);
+                       if (!host)
+                               host = add_hostname_list(hostname, 0);
+                       if (!proc->host || (proc->host != host))
+                               proc->host = host;
+                       if (is_hostname_filtered(hostname)) {
+                               add_filter_tid_list(proc);
                        }
                }
        }
@@ -282,7 +298,7 @@ struct processtop *get_proc_pid(struct lttngtop *ctx, int tid, int pid,
        tmp = find_process_tid(ctx, tid, NULL);
        if (tmp && tmp->pid == pid)
                return tmp;
-       return add_proc(ctx, tid, "Unknown", timestamp, hostname);
+       return add_proc(ctx, tid, NULL, timestamp, hostname);
 }
 
 void add_thread(struct processtop *parent, struct processtop *thread)
@@ -377,6 +393,7 @@ void copy_process_table(gpointer key, gpointer value, gpointer new_table)
 void rotate_perfcounter() {
        int i;
        struct processtop *tmp;
+
        for (i = 0; i < lttngtop.process_table->len; i++) {
                tmp = g_ptr_array_index(lttngtop.process_table, i);
                g_hash_table_foreach(tmp->perf, reset_perf_counter, NULL);
@@ -485,7 +502,10 @@ struct lttngtop* get_copy_lttngtop(unsigned long start, unsigned long end)
 
                        if (tmpfile != NULL) {
                                memcpy(newfile, tmpfile, sizeof(struct files));
-                               newfile->name = strdup(tmpfile->name);
+                               if (tmpfile->name)
+                                       newfile->name = strdup(tmpfile->name);
+                               else
+                                       newfile->name = NULL;
                                newfile->ref = new;
                                g_ptr_array_add(new->process_files_table,
                                                newfile);
@@ -573,7 +593,7 @@ enum bt_cb_ret handle_statedump_process_state(struct bt_ctf_event *call_data,
        struct processtop *proc;
        unsigned long timestamp;
        int64_t pid, tid, ppid, vtid, vpid, vppid;
-       char *procname, *hostname = NULL;
+       char *procname = NULL, *hostname = NULL;
 
        timestamp = bt_ctf_get_timestamp(call_data);
        if (timestamp == -1ULL)
@@ -590,8 +610,7 @@ enum bt_cb_ret handle_statedump_process_state(struct bt_ctf_event *call_data,
        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;
+               goto end;
        }
        tid = bt_ctf_get_int64(bt_ctf_get_field(call_data,
                                scope, "_tid"));
@@ -626,12 +645,6 @@ enum bt_cb_ret handle_statedump_process_state(struct bt_ctf_event *call_data,
                fprintf(stderr, "Missing process name context info\n");
                goto error;
        }
-       /*
-       hostname = bt_ctf_get_char_array(bt_ctf_get_field(call_data,
-                               scope, "_hostname"));
-       if (bt_ctf_field_get_error()) {
-       }
-       */
 
        proc = find_process_tid(&lttngtop, tid, procname);
        if (proc == NULL)
@@ -644,6 +657,7 @@ enum bt_cb_ret handle_statedump_process_state(struct bt_ctf_event *call_data,
                proc->pid = pid;
        }
 
+end:
        return BT_CB_OK;
 
 error:
@@ -669,26 +683,28 @@ struct tm format_timestamp(uint64_t timestamp)
 
 int *lookup_tid_list(int tid)
 {
-       if (!tid_list)
+       if (!tid_filter_list)
                return NULL;
 
-       return g_hash_table_lookup(tid_list, (gpointer) &tid);
+       return g_hash_table_lookup(tid_filter_list, (gpointer) &tid);
 }
 
-char *lookup_hostname_list(const char *hostname)
+struct host *lookup_hostname_list(const char *hostname)
 {
-       if (!hostname || !hostname_list)
+       if (!hostname || !global_host_list)
                return NULL;
 
-       return g_hash_table_lookup(hostname_list, (gpointer) hostname);
+       return g_hash_table_lookup(global_host_list, (gpointer) hostname);
 }
 
-void remove_hostname_list(const char *hostname)
+int is_hostname_filtered(const char *hostname)
 {
-       if (!hostname || !hostname_list)
-               return;
+       struct host *host;
 
-       g_hash_table_remove(hostname_list, (gpointer) hostname);
+       host = lookup_hostname_list(hostname);
+       if (host)
+               return host->filter;
+       return 0;
 }
 
 int *lookup_filter_tid_list(int tid)
@@ -696,14 +712,14 @@ int *lookup_filter_tid_list(int tid)
        return g_hash_table_lookup(global_filter_list, (gpointer) &tid);
 }
 
-void add_filter_tid_list(int tid, struct processtop *newproc)
+void add_filter_tid_list(struct processtop *proc)
 {
        unsigned long *hash_tid;
 
        hash_tid = malloc(sizeof(unsigned long));
-       *hash_tid = tid;
+       *hash_tid = proc->tid;
        g_hash_table_insert(global_filter_list,
-                       (gpointer) (unsigned long) hash_tid, newproc);
+                       (gpointer) (unsigned long) hash_tid, proc);
 }
 
 void remove_filter_tid_list(int tid)
@@ -711,3 +727,60 @@ void remove_filter_tid_list(int tid)
        g_hash_table_remove(global_filter_list,
                        (gpointer) (unsigned long) &tid);
 }
+
+struct host *add_hostname_list(char *hostname, int filter)
+{
+       struct host *host;
+
+       host = lookup_hostname_list(hostname);
+       if (host)
+               return host;
+
+       host = g_new0(struct host, 1);
+       host->hostname = strdup(hostname);
+       host->filter = filter;
+       g_hash_table_insert(global_host_list,
+                       (gpointer) host->hostname,
+                       (gpointer) host);
+
+       return host;
+}
+
+void update_hostname_filter(struct host *host)
+{
+       struct processtop *tmp;
+       int i;
+
+       for (i = 0; i < lttngtop.process_table->len; i++) {
+               tmp = g_ptr_array_index(lttngtop.process_table, i);
+               if (tmp->host == host) {
+                       if (host->filter)
+                               add_filter_tid_list(tmp);
+                       else
+                               remove_filter_tid_list(tmp->tid);
+               }
+       }
+}
+
+char *lookup_procname(const char *procname)
+{
+       if (!procname || !global_procname_list)
+               return NULL;
+
+       return g_hash_table_lookup(global_procname_list, (gpointer) procname);
+}
+
+char *add_procname_list(char *procname, int filter)
+{
+       char *proc;
+
+       proc = lookup_procname(procname);
+       if (proc)
+               return proc;
+
+       proc = strdup(procname);
+       g_hash_table_insert(global_procname_list,
+                       (gpointer) procname, (gpointer) procname);
+
+       return proc;
+}