X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust%2Ftracepoint.c;h=00fcc740101b5f443d77fba5b8596f3053643302;hb=4b4a133740c87d9a851023a7aeb06b78d887e51b;hp=a594d73ddd7bc6a3c893acd3d645635d23bc6c73;hpb=5517d34d4c242bb2a5233e08e21eec7fa12f3489;p=lttng-ust.git diff --git a/liblttng-ust/tracepoint.c b/liblttng-ust/tracepoint.c index a594d73d..00fcc740 100644 --- a/liblttng-ust/tracepoint.c +++ b/liblttng-ust/tracepoint.c @@ -1,21 +1,9 @@ /* + * SPDX-License-Identifier: LGPL-2.1-only + * * 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; - * 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 - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * * Ported to userspace by Pierre-Marc Fournier. */ @@ -26,17 +14,17 @@ #include #include -#include +#include #include #include #include #include #include -#include /* for LTTNG_UST_SYM_NAME_LEN */ +#include /* for LTTNG_UST_ABI_SYM_NAME_LEN */ #include -#include +#include #include "tracepoint-internal.h" #include "lttng-tracer-core.h" @@ -44,11 +32,22 @@ #include "error.h" /* Test compiler support for weak symbols with hidden visibility. */ -char __tracepoint_test_symbol[9] __attribute__((weak, visibility("hidden"))); +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; + static void (*new_tracepoint_cb)(struct lttng_ust_tracepoint *); /* @@ -89,6 +88,9 @@ static struct cds_hlist_head tracepoint_table[TRACEPOINT_TABLE_SIZE]; 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 @@ -100,8 +102,8 @@ struct tracepoint_entry { 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 { @@ -125,6 +127,7 @@ struct callsite_entry { 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] */ @@ -142,7 +145,7 @@ static void release_probes(void *old) if (old) { struct tp_probes *tp_probes = caa_container_of(old, struct tp_probes, probes[0]); - synchronize_rcu(); + lttng_ust_urcu_synchronize_rcu(); free(tp_probes); } } @@ -253,14 +256,14 @@ static struct tracepoint_entry *get_tracepoint(const char *name) size_t name_len = strlen(name); uint32_t hash; - 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; + if (name_len > LTTNG_UST_ABI_SYM_NAME_LEN - 1) { + WARN("Truncating tracepoint name %s which exceeds size limits of %u chars", name, LTTNG_UST_ABI_SYM_NAME_LEN - 1); + name_len = LTTNG_UST_ABI_SYM_NAME_LEN - 1; } hash = jhash(name, name_len, 0); head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)]; cds_hlist_for_each_entry(e, node, head, hlist) { - if (!strncmp(name, e->name, LTTNG_UST_SYM_NAME_LEN - 1)) + if (!strncmp(name, e->name, LTTNG_UST_ABI_SYM_NAME_LEN - 1)) return e; } return NULL; @@ -277,33 +280,45 @@ static struct tracepoint_entry *add_tracepoint(const char *name, 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) { - 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; + if (name_len > LTTNG_UST_ABI_SYM_NAME_LEN - 1) { + WARN("Truncating tracepoint name %s which exceeds size limits of %u chars", name, LTTNG_UST_ABI_SYM_NAME_LEN - 1); + name_len = LTTNG_UST_ABI_SYM_NAME_LEN - 1; } hash = jhash(name, name_len, 0); head = &tracepoint_table[hash & (TRACEPOINT_TABLE_SIZE - 1)]; cds_hlist_for_each_entry(e, node, head, hlist) { - if (!strncmp(name, e->name, LTTNG_UST_SYM_NAME_LEN - 1)) { + if (!strncmp(name, e->name, LTTNG_UST_ABI_SYM_NAME_LEN - 1)) { DBG("tracepoint %s busy", name); 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; } @@ -324,7 +339,7 @@ static void remove_tracepoint(struct tracepoint_entry *e) static void set_tracepoint(struct tracepoint_entry **entry, struct lttng_ust_tracepoint *elem, int active) { - WARN_ON(strncmp((*entry)->name, elem->name, LTTNG_UST_SYM_NAME_LEN - 1) != 0); + WARN_ON(strncmp((*entry)->name, elem->name, LTTNG_UST_ABI_SYM_NAME_LEN - 1) != 0); /* * Check that signatures match before connecting a probe to a * tracepoint. Warn the user if they don't. @@ -350,7 +365,7 @@ static void set_tracepoint(struct tracepoint_entry **entry, * include/linux/tracepoints.h. A matching cmm_smp_read_barrier_depends() * is used. */ - rcu_assign_pointer(elem->probes, (*entry)->probes); + lttng_ust_rcu_assign_pointer(elem->probes, (*entry)->probes); CMM_STORE_SHARED(elem->state, active); } @@ -363,7 +378,7 @@ static void set_tracepoint(struct tracepoint_entry **entry, static void disable_tracepoint(struct lttng_ust_tracepoint *elem) { CMM_STORE_SHARED(elem->state, 0); - rcu_assign_pointer(elem->probes, NULL); + lttng_ust_rcu_assign_pointer(elem->probes, NULL); } /* @@ -379,9 +394,9 @@ static void add_callsite(struct tracepoint_lib * lib, struct lttng_ust_tracepoin 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; + if (name_len > LTTNG_UST_ABI_SYM_NAME_LEN - 1) { + WARN("Truncating tracepoint name %s which exceeds size limits of %u chars", name, LTTNG_UST_ABI_SYM_NAME_LEN - 1); + name_len = LTTNG_UST_ABI_SYM_NAME_LEN - 1; } hash = jhash(name, name_len, 0); head = &callsite_table[hash & (CALLSITE_TABLE_SIZE - 1)]; @@ -398,6 +413,7 @@ static void add_callsite(struct tracepoint_lib * lib, struct lttng_ust_tracepoin if (!tp_entry) return; tp_entry->callsite_refcount++; + e->tp_entry_callsite_ref = true; } /* @@ -410,7 +426,8 @@ static void remove_callsite(struct callsite_entry *e) 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); } @@ -434,22 +451,27 @@ static void tracepoint_sync_callsites(const char *name) 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; + if (name_len > LTTNG_UST_ABI_SYM_NAME_LEN - 1) { + WARN("Truncating tracepoint name %s which exceeds size limits of %u chars", name, LTTNG_UST_ABI_SYM_NAME_LEN - 1); + name_len = LTTNG_UST_ABI_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 lttng_ust_tracepoint *tp = e->tp; - if (strncmp(name, tp->name, LTTNG_UST_SYM_NAME_LEN - 1)) + if (strncmp(name, tp->name, LTTNG_UST_ABI_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; } } } @@ -538,7 +560,12 @@ tracepoint_add_probe(const char *name, void (*probe)(void), void *data, 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; @@ -549,6 +576,16 @@ tracepoint_add_probe(const char *name, void (*probe)(void), void *data, 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 @@ -580,6 +617,33 @@ end: return ret; } +/* + * Caller needs to invoke __tracepoint_probe_release_queue() after + * calling lttng_ust_tp_probe_register_queue_release() one or multiple + * times to ensure it does not leak memory. + */ +int lttng_ust_tp_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) { @@ -624,6 +688,57 @@ end: return ret; } +/* + * Caller needs to invoke __tracepoint_probe_release_queue() after + * calling lttng_ust_tp_probe_unregister_queue_release() one or multiple + * times to ensure it does not leak memory. + */ +int lttng_ust_tp_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 lttng_ust_tp_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. */ + lttng_ust_urcu_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; @@ -704,20 +819,16 @@ void tracepoint_probe_update_all(void) need_update = 0; tracepoint_update_probes(); + /* Wait for grace period between update_probes and free. */ + lttng_ust_urcu_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: pthread_mutex_unlock(&tracepoint_mutex); } -void tracepoint_set_new_tracepoint_cb(void (*cb)(struct lttng_ust_tracepoint *)) -{ - new_tracepoint_cb = cb; -} - static void new_tracepoints(struct lttng_ust_tracepoint * const *start, struct lttng_ust_tracepoint * const *end) { @@ -731,12 +842,26 @@ static void new_tracepoints(struct lttng_ust_tracepoint * const *start, } } +/* + * tracepoint_{un,}register_lib is meant to be looked up by instrumented + * applications through dlsym(). If found, those can register their + * tracepoints, else those tracepoints will not be available for + * tracing. The number at the end of those symbols acts as a major + * version for tracepoints. + * + * Older instrumented applications should still work with newer + * liblttng-ust, but it is fine that instrumented applications compiled + * against recent liblttng-ust headers require a recent liblttng-ust + * runtime for those tracepoints to be taken into account. + */ int tracepoint_register_lib(struct lttng_ust_tracepoint * const *tracepoints_start, - int tracepoints_count) + int tracepoints_count); +int tracepoint_register_lib(struct lttng_ust_tracepoint * const *tracepoints_start, + int tracepoints_count) { struct tracepoint_lib *pl, *iter; - init_tracepoint(); + lttng_ust_tp_init(); pl = (struct tracepoint_lib *) zmalloc(sizeof(struct tracepoint_lib)); if (!pl) { @@ -769,7 +894,7 @@ lib_added: DBG("just registered a tracepoints section from %p and having %d tracepoints", tracepoints_start, tracepoints_count); - if (ust_debug()) { + if (ust_err_debug_enabled()) { int i; for (i = 0; i < tracepoints_count; i++) { @@ -780,6 +905,7 @@ lib_added: return 0; } +int tracepoint_unregister_lib(struct lttng_ust_tracepoint * const *tracepoints_start); int tracepoint_unregister_lib(struct lttng_ust_tracepoint * const *tracepoints_start) { struct tracepoint_lib *lib; @@ -814,21 +940,29 @@ int tracepoint_unregister_lib(struct lttng_ust_tracepoint * const *tracepoints_s */ static void check_weak_hidden(void) { - DBG("Your compiler support for weak symbols with hidden visibility is %s", - __tracepoint_test_symbol == lttng_ust_tp_check_weak_hidden() ? - "OK" : - "BROKEN. Please upgrade or fix your compiler to use LTTng-UST tracepoints."); + 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) +void lttng_ust_tp_init(void) { if (uatomic_xchg(&initialized, 1) == 1) return; - init_usterr(); + ust_err_init(); check_weak_hidden(); } -void exit_tracepoint(void) +void lttng_ust_tp_exit(void) { initialized = 0; } @@ -836,21 +970,51 @@ void exit_tracepoint(void) /* * Create the wrapper symbols. */ -#undef tp_rcu_read_lock_bp -#undef tp_rcu_read_unlock_bp -#undef tp_rcu_dereference_bp +#undef tp_rcu_read_lock +#undef tp_rcu_read_unlock +#undef tp_rcu_dereference + +void tp_rcu_read_lock(void); +void tp_rcu_read_lock(void) +{ + lttng_ust_urcu_read_lock(); +} + +void tp_rcu_read_unlock(void); +void tp_rcu_read_unlock(void) +{ + lttng_ust_urcu_read_unlock(); +} -void tp_rcu_read_lock_bp(void) +void *tp_rcu_dereference_sym(void *p); +void *tp_rcu_dereference_sym(void *p) { - rcu_read_lock_bp(); + return lttng_ust_rcu_dereference(p); } -void tp_rcu_read_unlock_bp(void) +/* + * 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); +void tp_disable_destructors(void) { - rcu_read_unlock_bp(); + uatomic_set(&tracepoint_destructors_state, 0); } -void *tp_rcu_dereference_sym_bp(void *p) +/* + * Returns 1 if the destructors are enabled and should be executed. + * Returns 0 if the destructors are disabled. + */ +int tp_get_destructors_state(void); +int tp_get_destructors_state(void) { - return rcu_dereference_bp(p); + return uatomic_read(&tracepoint_destructors_state); }