* 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/usterr-signal-safe.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);
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);
int ret = 0;
const struct objd_ops *ops;
struct lttcomm_ust_reply lur;
+ int shm_fd, wait_fd;
ust_lock();
if (ret >= 0) {
lur.ret_code = LTTCOMM_OK;
} else {
- lur.ret_code = LTTCOMM_SESSION_FAIL;
+ //lur.ret_code = LTTCOMM_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_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;
}
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)
+ && lur.ret_code == LTTCOMM_OK) {
+ /* we also need to send the file descriptors. */
+ ret = lttcomm_send_fds_unix_sock(sock,
+ &shm_fd, &shm_fd,
+ 1, sizeof(int));
+ if (ret < 0) {
+ perror("send shm_fd");
+ goto error;
+ }
+ ret = lttcomm_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;
}
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;
+ ERR(
+"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) {
ret = lttcomm_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;
}
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();
projects / lttng-ust.git / blobdiff