Commit a3785b7e authored by Tom Zanussi's avatar Tom Zanussi Committed by Steven Rostedt (VMware)
Browse files

tracing: Add hist trigger snapshot() action 

Add support for hist:handlerXXX($var).snapshot(), which will take a
snapshot of the current trace buffer whenever handlerXXX is hit.

As a first user, this also adds snapshot() action support for the
onmax() handler i.e. hist:onmax($var).snapshot().

Also, the hist trigger key printing is moved into a separate function
so the snapshot() action can print a histogram key outside the
histogram display - add and use hist_trigger_print_key() for that
purpose.

Link: http://lkml.kernel.org/r/2f1a952c0dcd8aca8702ce81269581a692396d45.1550100284.git.tom.zanussi@linux.intel.com



Signed-off-by: default avatarTom Zanussi <tom.zanussi@linux.intel.com>
Signed-off-by: default avatarSteven Rostedt (VMware) <rostedt@goodmis.org>
parent a35873a0

kernel/trace/trace.c

+3 −0
Original line number Diff line number Diff line
@@ -4919,6 +4919,9 @@ static const char readme_msg[] = 
	"\t    The available actions are:\n\n"

	"\t        <synthetic_event>(param list)        - generate synthetic event\n"

	"\t        save(field,...)                      - save current event fields\n"

#ifdef CONFIG_TRACER_SNAPSHOT

	"\t        snapshot()                           - snapshot the trace buffer\n"

#endif

#endif

;

kernel/trace/trace_events_hist.c

+256 −10
Original line number Diff line number Diff line
@@ -396,6 +396,7 @@ enum handler_id { 
enum action_id {

	ACTION_SAVE = 1,

	ACTION_TRACE,

	ACTION_SNAPSHOT,

};



struct action_data {
@@ -454,6 +455,83 @@ struct action_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[SYNTH_FIELDS_MAX];

};



struct snapshot_context {

	struct tracing_map_elt	*elt;

	void			*key;

};



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;

}



static char last_hist_cmd[MAX_FILTER_STR_VAL];

static char hist_err_str[MAX_FILTER_STR_VAL];
@@ -1726,12 +1804,6 @@ static struct hist_field *find_event_var(struct hist_trigger_data *hist_data, 
	return hist_field;

}



struct hist_elt_data {

	char *comm;

	u64 *var_ref_vals;

	char *field_var_str[SYNTH_FIELDS_MAX];

};



static u64 hist_field_var_ref(struct hist_field *hist_field,

			      struct tracing_map_elt *elt,

			      struct ring_buffer_event *rbe,
@@ -3452,6 +3524,112 @@ static bool check_track_val(struct tracing_map_elt *elt, 
	return data->track_data.check_val(track_val, var_val);

}



#ifdef CONFIG_TRACER_SNAPSHOT

static bool cond_snapshot_update(struct trace_array *tr, void *cond_data)

{

	/* called with tr->max_lock held */

	struct track_data *track_data = tr->cond_snapshot->cond_data;

	struct hist_elt_data *elt_data, *track_elt_data;

	struct snapshot_context *context = cond_data;

	u64 track_val;



	if (!track_data)

		return false;



	track_val = get_track_val(track_data->hist_data, context->elt,

				  track_data->action_data);



	track_data->track_val = track_val;

	memcpy(track_data->key, context->key, track_data->key_len);



	elt_data = context->elt->private_data;

	track_elt_data = track_data->elt.private_data;

	if (elt_data->comm)

		memcpy(track_elt_data->comm, elt_data->comm, TASK_COMM_LEN);



	track_data->updated = true;



	return true;

}



static void save_track_data_snapshot(struct hist_trigger_data *hist_data,

				     struct tracing_map_elt *elt, void *rec,

				     struct ring_buffer_event *rbe, void *key,

				     struct action_data *data,

				     u64 *var_ref_vals)

{

	struct trace_event_file *file = hist_data->event_file;

	struct snapshot_context context;



	context.elt = elt;

	context.key = key;



	tracing_snapshot_cond(file->tr, &context);

}



static void hist_trigger_print_key(struct seq_file *m,

				   struct hist_trigger_data *hist_data,

				   void *key,

				   struct tracing_map_elt *elt);



static struct action_data *snapshot_action(struct hist_trigger_data *hist_data)

{

	unsigned int i;



	if (!hist_data->n_actions)

		return NULL;



	for (i = 0; i < hist_data->n_actions; i++) {

		struct action_data *data = hist_data->actions[i];



		if (data->action == ACTION_SNAPSHOT)

			return data;

	}



	return NULL;

}



static void track_data_snapshot_print(struct seq_file *m,

				      struct hist_trigger_data *hist_data)

{

	struct trace_event_file *file = hist_data->event_file;

	struct track_data *track_data;

	struct action_data *action;



	track_data = tracing_cond_snapshot_data(file->tr);

	if (!track_data)

		return;



	if (!track_data->updated)

		return;



	action = snapshot_action(hist_data);

	if (!action)

		return;



	seq_puts(m, "\nSnapshot taken (see tracing/snapshot).  Details:\n");

	seq_printf(m, "\ttriggering value { %s(%s) }: %10llu",

		   action->handler == HANDLER_ONMAX ? "onmax" : "onchange",

		   action->track_data.var_str, track_data->track_val);



	seq_puts(m, "\ttriggered by event with key: ");

	hist_trigger_print_key(m, hist_data, track_data->key, &track_data->elt);

	seq_putc(m, '\n');

}

#else

static bool cond_snapshot_update(struct trace_array *tr, void *cond_data)

{

	return false;

}

static void save_track_data_snapshot(struct hist_trigger_data *hist_data,

				     struct tracing_map_elt *elt, void *rec,

				     struct ring_buffer_event *rbe, void *key,

				     struct action_data *data,

				     u64 *var_ref_vals) {}

static void track_data_snapshot_print(struct seq_file *m,

				      struct hist_trigger_data *hist_data) {}

#endif /* CONFIG_TRACER_SNAPSHOT */



static void track_data_print(struct seq_file *m,

			     struct hist_trigger_data *hist_data,

			     struct tracing_map_elt *elt,
@@ -3463,6 +3641,9 @@ static void track_data_print(struct seq_file *m, 
	if (data->handler == HANDLER_ONMAX)

		seq_printf(m, "\n\tmax: %10llu", track_val);



	if (data->action == ACTION_SNAPSHOT)

		return;



	for (i = 0; i < hist_data->n_save_vars; i++) {

		struct hist_field *save_val = hist_data->save_vars[i]->val;

		struct hist_field *save_var = hist_data->save_vars[i]->var;
@@ -3513,9 +3694,21 @@ static void action_data_destroy(struct action_data *data) 
static void track_data_destroy(struct hist_trigger_data *hist_data,

			       struct action_data *data)

{

	struct trace_event_file *file = hist_data->event_file;



	destroy_hist_field(data->track_data.track_var, 0);

	destroy_hist_field(data->track_data.var_ref, 0);



	if (data->action == ACTION_SNAPSHOT) {

		struct track_data *track_data;



		track_data = tracing_cond_snapshot_data(file->tr);

		if (track_data && track_data->hist_data == hist_data) {

			tracing_snapshot_cond_disable(file->tr);

			track_data_free(track_data);

		}

	}



	kfree(data->track_data.var_str);



	action_data_destroy(data);
@@ -3646,6 +3839,26 @@ static int action_parse(char *str, struct action_data *data, 
		data->track_data.save_data = save_track_data_vars;

		data->fn = ontrack_action;

		data->action = ACTION_SAVE;

	} else if (str_has_prefix(action_name, "snapshot")) {

		char *params = strsep(&str, ")");



		if (!str) {

			hist_err("action parsing: No closing paren found: %s", params);

			ret = -EINVAL;

			goto out;

		}



		if (handler == HANDLER_ONMAX)

			data->track_data.check_val = check_track_val_max;

		else {

			hist_err("action parsing: Handler doesn't support action: ", action_name);

			ret = -EINVAL;

			goto out;

		}



		data->track_data.save_data = save_track_data_snapshot;

		data->fn = ontrack_action;

		data->action = ACTION_SNAPSHOT;

	} else {

		char *params = strsep(&str, ")");
@@ -3942,6 +4155,8 @@ static int trace_action_create(struct hist_trigger_data *hist_data, 
static int action_create(struct hist_trigger_data *hist_data,

			 struct action_data *data)

{

	struct trace_event_file *file = hist_data->event_file;

	struct track_data *track_data;

	struct field_var *field_var;

	unsigned int i;

	char *param;
@@ -3950,6 +4165,21 @@ static int action_create(struct hist_trigger_data *hist_data, 
	if (data->action == ACTION_TRACE)

		return trace_action_create(hist_data, data);



	if (data->action == ACTION_SNAPSHOT) {

		track_data = track_data_alloc(hist_data->key_size, data, hist_data);

		if (IS_ERR(track_data)) {

			ret = PTR_ERR(track_data);

			goto out;

		}



		ret = tracing_snapshot_cond_enable(file->tr, track_data,

						   cond_snapshot_update);

		if (ret)

			track_data_free(track_data);



		goto out;

	}



	if (data->action == ACTION_SAVE) {

		if (hist_data->n_save_vars) {

			ret = -EEXIST;
@@ -4552,6 +4782,9 @@ static void print_actions(struct seq_file *m, 
	for (i = 0; i < hist_data->n_actions; i++) {

		struct action_data *data = hist_data->actions[i];



		if (data->action == ACTION_SNAPSHOT)

			continue;



		if (data->handler == HANDLER_ONMAX)

			track_data_print(m, hist_data, elt, data);

	}
@@ -4946,9 +5179,9 @@ static void hist_trigger_stacktrace_print(struct seq_file *m, 
	}

}



static void

hist_trigger_entry_print(struct seq_file *m,

			 struct hist_trigger_data *hist_data, void *key,

static void hist_trigger_print_key(struct seq_file *m,

				   struct hist_trigger_data *hist_data,

				   void *key,

				   struct tracing_map_elt *elt)

{

	struct hist_field *key_field;
@@ -5025,6 +5258,17 @@ hist_trigger_entry_print(struct seq_file *m, 
		seq_puts(m, " ");



	seq_puts(m, "}");

}



static void hist_trigger_entry_print(struct seq_file *m,

				     struct hist_trigger_data *hist_data,

				     void *key,

				     struct tracing_map_elt *elt)

{

	const char *field_name;

	unsigned int i;



	hist_trigger_print_key(m, hist_data, key, elt);



	seq_printf(m, " hitcount: %10llu",

		   tracing_map_read_sum(elt, HITCOUNT_IDX));
@@ -5091,6 +5335,8 @@ static void hist_trigger_show(struct seq_file *m, 
	if (n_entries < 0)

		n_entries = 0;



	track_data_snapshot_print(m, hist_data);



	seq_printf(m, "\nTotals:\n    Hits: %llu\n    Entries: %u\n    Dropped: %llu\n",

		   (u64)atomic64_read(&hist_data->map->hits),

		   n_entries, (u64)atomic64_read(&hist_data->map->drops));

CRA Git | Maintained and supported by SUSTech CRA and CCSE