sessiond: tsdl: remove useless std::move
[lttng-tools.git] / src / bin / lttng-sessiond / health.cpp
CommitLineData
173fca4f 1/*
ab5be9fa
MJ
2 * Copyright (C) 2012 David Goulet <dgoulet@efficios.com>
3 * Copyright (C) 2018 Jérémie Galarneau <jeremie.galarneau@efficios.com>
173fca4f 4 *
ab5be9fa 5 * SPDX-License-Identifier: GPL-2.0-only
173fca4f 6 *
173fca4f
JG
7 */
8
c9e313bc
SM
9#include "lttng-sessiond.hpp"
10#include "health-sessiond.hpp"
11#include <common/macros.hpp>
12#include <common/error.hpp>
13#include <common/utils.hpp>
14#include <common/pipe.hpp>
173fca4f
JG
15#include <inttypes.h>
16#include <sys/stat.h>
c9e313bc
SM
17#include "utils.hpp"
18#include "thread.hpp"
173fca4f 19
f1494934 20namespace {
c78d8e86
JG
21struct thread_notifiers {
22 struct lttng_pipe *quit_pipe;
23 sem_t ready;
24};
f1494934 25} /* namespace */
c78d8e86
JG
26
27static
28void mark_thread_as_ready(struct thread_notifiers *notifiers)
173fca4f 29{
c78d8e86
JG
30 DBG("Marking health management thread as ready");
31 sem_post(&notifiers->ready);
32}
173fca4f 33
c78d8e86
JG
34static
35void wait_until_thread_is_ready(struct thread_notifiers *notifiers)
36{
37 DBG("Waiting for health management thread to be ready");
38 sem_wait(&notifiers->ready);
39 DBG("Health management thread is ready");
40}
41
42static void cleanup_health_management_thread(void *data)
43{
7966af57 44 struct thread_notifiers *notifiers = (thread_notifiers *) data;
c78d8e86
JG
45
46 lttng_pipe_destroy(notifiers->quit_pipe);
47 sem_destroy(&notifiers->ready);
48 free(notifiers);
173fca4f
JG
49}
50
51/*
52 * Thread managing health check socket.
53 */
c78d8e86 54static void *thread_manage_health(void *data)
173fca4f
JG
55{
56 const bool is_root = (getuid() == 0);
8a00688e
MJ
57 int sock = -1, new_sock = -1, ret, i, err = -1;
58 uint32_t nb_fd;
173fca4f
JG
59 struct lttng_poll_event events;
60 struct health_comm_msg msg;
61 struct health_comm_reply reply;
62 /* Thread-specific quit pipe. */
7966af57 63 struct thread_notifiers *notifiers = (thread_notifiers *) data;
8a00688e 64 const auto thread_quit_pipe_fd = lttng_pipe_get_readfd(
c78d8e86 65 notifiers->quit_pipe);
173fca4f
JG
66
67 DBG("[thread] Manage health check started");
68
69 rcu_register_thread();
70
71 /*
72 * Created with a size of two for:
8a00688e 73 * - health client socket
173fca4f
JG
74 * - thread quit pipe
75 */
76 ret = lttng_poll_create(&events, 2, LTTNG_CLOEXEC);
77 if (ret < 0) {
78 goto error;
79 }
80
81 /* Create unix socket */
412d7227 82 sock = lttcomm_create_unix_sock(the_config.health_unix_sock_path.value);
173fca4f
JG
83 if (sock < 0) {
84 ERR("Unable to create health check Unix socket");
85 goto error;
86 }
87
88 if (is_root) {
89 /* lttng health client socket path permissions */
28ab59d0
JR
90 gid_t gid;
91
412d7227 92 ret = utils_get_group_id(the_config.tracing_group_name.value, true, &gid);
28ab59d0
JR
93 if (ret) {
94 /* Default to root group. */
95 gid = 0;
96 }
97
412d7227 98 ret = chown(the_config.health_unix_sock_path.value, 0, gid);
173fca4f 99 if (ret < 0) {
412d7227 100 ERR("Unable to set group on %s", the_config.health_unix_sock_path.value);
173fca4f
JG
101 PERROR("chown");
102 goto error;
103 }
104
412d7227 105 ret = chmod(the_config.health_unix_sock_path.value,
173fca4f
JG
106 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
107 if (ret < 0) {
412d7227 108 ERR("Unable to set permissions on %s", the_config.health_unix_sock_path.value);
173fca4f
JG
109 PERROR("chmod");
110 goto error;
111 }
112 }
113
114 /*
115 * Set the CLOEXEC flag. Return code is useless because either way, the
116 * show must go on.
117 */
118 (void) utils_set_fd_cloexec(sock);
119
120 ret = lttcomm_listen_unix_sock(sock);
121 if (ret < 0) {
122 goto error;
123 }
124
1524f98c 125 ret = lttng_poll_add(&events, thread_quit_pipe_fd, LPOLLIN);
173fca4f
JG
126 if (ret < 0) {
127 goto error;
128 }
129
8a00688e 130 /* Add the health client socket. */
173fca4f
JG
131 ret = lttng_poll_add(&events, sock, LPOLLIN | LPOLLPRI);
132 if (ret < 0) {
133 goto error;
134 }
135
c78d8e86 136 mark_thread_as_ready(notifiers);
173fca4f
JG
137 while (1) {
138 DBG("Health check ready");
139
140 /* Infinite blocking call, waiting for transmission */
141restart:
142 ret = lttng_poll_wait(&events, -1);
143 if (ret < 0) {
144 /*
145 * Restart interrupted system call.
146 */
147 if (errno == EINTR) {
148 goto restart;
149 }
150 goto error;
151 }
152
153 nb_fd = ret;
154
155 for (i = 0; i < nb_fd; i++) {
156 /* Fetch once the poll data */
8a00688e
MJ
157 const auto revents = LTTNG_POLL_GETEV(&events, i);
158 const auto pollfd = LTTNG_POLL_GETFD(&events, i);
159
160 /* Activity on thread quit pipe, exiting. */
161 if (pollfd == thread_quit_pipe_fd) {
162 DBG("Activity on thread quit pipe");
173fca4f
JG
163 err = 0;
164 goto exit;
165 }
8a00688e
MJ
166
167 /* Event on the health client socket. */
168 if (revents & LPOLLIN) {
169 continue;
170 } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
171 ERR("Health socket poll error");
172 goto error;
173 } else {
174 ERR("Unexpected poll events %u for sock %d", revents, pollfd);
175 goto error;
176 }
173fca4f
JG
177 }
178
179 new_sock = lttcomm_accept_unix_sock(sock);
180 if (new_sock < 0) {
181 goto error;
182 }
183
184 /*
185 * Set the CLOEXEC flag. Return code is useless because either way, the
186 * show must go on.
187 */
188 (void) utils_set_fd_cloexec(new_sock);
189
190 DBG("Receiving data from client for health...");
191 ret = lttcomm_recv_unix_sock(new_sock, (void *)&msg, sizeof(msg));
192 if (ret <= 0) {
193 DBG("Nothing recv() from client... continuing");
194 ret = close(new_sock);
195 if (ret) {
196 PERROR("close");
197 }
198 continue;
199 }
200
201 rcu_thread_online();
202
203 memset(&reply, 0, sizeof(reply));
204 for (i = 0; i < NR_HEALTH_SESSIOND_TYPES; i++) {
205 /*
206 * health_check_state returns 0 if health is
207 * bad.
208 */
412d7227 209 if (!health_check_state(the_health_sessiond, i)) {
173fca4f
JG
210 reply.ret_code |= 1ULL << i;
211 }
212 }
213
214 DBG2("Health check return value %" PRIx64, reply.ret_code);
215
216 ret = lttcomm_send_unix_sock(new_sock, (void *) &reply,
217 sizeof(reply));
218 if (ret < 0) {
219 ERR("Failed to send health data back to client");
220 }
221
222 /* End of transmission */
223 ret = close(new_sock);
224 if (ret) {
225 PERROR("close");
226 }
227 }
228
229exit:
230error:
231 if (err) {
232 ERR("Health error occurred in %s", __func__);
233 }
234 DBG("Health check thread dying");
412d7227 235 unlink(the_config.health_unix_sock_path.value);
173fca4f
JG
236 if (sock >= 0) {
237 ret = close(sock);
238 if (ret) {
239 PERROR("close");
240 }
241 }
242
243 lttng_poll_clean(&events);
244 rcu_unregister_thread();
245 return NULL;
246}
247
c78d8e86 248static bool shutdown_health_management_thread(void *data)
173fca4f 249{
7966af57 250 struct thread_notifiers *notifiers = ( thread_notifiers *) data;
c78d8e86 251 const int write_fd = lttng_pipe_get_writefd(notifiers->quit_pipe);
173fca4f 252
c78d8e86 253 return notify_thread_pipe(write_fd) == 1;
173fca4f
JG
254}
255
256bool launch_health_management_thread(void)
257{
c78d8e86 258 struct thread_notifiers *notifiers;
173fca4f 259 struct lttng_thread *thread;
173fca4f 260
64803277 261 notifiers = zmalloc<thread_notifiers>();
c78d8e86 262 if (!notifiers) {
21fa020e 263 goto error_alloc;
173fca4f
JG
264 }
265
c78d8e86
JG
266 sem_init(&notifiers->ready, 0, 0);
267 notifiers->quit_pipe = lttng_pipe_open(FD_CLOEXEC);
268 if (!notifiers->quit_pipe) {
269 goto error;
270 }
173fca4f
JG
271 thread = lttng_thread_create("Health management",
272 thread_manage_health,
273 shutdown_health_management_thread,
274 cleanup_health_management_thread,
c78d8e86 275 notifiers);
173fca4f
JG
276 if (!thread) {
277 goto error;
278 }
c78d8e86
JG
279
280 wait_until_thread_is_ready(notifiers);
173fca4f
JG
281 lttng_thread_put(thread);
282 return true;
283error:
c78d8e86 284 cleanup_health_management_thread(notifiers);
21fa020e 285error_alloc:
173fca4f
JG
286 return false;
287}
This page took 0.05972 seconds and 4 git commands to generate.