X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=libust%2Ftracepoint.c;h=6155e2900e43ff6d6c3b40220aae18f4fea3cbae;hb=6a843332a8ac7d1125e0961f148cc494e0397923;hp=ee335adfbf20e827c326574fc02d1b99e5ec1661;hpb=772030fed323e388da467735cf4b5e8781acb710;p=ust.git diff --git a/libust/tracepoint.c b/libust/tracepoint.c index ee335ad..6155e29 100644 --- a/libust/tracepoint.c +++ b/libust/tracepoint.c @@ -19,26 +19,14 @@ * 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 "kernelcompat.h" -#include "tracepoint.h" +#include +#include +#include #include "usterr.h" -//#include "list.h" #define _LGPL_SOURCE -#include +#include //extern struct tracepoint __start___tracepoints[] __attribute__((visibility("hidden"))); //extern struct tracepoint __stop___tracepoints[] __attribute__((visibility("hidden"))); @@ -86,8 +74,8 @@ struct tp_probes { 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 = malloc(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); } } @@ -115,7 +103,7 @@ static void debug_print_probes(struct tracepoint_entry *entry) return; for (i = 0; entry->funcs[i]; i++) - printk(KERN_DEBUG "Probe %d : %p\n", i, entry->funcs[i]); + DBG("Probe %d : %p", i, entry->funcs[i]); } static void * @@ -225,8 +213,7 @@ 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 */ } } @@ -234,7 +221,7 @@ static struct tracepoint_entry *add_tracepoint(const char *name) * 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); + e = malloc(sizeof(struct tracepoint_entry) + name_len); if (!e) return ERR_PTR(-ENOMEM); memcpy(&e->name[0], name, name_len); @@ -251,7 +238,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); } /* @@ -298,7 +285,7 @@ void tracepoint_update_probe_range(struct tracepoint *begin, struct tracepoint *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 (mark_entry) { @@ -308,18 +295,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); } /* @@ -366,9 +353,9 @@ int tracepoint_probe_register(const char *name, void *probe) { void *old; - mutex_lock(&tracepoints_mutex); + pthread_mutex_lock(&tracepoints_mutex); old = tracepoint_add_probe(name, probe); - mutex_unlock(&tracepoints_mutex); + pthread_mutex_unlock(&tracepoints_mutex); if (IS_ERR(old)) return PTR_ERR(old); @@ -408,9 +395,9 @@ int tracepoint_probe_unregister(const char *name, void *probe) { void *old; - mutex_lock(&tracepoints_mutex); + pthread_mutex_lock(&tracepoints_mutex); old = tracepoint_remove_probe(name, probe); - mutex_unlock(&tracepoints_mutex); + pthread_mutex_unlock(&tracepoints_mutex); if (IS_ERR(old)) return PTR_ERR(old); @@ -444,14 +431,14 @@ int tracepoint_probe_register_noupdate(const char *name, void *probe) { void *old; - mutex_lock(&tracepoints_mutex); + pthread_mutex_lock(&tracepoints_mutex); old = tracepoint_add_probe(name, probe); 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); @@ -467,14 +454,14 @@ int tracepoint_probe_unregister_noupdate(const char *name, void *probe) { void *old; - mutex_lock(&tracepoints_mutex); + pthread_mutex_lock(&tracepoints_mutex); old = tracepoint_remove_probe(name, probe); 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 +474,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 +503,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 +517,7 @@ int lib_get_iter_tracepoints(struct tracepoint_iter *iter) break; } } -//ust// mutex_unlock(&module_mutex); +//ust// pthread_mutex_unlock(&module_mutex); return found; } @@ -665,9 +652,9 @@ int tracepoint_register_lib(struct tracepoint *tracepoints_start, int tracepoint 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); @@ -679,10 +666,22 @@ int tracepoint_register_lib(struct tracepoint *tracepoints_start, int tracepoint 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; }