* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#define _LGPL_SOURCE
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/prctl.h>
#include <assert.h>
#include <signal.h>
#include <urcu/uatomic.h>
+#include <urcu/futex.h>
#include <lttng-ust-comm.h>
+#include <ust/lttng-events.h>
#include <ust/usterr-signal-safe.h>
#include <ust/lttng-ust-abi.h>
#include <ust/tracepoint.h>
.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);
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");
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);
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();
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)
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;
}
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");
}
}
/*
- * 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.
/*
* 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
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);
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
}
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;
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)
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:
error:
ust_unlock();
- /* Error handling: fallback on a 5 seconds sleep. */
- sleep(5);
return;
}
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) {
}
/* 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.
ret = handle_register_done(sock_info);
assert(!ret);
ust_unlock();
-
- /* Wait for sessiond availability with pipe */
- wait_for_sessiond(sock_info);
goto 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;
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.
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);
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();
/* 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();
projects / lttng-ust.git / blobdiff