trace-view: Implement event filter

This patch now implements the event filtering dialog for the trace-view (list)
only. This works with kernelshark too, but only the list is filtered.

Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

5 files changed, 412 insertions, 7 deletions

diff --git a/trace-filter.c b/trace-filter.c
index f9c384f..ba3b0fd 100644
--- a/trace-filter.c
+++ b/trace-filter.c
@@ -37,6 +37,7 @@ enum {
         COL_EVENT,
         COL_ACTIVE,
         COL_ACTIVE_START,
+        COL_EVENT_ID,
         NUM_EVENT_COLS,
 };
 
@@ -51,20 +52,26 @@ create_tree_event_model(GtkWidget *tree_view)
         struct event_format **events;
         struct event_format *event;
         char *last_system = NULL;
+        gboolean all_events;
+        gboolean sysactive;
+        gboolean active;
         gint i;
 
         model = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_view));
         trace_view = TRACE_VIEW_STORE(model);
 
+        all_events = trace_view_store_get_all_events_enabled(trace_view);
+
         pevent = tracecmd_get_pevent(trace_view->handle);
 
         treestore = gtk_tree_store_new(NUM_EVENT_COLS, G_TYPE_STRING,
-                                       G_TYPE_BOOLEAN, G_TYPE_BOOLEAN);
+                                       G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
+                                       G_TYPE_INT);
 
         gtk_tree_store_append(treestore, &iter_all, NULL);
         gtk_tree_store_set(treestore, &iter_all,
                            COL_EVENT,   "All",
-                           COL_ACTIVE, TRUE,
+                           COL_ACTIVE, all_events,
                            COL_ACTIVE_START, FALSE,
                            -1);
 
@@ -76,17 +83,22 @@ create_tree_event_model(GtkWidget *tree_view)
                 event = events[i];
                 if (!last_system || strcmp(last_system, event->system) != 0) {
                         gtk_tree_store_append(treestore, &iter_sys, &iter_all);
+                        sysactive = all_events ||
+                                trace_view_store_system_enabled(trace_view, event->system);
                         gtk_tree_store_set(treestore, &iter_sys,
                                            COL_EVENT, event->system,
-                                           COL_ACTIVE, TRUE,
+                                           COL_ACTIVE, sysactive,
                                            -1);
                         last_system = event->system;
                 }
 
+                active = all_events || sysactive ||
+                        trace_view_store_event_enabled(trace_view, event->id);
                 gtk_tree_store_append(treestore, &iter_events, &iter_sys);
                 gtk_tree_store_set(treestore, &iter_events,
                                    COL_EVENT, event->name,
-                                   COL_ACTIVE, FALSE,
+                                   COL_ACTIVE, active,
+                                   COL_EVENT_ID, event->id,
                                    -1);
 
         }
@@ -263,15 +275,114 @@ static GtkWidget *create_event_list_view(GtkWidget *tree_view)
         return view;
 }
 
+static void update_events(TraceViewStore *store,
+                          GtkTreeModel *model,
+                          GtkTreeIter *parent)
+{
+        GtkTreeIter event;
+        gboolean active;
+        gint id;
+
+        if (!gtk_tree_model_iter_children(model, &event, parent))
+                return;
+
+        for (;;) {
+
+                gtk_tree_model_get(model, &event,
+                                   COL_ACTIVE, &active,
+                                   COL_EVENT_ID, &id,
+                                   -1);
+
+                if (active)
+                        trace_view_store_set_event_enabled(store, id);
+
+                if (!gtk_tree_model_iter_next(model, &event))
+                        break;
+        }
+}
+
+static void update_system_events(TraceViewStore *store,
+                                 GtkTreeModel *model,
+                                 GtkTreeIter *parent)
+{
+        GtkTreeIter sys;
+        gboolean active;
+        gchar *system;
+
+        if (!gtk_tree_model_iter_children(model, &sys, parent))
+                return;
+
+        for (;;) {
+
+                gtk_tree_model_get(model, &sys,
+                                   COL_ACTIVE, &active,
+                                   COL_EVENT, &system,
+                                   -1);
+
+                if (active)
+                        trace_view_store_set_system_enabled(store, system);
+                else
+                        update_events(store, model, &sys);
+
+                g_free(system);
+
+                if (!gtk_tree_model_iter_next(model, &sys))
+                        break;
+        }
+}
+
+static void accept_events(GtkWidget *trace_tree_view, GtkTreeView *view)
+{
+        GtkTreeModel *model;
+        TraceViewStore *store;
+        GtkTreeIter iter;
+        gboolean active;
+
+        model = gtk_tree_view_get_model(GTK_TREE_VIEW(trace_tree_view));
+        if (!model)
+                return;
+
+        store = TRACE_VIEW_STORE(model);
+
+        model = gtk_tree_view_get_model(view);
+        if (!model)
+                return;
+
+        if (!gtk_tree_model_get_iter_first(model, &iter))
+                return;
+
+        gtk_tree_model_get(model, &iter,
+                           COL_ACTIVE, &active,
+                           -1);
+
+        if (active) {
+                if (trace_view_store_get_all_events_enabled(store))
+                        return;
+
+                trace_view_store_set_all_events_enabled(store);
+        } else
+                update_system_events(store, model, &iter);
+
+        /* Force an update */
+        g_object_ref(store);
+        gtk_tree_view_set_model(GTK_TREE_VIEW(trace_tree_view), NULL);
+        trace_view_store_update_filter(store);
+        gtk_tree_view_set_model(GTK_TREE_VIEW(trace_tree_view), GTK_TREE_MODEL(store));
+        g_object_unref(store);
+
+}
+
 /* Callback for the clicked signal of the Events filter button */
 static void
 event_dialog_response (gpointer data, gint response_id)
 {
         struct dialog_helper *helper = data;
+        GtkTreeView *view = helper->data;
 
         switch (response_id) {
         case GTK_RESPONSE_ACCEPT:
                 printf("accept!\n");
+                accept_events(helper->trace_tree, view);
                 break;
         case GTK_RESPONSE_REJECT:
                 printf("reject!\n");
@@ -319,6 +430,7 @@ void trace_filter_event_dialog(void *trace_tree)
                                        GTK_POLICY_AUTOMATIC,
                                        GTK_POLICY_AUTOMATIC);
         view = create_event_list_view(tree_view);
+        helper->data = view;
 
         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), scrollwin, TRUE, TRUE, 0);
         gtk_container_add(GTK_CONTAINER(scrollwin), view);
diff --git a/trace-hash.c b/trace-hash.c
index 99b9feb..8435e6c 100644
--- a/trace-hash.c
+++ b/trace-hash.c
@@ -116,3 +116,47 @@ struct filter_task *filter_task_hash_alloc(void)
 
         return hash;
 }
+
+void filter_task_hash_free(struct filter_task *hash)
+{
+        if (!hash)
+                return;
+
+        filter_task_clear(hash);
+        g_free(hash->hash);
+        g_free(hash);
+}
+
+struct filter_task *filter_task_hash_copy(struct filter_task *hash)
+{
+        struct filter_task *new_hash;
+        struct filter_task_item *task, **ptask;
+        gint i;
+
+        if (!hash)
+                return NULL;
+
+        new_hash = filter_task_hash_alloc();
+        g_assert(new_hash);
+
+        for (i = 0; i < FILTER_TASK_HASH_SIZE; i++) {
+                task = hash->hash[i];
+                if (!task)
+                        continue;
+
+                ptask = &new_hash->hash[i];
+
+                while (task) {
+
+                        *ptask = g_new0(typeof(*task), 1);
+                        g_assert(*ptask);
+                        **ptask = *task;
+
+                        ptask = &(*ptask)->next;
+                        task = task->next;
+                }
+        }
+
+        return new_hash;
+}
+
diff --git a/trace-hash.h b/trace-hash.h
index cab6195..9948138 100644
--- a/trace-hash.h
+++ b/trace-hash.h
@@ -21,6 +21,8 @@ void filter_task_add_pid(struct filter_task *hash, gint pid);
 void filter_task_remove_pid(struct filter_task *hash, gint pid);
 void filter_task_clear(struct filter_task *hash);
 struct filter_task *filter_task_hash_alloc(void);
+void filter_task_hash_free(struct filter_task *hash);
+struct filter_task *filter_task_hash_copy(struct filter_task *hash);
 
 static inline gint filter_task_count(struct filter_task *hash)
 {
diff --git a/trace-view-store.c b/trace-view-store.c
index 03664c8..5e81daa 100644
--- a/trace-view-store.c
+++ b/trace-view-store.c
@@ -1,5 +1,6 @@
 #include "trace-view-store.h"
 #include <stdlib.h>
+#include <string.h>
 
 #include "cpu.h"
 
@@ -207,6 +208,8 @@ trace_view_store_finalize (GObject *object)
         g_free(store->rows);
         g_free(store->cpu_items);
 
+        filter_task_hash_free(store->task_filter);
+
         if (store->spin) {
                 gtk_widget_destroy(store->spin);
                 store->spin = NULL;
@@ -490,6 +493,183 @@ trace_view_store_get_value (GtkTreeModel *tree_model,
         }
 }
 
+int str_cmp(const void *a, const void *b)
+{
+        char * const * sa = a;
+        char * const * sb = b;
+
+        return strcmp(*sa, *sb);
+}
+
+int id_cmp(const void *a, const void *b)
+{
+        const gint *ia = a;
+        const gint *ib = b;
+
+        if (*ia > *ib)
+                return 1;
+        if (*ia < *ib)
+                return -1;
+        return 0;
+}
+
+gboolean trace_view_store_system_enabled(TraceViewStore *store, const gchar *system)
+{
+        const gchar **sys = &system;
+
+        g_return_val_if_fail (TRACE_VIEW_IS_LIST (store), FALSE);
+
+        if (store->all_events)
+                return TRUE;
+
+        if (!store->systems)
+                return FALSE;
+
+        sys = bsearch(sys, store->systems, store->systems_size,
+                      sizeof(system), str_cmp);
+
+        return sys != NULL;
+}
+
+gboolean trace_view_store_event_enabled(TraceViewStore *store, gint event_id)
+{
+        gint key = event_id;
+        gint *ret;
+
+        g_return_val_if_fail (TRACE_VIEW_IS_LIST (store), FALSE);
+
+        if (store->all_events)
+                return TRUE;
+
+        /* TODO: search for the system of the event? */
+
+        if (!store->event_types)
+                return FALSE;
+
+        ret = bsearch(&key, store->event_types, store->event_types_size,
+                      sizeof(gint), id_cmp);
+
+        return ret != NULL;
+}
+
+void trace_view_store_set_all_events_enabled(TraceViewStore *store)
+{
+        gint i;
+
+        g_return_if_fail (TRACE_VIEW_IS_LIST (store));
+
+        if (store->all_events)
+                return;
+
+        if (store->systems_size) {
+                for (i = 0; i < store->systems_size; i++)
+                        g_free(store->systems[i]);
+
+                g_free(store->systems);
+                store->systems = NULL;
+                store->systems_size = 0;
+        }
+
+        g_free(store->event_types);
+        store->event_types = NULL;
+        store->event_types_size = 0;
+
+        store->all_events = 1;
+}
+
+static void remove_system(TraceViewStore *store, const gchar *system)
+{
+        const gchar **sys = &system;
+
+        if (!store->systems)
+                return;
+
+        sys = bsearch(sys, store->systems, store->systems_size,
+                      sizeof(system), str_cmp);
+
+        if (!sys)
+                return;
+
+        g_free(*((gchar **)sys));
+
+        g_memmove(sys, sys+1, sizeof(*sys) * (store->systems_size -
+                                              ((gchar **)sys - store->systems)));
+        store->systems_size--;
+        store->systems[store->systems_size] = NULL;
+}
+
+void trace_view_store_set_system_enabled(TraceViewStore *store, const gchar *system)
+{
+        g_return_if_fail (TRACE_VIEW_IS_LIST (store));
+
+        if (store->all_events)
+                /*
+                 * We are adding a new filter, so this is the
+                 * only system enabled.
+                 */
+                store->all_events = 0;
+
+        if (trace_view_store_system_enabled(store, system))
+                return;
+
+        if (!store->systems) {
+                store->systems = g_new0(gchar *, 2);
+                store->systems[0] = g_strdup(system);
+                store->systems_size++;
+                return;
+        }
+
+        store->systems_size++;
+        store->systems = g_realloc(store->systems,
+                                   sizeof(*store->systems) * (store->systems_size+1));
+        store->systems[store->systems_size - 1] = g_strdup(system);
+        store->systems[store->systems_size] = NULL;
+
+        qsort(store->systems, store->systems_size, sizeof(gchar *), str_cmp);
+}
+
+
+void trace_view_store_set_event_enabled(TraceViewStore *store, gint event_id)
+{
+        struct pevent *pevent;
+        struct event_format *event;
+
+        g_return_if_fail (TRACE_VIEW_IS_LIST (store));
+
+        pevent = tracecmd_get_pevent(store->handle);
+        event = pevent_find_event(pevent, event_id);
+        if (!event)
+                return;
+
+        if (store->all_events)
+                /*
+                 * We are adding a new filter, so this is the
+                 * only system enabled.
+                 */
+                store->all_events = 0;
+
+        remove_system(store, event->system);
+
+        if (trace_view_store_event_enabled(store, event_id))
+                return;
+
+        if (!store->event_types) {
+                store->event_types = g_new0(gint, 2);
+                store->event_types[0] = event_id;
+                store->event_types[1] = -1;
+                store->event_types_size++;
+                return;
+        }
+
+        store->event_types_size++;
+        store->event_types = g_realloc(store->event_types,
+                                       sizeof(*store->event_types) * (store->event_types_size+1));
+        store->event_types[store->event_types_size - 1] = event_id;
+        store->event_types[store->event_types_size] = -1;
+
+        qsort(store->event_types, store->event_types_size, sizeof(gint), id_cmp);
+}
+
 
 /*****************************************************************************
  *
@@ -1088,14 +1268,23 @@ gint get_next_pid(TraceViewStore *store, struct pevent *pevent, struct record *r
 void trace_view_store_filter_tasks(TraceViewStore *store, struct filter_task *filter)
 {
         struct tracecmd_input *handle;
+        struct event_format *event;
         struct pevent *pevent;
         struct record *record;
+        gint last_event_id = -1;
+        gint event_id;
         gint pid;
         gint cpu;
         gint i;
 
         g_return_if_fail (TRACE_VIEW_IS_LIST (store));
 
+        /* We may pass in the store->task_filter. Don't free it if we do */
+        if (store->task_filter && store->task_filter != filter)
+                filter_task_hash_free(store->task_filter);
+
+        store->task_filter = filter_task_hash_copy(filter);
+
         handle = store->handle;
         pevent = tracecmd_get_pevent(store->handle);
 
@@ -1115,7 +1304,22 @@ void trace_view_store_filter_tasks(TraceViewStore *store, struct filter_task *fi
 
                         g_assert(record->offset == store->cpu_list[cpu][i].offset);
 
-                        /* TODO: put event filter check here */
+                        /* The record may be filtered by the events */
+                        if (!store->all_events) {
+                                event_id = pevent_data_type(pevent, record);
+                                if (last_event_id != event_id) {
+                                        /* optimize: only search event when new */
+                                        event = pevent_find_event(pevent, event_id);
+                                        g_assert(event);
+                                }
+                                last_event_id = event_id;
+                                if (!trace_view_store_system_enabled(store, event->system) &&
+                                    !trace_view_store_event_enabled(store, event_id)) {
+                                        store->cpu_list[cpu][i].visible = 0;
+                                        goto skip;
+                                }
+                        }
+
                         pid = pevent_data_pid(pevent, record);
                         if (!filter || filter_task_find_pid(filter, pid))
                                 store->cpu_list[cpu][i].visible = 1;
@@ -1133,6 +1337,7 @@ void trace_view_store_filter_tasks(TraceViewStore *store, struct filter_task *fi
                                 store->cpu_list[cpu][i].visible = 0;
                         }
 
+ skip:
                         free_record(record);
                         record = tracecmd_read_data(handle, cpu);
                 }
@@ -1142,6 +1347,14 @@ void trace_view_store_filter_tasks(TraceViewStore *store, struct filter_task *fi
         merge_sort_rows_ts(store);
 }
 
+void trace_view_store_update_filter(TraceViewStore *store)
+{
+        g_return_if_fail (TRACE_VIEW_IS_LIST (store));
+
+        trace_view_store_filter_tasks(store, store->task_filter);
+}
+
+
 /*****************************************************************************
  *
  *      trace_view_store_append_record: Empty lists are boring. This function can
diff --git a/trace-view-store.h b/trace-view-store.h
index bfa19d9..f6825bc 100644
--- a/trace-view-store.h
+++ b/trace-view-store.h
@@ -94,7 +94,10 @@ struct trace_view_store
         gint                    all_events; /* set 1 when all events are enabled */
                                                 /* else */
         gchar                   **systems;  /* sorted list of systems that are enabled */
-        gint                    **event_types; /* sorted list of events that are enabled */
+        gint                    *event_types; /* sorted list of events that are enabled */
+        gint                    systems_size; /* size of systems array */
+        gint                    event_types_size; /* size of event_types array */
+        struct filter_task      *task_filter;   /* hash of tasks to filter on */
 
         gint                    all_cpus;   /* set 1 when all cpus are enabled */
                                                 /* else */
@@ -125,7 +128,19 @@ void trace_view_store_filter_tasks(TraceViewStore *store, struct filter_task *fi
 
 TraceViewRecord *trace_view_store_get_row(TraceViewStore *store, gint row);
 
-/* TraceViewStore methos */
+gboolean trace_view_store_system_enabled(TraceViewStore *store, const gchar *system);
+
+gboolean trace_view_store_event_enabled(TraceViewStore *store, gint event_id);
+
+void trace_view_store_set_all_events_enabled(TraceViewStore *store);
+
+void trace_view_store_set_system_enabled(TraceViewStore *store, const gchar *system);
+
+void trace_view_store_set_event_enabled(TraceViewStore *store, gint event_id);
+
+void trace_view_store_update_filter(TraceViewStore *store);
+
+/* TraceViewStore methods */
 GtkTreeModelFlags trace_view_store_get_flags    (GtkTreeModel   *tree_model);
 
 gint trace_view_store_get_n_columns     (GtkTreeModel   *tree_model);
@@ -191,4 +206,23 @@ static inline GtkWidget *trace_view_store_get_spin(TraceViewStore *store)
         return store->spin;
 }
 
+static inline gboolean trace_view_store_get_all_events_enabled(TraceViewStore *store)
+{
+        g_return_val_if_fail (TRACE_VIEW_IS_LIST (store), FALSE);
+        return store->all_events;
+}
+
+static inline gchar **trace_view_store_get_systems_enabled(TraceViewStore *store)
+{
+        g_return_val_if_fail (TRACE_VIEW_IS_LIST (store), NULL);
+        return store->systems;
+}
+
+static inline gint *trace_view_store_get_events_enabled(TraceViewStore *store)
+{
+        g_return_val_if_fail (TRACE_VIEW_IS_LIST (store), NULL);
+        return store->event_types;
+}
+
+
 #endif /* _trace_view_store_h_included_ */