#include <signal.h>
#include <urcu/uatomic.h>
#include <urcu/futex.h>
+#include <urcu/compiler.h>
-#include <ust-comm.h>
#include <lttng/ust-events.h>
-#include <lttng/usterr-signal-safe.h>
#include <lttng/ust-abi.h>
-#include <lttng/tracepoint.h>
-#include <lttng/tracepoint-internal.h>
#include <lttng/ust.h>
+#include <ust-comm.h>
+#include <usterr-signal-safe.h>
+#include "tracepoint-internal.h"
#include "ltt-tracer-core.h"
/*
pid_t ppid;
uid_t uid;
gid_t gid;
+ uint32_t bits_per_long;
char name[16]; /* process name */
} reg_msg;
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");
const struct lttng_ust_objd_ops *ops;
struct ustcomm_ust_reply lur;
int shm_fd, wait_fd;
+ union ust_args args;
ust_lock();
default:
if (ops->cmd)
ret = ops->cmd(lum->handle, lum->cmd,
- (unsigned long) &lum->u);
+ (unsigned long) &lum->u,
+ &args);
else
ret = -ENOSYS;
break;
* 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;
+ 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 = lum->u.channel.memory_map_size;
- shm_fd = lum->u.channel.shm_fd;
- wait_fd = lum->u.channel.wait_fd;
+ 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_VERSION:
+ case LTTNG_UST_TRACER_VERSION:
lur.u.version = lum->u.version;
break;
case LTTNG_UST_TRACEPOINT_LIST_GET:
- memcpy(lur.u.tracepoint_list_entry,
- lum->u.tracepoint_list_entry,
- LTTNG_UST_SYM_NAME_LEN);
+ memcpy(&lur.u.tracepoint, &lum->u.tracepoint, sizeof(lur.u.tracepoint));
break;
}
ret = send_reply(sock, &lur);
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;
* 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;
}
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;
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");
}
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;
DBG("process %d", getpid());
ust_unlock();
/* Restore signals */
- ret = sigprocmask(SIG_SETMASK, &restore_sigset, NULL);
+ ret = sigprocmask(SIG_SETMASK, restore_sigset, NULL);
if (ret == -1) {
PERROR("sigprocmask");
}