X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=libust%2Ftracepoint.c;h=16b4819b88e686f01a6f3ad08a6de3cecf783f0c;hb=c66428ac9ee17d0724baf4430e29887aeed5f259;hp=d6b09737a8cd052096e31465ea90573753db8d7e;hpb=34e4b7db790ca5ff678eae7cf5658455a8991870;p=ust.git

diff --git a/libust/tracepoint.c b/libust/tracepoint.c
index d6b0973..16b4819 100644
--- a/libust/tracepoint.c
+++ b/libust/tracepoint.c
@@ -19,26 +19,14 @@
  * Ported to userspace by Pierre-Marc Fournier.
  */
 
-//ust// #include <linux/module.h>
-//ust// #include <linux/mutex.h>
-//ust// #include <linux/types.h>
-//ust// #include <linux/jhash.h>
-//ust// #include <linux/list.h>
-//ust// #include <linux/rcupdate.h>
-//ust// #include <linux/tracepoint.h>
-//ust// #include <linux/err.h>
-//ust// #include <linux/slab.h>
-//ust// #include <linux/immediate.h>
-
 #include <errno.h>
-
-#include "kernelcompat.h"
-#include "tracepoint.h"
+#include <ust/tracepoint.h>
+#include <ust/core.h>
+#include <ust/kcompat/kcompat.h>
 #include "usterr.h"
-//#include "list.h"
 
 #define _LGPL_SOURCE
-#include <urcu.h>
+#include <urcu-bp.h>
 
 //extern struct tracepoint __start___tracepoints[] __attribute__((visibility("hidden")));
 //extern struct tracepoint __stop___tracepoints[] __attribute__((visibility("hidden")));
@@ -71,7 +59,7 @@ static struct hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE];
  */
 struct tracepoint_entry {
 	struct hlist_node hlist;
-	void **funcs;
+	struct probe *probes;
 	int refcount;	/* Number of times armed. 0 if disarmed. */
 	char name[0];
 };
@@ -81,13 +69,13 @@ struct tp_probes {
 //ust//		struct rcu_head rcu;
 		struct list_head list;
 	} u;
-	void *probes[0];
+	struct probe probes[0];
 };
 
 static inline void *allocate_probes(int count)
 {
-	struct tp_probes *p  = kmalloc(count * sizeof(void *)
-			+ sizeof(struct tp_probes), GFP_KERNEL);
+	struct tp_probes *p  = zmalloc(count * sizeof(void *)
+			+ sizeof(struct tp_probes));
 	return p == NULL ? NULL : p->probes;
 }
 
@@ -103,7 +91,7 @@ static inline void release_probes(void *old)
 			struct tp_probes, probes[0]);
 //ust//		call_rcu_sched(&tp_probes->u.rcu, rcu_free_old_probes);
 		synchronize_rcu();
-		kfree(tp_probes);
+		free(tp_probes);
 	}
 }
 
@@ -111,27 +99,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++)
-		printk(KERN_DEBUG "Probe %d : %p\n", 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 */
@@ -139,36 +129,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;
@@ -179,12 +173,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;
@@ -225,20 +220,19 @@ static struct tracepoint_entry *add_tracepoint(const char *name)
 	head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)];
 	hlist_for_each_entry(e, node, head, hlist) {
 		if (!strcmp(name, e->name)) {
-			printk(KERN_NOTICE
-				"tracepoint %s busy\n", 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 = kmalloc(sizeof(struct tracepoint_entry) + name_len, GFP_KERNEL);
+	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);
 	return e;
@@ -251,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);
-	kfree(e);
+	free(e);
 }
 
 /*
@@ -269,7 +263,7 @@ 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);
+	rcu_assign_pointer(elem->probes, (*entry)->probes);
 	elem->state__imv = active;
 }
 
@@ -282,7 +276,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);
 }
 
 /**
@@ -293,13 +287,17 @@ 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)
+				   struct tracepoint *end)
 {
 	struct tracepoint *iter;
 	struct tracepoint_entry *mark_entry;
 
-	mutex_lock(&tracepoints_mutex);
+	pthread_mutex_lock(&tracepoints_mutex);
 	for (iter = begin; iter < end; iter++) {
+		if (!iter->name) {
+			disable_tracepoint(iter);
+			continue;
+		}
 		mark_entry = get_tracepoint(iter->name);
 		if (mark_entry) {
 			set_tracepoint(&mark_entry, iter,
@@ -308,7 +306,18 @@ void tracepoint_update_probe_range(struct tracepoint *begin,
 			disable_tracepoint(iter);
 		}
 	}
-	mutex_unlock(&tracepoints_mutex);
+	pthread_mutex_unlock(&tracepoints_mutex);
+}
+
+static void lib_update_tracepoints(void)
+{
+	struct tracepoint_lib *lib;
+
+//ust//	pthread_mutex_lock(&module_mutex);
+	list_for_each_entry(lib, &libs, list)
+		tracepoint_update_probe_range(lib->tracepoints_start,
+				lib->tracepoints_start + lib->tracepoints_count);
+//ust//	pthread_mutex_unlock(&module_mutex);
 }
 
 /*
@@ -326,18 +335,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;
@@ -351,13 +361,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);
 
@@ -367,7 +377,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;
@@ -375,7 +385,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)
@@ -387,19 +397,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);
 
@@ -429,18 +440,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);
@@ -452,18 +464,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);
@@ -476,26 +489,53 @@ void tracepoint_probe_update_all(void)
 	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);
 	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);
 //ust//		call_rcu_sched(&pos->u.rcu, rcu_free_old_probes);
 		synchronize_rcu();
-		kfree(pos);
+		free(pos);
 	}
 }
 //ust// EXPORT_SYMBOL_GPL(tracepoint_probe_update_all);
 
+/*
+ * Returns 0 if current not found.
+ * Returns 1 if current found.
+ */
+int lib_get_iter_tracepoints(struct tracepoint_iter *iter)
+{
+	struct tracepoint_lib *iter_lib;
+	int found = 0;
+
+//ust//	pthread_mutex_lock(&module_mutex);
+	list_for_each_entry(iter_lib, &libs, list) {
+		if (iter_lib < iter->lib)
+			continue;
+		else if (iter_lib > iter->lib)
+			iter->tracepoint = NULL;
+		found = tracepoint_get_iter_range(&iter->tracepoint,
+			iter_lib->tracepoints_start,
+			iter_lib->tracepoints_start + iter_lib->tracepoints_count);
+		if (found) {
+			iter->lib = iter_lib;
+			break;
+		}
+	}
+//ust//	pthread_mutex_unlock(&module_mutex);
+	return found;
+}
+
 /**
  * tracepoint_get_iter_range - Get a next tracepoint iterator given a range.
  * @tracepoint: current tracepoints (in), next tracepoint (out)
@@ -532,7 +572,7 @@ static void tracepoint_get_iter(struct tracepoint_iter *iter)
 //ust//	}
 	/* tracepoints in libs. */
 	found = lib_get_iter_tracepoints(iter);
-end:
+//ust// end:
 	if (!found)
 		tracepoint_iter_reset(iter);
 }
@@ -600,44 +640,6 @@ void tracepoint_iter_reset(struct tracepoint_iter *iter)
 
 //ust// #endif /* CONFIG_MODULES */
 
-/*
- * Returns 0 if current not found.
- * Returns 1 if current found.
- */
-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) {
-		if (iter_lib < iter->lib)
-			continue;
-		else if (iter_lib > iter->lib)
-			iter->tracepoint = NULL;
-		found = marker_get_iter_range(&iter->tracepoint,
-			iter_lib->tracepoints_start,
-			iter_lib->tracepoints_start + iter_lib->tracepoints_count);
-		if (found) {
-			iter->lib = iter_lib;
-			break;
-		}
-	}
-//ust//	mutex_unlock(&module_mutex);
-	return found;
-}
-
-void lib_update_tracepoints(void)
-{
-	struct tracepoint_lib *lib;
-
-//ust//	mutex_lock(&module_mutex);
-	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);
-}
-
 static void (*new_tracepoint_cb)(struct tracepoint *) = NULL;
 
 void tracepoint_set_new_tracepoint_cb(void (*cb)(struct tracepoint *))
@@ -659,15 +661,15 @@ int tracepoint_register_lib(struct tracepoint *tracepoints_start, int tracepoint
 {
 	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);
+	pthread_mutex_lock(&tracepoints_mutex);
 	list_add(&pl->list, &libs);
-	mutex_unlock(&tracepoints_mutex);
+	pthread_mutex_unlock(&tracepoints_mutex);
 
 	new_tracepoints(tracepoints_start, tracepoints_start + tracepoints_count);
 
@@ -675,14 +677,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 tracepoints_count)
+int tracepoint_unregister_lib(struct tracepoint *tracepoints_start)
 {
-	/*FIXME: implement; but before implementing, tracepoint_register_lib must
-          have appropriate locking. */
+	struct tracepoint_lib *lib;
+
+	pthread_mutex_lock(&tracepoints_mutex);
+
+	list_for_each_entry(lib, &libs, list) {
+		if(lib->tracepoints_start == tracepoints_start) {
+			struct tracepoint_lib *lib2free = lib;
+			list_del(&lib->list);
+			free(lib2free);
+			break;
+		}
+	}
+
+	pthread_mutex_unlock(&tracepoints_mutex);
 
 	return 0;
 }