#include <stdio.h>
#include <urcu/arch.h>
-#include <urcu-bp.h>
+#include <urcu/urcu-bp.h>
#include <urcu/hlist.h>
#include <urcu/uatomic.h>
#include <urcu/compiler.h>
/* Set to 1 to enable tracepoint debug output */
static const int tracepoint_debug;
static int initialized;
+
+/*
+ * If tracepoint_destructors_state = 1, tracepoint destructors are
+ * enabled. They are disabled otherwise.
+ */
+static int tracepoint_destructors_state = 1;
+
+/*
+ * Expose the now deprecated symbol __tracepoints__disable_destructors for
+ * backward compatibility of applications built against old versions of
+ * lttng-ust. We need to keep __tracepoints__disable_destructors up to date
+ * within the new destructor disabling API because old applications read this
+ * symbol directly.
+ */
+int __tracepoints__disable_destructors __attribute__((weak));
+
static void (*new_tracepoint_cb)(struct lttng_ust_tracepoint *);
/*
struct lttng_ust_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];
+ char *signature;
+ char *name;
};
struct tp_probes {
struct cds_hlist_node hlist; /* hash table node */
struct cds_list_head node; /* lib list of callsites node */
struct lttng_ust_tracepoint *tp;
+ bool tp_entry_callsite_ref; /* Has a tp_entry took a ref on this callsite */
};
/* coverity[+alloc] */
if (old) {
struct tp_probes *tp_probes = caa_container_of(old,
struct tp_probes, probes[0]);
- synchronize_rcu();
+ urcu_bp_synchronize_rcu();
free(tp_probes);
}
}
struct cds_hlist_node *node;
struct tracepoint_entry *e;
size_t name_len = strlen(name);
+ size_t sig_len = strlen(signature);
+ size_t sig_off, name_off;
uint32_t hash;
if (name_len > LTTNG_UST_SYM_NAME_LEN - 1) {
return ERR_PTR(-EEXIST); /* Already there */
}
}
+
/*
- * Using zmalloc here to allocate a variable length element. Could
- * cause some memory fragmentation if overused.
+ * Using zmalloc here to allocate a variable length elements: name and
+ * signature. Could cause some memory fragmentation if overused.
*/
- e = zmalloc(sizeof(struct tracepoint_entry) + name_len + 1);
+ name_off = sizeof(struct tracepoint_entry);
+ sig_off = name_off + name_len + 1;
+
+ e = zmalloc(sizeof(struct tracepoint_entry) + name_len + 1 + sig_len + 1);
if (!e)
return ERR_PTR(-ENOMEM);
- memcpy(&e->name[0], name, name_len + 1);
+ e->name = (char *) e + name_off;
+ memcpy(e->name, name, name_len + 1);
e->name[name_len] = '\0';
+
+ e->signature = (char *) e + sig_off;
+ memcpy(e->signature, signature, sig_len + 1);
+ e->signature[sig_len] = '\0';
+
e->probes = NULL;
e->refcount = 0;
e->callsite_refcount = 0;
- e->signature = signature;
+
cds_hlist_add_head(&e->hlist, head);
return e;
}
if (!tp_entry)
return;
tp_entry->callsite_refcount++;
+ e->tp_entry_callsite_ref = true;
}
/*
tp_entry = get_tracepoint(e->tp->name);
if (tp_entry) {
- tp_entry->callsite_refcount--;
+ if (e->tp_entry_callsite_ref)
+ tp_entry->callsite_refcount--;
if (tp_entry->callsite_refcount == 0)
disable_tracepoint(e->tp);
}
if (strncmp(name, tp->name, LTTNG_UST_SYM_NAME_LEN - 1))
continue;
if (tp_entry) {
+ if (!e->tp_entry_callsite_ref) {
+ tp_entry->callsite_refcount++;
+ e->tp_entry_callsite_ref = true;
+ }
set_tracepoint(&tp_entry, tp,
!!tp_entry->refcount);
} else {
disable_tracepoint(tp);
+ e->tp_entry_callsite_ref = false;
}
}
}
struct lttng_ust_tracepoint_probe *old;
entry = get_tracepoint(name);
- if (!entry) {
+ if (entry) {
+ if (strcmp(entry->signature, signature) != 0) {
+ ERR("Tracepoint and probe signature do not match.");
+ return ERR_PTR(-EINVAL);
+ }
+ } else {
entry = add_tracepoint(name, signature);
if (IS_ERR(entry))
return (struct lttng_ust_tracepoint_probe *)entry;
release_queue_need_update = 0;
/* Wait for grace period between all sync_callsites and free. */
- synchronize_rcu();
+ urcu_bp_synchronize_rcu();
cds_list_for_each_entry_safe(pos, next, &release_probes, u.list) {
cds_list_del(&pos->u.list);
tracepoint_update_probes();
/* Wait for grace period between update_probes and free. */
- synchronize_rcu();
+ urcu_bp_synchronize_rcu();
cds_list_for_each_entry_safe(pos, next, &release_probes, u.list) {
cds_list_del(&pos->u.list);
free(pos);
void tp_rcu_read_lock_bp(void)
{
- rcu_read_lock_bp();
+ urcu_bp_read_lock();
}
void tp_rcu_read_unlock_bp(void)
{
- rcu_read_unlock_bp();
+ urcu_bp_read_unlock();
}
void *tp_rcu_dereference_sym_bp(void *p)
{
- return rcu_dereference_bp(p);
+ return urcu_bp_dereference(p);
+}
+
+/*
+ * Programs that have threads that survive after they exit, and therefore call
+ * library destructors, should disable the tracepoint destructors by calling
+ * tp_disable_destructors(). This will leak the tracepoint
+ * instrumentation library shared object, leaving its teardown to the operating
+ * system process teardown.
+ *
+ * To access and/or modify this value, users need to use a combination of
+ * dlopen(3) and dlsym(3) to get an handle on the
+ * tp_disable_destructors and tp_get_destructors_state symbols below.
+ */
+void tp_disable_destructors(void)
+{
+ uatomic_set(&tracepoint_destructors_state, 0);
+}
+
+/*
+ * Returns 1 if the destructors are enabled and should be executed.
+ * Returns 0 if the destructors are disabled.
+ */
+int tp_get_destructors_state(void)
+{
+ return uatomic_read(&tracepoint_destructors_state);
}
projects / lttng-ust.git / blobdiff