Fix: sessiond: leak of application socket on chmod failure
[lttng-tools.git] / src / bin / lttng-sessiond / ht-cleanup.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 <assert.h>
20
21 #include <common/hashtable/hashtable.h>
22 #include <common/common.h>
23 #include <common/utils.h>
24 #include <pthread.h>
25
26 #include "lttng-sessiond.h"
27 #include "health-sessiond.h"
28 #include "testpoint.h"
29 #include "utils.h"
30 #include "ht-cleanup.h"
31
32 static int ht_cleanup_quit_pipe[2] = { -1, -1 };
33
34 /*
35 * Check if the ht_cleanup thread quit pipe was triggered.
36 *
37 * Return true if it was triggered else false;
38 */
39 static bool check_quit_pipe(int fd, uint32_t events)
40 {
41 return (fd == ht_cleanup_quit_pipe[0] && (events & LPOLLIN));
42 }
43
44 static int init_pipe(int *pipe_fds)
45 {
46 int ret, i;
47
48 ret = pipe(pipe_fds);
49 if (ret < 0) {
50 PERROR("ht_cleanup thread quit pipe");
51 goto error;
52 }
53
54 for (i = 0; i < 2; i++) {
55 ret = fcntl(pipe_fds[i], F_SETFD, FD_CLOEXEC);
56 if (ret < 0) {
57 PERROR("fcntl ht_cleanup_quit_pipe");
58 goto error;
59 }
60 }
61 error:
62 return ret;
63 }
64
65 /*
66 * Create a poll set with O_CLOEXEC and add the thread quit pipe to the set.
67 */
68 static int set_pollset(struct lttng_poll_event *events, size_t size)
69 {
70 int ret;
71
72 ret = lttng_poll_create(events, size, LTTNG_CLOEXEC);
73 if (ret < 0) {
74 goto error;
75 }
76
77 ret = lttng_poll_add(events, ht_cleanup_quit_pipe[0],
78 LPOLLIN | LPOLLERR);
79 if (ret < 0) {
80 goto error;
81 }
82
83 ret = lttng_poll_add(events, ht_cleanup_pipe[0], LPOLLIN | LPOLLERR);
84 if (ret < 0) {
85 DBG("[ht-thread] lttng_poll_add error %d.", ret);
86 goto error;
87 }
88
89 return 0;
90
91 error:
92 return ret;
93 }
94
95 static void cleanup_ht_cleanup_thread(void *data)
96 {
97 utils_close_pipe(ht_cleanup_quit_pipe);
98 utils_close_pipe(ht_cleanup_pipe);
99 }
100
101 static void *thread_ht_cleanup(void *data)
102 {
103 int ret, i, pollfd, err = -1;
104 ssize_t size_ret;
105 uint32_t revents, nb_fd;
106 struct lttng_poll_event events;
107
108 DBG("[ht-thread] startup.");
109
110 rcu_register_thread();
111 rcu_thread_online();
112
113 health_register(health_sessiond, HEALTH_SESSIOND_TYPE_HT_CLEANUP);
114
115 if (testpoint(sessiond_thread_ht_cleanup)) {
116 DBG("[ht-thread] testpoint.");
117 goto error_testpoint;
118 }
119
120 health_code_update();
121
122 ret = set_pollset(&events, 2);
123 if (ret < 0) {
124 DBG("[ht-thread] sessiond_set_ht_cleanup_thread_pollset error %d.", ret);
125 goto error_poll_create;
126 }
127
128 health_code_update();
129
130 while (1) {
131 restart:
132 DBG3("[ht-thread] Polling.");
133 health_poll_entry();
134 ret = lttng_poll_wait(&events, -1);
135 DBG3("[ht-thread] Returning from poll on %d fds.",
136 LTTNG_POLL_GETNB(&events));
137 health_poll_exit();
138 if (ret < 0) {
139 /*
140 * Restart interrupted system call.
141 */
142 if (errno == EINTR) {
143 continue;
144 }
145 goto error;
146 }
147
148 nb_fd = ret;
149 for (i = 0; i < nb_fd; i++) {
150 struct lttng_ht *ht;
151
152 health_code_update();
153
154 /* Fetch once the poll data */
155 revents = LTTNG_POLL_GETEV(&events, i);
156 pollfd = LTTNG_POLL_GETFD(&events, i);
157
158 if (pollfd != ht_cleanup_pipe[0]) {
159 continue;
160 }
161
162 if (revents & LPOLLIN) {
163 /* Get socket from dispatch thread. */
164 size_ret = lttng_read(ht_cleanup_pipe[0], &ht,
165 sizeof(ht));
166 if (size_ret < sizeof(ht)) {
167 PERROR("ht cleanup notify pipe");
168 goto error;
169 }
170 health_code_update();
171 /*
172 * The whole point of this thread is to call
173 * lttng_ht_destroy from a context that is NOT:
174 * 1) a read-side RCU lock,
175 * 2) a call_rcu thread.
176 */
177 lttng_ht_destroy(ht);
178
179 health_code_update();
180
181 /*
182 * Ensure that we never process the quit pipe
183 * event while there is still data available
184 * on the ht clean pipe.
185 */
186 goto restart;
187 } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
188 ERR("ht cleanup pipe error");
189 goto error;
190 } else {
191 ERR("Unexpected poll events %u for sock %d", revents, pollfd);
192 goto error;
193 }
194 }
195
196 for (i = 0; i < nb_fd; i++) {
197 health_code_update();
198
199 /* Fetch once the poll data */
200 revents = LTTNG_POLL_GETEV(&events, i);
201 pollfd = LTTNG_POLL_GETFD(&events, i);
202
203 if (!revents) {
204 /* No activity for this FD (poll implementation). */
205 continue;
206 }
207
208 if (pollfd == ht_cleanup_pipe[0]) {
209 continue;
210 }
211
212 /* Thread quit pipe has been closed. Killing thread. */
213 ret = check_quit_pipe(pollfd, revents);
214 if (ret) {
215 err = 0;
216 DBG("[ht-cleanup] quit.");
217 goto exit;
218 }
219 }
220 }
221
222 exit:
223 error:
224 lttng_poll_clean(&events);
225 error_poll_create:
226 error_testpoint:
227 DBG("[ht-cleanup] Thread terminates.");
228 if (err) {
229 health_error();
230 ERR("Health error occurred in %s", __func__);
231 }
232 health_unregister(health_sessiond);
233 rcu_thread_offline();
234 rcu_unregister_thread();
235 return NULL;
236 }
237
238 static bool shutdown_ht_cleanup_thread(void *data)
239 {
240 int ret;
241
242 ret = notify_thread_pipe(ht_cleanup_quit_pipe[1]);
243 if (ret < 0) {
244 ERR("write error on ht_cleanup quit pipe");
245 goto end;
246 }
247 end:
248 return ret;
249 }
250
251 struct lttng_thread *launch_ht_cleanup_thread(void)
252 {
253 int ret;
254 struct lttng_thread *thread;
255
256 ret = init_pipe(ht_cleanup_pipe);
257 if (ret) {
258 goto error;
259 }
260
261 ret = init_pipe(ht_cleanup_quit_pipe);
262 if (ret) {
263 goto error;
264 }
265
266 thread = lttng_thread_create("HT cleanup",
267 thread_ht_cleanup,
268 shutdown_ht_cleanup_thread,
269 cleanup_ht_cleanup_thread,
270 NULL);
271 if (!thread) {
272 goto error;
273 }
274 return thread;
275 error:
276 cleanup_ht_cleanup_thread(NULL);
277 return NULL;
278 }
This page took 0.035548 seconds and 4 git commands to generate.