X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fust-thread.c;h=b53b0724184043c5af42f630b4ae584d4ece7495;hp=85803e472217901a50eeec10e6ace02c3c426ca1;hb=971a61c658e35f7e2a71040455a273320b409636;hpb=6c71277b0dc97ce8a4ac6b8d359b4b349c04b658 diff --git a/src/bin/lttng-sessiond/ust-thread.c b/src/bin/lttng-sessiond/ust-thread.c index 85803e472..b53b07241 100644 --- a/src/bin/lttng-sessiond/ust-thread.c +++ b/src/bin/lttng-sessiond/ust-thread.c @@ -14,7 +14,8 @@ * this program; if not, write to the Free Software Foundation, Inc., 51 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#define _GNU_SOURCE + +#define _LGPL_SOURCE #include #include @@ -24,15 +25,26 @@ #include "lttng-sessiond.h" #include "ust-thread.h" #include "health-sessiond.h" +#include "testpoint.h" +#include "utils.h" +#include "thread.h" + +struct thread_notifiers { + struct lttng_pipe *quit_pipe; + int apps_cmd_notify_pipe_read_fd; +}; /* * This thread manage application notify communication. */ -void *ust_thread_manage_notify(void *data) +static void *thread_application_notification(void *data) { int i, ret, pollfd, err = -1; + ssize_t size_ret; uint32_t revents, nb_fd; struct lttng_poll_event events; + struct thread_notifiers *notifiers = data; + const int quit_pipe_read_fd = lttng_pipe_get_readfd(notifiers->quit_pipe); DBG("[ust-thread] Manage application notify command"); @@ -42,15 +54,26 @@ void *ust_thread_manage_notify(void *data) health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_MANAGE_NOTIFY); + if (testpoint(sessiond_thread_app_manage_notify)) { + goto error_testpoint; + } + health_code_update(); - ret = sessiond_set_thread_pollset(&events, 2); + ret = lttng_poll_create(&events, 2, LTTNG_CLOEXEC); if (ret < 0) { goto error_poll_create; } /* Add notify pipe to the pollset. */ - ret = lttng_poll_add(&events, apps_cmd_notify_pipe[0], LPOLLIN | LPOLLERR); + ret = lttng_poll_add(&events, notifiers->apps_cmd_notify_pipe_read_fd, + LPOLLIN | LPOLLERR | LPOLLHUP | LPOLLRDHUP); + if (ret < 0) { + goto error; + } + + ret = lttng_poll_add(&events, quit_pipe_read_fd, + LPOLLIN | LPOLLERR); if (ret < 0) { goto error; } @@ -58,13 +81,14 @@ void *ust_thread_manage_notify(void *data) health_code_update(); while (1) { - DBG3("[ust-thread] Manage notify polling on %d fds", - LTTNG_POLL_GETNB(&events)); + DBG3("[ust-thread] Manage notify polling"); /* Inifinite blocking call, waiting for transmission */ restart: health_poll_entry(); ret = lttng_poll_wait(&events, -1); + DBG3("[ust-thread] Manage notify return from poll on %d fds", + LTTNG_POLL_GETNB(&events)); health_poll_exit(); if (ret < 0) { /* @@ -85,57 +109,69 @@ restart: revents = LTTNG_POLL_GETEV(&events, i); pollfd = LTTNG_POLL_GETFD(&events, i); + if (!revents) { + /* No activity for this FD (poll implementation). */ + continue; + } + /* Thread quit pipe has been closed. Killing thread. */ - ret = sessiond_check_thread_quit_pipe(pollfd, revents); - if (ret) { + if (pollfd == quit_pipe_read_fd) { err = 0; goto exit; - } - - /* Inspect the apps cmd pipe */ - if (pollfd == apps_cmd_notify_pipe[0]) { + } else if (pollfd == notifiers->apps_cmd_notify_pipe_read_fd) { + /* Inspect the apps cmd pipe */ int sock; - if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) { - ERR("Apps notify command pipe error"); - goto error; - } else if (!(revents & LPOLLIN)) { - /* No POLLIN and not a catched error, stop the thread. */ - ERR("Notify command pipe failed. revent: %u", revents); - goto error; - } - - do { + if (revents & LPOLLIN) { /* Get socket from dispatch thread. */ - ret = read(apps_cmd_notify_pipe[0], &sock, sizeof(sock)); - } while (ret < 0 && errno == EINTR); - if (ret < 0 || ret < sizeof(sock)) { - PERROR("read apps notify pipe"); - goto error; - } - health_code_update(); + size_ret = lttng_read(notifiers->apps_cmd_notify_pipe_read_fd, + &sock, sizeof(sock)); + if (size_ret < sizeof(sock)) { + PERROR("read apps notify pipe"); + goto error; + } + health_code_update(); - ret = lttng_poll_add(&events, sock, - LPOLLIN | LPOLLERR | LPOLLHUP | LPOLLRDHUP); - if (ret < 0) { - /* - * It's possible we've reached the max poll fd allowed. - * Let's close the socket but continue normal execution. - */ - ret = close(sock); - if (ret) { - PERROR("close notify socket %d", sock); + ret = lttng_poll_add(&events, sock, + LPOLLIN | LPOLLERR | LPOLLHUP | LPOLLRDHUP); + if (ret < 0) { + /* + * It's possible we've reached the max poll fd allowed. + * Let's close the socket but continue normal execution. + */ + ret = close(sock); + if (ret) { + PERROR("close notify socket %d", sock); + } + lttng_fd_put(LTTNG_FD_APPS, 1); + continue; } - lttng_fd_put(LTTNG_FD_APPS, 1); - continue; + DBG3("UST thread notify added sock %d to pollset", sock); + } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) { + ERR("Apps notify command pipe error"); + goto error; + } else { + ERR("Unexpected poll events %u for sock %d", revents, pollfd); + goto error; } - DBG3("UST thread notify added sock %d to pollset", sock); } else { /* * At this point, we know that a registered application * triggered the event. */ - if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) { + if (revents & (LPOLLIN | LPOLLPRI)) { + ret = ust_app_recv_notify(pollfd); + if (ret < 0) { + /* Removing from the poll set */ + ret = lttng_poll_del(&events, pollfd); + if (ret < 0) { + goto error; + } + + /* The socket is closed after a grace period here. */ + ust_app_notify_sock_unregister(pollfd); + } + } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) { /* Removing from the poll set */ ret = lttng_poll_del(&events, pollfd); if (ret < 0) { @@ -144,22 +180,9 @@ restart: /* The socket is closed after a grace period here. */ ust_app_notify_sock_unregister(pollfd); - } else if (revents & (LPOLLIN | LPOLLPRI)) { - ret = ust_app_recv_notify(pollfd); - if (ret < 0) { - /* - * If the notification failed either the application is - * dead or an internal error happened. In both cases, - * we can only continue here. If the application is - * dead, an unregistration will follow or else the - * application will notice that we are not responding - * on that socket and will close it. - */ - continue; - } } else { - ERR("Unknown poll events %u for sock %d", revents, pollfd); - continue; + ERR("Unexpected poll events %u for sock %d", revents, pollfd); + goto error; } health_code_update(); } @@ -170,8 +193,8 @@ exit: error: lttng_poll_clean(&events); error_poll_create: - utils_close_pipe(apps_cmd_notify_pipe); - apps_cmd_notify_pipe[0] = apps_cmd_notify_pipe[1] = -1; +error_testpoint: + DBG("Application notify communication apps thread cleanup complete"); if (err) { health_error(); @@ -182,3 +205,52 @@ error_poll_create: rcu_unregister_thread(); return NULL; } + +static bool shutdown_application_notification_thread(void *data) +{ + struct thread_notifiers *notifiers = data; + const int write_fd = lttng_pipe_get_writefd(notifiers->quit_pipe); + + return notify_thread_pipe(write_fd) == 1; +} + +static void cleanup_application_notification_thread(void *data) +{ + struct thread_notifiers *notifiers = data; + + lttng_pipe_destroy(notifiers->quit_pipe); + free(notifiers); +} + +bool launch_application_notification_thread(int apps_cmd_notify_pipe_read_fd) +{ + struct lttng_thread *thread; + struct thread_notifiers *notifiers; + struct lttng_pipe *quit_pipe; + + notifiers = zmalloc(sizeof(*notifiers)); + if (!notifiers) { + goto error; + } + notifiers->apps_cmd_notify_pipe_read_fd = apps_cmd_notify_pipe_read_fd; + + quit_pipe = lttng_pipe_open(FD_CLOEXEC); + if (!quit_pipe) { + goto error; + } + notifiers->quit_pipe = quit_pipe; + + thread = lttng_thread_create("Application notification", + thread_application_notification, + shutdown_application_notification_thread, + cleanup_application_notification_thread, + notifiers); + if (!thread) { + goto error; + } + lttng_thread_put(thread); + return true; +error: + cleanup_application_notification_thread(notifiers); + return false; +}