Commit fe4fa4ec authored by Valentin Schneider's avatar Valentin Schneider Committed by Steven Rostedt (Google)
Browse files

tracing/filters: Optimise cpumask vs cpumask filtering when user mask is a single CPU 

Steven noted that when the user-provided cpumask contains a single CPU,
then the filtering function can use a scalar as input instead of a
full-fledged cpumask.

Reuse do_filter_scalar_cpumask() when the input mask has a weight of one.

Link: https://lkml.kernel.org/r/20230707172155.70873-6-vschneid@redhat.com



Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Juri Lelli <juri.lelli@redhat.com>
Cc: Daniel Bristot de Oliveira <bristot@redhat.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Leonardo Bras <leobras@redhat.com>
Cc: Frederic Weisbecker <frederic@kernel.org>
Suggested-by: default avatarSteven Rostedt <rostedt@goodmis.org>
Signed-off-by: default avatarValentin Schneider <vschneid@redhat.com>
Signed-off-by: default avatarSteven Rostedt (Google) <rostedt@goodmis.org>
parent 347d24fc

kernel/trace/trace_events_filter.c

+34 −1
Original line number Diff line number Diff line
@@ -70,6 +70,7 @@ enum filter_pred_fn { 
	FILTER_PRED_FN_CPU,

	FILTER_PRED_FN_CPU_CPUMASK,

	FILTER_PRED_FN_CPUMASK,

	FILTER_PRED_FN_CPUMASK_CPU,

	FILTER_PRED_FN_FUNCTION,

	FILTER_PRED_FN_,

	FILTER_PRED_TEST_VISITED,
@@ -957,6 +958,22 @@ static int filter_pred_cpumask(struct filter_pred *pred, void *event) 
	return do_filter_cpumask(pred->op, mask, cmp);

}



/* Filter predicate for cpumask field vs user-provided scalar  */

static int filter_pred_cpumask_cpu(struct filter_pred *pred, void *event)

{

	u32 item = *(u32 *)(event + pred->offset);

	int loc = item & 0xffff;

	const struct cpumask *mask = (event + loc);

	unsigned int cpu = pred->val;



	/*

	 * This inverts the usual usage of the function (field is first element,

	 * user parameter is second), but that's fine because the (scalar, mask)

	 * operations used are symmetric.

	 */

	return do_filter_scalar_cpumask(pred->op, cpu, mask);

}



/* Filter predicate for COMM. */

static int filter_pred_comm(struct filter_pred *pred, void *event)

{
@@ -1453,6 +1470,8 @@ static int filter_pred_fn_call(struct filter_pred *pred, void *event) 
		return filter_pred_cpu_cpumask(pred, event);

	case FILTER_PRED_FN_CPUMASK:

		return filter_pred_cpumask(pred, event);

	case FILTER_PRED_FN_CPUMASK_CPU:

		return filter_pred_cpumask_cpu(pred, event);

	case FILTER_PRED_FN_FUNCTION:

		return filter_pred_function(pred, event);

	case FILTER_PRED_TEST_VISITED:
@@ -1666,6 +1685,7 @@ static int parse_pred(const char *str, void *data, 


	} else if (!strncmp(str + i, "CPUS", 4)) {

		unsigned int maskstart;

		bool single;

		char *tmp;



		switch (field->filter_type) {
@@ -1724,8 +1744,21 @@ static int parse_pred(const char *str, void *data, 


		/* Move along */

		i++;



		/*

		 * Optimisation: if the user-provided mask has a weight of one

		 * then we can treat it as a scalar input.

		 */

		single = cpumask_weight(pred->mask) == 1;

		if (single && field->filter_type == FILTER_CPUMASK) {

			pred->val = cpumask_first(pred->mask);

			kfree(pred->mask);

		}



		if (field->filter_type == FILTER_CPUMASK) {

			pred->fn_num = FILTER_PRED_FN_CPUMASK;

			pred->fn_num = single ?

				FILTER_PRED_FN_CPUMASK_CPU :

				FILTER_PRED_FN_CPUMASK;

		} else if (field->filter_type == FILTER_CPU) {

			pred->fn_num = FILTER_PRED_FN_CPU_CPUMASK;

		} else {