X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust%2Flttng-ust-comm.c;h=0116b5f744160cab7d4077146d4a532f606359d8;hb=5f003977aaebf8bed9cc3627d3e1b5ff9e6893e6;hp=d35511b2f1afecc7bf16a10317955130c6cbc175;hpb=69400ac4a4e6575f749c6326df7c2a2c8ac3bdc5;p=lttng-ust.git diff --git a/liblttng-ust/lttng-ust-comm.c b/liblttng-ust/lttng-ust-comm.c index d35511b2..0116b5f7 100644 --- a/liblttng-ust/lttng-ust-comm.c +++ b/liblttng-ust/lttng-ust-comm.c @@ -37,15 +37,16 @@ #include #include #include +#include -#include #include -#include #include -#include -#include #include +#include +#include +#include "tracepoint-internal.h" #include "ltt-tracer-core.h" +#include "../libringbuffer/tlsfixup.h" /* * Has lttng ust comm constructor been called ? @@ -167,6 +168,7 @@ int register_app_to_sessiond(int socket) pid_t ppid; uid_t uid; gid_t gid; + uint32_t bits_per_long; char name[16]; /* process name */ } reg_msg; @@ -176,6 +178,7 @@ int register_app_to_sessiond(int socket) reg_msg.ppid = getppid(); reg_msg.uid = getuid(); reg_msg.gid = getgid(); + reg_msg.bits_per_long = CAA_BITS_PER_LONG; prctl_ret = prctl(PR_GET_NAME, (unsigned long) reg_msg.name, 0, 0, 0); if (prctl_ret) { ERR("Error executing prctl"); @@ -237,6 +240,7 @@ int handle_message(struct sock_info *sock_info, const struct lttng_ust_objd_ops *ops; struct ustcomm_ust_reply lur; int shm_fd, wait_fd; + union ust_args args; ust_lock(); @@ -269,7 +273,8 @@ int handle_message(struct sock_info *sock_info, default: if (ops->cmd) ret = ops->cmd(lum->handle, lum->cmd, - (unsigned long) &lum->u); + (unsigned long) &lum->u, + &args); else ret = -ENOSYS; break; @@ -285,25 +290,30 @@ end: //lur.ret_code = USTCOMM_SESSION_FAIL; lur.ret_code = ret; } - switch (lum->cmd) { - case LTTNG_UST_STREAM: - /* - * Special-case reply to send stream info. - * Use lum.u output. - */ - lur.u.stream.memory_map_size = lum->u.stream.memory_map_size; - shm_fd = lum->u.stream.shm_fd; - wait_fd = lum->u.stream.wait_fd; - break; - case LTTNG_UST_METADATA: - case LTTNG_UST_CHANNEL: - lur.u.channel.memory_map_size = lum->u.channel.memory_map_size; - shm_fd = lum->u.channel.shm_fd; - wait_fd = lum->u.channel.wait_fd; - break; - case LTTNG_UST_VERSION: - lur.u.version = lum->u.version; - break; + if (ret >= 0) { + switch (lum->cmd) { + case LTTNG_UST_STREAM: + /* + * Special-case reply to send stream info. + * Use lum.u output. + */ + lur.u.stream.memory_map_size = *args.stream.memory_map_size; + shm_fd = *args.stream.shm_fd; + wait_fd = *args.stream.wait_fd; + break; + case LTTNG_UST_METADATA: + case LTTNG_UST_CHANNEL: + lur.u.channel.memory_map_size = *args.channel.memory_map_size; + shm_fd = *args.channel.shm_fd; + wait_fd = *args.channel.wait_fd; + break; + case LTTNG_UST_TRACER_VERSION: + lur.u.version = lum->u.version; + break; + case LTTNG_UST_TRACEPOINT_LIST_GET: + memcpy(&lur.u.tracepoint, &lum->u.tracepoint, sizeof(lur.u.tracepoint)); + break; + } } ret = send_reply(sock, &lur); if (ret < 0) { @@ -315,14 +325,20 @@ end: || lum->cmd == LTTNG_UST_CHANNEL || lum->cmd == LTTNG_UST_METADATA) && lur.ret_code == USTCOMM_OK) { + int sendret = 0; + /* we also need to send the file descriptors. */ ret = ustcomm_send_fds_unix_sock(sock, &shm_fd, &shm_fd, 1, sizeof(int)); if (ret < 0) { perror("send shm_fd"); - goto error; + sendret = ret; } + /* + * The sessiond expects 2 file descriptors, even upon + * error. + */ ret = ustcomm_send_fds_unix_sock(sock, &wait_fd, &wait_fd, 1, sizeof(int)); @@ -330,19 +346,67 @@ end: perror("send wait_fd"); goto error; } + if (sendret) { + ret = sendret; + goto error; + } } + /* + * We still have the memory map reference, and the fds have been + * sent to the sessiond. We can therefore close those fds. Note + * that we keep the write side of the wait_fd open, but close + * the read side. + */ + if (lur.ret_code == USTCOMM_OK) { + switch (lum->cmd) { + case LTTNG_UST_STREAM: + if (shm_fd >= 0) { + ret = close(shm_fd); + if (ret) { + PERROR("Error closing stream shm_fd"); + } + *args.stream.shm_fd = -1; + } + if (wait_fd >= 0) { + ret = close(wait_fd); + if (ret) { + PERROR("Error closing stream wait_fd"); + } + *args.stream.wait_fd = -1; + } + break; + case LTTNG_UST_METADATA: + case LTTNG_UST_CHANNEL: + if (shm_fd >= 0) { + ret = close(shm_fd); + if (ret) { + PERROR("Error closing channel shm_fd"); + } + *args.channel.shm_fd = -1; + } + if (wait_fd >= 0) { + ret = close(wait_fd); + if (ret) { + PERROR("Error closing channel wait_fd"); + } + *args.channel.wait_fd = -1; + } + break; + } + } + error: ust_unlock(); return ret; } static -void cleanup_sock_info(struct sock_info *sock_info) +void cleanup_sock_info(struct sock_info *sock_info, int exiting) { int ret; if (sock_info->socket != -1) { - ret = close(sock_info->socket); + ret = ustcomm_close_unix_sock(sock_info->socket); if (ret) { ERR("Error closing apps socket"); } @@ -356,7 +420,13 @@ void cleanup_sock_info(struct sock_info *sock_info) sock_info->root_handle = -1; } sock_info->constructor_sem_posted = 0; - if (sock_info->wait_shm_mmap) { + /* + * 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 (ret) { ERR("Error unmapping wait shm"); @@ -408,7 +478,7 @@ int get_wait_shm(struct sock_info *sock_info, size_t mmap_size) * shared memory map will have been created. */ pid = wait(&status); - if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) { + if (pid < 0 || !WIFEXITED(status) || WEXITSTATUS(status) != 0) { wait_shm_fd = -1; goto end; } @@ -556,14 +626,15 @@ void wait_for_sessiond(struct sock_info *sock_info) if (ret < 0) { if (errno == EFAULT) { wait_poll_fallback = 1; - WARN( + DBG( "Linux kernels 2.6.33 to 3.0 (with the exception of stable versions) " "do not support FUTEX_WAKE on read-only memory mappings correctly. " "Please upgrade your kernel " "(fix is commit 9ea71503a8ed9184d2d0b8ccc4d269d05f7940ae in Linux kernel " "mainline). LTTng-UST will use polling mode fallback."); + if (ust_debug()) + PERROR("futex"); } - PERROR("futex"); } } return; @@ -615,7 +686,7 @@ restart: } if (sock_info->socket != -1) { - ret = close(sock_info->socket); + ret = ustcomm_close_unix_sock(sock_info->socket); if (ret) { ERR("Error closing %s apps socket", sock_info->name); } @@ -625,7 +696,7 @@ restart: /* Register */ ret = ustcomm_connect_unix_sock(sock_info->sock_path); if (ret < 0) { - ERR("Error connecting to %s apps socket", sock_info->name); + DBG("Info: sessiond not accepting connections to %s apps socket", sock_info->name); prev_connect_failed = 1; /* * If we cannot find the sessiond daemon, don't delay @@ -676,6 +747,20 @@ restart: switch (len) { case 0: /* orderly shutdown */ DBG("%s ltt-sessiond has performed an orderly shutdown\n", sock_info->name); + ust_lock(); + /* + * Either sessiond has shutdown or refused us by closing the socket. + * In either case, we don't want to delay construction execution, + * and we need to wait before retry. + */ + prev_connect_failed = 1; + /* + * If we cannot register to the sessiond daemon, don't + * delay constructor execution. + */ + ret = handle_register_done(sock_info); + assert(!ret); + ust_unlock(); goto end; case sizeof(lum): DBG("message received\n"); @@ -685,6 +770,7 @@ restart: } continue; case -1: + DBG("Receive failed from lttng-sessiond with errno %d", errno); if (errno == ECONNRESET) { ERR("%s remote end closed connection\n", sock_info->name); goto end; @@ -757,6 +843,15 @@ void __attribute__((constructor)) lttng_ust_init(void) if (uatomic_xchg(&initialized, 1) == 1) return; + /* + * Fixup interdependency between TLS fixup mutex (which happens + * to be the dynamic linker mutex) and ust_lock, taken within + * the ust lock. + */ + lttng_fixup_event_tls(); + lttng_fixup_ringbuffer_tls(); + lttng_fixup_vtid_tls(); + /* * We want precise control over the order in which we construct * our sub-libraries vs starting to receive commands from @@ -814,10 +909,17 @@ void __attribute__((constructor)) lttng_ust_init(void) static void lttng_ust_cleanup(int exiting) { - cleanup_sock_info(&global_apps); + cleanup_sock_info(&global_apps, exiting); if (local_apps.allowed) { - cleanup_sock_info(&local_apps); + 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(); @@ -851,6 +953,7 @@ void __attribute__((destructor)) lttng_ust_exit(void) 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"); @@ -861,6 +964,14 @@ void __attribute__((destructor)) lttng_ust_exit(void) ERR("Error cancelling local ust listener thread"); } } + /* + * 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); } @@ -871,7 +982,7 @@ void __attribute__((destructor)) lttng_ust_exit(void) * in the middle of an tracepoint or ust tracing state modification. * Holding this mutex protects these structures across fork and clone. */ -void ust_before_fork(ust_fork_info_t *fork_info) +void ust_before_fork(sigset_t *save_sigset) { /* * Disable signals. This is to avoid that the child intervenes @@ -884,7 +995,7 @@ void ust_before_fork(ust_fork_info_t *fork_info) /* Disable signals */ sigfillset(&all_sigs); - ret = sigprocmask(SIG_BLOCK, &all_sigs, &fork_info->orig_sigs); + ret = sigprocmask(SIG_BLOCK, &all_sigs, save_sigset); if (ret == -1) { PERROR("sigprocmask"); } @@ -892,25 +1003,25 @@ void ust_before_fork(ust_fork_info_t *fork_info) rcu_bp_before_fork(); } -static void ust_after_fork_common(ust_fork_info_t *fork_info) +static void ust_after_fork_common(sigset_t *restore_sigset) { int ret; DBG("process %d", getpid()); ust_unlock(); /* Restore signals */ - ret = sigprocmask(SIG_SETMASK, &fork_info->orig_sigs, NULL); + ret = sigprocmask(SIG_SETMASK, restore_sigset, NULL); if (ret == -1) { PERROR("sigprocmask"); } } -void ust_after_fork_parent(ust_fork_info_t *fork_info) +void ust_after_fork_parent(sigset_t *restore_sigset) { DBG("process %d", getpid()); rcu_bp_after_fork_parent(); /* Release mutexes and reenable signals */ - ust_after_fork_common(fork_info); + ust_after_fork_common(restore_sigset); } /* @@ -922,7 +1033,7 @@ void ust_after_fork_parent(ust_fork_info_t *fork_info) * This is meant for forks() that have tracing in the child between the * fork and following exec call (if there is any). */ -void ust_after_fork_child(ust_fork_info_t *fork_info) +void ust_after_fork_child(sigset_t *restore_sigset) { DBG("process %d", getpid()); /* Release urcu mutexes */ @@ -930,6 +1041,6 @@ void ust_after_fork_child(ust_fork_info_t *fork_info) lttng_ust_cleanup(0); lttng_context_vtid_reset(); /* Release mutexes and reenable signals */ - ust_after_fork_common(fork_info); + ust_after_fork_common(restore_sigset); lttng_ust_init(); }