*/
int lttng_ust_loaded __attribute__((weak));
+/*
+ * Notes on async-signal-safety of ust lock: a few libc functions are used
+ * which are not strictly async-signal-safe:
+ *
+ * - pthread_setcancelstate
+ * - pthread_mutex_lock
+ * - pthread_mutex_unlock
+ *
+ * As of glibc 2.35, the implementation of pthread_setcancelstate only
+ * touches TLS data, and it appears to be safe to use from signal
+ * handlers. If the libc implementation changes, this will need to be
+ * revisited, and we may ask glibc to provide an async-signal-safe
+ * pthread_setcancelstate.
+ *
+ * As of glibc 2.35, the implementation of pthread_mutex_lock/unlock
+ * for fast mutexes only relies on the pthread_mutex_t structure.
+ * Disabling signals around all uses of this mutex ensures
+ * signal-safety. If the libc implementation changes and eventually uses
+ * other global resources, this will need to be revisited and we may
+ * need to implement our own mutex.
+ */
+
/*
* Return 0 on success, -1 if should quit.
* The lock is taken in both cases.
sigfillset(&sig_all_blocked);
ret = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_mask);
if (ret) {
- ERR("pthread_sigmask: %s", strerror(ret));
+ ERR("pthread_sigmask: ret=%d", ret);
}
if (!URCU_TLS(ust_mutex_nest)++)
pthread_mutex_lock(&ust_mutex);
ret = pthread_sigmask(SIG_SETMASK, &orig_mask, NULL);
if (ret) {
- ERR("pthread_sigmask: %s", strerror(ret));
+ ERR("pthread_sigmask: ret=%d", ret);
}
if (lttng_ust_comm_should_quit) {
return -1;
sigfillset(&sig_all_blocked);
ret = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_mask);
if (ret) {
- ERR("pthread_sigmask: %s", strerror(ret));
+ ERR("pthread_sigmask: ret=%d", ret);
}
if (!URCU_TLS(ust_mutex_nest)++)
pthread_mutex_lock(&ust_mutex);
ret = pthread_sigmask(SIG_SETMASK, &orig_mask, NULL);
if (ret) {
- ERR("pthread_sigmask: %s", strerror(ret));
+ ERR("pthread_sigmask: ret=%d", ret);
}
}
sigfillset(&sig_all_blocked);
ret = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_mask);
if (ret) {
- ERR("pthread_sigmask: %s", strerror(ret));
+ ERR("pthread_sigmask: ret=%d", ret);
}
if (!--URCU_TLS(ust_mutex_nest))
pthread_mutex_unlock(&ust_mutex);
ret = pthread_sigmask(SIG_SETMASK, &orig_mask, NULL);
if (ret) {
- ERR("pthread_sigmask: %s", strerror(ret));
+ ERR("pthread_sigmask: ret=%d", ret);
}
if (lttng_ust_cancelstate_disable_pop()) {
ERR("lttng_ust_cancelstate_disable_pop");
* Force a read (imply TLS allocation for dlopen) of TLS variables.
*/
static
-void lttng_nest_count_alloc_tls(void)
+void lttng_ust_nest_count_alloc_tls(void)
{
asm volatile ("" : : "m" (URCU_TLS(lttng_ust_nest_count)));
}
* Allocate lttng-ust urcu TLS.
*/
static
-void lttng_lttng_ust_urcu_alloc_tls(void)
+void lttng_ust_urcu_alloc_tls(void)
{
(void) lttng_ust_urcu_read_ongoing();
}
-void lttng_ust_alloc_tls(void)
+void lttng_ust_common_init_thread(int flags)
{
- lttng_lttng_ust_urcu_alloc_tls();
+ lttng_ust_urcu_alloc_tls();
lttng_ringbuffer_alloc_tls();
- lttng_vtid_alloc_tls();
- lttng_nest_count_alloc_tls();
- lttng_procname_alloc_tls();
+ lttng_ust_vtid_init_thread(flags);
+ lttng_ust_nest_count_alloc_tls();
+ lttng_ust_procname_init_thread(flags);
lttng_ust_mutex_nest_alloc_tls();
- lttng_ust_perf_counter_alloc_tls();
+ lttng_ust_perf_counter_init_thread(flags);
lttng_ust_common_alloc_tls();
- lttng_cgroup_ns_alloc_tls();
- lttng_ipc_ns_alloc_tls();
- lttng_net_ns_alloc_tls();
- lttng_time_ns_alloc_tls();
- lttng_uts_ns_alloc_tls();
+ lttng_ust_cgroup_ns_init_thread(flags);
+ lttng_ust_ipc_ns_init_thread(flags);
+ lttng_ust_net_ns_init_thread(flags);
+ lttng_ust_time_ns_init_thread(flags);
+ lttng_ust_uts_ns_init_thread(flags);
lttng_ust_ring_buffer_client_discard_alloc_tls();
lttng_ust_ring_buffer_client_discard_rt_alloc_tls();
lttng_ust_ring_buffer_client_overwrite_alloc_tls();
* ensure those are initialized before a signal handler nesting over
* this thread attempts to use them.
*/
- lttng_ust_alloc_tls();
+ lttng_ust_common_init_thread(LTTNG_UST_INIT_THREAD_MASK);
+
+ lttng_ust_urcu_register_thread();
}
int lttng_get_notify_socket(void *owner)
DBG("Waiting for %s apps sessiond", sock_info->name);
/* Wait for futex wakeup */
- if (uatomic_read((int32_t *) sock_info->wait_shm_mmap))
- goto end_wait;
-
- while (lttng_ust_futex_async((int32_t *) sock_info->wait_shm_mmap,
- FUTEX_WAIT, 0, NULL, NULL, 0)) {
+ while (!uatomic_read((int32_t *) sock_info->wait_shm_mmap)) {
+ if (!lttng_ust_futex_async((int32_t *) sock_info->wait_shm_mmap, FUTEX_WAIT, 0, NULL, NULL, 0)) {
+ /*
+ * Prior queued wakeups queued by unrelated code
+ * using the same address can cause futex wait to
+ * return 0 even through the futex value is still
+ * 0 (spurious wakeups). Check the value again
+ * in user-space to validate whether it really
+ * differs from 0.
+ */
+ continue;
+ }
switch (errno) {
- case EWOULDBLOCK:
+ case EAGAIN:
/* Value already changed. */
goto end_wait;
case EINTR:
/* Retry if interrupted by signal. */
- break; /* Get out of switch. */
+ break; /* Get out of switch. Check again. */
case EFAULT:
wait_poll_fallback = 1;
DBG(
int sock, ret, prev_connect_failed = 0, has_waited = 0, fd;
long timeout;
- lttng_ust_alloc_tls();
+ lttng_ust_common_init_thread(0);
/*
* If available, add '-ust' to the end of this thread's
* process name
* to be the dynamic linker mutex) and ust_lock, taken within
* the ust lock.
*/
- lttng_ust_alloc_tls();
+ lttng_ust_common_init_thread(0);
lttng_ust_loaded = 1;
int ret;
/* Allocate lttng-ust TLS. */
- lttng_ust_alloc_tls();
+ lttng_ust_common_init_thread(0);
if (URCU_TLS(lttng_ust_nest_count))
return;
projects / lttng-ust.git / blobdiff