#include <lttng/ust-events.h>
#include <lttng/ust-abi.h>
#include <lttng/ust.h>
+#include <lttng/ust-error.h>
#include <ust-comm.h>
#include <usterr-signal-safe.h>
+#include <helper.h>
#include "tracepoint-internal.h"
-#include "ltt-tracer-core.h"
+#include "lttng-tracer-core.h"
#include "compat.h"
+#include "../libringbuffer/tlsfixup.h"
/*
* Has lttng ust comm constructor been called ?
*/
static int sem_count = { 2 };
+/*
+ * Counting nesting within lttng-ust. Used to ensure that calling fork()
+ * from liblttng-ust does not execute the pre/post fork handlers.
+ */
+static int __thread lttng_ust_nest_count;
+
/*
* Info about socket and associated listener thread.
*/
int constructor_sem_posted;
int allowed;
int global;
+ int thread_active;
char sock_path[PATH_MAX];
int socket;
.root_handle = -1,
.allowed = 1,
+ .thread_active = 0,
.sock_path = DEFAULT_GLOBAL_APPS_UNIX_SOCK,
.socket = -1,
.global = 0,
.root_handle = -1,
.allowed = 0, /* Check setuid bit first */
+ .thread_active = 0,
.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);
-extern void ltt_ring_buffer_client_overwrite_exit(void);
-extern void ltt_ring_buffer_client_discard_exit(void);
-extern void ltt_ring_buffer_metadata_client_exit(void);
+extern void lttng_ring_buffer_client_overwrite_init(void);
+extern void lttng_ring_buffer_client_discard_init(void);
+extern void lttng_ring_buffer_metadata_client_init(void);
+extern void lttng_ring_buffer_client_overwrite_exit(void);
+extern void lttng_ring_buffer_client_discard_exit(void);
+extern void lttng_ring_buffer_metadata_client_exit(void);
+
+/*
+ * Force a read (imply TLS fixup for dlopen) of TLS variables.
+ */
+static
+void lttng_fixup_nest_count_tls(void)
+{
+ asm volatile ("" : : "m" (lttng_ust_nest_count));
+}
static
int setup_local_apps(void)
* Disallow per-user tracing for setuid binaries.
*/
if (uid != geteuid()) {
- local_apps.allowed = 0;
+ assert(local_apps.allowed == 0);
return 0;
- } else {
- local_apps.allowed = 1;
}
home_dir = (const char *) getenv("HOME");
- if (!home_dir)
+ if (!home_dir) {
+ WARN("HOME environment variable not set. Disabling LTTng-UST per-user tracing.");
+ assert(local_apps.allowed == 0);
return -ENOENT;
+ }
+ local_apps.allowed = 1;
snprintf(local_apps.sock_path, PATH_MAX,
DEFAULT_HOME_APPS_UNIX_SOCK, home_dir);
snprintf(local_apps.wait_shm_path, PATH_MAX,
case sizeof(*lur):
DBG("message successfully sent");
return 0;
- case -1:
- if (errno == ECONNRESET) {
- printf("remote end closed connection\n");
+ default:
+ if (len == -ECONNRESET) {
+ DBG("remote end closed connection");
return 0;
}
- return -1;
- default:
- printf("incorrect message size: %zd\n", len);
- return -1;
+ if (len < 0)
+ return len;
+ DBG("incorrect message size: %zd", len);
+ return -EINVAL;
}
}
struct ustcomm_ust_reply lur;
int shm_fd, wait_fd;
union ust_args args;
+ ssize_t len;
ust_lock();
if (lum->handle == LTTNG_UST_ROOT_HANDLE)
ret = -EPERM;
else
- ret = lttng_ust_objd_unref(lum->handle);
+ ret = lttng_ust_objd_unref(lum->handle, 1);
break;
+ case LTTNG_UST_FILTER:
+ {
+ /* Receive filter data */
+ struct lttng_ust_filter_bytecode_node *bytecode;
+
+ if (lum->u.filter.data_size > FILTER_BYTECODE_MAX_LEN) {
+ ERR("Filter data size is too large: %u bytes",
+ lum->u.filter.data_size);
+ ret = -EINVAL;
+ goto error;
+ }
+
+ if (lum->u.filter.reloc_offset > lum->u.filter.data_size) {
+ ERR("Filter reloc offset %u is not within data",
+ lum->u.filter.reloc_offset);
+ ret = -EINVAL;
+ goto error;
+ }
+
+ bytecode = zmalloc(sizeof(*bytecode) + lum->u.filter.data_size);
+ if (!bytecode) {
+ ret = -ENOMEM;
+ goto error;
+ }
+ len = ustcomm_recv_unix_sock(sock, bytecode->bc.data,
+ lum->u.filter.data_size);
+ switch (len) {
+ case 0: /* orderly shutdown */
+ ret = 0;
+ free(bytecode);
+ goto error;
+ default:
+ if (len == lum->u.filter.data_size) {
+ DBG("filter data received");
+ break;
+ } else if (len < 0) {
+ DBG("Receive failed from lttng-sessiond with errno %d", (int) -len);
+ if (len == -ECONNRESET) {
+ ERR("%s remote end closed connection", sock_info->name);
+ ret = len;
+ free(bytecode);
+ goto error;
+ }
+ ret = len;
+ goto end;
+ } else {
+ DBG("incorrect filter data message size: %zd", len);
+ ret = -EINVAL;
+ free(bytecode);
+ goto end;
+ }
+ }
+ bytecode->bc.len = lum->u.filter.data_size;
+ bytecode->bc.reloc_offset = lum->u.filter.reloc_offset;
+ bytecode->bc.seqnum = lum->u.filter.seqnum;
+ if (ops->cmd) {
+ ret = ops->cmd(lum->handle, lum->cmd,
+ (unsigned long) bytecode,
+ &args, sock_info);
+ if (ret) {
+ free(bytecode);
+ }
+ /* don't free bytecode if everything went fine. */
+ } else {
+ ret = -ENOSYS;
+ free(bytecode);
+ }
+ break;
+ }
default:
if (ops->cmd)
ret = ops->cmd(lum->handle, lum->cmd,
(unsigned long) &lum->u,
- &args);
+ &args, sock_info);
else
ret = -ENOSYS;
break;
lur.cmd = lum->cmd;
lur.ret_val = ret;
if (ret >= 0) {
- lur.ret_code = USTCOMM_OK;
+ lur.ret_code = LTTNG_UST_OK;
} else {
- //lur.ret_code = USTCOMM_SESSION_FAIL;
- lur.ret_code = ret;
+ /*
+ * Use -LTTNG_UST_ERR as wildcard for UST internal
+ * error that are not caused by the transport, except if
+ * we already have a more precise error message to
+ * report.
+ */
+ if (ret > -LTTNG_UST_ERR) {
+ /* Translate code to UST error. */
+ switch (ret) {
+ case -EEXIST:
+ lur.ret_code = -LTTNG_UST_ERR_EXIST;
+ break;
+ case -EINVAL:
+ lur.ret_code = -LTTNG_UST_ERR_INVAL;
+ break;
+ case -ENOENT:
+ lur.ret_code = -LTTNG_UST_ERR_NOENT;
+ break;
+ case -EPERM:
+ lur.ret_code = -LTTNG_UST_ERR_PERM;
+ break;
+ case -ENOSYS:
+ lur.ret_code = -LTTNG_UST_ERR_NOSYS;
+ break;
+ default:
+ lur.ret_code = -LTTNG_UST_ERR;
+ break;
+ }
+ } else {
+ lur.ret_code = ret;
+ }
}
if (ret >= 0) {
switch (lum->cmd) {
}
ret = send_reply(sock, &lur);
if (ret < 0) {
- perror("error sending reply");
+ DBG("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) {
+ && lur.ret_code == LTTNG_UST_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;
+ ERR("send shm_fd");
+ 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));
perror("send wait_fd");
goto error;
}
+ if (sendret) {
+ ret = sendret;
+ goto error;
+ }
+ }
+ /*
+ * LTTNG_UST_TRACEPOINT_FIELD_LIST_GET needs to send the field
+ * after the reply.
+ */
+ if (lur.ret_code == LTTNG_UST_OK) {
+ switch (lum->cmd) {
+ case LTTNG_UST_TRACEPOINT_FIELD_LIST_GET:
+ len = ustcomm_send_unix_sock(sock,
+ &args.field_list.entry,
+ sizeof(args.field_list.entry));
+ if (len < 0) {
+ ret = len;
+ goto error;
+ }
+ if (len != sizeof(args.field_list.entry)) {
+ ret = -EINVAL;
+ goto error;
+ }
+ }
}
/*
* We still have the memory map reference, and the fds have been
* that we keep the write side of the wait_fd open, but close
* the read side.
*/
- if (lur.ret_code == USTCOMM_OK) {
+ if (lur.ret_code == LTTNG_UST_OK) {
switch (lum->cmd) {
case LTTNG_UST_STREAM:
if (shm_fd >= 0) {
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");
}
sock_info->socket = -1;
}
if (sock_info->root_handle != -1) {
- ret = lttng_ust_objd_unref(sock_info->root_handle);
+ ret = lttng_ust_objd_unref(sock_info->root_handle, 1);
if (ret) {
ERR("Error unref root handle");
}
* If the open failed because the file did not exist, try
* creating it ourself.
*/
+ lttng_ust_nest_count++;
pid = fork();
+ lttng_ust_nest_count--;
if (pid > 0) {
int status;
ret = ftruncate(wait_shm_fd, mmap_size);
if (ret) {
PERROR("ftruncate");
- exit(EXIT_FAILURE);
+ _exit(EXIT_FAILURE);
}
- exit(EXIT_SUCCESS);
+ _exit(EXIT_SUCCESS);
}
/*
* For local shm, we need to have rw access to accept
*/
if (!sock_info->global && errno != EACCES) {
ERR("Error opening shm %s", sock_info->wait_shm_path);
- exit(EXIT_FAILURE);
+ _exit(EXIT_FAILURE);
}
/*
* The shm exists, but we cannot open it RW. Report
* success.
*/
- exit(EXIT_SUCCESS);
+ _exit(EXIT_SUCCESS);
} else {
return -1;
}
* This thread does not allocate any resource, except within
* handle_message, within mutex protection. This mutex protects against
* fork and exit.
- * The other moment it allocates resources is at socket connexion, which
+ * The other moment it allocates resources is at socket connection, which
* is also protected by the mutex.
*/
static
ust_lock();
if (lttng_ust_comm_should_quit) {
- ust_unlock();
goto quit;
}
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);
}
/*
* Create only one root handle per listener thread for the whole
- * process lifetime.
+ * process lifetime, so we ensure we get ID which is statically
+ * assigned to the root handle.
*/
if (sock_info->root_handle == -1) {
ret = lttng_abi_create_root_handle();
if (ret < 0) {
ERR("Error creating root handle");
- ust_unlock();
goto quit;
}
sock_info->root_handle = ret;
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);
+ DBG("%s lttng-sessiond has performed an orderly shutdown", sock_info->name);
ust_lock();
+ if (lttng_ust_comm_should_quit) {
+ goto quit;
+ }
/*
* Either sessiond has shutdown or refused us by closing the socket.
* In either case, we don't want to delay construction execution,
ust_unlock();
goto end;
case sizeof(lum):
- DBG("message received\n");
+ DBG("message received");
ret = handle_message(sock_info, sock, &lum);
- if (ret < 0) {
+ if (ret) {
ERR("Error handling message for %s socket", sock_info->name);
}
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);
+ default:
+ if (len < 0) {
+ DBG("Receive failed from lttng-sessiond with errno %d", (int) -len);
+ } else {
+ DBG("incorrect message size (%s socket): %zd", sock_info->name, len);
+ }
+ if (len == -ECONNRESET) {
+ DBG("%s remote end closed connection", sock_info->name);
goto end;
}
goto end;
- default:
- ERR("incorrect message size (%s socket): %zd\n", sock_info->name, len);
- continue;
}
}
end:
+ ust_lock();
+ if (lttng_ust_comm_should_quit) {
+ goto quit;
+ }
+ /* Cleanup socket handles before trying to reconnect */
+ lttng_ust_objd_table_owner_cleanup(sock_info);
+ ust_unlock();
goto restart; /* try to reconnect */
+
quit:
+ sock_info->thread_active = 0;
+ ust_unlock();
return NULL;
}
* sessiond monitoring thread: monitor presence of global and per-user
* sessiond by polling the application common named pipe.
*/
-/* TODO */
-
void __attribute__((constructor)) lttng_ust_init(void)
{
struct timespec constructor_timeout;
+ sigset_t sig_all_blocked, orig_parent_mask;
+ pthread_attr_t thread_attr;
int timeout_mode;
int ret;
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();
+ lttng_fixup_nest_count_tls();
+ lttng_fixup_procname_tls();
+
/*
* We want precise control over the order in which we construct
* our sub-libraries vs starting to receive commands from
*/
init_usterr();
init_tracepoint();
- ltt_ring_buffer_metadata_client_init();
- ltt_ring_buffer_client_overwrite_init();
- ltt_ring_buffer_client_discard_init();
+ lttng_ring_buffer_metadata_client_init();
+ lttng_ring_buffer_client_overwrite_init();
+ lttng_ring_buffer_client_discard_init();
timeout_mode = get_timeout(&constructor_timeout);
ret = setup_local_apps();
if (ret) {
- ERR("Error setting up to local apps");
+ DBG("local apps setup returned %d", ret);
}
- ret = pthread_create(&local_apps.ust_listener, NULL,
- ust_listener_thread, &local_apps);
+
+ /* A new thread created by pthread_create inherits the signal mask
+ * from the parent. To avoid any signal being received by the
+ * listener thread, we block all signals temporarily in the parent,
+ * while we create the listener thread.
+ */
+ sigfillset(&sig_all_blocked);
+ ret = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_parent_mask);
+ if (ret) {
+ ERR("pthread_sigmask: %s", strerror(ret));
+ }
+
+ ret = pthread_attr_init(&thread_attr);
+ if (ret) {
+ ERR("pthread_attr_init: %s", strerror(ret));
+ }
+ ret = pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
+ if (ret) {
+ ERR("pthread_attr_setdetachstate: %s", strerror(ret));
+ }
+
+ ust_lock();
+ ret = pthread_create(&global_apps.ust_listener, &thread_attr,
+ ust_listener_thread, &global_apps);
+ if (ret) {
+ ERR("pthread_create global: %s", strerror(ret));
+ }
+ global_apps.thread_active = 1;
+ ust_unlock();
if (local_apps.allowed) {
- ret = pthread_create(&global_apps.ust_listener, NULL,
- ust_listener_thread, &global_apps);
+ ust_lock();
+ ret = pthread_create(&local_apps.ust_listener, &thread_attr,
+ ust_listener_thread, &local_apps);
+ if (ret) {
+ ERR("pthread_create local: %s", strerror(ret));
+ }
+ local_apps.thread_active = 1;
+ ust_unlock();
} else {
handle_register_done(&local_apps);
}
+ ret = pthread_attr_destroy(&thread_attr);
+ if (ret) {
+ ERR("pthread_attr_destroy: %s", strerror(ret));
+ }
+
+ /* Restore original signal mask in parent */
+ ret = pthread_sigmask(SIG_SETMASK, &orig_parent_mask, NULL);
+ if (ret) {
+ ERR("pthread_sigmask: %s", strerror(ret));
+ }
switch (timeout_mode) {
case 1: /* timeout wait */
&constructor_timeout);
} while (ret < 0 && errno == EINTR);
if (ret < 0 && errno == ETIMEDOUT) {
- ERR("Timed out waiting for ltt-sessiond");
+ ERR("Timed out waiting for lttng-sessiond");
} else {
assert(!ret);
}
*/
lttng_ust_abi_exit();
lttng_ust_events_exit();
- ltt_ring_buffer_client_discard_exit();
- ltt_ring_buffer_client_overwrite_exit();
- ltt_ring_buffer_metadata_client_exit();
+ lttng_ring_buffer_client_discard_exit();
+ lttng_ring_buffer_client_overwrite_exit();
+ lttng_ring_buffer_metadata_client_exit();
exit_tracepoint();
if (!exiting) {
/* Reinitialize values for fork */
*/
ust_lock();
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");
+ if (global_apps.thread_active) {
+ ret = pthread_cancel(global_apps.ust_listener);
+ if (ret) {
+ ERR("Error cancelling global ust listener thread: %s",
+ strerror(ret));
+ } else {
+ global_apps.thread_active = 0;
+ }
}
- if (local_apps.allowed) {
+ if (local_apps.thread_active) {
ret = pthread_cancel(local_apps.ust_listener);
if (ret) {
- ERR("Error cancelling local ust listener thread");
+ ERR("Error cancelling local ust listener thread: %s",
+ strerror(ret));
+ } else {
+ local_apps.thread_active = 0;
}
}
+ ust_unlock();
+
/*
* Do NOT join threads: use of sys_futex makes it impossible to
* join the threads without using async-cancel, but async-cancel
sigset_t all_sigs;
int ret;
+ if (lttng_ust_nest_count)
+ return;
/* Disable signals */
sigfillset(&all_sigs);
ret = sigprocmask(SIG_BLOCK, &all_sigs, save_sigset);
void ust_after_fork_parent(sigset_t *restore_sigset)
{
+ if (lttng_ust_nest_count)
+ return;
DBG("process %d", getpid());
rcu_bp_after_fork_parent();
/* Release mutexes and reenable signals */
*/
void ust_after_fork_child(sigset_t *restore_sigset)
{
+ if (lttng_ust_nest_count)
+ return;
DBG("process %d", getpid());
/* Release urcu mutexes */
rcu_bp_after_fork_child();
projects / lttng-ust.git / blobdiff