kernel-shark: Enabled filtering of tasks for list and graph

The list and graph can now filter tasks.

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

7 files changed, 201 insertions, 19 deletions

diff --git a/Makefile b/Makefile
index de83e44..46f47ed 100644
--- a/Makefile
+++ b/Makefile
@@ -28,7 +28,7 @@ all: $(TARGETS)
 
 LIB_FILE = libtracecmd.a
 
-HEADERS = parse-events.h trace-cmd.h trace-local.h
+HEADERS = parse-events.h trace-cmd.h trace-local.h trace-hash.h
 
 trace-read.o::          $(HEADERS) 
 trace-cmd.o::           $(HEADERS) $(LIB_FILE)
@@ -43,7 +43,8 @@ trace-graph.o::		$(HEADERS) trace-graph.h
 trace-graph-main.o::    $(HEADERS) trace-graph.h
 kernel-shark.o::        $(HEADERS) kernel-shark.h
 
-TRACE_VIEW_OBJS = trace-view.o trace-view-store.o trace-filter.o trace-compat.o
+TRACE_VIEW_OBJS = trace-view.o trace-view-store.o trace-filter.o trace-compat.o \
+        trace-hash.o
 
 trace-cmd:: trace-cmd.o trace-read.o
         $(CC) $^ -rdynamic -o $@ $(LIBS)
diff --git a/kernel-shark.c b/kernel-shark.c
index 9cbc45a..fbc5a5f 100644
--- a/kernel-shark.c
+++ b/kernel-shark.c
@@ -156,7 +156,7 @@ static void row_double_clicked(GtkTreeView        *treeview,
 }
 
 static void
-filter_enable_clicked (gpointer data)
+filter_graph_enable_clicked (gpointer data)
 {
         struct shark_info *info = data;
 
@@ -164,11 +164,36 @@ filter_enable_clicked (gpointer data)
 }
 
 static void
+filter_list_enable_clicked (gpointer data)
+{
+        struct shark_info *info = data;
+
+        info->list_filter_enabled ^= 1;
+
+        if (info->list_filter_enabled)
+                trace_view_update_task_filter(info->treeview,
+                                              info->ginfo->task_filter);
+        else
+                trace_view_update_task_filter(info->treeview, NULL);
+}
+
+static void
 filter_add_task_clicked (gpointer data)
 {
         struct shark_info *info = data;
 
         trace_graph_filter_add_remove_task(info->ginfo, info->selected_task);
+
+        if (info->list_filter_enabled) {
+                if (filter_task_count(info->ginfo->task_filter))
+                        trace_view_update_task_filter(info->treeview,
+                                                      info->ginfo->task_filter);
+                else
+                        trace_view_update_task_filter(info->treeview, NULL);
+        }
+
+        if (!filter_task_count(info->ginfo->task_filter))
+                info->list_filter_enabled = 0;
 }
 
 static void
@@ -177,6 +202,11 @@ filter_clear_tasks_clicked (gpointer data)
         struct shark_info *info = data;
 
         trace_graph_clear_tasks(info->ginfo);
+
+        if (info->list_filter_enabled)
+                trace_view_update_task_filter(info->treeview, NULL);
+
+        info->list_filter_enabled = 0;
 }
 
 static gboolean
@@ -185,7 +215,8 @@ do_tree_popup(GtkWidget *widget, GdkEventButton *event, gpointer data)
         struct shark_info *info = data;
         struct graph_info *ginfo = info->ginfo;
         static GtkWidget *menu;
-        static GtkWidget *menu_filter_enable;
+        static GtkWidget *menu_filter_graph_enable;
+        static GtkWidget *menu_filter_list_enable;
         static GtkWidget *menu_filter_add_task;
         static GtkWidget *menu_filter_clear_tasks;
         struct record *record;
@@ -205,12 +236,20 @@ do_tree_popup(GtkWidget *widget, GdkEventButton *event, gpointer data)
 
         if (!menu) {
                 menu = gtk_menu_new();
-                menu_filter_enable = gtk_menu_item_new_with_label("Enable Filter");
-                gtk_widget_show(menu_filter_enable);
-                gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_enable);
+                menu_filter_graph_enable = gtk_menu_item_new_with_label("Enable Graph Filter");
+                gtk_widget_show(menu_filter_graph_enable);
+                gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_graph_enable);
 
-                g_signal_connect_swapped (G_OBJECT (menu_filter_enable), "activate",
-                                          G_CALLBACK (filter_enable_clicked),
+                g_signal_connect_swapped (G_OBJECT (menu_filter_graph_enable), "activate",
+                                          G_CALLBACK (filter_graph_enable_clicked),
+                                          data);
+
+                menu_filter_list_enable = gtk_menu_item_new_with_label("Enable List Filter");
+                gtk_widget_show(menu_filter_list_enable);
+                gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_list_enable);
+
+                g_signal_connect_swapped (G_OBJECT (menu_filter_list_enable), "activate",
+                                          G_CALLBACK (filter_list_enable_clicked),
                                           data);
 
                 menu_filter_add_task = gtk_menu_item_new_with_label("Add Task");
@@ -276,16 +315,26 @@ do_tree_popup(GtkWidget *widget, GdkEventButton *event, gpointer data)
                 gtk_widget_hide(menu_filter_add_task);
 
         if (ginfo->filter_enabled)
-                gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_enable),
-                                        "Disable Filter");
+                gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_graph_enable),
+                                        "Disable Graph Filter");
         else
-                gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_enable),
-                                        "Enable Filter");
+                gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_graph_enable),
+                                        "Enable Graph Filter");
 
-        if (ginfo->filter_available)
-                gtk_widget_set_sensitive(menu_filter_enable, TRUE);
+        if (info->list_filter_enabled)
+                gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_list_enable),
+                                        "Disable List Filter");
         else
-                gtk_widget_set_sensitive(menu_filter_enable, FALSE);
+                gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_list_enable),
+                                        "Enable List Filter");
+
+        if (ginfo->filter_available) {
+                gtk_widget_set_sensitive(menu_filter_graph_enable, TRUE);
+                gtk_widget_set_sensitive(menu_filter_list_enable, TRUE);
+        } else {
+                gtk_widget_set_sensitive(menu_filter_graph_enable, FALSE);
+                gtk_widget_set_sensitive(menu_filter_list_enable, FALSE);
+        }
 
         if (filter_task_count(ginfo->task_filter))
                 gtk_widget_set_sensitive(menu_filter_clear_tasks, TRUE);
diff --git a/kernel-shark.h b/kernel-shark.h
index 59d7b7a..34b2031 100644
--- a/kernel-shark.h
+++ b/kernel-shark.h
@@ -11,6 +11,7 @@ struct shark_info {
         GtkWidget                       *treeview;
         struct graph_callbacks          graph_cbs;
         gint                            selected_task;
+        gboolean                        list_filter_enabled;
 };
 
 #define offset_of(type, field)          (long)(&((type *)0)->field)
diff --git a/trace-view-store.c b/trace-view-store.c
index 04debbb..1f1e952 100644
--- a/trace-view-store.c
+++ b/trace-view-store.c
@@ -1075,6 +1075,43 @@ guint64 trace_view_store_get_offset_from_row(TraceViewStore *store, gint row)
         return store->rows[row]->offset;
 }
 
+void trace_view_store_filter_tasks(TraceViewStore *store, struct filter_task *filter)
+{
+        struct tracecmd_input *handle;
+        struct pevent *pevent;
+        struct record *record;
+        gint pid;
+        gint cpu;
+        gint i;
+
+        g_return_if_fail (TRACE_VIEW_IS_LIST (store));
+
+        handle = store->handle;
+        pevent = tracecmd_get_pevent(store->handle);
+
+        for (cpu = 0; cpu < store->cpus; cpu++) {
+                record = tracecmd_read_cpu_first(handle, cpu);
+
+                for (i = 0; i < store->cpu_items[cpu]; i++) {
+
+                        g_assert(record->offset == store->cpu_list[cpu][i].offset);
+
+                        /* TODO: put event filter check here */
+                        pid = pevent_data_pid(pevent, record);
+                        if (!filter || filter_task_find_pid(filter, pid))
+                                store->cpu_list[cpu][i].visible = 1;
+                        else
+                                store->cpu_list[cpu][i].visible = 0;
+
+                        free_record(record);
+                        record = tracecmd_read_data(handle, cpu);
+                }
+                g_assert(record == NULL);
+        }
+
+        merge_sort_rows_ts(store);
+}
+
 /*****************************************************************************
  *
  *      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 687a946..c7738da 100644
--- a/trace-view-store.h
+++ b/trace-view-store.h
@@ -3,6 +3,7 @@
 
 #include <gtk/gtk.h>
 #include "trace-cmd.h"
+#include "trace-hash.h"
 
 /* Some boilerplate GObject defines. 'klass' is used
  *   instead of 'class', because 'class' is a C++ keyword */
@@ -118,6 +119,8 @@ guint64 trace_view_store_get_time_from_row(TraceViewStore *store, gint row);
 
 guint64 trace_view_store_get_offset_from_row(TraceViewStore *store, gint row);
 
+void trace_view_store_filter_tasks(TraceViewStore *store, struct filter_task *filter);
+
 /* TraceViewStoreClass: more boilerplate GObject stuff */
 
 struct _TraceViewStoreClass
diff --git a/trace-view.c b/trace-view.c
index 6dd72ee..f9083f4 100644
--- a/trace-view.c
+++ b/trace-view.c
@@ -207,6 +207,96 @@ trace_view_load(GtkWidget *view, struct tracecmd_input *handle,
         g_object_unref(model); /* destroy model automatically with view */
 }
 
+/**
+ * trace_view_get_selected_row - return the selected row
+ * @treeview: The tree view
+ *
+ * Returns the selected row number (or -1 if none is selected)
+ */
+gint trace_view_get_selected_row(GtkWidget *treeview)
+{
+        GtkTreeView *tree = GTK_TREE_VIEW(treeview);
+        GtkTreeSelection *selection;
+        GtkTreeModel *model;
+        GtkTreePath *path;
+        gchar *spath;
+        GList *glist;
+        gint row;
+
+        model = gtk_tree_view_get_model(tree);
+        if (!model)
+                return -1;
+
+        selection = gtk_tree_view_get_selection(tree);
+        glist = gtk_tree_selection_get_selected_rows(selection, &model);
+        if (!glist)
+                return -1;
+
+        /* Only one row may be selected */
+        path = glist->data;
+        spath = gtk_tree_path_to_string(path);
+        row = atoi(spath);
+        g_free(spath);
+
+        gtk_tree_path_free(path);
+        g_list_free(glist);
+
+        return row;
+}
+
+void trace_view_make_selection_visible(GtkWidget *treeview)
+{
+        GtkTreeView *tree = GTK_TREE_VIEW(treeview);
+        GtkTreePath *path;
+        gchar *spath;
+        GString *gstr;
+        gint row;
+
+        row = trace_view_get_selected_row(treeview);
+        if (row < 0)
+                return;
+
+        gstr = g_string_new("");
+        g_string_printf(gstr, "%d", row);
+        spath = g_string_free(gstr, FALSE);
+
+        path = gtk_tree_path_new_from_string(spath);
+        g_free(spath);
+
+        gtk_tree_view_scroll_to_cell(tree, path, NULL, TRUE, 0.5, 0.0);
+
+        gtk_tree_path_free(path);
+}
+
+void trace_view_update_task_filter(GtkWidget *treeview, struct filter_task *filter)
+{
+        GtkTreeView *tree = GTK_TREE_VIEW(treeview);
+        GtkTreeModel *model;
+        guint64 time;
+        gint row;
+
+        model = gtk_tree_view_get_model(tree);
+        if (!model)
+                return;
+
+        /* Keep track of the currently selected row */
+        row = trace_view_get_selected_row(treeview);
+        if (row >= 0)
+                time = trace_view_store_get_time_from_row(TRACE_VIEW_STORE(model), row);
+
+        g_object_ref(model);
+        gtk_tree_view_set_model(tree, NULL);
+
+        trace_view_store_filter_tasks(TRACE_VIEW_STORE(model), filter);
+
+        gtk_tree_view_set_model(tree, model);
+        g_object_unref(model);
+
+        /* Keep selection near previous selection */
+        if (row >= 0)
+                trace_view_select(treeview, time);
+}
+
 void trace_view_select(GtkWidget *treeview, guint64 time)
 {
         GtkTreeView *tree = GTK_TREE_VIEW(treeview);
@@ -251,9 +341,8 @@ void trace_view_select(GtkWidget *treeview, guint64 time)
 
         selection = gtk_tree_view_get_selection(tree);
         gtk_tree_selection_select_path(selection, path);
+        gtk_tree_path_free(path);
 
         /* finally, make it visible */
-        gtk_tree_view_scroll_to_cell(tree, path, NULL, TRUE, 0.5, 0.0);
-
-        gtk_tree_path_free(path);
+        trace_view_make_selection_visible(treeview);    
 }
diff --git a/trace-view.h b/trace-view.h
index 57662df..03d331c 100644
--- a/trace-view.h
+++ b/trace-view.h
@@ -9,6 +9,8 @@ trace_view_load(GtkWidget *view, struct tracecmd_input *handle,
 
 void trace_view(int argc, char **argv);
 
+void trace_view_update_task_filter(GtkWidget *treeview, struct filter_task *filter);
+void trace_view_make_selection_visible(GtkWidget *treeview);
 
 /* We use void because this can be used by non gtk files */
 void trace_filter_event_dialog(void *traceview);