lkml.org 
[lkml]   [2015]   [Jun]   [8]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v7 07/10] tracing: Add 'hist' event trigger command
    Date
    'hist' triggers allow users to continually aggregate trace events,
    which can then be viewed afterwards by simply reading a 'hist' file
    containing the aggregation in a human-readable format.

    The basic idea is very simple and boils down to a mechanism whereby
    trace events, rather than being exhaustively dumped in raw form and
    viewed directly, are automatically 'compressed' into meaningful tables
    completely defined by the user.

    This is done strictly via single-line command-line commands and
    without the aid of any kind of programming language or interpreter.

    A surprising number of typical use cases can be accomplished by users
    via this simple mechanism. In fact, a large number of the tasks that
    users typically do using the more complicated script-based tracing
    tools, at least during the initial stages of an investigation, can be
    accomplished by simply specifying a set of keys and values to be used
    in the creation of a hash table.

    The Linux kernel trace event subsystem happens to provide an extensive
    list of keys and values ready-made for such a purpose in the form of
    the event format files associated with each trace event. By simply
    consulting the format file for field names of interest and by plugging
    them into the hist trigger command, users can create an endless number
    of useful aggregations to help with investigating various properties
    of the system. See Documentation/trace/events.txt for examples.

    hist triggers are implemented on top of the existing event trigger
    infrastructure, and as such are consistent with the existing triggers
    from a user's perspective as well.

    The basic syntax follows the existing trigger syntax. Users start an
    aggregation by writing a 'hist' trigger to the event of interest's
    trigger file:

    # echo hist:keys=xxx:values=yyy [ if filter] > event/trigger

    Once a hist trigger has been set up, by default it continually
    aggregates every matching event into a hash table using the event key
    and value fields specified.

    To view the aggregation at any point in time, simply read the 'hist'
    file in the same directory as the 'trigger' file:

    # cat event/hist

    The detailed syntax provides additional options for user control, and
    is described exhaustively in Documentation/trace/events.txt and in the
    virtual tracing/README file in the tracing subsystem.

    Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>

    fixes sort key parsing

    Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>

    Add sym-offset

    And change sym, add more space for both. And make modifiers stricter.

    Signed-off-by: Tom Zanussi <tom.zanussi@linux.intel.com>
    ---
    include/linux/trace_events.h | 5 +-
    kernel/trace/Kconfig | 14 +
    kernel/trace/Makefile | 1 +
    kernel/trace/trace.c | 55 ++
    kernel/trace/trace.h | 21 +
    kernel/trace/trace_events.c | 4 +
    kernel/trace/trace_events_hist.c | 1292 +++++++++++++++++++++++++++++++++++
    kernel/trace/trace_events_trigger.c | 29 +-
    8 files changed, 1404 insertions(+), 17 deletions(-)
    create mode 100644 kernel/trace/trace_events_hist.c

    diff --git a/include/linux/trace_events.h b/include/linux/trace_events.h
    index d70c0d2..0faf48b 100644
    --- a/include/linux/trace_events.h
    +++ b/include/linux/trace_events.h
    @@ -410,6 +410,7 @@ enum event_trigger_type {
    ETT_SNAPSHOT = (1 << 1),
    ETT_STACKTRACE = (1 << 2),
    ETT_EVENT_ENABLE = (1 << 3),
    + ETT_EVENT_HIST = (1 << 4),
    };

    extern int filter_match_preds(struct event_filter *filter, void *rec);
    @@ -507,7 +508,7 @@ event_trigger_unlock_commit(struct trace_event_file *file,
    trace_buffer_unlock_commit(buffer, event, irq_flags, pc);

    if (tt)
    - event_triggers_post_call(file, tt);
    + event_triggers_post_call(file, tt, entry);
    }

    /**
    @@ -540,7 +541,7 @@ event_trigger_unlock_commit_regs(struct trace_event_file *file,
    irq_flags, pc, regs);

    if (tt)
    - event_triggers_post_call(file, tt);
    + event_triggers_post_call(file, tt, entry);
    }

    #ifdef CONFIG_BPF_SYSCALL
    diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
    index 3b9a48a..85f8025 100644
    --- a/kernel/trace/Kconfig
    +++ b/kernel/trace/Kconfig
    @@ -528,6 +528,20 @@ config MMIOTRACE
    See Documentation/trace/mmiotrace.txt.
    If you are not helping to develop drivers, say N.

    +config HIST_TRIGGERS
    + bool "Histogram triggers"
    + depends on ARCH_HAVE_NMI_SAFE_CMPXCHG
    + help
    + Hist triggers allow one or more arbitrary trace event fields
    + to be aggregated into hash tables and dumped to stdout by
    + reading a debugfs/tracefs file. They're useful for
    + gathering quick and dirty (though precise) summaries of
    + event activity as an initial guide for further investigation
    + using more advanced tools.
    +
    + See Documentation/trace/events.txt.
    + If in doubt, say N.
    +
    config MMIOTRACE_TEST
    tristate "Test module for mmiotrace"
    depends on MMIOTRACE && m
    diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile
    index 3b26cfb..7faace3 100644
    --- a/kernel/trace/Makefile
    +++ b/kernel/trace/Makefile
    @@ -54,6 +54,7 @@ obj-$(CONFIG_EVENT_TRACING) += trace_event_perf.o
    endif
    obj-$(CONFIG_EVENT_TRACING) += trace_events_filter.o
    obj-$(CONFIG_EVENT_TRACING) += trace_events_trigger.o
    +obj-$(CONFIG_HIST_TRIGGERS) += trace_events_hist.o
    obj-$(CONFIG_BPF_EVENTS) += bpf_trace.o
    obj-$(CONFIG_KPROBE_EVENT) += trace_kprobe.o
    obj-$(CONFIG_TRACEPOINTS) += power-traces.o
    diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
    index abcbf7f..c37c2d5 100644
    --- a/kernel/trace/trace.c
    +++ b/kernel/trace/trace.c
    @@ -3767,6 +3767,9 @@ static const char readme_msg[] =
    #ifdef CONFIG_TRACER_SNAPSHOT
    "\t\t snapshot\n"
    #endif
    +#ifdef CONFIG_HIST_TRIGGERS
    + "\t\t hist (see below)\n"
    +#endif
    "\t example: echo traceoff > events/block/block_unplug/trigger\n"
    "\t echo traceoff:3 > events/block/block_unplug/trigger\n"
    "\t echo 'enable_event:kmem:kmalloc:3 if nr_rq > 1' > \\\n"
    @@ -3782,6 +3785,58 @@ static const char readme_msg[] =
    "\t To remove a trigger with a count:\n"
    "\t echo '!<trigger>:0 > <system>/<event>/trigger\n"
    "\t Filters can be ignored when removing a trigger.\n"
    +#ifdef CONFIG_HIST_TRIGGERS
    + " hist trigger\t- If set, event hits are aggregated into a hash table\n"
    + "\t Format: hist:keys=<field1>[,field2,...]\n"
    + "\t [:values=<field1[,field2,...]]\n"
    + "\t [:sort=field1,field2,...]\n"
    + "\t [:size=#entries]\n"
    + "\t [:pause][:continue][:clear]\n"
    + "\t [if <filter>]\n\n"
    + "\t When a matching event is hit, an entry is added to a hash\n"
    + "\t table using the key(s) and value(s) named. Keys and values\n"
    + "\t correspond to fields in the event's format description.\n"
    + "\t Values must correspond to numeric fields - on an event hit,\n"
    + "\t the value(s) will be added to a sum kept for that field.\n"
    + "\t The special string 'hitcount' can be used in place of an\n"
    + "\t explicit value field - this is simply a count of event hits.\n"
    + "\t If 'values' is not specified, 'hitcount' will be assumed.\n"
    + "\t Keys can be any field, or the special string 'stacktrace',\n"
    + "\t which will use the event's kernel stacktrace as the key.\n"
    + "\t Compound keys consisting of up to two fields can be specified\n"
    + "\t by the 'keys' keyword. Additionally, sort keys consisting\n"
    + "\t of up to two fields can be specified by the 'sort' keyword.\n\n"
    + "\t Reading the 'hist' file for the event will dump the hash\n"
    + "\t table in its entirety to stdout. Each printed hash table\n"
    + "\t entry is a simple list of the keys and values comprising the\n"
    + "\t entry; keys are printed first and are delineated by curly\n"
    + "\t braces, and are followed by the set of value fields for the\n"
    + "\t entry. By default, numeric fields are displayed as base-10\n"
    + "\t integers. This can be modified by appending any of the\n"
    + "\t following modifiers to the field name:\n\n"
    + "\t .hex display a number as a hex value\n"
    + "\t .sym display an address as a symbol\n"
    + "\t .sym-offset display an address as a symbol and offset\n"
    + "\t .syscall display a syscall id as a syscall name\n"
    + "\t .execname display a common_pid as a program name\n\n"
    + "\t By default, the size of the hash table is 2048 entries. The\n"
    + "\t 'size' param can be used to specify more or fewer than that.\n"
    + "\t The units are in terms of hashtable entries - if a run uses\n"
    + "\t more entries than specified, the results will show the number\n"
    + "\t of 'drops', the number of hits that were ignored. The size\n"
    + "\t should be a power of 2 between 128 and 131072 (any non-\n"
    + "\t power-of-2 number specified will be rounded up).\n\n"
    + "\t The 'sort' param can be used to specify a value field to sort\n"
    + "\t on. The default if unspecified is 'hitcount' and the.\n"
    + "\t default sort order is 'ascending'. To sort in the opposite\n"
    + "\t direction, append .descending' to the sort key.\n\n"
    + "\t The 'pause' param can be used to pause an existing hist\n"
    + "\t trigger or to start a hist trigger but not log any events\n"
    + "\t until told to do so. 'continue' can be used to start or\n"
    + "\t restart a paused hist trigger.\n\n"
    + "\t The 'clear' param will clear the contents of a running hist\n"
    + "\t trigger and leave its current paused/active state.\n\n"
    +#endif
    ;

    static ssize_t
    diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
    index 8dcb77c..e6cb781 100644
    --- a/kernel/trace/trace.h
    +++ b/kernel/trace/trace.h
    @@ -1098,6 +1098,13 @@ extern struct mutex event_mutex;
    extern struct list_head ftrace_events;

    extern const struct file_operations event_trigger_fops;
    +extern const struct file_operations event_hist_fops;
    +
    +#ifdef CONFIG_HIST_TRIGGERS
    +extern int register_trigger_hist_cmd(void);
    +#else
    +static inline int register_trigger_hist_cmd(void) { return 0; }
    +#endif

    extern int register_trigger_cmds(void);
    extern void clear_event_triggers(struct trace_array *tr);
    @@ -1114,6 +1121,20 @@ struct event_trigger_data {
    struct list_head list;
    };

    +extern void trigger_data_free(struct event_trigger_data *data);
    +extern int event_trigger_init(struct event_trigger_ops *ops,
    + struct event_trigger_data *data);
    +extern int trace_event_trigger_enable_disable(struct trace_event_file *file,
    + int trigger_enable);
    +extern void update_cond_flag(struct trace_event_file *file);
    +extern void unregister_trigger(char *glob, struct event_trigger_ops *ops,
    + struct event_trigger_data *test,
    + struct trace_event_file *file);
    +extern int set_trigger_filter(char *filter_str,
    + struct event_trigger_data *trigger_data,
    + struct trace_event_file *file);
    +extern int register_event_command(struct event_command *cmd);
    +
    /**
    * struct event_trigger_ops - callbacks for trace event triggers
    *
    diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
    index 404a372..2bf0465 100644
    --- a/kernel/trace/trace_events.c
    +++ b/kernel/trace/trace_events.c
    @@ -1628,6 +1628,10 @@ event_create_dir(struct dentry *parent, struct trace_event_file *file)
    trace_create_file("trigger", 0644, file->dir, file,
    &event_trigger_fops);

    +#ifdef CONFIG_HIST_TRIGGERS
    + trace_create_file("hist", 0444, file->dir, file,
    + &event_hist_fops);
    +#endif
    trace_create_file("format", 0444, file->dir, call,
    &ftrace_event_format_fops);

    diff --git a/kernel/trace/trace_events_hist.c b/kernel/trace/trace_events_hist.c
    new file mode 100644
    index 0000000..e005683
    --- /dev/null
    +++ b/kernel/trace/trace_events_hist.c
    @@ -0,0 +1,1292 @@
    +/*
    + * trace_events_hist - trace event hist triggers
    + *
    + * This program is free software; you can redistribute it and/or modify
    + * it under the terms of the GNU General Public License as published by
    + * the Free Software Foundation; either version 2 of the License, or
    + * (at your option) any later version.
    + *
    + * This program is distributed in the hope that it will be useful,
    + * but WITHOUT ANY WARRANTY; without even the implied warranty of
    + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    + * GNU General Public License for more details.
    + *
    + * Copyright (C) 2015 Tom Zanussi <tom.zanussi@linux.intel.com>
    + */
    +
    +#include <linux/module.h>
    +#include <linux/kallsyms.h>
    +#include <linux/mutex.h>
    +#include <linux/slab.h>
    +#include <linux/stacktrace.h>
    +
    +#include "tracing_map.h"
    +#include "trace.h"
    +
    +struct hist_field;
    +
    +typedef u64 (*hist_field_fn_t) (struct hist_field *field, void *event);
    +
    +struct hist_field {
    + struct ftrace_event_field *field;
    + unsigned long flags;
    + hist_field_fn_t fn;
    + unsigned int size;
    + unsigned int offset;
    +};
    +
    +static u64 hist_field_none(struct hist_field *field, void *event)
    +{
    + return 0;
    +}
    +
    +static u64 hist_field_counter(struct hist_field *field, void *event)
    +{
    + return 1;
    +}
    +
    +static u64 hist_field_string(struct hist_field *hist_field, void *event)
    +{
    + char *addr = (char *)(event + hist_field->field->offset);
    +
    + return (u64)addr;
    +}
    +
    +#define DEFINE_HIST_FIELD_FN(type) \
    +static u64 hist_field_##type(struct hist_field *hist_field, void *event)\
    +{ \
    + type *addr = (type *)(event + hist_field->field->offset); \
    + \
    + return (u64)*addr; \
    +}
    +
    +DEFINE_HIST_FIELD_FN(s64);
    +DEFINE_HIST_FIELD_FN(u64);
    +DEFINE_HIST_FIELD_FN(s32);
    +DEFINE_HIST_FIELD_FN(u32);
    +DEFINE_HIST_FIELD_FN(s16);
    +DEFINE_HIST_FIELD_FN(u16);
    +DEFINE_HIST_FIELD_FN(s8);
    +DEFINE_HIST_FIELD_FN(u8);
    +
    +#define HITCOUNT_IDX 0
    +#define HIST_KEY_MAX 2
    +#define HIST_KEY_SIZE_MAX 128
    +
    +enum hist_field_flags {
    + HIST_FIELD_HITCOUNT = 1,
    + HIST_FIELD_KEY = 2,
    + HIST_FIELD_SYM = 4,
    + HIST_FIELD_SYM_OFFSET = 8,
    + HIST_FIELD_HEX = 16,
    + HIST_FIELD_STACKTRACE = 32,
    + HIST_FIELD_STRING = 64,
    + HIST_FIELD_EXECNAME = 128,
    + HIST_FIELD_SYSCALL = 256,
    +};
    +
    +struct hist_trigger_attrs {
    + char *keys_str;
    + char *vals_str;
    + char *sort_key_str;
    + bool pause;
    + bool cont;
    + bool clear;
    + unsigned int map_bits;
    +};
    +
    +struct hist_trigger_data {
    + atomic64_t total_hits;
    + struct hist_field *fields[TRACING_MAP_FIELDS_MAX];
    + unsigned int n_vals;
    + unsigned int n_keys;
    + unsigned int n_fields;
    + unsigned int key_size;
    + struct tracing_map_sort_key sort_keys[TRACING_MAP_SORT_KEYS_MAX];
    + unsigned int n_sort_keys;
    + struct trace_event_file *event_file;
    + atomic64_t drops;
    + struct hist_trigger_attrs *attrs;
    + struct tracing_map *map;
    +};
    +
    +#define HIST_STACKTRACE_DEPTH 16
    +#define HIST_STACKTRACE_SKIP 5
    +
    +static hist_field_fn_t select_value_fn(int field_size, int field_is_signed)
    +{
    + hist_field_fn_t fn = NULL;
    +
    + switch (field_size) {
    + case 8:
    + if (field_is_signed)
    + fn = hist_field_s64;
    + else
    + fn = hist_field_u64;
    + break;
    + case 4:
    + if (field_is_signed)
    + fn = hist_field_s32;
    + else
    + fn = hist_field_u32;
    + break;
    + case 2:
    + if (field_is_signed)
    + fn = hist_field_s16;
    + else
    + fn = hist_field_u16;
    + break;
    + case 1:
    + if (field_is_signed)
    + fn = hist_field_s8;
    + else
    + fn = hist_field_u8;
    + break;
    + }
    +
    + return fn;
    +}
    +
    +static int parse_map_size(char *str)
    +{
    + unsigned long size, map_bits;
    + int ret;
    +
    + strsep(&str, "=");
    + if (!str) {
    + ret = -EINVAL;
    + goto out;
    + }
    +
    + ret = kstrtoul(str, 0, &size);
    + if (ret)
    + goto out;
    +
    + map_bits = ilog2(roundup_pow_of_two(size));
    + if (map_bits < TRACING_MAP_BITS_MIN ||
    + map_bits > TRACING_MAP_BITS_MAX)
    + ret = -EINVAL;
    + else
    + ret = map_bits;
    + out:
    + return ret;
    +}
    +
    +static void destroy_hist_trigger_attrs(struct hist_trigger_attrs *attrs)
    +{
    + kfree(attrs->sort_key_str);
    + kfree(attrs->keys_str);
    + kfree(attrs->vals_str);
    + kfree(attrs);
    +}
    +
    +static struct hist_trigger_attrs *parse_hist_trigger_attrs(char *trigger_str)
    +{
    + struct hist_trigger_attrs *attrs;
    + int ret = 0;
    +
    + attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
    + if (!attrs)
    + return ERR_PTR(-ENOMEM);
    +
    + while (trigger_str) {
    + char *str = strsep(&trigger_str, ":");
    +
    + if (!strncmp(str, "keys", strlen("keys")) ||
    + !strncmp(str, "key", strlen("key")))
    + attrs->keys_str = kstrdup(str, GFP_KERNEL);
    + else if (!strncmp(str, "values", strlen("values")) ||
    + !strncmp(str, "vals", strlen("vals")) ||
    + !strncmp(str, "val", strlen("val")))
    + attrs->vals_str = kstrdup(str, GFP_KERNEL);
    + else if (!strncmp(str, "sort", strlen("sort")))
    + attrs->sort_key_str = kstrdup(str, GFP_KERNEL);
    + else if (!strncmp(str, "pause", strlen("pause")))
    + attrs->pause = true;
    + else if (!strncmp(str, "continue", strlen("continue")) ||
    + !strncmp(str, "cont", strlen("cont")))
    + attrs->cont = true;
    + else if (!strncmp(str, "clear", strlen("clear")))
    + attrs->clear = true;
    + else if (!strncmp(str, "size", strlen("size"))) {
    + int map_bits = parse_map_size(str);
    +
    + if (map_bits < 0) {
    + ret = map_bits;
    + goto free;
    + }
    + attrs->map_bits = map_bits;
    + } else {
    + ret = -EINVAL;
    + goto free;
    + }
    + }
    +
    + return attrs;
    + free:
    + destroy_hist_trigger_attrs(attrs);
    +
    + return ERR_PTR(ret);
    +}
    +
    +static inline void save_comm(char *comm, struct task_struct *task)
    +{
    + if (!task->pid) {
    + strcpy(comm, "<idle>");
    + return;
    + }
    +
    + if (WARN_ON_ONCE(task->pid < 0)) {
    + strcpy(comm, "<XXX>");
    + return;
    + }
    +
    + if (task->pid > PID_MAX_DEFAULT) {
    + strcpy(comm, "<...>");
    + return;
    + }
    +
    + memcpy(comm, task->comm, TASK_COMM_LEN);
    +}
    +
    +static void hist_trigger_elt_free(struct tracing_map_elt *elt)
    +{
    + kfree((char *)elt->private_data);
    +}
    +
    +static int hist_trigger_elt_alloc(struct tracing_map_elt *elt)
    +{
    + struct hist_trigger_data *hist_data = elt->map->private_data;
    + struct hist_field *key_field;
    + unsigned int i;
    +
    + for (i = hist_data->n_vals; i < hist_data->n_fields; i++) {
    + key_field = hist_data->fields[i];
    +
    + if (key_field->flags & HIST_FIELD_EXECNAME) {
    + unsigned int size = TASK_COMM_LEN + 1;
    +
    + elt->private_data = kzalloc(size, GFP_KERNEL);
    + if (!elt->private_data)
    + return -ENOMEM;
    + break;
    + }
    + }
    +
    + return 0;
    +}
    +
    +static void hist_trigger_elt_copy(struct tracing_map_elt *to,
    + struct tracing_map_elt *from)
    +{
    + char *comm_from = from->private_data;
    + char *comm_to = to->private_data;
    +
    + if (comm_from)
    + memcpy(comm_to, comm_from, TASK_COMM_LEN + 1);
    +}
    +
    +static void hist_trigger_elt_init(struct tracing_map_elt *elt)
    +{
    + char *comm = elt->private_data;
    +
    + if (comm)
    + save_comm(comm, current);
    +}
    +
    +static struct tracing_map_ops hist_trigger_ops = {
    + .elt_alloc = hist_trigger_elt_alloc,
    + .elt_copy = hist_trigger_elt_copy,
    + .elt_free = hist_trigger_elt_free,
    + .elt_init = hist_trigger_elt_init,
    +};
    +
    +static void destroy_hist_field(struct hist_field *hist_field)
    +{
    + kfree(hist_field);
    +}
    +
    +static struct hist_field *create_hist_field(struct ftrace_event_field *field,
    + unsigned long flags)
    +{
    + struct hist_field *hist_field;
    +
    + if (field && is_function_field(field))
    + return NULL;
    +
    + hist_field = kzalloc(sizeof(struct hist_field), GFP_KERNEL);
    + if (!hist_field)
    + return NULL;
    +
    + if (flags & HIST_FIELD_HITCOUNT) {
    + hist_field->fn = hist_field_counter;
    + goto out;
    + }
    +
    + if (flags & HIST_FIELD_STACKTRACE) {
    + hist_field->fn = hist_field_none;
    + goto out;
    + }
    +
    + if (is_string_field(field)) {
    + flags |= HIST_FIELD_STRING;
    + hist_field->fn = hist_field_string;
    + } else {
    + hist_field->fn = select_value_fn(field->size,
    + field->is_signed);
    + if (!hist_field->fn) {
    + destroy_hist_field(hist_field);
    + return NULL;
    + }
    + }
    + out:
    + hist_field->field = field;
    + hist_field->flags = flags;
    +
    + return hist_field;
    +}
    +
    +static void destroy_hist_fields(struct hist_trigger_data *hist_data)
    +{
    + unsigned int i;
    +
    + for (i = 0; i < hist_data->n_fields; i++) {
    + destroy_hist_field(hist_data->fields[i]);
    + hist_data->fields[i] = NULL;
    + }
    +}
    +
    +static int create_hitcount_val(struct hist_trigger_data *hist_data)
    +{
    + hist_data->fields[HITCOUNT_IDX] =
    + create_hist_field(NULL, HIST_FIELD_HITCOUNT);
    + if (!hist_data->fields[HITCOUNT_IDX])
    + return -ENOMEM;
    +
    + hist_data->n_vals++;
    +
    + return 0;
    +}
    +
    +static int create_val_field(struct hist_trigger_data *hist_data,
    + unsigned int val_idx,
    + struct trace_event_file *file,
    + char *field_str)
    +{
    + struct ftrace_event_field *field = NULL;
    + unsigned long flags = 0;
    + char *field_name;
    + int ret = 0;
    +
    + if (!strcmp(field_str, "hitcount"))
    + return ret;
    +
    + field_name = strsep(&field_str, ".");
    + if (field_str) {
    + if (!strcmp(field_str, "sym"))
    + flags |= HIST_FIELD_SYM;
    + else if (!strcmp(field_str, "sym-offset"))
    + flags |= HIST_FIELD_SYM_OFFSET;
    + else if (!strcmp(field_str, "hex"))
    + flags |= HIST_FIELD_HEX;
    + else {
    + ret = -EINVAL;
    + goto out;
    + }
    + }
    +
    + field = trace_find_event_field(file->event_call, field_name);
    + if (!field) {
    + ret = -EINVAL;
    + goto out;
    + }
    +
    + hist_data->fields[val_idx] = create_hist_field(field, flags);
    + if (!hist_data->fields[val_idx]) {
    + ret = -ENOMEM;
    + goto out;
    + }
    + hist_data->n_vals++;
    + out:
    + return ret;
    +}
    +
    +static int create_val_fields(struct hist_trigger_data *hist_data,
    + struct trace_event_file *file)
    +{
    + char *fields_str, *field_str;
    + unsigned int i;
    + int ret;
    +
    + ret = create_hitcount_val(hist_data);
    + if (ret)
    + goto out;
    +
    + fields_str = hist_data->attrs->vals_str;
    + if (!fields_str)
    + goto out;
    +
    + strsep(&fields_str, "=");
    + if (!fields_str)
    + goto out;
    +
    + for (i = 1; i < TRACING_MAP_FIELDS_MAX - 1; i++) {
    + field_str = strsep(&fields_str, ",");
    + if (!field_str)
    + break;
    + ret = create_val_field(hist_data, i, file, field_str);
    + if (ret)
    + goto out;
    + }
    + out:
    + return ret;
    +}
    +
    +static int create_key_field(struct hist_trigger_data *hist_data,
    + unsigned int key_idx,
    + unsigned int key_offset,
    + struct trace_event_file *file,
    + char *field_str)
    +{
    + struct ftrace_event_field *field = NULL;
    + unsigned long flags = 0;
    + unsigned int key_size;
    + char *field_name;
    + int ret = 0;
    +
    + flags |= HIST_FIELD_KEY;
    +
    + if (!strcmp(field_str, "stacktrace")) {
    + flags |= HIST_FIELD_STACKTRACE;
    + key_size = sizeof(unsigned long) * HIST_STACKTRACE_DEPTH;
    + } else {
    + field_name = strsep(&field_str, ".");
    + if (field_str) {
    + if (!strcmp(field_str, "sym"))
    + flags |= HIST_FIELD_SYM;
    + else if (!strcmp(field_str, "sym-offset"))
    + flags |= HIST_FIELD_SYM_OFFSET;
    + else if (!strcmp(field_str, "hex"))
    + flags |= HIST_FIELD_HEX;
    + else if (!strcmp(field_str, "execname") &&
    + !strcmp(field_name, "common_pid"))
    + flags |= HIST_FIELD_EXECNAME;
    + else if (!strcmp(field_str, "syscall"))
    + flags |= HIST_FIELD_SYSCALL;
    + else {
    + ret = -EINVAL;
    + goto out;
    + }
    + }
    +
    + field = trace_find_event_field(file->event_call, field_name);
    + if (!field) {
    + ret = -EINVAL;
    + goto out;
    + }
    +
    + key_size = field->size;
    + }
    +
    + hist_data->fields[key_idx] = create_hist_field(field, flags);
    + if (!hist_data->fields[key_idx]) {
    + ret = -ENOMEM;
    + goto out;
    + }
    +
    + key_size = ALIGN(key_size, sizeof(u64));
    + hist_data->fields[key_idx]->size = key_size;
    + hist_data->fields[key_idx]->offset = key_offset;
    + hist_data->key_size += key_size;
    + if (hist_data->key_size > HIST_KEY_SIZE_MAX) {
    + ret = -EINVAL;
    + goto out;
    + }
    +
    + hist_data->n_keys++;
    + ret = key_size;
    + out:
    + return ret;
    +}
    +
    +static int create_key_fields(struct hist_trigger_data *hist_data,
    + struct trace_event_file *file)
    +{
    + unsigned int i, key_offset = 0, n_vals = hist_data->n_vals;
    + char *fields_str, *field_str;
    + int ret = -EINVAL;
    +
    + fields_str = hist_data->attrs->keys_str;
    + if (!fields_str)
    + goto out;
    +
    + strsep(&fields_str, "=");
    + if (!fields_str)
    + goto out;
    +
    + for (i = n_vals; i < n_vals + HIST_KEY_MAX; i++) {
    + field_str = strsep(&fields_str, ",");
    + if (!field_str)
    + break;
    + ret = create_key_field(hist_data, i, key_offset, file, field_str);
    + if (ret < 0)
    + goto out;
    + key_offset += ret;
    + }
    + ret = 0;
    + out:
    + return ret;
    +}
    +
    +static int create_hist_fields(struct hist_trigger_data *hist_data,
    + struct trace_event_file *file)
    +{
    + int ret;
    +
    + ret = create_val_fields(hist_data, file);
    + if (ret)
    + goto out;
    +
    + ret = create_key_fields(hist_data, file);
    + if (ret)
    + goto out;
    +
    + hist_data->n_fields = hist_data->n_vals + hist_data->n_keys;
    + out:
    + return ret;
    +}
    +
    +static int is_descending(const char *str)
    +{
    + if (!str)
    + return 0;
    +
    + if (!strcmp(str, "descending"))
    + return 1;
    +
    + if (!strcmp(str, "ascending"))
    + return 0;
    +
    + return -EINVAL;
    +}
    +
    +static int create_sort_keys(struct hist_trigger_data *hist_data)
    +{
    + char *fields_str = hist_data->attrs->sort_key_str;
    + struct ftrace_event_field *field = NULL;
    + struct tracing_map_sort_key *sort_key;
    + unsigned int i, j;
    + int ret = 1;
    +
    + hist_data->n_sort_keys = 1;
    +
    + if (!fields_str)
    + goto out;
    +
    + strsep(&fields_str, "=");
    + if (!fields_str) {
    + ret = -EINVAL;
    + goto out;
    + }
    +
    + for (i = 0; i < TRACING_MAP_SORT_KEYS_MAX; i++) {
    + char *field_str, *field_name;
    +
    + sort_key = &hist_data->sort_keys[i];
    +
    + field_str = strsep(&fields_str, ",");
    + if (!field_str) {
    + if (i == 0)
    + ret = -EINVAL;
    + break;
    + }
    +
    + if ((i == TRACING_MAP_SORT_KEYS_MAX - 1) && fields_str) {
    + ret = -EINVAL;
    + break;
    + }
    +
    + field_name = strsep(&field_str, ".");
    + if (!field_name) {
    + ret = -EINVAL;
    + break;
    + }
    +
    + if (!strcmp(field_name, "hitcount")) {
    + ret = is_descending(field_str);
    + if (ret < 0)
    + break;
    + sort_key->descending = ret;
    + continue;
    + }
    +
    + for (j = 1; j < hist_data->n_fields; j++) {
    + field = hist_data->fields[j]->field;
    + if (field && !strcmp(field_name, field->name)) {
    + sort_key->field_idx = j;
    + ret = is_descending(field_str);
    + if (ret < 0)
    + goto out;
    + sort_key->descending = ret;
    + break;
    + }
    + }
    + if (j == hist_data->n_fields) {
    + ret = -EINVAL;
    + break;
    + }
    + }
    + hist_data->n_sort_keys = i;
    + out:
    + return ret;
    +}
    +
    +static void destroy_hist_data(struct hist_trigger_data *hist_data)
    +{
    + destroy_hist_trigger_attrs(hist_data->attrs);
    + destroy_hist_fields(hist_data);
    + tracing_map_destroy(hist_data->map);
    + kfree(hist_data);
    +}
    +
    +static int create_tracing_map_fields(struct hist_trigger_data *hist_data)
    +{
    + struct tracing_map *map = hist_data->map;
    + struct ftrace_event_field *field;
    + struct hist_field *hist_field;
    + unsigned int i, idx;
    +
    + for (i = 0; i < hist_data->n_fields; i++) {
    + hist_field = hist_data->fields[i];
    + if (hist_field->flags & HIST_FIELD_KEY) {
    + tracing_map_cmp_fn_t cmp_fn;
    +
    + field = hist_field->field;
    +
    + if (hist_field->flags & HIST_FIELD_STACKTRACE)
    + cmp_fn = tracing_map_cmp_none;
    + else if (is_string_field(field))
    + cmp_fn = tracing_map_cmp_string;
    + else
    + cmp_fn = tracing_map_cmp_num(field->size,
    + field->is_signed);
    + idx = tracing_map_add_key_field(map,
    + hist_field->offset,
    + cmp_fn);
    + } else
    + idx = tracing_map_add_sum_field(map);
    +
    + if (idx < 0)
    + return idx;
    + }
    +
    + return 0;
    +}
    +
    +static struct hist_trigger_data *
    +create_hist_data(unsigned int map_bits,
    + struct hist_trigger_attrs *attrs,
    + struct trace_event_file *file)
    +{
    + struct hist_trigger_data *hist_data;
    + int ret = 0;
    +
    + hist_data = kzalloc(sizeof(*hist_data), GFP_KERNEL);
    + if (!hist_data)
    + return ERR_PTR(-ENOMEM);
    +
    + hist_data->attrs = attrs;
    +
    + ret = create_hist_fields(hist_data, file);
    + if (ret < 0)
    + goto free;
    +
    + ret = create_sort_keys(hist_data);
    + if (ret < 0)
    + goto free;
    +
    + hist_data->map = tracing_map_create(map_bits, hist_data->key_size,
    + &hist_trigger_ops,
    + hist_data);
    + if (IS_ERR(hist_data->map)) {
    + ret = PTR_ERR(hist_data->map);
    + hist_data->map = NULL;
    + goto free;
    + }
    +
    + ret = create_tracing_map_fields(hist_data);
    + if (ret)
    + goto free;
    +
    + ret = tracing_map_init(hist_data->map);
    + if (ret)
    + goto free;
    +
    + hist_data->event_file = file;
    + out:
    + return hist_data;
    + free:
    + destroy_hist_data(hist_data);
    + if (ret)
    + hist_data = ERR_PTR(ret);
    + else
    + hist_data = NULL;
    +
    + goto out;
    +}
    +
    +static void hist_trigger_elt_update(struct hist_trigger_data *hist_data,
    + struct tracing_map_elt *elt,
    + void *rec)
    +{
    + struct hist_field *hist_field;
    + unsigned int i;
    + u64 hist_val;
    +
    + for (i = 0; i < hist_data->n_vals; i++) {
    + hist_field = hist_data->fields[i];
    + hist_val = hist_field->fn(hist_field, rec);
    + tracing_map_update_sum(elt, i, hist_val);
    + }
    +}
    +
    +static void event_hist_trigger(struct event_trigger_data *data, void *rec)
    +{
    + struct hist_trigger_data *hist_data = data->private_data;
    + unsigned long entries[HIST_STACKTRACE_DEPTH];
    + char compound_key[HIST_KEY_SIZE_MAX];
    + struct stack_trace stacktrace;
    + struct hist_field *key_field;
    + struct tracing_map_elt *elt;
    + u64 field_contents;
    + void *key = NULL;
    + unsigned int i;
    +
    + if (atomic64_read(&hist_data->drops)) {
    + atomic64_inc(&hist_data->drops);
    + return;
    + }
    +
    + if (hist_data->n_keys > 1)
    + memset(compound_key, 0, hist_data->key_size);
    +
    + for (i = hist_data->n_vals; i < hist_data->n_fields; i++) {
    + key_field = hist_data->fields[i];
    +
    + if (key_field->flags & HIST_FIELD_STACKTRACE) {
    + stacktrace.max_entries = HIST_STACKTRACE_DEPTH;
    + stacktrace.entries = entries;
    + stacktrace.nr_entries = 0;
    + stacktrace.skip = HIST_STACKTRACE_SKIP;
    +
    + memset(stacktrace.entries, 0, hist_data->key_size);
    + save_stack_trace(&stacktrace);
    +
    + key = entries;
    + } else {
    + field_contents = key_field->fn(key_field, rec);
    + if (key_field->flags & HIST_FIELD_STRING)
    + key = (void *)field_contents;
    + else
    + key = (void *)&field_contents;
    +
    + if (hist_data->n_keys > 1) {
    + memcpy(compound_key + key_field->offset, key,
    + key_field->size);
    + }
    + }
    + }
    +
    + if (hist_data->n_keys > 1)
    + key = compound_key;
    +
    + elt = tracing_map_insert(hist_data->map, key);
    + if (elt)
    + hist_trigger_elt_update(hist_data, elt, rec);
    + else
    + atomic64_inc(&hist_data->drops);
    +
    + atomic64_inc(&hist_data->total_hits);
    +}
    +
    +static void hist_trigger_stacktrace_print(struct seq_file *m,
    + unsigned long *stacktrace_entries,
    + unsigned int max_entries)
    +{
    + char str[KSYM_SYMBOL_LEN];
    + unsigned int spaces = 8;
    + unsigned int i;
    +
    + for (i = 0; i < max_entries; i++) {
    + if (stacktrace_entries[i] == ULONG_MAX)
    + return;
    +
    + seq_printf(m, "%*c", 1 + spaces, ' ');
    + sprint_symbol(str, stacktrace_entries[i]);
    + seq_printf(m, "%s\n", str);
    + }
    +}
    +
    +static void
    +hist_trigger_entry_print(struct seq_file *m,
    + struct hist_trigger_data *hist_data, void *key,
    + struct tracing_map_elt *elt)
    +{
    + struct hist_field *key_field;
    + char str[KSYM_SYMBOL_LEN];
    + bool multiline = false;
    + unsigned int i;
    + u64 uval;
    +
    + seq_puts(m, "{ ");
    +
    + for (i = hist_data->n_vals; i < hist_data->n_fields; i++) {
    + key_field = hist_data->fields[i];
    +
    + if (i > hist_data->n_vals)
    + seq_puts(m, ", ");
    +
    + if (key_field->flags & HIST_FIELD_SYM) {
    + uval = *(u64 *)(key + key_field->offset);
    + sprint_symbol_no_offset(str, uval);
    + seq_printf(m, "%s: [%llx] %-45s",
    + key_field->field->name, uval, str);
    + } else if (key_field->flags & HIST_FIELD_SYM_OFFSET) {
    + uval = *(u64 *)(key + key_field->offset);
    + sprint_symbol(str, uval);
    + seq_printf(m, "%s: [%llx] %-55s",
    + key_field->field->name, uval, str);
    + } else if (key_field->flags & HIST_FIELD_HEX) {
    + uval = *(u64 *)(key + key_field->offset);
    + seq_printf(m, "%s: %llx",
    + key_field->field->name, uval);
    + } else if (key_field->flags & HIST_FIELD_STACKTRACE) {
    + seq_puts(m, "stacktrace:\n");
    + hist_trigger_stacktrace_print(m,
    + key + key_field->offset,
    + HIST_STACKTRACE_DEPTH);
    + multiline = true;
    + } else if (key_field->flags & HIST_FIELD_STRING) {
    + seq_printf(m, "%s: %-35s", key_field->field->name,
    + (char *)(key + key_field->offset));
    + } else if (key_field->flags & HIST_FIELD_EXECNAME) {
    + char *comm = elt->private_data;
    +
    + uval = *(u64 *)(key + key_field->offset);
    + seq_printf(m, "%s: %-16s[%10llu]",
    + key_field->field->name, comm, uval);
    + } else if (key_field->flags & HIST_FIELD_SYSCALL) {
    + const char *syscall_name;
    +
    + uval = *(u64 *)(key + key_field->offset);
    + syscall_name = get_syscall_name(uval);
    + if (!syscall_name)
    + syscall_name = "unknown_syscall";
    +
    + seq_printf(m, "%s: %-30s[%3llu]",
    + key_field->field->name, syscall_name, uval);
    + } else {
    + uval = *(u64 *)(key + key_field->offset);
    + seq_printf(m, "%s: %10llu",
    + key_field->field->name, uval);
    + }
    + }
    +
    + if (!multiline)
    + seq_puts(m, " ");
    +
    + seq_puts(m, "}");
    +
    + seq_printf(m, " hitcount: %10llu",
    + tracing_map_read_sum(elt, HITCOUNT_IDX));
    +
    + for (i = 1; i < hist_data->n_vals; i++) {
    + seq_printf(m, " %s: %10llu",
    + hist_data->fields[i]->field->name,
    + tracing_map_read_sum(elt, i));
    + }
    +
    + seq_puts(m, "\n");
    +}
    +
    +static int print_entries(struct seq_file *m,
    + struct hist_trigger_data *hist_data)
    +{
    + struct tracing_map_sort_entry **sort_entries = NULL;
    + struct tracing_map *map = hist_data->map;
    + unsigned int i, n_entries;
    +
    + n_entries = tracing_map_sort_entries(map, hist_data->sort_keys,
    + hist_data->n_sort_keys,
    + &sort_entries);
    + if (n_entries < 0)
    + return n_entries;
    +
    + for (i = 0; i < n_entries; i++)
    + hist_trigger_entry_print(m, hist_data,
    + sort_entries[i]->key,
    + sort_entries[i]->elt);
    +
    + tracing_map_destroy_sort_entries(sort_entries, n_entries);
    +
    + return n_entries;
    +}
    +
    +static int hist_show(struct seq_file *m, void *v)
    +{
    + struct event_trigger_data *test, *data = NULL;
    + struct trace_event_file *event_file;
    + struct hist_trigger_data *hist_data;
    + int n_entries, ret = 0;
    +
    + mutex_lock(&event_mutex);
    +
    + event_file = event_file_data(m->private);
    + if (unlikely(!event_file)) {
    + ret = -ENODEV;
    + goto out_unlock;
    + }
    +
    + list_for_each_entry_rcu(test, &event_file->triggers, list) {
    + if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
    + data = test;
    + break;
    + }
    + }
    + if (!data)
    + goto out_unlock;
    +
    + seq_puts(m, "# trigger info: ");
    + data->ops->print(m, data->ops, data);
    + seq_puts(m, "\n");
    +
    + hist_data = data->private_data;
    + n_entries = print_entries(m, hist_data);
    + if (n_entries < 0) {
    + ret = n_entries;
    + n_entries = 0;
    + }
    +
    + seq_printf(m, "\nTotals:\n Hits: %lu\n Entries: %u\n Dropped: %lu\n",
    + atomic64_read(&hist_data->total_hits),
    + n_entries, atomic64_read(&hist_data->drops));
    + out_unlock:
    + mutex_unlock(&event_mutex);
    +
    + return ret;
    +}
    +
    +static int event_hist_open(struct inode *inode, struct file *file)
    +{
    + return single_open(file, hist_show, file);
    +}
    +
    +const struct file_operations event_hist_fops = {
    + .open = event_hist_open,
    + .read = seq_read,
    + .llseek = seq_lseek,
    + .release = single_release,
    +};
    +
    +static const char *get_hist_field_flags(struct hist_field *hist_field)
    +{
    + const char *flags_str = NULL;
    +
    + if (hist_field->flags & HIST_FIELD_SYM)
    + flags_str = "sym";
    + else if (hist_field->flags & HIST_FIELD_SYM_OFFSET)
    + flags_str = "sym-offset";
    + else if (hist_field->flags & HIST_FIELD_HEX)
    + flags_str = "hex";
    + else if (hist_field->flags & HIST_FIELD_SYSCALL)
    + flags_str = "syscall";
    + else if (hist_field->flags & HIST_FIELD_EXECNAME)
    + flags_str = "execname";
    +
    + return flags_str;
    +}
    +
    +static void hist_field_print(struct seq_file *m, struct hist_field *hist_field)
    +{
    + seq_printf(m, "%s", hist_field->field->name);
    + if (hist_field->flags) {
    + const char *flags_str = get_hist_field_flags(hist_field);
    +
    + if (flags_str)
    + seq_printf(m, ".%s", flags_str);
    + }
    +}
    +
    +static int event_hist_trigger_print(struct seq_file *m,
    + struct event_trigger_ops *ops,
    + struct event_trigger_data *data)
    +{
    + struct hist_trigger_data *hist_data = data->private_data;
    + struct hist_field *key_field;
    + unsigned int i;
    +
    + seq_puts(m, "hist:keys=");
    +
    + for (i = hist_data->n_vals; i < hist_data->n_fields; i++) {
    + key_field = hist_data->fields[i];
    +
    + if (i > hist_data->n_vals)
    + seq_puts(m, ",");
    +
    + if (key_field->flags & HIST_FIELD_STACKTRACE)
    + seq_puts(m, "stacktrace");
    + else
    + hist_field_print(m, key_field);
    + }
    +
    + seq_puts(m, ":vals=");
    +
    + if (hist_data->n_vals == 1)
    + seq_puts(m, "hitcount");
    + else {
    + for (i = 1; i < hist_data->n_vals; i++) {
    + if (i > 1)
    + seq_puts(m, ",");
    + hist_field_print(m, hist_data->fields[i]);
    + }
    + }
    +
    + seq_puts(m, ":sort=");
    +
    + for (i = 0; i < hist_data->n_sort_keys; i++) {
    + struct tracing_map_sort_key *sort_key;
    +
    + sort_key = &hist_data->sort_keys[i];
    +
    + if (i > 0)
    + seq_puts(m, ",");
    +
    + if (sort_key->field_idx == HITCOUNT_IDX)
    + seq_puts(m, "hitcount");
    + else {
    + unsigned int idx = sort_key->field_idx;
    +
    + hist_field_print(m, hist_data->fields[idx]);
    + }
    +
    + if (sort_key->descending)
    + seq_puts(m, ".descending");
    + }
    +
    + seq_printf(m, ":size=%u", (1 << hist_data->map->map_bits));
    +
    + if (data->filter_str)
    + seq_printf(m, " if %s", data->filter_str);
    +
    + if (data->paused)
    + seq_puts(m, " [paused]");
    + else
    + seq_puts(m, " [active]");
    +
    + seq_putc(m, '\n');
    +
    + return 0;
    +}
    +
    +static void event_hist_trigger_free(struct event_trigger_ops *ops,
    + struct event_trigger_data *data)
    +{
    + struct hist_trigger_data *hist_data = data->private_data;
    +
    + if (WARN_ON_ONCE(data->ref <= 0))
    + return;
    +
    + data->ref--;
    + if (!data->ref) {
    + trigger_data_free(data);
    + destroy_hist_data(hist_data);
    + }
    +}
    +
    +static struct event_trigger_ops event_hist_trigger_ops = {
    + .func = event_hist_trigger,
    + .print = event_hist_trigger_print,
    + .init = event_trigger_init,
    + .free = event_hist_trigger_free,
    +};
    +
    +static struct event_trigger_ops *event_hist_get_trigger_ops(char *cmd,
    + char *param)
    +{
    + return &event_hist_trigger_ops;
    +}
    +
    +static void hist_clear(struct event_trigger_data *data)
    +{
    + struct hist_trigger_data *hist_data = data->private_data;
    + bool paused;
    +
    + paused = data->paused;
    + data->paused = true;
    +
    + synchronize_sched();
    +
    + tracing_map_clear(hist_data->map);
    +
    + atomic64_set(&hist_data->total_hits, 0);
    + atomic64_set(&hist_data->drops, 0);
    +
    + data->paused = paused;
    +}
    +
    +static int hist_register_trigger(char *glob, struct event_trigger_ops *ops,
    + struct event_trigger_data *data,
    + struct trace_event_file *file)
    +{
    + struct hist_trigger_data *hist_data = data->private_data;
    + struct event_trigger_data *test;
    + int ret = 0;
    +
    + list_for_each_entry_rcu(test, &file->triggers, list) {
    + if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
    + if (hist_data->attrs->clear)
    + hist_clear(test);
    + else if (hist_data->attrs->pause)
    + test->paused = true;
    + else if (hist_data->attrs->cont)
    + test->paused = false;
    + else
    + ret = -EEXIST;
    + goto out;
    + }
    + }
    +
    + if (hist_data->attrs->pause)
    + data->paused = true;
    +
    + if (data->ops->init) {
    + ret = data->ops->init(data->ops, data);
    + if (ret < 0)
    + goto out;
    + }
    +
    + list_add_rcu(&data->list, &file->triggers);
    + ret++;
    +
    + update_cond_flag(file);
    + if (trace_event_trigger_enable_disable(file, 1) < 0) {
    + list_del_rcu(&data->list);
    + update_cond_flag(file);
    + ret--;
    + }
    + out:
    + return ret;
    +}
    +
    +static int event_hist_trigger_func(struct event_command *cmd_ops,
    + struct trace_event_file *file,
    + char *glob, char *cmd, char *param)
    +{
    + unsigned int hist_trigger_bits = TRACING_MAP_BITS_DEFAULT;
    + struct event_trigger_data *trigger_data;
    + struct hist_trigger_attrs *attrs;
    + struct event_trigger_ops *trigger_ops;
    + struct hist_trigger_data *hist_data;
    + char *trigger;
    + int ret = 0;
    +
    + if (!param)
    + return -EINVAL;
    +
    + /* separate the trigger from the filter (k:v [if filter]) */
    + trigger = strsep(&param, " \t");
    + if (!trigger)
    + return -EINVAL;
    +
    + attrs = parse_hist_trigger_attrs(trigger);
    + if (IS_ERR(attrs))
    + return PTR_ERR(attrs);
    +
    + if (!attrs->keys_str)
    + return -EINVAL;
    +
    + if (attrs->map_bits)
    + hist_trigger_bits = attrs->map_bits;
    +
    + hist_data = create_hist_data(hist_trigger_bits, attrs, file);
    + if (IS_ERR(hist_data))
    + return PTR_ERR(hist_data);
    +
    + trigger_ops = cmd_ops->get_trigger_ops(cmd, trigger);
    +
    + ret = -ENOMEM;
    + trigger_data = kzalloc(sizeof(*trigger_data), GFP_KERNEL);
    + if (!trigger_data)
    + goto out;
    +
    + trigger_data->count = -1;
    + trigger_data->ops = trigger_ops;
    + trigger_data->cmd_ops = cmd_ops;
    +
    + INIT_LIST_HEAD(&trigger_data->list);
    + RCU_INIT_POINTER(trigger_data->filter, NULL);
    +
    + trigger_data->private_data = hist_data;
    +
    + if (glob[0] == '!') {
    + cmd_ops->unreg(glob+1, trigger_ops, trigger_data, file);
    + ret = 0;
    + goto out_free;
    + }
    +
    + if (!param) /* if param is non-empty, it's supposed to be a filter */
    + goto out_reg;
    +
    + if (!cmd_ops->set_filter)
    + goto out_reg;
    +
    + ret = cmd_ops->set_filter(param, trigger_data, file);
    + if (ret < 0)
    + goto out_free;
    + out_reg:
    + ret = cmd_ops->reg(glob, trigger_ops, trigger_data, file);
    + /*
    + * The above returns on success the # of triggers registered,
    + * but if it didn't register any it returns zero. Consider no
    + * triggers registered a failure too.
    + */
    + if (!ret) {
    + if (!(attrs->pause || attrs->cont || attrs->clear))
    + ret = -ENOENT;
    + goto out_free;
    + } else if (ret < 0)
    + goto out_free;
    + /* Just return zero, not the number of registered triggers */
    + ret = 0;
    + out:
    + return ret;
    + out_free:
    + if (cmd_ops->set_filter)
    + cmd_ops->set_filter(NULL, trigger_data, NULL);
    +
    + kfree(trigger_data);
    +
    + destroy_hist_data(hist_data);
    + goto out;
    +}
    +
    +static struct event_command trigger_hist_cmd = {
    + .name = "hist",
    + .trigger_type = ETT_EVENT_HIST,
    + .post_trigger = true, /* need non-NULL rec */
    + .func = event_hist_trigger_func,
    + .reg = hist_register_trigger,
    + .unreg = unregister_trigger,
    + .get_trigger_ops = event_hist_get_trigger_ops,
    + .set_filter = set_trigger_filter,
    +};
    +
    +__init int register_trigger_hist_cmd(void)
    +{
    + int ret;
    +
    + ret = register_event_command(&trigger_hist_cmd);
    + WARN_ON(ret < 0);
    +
    + return ret;
    +}
    diff --git a/kernel/trace/trace_events_trigger.c b/kernel/trace/trace_events_trigger.c
    index ecf65e1..e80f30b 100644
    --- a/kernel/trace/trace_events_trigger.c
    +++ b/kernel/trace/trace_events_trigger.c
    @@ -28,8 +28,7 @@
    static LIST_HEAD(trigger_commands);
    static DEFINE_MUTEX(trigger_cmd_mutex);

    -static void
    -trigger_data_free(struct event_trigger_data *data)
    +void trigger_data_free(struct event_trigger_data *data)
    {
    if (data->cmd_ops->set_filter)
    data->cmd_ops->set_filter(NULL, data, NULL);
    @@ -316,7 +315,7 @@ const struct file_operations event_trigger_fops = {
    * Currently we only register event commands from __init, so mark this
    * __init too.
    */
    -static __init int register_event_command(struct event_command *cmd)
    +__init int register_event_command(struct event_command *cmd)
    {
    struct event_command *p;
    int ret = 0;
    @@ -405,9 +404,8 @@ event_trigger_print(const char *name, struct seq_file *m,
    *
    * Return: 0 on success, errno otherwise
    */
    -static int
    -event_trigger_init(struct event_trigger_ops *ops,
    - struct event_trigger_data *data)
    +int event_trigger_init(struct event_trigger_ops *ops,
    + struct event_trigger_data *data)
    {
    data->ref++;
    return 0;
    @@ -435,8 +433,8 @@ event_trigger_free(struct event_trigger_ops *ops,
    trigger_data_free(data);
    }

    -static int trace_event_trigger_enable_disable(struct trace_event_file *file,
    - int trigger_enable)
    +int trace_event_trigger_enable_disable(struct trace_event_file *file,
    + int trigger_enable)
    {
    int ret = 0;

    @@ -493,7 +491,7 @@ clear_event_triggers(struct trace_array *tr)
    * its TRIGGER_COND bit set, otherwise the TRIGGER_COND bit should be
    * cleared.
    */
    -static void update_cond_flag(struct trace_event_file *file)
    +void update_cond_flag(struct trace_event_file *file)
    {
    struct event_trigger_data *data;
    bool set_cond = false;
    @@ -570,9 +568,9 @@ out:
    * Usually used directly as the @unreg method in event command
    * implementations.
    */
    -static void unregister_trigger(char *glob, struct event_trigger_ops *ops,
    - struct event_trigger_data *test,
    - struct trace_event_file *file)
    +void unregister_trigger(char *glob, struct event_trigger_ops *ops,
    + struct event_trigger_data *test,
    + struct trace_event_file *file)
    {
    struct event_trigger_data *data;
    bool unregistered = false;
    @@ -706,9 +704,9 @@ event_trigger_callback(struct event_command *cmd_ops,
    *
    * Return: 0 on success, errno otherwise
    */
    -static int set_trigger_filter(char *filter_str,
    - struct event_trigger_data *trigger_data,
    - struct trace_event_file *file)
    +int set_trigger_filter(char *filter_str,
    + struct event_trigger_data *trigger_data,
    + struct trace_event_file *file)
    {
    struct event_trigger_data *data = trigger_data;
    struct event_filter *filter = NULL, *tmp;
    @@ -1439,6 +1437,7 @@ __init int register_trigger_cmds(void)
    register_trigger_snapshot_cmd();
    register_trigger_stacktrace_cmd();
    register_trigger_enable_disable_cmds();
    + register_trigger_hist_cmd();

    return 0;
    }
    --
    1.9.3


    \
     
     \ /
      Last update: 2015-06-09 00:01    [W:4.532 / U:0.320 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site