X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=libust%2Flttng-ust-comm.c;h=1246c654c34f5d83f65dc2425a9f0a4728179292;hb=4318ae1be57eb7983ab4857a7a8eeb4a030a8216;hp=53e0b1efe647c1b4c8a7ec1a3cf22003ae0a4606;hpb=58d4b2a2484f1d6277c5553a661cf161a9de9af3;p=lttng-ust.git diff --git a/libust/lttng-ust-comm.c b/libust/lttng-ust-comm.c index 53e0b1ef..1246c654 100644 --- a/libust/lttng-ust-comm.c +++ b/libust/lttng-ust-comm.c @@ -19,6 +19,7 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ +#define _LGPL_SOURCE #include #include #include @@ -35,13 +36,15 @@ #include #include #include - -#include -#include -#include -#include -#include -#include +#include + +#include +#include +#include +#include +#include +#include +#include #include "ltt-tracer-core.h" /* @@ -117,6 +120,8 @@ struct sock_info local_apps = { .socket = -1, }; +static int wait_poll_fallback; + extern void ltt_ring_buffer_client_overwrite_init(void); extern void ltt_ring_buffer_client_discard_init(void); extern void ltt_ring_buffer_metadata_client_init(void); @@ -177,18 +182,18 @@ int register_app_to_sessiond(int socket) return -errno; } - ret = lttcomm_send_unix_sock(socket, ®_msg, sizeof(reg_msg)); + ret = ustcomm_send_unix_sock(socket, ®_msg, sizeof(reg_msg)); if (ret >= 0 && ret != sizeof(reg_msg)) return -EIO; return ret; } static -int send_reply(int sock, struct lttcomm_ust_reply *lur) +int send_reply(int sock, struct ustcomm_ust_reply *lur) { ssize_t len; - len = lttcomm_send_unix_sock(sock, lur, sizeof(*lur)); + len = ustcomm_send_unix_sock(sock, lur, sizeof(*lur)); switch (len) { case sizeof(*lur): DBG("message successfully sent"); @@ -213,6 +218,9 @@ int handle_register_done(struct sock_info *sock_info) if (sock_info->constructor_sem_posted) return 0; sock_info->constructor_sem_posted = 1; + if (uatomic_read(&sem_count) <= 0) { + return 0; + } ret = uatomic_add_return(&sem_count, -1); if (ret == 0) { ret = sem_post(&constructor_wait); @@ -223,11 +231,12 @@ int handle_register_done(struct sock_info *sock_info) static int handle_message(struct sock_info *sock_info, - int sock, struct lttcomm_ust_msg *lum) + int sock, struct ustcomm_ust_msg *lum) { int ret = 0; - const struct objd_ops *ops; - struct lttcomm_ust_reply lur; + const struct lttng_ust_objd_ops *ops; + struct ustcomm_ust_reply lur; + int shm_fd, wait_fd; ust_lock(); @@ -255,7 +264,7 @@ int handle_message(struct sock_info *sock_info, if (lum->handle == LTTNG_UST_ROOT_HANDLE) ret = -EPERM; else - ret = objd_unref(lum->handle); + ret = lttng_ust_objd_unref(lum->handle); break; default: if (ops->cmd) @@ -271,12 +280,58 @@ end: lur.cmd = lum->cmd; lur.ret_val = ret; if (ret >= 0) { - lur.ret_code = LTTCOMM_OK; + lur.ret_code = USTCOMM_OK; } else { - lur.ret_code = LTTCOMM_SESSION_FAIL; + //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; } ret = send_reply(sock, &lur); + if (ret < 0) { + perror("error sending reply"); + goto error; + } + if ((lum->cmd == LTTNG_UST_STREAM + || lum->cmd == LTTNG_UST_CHANNEL + || lum->cmd == LTTNG_UST_METADATA) + && lur.ret_code == USTCOMM_OK) { + /* 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; + } + ret = ustcomm_send_fds_unix_sock(sock, + &wait_fd, &wait_fd, + 1, sizeof(int)); + if (ret < 0) { + perror("send wait_fd"); + goto error; + } + } +error: ust_unlock(); return ret; } @@ -294,7 +349,7 @@ void cleanup_sock_info(struct sock_info *sock_info) sock_info->socket = -1; } if (sock_info->root_handle != -1) { - ret = objd_unref(sock_info->root_handle); + ret = lttng_ust_objd_unref(sock_info->root_handle); if (ret) { ERR("Error unref root handle"); } @@ -311,48 +366,35 @@ void cleanup_sock_info(struct sock_info *sock_info) } /* - * Using fork to set umask to 0777 in the child process (not - * multi-thread safe). + * Using fork to set umask in the child process (not multi-thread safe). + * We deal with the shm_open vs ftruncate race (happening when the + * sessiond owns the shm and does not let everybody modify it, to ensure + * safety against shm_unlink) by simply letting the mmap fail and + * retrying after a few seconds. + * For global shm, everybody has rw access to it until the sessiond + * starts. */ static int get_wait_shm(struct sock_info *sock_info, size_t mmap_size) { int wait_shm_fd, ret; - int read_mode; pid_t pid; /* - * At this point, we should be able to open it for - * reading. If it fails, then it's because there is - * something wrong: bail out in that case. - */ - read_mode = S_IRUSR | S_IRGRP; - if (sock_info->global) - read_mode |= S_IROTH; - - /* - * Try to open read-only. If it is set read-only, it - * means the shm size has been already set with - * ftruncate. Note: all processes creating shm need to - * call ftruncate on the shm before restricting its - * access rights to read-only. The shm should never be - * unlinked. It a rogue process try to create a non-accessible - * shm or to unlink it, the worse-case scenario is that we don't - * use the shm wakeup method and sleep/retry instead. + * Try to open read-only. */ - wait_shm_fd = shm_open(sock_info->wait_shm_path, - O_RDONLY, read_mode); + wait_shm_fd = shm_open(sock_info->wait_shm_path, O_RDONLY, 0); if (wait_shm_fd >= 0) { goto end; } else if (wait_shm_fd < 0 && errno != ENOENT) { /* - * Real-only open did not work. It's a failure - * that prohibits using shm. + * Real-only open did not work, and it's not because the + * entry was not present. It's a failure that prohibits + * using shm. */ ERR("Error opening shm %s", sock_info->wait_shm_path); goto end; } - /* * If the open failed because the file did not exist, try * creating it ourself. @@ -373,8 +415,7 @@ int get_wait_shm(struct sock_info *sock_info, size_t mmap_size) /* * Try to open read-only again after creation. */ - wait_shm_fd = shm_open(sock_info->wait_shm_path, - O_RDONLY, read_mode); + wait_shm_fd = shm_open(sock_info->wait_shm_path, O_RDONLY, 0); if (wait_shm_fd < 0) { /* * Real-only open did not work. It's a failure @@ -388,21 +429,18 @@ int get_wait_shm(struct sock_info *sock_info, size_t mmap_size) int create_mode; /* Child */ - create_mode = S_IRUSR | S_IRGRP | S_IWUSR | S_IWGRP; + create_mode = S_IRUSR | S_IWUSR | S_IRGRP; if (sock_info->global) - create_mode |= S_IROTH | S_IWOTH; + create_mode |= S_IROTH | S_IWGRP | S_IWOTH; /* * We're alone in a child process, so we can modify the * process-wide umask. */ - umask(create_mode); + umask(~create_mode); /* - * First try creating shm (or get rw access). We need to start - * by this because of the ftruncate vs concurrent map race. - * We need to give write access to everyone because of the - * ftruncate vs mmap race too. We don't do an exclusive - * open, because we allow other processes to - * create+ftruncate it concurrently. + * Try creating shm (or get rw access). + * We don't do an exclusive open, because we allow other + * processes to create+ftruncate it concurrently. */ wait_shm_fd = shm_open(sock_info->wait_shm_path, O_RDWR | O_CREAT, create_mode); @@ -412,28 +450,55 @@ int get_wait_shm(struct sock_info *sock_info, size_t mmap_size) PERROR("ftruncate"); exit(EXIT_FAILURE); } - ret = fchmod(wait_shm_fd, read_mode); - if (ret) { - PERROR("fchmod"); - exit(EXIT_FAILURE); - } exit(EXIT_SUCCESS); } - if (errno != EACCES) { + /* + * For local shm, we need to have rw access to accept + * opening it: this means the local sessiond will be + * able to wake us up. For global shm, we open it even + * if rw access is not granted, because the root.root + * sessiond will be able to override all rights and wake + * us up. + */ + if (!sock_info->global && errno != EACCES) { ERR("Error opening shm %s", sock_info->wait_shm_path); exit(EXIT_FAILURE); } /* - * The shm exists, but we cannot open it RW. It means it - * has already been setup and ftruncated, so we can - * let the child exit. + * The shm exists, but we cannot open it RW. Report + * success. */ exit(EXIT_SUCCESS); } else { return -1; } end: + if (wait_shm_fd >= 0 && !sock_info->global) { + struct stat statbuf; + + /* + * Ensure that our user is the owner of the shm file for + * local shm. If we do not own the file, it means our + * sessiond will not have access to wake us up (there is + * probably a rogue process trying to fake our + * sessiond). Fallback to polling method in this case. + */ + ret = fstat(wait_shm_fd, &statbuf); + if (ret) { + PERROR("fstat"); + goto error_close; + } + if (statbuf.st_uid != getuid()) + goto error_close; + } return wait_shm_fd; + +error_close: + ret = close(wait_shm_fd); + if (ret) { + PERROR("Error closing fd"); + } + return -1; } static @@ -449,14 +514,14 @@ char *get_map_shm(struct sock_info *sock_info) } wait_shm_mmap = mmap(NULL, mmap_size, PROT_READ, MAP_SHARED, wait_shm_fd, 0); - if (wait_shm_mmap == MAP_FAILED) { - PERROR("mmap"); - goto error; - } /* close shm fd immediately after taking the mmap reference */ ret = close(wait_shm_fd); if (ret) { - ERR("Error closing fd"); + PERROR("Error closing fd"); + } + if (wait_shm_mmap == MAP_FAILED) { + DBG("mmap error (can be caused by race with sessiond). Fallback to poll mode."); + goto error; } return wait_shm_mmap; @@ -467,10 +532,15 @@ error: static void wait_for_sessiond(struct sock_info *sock_info) { + int ret; + ust_lock(); if (lttng_ust_comm_should_quit) { goto quit; } + if (wait_poll_fallback) { + goto error; + } if (!sock_info->wait_shm_mmap) { sock_info->wait_shm_mmap = get_map_shm(sock_info); if (!sock_info->wait_shm_mmap) @@ -479,9 +549,23 @@ void wait_for_sessiond(struct sock_info *sock_info) ust_unlock(); DBG("Waiting for %s apps sessiond", sock_info->name); - /* Wait for futex wakeup TODO */ - sleep(5); - + /* Wait for futex wakeup */ + if (uatomic_read((int32_t *) sock_info->wait_shm_mmap) == 0) { + ret = futex_async((int32_t *) sock_info->wait_shm_mmap, + FUTEX_WAIT, 0, NULL, NULL, 0); + if (ret < 0) { + if (errno == EFAULT) { + wait_poll_fallback = 1; + WARN( +"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."); + } + PERROR("futex"); + } + } return; quit: @@ -490,8 +574,6 @@ quit: error: ust_unlock(); - /* Error handling: fallback on a 5 seconds sleep. */ - sleep(5); return; } @@ -506,10 +588,25 @@ static void *ust_listener_thread(void *arg) { struct sock_info *sock_info = arg; - int sock, ret; + int sock, ret, prev_connect_failed = 0, has_waited = 0; /* Restart trying to connect to the session daemon */ restart: + if (prev_connect_failed) { + /* Wait for sessiond availability with pipe */ + wait_for_sessiond(sock_info); + if (has_waited) { + has_waited = 0; + /* + * Sleep for 5 seconds before retrying after a + * sequence of failure / wait / failure. This + * deals with a killed or broken session daemon. + */ + sleep(5); + } + has_waited = 1; + prev_connect_failed = 0; + } ust_lock(); if (lttng_ust_comm_should_quit) { @@ -526,9 +623,10 @@ restart: } /* Register */ - ret = lttcomm_connect_unix_sock(sock_info->sock_path); + ret = ustcomm_connect_unix_sock(sock_info->sock_path); if (ret < 0) { ERR("Error connecting to %s apps socket", sock_info->name); + prev_connect_failed = 1; /* * If we cannot find the sessiond daemon, don't delay * constructor execution. @@ -536,9 +634,6 @@ restart: ret = handle_register_done(sock_info); assert(!ret); ust_unlock(); - - /* Wait for sessiond availability with pipe */ - wait_for_sessiond(sock_info); goto restart; } @@ -550,7 +645,7 @@ restart: */ if (sock_info->root_handle == -1) { ret = lttng_abi_create_root_handle(); - if (ret) { + if (ret < 0) { ERR("Error creating root handle"); ust_unlock(); goto quit; @@ -561,6 +656,7 @@ restart: ret = register_app_to_sessiond(sock); if (ret < 0) { ERR("Error registering to %s apps socket", sock_info->name); + prev_connect_failed = 1; /* * If we cannot register to the sessiond daemon, don't * delay constructor execution. @@ -568,16 +664,15 @@ restart: ret = handle_register_done(sock_info); assert(!ret); ust_unlock(); - wait_for_sessiond(sock_info); goto restart; } ust_unlock(); for (;;) { ssize_t len; - struct lttcomm_ust_msg lum; + struct ustcomm_ust_msg lum; - len = lttcomm_recv_unix_sock(sock, &lum, sizeof(lum)); + len = ustcomm_recv_unix_sock(sock, &lum, sizeof(lum)); switch (len) { case 0: /* orderly shutdown */ DBG("%s ltt-sessiond has performed an orderly shutdown\n", sock_info->name); @@ -724,7 +819,7 @@ void lttng_ust_cleanup(int exiting) cleanup_sock_info(&local_apps); } lttng_ust_abi_exit(); - ltt_events_exit(); + lttng_ust_events_exit(); ltt_ring_buffer_client_discard_exit(); ltt_ring_buffer_client_overwrite_exit(); ltt_ring_buffer_metadata_client_exit(); @@ -833,6 +928,7 @@ void ust_after_fork_child(ust_fork_info_t *fork_info) /* Release urcu mutexes */ rcu_bp_after_fork_child(); lttng_ust_cleanup(0); + lttng_context_vtid_reset(); /* Release mutexes and reenable signals */ ust_after_fork_common(fork_info); lttng_ust_init();