}
sock_info->constructor_sem_posted = 0;
/*
- * When called from process exit, we allow this memory map to be
- * released by the OS at exit(), because removing it prior to
- * this can cause a segmentation fault when using the
- * futex_async timer-based fallback. And we cannot join those
- * threads because sys_futex does not react to the cancellation
- * request.
- *
- * So we actually _do_ release it only after a fork, since all
- * threads have vanished anyway.
+ * wait_shm_mmap is used by listener threads outside of the
+ * ust lock, so we cannot tear it down ourselves, because we
+ * cannot join on these threads. Leave this task to the OS
+ * process exit.
*/
if (!exiting && sock_info->wait_shm_mmap) {
ret = munmap(sock_info->wait_shm_mmap, sysconf(_SC_PAGE_SIZE));
if (local_apps.allowed) {
cleanup_sock_info(&local_apps, exiting);
}
+ /*
+ * The teardown in this function all affect data structures
+ * accessed under the UST lock by the listener thread. This
+ * lock, along with the lttng_ust_comm_should_quit flag, ensure
+ * that none of these threads are accessing this data at this
+ * point.
+ */
lttng_ust_abi_exit();
lttng_ust_events_exit();
ltt_ring_buffer_client_discard_exit();
lttng_ust_comm_should_quit = 1;
ust_unlock();
+ /* cancel threads */
ret = pthread_cancel(global_apps.ust_listener);
if (ret) {
ERR("Error cancelling global ust listener thread");
}
}
/*
- * We cannot join the threads because they might be waiting on
- * sys_futex. Simply let the OS exit() clean up those threads.
+ * Do NOT join threads: use of sys_futex makes it impossible to
+ * join the threads without using async-cancel, but async-cancel
+ * is delivered by a signal, which could hit the target thread
+ * anywhere in its code path, including while the ust_lock() is
+ * held, causing a deadlock for the other thread. Let the OS
+ * cleanup the threads if there are stalled in a syscall.
*/
lttng_ust_cleanup(1);
}