Fix: move testpoint after state update
[lttng-tools.git] / src / bin / lttng-sessiond / register.c
CommitLineData
1785d7f2
JG
1/*
2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 * Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
4 * 2013 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License, version 2 only,
8 * as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20#include <stddef.h>
21#include <stdlib.h>
22#include <urcu.h>
23#include <common/futex.h>
24#include <common/macros.h>
25#include <common/utils.h>
26#include <sys/stat.h>
27
28#include "register.h"
29#include "lttng-sessiond.h"
30#include "testpoint.h"
31#include "health-sessiond.h"
32#include "fd-limit.h"
33#include "shm.h"
34#include "utils.h"
35#include "thread.h"
36
a13091b7 37struct thread_state {
1785d7f2
JG
38 struct lttng_pipe *quit_pipe;
39 struct ust_cmd_queue *ust_cmd_queue;
9c9d917c 40 sem_t ready;
86d0f119 41 bool running;
a13091b7 42 int application_socket;
1785d7f2
JG
43};
44
45/*
46 * Creates the application socket.
47 */
48static int create_application_socket(void)
49{
50 int ret = 0;
51 int apps_sock;
52 const mode_t old_umask = umask(0);
53
54 /* Create the application unix socket */
55 apps_sock = lttcomm_create_unix_sock(config.apps_unix_sock_path.value);
56 if (apps_sock < 0) {
57 ERR("Create unix sock failed: %s", config.apps_unix_sock_path.value);
58 ret = -1;
59 goto end;
60 }
61
62 /* Set the cloexec flag */
63 ret = utils_set_fd_cloexec(apps_sock);
64 if (ret < 0) {
65 ERR("Unable to set CLOEXEC flag to the app Unix socket (fd: %d). "
66 "Continuing but note that the consumer daemon will have a "
67 "reference to this socket on exec()", apps_sock);
68 }
69
70 /* File permission MUST be 666 */
71 ret = chmod(config.apps_unix_sock_path.value,
72 S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
73 if (ret < 0) {
74 PERROR("Set file permissions failed on %s",
75 config.apps_unix_sock_path.value);
d9c6b5f2 76 goto error_close_socket;
1785d7f2
JG
77 }
78
79 DBG3("Session daemon application socket created (fd = %d) ", apps_sock);
80 ret = apps_sock;
81end:
82 umask(old_umask);
83 return ret;
d9c6b5f2
JG
84error_close_socket:
85 if (close(apps_sock)) {
86 PERROR("Failed to close application socket in error path");
87 }
88 apps_sock = -1;
89 ret = -1;
90 goto end;
1785d7f2
JG
91}
92
93/*
94 * Notify UST applications using the shm mmap futex.
95 */
96static int notify_ust_apps(int active, bool is_root)
97{
98 char *wait_shm_mmap;
99
100 DBG("Notifying applications of session daemon state: %d", active);
101
102 /* See shm.c for this call implying mmap, shm and futex calls */
103 wait_shm_mmap = shm_ust_get_mmap(config.wait_shm_path.value, is_root);
104 if (wait_shm_mmap == NULL) {
105 goto error;
106 }
107
108 /* Wake waiting process */
109 futex_wait_update((int32_t *) wait_shm_mmap, active);
110
111 /* Apps notified successfully */
112 return 0;
113
114error:
115 return -1;
116}
117
118static void cleanup_application_registration_thread(void *data)
119{
a13091b7 120 struct thread_state *thread_state = data;
1785d7f2 121
a13091b7
JG
122 if (!data) {
123 return;
124 }
125
126 lttng_pipe_destroy(thread_state->quit_pipe);
127 free(thread_state);
1785d7f2
JG
128}
129
a13091b7 130static void set_thread_status(struct thread_state *thread_state, bool running)
9c9d917c 131{
86d0f119 132 DBG("Marking application registration thread's state as %s", running ? "running" : "error");
a13091b7
JG
133 thread_state->running = running;
134 sem_post(&thread_state->ready);
9c9d917c
JG
135}
136
a13091b7 137static bool wait_thread_status(struct thread_state *thread_state)
9c9d917c
JG
138{
139 DBG("Waiting for application registration thread to be ready");
a13091b7
JG
140 sem_wait(&thread_state->ready);
141 if (thread_state->running) {
86d0f119
JG
142 DBG("Application registration thread is ready");
143 } else {
144 ERR("Initialization of application registration thread failed");
145 }
146
a13091b7 147 return thread_state->running;
86d0f119
JG
148}
149
150static void thread_init_cleanup(void *data)
151{
a13091b7 152 struct thread_state *thread_state = data;
86d0f119 153
a13091b7 154 set_thread_status(thread_state, false);
9c9d917c
JG
155}
156
1785d7f2
JG
157/*
158 * This thread manage application registration.
159 */
160static void *thread_application_registration(void *data)
161{
162 int sock = -1, i, ret, pollfd, err = -1;
1785d7f2
JG
163 uint32_t revents, nb_fd;
164 struct lttng_poll_event events;
165 /*
166 * Gets allocated in this thread, enqueued to a global queue, dequeued
167 * and freed in the manage apps thread.
168 */
169 struct ust_command *ust_cmd = NULL;
170 const bool is_root = (getuid() == 0);
a13091b7
JG
171 struct thread_state *thread_state = data;
172 const int application_socket = thread_state->application_socket;
1785d7f2 173 const int quit_pipe_read_fd = lttng_pipe_get_readfd(
a13091b7 174 thread_state->quit_pipe);
1785d7f2
JG
175
176 DBG("[thread] Manage application registration started");
177
a0b34569 178 pthread_cleanup_push(thread_init_cleanup, thread_state);
1785d7f2
JG
179 health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_REG);
180
a13091b7 181 ret = lttcomm_listen_unix_sock(application_socket);
1785d7f2
JG
182 if (ret < 0) {
183 goto error_listen;
184 }
185
186 /*
187 * Pass 2 as size here for the thread quit pipe and apps_sock. Nothing
188 * more will be added to this poll set.
189 */
190 ret = lttng_poll_create(&events, 2, LTTNG_CLOEXEC);
191 if (ret < 0) {
192 goto error_create_poll;
193 }
194
195 /* Add the application registration socket */
a13091b7 196 ret = lttng_poll_add(&events, application_socket, LPOLLIN | LPOLLRDHUP);
1785d7f2
JG
197 if (ret < 0) {
198 goto error_poll_add;
199 }
200
201 /* Add the application registration socket */
202 ret = lttng_poll_add(&events, quit_pipe_read_fd, LPOLLIN | LPOLLRDHUP);
203 if (ret < 0) {
204 goto error_poll_add;
205 }
206
a13091b7
JG
207 set_thread_status(thread_state, true);
208 pthread_cleanup_pop(0);
1785d7f2 209
9ad83bb6
JR
210 if (testpoint(sessiond_thread_registration_apps)) {
211 goto error_poll_add;
212 }
213
1785d7f2
JG
214 while (1) {
215 DBG("Accepting application registration");
216
217 /* Inifinite blocking call, waiting for transmission */
218 restart:
219 health_poll_entry();
220 ret = lttng_poll_wait(&events, -1);
221 health_poll_exit();
222 if (ret < 0) {
223 /*
224 * Restart interrupted system call.
225 */
226 if (errno == EINTR) {
227 goto restart;
228 }
229 goto error;
230 }
231
232 nb_fd = ret;
233
234 for (i = 0; i < nb_fd; i++) {
235 health_code_update();
236
237 /* Fetch once the poll data */
238 revents = LTTNG_POLL_GETEV(&events, i);
239 pollfd = LTTNG_POLL_GETFD(&events, i);
240
1785d7f2
JG
241 /* Thread quit pipe has been closed. Killing thread. */
242 if (pollfd == quit_pipe_read_fd) {
243 err = 0;
244 goto exit;
245 } else {
246 /* Event on the registration socket */
247 if (revents & LPOLLIN) {
a13091b7 248 sock = lttcomm_accept_unix_sock(application_socket);
1785d7f2
JG
249 if (sock < 0) {
250 goto error;
251 }
252
253 /*
254 * Set socket timeout for both receiving and ending.
255 * app_socket_timeout is in seconds, whereas
256 * lttcomm_setsockopt_rcv_timeout and
257 * lttcomm_setsockopt_snd_timeout expect msec as
258 * parameter.
259 */
260 if (config.app_socket_timeout >= 0) {
261 (void) lttcomm_setsockopt_rcv_timeout(sock,
262 config.app_socket_timeout * 1000);
263 (void) lttcomm_setsockopt_snd_timeout(sock,
264 config.app_socket_timeout * 1000);
265 }
266
267 /*
268 * Set the CLOEXEC flag. Return code is useless because
269 * either way, the show must go on.
270 */
271 (void) utils_set_fd_cloexec(sock);
272
273 /* Create UST registration command for enqueuing */
274 ust_cmd = zmalloc(sizeof(struct ust_command));
275 if (ust_cmd == NULL) {
276 PERROR("ust command zmalloc");
277 ret = close(sock);
278 if (ret) {
279 PERROR("close");
280 }
229afb9c 281 sock = -1;
1785d7f2
JG
282 goto error;
283 }
284
285 /*
286 * Using message-based transmissions to ensure we don't
287 * have to deal with partially received messages.
288 */
289 ret = lttng_fd_get(LTTNG_FD_APPS, 1);
290 if (ret < 0) {
291 ERR("Exhausted file descriptors allowed for applications.");
292 free(ust_cmd);
293 ret = close(sock);
294 if (ret) {
295 PERROR("close");
296 }
297 sock = -1;
298 continue;
299 }
300
301 health_code_update();
302 ret = ust_app_recv_registration(sock, &ust_cmd->reg_msg);
303 if (ret < 0) {
304 free(ust_cmd);
305 /* Close socket of the application. */
306 ret = close(sock);
307 if (ret) {
308 PERROR("close");
309 }
310 lttng_fd_put(LTTNG_FD_APPS, 1);
311 sock = -1;
312 continue;
313 }
314 health_code_update();
315
316 ust_cmd->sock = sock;
317 sock = -1;
318
319 DBG("UST registration received with pid:%d ppid:%d uid:%d"
320 " gid:%d sock:%d name:%s (version %d.%d)",
321 ust_cmd->reg_msg.pid, ust_cmd->reg_msg.ppid,
322 ust_cmd->reg_msg.uid, ust_cmd->reg_msg.gid,
323 ust_cmd->sock, ust_cmd->reg_msg.name,
324 ust_cmd->reg_msg.major, ust_cmd->reg_msg.minor);
325
326 /*
327 * Lock free enqueue the registration request. The red pill
328 * has been taken! This apps will be part of the *system*.
329 */
a13091b7
JG
330 cds_wfcq_enqueue(&thread_state->ust_cmd_queue->head,
331 &thread_state->ust_cmd_queue->tail,
1785d7f2
JG
332 &ust_cmd->node);
333
334 /*
335 * Wake the registration queue futex. Implicit memory
336 * barrier with the exchange in cds_wfcq_enqueue.
337 */
a13091b7 338 futex_nto1_wake(&thread_state->ust_cmd_queue->futex);
1785d7f2
JG
339 } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
340 ERR("Register apps socket poll error");
341 goto error;
342 } else {
343 ERR("Unexpected poll events %u for sock %d", revents, pollfd);
344 goto error;
345 }
346 }
347 }
348 }
349
350exit:
351error:
352 /* Notify that the registration thread is gone */
353 notify_ust_apps(0, is_root);
354
a13091b7
JG
355 ret = close(application_socket);
356 if (ret) {
357 PERROR("Failed to close application registration socket");
1785d7f2
JG
358 }
359 if (sock >= 0) {
360 ret = close(sock);
361 if (ret) {
a13091b7 362 PERROR("Failed to close application socket");
1785d7f2
JG
363 }
364 lttng_fd_put(LTTNG_FD_APPS, 1);
365 }
366 unlink(config.apps_unix_sock_path.value);
367
368error_poll_add:
369 lttng_poll_clean(&events);
370error_listen:
371error_create_poll:
1785d7f2
JG
372 DBG("UST Registration thread cleanup complete");
373 if (err) {
374 health_error();
375 ERR("Health error occurred in %s", __func__);
376 }
377 health_unregister(health_sessiond);
378 return NULL;
379}
380
381static bool shutdown_application_registration_thread(void *data)
382{
a13091b7
JG
383 struct thread_state *thread_state = data;
384 const int write_fd = lttng_pipe_get_writefd(thread_state->quit_pipe);
1785d7f2
JG
385
386 return notify_thread_pipe(write_fd) == 1;
387}
388
bd9addf7 389struct lttng_thread *launch_application_registration_thread(
1785d7f2
JG
390 struct ust_cmd_queue *cmd_queue)
391{
a13091b7 392 int ret;
1785d7f2 393 struct lttng_pipe *quit_pipe;
a13091b7
JG
394 struct thread_state *thread_state = NULL;
395 struct lttng_thread *thread = NULL;
396 const bool is_root = (getuid() == 0);
397 int application_socket = -1;
1785d7f2 398
a13091b7
JG
399 thread_state = zmalloc(sizeof(*thread_state));
400 if (!thread_state) {
21fa020e
JG
401 goto error_alloc;
402 }
403 quit_pipe = lttng_pipe_open(FD_CLOEXEC);
404 if (!quit_pipe) {
1785d7f2
JG
405 goto error;
406 }
a13091b7
JG
407 thread_state->quit_pipe = quit_pipe;
408 thread_state->ust_cmd_queue = cmd_queue;
409 application_socket = create_application_socket();
410 if (application_socket < 0) {
411 goto error;
412 }
413 thread_state->application_socket = application_socket;
414 sem_init(&thread_state->ready, 0, 0);
1785d7f2
JG
415
416 thread = lttng_thread_create("UST application registration",
417 thread_application_registration,
418 shutdown_application_registration_thread,
419 cleanup_application_registration_thread,
a13091b7 420 thread_state);
1785d7f2
JG
421 if (!thread) {
422 goto error;
423 }
a13091b7
JG
424 /*
425 * The application registration thread now owns the application socket
426 * and the global thread state. The thread state is used to wait for
427 * the thread's status, but its ownership now belongs to the thread.
428 */
429 application_socket = -1;
430 if (!wait_thread_status(thread_state)) {
431 thread_state = NULL;
432 goto error;
86d0f119 433 }
a13091b7
JG
434
435 /* Notify all applications to register. */
436 ret = notify_ust_apps(1, is_root);
437 if (ret < 0) {
438 ERR("Failed to notify applications or create the wait shared memory.\n"
439 "Execution continues but there might be problems for already\n"
440 "running applications that wishes to register.");
441 }
442
bd9addf7 443 return thread;
1785d7f2 444error:
a13091b7
JG
445 lttng_thread_put(thread);
446 cleanup_application_registration_thread(thread_state);
447 if (application_socket >= 0) {
448 if (close(application_socket)) {
449 PERROR("Failed to close application registration socket");
450 }
451 }
21fa020e 452error_alloc:
bd9addf7 453 return NULL;
1785d7f2 454}
This page took 0.068564 seconds and 4 git commands to generate.