4 files changed, 374 insertions, 10 deletions

diff --git a/tools/lib/traceevent/event-parse.c b/tools/lib/traceevent/event-parse.c
index b83184f2d484..93825a17dcce 100644
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -765,6 +765,9 @@ static void free_arg(struct print_arg *arg)
         case PRINT_BSTRING:
                 free(arg->string.string);
                 break;
+        case PRINT_BITMASK:
+                free(arg->bitmask.bitmask);
+                break;
         case PRINT_DYNAMIC_ARRAY:
                 free(arg->dynarray.index);
                 break;
@@ -2268,6 +2271,7 @@ static int arg_num_eval(struct print_arg *arg, long long *val)
         case PRINT_FIELD ... PRINT_SYMBOL:
         case PRINT_STRING:
         case PRINT_BSTRING:
+        case PRINT_BITMASK:
         default:
                 do_warning("invalid eval type %d", arg->type);
                 ret = 0;
@@ -2296,6 +2300,7 @@ static char *arg_eval (struct print_arg *arg)
         case PRINT_FIELD ... PRINT_SYMBOL:
         case PRINT_STRING:
         case PRINT_BSTRING:
+        case PRINT_BITMASK:
         default:
                 do_warning("invalid eval type %d", arg->type);
                 break;
@@ -2683,6 +2688,35 @@ process_str(struct event_format *event __maybe_unused, struct print_arg *arg,
         return EVENT_ERROR;
 }
 
+static enum event_type
+process_bitmask(struct event_format *event __maybe_unused, struct print_arg *arg,
+            char **tok)
+{
+        enum event_type type;
+        char *token;
+
+        if (read_expect_type(EVENT_ITEM, &token) < 0)
+                goto out_free;
+
+        arg->type = PRINT_BITMASK;
+        arg->bitmask.bitmask = token;
+        arg->bitmask.offset = -1;
+
+        if (read_expected(EVENT_DELIM, ")") < 0)
+                goto out_err;
+
+        type = read_token(&token);
+        *tok = token;
+
+        return type;
+
+ out_free:
+        free_token(token);
+ out_err:
+        *tok = NULL;
+        return EVENT_ERROR;
+}
+
 static struct pevent_function_handler *
 find_func_handler(struct pevent *pevent, char *func_name)
 {
@@ -2797,6 +2831,10 @@ process_function(struct event_format *event, struct print_arg *arg,
                 free_token(token);
                 return process_str(event, arg, tok);
         }
+        if (strcmp(token, "__get_bitmask") == 0) {
+                free_token(token);
+                return process_bitmask(event, arg, tok);
+        }
         if (strcmp(token, "__get_dynamic_array") == 0) {
                 free_token(token);
                 return process_dynamic_array(event, arg, tok);
@@ -3324,6 +3362,7 @@ eval_num_arg(void *data, int size, struct event_format *event, struct print_arg
                 return eval_type(val, arg, 0);
         case PRINT_STRING:
         case PRINT_BSTRING:
+        case PRINT_BITMASK:
                 return 0;
         case PRINT_FUNC: {
                 struct trace_seq s;
@@ -3556,6 +3595,60 @@ static void print_str_to_seq(struct trace_seq *s, const char *format,
                 trace_seq_printf(s, format, str);
 }
 
+static void print_bitmask_to_seq(struct pevent *pevent,
+                                 struct trace_seq *s, const char *format,
+                                 int len_arg, const void *data, int size)
+{
+        int nr_bits = size * 8;
+        int str_size = (nr_bits + 3) / 4;
+        int len = 0;
+        char buf[3];
+        char *str;
+        int index;
+        int i;
+
+        /*
+         * The kernel likes to put in commas every 32 bits, we
+         * can do the same.
+         */
+        str_size += (nr_bits - 1) / 32;
+
+        str = malloc(str_size + 1);
+        if (!str) {
+                do_warning("%s: not enough memory!", __func__);
+                return;
+        }
+        str[str_size] = 0;
+
+        /* Start out with -2 for the two chars per byte */
+        for (i = str_size - 2; i >= 0; i -= 2) {
+                /*
+                 * data points to a bit mask of size bytes.
+                 * In the kernel, this is an array of long words, thus
+                 * endianess is very important.
+                 */
+                if (pevent->file_bigendian)
+                        index = size - (len + 1);
+                else
+                        index = len;
+
+                snprintf(buf, 3, "%02x", *((unsigned char *)data + index));
+                memcpy(str + i, buf, 2);
+                len++;
+                if (!(len & 3) && i > 0) {
+                        i--;
+                        str[i] = ',';
+                }
+        }
+
+        if (len_arg >= 0)
+                trace_seq_printf(s, format, len_arg, str);
+        else
+                trace_seq_printf(s, format, str);
+
+        free(str);
+}
+
 static void print_str_arg(struct trace_seq *s, void *data, int size,
                           struct event_format *event, const char *format,
                           int len_arg, struct print_arg *arg)
@@ -3691,6 +3784,23 @@ static void print_str_arg(struct trace_seq *s, void *data, int size,
         case PRINT_BSTRING:
                 print_str_to_seq(s, format, len_arg, arg->string.string);
                 break;
+        case PRINT_BITMASK: {
+                int bitmask_offset;
+                int bitmask_size;
+
+                if (arg->bitmask.offset == -1) {
+                        struct format_field *f;
+
+                        f = pevent_find_any_field(event, arg->bitmask.bitmask);
+                        arg->bitmask.offset = f->offset;
+                }
+                bitmask_offset = data2host4(pevent, data + arg->bitmask.offset);
+                bitmask_size = bitmask_offset >> 16;
+                bitmask_offset &= 0xffff;
+                print_bitmask_to_seq(pevent, s, format, len_arg,
+                                     data + bitmask_offset, bitmask_size);
+                break;
+        }
         case PRINT_OP:
                 /*
                  * The only op for string should be ? :
@@ -4822,6 +4932,9 @@ static void print_args(struct print_arg *args)
         case PRINT_BSTRING:
                 printf("__get_str(%s)", args->string.string);
                 break;
+        case PRINT_BITMASK:
+                printf("__get_bitmask(%s)", args->bitmask.bitmask);
+                break;
         case PRINT_TYPE:
                 printf("(%s)", args->typecast.type);
                 print_args(args->typecast.item);
diff --git a/tools/lib/traceevent/event-parse.h b/tools/lib/traceevent/event-parse.h
index feab94281634..7a3873ff9a4f 100644
--- a/tools/lib/traceevent/event-parse.h
+++ b/tools/lib/traceevent/event-parse.h
@@ -107,8 +107,8 @@ typedef int (*pevent_event_handler_func)(struct trace_seq *s,
 typedef int (*pevent_plugin_load_func)(struct pevent *pevent);
 typedef int (*pevent_plugin_unload_func)(struct pevent *pevent);
 
-struct plugin_option {
-        struct plugin_option            *next;
+struct pevent_plugin_option {
+        struct pevent_plugin_option     *next;
         void                            *handle;
         char                            *file;
         char                            *name;
@@ -135,7 +135,7 @@ struct plugin_option {
  * PEVENT_PLUGIN_OPTIONS:  (optional)
  *   Plugin options that can be set before loading
  *
- *   struct plugin_option PEVENT_PLUGIN_OPTIONS[] = {
+ *   struct pevent_plugin_option PEVENT_PLUGIN_OPTIONS[] = {
  *      {
  *              .name = "option-name",
  *              .plugin_alias = "overide-file-name", (optional)
@@ -208,6 +208,11 @@ struct print_arg_string {
         int                     offset;
 };
 
+struct print_arg_bitmask {
+        char                    *bitmask;
+        int                     offset;
+};
+
 struct print_arg_field {
         char                    *name;
         struct format_field     *field;
@@ -274,6 +279,7 @@ enum print_arg_type {
         PRINT_DYNAMIC_ARRAY,
         PRINT_OP,
         PRINT_FUNC,
+        PRINT_BITMASK,
 };
 
 struct print_arg {
@@ -288,6 +294,7 @@ struct print_arg {
                 struct print_arg_hex            hex;
                 struct print_arg_func           func;
                 struct print_arg_string         string;
+                struct print_arg_bitmask        bitmask;
                 struct print_arg_op             op;
                 struct print_arg_dynarray       dynarray;
         };
@@ -354,6 +361,8 @@ enum pevent_func_arg_type {
 
 enum pevent_flag {
         PEVENT_NSEC_OUTPUT              = 1,    /* output in NSECS */
+        PEVENT_DISABLE_SYS_PLUGINS      = 1 << 1,
+        PEVENT_DISABLE_PLUGINS          = 1 << 2,
 };
 
 #define PEVENT_ERRORS                                                         \
@@ -410,9 +419,19 @@ enum pevent_errno {
 
 struct plugin_list;
 
+#define INVALID_PLUGIN_LIST_OPTION      ((char **)((unsigned long)-1))
+
 struct plugin_list *traceevent_load_plugins(struct pevent *pevent);
 void traceevent_unload_plugins(struct plugin_list *plugin_list,
                                struct pevent *pevent);
+char **traceevent_plugin_list_options(void);
+void traceevent_plugin_free_options_list(char **list);
+int traceevent_plugin_add_options(const char *name,
+                                  struct pevent_plugin_option *options);
+void traceevent_plugin_remove_options(struct pevent_plugin_option *options);
+void traceevent_print_plugins(struct trace_seq *s,
+                              const char *prefix, const char *suffix,
+                              const struct plugin_list *list);
 
 struct cmdline;
 struct cmdline_list;
diff --git a/tools/lib/traceevent/event-plugin.c b/tools/lib/traceevent/event-plugin.c
index 0c8bf6780e4d..136162c03af1 100644
--- a/tools/lib/traceevent/event-plugin.c
+++ b/tools/lib/traceevent/event-plugin.c
@@ -18,6 +18,7 @@
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
 
+#include <stdio.h>
 #include <string.h>
 #include <dlfcn.h>
 #include <stdlib.h>
@@ -30,12 +31,207 @@
 
 #define LOCAL_PLUGIN_DIR ".traceevent/plugins"
 
+static struct registered_plugin_options {
+        struct registered_plugin_options        *next;
+        struct pevent_plugin_option             *options;
+} *registered_options;
+
+static struct trace_plugin_options {
+        struct trace_plugin_options     *next;
+        char                            *plugin;
+        char                            *option;
+        char                            *value;
+} *trace_plugin_options;
+
 struct plugin_list {
         struct plugin_list      *next;
         char                    *name;
         void                    *handle;
 };
 
+/**
+ * traceevent_plugin_list_options - get list of plugin options
+ *
+ * Returns an array of char strings that list the currently registered
+ * plugin options in the format of <plugin>:<option>. This list can be
+ * used by toggling the option.
+ *
+ * Returns NULL if there's no options registered. On error it returns
+ * INVALID_PLUGIN_LIST_OPTION
+ *
+ * Must be freed with traceevent_plugin_free_options_list().
+ */
+char **traceevent_plugin_list_options(void)
+{
+        struct registered_plugin_options *reg;
+        struct pevent_plugin_option *op;
+        char **list = NULL;
+        char *name;
+        int count = 0;
+
+        for (reg = registered_options; reg; reg = reg->next) {
+                for (op = reg->options; op->name; op++) {
+                        char *alias = op->plugin_alias ? op->plugin_alias : op->file;
+                        char **temp = list;
+
+                        name = malloc(strlen(op->name) + strlen(alias) + 2);
+                        if (!name)
+                                goto err;
+
+                        sprintf(name, "%s:%s", alias, op->name);
+                        list = realloc(list, count + 2);
+                        if (!list) {
+                                list = temp;
+                                free(name);
+                                goto err;
+                        }
+                        list[count++] = name;
+                        list[count] = NULL;
+                }
+        }
+        return list;
+
+ err:
+        while (--count >= 0)
+                free(list[count]);
+        free(list);
+
+        return INVALID_PLUGIN_LIST_OPTION;
+}
+
+void traceevent_plugin_free_options_list(char **list)
+{
+        int i;
+
+        if (!list)
+                return;
+
+        if (list == INVALID_PLUGIN_LIST_OPTION)
+                return;
+
+        for (i = 0; list[i]; i++)
+                free(list[i]);
+
+        free(list);
+}
+
+static int
+update_option(const char *file, struct pevent_plugin_option *option)
+{
+        struct trace_plugin_options *op;
+        char *plugin;
+
+        if (option->plugin_alias) {
+                plugin = strdup(option->plugin_alias);
+                if (!plugin)
+                        return -1;
+        } else {
+                char *p;
+                plugin = strdup(file);
+                if (!plugin)
+                        return -1;
+                p = strstr(plugin, ".");
+                if (p)
+                        *p = '\0';
+        }
+
+        /* first look for named options */
+        for (op = trace_plugin_options; op; op = op->next) {
+                if (!op->plugin)
+                        continue;
+                if (strcmp(op->plugin, plugin) != 0)
+                        continue;
+                if (strcmp(op->option, option->name) != 0)
+                        continue;
+
+                option->value = op->value;
+                option->set ^= 1;
+                goto out;
+        }
+
+        /* first look for unnamed options */
+        for (op = trace_plugin_options; op; op = op->next) {
+                if (op->plugin)
+                        continue;
+                if (strcmp(op->option, option->name) != 0)
+                        continue;
+
+                option->value = op->value;
+                option->set ^= 1;
+                break;
+        }
+
+ out:
+        free(plugin);
+        return 0;
+}
+
+/**
+ * traceevent_plugin_add_options - Add a set of options by a plugin
+ * @name: The name of the plugin adding the options
+ * @options: The set of options being loaded
+ *
+ * Sets the options with the values that have been added by user.
+ */
+int traceevent_plugin_add_options(const char *name,
+                                  struct pevent_plugin_option *options)
+{
+        struct registered_plugin_options *reg;
+
+        reg = malloc(sizeof(*reg));
+        if (!reg)
+                return -1;
+        reg->next = registered_options;
+        reg->options = options;
+        registered_options = reg;
+
+        while (options->name) {
+                update_option(name, options);
+                options++;
+        }
+        return 0;
+}
+
+/**
+ * traceevent_plugin_remove_options - remove plugin options that were registered
+ * @options: Options to removed that were registered with traceevent_plugin_add_options
+ */
+void traceevent_plugin_remove_options(struct pevent_plugin_option *options)
+{
+        struct registered_plugin_options **last;
+        struct registered_plugin_options *reg;
+
+        for (last = &registered_options; *last; last = &(*last)->next) {
+                if ((*last)->options == options) {
+                        reg = *last;
+                        *last = reg->next;
+                        free(reg);
+                        return;
+                }
+        }
+}
+
+/**
+ * traceevent_print_plugins - print out the list of plugins loaded
+ * @s: the trace_seq descripter to write to
+ * @prefix: The prefix string to add before listing the option name
+ * @suffix: The suffix string ot append after the option name
+ * @list: The list of plugins (usually returned by traceevent_load_plugins()
+ *
+ * Writes to the trace_seq @s the list of plugins (files) that is
+ * returned by traceevent_load_plugins(). Use @prefix and @suffix for formating:
+ * @prefix = "  ", @suffix = "\n".
+ */
+void traceevent_print_plugins(struct trace_seq *s,
+                              const char *prefix, const char *suffix,
+                              const struct plugin_list *list)
+{
+        while (list) {
+                trace_seq_printf(s, "%s%s%s", prefix, list->name, suffix);
+                list = list->next;
+        }
+}
+
 static void
 load_plugin(struct pevent *pevent, const char *path,
             const char *file, void *data)
@@ -148,12 +344,17 @@ load_plugins(struct pevent *pevent, const char *suffix,
         char *path;
         char *envdir;
 
+        if (pevent->flags & PEVENT_DISABLE_PLUGINS)
+                return;
+
         /*
          * If a system plugin directory was defined,
          * check that first.
          */
 #ifdef PLUGIN_DIR
-        load_plugins_dir(pevent, suffix, PLUGIN_DIR, load_plugin, data);
+        if (!(pevent->flags & PEVENT_DISABLE_SYS_PLUGINS))
+                load_plugins_dir(pevent, suffix, PLUGIN_DIR,
+                                 load_plugin, data);
 #endif
 
         /*
diff --git a/tools/lib/traceevent/plugin_function.c b/tools/lib/traceevent/plugin_function.c
index 80ba4ff1fe84..a00ec190821a 100644
--- a/tools/lib/traceevent/plugin_function.c
+++ b/tools/lib/traceevent/plugin_function.c
@@ -33,6 +33,29 @@ static int cpus = -1;
 
 #define STK_BLK 10
 
+struct pevent_plugin_option plugin_options[] =
+{
+        {
+                .name = "parent",
+                .plugin_alias = "ftrace",
+                .description =
+                "Print parent of functions for function events",
+        },
+        {
+                .name = "indent",
+                .plugin_alias = "ftrace",
+                .description =
+                "Try to show function call indents, based on parents",
+                .set = 1,
+        },
+        {
+                .name = NULL,
+        }
+};
+
+static struct pevent_plugin_option *ftrace_parent = &plugin_options[0];
+static struct pevent_plugin_option *ftrace_indent = &plugin_options[1];
+
 static void add_child(struct func_stack *stack, const char *child, int pos)
 {
         int i;
@@ -119,7 +142,8 @@ static int function_handler(struct trace_seq *s, struct pevent_record *record,
 
         parent = pevent_find_function(pevent, pfunction);
 
-        index = add_and_get_index(parent, func, record->cpu);
+        if (parent && ftrace_indent->set)
+                index = add_and_get_index(parent, func, record->cpu);
 
         trace_seq_printf(s, "%*s", index*3, "");
 
@@ -128,11 +152,13 @@ static int function_handler(struct trace_seq *s, struct pevent_record *record,
         else
                 trace_seq_printf(s, "0x%llx", function);
 
-        trace_seq_printf(s, " <-- ");
-        if (parent)
-                trace_seq_printf(s, "%s", parent);
-        else
-                trace_seq_printf(s, "0x%llx", pfunction);
+        if (ftrace_parent->set) {
+                trace_seq_printf(s, " <-- ");
+                if (parent)
+                        trace_seq_printf(s, "%s", parent);
+                else
+                        trace_seq_printf(s, "0x%llx", pfunction);
+        }
 
         return 0;
 }
@@ -141,6 +167,9 @@ int PEVENT_PLUGIN_LOADER(struct pevent *pevent)
 {
         pevent_register_event_handler(pevent, -1, "ftrace", "function",
                                       function_handler, NULL);
+
+        traceevent_plugin_add_options("ftrace", plugin_options);
+
         return 0;
 }
 
@@ -157,6 +186,8 @@ void PEVENT_PLUGIN_UNLOADER(struct pevent *pevent)
                 free(fstack[i].stack);
         }
 
+        traceevent_plugin_remove_options(plugin_options);
+
         free(fstack);
         fstack = NULL;
         cpus = -1;