Bug Summary

File:lwan-thread.c
Warning:line 779, 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-09-162936-4009878-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#include "lwan-private.h"
35#include "lwan-tq.h"
36#include "list.h"
37
38static void lwan_strbuf_free_defer(void *data)
39{
40 lwan_strbuf_free((struct lwan_strbuf *)data);
41}
42
43static 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
165static ALWAYS_INLINEinline __attribute__((always_inline)) uint32_t
166conn_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
178static 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
232static 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
239static enum lwan_connection_coro_yield
240resume_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
284static 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
303static 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
312static ALWAYS_INLINEinline __attribute__((always_inline)) bool_Bool 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 (UNLIKELY(!conn->coro)__builtin_expect(((!conn->coro)), (0))) {
331 /* FIXME: send a "busy" response to this client? we don't have a coroutine
332 * at this point, can't use lwan_send() here */
333 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"
, 333, __FUNCTION__, "Could not create coroutine, dropping connection"
)
;
334
335 conn->flags = 0;
336
337 int fd = lwan_connection_get_fd(tq->lwan, conn);
338 shutdown(fd, SHUT_RDWRSHUT_RDWR);
339 close(fd);
340
341 return false0;
342 }
343
344 timeout_queue_insert(tq, conn);
345 return true1;
346}
347
348static bool_Bool process_pending_timers(struct timeout_queue *tq,
349 struct lwan_thread *t,
350 int epoll_fd)
351{
352 struct timeout *timeout;
353 bool_Bool should_expire_timers = false0;
354
355 while ((timeout = timeouts_get(t->wheel))) {
356 struct lwan_request *request;
357
358 if (timeout == &tq->timeout) {
359 should_expire_timers = true1;
360 continue;
361 }
362
363 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))
;
364
365 update_epoll_flags(request->fd, request->conn, epoll_fd,
366 CONN_CORO_RESUME);
367 }
368
369 if (should_expire_timers) {
370 timeout_queue_expire_waiting(tq);
371
372 /* tq timeout expires every 1000ms if there are connections, so
373 * update the date cache at this point as well. */
374 update_date_cache(t);
375
376 if (!timeout_queue_empty(tq)) {
377 timeouts_add(t->wheel, &tq->timeout, 1000);
378 return true1;
379 }
380
381 timeouts_del(t->wheel, &tq->timeout);
382 }
383
384 return false0;
385}
386
387static int
388turn_timer_wheel(struct timeout_queue *tq, struct lwan_thread *t, int epoll_fd)
389{
390 const int infinite_timeout = -1;
391 timeout_t wheel_timeout;
392 struct timespec now;
393
394 if (UNLIKELY(clock_gettime(monotonic_clock_id, &now) < 0)__builtin_expect(((clock_gettime(monotonic_clock_id, &now
) < 0)), (0))
)
395 lwan_status_critical("Could not get monotonic time")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 395, __FUNCTION__, "Could not get monotonic time")
;
396
397 timeouts_update(t->wheel,
398 (timeout_t)(now.tv_sec * 1000 + now.tv_nsec / 1000000));
399
400 /* Check if there's an expired timer. */
401 wheel_timeout = timeouts_timeout(t->wheel);
402 if (wheel_timeout > 0) {
403 return (int)wheel_timeout; /* No, but will soon. Wake us up in
404 wheel_timeout ms. */
405 }
406
407 if (UNLIKELY((int64_t)wheel_timeout < 0)__builtin_expect((((int64_t)wheel_timeout < 0)), (0)))
408 return infinite_timeout; /* None found. */
409
410 if (!process_pending_timers(tq, t, epoll_fd))
411 return infinite_timeout; /* No more timers to process. */
412
413 /* After processing pending timers, determine when to wake up. */
414 return (int)timeouts_timeout(t->wheel);
415}
416
417enum herd_accept { HERD_MORE = 0, HERD_GONE = -1, HERD_SHUTDOWN = 1 };
418
419static ALWAYS_INLINEinline __attribute__((always_inline)) enum herd_accept
420accept_one(struct lwan *l, const struct lwan_thread *t)
421{
422 int fd = accept4(t->listen_fd, NULL((void*)0), NULL((void*)0), SOCK_NONBLOCKSOCK_NONBLOCK | SOCK_CLOEXECSOCK_CLOEXEC);
423
424 if (LIKELY(fd >= 0)__builtin_expect((!!(fd >= 0)), (1))) {
425 lwan_thread_add_client(l->conns[fd].thread, fd);
426 return HERD_MORE;
427 }
428
429 switch (errno(*__errno_location ())) {
430 case EAGAIN11:
431 return HERD_GONE;
432
433 case EBADF9:
434 case ECONNABORTED103:
435 case EINVAL22:
436 lwan_status_info("Listening socket closed")lwan_status_info_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 436, __FUNCTION__, "Listening socket closed")
;
437 return HERD_SHUTDOWN;
438
439 default:
440 lwan_status_perror("accept")lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 440, __FUNCTION__, "accept")
;
441 return HERD_MORE;
442 }
443}
444
445static bool_Bool try_accept_connections(const struct lwan_thread *t)
446{
447 struct lwan *lwan = t->lwan;
448 enum herd_accept ha;
449
450 while ((ha = accept_one(lwan, t)) == HERD_MORE) {
451 }
452
453 if (ha > HERD_MORE)
454 return false0;
455
456 return true1;
457}
458
459static int create_listen_socket(struct lwan_thread *t, bool_Bool print_listening_msg)
460{
461 int listen_fd;
462
463 listen_fd = lwan_create_listen_socket(t->lwan, print_listening_msg);
464 if (listen_fd < 0)
465 lwan_status_critical("Could not create listen_fd")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 465, __FUNCTION__, "Could not create listen_fd")
;
466
467 struct epoll_event event = {
468 .events = EPOLLINEPOLLIN | EPOLLETEPOLLET | EPOLLERREPOLLERR,
469 .data.ptr = NULL((void*)0),
470 };
471 if (epoll_ctl(t->epoll_fd, EPOLL_CTL_ADD1, listen_fd, &event) < 0)
472 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"
, 472, __FUNCTION__, "Could not add socket to epoll")
;
473
474 return listen_fd;
475}
476
477static void *thread_io_loop(void *data)
478{
479 struct lwan_thread *t = data;
480 int epoll_fd = t->epoll_fd;
481 const int max_events = LWAN_MIN((int)t->lwan->thread.max_fd, 1024)({ const __typeof__(((int)t->lwan->thread.max_fd) + 0) lwan_tmp_id6
= ((int)t->lwan->thread.max_fd); const __typeof__((1024
) + 0) lwan_tmp_id7 = (1024); lwan_tmp_id6 > lwan_tmp_id7 ?
lwan_tmp_id7 : lwan_tmp_id6; })
;
482 struct lwan *lwan = t->lwan;
483 struct epoll_event *events;
484 struct coro_switcher switcher;
485 struct timeout_queue tq;
486
487 lwan_status_debug("Worker thread #%zd starting",lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 488, __FUNCTION__, "Worker thread #%zd starting", t - t->
lwan->thread.threads + 1)
488 t - t->lwan->thread.threads + 1)lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 488, __FUNCTION__, "Worker thread #%zd starting", t - t->
lwan->thread.threads + 1)
;
489 lwan_set_thread_name("worker");
490
491 events = calloc((size_t)max_events, sizeof(*events));
492 if (UNLIKELY(!events)__builtin_expect(((!events)), (0)))
493 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"
, 493, __FUNCTION__, "Could not allocate memory for events")
;
494
495 update_date_cache(t);
496
497 timeout_queue_init(&tq, lwan);
498
499 pthread_barrier_wait(&lwan->thread.barrier);
500
501 for (;;) {
502 int timeout = turn_timer_wheel(&tq, t, epoll_fd);
503 int n_fds = epoll_wait(epoll_fd, events, max_events, timeout);
504
505 if (UNLIKELY(n_fds < 0)__builtin_expect(((n_fds < 0)), (0))) {
506 if (errno(*__errno_location ()) == EBADF9 || errno(*__errno_location ()) == EINVAL22)
507 break;
508 continue;
509 }
510
511 for (struct epoll_event *event = events; n_fds--; event++) {
512 struct lwan_connection *conn;
513
514 if (!event->data.ptr) {
515 if (UNLIKELY(!try_accept_connections(t))__builtin_expect(((!try_accept_connections(t))), (0))) {
516 close(epoll_fd);
517 epoll_fd = -1;
518 break;
519 }
520 timeouts_add(t->wheel, &tq.timeout, 1000);
521 continue;
522 }
523
524 conn = event->data.ptr;
525
526 if (UNLIKELY(event->events & (EPOLLRDHUP | EPOLLHUP))__builtin_expect(((event->events & (EPOLLRDHUP | EPOLLHUP
))), (0))
) {
527 timeout_queue_expire(&tq, conn);
528 continue;
529 }
530
531 if (!conn->coro) {
532 if (UNLIKELY(!spawn_coro(conn, &switcher, &tq))__builtin_expect(((!spawn_coro(conn, &switcher, &tq))
), (0))
)
533 continue;
534 }
535
536 resume_coro(&tq, conn, epoll_fd);
537 timeout_queue_move_to_last(&tq, conn);
538 }
539 }
540
541 pthread_barrier_wait(&lwan->thread.barrier);
542
543 timeout_queue_expire_all(&tq);
544 free(events);
545
546 return NULL((void*)0);
547}
548
549static void create_thread(struct lwan *l, struct lwan_thread *thread)
550{
551 int ignore;
552 pthread_attr_t attr;
553
554 memset(thread, 0, sizeof(*thread));
555 thread->lwan = l;
556
557 thread->wheel = timeouts_open(&ignore);
558 if (!thread->wheel)
559 lwan_status_critical("Could not create timer wheel")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 559, __FUNCTION__, "Could not create timer wheel")
;
560
561 if ((thread->epoll_fd = epoll_create1(EPOLL_CLOEXECEPOLL_CLOEXEC)) < 0)
562 lwan_status_critical_perror("epoll_create")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 562, __FUNCTION__, "epoll_create")
;
563
564 if (pthread_attr_init(&attr))
565 lwan_status_critical_perror("pthread_attr_init")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 565, __FUNCTION__, "pthread_attr_init")
;
566
567 if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEMPTHREAD_SCOPE_SYSTEM))
568 lwan_status_critical_perror("pthread_attr_setscope")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 568, __FUNCTION__, "pthread_attr_setscope")
;
569
570 if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLEPTHREAD_CREATE_JOINABLE))
571 lwan_status_critical_perror("pthread_attr_setdetachstate")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 571, __FUNCTION__, "pthread_attr_setdetachstate")
;
572
573 if (pthread_create(&thread->self, &attr, thread_io_loop, thread))
574 lwan_status_critical_perror("pthread_create")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 574, __FUNCTION__, "pthread_create")
;
575
576 if (pthread_attr_destroy(&attr))
577 lwan_status_critical_perror("pthread_attr_destroy")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c"
, 577, __FUNCTION__, "pthread_attr_destroy")
;
578}
579
580void lwan_thread_add_client(struct lwan_thread *t, int fd)
581{
582 struct epoll_event ev = {
583 .data.ptr = &t->lwan->conns[fd],
584 .events = conn_flags_to_epoll_events(CONN_EVENTS_READ),
585 };
586 epoll_ctl(t->epoll_fd, EPOLL_CTL_ADD1, fd, &ev);
587}
588
589#if defined(__linux__1) && defined(__x86_64__1)
590static 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
657static void
658siblings_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
679static bool_Bool
680topology_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)) {
10
Assuming the condition is false
11
Taking false branch
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++)
12
Assuming 'i' is >= 'n_threads'
13
Loop condition is false. Execution continues on line 696
695 schedtbl[i] = (i / 2) % l->thread.count;
696 return false0;
14
Returning without writing to '*schedtbl'
697}
698
699static void
700adjust_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)
714static bool_Bool
715topology_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
722static void
723adjust_threads_affinity(struct lwan *l, uint32_t *schedtbl, uint32_t n)
724{
725}
726#endif
727
728void lwan_thread_init(struct lwan *l)
729{
730 if (pthread_barrier_init(&l->thread.barrier, NULL((void*)0),
1
Assuming the condition is false
2
Taking false branch
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)
3
Assuming field 'threads' is non-null
4
Taking false branch
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
4.1
'i' is < field 'count'
< l->thread.count
; i++) {
5
Loop condition is true. Entering loop body
7
Assuming 'i' is >= field 'count'
8
Loop condition is false. Execution continues on line 750
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)
6
Taking false branch
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);
9
Calling 'topology_to_schedtbl'
15
Returning from 'topology_to_schedtbl'
772
773 n_threads--; /* Transform count into mask for AND below */
774
775 if (adj_affinity
15.1
'adj_affinity' is false
)
16
Taking false branch
776 adjust_threads_affinity(l, schedtbl, n_threads);
777
778 for (unsigned int i = 0; i < total_conns; i++)
17
Assuming 'i' is < 'total_conns'
18
Loop condition is true. Entering loop body
779 l->conns[i].thread = &l->thread.threads[schedtbl[i & n_threads]];
19
Array subscript is undefined
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
790void 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}