Commit d9bbfbd1 authored by Steven Rostedt (Google)'s avatar Steven Rostedt (Google)
Browse files

ftrace: Allow subops filtering to be modified 

The subops filters use a "manager" ops to enable and disable its filters.
The manager ops can handle more than one subops, and its filter is what
controls what functions get set. Add a ftrace_hash_move_and_update_subops()
function that will update the manager ops when the subops filters change.

Link: https://lore.kernel.org/linux-trace-kernel/20240603190822.673932251@goodmis.org



Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Alexei Starovoitov <alexei.starovoitov@gmail.com>
Cc: Florent Revest <revest@chromium.org>
Cc: Martin KaFai Lau <martin.lau@linux.dev>
Cc: bpf <bpf@vger.kernel.org>
Cc: Sven Schnelle <svens@linux.ibm.com>
Cc: Alexei Starovoitov <ast@kernel.org>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Arnaldo Carvalho de Melo <acme@kernel.org>
Cc: Daniel Borkmann <daniel@iogearbox.net>
Cc: Alan Maguire <alan.maguire@oracle.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Guo Ren <guoren@kernel.org>
Reviewed-by: default avatarMasami Hiramatsu (Google) <mhiramat@kernel.org>
Signed-off-by: default avatarSteven Rostedt (Google) <rostedt@goodmis.org>
parent 5fccc755

include/linux/ftrace.h

+3 −0
Original line number Diff line number Diff line
@@ -227,6 +227,7 @@ ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops); 
 *             ftrace_enabled.

 * DIRECT - Used by the direct ftrace_ops helper for direct functions

 *            (internal ftrace only, should not be used by others)

 * SUBOP  - Is controlled by another op in field managed.

 */

enum {

	FTRACE_OPS_FL_ENABLED			= BIT(0),
@@ -247,6 +248,7 @@ enum { 
	FTRACE_OPS_FL_TRACE_ARRAY		= BIT(15),

	FTRACE_OPS_FL_PERMANENT                 = BIT(16),

	FTRACE_OPS_FL_DIRECT			= BIT(17),

	FTRACE_OPS_FL_SUBOP			= BIT(18),

};



#ifndef CONFIG_DYNAMIC_FTRACE_WITH_ARGS
@@ -336,6 +338,7 @@ struct ftrace_ops { 
	struct list_head		list;

	struct list_head		subop_list;

	ftrace_ops_func_t		ops_func;

	struct ftrace_ops		*managed;

#ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS

	unsigned long			direct_call;

#endif

kernel/trace/ftrace.c

+113 −28
Original line number Diff line number Diff line
@@ -3343,10 +3343,28 @@ static bool ops_equal(struct ftrace_hash *A, struct ftrace_hash *B) 
	return true;

}



static int ftrace_hash_move_and_update_ops(struct ftrace_ops *ops,

static void ftrace_ops_update_code(struct ftrace_ops *ops,

				   struct ftrace_ops_hash *old_hash);



static int __ftrace_hash_move_and_update_ops(struct ftrace_ops *ops,

					     struct ftrace_hash **orig_hash,

					     struct ftrace_hash *hash,

					   int enable);

					     int enable)

{

	struct ftrace_ops_hash old_hash_ops;

	struct ftrace_hash *old_hash;

	int ret;



	old_hash = *orig_hash;

	old_hash_ops.filter_hash = ops->func_hash->filter_hash;

	old_hash_ops.notrace_hash = ops->func_hash->notrace_hash;

	ret = ftrace_hash_move(ops, enable, orig_hash, hash);

	if (!ret) {

		ftrace_ops_update_code(ops, &old_hash_ops);

		free_ftrace_hash_rcu(old_hash);

	}

	return ret;

}



static int ftrace_update_ops(struct ftrace_ops *ops, struct ftrace_hash *filter_hash,

			     struct ftrace_hash *notrace_hash)
@@ -3354,14 +3372,14 @@ static int ftrace_update_ops(struct ftrace_ops *ops, struct ftrace_hash *filter_ 
	int ret;



	if (!ops_equal(filter_hash, ops->func_hash->filter_hash)) {

		ret = ftrace_hash_move_and_update_ops(ops, &ops->func_hash->filter_hash,

		ret = __ftrace_hash_move_and_update_ops(ops, &ops->func_hash->filter_hash,

							filter_hash, 1);

		if (ret < 0)

			return ret;

	}



	if (!ops_equal(notrace_hash, ops->func_hash->notrace_hash)) {

		ret = ftrace_hash_move_and_update_ops(ops, &ops->func_hash->notrace_hash,

		ret = __ftrace_hash_move_and_update_ops(ops, &ops->func_hash->notrace_hash,

							notrace_hash, 0);

		if (ret < 0)

			return ret;
@@ -3435,7 +3453,8 @@ int ftrace_startup_subops(struct ftrace_ops *ops, struct ftrace_ops *subops, int 
		} else {

			free_ftrace_hash(save_filter_hash);

			free_ftrace_hash(save_notrace_hash);

			subops->flags |= FTRACE_OPS_FL_ENABLED;

			subops->flags |= FTRACE_OPS_FL_ENABLED | FTRACE_OPS_FL_SUBOP;

			subops->managed = ops;

		}

		return ret;

	}
@@ -3489,11 +3508,12 @@ int ftrace_startup_subops(struct ftrace_ops *ops, struct ftrace_ops *subops, int 
	ret = ftrace_update_ops(ops, filter_hash, notrace_hash);

	free_ftrace_hash(filter_hash);

	free_ftrace_hash(notrace_hash);

	if (ret < 0)

	if (ret < 0) {

		list_del(&subops->list);

	else

		subops->flags |= FTRACE_OPS_FL_ENABLED;



	} else {

		subops->flags |= FTRACE_OPS_FL_ENABLED | FTRACE_OPS_FL_SUBOP;

		subops->managed = ops;

	}

	return ret;

}
@@ -3538,6 +3558,8 @@ int ftrace_shutdown_subops(struct ftrace_ops *ops, struct ftrace_ops *subops, in 
		free_ftrace_hash(ops->func_hash->notrace_hash);

		ops->func_hash->filter_hash = EMPTY_HASH;

		ops->func_hash->notrace_hash = EMPTY_HASH;

		subops->flags &= ~(FTRACE_OPS_FL_ENABLED | FTRACE_OPS_FL_SUBOP);

		subops->managed = NULL;



		return 0;

	}
@@ -3553,16 +3575,65 @@ int ftrace_shutdown_subops(struct ftrace_ops *ops, struct ftrace_ops *subops, in 
	}



	ret = ftrace_update_ops(ops, filter_hash, notrace_hash);

	if (ret < 0)

	if (ret < 0) {

		list_add(&subops->list, &ops->subop_list);

	else

		subops->flags &= ~FTRACE_OPS_FL_ENABLED;



	} else {

		subops->flags &= ~(FTRACE_OPS_FL_ENABLED | FTRACE_OPS_FL_SUBOP);

		subops->managed = NULL;

	}

	free_ftrace_hash(filter_hash);

	free_ftrace_hash(notrace_hash);

	return ret;

}



static int ftrace_hash_move_and_update_subops(struct ftrace_ops *subops,

					      struct ftrace_hash **orig_subhash,

					      struct ftrace_hash *hash,

					      int enable)

{

	struct ftrace_ops *ops = subops->managed;

	struct ftrace_hash **orig_hash;

	struct ftrace_hash *save_hash;

	struct ftrace_hash *new_hash;

	int ret;



	/* Manager ops can not be subops (yet) */

	if (WARN_ON_ONCE(!ops || ops->flags & FTRACE_OPS_FL_SUBOP))

		return -EINVAL;



	/* Move the new hash over to the subops hash */

	save_hash = *orig_subhash;

	*orig_subhash = __ftrace_hash_move(hash);

	if (!*orig_subhash) {

		*orig_subhash = save_hash;

		return -ENOMEM;

	}



	/* Create a new_hash to hold the ops new functions */

	if (enable) {

		orig_hash = &ops->func_hash->filter_hash;

		new_hash = append_hashes(ops);

	} else {

		orig_hash = &ops->func_hash->notrace_hash;

		new_hash = intersect_hashes(ops);

	}



	/* Move the hash over to the new hash */

	ret = __ftrace_hash_move_and_update_ops(ops, orig_hash, new_hash, enable);



	free_ftrace_hash(new_hash);



	if (ret) {

		/* Put back the original hash */

		free_ftrace_hash_rcu(*orig_subhash);

		*orig_subhash = save_hash;

	} else {

		free_ftrace_hash_rcu(save_hash);

	}

	return ret;

}





static u64		ftrace_update_time;

unsigned long		ftrace_update_tot_cnt;

unsigned long		ftrace_number_of_pages;
@@ -4779,19 +4850,33 @@ static int ftrace_hash_move_and_update_ops(struct ftrace_ops *ops, 
					   struct ftrace_hash *hash,

					   int enable)

{

	struct ftrace_ops_hash old_hash_ops;

	struct ftrace_hash *old_hash;

	int ret;

	if (ops->flags & FTRACE_OPS_FL_SUBOP)

		return ftrace_hash_move_and_update_subops(ops, orig_hash, hash, enable);



	old_hash = *orig_hash;

	old_hash_ops.filter_hash = ops->func_hash->filter_hash;

	old_hash_ops.notrace_hash = ops->func_hash->notrace_hash;

	ret = ftrace_hash_move(ops, enable, orig_hash, hash);

	if (!ret) {

		ftrace_ops_update_code(ops, &old_hash_ops);

		free_ftrace_hash_rcu(old_hash);

	/*

	 * If this ops is not enabled, it could be sharing its filters

	 * with a subop. If that's the case, update the subop instead of

	 * this ops. Shared filters are only allowed to have one ops set

	 * at a time, and if we update the ops that is not enabled,

	 * it will not affect subops that share it.

	 */

	if (!(ops->flags & FTRACE_OPS_FL_ENABLED)) {

		struct ftrace_ops *op;



		/* Check if any other manager subops maps to this hash */

		do_for_each_ftrace_op(op, ftrace_ops_list) {

			struct ftrace_ops *subops;



			list_for_each_entry(subops, &op->subop_list, list) {

				if ((subops->flags & FTRACE_OPS_FL_ENABLED) &&

				     subops->func_hash == ops->func_hash) {

					return ftrace_hash_move_and_update_subops(subops, orig_hash, hash, enable);

				}

	return ret;

			}

		} while_for_each_ftrace_op(op);

	}



	return __ftrace_hash_move_and_update_ops(ops, orig_hash, hash, enable);

}



static bool module_exists(const char *module)