X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;ds=sidebyside;f=liblttng-ust%2Flttng-ust-comm.c;h=a1ebcbe6fc83564a5fc4d9c0c0642403938da35f;hb=000b86624a1b4a10fcef3f5b39598f57f2d9d6cd;hp=842876fb743c857cf519ff5161d8d333d639bd16;hpb=1879f67f1532fe1644a0657a5d52f063b43c0bf4;p=lttng-ust.git diff --git a/liblttng-ust/lttng-ust-comm.c b/liblttng-ust/lttng-ust-comm.c index 842876fb..a1ebcbe6 100644 --- a/liblttng-ust/lttng-ust-comm.c +++ b/liblttng-ust/lttng-ust-comm.c @@ -41,11 +41,14 @@ #include #include #include +#include +#include +#include #include #include #include #include "tracepoint-internal.h" -#include "ltt-tracer-core.h" +#include "lttng-tracer-core.h" #include "compat.h" #include "../libringbuffer/tlsfixup.h" @@ -83,7 +86,7 @@ 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; +static DEFINE_URCU_TLS(int, lttng_ust_nest_count); /* * Info about socket and associated listener thread. @@ -95,6 +98,7 @@ struct sock_info { int constructor_sem_posted; int allowed; int global; + int thread_active; char sock_path[PATH_MAX]; int socket; @@ -110,6 +114,7 @@ struct sock_info global_apps = { .root_handle = -1, .allowed = 1, + .thread_active = 0, .sock_path = DEFAULT_GLOBAL_APPS_UNIX_SOCK, .socket = -1, @@ -124,18 +129,54 @@ struct sock_info local_apps = { .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); +static const char *cmd_name_mapping[] = { + [ LTTNG_UST_RELEASE ] = "Release", + [ LTTNG_UST_SESSION ] = "Create Session", + [ LTTNG_UST_TRACER_VERSION ] = "Get Tracer Version", + + [ LTTNG_UST_TRACEPOINT_LIST ] = "Create Tracepoint List", + [ LTTNG_UST_WAIT_QUIESCENT ] = "Wait for Quiescent State", + [ LTTNG_UST_REGISTER_DONE ] = "Registration Done", + [ LTTNG_UST_TRACEPOINT_FIELD_LIST ] = "Create Tracepoint Field List", + + /* Session FD commands */ + [ LTTNG_UST_CHANNEL ] = "Create Channel", + [ LTTNG_UST_SESSION_START ] = "Start Session", + [ LTTNG_UST_SESSION_STOP ] = "Stop Session", + + /* Channel FD commands */ + [ LTTNG_UST_STREAM ] = "Create Stream", + [ LTTNG_UST_EVENT ] = "Create Event", + + /* Event and Channel FD commands */ + [ LTTNG_UST_CONTEXT ] = "Create Context", + [ LTTNG_UST_FLUSH_BUFFER ] = "Flush Buffer", + + /* Event, Channel and Session commands */ + [ LTTNG_UST_ENABLE ] = "Enable", + [ LTTNG_UST_DISABLE ] = "Disable", + + /* Tracepoint list commands */ + [ LTTNG_UST_TRACEPOINT_LIST_GET ] = "List Next Tracepoint", + [ LTTNG_UST_TRACEPOINT_FIELD_LIST_GET ] = "List Next Tracepoint Field", + + /* Event FD commands */ + [ LTTNG_UST_FILTER ] = "Create Filter", +}; + +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. @@ -143,7 +184,19 @@ extern void ltt_ring_buffer_metadata_client_exit(void); static void lttng_fixup_nest_count_tls(void) { - asm volatile ("" : : "m" (lttng_ust_nest_count)); + asm volatile ("" : : "m" (URCU_TLS(lttng_ust_nest_count))); +} + +static +void print_cmd(int cmd, int handle) +{ + const char *cmd_name = "Unknown"; + + if (cmd_name_mapping[cmd]) { + cmd_name = cmd_name_mapping[cmd]; + } + DBG("Message Received \"%s\", Handle \"%s\" (%d)", cmd_name, + lttng_ust_obj_get_name(handle), handle); } static @@ -157,14 +210,16 @@ 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, @@ -212,15 +267,15 @@ int send_reply(int sock, struct ustcomm_ust_reply *lur) 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; } } @@ -250,7 +305,6 @@ int handle_message(struct sock_info *sock_info, int ret = 0; const struct lttng_ust_objd_ops *ops; struct ustcomm_ust_reply lur; - int shm_fd, wait_fd; union ust_args args; ssize_t len; @@ -259,7 +313,7 @@ int handle_message(struct sock_info *sock_info, memset(&lur, 0, sizeof(lur)); if (lttng_ust_comm_should_quit) { - ret = -EPERM; + ret = -LTTNG_UST_ERR_EXITING; goto end; } @@ -285,53 +339,62 @@ int handle_message(struct sock_info *sock_info, case LTTNG_UST_FILTER: { /* Receive filter data */ - struct lttng_ust_filter_bytecode *bytecode; + 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\n", + 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->data, + 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; - 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); - ret = -EINVAL; - free(bytecode); - goto error; - } - ret = -EINVAL; - goto end; default: if (len == lum->u.filter.data_size) { - DBG("filter data received\n"); + 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 { - ERR("incorrect filter data message size: %zd\n", len); + DBG("incorrect filter data message size: %zd", len); ret = -EINVAL; free(bytecode); goto end; } } - bytecode->len = lum->u.filter.data_size; - bytecode->reloc_offset = lum->u.filter.reloc_offset; + 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); + &args, sock_info); if (ret) { free(bytecode); } @@ -342,11 +405,67 @@ int handle_message(struct sock_info *sock_info, } break; } + case LTTNG_UST_CHANNEL: + { + void *chan_data; + + len = ustcomm_recv_channel_from_sessiond(sock, + &chan_data, lum->u.channel.len); + switch (len) { + case 0: /* orderly shutdown */ + ret = 0; + goto error; + default: + if (len == lum->u.channel.len) { + DBG("channel 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; + goto error; + } + ret = len; + goto end; + } else { + DBG("incorrect channel data message size: %zd", len); + ret = -EINVAL; + goto end; + } + } + args.channel.chan_data = chan_data; + if (ops->cmd) + ret = ops->cmd(lum->handle, lum->cmd, + (unsigned long) &lum->u, + &args, sock_info); + else + ret = -ENOSYS; + break; + } + case LTTNG_UST_STREAM: + { + /* Receive shm_fd, wakeup_fd */ + ret = ustcomm_recv_stream_from_sessiond(sock, + &lum->u.stream.len, + &args.stream.shm_fd, + &args.stream.wakeup_fd); + if (ret) { + goto end; + } + if (ops->cmd) + ret = ops->cmd(lum->handle, lum->cmd, + (unsigned long) &lum->u, + &args, sock_info); + else + ret = -ENOSYS; + break; + } default: if (ops->cmd) ret = ops->cmd(lum->handle, lum->cmd, (unsigned long) &lum->u, - &args); + &args, sock_info); else ret = -ENOSYS; break; @@ -357,28 +476,42 @@ end: 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) { - case LTTNG_UST_STREAM: - /* - * Special-case reply to send stream info. - * Use lum.u output. - */ - lur.u.stream.memory_map_size = *args.stream.memory_map_size; - shm_fd = *args.stream.shm_fd; - wait_fd = *args.stream.wait_fd; - break; - case LTTNG_UST_METADATA: - case LTTNG_UST_CHANNEL: - lur.u.channel.memory_map_size = *args.channel.memory_map_size; - shm_fd = *args.channel.shm_fd; - wait_fd = *args.channel.wait_fd; - break; case LTTNG_UST_TRACER_VERSION: lur.u.version = lum->u.version; break; @@ -387,99 +520,31 @@ end: break; } } + DBG("Return value: %d", lur.ret_val); 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) { - 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"); - 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)); - if (ret < 0) { - 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 == 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 != sizeof(args.field_list.entry)) { - ret = -1; + if (len < 0) { + ret = len; goto error; } - } - } - /* - * We still have the memory map reference, and the fds have been - * sent to the sessiond. We can therefore close those fds. Note - * that we keep the write side of the wait_fd open, but close - * the read side. - */ - if (lur.ret_code == USTCOMM_OK) { - switch (lum->cmd) { - case LTTNG_UST_STREAM: - if (shm_fd >= 0) { - ret = close(shm_fd); - if (ret) { - PERROR("Error closing stream shm_fd"); - } - *args.stream.shm_fd = -1; - } - if (wait_fd >= 0) { - ret = close(wait_fd); - if (ret) { - PERROR("Error closing stream wait_fd"); - } - *args.stream.wait_fd = -1; - } - break; - case LTTNG_UST_METADATA: - case LTTNG_UST_CHANNEL: - if (shm_fd >= 0) { - ret = close(shm_fd); - if (ret) { - PERROR("Error closing channel shm_fd"); - } - *args.channel.shm_fd = -1; - } - if (wait_fd >= 0) { - ret = close(wait_fd); - if (ret) { - PERROR("Error closing channel wait_fd"); - } - *args.channel.wait_fd = -1; + if (len != sizeof(args.field_list.entry)) { + ret = -EINVAL; + goto error; } - break; } } @@ -557,9 +622,9 @@ int get_wait_shm(struct sock_info *sock_info, size_t mmap_size) * If the open failed because the file did not exist, 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; @@ -608,9 +673,9 @@ int get_wait_shm(struct sock_info *sock_info, size_t mmap_size) 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 @@ -622,13 +687,13 @@ int get_wait_shm(struct sock_info *sock_info, size_t mmap_size) */ 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; } @@ -771,7 +836,6 @@ restart: ust_lock(); if (lttng_ust_comm_should_quit) { - ust_unlock(); goto quit; } @@ -802,13 +866,13 @@ restart: /* * 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; @@ -836,8 +900,11 @@ restart: 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, @@ -853,28 +920,39 @@ restart: ust_unlock(); goto end; case sizeof(lum): - DBG("message received\n"); + print_cmd(lum.cmd, lum.handle); 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; } @@ -922,8 +1000,6 @@ int get_timeout(struct timespec *constructor_timeout) * 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; @@ -940,10 +1016,10 @@ void __attribute__((constructor)) lttng_ust_init(void) * 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 @@ -953,9 +1029,9 @@ void __attribute__((constructor)) lttng_ust_init(void) */ 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); @@ -964,7 +1040,7 @@ void __attribute__((constructor)) lttng_ust_init(void) 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 @@ -987,17 +1063,24 @@ void __attribute__((constructor)) lttng_ust_init(void) 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) { + 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); } @@ -1019,7 +1102,7 @@ void __attribute__((constructor)) lttng_ust_init(void) &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); } @@ -1051,9 +1134,9 @@ void lttng_ust_cleanup(int exiting) */ 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 */ @@ -1080,21 +1163,28 @@ void __attribute__((destructor)) lttng_ust_exit(void) */ 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: %s", - strerror(ret)); + 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: %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 @@ -1124,7 +1214,7 @@ void ust_before_fork(sigset_t *save_sigset) sigset_t all_sigs; int ret; - if (lttng_ust_nest_count) + if (URCU_TLS(lttng_ust_nest_count)) return; /* Disable signals */ sigfillset(&all_sigs); @@ -1151,7 +1241,7 @@ static void ust_after_fork_common(sigset_t *restore_sigset) 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(); @@ -1170,7 +1260,7 @@ void ust_after_fork_parent(sigset_t *restore_sigset) */ 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 */