2 * Copyright (C) 2011 EfficiOS Inc.
3 * Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
4 * Copyright (C) 2013 Jérémie Galarneau <jeremie.galarneau@efficios.com>
6 * SPDX-License-Identifier: GPL-2.0-only
10 #include "health-sessiond.hpp"
11 #include "manage-apps.hpp"
12 #include "testpoint.hpp"
19 struct thread_notifiers
{
20 struct lttng_pipe
*quit_pipe
;
21 int apps_cmd_pipe_read_fd
;
25 static void cleanup_application_management_thread(void *data
)
27 struct thread_notifiers
*notifiers
= (thread_notifiers
*) data
;
29 lttng_pipe_destroy(notifiers
->quit_pipe
);
34 * This thread receives application command sockets (FDs) on the
35 * apps_cmd_pipe and waits (polls) on them until they are closed
38 * At that point, it flushes the data (tracing and metadata) associated
39 * with this application and tears down ust app sessions and other
40 * associated data structures through ust_app_unregister_by_socket().
42 * Note that this thread never sends commands to the applications
43 * through the command sockets; it merely listens for hang-ups
44 * and errors on those sockets and cleans-up as they occur.
46 static void *thread_application_management(void *data
)
51 struct lttng_poll_event events
;
52 struct thread_notifiers
*notifiers
= (thread_notifiers
*) data
;
53 const auto thread_quit_pipe_fd
= lttng_pipe_get_readfd(notifiers
->quit_pipe
);
55 DBG("[thread] Manage application started");
57 rcu_register_thread();
60 health_register(the_health_sessiond
, HEALTH_SESSIOND_TYPE_APP_MANAGE
);
62 if (testpoint(sessiond_thread_manage_apps
)) {
68 ret
= lttng_poll_create(&events
, 2, LTTNG_CLOEXEC
);
70 goto error_poll_create
;
73 ret
= lttng_poll_add(&events
, notifiers
->apps_cmd_pipe_read_fd
, LPOLLIN
| LPOLLRDHUP
);
78 ret
= lttng_poll_add(&events
, thread_quit_pipe_fd
, LPOLLIN
);
83 if (testpoint(sessiond_thread_manage_apps_before_loop
)) {
90 DBG("Apps thread polling");
92 /* Inifinite blocking call, waiting for transmission */
95 ret
= lttng_poll_wait(&events
, -1);
96 DBG("Apps thread return from poll on %d fds", LTTNG_POLL_GETNB(&events
));
100 * Restart interrupted system call.
102 if (errno
== EINTR
) {
110 for (i
= 0; i
< nb_fd
; i
++) {
111 /* Fetch once the poll data */
112 const auto revents
= LTTNG_POLL_GETEV(&events
, i
);
113 const auto pollfd
= LTTNG_POLL_GETFD(&events
, i
);
115 health_code_update();
117 /* Activity on thread quit pipe, exiting. */
118 if (pollfd
== thread_quit_pipe_fd
) {
119 DBG("Activity on thread quit pipe");
124 if (pollfd
== notifiers
->apps_cmd_pipe_read_fd
) {
125 /* Inspect the apps cmd pipe */
126 if (revents
& LPOLLIN
) {
130 size_ret
= lttng_read(notifiers
->apps_cmd_pipe_read_fd
,
133 if (size_ret
< sizeof(sock
)) {
134 PERROR("read apps cmd pipe");
138 health_code_update();
141 * Since this is a command socket (write then read),
142 * we only monitor the error events of the socket.
144 ret
= lttng_poll_add(&events
, sock
, LPOLLRDHUP
);
149 DBG("Apps with sock %d added to poll set", sock
);
150 } else if (revents
& (LPOLLERR
| LPOLLHUP
| LPOLLRDHUP
)) {
151 ERR("Apps command pipe error");
154 ERR("Unknown poll events %u for sock %d", revents
, pollfd
);
159 * At this point, we know that a registered application made
160 * the event at poll_wait.
162 if (revents
& (LPOLLERR
| LPOLLHUP
| LPOLLRDHUP
)) {
163 /* Removing from the poll set */
164 ret
= lttng_poll_del(&events
, pollfd
);
169 /* Socket closed on remote end. */
170 ust_app_unregister_by_socket(pollfd
);
172 ERR("Unexpected poll events %u for sock %d",
179 health_code_update();
185 lttng_poll_clean(&events
);
190 * We don't clean the UST app hash table here since already registered
191 * applications can still be controlled so let them be until the session
192 * daemon dies or the applications stop.
197 ERR("Health error occurred in %s", __func__
);
199 health_unregister(the_health_sessiond
);
200 DBG("Application communication apps thread cleanup complete");
201 rcu_thread_offline();
202 rcu_unregister_thread();
206 static bool shutdown_application_management_thread(void *data
)
208 struct thread_notifiers
*notifiers
= (thread_notifiers
*) data
;
209 const int write_fd
= lttng_pipe_get_writefd(notifiers
->quit_pipe
);
211 return notify_thread_pipe(write_fd
) == 1;
214 bool launch_application_management_thread(int apps_cmd_pipe_read_fd
)
216 struct lttng_pipe
*quit_pipe
;
217 struct thread_notifiers
*notifiers
= nullptr;
218 struct lttng_thread
*thread
;
220 notifiers
= zmalloc
<thread_notifiers
>();
224 quit_pipe
= lttng_pipe_open(FD_CLOEXEC
);
228 notifiers
->quit_pipe
= quit_pipe
;
229 notifiers
->apps_cmd_pipe_read_fd
= apps_cmd_pipe_read_fd
;
231 thread
= lttng_thread_create("UST application management",
232 thread_application_management
,
233 shutdown_application_management_thread
,
234 cleanup_application_management_thread
,
240 lttng_thread_put(thread
);
243 cleanup_application_management_thread(notifiers
);