Bug Summary

File:lwan-thread.c
Warning:line 852, column 31
Array subscript is undefined

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name lwan-thread.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -fno-plt -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/clang/11.1.0 -include /home/buildbot/lwan-worker/clang-analyze/build/lwan-build-config.h -D _FILE_OFFSET_BITS=64 -D _TIME_BITS=64 -I /home/buildbot/lwan-worker/clang-analyze/build/src/lib/missing -I /usr/include/luajit-2.0 -I /usr/include/valgrind -I /home/buildbot/lwan-worker/clang-analyze/build/src/lib -I /home/buildbot/lwan-worker/clang-analyze/build -internal-isystem /usr/local/include -internal-isystem /usr/lib/clang/11.1.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-unused-parameter -Wno-free-nonheap-object -std=gnu99 -fdebug-compilation-dir /home/buildbot/lwan-worker/clang-analyze/build/src/lib -ferror-limit 19 -stack-protector 2 -fgnuc-version=4.2.1 -analyzer-output=html -faddrsig -o /home/buildbot/lwan-worker/clang-analyze/CLANG/2021-05-08-202938-3935675-1 -x c /home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c
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#if defined(HAVE_EVENTFD)
35#include <sys/eventfd.h>
36#endif
37
38#include "lwan-private.h"
39#include "lwan-tq.h"
40#include "list.h"
41
42static void lwan_strbuf_free_defer(void *data)
43{
44 lwan_strbuf_free((struct lwan_strbuf *)data);
45}
46
47static void graceful_close(struct lwan *l,
48 struct lwan_connection *conn,
49 char buffer[static DEFAULT_BUFFER_SIZE4096])
50{
51 int fd = lwan_connection_get_fd(l, conn);
52
53 while (TIOCOUTQ0x5411) {
54 /* This ioctl isn't probably doing what it says on the tin; the details
55 * are subtle, but it seems to do the trick to allow gracefully closing
56 * the connection in some cases with minimal system calls. */
57 int bytes_waiting;
58 int r = ioctl(fd, TIOCOUTQ0x5411, &bytes_waiting);
59
60 if (!r && !bytes_waiting) /* See note about close(2) below. */
61 return;
62 if (r < 0 && errno(*__errno_location ()) == EINTR4)
63 continue;
64
65 break;
66 }
67
68 if (UNLIKELY(shutdown(fd, SHUT_WR) < 0)__builtin_expect(((shutdown(fd, SHUT_WR) < 0)), (0))) {
69 if (UNLIKELY(errno == ENOTCONN)__builtin_expect((((*__errno_location ()) == 107)), (0)))
70 return;
71 }
72
73 for (int tries = 0; tries < 20; tries++) {
74 ssize_t r = read(fd, buffer, DEFAULT_BUFFER_SIZE4096);
75
76 if (!r)
77 break;
78
79 if (r < 0) {
80 switch (errno(*__errno_location ())) {
81 case EAGAIN11:
82 break;
83 case EINTR4:
84 continue;
85 default:
86 return;
87 }
88 }
89
90 coro_yield(conn->coro, CONN_CORO_WANT_READ);
91 }
92
93 /* close(2) will be called when the coroutine yields with CONN_CORO_ABORT */
94}
95
96__attribute__((noreturn)) static int process_request_coro(struct coro *coro,
97 void *data)
98{
99 /* NOTE: This function should not return; coro_yield should be used
100 * instead. This ensures the storage for `strbuf` is alive when the
101 * coroutine ends and lwan_strbuf_free() is called. */
102 struct lwan_connection *conn = data;
103 struct lwan *lwan = conn->thread->lwan;
104 int fd = lwan_connection_get_fd(lwan, conn);
105 enum lwan_request_flags flags = lwan->config.request_flags;
106 struct lwan_strbuf strbuf = LWAN_STRBUF_STATIC_INIT(struct lwan_strbuf) { .buffer = "" };
107 char request_buffer[DEFAULT_BUFFER_SIZE4096];
108 struct lwan_value buffer = {.value = request_buffer, .len = 0};
109 char *next_request = NULL((void*)0);
110 char *header_start[N_HEADER_START64];
111 struct lwan_proxy proxy;
112 const int error_when_n_packets = lwan_calculate_n_packets(DEFAULT_BUFFER_SIZE4096);
113
114 coro_defer(coro, lwan_strbuf_free_defer, &strbuf);
115
116 const size_t init_gen = 1; /* 1 call to coro_defer() */
117 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"
, 117, __extension__ __PRETTY_FUNCTION__); }))
;
118
119 while (true1) {
120 struct lwan_request_parser_helper helper = {
121 .buffer = &buffer,
122 .next_request = next_request,
123 .error_when_n_packets = error_when_n_packets,
124 .header_start = header_start,
125 };
126 struct lwan_request request = {.conn = conn,
127 .global_response_headers = &lwan->headers,
128 .fd = fd,
129 .response = {.buffer = &strbuf},
130 .flags = flags,
131 .proxy = &proxy,
132 .helper = &helper};
133
134 lwan_process_request(lwan, &request);
135
136 /* Run the deferred instructions now (except those used to initialize
137 * the coroutine), so that if the connection is gracefully closed,
138 * the storage for ``helper'' is still there. */
139 coro_deferred_run(coro, init_gen);
140
141 if (UNLIKELY(!(conn->flags & CONN_IS_KEEP_ALIVE))__builtin_expect(((!(conn->flags & CONN_IS_KEEP_ALIVE)
)), (0))
) {
142 graceful_close(lwan, conn, request_buffer);
143 break;
144 }
145
146 if (next_request && *next_request) {
147 conn->flags |= CONN_CORK;
148
149 if (!(conn->flags & CONN_EVENTS_WRITE))
150 coro_yield(coro, CONN_CORO_WANT_WRITE);
151 } else {
152 conn->flags &= ~CONN_CORK;
153 coro_yield(coro, CONN_CORO_WANT_READ);
154 }
155
156 /* Ensure string buffer is reset between requests, and that the backing
157 * store isn't over 2KB. */
158 lwan_strbuf_reset_trim(&strbuf, 2048);
159
160 /* Only allow flags from config. */
161 flags = request.flags & (REQUEST_PROXIED | REQUEST_ALLOW_CORS);
162 next_request = helper.next_request;
163 }
164
165 coro_yield(coro, CONN_CORO_ABORT);
166 __builtin_unreachable();
167}
168
169static ALWAYS_INLINEinline __attribute__((always_inline)) uint32_t
170conn_flags_to_epoll_events(enum lwan_connection_flags flags)
171{
172 static const uint32_t map[CONN_EVENTS_MASK + 1] = {
173 [0 /* Suspended (timer or await) */] = EPOLLRDHUPEPOLLRDHUP,
174 [CONN_EVENTS_WRITE] = EPOLLOUTEPOLLOUT | EPOLLRDHUPEPOLLRDHUP,
175 [CONN_EVENTS_READ] = EPOLLINEPOLLIN | EPOLLRDHUPEPOLLRDHUP,
176 [CONN_EVENTS_READ_WRITE] = EPOLLINEPOLLIN | EPOLLOUTEPOLLOUT | EPOLLRDHUPEPOLLRDHUP,
177 };
178
179 return map[flags & CONN_EVENTS_MASK];
180}
181
182static void update_epoll_flags(int fd,
183 struct lwan_connection *conn,
184 int epoll_fd,
185 enum lwan_connection_coro_yield yield_result)
186{
187 static const enum lwan_connection_flags or_mask[CONN_CORO_MAX] = {
188 [CONN_CORO_YIELD] = 0,
189
190 [CONN_CORO_WANT_READ_WRITE] = CONN_EVENTS_READ_WRITE,
191 [CONN_CORO_WANT_READ] = CONN_EVENTS_READ,
192 [CONN_CORO_WANT_WRITE] = CONN_EVENTS_WRITE,
193
194 /* While the coro is suspended, we're not interested in either EPOLLIN
195 * or EPOLLOUT events. We still want to track this fd in epoll, though,
196 * so unset both so that only EPOLLRDHUP (plus the implicitly-set ones)
197 * are set. */
198 [CONN_CORO_SUSPEND] = CONN_SUSPENDED,
199
200 /* Ideally, when suspending a coroutine, the current flags&CONN_EVENTS_MASK
201 * would have to be stored and restored -- however, resuming as if the
202 * client coroutine is interested in a write event always guarantees that
203 * they'll be resumed as they're TCP sockets. There's a good chance that
204 * trying to read from a socket after resuming a coroutine will succeed,
205 * but if it doesn't because read() returns -EAGAIN, the I/O wrappers will
206 * yield with CONN_CORO_WANT_READ anyway. */
207 [CONN_CORO_RESUME] = CONN_EVENTS_WRITE,
208 };
209 static const enum lwan_connection_flags and_mask[CONN_CORO_MAX] = {
210 [CONN_CORO_YIELD] = ~0,
211
212 [CONN_CORO_WANT_READ_WRITE] = ~0,
213 [CONN_CORO_WANT_READ] = ~CONN_EVENTS_WRITE,
214 [CONN_CORO_WANT_WRITE] = ~CONN_EVENTS_READ,
215
216 [CONN_CORO_SUSPEND] = ~CONN_EVENTS_READ_WRITE,
217 [CONN_CORO_RESUME] = ~CONN_SUSPENDED,
218 };
219 enum lwan_connection_flags prev_flags = conn->flags;
220
221 conn->flags |= or_mask[yield_result];
222 conn->flags &= and_mask[yield_result];
223
224 if (conn->flags == prev_flags)
225 return;
226
227 struct epoll_event event = {
228 .events = conn_flags_to_epoll_events(conn->flags),
229 .data.ptr = conn,
230 };
231
232 if (UNLIKELY(epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &event) < 0)__builtin_expect(((epoll_ctl(epoll_fd, 3, fd, &event) <
0)), (0))
)
233 lwan_status_perror("epoll_ctl")lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 233, __FUNCTION__, "epoll_ctl")
;
234}
235
236static void clear_async_await_flag(void *data)
237{
238 struct lwan_connection *async_fd_conn = data;
239
240 async_fd_conn->flags &= ~CONN_ASYNC_AWAIT;
241}
242
243static enum lwan_connection_coro_yield
244resume_async(struct timeout_queue *tq,
245 enum lwan_connection_coro_yield yield_result,
246 int64_t from_coro,
247 struct lwan_connection *conn,
248 int epoll_fd)
249{
250 static const enum lwan_connection_flags to_connection_flags[] = {
251 [CONN_CORO_ASYNC_AWAIT_READ] = CONN_EVENTS_READ,
252 [CONN_CORO_ASYNC_AWAIT_WRITE] = CONN_EVENTS_WRITE,
253 [CONN_CORO_ASYNC_AWAIT_READ_WRITE] = CONN_EVENTS_READ_WRITE,
254 };
255 int await_fd = (int)((uint64_t)from_coro >> 32);
256 enum lwan_connection_flags flags;
257 int op;
258
259 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"
, 259, __extension__ __PRETTY_FUNCTION__); }))
;
260 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"
, 261, __extension__ __PRETTY_FUNCTION__); }))
261 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"
, 261, __extension__ __PRETTY_FUNCTION__); }))
;
262
263 flags = to_connection_flags[yield_result];
264
265 struct lwan_connection *await_fd_conn = &tq->lwan->conns[await_fd];
266 if (LIKELY(await_fd_conn->flags & CONN_ASYNC_AWAIT)__builtin_expect((!!(await_fd_conn->flags & CONN_ASYNC_AWAIT
)), (1))
) {
267 if (LIKELY((await_fd_conn->flags & CONN_EVENTS_MASK) == flags)__builtin_expect((!!((await_fd_conn->flags & CONN_EVENTS_MASK
) == flags)), (1))
)
268 return CONN_CORO_SUSPEND;
269
270 op = EPOLL_CTL_MOD3;
271 } else {
272 op = EPOLL_CTL_ADD1;
273 flags |= CONN_ASYNC_AWAIT;
274 coro_defer(conn->coro, clear_async_await_flag, await_fd_conn);
275 }
276
277 struct epoll_event event = {.events = conn_flags_to_epoll_events(flags),
278 .data.ptr = conn};
279 if (LIKELY(!epoll_ctl(epoll_fd, op, await_fd, &event))__builtin_expect((!!(!epoll_ctl(epoll_fd, op, await_fd, &
event))), (1))
) {
280 await_fd_conn->flags &= ~CONN_EVENTS_MASK;
281 await_fd_conn->flags |= flags;
282 return CONN_CORO_SUSPEND;
283 }
284
285 return CONN_CORO_ABORT;
286}
287
288static ALWAYS_INLINEinline __attribute__((always_inline)) void resume_coro(struct timeout_queue *tq,
289 struct lwan_connection *conn,
290 int epoll_fd)
291{
292 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"
, 292, __extension__ __PRETTY_FUNCTION__); }))
;
293
294 int64_t from_coro = coro_resume(conn->coro);
295 enum lwan_connection_coro_yield yield_result = from_coro & 0xffffffff;
296
297 if (UNLIKELY(yield_result >= CONN_CORO_ASYNC)__builtin_expect(((yield_result >= CONN_CORO_ASYNC)), (0)))
298 yield_result = resume_async(tq, yield_result, from_coro, conn, epoll_fd);
299
300 if (UNLIKELY(yield_result == CONN_CORO_ABORT)__builtin_expect(((yield_result == CONN_CORO_ABORT)), (0)))
301 return timeout_queue_expire(tq, conn);
302
303 return update_epoll_flags(lwan_connection_get_fd(tq->lwan, conn), conn,
304 epoll_fd, yield_result);
305}
306
307static void update_date_cache(struct lwan_thread *thread)
308{
309 time_t now = time(NULL((void*)0));
310
311 lwan_format_rfc_time(now, thread->date.date);
312 lwan_format_rfc_time(now + (time_t)thread->lwan->config.expires,
313 thread->date.expires);
314}
315
316static ALWAYS_INLINEinline __attribute__((always_inline)) bool_Bool spawn_coro(struct lwan_connection *conn,
317 struct coro_switcher *switcher,
318 struct timeout_queue *tq)
319{
320 struct lwan_thread *t = conn->thread;
321
322 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"
, 322, __extension__ __PRETTY_FUNCTION__); }))
;
323 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"
, 323, __extension__ __PRETTY_FUNCTION__); }))
;
324 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"
, 324, __extension__ __PRETTY_FUNCTION__); }))
;
325 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"
, 326, __extension__ __PRETTY_FUNCTION__); }))
326 (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"
, 326, __extension__ __PRETTY_FUNCTION__); }))
;
327
328 *conn = (struct lwan_connection) {
329 .coro = coro_new(switcher, process_request_coro, conn),
330 .flags = CONN_EVENTS_READ,
331 .time_to_expire = tq->current_time + tq->move_to_last_bump,
332 .thread = t,
333 };
334 if (UNLIKELY(!conn->coro)__builtin_expect(((!conn->coro)), (0))) {
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 return false0;
346 }
347
348 timeout_queue_insert(tq, conn);
349 return true1;
350}
351
352static void accept_nudge(struct lwan_thread *t,
353 struct timeout_queue *tq,
354 int pipe_fd)
355{
356 uint64_t event;
357
358 /* Errors are ignored here as pipe_fd serves just as a way to wake the
359 * thread from epoll_wait(). It's fine to consume the queue at this
360 * point, regardless of the error type. */
361 (void)read(pipe_fd, &event, sizeof(event));
362 timeouts_add(t->wheel, &tq->timeout, 1000);
363}
364
365static bool_Bool process_pending_timers(struct timeout_queue *tq,
366 struct lwan_thread *t,
367 int epoll_fd)
368{
369 struct timeout *timeout;
370 bool_Bool should_expire_timers = false0;
371
372 while ((timeout = timeouts_get(t->wheel))) {
373 struct lwan_request *request;
374
375 if (timeout == &tq->timeout) {
376 should_expire_timers = true1;
377 continue;
378 }
379
380 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))
;
381
382 update_epoll_flags(request->fd, request->conn, epoll_fd,
383 CONN_CORO_RESUME);
384 }
385
386 if (should_expire_timers) {
387 timeout_queue_expire_waiting(tq);
388
389 /* tq timeout expires every 1000ms if there are connections, so
390 * update the date cache at this point as well. */
391 update_date_cache(t);
392
393 if (!timeout_queue_empty(tq)) {
394 timeouts_add(t->wheel, &tq->timeout, 1000);
395 return true1;
396 }
397
398 timeouts_del(t->wheel, &tq->timeout);
399 }
400
401 return false0;
402}
403
404static int
405turn_timer_wheel(struct timeout_queue *tq, struct lwan_thread *t, int epoll_fd)
406{
407 const int infinite_timeout = -1;
408 timeout_t wheel_timeout;
409 struct timespec now;
410
411 if (UNLIKELY(clock_gettime(monotonic_clock_id, &now) < 0)__builtin_expect(((clock_gettime(monotonic_clock_id, &now
) < 0)), (0))
)
412 lwan_status_critical("Could not get monotonic time")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 412, __FUNCTION__, "Could not get monotonic time")
;
413
414 timeouts_update(t->wheel,
415 (timeout_t)(now.tv_sec * 1000 + now.tv_nsec / 1000000));
416
417 /* Check if there's an expired timer. */
418 wheel_timeout = timeouts_timeout(t->wheel);
419 if (wheel_timeout > 0) {
420 return (int)wheel_timeout; /* No, but will soon. Wake us up in
421 wheel_timeout ms. */
422 }
423
424 if (UNLIKELY((int64_t)wheel_timeout < 0)__builtin_expect((((int64_t)wheel_timeout < 0)), (0)))
425 return infinite_timeout; /* None found. */
426
427 if (!process_pending_timers(tq, t, epoll_fd))
428 return infinite_timeout; /* No more timers to process. */
429
430 /* After processing pending timers, determine when to wake up. */
431 return (int)timeouts_timeout(t->wheel);
432}
433
434enum herd_accept { HERD_MORE = 0, HERD_GONE = -1, HERD_SHUTDOWN = 1 };
435
436struct core_bitmap {
437 uint64_t bitmap[4];
438};
439
440static ALWAYS_INLINEinline __attribute__((always_inline)) int schedule_client(struct lwan *l, int fd)
441{
442 struct lwan_thread *thread = l->conns[fd].thread;
443
444 lwan_thread_add_client(thread, fd);
445
446 return (int)(thread - l->thread.threads);
447}
448
449static ALWAYS_INLINEinline __attribute__((always_inline)) enum herd_accept
450accept_one(struct lwan *l, int listen_fd, struct core_bitmap *cores)
451{
452 int fd = accept4(listen_fd, NULL((void*)0), NULL((void*)0), SOCK_NONBLOCKSOCK_NONBLOCK | SOCK_CLOEXECSOCK_CLOEXEC);
453
454 if (LIKELY(fd >= 0)__builtin_expect((!!(fd >= 0)), (1))) {
455 int core = schedule_client(l, fd);
456
457 cores->bitmap[core / 64] |= UINT64_C(1)1UL<<(core % 64);
458
459 return HERD_MORE;
460 }
461
462 switch (errno(*__errno_location ())) {
463 case EAGAIN11:
464 return HERD_GONE;
465
466 case EBADF9:
467 case ECONNABORTED103:
468 case EINVAL22:
469 lwan_status_info("Listening socket closed")lwan_status_info_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 469, __FUNCTION__, "Listening socket closed")
;
470 return HERD_SHUTDOWN;
471
472 default:
473 lwan_status_perror("accept")lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 473, __FUNCTION__, "accept")
;
474 return HERD_MORE;
475 }
476}
477
478static bool_Bool try_accept_connections(struct lwan_thread *t, int listen_fd)
479{
480 struct lwan *lwan = t->lwan;
481 struct core_bitmap cores = {};
482 enum herd_accept ha;
483
484 ha = accept_one(lwan, listen_fd, &cores);
485 if (ha == HERD_MORE) {
486 do {
487 ha = accept_one(lwan, listen_fd, &cores);
488 } while (ha == HERD_MORE);
489 }
490 if (UNLIKELY(ha > HERD_MORE)__builtin_expect(((ha > HERD_MORE)), (0)))
491 return false0;
492
493 for (size_t i = 0; i < N_ELEMENTS(cores.bitmap)((!sizeof(char[1 - 2 * __builtin_types_compatible_p( __typeof__
(cores.bitmap), __typeof__(&(cores.bitmap)[0]))])) | sizeof
(cores.bitmap) / sizeof(cores.bitmap[0]))
; i++) {
494 for (uint64_t c = cores.bitmap[i]; c; c ^= c & -c) {
495 size_t core = (size_t)__builtin_ctzl(c);
496 struct lwan_thread *cur_thread = &lwan->thread.threads[i * 64 + core];
497
498 if (cur_thread != t)
499 lwan_thread_nudge(cur_thread);
500 }
501 }
502
503 return true1;
504}
505
506static int create_listen_socket(struct lwan_thread *t)
507{
508 int listen_fd;
509
510 listen_fd = lwan_create_listen_socket(t->lwan);
511 if (listen_fd < 0)
512 lwan_status_critical("Could not create listen_fd")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 512, __FUNCTION__, "Could not create listen_fd")
;
513
514 struct epoll_event event = {
515 .events = EPOLLINEPOLLIN | EPOLLETEPOLLET | EPOLLHUPEPOLLHUP | EPOLLERREPOLLERR | EPOLLEXCLUSIVEEPOLLEXCLUSIVE,
516 .data.ptr = NULL((void*)0),
517 };
518 if (epoll_ctl(t->epoll_fd, EPOLL_CTL_ADD1, listen_fd, &event) < 0)
519 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"
, 519, __FUNCTION__, "Could not add socket to epoll")
;
520
521 return listen_fd;
522}
523
524static void *thread_io_loop(void *data)
525{
526 struct lwan_thread *t = data;
527 int epoll_fd = t->epoll_fd;
528 const int read_pipe_fd = t->pipe_fd[0];
529 const int max_events = LWAN_MIN((int)t->lwan->thread.max_fd, 1024)({ const __typeof__(((int)t->lwan->thread.max_fd) + 0) lwan_tmp_id10
= ((int)t->lwan->thread.max_fd); const __typeof__((1024
) + 0) lwan_tmp_id11 = (1024); lwan_tmp_id10 > lwan_tmp_id11
? lwan_tmp_id11 : lwan_tmp_id10; })
;
530 struct lwan *lwan = t->lwan;
531 struct epoll_event *events;
532 struct coro_switcher switcher;
533 struct timeout_queue tq;
534 int listen_fd;
535
536 lwan_status_debug("Worker thread #%zd starting",lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 537, __FUNCTION__, "Worker thread #%zd starting", t - t->
lwan->thread.threads + 1)
537 t - t->lwan->thread.threads + 1)lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 537, __FUNCTION__, "Worker thread #%zd starting", t - t->
lwan->thread.threads + 1)
;
538 lwan_set_thread_name("worker");
539
540 listen_fd = create_listen_socket(t);
541
542 events = calloc((size_t)max_events, sizeof(*events));
543 if (UNLIKELY(!events)__builtin_expect(((!events)), (0)))
544 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"
, 544, __FUNCTION__, "Could not allocate memory for events")
;
545
546 update_date_cache(t);
547
548 timeout_queue_init(&tq, lwan);
549
550 pthread_barrier_wait(&lwan->thread.barrier);
551
552 for (;;) {
553 int timeout = turn_timer_wheel(&tq, t, epoll_fd);
554 int n_fds = epoll_wait(epoll_fd, events, max_events, timeout);
555
556 if (UNLIKELY(n_fds < 0)__builtin_expect(((n_fds < 0)), (0))) {
557 if (errno(*__errno_location ()) == EBADF9 || errno(*__errno_location ()) == EINVAL22)
558 break;
559 continue;
560 }
561
562 for (struct epoll_event *event = events; n_fds--; event++) {
563 struct lwan_connection *conn;
564
565 if (UNLIKELY(!event->data.ptr)__builtin_expect(((!event->data.ptr)), (0))) {
566 accept_nudge(t, &tq, read_pipe_fd);
567 if (UNLIKELY(!try_accept_connections(t, listen_fd))__builtin_expect(((!try_accept_connections(t, listen_fd))), (
0))
) {
568 close(epoll_fd);
569 epoll_fd = -1;
570 break;
571 }
572 continue;
573 }
574
575 conn = event->data.ptr;
576
577 if (UNLIKELY(event->events & (EPOLLRDHUP | EPOLLHUP))__builtin_expect(((event->events & (EPOLLRDHUP | EPOLLHUP
))), (0))
) {
578 timeout_queue_expire(&tq, conn);
579 continue;
580 }
581
582 if (!conn->coro) {
583 if (UNLIKELY(!spawn_coro(conn, &switcher, &tq))__builtin_expect(((!spawn_coro(conn, &switcher, &tq))
), (0))
)
584 continue;
585 }
586
587 resume_coro(&tq, conn, epoll_fd);
588 timeout_queue_move_to_last(&tq, conn);
589 }
590 }
591
592 pthread_barrier_wait(&lwan->thread.barrier);
593
594 timeout_queue_expire_all(&tq);
595 free(events);
596 close(listen_fd);
597
598 return NULL((void*)0);
599}
600
601static void create_thread(struct lwan *l, struct lwan_thread *thread,
602 const size_t n_queue_fds)
603{
604 int ignore;
605 pthread_attr_t attr;
606
607 memset(thread, 0, sizeof(*thread));
608 thread->lwan = l;
609
610 thread->wheel = timeouts_open(&ignore);
611 if (!thread->wheel)
612 lwan_status_critical("Could not create timer wheel")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 612, __FUNCTION__, "Could not create timer wheel")
;
613
614 if ((thread->epoll_fd = epoll_create1(EPOLL_CLOEXECEPOLL_CLOEXEC)) < 0)
615 lwan_status_critical_perror("epoll_create")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 615, __FUNCTION__, "epoll_create")
;
616
617 if (pthread_attr_init(&attr))
618 lwan_status_critical_perror("pthread_attr_init")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 618, __FUNCTION__, "pthread_attr_init")
;
619
620 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEMPTHREAD_SCOPE_SYSTEM))
621 lwan_status_critical_perror("pthread_attr_setscope")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 621, __FUNCTION__, "pthread_attr_setscope")
;
622
623 if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLEPTHREAD_CREATE_JOINABLE))
624 lwan_status_critical_perror("pthread_attr_setdetachstate")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 624, __FUNCTION__, "pthread_attr_setdetachstate")
;
625
626#if defined(HAVE_EVENTFD)
627 int efd = eventfd(0, EFD_NONBLOCKEFD_NONBLOCK | EFD_SEMAPHOREEFD_SEMAPHORE | EFD_CLOEXECEFD_CLOEXEC);
628 if (efd < 0)
629 lwan_status_critical_perror("eventfd")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 629, __FUNCTION__, "eventfd")
;
630
631 thread->pipe_fd[0] = thread->pipe_fd[1] = efd;
632#else
633 if (pipe2(thread->pipe_fd, O_NONBLOCK04000 | O_CLOEXEC02000000) < 0)
634 lwan_status_critical_perror("pipe")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 634, __FUNCTION__, "pipe")
;
635#endif
636
637 struct epoll_event event = { .events = EPOLLINEPOLLIN, .data.ptr = NULL((void*)0) };
638 if (epoll_ctl(thread->epoll_fd, EPOLL_CTL_ADD1, thread->pipe_fd[0], &event) < 0)
639 lwan_status_critical_perror("epoll_ctl")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 639, __FUNCTION__, "epoll_ctl")
;
640
641 if (pthread_create(&thread->self, &attr, thread_io_loop, thread))
642 lwan_status_critical_perror("pthread_create")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 642, __FUNCTION__, "pthread_create")
;
643
644 if (pthread_attr_destroy(&attr))
645 lwan_status_critical_perror("pthread_attr_destroy")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 645, __FUNCTION__, "pthread_attr_destroy")
;
646}
647
648void lwan_thread_nudge(struct lwan_thread *t)
649{
650 uint64_t event = 1;
651
652 if (UNLIKELY(write(t->pipe_fd[1], &event, sizeof(event)) < 0)__builtin_expect(((write(t->pipe_fd[1], &event, sizeof
(event)) < 0)), (0))
)
653 lwan_status_perror("write")lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 653, __FUNCTION__, "write")
;
654}
655
656void lwan_thread_add_client(struct lwan_thread *t, int fd)
657{
658 struct epoll_event ev = {
659 .data.ptr = &t->lwan->conns[fd],
660 .events = conn_flags_to_epoll_events(CONN_EVENTS_READ),
661 };
662 epoll_ctl(t->epoll_fd, EPOLL_CTL_ADD1, fd, &ev);
663}
664
665#if defined(__linux__1) && defined(__x86_64__1)
666static bool_Bool read_cpu_topology(struct lwan *l, uint32_t siblings[])
667{
668 char path[PATH_MAX4096];
669
670 for (uint32_t i = 0; i < l->available_cpus; i++)
671 siblings[i] = 0xbebacafe;
672
673 for (unsigned int i = 0; i < l->available_cpus; i++) {
674 FILE *sib;
675 uint32_t id, sibling;
676 char separator;
677
678 snprintf(path, sizeof(path),
679 "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list",
680 i);
681
682 sib = fopen(path, "re");
683 if (!sib) {
684 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"
, 685, __FUNCTION__, "Could not open `%s` to determine CPU topology"
, path)
685 path)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 685, __FUNCTION__, "Could not open `%s` to determine CPU topology"
, path)
;
686 return false0;
687 }
688
689 switch (fscanf(sib, "%u%c%u", &id, &separator, &sibling)) {
690 case 2: /* No SMT */
691 siblings[i] = id;
692 break;
693 case 3: /* SMT */
694 if (!(separator == ',' || separator == '-')) {
695 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"
, 695, __FUNCTION__, "Expecting either ',' or '-' for sibling separator"
)
;
696 __builtin_unreachable();
697 }
698
699 siblings[i] = sibling;
700 break;
701 default:
702 lwan_status_critical("%s has invalid format", path)lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 702, __FUNCTION__, "%s has invalid format", path)
;
703 __builtin_unreachable();
704 }
705
706 fclose(sib);
707 }
708
709 /* Perform a sanity check here, as some systems seem to filter out the
710 * result of sysconf() to obtain the number of configured and online
711 * CPUs but don't bother changing what's available through sysfs as far
712 * as the CPU topology information goes. It's better to fall back to a
713 * possibly non-optimal setup than just crash during startup while
714 * trying to perform an out-of-bounds array access. */
715 for (unsigned int i = 0; i < l->available_cpus; i++) {
716 if (siblings[i] == 0xbebacafe) {
717 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"
, 717, __FUNCTION__, "Could not determine sibling for CPU %d"
, i)
;
718 return false0;
719 }
720
721 if (siblings[i] >= l->available_cpus) {
722 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"
, 725, __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)
723 "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"
, 725, __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)
724 "Is Lwan running in a (broken) container?",lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 725, __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)
725 siblings[i], l->available_cpus, l->online_cpus)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 725, __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)
;
726 return false0;
727 }
728 }
729
730 return true1;
731}
732
733static void
734siblings_to_schedtbl(struct lwan *l, uint32_t siblings[], uint32_t schedtbl[])
735{
736 int *seen = alloca(l->available_cpus * sizeof(int))__builtin_alloca (l->available_cpus * sizeof(int));
737 unsigned int n_schedtbl = 0;
738
739 for (uint32_t i = 0; i < l->available_cpus; i++)
740 seen[i] = -1;
741
742 for (uint32_t i = 0; i < l->available_cpus; i++) {
743 if (seen[siblings[i]] < 0) {
744 seen[siblings[i]] = (int)i;
745 } else {
746 schedtbl[n_schedtbl++] = (uint32_t)seen[siblings[i]];
747 schedtbl[n_schedtbl++] = i;
748 }
749 }
750
751 if (n_schedtbl != l->available_cpus)
752 memcpy(schedtbl, seen, l->available_cpus * sizeof(int));
753}
754
755static bool_Bool
756topology_to_schedtbl(struct lwan *l, uint32_t schedtbl[], uint32_t n_threads)
757{
758 uint32_t *siblings = alloca(l->available_cpus * sizeof(uint32_t))__builtin_alloca (l->available_cpus * sizeof(uint32_t));
759
760 if (read_cpu_topology(l, siblings)) {
11
Assuming the condition is false
12
Taking false branch
761 uint32_t *affinity = alloca(l->available_cpus * sizeof(uint32_t))__builtin_alloca (l->available_cpus * sizeof(uint32_t));
762
763 siblings_to_schedtbl(l, siblings, affinity);
764
765 for (uint32_t i = 0; i < n_threads; i++)
766 schedtbl[i] = affinity[i % l->available_cpus];
767 return true1;
768 }
769
770 for (uint32_t i = 0; i < n_threads; i++)
13
Assuming 'i' is >= 'n_threads'
14
Loop condition is false. Execution continues on line 772
771 schedtbl[i] = (i / 2) % l->thread.count;
772 return false0;
15
Returning without writing to '*schedtbl'
773}
774
775static void
776adjust_threads_affinity(struct lwan *l, uint32_t *schedtbl, uint32_t mask)
777{
778 for (uint32_t i = 0; i < l->thread.count; i++) {
779 cpu_set_t set;
780
781 CPU_ZERO(&set)do __builtin_memset (&set, '\0', sizeof (cpu_set_t)); while
(0)
;
782 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; }))
;
783
784 if (pthread_setaffinity_np(l->thread.threads[i].self, sizeof(set),
785 &set))
786 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"
, 786, __FUNCTION__, "Could not set affinity for thread %d", i
)
;
787 }
788}
789#elif defined(__x86_64__1)
790static bool_Bool
791topology_to_schedtbl(struct lwan *l, uint32_t schedtbl[], uint32_t n_threads)
792{
793 for (uint32_t i = 0; i < n_threads; i++)
794 schedtbl[i] = (i / 2) % l->thread.count;
795 return false0;
796}
797
798