#include <time.h>
#include <assert.h>
#include <signal.h>
+#include <dlfcn.h>
#include <urcu/uatomic.h>
#include <urcu/futex.h>
#include <urcu/compiler.h>
#include <lttng/ust.h>
#include <lttng/ust-error.h>
#include <lttng/ust-ctl.h>
+#include <urcu/tls-compat.h>
#include <ust-comm.h>
#include <usterr-signal-safe.h>
#include <helper.h>
#include "lttng-tracer-core.h"
#include "compat.h"
#include "../libringbuffer/tlsfixup.h"
+#include "lttng-ust-baddr.h"
/*
* Has lttng ust comm constructor been called ?
* The ust_lock/ust_unlock lock is used as a communication thread mutex.
* Held when handling a command, also held by fork() to deal with
* removal of threads, and by exit path.
+ *
+ * The UST lock is the centralized mutex across UST tracing control and
+ * probe registration.
+ *
+ * ust_exit_mutex must never nest in ust_mutex.
*/
+static pthread_mutex_t ust_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+/*
+ * ust_exit_mutex protects thread_active variable wrt thread exit. It
+ * cannot be done by ust_mutex because pthread_cancel(), which takes an
+ * internal libc lock, cannot nest within ust_mutex.
+ *
+ * It never nests within a ust_mutex.
+ */
+static pthread_mutex_t ust_exit_mutex = PTHREAD_MUTEX_INITIALIZER;
/* Should the ust comm thread quit ? */
static int lttng_ust_comm_should_quit;
+/*
+ * Return 0 on success, -1 if should quilt.
+ * The lock is taken in both cases.
+ */
+int ust_lock(void)
+{
+ pthread_mutex_lock(&ust_mutex);
+ if (lttng_ust_comm_should_quit) {
+ return -1;
+ } else {
+ return 0;
+ }
+}
+
+/*
+ * ust_lock_nocheck() can be used in constructors/destructors, because
+ * they are already nested within the dynamic loader lock, and therefore
+ * have exclusive access against execution of liblttng-ust destructor.
+ */
+void ust_lock_nocheck(void)
+{
+ pthread_mutex_lock(&ust_mutex);
+}
+
+void ust_unlock(void)
+{
+ pthread_mutex_unlock(&ust_mutex);
+}
+
/*
* Wait for either of these before continuing to the main
* program:
* 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;
+static DEFINE_URCU_TLS(int, lttng_ust_nest_count);
/*
* Info about socket and associated listener thread.
char sock_path[PATH_MAX];
int socket;
+ int notify_socket;
char wait_shm_path[PATH_MAX];
char *wait_shm_mmap;
+ /* Keep track of lazy state dump not performed yet. */
+ int statedump_pending;
};
/* Socket from app (connect) to session daemon (listen) for communication */
.allowed = 1,
.thread_active = 0,
- .sock_path = DEFAULT_GLOBAL_APPS_UNIX_SOCK,
+ .sock_path = LTTNG_DEFAULT_RUNDIR "/" LTTNG_UST_SOCK_FILENAME,
.socket = -1,
+ .notify_socket = -1,
- .wait_shm_path = DEFAULT_GLOBAL_APPS_WAIT_SHM_PATH,
+ .wait_shm_path = "/" LTTNG_UST_WAIT_FILENAME,
+
+ .statedump_pending = 0,
};
/* TODO: allow global_apps_sock_path override */
.thread_active = 0,
.socket = -1,
+ .notify_socket = -1,
+
+ .statedump_pending = 0,
};
static int wait_poll_fallback;
/* Event FD commands */
[ LTTNG_UST_FILTER ] = "Create Filter",
+ [ LTTNG_UST_EXCLUSION ] = "Add exclusions to event",
};
+static const char *str_timeout;
+static int got_timeout_env;
+
extern void lttng_ring_buffer_client_overwrite_init(void);
+extern void lttng_ring_buffer_client_overwrite_rt_init(void);
extern void lttng_ring_buffer_client_discard_init(void);
+extern void lttng_ring_buffer_client_discard_rt_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_overwrite_rt_exit(void);
extern void lttng_ring_buffer_client_discard_exit(void);
+extern void lttng_ring_buffer_client_discard_rt_exit(void);
extern void lttng_ring_buffer_metadata_client_exit(void);
+/*
+ * Returns the HOME directory path. Caller MUST NOT free(3) the returned
+ * pointer.
+ */
+static
+const char *get_lttng_home_dir(void)
+{
+ const char *val;
+
+ val = (const char *) getenv("LTTNG_HOME");
+ if (val != NULL) {
+ return val;
+ }
+ return (const char *) getenv("HOME");
+}
+
/*
* 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));
+ asm volatile ("" : : "m" (URCU_TLS(lttng_ust_nest_count)));
+}
+
+int lttng_get_notify_socket(void *owner)
+{
+ struct sock_info *info = owner;
+
+ return info->notify_socket;
}
static
{
const char *cmd_name = "Unknown";
- if (cmd_name_mapping[cmd]) {
+ if (cmd >= 0 && cmd < LTTNG_ARRAY_SIZE(cmd_name_mapping)
+ && cmd_name_mapping[cmd]) {
cmd_name = cmd_name_mapping[cmd];
}
- DBG("Message Received \"%s\", Handle \"%s\" (%d)", cmd_name,
+ DBG("Message Received \"%s\" (%d), Handle \"%s\" (%d)",
+ cmd_name, cmd,
lttng_ust_obj_get_name(handle), handle);
}
assert(local_apps.allowed == 0);
return 0;
}
- home_dir = (const char *) getenv("HOME");
+ home_dir = get_lttng_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,
- DEFAULT_HOME_APPS_WAIT_SHM_PATH, uid);
+ snprintf(local_apps.sock_path, PATH_MAX, "%s/%s/%s",
+ home_dir,
+ LTTNG_DEFAULT_HOME_RUNDIR,
+ LTTNG_UST_SOCK_FILENAME);
+ snprintf(local_apps.wait_shm_path, PATH_MAX, "/%s-%u",
+ LTTNG_UST_WAIT_FILENAME,
+ uid);
return 0;
}
+/*
+ * Get notify_sock timeout, in ms.
+ * -1: don't wait. 0: wait forever. >0: timeout, in ms.
+ */
static
-int register_app_to_sessiond(int socket)
+long get_timeout(void)
{
- ssize_t ret;
- struct {
- uint32_t major;
- uint32_t minor;
- pid_t pid;
- pid_t ppid;
- uid_t uid;
- gid_t gid;
- uint32_t bits_per_long;
- char name[16]; /* process name */
- } reg_msg;
-
- reg_msg.major = LTTNG_UST_COMM_VERSION_MAJOR;
- reg_msg.minor = LTTNG_UST_COMM_VERSION_MINOR;
- reg_msg.pid = getpid();
- reg_msg.ppid = getppid();
- reg_msg.uid = getuid();
- reg_msg.gid = getgid();
- reg_msg.bits_per_long = CAA_BITS_PER_LONG;
- lttng_ust_getprocname(reg_msg.name);
-
- ret = ustcomm_send_unix_sock(socket, ®_msg, sizeof(reg_msg));
- if (ret >= 0 && ret != sizeof(reg_msg))
- return -EIO;
- return ret;
+ long constructor_delay_ms = LTTNG_UST_DEFAULT_CONSTRUCTOR_TIMEOUT_MS;
+
+ if (!got_timeout_env) {
+ str_timeout = getenv("LTTNG_UST_REGISTER_TIMEOUT");
+ got_timeout_env = 1;
+ }
+ if (str_timeout)
+ constructor_delay_ms = strtol(str_timeout, NULL, 10);
+ return constructor_delay_ms;
+}
+
+static
+long get_notify_sock_timeout(void)
+{
+ return get_timeout();
+}
+
+/*
+ * Return values: -1: don't wait. 0: wait forever. 1: timeout wait.
+ */
+static
+int get_constructor_timeout(struct timespec *constructor_timeout)
+{
+ long constructor_delay_ms;
+ int ret;
+
+ constructor_delay_ms = get_timeout();
+
+ switch (constructor_delay_ms) {
+ case -1:/* fall-through */
+ case 0:
+ return constructor_delay_ms;
+ default:
+ break;
+ }
+
+ /*
+ * If we are unable to find the current time, don't wait.
+ */
+ ret = clock_gettime(CLOCK_REALTIME, constructor_timeout);
+ if (ret) {
+ return -1;
+ }
+ constructor_timeout->tv_sec += constructor_delay_ms / 1000UL;
+ constructor_timeout->tv_nsec +=
+ (constructor_delay_ms % 1000UL) * 1000000UL;
+ if (constructor_timeout->tv_nsec >= 1000000000UL) {
+ constructor_timeout->tv_sec++;
+ constructor_timeout->tv_nsec -= 1000000000UL;
+ }
+ return 1;
+}
+
+static
+int register_to_sessiond(int socket, enum ustctl_socket_type type)
+{
+ return ustcomm_send_reg_msg(socket,
+ type,
+ CAA_BITS_PER_LONG,
+ lttng_alignof(uint8_t) * CHAR_BIT,
+ lttng_alignof(uint16_t) * CHAR_BIT,
+ lttng_alignof(uint32_t) * CHAR_BIT,
+ lttng_alignof(uint64_t) * CHAR_BIT,
+ lttng_alignof(unsigned long) * CHAR_BIT);
}
static
return 0;
}
+/*
+ * Only execute pending statedump after the constructor semaphore has
+ * been posted by each listener thread. This means statedump will only
+ * be performed after the "registration done" command is received from
+ * each session daemon the application is connected to.
+ *
+ * This ensures we don't run into deadlock issues with the dynamic
+ * loader mutex, which is held while the constructor is called and
+ * waiting on the constructor semaphore. All operations requiring this
+ * dynamic loader lock need to be postponed using this mechanism.
+ */
+static
+void handle_pending_statedump(struct sock_info *sock_info)
+{
+ int ctor_passed = sock_info->constructor_sem_posted;
+
+ if (ctor_passed && sock_info->statedump_pending) {
+ sock_info->statedump_pending = 0;
+ lttng_handle_pending_statedump(sock_info);
+ }
+}
+
static
int handle_message(struct sock_info *sock_info,
int sock, struct ustcomm_ust_msg *lum)
union ust_args args;
ssize_t len;
- ust_lock();
-
memset(&lur, 0, sizeof(lur));
- if (lttng_ust_comm_should_quit) {
+ if (ust_lock()) {
ret = -LTTNG_UST_ERR_EXITING;
goto end;
}
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:
{
goto error;
}
ret = len;
+ free(bytecode);
goto end;
} else {
DBG("incorrect filter data message size: %zd", len);
}
break;
}
+ case LTTNG_UST_EXCLUSION:
+ {
+ /* Receive exclusion names */
+ struct lttng_ust_excluder_node *node;
+ unsigned int count;
+
+ count = lum->u.exclusion.count;
+ if (count == 0) {
+ /* There are no names to read */
+ ret = 0;
+ goto error;
+ }
+ node = zmalloc(sizeof(*node) +
+ count * LTTNG_UST_SYM_NAME_LEN);
+ if (!node) {
+ ret = -ENOMEM;
+ goto error;
+ }
+ node->excluder.count = count;
+ len = ustcomm_recv_unix_sock(sock, node->excluder.names,
+ count * LTTNG_UST_SYM_NAME_LEN);
+ switch (len) {
+ case 0: /* orderly shutdown */
+ ret = 0;
+ free(node);
+ goto error;
+ default:
+ if (len == count * LTTNG_UST_SYM_NAME_LEN) {
+ DBG("Exclusion 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(node);
+ goto error;
+ }
+ ret = len;
+ free(node);
+ goto end;
+ } else {
+ DBG("Incorrect exclusion data message size: %zd", len);
+ ret = -EINVAL;
+ free(node);
+ goto end;
+ }
+ }
+ if (ops->cmd) {
+ ret = ops->cmd(lum->handle, lum->cmd,
+ (unsigned long) node,
+ &args, sock_info);
+ if (ret) {
+ free(node);
+ }
+ /* Don't free exclusion data if everything went fine. */
+ } else {
+ ret = -ENOSYS;
+ free(node);
+ }
+ break;
+ }
case LTTNG_UST_CHANNEL:
{
void *chan_data;
+ int wakeup_fd;
len = ustcomm_recv_channel_from_sessiond(sock,
- &chan_data, lum->u.channel.len);
+ &chan_data, lum->u.channel.len,
+ &wakeup_fd);
switch (len) {
case 0: /* orderly shutdown */
ret = 0;
}
}
args.channel.chan_data = chan_data;
+ args.channel.wakeup_fd = wakeup_fd;
if (ops->cmd)
ret = ops->cmd(lum->handle, lum->cmd,
(unsigned long) &lum->u,
error:
ust_unlock();
+
+ /*
+ * Performed delayed statedump operations outside of the UST
+ * lock. We need to take the dynamic loader lock before we take
+ * the UST lock internally within handle_pending_statedump().
+ */
+ handle_pending_statedump(sock_info);
+
return ret;
}
{
int ret;
- if (sock_info->socket != -1) {
- 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");
}
sock_info->root_handle = -1;
}
sock_info->constructor_sem_posted = 0;
+
/*
- * wait_shm_mmap is used by listener threads outside of the
- * ust lock, so we cannot tear it down ourselves, because we
- * cannot join on these threads. Leave this task to the OS
+ * wait_shm_mmap, socket and notify socket are used by listener
+ * threads outside of the ust lock, so we cannot tear them down
+ * ourselves, because we cannot join on these threads. Leave
+ * responsibility of cleaning up these resources to the OS
* process exit.
*/
- if (!exiting && sock_info->wait_shm_mmap) {
+ if (exiting)
+ return;
+
+ if (sock_info->socket != -1) {
+ ret = ustcomm_close_unix_sock(sock_info->socket);
+ if (ret) {
+ ERR("Error closing ust cmd socket");
+ }
+ sock_info->socket = -1;
+ }
+ if (sock_info->notify_socket != -1) {
+ ret = ustcomm_close_unix_sock(sock_info->notify_socket);
+ if (ret) {
+ ERR("Error closing ust notify socket");
+ }
+ sock_info->notify_socket = -1;
+ }
+ if (sock_info->wait_shm_mmap) {
ret = munmap(sock_info->wait_shm_mmap, sysconf(_SC_PAGE_SIZE));
if (ret) {
ERR("Error unmapping wait shm");
*/
wait_shm_fd = shm_open(sock_info->wait_shm_path, O_RDONLY, 0);
if (wait_shm_fd >= 0) {
+ int32_t tmp_read;
+ ssize_t len;
+ size_t bytes_read = 0;
+
+ /*
+ * Try to read the fd. If unable to do so, try opening
+ * it in write mode.
+ */
+ do {
+ len = read(wait_shm_fd,
+ &((char *) &tmp_read)[bytes_read],
+ sizeof(tmp_read) - bytes_read);
+ if (len > 0) {
+ bytes_read += len;
+ }
+ } while ((len < 0 && errno == EINTR)
+ || (len > 0 && bytes_read < sizeof(tmp_read)));
+ if (bytes_read != sizeof(tmp_read)) {
+ ret = close(wait_shm_fd);
+ if (ret) {
+ ERR("close wait_shm_fd");
+ }
+ goto open_write;
+ }
goto end;
} else if (wait_shm_fd < 0 && errno != ENOENT) {
/*
ERR("Error opening shm %s", sock_info->wait_shm_path);
goto end;
}
+
+open_write:
/*
- * If the open failed because the file did not exist, try
- * creating it ourself.
+ * If the open failed because the file did not exist, or because
+ * the file was not truncated yet, try creating it ourself.
*/
- lttng_ust_nest_count++;
+ URCU_TLS(lttng_ust_nest_count)++;
pid = fork();
- lttng_ust_nest_count--;
+ URCU_TLS(lttng_ust_nest_count)--;
if (pid > 0) {
int status;
{
int ret;
- ust_lock();
- if (lttng_ust_comm_should_quit) {
+ if (ust_lock()) {
goto quit;
}
if (wait_poll_fallback) {
{
struct sock_info *sock_info = arg;
int sock, ret, prev_connect_failed = 0, has_waited = 0;
+ long timeout;
/* Restart trying to connect to the session daemon */
restart:
has_waited = 1;
prev_connect_failed = 0;
}
- ust_lock();
-
- if (lttng_ust_comm_should_quit) {
- goto quit;
- }
if (sock_info->socket != -1) {
ret = ustcomm_close_unix_sock(sock_info->socket);
if (ret) {
- ERR("Error closing %s apps socket", sock_info->name);
+ ERR("Error closing %s ust cmd socket",
+ sock_info->name);
}
sock_info->socket = -1;
}
+ if (sock_info->notify_socket != -1) {
+ ret = ustcomm_close_unix_sock(sock_info->notify_socket);
+ if (ret) {
+ ERR("Error closing %s ust notify socket",
+ sock_info->name);
+ }
+ sock_info->notify_socket = -1;
+ }
- /* Register */
+ /*
+ * Register. We need to perform both connect and sending
+ * registration message before doing the next connect otherwise
+ * we may reach unix socket connect queue max limits and block
+ * on the 2nd connect while the session daemon is awaiting the
+ * first connect registration message.
+ */
+ /* Connect cmd socket */
ret = ustcomm_connect_unix_sock(sock_info->sock_path);
if (ret < 0) {
DBG("Info: sessiond not accepting connections to %s apps socket", sock_info->name);
prev_connect_failed = 1;
+
+ if (ust_lock()) {
+ goto quit;
+ }
+
/*
* If we cannot find the sessiond daemon, don't delay
* constructor execution.
ust_unlock();
goto restart;
}
+ sock_info->socket = ret;
- sock_info->socket = sock = ret;
+ if (ust_lock()) {
+ goto quit;
+ }
/*
* Create only one root handle per listener thread for the whole
sock_info->root_handle = ret;
}
- ret = register_app_to_sessiond(sock);
+ ret = register_to_sessiond(sock_info->socket, USTCTL_SOCKET_CMD);
if (ret < 0) {
- ERR("Error registering to %s apps socket", sock_info->name);
+ ERR("Error registering to %s ust cmd socket",
+ sock_info->name);
prev_connect_failed = 1;
/*
* If we cannot register to the sessiond daemon, don't
ust_unlock();
goto restart;
}
+
+ ust_unlock();
+
+ /* Connect notify socket */
+ ret = ustcomm_connect_unix_sock(sock_info->sock_path);
+ if (ret < 0) {
+ DBG("Info: sessiond not accepting connections to %s apps socket", sock_info->name);
+ prev_connect_failed = 1;
+
+ if (ust_lock()) {
+ goto quit;
+ }
+
+ /*
+ * If we cannot find the sessiond daemon, don't delay
+ * constructor execution.
+ */
+ ret = handle_register_done(sock_info);
+ assert(!ret);
+ ust_unlock();
+ goto restart;
+ }
+ sock_info->notify_socket = ret;
+
+ timeout = get_notify_sock_timeout();
+ if (timeout >= 0) {
+ /*
+ * Give at least 10ms to sessiond to reply to
+ * notifications.
+ */
+ if (timeout < 10)
+ timeout = 10;
+ ret = ustcomm_setsockopt_rcv_timeout(sock_info->notify_socket,
+ timeout);
+ if (ret < 0) {
+ WARN("Error setting socket receive timeout");
+ }
+ ret = ustcomm_setsockopt_snd_timeout(sock_info->notify_socket,
+ timeout);
+ if (ret < 0) {
+ WARN("Error setting socket send timeout");
+ }
+ } else if (timeout < -1) {
+ WARN("Unsupported timeout value %ld", timeout);
+ }
+
+ if (ust_lock()) {
+ goto quit;
+ }
+
+ ret = register_to_sessiond(sock_info->notify_socket,
+ USTCTL_SOCKET_NOTIFY);
+ if (ret < 0) {
+ ERR("Error registering to %s ust notify 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();
+ goto restart;
+ }
+ sock = sock_info->socket;
+
ust_unlock();
for (;;) {
switch (len) {
case 0: /* orderly shutdown */
DBG("%s lttng-sessiond has performed an orderly shutdown", sock_info->name);
- ust_lock();
- if (lttng_ust_comm_should_quit) {
+ if (ust_lock()) {
goto quit;
}
/*
}
end:
- ust_lock();
- if (lttng_ust_comm_should_quit) {
+ if (ust_lock()) {
goto quit;
}
/* Cleanup socket handles before trying to reconnect */
goto restart; /* try to reconnect */
quit:
- sock_info->thread_active = 0;
ust_unlock();
- return NULL;
-}
-/*
- * Return values: -1: don't wait. 0: wait forever. 1: timeout wait.
- */
-static
-int get_timeout(struct timespec *constructor_timeout)
-{
- long constructor_delay_ms = LTTNG_UST_DEFAULT_CONSTRUCTOR_TIMEOUT_MS;
- char *str_delay;
- int ret;
-
- str_delay = getenv("LTTNG_UST_REGISTER_TIMEOUT");
- if (str_delay) {
- constructor_delay_ms = strtol(str_delay, NULL, 10);
- }
-
- switch (constructor_delay_ms) {
- case -1:/* fall-through */
- case 0:
- return constructor_delay_ms;
- default:
- break;
- }
-
- /*
- * If we are unable to find the current time, don't wait.
- */
- ret = clock_gettime(CLOCK_REALTIME, constructor_timeout);
- if (ret) {
- return -1;
- }
- constructor_timeout->tv_sec += constructor_delay_ms / 1000UL;
- constructor_timeout->tv_nsec +=
- (constructor_delay_ms % 1000UL) * 1000000UL;
- if (constructor_timeout->tv_nsec >= 1000000000UL) {
- constructor_timeout->tv_sec++;
- constructor_timeout->tv_nsec -= 1000000000UL;
- }
- return 1;
+ pthread_mutex_lock(&ust_exit_mutex);
+ sock_info->thread_active = 0;
+ pthread_mutex_unlock(&ust_exit_mutex);
+ return NULL;
}
/*
init_tracepoint();
lttng_ring_buffer_metadata_client_init();
lttng_ring_buffer_client_overwrite_init();
+ lttng_ring_buffer_client_overwrite_rt_init();
lttng_ring_buffer_client_discard_init();
+ lttng_ring_buffer_client_discard_rt_init();
+ lttng_context_init();
- timeout_mode = get_timeout(&constructor_timeout);
+ timeout_mode = get_constructor_timeout(&constructor_timeout);
ret = sem_init(&constructor_wait, 0, 0);
assert(!ret);
ERR("pthread_attr_setdetachstate: %s", strerror(ret));
}
- ust_lock();
+ ust_lock_nocheck();
ret = pthread_create(&global_apps.ust_listener, &thread_attr,
ust_listener_thread, &global_apps);
if (ret) {
ust_unlock();
if (local_apps.allowed) {
- ust_lock();
+ ust_lock_nocheck();
ret = pthread_create(&local_apps.ust_listener, &thread_attr,
ust_listener_thread, &local_apps);
if (ret) {
*/
lttng_ust_abi_exit();
lttng_ust_events_exit();
+ lttng_context_exit();
+ lttng_ring_buffer_client_discard_rt_exit();
lttng_ring_buffer_client_discard_exit();
+ lttng_ring_buffer_client_overwrite_rt_exit();
lttng_ring_buffer_client_overwrite_exit();
lttng_ring_buffer_metadata_client_exit();
exit_tracepoint();
* mutexes to ensure it is not in a mutex critical section when
* pthread_cancel is later called.
*/
- ust_lock();
+ ust_lock_nocheck();
lttng_ust_comm_should_quit = 1;
+ ust_unlock();
+ pthread_mutex_lock(&ust_exit_mutex);
/* cancel threads */
if (global_apps.thread_active) {
ret = pthread_cancel(global_apps.ust_listener);
local_apps.thread_active = 0;
}
}
- ust_unlock();
+ pthread_mutex_unlock(&ust_exit_mutex);
/*
* Do NOT join threads: use of sys_futex makes it impossible to
sigset_t all_sigs;
int ret;
- if (lttng_ust_nest_count)
+ if (URCU_TLS(lttng_ust_nest_count))
return;
/* Disable signals */
sigfillset(&all_sigs);
if (ret == -1) {
PERROR("sigprocmask");
}
- ust_lock();
+ ust_lock_nocheck();
rcu_bp_before_fork();
}
void ust_after_fork_parent(sigset_t *restore_sigset)
{
- if (lttng_ust_nest_count)
+ if (URCU_TLS(lttng_ust_nest_count))
return;
DBG("process %d", getpid());
rcu_bp_after_fork_parent();
*/
void ust_after_fork_child(sigset_t *restore_sigset)
{
- if (lttng_ust_nest_count)
+ if (URCU_TLS(lttng_ust_nest_count))
return;
DBG("process %d", getpid());
/* Release urcu mutexes */
ust_after_fork_common(restore_sigset);
lttng_ust_init();
}
+
+void lttng_ust_sockinfo_session_enabled(void *owner)
+{
+ struct sock_info *sock_info = owner;
+ sock_info->statedump_pending = 1;
+}
projects / lttng-ust.git / blobdiff