X-Git-Url: https://git.lttng.org/?p=ust.git;a=blobdiff_plain;f=libust%2Ftracepoint.c;h=ca40902494f61b9785a1e0b863852dca4694aff3;hp=8eee320d4149bbc7bca9416ce7264a4c2821a900;hb=f218ff2821b494cf7b0fc3978e944070ad418772;hpb=518d7abb8e3720433c611499f704c3bd9d554102

diff --git a/libust/tracepoint.c b/libust/tracepoint.c
index 8eee320..ca40902 100644
--- a/libust/tracepoint.c
+++ b/libust/tracepoint.c
@@ -27,6 +27,7 @@
 
 #define _LGPL_SOURCE
 #include <urcu-bp.h>
+#include <urcu/hlist.h>
 
 //extern struct tracepoint __start___tracepoints[] __attribute__((visibility("hidden")));
 //extern struct tracepoint __stop___tracepoints[] __attribute__((visibility("hidden")));
@@ -35,7 +36,7 @@
 static const int tracepoint_debug;
 
 /* libraries that contain tracepoints (struct tracepoint_lib) */
-static LIST_HEAD(libs);
+static CDS_LIST_HEAD(libs);
 
 /*
  * tracepoints_mutex nests inside module_mutex. Tracepoints mutex protects the
@@ -49,7 +50,7 @@ static DEFINE_MUTEX(tracepoints_mutex);
  */
 #define TRACEPOINT_HASH_BITS 6
 #define TRACEPOINT_TABLE_SIZE (1 << TRACEPOINT_HASH_BITS)
-static struct hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
+static struct cds_hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
 
 /*
  * Note about RCU :
@@ -58,8 +59,8 @@ static struct hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
  * Tracepoint entries modifications are protected by the tracepoints_mutex.
  */
 struct tracepoint_entry {
-	struct hlist_node hlist;
-	void **funcs;
+	struct cds_hlist_node hlist;
+	struct probe *probes;
 	int refcount;	/* Number of times armed. 0 if disarmed. */
 	char name[0];
 };
@@ -67,14 +68,14 @@ struct tracepoint_entry {
 struct tp_probes {
 	union {
 //ust//		struct rcu_head rcu;
-		struct list_head list;
+		struct cds_list_head list;
 	} u;
-	void *probes[0];
+	struct probe probes[0];
 };
 
 static inline void *allocate_probes(int count)
 {
-	struct tp_probes *p  = malloc(count * sizeof(void *)
+	struct tp_probes *p  = zmalloc(count * sizeof(struct probe)
 			+ sizeof(struct tp_probes));
 	return p == NULL ? NULL : p->probes;
 }
@@ -87,7 +88,7 @@ static inline void *allocate_probes(int count)
 static inline void release_probes(void *old)
 {
 	if (old) {
-		struct tp_probes *tp_probes = container_of(old,
+		struct tp_probes *tp_probes = _ust_container_of(old,
 			struct tp_probes, probes[0]);
 //ust//		call_rcu_sched(&tp_probes->u.rcu, rcu_free_old_probes);
 		synchronize_rcu();
@@ -99,27 +100,29 @@ static void debug_print_probes(struct tracepoint_entry *entry)
 {
 	int i;
 
-	if (!tracepoint_debug || !entry->funcs)
+	if (!tracepoint_debug || !entry->probes)
 		return;
 
-	for (i = 0; entry->funcs[i]; i++)
-		DBG("Probe %d : %p", i, entry->funcs[i]);
+	for (i = 0; entry->probes[i].func; i++)
+		DBG("Probe %d : %p", i, entry->probes[i].func);
 }
 
 static void *
-tracepoint_entry_add_probe(struct tracepoint_entry *entry, void *probe)
+tracepoint_entry_add_probe(struct tracepoint_entry *entry,
+			   void *probe, void *data)
 {
 	int nr_probes = 0;
-	void **old, **new;
+	struct probe *old, *new;
 
 	WARN_ON(!probe);
 
 	debug_print_probes(entry);
-	old = entry->funcs;
+	old = entry->probes;
 	if (old) {
 		/* (N -> N+1), (N != 0, 1) probes */
-		for (nr_probes = 0; old[nr_probes]; nr_probes++)
-			if (old[nr_probes] == probe)
+		for (nr_probes = 0; old[nr_probes].func; nr_probes++)
+			if (old[nr_probes].func == probe &&
+			    old[nr_probes].data == data)
 				return ERR_PTR(-EEXIST);
 	}
 	/* + 2 : one for new probe, one for NULL func */
@@ -127,36 +130,40 @@ tracepoint_entry_add_probe(struct tracepoint_entry *entry, void *probe)
 	if (new == NULL)
 		return ERR_PTR(-ENOMEM);
 	if (old)
-		memcpy(new, old, nr_probes * sizeof(void *));
-	new[nr_probes] = probe;
-	new[nr_probes + 1] = NULL;
+		memcpy(new, old, nr_probes * sizeof(struct probe));
+	new[nr_probes].func = probe;
+	new[nr_probes].data = data;
+	new[nr_probes + 1].func = NULL;
 	entry->refcount = nr_probes + 1;
-	entry->funcs = new;
+	entry->probes = new;
 	debug_print_probes(entry);
 	return old;
 }
 
 static void *
-tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe)
+tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe,
+			      void *data)
 {
 	int nr_probes = 0, nr_del = 0, i;
-	void **old, **new;
+	struct probe *old, *new;
 
-	old = entry->funcs;
+	old = entry->probes;
 
 	if (!old)
 		return ERR_PTR(-ENOENT);
 
 	debug_print_probes(entry);
 	/* (N -> M), (N > 1, M >= 0) probes */
-	for (nr_probes = 0; old[nr_probes]; nr_probes++) {
-		if ((!probe || old[nr_probes] == probe))
+	for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
+		if (!probe ||
+		     (old[nr_probes].func == probe &&
+		     old[nr_probes].data == data))
 			nr_del++;
 	}
 
 	if (nr_probes - nr_del == 0) {
 		/* N -> 0, (N > 1) */
-		entry->funcs = NULL;
+		entry->probes = NULL;
 		entry->refcount = 0;
 		debug_print_probes(entry);
 		return old;
@@ -167,12 +174,13 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe)
 		new = allocate_probes(nr_probes - nr_del + 1);
 		if (new == NULL)
 			return ERR_PTR(-ENOMEM);
-		for (i = 0; old[i]; i++)
-			if ((probe && old[i] != probe))
+		for (i = 0; old[i].func; i++)
+			if (probe &&
+			    (old[i].func != probe || old[i].data != data))
 				new[j++] = old[i];
-		new[nr_probes - nr_del] = NULL;
+		new[nr_probes - nr_del].func = NULL;
 		entry->refcount = nr_probes - nr_del;
-		entry->funcs = new;
+		entry->probes = new;
 	}
 	debug_print_probes(entry);
 	return old;
@@ -185,13 +193,13 @@ tracepoint_entry_remove_probe(struct tracepoint_entry *entry, void *probe)
  */
 static struct tracepoint_entry *get_tracepoint(const char *name)
 {
-	struct hlist_head *head;
-	struct hlist_node *node;
+	struct cds_hlist_head *head;
+	struct cds_hlist_node *node;
 	struct tracepoint_entry *e;
 	u32 hash = jhash(name, strlen(name), 0);
 
 	head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
-	hlist_for_each_entry(e, node, head, hlist) {
+	cds_hlist_for_each_entry(e, node, head, hlist) {
 		if (!strcmp(name, e->name))
 			return e;
 	}
@@ -204,30 +212,30 @@ static struct tracepoint_entry *get_tracepoint(const char *name)
  */
 static struct tracepoint_entry *add_tracepoint(const char *name)
 {
-	struct hlist_head *head;
-	struct hlist_node *node;
+	struct cds_hlist_head *head;
+	struct cds_hlist_node *node;
 	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, node, head, hlist) {
+	cds_hlist_for_each_entry(e, node, head, hlist) {
 		if (!strcmp(name, e->name)) {
 			DBG("tracepoint %s busy", name);
 			return ERR_PTR(-EEXIST);	/* Already there */
 		}
 	}
 	/*
-	 * Using kmalloc here to allocate a variable length element. Could
+	 * Using zmalloc here to allocate a variable length element. Could
 	 * cause some memory fragmentation if overused.
 	 */
-	e = malloc(sizeof(struct tracepoint_entry) + name_len);
+	e = zmalloc(sizeof(struct tracepoint_entry) + name_len);
 	if (!e)
 		return ERR_PTR(-ENOMEM);
 	memcpy(&e->name[0], name, name_len);
-	e->funcs = NULL;
+	e->probes = NULL;
 	e->refcount = 0;
-	hlist_add_head(&e->hlist, head);
+	cds_hlist_add_head(&e->hlist, head);
 	return e;
 }
 
@@ -237,7 +245,7 @@ static struct tracepoint_entry *add_tracepoint(const char *name)
  */
 static inline void remove_tracepoint(struct tracepoint_entry *e)
 {
-	hlist_del(&e->hlist);
+	cds_hlist_del(&e->hlist);
 	free(e);
 }
 
@@ -250,13 +258,13 @@ static void set_tracepoint(struct tracepoint_entry **entry,
 	WARN_ON(strcmp((*entry)->name, elem->name) != 0);
 
 	/*
-	 * rcu_assign_pointer has a smp_wmb() which makes sure that the new
+	 * rcu_assign_pointer has a cmm_smp_wmb() which makes sure that the new
 	 * probe callbacks array is consistent before setting a pointer to it.
 	 * This array is referenced by __DO_TRACE from
-	 * include/linux/tracepoints.h. A matching smp_read_barrier_depends()
+	 * include/linux/tracepoints.h. A matching cmm_smp_read_barrier_depends()
 	 * is used.
 	 */
-	rcu_assign_pointer(elem->funcs, (*entry)->funcs);
+	rcu_assign_pointer(elem->probes, (*entry)->probes);
 	elem->state__imv = active;
 }
 
@@ -269,7 +277,7 @@ static void set_tracepoint(struct tracepoint_entry **entry,
 static void disable_tracepoint(struct tracepoint *elem)
 {
 	elem->state__imv = 0;
-	rcu_assign_pointer(elem->funcs, NULL);
+	rcu_assign_pointer(elem->probes, NULL);
 }
 
 /**
@@ -279,34 +287,38 @@ static void disable_tracepoint(struct tracepoint *elem)
  *
  * Updates the probe callback corresponding to a range of tracepoints.
  */
-void tracepoint_update_probe_range(struct tracepoint *begin,
-	struct tracepoint *end)
+void tracepoint_update_probe_range(struct tracepoint * const *begin,
+				   struct tracepoint * const *end)
 {
-	struct tracepoint *iter;
+	struct tracepoint * const *iter;
 	struct tracepoint_entry *mark_entry;
 
-	mutex_lock(&tracepoints_mutex);
+	pthread_mutex_lock(&tracepoints_mutex);
 	for (iter = begin; iter < end; iter++) {
-		mark_entry = get_tracepoint(iter->name);
+		if (!(*iter)->name) {
+			disable_tracepoint(*iter);
+			continue;
+		}
+		mark_entry = get_tracepoint((*iter)->name);
 		if (mark_entry) {
-			set_tracepoint(&mark_entry, iter,
+			set_tracepoint(&mark_entry, *iter,
 					!!mark_entry->refcount);
 		} else {
-			disable_tracepoint(iter);
+			disable_tracepoint(*iter);
 		}
 	}
-	mutex_unlock(&tracepoints_mutex);
+	pthread_mutex_unlock(&tracepoints_mutex);
 }
 
 static void lib_update_tracepoints(void)
 {
 	struct tracepoint_lib *lib;
 
-//ust//	mutex_lock(&module_mutex);
-	list_for_each_entry(lib, &libs, list)
+//ust//	pthread_mutex_lock(&module_mutex);
+	cds_list_for_each_entry(lib, &libs, list)
 		tracepoint_update_probe_range(lib->tracepoints_start,
 				lib->tracepoints_start + lib->tracepoints_count);
-//ust//	mutex_unlock(&module_mutex);
+//ust//	pthread_mutex_unlock(&module_mutex);
 }
 
 /*
@@ -324,18 +336,19 @@ static void tracepoint_update_probes(void)
 //ust//	module_imv_update();
 }
 
-static void *tracepoint_add_probe(const char *name, void *probe)
+static struct probe *
+tracepoint_add_probe(const char *name, void *probe, void *data)
 {
 	struct tracepoint_entry *entry;
-	void *old;
+	struct probe *old;
 
 	entry = get_tracepoint(name);
 	if (!entry) {
 		entry = add_tracepoint(name);
 		if (IS_ERR(entry))
-			return entry;
+			return (struct probe *)entry;
 	}
-	old = tracepoint_entry_add_probe(entry, probe);
+	old = tracepoint_entry_add_probe(entry, probe, data);
 	if (IS_ERR(old) && !entry->refcount)
 		remove_tracepoint(entry);
 	return old;
@@ -349,13 +362,13 @@ static void *tracepoint_add_probe(const char *name, void *probe)
  * Returns 0 if ok, error value on error.
  * The probe address must at least be aligned on the architecture pointer size.
  */
-int tracepoint_probe_register(const char *name, void *probe)
+int tracepoint_probe_register(const char *name, void *probe, void *data)
 {
 	void *old;
 
-	mutex_lock(&tracepoints_mutex);
-	old = tracepoint_add_probe(name, probe);
-	mutex_unlock(&tracepoints_mutex);
+	pthread_mutex_lock(&tracepoints_mutex);
+	old = tracepoint_add_probe(name, probe, data);
+	pthread_mutex_unlock(&tracepoints_mutex);
 	if (IS_ERR(old))
 		return PTR_ERR(old);
 
@@ -365,7 +378,7 @@ int tracepoint_probe_register(const char *name, void *probe)
 }
 //ust// EXPORT_SYMBOL_GPL(tracepoint_probe_register);
 
-static void *tracepoint_remove_probe(const char *name, void *probe)
+static void *tracepoint_remove_probe(const char *name, void *probe, void *data)
 {
 	struct tracepoint_entry *entry;
 	void *old;
@@ -373,7 +386,7 @@ static void *tracepoint_remove_probe(const char *name, void *probe)
 	entry = get_tracepoint(name);
 	if (!entry)
 		return ERR_PTR(-ENOENT);
-	old = tracepoint_entry_remove_probe(entry, probe);
+	old = tracepoint_entry_remove_probe(entry, probe, data);
 	if (IS_ERR(old))
 		return old;
 	if (!entry->refcount)
@@ -385,19 +398,20 @@ static void *tracepoint_remove_probe(const char *name, void *probe)
  * tracepoint_probe_unregister -  Disconnect a probe from a tracepoint
  * @name: tracepoint name
  * @probe: probe function pointer
+ * @probe: probe data pointer
  *
  * 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.
  */
-int tracepoint_probe_unregister(const char *name, void *probe)
+int tracepoint_probe_unregister(const char *name, void *probe, void *data)
 {
 	void *old;
 
-	mutex_lock(&tracepoints_mutex);
-	old = tracepoint_remove_probe(name, probe);
-	mutex_unlock(&tracepoints_mutex);
+	pthread_mutex_lock(&tracepoints_mutex);
+	old = tracepoint_remove_probe(name, probe, data);
+	pthread_mutex_unlock(&tracepoints_mutex);
 	if (IS_ERR(old))
 		return PTR_ERR(old);
 
@@ -407,16 +421,16 @@ int tracepoint_probe_unregister(const char *name, void *probe)
 }
 //ust// EXPORT_SYMBOL_GPL(tracepoint_probe_unregister);
 
-static LIST_HEAD(old_probes);
+static CDS_LIST_HEAD(old_probes);
 static int need_update;
 
 static void tracepoint_add_old_probes(void *old)
 {
 	need_update = 1;
 	if (old) {
-		struct tp_probes *tp_probes = container_of(old,
+		struct tp_probes *tp_probes = _ust_container_of(old,
 			struct tp_probes, probes[0]);
-		list_add(&tp_probes->u.list, &old_probes);
+		cds_list_add(&tp_probes->u.list, &old_probes);
 	}
 }
 
@@ -427,18 +441,19 @@ static void tracepoint_add_old_probes(void *old)
  *
  * caller must call tracepoint_probe_update_all()
  */
-int tracepoint_probe_register_noupdate(const char *name, void *probe)
+int tracepoint_probe_register_noupdate(const char *name, void *probe,
+				       void *data)
 {
 	void *old;
 
-	mutex_lock(&tracepoints_mutex);
-	old = tracepoint_add_probe(name, probe);
+	pthread_mutex_lock(&tracepoints_mutex);
+	old = tracepoint_add_probe(name, probe, data);
 	if (IS_ERR(old)) {
-		mutex_unlock(&tracepoints_mutex);
+		pthread_mutex_unlock(&tracepoints_mutex);
 		return PTR_ERR(old);
 	}
 	tracepoint_add_old_probes(old);
-	mutex_unlock(&tracepoints_mutex);
+	pthread_mutex_unlock(&tracepoints_mutex);
 	return 0;
 }
 //ust// EXPORT_SYMBOL_GPL(tracepoint_probe_register_noupdate);
@@ -450,18 +465,19 @@ int tracepoint_probe_register_noupdate(const char *name, void *probe)
  *
  * caller must call tracepoint_probe_update_all()
  */
-int tracepoint_probe_unregister_noupdate(const char *name, void *probe)
+int tracepoint_probe_unregister_noupdate(const char *name, void *probe,
+					 void *data)
 {
 	void *old;
 
-	mutex_lock(&tracepoints_mutex);
-	old = tracepoint_remove_probe(name, probe);
+	pthread_mutex_lock(&tracepoints_mutex);
+	old = tracepoint_remove_probe(name, probe, data);
 	if (IS_ERR(old)) {
-		mutex_unlock(&tracepoints_mutex);
+		pthread_mutex_unlock(&tracepoints_mutex);
 		return PTR_ERR(old);
 	}
 	tracepoint_add_old_probes(old);
-	mutex_unlock(&tracepoints_mutex);
+	pthread_mutex_unlock(&tracepoints_mutex);
 	return 0;
 }
 //ust// EXPORT_SYMBOL_GPL(tracepoint_probe_unregister_noupdate);
@@ -471,22 +487,22 @@ int tracepoint_probe_unregister_noupdate(const char *name, void *probe)
  */
 void tracepoint_probe_update_all(void)
 {
-	LIST_HEAD(release_probes);
+	CDS_LIST_HEAD(release_probes);
 	struct tp_probes *pos, *next;
 
-	mutex_lock(&tracepoints_mutex);
+	pthread_mutex_lock(&tracepoints_mutex);
 	if (!need_update) {
-		mutex_unlock(&tracepoints_mutex);
+		pthread_mutex_unlock(&tracepoints_mutex);
 		return;
 	}
-	if (!list_empty(&old_probes))
-		list_replace_init(&old_probes, &release_probes);
+	if (!cds_list_empty(&old_probes))
+		cds_list_replace_init(&old_probes, &release_probes);
 	need_update = 0;
-	mutex_unlock(&tracepoints_mutex);
+	pthread_mutex_unlock(&tracepoints_mutex);
 
 	tracepoint_update_probes();
-	list_for_each_entry_safe(pos, next, &release_probes, u.list) {
-		list_del(&pos->u.list);
+	cds_list_for_each_entry_safe(pos, next, &release_probes, u.list) {
+		cds_list_del(&pos->u.list);
 //ust//		call_rcu_sched(&pos->u.rcu, rcu_free_old_probes);
 		synchronize_rcu();
 		free(pos);
@@ -503,8 +519,8 @@ int lib_get_iter_tracepoints(struct tracepoint_iter *iter)
 	struct tracepoint_lib *iter_lib;
 	int found = 0;
 
-//ust//	mutex_lock(&module_mutex);
-	list_for_each_entry(iter_lib, &libs, list) {
+//ust//	pthread_mutex_lock(&module_mutex);
+	cds_list_for_each_entry(iter_lib, &libs, list) {
 		if (iter_lib < iter->lib)
 			continue;
 		else if (iter_lib > iter->lib)
@@ -517,7 +533,7 @@ int lib_get_iter_tracepoints(struct tracepoint_iter *iter)
 			break;
 		}
 	}
-//ust//	mutex_unlock(&module_mutex);
+//ust//	pthread_mutex_unlock(&module_mutex);
 	return found;
 }
 
@@ -531,8 +547,8 @@ int lib_get_iter_tracepoints(struct tracepoint_iter *iter)
  * Will return the first tracepoint in the range if the input tracepoint is
  * NULL.
  */
-int tracepoint_get_iter_range(struct tracepoint **tracepoint,
-	struct tracepoint *begin, struct tracepoint *end)
+int tracepoint_get_iter_range(struct tracepoint * const **tracepoint,
+	struct tracepoint * const *begin, struct tracepoint * const *end)
 {
 	if (!*tracepoint && begin != end) {
 		*tracepoint = begin;
@@ -632,29 +648,29 @@ void tracepoint_set_new_tracepoint_cb(void (*cb)(struct tracepoint *))
 	new_tracepoint_cb = cb;
 }
 
-static void new_tracepoints(struct tracepoint *start, struct tracepoint *end)
+static void new_tracepoints(struct tracepoint * const *start, struct tracepoint * const *end)
 {
-	if(new_tracepoint_cb) {
-		struct tracepoint *t;
+	if (new_tracepoint_cb) {
+		struct tracepoint * const *t;
 		for(t=start; t < end; t++) {
-			new_tracepoint_cb(t);
+			new_tracepoint_cb(*t);
 		}
 	}
 }
 
-int tracepoint_register_lib(struct tracepoint *tracepoints_start, int tracepoints_count)
+int tracepoint_register_lib(struct tracepoint * const *tracepoints_start, int tracepoints_count)
 {
 	struct tracepoint_lib *pl;
 
-	pl = (struct tracepoint_lib *) malloc(sizeof(struct tracepoint_lib));
+	pl = (struct tracepoint_lib *) zmalloc(sizeof(struct tracepoint_lib));
 
 	pl->tracepoints_start = tracepoints_start;
 	pl->tracepoints_count = tracepoints_count;
 
 	/* FIXME: maybe protect this with its own mutex? */
-	mutex_lock(&tracepoints_mutex);
-	list_add(&pl->list, &libs);
-	mutex_unlock(&tracepoints_mutex);
+	pthread_mutex_lock(&tracepoints_mutex);
+	cds_list_add(&pl->list, &libs);
+	pthread_mutex_unlock(&tracepoints_mutex);
 
 	new_tracepoints(tracepoints_start, tracepoints_start + tracepoints_count);
 
@@ -662,26 +678,26 @@ int tracepoint_register_lib(struct tracepoint *tracepoints_start, int tracepoint
 	lib_update_tracepoints();
 
 	DBG("just registered a tracepoints section from %p and having %d tracepoints", tracepoints_start, tracepoints_count);
-	
+
 	return 0;
 }
 
-int tracepoint_unregister_lib(struct tracepoint *tracepoints_start)
+int tracepoint_unregister_lib(struct tracepoint * const *tracepoints_start)
 {
 	struct tracepoint_lib *lib;
 
-	mutex_lock(&tracepoints_mutex);
+	pthread_mutex_lock(&tracepoints_mutex);
 
-	list_for_each_entry(lib, &libs, list) {
-		if(lib->tracepoints_start == tracepoints_start) {
+	cds_list_for_each_entry(lib, &libs, list) {
+		if (lib->tracepoints_start == tracepoints_start) {
 			struct tracepoint_lib *lib2free = lib;
-			list_del(&lib->list);
+			cds_list_del(&lib->list);
 			free(lib2free);
 			break;
 		}
 	}
 
-	mutex_unlock(&tracepoints_mutex);
+	pthread_mutex_unlock(&tracepoints_mutex);
 
 	return 0;
 }