X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=libust%2Flttng-ust-comm.c;h=a9f5797df671cc8af4ff5e2f01f4408ab0143360;hb=11ff9c7d186237bf04d14ca05b2071bc0f12cae3;hp=a41683a40ce85c68418a77764ef62f75582b89c3;hpb=a4be89629a02fb95790eecf786c7f3b720c03a8e;p=lttng-ust.git diff --git a/libust/lttng-ust-comm.c b/libust/lttng-ust-comm.c index a41683a4..a9f5797d 100644 --- a/libust/lttng-ust-comm.c +++ b/libust/lttng-ust-comm.c @@ -27,6 +27,8 @@ #include #include #include +#include +#include #include /* @@ -38,25 +40,43 @@ static pthread_mutex_t lttng_ust_comm_mutex = PTHREAD_MUTEX_INITIALIZER; /* Should the ust comm thread quit ? */ static int lttng_ust_comm_should_quit; +/* + * Wait for either of these before continuing to the main + * program: + * - the register_done message from sessiond daemon + * (will let the sessiond daemon enable sessions before main + * starts.) + * - sessiond daemon is not reachable. + * - timeout (ensuring applications are resilient to session + * daemon problems). + */ +static sem_t constructor_wait; + /* * Info about socket and associated listener thread. */ struct sock_info { + const char *name; char sock_path[PATH_MAX]; int socket; pthread_t ust_listener; /* listener thread */ + int root_handle; }; /* Socket from app (connect) to session daemon (listen) for communication */ struct sock_info global_apps = { + .name = "global", .sock_path = DEFAULT_GLOBAL_APPS_UNIX_SOCK, .socket = -1, + .root_handle = -1, }; /* TODO: allow global_apps_sock_path override */ struct sock_info local_apps = { + .name = "local", .socket = -1, + .root_handle = -1, }; static @@ -117,62 +137,96 @@ int send_reply(int sock, struct lttcomm_ust_reply *lur) } static -int handle_message(int sock, struct lttcomm_ust_msg *lum) +int handle_register_done(void) +{ + int ret; + + ret = sem_post(&constructor_wait); + assert(!ret); + return 0; +} + +static +int handle_message(struct sock_info *sock_info, + int sock, struct lttcomm_ust_msg *lum) { int ret = 0; + const struct objd_ops *ops; + struct lttcomm_ust_reply lur; pthread_mutex_lock(<tng_ust_comm_mutex); + memset(&lur, 0, sizeof(lur)); + if (lttng_ust_comm_should_quit) { - ret = 0; + ret = -EPERM; goto end; } - switch (lum->cmd_type) { - case UST_CREATE_SESSION: - { - struct lttcomm_ust_reply lur; - - DBG("Handling create session message"); - memset(&lur, 0, sizeof(lur)); - lur.cmd_type = UST_CREATE_SESSION; - ret = lttng_abi_create_session(); - if (ret >= 0) { - lur.ret_val = ret; - lur.ret_code = LTTCOMM_OK; - } else { - lur.ret_code = LTTCOMM_SESSION_FAIL; - } - ret = send_reply(sock, &lur); - break; + ops = objd_ops(lum->handle); + if (!ops) { + ret = -ENOENT; + goto end; } - case UST_RELEASE: - { - struct lttcomm_ust_reply lur; - - DBG("Handling release message, handle: %d", - lum->handle); - memset(&lur, 0, sizeof(lur)); - lur.cmd_type = UST_RELEASE; - ret = objd_unref(lum->handle); - if (!ret) { - lur.ret_code = LTTCOMM_OK; - } else { - lur.ret_code = LTTCOMM_ERR; - } - ret = send_reply(sock, &lur); + + switch (lum->cmd) { + case LTTNG_UST_REGISTER_DONE: + if (lum->handle == LTTNG_UST_ROOT_HANDLE) + ret = handle_register_done(); + else + ret = -EINVAL; + break; + case LTTNG_UST_RELEASE: + if (lum->handle == LTTNG_UST_ROOT_HANDLE) + ret = -EPERM; + else + ret = objd_unref(lum->handle); break; - } default: - ERR("Unimplemented command %d", (int) lum->cmd_type); - ret = -1; - goto end; + if (ops->cmd) + ret = ops->cmd(lum->handle, lum->cmd, + (unsigned long) &lum->u); + else + ret = -ENOSYS; + break; } + end: + lur.handle = lum->handle; + lur.cmd = lum->cmd; + lur.ret_val = ret; + if (ret >= 0) { + lur.ret_code = LTTCOMM_OK; + } else { + lur.ret_code = LTTCOMM_SESSION_FAIL; + } + ret = send_reply(sock, &lur); + pthread_mutex_unlock(<tng_ust_comm_mutex); return ret; } +static +void cleanup_sock_info(struct sock_info *sock_info) +{ + int ret; + + if (sock_info->socket != -1) { + ret = close(sock_info->socket); + if (ret) { + ERR("Error closing local apps socket"); + } + sock_info->socket = -1; + } + if (sock_info->root_handle != -1) { + ret = objd_unref(sock_info->root_handle); + if (ret) { + ERR("Error unref root handle"); + } + sock_info->root_handle = -1; + } +} + /* * This thread does not allocate any resource, except within * handle_message, within mutex protection. This mutex protects against @@ -198,55 +252,83 @@ restart: if (sock_info->socket != -1) { ret = close(sock_info->socket); if (ret) { - ERR("Error closing local apps socket"); + ERR("Error closing %s apps socket", sock_info->name); } sock_info->socket = -1; } + /* Check for sessiond availability with pipe TODO */ /* Register */ ret = lttcomm_connect_unix_sock(sock_info->sock_path); if (ret < 0) { - ERR("Error connecting to global apps socket"); + ERR("Error connecting to %s apps socket", sock_info->name); + /* + * If we cannot find the sessiond daemon, don't delay + * constructor execution. + */ + ret = handle_register_done(); + assert(!ret); pthread_mutex_unlock(<tng_ust_comm_mutex); sleep(5); goto restart; - } else { - sock_info->socket = sock = ret; - pthread_mutex_unlock(<tng_ust_comm_mutex); + } + + sock_info->socket = sock = ret; + + /* + * Create only one root handle per listener thread for the whole + * process lifetime. + */ + if (sock_info->root_handle == -1) { + ret = lttng_abi_create_root_handle(); + if (ret) { + ERR("Error creating root handle"); + pthread_mutex_unlock(<tng_ust_comm_mutex); + goto quit; + } + sock_info->root_handle = ret; } ret = register_app_to_sessiond(sock); if (ret < 0) { - ERR("Error registering app to local apps socket"); + ERR("Error registering to %s apps socket", sock_info->name); + /* + * If we cannot register to the sessiond daemon, don't + * delay constructor execution. + */ + ret = handle_register_done(); + assert(!ret); + pthread_mutex_unlock(<tng_ust_comm_mutex); sleep(5); goto restart; } + pthread_mutex_unlock(<tng_ust_comm_mutex); + for (;;) { ssize_t len; struct lttcomm_ust_msg lum; - /* Receive session handle */ len = lttcomm_recv_unix_sock(sock, &lum, sizeof(lum)); switch (len) { case 0: /* orderly shutdown */ - DBG("ltt-sessiond has performed an orderly shutdown\n"); + DBG("%s ltt-sessiond has performed an orderly shutdown\n", sock_info->name); goto end; case sizeof(lum): DBG("message received\n"); - ret = handle_message(sock, &lum); + ret = handle_message(sock_info, sock, &lum); if (ret < 0) { - ERR("Error handling message\n"); + ERR("Error handling message for %s socket", sock_info->name); } continue; case -1: if (errno == ECONNRESET) { - ERR("remote end closed connection\n"); + ERR("%s remote end closed connection\n", sock_info->name); goto end; } goto end; default: - ERR("incorrect message size: %zd\n", len); + ERR("incorrect message size (%s socket): %zd\n", sock_info->name, len); continue; } @@ -257,6 +339,31 @@ quit: return NULL; } +static +int get_timeout(struct timespec *constructor_timeout) +{ + struct timespec constructor_delay = + { + .tv_sec = LTTNG_UST_DEFAULT_CONSTRUCTOR_TIMEOUT_S, + .tv_nsec = LTTNG_UST_DEFAULT_CONSTRUCTOR_TIMEOUT_NS, + }; + struct timespec realtime; + int ret; + + ret = clock_gettime(CLOCK_REALTIME, &realtime); + if (ret) + return ret; + + constructor_timeout->tv_sec = + realtime.tv_sec + constructor_delay.tv_sec; + constructor_timeout->tv_nsec = + constructor_delay.tv_nsec + realtime.tv_nsec; + if (constructor_timeout->tv_nsec >= 1000000000UL) { + constructor_timeout->tv_sec++; + constructor_timeout->tv_nsec -= 1000000000UL; + } + return 0; +} /* * sessiond monitoring thread: monitor presence of global and per-user @@ -266,20 +373,42 @@ quit: void __attribute__((constructor)) lttng_ust_comm_init(void) { + struct timespec constructor_timeout; int ret; init_usterr(); + ret = get_timeout(&constructor_timeout); + assert(!ret); + + ret = sem_init(&constructor_wait, 0, 2); + assert(!ret); + ret = setup_local_apps_socket(); if (ret) { ERR("Error setting up to local apps socket"); } -#if 0 + + /* + * Wait for the pthread cond to let us continue to main program + * execution. Hold mutex across thread creation, so we start + * waiting for the condition before the threads can signal its + * completion. + */ + pthread_mutex_lock(<tng_ust_comm_mutex); ret = pthread_create(&global_apps.ust_listener, NULL, ust_listener_thread, &global_apps); -#endif //0 ret = pthread_create(&local_apps.ust_listener, NULL, ust_listener_thread, &local_apps); + + ret = sem_timedwait(&constructor_wait, &constructor_timeout); + if (ret < 0 && errno == ETIMEDOUT) { + ERR("Timed out waiting for ltt-sessiond"); + } else { + assert(!ret); + } + pthread_mutex_unlock(<tng_ust_comm_mutex); + } void __attribute__((destructor)) lttng_ust_comm_exit(void) @@ -307,20 +436,15 @@ void __attribute__((destructor)) lttng_ust_comm_exit(void) ERR("Error cancelling global ust listener thread"); } #endif //0 - if (global_apps.socket != -1) { - ret = close(global_apps.socket); - assert(!ret); - } + + cleanup_sock_info(&global_apps); ret = pthread_cancel(local_apps.ust_listener); if (ret) { ERR("Error cancelling local ust listener thread"); } - if (local_apps.socket != -1) { - ret = close(local_apps.socket); - assert(!ret); - } + cleanup_sock_info(&local_apps); lttng_ust_abi_exit(); ltt_events_exit();