Skip to contentSkip to conversation

Tracepoint API simplification/cleanup

PATCH In review Mathieu Desnoyers 2 participants 6 messages Mar 21, 2014 – Mar 22, 2014

Subsystems (2)
lore
Share & tools
lore

Mathieu Desnoyers

author reviewer
#0 lore raw

v7 cover Tracepoint API simplification/cleanup

Here is v7 of the tracepoint register/unregister API simplification, submitted for 3.15.

Changes since v1:
- Adapt ftrace/perf callers,
- Update tracepoint.h macro,
- Build tested.

Changes since v2:
- Introduce for_each_tracepoint() iterator to allow listing the currently loaded tracepoints, for modules using coming/going notifiers to track tracepoints.

Changes since v3:
- Introduce module coming and going notifiers each with their own priority to ensure that other coming notifiers are called after, and coming notifiers are called before the tracepoint notifiers.
- Fix: move for_each_tracepoint() outside of the CONFIG_MODULE ifdef.

Changes since v4:
- Split tracepoints_mutex into two locks: tp_modlist_mutex, which protects the tracepoint list of modules, and a tracepoint_mutex, which protects the tracepoints per se. tracepoint_mutex nests inside tp_modlist_mutex.
- Introduce a tracepoint module notifier, to ensure consistency between iteration on tracepoints with for_each_tracepoint() and module coming and going notifications. This consistency is ensured by holding tp_modlist_mutex when calling the notifier and when iterating on the tracepoint module list.

Changes since v5:
- Remove tracepoint_add_old_probes within "Tracepoint cleanup: remove unused API functions" rather than in later patch.
- Remove struct tp_probes "old probes" list within "Tracepoint cleanup:
remove unused API functions", as it is not needed anymore.
- Within "Tracepoint cleanup: remove unused API functions", simply add the new module to tail of list, since there is no need to keep it ordered anymore.

Changes since v6:
- Remove unused struct list_head list from struct tp_probes in patch "Tracepoint: register/unregister struct tracepoint",
- Rename for_each_tracepoint() to for_each_kernel_tracepoint(). Only iterate on kernel tracepoints,
- Registered tracepoint module notifiers now receive struct tp_module pointer rather than struct module pointer,
- register_tracepoint_module_notifier and unregister_tracepoint_module_notifier now iterate on all modules and call coming/going notifiers. This ensures notifier registration and listing of already loaded modules are done atomically (protected by tp_modlist_mutex).

Thanks!

Mathieu

Mathieu Desnoyers (2):
Tracepoint cleanup: remove unused API functions
Tracepoint: register/unregister struct tracepoint

 include/linux/ftrace_event.h |    1 +
 include/linux/tracepoint.h   |   60 ++--
 include/trace/ftrace.h       |    2 +
 kernel/trace/trace_events.c  |    8 +-
 kernel/tracepoint.c          |  705 ++++++++++++++----------------------------
 5 files changed, 260 insertions(+), 516 deletions(-)
Signature · 1 line
1.7.10.4
author reviewer
#1 lore raw

PATCH v7 1/2 Tracepoint cleanup: remove unused API functions

After the following commit:

commit b75ef8b44b1cb95f5a26484b0e2fe37a63b12b44

Author: Mathieu Desnoyers <[email protected]>
Date:   Wed Aug 10 15:18:39 2011 -0400

Tracepoint: Dissociate from module mutex

The following functions became unnecessary:

- tracepoint_probe_register_noupdate,
- tracepoint_probe_unregister_noupdate,
- tracepoint_probe_update_all.

In fact, none of the in-kernel tracers, nor LTTng, nor SystemTAP use them. Remove those.

Moreover, the functions:

- tracepoint_iter_start,
- tracepoint_iter_next,
- tracepoint_iter_stop,
- tracepoint_iter_reset.

are unused by in-kernel tracers, LTTng and SystemTAP. Remove those too.

CC Steven Rostedt <[email protected]>
CC Ingo Molnar <[email protected]>
CC Frederic Weisbecker <[email protected]>
CC Andrew Morton <[email protected]>
CC Frank Ch. Eigler <[email protected]>
CC Johannes Berg <[email protected]>
---
 include/linux/tracepoint.h |   18 ----
 kernel/tracepoint.c        |  221 +-------------------------------------------
 2 files changed, 5 insertions(+), 234 deletions(-)
include/linux/tracepoint.h +0 -18
index 7159a0a..812b255 100644
@@ -48,12 +48,6 @@ extern int tracepoint_probe_register(const char *name, void *probe, void *data);
 extern int
 tracepoint_probe_unregister(const char *name, void *probe, void *data);
 
-extern int tracepoint_probe_register_noupdate(const char *name, void *probe,
-					      void *data);
-extern int tracepoint_probe_unregister_noupdate(const char *name, void *probe,
-						void *data);
-extern void tracepoint_probe_update_all(void);
-
 #ifdef CONFIG_MODULES
 struct tp_module {
 	struct list_head list;
@@ -68,18 +62,6 @@ static inline bool trace_module_has_bad_taint(struct module *mod)
 }
 #endif /* CONFIG_MODULES */
 
-struct tracepoint_iter {
-#ifdef CONFIG_MODULES
-	struct tp_module *module;
-#endif /* CONFIG_MODULES */
-	struct tracepoint * const *tracepoint;
-};
-
-extern void tracepoint_iter_start(struct tracepoint_iter *iter);
-extern void tracepoint_iter_next(struct tracepoint_iter *iter);
-extern void tracepoint_iter_stop(struct tracepoint_iter *iter);
-extern void tracepoint_iter_reset(struct tracepoint_iter *iter);
-
 /*
  * tracepoint_synchronize_unregister must be called between the last tracepoint
  * probe unregistration and the end of module exit to make sure there is no
kernel/tracepoint.c +5 -216

257 lines not on this page · raw message

Signature · 1 line
1.7.10.4
author reviewer
#2 lore raw

PATCH v7 2/2 Tracepoint: register/unregister struct tracepoint

In reply to Mathieu Desnoyers

Register/unregister tracepoint probes with struct tracepoint pointer rather than tracepoint name.

This change, which vastly simplifies tracepoint.c, has been proposed by Steven Rostedt.

Quoted 1 line

From this point on, the tracers need to pass a struct tracepoint pointer

to probe register/unregister. A probe can now only be connected to a tracepoint that exists. Moreover, tracers are responsible for unregistering the probe before the module containing its associated tracepoint is unloaded.

CC Steven Rostedt <[email protected]>
CC Ingo Molnar <[email protected]>
CC Frederic Weisbecker <[email protected]>
CC Andrew Morton <[email protected]>
CC Frank Ch. Eigler <[email protected]>
CC Johannes Berg <[email protected]>
---
 include/linux/ftrace_event.h |    1 +
 include/linux/tracepoint.h   |   42 ++--
 include/trace/ftrace.h       |    2 +
 kernel/trace/trace_events.c  |    8 +-
 kernel/tracepoint.c          |  524 ++++++++++++++++++++----------------------
 5 files changed, 275 insertions(+), 302 deletions(-)
include/linux/ftrace_event.h +1 -0
index 4e4cc28..1592c1c 100644
@@ -230,6 +230,7 @@ struct ftrace_event_call {
 	struct list_head	list;
 	struct ftrace_event_class *class;
 	char			*name;
+	struct tracepoint	*tp;
 	struct trace_event	event;
 	const char		*print_fmt;
 	struct event_filter	*filter;
include/linux/tracepoint.h +25 -17

82 lines not on this page · raw message

include/trace/ftrace.h +2 -0
index 1a8b28d..415b986 100644
@@ -625,6 +625,7 @@ static struct ftrace_event_class __used __refdata event_class_##call = { \
 									\
 static struct ftrace_event_call __used event_##call = {			\
 	.name			= #call,				\
+	.tp			= &__tracepoint_##call,			\
 	.class			= &event_class_##template,		\
 	.event.funcs		= &ftrace_event_type_funcs_##template,	\
 	.print_fmt		= print_fmt_##template,			\
@@ -639,6 +640,7 @@ static const char print_fmt_##call[] = print;				\
 									\
 static struct ftrace_event_call __used event_##call = {			\
 	.name			= #call,				\
+	.tp			= &__tracepoint_##call,			\
 	.class			= &event_class_##template,		\
 	.event.funcs		= &ftrace_event_type_funcs_##call,	\
 	.print_fmt		= print_fmt_##call,			\
kernel/trace/trace_events.c +4 -4
index f3989ce..0e39692 100644
@@ -201,22 +201,22 @@ int ftrace_event_reg(struct ftrace_event_call *call,
 
 	switch (type) {
 	case TRACE_REG_REGISTER:
-		return tracepoint_probe_register(call->name,
+		return tracepoint_probe_register(call->tp,
 						 call->class->probe,
 						 file);
 	case TRACE_REG_UNREGISTER:
-		tracepoint_probe_unregister(call->name,
+		tracepoint_probe_unregister(call->tp,
 					    call->class->probe,
 					    file);
 		return 0;
 
 #ifdef CONFIG_PERF_EVENTS
 	case TRACE_REG_PERF_REGISTER:
-		return tracepoint_probe_register(call->name,
+		return tracepoint_probe_register(call->tp,
 						 call->class->perf_probe,
 						 call);
 	case TRACE_REG_PERF_UNREGISTER:
-		tracepoint_probe_unregister(call->name,
+		tracepoint_probe_unregister(call->tp,
 					    call->class->perf_probe,
 					    call);
 		return 0;
kernel/tracepoint.c +243 -281

711 lines not on this page · raw message

Signature · 1 line
1.7.10.4
maintainer
#3 lore raw

Re: [PATCH v7 2/2] Tracepoint: register/unregister struct tracepoint

On Fri, 21 Mar 2014 01:19:02 -0400

include/linux/ftrace_event.h struct ftrace_event_call { · line 233

Quoted 9 lines
include/linux/ftrace_event.h +1 -0
index 4e4cc28..1592c1c 100644
@@ -230,6 +230,7 @@ struct ftrace_event_call {
 	struct list_head	list;
 	struct ftrace_event_class *class;
 	char			*name;
+	struct tracepoint	*tp;

This change right here just added 17K to the kernel (on a minimum config):

text data bss dec hex filename
8425515 2018936 1302528 11746979 b33ea3 vmlinux.orig
8424914 2036472 1302528 11763914 b380ca vmlinux

The two are redundant. Might as well remove .name and then use .tp->name for referencing the name of the event.

-- Steve

Quoted 3 lines
include/linux/ftrace_event.h +0 -0
 	struct trace_event	event;
 	const char		*print_fmt;
 	struct event_filter	*filter;
author reviewer
#4 lore raw

Re: [PATCH v7 2/2] Tracepoint: register/unregister struct tracepoint

----- Original Message -----

Quoted 23 lines

From: "Steven Rostedt" <[email protected]>
To: "Mathieu Desnoyers" <[email protected]>
Cc: [email protected], "Ingo Molnar" <[email protected]>, "Frederic Weisbecker" <[email protected]>, "Andrew Morton" <[email protected]>, "Frank Ch. Eigler" <[email protected]>, "Johannes Berg" <[email protected]>
Sent: Friday, March 21, 2014 3:40:00 PM
Subject: Re: [PATCH v7 2/2] Tracepoint: register/unregister struct tracepoint

On Fri, 21 Mar 2014 01:19:02 -0400

include/linux/ftrace_event.h struct ftrace_event_call { · line 233

Quoted 9 lines
include/linux/ftrace_event.h +1 -0
index 4e4cc28..1592c1c 100644
@@ -230,6 +230,7 @@ struct ftrace_event_call {
 	struct list_head	list;
 	struct ftrace_event_class *class;
 	char			*name;
+	struct tracepoint	*tp;

This change right here just added 17K to the kernel (on a minimum config):

Quoted 6 lines

text data bss dec hex filename
8425515 2018936 1302528 11746979 b33ea3 vmlinux.orig
8424914 2036472 1302528 11763914 b380ca vmlinux

The two are redundant. Might as well remove .name and then use .tp->name for referencing the name of the event.

What should we do about:

kernel/trace/trace_export.c:

struct ftrace_event_call __used event_##call = {                        \
        .name                   = #call,                                \
        .event.type             = etype,                                \
        .class                  = &event_class_ftrace_##call,           \
        .print_fmt              = print,                                \
        .flags                  = TRACE_EVENT_FL_IGNORE_ENABLE | TRACE_EVENT_FL_USE_CALL_FILTER, \
}; 

when replacing the .name for a .tp->name, it is unclear what the tracepoint structure should be (is there even one ?).

Thanks,

Mathieu

Quoted 8 lines

-- Steve

Quoted 3 lines
include/linux/ftrace_event.h +0 -0
 	struct trace_event	event;
 	const char		*print_fmt;
 	struct event_filter	*filter;
Signature · 3 lines
Mathieu Desnoyers
EfficiOS Inc.
http://www.efficios.com
maintainer
#5 lore raw

Re: [PATCH v7 2/2] Tracepoint: register/unregister struct tracepoint

In reply to Mathieu Desnoyers

include/linux/ftrace_event.h struct ftrace_event_call { · line 233

Quoted 9 lines · On Fri, 21 Mar 2014 01:19:02 -0400 Mathieu Desnoyers…
include/linux/ftrace_event.h +1 -0
index 4e4cc28..1592c1c 100644
@@ -230,6 +230,7 @@ struct ftrace_event_call {
 	struct list_head	list;
 	struct ftrace_event_class *class;
 	char			*name;
+	struct tracepoint	*tp;

Already mentioned this should be one or the other.

Quoted 19 lines
include/linux/ftrace_event.h +0 -0
 	struct trace_event	event;
 	const char		*print_fmt;
 	struct event_filter	*filter;
include/trace/ftrace.h +1 -0
index 1a8b28d..415b986 100644
@@ -625,6 +625,7 @@ static struct ftrace_event_class __used __refdata event_class_##call = { \
 									\
 static struct ftrace_event_call __used event_##call = {			\
 	.name			= #call,				\
+	.tp			= &__tracepoint_##call,			\
 	.class			= &event_class_##template,		\
 	.event.funcs		= &ftrace_event_type_funcs_##template,	\
 	.print_fmt		= print_fmt_##template,			\

include/trace/ftrace.h static const char print_fmt_##call[] = print; \ · line 644

Quoted 5 lines
include/trace/ftrace.h +1 -0
@@ -639,6 +640,7 @@ static const char print_fmt_##call[] = print;				\
 									\
 static struct ftrace_event_call __used event_##call = {			\
 	.name			= #call,				\
+	.tp			= &__tracepoint_##call,			\
 	.class			= &event_class_##template,		\

Same here.

Quoted 64 lines
include/trace/ftrace.h +0 -0
 	.event.funcs		= &ftrace_event_type_funcs_##call,	\
 	.print_fmt		= print_fmt_##call,			\
kernel/tracepoint.c +9 -20
index f27e5f0..85dc2f2 100644
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008 Mathieu Desnoyers
+ * Copyright (C) 2008-2014 Mathieu Desnoyers
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -33,38 +33,27 @@ extern struct tracepoint * const __stop___tracepoints_ptrs[];
 /* Set to 1 to enable tracepoint debug output */
 static const int tracepoint_debug;
 
+#ifdef CONFIG_MODULES
 /*
- * Tracepoints mutex protects the builtin and module tracepoints and the hash
- * table, as well as the local module list.
+ * Tracepoint module list mutex protects the local module list.
  */
-static DEFINE_MUTEX(tracepoints_mutex);
+static DEFINE_MUTEX(tp_modlist_mutex);
 
-#ifdef CONFIG_MODULES
-/* Local list of struct module */
-static LIST_HEAD(tracepoint_module_list);
+/* Local list of struct tp_module */
+static LIST_HEAD(tp_modlist);
 #endif /* CONFIG_MODULES */
 
 /*
- * Tracepoint hash table, containing the active tracepoints.
- * Protected by tracepoints_mutex.
+ * tracepoint_mutex protects the builtin and module tracepoints.
+ * tracepoint_mutex nests inside tp_modlist_mutex.
  */
-#define TRACEPOINT_HASH_BITS 6
-#define TRACEPOINT_TABLE_SIZE (1 << TRACEPOINT_HASH_BITS)
-static struct hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
+static DEFINE_MUTEX(tracepoint_mutex);
 
 /*
  * Note about RCU :
  * It is used to delay the free of multiple probes array until a quiescent
  * state is reached.
- * Tracepoint entries modifications are protected by the tracepoints_mutex.
  */
-struct tracepoint_entry {
-	struct hlist_node hlist;
-	struct tracepoint_func *funcs;
-	int refcount;	/* Number of times armed. 0 if disarmed. */
-	char name[0];
-};
-
 struct tp_probes {
 	struct rcu_head rcu;
 	struct tracepoint_func probes[0];

kernel/tracepoint.c static inline void release_probes(struct tracepoint_func *old) · line 84

Quoted 6 lines
kernel/tracepoint.c +2 -1
@@ -91,34 +80,35 @@ static inline void release_probes(struct tracepoint_func *old)
 	}
 }
 
-static void debug_print_probes(struct tracepoint_entry *entry)
+static
+void debug_print_probes(struct tracepoint_func *funcs)

Why is the above on two lines?

Quoted 8 lines
kernel/tracepoint.c +1 -2
 {
 	int i;
 
-	if (!tracepoint_debug || !entry->funcs)
+	if (!tracepoint_debug || !funcs)
 		return;
 
-	for (i = 0; entry->funcs[i].func; i++)

kernel/tracepoint.c static inline void release_probes(struct tracepoint_func *old) · line 96

Quoted 10 lines
kernel/tracepoint.c +4 -4
-		printk(KERN_DEBUG "Probe %d : %p\n", i, entry->funcs[i].func);
+	for (i = 0; funcs[i].func; i++)
+		printk(KERN_DEBUG "Probe %d : %p\n", i, funcs[i].func);
 }
 
-static struct tracepoint_func *
-tracepoint_entry_add_probe(struct tracepoint_entry *entry,
-			   void *probe, void *data)
+static
+struct tracepoint_func *func_add(struct tracepoint_func **funcs,

Again, static should never be on a separate line. If the function name is too big, you move the name down:

static struct tracepoint_func *
func_add(...)

Quoted 34 lines
kernel/tracepoint.c +7 -10
+		struct tracepoint_func *tp_func)
 {
 	int nr_probes = 0;
 	struct tracepoint_func *old, *new;
 
-	if (WARN_ON(!probe))
+	if (WARN_ON(!tp_func->func))
 		return ERR_PTR(-EINVAL);
 
-	debug_print_probes(entry);
-	old = entry->funcs;
+	debug_print_probes(*funcs);
+	old = *funcs;
 	if (old) {
 		/* (N -> N+1), (N != 0, 1) probes */
 		for (nr_probes = 0; old[nr_probes].func; nr_probes++)
-			if (old[nr_probes].func == probe &&
-			    old[nr_probes].data == data)
+			if (old[nr_probes].func == tp_func->func &&
+			    old[nr_probes].data == tp_func->data)
 				return ERR_PTR(-EEXIST);
 	}
 	/* + 2 : one for new probe, one for NULL func */
@@ -127,33 +117,31 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry,
 		return ERR_PTR(-ENOMEM);
 	if (old)
 		memcpy(new, old, nr_probes * sizeof(struct tracepoint_func));
-	new[nr_probes].func = probe;
-	new[nr_probes].data = data;
+	new[nr_probes] = *tp_func;
 	new[nr_probes + 1].func = NULL;
-	entry->refcount = nr_probes + 1;
-	entry->funcs = new;
-	debug_print_probes(entry);

kernel/tracepoint.c tracepoint_entry_add_probe(struct tracepoint_entry *entry, · line 128

Quoted 10 lines
kernel/tracepoint.c +4 -3
+	*funcs = new;
+	debug_print_probes(*funcs);
 	return old;
 }
 
-static void *
-tracepoint_entry_remove_probe(struct tracepoint_entry *entry,
-			      void *probe, void *data)
+static
+void *func_remove(struct tracepoint_func **funcs,

Again, fix this.

Quoted 104 lines
kernel/tracepoint.c +12 -61
+		struct tracepoint_func *tp_func)
 {
 	int nr_probes = 0, nr_del = 0, i;
 	struct tracepoint_func *old, *new;
 
-	old = entry->funcs;
+	old = *funcs;
 
 	if (!old)
 		return ERR_PTR(-ENOENT);
 
-	debug_print_probes(entry);
+	debug_print_probes(*funcs);
 	/* (N -> M), (N > 1, M >= 0) probes */
-	if (probe) {
+	if (tp_func->func) {
 		for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
-			if (old[nr_probes].func == probe &&
-			     old[nr_probes].data == data)
+			if (old[nr_probes].func == tp_func->func &&
+			     old[nr_probes].data == tp_func->data)
 				nr_del++;
 		}
 	}
@@ -164,9 +152,8 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry,
 	 */
 	if (nr_probes - nr_del == 0) {
 		/* N -> 0, (N > 1) */
-		entry->funcs = NULL;
-		entry->refcount = 0;
-		debug_print_probes(entry);
+		*funcs = NULL;
+		debug_print_probes(*funcs);
 		return old;
 	} else {
 		int j = 0;
@@ -176,90 +163,35 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry,
 		if (new == NULL)
 			return ERR_PTR(-ENOMEM);
 		for (i = 0; old[i].func; i++)
-			if (old[i].func != probe || old[i].data != data)
+			if (old[i].func != tp_func->func
+					|| old[i].data != tp_func->data)
 				new[j++] = old[i];
 		new[nr_probes - nr_del].func = NULL;
-		entry->refcount = nr_probes - nr_del;
-		entry->funcs = new;
+		*funcs = new;
 	}
-	debug_print_probes(entry);
+	debug_print_probes(*funcs);
 	return old;
 }
 
 /*
- * Get tracepoint if the tracepoint is present in the tracepoint hash table.
- * Must be called with tracepoints_mutex held.
- * Returns NULL if not present.
- */
-static struct tracepoint_entry *get_tracepoint(const char *name)
-{
-	struct hlist_head *head;
-	struct tracepoint_entry *e;
-	u32 hash = jhash(name, strlen(name), 0);
-
-	head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
-	hlist_for_each_entry(e, head, hlist) {
-		if (!strcmp(name, e->name))
-			return e;
-	}
-	return NULL;
-}
-
-/*
- * Add the tracepoint to the tracepoint hash table. Must be called with
- * tracepoints_mutex held.
- */
-static struct tracepoint_entry *add_tracepoint(const char *name)
-{
-	struct hlist_head *head;
-	struct tracepoint_entry *e;
-	size_t name_len = strlen(name) + 1;
-	u32 hash = jhash(name, name_len-1, 0);
-
-	head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
-	hlist_for_each_entry(e, head, hlist) {
-		if (!strcmp(name, e->name)) {
-			printk(KERN_NOTICE
-				"tracepoint %s busy\n", name);
-			return ERR_PTR(-EEXIST);	/* Already there */
-		}
-	}
-	/*
-	 * Using kmalloc here to allocate a variable length element. Could
-	 * cause some memory fragmentation if overused.
-	 */
-	e = kmalloc(sizeof(struct tracepoint_entry) + name_len, GFP_KERNEL);
-	if (!e)
-		return ERR_PTR(-ENOMEM);
-	memcpy(&e->name[0], name, name_len);
-	e->funcs = NULL;
-	e->refcount = 0;
-	hlist_add_head(&e->hlist, head);
-	return e;

kernel/tracepoint.c tracepoint_entry_remove_probe(struct tracepoint_entry *entry, · line 180

Quoted 10 lines
kernel/tracepoint.c +3 -6
-}
-
-/*
- * Remove the tracepoint from the tracepoint hash table. Must be called with
- * mutex_lock held.
+ * Add the probe function to a tracepoint.
  */
-static inline void remove_tracepoint(struct tracepoint_entry *e)
+static
+int tracepoint_add_func(struct tracepoint *tp,

Again fix.

Quoted 46 lines
kernel/tracepoint.c +15 -19
+		struct tracepoint_func *func)
 {
-	hlist_del(&e->hlist);
-	kfree(e);
-}
+	struct tracepoint_func *old, *tp_funcs;
 
-/*
- * Sets the probe callback corresponding to one tracepoint.
- */
-static void set_tracepoint(struct tracepoint_entry **entry,
-	struct tracepoint *elem, int active)
-{
-	WARN_ON(strcmp((*entry)->name, elem->name) != 0);
+	if (tp->regfunc && !static_key_enabled(&tp->key))
+		tp->regfunc();
 
-	if (elem->regfunc && !static_key_enabled(&elem->key) && active)
-		elem->regfunc();
-	else if (elem->unregfunc && static_key_enabled(&elem->key) && !active)
-		elem->unregfunc();
+	tp_funcs = tp->funcs;
+	old = func_add(&tp_funcs, func);
+	if (IS_ERR(old)) {
+		WARN_ON_ONCE(1);
+		return PTR_ERR(old);
+	}
+	release_probes(old);
 
 	/*
 	 * rcu_assign_pointer has a smp_wmb() which makes sure that the new
@@ -268,192 +200,180 @@ static void set_tracepoint(struct tracepoint_entry **entry,
 	 * include/linux/tracepoints.h. A matching smp_read_barrier_depends()
 	 * is used.
 	 */
-	rcu_assign_pointer(elem->funcs, (*entry)->funcs);
-	if (active && !static_key_enabled(&elem->key))
-		static_key_slow_inc(&elem->key);
-	else if (!active && static_key_enabled(&elem->key))
-		static_key_slow_dec(&elem->key);
+	rcu_assign_pointer(tp->funcs, tp_funcs);
+	if (!static_key_enabled(&tp->key))
+		static_key_slow_inc(&tp->key);
+	return 0;
 }
 

kernel/tracepoint.c static void set_tracepoint(struct tracepoint_entry **entry, · line 216

Quoted 10 lines
kernel/tracepoint.c +3 -2
 /*
- * Disable a tracepoint and its probe callback.
+ * Remove a probe function from a tracepoint.
  * Note: only waiting an RCU period after setting elem->call to the empty
  * function insures that the original callback is not used anymore. This insured
  * by preempt_disable around the call site.
  */
-static void disable_tracepoint(struct tracepoint *elem)
+static
+int tracepoint_remove_func(struct tracepoint *tp,

Again fix.

Quoted 169 lines
kernel/tracepoint.c +67 -82
+		struct tracepoint_func *func)
 {
-	if (elem->unregfunc && static_key_enabled(&elem->key))
-		elem->unregfunc();
-
-	if (static_key_enabled(&elem->key))
-		static_key_slow_dec(&elem->key);
-	rcu_assign_pointer(elem->funcs, NULL);
-}
+	struct tracepoint_func *old, *tp_funcs;
 
-/**
- * tracepoint_update_probe_range - Update a probe range
- * @begin: beginning of the range
- * @end: end of the range
- *
- * Updates the probe callback corresponding to a range of tracepoints.
- * Called with tracepoints_mutex held.
- */
-static void tracepoint_update_probe_range(struct tracepoint * const *begin,
-					  struct tracepoint * const *end)
-{
-	struct tracepoint * const *iter;
-	struct tracepoint_entry *mark_entry;
+	tp_funcs = tp->funcs;
+	old = func_remove(&tp_funcs, func);
+	if (IS_ERR(old)) {
+		WARN_ON_ONCE(1);
+		return PTR_ERR(old);
+	}
+	release_probes(old);
 
-	if (!begin)
-		return;
+	if (!tp_funcs) {
+		/* Removed last function */
+		if (tp->unregfunc && static_key_enabled(&tp->key))
+			tp->unregfunc();
 
-	for (iter = begin; iter < end; iter++) {
-		mark_entry = get_tracepoint((*iter)->name);
-		if (mark_entry) {
-			set_tracepoint(&mark_entry, *iter,
-					!!mark_entry->refcount);
-		} else {
-			disable_tracepoint(*iter);
-		}
+		if (static_key_enabled(&tp->key))
+			static_key_slow_dec(&tp->key);
 	}
+	rcu_assign_pointer(tp->funcs, tp_funcs);
+	return 0;
 }
 
-#ifdef CONFIG_MODULES
-void module_update_tracepoints(void)
-{
-	struct tp_module *tp_mod;
-
-	list_for_each_entry(tp_mod, &tracepoint_module_list, list)
-		tracepoint_update_probe_range(tp_mod->tracepoints_ptrs,
-			tp_mod->tracepoints_ptrs + tp_mod->num_tracepoints);
-}
-#else /* CONFIG_MODULES */
-void module_update_tracepoints(void)
+/**
+ * tracepoint_probe_register -  Connect a probe to a tracepoint
+ * @tp: tracepoint
+ * @probe: probe handler
+ *
+ * Returns 0 if ok, error value on error.
+ * Note: if @tp is within a module, the caller is responsible for
+ * unregistering the probe before the module is gone. This can be
+ * performed either with a tracepoint module going notifier, or from
+ * within module exit functions.
+ */
+int tracepoint_probe_register(struct tracepoint *tp, void *probe, void *data)
 {
+	struct tracepoint_func tp_func;
+	int ret;
+
+	mutex_lock(&tracepoint_mutex);
+	tp_func.func = probe;
+	tp_func.data = data;
+	ret = tracepoint_add_func(tp, &tp_func);
+	mutex_unlock(&tracepoint_mutex);
+	return ret;
 }
-#endif /* CONFIG_MODULES */
-
+EXPORT_SYMBOL_GPL(tracepoint_probe_register);
 
-/*
- * Update probes, removing the faulty probes.
- * Called with tracepoints_mutex held.
+/**
+ * tracepoint_probe_unregister -  Disconnect a probe from a tracepoint
+ * @tp: tracepoint
+ * @probe: probe function pointer
+ *
+ * Returns 0 if ok, error value on error.
  */
-static void tracepoint_update_probes(void)
+int tracepoint_probe_unregister(struct tracepoint *tp, void *probe, void *data)
 {
-	/* Core kernel tracepoints */
-	tracepoint_update_probe_range(__start___tracepoints_ptrs,
-		__stop___tracepoints_ptrs);
-	/* tracepoints in modules. */
-	module_update_tracepoints();
+	struct tracepoint_func tp_func;
+	int ret;
+
+	mutex_lock(&tracepoint_mutex);
+	tp_func.func = probe;
+	tp_func.data = data;
+	ret = tracepoint_remove_func(tp, &tp_func);
+	mutex_unlock(&tracepoint_mutex);
+	return ret;
 }
+EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
 
-static struct tracepoint_func *
-tracepoint_add_probe(const char *name, void *probe, void *data)
+#ifdef CONFIG_MODULES
+bool trace_module_has_bad_taint(struct module *mod)
 {
-	struct tracepoint_entry *entry;
-	struct tracepoint_func *old;
-
-	entry = get_tracepoint(name);
-	if (!entry) {
-		entry = add_tracepoint(name);
-		if (IS_ERR(entry))
-			return (struct tracepoint_func *)entry;
-	}
-	old = tracepoint_entry_add_probe(entry, probe, data);
-	if (IS_ERR(old) && !entry->refcount)
-		remove_tracepoint(entry);
-	return old;
+	return mod->taints & ~((1 << TAINT_OOT_MODULE) | (1 << TAINT_CRAP));
 }
 
+static BLOCKING_NOTIFIER_HEAD(tracepoint_notify_list);
+
 /**
- * tracepoint_probe_register -  Connect a probe to a tracepoint
- * @name: tracepoint name
- * @probe: probe handler
+ * register_tracepoint_notifier - register tracepoint coming/going notifier
+ * @nb: notifier block
  *
- * Returns 0 if ok, error value on error.
- * The probe address must at least be aligned on the architecture pointer size.
+ * Notifiers registered with this function are called on module
+ * coming/going with the tp_modlist_mutex held.
+ * The notifier block callback should expect a "struct tp_module" data
+ * pointer.
  */
-int tracepoint_probe_register(const char *name, void *probe, void *data)
-{
-	struct tracepoint_func *old;
-
-	mutex_lock(&tracepoints_mutex);
-	old = tracepoint_add_probe(name, probe, data);
-	if (IS_ERR(old)) {
-		mutex_unlock(&tracepoints_mutex);
-		return PTR_ERR(old);
-	}

kernel/tracepoint.c static void set_tracepoint(struct tracepoint_entry **entry, · line 304

Quoted 10 lines
kernel/tracepoint.c +1 -9
-	tracepoint_update_probes();		/* may update entry */
-	mutex_unlock(&tracepoints_mutex);
-	release_probes(old);
-	return 0;
-}
-EXPORT_SYMBOL_GPL(tracepoint_probe_register);
-
-static struct tracepoint_func *
-tracepoint_remove_probe(const char *name, void *probe, void *data)
+int register_tracepoint_module_notifier(struct notifier_block *nb)

WTF is this?

You created a notifier for a notifier? No! keep track yourself what tracepoints you enabled for a module and just add a module notifier for yourself and when a module exits, remove your tracepoints. This is dead code. There's no users in the kernel of this notifier. It's not needed. Get rid of it.

The ftrace event system can handle events that are being removed when a module is unloaded. So can your code.

-- Steve

Quoted 249 lines
kernel/tracepoint.c +115 -62
 {
-	struct tracepoint_entry *entry;
-	struct tracepoint_func *old;
+	struct tp_module *tp_mod;
+	int ret;
 
-	entry = get_tracepoint(name);
-	if (!entry)
-		return ERR_PTR(-ENOENT);
-	old = tracepoint_entry_remove_probe(entry, probe, data);
-	if (IS_ERR(old))
-		return old;
-	if (!entry->refcount)
-		remove_tracepoint(entry);
-	return old;
+	mutex_lock(&tp_modlist_mutex);
+	ret = blocking_notifier_chain_register(&tracepoint_notify_list, nb);
+	if (ret)
+		goto end;
+	list_for_each_entry(tp_mod, &tp_modlist, list)
+		(void) nb->notifier_call(nb, MODULE_STATE_COMING, tp_mod);
+end:
+	mutex_unlock(&tp_modlist_mutex);
+	return ret;
 }
+EXPORT_SYMBOL_GPL(register_tracepoint_module_notifier);
 
 /**
- * tracepoint_probe_unregister -  Disconnect a probe from a tracepoint
- * @name: tracepoint name
- * @probe: probe function pointer
+ * unregister_tracepoint_notifier - unregister tracepoint coming/going notifier
+ * @nb: notifier block
  *
- * We do not need to call a synchronize_sched to make sure the probes have
- * finished running before doing a module unload, because the module unload
- * itself uses stop_machine(), which insures that every preempt disabled section
- * have finished.
+ * The notifier block callback should expect a "struct tp_module" data
+ * pointer.
  */
-int tracepoint_probe_unregister(const char *name, void *probe, void *data)
+int unregister_tracepoint_module_notifier(struct notifier_block *nb)
 {
-	struct tracepoint_func *old;
+	struct tp_module *tp_mod;
+	int ret;
+
+	mutex_lock(&tp_modlist_mutex);
+	ret = blocking_notifier_chain_unregister(&tracepoint_notify_list, nb);
+	if (ret)
+		goto end;
+	list_for_each_entry(tp_mod, &tp_modlist, list)
+		(void) nb->notifier_call(nb, MODULE_STATE_GOING, tp_mod);
+end:
+	mutex_unlock(&tp_modlist_mutex);
+	return ret;
 
-	mutex_lock(&tracepoints_mutex);
-	old = tracepoint_remove_probe(name, probe, data);
-	if (IS_ERR(old)) {
-		mutex_unlock(&tracepoints_mutex);
-		return PTR_ERR(old);
-	}
-	tracepoint_update_probes();		/* may update entry */
-	mutex_unlock(&tracepoints_mutex);
-	release_probes(old);
-	return 0;
 }
-EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
+EXPORT_SYMBOL_GPL(unregister_tracepoint_module_notifier);
 
-#ifdef CONFIG_MODULES
-bool trace_module_has_bad_taint(struct module *mod)
+/*
+ * Ensure the tracer unregistered the module's probes before the module
+ * teardown is performed. Prevents leaks of probe and data pointers.
+ */
+static
+void tp_module_going_check_quiescent(struct tracepoint * const *begin,
+		struct tracepoint * const *end)
 {
-	return mod->taints & ~((1 << TAINT_OOT_MODULE) | (1 << TAINT_CRAP));
+	struct tracepoint * const *iter;
+
+	if (!begin)
+		return;
+	for (iter = begin; iter < end; iter++)
+		WARN_ON_ONCE((*iter)->funcs);
 }
 
-static int tracepoint_module_coming(struct module *mod)
+static
+int tracepoint_module_coming(struct module *mod)
 {
 	struct tp_module *tp_mod;
 	int ret = 0;
 
 	/*
-	 * We skip modules that taint the kernel, especially those with different
-	 * module headers (for forced load), to make sure we don't cause a crash.
-	 * Staging and out-of-tree GPL modules are fine.
+	 * We skip modules that taint the kernel, especially those with
+	 * different module headers (for forced load), to make sure we
+	 * don't cause a crash. Staging and out-of-tree GPL modules are
+	 * fine.
 	 */
 	if (trace_module_has_bad_taint(mod))
 		return 0;
-	mutex_lock(&tracepoints_mutex);
+	mutex_lock(&tp_modlist_mutex);
 	tp_mod = kmalloc(sizeof(struct tp_module), GFP_KERNEL);
 	if (!tp_mod) {
 		ret = -ENOMEM;
@@ -461,25 +381,32 @@ static int tracepoint_module_coming(struct module *mod)
 	}
 	tp_mod->num_tracepoints = mod->num_tracepoints;
 	tp_mod->tracepoints_ptrs = mod->tracepoints_ptrs;
-	list_add_tail(&tp_mod->list, &tracepoint_module_list);
-	tracepoint_update_probe_range(mod->tracepoints_ptrs,
-		mod->tracepoints_ptrs + mod->num_tracepoints);
+	list_add_tail(&tp_mod->list, &tp_modlist);
+	blocking_notifier_call_chain(&tracepoint_notify_list,
+			MODULE_STATE_COMING, tp_mod);
 end:
-	mutex_unlock(&tracepoints_mutex);
+	mutex_unlock(&tp_modlist_mutex);
 	return ret;
 }
 
-static int tracepoint_module_going(struct module *mod)
+static
+void tracepoint_module_going(struct module *mod)
 {
-	struct tp_module *pos;
-
-	mutex_lock(&tracepoints_mutex);
-	tracepoint_update_probe_range(mod->tracepoints_ptrs,
-		mod->tracepoints_ptrs + mod->num_tracepoints);
-	list_for_each_entry(pos, &tracepoint_module_list, list) {
-		if (pos->tracepoints_ptrs == mod->tracepoints_ptrs) {
-			list_del(&pos->list);
-			kfree(pos);
+	struct tp_module *tp_mod;
+
+	mutex_lock(&tp_modlist_mutex);
+	list_for_each_entry(tp_mod, &tp_modlist, list) {
+		if (tp_mod->tracepoints_ptrs == mod->tracepoints_ptrs) {
+			blocking_notifier_call_chain(&tracepoint_notify_list,
+					MODULE_STATE_GOING, tp_mod);
+			list_del(&tp_mod->list);
+			kfree(tp_mod);
+			/*
+			 * Called the going notifier before checking for
+			 * quiescence.
+			 */
+			tp_module_going_check_quiescent(mod->tracepoints_ptrs,
+				mod->tracepoints_ptrs + mod->num_tracepoints);
 			break;
 		}
 	}
@@ -489,12 +416,12 @@ static int tracepoint_module_going(struct module *mod)
 	 * flag on "going", in case a module taints the kernel only after being
 	 * loaded.
 	 */
-	mutex_unlock(&tracepoints_mutex);
-	return 0;
+	mutex_unlock(&tp_modlist_mutex);
 }
 
+static
 int tracepoint_module_notify(struct notifier_block *self,
-			     unsigned long val, void *data)
+		unsigned long val, void *data)
 {
 	struct module *mod = data;
 	int ret = 0;
@@ -503,30 +430,65 @@ int tracepoint_module_notify(struct notifier_block *self,
 	case MODULE_STATE_COMING:
 		ret = tracepoint_module_coming(mod);
 		break;
-	case MODULE_STATE_LIVE:
-		break;
 	case MODULE_STATE_GOING:
-		ret = tracepoint_module_going(mod);
+		tracepoint_module_going(mod);
+		break;
+	default:
 		break;
 	}
 	return ret;
 }
 
+static
 struct notifier_block tracepoint_module_nb = {
 	.notifier_call = tracepoint_module_notify,
 	.priority = 0,
 };
 
-static int init_tracepoints(void)
+static __init
+int init_tracepoints(void)
 {
-	return register_module_notifier(&tracepoint_module_nb);
+	int ret;
+
+	ret = register_module_notifier(&tracepoint_module_nb);
+	if (ret) {
+		pr_warning("Failed to register tracepoint module enter notifier\n");
+	}
+	return ret;
 }
 __initcall(init_tracepoints);
 #endif /* CONFIG_MODULES */
 
+static
+void for_each_tracepoint_range(struct tracepoint * const *begin,
+		struct tracepoint * const *end,
+		void (*fct)(struct tracepoint *tp, void *priv),
+		void *priv)
+{
+	struct tracepoint * const *iter;
+
+	if (!begin)
+		return;
+	for (iter = begin; iter < end; iter++)
+		fct(*iter, priv);
+}
+
+/**
+ * for_each_kernel_tracepoint - iteration on all kernel tracepoints
+ * @fct: callback
+ * @priv: private data
+ */
+void for_each_kernel_tracepoint(void (*fct)(struct tracepoint *tp, void *priv),
+		void *priv)
+{
+	for_each_tracepoint_range(__start___tracepoints_ptrs,
+		__stop___tracepoints_ptrs, fct, priv);
+}
+EXPORT_SYMBOL_GPL(for_each_kernel_tracepoint);
+
 #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
 
-/* NB: reg/unreg are called while guarded with the tracepoints_mutex */
+/* NB: reg/unreg are called while guarded with the tracepoint_mutex */
 static int sys_tracepoint_refcount;
 
 void syscall_regfunc(void)