#include <urcu/hlist.h>
#include <urcu/uatomic.h>
#include <urcu/compiler.h>
+#include <urcu/system.h>
#include <lttng/tracepoint.h>
#include <lttng/ust-abi.h> /* for LTTNG_UST_SYM_NAME_LEN */
struct cds_hlist_node hlist;
struct tracepoint_probe *probes;
int refcount; /* Number of times armed. 0 if disarmed. */
+ int callsite_refcount; /* how many libs use this tracepoint */
const char *signature;
char name[0];
};
struct tracepoint_probe probes[0];
};
+/*
+ * Callsite hash table, containing the tracepoint call sites.
+ * Protected by tracepoint mutex.
+ */
+#define CALLSITE_HASH_BITS 12
+#define CALLSITE_TABLE_SIZE (1 << CALLSITE_HASH_BITS)
+static struct cds_hlist_head callsite_table[CALLSITE_TABLE_SIZE];
+
+struct callsite_entry {
+ struct cds_hlist_node hlist; /* hash table node */
+ struct cds_list_head node; /* lib list of callsites node */
+ struct tracepoint *tp;
+};
+
+/* coverity[+alloc] */
static void *allocate_probes(int count)
{
struct tp_probes *p = zmalloc(count * sizeof(struct tracepoint_probe)
return p == NULL ? NULL : p->probes;
}
+/* coverity[+free : arg-0] */
static void release_probes(void *old)
{
if (old) {
debug_print_probes(entry);
/* (N -> M), (N > 1, M >= 0) probes */
- 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 (probe) {
+ for (nr_probes = 0; old[nr_probes].func; nr_probes++) {
+ if (old[nr_probes].func == probe &&
+ old[nr_probes].data == data)
+ nr_del++;
+ }
}
if (nr_probes - nr_del == 0) {
if (new == NULL)
return ERR_PTR(-ENOMEM);
for (i = 0; old[i].func; i++)
- if (probe &&
- (old[i].func != probe || old[i].data != data))
+ if (old[i].func != probe || old[i].data != data)
new[j++] = old[i];
new[nr_probes - nr_del].func = NULL;
entry->refcount = nr_probes - nr_del;
e->name[name_len] = '\0';
e->probes = NULL;
e->refcount = 0;
+ e->callsite_refcount = 0;
e->signature = signature;
cds_hlist_add_head(&e->hlist, head);
return e;
* is used.
*/
rcu_assign_pointer(elem->probes, (*entry)->probes);
- elem->state = active;
+ CMM_STORE_SHARED(elem->state, active);
}
/*
*/
static void disable_tracepoint(struct tracepoint *elem)
{
- elem->state = 0;
+ CMM_STORE_SHARED(elem->state, 0);
rcu_assign_pointer(elem->probes, NULL);
}
+/*
+ * Add the callsite to the callsite hash table. Must be called with
+ * tracepoint mutex held.
+ */
+static void add_callsite(struct tracepoint_lib * lib, struct tracepoint *tp)
+{
+ struct cds_hlist_head *head;
+ struct callsite_entry *e;
+ const char *name = tp->name;
+ size_t name_len = strlen(name);
+ uint32_t hash;
+ struct tracepoint_entry *tp_entry;
+
+ if (name_len > LTTNG_UST_SYM_NAME_LEN - 1) {
+ WARN("Truncating tracepoint name %s which exceeds size limits of %u chars", name, LTTNG_UST_SYM_NAME_LEN - 1);
+ name_len = LTTNG_UST_SYM_NAME_LEN - 1;
+ }
+ hash = jhash(name, name_len, 0);
+ head = &callsite_table[hash & (CALLSITE_TABLE_SIZE - 1)];
+ e = zmalloc(sizeof(struct callsite_entry));
+ if (!e) {
+ PERROR("Unable to add callsite for tracepoint \"%s\"", name);
+ return;
+ }
+ cds_hlist_add_head(&e->hlist, head);
+ e->tp = tp;
+ cds_list_add(&e->node, &lib->callsites);
+
+ tp_entry = get_tracepoint(name);
+ if (!tp_entry)
+ return;
+ tp_entry->callsite_refcount++;
+}
+
+/*
+ * Remove the callsite from the callsite hash table and from lib
+ * callsite list. Must be called with tracepoint mutex held.
+ */
+static void remove_callsite(struct callsite_entry *e)
+{
+ struct tracepoint_entry *tp_entry;
+
+ tp_entry = get_tracepoint(e->tp->name);
+ if (tp_entry) {
+ tp_entry->callsite_refcount--;
+ if (tp_entry->callsite_refcount == 0)
+ disable_tracepoint(e->tp);
+ }
+ cds_hlist_del(&e->hlist);
+ cds_list_del(&e->node);
+ free(e);
+}
+
+/*
+ * Enable/disable all callsites based on the state of a specific
+ * tracepoint entry.
+ * Must be called with tracepoint mutex held.
+ */
+static void tracepoint_sync_callsites(const char *name)
+{
+ struct cds_hlist_head *head;
+ struct cds_hlist_node *node;
+ struct callsite_entry *e;
+ size_t name_len = strlen(name);
+ uint32_t hash;
+ struct tracepoint_entry *tp_entry;
+
+ tp_entry = get_tracepoint(name);
+ if (name_len > LTTNG_UST_SYM_NAME_LEN - 1) {
+ WARN("Truncating tracepoint name %s which exceeds size limits of %u chars", name, LTTNG_UST_SYM_NAME_LEN - 1);
+ name_len = LTTNG_UST_SYM_NAME_LEN - 1;
+ }
+ hash = jhash(name, name_len, 0);
+ head = &callsite_table[hash & (CALLSITE_TABLE_SIZE - 1)];
+ cds_hlist_for_each_entry(e, node, head, hlist) {
+ struct tracepoint *tp = e->tp;
+
+ if (strncmp(name, tp->name, LTTNG_UST_SYM_NAME_LEN - 1))
+ continue;
+ if (tp_entry) {
+ set_tracepoint(&tp_entry, tp,
+ !!tp_entry->refcount);
+ } else {
+ disable_tracepoint(tp);
+ }
+ }
+}
+
/**
* tracepoint_update_probe_range - Update a probe range
* @begin: beginning of the range
}
}
-static void lib_update_tracepoints(void)
+static void lib_update_tracepoints(struct tracepoint_lib *lib)
{
- struct tracepoint_lib *lib;
+ tracepoint_update_probe_range(lib->tracepoints_start,
+ lib->tracepoints_start + lib->tracepoints_count);
+}
- cds_list_for_each_entry(lib, &libs, list) {
- tracepoint_update_probe_range(lib->tracepoints_start,
- lib->tracepoints_start + lib->tracepoints_count);
+static void lib_register_callsites(struct tracepoint_lib *lib)
+{
+ struct tracepoint * const *begin;
+ struct tracepoint * const *end;
+ struct tracepoint * const *iter;
+
+ begin = lib->tracepoints_start;
+ end = lib->tracepoints_start + lib->tracepoints_count;
+
+ for (iter = begin; iter < end; iter++) {
+ if (!*iter)
+ continue; /* skip dummy */
+ if (!(*iter)->name) {
+ continue;
+ }
+ add_callsite(lib, *iter);
}
}
+static void lib_unregister_callsites(struct tracepoint_lib *lib)
+{
+ struct callsite_entry *callsite, *tmp;
+
+ cds_list_for_each_entry_safe(callsite, tmp, &lib->callsites, node)
+ remove_callsite(callsite);
+}
+
/*
* Update probes, removing the faulty probes.
*/
static void tracepoint_update_probes(void)
{
+ struct tracepoint_lib *lib;
+
/* tracepoints registered from libraries and executable. */
- lib_update_tracepoints();
+ cds_list_for_each_entry(lib, &libs, list)
+ lib_update_tracepoints(lib);
}
static struct tracepoint_probe *
goto end;
}
- tracepoint_update_probes(); /* may update entry */
+ tracepoint_sync_callsites(name);
release_probes(old);
end:
pthread_mutex_unlock(&tracepoint_mutex);
ret = PTR_ERR(old);
goto end;
}
- tracepoint_update_probes(); /* may update entry */
+ tracepoint_sync_callsites(name);
release_probes(old);
end:
pthread_mutex_unlock(&tracepoint_mutex);
}
}
-static
-void lib_disable_tracepoints(struct tracepoint * const *begin,
- struct tracepoint * const *end)
-{
- struct tracepoint * const *iter;
-
- for (iter = begin; iter < end; iter++) {
- if (!*iter)
- continue; /* skip dummy */
- disable_tracepoint(*iter);
- }
-
-}
-
int tracepoint_register_lib(struct tracepoint * const *tracepoints_start,
int tracepoints_count)
{
init_tracepoint();
pl = (struct tracepoint_lib *) zmalloc(sizeof(struct tracepoint_lib));
-
+ if (!pl) {
+ PERROR("Unable to register tracepoint lib");
+ return -1;
+ }
pl->tracepoints_start = tracepoints_start;
pl->tracepoints_count = tracepoints_count;
+ CDS_INIT_LIST_HEAD(&pl->callsites);
pthread_mutex_lock(&tracepoint_mutex);
/*
cds_list_add(&pl->list, &libs);
lib_added:
new_tracepoints(tracepoints_start, tracepoints_start + tracepoints_count);
-
- /* TODO: update just the loaded lib */
- lib_update_tracepoints();
+ lib_register_callsites(pl);
+ lib_update_tracepoints(pl);
pthread_mutex_unlock(&tracepoint_mutex);
DBG("just registered a tracepoints section from %p and having %d tracepoints",
int tracepoint_unregister_lib(struct tracepoint * const *tracepoints_start)
{
struct tracepoint_lib *lib;
- int tracepoints_count;
pthread_mutex_lock(&tracepoint_mutex);
cds_list_for_each_entry(lib, &libs, list) {
- if (lib->tracepoints_start == tracepoints_start) {
- struct tracepoint_lib *lib2free = lib;
+ if (lib->tracepoints_start != tracepoints_start)
+ continue;
- cds_list_del(&lib->list);
- tracepoints_count = lib->tracepoints_count;
- free(lib2free);
- goto found;
- }
+ cds_list_del(&lib->list);
+ /*
+ * Unregistering a callsite also decreases the
+ * callsite reference count of the corresponding
+ * tracepoint, and disables the tracepoint if
+ * the reference count drops to zero.
+ */
+ lib_unregister_callsites(lib);
+ DBG("just unregistered a tracepoints section from %p",
+ lib->tracepoints_start);
+ free(lib);
+ break;
}
- goto end;
-found:
- /*
- * Force tracepoint disarm for all tracepoints of this lib.
- * This takes care of destructor of library that would leave a
- * LD_PRELOAD wrapper override function enabled for tracing, but
- * the session teardown would not be able to reach the
- * tracepoint anymore to disable it.
- */
- lib_disable_tracepoints(tracepoints_start,
- tracepoints_start + tracepoints_count);
- DBG("just unregistered a tracepoints section from %p",
- tracepoints_start);
-end:
pthread_mutex_unlock(&tracepoint_mutex);
return 0;
}
projects / lttng-ust.git / blobdiff