#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 "compat.h"
* 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;
}
}
else
ret = lttng_ust_objd_unref(lum->handle);
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;
+ 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. */
&shm_fd, &shm_fd,
1, sizeof(int));
if (ret < 0) {
- perror("send shm_fd");
+ ERR("send shm_fd");
sendret = ret;
}
/*
* LTTNG_UST_TRACEPOINT_FIELD_LIST_GET needs to send the field
* after the reply.
*/
- if (lur.ret_code == USTCOMM_OK) {
+ 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 = -1;
+ ret = -EINVAL;
goto error;
}
}
* 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) {
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;
}
/*
* 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();
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 ltt-sessiond has performed an orderly shutdown", sock_info->name);
ust_lock();
/*
* Either sessiond has shutdown or refused us by closing the socket.
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();
+ /* Cleanup socket handles before trying to reconnect */
+ lttng_ust_objd_table_owner_cleanup(sock_info);
+ ust_unlock();
goto restart; /* try to reconnect */
quit:
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;
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
ret = setup_local_apps();
if (ret) {
- ERR("Error setting up to local apps");
+ DBG("local apps setup returned %d", ret);
}
/* A new thread created by pthread_create inherits the signal mask
ERR("pthread_sigmask: %s", strerror(ret));
}
- ret = pthread_create(&global_apps.ust_listener, NULL,
+ 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));
+ }
+
+ ret = pthread_create(&global_apps.ust_listener, &thread_attr,
ust_listener_thread, &global_apps);
if (ret) {
ERR("pthread_create global: %s", strerror(ret));
}
if (local_apps.allowed) {
- ret = pthread_create(&local_apps.ust_listener, NULL,
+ ret = pthread_create(&local_apps.ust_listener, &thread_attr,
ust_listener_thread, &local_apps);
if (ret) {
ERR("pthread_create local: %s", strerror(ret));
} 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);