Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d7fbf8df authored by Steven Rostedt (VMware)'s avatar Steven Rostedt (VMware)
Browse files

ftrace: Implement cached modules tracing on module load 



If a module is cached in the set_ftrace_filter, and that module is loaded,
then enable tracing on that module as if the cached module text was written
into set_ftrace_filter just as the module is loaded.

  # echo ":mod:kvm_intel" >
  # cat /sys/kernel/tracing/set_ftrace_filter
 #### all functions enabled ####
 :mod:kvm_intel
  # modprobe kvm_intel
  # cat /sys/kernel/tracing/set_ftrace_filter
 vmx_get_rflags [kvm_intel]
 vmx_get_pkru [kvm_intel]
 vmx_get_interrupt_shadow [kvm_intel]
 vmx_rdtscp_supported [kvm_intel]
 vmx_invpcid_supported [kvm_intel]
 [..]

Signed-off-by: default avatarSteven Rostedt (VMware) <rostedt@goodmis.org>
parent 5985ea8b

kernel/trace/ftrace.c

+93 −0
Original line number Diff line number Diff line
@@ -3969,6 +3969,97 @@ static int cache_mod(struct trace_array *tr, 
	return ret;

}



static int

ftrace_set_regex(struct ftrace_ops *ops, unsigned char *buf, int len,

		 int reset, int enable);



static void process_mod_list(struct list_head *head, struct ftrace_ops *ops,

			     char *mod, bool enable)

{

	struct ftrace_mod_load *ftrace_mod, *n;

	struct ftrace_hash **orig_hash, *new_hash;

	LIST_HEAD(process_mods);

	char *func;

	int ret;



	mutex_lock(&ops->func_hash->regex_lock);



	if (enable)

		orig_hash = &ops->func_hash->filter_hash;

	else

		orig_hash = &ops->func_hash->notrace_hash;



	new_hash = alloc_and_copy_ftrace_hash(FTRACE_HASH_DEFAULT_BITS,

					      *orig_hash);

	if (!new_hash)

		return; /* Warn? */



	mutex_lock(&ftrace_lock);



	list_for_each_entry_safe(ftrace_mod, n, head, list) {



		if (strcmp(ftrace_mod->module, mod) != 0)

			continue;



		if (ftrace_mod->func)

			func = kstrdup(ftrace_mod->func, GFP_KERNEL);

		else

			func = kstrdup("*", GFP_KERNEL);



		if (!func) /* warn? */

			continue;



		list_del(&ftrace_mod->list);

		list_add(&ftrace_mod->list, &process_mods);



		/* Use the newly allocated func, as it may be "*" */

		kfree(ftrace_mod->func);

		ftrace_mod->func = func;

	}



	mutex_unlock(&ftrace_lock);



	list_for_each_entry_safe(ftrace_mod, n, &process_mods, list) {



		func = ftrace_mod->func;



		/* Grabs ftrace_lock, which is why we have this extra step */

		match_records(new_hash, func, strlen(func), mod);

		free_ftrace_mod(ftrace_mod);

	}



	mutex_lock(&ftrace_lock);



	ret = ftrace_hash_move_and_update_ops(ops, orig_hash,

					      new_hash, enable);

	mutex_unlock(&ftrace_lock);



	mutex_unlock(&ops->func_hash->regex_lock);



	free_ftrace_hash(new_hash);

}



static void process_cached_mods(const char *mod_name)

{

	struct trace_array *tr;

	char *mod;



	mod = kstrdup(mod_name, GFP_KERNEL);

	if (!mod)

		return;



	mutex_lock(&trace_types_lock);

	list_for_each_entry(tr, &ftrace_trace_arrays, list) {

		if (!list_empty(&tr->mod_trace))

			process_mod_list(&tr->mod_trace, tr->ops, mod, true);

		if (!list_empty(&tr->mod_notrace))

			process_mod_list(&tr->mod_notrace, tr->ops, mod, false);

	}

	mutex_unlock(&trace_types_lock);



	kfree(mod);

}



/*

 * We register the module command as a template to show others how

 * to register the a command as well.
@@ -5682,6 +5773,8 @@ void ftrace_module_enable(struct module *mod) 


 out_unlock:

	mutex_unlock(&ftrace_lock);



	process_cached_mods(mod->name);

}



void ftrace_module_init(struct module *mod)