X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=libust%2Ftracepoint.c;h=16b4819b88e686f01a6f3ad08a6de3cecf783f0c;hb=c66428ac9ee17d0724baf4430e29887aeed5f259;hp=cc2adf15e8e8c7ded54281be445528ac4086dcc0;hpb=fbca6b624335eef18c8d86194aeb101a720168f4;p=ust.git diff --git a/libust/tracepoint.c b/libust/tracepoint.c index cc2adf1..16b4819 100644 --- a/libust/tracepoint.c +++ b/libust/tracepoint.c @@ -19,23 +19,11 @@ * Ported to userspace by Pierre-Marc Fournier. */ -//ust// #include -//ust// #include -//ust// #include -//ust// #include -//ust// #include -//ust// #include -//ust// #include -//ust// #include -//ust// #include -//ust// #include - #include - -#include #include +#include +#include #include "usterr.h" -//#include "list.h" #define _LGPL_SOURCE #include @@ -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,18 +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// mutex_lock(&module_mutex); +//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// mutex_unlock(&module_mutex); +//ust// pthread_mutex_unlock(&module_mutex); } /* @@ -337,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; @@ -362,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); @@ -378,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; @@ -386,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) @@ -398,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); @@ -440,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); @@ -463,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); @@ -487,22 +489,22 @@ 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); @@ -516,7 +518,7 @@ int lib_get_iter_tracepoints(struct tracepoint_iter *iter) struct tracepoint_lib *iter_lib; int found = 0; -//ust// mutex_lock(&module_mutex); +//ust// pthread_mutex_lock(&module_mutex); list_for_each_entry(iter_lib, &libs, list) { if (iter_lib < iter->lib) continue; @@ -530,7 +532,7 @@ int lib_get_iter_tracepoints(struct tracepoint_iter *iter) break; } } -//ust// mutex_unlock(&module_mutex); +//ust// pthread_mutex_unlock(&module_mutex); return found; } @@ -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; }