#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 */
#include "jhash.h"
#include "error.h"
+/* Test compiler support for weak symbols with hidden visibility. */
+int __tracepoint_test_symbol1 __attribute__((weak, visibility("hidden")));
+void *__tracepoint_test_symbol2 __attribute__((weak, visibility("hidden")));
+struct {
+ char a[24];
+} __tracepoint_test_symbol3 __attribute__((weak, visibility("hidden")));
+
/* 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 *);
/*
static CDS_LIST_HEAD(old_probes);
static int need_update;
+static CDS_LIST_HEAD(release_queue);
+static int release_queue_need_update;
+
/*
* Note about RCU :
* It is used to to delay the free of multiple probes array until a quiescent
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] */
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;
}
* is used.
*/
rcu_assign_pointer(elem->probes, (*entry)->probes);
- elem->state = active;
+ CMM_STORE_SHARED(elem->state, active);
}
/*
*/
static void disable_tracepoint(struct lttng_ust_tracepoint *elem)
{
- elem->state = 0;
+ CMM_STORE_SHARED(elem->state, 0);
rcu_assign_pointer(elem->probes, NULL);
}
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;
return old;
}
+static void tracepoint_release_queue_add_old_probes(void *old)
+{
+ release_queue_need_update = 1;
+ if (old) {
+ struct tp_probes *tp_probes = caa_container_of(old,
+ struct tp_probes, probes[0]);
+ cds_list_add(&tp_probes->u.list, &release_queue);
+ }
+}
+
/**
* __tracepoint_probe_register - Connect a probe to a tracepoint
* @name: tracepoint name
return ret;
}
+/*
+ * Caller needs to invoke __tracepoint_probe_release_queue() after
+ * calling __tracepoint_probe_register_queue_release() one or multiple
+ * times to ensure it does not leak memory.
+ */
+int __tracepoint_probe_register_queue_release(const char *name,
+ void (*probe)(void), void *data, const char *signature)
+{
+ void *old;
+ int ret = 0;
+
+ DBG("Registering probe to tracepoint %s. Queuing release.", name);
+
+ pthread_mutex_lock(&tracepoint_mutex);
+ old = tracepoint_add_probe(name, probe, data, signature);
+ if (IS_ERR(old)) {
+ ret = PTR_ERR(old);
+ goto end;
+ }
+
+ tracepoint_sync_callsites(name);
+ tracepoint_release_queue_add_old_probes(old);
+end:
+ pthread_mutex_unlock(&tracepoint_mutex);
+ return ret;
+}
+
static void *tracepoint_remove_probe(const char *name, void (*probe)(void),
void *data)
{
return ret;
}
+/*
+ * Caller needs to invoke __tracepoint_probe_release_queue() after
+ * calling __tracepoint_probe_unregister_queue_release() one or multiple
+ * times to ensure it does not leak memory.
+ */
+int __tracepoint_probe_unregister_queue_release(const char *name,
+ void (*probe)(void), void *data)
+{
+ void *old;
+ int ret = 0;
+
+ DBG("Un-registering probe from tracepoint %s. Queuing release.", name);
+
+ pthread_mutex_lock(&tracepoint_mutex);
+ old = tracepoint_remove_probe(name, probe, data);
+ if (IS_ERR(old)) {
+ ret = PTR_ERR(old);
+ goto end;
+ }
+ tracepoint_sync_callsites(name);
+ tracepoint_release_queue_add_old_probes(old);
+end:
+ pthread_mutex_unlock(&tracepoint_mutex);
+ return ret;
+}
+
+void __tracepoint_probe_prune_release_queue(void)
+{
+ CDS_LIST_HEAD(release_probes);
+ struct tp_probes *pos, *next;
+
+ DBG("Release queue of unregistered tracepoint probes.");
+
+ pthread_mutex_lock(&tracepoint_mutex);
+ if (!release_queue_need_update)
+ goto end;
+ if (!cds_list_empty(&release_queue))
+ cds_list_replace_init(&release_queue, &release_probes);
+ release_queue_need_update = 0;
+
+ /* Wait for grace period between all sync_callsites and free. */
+ synchronize_rcu();
+
+ cds_list_for_each_entry_safe(pos, next, &release_probes, u.list) {
+ cds_list_del(&pos->u.list);
+ free(pos);
+ }
+end:
+ pthread_mutex_unlock(&tracepoint_mutex);
+}
+
static void tracepoint_add_old_probes(void *old)
{
need_update = 1;
need_update = 0;
tracepoint_update_probes();
+ /* Wait for grace period between update_probes and free. */
+ synchronize_rcu();
cds_list_for_each_entry_safe(pos, next, &release_probes, u.list) {
cds_list_del(&pos->u.list);
- synchronize_rcu();
free(pos);
}
end:
return 0;
}
+/*
+ * Report in debug message whether the compiler correctly supports weak
+ * hidden symbols. This test checks that the address associated with two
+ * weak symbols with hidden visibility is the same when declared within
+ * two compile units part of the same module.
+ */
+static void check_weak_hidden(void)
+{
+ DBG("Your compiler treats weak symbols with hidden visibility for integer objects as %s between compile units part of the same module.",
+ &__tracepoint_test_symbol1 == lttng_ust_tp_check_weak_hidden1() ?
+ "SAME address" :
+ "DIFFERENT addresses");
+ DBG("Your compiler treats weak symbols with hidden visibility for pointer objects as %s between compile units part of the same module.",
+ &__tracepoint_test_symbol2 == lttng_ust_tp_check_weak_hidden2() ?
+ "SAME address" :
+ "DIFFERENT addresses");
+ DBG("Your compiler treats weak symbols with hidden visibility for 24-byte structure objects as %s between compile units part of the same module.",
+ &__tracepoint_test_symbol3 == lttng_ust_tp_check_weak_hidden3() ?
+ "SAME address" :
+ "DIFFERENT addresses");
+}
+
void init_tracepoint(void)
{
if (uatomic_xchg(&initialized, 1) == 1)
return;
init_usterr();
+ check_weak_hidden();
}
void exit_tracepoint(void)
{
return rcu_dereference_bp(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