X-Git-Url: http://git.lttng.org/?p=ust.git;a=blobdiff_plain;f=libust%2Ftracepoint.c;h=3bc5795afc17ce2f811e69015ac338b62ecd5519;hp=9de21c884892b64b78365bef3718aa5c547fcf08;hb=HEAD;hpb=93d0f2eaff675059588e958e3de74a1bb7dd4028 diff --git a/libust/tracepoint.c b/libust/tracepoint.c index 9de21c8..3bc5795 100644 --- a/libust/tracepoint.c +++ b/libust/tracepoint.c @@ -1,11 +1,11 @@ /* - * Copyright (C) 2008 Mathieu Desnoyers + * Copyright (C) 2008-2011 Mathieu Desnoyers * Copyright (C) 2009 Pierre-Marc Fournier * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. + * License as published by the Free Software Foundation; + * version 2.1 of the License. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -19,41 +19,57 @@ * 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 - +#define _LGPL_SOURCE #include - -#include "kernelcompat.h" #include -#include "usterr.h" -//#include "list.h" - -#define _LGPL_SOURCE +#include +#include +#include #include +#include + +#include "usterr_signal_safe.h" -//extern struct tracepoint __start___tracepoints[] __attribute__((visibility("hidden"))); -//extern struct tracepoint __stop___tracepoints[] __attribute__((visibility("hidden"))); +extern struct tracepoint * const __start___tracepoints_ptrs[] + __attribute__((visibility("hidden"))); +extern struct tracepoint * const __stop___tracepoints_ptrs[] + __attribute__((visibility("hidden"))); + +static struct tracepoint * __tracepoint_ptr_dummy + __attribute__((used, section("__tracepoints_ptrs"))); /* Set to 1 to enable tracepoint debug output */ static const int tracepoint_debug; +static int initialized; +static void (*new_tracepoint_cb)(struct tracepoint *); /* libraries that contain tracepoints (struct tracepoint_lib) */ -static LIST_HEAD(libs); +static CDS_LIST_HEAD(libs); + +/* + * Allow nested mutex for mutex listing and nested enable. + */ +static __thread int nested_mutex; /* - * tracepoints_mutex nests inside module_mutex. Tracepoints mutex protects the - * builtin and module tracepoints and the hash table. + * Tracepoints mutex protects the library tracepoints, the hash table, + * and the library list. */ -static DEFINE_MUTEX(tracepoints_mutex); +static pthread_mutex_t tracepoints_mutex; + +static +void lock_tracepoints(void) +{ + if (!(nested_mutex++)) + pthread_mutex_lock(&tracepoints_mutex); +} + +static +void unlock_tracepoints(void) +{ + if (!(--nested_mutex)) + pthread_mutex_unlock(&tracepoints_mutex); +} /* * Tracepoint hash table, containing the active tracepoints. @@ -61,7 +77,10 @@ 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]; + +static CDS_LIST_HEAD(old_probes); +static int need_update; /* * Note about RCU : @@ -70,40 +89,33 @@ 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 tracepoint_probe *probes; int refcount; /* Number of times armed. 0 if disarmed. */ char name[0]; }; struct tp_probes { union { -//ust// struct rcu_head rcu; - struct list_head list; + struct cds_list_head list; } u; - void *probes[0]; + struct tracepoint_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(struct tracepoint_probe) + + sizeof(struct tp_probes)); return p == NULL ? NULL : p->probes; } -//ust// static void rcu_free_old_probes(struct rcu_head *head) -//ust// { -//ust// kfree(container_of(head, struct tp_probes, u.rcu)); -//ust// } - 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(); - kfree(tp_probes); + free(tp_probes); } } @@ -111,27 +123,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 tracepoint_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 +153,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 tracepoint_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 tracepoint_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 +197,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; @@ -197,13 +216,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; } @@ -216,31 +235,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)) { - 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); + cds_hlist_add_head(&e->hlist, head); return e; } @@ -250,8 +268,8 @@ static struct tracepoint_entry *add_tracepoint(const char *name) */ static inline void remove_tracepoint(struct tracepoint_entry *e) { - hlist_del(&e->hlist); - kfree(e); + cds_hlist_del(&e->hlist); + free(e); } /* @@ -263,14 +281,14 @@ 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); - elem->state__imv = active; + rcu_assign_pointer(elem->probes, (*entry)->probes); + elem->state = active; } /* @@ -281,8 +299,8 @@ 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); + elem->state = 0; + rcu_assign_pointer(elem->probes, NULL); } /** @@ -292,34 +310,40 @@ 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) +static +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); for (iter = begin; iter < end; iter++) { - mark_entry = get_tracepoint(iter->name); + if (!*iter) + continue; /* skip dummy */ + 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); } static void lib_update_tracepoints(void) { struct tracepoint_lib *lib; -//ust// mutex_lock(&module_mutex); - list_for_each_entry(lib, &libs, list) + lock_tracepoints(); + 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); + } + unlock_tracepoints(); } /* @@ -327,48 +351,43 @@ static void lib_update_tracepoints(void) */ static void tracepoint_update_probes(void) { - /* Core kernel tracepoints */ -//ust// tracepoint_update_probe_range(__start___tracepoints, -//ust// __stop___tracepoints); - /* tracepoints in modules. */ + /* tracepoints registered from libraries and executable. */ lib_update_tracepoints(); - /* Update immediate values */ - core_imv_update(); -//ust// module_imv_update(); } -static void *tracepoint_add_probe(const char *name, void *probe) +static struct tracepoint_probe * +tracepoint_add_probe(const char *name, void *probe, void *data) { struct tracepoint_entry *entry; - void *old; + struct tracepoint_probe *old; entry = get_tracepoint(name); if (!entry) { entry = add_tracepoint(name); if (IS_ERR(entry)) - return entry; + return (struct tracepoint_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; } /** - * tracepoint_probe_register - Connect a probe to a tracepoint + * __tracepoint_probe_register - Connect a probe to a tracepoint * @name: tracepoint name * @probe: probe handler * * 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); + lock_tracepoints(); + old = tracepoint_add_probe(name, probe, data); + unlock_tracepoints(); if (IS_ERR(old)) return PTR_ERR(old); @@ -376,9 +395,8 @@ int tracepoint_probe_register(const char *name, void *probe) release_probes(old); return 0; } -//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 +404,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 +416,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); + lock_tracepoints(); + old = tracepoint_remove_probe(name, probe, data); + unlock_tracepoints(); if (IS_ERR(old)) return PTR_ERR(old); @@ -418,18 +437,14 @@ int tracepoint_probe_unregister(const char *name, void *probe) release_probes(old); return 0; } -//ust// EXPORT_SYMBOL_GPL(tracepoint_probe_unregister); - -static 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); } } @@ -440,21 +455,21 @@ 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); + lock_tracepoints(); + old = tracepoint_add_probe(name, probe, data); if (IS_ERR(old)) { - mutex_unlock(&tracepoints_mutex); + unlock_tracepoints(); return PTR_ERR(old); } tracepoint_add_old_probes(old); - mutex_unlock(&tracepoints_mutex); + unlock_tracepoints(); return 0; } -//ust// EXPORT_SYMBOL_GPL(tracepoint_probe_register_noupdate); /** * tracepoint_probe_unregister_noupdate - remove a probe but not disconnect @@ -463,61 +478,60 @@ 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); + lock_tracepoints(); + old = tracepoint_remove_probe(name, probe, data); if (IS_ERR(old)) { - mutex_unlock(&tracepoints_mutex); + unlock_tracepoints(); return PTR_ERR(old); } tracepoint_add_old_probes(old); - mutex_unlock(&tracepoints_mutex); + unlock_tracepoints(); return 0; } -//ust// EXPORT_SYMBOL_GPL(tracepoint_probe_unregister_noupdate); /** * tracepoint_probe_update_all - update tracepoints */ void tracepoint_probe_update_all(void) { - LIST_HEAD(release_probes); + CDS_LIST_HEAD(release_probes); struct tp_probes *pos, *next; - mutex_lock(&tracepoints_mutex); + lock_tracepoints(); if (!need_update) { - mutex_unlock(&tracepoints_mutex); + unlock_tracepoints(); 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); + unlock_tracepoints(); 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); + cds_list_for_each_entry_safe(pos, next, &release_probes, u.list) { + cds_list_del(&pos->u.list); 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. + * + * Called with tracepoint mutex held */ 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) { + cds_list_for_each_entry(iter_lib, &libs, list) { if (iter_lib < iter->lib) continue; else if (iter_lib > iter->lib) @@ -530,7 +544,6 @@ int lib_get_iter_tracepoints(struct tracepoint_iter *iter) break; } } -//ust// mutex_unlock(&module_mutex); return found; } @@ -543,44 +556,44 @@ int lib_get_iter_tracepoints(struct tracepoint_iter *iter) * Returns whether a next tracepoint has been found (1) or not (0). * Will return the first tracepoint in the range if the input tracepoint is * NULL. + * Called with tracepoint mutex held. */ -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) { + if (!*tracepoint && begin != end) *tracepoint = begin; - return 1; + while (*tracepoint >= begin && *tracepoint < end) { + if (!**tracepoint) + (*tracepoint)++; /* skip dummy */ + else + return 1; } - if (*tracepoint >= begin && *tracepoint < end) - return 1; return 0; } -//ust// EXPORT_SYMBOL_GPL(tracepoint_get_iter_range); +/* + * Called with tracepoint mutex held. + */ static void tracepoint_get_iter(struct tracepoint_iter *iter) { int found = 0; -//ust// /* Core kernel tracepoints */ -//ust// if (!iter->module) { -//ust// found = tracepoint_get_iter_range(&iter->tracepoint, -//ust// __start___tracepoints, __stop___tracepoints); -//ust// if (found) -//ust// goto end; -//ust// } /* tracepoints in libs. */ found = lib_get_iter_tracepoints(iter); -//ust// end: if (!found) tracepoint_iter_reset(iter); } void tracepoint_iter_start(struct tracepoint_iter *iter) { + lock_tracepoints(); tracepoint_get_iter(iter); } -//ust// EXPORT_SYMBOL_GPL(tracepoint_iter_start); +/* + * Called with tracepoint mutex held. + */ void tracepoint_iter_next(struct tracepoint_iter *iter) { iter->tracepoint++; @@ -591,98 +604,101 @@ void tracepoint_iter_next(struct tracepoint_iter *iter) */ tracepoint_get_iter(iter); } -//ust// EXPORT_SYMBOL_GPL(tracepoint_iter_next); void tracepoint_iter_stop(struct tracepoint_iter *iter) { + unlock_tracepoints(); } -//ust// EXPORT_SYMBOL_GPL(tracepoint_iter_stop); void tracepoint_iter_reset(struct tracepoint_iter *iter) { -//ust// iter->module = NULL; iter->tracepoint = NULL; } -//ust// EXPORT_SYMBOL_GPL(tracepoint_iter_reset); - -//ust// #ifdef CONFIG_MODULES - -//ust// int tracepoint_module_notify(struct notifier_block *self, -//ust// unsigned long val, void *data) -//ust// { -//ust// struct module *mod = data; -//ust// -//ust// switch (val) { -//ust// case MODULE_STATE_COMING: -//ust// tracepoint_update_probe_range(mod->tracepoints, -//ust// mod->tracepoints + mod->num_tracepoints); -//ust// break; -//ust// case MODULE_STATE_GOING: -//ust// tracepoint_update_probe_range(mod->tracepoints, -//ust// mod->tracepoints + mod->num_tracepoints); -//ust// break; -//ust// } -//ust// return 0; -//ust// } - -//ust// struct notifier_block tracepoint_module_nb = { -//ust// .notifier_call = tracepoint_module_notify, -//ust// .priority = 0, -//ust// }; - -//ust// static int init_tracepoints(void) -//ust// { -//ust// return register_module_notifier(&tracepoint_module_nb); -//ust// } -//ust// __initcall(init_tracepoints); - -//ust// #endif /* CONFIG_MODULES */ - -static void (*new_tracepoint_cb)(struct tracepoint *) = NULL; 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; - for(t=start; t < end; t++) { - new_tracepoint_cb(t); + if (new_tracepoint_cb) { + struct tracepoint * const *t; + + for (t = start; t < end; t++) { + if (*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; + struct tracepoint_lib *pl, *iter; - 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); + lock_tracepoints(); + /* + * We sort the libs by struct lib pointer address. + */ + cds_list_for_each_entry_reverse(iter, &libs, list) { + BUG_ON(iter == pl); /* Should never be in the list twice */ + if (iter < pl) { + /* We belong to the location right after iter. */ + cds_list_add(&pl->list, &iter->list); + goto lib_added; + } + } + /* We should be added at the head of the list */ + cds_list_add(&pl->list, &libs); +lib_added: + unlock_tracepoints(); new_tracepoints(tracepoints_start, tracepoints_start + tracepoints_count); - /* FIXME: update just the loaded lib */ + /* TODO: update just the loaded lib */ lib_update_tracepoints(); - DBG("just registered a tracepoints section from %p and having %d tracepoints", tracepoints_start, tracepoints_count); - + /* tracepoints_count - 1: skip dummy */ + DBG("just registered a tracepoints section from %p and having %d tracepoints (minus dummy tracepoints)", tracepoints_start, tracepoints_count); + return 0; } -int tracepoint_unregister_lib(struct tracepoint *tracepoints_start, int tracepoints_count) +int tracepoint_unregister_lib(struct tracepoint * const *tracepoints_start) { - /*FIXME: implement; but before implementing, tracepoint_register_lib must - have appropriate locking. */ + struct tracepoint_lib *lib; + + lock_tracepoints(); + cds_list_for_each_entry(lib, &libs, list) { + if (lib->tracepoints_start == tracepoints_start) { + struct tracepoint_lib *lib2free = lib; + cds_list_del(&lib->list); + free(lib2free); + break; + } + } + unlock_tracepoints(); return 0; } + +void __attribute__((constructor)) init_tracepoint(void) +{ + if (!initialized) { + tracepoint_register_lib(__start___tracepoints_ptrs, + __stop___tracepoints_ptrs + - __start___tracepoints_ptrs); + initialized = 1; + } +} + +void __attribute__((destructor)) destroy_tracepoint(void) +{ + tracepoint_unregister_lib(__start___tracepoints_ptrs); +}