| File: | lwan-thread.c |
| Warning: | line 704, column 9 Assigned value is garbage or undefined |
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 | lwan_thread_add_client(l->conns[fd].thread, fd); | |||
| 424 | return HERD_MORE; | |||
| 425 | } | |||
| 426 | ||||
| 427 | switch (errno(*__errno_location ())) { | |||
| 428 | case EAGAIN11: | |||
| 429 | return HERD_GONE; | |||
| 430 | ||||
| 431 | case EBADF9: | |||
| 432 | case ECONNABORTED103: | |||
| 433 | case EINVAL22: | |||
| 434 | lwan_status_info("Listening socket closed")lwan_status_info_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 434, __FUNCTION__, "Listening socket closed"); | |||
| 435 | return HERD_SHUTDOWN; | |||
| 436 | ||||
| 437 | default: | |||
| 438 | lwan_status_perror("accept")lwan_status_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 438, __FUNCTION__, "accept"); | |||
| 439 | return HERD_MORE; | |||
| 440 | } | |||
| 441 | } | |||
| 442 | ||||
| 443 | static bool_Bool try_accept_connections(const struct lwan_thread *t) | |||
| 444 | { | |||
| 445 | struct lwan *lwan = t->lwan; | |||
| 446 | enum herd_accept ha; | |||
| 447 | ||||
| 448 | while ((ha = accept_one(lwan, t)) == HERD_MORE) { | |||
| 449 | } | |||
| 450 | ||||
| 451 | if (ha > HERD_MORE) | |||
| 452 | return false0; | |||
| 453 | ||||
| 454 | return true1; | |||
| 455 | } | |||
| 456 | ||||
| 457 | static int create_listen_socket(struct lwan_thread *t, bool_Bool print_listening_msg) | |||
| 458 | { | |||
| 459 | int listen_fd; | |||
| 460 | ||||
| 461 | listen_fd = lwan_create_listen_socket(t->lwan, print_listening_msg); | |||
| 462 | if (listen_fd < 0) | |||
| 463 | lwan_status_critical("Could not create listen_fd")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 463, __FUNCTION__, "Could not create listen_fd"); | |||
| 464 | ||||
| 465 | struct epoll_event event = { | |||
| 466 | .events = EPOLLINEPOLLIN | EPOLLETEPOLLET | EPOLLERREPOLLERR, | |||
| 467 | .data.ptr = NULL((void*)0), | |||
| 468 | }; | |||
| 469 | if (epoll_ctl(t->epoll_fd, EPOLL_CTL_ADD1, listen_fd, &event) < 0) | |||
| 470 | 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" , 470, __FUNCTION__, "Could not add socket to epoll"); | |||
| 471 | ||||
| 472 | return listen_fd; | |||
| 473 | } | |||
| 474 | ||||
| 475 | static void *thread_io_loop(void *data) | |||
| 476 | { | |||
| 477 | struct lwan_thread *t = data; | |||
| 478 | int epoll_fd = t->epoll_fd; | |||
| 479 | 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; }); | |||
| 480 | struct lwan *lwan = t->lwan; | |||
| 481 | struct epoll_event *events; | |||
| 482 | struct coro_switcher switcher; | |||
| 483 | struct timeout_queue tq; | |||
| 484 | ||||
| 485 | lwan_status_debug("Worker thread #%zd starting",lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 486, __FUNCTION__, "Worker thread #%zd starting", t - t-> lwan->thread.threads + 1) | |||
| 486 | t - t->lwan->thread.threads + 1)lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 486, __FUNCTION__, "Worker thread #%zd starting", t - t-> lwan->thread.threads + 1); | |||
| 487 | lwan_set_thread_name("worker"); | |||
| 488 | ||||
| 489 | events = calloc((size_t)max_events, sizeof(*events)); | |||
| 490 | if (UNLIKELY(!events)__builtin_expect(((!events)), (0))) | |||
| 491 | 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" , 491, __FUNCTION__, "Could not allocate memory for events"); | |||
| 492 | ||||
| 493 | update_date_cache(t); | |||
| 494 | ||||
| 495 | timeout_queue_init(&tq, lwan); | |||
| 496 | ||||
| 497 | pthread_barrier_wait(&lwan->thread.barrier); | |||
| 498 | ||||
| 499 | for (;;) { | |||
| 500 | int timeout = turn_timer_wheel(&tq, t, epoll_fd); | |||
| 501 | int n_fds = epoll_wait(epoll_fd, events, max_events, timeout); | |||
| 502 | ||||
| 503 | if (UNLIKELY(n_fds < 0)__builtin_expect(((n_fds < 0)), (0))) { | |||
| 504 | if (errno(*__errno_location ()) == EBADF9 || errno(*__errno_location ()) == EINVAL22) | |||
| 505 | break; | |||
| 506 | continue; | |||
| 507 | } | |||
| 508 | ||||
| 509 | for (struct epoll_event *event = events; n_fds--; event++) { | |||
| 510 | struct lwan_connection *conn; | |||
| 511 | ||||
| 512 | if (!event->data.ptr) { | |||
| 513 | if (UNLIKELY(!try_accept_connections(t))__builtin_expect(((!try_accept_connections(t))), (0))) { | |||
| 514 | close(epoll_fd); | |||
| 515 | epoll_fd = -1; | |||
| 516 | break; | |||
| 517 | } | |||
| 518 | timeouts_add(t->wheel, &tq.timeout, 1000); | |||
| 519 | continue; | |||
| 520 | } | |||
| 521 | ||||
| 522 | conn = event->data.ptr; | |||
| 523 | ||||
| 524 | if (UNLIKELY(event->events & (EPOLLRDHUP | EPOLLHUP))__builtin_expect(((event->events & (EPOLLRDHUP | EPOLLHUP ))), (0))) { | |||
| 525 | timeout_queue_expire(&tq, conn); | |||
| 526 | continue; | |||
| 527 | } | |||
| 528 | ||||
| 529 | if (!conn->coro) { | |||
| 530 | spawn_coro(conn, &switcher, &tq); | |||
| 531 | continue; | |||
| 532 | } | |||
| 533 | ||||
| 534 | resume_coro(&tq, conn, epoll_fd); | |||
| 535 | timeout_queue_move_to_last(&tq, conn); | |||
| 536 | } | |||
| 537 | } | |||
| 538 | ||||
| 539 | pthread_barrier_wait(&lwan->thread.barrier); | |||
| 540 | ||||
| 541 | timeout_queue_expire_all(&tq); | |||
| 542 | free(events); | |||
| 543 | ||||
| 544 | return NULL((void*)0); | |||
| 545 | } | |||
| 546 | ||||
| 547 | static void create_thread(struct lwan *l, struct lwan_thread *thread) | |||
| 548 | { | |||
| 549 | int ignore; | |||
| 550 | pthread_attr_t attr; | |||
| 551 | ||||
| 552 | memset(thread, 0, sizeof(*thread)); | |||
| 553 | thread->lwan = l; | |||
| 554 | ||||
| 555 | thread->wheel = timeouts_open(&ignore); | |||
| 556 | if (!thread->wheel) | |||
| 557 | lwan_status_critical("Could not create timer wheel")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 557, __FUNCTION__, "Could not create timer wheel"); | |||
| 558 | ||||
| 559 | if ((thread->epoll_fd = epoll_create1(EPOLL_CLOEXECEPOLL_CLOEXEC)) < 0) | |||
| 560 | lwan_status_critical_perror("epoll_create")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 560, __FUNCTION__, "epoll_create"); | |||
| 561 | ||||
| 562 | if (pthread_attr_init(&attr)) | |||
| 563 | lwan_status_critical_perror("pthread_attr_init")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 563, __FUNCTION__, "pthread_attr_init"); | |||
| 564 | ||||
| 565 | if (pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEMPTHREAD_SCOPE_SYSTEM)) | |||
| 566 | lwan_status_critical_perror("pthread_attr_setscope")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 566, __FUNCTION__, "pthread_attr_setscope"); | |||
| 567 | ||||
| 568 | if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLEPTHREAD_CREATE_JOINABLE)) | |||
| 569 | lwan_status_critical_perror("pthread_attr_setdetachstate")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 569, __FUNCTION__, "pthread_attr_setdetachstate"); | |||
| 570 | ||||
| 571 | if (pthread_create(&thread->self, &attr, thread_io_loop, thread)) | |||
| 572 | lwan_status_critical_perror("pthread_create")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 572, __FUNCTION__, "pthread_create"); | |||
| 573 | ||||
| 574 | if (pthread_attr_destroy(&attr)) | |||
| 575 | lwan_status_critical_perror("pthread_attr_destroy")lwan_status_critical_perror_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 575, __FUNCTION__, "pthread_attr_destroy"); | |||
| 576 | } | |||
| 577 | ||||
| 578 | void lwan_thread_add_client(struct lwan_thread *t, int fd) | |||
| 579 | { | |||
| 580 | struct epoll_event ev = { | |||
| 581 | .data.ptr = &t->lwan->conns[fd], | |||
| 582 | .events = conn_flags_to_epoll_events(CONN_EVENTS_READ), | |||
| 583 | }; | |||
| 584 | epoll_ctl(t->epoll_fd, EPOLL_CTL_ADD1, fd, &ev); | |||
| 585 | } | |||
| 586 | ||||
| 587 | #if defined(__linux__1) && defined(__x86_64__1) | |||
| 588 | static bool_Bool read_cpu_topology(struct lwan *l, uint32_t siblings[]) | |||
| 589 | { | |||
| 590 | char path[PATH_MAX4096]; | |||
| 591 | ||||
| 592 | for (uint32_t i = 0; i < l->available_cpus; i++) | |||
| 593 | siblings[i] = 0xbebacafe; | |||
| 594 | ||||
| 595 | for (unsigned int i = 0; i < l->available_cpus; i++) { | |||
| 596 | FILE *sib; | |||
| 597 | uint32_t id, sibling; | |||
| 598 | char separator; | |||
| 599 | ||||
| 600 | snprintf(path, sizeof(path), | |||
| 601 | "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list", | |||
| 602 | i); | |||
| 603 | ||||
| 604 | sib = fopen(path, "re"); | |||
| 605 | if (!sib) { | |||
| 606 | 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" , 607, __FUNCTION__, "Could not open `%s` to determine CPU topology" , path) | |||
| 607 | path)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 607, __FUNCTION__, "Could not open `%s` to determine CPU topology" , path); | |||
| 608 | return false0; | |||
| 609 | } | |||
| 610 | ||||
| 611 | switch (fscanf(sib, "%u%c%u", &id, &separator, &sibling)) { | |||
| 612 | case 2: /* No SMT */ | |||
| 613 | siblings[i] = id; | |||
| 614 | break; | |||
| 615 | case 3: /* SMT */ | |||
| 616 | if (!(separator == ',' || separator == '-')) { | |||
| 617 | 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" , 617, __FUNCTION__, "Expecting either ',' or '-' for sibling separator" ); | |||
| 618 | __builtin_unreachable(); | |||
| 619 | } | |||
| 620 | ||||
| 621 | siblings[i] = sibling; | |||
| 622 | break; | |||
| 623 | default: | |||
| 624 | lwan_status_critical("%s has invalid format", path)lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 624, __FUNCTION__, "%s has invalid format", path); | |||
| 625 | __builtin_unreachable(); | |||
| 626 | } | |||
| 627 | ||||
| 628 | fclose(sib); | |||
| 629 | } | |||
| 630 | ||||
| 631 | /* Perform a sanity check here, as some systems seem to filter out the | |||
| 632 | * result of sysconf() to obtain the number of configured and online | |||
| 633 | * CPUs but don't bother changing what's available through sysfs as far | |||
| 634 | * as the CPU topology information goes. It's better to fall back to a | |||
| 635 | * possibly non-optimal setup than just crash during startup while | |||
| 636 | * trying to perform an out-of-bounds array access. */ | |||
| 637 | for (unsigned int i = 0; i < l->available_cpus; i++) { | |||
| 638 | if (siblings[i] == 0xbebacafe) { | |||
| 639 | 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" , 639, __FUNCTION__, "Could not determine sibling for CPU %d" , i); | |||
| 640 | return false0; | |||
| 641 | } | |||
| 642 | ||||
| 643 | if (siblings[i] >= l->available_cpus) { | |||
| 644 | 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" , 647, __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) | |||
| 645 | "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" , 647, __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) | |||
| 646 | "Is Lwan running in a (broken) container?",lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 647, __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 | siblings[i], l->available_cpus, l->online_cpus)lwan_status_warning_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 647, __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 | return false0; | |||
| 649 | } | |||
| 650 | } | |||
| 651 | ||||
| 652 | return true1; | |||
| 653 | } | |||
| 654 | ||||
| 655 | static void | |||
| 656 | siblings_to_schedtbl(struct lwan *l, uint32_t siblings[], uint32_t schedtbl[]) | |||
| 657 | { | |||
| 658 | int *seen = alloca(l->available_cpus * sizeof(int))__builtin_alloca (l->available_cpus * sizeof(int)); | |||
| 659 | unsigned int n_schedtbl = 0; | |||
| 660 | ||||
| 661 | for (uint32_t i = 0; i < l->available_cpus; i++) | |||
| 662 | seen[i] = -1; | |||
| 663 | ||||
| 664 | for (uint32_t i = 0; i < l->available_cpus; i++) { | |||
| 665 | if (seen[siblings[i]] < 0) { | |||
| 666 | seen[siblings[i]] = (int)i; | |||
| 667 | } else { | |||
| 668 | schedtbl[n_schedtbl++] = (uint32_t)seen[siblings[i]]; | |||
| 669 | schedtbl[n_schedtbl++] = i; | |||
| 670 | } | |||
| 671 | } | |||
| 672 | ||||
| 673 | if (n_schedtbl != l->available_cpus) | |||
| 674 | memcpy(schedtbl, seen, l->available_cpus * sizeof(int)); | |||
| 675 | } | |||
| 676 | ||||
| 677 | static bool_Bool | |||
| 678 | topology_to_schedtbl(struct lwan *l, uint32_t schedtbl[], uint32_t n_threads) | |||
| 679 | { | |||
| 680 | uint32_t *siblings = alloca(l->available_cpus * sizeof(uint32_t))__builtin_alloca (l->available_cpus * sizeof(uint32_t)); | |||
| 681 | ||||
| 682 | if (read_cpu_topology(l, siblings)) { | |||
| 683 | uint32_t *affinity = alloca(l->available_cpus * sizeof(uint32_t))__builtin_alloca (l->available_cpus * sizeof(uint32_t)); | |||
| 684 | ||||
| 685 | siblings_to_schedtbl(l, siblings, affinity); | |||
| 686 | ||||
| 687 | for (uint32_t i = 0; i < n_threads; i++) | |||
| 688 | schedtbl[i] = affinity[i % l->available_cpus]; | |||
| 689 | return true1; | |||
| 690 | } | |||
| 691 | ||||
| 692 | for (uint32_t i = 0; i < n_threads; i++) | |||
| 693 | schedtbl[i] = (i / 2) % l->thread.count; | |||
| 694 | return false0; | |||
| 695 | } | |||
| 696 | ||||
| 697 | static void | |||
| 698 | adjust_threads_affinity(struct lwan *l, uint32_t *schedtbl, uint32_t mask) | |||
| 699 | { | |||
| 700 | for (uint32_t i = 0; i < l->thread.count; i++) { | |||
| 701 | cpu_set_t set; | |||
| 702 | ||||
| 703 | CPU_ZERO(&set)do __builtin_memset (&set, '\0', sizeof (cpu_set_t)); while (0); | |||
| 704 | 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; })); | |||
| ||||
| 705 | ||||
| 706 | if (pthread_setaffinity_np(l->thread.threads[i].self, sizeof(set), | |||
| 707 | &set)) | |||
| 708 | 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" , 708, __FUNCTION__, "Could not set affinity for thread %d", i ); | |||
| 709 | } | |||
| 710 | } | |||
| 711 | #elif defined(__x86_64__1) | |||
| 712 | static bool_Bool | |||
| 713 | topology_to_schedtbl(struct lwan *l, uint32_t schedtbl[], uint32_t n_threads) | |||
| 714 | { | |||
| 715 | for (uint32_t i = 0; i < n_threads; i++) | |||
| 716 | schedtbl[i] = (i / 2) % l->thread.count; | |||
| 717 | return false0; | |||
| 718 | } | |||
| 719 | ||||
| 720 | static void | |||
| 721 | adjust_threads_affinity(struct lwan *l, uint32_t *schedtbl, uint32_t n) | |||
| 722 | { | |||
| 723 | } | |||
| 724 | #endif | |||
| 725 | ||||
| 726 | void lwan_thread_init(struct lwan *l) | |||
| 727 | { | |||
| 728 | if (pthread_barrier_init(&l->thread.barrier, NULL((void*)0), | |||
| ||||
| 729 | (unsigned)l->thread.count + 1)) | |||
| 730 | lwan_status_critical("Could not create barrier")lwan_status_critical_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 730, __FUNCTION__, "Could not create barrier"); | |||
| 731 | ||||
| 732 | lwan_status_debug("Initializing threads")lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 732, __FUNCTION__, "Initializing threads"); | |||
| 733 | ||||
| 734 | l->thread.threads = | |||
| 735 | calloc((size_t)l->thread.count, sizeof(struct lwan_thread)); | |||
| 736 | if (!l->thread.threads) | |||
| 737 | 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" , 737, __FUNCTION__, "Could not allocate memory for threads"); | |||
| 738 | ||||
| 739 | for (unsigned int i = 0; i
| |||
| 740 | struct lwan_thread *thread = &l->thread.threads[i]; | |||
| 741 | ||||
| 742 | create_thread(l, thread); | |||
| 743 | ||||
| 744 | if ((thread->listen_fd = create_listen_socket(thread, i == 0)) < 0) | |||
| 745 | 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" , 745, __FUNCTION__, "Could not create listening socket"); | |||
| 746 | } | |||
| 747 | ||||
| 748 | const unsigned int total_conns = l->thread.max_fd * l->thread.count; | |||
| 749 | #ifdef __x86_64__1 | |||
| 750 | 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; })] | |||
| 751 | "Two connections per cache line")extern int (*__Static_assert_function (void)) [!!sizeof (struct { int __error_if_negative: (sizeof(struct lwan_connection) == 32) ? 2 : -1; })]; | |||
| 752 | ||||
| 753 | 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" , 755, __FUNCTION__, "%d CPUs of %d are online. " "Reading topology to pre-schedule clients" , l->online_cpus, l->available_cpus) | |||
| 754 | "Reading topology to pre-schedule clients",lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 755, __FUNCTION__, "%d CPUs of %d are online. " "Reading topology to pre-schedule clients" , l->online_cpus, l->available_cpus) | |||
| 755 | l->online_cpus, l->available_cpus)lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 755, __FUNCTION__, "%d CPUs of %d are online. " "Reading topology to pre-schedule clients" , l->online_cpus, l->available_cpus); | |||
| 756 | ||||
| 757 | /* | |||
| 758 | * Pre-schedule each file descriptor, to reduce some operations in the | |||
| 759 | * fast path. | |||
| 760 | * | |||
| 761 | * Since struct lwan_connection is guaranteed to be 32-byte long, two of | |||
| 762 | * them can fill up a cache line. Assume siblings share cache lines and | |||
| 763 | * use the CPU topology to group two connections per cache line in such | |||
| 764 | * a way that false sharing is avoided. | |||
| 765 | */ | |||
| 766 | uint32_t n_threads = (uint32_t)lwan_nextpow2((size_t)((l->thread.count - 1) * 2)); | |||
| 767 | uint32_t *schedtbl = alloca(n_threads * sizeof(uint32_t))__builtin_alloca (n_threads * sizeof(uint32_t)); | |||
| 768 | ||||
| 769 | bool_Bool adj_affinity = topology_to_schedtbl(l, schedtbl, n_threads); | |||
| 770 | ||||
| 771 | n_threads--; /* Transform count into mask for AND below */ | |||
| 772 | ||||
| 773 | if (adj_affinity
| |||
| 774 | adjust_threads_affinity(l, schedtbl, n_threads); | |||
| 775 | ||||
| 776 | for (unsigned int i = 0; i < total_conns; i++) | |||
| 777 | l->conns[i].thread = &l->thread.threads[schedtbl[i & n_threads]]; | |||
| 778 | #else | |||
| 779 | for (unsigned int i = 0; i < total_conns; i++) | |||
| 780 | l->conns[i].thread = &l->thread.threads[i % l->thread.count]; | |||
| 781 | #endif | |||
| 782 | ||||
| 783 | pthread_barrier_wait(&l->thread.barrier); | |||
| 784 | ||||
| 785 | 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" , 785, __FUNCTION__, "Worker threads created and ready to serve" ); | |||
| 786 | } | |||
| 787 | ||||
| 788 | void lwan_thread_shutdown(struct lwan *l) | |||
| 789 | { | |||
| 790 | lwan_status_debug("Shutting down threads")lwan_status_debug_debug("/home/buildbot/lwan-worker/clang-analyze/build/src/lib/lwan-thread.c" , 790, __FUNCTION__, "Shutting down threads"); | |||
| 791 | ||||
| 792 | for (unsigned int i = 0; i < l->thread.count; i++) { | |||
| 793 | struct lwan_thread *t = &l->thread.threads[i]; | |||
| 794 | int epoll_fd = t->epoll_fd; | |||
| 795 | int listen_fd = t->listen_fd; | |||
| 796 | ||||
| 797 | t->listen_fd = -1; | |||
| 798 | t->epoll_fd = -1; | |||
| 799 | close(epoll_fd); | |||
| 800 | close(listen_fd); | |||
| 801 | } | |||
| 802 | ||||
| 803 | pthread_barrier_wait(&l->thread.barrier); | |||
| 804 | pthread_barrier_destroy(&l->thread.barrier); | |||
| 805 | ||||
| 806 | for (unsigned int i = 0; i < l->thread.count; i++) { | |||
| 807 | struct lwan_thread *t = &l->thread.threads[i]; | |||
| 808 | ||||
| 809 | pthread_join(l->thread.threads[i].self, NULL((void*)0)); | |||
| 810 | timeouts_close(t->wheel); | |||
| 811 | } | |||
| 812 | ||||
| 813 | free(l->thread.threads); | |||
| 814 | } |