kernelshark: Allow for separate list and graph task filters

To make the task filters more like the event filters, allow the
list and graph to have their own filtering.

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

5 files changed, 424 insertions, 47 deletions

diff --git a/kernel-shark.c b/kernel-shark.c
index b056420..e591657 100644
--- a/kernel-shark.c
+++ b/kernel-shark.c
@@ -64,6 +64,68 @@ void usage(char *prog)
         printf("  -i    input_file, default is %s\n", default_input_file);
 }
 
+/*
+ * trace_sync_select_menu - helper function to the syncing of list and graph filters
+ *
+ * Creates a pop up dialog with the selections given. The selections will be
+ * radio buttons to the user. The keep is a value that will be set to the check
+ * box (default on) if the user wants to keep the selection persistant.
+ */
+static int trace_sync_select_menu(const gchar *title,
+                                  gchar **selections, gboolean *keep)
+{
+        GtkWidget *dialog;
+        GtkWidget *radio;
+        GtkWidget *check;
+        GSList *group;
+        int result;
+        int i;
+
+        dialog = gtk_dialog_new_with_buttons(title,
+                                             NULL,
+                                             GTK_DIALOG_MODAL,
+                                             "OK", GTK_RESPONSE_ACCEPT,
+                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+                                             NULL);
+
+        radio = gtk_radio_button_new_with_label(NULL, selections[0]);
+        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), radio, TRUE, TRUE, 0);
+        gtk_widget_show(radio);
+
+        group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radio));
+
+        for (i = 1; selections[i]; i++) {
+                radio = gtk_radio_button_new_with_label(group, selections[i]);
+                gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), radio, TRUE, TRUE, 0);
+                gtk_widget_show(radio);
+        }
+
+        check = gtk_check_button_new_with_label("Keep the filters in sync?");
+        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), check, TRUE, TRUE, 0);
+        gtk_widget_show(check);
+
+        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
+
+        result = gtk_dialog_run(GTK_DIALOG(dialog));
+        switch (result) {
+        case GTK_RESPONSE_ACCEPT:
+                i = 0;
+                for (i = 0; group; i++, group = g_slist_next(group)) {
+                        radio = group->data;
+                        if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(radio)))
+                                break;
+                }
+                result = i;
+                *keep = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(check));
+                break;
+        default:
+                result = -1;
+        }
+
+        gtk_widget_destroy(dialog);
+        return result;
+}
+
 /* graph callbacks */
 
 /* convert_nano() and print_time() are copied from trace-graph.c for debugging
@@ -113,15 +175,30 @@ static void ks_graph_filter(struct graph_info *ginfo,
         cbs = trace_graph_get_callbacks(ginfo);
         info = container_of(cbs, struct shark_info, graph_cbs);
 
+        if (!info->sync_task_filters)
+                return;
+
         if (info->list_filter_enabled)
                 trace_view_update_filters(info->treeview,
                                           task_filter, hide_tasks);
+
+        if (filter_task_count(task_filter) ||
+            filter_task_count(hide_tasks))
+                info->list_filter_available = 1;
+        else {
+                info->list_filter_enabled = 0;
+                info->list_filter_available = 0;
+        }
 }
 
 static void free_info(struct shark_info *info)
 {
         tracecmd_close(info->handle);
         trace_graph_free_info(info->ginfo);
+
+        filter_task_hash_free(info->list_task_filter);
+        filter_task_hash_free(info->list_hide_tasks);
+
         free(info->ginfo);
         free(info);
 }
@@ -244,6 +321,99 @@ delete_event (GtkWidget *widget, GdkEvent *event, gpointer data)
 
 /* Callback for the clicked signal of the Events filter button */
 static void
+sync_task_filter_clicked (GtkWidget *subitem, gpointer data)
+{
+        struct shark_info *info = data;
+        struct filter_task *task_filter;
+        struct filter_task *hide_tasks;
+        GtkTreeView *trace_tree = GTK_TREE_VIEW(info->treeview);
+        GtkTreeModel *model;
+        TraceViewStore *store;
+        gboolean keep;
+        gchar *selections[] = { "Sync List Filter with Graph Filter",
+                                "Sync Graph Filter with List Filter",
+                                NULL };
+        int result;
+
+        if (info->sync_task_filters) {
+                /* Separate the List and Graph filters */
+
+                info->sync_task_filters = 0;
+                gtk_menu_item_set_label(GTK_MENU_ITEM(info->task_sync_menu),
+                                        "Sync Graph and List Task Filters");
+
+                /* The list now uses its own hash */
+                info->list_task_filter = filter_task_hash_copy(info->ginfo->task_filter);
+                info->list_hide_tasks = filter_task_hash_copy(info->ginfo->hide_tasks);
+                return;
+        }
+
+        model = gtk_tree_view_get_model(trace_tree);
+        if (!model)
+                return;
+
+        store = TRACE_VIEW_STORE(model);
+
+        /* Ask user which way to sync */
+        result = trace_sync_select_menu("Sync Task Filters",
+                                        selections, &keep);
+
+        switch (result) {
+        case 0:
+                /* Sync List Filter with Graph Filter */
+                filter_task_hash_free(info->list_task_filter);
+                filter_task_hash_free(info->list_hide_tasks);
+
+                info->list_task_filter = NULL;
+                info->list_hide_tasks = NULL;
+
+                task_filter = info->ginfo->task_filter;
+                hide_tasks = info->ginfo->hide_tasks;
+
+                if (!keep) {
+                        info->list_task_filter = filter_task_hash_copy(task_filter);
+                        info->list_hide_tasks = filter_task_hash_copy(hide_tasks);
+                }
+
+                if (info->list_filter_enabled)
+                        trace_view_update_filters(info->treeview,
+                                                  task_filter, hide_tasks);
+
+                if (!filter_task_count(task_filter) &&
+                    !filter_task_count(hide_tasks)) {
+                        info->list_filter_enabled = 0;
+                        info->list_filter_available = 0;
+                } else
+                        info->list_filter_available = 1;
+
+                break;
+        case 1:
+                /* Sync Graph Filter with List Filter */
+                trace_graph_update_filters(info->ginfo,
+                                           info->list_task_filter,
+                                           info->list_hide_tasks);
+
+                if (keep) {
+                        filter_task_hash_free(info->list_task_filter);
+                        filter_task_hash_free(info->list_hide_tasks);
+
+                        info->list_task_filter = NULL;
+                        info->list_hide_tasks = NULL;
+                }
+                break;
+        default:
+                keep = 0;
+        }
+
+        if (keep) {
+                info->sync_task_filters = 1;
+                gtk_menu_item_set_label(GTK_MENU_ITEM(info->task_sync_menu),
+                                        "Unsync Graph and List Task Filters");
+        }
+}
+
+/* Callback for the clicked signal of the Events filter button */
+static void
 list_events_clicked (gpointer data)
 {
         struct shark_info *info = data;
@@ -510,26 +680,70 @@ static void
 filter_list_enable_clicked (gpointer data)
 {
         struct shark_info *info = data;
+        struct filter_task *task_filter;
+        struct filter_task *hide_tasks;
 
         info->list_filter_enabled ^= 1;
 
+        if (info->sync_task_filters) {
+                task_filter = info->ginfo->task_filter;
+                hide_tasks = info->ginfo->hide_tasks;
+        } else {
+                task_filter = info->list_task_filter;
+                hide_tasks = info->list_hide_tasks;
+        }
+
         if (info->list_filter_enabled)
                 trace_view_update_filters(info->treeview,
-                                          info->ginfo->task_filter,
-                                          info->ginfo->hide_tasks);
+                                          task_filter, hide_tasks);
         else
                 trace_view_update_filters(info->treeview, NULL, NULL);
 }
 
 static void
+filter_update_list_filter(struct shark_info *info,
+                          struct filter_task *filter,
+                          struct filter_task *other_filter)
+{
+        struct filter_task_item *task;
+        int pid = info->selected_task;
+
+        task = filter_task_find_pid(filter, pid);
+        if (task) {
+                filter_task_remove_pid(filter, pid);
+                if (!filter_task_count(filter) &&
+                    !filter_task_count(other_filter)) {
+                        info->list_filter_enabled = 0;
+                        info->list_filter_available = 0;
+                }
+        } else {
+                filter_task_add_pid(filter, pid);
+                info->list_filter_available = 1;
+        }
+}
+
+static void
 filter_add_task_clicked (gpointer data)
 {
         struct shark_info *info = data;
+        int pid = info->selected_task;
 
-        trace_graph_filter_add_remove_task(info->ginfo, info->selected_task);
+        if (info->sync_task_filters) {
+                trace_graph_filter_add_remove_task(info->ginfo, pid);
+                return;
+        }
 
-        if (!filter_task_count(info->ginfo->task_filter))
-                info->list_filter_enabled = 0;
+        filter_update_list_filter(info, info->list_task_filter, info->list_hide_tasks);
+        trace_view_update_filters(info->treeview,
+                                  info->list_task_filter, info->list_hide_tasks);
+}
+
+static void
+filter_graph_add_task_clicked (gpointer data)
+{
+        struct shark_info *info = data;
+
+        trace_graph_filter_add_remove_task(info->ginfo, info->selected_task);
 }
 
 static void
@@ -537,11 +751,22 @@ filter_hide_task_clicked (gpointer data)
 {
         struct shark_info *info = data;
 
-        trace_graph_filter_hide_show_task(info->ginfo, info->selected_task);
+        if (info->sync_task_filters) {
+                trace_graph_filter_hide_show_task(info->ginfo, info->selected_task);
+                return;
+        }
 
-        if (!filter_task_count(info->ginfo->task_filter) &&
-            !filter_task_count(info->ginfo->hide_tasks))
-                info->list_filter_enabled = 0;
+        filter_update_list_filter(info, info->list_hide_tasks, info->list_task_filter);
+        trace_view_update_filters(info->treeview,
+                                  info->list_task_filter, info->list_hide_tasks);
+}
+
+static void
+filter_graph_hide_task_clicked (gpointer data)
+{
+        struct shark_info *info = data;
+
+        trace_graph_filter_hide_show_task(info->ginfo, info->selected_task);
 }
 
 static void
@@ -549,11 +774,27 @@ filter_clear_tasks_clicked (gpointer data)
 {
         struct shark_info *info = data;
 
-        trace_graph_clear_tasks(info->ginfo);
+        if (info->sync_task_filters) {
+                trace_graph_clear_tasks(info->ginfo);
+                return;
+        }
 
+        filter_task_clear(info->list_task_filter);
+        filter_task_clear(info->list_hide_tasks);
+        trace_view_update_filters(info->treeview, NULL, NULL);
+
+        info->list_filter_available = 0;
         info->list_filter_enabled = 0;
 }
 
+static void
+filter_graph_clear_tasks_clicked (gpointer data)
+{
+        struct shark_info *info = data;
+
+        trace_graph_clear_tasks(info->ginfo);
+}
+
 static void graph_check_toggle(gpointer data, GtkWidget *widget)
 {
         struct shark_info *info = data;
@@ -561,6 +802,17 @@ static void graph_check_toggle(gpointer data, GtkWidget *widget)
         info->graph_follows = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
 }
 
+static void set_menu_label(GtkWidget *menu, const char *comm, int pid,
+                           const char *fmt)
+{
+        int len = strlen(comm) + strlen(fmt) + 50;
+        char text[len];
+
+        snprintf(text, len, fmt, comm, pid);
+
+        gtk_menu_item_set_label(GTK_MENU_ITEM(menu), text);
+}
+
 static gboolean
 do_tree_popup(GtkWidget *widget, GdkEventButton *event, gpointer data)
 {
@@ -572,11 +824,13 @@ do_tree_popup(GtkWidget *widget, GdkEventButton *event, gpointer data)
         static GtkWidget *menu_filter_add_task;
         static GtkWidget *menu_filter_hide_task;
         static GtkWidget *menu_filter_clear_tasks;
+        static GtkWidget *menu_filter_graph_add_task;
+        static GtkWidget *menu_filter_graph_hide_task;
+        static GtkWidget *menu_filter_graph_clear_tasks;
         struct record *record;
         TraceViewRecord *vrec;
         GtkTreeModel *model;
         const char *comm;
-        gchar *text;
         gint pid;
         gint len;
         guint64 offset;
@@ -585,7 +839,7 @@ do_tree_popup(GtkWidget *widget, GdkEventButton *event, gpointer data)
 
         if (!menu) {
                 menu = gtk_menu_new();
-                menu_filter_graph_enable = gtk_menu_item_new_with_label("Enable Graph Filter");
+                menu_filter_graph_enable = gtk_menu_item_new_with_label("Enable Graph Task Filter");
                 gtk_widget_show(menu_filter_graph_enable);
                 gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_graph_enable);
 
@@ -593,7 +847,7 @@ do_tree_popup(GtkWidget *widget, GdkEventButton *event, gpointer data)
                                           G_CALLBACK (filter_graph_enable_clicked),
                                           data);
 
-                menu_filter_list_enable = gtk_menu_item_new_with_label("Enable List Filter");
+                menu_filter_list_enable = gtk_menu_item_new_with_label("Enable List Task Filter");
                 gtk_widget_show(menu_filter_list_enable);
                 gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_list_enable);
 
@@ -609,6 +863,14 @@ do_tree_popup(GtkWidget *widget, GdkEventButton *event, gpointer data)
                                           G_CALLBACK (filter_add_task_clicked),
                                           data);
 
+                menu_filter_graph_add_task = gtk_menu_item_new_with_label("Add Task to Graph");
+                gtk_widget_show(menu_filter_graph_add_task);
+                gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_graph_add_task);
+
+                g_signal_connect_swapped (G_OBJECT (menu_filter_graph_add_task), "activate",
+                                          G_CALLBACK (filter_graph_add_task_clicked),
+                                          data);
+
                 menu_filter_hide_task = gtk_menu_item_new_with_label("Hide Task");
                 gtk_widget_show(menu_filter_hide_task);
                 gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_hide_task);
@@ -617,6 +879,14 @@ do_tree_popup(GtkWidget *widget, GdkEventButton *event, gpointer data)
                                           G_CALLBACK (filter_hide_task_clicked),
                                           data);
 
+                menu_filter_graph_hide_task = gtk_menu_item_new_with_label("Hide Task from Graph");
+                gtk_widget_show(menu_filter_graph_hide_task);
+                gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_graph_hide_task);
+
+                g_signal_connect_swapped (G_OBJECT (menu_filter_graph_hide_task), "activate",
+                                          G_CALLBACK (filter_graph_hide_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);
@@ -625,6 +895,15 @@ do_tree_popup(GtkWidget *widget, GdkEventButton *event, gpointer data)
                                           G_CALLBACK (filter_clear_tasks_clicked),
                                           data);
 
+                menu_filter_graph_clear_tasks =
+                        gtk_menu_item_new_with_label("Clear Graph Task Filter");
+                gtk_widget_show(menu_filter_graph_clear_tasks);
+                gtk_menu_shell_append(GTK_MENU_SHELL (menu), menu_filter_graph_clear_tasks);
+
+                g_signal_connect_swapped (G_OBJECT (menu_filter_graph_clear_tasks), "activate",
+                                          G_CALLBACK (filter_graph_clear_tasks_clicked),
+                                          data);
+
         }
 
         row = trace_view_get_selected_row(GTK_WIDGET(info->treeview));
@@ -642,29 +921,59 @@ do_tree_popup(GtkWidget *widget, GdkEventButton *event, gpointer data)
 
                         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 from filter", comm, pid);
-                        else
-                                snprintf(text, len, "Add %s-%d to filter", comm, pid);
+                        if (info->sync_task_filters) {
+                                if (trace_graph_filter_task_find_pid(ginfo, pid))
+                                        set_menu_label(menu_filter_add_task, comm, pid,
+                                                       "Remove %s-%d from filters");
+                                else
+                                        set_menu_label(menu_filter_add_task, comm, pid,
+                                                       "Add %s-%d to filters");
+
+                                if (trace_graph_hide_task_find_pid(ginfo, pid))
+                                        set_menu_label(menu_filter_hide_task, comm, pid,
+                                                       "Show %s-%d");
+                                else
+                                        set_menu_label(menu_filter_hide_task, comm, pid,
+                                                       "Hide %s-%d");
+
+                                gtk_widget_hide(menu_filter_graph_add_task);
+                                gtk_widget_hide(menu_filter_graph_hide_task);
+
+                        } else {
+                                if (filter_task_find_pid(info->list_task_filter, pid))
+                                        set_menu_label(menu_filter_add_task, comm, pid,
+                                                       "Remove %s-%d from List filter");
+                                else
+                                        set_menu_label(menu_filter_add_task, comm, pid,
+                                                       "Add %s-%d to List filter");
+
+                                if (filter_task_find_pid(info->list_hide_tasks, pid))
+                                        set_menu_label(menu_filter_hide_task, comm, pid,
+                                                       "Show %s-%d in List");
+                                else
+                                        set_menu_label(menu_filter_hide_task, comm, pid,
+                                                       "Hide %s-%d from List");
+
+                                if (trace_graph_filter_task_find_pid(ginfo, pid))
+                                        set_menu_label(menu_filter_graph_add_task, comm, pid,
+                                                       "Remove %s-%d from Graph filter");
+                                else
+                                        set_menu_label(menu_filter_graph_add_task, comm, pid,
+                                                       "Add %s-%d to Graph filter");
+
+                                if (trace_graph_hide_task_find_pid(ginfo, pid))
+                                        set_menu_label(menu_filter_graph_hide_task, comm, pid,
+                                                       "Show %s-%d in Graph");
+                                else
+                                        set_menu_label(menu_filter_graph_hide_task, comm, pid,
+                                                       "Hide %s-%d from Graph");
+
+                                gtk_widget_show(menu_filter_graph_add_task);
+                                gtk_widget_show(menu_filter_graph_hide_task);
+                        }
 
                         ginfo->filter_task_selected = pid;
 
-                        gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_add_task),
-                                                text);
-
-                        if (trace_graph_hide_task_find_pid(ginfo, pid))
-                                snprintf(text, len, "Show %s-%d", comm, pid);
-                        else
-                                snprintf(text, len, "Hide %s-%d", comm, pid);
-
-                        gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_hide_task),
-                                                text);
-
-                        g_free(text);
-
                         info->selected_task = pid;
 
                         gtk_widget_show(menu_filter_add_task);
@@ -674,35 +983,62 @@ do_tree_popup(GtkWidget *widget, GdkEventButton *event, gpointer data)
         } else {
                 gtk_widget_hide(menu_filter_add_task);
                 gtk_widget_hide(menu_filter_hide_task);
+                gtk_widget_hide(menu_filter_graph_add_task);
+                gtk_widget_hide(menu_filter_graph_hide_task);
         }
 
         if (ginfo->filter_enabled)
                 gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_graph_enable),
-                                        "Disable Graph Filter");
+                                        "Disable Graph Task Filter");
         else
                 gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_graph_enable),
-                                        "Enable Graph Filter");
+                                        "Enable Graph Task Filter");
 
         if (info->list_filter_enabled)
                 gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_list_enable),
-                                        "Disable List Filter");
+                                        "Disable List Task Filter");
         else
                 gtk_menu_item_set_label(GTK_MENU_ITEM(menu_filter_list_enable),
-                                        "Enable List Filter");
+                                        "Enable List Task Filter");
 
-        if (ginfo->filter_available) {
+        if (ginfo->filter_available)
                 gtk_widget_set_sensitive(menu_filter_graph_enable, TRUE);
-                gtk_widget_set_sensitive(menu_filter_list_enable, TRUE);
-        } else {
+        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) ||
-            filter_task_count(ginfo->hide_tasks))
-                gtk_widget_set_sensitive(menu_filter_clear_tasks, TRUE);
+        if ((info->sync_task_filters && ginfo->filter_available) ||
+            (!info->sync_task_filters && info->list_filter_available))
+                gtk_widget_set_sensitive(menu_filter_list_enable, TRUE);
         else
-                gtk_widget_set_sensitive(menu_filter_clear_tasks, FALSE);
+                gtk_widget_set_sensitive(menu_filter_list_enable, FALSE);
+
+        if (info->sync_task_filters) {
+                if (filter_task_count(ginfo->task_filter) ||
+                    filter_task_count(ginfo->hide_tasks))
+                        gtk_widget_set_sensitive(menu_filter_clear_tasks, TRUE);
+                else
+                        gtk_widget_set_sensitive(menu_filter_clear_tasks, FALSE);
+
+                set_menu_label(menu_filter_clear_tasks, comm, pid,
+                               "Clear Task Filter");
+                gtk_widget_hide(menu_filter_graph_clear_tasks);
+        } else {
+                if (filter_task_count(ginfo->task_filter) ||
+                    filter_task_count(ginfo->hide_tasks))
+                        gtk_widget_set_sensitive(menu_filter_graph_clear_tasks, TRUE);
+                else
+                        gtk_widget_set_sensitive(menu_filter_graph_clear_tasks, FALSE);
+
+                if (filter_task_count(info->list_task_filter) ||
+                    filter_task_count(info->list_hide_tasks))
+                        gtk_widget_set_sensitive(menu_filter_clear_tasks, TRUE);
+                else
+                        gtk_widget_set_sensitive(menu_filter_clear_tasks, FALSE);
+
+                set_menu_label(menu_filter_clear_tasks, comm, pid,
+                               "Clear List Task Filter");
+                gtk_widget_show(menu_filter_graph_clear_tasks);
+        }
                 
         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 3,
                        gtk_get_current_event_time());
@@ -785,6 +1121,7 @@ void kernel_shark(int argc, char **argv)
                 handle = NULL;
 
         info->handle = handle;
+        info->sync_task_filters = TRUE;
 
         /* --- Main window --- */
 
@@ -891,6 +1228,25 @@ void kernel_shark(int argc, char **argv)
         menu = gtk_menu_new();    /* Don't need to show menus */
 
 
+
+        /* --- Filter - Sync task Option --- */
+
+        sub_item = gtk_menu_item_new_with_label("Unsync Graph and List Task Filters");
+
+        info->task_sync_menu = sub_item;
+
+        /* Add them to the menu */
+        gtk_menu_shell_append(GTK_MENU_SHELL (menu), sub_item);
+
+        /* We can attach the Quit menu item to our exit function */
+        g_signal_connect (G_OBJECT (sub_item), "activate",
+                          G_CALLBACK (sync_task_filter_clicked),
+                          (gpointer) info);
+
+        /* We do need to show menu items */
+        gtk_widget_show(sub_item);
+
+
         /* --- Filter - List Events Option --- */
 
         sub_item = gtk_menu_item_new_with_label("list events");
diff --git a/kernel-shark.h b/kernel-shark.h
index edb3787..f931406 100644
--- a/kernel-shark.h
+++ b/kernel-shark.h
@@ -30,10 +30,15 @@ struct shark_info {
         struct tracecmd_input           *handle;
         GtkWidget                       *treeview;
         GtkWidget                       *spin;
+        GtkWidget                       *task_sync_menu;
         struct graph_callbacks          graph_cbs;
         gint                            selected_task;
         gboolean                        list_filter_enabled;
+        gboolean                        list_filter_available;
         gboolean                        graph_follows;
+        gboolean                        sync_task_filters;
+        struct filter_task              *list_task_filter;
+        struct filter_task              *list_hide_tasks;
 };
 
 #define offset_of(type, field)          (long)(&((type *)0)->field)
diff --git a/trace-graph.c b/trace-graph.c
index 9e5cd19..2bbe73f 100644
--- a/trace-graph.c
+++ b/trace-graph.c
@@ -548,6 +548,20 @@ void trace_graph_clear_tasks(struct graph_info *ginfo)
                 redraw_graph(ginfo);
 }
 
+void trace_graph_update_filters(struct graph_info *ginfo,
+                                struct filter_task *task_filter,
+                                struct filter_task *hide_tasks)
+{
+        filter_task_hash_free(ginfo->task_filter);
+        filter_task_hash_free(ginfo->hide_tasks);
+
+        ginfo->task_filter = filter_task_hash_copy(task_filter);
+        ginfo->hide_tasks = filter_task_hash_copy(hide_tasks);
+
+        if (ginfo->filter_enabled)
+                redraw_graph(ginfo);
+}
+
 static void
 filter_clear_tasks_clicked (gpointer data)
 {
diff --git a/trace-graph.h b/trace-graph.h
index 916ad50..91194c1 100644
--- a/trace-graph.h
+++ b/trace-graph.h
@@ -311,6 +311,9 @@ int trace_graph_load_filters(struct graph_info *ginfo,
                              struct tracecmd_xml_handle *handle);
 int trace_graph_save_filters(struct graph_info *ginfo,
                              struct tracecmd_xml_handle *handle);
+void trace_graph_update_filters(struct graph_info *ginfo,
+                                struct filter_task *task_filter,
+                                struct filter_task *hide_tasks);
 
 /* plots */
 void trace_graph_plot_free(struct graph_info *ginfo);
diff --git a/trace-view-store.c b/trace-view-store.c
index ba40aad..6f70ca5 100644
--- a/trace-view-store.c
+++ b/trace-view-store.c
@@ -1330,7 +1330,6 @@ void trace_view_store_assign_filters(TraceViewStore *store,
 
         if (store->task_filter != task_filter)
                 store->task_filter = filter_task_hash_copy(task_filter);
-
 }