Commit 05dc5e9c authored by Jiri Olsa's avatar Jiri Olsa Committed by Andrii Nakryiko
Browse files

ftrace: Add update_ftrace_direct_add function 



Adding update_ftrace_direct_add function that adds all entries
(ip -> addr) provided in hash argument to direct ftrace ops
and updates its attachments.

The difference to current register_ftrace_direct is
 - hash argument that allows to register multiple ip -> direct
   entries at once
 - we can call update_ftrace_direct_add multiple times on the
   same ftrace_ops object, becase after first registration with
   register_ftrace_function_nolock, it uses ftrace_update_ops to
   update the ftrace_ops object

This change will allow us to have simple ftrace_ops for all bpf
direct interface users in following changes.

Signed-off-by: default avatarJiri Olsa <jolsa@kernel.org>
Signed-off-by: default avatarAndrii Nakryiko <andrii@kernel.org>
Reviewed-by: default avatarSteven Rostedt (Google) <rostedt@goodmis.org>
Link: https://lore.kernel.org/bpf/20251230145010.103439-5-jolsa@kernel.org
parent 0e860d07

include/linux/ftrace.h

+7 −0
Original line number Diff line number Diff line
@@ -543,6 +543,8 @@ int unregister_ftrace_direct(struct ftrace_ops *ops, unsigned long addr, 
int modify_ftrace_direct(struct ftrace_ops *ops, unsigned long addr);

int modify_ftrace_direct_nolock(struct ftrace_ops *ops, unsigned long addr);



int update_ftrace_direct_add(struct ftrace_ops *ops, struct ftrace_hash *hash);



void ftrace_stub_direct_tramp(void);



#else
@@ -569,6 +571,11 @@ static inline int modify_ftrace_direct_nolock(struct ftrace_ops *ops, unsigned l 
	return -ENODEV;

}



static inline int update_ftrace_direct_add(struct ftrace_ops *ops, struct ftrace_hash *hash)

{

	return -ENODEV;

}



/*

 * This must be implemented by the architecture.

 * It is the way the ftrace direct_ops helper, when called

kernel/trace/ftrace.c

+140 −0
Original line number Diff line number Diff line
@@ -6278,6 +6278,146 @@ int modify_ftrace_direct(struct ftrace_ops *ops, unsigned long addr) 
	return err;

}

EXPORT_SYMBOL_GPL(modify_ftrace_direct);



static unsigned long hash_count(struct ftrace_hash *hash)

{

	return hash ? hash->count : 0;

}



/**

 * hash_add - adds two struct ftrace_hash and returns the result

 * @a: struct ftrace_hash object

 * @b: struct ftrace_hash object

 *

 * Returns struct ftrace_hash object on success, NULL on error.

 */

static struct ftrace_hash *hash_add(struct ftrace_hash *a, struct ftrace_hash *b)

{

	struct ftrace_func_entry *entry;

	struct ftrace_hash *add;

	int size;



	size = hash_count(a) + hash_count(b);

	if (size > 32)

		size = 32;



	add = alloc_and_copy_ftrace_hash(fls(size), a);

	if (!add)

		return NULL;



	size = 1 << b->size_bits;

	for (int i = 0; i < size; i++) {

		hlist_for_each_entry(entry, &b->buckets[i], hlist) {

			if (add_ftrace_hash_entry_direct(add, entry->ip, entry->direct) == NULL) {

				free_ftrace_hash(add);

				return NULL;

			}

		}

	}

	return add;

}



/**

 * update_ftrace_direct_add - Updates @ops by adding direct

 * callers provided in @hash

 * @ops: The address of the struct ftrace_ops object

 * @hash: The address of the struct ftrace_hash object

 *

 * This is used to add custom direct callers (ip -> addr) to @ops,

 * specified in @hash. The @ops will be either registered or updated.

 *

 * Returns: zero on success. Non zero on error, which includes:

 *  -EINVAL - The @hash is empty

 */

int update_ftrace_direct_add(struct ftrace_ops *ops, struct ftrace_hash *hash)

{

	struct ftrace_hash *old_direct_functions = NULL;

	struct ftrace_hash *new_direct_functions;

	struct ftrace_hash *old_filter_hash;

	struct ftrace_hash *new_filter_hash = NULL;

	struct ftrace_func_entry *entry;

	int err = -EINVAL;

	int size;

	bool reg;



	if (!hash_count(hash))

		return -EINVAL;



	mutex_lock(&direct_mutex);



	/* Make sure requested entries are not already registered. */

	size = 1 << hash->size_bits;

	for (int i = 0; i < size; i++) {

		hlist_for_each_entry(entry, &hash->buckets[i], hlist) {

			if (__ftrace_lookup_ip(direct_functions, entry->ip))

				goto out_unlock;

		}

	}



	old_filter_hash = ops->func_hash ? ops->func_hash->filter_hash : NULL;



	/* If there's nothing in filter_hash we need to register the ops. */

	reg = hash_count(old_filter_hash) == 0;

	if (reg) {

		if (ops->func || ops->trampoline)

			goto out_unlock;

		if (ops->flags & FTRACE_OPS_FL_ENABLED)

			goto out_unlock;

	}



	err = -ENOMEM;

	new_filter_hash = hash_add(old_filter_hash, hash);

	if (!new_filter_hash)

		goto out_unlock;



	new_direct_functions = hash_add(direct_functions, hash);

	if (!new_direct_functions)

		goto out_unlock;



	old_direct_functions = direct_functions;

	rcu_assign_pointer(direct_functions, new_direct_functions);



	if (reg) {

		ops->func = call_direct_funcs;

		ops->flags |= MULTI_FLAGS;

		ops->trampoline = FTRACE_REGS_ADDR;

		ops->local_hash.filter_hash = new_filter_hash;



		err = register_ftrace_function_nolock(ops);

		if (err) {

			/* restore old filter on error */

			ops->local_hash.filter_hash = old_filter_hash;



			/* cleanup for possible another register call */

			ops->func = NULL;

			ops->trampoline = 0;

		} else {

			new_filter_hash = old_filter_hash;

		}

	} else {

		err = ftrace_update_ops(ops, new_filter_hash, EMPTY_HASH);

		/*

		 * new_filter_hash is dup-ed, so we need to release it anyway,

		 * old_filter_hash either stays on error or is already released

		 */

	}



	if (err) {

		/* reset direct_functions and free the new one */

		rcu_assign_pointer(direct_functions, old_direct_functions);

		old_direct_functions = new_direct_functions;

	}



 out_unlock:

	mutex_unlock(&direct_mutex);



	if (old_direct_functions && old_direct_functions != EMPTY_HASH)

		call_rcu_tasks(&old_direct_functions->rcu, register_ftrace_direct_cb);

	free_ftrace_hash(new_filter_hash);



	return err;

}



#endif /* CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS */



/**