#include "lttng-tracer-core.h"
#include "compat.h"
#include "../libringbuffer/tlsfixup.h"
+#include "lttng-ust-baddr.h"
/*
* Has lttng ust comm constructor been called ?
char wait_shm_path[PATH_MAX];
char *wait_shm_mmap;
- struct lttng_session *session_enabled;
+ /* Keep track of lazy state dump not performed yet. */
+ int statedump_pending;
};
/* Socket from app (connect) to session daemon (listen) for communication */
.wait_shm_path = "/" LTTNG_UST_WAIT_FILENAME,
- .session_enabled = NULL,
+ .statedump_pending = 0,
};
/* TODO: allow global_apps_sock_path override */
.socket = -1,
.notify_socket = -1,
- .session_enabled = NULL,
+ .statedump_pending = 0,
};
static int wait_poll_fallback;
static const char *str_timeout;
static int got_timeout_env;
-static void *ust_baddr_handle;
extern void lttng_ring_buffer_client_overwrite_init(void);
extern void lttng_ring_buffer_client_overwrite_rt_init(void);
lttng_ust_obj_get_name(handle), handle);
}
-static
-void *lttng_ust_baddr_handle(void)
-{
- if (!ust_baddr_handle) {
- ust_baddr_handle = dlopen(
- "liblttng-ust-baddr.so.0", RTLD_NOW | RTLD_GLOBAL);
- if (ust_baddr_handle == NULL)
- ERR("%s", dlerror());
- }
- return ust_baddr_handle;
-}
-
-static
-int lttng_ust_baddr_statedump(struct lttng_session *session)
-{
- static
- int (*lttng_ust_baddr_init_fn)(struct lttng_session *);
-
- if (!lttng_ust_baddr_init_fn) {
- void *baddr_handle = lttng_ust_baddr_handle();
- if (baddr_handle) {
- lttng_ust_baddr_init_fn = dlsym(baddr_handle,
- "lttng_ust_baddr_statedump");
- if (lttng_ust_baddr_init_fn == NULL)
- ERR("%s", dlerror());
- }
- if (!lttng_ust_baddr_init_fn)
- return -1;
- }
-
- return lttng_ust_baddr_init_fn(session);
-}
-
static
int setup_local_apps(void)
{
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)
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;
}
ret = handle_message(sock_info, sock, &lum);
if (ret) {
ERR("Error handling message for %s socket", sock_info->name);
- } else {
- struct lttng_session *session =
- sock_info->session_enabled;
- if (session) {
- sock_info->session_enabled = NULL;
- lttng_ust_baddr_statedump(session);
- }
}
continue;
default:
* cleanup the threads if there are stalled in a syscall.
*/
lttng_ust_cleanup(1);
-
- if (ust_baddr_handle) {
- int ret = dlclose(ust_baddr_handle);
- if (ret)
- ERR("%s", dlerror());
- }
}
/*
lttng_ust_init();
}
-void lttng_ust_sockinfo_session_enabled(void *owner,
- struct lttng_session *session_enabled)
+void lttng_ust_sockinfo_session_enabled(void *owner)
{
struct sock_info *sock_info = owner;
- sock_info->session_enabled = session_enabled;
+ sock_info->statedump_pending = 1;
}