*/
static sem_t constructor_wait;
/*
- * Doing this for both the global and local sessiond.
+ * Doing this for the ust_app, global and local sessiond.
*/
enum {
- sem_count_initial_value = 4,
+ sem_count_initial_value = 6,
};
static int sem_count = sem_count_initial_value;
int root_handle;
int registration_done;
int allowed;
- int global;
+ bool multi_user;
int thread_active;
char sock_path[PATH_MAX];
int socket;
int notify_socket;
+ /*
+ * If wait_shm_is_file is true, use standard open to open and
+ * create the shared memory used for waiting on session daemon.
+ * Otherwise, use shm_open to create this file.
+ */
+ bool wait_shm_is_file;
char wait_shm_path[PATH_MAX];
char *wait_shm_mmap;
+
/* Keep track of lazy state dump not performed yet. */
int statedump_pending;
int initial_statedump_done;
};
/* Socket from app (connect) to session daemon (listen) for communication */
+static struct sock_info ust_app = {
+ .name = "ust_app",
+ .multi_user = true,
+
+ .root_handle = -1,
+ .registration_done = 0,
+ .allowed = 0,
+ .thread_active = 0,
+
+ .socket = -1,
+ .notify_socket = -1,
+
+ .wait_shm_is_file = true,
+
+ .statedump_pending = 0,
+ .initial_statedump_done = 0,
+ .procname[0] = '\0'
+};
+
+
static struct sock_info global_apps = {
.name = "global",
- .global = 1,
+ .multi_user = true,
.root_handle = -1,
.registration_done = 0,
.socket = -1,
.notify_socket = -1,
+ .wait_shm_is_file = false,
.wait_shm_path = "/" LTTNG_UST_WAIT_FILENAME,
.statedump_pending = 0,
.procname[0] = '\0'
};
-/* TODO: allow global_apps_sock_path override */
-
static struct sock_info local_apps = {
.name = "local",
- .global = 0,
+ .multi_user = false,
.root_handle = -1,
.registration_done = 0,
.allowed = 0, /* Check setuid bit first */
.socket = -1,
.notify_socket = -1,
+ .wait_shm_is_file = false,
+
.statedump_pending = 0,
.initial_statedump_done = 0,
.procname[0] = '\0'
return (const char *) lttng_ust_getenv("HOME");
}
+/*
+ * Returns the LTTNG_UST_APP_PATH path. If environment variable exists
+ * and contains a ':', the first path before the ':' separator is returned.
+ * The return value should be freed by the caller if it is not NULL.
+ */
+static
+char *get_lttng_ust_app_path(void)
+{
+ const char *env_val = lttng_ust_getenv("LTTNG_UST_APP_PATH");
+ char *val = NULL;
+ char *sep = NULL;
+ if (env_val == NULL)
+ goto error;
+ sep = strchr((char*)env_val, ':');
+ if (sep) {
+ /*
+ * Split into multiple paths using ':' as a separator.
+ * There is no escaping of the ':' separator.
+ */
+ WARN("':' separator in LTTNG_UST_APP_PATH, only the first path will be used.");
+ val = zmalloc(sep - env_val + 1);
+ if (!val) {
+ PERROR("zmalloc get_lttng_ust_app_path");
+ goto error;
+ }
+ memcpy(val, env_val, sep - env_val);
+ val[sep - env_val] = '\0';
+ } else {
+ val = strdup(env_val);
+ if (!val) {
+ PERROR("strdup");
+ goto error;
+ }
+ }
+
+error:
+ return val;
+}
+
/*
* Force a read (imply TLS allocation for dlopen) of TLS variables.
*/
static
void lttng_ust_nest_count_alloc_tls(void)
{
- asm volatile ("" : : "m" (URCU_TLS(lttng_ust_nest_count)));
+ __asm__ __volatile__ ("" : : "m" (URCU_TLS(lttng_ust_nest_count)));
}
static
void lttng_ust_mutex_nest_alloc_tls(void)
{
- asm volatile ("" : : "m" (URCU_TLS(ust_mutex_nest)));
+ __asm__ __volatile__ ("" : : "m" (URCU_TLS(ust_mutex_nest)));
}
/*
* this thread attempts to use them.
*/
lttng_ust_common_init_thread(LTTNG_UST_INIT_THREAD_MASK);
+
+ lttng_ust_urcu_register_thread();
}
int lttng_get_notify_socket(void *owner)
lttng_ust_obj_get_name(handle), handle);
}
+static
+int setup_ust_apps(void)
+{
+ char *ust_app_path = NULL;
+ int ret = 0;
+ uid_t uid;
+
+ assert(!ust_app.wait_shm_mmap);
+
+ uid = getuid();
+ /*
+ * Disallow ust apps tracing for setuid binaries, because we
+ * cannot use the environment variables anyway.
+ */
+ if (uid != geteuid()) {
+ DBG("UST app tracing disabled for setuid binary.");
+ assert(ust_app.allowed == 0);
+ ret = 0;
+ goto end;
+ }
+ ust_app_path = get_lttng_ust_app_path();
+ if (!ust_app_path) {
+ DBG("LTTNG_UST_APP_PATH environment variable not set.");
+ assert(ust_app.allowed == 0);
+ ret = -ENOENT;
+ goto end;
+ }
+ /*
+ * The LTTNG_UST_APP_PATH env. var. disables global and local
+ * sessiond connections.
+ */
+ ust_app.allowed = 1;
+ snprintf(ust_app.sock_path, PATH_MAX, "%s/%s",
+ ust_app_path, LTTNG_UST_SOCK_FILENAME);
+ snprintf(ust_app.wait_shm_path, PATH_MAX, "%s/%s",
+ ust_app_path,
+ LTTNG_UST_WAIT_FILENAME);
+
+ ust_app.wait_shm_mmap = get_map_shm(&ust_app);
+ if (!ust_app.wait_shm_mmap) {
+ WARN("Unable to get map shm for ust_app. Disabling LTTng-UST ust_app tracing.");
+ ust_app.allowed = 0;
+ ret = -EIO;
+ goto end;
+ }
+
+ lttng_pthread_getname_np(ust_app.procname, LTTNG_UST_CONTEXT_PROCNAME_LEN);
+end:
+ if (ust_app_path)
+ free(ust_app_path);
+ return ret;
+}
+
static
int setup_global_apps(void)
{
int ret = 0;
assert(!global_apps.wait_shm_mmap);
+ /*
+ * The LTTNG_UST_APP_PATH env. var. disables global sessiond
+ * connections.
+ */
+ if (ust_app.allowed)
+ return 0;
+
global_apps.wait_shm_mmap = get_map_shm(&global_apps);
if (!global_apps.wait_shm_mmap) {
WARN("Unable to get map shm for global apps. Disabling LTTng-UST global tracing.");
error:
return ret;
}
+
static
int setup_local_apps(void)
{
assert(!local_apps.wait_shm_mmap);
+ /*
+ * The LTTNG_UST_APP_PATH env. var. disables local sessiond
+ * connections.
+ */
+ if (ust_app.allowed)
+ return 0;
+
uid = getuid();
/*
* Disallow per-user tracing for setuid binaries.
}
}
+static
+int wait_shm_open(struct sock_info *sock_info, int flags, mode_t mode)
+{
+ if (sock_info->wait_shm_is_file)
+ return open(sock_info->wait_shm_path, flags, mode);
+ else
+ return shm_open(sock_info->wait_shm_path, flags, mode);
+}
+
/*
* Using fork to set umask in the child process (not multi-thread safe).
* We deal with the shm_open vs ftruncate race (happening when the
/*
* Try to open read-only.
*/
- wait_shm_fd = shm_open(sock_info->wait_shm_path, O_RDONLY, 0);
+ wait_shm_fd = wait_shm_open(sock_info, O_RDONLY, 0);
if (wait_shm_fd >= 0) {
int32_t tmp_read;
ssize_t len;
pid = fork();
URCU_TLS(lttng_ust_nest_count)--;
if (pid > 0) {
- int status;
+ int status, wait_ret;
/*
* Parent: wait for child to return, in which case the
* shared memory map will have been created.
*/
- pid = wait(&status);
- if (pid < 0 || !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+ wait_ret = waitpid(pid, &status, 0);
+ if (wait_ret < 0 || !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
wait_shm_fd = -1;
goto end;
}
/*
* Try to open read-only again after creation.
*/
- wait_shm_fd = shm_open(sock_info->wait_shm_path, O_RDONLY, 0);
+ wait_shm_fd = wait_shm_open(sock_info, O_RDONLY, 0);
if (wait_shm_fd < 0) {
/*
* Real-only open did not work. It's a failure
/* Child */
create_mode = S_IRUSR | S_IWUSR | S_IRGRP;
- if (sock_info->global)
+ if (sock_info->multi_user)
create_mode |= S_IROTH | S_IWGRP | S_IWOTH;
/*
* We're alone in a child process, so we can modify the
* We don't do an exclusive open, because we allow other
* processes to create+ftruncate it concurrently.
*/
- wait_shm_fd = shm_open(sock_info->wait_shm_path,
+ wait_shm_fd = wait_shm_open(sock_info,
O_RDWR | O_CREAT, create_mode);
if (wait_shm_fd >= 0) {
ret = ftruncate(wait_shm_fd, mmap_size);
* sessiond will be able to override all rights and wake
* us up.
*/
- if (!sock_info->global && errno != EACCES) {
+ if (!sock_info->multi_user && errno != EACCES) {
ERR("Error opening shm %s", sock_info->wait_shm_path);
_exit(EXIT_FAILURE);
}
return -1;
}
end:
- if (wait_shm_fd >= 0 && !sock_info->global) {
+ if (wait_shm_fd >= 0 && !sock_info->multi_user) {
struct stat statbuf;
/*
PERROR("sem_init");
}
+ ret = setup_ust_apps();
+ if (ret) {
+ assert(ust_app.allowed == 0);
+ DBG("ust_app setup returned %d", ret);
+ }
ret = setup_global_apps();
if (ret) {
assert(global_apps.allowed == 0);
ERR("pthread_attr_setdetachstate: %s", strerror(ret));
}
+ if (ust_app.allowed) {
+ pthread_mutex_lock(&ust_exit_mutex);
+ ret = pthread_create(&ust_app.ust_listener, &thread_attr,
+ ust_listener_thread, &ust_app);
+ if (ret) {
+ ERR("pthread_create ust_app: %s", strerror(ret));
+ }
+ ust_app.thread_active = 1;
+ pthread_mutex_unlock(&ust_exit_mutex);
+ } else {
+ handle_register_done(&ust_app);
+ }
+
if (global_apps.allowed) {
pthread_mutex_lock(&ust_exit_mutex);
ret = pthread_create(&global_apps.ust_listener, &thread_attr,
static
void lttng_ust_cleanup(int exiting)
{
+ cleanup_sock_info(&ust_app, exiting);
cleanup_sock_info(&global_apps, exiting);
cleanup_sock_info(&local_apps, exiting);
+ ust_app.allowed = 0;
local_apps.allowed = 0;
global_apps.allowed = 0;
/*
pthread_mutex_lock(&ust_exit_mutex);
/* cancel threads */
+ if (ust_app.thread_active) {
+ ret = pthread_cancel(ust_app.ust_listener);
+ if (ret) {
+ ERR("Error cancelling ust listener thread: %s",
+ strerror(ret));
+ } else {
+ ust_app.thread_active = 0;
+ }
+ }
if (global_apps.thread_active) {
ret = pthread_cancel(global_apps.ust_listener);
if (ret) {