File: | lwan-thread.c |
Warning: | line 546, column 13 Value stored to 'accepted_connections' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* |
2 | * lwan - simple web server |
3 | * Copyright (c) 2012, 2013 Leandro A. F. Pereira <leandro@hardinfo.org> |
4 | * |
5 | * This program is free software; you can redistribute it and/or |
6 | * modify it under the terms of the GNU General Public License |
7 | * as published by the Free Software Foundation; either version 2 |
8 | * of the License, or any later version. |
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 |
16 | * along with this program; if not, write to the Free Software |
17 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, |
18 | * USA. |
19 | */ |
20 | |
21 | #define _GNU_SOURCE |
22 | #include <assert.h> |
23 | #include <errno(*__errno_location ()).h> |
24 | #include <fcntl.h> |
25 | #include <pthread.h> |
26 | #include <sched.h> |
27 | #include <stdlib.h> |
28 | #include <string.h> |
29 | #include <sys/epoll.h> |
30 | #include <sys/ioctl.h> |
31 | #include <sys/socket.h> |
32 | #include <unistd.h> |
33 | |
34 | #include "lwan-private.h" |
35 | #include "lwan-tq.h" |
36 | #include "list.h" |
37 | |
38 | static void lwan_strbuf_free_defer(void *data) |
39 | { |
40 | lwan_strbuf_free((struct lwan_strbuf *)data); |
41 | } |
42 | |
43 | static void graceful_close(struct lwan *l, |
44 | struct lwan_connection *conn, |
45 | char buffer[static DEFAULT_BUFFER_SIZE4096]) |
46 | { |
47 | int fd = lwan_connection_get_fd(l, conn); |
48 | |
49 | while (TIOCOUTQ0x5411) { |
50 | /* This ioctl isn't probably doing what it says on the tin; the details |
51 | * are subtle, but it seems to do the trick to allow gracefully closing |
52 | * the connection in some cases with minimal system calls. */ |
53 | int bytes_waiting; |
54 | int r = ioctl(fd, TIOCOUTQ0x5411, &bytes_waiting); |
55 | |
56 | if (!r && !bytes_waiting) /* See note about close(2) below. */ |
57 | return; |
58 | if (r < 0 && errno(*__errno_location ()) == EINTR4) |
59 | continue; |
60 | |
61 | break; |
62 | } |
63 | |
64 | if (UNLIKELY(shutdown(fd, SHUT_WR) < 0)__builtin_expect(((shutdown(fd, SHUT_WR) < 0)), (0))) { |
65 | if (UNLIKELY(errno == ENOTCONN)__builtin_expect((((*__errno_location ()) == 107)), (0))) |
66 | return; |
67 | } |
68 | |
69 | for (int tries = 0; tries < 20; tries++) { |
70 | ssize_t r = read(fd, buffer, DEFAULT_BUFFER_SIZE4096); |
71 | |
72 | if (!r) |
73 | break; |
74 | |
75 | if (r < 0) { |
76 | switch (errno(*__errno_location ())) { |
77 | case EAGAIN11: |
78 | break; |
79 | case EINTR4: |
80 | continue; |
81 | default: |
82 | return; |
83 | } |
84 | } |
85 | |
86 | coro_yield(conn->coro, CONN_CORO_WANT_READ); |
87 | } |
88 | |
89 | /* close(2) will be called when the coroutine yields with CONN_CORO_ABORT */ |
90 | } |
91 | |
92 | __attribute__((noreturn)) static int process_request_coro(struct coro *coro, |
93 | void *data) |
94 | { |
95 | /* NOTE: This function should not return; coro_yield should be used |
96 | * instead. This ensures the storage for `strbuf` is alive when the |
97 | * coroutine ends and lwan_strbuf_free() is called. */ |
98 | struct lwan_connection *conn = data; |
99 | struct lwan *lwan = conn->thread->lwan; |
100 | int fd = lwan_connection_get_fd(lwan, conn); |
101 | enum lwan_request_flags flags = lwan->config.request_flags; |
102 | struct lwan_strbuf strbuf = LWAN_STRBUF_STATIC_INIT(struct lwan_strbuf) { .buffer = "" }; |
103 | char request_buffer[DEFAULT_BUFFER_SIZE4096]; |
104 | struct lwan_value buffer = {.value = request_buffer, .len = 0}; |
105 | char *next_request = NULL((void*)0); |
106 | char *header_start[N_HEADER_START64]; |
107 | struct lwan_proxy proxy; |
108 | const int error_when_n_packets = lwan_calculate_n_packets(DEFAULT_BUFFER_SIZE4096); |
109 | |
110 | coro_defer(coro, lwan_strbuf_free_defer, &strbuf); |
111 | |
112 | const size_t init_gen = 1; /* 1 call to coro_defer() */ |
113 | assert(init_gen == coro_deferred_get_generation(coro))((void) sizeof ((init_gen == coro_deferred_get_generation(coro )) ? 1 : 0), __extension__ ({ if (init_gen == coro_deferred_get_generation (coro)) ; else __assert_fail ("init_gen == coro_deferred_get_generation(coro)" , "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 113, __extension__ __PRETTY_FUNCTION__); })); |
114 | |
115 | while (true1) { |
116 | struct lwan_request_parser_helper helper = { |
117 | .buffer = &buffer, |
118 | .next_request = next_request, |
119 | .error_when_n_packets = error_when_n_packets, |
120 | .header_start = header_start, |
121 | }; |
122 | struct lwan_request request = {.conn = conn, |
123 | .global_response_headers = &lwan->headers, |
124 | .fd = fd, |
125 | .response = {.buffer = &strbuf}, |
126 | .flags = flags, |
127 | .proxy = &proxy, |
128 | .helper = &helper}; |
129 | |
130 | lwan_process_request(lwan, &request); |
131 | |
132 | /* Run the deferred instructions now (except those used to initialize |
133 | * the coroutine), so that if the connection is gracefully closed, |
134 | * the storage for ``helper'' is still there. */ |
135 | coro_deferred_run(coro, init_gen); |
136 | |
137 | if (UNLIKELY(!(conn->flags & CONN_IS_KEEP_ALIVE))__builtin_expect(((!(conn->flags & CONN_IS_KEEP_ALIVE) )), (0))) { |
138 | graceful_close(lwan, conn, request_buffer); |
139 | break; |
140 | } |
141 | |
142 | if (next_request && *next_request) { |
143 | conn->flags |= CONN_CORK; |
144 | |
145 | if (!(conn->flags & CONN_EVENTS_WRITE)) |
146 | coro_yield(coro, CONN_CORO_WANT_WRITE); |
147 | } else { |
148 | conn->flags &= ~CONN_CORK; |
149 | coro_yield(coro, CONN_CORO_WANT_READ); |
150 | } |
151 | |
152 | /* Ensure string buffer is reset between requests, and that the backing |
153 | * store isn't over 2KB. */ |
154 | lwan_strbuf_reset_trim(&strbuf, 2048); |
155 | |
156 | /* Only allow flags from config. */ |
157 | flags = request.flags & (REQUEST_PROXIED | REQUEST_ALLOW_CORS); |
158 | next_request = helper.next_request; |
159 | } |
160 | |
161 | coro_yield(coro, CONN_CORO_ABORT); |
162 | __builtin_unreachable(); |
163 | } |
164 | |
165 | static ALWAYS_INLINEinline __attribute__((always_inline)) uint32_t |
166 | conn_flags_to_epoll_events(enum lwan_connection_flags flags) |
167 | { |
168 | static const uint32_t map[CONN_EVENTS_MASK + 1] = { |
169 | [0 /* Suspended (timer or await) */] = EPOLLRDHUPEPOLLRDHUP, |
170 | [CONN_EVENTS_WRITE] = EPOLLOUTEPOLLOUT | EPOLLRDHUPEPOLLRDHUP, |
171 | [CONN_EVENTS_READ] = EPOLLINEPOLLIN | EPOLLRDHUPEPOLLRDHUP, |
172 | [CONN_EVENTS_READ_WRITE] = EPOLLINEPOLLIN | EPOLLOUTEPOLLOUT | EPOLLRDHUPEPOLLRDHUP, |
173 | }; |
174 | |
175 | return map[flags & CONN_EVENTS_MASK]; |
176 | } |
177 | |
178 | static void update_epoll_flags(int fd, |
179 | struct lwan_connection *conn, |
180 | int epoll_fd, |
181 | enum lwan_connection_coro_yield yield_result) |
182 | { |
183 | static const enum lwan_connection_flags or_mask[CONN_CORO_MAX] = { |
184 | [CONN_CORO_YIELD] = 0, |
185 | |
186 | [CONN_CORO_WANT_READ_WRITE] = CONN_EVENTS_READ_WRITE, |
187 | [CONN_CORO_WANT_READ] = CONN_EVENTS_READ, |
188 | [CONN_CORO_WANT_WRITE] = CONN_EVENTS_WRITE, |
189 | |
190 | /* While the coro is suspended, we're not interested in either EPOLLIN |
191 | * or EPOLLOUT events. We still want to track this fd in epoll, though, |
192 | * so unset both so that only EPOLLRDHUP (plus the implicitly-set ones) |
193 | * are set. */ |
194 | [CONN_CORO_SUSPEND] = CONN_SUSPENDED, |
195 | |
196 | /* Ideally, when suspending a coroutine, the current flags&CONN_EVENTS_MASK |
197 | * would have to be stored and restored -- however, resuming as if the |
198 | * client coroutine is interested in a write event always guarantees that |
199 | * they'll be resumed as they're TCP sockets. There's a good chance that |
200 | * trying to read from a socket after resuming a coroutine will succeed, |
201 | * but if it doesn't because read() returns -EAGAIN, the I/O wrappers will |
202 | * yield with CONN_CORO_WANT_READ anyway. */ |
203 | [CONN_CORO_RESUME] = CONN_EVENTS_WRITE, |
204 | }; |
205 | static const enum lwan_connection_flags and_mask[CONN_CORO_MAX] = { |
206 | [CONN_CORO_YIELD] = ~0, |
207 | |
208 | [CONN_CORO_WANT_READ_WRITE] = ~0, |
209 | [CONN_CORO_WANT_READ] = ~CONN_EVENTS_WRITE, |
210 | [CONN_CORO_WANT_WRITE] = ~CONN_EVENTS_READ, |
211 | |
212 | [CONN_CORO_SUSPEND] = ~CONN_EVENTS_READ_WRITE, |
213 | [CONN_CORO_RESUME] = ~CONN_SUSPENDED, |
214 | }; |
215 | enum lwan_connection_flags prev_flags = conn->flags; |
216 | |
217 | conn->flags |= or_mask[yield_result]; |
218 | conn->flags &= and_mask[yield_result]; |
219 | |
220 | if (conn->flags == prev_flags) |
221 | return; |
222 | |
223 | struct epoll_event event = { |
224 | .events = conn_flags_to_epoll_events(conn->flags), |
225 | .data.ptr = conn, |
226 | }; |
227 | |
228 | if (UNLIKELY(epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &event) < 0)__builtin_expect(((epoll_ctl(epoll_fd, 3, fd, &event) < 0)), (0))) |
229 | lwan_status_perror("epoll_ctl")lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 229, __FUNCTION__, "epoll_ctl"); |
230 | } |
231 | |
232 | static void clear_async_await_flag(void *data) |
233 | { |
234 | struct lwan_connection *async_fd_conn = data; |
235 | |
236 | async_fd_conn->flags &= ~CONN_ASYNC_AWAIT; |
237 | } |
238 | |
239 | static enum lwan_connection_coro_yield |
240 | resume_async(struct timeout_queue *tq, |
241 | enum lwan_connection_coro_yield yield_result, |
242 | int64_t from_coro, |
243 | struct lwan_connection *conn, |
244 | int epoll_fd) |
245 | { |
246 | static const enum lwan_connection_flags to_connection_flags[] = { |
247 | [CONN_CORO_ASYNC_AWAIT_READ] = CONN_EVENTS_READ, |
248 | [CONN_CORO_ASYNC_AWAIT_WRITE] = CONN_EVENTS_WRITE, |
249 | [CONN_CORO_ASYNC_AWAIT_READ_WRITE] = CONN_EVENTS_READ_WRITE, |
250 | }; |
251 | int await_fd = (int)((uint64_t)from_coro >> 32); |
252 | enum lwan_connection_flags flags; |
253 | int op; |
254 | |
255 | assert(await_fd >= 0)((void) sizeof ((await_fd >= 0) ? 1 : 0), __extension__ ({ if (await_fd >= 0) ; else __assert_fail ("await_fd >= 0" , "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 255, __extension__ __PRETTY_FUNCTION__); })); |
256 | assert(yield_result >= CONN_CORO_ASYNC_AWAIT_READ &&((void) sizeof ((yield_result >= CONN_CORO_ASYNC_AWAIT_READ && yield_result <= CONN_CORO_ASYNC_AWAIT_READ_WRITE ) ? 1 : 0), __extension__ ({ if (yield_result >= CONN_CORO_ASYNC_AWAIT_READ && yield_result <= CONN_CORO_ASYNC_AWAIT_READ_WRITE ) ; else __assert_fail ("yield_result >= CONN_CORO_ASYNC_AWAIT_READ && yield_result <= CONN_CORO_ASYNC_AWAIT_READ_WRITE" , "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 257, __extension__ __PRETTY_FUNCTION__); })) |
257 | yield_result <= CONN_CORO_ASYNC_AWAIT_READ_WRITE)((void) sizeof ((yield_result >= CONN_CORO_ASYNC_AWAIT_READ && yield_result <= CONN_CORO_ASYNC_AWAIT_READ_WRITE ) ? 1 : 0), __extension__ ({ if (yield_result >= CONN_CORO_ASYNC_AWAIT_READ && yield_result <= CONN_CORO_ASYNC_AWAIT_READ_WRITE ) ; else __assert_fail ("yield_result >= CONN_CORO_ASYNC_AWAIT_READ && yield_result <= CONN_CORO_ASYNC_AWAIT_READ_WRITE" , "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 257, __extension__ __PRETTY_FUNCTION__); })); |
258 | |
259 | flags = to_connection_flags[yield_result]; |
260 | |
261 | struct lwan_connection *await_fd_conn = &tq->lwan->conns[await_fd]; |
262 | if (LIKELY(await_fd_conn->flags & CONN_ASYNC_AWAIT)__builtin_expect((!!(await_fd_conn->flags & CONN_ASYNC_AWAIT )), (1))) { |
263 | if (LIKELY((await_fd_conn->flags & CONN_EVENTS_MASK) == flags)__builtin_expect((!!((await_fd_conn->flags & CONN_EVENTS_MASK ) == flags)), (1))) |
264 | return CONN_CORO_SUSPEND; |
265 | |
266 | op = EPOLL_CTL_MOD3; |
267 | } else { |
268 | op = EPOLL_CTL_ADD1; |
269 | flags |= CONN_ASYNC_AWAIT; |
270 | coro_defer(conn->coro, clear_async_await_flag, await_fd_conn); |
271 | } |
272 | |
273 | struct epoll_event event = {.events = conn_flags_to_epoll_events(flags), |
274 | .data.ptr = conn}; |
275 | if (LIKELY(!epoll_ctl(epoll_fd, op, await_fd, &event))__builtin_expect((!!(!epoll_ctl(epoll_fd, op, await_fd, & event))), (1))) { |
276 | await_fd_conn->flags &= ~CONN_EVENTS_MASK; |
277 | await_fd_conn->flags |= flags; |
278 | return CONN_CORO_SUSPEND; |
279 | } |
280 | |
281 | return CONN_CORO_ABORT; |
282 | } |
283 | |
284 | static ALWAYS_INLINEinline __attribute__((always_inline)) void resume_coro(struct timeout_queue *tq, |
285 | struct lwan_connection *conn, |
286 | int epoll_fd) |
287 | { |
288 | assert(conn->coro)((void) sizeof ((conn->coro) ? 1 : 0), __extension__ ({ if (conn->coro) ; else __assert_fail ("conn->coro", "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 288, __extension__ __PRETTY_FUNCTION__); })); |
289 | |
290 | int64_t from_coro = coro_resume(conn->coro); |
291 | enum lwan_connection_coro_yield yield_result = from_coro & 0xffffffff; |
292 | |
293 | if (UNLIKELY(yield_result >= CONN_CORO_ASYNC)__builtin_expect(((yield_result >= CONN_CORO_ASYNC)), (0))) |
294 | yield_result = resume_async(tq, yield_result, from_coro, conn, epoll_fd); |
295 | |
296 | if (UNLIKELY(yield_result == CONN_CORO_ABORT)__builtin_expect(((yield_result == CONN_CORO_ABORT)), (0))) |
297 | return timeout_queue_expire(tq, conn); |
298 | |
299 | return update_epoll_flags(lwan_connection_get_fd(tq->lwan, conn), conn, |
300 | epoll_fd, yield_result); |
301 | } |
302 | |
303 | static void update_date_cache(struct lwan_thread *thread) |
304 | { |
305 | time_t now = time(NULL((void*)0)); |
306 | |
307 | lwan_format_rfc_time(now, thread->date.date); |
308 | lwan_format_rfc_time(now + (time_t)thread->lwan->config.expires, |
309 | thread->date.expires); |
310 | } |
311 | |
312 | static ALWAYS_INLINEinline __attribute__((always_inline)) void spawn_coro(struct lwan_connection *conn, |
313 | struct coro_switcher *switcher, |
314 | struct timeout_queue *tq) |
315 | { |
316 | struct lwan_thread *t = conn->thread; |
317 | |
318 | assert(!conn->coro)((void) sizeof ((!conn->coro) ? 1 : 0), __extension__ ({ if (!conn->coro) ; else __assert_fail ("!conn->coro", "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 318, __extension__ __PRETTY_FUNCTION__); })); |
319 | assert(t)((void) sizeof ((t) ? 1 : 0), __extension__ ({ if (t) ; else __assert_fail ("t", "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 319, __extension__ __PRETTY_FUNCTION__); })); |
320 | assert((uintptr_t)t >= (uintptr_t)tq->lwan->thread.threads)((void) sizeof (((uintptr_t)t >= (uintptr_t)tq->lwan-> thread.threads) ? 1 : 0), __extension__ ({ if ((uintptr_t)t >= (uintptr_t)tq->lwan->thread.threads) ; else __assert_fail ("(uintptr_t)t >= (uintptr_t)tq->lwan->thread.threads" , "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 320, __extension__ __PRETTY_FUNCTION__); })); |
321 | assert((uintptr_t)t <((void) sizeof (((uintptr_t)t < (uintptr_t)(tq->lwan-> thread.threads + tq->lwan->thread.count)) ? 1 : 0), __extension__ ({ if ((uintptr_t)t < (uintptr_t)(tq->lwan->thread. threads + tq->lwan->thread.count)) ; else __assert_fail ("(uintptr_t)t < (uintptr_t)(tq->lwan->thread.threads + tq->lwan->thread.count)" , "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 322, __extension__ __PRETTY_FUNCTION__); })) |
322 | (uintptr_t)(tq->lwan->thread.threads + tq->lwan->thread.count))((void) sizeof (((uintptr_t)t < (uintptr_t)(tq->lwan-> thread.threads + tq->lwan->thread.count)) ? 1 : 0), __extension__ ({ if ((uintptr_t)t < (uintptr_t)(tq->lwan->thread. threads + tq->lwan->thread.count)) ; else __assert_fail ("(uintptr_t)t < (uintptr_t)(tq->lwan->thread.threads + tq->lwan->thread.count)" , "/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 322, __extension__ __PRETTY_FUNCTION__); })); |
323 | |
324 | *conn = (struct lwan_connection) { |
325 | .coro = coro_new(switcher, process_request_coro, conn), |
326 | .flags = CONN_EVENTS_READ, |
327 | .time_to_expire = tq->current_time + tq->move_to_last_bump, |
328 | .thread = t, |
329 | }; |
330 | if (LIKELY(conn->coro)__builtin_expect((!!(conn->coro)), (1))) { |
331 | timeout_queue_insert(tq, conn); |
332 | return; |
333 | } |
334 | |
335 | /* FIXME: send a "busy" response to this client? we don't have a coroutine |
336 | * at this point, can't use lwan_send() here */ |
337 | lwan_status_error("Could not create coroutine, dropping connection")lwan_status_error_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 337, __FUNCTION__, "Could not create coroutine, dropping connection" ); |
338 | |
339 | conn->flags = 0; |
340 | |
341 | int fd = lwan_connection_get_fd(tq->lwan, conn); |
342 | shutdown(fd, SHUT_RDWRSHUT_RDWR); |
343 | close(fd); |
344 | } |
345 | |
346 | static bool_Bool process_pending_timers(struct timeout_queue *tq, |
347 | struct lwan_thread *t, |
348 | int epoll_fd) |
349 | { |
350 | struct timeout *timeout; |
351 | bool_Bool should_expire_timers = false0; |
352 | |
353 | while ((timeout = timeouts_get(t->wheel))) { |
354 | struct lwan_request *request; |
355 | |
356 | if (timeout == &tq->timeout) { |
357 | should_expire_timers = true1; |
358 | continue; |
359 | } |
360 | |
361 | request = container_of(timeout, struct lwan_request, timeout)((struct lwan_request *) ((char *)(timeout) - __builtin_offsetof (struct lwan_request, timeout)) + ((typeof(*(timeout)) *)0 != (typeof(((struct lwan_request *)0)->timeout) *)0)); |
362 | |
363 | update_epoll_flags(request->fd, request->conn, epoll_fd, |
364 | CONN_CORO_RESUME); |
365 | } |
366 | |
367 | if (should_expire_timers) { |
368 | timeout_queue_expire_waiting(tq); |
369 | |
370 | /* tq timeout expires every 1000ms if there are connections, so |
371 | * update the date cache at this point as well. */ |
372 | update_date_cache(t); |
373 | |
374 | if (!timeout_queue_empty(tq)) { |
375 | timeouts_add(t->wheel, &tq->timeout, 1000); |
376 | return true1; |
377 | } |
378 | |
379 | timeouts_del(t->wheel, &tq->timeout); |
380 | } |
381 | |
382 | return false0; |
383 | } |
384 | |
385 | static int |
386 | turn_timer_wheel(struct timeout_queue *tq, struct lwan_thread *t, int epoll_fd) |
387 | { |
388 | const int infinite_timeout = -1; |
389 | timeout_t wheel_timeout; |
390 | struct timespec now; |
391 | |
392 | if (UNLIKELY(clock_gettime(monotonic_clock_id, &now) < 0)__builtin_expect(((clock_gettime(monotonic_clock_id, &now ) < 0)), (0))) |
393 | lwan_status_critical("Could not get monotonic time")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 393, __FUNCTION__, "Could not get monotonic time"); |
394 | |
395 | timeouts_update(t->wheel, |
396 | (timeout_t)(now.tv_sec * 1000 + now.tv_nsec / 1000000)); |
397 | |
398 | /* Check if there's an expired timer. */ |
399 | wheel_timeout = timeouts_timeout(t->wheel); |
400 | if (wheel_timeout > 0) { |
401 | return (int)wheel_timeout; /* No, but will soon. Wake us up in |
402 | wheel_timeout ms. */ |
403 | } |
404 | |
405 | if (UNLIKELY((int64_t)wheel_timeout < 0)__builtin_expect((((int64_t)wheel_timeout < 0)), (0))) |
406 | return infinite_timeout; /* None found. */ |
407 | |
408 | if (!process_pending_timers(tq, t, epoll_fd)) |
409 | return infinite_timeout; /* No more timers to process. */ |
410 | |
411 | /* After processing pending timers, determine when to wake up. */ |
412 | return (int)timeouts_timeout(t->wheel); |
413 | } |
414 | |
415 | enum herd_accept { HERD_MORE = 0, HERD_GONE = -1, HERD_SHUTDOWN = 1 }; |
416 | |
417 | static ALWAYS_INLINEinline __attribute__((always_inline)) enum herd_accept |
418 | accept_one(struct lwan *l, const struct lwan_thread *t) |
419 | { |
420 | int fd = accept4(t->listen_fd, NULL((void*)0), NULL((void*)0), SOCK_NONBLOCKSOCK_NONBLOCK | SOCK_CLOEXECSOCK_CLOEXEC); |
421 | |
422 | if (LIKELY(fd >= 0)__builtin_expect((!!(fd >= 0)), (1))) { |
423 | struct epoll_event ev = { |
424 | .data.ptr = &l->conns[fd], |
425 | .events = conn_flags_to_epoll_events(CONN_EVENTS_READ), |
426 | }; |
427 | epoll_ctl(t->epoll_fd, EPOLL_CTL_ADD1, fd, &ev); |
428 | |
429 | return HERD_MORE; |
430 | } |
431 | |
432 | switch (errno(*__errno_location ())) { |
433 | case EAGAIN11: |
434 | return HERD_GONE; |
435 | |
436 | case EBADF9: |
437 | case ECONNABORTED103: |
438 | case EINVAL22: |
439 | lwan_status_info("Listening socket closed")lwan_status_info_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 439, __FUNCTION__, "Listening socket closed"); |
440 | return HERD_SHUTDOWN; |
441 | |
442 | default: |
443 | lwan_status_perror("accept")lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 443, __FUNCTION__, "accept"); |
444 | return HERD_MORE; |
445 | } |
446 | } |
447 | |
448 | static bool_Bool try_accept_connections(const struct lwan_thread *t) |
449 | { |
450 | struct lwan *lwan = t->lwan; |
451 | enum herd_accept ha; |
452 | |
453 | while ((ha = accept_one(lwan, t)) == HERD_MORE) { |
454 | } |
455 | |
456 | if (ha > HERD_MORE) |
457 | return false0; |
458 | |
459 | return true1; |
460 | } |
461 | |
462 | static int create_listen_socket(struct lwan_thread *t, bool_Bool print_listening_msg) |
463 | { |
464 | int listen_fd; |
465 | |
466 | listen_fd = lwan_create_listen_socket(t->lwan, print_listening_msg); |
467 | if (listen_fd < 0) |
468 | lwan_status_critical("Could not create listen_fd")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 468, __FUNCTION__, "Could not create listen_fd"); |
469 | |
470 | struct epoll_event event = { |
471 | .events = EPOLLINEPOLLIN | EPOLLETEPOLLET | EPOLLERREPOLLERR, |
472 | .data.ptr = NULL((void*)0), |
473 | }; |
474 | if (epoll_ctl(t->epoll_fd, EPOLL_CTL_ADD1, listen_fd, &event) < 0) |
475 | lwan_status_critical_perror("Could not add socket to epoll")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 475, __FUNCTION__, "Could not add socket to epoll"); |
476 | |
477 | return listen_fd; |
478 | } |
479 | |
480 | static void *thread_io_loop(void *data) |
481 | { |
482 | struct lwan_thread *t = data; |
483 | int epoll_fd = t->epoll_fd; |
484 | const int max_events = LWAN_MIN((int)t->lwan->thread.max_fd, 1024)({ const __typeof__(((int)t->lwan->thread.max_fd) + 0) lwan_tmp_id4 = ((int)t->lwan->thread.max_fd); const __typeof__((1024 ) + 0) lwan_tmp_id5 = (1024); lwan_tmp_id4 > lwan_tmp_id5 ? lwan_tmp_id5 : lwan_tmp_id4; }); |
485 | struct lwan *lwan = t->lwan; |
486 | struct epoll_event *events; |
487 | struct coro_switcher switcher; |
488 | struct timeout_queue tq; |
489 | |
490 | lwan_status_debug("Worker thread #%zd starting",lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 491, __FUNCTION__, "Worker thread #%zd starting", t - t-> lwan->thread.threads + 1) |
491 | t - t->lwan->thread.threads + 1)lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 491, __FUNCTION__, "Worker thread #%zd starting", t - t-> lwan->thread.threads + 1); |
492 | lwan_set_thread_name("worker"); |
493 | |
494 | events = calloc((size_t)max_events, sizeof(*events)); |
495 | if (UNLIKELY(!events)__builtin_expect(((!events)), (0))) |
496 | lwan_status_critical("Could not allocate memory for events")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 496, __FUNCTION__, "Could not allocate memory for events"); |
497 | |
498 | update_date_cache(t); |
499 | |
500 | timeout_queue_init(&tq, lwan); |
501 | |
502 | pthread_barrier_wait(&lwan->thread.barrier); |
503 | |
504 | for (;;) { |
505 | int timeout = turn_timer_wheel(&tq, t, epoll_fd); |
506 | int n_fds = epoll_wait(epoll_fd, events, max_events, timeout); |
507 | bool_Bool accepted_connections = false0; |
508 | |
509 | if (UNLIKELY(n_fds < 0)__builtin_expect(((n_fds < 0)), (0))) { |
510 | if (errno(*__errno_location ()) == EBADF9 || errno(*__errno_location ()) == EINVAL22) |
511 | break; |
512 | continue; |
513 | } |
514 | |
515 | for (struct epoll_event *event = events; n_fds--; event++) { |
516 | struct lwan_connection *conn; |
517 | |
518 | if (!event->data.ptr) { |
519 | if (LIKELY(try_accept_connections(t))__builtin_expect((!!(try_accept_connections(t))), (1))) { |
520 | accepted_connections = true1; |
521 | continue; |
522 | } |
523 | close(epoll_fd); |
524 | epoll_fd = -1; |
525 | break; |
526 | } |
527 | |
528 | conn = event->data.ptr; |
529 | |
530 | if (UNLIKELY(event->events & (EPOLLRDHUP | EPOLLHUP))__builtin_expect(((event->events & (EPOLLRDHUP | EPOLLHUP ))), (0))) { |
531 | timeout_queue_expire(&tq, conn); |
532 | continue; |
533 | } |
534 | |
535 | if (!conn->coro) { |
536 | spawn_coro(conn, &switcher, &tq); |
537 | continue; |
538 | } |
539 | |
540 | resume_coro(&tq, conn, epoll_fd); |
541 | timeout_queue_move_to_last(&tq, conn); |
542 | } |
543 | |
544 | if (accepted_connections) { |
545 | timeouts_add(t->wheel, &tq.timeout, 1000); |
546 | accepted_connections = false0; |
Value stored to 'accepted_connections' is never read | |
547 | } |
548 | } |
549 | |
550 | pthread_barrier_wait(&lwan->thread.barrier); |
551 | |
552 | timeout_queue_expire_all(&tq); |
553 | free(events); |
554 | |
555 | return NULL((void*)0); |
556 | } |
557 | |
558 | static void create_thread(struct lwan *l, struct lwan_thread *thread) |
559 | { |
560 | int ignore; |
561 | pthread_attr_t attr; |
562 | |
563 | memset(thread, 0, sizeof(*thread)); |
564 | thread->lwan = l; |
565 | |
566 | thread->wheel = timeouts_open(&ignore); |
567 | if (!thread->wheel) |
568 | lwan_status_critical("Could not create timer wheel")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 568, __FUNCTION__, "Could not create timer wheel"); |
569 | |
570 | if ((thread->epoll_fd = epoll_create1(EPOLL_CLOEXECEPOLL_CLOEXEC)) < 0) |
571 | lwan_status_critical_perror("epoll_create")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 571, __FUNCTION__, "epoll_create"); |
572 | |
573 | if (pthread_attr_init(&attr)) |
574 | lwan_status_critical_perror("pthread_attr_init")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 574, __FUNCTION__, "pthread_attr_init"); |
575 | |
576 | if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEMPTHREAD_SCOPE_SYSTEM)) |
577 | lwan_status_critical_perror("pthread_attr_setscope")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 577, __FUNCTION__, "pthread_attr_setscope"); |
578 | |
579 | if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLEPTHREAD_CREATE_JOINABLE)) |
580 | lwan_status_critical_perror("pthread_attr_setdetachstate")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 580, __FUNCTION__, "pthread_attr_setdetachstate"); |
581 | |
582 | if (pthread_create(&thread->self, &attr, thread_io_loop, thread)) |
583 | lwan_status_critical_perror("pthread_create")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 583, __FUNCTION__, "pthread_create"); |
584 | |
585 | if (pthread_attr_destroy(&attr)) |
586 | lwan_status_critical_perror("pthread_attr_destroy")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 586, __FUNCTION__, "pthread_attr_destroy"); |
587 | } |
588 | |
589 | #if defined(__linux__1) && defined(__x86_64__1) |
590 | static bool_Bool read_cpu_topology(struct lwan *l, uint32_t siblings[]) |
591 | { |
592 | char path[PATH_MAX4096]; |
593 | |
594 | for (uint32_t i = 0; i < l->available_cpus; i++) |
595 | siblings[i] = 0xbebacafe; |
596 | |
597 | for (unsigned int i = 0; i < l->available_cpus; i++) { |
598 | FILE *sib; |
599 | uint32_t id, sibling; |
600 | char separator; |
601 | |
602 | snprintf(path, sizeof(path), |
603 | "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", |
604 | i); |
605 | |
606 | sib = fopen(path, "re"); |
607 | if (!sib) { |
608 | lwan_status_warning("Could not open `%s` to determine CPU topology",lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 609, __FUNCTION__, "Could not open `%s` to determine CPU topology" , path) |
609 | path)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 609, __FUNCTION__, "Could not open `%s` to determine CPU topology" , path); |
610 | return false0; |
611 | } |
612 | |
613 | switch (fscanf(sib, "%u%c%u", &id, &separator, &sibling)) { |
614 | case 2: /* No SMT */ |
615 | siblings[i] = id; |
616 | break; |
617 | case 3: /* SMT */ |
618 | if (!(separator == ',' || separator == '-')) { |
619 | lwan_status_critical("Expecting either ',' or '-' for sibling separator")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 619, __FUNCTION__, "Expecting either ',' or '-' for sibling separator" ); |
620 | __builtin_unreachable(); |
621 | } |
622 | |
623 | siblings[i] = sibling; |
624 | break; |
625 | default: |
626 | lwan_status_critical("%s has invalid format", path)lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 626, __FUNCTION__, "%s has invalid format", path); |
627 | __builtin_unreachable(); |
628 | } |
629 | |
630 | fclose(sib); |
631 | } |
632 | |
633 | /* Perform a sanity check here, as some systems seem to filter out the |
634 | * result of sysconf() to obtain the number of configured and online |
635 | * CPUs but don't bother changing what's available through sysfs as far |
636 | * as the CPU topology information goes. It's better to fall back to a |
637 | * possibly non-optimal setup than just crash during startup while |
638 | * trying to perform an out-of-bounds array access. */ |
639 | for (unsigned int i = 0; i < l->available_cpus; i++) { |
640 | if (siblings[i] == 0xbebacafe) { |
641 | lwan_status_warning("Could not determine sibling for CPU %d", i)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 641, __FUNCTION__, "Could not determine sibling for CPU %d" , i); |
642 | return false0; |
643 | } |
644 | |
645 | if (siblings[i] >= l->available_cpus) { |
646 | lwan_status_warning("CPU information topology says CPU %d exists, "lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 649, __FUNCTION__, "CPU information topology says CPU %d exists, " "but max available CPUs is %d (online CPUs: %d). " "Is Lwan running in a (broken) container?" , siblings[i], l->available_cpus, l->online_cpus) |
647 | "but max available CPUs is %d (online CPUs: %d). "lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 649, __FUNCTION__, "CPU information topology says CPU %d exists, " "but max available CPUs is %d (online CPUs: %d). " "Is Lwan running in a (broken) container?" , siblings[i], l->available_cpus, l->online_cpus) |
648 | "Is Lwan running in a (broken) container?",lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 649, __FUNCTION__, "CPU information topology says CPU %d exists, " "but max available CPUs is %d (online CPUs: %d). " "Is Lwan running in a (broken) container?" , siblings[i], l->available_cpus, l->online_cpus) |
649 | siblings[i], l->available_cpus, l->online_cpus)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 649, __FUNCTION__, "CPU information topology says CPU %d exists, " "but max available CPUs is %d (online CPUs: %d). " "Is Lwan running in a (broken) container?" , siblings[i], l->available_cpus, l->online_cpus); |
650 | return false0; |
651 | } |
652 | } |
653 | |
654 | return true1; |
655 | } |
656 | |
657 | static void |
658 | siblings_to_schedtbl(struct lwan *l, uint32_t siblings[], uint32_t schedtbl[]) |
659 | { |
660 | int *seen = alloca(l->available_cpus * sizeof(int))__builtin_alloca (l->available_cpus * sizeof(int)); |
661 | unsigned int n_schedtbl = 0; |
662 | |
663 | for (uint32_t i = 0; i < l->available_cpus; i++) |
664 | seen[i] = -1; |
665 | |
666 | for (uint32_t i = 0; i < l->available_cpus; i++) { |
667 | if (seen[siblings[i]] < 0) { |
668 | seen[siblings[i]] = (int)i; |
669 | } else { |
670 | schedtbl[n_schedtbl++] = (uint32_t)seen[siblings[i]]; |
671 | schedtbl[n_schedtbl++] = i; |
672 | } |
673 | } |
674 | |
675 | if (n_schedtbl != l->available_cpus) |
676 | memcpy(schedtbl, seen, l->available_cpus * sizeof(int)); |
677 | } |
678 | |
679 | static bool_Bool |
680 | topology_to_schedtbl(struct lwan *l, uint32_t schedtbl[], uint32_t n_threads) |
681 | { |
682 | uint32_t *siblings = alloca(l->available_cpus * sizeof(uint32_t))__builtin_alloca (l->available_cpus * sizeof(uint32_t)); |
683 | |
684 | if (read_cpu_topology(l, siblings)) { |
685 | uint32_t *affinity = alloca(l->available_cpus * sizeof(uint32_t))__builtin_alloca (l->available_cpus * sizeof(uint32_t)); |
686 | |
687 | siblings_to_schedtbl(l, siblings, affinity); |
688 | |
689 | for (uint32_t i = 0; i < n_threads; i++) |
690 | schedtbl[i] = affinity[i % l->available_cpus]; |
691 | return true1; |
692 | } |
693 | |
694 | for (uint32_t i = 0; i < n_threads; i++) |
695 | schedtbl[i] = (i / 2) % l->thread.count; |
696 | return false0; |
697 | } |
698 | |
699 | static void |
700 | adjust_threads_affinity(struct lwan *l, uint32_t *schedtbl, uint32_t mask) |
701 | { |
702 | for (uint32_t i = 0; i < l->thread.count; i++) { |
703 | cpu_set_t set; |
704 | |
705 | CPU_ZERO(&set)do __builtin_memset (&set, '\0', sizeof (cpu_set_t)); while (0); |
706 | CPU_SET(schedtbl[i & mask], &set)(__extension__ ({ size_t __cpu = (schedtbl[i & mask]); __cpu / 8 < (sizeof (cpu_set_t)) ? (((__cpu_mask *) ((&set) ->__bits))[((__cpu) / (8 * sizeof (__cpu_mask)))] |= ((__cpu_mask ) 1 << ((__cpu) % (8 * sizeof (__cpu_mask))))) : 0; })); |
707 | |
708 | if (pthread_setaffinity_np(l->thread.threads[i].self, sizeof(set), |
709 | &set)) |
710 | lwan_status_warning("Could not set affinity for thread %d", i)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 710, __FUNCTION__, "Could not set affinity for thread %d", i ); |
711 | } |
712 | } |
713 | #elif defined(__x86_64__1) |
714 | static bool_Bool |
715 | topology_to_schedtbl(struct lwan *l, uint32_t schedtbl[], uint32_t n_threads) |
716 | { |
717 | for (uint32_t i = 0; i < n_threads; i++) |
718 | schedtbl[i] = (i / 2) % l->thread.count; |
719 | return false0; |
720 | } |
721 | |
722 | static void |
723 | adjust_threads_affinity(struct lwan *l, uint32_t *schedtbl, uint32_t n) |
724 | { |
725 | } |
726 | #endif |
727 | |
728 | void lwan_thread_init(struct lwan *l) |
729 | { |
730 | if (pthread_barrier_init(&l->thread.barrier, NULL((void*)0), |
731 | (unsigned)l->thread.count + 1)) |
732 | lwan_status_critical("Could not create barrier")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 732, __FUNCTION__, "Could not create barrier"); |
733 | |
734 | lwan_status_debug("Initializing threads")lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 734, __FUNCTION__, "Initializing threads"); |
735 | |
736 | l->thread.threads = |
737 | calloc((size_t)l->thread.count, sizeof(struct lwan_thread)); |
738 | if (!l->thread.threads) |
739 | lwan_status_critical("Could not allocate memory for threads")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 739, __FUNCTION__, "Could not allocate memory for threads"); |
740 | |
741 | for (unsigned int i = 0; i < l->thread.count; i++) { |
742 | struct lwan_thread *thread = &l->thread.threads[i]; |
743 | |
744 | create_thread(l, thread); |
745 | |
746 | if ((thread->listen_fd = create_listen_socket(thread, i == 0)) < 0) |
747 | lwan_status_critical_perror("Could not create listening socket")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 747, __FUNCTION__, "Could not create listening socket"); |
748 | } |
749 | |
750 | const unsigned int total_conns = l->thread.max_fd * l->thread.count; |
751 | #ifdef __x86_64__1 |
752 | static_assert(sizeof(struct lwan_connection) == 32,extern int (*__Static_assert_function (void)) [!!sizeof (struct { int __error_if_negative: (sizeof(struct lwan_connection) == 32) ? 2 : -1; })] |
753 | "Two connections per cache line")extern int (*__Static_assert_function (void)) [!!sizeof (struct { int __error_if_negative: (sizeof(struct lwan_connection) == 32) ? 2 : -1; })]; |
754 | |
755 | lwan_status_debug("%d CPUs of %d are online. "lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 757, __FUNCTION__, "%d CPUs of %d are online. " "Reading topology to pre-schedule clients" , l->online_cpus, l->available_cpus) |
756 | "Reading topology to pre-schedule clients",lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 757, __FUNCTION__, "%d CPUs of %d are online. " "Reading topology to pre-schedule clients" , l->online_cpus, l->available_cpus) |
757 | l->online_cpus, l->available_cpus)lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 757, __FUNCTION__, "%d CPUs of %d are online. " "Reading topology to pre-schedule clients" , l->online_cpus, l->available_cpus); |
758 | |
759 | /* |
760 | * Pre-schedule each file descriptor, to reduce some operations in the |
761 | * fast path. |
762 | * |
763 | * Since struct lwan_connection is guaranteed to be 32-byte long, two of |
764 | * them can fill up a cache line. Assume siblings share cache lines and |
765 | * use the CPU topology to group two connections per cache line in such |
766 | * a way that false sharing is avoided. |
767 | */ |
768 | uint32_t n_threads = (uint32_t)lwan_nextpow2((size_t)((l->thread.count - 1) * 2)); |
769 | uint32_t *schedtbl = alloca(n_threads * sizeof(uint32_t))__builtin_alloca (n_threads * sizeof(uint32_t)); |
770 | |
771 | bool_Bool adj_affinity = topology_to_schedtbl(l, schedtbl, n_threads); |
772 | |
773 | n_threads--; /* Transform count into mask for AND below */ |
774 | |
775 | if (adj_affinity) |
776 | adjust_threads_affinity(l, schedtbl, n_threads); |
777 | |
778 | for (unsigned int i = 0; i < total_conns; i++) |
779 | l->conns[i].thread = &l->thread.threads[schedtbl[i & n_threads]]; |
780 | #else |
781 | for (unsigned int i = 0; i < total_conns; i++) |
782 | l->conns[i].thread = &l->thread.threads[i % l->thread.count]; |
783 | #endif |
784 | |
785 | pthread_barrier_wait(&l->thread.barrier); |
786 | |
787 | lwan_status_debug("Worker threads created and ready to serve")lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 787, __FUNCTION__, "Worker threads created and ready to serve" ); |
788 | } |
789 | |
790 | void lwan_thread_shutdown(struct lwan *l) |
791 | { |
792 | lwan_status_debug("Shutting down threads")lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 792, __FUNCTION__, "Shutting down threads"); |
793 | |
794 | for (unsigned int i = 0; i < l->thread.count; i++) { |
795 | struct lwan_thread *t = &l->thread.threads[i]; |
796 | int epoll_fd = t->epoll_fd; |
797 | int listen_fd = t->listen_fd; |
798 | |
799 | t->listen_fd = -1; |
800 | t->epoll_fd = -1; |
801 | close(epoll_fd); |
802 | close(listen_fd); |
803 | } |
804 | |
805 | pthread_barrier_wait(&l->thread.barrier); |
806 | pthread_barrier_destroy(&l->thread.barrier); |
807 | |
808 | for (unsigned int i = 0; i < l->thread.count; i++) { |
809 | struct lwan_thread *t = &l->thread.threads[i]; |
810 | |
811 | pthread_join(l->thread.threads[i].self, NULL((void*)0)); |
812 | timeouts_close(t->wheel); |
813 | } |
814 | |
815 | free(l->thread.threads); |
816 | } |