trace-graph: Add task filtering popup menus

Add popup menus to graph that allows the use to add or remove
tasks from the filter, as well as to enable or disable the filter.

This only adds the popup menus, the filtering is not actually done yet.

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

4 files changed, 310 insertions, 16 deletions

diff --git a/trace-compat.c b/trace-compat.c
index 9c1d7e3..118a826 100644
--- a/trace-compat.c
+++ b/trace-compat.c
@@ -2,6 +2,9 @@
 
 #if GTK_VERSION < CALC_GTK_VERSION(2,18,0)
 
+#warning Using compat functions for older GTK library
+#warning Please upgrade your GTK to at least 2.18
+
 void gtk_cell_renderer_get_padding(GtkCellRenderer *cell,
                                    gint *xpad, gint *ypad)
 {
@@ -13,6 +16,20 @@ void gtk_cell_renderer_get_padding(GtkCellRenderer *cell,
 
 #endif /* version < 2.18.0 */
 
+#if GTK_VERSION < CALC_GTK_VERSION(2,16,0)
+
+void gtk_menu_item_set_label(GtkMenuItem *menu_item, const gchar *label)
+{
+        g_return_if_fail(GTK_IS_MENU_ITEM(menu_item));
+
+        if (GTK_IS_LABEL(GTK_BIN(menu_item)->child)) {
+                gtk_label_set_label(GTK_LABEL(GTK_BIN(menu_item)->child),
+                                    label ? label : "");
+        }
+}
+
+#endif /* version < 2.18.0 */
+
 #if GTK_VERSION < CALC_GTK_VERSION(2,14,0)
 
 gdouble gtk_adjustment_get_page_size(GtkAdjustment *adj)
diff --git a/trace-compat.h b/trace-compat.h
index 381fc6c..8f8ad11 100644
--- a/trace-compat.h
+++ b/trace-compat.h
@@ -12,6 +12,12 @@ void gtk_cell_renderer_get_padding(GtkCellRenderer *cell,
 
 #endif /* version < 2.18.0 */
 
+#if GTK_VERSION < CALC_GTK_VERSION(2,16,0)
+
+void gtk_menu_item_set_label(GtkMenuItem *menu_item, const gchar *label);
+
+#endif /* version < 2.18.0 */
+
 #if GTK_VERSION < CALC_GTK_VERSION(2,14,0)
 
 gdouble gtk_adjustment_get_page_size(GtkAdjustment *adj);
diff --git a/trace-graph.c b/trace-graph.c
index b70e27d..504eb36 100644
--- a/trace-graph.c
+++ b/trace-graph.c
@@ -55,12 +55,20 @@
 #define CPU_LABEL(cpu) (CPU_TOP(cpu))
 #define CPU_X           5
 
+#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 gint do_hash(gint val);
 
 static void convert_nano(unsigned long long time, unsigned long *sec,
                          unsigned long *usec)
@@ -80,6 +88,87 @@ 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)
+{
+        gint key = do_hash(pid) % FILTER_TASK_HASH_SIZE;
+        struct filter_task *task = ginfo->filter_task_hash[key];
+
+        while (task) {
+                if (task->pid == pid)
+                        break;
+                task = task->next;
+        }
+        return task;
+}
+
+static void filter_task_add_pid(struct graph_info *ginfo, gint pid)
+{
+        gint key = do_hash(pid) % FILTER_TASK_HASH_SIZE;
+        struct filter_task *task;
+
+        task = g_new0(typeof(*task), 1);
+        g_assert(task);
+
+        task->pid = pid;
+        task->next = ginfo->filter_task_hash[key];
+        ginfo->filter_task_hash[key] = task;
+
+        ginfo->filter_task_count++;
+        ginfo->filter_available = 1;
+}
+
+static void filter_task_remove_pid(struct graph_info *ginfo, gint pid)
+{
+        gint key = do_hash(pid) % FILTER_TASK_HASH_SIZE;
+        struct filter_task **next = &ginfo->filter_task_hash[key];
+        struct filter_task *task;
+
+        while (*next) {
+                if ((*next)->pid == pid)
+                        break;
+                next = &(*next)->next;
+        }
+        if (!*next)
+                return;
+
+        task = *next;
+
+        *next = task->next;
+
+        g_free(task);
+
+        if (--ginfo->filter_task_count)
+                return;
+
+        ginfo->filter_available = 0;
+}
+
+static void filter_task_clear(struct graph_info *ginfo)
+{
+        struct filter_task *task, *next;;
+        gint i;
+
+        if (!ginfo->filter_task_count)
+                return;
+
+        for (i = 0; i < FILTER_TASK_HASH_SIZE; i++) {
+                next = ginfo->filter_task_hash[i];
+                if (!next)
+                        continue;
+
+                ginfo->filter_task_hash[i] = NULL;
+                while (next) {
+                        task = next;
+                        next = task->next;
+                        g_free(task);
+                }
+        }
+
+        ginfo->filter_task_count = 0;
+        ginfo->filter_available = 0;
+}
+
 static void __update_with_backend(struct graph_info *ginfo,
                                 gint x, gint y,
                                 gint width, gint height)
@@ -146,16 +235,188 @@ static void clear_last_line(GtkWidget *widget, struct graph_info *ginfo)
         update_with_backend(ginfo, x, 0, x+2, widget->allocation.height);
 }
 
+static struct record *
+find_record_on_cpu(struct graph_info *ginfo, gint cpu, guint64 time)
+{
+        struct record *record = NULL;
+        guint64 offset = 0;
+
+        tracecmd_set_cpu_to_timestamp(ginfo->handle, cpu, time);
+        do {
+                if (record) {
+                        offset = record->offset;
+                        free_record(record);
+                }
+                record = tracecmd_read_data(ginfo->handle, cpu);
+        } while (record && record->ts <= (time - 1 / ginfo->resolution));
+
+        if (record) {
+
+                if (record->ts > (time + 1 / ginfo->resolution) && offset) {
+                        dprintf(3, "old ts = %llu!\n", record->ts);
+                        free_record(record);
+                        record = tracecmd_read_at(ginfo->handle, offset, NULL);
+                }
+        }
+
+        return record;
+}
+
+static void
+filter_enable_clicked (gpointer data)
+{
+        struct graph_info *ginfo = data;
+
+        ginfo->filter_enabled ^= 1;
+}
+
+static void
+filter_add_task_clicked (gpointer data)
+{
+        struct graph_info *ginfo = data;
+        struct filter_task *task;
+
+        task = filter_task_find_pid(ginfo, ginfo->filter_task_selected);
+
+        if (task)
+                filter_task_remove_pid(ginfo, task->pid);
+        else
+                filter_task_add_pid(ginfo, ginfo->filter_task_selected);
+}
+
+static void
+filter_clear_tasks_clicked (gpointer data)
+{
+        struct graph_info *ginfo = data;
+
+        filter_task_clear(ginfo);
+}
+
+static gboolean
+do_pop_up(GtkWidget *widget, GdkEventButton *event, gpointer data)
+{
+        struct graph_info *ginfo = data;
+        static GtkWidget *menu;
+        static GtkWidget *menu_filter_enable;
+        static GtkWidget *menu_filter_add_task;
+        static GtkWidget *menu_filter_clear_tasks;
+        struct record *record = NULL;
+        const char *comm;
+        guint64 time;
+        gchar *text;
+        gint pid;
+        gint len;
+        gint x, y;
+        gint cpu;
+
+        x = event->x;
+        y = event->y;
+
+        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);
+
+        }
+
+        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);
+
+        time =  (x / ginfo->resolution) + ginfo->view_start_time;
+
+        for (cpu = 0; cpu < ginfo->cpus; cpu++) {
+                if (y >= (CPU_TOP(cpu) - CPU_GIVE) &&
+                    y <= (CPU_BOTTOM(cpu) + CPU_GIVE)) {
+                        record = find_record_on_cpu(ginfo, cpu, time);
+                        break;
+                }
+        }
+
+        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 (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);
+
+                gtk_widget_set_sensitive(menu_filter_add_task, TRUE);
+
+                free_record(record);
+        } else {
+                gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_add_task),
+                                        "Add task to filter");
+                gtk_widget_set_sensitive(menu_filter_add_task, 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)
 {
         struct graph_info *ginfo = data;
 
+        if (event->button == 3)
+                return do_pop_up(widget, event, data);
+
         if (event->button != 1)
                 return TRUE;
 
         /* check for double click */
-        if (event->type==GDK_2BUTTON_PRESS) {
+        if (event->type == GDK_2BUTTON_PRESS) {
                 if (ginfo->line_active) {
                         ginfo->line_active = FALSE;
                         clear_last_line(widget, ginfo);
@@ -309,22 +570,10 @@ static void draw_cpu_info(struct graph_info *ginfo, gint cpu, gint x, gint y)
         trace_seq_init(&s);
 
         dprintf(3, "start=%zu end=%zu time=%lu\n", ginfo->start_time, ginfo->end_time, time);
-        tracecmd_set_cpu_to_timestamp(ginfo->handle, cpu, time);
-        do {
-                if (record) {
-                        offset = record->offset;
-                        free_record(record);
-                }
-                record = tracecmd_read_data(ginfo->handle, cpu);
-        } while (record && record->ts <= (time - 1 / ginfo->resolution));
 
-        if (record) {
+        record = find_record_on_cpu(ginfo, cpu, time);
 
-                if (record->ts > (time + 1 / ginfo->resolution) && offset) {
-                        dprintf(3, "old ts = %llu!\n", record->ts);
-                        free_record(record);
-                        record = tracecmd_read_at(ginfo->handle, offset, NULL);
-                }
+        if (record) {
 
                 if (!check_sched_switch(ginfo, record, &pid, &comm)) {
                         pid = pevent_data_pid(ginfo->pevent, record);
@@ -763,10 +1012,19 @@ static gint do_hash(gint val)
         return hash;
 }
 
+static gint hash_pid(gint val)
+{
+        /* idle always gets black */
+        if (!val)
+                return 0;
+
+        return do_hash(val);
+}
+
 static void set_color_by_pid(GtkWidget *widget, GdkGC *gc, gint pid)
 {
         GdkColor color;
-        gint hash = do_hash(pid);
+        gint hash = hash_pid(pid);
         static gint last_pid = -1;
 
         if (!(hash & 0xffffff) && last_pid != pid) {
@@ -1317,6 +1575,9 @@ trace_graph_create_with_callbacks(struct tracecmd_input *handle,
         ginfo->start_time = -1ULL;
         ginfo->end_time = 0;
 
+        ginfo->filter_task_hash = g_new0(typeof(*ginfo->filter_task_hash),
+                                         FILTER_TASK_HASH_SIZE);
+
         ginfo->widget = gtk_hbox_new(FALSE, 0);
         gtk_widget_show(ginfo->widget);
 
diff --git a/trace-graph.h b/trace-graph.h
index a9d7293..a3d3901 100644
--- a/trace-graph.h
+++ b/trace-graph.h
@@ -11,6 +11,8 @@ struct graph_callbacks {
         graph_select_cb         *select;
 };
 
+struct filter_task;
+
 struct graph_info {
         struct tracecmd_input   *handle;
         struct pevent           *pevent;
@@ -47,6 +49,14 @@ struct graph_info {
 
         struct graph_callbacks  *callbacks;     /* call back hooks for changes to graph */
 
+        int                     filter_enabled;
+        int                     filter_available;
+
+        struct filter_task      **filter_task_hash;
+        gint                    filter_task_count;
+        gint                    filter_task_selected;
+
+
         /* Box info for CPU data info window */
         gint                    cpu_data_x;
         gint                    cpu_data_y;