9 files changed, 257 insertions, 55 deletions

diff --git a/Makefile b/Makefile
index e879e90..de83e44 100644
--- a/Makefile
+++ b/Makefile
@@ -51,10 +51,11 @@ trace-cmd:: trace-cmd.o trace-read.o
 trace-view:: trace-view-main.o $(TRACE_VIEW_OBJS)
         $(CC) $^ -rdynamic -o $@ $(CONFIG_LIBS) $(LIBS)
 
-trace-graph:: trace-graph-main.o trace-graph.o trace-compat.o
+trace-graph:: trace-graph-main.o trace-graph.o trace-compat.o trace-hash.o
         $(CC) $^ -rdynamic -o $@ $(CONFIG_LIBS) $(LIBS)
 
-kernelshark:: kernel-shark.o trace-compat.o $(TRACE_VIEW_OBJS) trace-graph.o
+kernelshark:: kernel-shark.o trace-compat.o $(TRACE_VIEW_OBJS) trace-graph.o \
+                trace-hash.o
         $(CC) $^ -rdynamic -o $@ $(CONFIG_LIBS) $(LIBS)
 
 .PHONY: gtk_depends
diff --git a/kernel-shark.c b/kernel-shark.c
index 6e1c206..6e92730 100644
--- a/kernel-shark.c
+++ b/kernel-shark.c
@@ -155,6 +155,158 @@ static void row_double_clicked(GtkTreeView        *treeview,
         trace_graph_select_by_time(info->ginfo, time);
 }
 
+static void
+filter_enable_clicked (gpointer data)
+{
+        struct shark_info *info = data;
+
+        trace_graph_filter_toggle(info->ginfo);
+}
+
+static void
+filter_add_task_clicked (gpointer data)
+{
+        struct shark_info *info = data;
+
+        trace_graph_filter_add_remove_task(info->ginfo, info->selected_task);
+}
+
+static void
+filter_clear_tasks_clicked (gpointer data)
+{
+        struct shark_info *info = data;
+
+        trace_graph_clear_tasks(info->ginfo);
+}
+
+static gboolean
+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_add_task;
+        static GtkWidget *menu_filter_clear_tasks;
+        struct record *record;
+        TraceViewStore *store;
+        GtkTreeSelection *selection;
+        GtkTreeModel *model;
+        GtkTreePath *path;
+        const char *comm;
+        gchar *text;
+        gint pid;
+        gint len;
+        GList *glist;
+        gchar *spath;
+        guint64 offset;
+        gint row;
+        gint cpu;
+
+        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);
+
+                g_signal_connect_swapped (G_OBJECT (menu_filter_enable), "activate",
+                                          G_CALLBACK (filter_enable_clicked),
+                                          data);
+
+                menu_filter_add_task = gtk_menu_item_new_with_label("Add Task");
+                gtk_widget_show(menu_filter_add_task);
+                gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_add_task);
+
+                g_signal_connect_swapped (G_OBJECT (menu_filter_add_task), "activate",
+                                          G_CALLBACK (filter_add_task_clicked),
+                                          data);
+
+                menu_filter_clear_tasks = gtk_menu_item_new_with_label("Clear Task Filter");
+                gtk_widget_show(menu_filter_clear_tasks);
+                gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_clear_tasks);
+
+                g_signal_connect_swapped (G_OBJECT (menu_filter_clear_tasks), "activate",
+                                          G_CALLBACK (filter_clear_tasks_clicked),
+                                          data);
+
+        }
+
+        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(info->treeview));
+        glist = gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(selection), NULL);
+        if (glist) {
+                path = glist->data;
+                g_list_free(glist);
+                spath = gtk_tree_path_to_string(path);
+                gtk_tree_path_free(path);
+                row = atoi(spath);
+                g_free(spath);
+
+                model = gtk_tree_view_get_model(GTK_TREE_VIEW(info->treeview));
+                store = TRACE_VIEW_STORE(model);
+                offset = trace_view_store_get_offset_from_row(store, row);
+
+                record = tracecmd_read_at(info->handle, offset, &cpu);
+
+                if (record) {
+                        pid = pevent_data_pid(ginfo->pevent, record);
+                        comm = pevent_data_comm_from_pid(ginfo->pevent, pid);
+
+                        len = strlen(comm) + 50;
+
+                        text = g_malloc(len);
+                        g_assert(text);
+
+                        if (trace_graph_filter_task_find_pid(ginfo, pid))
+                                snprintf(text, len, "Remove %s-%d to filter", comm, pid);
+                        else
+                                snprintf(text, len, "Add %s-%d to filter", comm, pid);
+
+                        ginfo->filter_task_selected = pid;
+
+                        gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_add_task),
+                                                text);
+                        g_free(text);
+
+                        info->selected_task = pid;
+
+                        gtk_widget_show(menu_filter_add_task);
+                        free_record(record);
+                }
+        } else
+                gtk_widget_hide(menu_filter_add_task);
+
+        if (ginfo->filter_enabled)
+                gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_enable),
+                                        "Disable Filter");
+        else
+                gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_enable),
+                                        "Enable Filter");
+
+        if (ginfo->filter_available)
+                gtk_widget_set_sensitive(menu_filter_enable, TRUE);
+        else
+                gtk_widget_set_sensitive(menu_filter_enable, FALSE);
+
+        if (ginfo->filter_task_count)
+                gtk_widget_set_sensitive(menu_filter_clear_tasks, TRUE);
+        else
+                gtk_widget_set_sensitive(menu_filter_clear_tasks, FALSE);
+                
+        gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 3,
+                       gtk_get_current_event_time());
+
+        return TRUE;
+}
+
+static gboolean
+button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
+{
+        if (event->button == 3)
+                return do_tree_popup(widget, event, data);
+
+        return FALSE;
+}
+
 void kernel_shark(int argc, char **argv)
 {
         struct tracecmd_input *handle;
@@ -362,6 +514,9 @@ void kernel_shark(int argc, char **argv)
 
         gtk_container_add(GTK_CONTAINER(scrollwin), info->treeview);
 
+        gtk_signal_connect(GTK_OBJECT(info->treeview), "button_press_event",
+                           (GtkSignalFunc) button_press_event, info);
+
         gtk_widget_show(info->treeview);
 
 
diff --git a/kernel-shark.h b/kernel-shark.h
index bf9e632..59d7b7a 100644
--- a/kernel-shark.h
+++ b/kernel-shark.h
@@ -10,6 +10,7 @@ struct shark_info {
         struct tracecmd_input           *handle;
         GtkWidget                       *treeview;
         struct graph_callbacks          graph_cbs;
+        gint                            selected_task;
 };
 
 #define offset_of(type, field)          (long)(&((type *)0)->field)
diff --git a/trace-graph.c b/trace-graph.c
index 54ea8ea..1641d97 100644
--- a/trace-graph.c
+++ b/trace-graph.c
@@ -29,6 +29,7 @@
 #include "trace-cmd.h"
 #include "trace-local.h"
 #include "trace-graph.h"
+#include "trace-hash.h"
 
 #define DEBUG_LEVEL     2
 #if DEBUG_LEVEL > 0
@@ -57,18 +58,12 @@
 
 #define FILTER_TASK_HASH_SIZE   256
 
-struct filter_task {
-        struct filter_task      *next;
-        gint                    pid;
-};
-
 static gint ftrace_sched_switch_id = -1;
 static gint event_sched_switch_id = -1;
 
 static gint largest_cpu_label = 0;
 
 static void redraw_pixmap_backend(struct graph_info *ginfo);
-static guint do_hash(gint val);
 
 static void convert_nano(unsigned long long time, unsigned long *sec,
                          unsigned long *usec)
@@ -88,10 +83,10 @@ static void print_time(unsigned long long time)
         printf("%lu.%06lu", sec, usec);
 }
 
-static struct filter_task *
-filter_task_find_pid(struct graph_info *ginfo, gint pid)
+struct filter_task *
+trace_graph_filter_task_find_pid(struct graph_info *ginfo, gint pid)
 {
-        gint key = do_hash(pid) % FILTER_TASK_HASH_SIZE;
+        gint key = trace_hash(pid) % FILTER_TASK_HASH_SIZE;
         struct filter_task *task = ginfo->filter_task_hash[key];
 
         while (task) {
@@ -104,7 +99,7 @@ filter_task_find_pid(struct graph_info *ginfo, gint pid)
 
 static void filter_task_add_pid(struct graph_info *ginfo, gint pid)
 {
-        gint key = do_hash(pid) % FILTER_TASK_HASH_SIZE;
+        gint key = trace_hash(pid) % FILTER_TASK_HASH_SIZE;
         struct filter_task *task;
 
         task = g_new0(typeof(*task), 1);
@@ -120,7 +115,7 @@ static void filter_task_add_pid(struct graph_info *ginfo, gint pid)
 
 static void filter_task_remove_pid(struct graph_info *ginfo, gint pid)
 {
-        gint key = do_hash(pid) % FILTER_TASK_HASH_SIZE;
+        gint key = trace_hash(pid) % FILTER_TASK_HASH_SIZE;
         struct filter_task **next = &ginfo->filter_task_hash[key];
         struct filter_task *task;
 
@@ -178,7 +173,7 @@ gboolean filter_on_task(struct graph_info *ginfo, gint pid)
         
         if (ginfo->filter_enabled &&
             ginfo->filter_task_count &&
-            !filter_task_find_pid(ginfo, pid))
+            !trace_graph_filter_task_find_pid(ginfo, pid))
                 filter = TRUE;
 
         return filter;
@@ -288,37 +283,47 @@ find_record_on_cpu(struct graph_info *ginfo, gint cpu, guint64 time)
         return record;
 }
 
-static void
-filter_enable_clicked (gpointer data)
+void trace_graph_filter_toggle(struct graph_info *ginfo)
 {
-        struct graph_info *ginfo = data;
-
         ginfo->filter_enabled ^= 1;
 
         redraw_graph(ginfo);
 }
 
 static void
-filter_add_task_clicked (gpointer data)
+filter_enable_clicked (gpointer data)
 {
         struct graph_info *ginfo = data;
+
+        trace_graph_filter_toggle(ginfo);
+}
+
+void trace_graph_filter_add_remove_task(struct graph_info *ginfo,
+                                        gint pid)
+{
         struct filter_task *task;
 
-        task = filter_task_find_pid(ginfo, ginfo->filter_task_selected);
+        task = trace_graph_filter_task_find_pid(ginfo, pid);
 
         if (task)
                 filter_task_remove_pid(ginfo, task->pid);
         else
-                filter_task_add_pid(ginfo, ginfo->filter_task_selected);
+                filter_task_add_pid(ginfo, pid);
 
         if (ginfo->filter_enabled)
                 redraw_graph(ginfo);
 }
 
 static void
-filter_clear_tasks_clicked (gpointer data)
+filter_add_task_clicked (gpointer data)
 {
         struct graph_info *ginfo = data;
+
+        trace_graph_filter_add_remove_task(ginfo, ginfo->filter_task_selected);
+}
+
+void trace_graph_clear_tasks(struct graph_info *ginfo)
+{
         gint filter_enabled = ginfo->filter_enabled;
 
         filter_task_clear(ginfo);
@@ -327,6 +332,14 @@ filter_clear_tasks_clicked (gpointer data)
                 redraw_graph(ginfo);
 }
 
+static void
+filter_clear_tasks_clicked (gpointer data)
+{
+        struct graph_info *ginfo = data;
+
+        trace_graph_clear_tasks(ginfo);
+}
+
 static gboolean
 do_pop_up(GtkWidget *widget, GdkEventButton *event, gpointer data)
 {
@@ -411,7 +424,7 @@ do_pop_up(GtkWidget *widget, GdkEventButton *event, gpointer data)
                 text = g_malloc(len);
                 g_assert(text);
 
-                if (filter_task_find_pid(ginfo, pid))
+                if (trace_graph_filter_task_find_pid(ginfo, pid))
                         snprintf(text, len, "Remove %s-%d to filter", comm, pid);
                 else
                         snprintf(text, len, "Add %s-%d to filter", comm, pid);
@@ -1017,43 +1030,13 @@ button_release_event(GtkWidget *widget, GdkEventMotion *event, gpointer data)
         return TRUE;
 }
 
-static guint do_hash(gint val)
-{
-        int hash, tmp;
-
-        /* idle always gets black */
-        if (!val)
-                return 0;
-
-        hash = 12546869;        /* random prime */
-
-        /*
-         * The following hash is based off of Paul Hsieh's super fast hash:
-         *  http://www.azillionmonkeys.com/qed/hash.html
-         */
-
-        hash += (val & 0xffff);
-        tmp = (val >> 16) ^ hash;
-        hash = (hash << 16) ^ tmp;
-        hash += hash >> 11;
-
-        hash ^= hash << 3;
-        hash += hash >> 5;
-        hash ^= hash << 4;
-        hash += hash >> 17;
-        hash ^= hash << 25;
-        hash += hash >> 6;
-
-        return hash;
-}
-
 static gint hash_pid(gint val)
 {
         /* idle always gets black */
         if (!val)
                 return 0;
 
-        return do_hash(val);
+        return trace_hash(val);
 }
 
 static void set_color_by_pid(GtkWidget *widget, GdkGC *gc, gint pid)
diff --git a/trace-graph.h b/trace-graph.h
index a3d3901..ac52003 100644
--- a/trace-graph.h
+++ b/trace-graph.h
@@ -11,7 +11,10 @@ struct graph_callbacks {
         graph_select_cb         *select;
 };
 
-struct filter_task;
+struct filter_task {
+        struct filter_task      *next;
+        gint                    pid;
+};
 
 struct graph_info {
         struct tracecmd_input   *handle;
@@ -93,4 +96,11 @@ static inline GtkWidget *trace_graph_get_window(struct graph_info *ginfo)
         return ginfo->widget;
 }
 
+struct filter_task *
+trace_graph_filter_task_find_pid(struct graph_info *ginfo, gint pid);
+void trace_graph_filter_toggle(struct graph_info *ginfo);
+void trace_graph_filter_add_remove_task(struct graph_info *info,
+                                        gint pid);
+void trace_graph_clear_tasks(struct graph_info *ginfo);
+
 #endif /* _TRACE_GRAPH_H */
diff --git a/trace-hash.c b/trace-hash.c
new file mode 100644
index 0000000..9d830e2
--- /dev/null
+++ b/trace-hash.c
@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "trace-hash.h"
+
+guint trace_hash(gint val)
+{
+        gint hash, tmp;
+
+        hash = 12546869;        /* random prime */
+
+        /*
+         * The following hash is based off of Paul Hsieh's super fast hash:
+         *  http://www.azillionmonkeys.com/qed/hash.html
+         */
+
+        hash += (val & 0xffff);
+        tmp = (val >> 16) ^ hash;
+        hash = (hash << 16) ^ tmp;
+        hash += hash >> 11;
+
+        hash ^= hash << 3;
+        hash += hash >> 5;
+        hash ^= hash << 4;
+        hash += hash >> 17;
+        hash ^= hash << 25;
+        hash += hash >> 6;
+
+        return hash;
+}
diff --git a/trace-hash.h b/trace-hash.h
new file mode 100644
index 0000000..8a22044
--- /dev/null
+++ b/trace-hash.h
@@ -0,0 +1,8 @@
+#ifndef _TRACE_HASH_H
+#define _TRACE_HASH_H
+
+#include <glib.h>
+
+guint trace_hash(gint val);
+
+#endif /* _TRACE_HASH_H */
diff --git a/trace-view-store.c b/trace-view-store.c
index 6f7a46a..04debbb 100644
--- a/trace-view-store.c
+++ b/trace-view-store.c
@@ -1064,6 +1064,17 @@ guint64 trace_view_store_get_time_from_row(TraceViewStore *store, gint row)
         return store->rows[row]->timestamp;
 }
 
+guint64 trace_view_store_get_offset_from_row(TraceViewStore *store, gint row)
+{
+        g_return_val_if_fail (TRACE_VIEW_IS_LIST (store), 0);
+
+        row += store->start_row;
+
+        g_return_val_if_fail (row >= 0 && row < store->actual_rows, 0);
+
+        return store->rows[row]->offset;
+}
+
 /*****************************************************************************
  *
  *      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 35f1193..687a946 100644
--- a/trace-view-store.h
+++ b/trace-view-store.h
@@ -116,6 +116,8 @@ gint trace_view_store_get_timestamp_visible_row(TraceViewStore *store, guint64 t
 
 guint64 trace_view_store_get_time_from_row(TraceViewStore *store, gint row);
 
+guint64 trace_view_store_get_offset_from_row(TraceViewStore *store, gint row);
+
 /* TraceViewStoreClass: more boilerplate GObject stuff */
 
 struct _TraceViewStoreClass