Quelle  trace_events_hist.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * trace_events_hist - trace event hist triggers
 *
 * Copyright (C) 2015 Tom Zanussi <tom.zanussi@linux.intel.com>
 */

#include <linux/module.h>
#include <linux/kallsyms.h>
#include <linux/security.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/stacktrace.h>
#include <linux/rculist.h>
#include <linux/tracefs.h>

/* for gfp flag names */
#include <linux/trace_events.h>
#include <trace/events/mmflags.h>

#include "tracing_map.h"
#include "trace_synth.h"

#define ERRORS        \
 C(NONE,   "No error"),    \
 C(DUPLICATE_VAR, "Variable already defined"),  \
 C(VAR_NOT_UNIQUE, "Variable name not unique, need to use fully qualified name (subsys.event.var) for variable"), \
 C(TOO_MANY_VARS, "Too many variables defined"),  \
 C(MALFORMED_ASSIGNMENT, "Malformed assignment"),  \
 C(NAMED_MISMATCH, "Named hist trigger doesn't match existing named trigger (includes variables)"), \
 C(TRIGGER_EEXIST, "Hist trigger already exists"),  \
 C(TRIGGER_ENOENT_CLEAR, "Can't clear or continue a nonexistent hist trigger"), \
 C(SET_CLOCK_FAIL, "Couldn't set trace_clock"),  \
 C(BAD_FIELD_MODIFIER, "Invalid field modifier"),  \
 C(TOO_MANY_SUBEXPR, "Too many subexpressions (3 max)"), \
 C(TIMESTAMP_MISMATCH, "Timestamp units in expression don't match"), \
 C(TOO_MANY_FIELD_VARS, "Too many field variables defined"), \
 C(EVENT_FILE_NOT_FOUND, "Event file not found"),  \
 C(HIST_NOT_FOUND, "Matching event histogram not found"), \
 C(HIST_CREATE_FAIL, "Couldn't create histogram for field"), \
 C(SYNTH_VAR_NOT_FOUND, "Couldn't find synthetic variable"), \
 C(SYNTH_EVENT_NOT_FOUND,"Couldn't find synthetic event"), \
 C(SYNTH_TYPE_MISMATCH, "Param type doesn't match synthetic event field type"), \
 C(SYNTH_COUNT_MISMATCH, "Param count doesn't match synthetic event field count"), \
 C(FIELD_VAR_PARSE_FAIL, "Couldn't parse field variable"), \
 C(VAR_CREATE_FIND_FAIL, "Couldn't create or find variable"), \
 C(ONX_NOT_VAR,  "For onmax(x) or onchange(x), x must be a variable"), \
 C(ONX_VAR_NOT_FOUND, "Couldn't find onmax or onchange variable"), \
 C(ONX_VAR_CREATE_FAIL, "Couldn't create onmax or onchange variable"), \
 C(FIELD_VAR_CREATE_FAIL,"Couldn't create field variable"), \
 C(TOO_MANY_PARAMS, "Too many action params"),  \
 C(PARAM_NOT_FOUND, "Couldn't find param"),   \
 C(INVALID_PARAM, "Invalid action param"),  \
 C(ACTION_NOT_FOUND, "No action found"),   \
 C(NO_SAVE_PARAMS, "No params found for save()"),  \
 C(TOO_MANY_SAVE_ACTIONS,"Can't have more than one save() action per hist"), \
 C(ACTION_MISMATCH, "Handler doesn't support action"), \
 C(NO_CLOSING_PAREN, "No closing paren found"),  \
 C(SUBSYS_NOT_FOUND, "Missing subsystem"),   \
 C(INVALID_SUBSYS_EVENT, "Invalid subsystem or event name"), \
 C(INVALID_REF_KEY, "Using variable references in keys not supported"), \
 C(VAR_NOT_FOUND, "Couldn't find variable"),  \
 C(FIELD_NOT_FOUND, "Couldn't find field"),   \
 C(EMPTY_ASSIGNMENT, "Empty assignment"),   \
 C(INVALID_SORT_MODIFIER,"Invalid sort modifier"),  \
 C(EMPTY_SORT_FIELD, "Empty sort field"),   \
 C(TOO_MANY_SORT_FIELDS, "Too many sort fields (Max = 2)"), \
 C(INVALID_SORT_FIELD, "Sort field must be a key or a val"), \
 C(INVALID_STR_OPERAND, "String type can not be an operand in expression"), \
 C(EXPECT_NUMBER, "Expecting numeric literal"),  \
 C(UNARY_MINUS_SUBEXPR, "Unary minus not supported in sub-expressions"), \
 C(DIVISION_BY_ZERO, "Division by zero"),   \
 C(NEED_NOHC_VAL, "Non-hitcount value is required for 'nohitcount'"),

#undef C
#define C(a, b)  HIST_ERR_##a

enum { ERRORS };

#undef C
#define C(a, b)  b

static const char *err_text[] = { ERRORS };

struct hist_field;

typedef u64 (*hist_field_fn_t) (struct hist_field *field,
    struct tracing_map_elt *elt,
    struct trace_buffer *buffer,
    struct ring_buffer_event *rbe,
    void *event);

#define HIST_FIELD_OPERANDS_MAX 2
#define HIST_FIELDS_MAX  (TRACING_MAP_FIELDS_MAX + TRACING_MAP_VARS_MAX)
#define HIST_ACTIONS_MAX 8
#define HIST_CONST_DIGITS_MAX 21
#define HIST_DIV_SHIFT  20  /* For optimizing division by constants */

enum field_op_id {
 FIELD_OP_NONE,
 FIELD_OP_PLUS,
 FIELD_OP_MINUS,
 FIELD_OP_UNARY_MINUS,
 FIELD_OP_DIV,
 FIELD_OP_MULT,
};

enum hist_field_fn {
 HIST_FIELD_FN_NOP,
 HIST_FIELD_FN_VAR_REF,
 HIST_FIELD_FN_COUNTER,
 HIST_FIELD_FN_CONST,
 HIST_FIELD_FN_LOG2,
 HIST_FIELD_FN_BUCKET,
 HIST_FIELD_FN_TIMESTAMP,
 HIST_FIELD_FN_CPU,
 HIST_FIELD_FN_COMM,
 HIST_FIELD_FN_STRING,
 HIST_FIELD_FN_DYNSTRING,
 HIST_FIELD_FN_RELDYNSTRING,
 HIST_FIELD_FN_PSTRING,
 HIST_FIELD_FN_S64,
 HIST_FIELD_FN_U64,
 HIST_FIELD_FN_S32,
 HIST_FIELD_FN_U32,
 HIST_FIELD_FN_S16,
 HIST_FIELD_FN_U16,
 HIST_FIELD_FN_S8,
 HIST_FIELD_FN_U8,
 HIST_FIELD_FN_UMINUS,
 HIST_FIELD_FN_MINUS,
 HIST_FIELD_FN_PLUS,
 HIST_FIELD_FN_DIV,
 HIST_FIELD_FN_MULT,
 HIST_FIELD_FN_DIV_POWER2,
 HIST_FIELD_FN_DIV_NOT_POWER2,
 HIST_FIELD_FN_DIV_MULT_SHIFT,
 HIST_FIELD_FN_EXECNAME,
 HIST_FIELD_FN_STACK,
};

/*
 * A hist_var (histogram variable) contains variable information for
 * hist_fields having the HIST_FIELD_FL_VAR or HIST_FIELD_FL_VAR_REF
 * flag set.  A hist_var has a variable name e.g. ts0, and is
 * associated with a given histogram trigger, as specified by
 * hist_data.  The hist_var idx is the unique index assigned to the
 * variable by the hist trigger's tracing_map.  The idx is what is
 * used to set a variable's value and, by a variable reference, to
 * retrieve it.
 */
struct hist_var {
 char    *name;
 struct hist_trigger_data *hist_data;
 unsigned int   idx;
};

struct hist_field {
 struct ftrace_event_field *field;
 unsigned long   flags;
 unsigned long   buckets;
 const char   *type;
 struct hist_field  *operands[HIST_FIELD_OPERANDS_MAX];
 struct hist_trigger_data *hist_data;
 enum hist_field_fn  fn_num;
 unsigned int   ref;
 unsigned int   size;
 unsigned int   offset;
 unsigned int                    is_signed;

 /*
 * Variable fields contain variable-specific info in var.
 */
 struct hist_var   var;
 enum field_op_id  operator;
 char    *system;
 char    *event_name;

 /*
 * The name field is used for EXPR and VAR_REF fields.  VAR
 * fields contain the variable name in var.name.
 */
 char    *name;

 /*
 * When a histogram trigger is hit, if it has any references
 * to variables, the values of those variables are collected
 * into a var_ref_vals array by resolve_var_refs().  The
 * current value of each variable is read from the tracing_map
 * using the hist field's hist_var.idx and entered into the
 * var_ref_idx entry i.e. var_ref_vals[var_ref_idx].
 */
 unsigned int   var_ref_idx;
 bool                            read_once;

 unsigned int   var_str_idx;

 /* Numeric literals are represented as u64 */
 u64    constant;
 /* Used to optimize division by constants */
 u64    div_multiplier;
};

static u64 hist_fn_call(struct hist_field *hist_field,
   struct tracing_map_elt *elt,
   struct trace_buffer *buffer,
   struct ring_buffer_event *rbe,
   void *event);

static u64 hist_field_const(struct hist_field *field,
      struct tracing_map_elt *elt,
      struct trace_buffer *buffer,
      struct ring_buffer_event *rbe,
      void *event)
{
 return field->constant;
}

static u64 hist_field_counter(struct hist_field *field,
         struct tracing_map_elt *elt,
         struct trace_buffer *buffer,
         struct ring_buffer_event *rbe,
         void *event)
{
 return 1;
}

static u64 hist_field_string(struct hist_field *hist_field,
        struct tracing_map_elt *elt,
        struct trace_buffer *buffer,
        struct ring_buffer_event *rbe,
        void *event)
{
 char *addr = (char *)(event + hist_field->field->offset);

 return (u64)(unsigned long)addr;
}

static u64 hist_field_dynstring(struct hist_field *hist_field,
    struct tracing_map_elt *elt,
    struct trace_buffer *buffer,
    struct ring_buffer_event *rbe,
    void *event)
{
 u32 str_item = *(u32 *)(event + hist_field->field->offset);
 int str_loc = str_item & 0xffff;
 char *addr = (char *)(event + str_loc);

 return (u64)(unsigned long)addr;
}

static u64 hist_field_reldynstring(struct hist_field *hist_field,
       struct tracing_map_elt *elt,
       struct trace_buffer *buffer,
       struct ring_buffer_event *rbe,
       void *event)
{
 u32 *item = event + hist_field->field->offset;
 u32 str_item = *item;
 int str_loc = str_item & 0xffff;
 char *addr = (char *)&item[1] + str_loc;

 return (u64)(unsigned long)addr;
}

static u64 hist_field_pstring(struct hist_field *hist_field,
         struct tracing_map_elt *elt,
         struct trace_buffer *buffer,
         struct ring_buffer_event *rbe,
         void *event)
{
 char **addr = (char **)(event + hist_field->field->offset);

 return (u64)(unsigned long)*addr;
}

static u64 hist_field_log2(struct hist_field *hist_field,
      struct tracing_map_elt *elt,
      struct trace_buffer *buffer,
      struct ring_buffer_event *rbe,
      void *event)
{
 struct hist_field *operand = hist_field->operands[0];

 u64 val = hist_fn_call(operand, elt, buffer, rbe, event);

 return (u64) ilog2(roundup_pow_of_two(val));
}

static u64 hist_field_bucket(struct hist_field *hist_field,
        struct tracing_map_elt *elt,
        struct trace_buffer *buffer,
        struct ring_buffer_event *rbe,
        void *event)
{
 struct hist_field *operand = hist_field->operands[0];
 unsigned long buckets = hist_field->buckets;

 u64 val = hist_fn_call(operand, elt, buffer, rbe, event);

 if (WARN_ON_ONCE(!buckets))
  return val;

 if (val >= LONG_MAX)
  val = div64_ul(val, buckets);
 else
  val = (u64)((unsigned long)val / buckets);
 return val * buckets;
}

static u64 hist_field_plus(struct hist_field *hist_field,
      struct tracing_map_elt *elt,
      struct trace_buffer *buffer,
      struct ring_buffer_event *rbe,
      void *event)
{
 struct hist_field *operand1 = hist_field->operands[0];
 struct hist_field *operand2 = hist_field->operands[1];

 u64 val1 = hist_fn_call(operand1, elt, buffer, rbe, event);
 u64 val2 = hist_fn_call(operand2, elt, buffer, rbe, event);

 return val1 + val2;
}

static u64 hist_field_minus(struct hist_field *hist_field,
       struct tracing_map_elt *elt,
       struct trace_buffer *buffer,
       struct ring_buffer_event *rbe,
       void *event)
{
 struct hist_field *operand1 = hist_field->operands[0];
 struct hist_field *operand2 = hist_field->operands[1];

 u64 val1 = hist_fn_call(operand1, elt, buffer, rbe, event);
 u64 val2 = hist_fn_call(operand2, elt, buffer, rbe, event);

 return val1 - val2;
}

static u64 hist_field_div(struct hist_field *hist_field,
      struct tracing_map_elt *elt,
      struct trace_buffer *buffer,
      struct ring_buffer_event *rbe,
      void *event)
{
 struct hist_field *operand1 = hist_field->operands[0];
 struct hist_field *operand2 = hist_field->operands[1];

 u64 val1 = hist_fn_call(operand1, elt, buffer, rbe, event);
 u64 val2 = hist_fn_call(operand2, elt, buffer, rbe, event);

 /* Return -1 for the undefined case */
 if (!val2)
  return -1;

 /* Use shift if the divisor is a power of 2 */
 if (!(val2 & (val2 - 1)))
  return val1 >> __ffs64(val2);

 return div64_u64(val1, val2);
}

static u64 div_by_power_of_two(struct hist_field *hist_field,
    struct tracing_map_elt *elt,
    struct trace_buffer *buffer,
    struct ring_buffer_event *rbe,
    void *event)
{
 struct hist_field *operand1 = hist_field->operands[0];
 struct hist_field *operand2 = hist_field->operands[1];

 u64 val1 = hist_fn_call(operand1, elt, buffer, rbe, event);

 return val1 >> __ffs64(operand2->constant);
}

static u64 div_by_not_power_of_two(struct hist_field *hist_field,
    struct tracing_map_elt *elt,
    struct trace_buffer *buffer,
    struct ring_buffer_event *rbe,
    void *event)
{
 struct hist_field *operand1 = hist_field->operands[0];
 struct hist_field *operand2 = hist_field->operands[1];

 u64 val1 = hist_fn_call(operand1, elt, buffer, rbe, event);

 return div64_u64(val1, operand2->constant);
}

static u64 div_by_mult_and_shift(struct hist_field *hist_field,
    struct tracing_map_elt *elt,
    struct trace_buffer *buffer,
    struct ring_buffer_event *rbe,
    void *event)
{
 struct hist_field *operand1 = hist_field->operands[0];
 struct hist_field *operand2 = hist_field->operands[1];

 u64 val1 = hist_fn_call(operand1, elt, buffer, rbe, event);

 /*
 * If the divisor is a constant, do a multiplication and shift instead.
 *
 * Choose Z = some power of 2. If Y <= Z, then:
 *     X / Y = (X * (Z / Y)) / Z
 *
 * (Z / Y) is a constant (mult) which is calculated at parse time, so:
 *     X / Y = (X * mult) / Z
 *
 * The division by Z can be replaced by a shift since Z is a power of 2:
 *     X / Y = (X * mult) >> HIST_DIV_SHIFT
 *
 * As long, as X < Z the results will not be off by more than 1.
 */
 if (val1 < (1 << HIST_DIV_SHIFT)) {
  u64 mult = operand2->div_multiplier;

  return (val1 * mult + ((1 << HIST_DIV_SHIFT) - 1)) >> HIST_DIV_SHIFT;
 }

 return div64_u64(val1, operand2->constant);
}

static u64 hist_field_mult(struct hist_field *hist_field,
      struct tracing_map_elt *elt,
      struct trace_buffer *buffer,
      struct ring_buffer_event *rbe,
      void *event)
{
 struct hist_field *operand1 = hist_field->operands[0];
 struct hist_field *operand2 = hist_field->operands[1];

 u64 val1 = hist_fn_call(operand1, elt, buffer, rbe, event);
 u64 val2 = hist_fn_call(operand2, elt, buffer, rbe, event);

 return val1 * val2;
}

static u64 hist_field_unary_minus(struct hist_field *hist_field,
      struct tracing_map_elt *elt,
      struct trace_buffer *buffer,
      struct ring_buffer_event *rbe,
      void *event)
{
 struct hist_field *operand = hist_field->operands[0];

 s64 sval = (s64)hist_fn_call(operand, elt, buffer, rbe, event);
 u64 val = (u64)-sval;

 return val;
}

#define DEFINE_HIST_FIELD_FN(type)     \
 static u64 hist_field_##type(struct hist_field *hist_field, \
         struct tracing_map_elt *elt, \
         struct trace_buffer *buffer, \
         struct ring_buffer_event *rbe, \
         void *event)   \
{         \
 type *addr = (type *)(event + hist_field->field->offset); \
         \
 return (u64)(unsigned long)*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 for_each_hist_field(i, hist_data) \
 for ((i) = 0; (i) < (hist_data)->n_fields; (i)++)

#define for_each_hist_val_field(i, hist_data) \
 for ((i) = 0; (i) < (hist_data)->n_vals; (i)++)

#define for_each_hist_key_field(i, hist_data) \
 for ((i) = (hist_data)->n_vals; (i) < (hist_data)->n_fields; (i)++)

#define HITCOUNT_IDX  0
#define HIST_KEY_SIZE_MAX (MAX_FILTER_STR_VAL + HIST_STACKTRACE_SIZE)

enum hist_field_flags {
 HIST_FIELD_FL_HITCOUNT  = 1 << 0,
 HIST_FIELD_FL_KEY  = 1 << 1,
 HIST_FIELD_FL_STRING  = 1 << 2,
 HIST_FIELD_FL_HEX  = 1 << 3,
 HIST_FIELD_FL_SYM  = 1 << 4,
 HIST_FIELD_FL_SYM_OFFSET = 1 << 5,
 HIST_FIELD_FL_EXECNAME  = 1 << 6,
 HIST_FIELD_FL_SYSCALL  = 1 << 7,
 HIST_FIELD_FL_STACKTRACE = 1 << 8,
 HIST_FIELD_FL_LOG2  = 1 << 9,
 HIST_FIELD_FL_TIMESTAMP  = 1 << 10,
 HIST_FIELD_FL_TIMESTAMP_USECS = 1 << 11,
 HIST_FIELD_FL_VAR  = 1 << 12,
 HIST_FIELD_FL_EXPR  = 1 << 13,
 HIST_FIELD_FL_VAR_REF  = 1 << 14,
 HIST_FIELD_FL_CPU  = 1 << 15,
 HIST_FIELD_FL_ALIAS  = 1 << 16,
 HIST_FIELD_FL_BUCKET  = 1 << 17,
 HIST_FIELD_FL_CONST  = 1 << 18,
 HIST_FIELD_FL_PERCENT  = 1 << 19,
 HIST_FIELD_FL_GRAPH  = 1 << 20,
 HIST_FIELD_FL_COMM  = 1 << 21,
};

struct var_defs {
 unsigned int n_vars;
 char  *name[TRACING_MAP_VARS_MAX];
 char  *expr[TRACING_MAP_VARS_MAX];
};

struct hist_trigger_attrs {
 char  *keys_str;
 char  *vals_str;
 char  *sort_key_str;
 char  *name;
 char  *clock;
 bool  pause;
 bool  cont;
 bool  clear;
 bool  ts_in_usecs;
 bool  no_hitcount;
 unsigned int map_bits;

 char  *assignment_str[TRACING_MAP_VARS_MAX];
 unsigned int n_assignments;

 char  *action_str[HIST_ACTIONS_MAX];
 unsigned int n_actions;

 struct var_defs var_defs;
};

struct field_var {
 struct hist_field *var;
 struct hist_field *val;
};

struct field_var_hist {
 struct hist_trigger_data *hist_data;
 char    *cmd;
};

struct hist_trigger_data {
 struct hist_field               *fields[HIST_FIELDS_MAX];
 unsigned int   n_vals;
 unsigned int   n_keys;
 unsigned int   n_fields;
 unsigned int   n_vars;
 unsigned int   n_var_str;
 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;
 struct hist_trigger_attrs *attrs;
 struct tracing_map  *map;
 bool    enable_timestamps;
 bool    remove;
 struct hist_field               *var_refs[TRACING_MAP_VARS_MAX];
 unsigned int   n_var_refs;

 struct action_data  *actions[HIST_ACTIONS_MAX];
 unsigned int   n_actions;

 struct field_var  *field_vars[SYNTH_FIELDS_MAX];
 unsigned int   n_field_vars;
 unsigned int   n_field_var_str;
 struct field_var_hist  *field_var_hists[SYNTH_FIELDS_MAX];
 unsigned int   n_field_var_hists;

 struct field_var  *save_vars[SYNTH_FIELDS_MAX];
 unsigned int   n_save_vars;
 unsigned int   n_save_var_str;
};

struct action_data;

typedef void (*action_fn_t) (struct hist_trigger_data *hist_data,
        struct tracing_map_elt *elt,
        struct trace_buffer *buffer, void *rec,
        struct ring_buffer_event *rbe, void *key,
        struct action_data *data, u64 *var_ref_vals);

typedef bool (*check_track_val_fn_t) (u64 track_val, u64 var_val);

enum handler_id {
 HANDLER_ONMATCH = 1,
 HANDLER_ONMAX,
 HANDLER_ONCHANGE,
};

enum action_id {
 ACTION_SAVE = 1,
 ACTION_TRACE,
 ACTION_SNAPSHOT,
};

struct action_data {
 enum handler_id  handler;
 enum action_id  action;
 char   *action_name;
 action_fn_t  fn;

 unsigned int  n_params;
 char   *params[SYNTH_FIELDS_MAX];

 /*
 * When a histogram trigger is hit, the values of any
 * references to variables, including variables being passed
 * as parameters to synthetic events, are collected into a
 * var_ref_vals array.  This var_ref_idx array is an array of
 * indices into the var_ref_vals array, one for each synthetic
 * event param, and is passed to the synthetic event
 * invocation.
 */
 unsigned int  var_ref_idx[SYNTH_FIELDS_MAX];
 struct synth_event *synth_event;
 bool   use_trace_keyword;
 char   *synth_event_name;

 union {
  struct {
   char   *event;
   char   *event_system;
  } match_data;

  struct {
   /*
 * var_str contains the $-unstripped variable
 * name referenced by var_ref, and used when
 * printing the action.  Because var_ref
 * creation is deferred to create_actions(),
 * we need a per-action way to save it until
 * then, thus var_str.
 */
   char   *var_str;

   /*
 * var_ref refers to the variable being
 * tracked e.g onmax($var).
 */
   struct hist_field *var_ref;

   /*
 * track_var contains the 'invisible' tracking
 * variable created to keep the current
 * e.g. max value.
 */
   struct hist_field *track_var;

   check_track_val_fn_t check_val;
   action_fn_t  save_data;
  } track_data;
 };
};

struct track_data {
 u64    track_val;
 bool    updated;

 unsigned int   key_len;
 void    *key;
 struct tracing_map_elt  elt;

 struct action_data  *action_data;
 struct hist_trigger_data *hist_data;
};

struct hist_elt_data {
 char *comm;
 u64 *var_ref_vals;
 char **field_var_str;
 int n_field_var_str;
};

struct snapshot_context {
 struct tracing_map_elt *elt;
 void   *key;
};

/*
 * Returns the specific division function to use if the divisor
 * is constant. This avoids extra branches when the trigger is hit.
 */
static enum hist_field_fn hist_field_get_div_fn(struct hist_field *divisor)
{
 u64 div = divisor->constant;

 if (!(div & (div - 1)))
  return HIST_FIELD_FN_DIV_POWER2;

 /* If the divisor is too large, do a regular division */
 if (div > (1 << HIST_DIV_SHIFT))
  return HIST_FIELD_FN_DIV_NOT_POWER2;

 divisor->div_multiplier = div64_u64((u64)(1 << HIST_DIV_SHIFT), div);
 return HIST_FIELD_FN_DIV_MULT_SHIFT;
}

static void track_data_free(struct track_data *track_data)
{
 struct hist_elt_data *elt_data;

 if (!track_data)
  return;

 kfree(track_data->key);

 elt_data = track_data->elt.private_data;
 if (elt_data) {
  kfree(elt_data->comm);
  kfree(elt_data);
 }

 kfree(track_data);
}

static struct track_data *track_data_alloc(unsigned int key_len,
        struct action_data *action_data,
        struct hist_trigger_data *hist_data)
{
 struct track_data *data = kzalloc(sizeof(*data), GFP_KERNEL);
 struct hist_elt_data *elt_data;

 if (!data)
  return ERR_PTR(-ENOMEM);

 data->key = kzalloc(key_len, GFP_KERNEL);
 if (!data->key) {
  track_data_free(data);
  return ERR_PTR(-ENOMEM);
 }

 data->key_len = key_len;
 data->action_data = action_data;
 data->hist_data = hist_data;

 elt_data = kzalloc(sizeof(*elt_data), GFP_KERNEL);
 if (!elt_data) {
  track_data_free(data);
  return ERR_PTR(-ENOMEM);
 }

 data->elt.private_data = elt_data;

 elt_data->comm = kzalloc(TASK_COMM_LEN, GFP_KERNEL);
 if (!elt_data->comm) {
  track_data_free(data);
  return ERR_PTR(-ENOMEM);
 }

 return data;
}

#define HIST_PREFIX "hist:"

static char *last_cmd;
static char last_cmd_loc[MAX_FILTER_STR_VAL];

static int errpos(char *str)
{
 if (!str || !last_cmd)
  return 0;

 return err_pos(last_cmd, str);
}

static void last_cmd_set(struct trace_event_file *file, char *str)
{
 const char *system = NULL, *name = NULL;
 struct trace_event_call *call;

 if (!str)
  return;

 kfree(last_cmd);

 last_cmd = kasprintf(GFP_KERNEL, HIST_PREFIX "%s", str);
 if (!last_cmd)
  return;

 if (file) {
  call = file->event_call;
  system = call->class->system;
  if (system) {
   name = trace_event_name(call);
   if (!name)
    system = NULL;
  }
 }

 if (system)
  snprintf(last_cmd_loc, MAX_FILTER_STR_VAL, HIST_PREFIX "%s:%s", system, name);
}

static void hist_err(struct trace_array *tr, u8 err_type, u16 err_pos)
{
 if (!last_cmd)
  return;

 tracing_log_err(tr, last_cmd_loc, last_cmd, err_text,
   err_type, err_pos);
}

static void hist_err_clear(void)
{
 if (last_cmd)
  last_cmd[0] = '\0';
 last_cmd_loc[0] = '\0';
}

typedef void (*synth_probe_func_t) (void *__data, u64 *var_ref_vals,
        unsigned int *var_ref_idx);

static inline void trace_synth(struct synth_event *event, u64 *var_ref_vals,
          unsigned int *var_ref_idx)
{
 struct tracepoint *tp = event->tp;

 if (unlikely(static_key_enabled(&tp->key))) {
  struct tracepoint_func *probe_func_ptr;
  synth_probe_func_t probe_func;
  void *__data;

  if (!(cpu_online(raw_smp_processor_id())))
   return;

  probe_func_ptr = rcu_dereference_sched((tp)->funcs);
  if (probe_func_ptr) {
   do {
    probe_func = probe_func_ptr->func;
    __data = probe_func_ptr->data;
    probe_func(__data, var_ref_vals, var_ref_idx);
   } while ((++probe_func_ptr)->func);
  }
 }
}

static void action_trace(struct hist_trigger_data *hist_data,
    struct tracing_map_elt *elt,
    struct trace_buffer *buffer, void *rec,
    struct ring_buffer_event *rbe, void *key,
    struct action_data *data, u64 *var_ref_vals)
{
 struct synth_event *event = data->synth_event;

 trace_synth(event, var_ref_vals, data->var_ref_idx);
}

struct hist_var_data {
 struct list_head list;
 struct hist_trigger_data *hist_data;
};

static u64 hist_field_timestamp(struct hist_field *hist_field,
    struct tracing_map_elt *elt,
    struct trace_buffer *buffer,
    struct ring_buffer_event *rbe,
    void *event)
{
 struct hist_trigger_data *hist_data = hist_field->hist_data;
 struct trace_array *tr = hist_data->event_file->tr;

 u64 ts = ring_buffer_event_time_stamp(buffer, rbe);

 if (hist_data->attrs->ts_in_usecs && trace_clock_in_ns(tr))
  ts = ns2usecs(ts);

 return ts;
}

static u64 hist_field_cpu(struct hist_field *hist_field,
     struct tracing_map_elt *elt,
     struct trace_buffer *buffer,
     struct ring_buffer_event *rbe,
     void *event)
{
 int cpu = smp_processor_id();

 return cpu;
}

static u64 hist_field_comm(struct hist_field *hist_field,
     struct tracing_map_elt *elt,
     struct trace_buffer *buffer,
     struct ring_buffer_event *rbe,
     void *event)
{
 return (u64)(unsigned long)current->comm;
}

/**
 * check_field_for_var_ref - Check if a VAR_REF field references a variable
 * @hist_field: The VAR_REF field to check
 * @var_data: The hist trigger that owns the variable
 * @var_idx: The trigger variable identifier
 *
 * Check the given VAR_REF field to see whether or not it references
 * the given variable associated with the given trigger.
 *
 * Return: The VAR_REF field if it does reference the variable, NULL if not
 */
static struct hist_field *
check_field_for_var_ref(struct hist_field *hist_field,
   struct hist_trigger_data *var_data,
   unsigned int var_idx)
{
 WARN_ON(!(hist_field && hist_field->flags & HIST_FIELD_FL_VAR_REF));

 if (hist_field && hist_field->var.idx == var_idx &&
     hist_field->var.hist_data == var_data)
  return hist_field;

 return NULL;
}

/**
 * find_var_ref - Check if a trigger has a reference to a trigger variable
 * @hist_data: The hist trigger that might have a reference to the variable
 * @var_data: The hist trigger that owns the variable
 * @var_idx: The trigger variable identifier
 *
 * Check the list of var_refs[] on the first hist trigger to see
 * whether any of them are references to the variable on the second
 * trigger.
 *
 * Return: The VAR_REF field referencing the variable if so, NULL if not
 */
static struct hist_field *find_var_ref(struct hist_trigger_data *hist_data,
           struct hist_trigger_data *var_data,
           unsigned int var_idx)
{
 struct hist_field *hist_field;
 unsigned int i;

 for (i = 0; i < hist_data->n_var_refs; i++) {
  hist_field = hist_data->var_refs[i];
  if (check_field_for_var_ref(hist_field, var_data, var_idx))
   return hist_field;
 }

 return NULL;
}

/**
 * find_any_var_ref - Check if there is a reference to a given trigger variable
 * @hist_data: The hist trigger
 * @var_idx: The trigger variable identifier
 *
 * Check to see whether the given variable is currently referenced by
 * any other trigger.
 *
 * The trigger the variable is defined on is explicitly excluded - the
 * assumption being that a self-reference doesn't prevent a trigger
 * from being removed.
 *
 * Return: The VAR_REF field referencing the variable if so, NULL if not
 */
static struct hist_field *find_any_var_ref(struct hist_trigger_data *hist_data,
        unsigned int var_idx)
{
 struct trace_array *tr = hist_data->event_file->tr;
 struct hist_field *found = NULL;
 struct hist_var_data *var_data;

 list_for_each_entry(var_data, &tr->hist_vars, list) {
  if (var_data->hist_data == hist_data)
   continue;
  found = find_var_ref(var_data->hist_data, hist_data, var_idx);
  if (found)
   break;
 }

 return found;
}

/**
 * check_var_refs - Check if there is a reference to any of trigger's variables
 * @hist_data: The hist trigger
 *
 * A trigger can define one or more variables.  If any one of them is
 * currently referenced by any other trigger, this function will
 * determine that.
 *
 * Typically used to determine whether or not a trigger can be removed
 * - if there are any references to a trigger's variables, it cannot.
 *
 * Return: True if there is a reference to any of trigger's variables
 */
static bool check_var_refs(struct hist_trigger_data *hist_data)
{
 struct hist_field *field;
 bool found = false;
 int i;

 for_each_hist_field(i, hist_data) {
  field = hist_data->fields[i];
  if (field && field->flags & HIST_FIELD_FL_VAR) {
   if (find_any_var_ref(hist_data, field->var.idx)) {
    found = true;
    break;
   }
  }
 }

 return found;
}

static struct hist_var_data *find_hist_vars(struct hist_trigger_data *hist_data)
{
 struct trace_array *tr = hist_data->event_file->tr;
 struct hist_var_data *var_data, *found = NULL;

 list_for_each_entry(var_data, &tr->hist_vars, list) {
  if (var_data->hist_data == hist_data) {
   found = var_data;
   break;
  }
 }

 return found;
}

static bool field_has_hist_vars(struct hist_field *hist_field,
    unsigned int level)
{
 int i;

 if (level > 3)
  return false;

 if (!hist_field)
  return false;

 if (hist_field->flags & HIST_FIELD_FL_VAR ||
     hist_field->flags & HIST_FIELD_FL_VAR_REF)
  return true;

 for (i = 0; i < HIST_FIELD_OPERANDS_MAX; i++) {
  struct hist_field *operand;

  operand = hist_field->operands[i];
  if (field_has_hist_vars(operand, level + 1))
   return true;
 }

 return false;
}

static bool has_hist_vars(struct hist_trigger_data *hist_data)
{
 struct hist_field *hist_field;
 int i;

 for_each_hist_field(i, hist_data) {
  hist_field = hist_data->fields[i];
  if (field_has_hist_vars(hist_field, 0))
   return true;
 }

 return false;
}

static int save_hist_vars(struct hist_trigger_data *hist_data)
{
 struct trace_array *tr = hist_data->event_file->tr;
 struct hist_var_data *var_data;

 var_data = find_hist_vars(hist_data);
 if (var_data)
  return 0;

 if (tracing_check_open_get_tr(tr))
  return -ENODEV;

 var_data = kzalloc(sizeof(*var_data), GFP_KERNEL);
 if (!var_data) {
  trace_array_put(tr);
  return -ENOMEM;
 }

 var_data->hist_data = hist_data;
 list_add(&var_data->list, &tr->hist_vars);

 return 0;
}

static void remove_hist_vars(struct hist_trigger_data *hist_data)
{
 struct trace_array *tr = hist_data->event_file->tr;
 struct hist_var_data *var_data;

 var_data = find_hist_vars(hist_data);
 if (!var_data)
  return;

 if (WARN_ON(check_var_refs(hist_data)))
  return;

 list_del(&var_data->list);

 kfree(var_data);

 trace_array_put(tr);
}

static struct hist_field *find_var_field(struct hist_trigger_data *hist_data,
      const char *var_name)
{
 struct hist_field *hist_field, *found = NULL;
 int i;

 for_each_hist_field(i, hist_data) {
  hist_field = hist_data->fields[i];
  if (hist_field && hist_field->flags & HIST_FIELD_FL_VAR &&
      strcmp(hist_field->var.name, var_name) == 0) {
   found = hist_field;
   break;
  }
 }

 return found;
}

static struct hist_field *find_var(struct hist_trigger_data *hist_data,
       struct trace_event_file *file,
       const char *var_name)
{
 struct hist_trigger_data *test_data;
 struct event_trigger_data *test;
 struct hist_field *hist_field;

 lockdep_assert_held(&event_mutex);

 hist_field = find_var_field(hist_data, var_name);
 if (hist_field)
  return hist_field;

 list_for_each_entry(test, &file->triggers, list) {
  if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
   test_data = test->private_data;
   hist_field = find_var_field(test_data, var_name);
   if (hist_field)
    return hist_field;
  }
 }

 return NULL;
}

static struct trace_event_file *find_var_file(struct trace_array *tr,
           char *system,
           char *event_name,
           char *var_name)
{
 struct hist_trigger_data *var_hist_data;
 struct hist_var_data *var_data;
 struct trace_event_file *file, *found = NULL;

 if (system)
  return find_event_file(tr, system, event_name);

 list_for_each_entry(var_data, &tr->hist_vars, list) {
  var_hist_data = var_data->hist_data;
  file = var_hist_data->event_file;
  if (file == found)
   continue;

  if (find_var_field(var_hist_data, var_name)) {
   if (found) {
    hist_err(tr, HIST_ERR_VAR_NOT_UNIQUE, errpos(var_name));
    return NULL;
   }

   found = file;
  }
 }

 return found;
}

static struct hist_field *find_file_var(struct trace_event_file *file,
     const char *var_name)
{
 struct hist_trigger_data *test_data;
 struct event_trigger_data *test;
 struct hist_field *hist_field;

 lockdep_assert_held(&event_mutex);

 list_for_each_entry(test, &file->triggers, list) {
  if (test->cmd_ops->trigger_type == ETT_EVENT_HIST) {
   test_data = test->private_data;
   hist_field = find_var_field(test_data, var_name);
   if (hist_field)
    return hist_field;
  }
 }

 return NULL;
}

static struct hist_field *
find_match_var(struct hist_trigger_data *hist_data, char *var_name)
{
 struct trace_array *tr = hist_data->event_file->tr;
 struct hist_field *hist_field, *found = NULL;
 struct trace_event_file *file;
 unsigned int i;

 for (i = 0; i < hist_data->n_actions; i++) {
  struct action_data *data = hist_data->actions[i];

  if (data->handler == HANDLER_ONMATCH) {
   char *system = data->match_data.event_system;
   char *event_name = data->match_data.event;

   file = find_var_file(tr, system, event_name, var_name);
   if (!file)
    continue;
   hist_field = find_file_var(file, var_name);
   if (hist_field) {
    if (found) {
     hist_err(tr, HIST_ERR_VAR_NOT_UNIQUE,
       errpos(var_name));
     return ERR_PTR(-EINVAL);
    }

    found = hist_field;
   }
  }
 }
 return found;
}

static struct hist_field *find_event_var(struct hist_trigger_data *hist_data,
      char *system,
      char *event_name,
      char *var_name)
{
 struct trace_array *tr = hist_data->event_file->tr;
 struct hist_field *hist_field = NULL;
 struct trace_event_file *file;

 if (!system || !event_name) {
  hist_field = find_match_var(hist_data, var_name);
  if (IS_ERR(hist_field))
   return NULL;
  if (hist_field)
   return hist_field;
 }

 file = find_var_file(tr, system, event_name, var_name);
 if (!file)
  return NULL;

 hist_field = find_file_var(file, var_name);

 return hist_field;
}

static u64 hist_field_var_ref(struct hist_field *hist_field,
         struct tracing_map_elt *elt,
         struct trace_buffer *buffer,
         struct ring_buffer_event *rbe,
         void *event)
{
 struct hist_elt_data *elt_data;
 u64 var_val = 0;

 if (WARN_ON_ONCE(!elt))
  return var_val;

 elt_data = elt->private_data;
 var_val = elt_data->var_ref_vals[hist_field->var_ref_idx];

 return var_val;
}

static bool resolve_var_refs(struct hist_trigger_data *hist_data, void *key,
        u64 *var_ref_vals, bool self)
{
 struct hist_trigger_data *var_data;
 struct tracing_map_elt *var_elt;
 struct hist_field *hist_field;
 unsigned int i, var_idx;
 bool resolved = true;
 u64 var_val = 0;

 for (i = 0; i < hist_data->n_var_refs; i++) {
  hist_field = hist_data->var_refs[i];
  var_idx = hist_field->var.idx;
  var_data = hist_field->var.hist_data;

  if (var_data == NULL) {
   resolved = false;
   break;
  }

  if ((self && var_data != hist_data) ||
      (!self && var_data == hist_data))
   continue;

  var_elt = tracing_map_lookup(var_data->map, key);
  if (!var_elt) {
   resolved = false;
   break;
  }

  if (!tracing_map_var_set(var_elt, var_idx)) {
   resolved = false;
   break;
  }

  if (self || !hist_field->read_once)
   var_val = tracing_map_read_var(var_elt, var_idx);
  else
   var_val = tracing_map_read_var_once(var_elt, var_idx);

  var_ref_vals[i] = var_val;
 }

 return resolved;
}

static const char *hist_field_name(struct hist_field *field,
       unsigned int level)
{
 const char *field_name = "";

 if (WARN_ON_ONCE(!field))
  return field_name;

 if (level > 1)
  return field_name;

 if (field->field)
  field_name = field->field->name;
 else if (field->flags & HIST_FIELD_FL_LOG2 ||
   field->flags & HIST_FIELD_FL_ALIAS ||
   field->flags & HIST_FIELD_FL_BUCKET)
  field_name = hist_field_name(field->operands[0], ++level);
 else if (field->flags & HIST_FIELD_FL_CPU)
  field_name = "common_cpu";
 else if (field->flags & HIST_FIELD_FL_COMM)
  field_name = "common_comm";
 else if (field->flags & HIST_FIELD_FL_EXPR ||
   field->flags & HIST_FIELD_FL_VAR_REF) {
  if (field->system) {
   static char full_name[MAX_FILTER_STR_VAL];

   strcat(full_name, field->system);
   strcat(full_name, ".");
   strcat(full_name, field->event_name);
   strcat(full_name, ".");
   strcat(full_name, field->name);
   field_name = full_name;
  } else
   field_name = field->name;
 } else if (field->flags & HIST_FIELD_FL_TIMESTAMP)
  field_name = "common_timestamp";
 else if (field->flags & HIST_FIELD_FL_STACKTRACE) {
  field_name = "common_stacktrace";
 } else if (field->flags & HIST_FIELD_FL_HITCOUNT)
  field_name = "hitcount";

 if (field_name == NULL)
  field_name = "";

 return field_name;
}

static enum hist_field_fn select_value_fn(int field_size, int field_is_signed)
{
 switch (field_size) {
 case 8:
  if (field_is_signed)
   return HIST_FIELD_FN_S64;
  else
   return HIST_FIELD_FN_U64;
 case 4:
  if (field_is_signed)
   return HIST_FIELD_FN_S32;
  else
   return HIST_FIELD_FN_U32;
 case 2:
  if (field_is_signed)
   return HIST_FIELD_FN_S16;
  else
   return HIST_FIELD_FN_U16;
 case 1:
  if (field_is_signed)
   return HIST_FIELD_FN_S8;
  else
   return HIST_FIELD_FN_U8;
 }

 return HIST_FIELD_FN_NOP;
}

static int parse_map_size(char *str)
{
 unsigned long size, map_bits;
 int ret;

 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)
{
 unsigned int i;

 if (!attrs)
  return;

 for (i = 0; i < attrs->n_assignments; i++)
  kfree(attrs->assignment_str[i]);

 for (i = 0; i < attrs->n_actions; i++)
  kfree(attrs->action_str[i]);

 kfree(attrs->name);
 kfree(attrs->sort_key_str);
 kfree(attrs->keys_str);
 kfree(attrs->vals_str);
 kfree(attrs->clock);
 kfree(attrs);
}

static int parse_action(char *str, struct hist_trigger_attrs *attrs)
{
 int ret = -EINVAL;

 if (attrs->n_actions >= HIST_ACTIONS_MAX)
  return ret;

 if ((str_has_prefix(str, "onmatch(")) ||
     (str_has_prefix(str, "onmax(")) ||
     (str_has_prefix(str, "onchange("))) {
  attrs->action_str[attrs->n_actions] = kstrdup(str, GFP_KERNEL);
  if (!attrs->action_str[attrs->n_actions]) {
   ret = -ENOMEM;
   return ret;
  }
  attrs->n_actions++;
  ret = 0;
 }
 return ret;
}

static int parse_assignment(struct trace_array *tr,
       char *str, struct hist_trigger_attrs *attrs)
{
 int len, ret = 0;

 if ((len = str_has_prefix(str, "key=")) ||
     (len = str_has_prefix(str, "keys="))) {
  attrs->keys_str = kstrdup(str + len, GFP_KERNEL);
  if (!attrs->keys_str) {
   ret = -ENOMEM;
   goto out;
  }
 } else if ((len = str_has_prefix(str, "val=")) ||
     (len = str_has_prefix(str, "vals=")) ||
     (len = str_has_prefix(str, "values="))) {
  attrs->vals_str = kstrdup(str + len, GFP_KERNEL);
  if (!attrs->vals_str) {
   ret = -ENOMEM;
   goto out;
  }
 } else if ((len = str_has_prefix(str, "sort="))) {
  attrs->sort_key_str = kstrdup(str + len, GFP_KERNEL);
  if (!attrs->sort_key_str) {
   ret = -ENOMEM;
   goto out;
  }
 } else if (str_has_prefix(str, "name=")) {
  attrs->name = kstrdup(str, GFP_KERNEL);
  if (!attrs->name) {
   ret = -ENOMEM;
   goto out;
  }
 } else if ((len = str_has_prefix(str, "clock="))) {
  str += len;

  str = strstrip(str);
  attrs->clock = kstrdup(str, GFP_KERNEL);
  if (!attrs->clock) {
   ret = -ENOMEM;
   goto out;
  }
 } else if ((len = str_has_prefix(str, "size="))) {
  int map_bits = parse_map_size(str + len);

  if (map_bits < 0) {
   ret = map_bits;
   goto out;
  }
  attrs->map_bits = map_bits;
 } else {
  char *assignment;

  if (attrs->n_assignments == TRACING_MAP_VARS_MAX) {
   hist_err(tr, HIST_ERR_TOO_MANY_VARS, errpos(str));
   ret = -EINVAL;
   goto out;
  }

  assignment = kstrdup(str, GFP_KERNEL);
  if (!assignment) {
   ret = -ENOMEM;
   goto out;
  }

  attrs->assignment_str[attrs->n_assignments++] = assignment;
 }
 out:
 return ret;
}

static struct hist_trigger_attrs *
parse_hist_trigger_attrs(struct trace_array *tr, 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, ":");
  char *rhs;

  rhs = strchr(str, '=');
  if (rhs) {
   if (!strlen(++rhs)) {
    ret = -EINVAL;
    hist_err(tr, HIST_ERR_EMPTY_ASSIGNMENT, errpos(str));
    goto free;
   }
   ret = parse_assignment(tr, str, attrs);
   if (ret)
    goto free;
  } else if (strcmp(str, "nohitcount") == 0 ||
      strcmp(str, "NOHC") == 0)
   attrs->no_hitcount = true;
  else if (strcmp(str, "pause") == 0)
   attrs->pause = true;
  else if ((strcmp(str, "cont") == 0) ||
    (strcmp(str, "continue") == 0))
   attrs->cont = true;
  else if (strcmp(str, "clear") == 0)
   attrs->clear = true;
  else {
   ret = parse_action(str, attrs);
   if (ret)
    goto free;
  }
 }

 if (!attrs->keys_str) {
  ret = -EINVAL;
  goto free;
 }

 if (!attrs->clock) {
  attrs->clock = kstrdup("global", GFP_KERNEL);
  if (!attrs->clock) {
   ret = -ENOMEM;
   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, "");
  return;
 }

 if (WARN_ON_ONCE(task->pid < 0)) {
  strcpy(comm, "");
  return;
 }

 strscpy(comm, task->comm, TASK_COMM_LEN);
}

static void hist_elt_data_free(struct hist_elt_data *elt_data)
{
 unsigned int i;

 for (i = 0; i < elt_data->n_field_var_str; i++)
  kfree(elt_data->field_var_str[i]);

 kfree(elt_data->field_var_str);

 kfree(elt_data->comm);
 kfree(elt_data);
}

static void hist_trigger_elt_data_free(struct tracing_map_elt *elt)
{
 struct hist_elt_data *elt_data = elt->private_data;

 hist_elt_data_free(elt_data);
}

static int hist_trigger_elt_data_alloc(struct tracing_map_elt *elt)
{
 struct hist_trigger_data *hist_data = elt->map->private_data;
 unsigned int size = TASK_COMM_LEN;
 struct hist_elt_data *elt_data;
 struct hist_field *hist_field;
 unsigned int i, n_str;

 elt_data = kzalloc(sizeof(*elt_data), GFP_KERNEL);
 if (!elt_data)
  return -ENOMEM;

 for_each_hist_field(i, hist_data) {
  hist_field = hist_data->fields[i];

  if (hist_field->flags & HIST_FIELD_FL_EXECNAME) {
   elt_data->comm = kzalloc(size, GFP_KERNEL);
   if (!elt_data->comm) {
    kfree(elt_data);
    return -ENOMEM;
   }
   break;
  }
 }

 n_str = hist_data->n_field_var_str + hist_data->n_save_var_str +
  hist_data->n_var_str;
 if (n_str > SYNTH_FIELDS_MAX) {
  hist_elt_data_free(elt_data);
  return -EINVAL;
 }

 BUILD_BUG_ON(STR_VAR_LEN_MAX & (sizeof(u64) - 1));

 size = STR_VAR_LEN_MAX;

 elt_data->field_var_str = kcalloc(n_str, sizeof(char *), GFP_KERNEL);
 if (!elt_data->field_var_str) {
  hist_elt_data_free(elt_data);
  return -EINVAL;
 }
 elt_data->n_field_var_str = n_str;

 for (i = 0; i < n_str; i++) {
  elt_data->field_var_str[i] = kzalloc(size, GFP_KERNEL);
  if (!elt_data->field_var_str[i]) {
   hist_elt_data_free(elt_data);
   return -ENOMEM;
  }
 }

 elt->private_data = elt_data;

 return 0;
}

static void hist_trigger_elt_data_init(struct tracing_map_elt *elt)
{
 struct hist_elt_data *elt_data = elt->private_data;

 if (elt_data->comm)
  save_comm(elt_data->comm, current);
}

static const struct tracing_map_ops hist_trigger_elt_data_ops = {
 .elt_alloc = hist_trigger_elt_data_alloc,
 .elt_free = hist_trigger_elt_data_free,
 .elt_init = hist_trigger_elt_data_init,
};

static const char *get_hist_field_flags(struct hist_field *hist_field)
{
 const char *flags_str = NULL;

 if (hist_field->flags & HIST_FIELD_FL_HEX)
  flags_str = "hex";
 else if (hist_field->flags & HIST_FIELD_FL_SYM)
  flags_str = "sym";
 else if (hist_field->flags & HIST_FIELD_FL_SYM_OFFSET)
  flags_str = "sym-offset";
 else if (hist_field->flags & HIST_FIELD_FL_EXECNAME)
  flags_str = "execname";
 else if (hist_field->flags & HIST_FIELD_FL_SYSCALL)
  flags_str = "syscall";
 else if (hist_field->flags & HIST_FIELD_FL_LOG2)
  flags_str = "log2";
 else if (hist_field->flags & HIST_FIELD_FL_BUCKET)
  flags_str = "buckets";
 else if (hist_field->flags & HIST_FIELD_FL_TIMESTAMP_USECS)
  flags_str = "usecs";
 else if (hist_field->flags & HIST_FIELD_FL_PERCENT)
  flags_str = "percent";
 else if (hist_field->flags & HIST_FIELD_FL_GRAPH)
  flags_str = "graph";
 else if (hist_field->flags & HIST_FIELD_FL_STACKTRACE)
  flags_str = "stacktrace";

 return flags_str;
}

static void expr_field_str(struct hist_field *field, char *expr)
{
 if (field->flags & HIST_FIELD_FL_VAR_REF)
  strcat(expr, "$");
 else if (field->flags & HIST_FIELD_FL_CONST) {
  char str[HIST_CONST_DIGITS_MAX];

  snprintf(str, HIST_CONST_DIGITS_MAX, "%llu", field->constant);
  strcat(expr, str);
 }

 strcat(expr, hist_field_name(field, 0));

 if (field->flags && !(field->flags & HIST_FIELD_FL_VAR_REF)) {
  const char *flags_str = get_hist_field_flags(field);

  if (flags_str) {
   strcat(expr, ".");
   strcat(expr, flags_str);
  }
 }
}

static char *expr_str(struct hist_field *field, unsigned int level)
{
 char *expr;

 if (level > 1)
  return NULL;

 expr = kzalloc(MAX_FILTER_STR_VAL, GFP_KERNEL);
 if (!expr)
  return NULL;

 if (!field->operands[0]) {
  expr_field_str(field, expr);
  return expr;
 }

 if (field->operator == FIELD_OP_UNARY_MINUS) {
  char *subexpr;

  strcat(expr, "-(");
  subexpr = expr_str(field->operands[0], ++level);
  if (!subexpr) {
   kfree(expr);
   return NULL;
  }
  strcat(expr, subexpr);
  strcat(expr, ")");

  kfree(subexpr);

  return expr;
 }

 expr_field_str(field->operands[0], expr);

 switch (field->operator) {
 case FIELD_OP_MINUS:
  strcat(expr, "-");
  break;
 case FIELD_OP_PLUS:
  strcat(expr, "+");
  break;
 case FIELD_OP_DIV:
  strcat(expr, "/");
  break;
 case FIELD_OP_MULT:
  strcat(expr, "*");
  break;
 default:
  kfree(expr);
  return NULL;
 }

 expr_field_str(field->operands[1], expr);

 return expr;
}

/*
 * If field_op != FIELD_OP_NONE, *sep points to the root operator
 * of the expression tree to be evaluated.
 */
static int contains_operator(char *str, char **sep)
{
 enum field_op_id field_op = FIELD_OP_NONE;
 char *minus_op, *plus_op, *div_op, *mult_op;


 /*
 * Report the last occurrence of the operators first, so that the
 * expression is evaluated left to right. This is important since
 * subtraction and division are not associative.
 *
 * e.g
 * 64/8/4/2 is 1, i.e 64/8/4/2 = ((64/8)/4)/2
 * 14-7-5-2 is 0, i.e 14-7-5-2 = ((14-7)-5)-2
 */

 /*
 * First, find lower precedence addition and subtraction
 * since the expression will be evaluated recursively.
 */
 minus_op = strrchr(str, '-');
 if (minus_op) {
  /*
 * Unary minus is not supported in sub-expressions. If
 * present, it is always the next root operator.
 */
  if (minus_op == str) {
   field_op = FIELD_OP_UNARY_MINUS;
   goto out;
  }

  field_op = FIELD_OP_MINUS;
 }

 plus_op = strrchr(str, '+');
 if (plus_op || minus_op) {
  /*
 * For operators of the same precedence use to rightmost as the
 * root, so that the expression is evaluated left to right.
 */
  if (plus_op > minus_op)
   field_op = FIELD_OP_PLUS;
  goto out;
 }

 /*
 * Multiplication and division have higher precedence than addition and
 * subtraction.
 */
 div_op = strrchr(str, '/');
 if (div_op)
  field_op = FIELD_OP_DIV;

 mult_op = strrchr(str, '*');
 /*
 * For operators of the same precedence use to rightmost as the
 * root, so that the expression is evaluated left to right.
 */
 if (mult_op > div_op)
  field_op = FIELD_OP_MULT;

out:
 if (sep) {
  switch (field_op) {
  case FIELD_OP_UNARY_MINUS:
  case FIELD_OP_MINUS:
   *sep = minus_op;
   break;
  case FIELD_OP_PLUS:
   *sep = plus_op;
   break;
  case FIELD_OP_DIV:
   *sep = div_op;
   break;
  case FIELD_OP_MULT:
   *sep = mult_op;
   break;
  case FIELD_OP_NONE:
  default:
   *sep = NULL;
   break;
  }
 }

 return field_op;
}

static void get_hist_field(struct hist_field *hist_field)
{
 hist_field->ref++;
}

static void __destroy_hist_field(struct hist_field *hist_field)
{
 if (--hist_field->ref > 1)
  return;

 kfree(hist_field->var.name);
 kfree(hist_field->name);

 /* Can likely be a const */
 kfree_const(hist_field->type);

 kfree(hist_field->system);
 kfree(hist_field->event_name);

 kfree(hist_field);
}

static void destroy_hist_field(struct hist_field *hist_field,
          unsigned int level)
{
 unsigned int i;

 if (level > 3)
  return;

 if (!hist_field)
  return;

 if (hist_field->flags & HIST_FIELD_FL_VAR_REF)
  return; /* var refs will be destroyed separately */

 for (i = 0; i < HIST_FIELD_OPERANDS_MAX; i++)
  destroy_hist_field(hist_field->operands[i], level + 1);

 __destroy_hist_field(hist_field);
}

static struct hist_field *create_hist_field(struct hist_trigger_data *hist_data,
         struct ftrace_event_field *field,
         unsigned long flags,
         char *var_name)
{
 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;

 hist_field->ref = 1;

 hist_field->hist_data = hist_data;

 if (flags & HIST_FIELD_FL_EXPR || flags & HIST_FIELD_FL_ALIAS)
  goto out; /* caller will populate */

 if (flags & HIST_FIELD_FL_VAR_REF) {
  hist_field->fn_num = HIST_FIELD_FN_VAR_REF;
  goto out;
 }

 if (flags & HIST_FIELD_FL_HITCOUNT) {
  hist_field->fn_num = HIST_FIELD_FN_COUNTER;
  hist_field->size = sizeof(u64);
  hist_field->type = "u64";
  goto out;
 }

 if (flags & HIST_FIELD_FL_CONST) {
  hist_field->fn_num = HIST_FIELD_FN_CONST;
  hist_field->size = sizeof(u64);
  hist_field->type = kstrdup("u64", GFP_KERNEL);
  if (!hist_field->type)
   goto free;
  goto out;
 }

 if (flags & HIST_FIELD_FL_STACKTRACE) {
  if (field)
   hist_field->fn_num = HIST_FIELD_FN_STACK;
  else
   hist_field->fn_num = HIST_FIELD_FN_NOP;
  hist_field->size = HIST_STACKTRACE_SIZE;
  hist_field->type = kstrdup_const("unsigned long[]", GFP_KERNEL);
  if (!hist_field->type)
   goto free;
  goto out;
 }

 if (flags & (HIST_FIELD_FL_LOG2 | HIST_FIELD_FL_BUCKET)) {
  unsigned long fl = flags & ~(HIST_FIELD_FL_LOG2 | HIST_FIELD_FL_BUCKET);
  hist_field->fn_num = flags & HIST_FIELD_FL_LOG2 ? HIST_FIELD_FN_LOG2 :
   HIST_FIELD_FN_BUCKET;
  hist_field->operands[0] = create_hist_field(hist_data, field, fl, NULL);
  if (!hist_field->operands[0])
   goto free;
  hist_field->size = hist_field->operands[0]->size;
  hist_field->type = kstrdup_const(hist_field->operands[0]->type, GFP_KERNEL);
  if (!hist_field->type)
   goto free;
  goto out;
 }

 if (flags & HIST_FIELD_FL_TIMESTAMP) {
  hist_field->fn_num = HIST_FIELD_FN_TIMESTAMP;
  hist_field->size = sizeof(u64);
  hist_field->type = "u64";
  goto out;
 }

 if (flags & HIST_FIELD_FL_CPU) {
  hist_field->fn_num = HIST_FIELD_FN_CPU;
  hist_field->size = sizeof(int);
  hist_field->type = "unsigned int";
  goto out;
 }

 if (flags & HIST_FIELD_FL_COMM) {
  hist_field->fn_num = HIST_FIELD_FN_COMM;
  hist_field->size = MAX_FILTER_STR_VAL;
  hist_field->type = "char[]";
  goto out;
 }

 if (WARN_ON_ONCE(!field))
  goto out;

 /* Pointers to strings are just pointers and dangerous to dereference */
 if (is_string_field(field) &&
     (field->filter_type != FILTER_PTR_STRING)) {
  flags |= HIST_FIELD_FL_STRING;

  hist_field->size = MAX_FILTER_STR_VAL;
  hist_field->type = kstrdup_const(field->type, GFP_KERNEL);
  if (!hist_field->type)
   goto free;

  if (field->filter_type == FILTER_STATIC_STRING) {
   hist_field->fn_num = HIST_FIELD_FN_STRING;
   hist_field->size = field->size;
  } else if (field->filter_type == FILTER_DYN_STRING) {
   hist_field->fn_num = HIST_FIELD_FN_DYNSTRING;
  } else if (field->filter_type == FILTER_RDYN_STRING)
   hist_field->fn_num = HIST_FIELD_FN_RELDYNSTRING;
  else
   hist_field->fn_num = HIST_FIELD_FN_PSTRING;
 } else {
  hist_field->size = field->size;
  hist_field->is_signed = field->is_signed;
  hist_field->type = kstrdup_const(field->type, GFP_KERNEL);
  if (!hist_field->type)
   goto free;

  hist_field->fn_num = select_value_fn(field->size,
           field->is_signed);
  if (hist_field->fn_num == HIST_FIELD_FN_NOP) {
   destroy_hist_field(hist_field, 0);
   return NULL;
  }
 }
 out:
 hist_field->field = field;
 hist_field->flags = flags;

 if (var_name) {
  hist_field->var.name = kstrdup(var_name, GFP_KERNEL);
  if (!hist_field->var.name)
   goto free;
 }

 return hist_field;
 free:
 destroy_hist_field(hist_field, 0);
 return NULL;
}

static void destroy_hist_fields(struct hist_trigger_data *hist_data)
{
 unsigned int i;

 for (i = 0; i < HIST_FIELDS_MAX; i++) {
  if (hist_data->fields[i]) {
   destroy_hist_field(hist_data->fields[i], 0);
   hist_data->fields[i] = NULL;
  }
 }

 for (i = 0; i < hist_data->n_var_refs; i++) {
  WARN_ON(!(hist_data->var_refs[i]->flags & HIST_FIELD_FL_VAR_REF));
  __destroy_hist_field(hist_data->var_refs[i]);
  hist_data->var_refs[i] = NULL;
 }
}

static int init_var_ref(struct hist_field *ref_field,
   struct hist_field *var_field,
   char *system, char *event_name)
{
 int err = 0;

 ref_field->var.idx = var_field->var.idx;
 ref_field->var.hist_data = var_field->hist_data;
 ref_field->size = var_field->size;
 ref_field->is_signed = var_field->is_signed;
 ref_field->flags |= var_field->flags &
  (HIST_FIELD_FL_TIMESTAMP | HIST_FIELD_FL_TIMESTAMP_USECS);

 if (system) {
  ref_field->system = kstrdup(system, GFP_KERNEL);
  if (!ref_field->system)
   return -ENOMEM;
 }

 if (event_name) {
  ref_field->event_name = kstrdup(event_name, GFP_KERNEL);
  if (!ref_field->event_name) {
   err = -ENOMEM;
   goto free;
  }
 }

 if (var_field->var.name) {
  ref_field->name = kstrdup(var_field->var.name, GFP_KERNEL);
  if (!ref_field->name) {
   err = -ENOMEM;
   goto free;
  }
 } else if (var_field->name) {
  ref_field->name = kstrdup(var_field->name, GFP_KERNEL);
  if (!ref_field->name) {
   err = -ENOMEM;
   goto free;
  }
 }

 ref_field->type = kstrdup_const(var_field->type, GFP_KERNEL);
 if (!ref_field->type) {
  err = -ENOMEM;
  goto free;
 }
 out:
 return err;
 free:
 kfree(ref_field->system);
 ref_field->system = NULL;
 kfree(ref_field->event_name);
 ref_field->event_name = NULL;
 kfree(ref_field->name);
 ref_field->name = NULL;

 goto out;
}

static int find_var_ref_idx(struct hist_trigger_data *hist_data,
       struct hist_field *var_field)
{
 struct hist_field *ref_field;
 int i;

 for (i = 0; i < hist_data->n_var_refs; i++) {
  ref_field = hist_data->var_refs[i];
  if (ref_field->var.idx == var_field->var.idx &&
      ref_field->var.hist_data == var_field->hist_data)
   return i;
 }

 return -ENOENT;
}

/**
 * create_var_ref - Create a variable reference and attach it to trigger
 * @hist_data: The trigger that will be referencing the variable
 * @var_field: The VAR field to create a reference to
 * @system: The optional system string
 * @event_name: The optional event_name string
 *
 * Given a variable hist_field, create a VAR_REF hist_field that
 * represents a reference to it.
 *
 * This function also adds the reference to the trigger that
 * now references the variable.
 *
 * Return: The VAR_REF field if successful, NULL if not
 */
static struct hist_field *create_var_ref(struct hist_trigger_data *hist_data,
      struct hist_field *var_field,
      char *system, char *event_name)
{
 unsigned long flags = HIST_FIELD_FL_VAR_REF;
 struct hist_field *ref_field;
 int i;

 /* Check if the variable already exists */
 for (i = 0; i < hist_data->n_var_refs; i++) {
  ref_field = hist_data->var_refs[i];
  if (ref_field->var.idx == var_field->var.idx &&
      ref_field->var.hist_data == var_field->hist_data) {
   get_hist_field(ref_field);
   return ref_field;
  }
 }
 /* Sanity check to avoid out-of-bound write on 'hist_data->var_refs' */
 if (hist_data->n_var_refs >= TRACING_MAP_VARS_MAX)
  return NULL;
 ref_field = create_hist_field(var_field->hist_data, NULL, flags, NULL);
 if (ref_field) {
  if (init_var_ref(ref_field, var_field, system, event_name)) {
   destroy_hist_field(ref_field, 0);
   return NULL;
  }

  hist_data->var_refs[hist_data->n_var_refs] = ref_field;
  ref_field->var_ref_idx = hist_data->n_var_refs++;
 }

 return ref_field;
}

static bool is_var_ref(char *var_name)
{
 if (!var_name || strlen(var_name) < 2 || var_name[0] != '$')
  return false;

 return true;
}

static char *field_name_from_var(struct hist_trigger_data *hist_data,
     char *var_name)
{
 char *name, *field;
 unsigned int i;

 for (i = 0; i < hist_data->attrs->var_defs.n_vars; i++) {
  name = hist_data->attrs->var_defs.name[i];

  if (strcmp(var_name, name) == 0) {
   field = hist_data->attrs->var_defs.expr[i];
   if (contains_operator(field, NULL) || is_var_ref(field))
    continue;
   return field;
  }
 }

 return NULL;
}

static char *local_field_var_ref(struct hist_trigger_data *hist_data,
     char *system, char *event_name,
     char *var_name)
{
 struct trace_event_call *call;

 if (system && event_name) {
  call = hist_data->event_file->event_call;

  if (strcmp(system, call->class->system) != 0)
   return NULL;

  if (strcmp(event_name, trace_event_name(call)) != 0)
   return NULL;
 }

 if (!!system != !!event_name)
  return NULL;

 if (!is_var_ref(var_name))
  return NULL;

 var_name++;

 return field_name_from_var(hist_data, var_name);
}

static struct hist_field *parse_var_ref(struct hist_trigger_data *hist_data,
     char *system, char *event_name,
     char *var_name)
{
 struct hist_field *var_field = NULL, *ref_field = NULL;
 struct trace_array *tr = hist_data->event_file->tr;

 if (!is_var_ref(var_name))
  return NULL;

 var_name++;

 var_field = find_event_var(hist_data, system, event_name, var_name);
 if (var_field)
  ref_field = create_var_ref(hist_data, var_field,
        system, event_name);

 if (!ref_field)
  hist_err(tr, HIST_ERR_VAR_NOT_FOUND, errpos(var_name));

 return ref_field;
}

static struct ftrace_event_field *
parse_field(struct hist_trigger_data *hist_data, struct trace_event_file *file,
     char *field_str, unsigned long *flags, unsigned long *buckets)
{
 struct ftrace_event_field *field = NULL;
 char *field_name, *modifier, *str;
 struct trace_array *tr = file->tr;

 modifier = str = kstrdup(field_str, GFP_KERNEL);
 if (!modifier)
  return ERR_PTR(-ENOMEM);

 field_name = strsep(&modifier, ".");
 if (modifier) {
  if (strcmp(modifier, "hex") == 0)
   *flags |= HIST_FIELD_FL_HEX;
  else if (strcmp(modifier, "sym") == 0)
   *flags |= HIST_FIELD_FL_SYM;
  /*
 * 'sym-offset' occurrences in the trigger string are modified
 * to 'symXoffset' to simplify arithmetic expression parsing.
 */
  else if (strcmp(modifier, "symXoffset") == 0)
   *flags |= HIST_FIELD_FL_SYM_OFFSET;
  else if ((strcmp(modifier, "execname") == 0) &&
    (strcmp(field_name, "common_pid") == 0))
   *flags |= HIST_FIELD_FL_EXECNAME;
  else if (strcmp(modifier, "syscall") == 0)
   *flags |= HIST_FIELD_FL_SYSCALL;
  else if (strcmp(modifier, "stacktrace") == 0)
   *flags |= HIST_FIELD_FL_STACKTRACE;
  else if (strcmp(modifier, "log2") == 0)
   *flags |= HIST_FIELD_FL_LOG2;
  else if (strcmp(modifier, "usecs") == 0)
   *flags |= HIST_FIELD_FL_TIMESTAMP_USECS;
  else if (strncmp(modifier, "bucket", 6) == 0) {
   int ret;

   modifier += 6;

   if (*modifier == 's')
    modifier++;
   if (*modifier != '=')
    goto error;
   modifier++;
   ret = kstrtoul(modifier, 0, buckets);
   if (ret || !(*buckets))
    goto error;
   *flags |= HIST_FIELD_FL_BUCKET;
  } else if (strncmp(modifier, "percent", 7) == 0) {
   if (*flags & (HIST_FIELD_FL_VAR | HIST_FIELD_FL_KEY))
    goto error;
   *flags |= HIST_FIELD_FL_PERCENT;
  } else if (strncmp(modifier, "graph", 5) == 0) {
   if (*flags & (HIST_FIELD_FL_VAR | HIST_FIELD_FL_KEY))
    goto error;
   *flags |= HIST_FIELD_FL_GRAPH;
  } else {
 error:
   hist_err(tr, HIST_ERR_BAD_FIELD_MODIFIER, errpos(modifier));
   field = ERR_PTR(-EINVAL);
   goto out;
  }
 }

 if (strcmp(field_name, "common_timestamp") == 0) {
  *flags |= HIST_FIELD_FL_TIMESTAMP;
  hist_data->enable_timestamps = true;
  if (*flags & HIST_FIELD_FL_TIMESTAMP_USECS)
   hist_data->attrs->ts_in_usecs = true;
 } else if (strcmp(field_name, "common_stacktrace") == 0) {
  *flags |= HIST_FIELD_FL_STACKTRACE;
 } else if (strcmp(field_name, "common_cpu") == 0) {
  *flags |= HIST_FIELD_FL_CPU;
 } else if (strcmp(field_name, "common_comm") == 0) {
  *flags |= HIST_FIELD_FL_COMM | HIST_FIELD_FL_STRING;
 } else if (strcmp(field_name, "hitcount") == 0)
  *flags |= HIST_FIELD_FL_HITCOUNT;
 else {
  field = trace_find_event_field(file->event_call, field_name);
  if (!field || !field->size) {
   /*
 * For backward compatibility, if field_name
 * was "cpu" or "stacktrace", then we treat this
 * the same as common_cpu and common_stacktrace
 * respectively. This also works for "CPU", and
 * "STACKTRACE".
 */
   if (field && field->filter_type == FILTER_CPU) {
    *flags |= HIST_FIELD_FL_CPU;
   } else if (field && field->filter_type == FILTER_STACKTRACE) {
    *flags |= HIST_FIELD_FL_STACKTRACE;
   } else if (field && field->filter_type == FILTER_COMM) {
    *flags |= HIST_FIELD_FL_COMM | HIST_FIELD_FL_STRING;
   } else {
    hist_err(tr, HIST_ERR_FIELD_NOT_FOUND,
      errpos(field_name));
    field = ERR_PTR(-EINVAL);
    goto out;
   }
  }
 }
 out:
 kfree(str);

 return field;
}

static struct hist_field *create_alias(struct hist_trigger_data *hist_data,
           struct hist_field *var_ref,
           char *var_name)
{
 struct hist_field *alias = NULL;
 unsigned long flags = HIST_FIELD_FL_ALIAS | HIST_FIELD_FL_VAR;

 alias = create_hist_field(hist_data, NULL, flags, var_name);
 if (!alias)
  return NULL;

 alias->fn_num = var_ref->fn_num;
 alias->operands[0] = var_ref;

 if (init_var_ref(alias, var_ref, var_ref->system, var_ref->event_name)) {
  destroy_hist_field(alias, 0);
  return NULL;
 }

 alias->var_ref_idx = var_ref->var_ref_idx;

 return alias;
}

static struct hist_field *parse_const(struct hist_trigger_data *hist_data,
          char *str, char *var_name,
          unsigned long *flags)
{
 struct trace_array *tr = hist_data->event_file->tr;
 struct hist_field *field = NULL;
 u64 constant;

 if (kstrtoull(str, 0, &constant)) {
  hist_err(tr, HIST_ERR_EXPECT_NUMBER, errpos(str));
  return NULL;
 }

 *flags |= HIST_FIELD_FL_CONST;
 field = create_hist_field(hist_data, NULL, *flags, var_name);
 if (!field)
  return NULL;

 field->constant = constant;

 return field;
}

static struct hist_field *parse_atom(struct hist_trigger_data *hist_data,
         struct trace_event_file *file, char *str,
         unsigned long *flags, char *var_name)
{
 char *s, *ref_system = NULL, *ref_event = NULL, *ref_var = str;
 struct ftrace_event_field *field = NULL;
 struct hist_field *hist_field = NULL;
 unsigned long buckets = 0;
 int ret = 0;

 if (isdigit(str[0])) {
  hist_field = parse_const(hist_data, str, var_name, flags);
  if (!hist_field) {
   ret = -EINVAL;
   goto out;
  }
  return hist_field;
 }

 s = strchr(str, '.');
 if (s) {
  s = strchr(++s, '.');
  if (s) {
   ref_system = strsep(&str, ".");
   if (!str) {
    ret = -EINVAL;
    goto out;
   }
   ref_event = strsep(&str, ".");
   if (!str) {
    ret = -EINVAL;
    goto out;
   }
   ref_var = str;
  }
 }

 s = local_field_var_ref(hist_data, ref_system, ref_event, ref_var);
 if (!s) {
  hist_field = parse_var_ref(hist_data, ref_system,
        ref_event, ref_var);
  if (hist_field) {
   if (var_name) {
    hist_field = create_alias(hist_data, hist_field, var_name);
    if (!hist_field) {
     ret = -ENOMEM;
     goto out;
    }
   }
   return hist_field;
  }
 } else
  str = s;

 field = parse_field(hist_data, file, str, flags, &buckets);
 if (IS_ERR(field)) {
  ret = PTR_ERR(field);
  goto out;
 }

 hist_field = create_hist_field(hist_data, field, *flags, var_name);
 if (!hist_field) {
  ret = -ENOMEM;
  goto out;
 }
 hist_field->buckets = buckets;

 return hist_field;
 out:
 return ERR_PTR(ret);
}

static struct hist_field *parse_expr(struct hist_trigger_data *hist_data,
         struct trace_event_file *file,
         char *str, unsigned long flags,
         char *var_name, unsigned int *n_subexprs);

static struct hist_field *parse_unary(struct hist_trigger_data *hist_data,
          struct trace_event_file *file,
          char *str, unsigned long flags,
          char *var_name, unsigned int *n_subexprs)
{
 struct hist_field *operand1, *expr = NULL;
 unsigned long operand_flags;
 int ret = 0;
 char *s;

 /* Unary minus operator, increment n_subexprs */
 ++*n_subexprs;

 /* we support only -(xxx) i.e. explicit parens required */

 if (*n_subexprs > 3) {
  hist_err(file->tr, HIST_ERR_TOO_MANY_SUBEXPR, errpos(str));
  ret = -EINVAL;
  goto free;
 }

 str++; /* skip leading '-' */

 s = strchr(str, '(');
 if (s)
  str++;
 else {
  ret = -EINVAL;
  goto free;
 }

 s = strrchr(str, ')');
 if (s) {
   /* unary minus not supported in sub-expressions */
  if (*(s+1) != '\0') {
   hist_err(file->tr, HIST_ERR_UNARY_MINUS_SUBEXPR,
     errpos(str));
   ret = -EINVAL;
   goto free;
  }
  *s = '\0';
 }
 else {
  ret = -EINVAL; /* no closing ')' */
  goto free;
 }

 flags |= HIST_FIELD_FL_EXPR;
 expr = create_hist_field(hist_data, NULL, flags, var_name);
 if (!expr) {
  ret = -ENOMEM;
  goto free;
 }

 operand_flags = 0;
 operand1 = parse_expr(hist_data, file, str, operand_flags, NULL, n_subexprs);
 if (IS_ERR(operand1)) {
  ret = PTR_ERR(operand1);
  goto free;
 }
 if (operand1->flags & HIST_FIELD_FL_STRING) {
  /* String type can not be the operand of unary operator. */
  hist_err(file->tr, HIST_ERR_INVALID_STR_OPERAND, errpos(str));
  destroy_hist_field(operand1, 0);
  ret = -EINVAL;
  goto free;
 }

 expr->flags |= operand1->flags &
  (HIST_FIELD_FL_TIMESTAMP | HIST_FIELD_FL_TIMESTAMP_USECS);
 expr->fn_num = HIST_FIELD_FN_UMINUS;
 expr->operands[0] = operand1;
 expr->size = operand1->size;
 expr->is_signed = operand1->is_signed;
 expr->operator = FIELD_OP_UNARY_MINUS;
 expr->name = expr_str(expr, 0);
 expr->type = kstrdup_const(operand1->type, GFP_KERNEL);
 if (!expr->type) {
--> --------------------

--> maximum size reached

--> --------------------