relayd: track the health thread's poll fd with fd-tracker
[lttng-tools.git] / src / bin / lttng-relayd / health-relayd.c
1 /*
2 * Copyright (C) 2013 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License, version 2 only,
6 * as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 */
17
18 #define _LGPL_SOURCE
19 #include <fcntl.h>
20 #include <getopt.h>
21 #include <grp.h>
22 #include <limits.h>
23 #include <pthread.h>
24 #include <signal.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <sys/ipc.h>
29 #include <sys/resource.h>
30 #include <sys/shm.h>
31 #include <sys/socket.h>
32 #include <sys/stat.h>
33 #include <sys/types.h>
34 #include <urcu/list.h>
35 #include <poll.h>
36 #include <unistd.h>
37 #include <sys/mman.h>
38 #include <assert.h>
39 #include <urcu/compiler.h>
40 #include <inttypes.h>
41
42 #include <common/defaults.h>
43 #include <common/common.h>
44 #include <common/consumer/consumer.h>
45 #include <common/consumer/consumer-timer.h>
46 #include <common/compat/poll.h>
47 #include <common/sessiond-comm/sessiond-comm.h>
48 #include <common/utils.h>
49 #include <common/compat/getenv.h>
50 #include <common/fd-tracker/utils.h>
51
52 #include "lttng-relayd.h"
53 #include "health-relayd.h"
54
55 /* Global health check unix path */
56 static
57 char health_unix_sock_path[PATH_MAX];
58
59 int health_quit_pipe[2] = { -1, -1 };
60
61 /*
62 * Check if the thread quit pipe was triggered.
63 *
64 * Return 1 if it was triggered else 0;
65 */
66 static
67 int check_health_quit_pipe(int fd, uint32_t events)
68 {
69 if (fd == health_quit_pipe[0] && (events & LPOLLIN)) {
70 return 1;
71 }
72
73 return 0;
74 }
75
76 /*
77 * Send data on a unix socket using the liblttsessiondcomm API.
78 *
79 * Return lttcomm error code.
80 */
81 static int send_unix_sock(int sock, void *buf, size_t len)
82 {
83 /* Check valid length */
84 if (len == 0) {
85 return -1;
86 }
87
88 return lttcomm_send_unix_sock(sock, buf, len);
89 }
90
91 static int create_lttng_rundir_with_perm(const char *rundir)
92 {
93 int ret;
94
95 DBG3("Creating LTTng run directory: %s", rundir);
96
97 ret = mkdir(rundir, S_IRWXU);
98 if (ret < 0) {
99 if (errno != EEXIST) {
100 ERR("Unable to create %s", rundir);
101 goto error;
102 } else {
103 ret = 0;
104 }
105 } else if (ret == 0) {
106 int is_root = !getuid();
107
108 if (is_root) {
109 gid_t gid;
110
111 ret = utils_get_group_id(tracing_group_name, true, &gid);
112 if (ret) {
113 /* Default to root group. */
114 gid = 0;
115 }
116
117 ret = chown(rundir, 0, gid);
118 if (ret < 0) {
119 ERR("Unable to set group on %s", rundir);
120 PERROR("chown");
121 ret = -1;
122 goto error;
123 }
124
125 ret = chmod(rundir,
126 S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
127 if (ret < 0) {
128 ERR("Unable to set permissions on %s", health_unix_sock_path);
129 PERROR("chmod");
130 ret = -1;
131 goto error;
132 }
133 }
134 }
135
136 error:
137 return ret;
138 }
139
140 static
141 int parse_health_env(void)
142 {
143 const char *health_path;
144
145 health_path = lttng_secure_getenv(LTTNG_RELAYD_HEALTH_ENV);
146 if (health_path) {
147 strncpy(health_unix_sock_path, health_path,
148 PATH_MAX);
149 health_unix_sock_path[PATH_MAX - 1] = '\0';
150 }
151
152 return 0;
153 }
154
155 static
156 int setup_health_path(void)
157 {
158 int is_root, ret = 0;
159 const char *home_path = NULL;
160 char *rundir = NULL, *relayd_path = NULL;
161
162 ret = parse_health_env();
163 if (ret) {
164 return ret;
165 }
166
167 is_root = !getuid();
168
169 if (is_root) {
170 rundir = strdup(DEFAULT_LTTNG_RUNDIR);
171 if (!rundir) {
172 ret = -ENOMEM;
173 goto end;
174 }
175 } else {
176 /*
177 * Create rundir from home path. This will create something like
178 * $HOME/.lttng
179 */
180 home_path = utils_get_home_dir();
181
182 if (home_path == NULL) {
183 /* TODO: Add --socket PATH option */
184 ERR("Can't get HOME directory for sockets creation.");
185 ret = -EPERM;
186 goto end;
187 }
188
189 ret = asprintf(&rundir, DEFAULT_LTTNG_HOME_RUNDIR, home_path);
190 if (ret < 0) {
191 ret = -ENOMEM;
192 goto end;
193 }
194 }
195
196 ret = asprintf(&relayd_path, DEFAULT_RELAYD_PATH, rundir);
197 if (ret < 0) {
198 ret = -ENOMEM;
199 goto end;
200 }
201
202 ret = create_lttng_rundir_with_perm(rundir);
203 if (ret < 0) {
204 goto end;
205 }
206
207 ret = create_lttng_rundir_with_perm(relayd_path);
208 if (ret < 0) {
209 goto end;
210 }
211
212 if (is_root) {
213 if (strlen(health_unix_sock_path) != 0) {
214 goto end;
215 }
216 snprintf(health_unix_sock_path, sizeof(health_unix_sock_path),
217 DEFAULT_GLOBAL_RELAY_HEALTH_UNIX_SOCK,
218 (int) getpid());
219 } else {
220 /* Set health check Unix path */
221 if (strlen(health_unix_sock_path) != 0) {
222 goto end;
223 }
224
225 snprintf(health_unix_sock_path, sizeof(health_unix_sock_path),
226 DEFAULT_HOME_RELAY_HEALTH_UNIX_SOCK,
227 home_path, (int) getpid());
228 }
229
230 end:
231 free(rundir);
232 free(relayd_path);
233 return ret;
234 }
235
236 static
237 int accept_unix_socket(void *data, int *out_fd)
238 {
239 int ret;
240 int accepting_sock = *((int *) data);
241
242 ret = lttcomm_accept_unix_sock(accepting_sock);
243 if (ret < 0) {
244 goto end;
245 }
246
247 *out_fd = ret;
248 ret = 0;
249 end:
250 return ret;
251 }
252
253 /*
254 * Thread managing health check socket.
255 */
256 void *thread_manage_health(void *data)
257 {
258 int sock = -1, new_sock = -1, ret, i, pollfd, err = -1;
259 uint32_t revents, nb_fd;
260 struct lttng_poll_event events;
261 struct health_comm_msg msg;
262 struct health_comm_reply reply;
263 int is_root;
264
265 DBG("[thread] Manage health check started");
266
267 setup_health_path();
268
269 rcu_register_thread();
270
271 /* We might hit an error path before this is created. */
272 lttng_poll_init(&events);
273
274 /* Create unix socket */
275 sock = lttcomm_create_unix_sock(health_unix_sock_path);
276 if (sock < 0) {
277 ERR("Unable to create health check Unix socket");
278 err = -1;
279 goto error;
280 }
281
282 is_root = !getuid();
283 if (is_root) {
284 /* lttng health client socket path permissions */
285 gid_t gid;
286
287 ret = utils_get_group_id(tracing_group_name, true, &gid);
288 if (ret) {
289 /* Default to root group. */
290 gid = 0;
291 }
292
293 ret = chown(health_unix_sock_path, 0, gid);
294 if (ret < 0) {
295 ERR("Unable to set group on %s", health_unix_sock_path);
296 PERROR("chown");
297 err = -1;
298 goto error;
299 }
300
301 ret = chmod(health_unix_sock_path,
302 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
303 if (ret < 0) {
304 ERR("Unable to set permissions on %s", health_unix_sock_path);
305 PERROR("chmod");
306 err = -1;
307 goto error;
308 }
309 }
310
311 /*
312 * Set the CLOEXEC flag. Return code is useless because either way, the
313 * show must go on.
314 */
315 (void) utils_set_fd_cloexec(sock);
316
317 ret = lttcomm_listen_unix_sock(sock);
318 if (ret < 0) {
319 goto error;
320 }
321
322 /* Size is set to 2 for the unix socket and quit pipe. */
323 ret = fd_tracker_util_poll_create(the_fd_tracker,
324 "Health management thread epoll", &events, 2,
325 LTTNG_CLOEXEC);
326 if (ret < 0) {
327 ERR("Poll set creation failed");
328 goto error;
329 }
330
331 ret = lttng_poll_add(&events, health_quit_pipe[0], LPOLLIN);
332 if (ret < 0) {
333 goto error;
334 }
335
336 /* Add the application registration socket */
337 ret = lttng_poll_add(&events, sock, LPOLLIN | LPOLLPRI);
338 if (ret < 0) {
339 goto error;
340 }
341
342 lttng_relay_notify_ready();
343
344 while (1) {
345 char *accepted_socket_name;
346
347 DBG("Health check ready");
348
349 /* Inifinite blocking call, waiting for transmission */
350 restart:
351 ret = lttng_poll_wait(&events, -1);
352 if (ret < 0) {
353 /*
354 * Restart interrupted system call.
355 */
356 if (errno == EINTR) {
357 goto restart;
358 }
359 goto error;
360 }
361
362 nb_fd = ret;
363
364 for (i = 0; i < nb_fd; i++) {
365 /* Fetch once the poll data */
366 revents = LTTNG_POLL_GETEV(&events, i);
367 pollfd = LTTNG_POLL_GETFD(&events, i);
368
369 /* Thread quit pipe has been closed. Killing thread. */
370 ret = check_health_quit_pipe(pollfd, revents);
371 if (ret) {
372 err = 0;
373 goto exit;
374 }
375
376 /* Event on the registration socket */
377 if (pollfd == sock) {
378 if (revents & LPOLLIN) {
379 continue;
380 } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
381 ERR("Health socket poll error");
382 goto error;
383 } else {
384 ERR("Unexpected poll events %u for sock %d", revents, pollfd);
385 goto error;
386 }
387 }
388 }
389
390 ret = asprintf(&accepted_socket_name, "Socket accepted from unix socket @ %s",
391 health_unix_sock_path);
392 if (ret == -1) {
393 PERROR("Failed to allocate name of accepted socket from unix socket @ %s",
394 health_unix_sock_path);
395 goto error;
396 }
397 ret = fd_tracker_open_unsuspendable_fd(the_fd_tracker, &new_sock,
398 (const char **) &accepted_socket_name, 1,
399 accept_unix_socket, &sock);
400 free(accepted_socket_name);
401 if (ret < 0) {
402 goto error;
403 }
404
405 /*
406 * Set the CLOEXEC flag. Return code is useless because either way, the
407 * show must go on.
408 */
409 (void) utils_set_fd_cloexec(new_sock);
410
411 DBG("Receiving data from client for health...");
412 ret = lttcomm_recv_unix_sock(new_sock, (void *)&msg, sizeof(msg));
413 if (ret <= 0) {
414 DBG("Nothing recv() from client... continuing");
415 ret = fd_tracker_close_unsuspendable_fd(the_fd_tracker,
416 &new_sock, 1, fd_tracker_util_close_fd,
417 NULL);
418 if (ret) {
419 PERROR("close");
420 }
421 new_sock = -1;
422 continue;
423 }
424
425 rcu_thread_online();
426
427 assert(msg.cmd == HEALTH_CMD_CHECK);
428
429 memset(&reply, 0, sizeof(reply));
430 for (i = 0; i < NR_HEALTH_RELAYD_TYPES; i++) {
431 /*
432 * health_check_state return 0 if thread is in
433 * error.
434 */
435 if (!health_check_state(health_relayd, i)) {
436 reply.ret_code |= 1ULL << i;
437 }
438 }
439
440 DBG2("Health check return value %" PRIx64, reply.ret_code);
441
442 ret = send_unix_sock(new_sock, (void *) &reply, sizeof(reply));
443 if (ret < 0) {
444 ERR("Failed to send health data back to client");
445 }
446
447 /* End of transmission */
448 ret = fd_tracker_close_unsuspendable_fd(the_fd_tracker,
449 &new_sock, 1, fd_tracker_util_close_fd,
450 NULL);
451 if (ret) {
452 PERROR("close");
453 }
454 new_sock = -1;
455 }
456
457 error:
458 lttng_relay_stop_threads();
459 exit:
460 if (err) {
461 ERR("Health error occurred in %s", __func__);
462 }
463 DBG("Health check thread dying");
464 unlink(health_unix_sock_path);
465 if (sock >= 0) {
466 ret = close(sock);
467 if (ret) {
468 PERROR("close");
469 }
470 }
471
472 /*
473 * We do NOT rmdir rundir nor the relayd path because there are
474 * other processes using them.
475 */
476
477 (void) fd_tracker_util_poll_clean(the_fd_tracker, &events);
478
479 rcu_unregister_thread();
480 return NULL;
481 }
This page took 0.060052 seconds and 4 git commands to generate.