blob: a114deb9b1c2e4a0052824fe92cfdff008c4fedd [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
Willy Tarreaua5357cd2021-05-09 06:14:25 +02002 * HAProxy : High Availability-enabled HTTP/TCP proxy
Willy Tarreau1e183b82022-01-07 16:40:23 +01003 * Copyright 2000-2022 Willy Tarreau <willy@haproxy.org>.
Willy Tarreaubaaee002006-06-26 02:48:02 +02004 *
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
8 * 2 of the License, or (at your option) any later version.
9 *
Ilya Shipitsin46a030c2020-07-05 16:36:08 +050010 * Please refer to RFC7230 - RFC7235 information about HTTP protocol, and
11 * RFC6265 for information about cookies usage. More generally, the IETF HTTP
Willy Tarreaubaaee002006-06-26 02:48:02 +020012 * Working Group's web site should be consulted for protocol related changes :
13 *
14 * http://ftp.ics.uci.edu/pub/ietf/http/
15 *
16 * Pending bugs (may be not fixed because never reproduced) :
17 * - solaris only : sometimes, an HTTP proxy with only a dispatch address causes
18 * the proxy to terminate (no core) if the client breaks the connection during
19 * the response. Seen on 1.1.8pre4, but never reproduced. May not be related to
20 * the snprintf() bug since requests were simple (GET / HTTP/1.0), but may be
21 * related to missing setsid() (fixed in 1.1.15)
22 * - a proxy with an invalid config will prevent the startup even if disabled.
23 *
24 * ChangeLog has moved to the CHANGELOG file.
25 *
Willy Tarreaubaaee002006-06-26 02:48:02 +020026 */
27
David Carlier7ece0962015-12-08 21:43:09 +000028#define _GNU_SOURCE
Willy Tarreaubaaee002006-06-26 02:48:02 +020029#include <stdio.h>
30#include <stdlib.h>
31#include <unistd.h>
32#include <string.h>
33#include <ctype.h>
Maxime de Roucy379d9c72016-05-13 23:52:56 +020034#include <dirent.h>
Maxime de Roucy379d9c72016-05-13 23:52:56 +020035#include <sys/stat.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020036#include <sys/time.h>
37#include <sys/types.h>
38#include <sys/socket.h>
39#include <netinet/tcp.h>
40#include <netinet/in.h>
41#include <arpa/inet.h>
42#include <netdb.h>
43#include <fcntl.h>
44#include <errno.h>
45#include <signal.h>
46#include <stdarg.h>
47#include <sys/resource.h>
Tim Duesterhusdfad6a42020-04-18 16:02:47 +020048#include <sys/utsname.h>
Marc-Antoine Perennou992709b2013-02-12 10:53:52 +010049#include <sys/wait.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020050#include <time.h>
51#include <syslog.h>
Michael Schererab012dd2013-01-12 18:35:19 +010052#include <grp.h>
Willy Tarreaufc6c0322012-11-16 16:12:27 +010053#ifdef USE_CPU_AFFINITY
Willy Tarreaufc6c0322012-11-16 16:12:27 +010054#include <sched.h>
David Carlier42d9e5a2018-11-12 16:22:19 +000055#if defined(__FreeBSD__) || defined(__DragonFly__)
Pieter Baauwcaa6a1b2015-09-17 21:26:40 +020056#include <sys/param.h>
David Carlier42d9e5a2018-11-12 16:22:19 +000057#ifdef __FreeBSD__
Pieter Baauwcaa6a1b2015-09-17 21:26:40 +020058#include <sys/cpuset.h>
David Carlier42d9e5a2018-11-12 16:22:19 +000059#endif
David Carlier6d5c8412017-11-29 11:02:32 +000060#include <pthread_np.h>
Pieter Baauwcaa6a1b2015-09-17 21:26:40 +020061#endif
David Carlier5e4c8e22019-09-13 05:12:58 +010062#ifdef __APPLE__
63#include <mach/mach_types.h>
64#include <mach/thread_act.h>
65#include <mach/thread_policy.h>
66#endif
Willy Tarreaufc6c0322012-11-16 16:12:27 +010067#endif
Willy Tarreaubaaee002006-06-26 02:48:02 +020068
Willy Tarreau636848a2019-04-15 19:38:50 +020069#if defined(USE_PRCTL)
70#include <sys/prctl.h>
71#endif
72
devnexen@gmail.com078062b2021-08-21 09:13:10 +010073#if defined(USE_PROCCTL)
74#include <sys/procctl.h>
75#endif
76
Willy Tarreaubaaee002006-06-26 02:48:02 +020077#ifdef DEBUG_FULL
78#include <assert.h>
79#endif
Tim Duesterhusd6942c82017-11-20 15:58:35 +010080#if defined(USE_SYSTEMD)
81#include <systemd/sd-daemon.h>
82#endif
Willy Tarreaubaaee002006-06-26 02:48:02 +020083
Willy Tarreau6c3a6812020-03-06 18:57:15 +010084#include <import/sha1.h>
85
Willy Tarreaub2551052020-06-09 09:07:15 +020086#include <haproxy/acl.h>
Amaury Denoyelle68fd7e42021-03-25 17:15:52 +010087#include <haproxy/action.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020088#include <haproxy/activity.h>
89#include <haproxy/api.h>
90#include <haproxy/arg.h>
91#include <haproxy/auth.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020092#include <haproxy/base64.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020093#include <haproxy/capture-t.h>
Amaury Denoyelle5a6926d2021-03-30 17:34:24 +020094#include <haproxy/cfgdiag.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020095#include <haproxy/cfgparse.h>
Willy Tarreauc13ed532020-06-02 10:22:45 +020096#include <haproxy/chunk.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020097#include <haproxy/cli.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020098#include <haproxy/connection.h>
Amaury Denoyellea6f9c5d2021-04-23 16:58:08 +020099#ifdef USE_CPU_AFFINITY
Amaury Denoyelle982fb532021-04-21 18:39:58 +0200100#include <haproxy/cpuset.h>
Amaury Denoyellea6f9c5d2021-04-23 16:58:08 +0200101#endif
Willy Tarreaueb92deb2020-06-04 10:53:16 +0200102#include <haproxy/dns.h>
Willy Tarreau2741c8c2020-06-02 11:28:02 +0200103#include <haproxy/dynbuf.h>
Willy Tarreau8d366972020-05-27 16:10:29 +0200104#include <haproxy/errors.h>
Willy Tarreaub2551052020-06-09 09:07:15 +0200105#include <haproxy/fd.h>
Willy Tarreauc7babd82020-06-04 21:29:29 +0200106#include <haproxy/filters.h>
Willy Tarreaub2551052020-06-09 09:07:15 +0200107#include <haproxy/global.h>
Willy Tarreau86416052020-06-04 09:20:54 +0200108#include <haproxy/hlua.h>
Willy Tarreauc761f842020-06-04 11:40:28 +0200109#include <haproxy/http_rules.h>
Willy Tarreau853b2972020-05-27 18:01:47 +0200110#include <haproxy/list.h>
Willy Tarreau213e9902020-06-04 14:58:24 +0200111#include <haproxy/listener.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +0200112#include <haproxy/log.h>
Willy Tarreaub5abe5b2020-06-04 14:07:37 +0200113#include <haproxy/mworker.h>
Willy Tarreau7a00efb2020-06-02 17:02:59 +0200114#include <haproxy/namespace.h>
Willy Tarreau6131d6a2020-06-02 16:48:09 +0200115#include <haproxy/net_helper.h>
Willy Tarreau6019fab2020-05-27 16:26:00 +0200116#include <haproxy/openssl-compat.h>
Willy Tarreau225a90a2020-06-04 15:06:28 +0200117#include <haproxy/pattern.h>
Willy Tarreau3c2a7c22020-06-04 18:38:21 +0200118#include <haproxy/peers.h>
Willy Tarreaub2551052020-06-09 09:07:15 +0200119#include <haproxy/pool.h>
120#include <haproxy/protocol.h>
Willy Tarreaubf3b06b2020-08-26 10:23:40 +0200121#include <haproxy/proto_tcp.h>
Willy Tarreaua264d962020-06-04 22:29:18 +0200122#include <haproxy/proxy.h>
Willy Tarreau7cd8b6e2020-06-02 17:32:26 +0200123#include <haproxy/regex.h>
Willy Tarreaub2551052020-06-09 09:07:15 +0200124#include <haproxy/sample.h>
Willy Tarreau1e56f922020-06-04 23:20:13 +0200125#include <haproxy/server.h>
Willy Tarreau48d25b32020-06-04 18:58:52 +0200126#include <haproxy/session.h>
Willy Tarreau3727a8a2020-06-04 17:37:26 +0200127#include <haproxy/signal.h>
Willy Tarreau063d47d2020-08-28 16:29:53 +0200128#include <haproxy/sock.h>
Willy Tarreau25140cc2020-08-28 15:40:33 +0200129#include <haproxy/sock_inet.h>
Willy Tarreau209108d2020-06-04 20:30:20 +0200130#include <haproxy/ssl_sock.h>
Amaury Denoyelleee63d4b2020-10-05 11:49:42 +0200131#include <haproxy/stats-t.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +0200132#include <haproxy/stream.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +0200133#include <haproxy/task.h>
Willy Tarreau3f567e42020-05-28 15:29:19 +0200134#include <haproxy/thread.h>
Willy Tarreaub2551052020-06-09 09:07:15 +0200135#include <haproxy/time.h>
136#include <haproxy/tools.h>
137#include <haproxy/uri_auth-t.h>
Willy Tarreaua1718922020-06-04 16:25:31 +0200138#include <haproxy/vars.h>
Willy Tarreaub2551052020-06-09 09:07:15 +0200139#include <haproxy/version.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +0200140
Willy Tarreaubaaee002006-06-26 02:48:02 +0200141
Willy Tarreau7b5654f2019-03-29 21:30:17 +0100142/* array of init calls for older platforms */
143DECLARE_INIT_STAGES;
144
Willy Tarreauf4596402021-04-10 16:53:05 +0200145/* create a read_mostly section to hold variables which are accessed a lot
146 * but which almost never change. The purpose is to isolate them in their
147 * own cache lines where they don't risk to be perturbated by write accesses
148 * to neighbor variables. We need to create an empty aligned variable for
149 * this. The fact that the variable is of size zero means that it will be
150 * eliminated at link time if no other variable uses it, but alignment will
151 * be respected.
152 */
153empty_t __read_mostly_align HA_SECTION("read_mostly") ALIGNED(64);
154
Willy Tarreauf0d3b732021-05-06 16:30:32 +0200155#ifdef BUILD_FEATURES
156const char *build_features = BUILD_FEATURES;
157#else
158const char *build_features = "";
159#endif
160
Willy Tarreau477ecd82010-01-03 21:12:30 +0100161/* list of config files */
162static struct list cfg_cfgfiles = LIST_HEAD_INIT(cfg_cfgfiles);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200163int pid; /* current process id */
Willy Tarreau28156642007-11-26 16:13:36 +0100164int relative_pid = 1; /* process id starting at 1 */
Willy Tarreau387bd4f2017-11-10 19:08:14 +0100165unsigned long pid_bit = 1; /* bit corresponding to the process id */
Willy Tarreaua38a7172019-02-02 17:11:28 +0100166unsigned long all_proc_mask = 1; /* mask of all processes */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200167
Willy Tarreauf8ea00e2020-03-12 17:24:53 +0100168volatile unsigned long sleeping_thread_mask = 0; /* Threads that are about to sleep in poll() */
Willy Tarreau4b3f27b2020-03-12 17:28:01 +0100169volatile unsigned long stopping_thread_mask = 0; /* Threads acknowledged stopping */
Willy Tarreauf8ea00e2020-03-12 17:24:53 +0100170
Willy Tarreaubaaee002006-06-26 02:48:02 +0200171/* global options */
172struct global global = {
Cyril Bonté203ec5a2017-03-23 22:44:13 +0100173 .hard_stop_after = TICK_ETERNITY,
Willy Tarreau247a13a2012-11-15 17:38:15 +0100174 .nbproc = 1,
Amaury Denoyelle0f50cb92021-03-26 18:50:33 +0100175 .numa_cpu_mapping = 1,
Willy Tarreau149ab772019-01-26 14:27:06 +0100176 .nbthread = 0,
William Lallemand5f232402012-04-05 18:02:55 +0200177 .req_count = 0,
William Lallemand0f99e342011-10-12 17:50:54 +0200178 .logsrvs = LIST_HEAD_INIT(global.logsrvs),
William Lallemand9d5f5482012-11-07 16:12:57 +0100179 .maxzlibmem = 0,
William Lallemandd85f9172012-11-09 17:05:39 +0100180 .comp_rate_lim = 0,
Emeric Brun850efd52014-01-29 12:24:34 +0100181 .ssl_server_verify = SSL_SERVER_VERIFY_REQUIRED,
Emeric Bruned760922010-10-22 17:59:25 +0200182 .unix_bind = {
183 .ux = {
184 .uid = -1,
185 .gid = -1,
186 .mode = 0,
187 }
188 },
Willy Tarreau27a674e2009-08-17 07:23:33 +0200189 .tune = {
Willy Tarreau7ac908b2019-02-27 12:02:18 +0100190 .options = GTUNE_LISTENER_MQ,
Willy Tarreauc77d3642018-12-12 06:19:42 +0100191 .bufsize = (BUFSIZE + 2*sizeof(void *) - 1) & -(2*sizeof(void *)),
Christopher Faulet546c4692020-01-22 14:31:21 +0100192 .maxrewrite = MAXREWRITE,
Willy Tarreaua24adf02014-11-27 01:11:56 +0100193 .reserved_bufs = RESERVED_BUFS,
Willy Tarreauf3045d22015-04-29 16:24:50 +0200194 .pattern_cache = DEFAULT_PAT_LRU_SIZE,
Olivier Houchard88698d92019-04-16 19:07:22 +0200195 .pool_low_ratio = 20,
196 .pool_high_ratio = 25,
Christopher Faulet41ba36f2019-07-19 09:36:45 +0200197 .max_http_hdr = MAX_HTTP_HDR,
Emeric Brunfc32aca2012-09-03 12:10:29 +0200198#ifdef USE_OPENSSL
Emeric Brun46635772012-11-14 11:32:56 +0100199 .sslcachesize = SSLCACHESIZE,
Emeric Brunfc32aca2012-09-03 12:10:29 +0200200#endif
William Lallemandf3747832012-11-09 12:33:10 +0100201 .comp_maxlevel = 1,
Willy Tarreau7e312732014-02-12 16:35:14 +0100202#ifdef DEFAULT_IDLE_TIMER
203 .idle_timer = DEFAULT_IDLE_TIMER,
204#else
205 .idle_timer = 1000, /* 1 second */
206#endif
Willy Tarreau27a674e2009-08-17 07:23:33 +0200207 },
Emeric Brun76d88952012-10-05 15:47:31 +0200208#ifdef USE_OPENSSL
209#ifdef DEFAULT_MAXSSLCONN
Willy Tarreau403edff2012-09-06 11:58:37 +0200210 .maxsslconn = DEFAULT_MAXSSLCONN,
211#endif
Emeric Brun76d88952012-10-05 15:47:31 +0200212#endif
Willy Tarreaubaaee002006-06-26 02:48:02 +0200213 /* others NULL OK */
214};
215
216/*********************************************************************/
217
218int stopping; /* non zero means stopping in progress */
Cyril Bonté203ec5a2017-03-23 22:44:13 +0100219int killed; /* non zero means a hard-stop is triggered */
Willy Tarreauaf7ad002010-08-31 15:39:26 +0200220int jobs = 0; /* number of active jobs (conns, listeners, active tasks, ...) */
William Lallemanda7199262018-11-16 16:57:20 +0100221int unstoppable_jobs = 0; /* number of active jobs that can't be stopped during a soft stop */
Willy Tarreau199ad242018-11-05 16:31:22 +0100222int active_peers = 0; /* number of active peers (connection attempts and connected) */
Willy Tarreau2d372c22018-11-05 17:12:27 +0100223int connected_peers = 0; /* number of connected peers (verified ones) */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200224
Ilya Shipitsin46a030c2020-07-05 16:36:08 +0500225/* Here we store information about the pids of the processes we may pause
Willy Tarreaubaaee002006-06-26 02:48:02 +0200226 * or kill. We will send them a signal every 10 ms until we can bind to all
227 * our ports. With 200 retries, that's about 2 seconds.
228 */
229#define MAX_START_RETRIES 200
Willy Tarreaubaaee002006-06-26 02:48:02 +0200230static int *oldpids = NULL;
231static int oldpids_sig; /* use USR1 or TERM */
232
Olivier Houchardf73629d2017-04-05 22:33:04 +0200233/* Path to the unix socket we use to retrieve listener sockets from the old process */
234static const char *old_unixsocket;
235
William Lallemand85b0bd92017-06-01 17:38:53 +0200236static char *cur_unixsocket = NULL;
237
William Lallemandcb11fd22017-06-01 17:38:52 +0200238int atexit_flag = 0;
239
Willy Tarreaubb545b42010-08-25 12:58:59 +0200240int nb_oldpids = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200241const int zero = 0;
242const int one = 1;
Alexandre Cassen87ea5482007-10-11 20:48:58 +0200243const struct linger nolinger = { .l_onoff = 1, .l_linger = 0 };
Willy Tarreaubaaee002006-06-26 02:48:02 +0200244
Willy Tarreau1d21e0a2010-03-12 21:58:54 +0100245char hostname[MAX_HOSTNAME_LEN];
Dragan Dosen4f014152020-06-18 16:56:47 +0200246char *localpeer = NULL;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200247
William Lallemand00417412020-06-05 14:08:41 +0200248static char **old_argv = NULL; /* previous argv but cleaned up */
William Lallemand73b85e72017-06-01 17:38:51 +0200249
William Lallemandbc193052018-09-11 10:06:26 +0200250struct list proc_list = LIST_HEAD_INIT(proc_list);
251
252int master = 0; /* 1 if in master, 0 if in child */
Willy Tarreaubf696402019-03-01 10:09:28 +0100253unsigned int rlim_fd_cur_at_boot = 0;
254unsigned int rlim_fd_max_at_boot = 0;
William Lallemandbc193052018-09-11 10:06:26 +0200255
Willy Tarreau6c3a6812020-03-06 18:57:15 +0100256/* per-boot randomness */
257unsigned char boot_seed[20]; /* per-boot random seed (160 bits initially) */
258
William Lallemandb3f2be32018-09-11 10:06:18 +0200259static void *run_thread_poll_loop(void *data);
260
Willy Tarreauff055502014-04-28 22:27:06 +0200261/* bitfield of a few warnings to emit just once (WARN_*) */
262unsigned int warned = 0;
263
Amaury Denoyelle484454d2021-05-05 16:18:45 +0200264/* set if experimental features have been used for the current process */
265static unsigned int tainted = 0;
266
Amaury Denoyelled2e53cd2021-05-06 16:21:39 +0200267unsigned int experimental_directives_allowed = 0;
268
269int check_kw_experimental(struct cfg_keyword *kw, const char *file, int linenum,
270 char **errmsg)
271{
272 if (kw->flags & KWF_EXPERIMENTAL) {
273 if (!experimental_directives_allowed) {
Amaury Denoyelle86c1d0f2021-05-07 15:07:21 +0200274 memprintf(errmsg, "parsing [%s:%d] : '%s' directive is experimental, must be allowed via a global 'expose-experimental-directives'",
Amaury Denoyelled2e53cd2021-05-06 16:21:39 +0200275 file, linenum, kw->kw);
276 return 1;
277 }
278 mark_tainted(TAINTED_CONFIG_EXP_KW_DECLARED);
279 }
280
281 return 0;
282}
283
William Lallemande7361152018-10-26 14:47:36 +0200284/* master CLI configuration (-S flag) */
285struct list mworker_cli_conf = LIST_HEAD_INIT(mworker_cli_conf);
Willy Tarreaucdb737e2016-12-21 18:43:10 +0100286
287/* These are strings to be reported in the output of "haproxy -vv". They may
288 * either be constants (in which case must_free must be zero) or dynamically
289 * allocated strings to pass to free() on exit, and in this case must_free
290 * must be non-zero.
291 */
292struct list build_opts_list = LIST_HEAD_INIT(build_opts_list);
293struct build_opts_str {
294 struct list list;
295 const char *str;
296 int must_free;
297};
298
Willy Tarreaubaaee002006-06-26 02:48:02 +0200299/*********************************************************************/
300/* general purpose functions ***************************************/
301/*********************************************************************/
302
Willy Tarreaucdb737e2016-12-21 18:43:10 +0100303/* used to register some build option strings at boot. Set must_free to
304 * non-zero if the string must be freed upon exit.
305 */
306void hap_register_build_opts(const char *str, int must_free)
307{
308 struct build_opts_str *b;
309
310 b = calloc(1, sizeof(*b));
311 if (!b) {
312 fprintf(stderr, "out of memory\n");
313 exit(1);
314 }
315 b->str = str;
316 b->must_free = must_free;
Willy Tarreau2b718102021-04-21 07:32:39 +0200317 LIST_APPEND(&build_opts_list, &b->list);
Willy Tarreaucdb737e2016-12-21 18:43:10 +0100318}
319
Willy Tarreaua43dfda2021-05-06 07:43:35 +0200320#define VERSION_MAX_ELTS 7
321
322/* This function splits an haproxy version string into an array of integers.
323 * The syntax of the supported version string is the following:
324 *
325 * <a>[.<b>[.<c>[.<d>]]][-{dev,pre,rc}<f>][-*][-<g>]
326 *
327 * This validates for example:
328 * 1.2.1-pre2, 1.2.1, 1.2.10.1, 1.3.16-rc1, 1.4-dev3, 1.5-dev18, 1.5-dev18-43
329 * 2.4-dev18-f6818d-20
330 *
331 * The result is set in a array of <VERSION_MAX_ELTS> elements. Each letter has
332 * one fixed place in the array. The tags take a numeric value called <e> which
333 * defaults to 3. "dev" is 1, "rc" and "pre" are 2. Numbers not encountered are
334 * considered as zero (henxe 1.5 and 1.5.0 are the same).
335 *
336 * The resulting values are:
337 * 1.2.1-pre2 1, 2, 1, 0, 2, 2, 0
338 * 1.2.1 1, 2, 1, 0, 3, 0, 0
339 * 1.2.10.1 1, 2, 10, 1, 3, 0, 0
340 * 1.3.16-rc1 1, 3, 16, 0, 2, 1, 0
341 * 1.4-dev3 1, 4, 0, 0, 1, 3, 0
342 * 1.5-dev18 1, 5, 0, 0, 1, 18, 0
343 * 1.5-dev18-43 1, 5, 0, 0, 1, 18, 43
344 * 2.4-dev18-f6818d-20 2, 4, 0, 0, 1, 18, 20
345 *
346 * The function returns non-zero if the conversion succeeded, or zero if it
347 * failed.
348 */
349int split_version(const char *version, unsigned int *value)
350{
351 const char *p, *s;
352 char *error;
353 int nelts;
354
355 /* Initialize array with zeroes */
356 for (nelts = 0; nelts < VERSION_MAX_ELTS; nelts++)
357 value[nelts] = 0;
358 value[4] = 3;
359
360 p = version;
361
362 /* If the version number is empty, return false */
363 if (*p == '\0')
364 return 0;
365
366 /* Convert first number <a> */
367 value[0] = strtol(p, &error, 10);
368 p = error + 1;
369 if (*error == '\0')
370 return 1;
371 if (*error == '-')
372 goto split_version_tag;
373 if (*error != '.')
374 return 0;
375
376 /* Convert first number <b> */
377 value[1] = strtol(p, &error, 10);
378 p = error + 1;
379 if (*error == '\0')
380 return 1;
381 if (*error == '-')
382 goto split_version_tag;
383 if (*error != '.')
384 return 0;
385
386 /* Convert first number <c> */
387 value[2] = strtol(p, &error, 10);
388 p = error + 1;
389 if (*error == '\0')
390 return 1;
391 if (*error == '-')
392 goto split_version_tag;
393 if (*error != '.')
394 return 0;
395
396 /* Convert first number <d> */
397 value[3] = strtol(p, &error, 10);
398 p = error + 1;
399 if (*error == '\0')
400 return 1;
401 if (*error != '-')
402 return 0;
403
404 split_version_tag:
405 /* Check for commit number */
406 if (*p >= '0' && *p <= '9')
407 goto split_version_commit;
408
409 /* Read tag */
410 if (strncmp(p, "dev", 3) == 0) { value[4] = 1; p += 3; }
411 else if (strncmp(p, "rc", 2) == 0) { value[4] = 2; p += 2; }
412 else if (strncmp(p, "pre", 3) == 0) { value[4] = 2; p += 3; }
413 else
414 goto split_version_commit;
415
416 /* Convert tag number */
417 value[5] = strtol(p, &error, 10);
418 p = error + 1;
419 if (*error == '\0')
420 return 1;
421 if (*error != '-')
422 return 0;
423
424 split_version_commit:
425 /* Search the last "-" */
426 s = strrchr(p, '-');
427 if (s) {
428 s++;
429 if (*s == '\0')
430 return 0;
431 value[6] = strtol(s, &error, 10);
432 if (*error != '\0')
433 value[6] = 0;
434 return 1;
435 }
436
437 /* convert the version */
438 value[6] = strtol(p, &error, 10);
439 if (*error != '\0')
440 value[6] = 0;
441
442 return 1;
443}
444
445/* This function compares the current haproxy version with an arbitrary version
446 * string. It returns:
447 * -1 : the version in argument is older than the current haproxy version
448 * 0 : the version in argument is the same as the current haproxy version
449 * 1 : the version in argument is newer than the current haproxy version
450 *
451 * Or some errors:
452 * -2 : the current haproxy version is not parsable
453 * -3 : the version in argument is not parsable
454 */
455int compare_current_version(const char *version)
456{
457 unsigned int loc[VERSION_MAX_ELTS];
458 unsigned int mod[VERSION_MAX_ELTS];
459 int i;
460
461 /* split versions */
462 if (!split_version(haproxy_version, loc))
463 return -2;
464 if (!split_version(version, mod))
465 return -3;
466
467 /* compare versions */
468 for (i = 0; i < VERSION_MAX_ELTS; i++) {
469 if (mod[i] < loc[i])
470 return -1;
471 else if (mod[i] > loc[i])
472 return 1;
473 }
474 return 0;
475}
476
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100477static void display_version()
Willy Tarreaubaaee002006-06-26 02:48:02 +0200478{
Tim Duesterhusdfad6a42020-04-18 16:02:47 +0200479 struct utsname utsname;
480
Willy Tarreaua5357cd2021-05-09 06:14:25 +0200481 printf("HAProxy version %s %s - https://haproxy.org/\n"
Willy Tarreau08dd2022019-11-21 18:07:30 +0100482 PRODUCT_STATUS "\n", haproxy_version, haproxy_date);
Willy Tarreau47479eb2019-11-21 18:48:20 +0100483
484 if (strlen(PRODUCT_URL_BUGS) > 0) {
485 char base_version[20];
486 int dots = 0;
487 char *del;
488
489 /* only retrieve the base version without distro-specific extensions */
490 for (del = haproxy_version; *del; del++) {
491 if (*del == '.')
492 dots++;
493 else if (*del < '0' || *del > '9')
494 break;
495 }
496
497 strlcpy2(base_version, haproxy_version, del - haproxy_version + 1);
498 if (dots < 2)
499 printf("Known bugs: https://github.com/haproxy/haproxy/issues?q=is:issue+is:open\n");
500 else
501 printf("Known bugs: " PRODUCT_URL_BUGS "\n", base_version);
502 }
Tim Duesterhusdfad6a42020-04-18 16:02:47 +0200503
504 if (uname(&utsname) == 0) {
505 printf("Running on: %s %s %s %s\n", utsname.sysname, utsname.release, utsname.version, utsname.machine);
506 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200507}
508
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100509static void display_build_opts()
Willy Tarreau7b066db2007-12-02 11:28:59 +0100510{
Willy Tarreaucdb737e2016-12-21 18:43:10 +0100511 struct build_opts_str *item;
512
Willy Tarreau7b066db2007-12-02 11:28:59 +0100513 printf("Build options :"
514#ifdef BUILD_TARGET
Willy Tarreau9f2b7302008-01-02 20:48:34 +0100515 "\n TARGET = " BUILD_TARGET
Willy Tarreau7b066db2007-12-02 11:28:59 +0100516#endif
517#ifdef BUILD_CPU
Willy Tarreau9f2b7302008-01-02 20:48:34 +0100518 "\n CPU = " BUILD_CPU
Willy Tarreau7b066db2007-12-02 11:28:59 +0100519#endif
520#ifdef BUILD_CC
Willy Tarreau9f2b7302008-01-02 20:48:34 +0100521 "\n CC = " BUILD_CC
522#endif
523#ifdef BUILD_CFLAGS
524 "\n CFLAGS = " BUILD_CFLAGS
Willy Tarreau7b066db2007-12-02 11:28:59 +0100525#endif
Willy Tarreau9f2b7302008-01-02 20:48:34 +0100526#ifdef BUILD_OPTIONS
527 "\n OPTIONS = " BUILD_OPTIONS
Willy Tarreau7b066db2007-12-02 11:28:59 +0100528#endif
Tim Duesterhusc8d19702020-11-21 18:07:59 +0100529#ifdef BUILD_DEBUG
530 "\n DEBUG = " BUILD_DEBUG
531#endif
Willy Tarreau7728ed32019-03-27 13:20:08 +0100532#ifdef BUILD_FEATURES
533 "\n\nFeature list : " BUILD_FEATURES
534#endif
Willy Tarreau27a674e2009-08-17 07:23:33 +0200535 "\n\nDefault settings :"
Willy Tarreauca783d42019-03-13 10:03:07 +0100536 "\n bufsize = %d, maxrewrite = %d, maxpollevents = %d"
Willy Tarreau27a674e2009-08-17 07:23:33 +0200537 "\n\n",
Willy Tarreauca783d42019-03-13 10:03:07 +0100538 BUFSIZE, MAXREWRITE, MAX_POLL_EVENTS);
Willy Tarreaube5b6852009-10-03 18:57:08 +0200539
Willy Tarreaucdb737e2016-12-21 18:43:10 +0100540 list_for_each_entry(item, &build_opts_list, list) {
541 puts(item->str);
542 }
543
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +0100544 putchar('\n');
545
Willy Tarreaube5b6852009-10-03 18:57:08 +0200546 list_pollers(stdout);
547 putchar('\n');
Christopher Faulet98d9fe22018-04-10 14:37:32 +0200548 list_mux_proto(stdout);
549 putchar('\n');
Willy Tarreau679bba12019-03-19 08:08:10 +0100550 list_services(stdout);
551 putchar('\n');
Christopher Fauletb3f4e142016-03-07 12:46:38 +0100552 list_filters(stdout);
553 putchar('\n');
Willy Tarreau7b066db2007-12-02 11:28:59 +0100554}
555
Willy Tarreaubaaee002006-06-26 02:48:02 +0200556/*
557 * This function prints the command line usage and exits
558 */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100559static void usage(char *name)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200560{
561 display_version();
562 fprintf(stderr,
Maxime de Roucy379d9c72016-05-13 23:52:56 +0200563 "Usage : %s [-f <cfgfile|cfgdir>]* [ -vdV"
Willy Tarreaubaaee002006-06-26 02:48:02 +0200564 "D ] [ -n <maxconn> ] [ -N <maxpconn> ]\n"
Willy Tarreaua088d312015-10-08 11:58:48 +0200565 " [ -p <pidfile> ] [ -m <max megs> ] [ -C <dir> ] [-- <cfgfile>*]\n"
Willy Tarreau7b066db2007-12-02 11:28:59 +0100566 " -v displays version ; -vv shows known build options.\n"
Willy Tarreaubaaee002006-06-26 02:48:02 +0200567 " -d enters debug mode ; -db only disables background mode.\n"
Willy Tarreau6e064432012-05-08 15:40:42 +0200568 " -dM[<byte>] poisons memory with <byte> (defaults to 0x50)\n"
Willy Tarreaubaaee002006-06-26 02:48:02 +0200569 " -V enters verbose mode (disables quiet mode)\n"
Willy Tarreau576132e2011-09-10 19:26:56 +0200570 " -D goes daemon ; -C changes to <dir> before loading files.\n"
William Lallemand095ba4c2017-06-01 17:38:50 +0200571 " -W master-worker mode.\n"
Tim Duesterhusd6942c82017-11-20 15:58:35 +0100572#if defined(USE_SYSTEMD)
573 " -Ws master-worker mode with systemd notify support.\n"
574#endif
Willy Tarreaubaaee002006-06-26 02:48:02 +0200575 " -q quiet mode : don't display messages\n"
Willy Tarreau5d01a632009-06-22 16:02:30 +0200576 " -c check mode : only check config files and exit\n"
Willy Tarreauca783d42019-03-13 10:03:07 +0100577 " -n sets the maximum total # of connections (uses ulimit -n)\n"
Willy Tarreaubaaee002006-06-26 02:48:02 +0200578 " -m limits the usable amount of memory (in MB)\n"
579 " -N sets the default, per-proxy maximum # of connections (%d)\n"
Emeric Brun2b920a12010-09-23 18:30:22 +0200580 " -L set local peer name (default to hostname)\n"
Willy Tarreaubaaee002006-06-26 02:48:02 +0200581 " -p writes pids of all children to this file\n"
Willy Tarreaue5733232019-05-22 19:24:06 +0200582#if defined(USE_EPOLL)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200583 " -de disables epoll() usage even when available\n"
584#endif
Willy Tarreaue5733232019-05-22 19:24:06 +0200585#if defined(USE_KQUEUE)
Willy Tarreau1e63130a2007-04-09 12:03:06 +0200586 " -dk disables kqueue() usage even when available\n"
587#endif
Willy Tarreaue5733232019-05-22 19:24:06 +0200588#if defined(USE_EVPORTS)
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000589 " -dv disables event ports usage even when available\n"
590#endif
Willy Tarreaue5733232019-05-22 19:24:06 +0200591#if defined(USE_POLL)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200592 " -dp disables poll() usage even when available\n"
593#endif
Willy Tarreaue5733232019-05-22 19:24:06 +0200594#if defined(USE_LINUX_SPLICE)
Willy Tarreau3ab68cf2009-01-25 16:03:28 +0100595 " -dS disables splice usage (broken on old kernels)\n"
596#endif
Nenad Merdanovic88afe032014-04-14 15:56:58 +0200597#if defined(USE_GETADDRINFO)
598 " -dG disables getaddrinfo() usage\n"
599#endif
Lukas Tribusa0bcbdc2016-09-12 21:42:20 +0000600#if defined(SO_REUSEPORT)
601 " -dR disables SO_REUSEPORT usage\n"
602#endif
Willy Tarreau0aa9dbe2021-12-28 15:43:11 +0100603#if defined(HA_HAVE_DUMP_LIBS)
604 " -dL dumps loaded object files after config checks\n"
605#endif
Willy Tarreau3eed10e2016-11-07 21:03:16 +0100606 " -dr ignores server address resolution failures\n"
Emeric Brun850efd52014-01-29 12:24:34 +0100607 " -dV disables SSL verify on servers side\n"
Willy Tarreau3eb10b82020-04-15 16:42:39 +0200608 " -dW fails if any warning is emitted\n"
Amaury Denoyelle7b01a8d2021-03-29 10:29:07 +0200609 " -dD diagnostic mode : warn about suspicious configuration statements\n"
Willy Tarreauc6ca1aa2015-10-08 11:32:32 +0200610 " -sf/-st [pid ]* finishes/terminates old pids.\n"
Olivier Houchardf73629d2017-04-05 22:33:04 +0200611 " -x <unix_socket> get listening sockets from a unix socket\n"
William Lallemand63329e32019-06-13 17:03:37 +0200612 " -S <bind>[,<bind options>...] new master CLI\n"
Willy Tarreaubaaee002006-06-26 02:48:02 +0200613 "\n",
Willy Tarreauca783d42019-03-13 10:03:07 +0100614 name, cfg_maxpconn);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200615 exit(1);
616}
617
618
619
620/*********************************************************************/
621/* more specific functions ***************************************/
622/*********************************************************************/
623
William Lallemand73b85e72017-06-01 17:38:51 +0200624/* sends the signal <sig> to all pids found in <oldpids>. Returns the number of
625 * pids the signal was correctly delivered to.
626 */
William Lallemande25473c2019-04-01 11:29:56 +0200627int tell_old_pids(int sig)
William Lallemand73b85e72017-06-01 17:38:51 +0200628{
629 int p;
630 int ret = 0;
631 for (p = 0; p < nb_oldpids; p++)
632 if (kill(oldpids[p], sig) == 0)
633 ret++;
634 return ret;
635}
636
William Lallemand75ea0a02017-11-15 19:02:58 +0100637/*
William Lallemand73b85e72017-06-01 17:38:51 +0200638 * remove a pid forom the olpid array and decrease nb_oldpids
639 * return 1 pid was found otherwise return 0
640 */
641
642int delete_oldpid(int pid)
643{
644 int i;
645
646 for (i = 0; i < nb_oldpids; i++) {
647 if (oldpids[i] == pid) {
648 oldpids[i] = oldpids[nb_oldpids - 1];
649 oldpids[nb_oldpids - 1] = 0;
650 nb_oldpids--;
651 return 1;
652 }
653 }
654 return 0;
655}
656
William Lallemand85b0bd92017-06-01 17:38:53 +0200657
658static void get_cur_unixsocket()
659{
Willy Tarreau7b11b7e2022-02-01 08:47:41 +0100660 /* get rid of the one found on the command line for now */
661 ha_free(&cur_unixsocket);
662
William Lallemand85b0bd92017-06-01 17:38:53 +0200663 /* if -x was used, try to update the stat socket if not available anymore */
Willy Tarreau4975d142021-03-13 11:00:33 +0100664 if (global.cli_fe) {
William Lallemand85b0bd92017-06-01 17:38:53 +0200665 struct bind_conf *bind_conf;
666
667 /* pass through all stats socket */
Willy Tarreau4975d142021-03-13 11:00:33 +0100668 list_for_each_entry(bind_conf, &global.cli_fe->conf.bind, by_fe) {
William Lallemand85b0bd92017-06-01 17:38:53 +0200669 struct listener *l;
670
671 list_for_each_entry(l, &bind_conf->listeners, by_bind) {
672
Willy Tarreau37159062020-08-27 07:48:42 +0200673 if (l->rx.addr.ss_family == AF_UNIX &&
William Lallemand85b0bd92017-06-01 17:38:53 +0200674 (bind_conf->level & ACCESS_FD_LISTENERS)) {
675 const struct sockaddr_un *un;
676
Willy Tarreau37159062020-08-27 07:48:42 +0200677 un = (struct sockaddr_un *)&l->rx.addr;
William Lallemand85b0bd92017-06-01 17:38:53 +0200678 /* priority to old_unixsocket */
679 if (!cur_unixsocket) {
680 cur_unixsocket = strdup(un->sun_path);
681 } else {
Tim Duesterhuse5ff1412021-01-02 22:31:53 +0100682 if (old_unixsocket && strcmp(un->sun_path, old_unixsocket) == 0) {
William Lallemand85b0bd92017-06-01 17:38:53 +0200683 free(cur_unixsocket);
684 cur_unixsocket = strdup(old_unixsocket);
685 return;
686 }
687 }
688 }
689 }
690 }
691 }
692 if (!cur_unixsocket && old_unixsocket)
693 cur_unixsocket = strdup(old_unixsocket);
694}
695
William Lallemand73b85e72017-06-01 17:38:51 +0200696/*
697 * When called, this function reexec haproxy with -sf followed by current
Joseph Herlant03420902018-11-15 10:41:50 -0800698 * children PIDs and possibly old children PIDs if they didn't leave yet.
William Lallemand73b85e72017-06-01 17:38:51 +0200699 */
William Lallemanda57b7e32018-12-14 21:11:31 +0100700void mworker_reload()
William Lallemand73b85e72017-06-01 17:38:51 +0200701{
William Lallemand00417412020-06-05 14:08:41 +0200702 char **next_argv = NULL;
703 int old_argc = 0; /* previous number of argument */
William Lallemand73b85e72017-06-01 17:38:51 +0200704 int next_argc = 0;
William Lallemand00417412020-06-05 14:08:41 +0200705 int i = 0;
William Lallemand73b85e72017-06-01 17:38:51 +0200706 char *msg = NULL;
Willy Tarreau8dca1952019-03-01 10:21:55 +0100707 struct rlimit limit;
William Lallemand7c756a82018-11-26 11:53:40 +0100708 struct per_thread_deinit_fct *ptdf;
William Lallemand73b85e72017-06-01 17:38:51 +0200709
710 mworker_block_signals();
Tim Duesterhusd6942c82017-11-20 15:58:35 +0100711#if defined(USE_SYSTEMD)
712 if (global.tune.options & GTUNE_USE_SYSTEMD)
713 sd_notify(0, "RELOADING=1");
714#endif
William Lallemand73b85e72017-06-01 17:38:51 +0200715 setenv("HAPROXY_MWORKER_REEXEC", "1", 1);
716
William Lallemand030571a2022-01-28 21:17:30 +0100717 mworker_cleanup_proc();
William Lallemandbc193052018-09-11 10:06:26 +0200718 mworker_proc_list_to_env(); /* put the children description in the env */
719
William Lallemand7c756a82018-11-26 11:53:40 +0100720 /* during the reload we must ensure that every FDs that can't be
721 * reuse (ie those that are not referenced in the proc_list)
722 * are closed or they will leak. */
723
724 /* close the listeners FD */
725 mworker_cli_proxy_stop();
William Lallemand16866672019-06-24 17:40:48 +0200726
727 if (getenv("HAPROXY_MWORKER_WAIT_ONLY") == NULL) {
728 /* close the poller FD and the thread waker pipe FD */
729 list_for_each_entry(ptdf, &per_thread_deinit_list, list)
730 ptdf->fct();
731 if (fdtab)
732 deinit_pollers();
733 }
Ilya Shipitsin98a9e1b2021-02-19 23:42:53 +0500734#ifdef HAVE_SSL_RAND_KEEP_RANDOM_DEVICES_OPEN
William Lallemand5fdb5b32019-10-15 14:04:08 +0200735 /* close random device FDs */
736 RAND_keep_random_devices_open(0);
Rob Allen56996da2019-05-03 09:11:32 +0100737#endif
William Lallemand7c756a82018-11-26 11:53:40 +0100738
Willy Tarreau8dca1952019-03-01 10:21:55 +0100739 /* restore the initial FD limits */
740 limit.rlim_cur = rlim_fd_cur_at_boot;
741 limit.rlim_max = rlim_fd_max_at_boot;
742 if (setrlimit(RLIMIT_NOFILE, &limit) == -1) {
743 getrlimit(RLIMIT_NOFILE, &limit);
744 ha_warning("Failed to restore initial FD limits (cur=%u max=%u), using cur=%u max=%u\n",
745 rlim_fd_cur_at_boot, rlim_fd_max_at_boot,
746 (unsigned int)limit.rlim_cur, (unsigned int)limit.rlim_max);
747 }
748
William Lallemand73b85e72017-06-01 17:38:51 +0200749 /* compute length */
William Lallemand00417412020-06-05 14:08:41 +0200750 while (old_argv[old_argc])
751 old_argc++;
William Lallemand73b85e72017-06-01 17:38:51 +0200752
William Lallemand85b0bd92017-06-01 17:38:53 +0200753 /* 1 for haproxy -sf, 2 for -x /socket */
William Lallemandaba7f8b2021-04-21 16:55:34 +0200754 next_argv = calloc(old_argc + 1 + 2 + mworker_child_nb() + 1,
Tim Duesterhuse52b6e52020-09-12 20:26:43 +0200755 sizeof(*next_argv));
William Lallemand73b85e72017-06-01 17:38:51 +0200756 if (next_argv == NULL)
757 goto alloc_error;
758
William Lallemand00417412020-06-05 14:08:41 +0200759 /* copy the program name */
760 next_argv[next_argc++] = old_argv[0];
761
762 /* insert the new options just after argv[0] in case we have a -- */
763
William Lallemand73b85e72017-06-01 17:38:51 +0200764 /* add -sf <PID>* to argv */
William Lallemand3f128872019-04-01 11:29:59 +0200765 if (mworker_child_nb() > 0) {
766 struct mworker_proc *child;
767
William Lallemand73b85e72017-06-01 17:38:51 +0200768 next_argv[next_argc++] = "-sf";
William Lallemand3f128872019-04-01 11:29:59 +0200769
770 list_for_each_entry(child, &proc_list, list) {
William Lallemand677e2f22019-11-19 17:04:18 +0100771 if (!(child->options & (PROC_O_TYPE_WORKER|PROC_O_TYPE_PROG)) || child->pid <= -1 )
William Lallemand3f128872019-04-01 11:29:59 +0200772 continue;
William Lallemand00417412020-06-05 14:08:41 +0200773 if ((next_argv[next_argc++] = memprintf(&msg, "%d", child->pid)) == NULL)
William Lallemand73b85e72017-06-01 17:38:51 +0200774 goto alloc_error;
775 msg = NULL;
776 }
777 }
William Lallemand2bf6d622017-06-20 11:20:23 +0200778 /* add the -x option with the stat socket */
William Lallemand85b0bd92017-06-01 17:38:53 +0200779 if (cur_unixsocket) {
William Lallemand2bf6d622017-06-20 11:20:23 +0200780 next_argv[next_argc++] = "-x";
781 next_argv[next_argc++] = (char *)cur_unixsocket;
William Lallemand85b0bd92017-06-01 17:38:53 +0200782 }
783
William Lallemand00417412020-06-05 14:08:41 +0200784 /* copy the previous options */
785 for (i = 1; i < old_argc; i++)
786 next_argv[next_argc++] = old_argv[i];
787
Christopher Faulet767a84b2017-11-24 16:50:31 +0100788 ha_warning("Reexecuting Master process\n");
Willy Tarreaue0d86e22019-08-26 10:37:39 +0200789 signal(SIGPROF, SIG_IGN);
Tim Duesterhus0436ab72017-11-12 17:39:18 +0100790 execvp(next_argv[0], next_argv);
William Lallemand73b85e72017-06-01 17:38:51 +0200791
Christopher Faulet767a84b2017-11-24 16:50:31 +0100792 ha_warning("Failed to reexecute the master process [%d]: %s\n", pid, strerror(errno));
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100793 ha_free(&next_argv);
William Lallemand722d4ca2017-11-15 19:02:55 +0100794 return;
795
William Lallemand73b85e72017-06-01 17:38:51 +0200796alloc_error:
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100797 ha_free(&next_argv);
Joseph Herlant07a08342018-11-15 10:43:05 -0800798 ha_warning("Failed to reexecute the master process [%d]: Cannot allocate memory\n", pid);
William Lallemand73b85e72017-06-01 17:38:51 +0200799 return;
800}
801
William Lallemandb3f2be32018-09-11 10:06:18 +0200802static void mworker_loop()
803{
804
805#if defined(USE_SYSTEMD)
806 if (global.tune.options & GTUNE_USE_SYSTEMD)
807 sd_notifyf(0, "READY=1\nMAINPID=%lu", (unsigned long)getpid());
808#endif
Willy Tarreaud83b6c12019-04-18 11:31:36 +0200809 /* Busy polling makes no sense in the master :-) */
810 global.tune.options &= ~GTUNE_BUSY_POLLING;
William Lallemandb3f2be32018-09-11 10:06:18 +0200811
William Lallemandbc193052018-09-11 10:06:26 +0200812 master = 1;
813
Willy Tarreaud26c9f92019-12-11 14:24:07 +0100814 signal_unregister(SIGTTIN);
815 signal_unregister(SIGTTOU);
William Lallemand0564d412018-11-20 17:36:53 +0100816 signal_unregister(SIGUSR1);
817 signal_unregister(SIGHUP);
818 signal_unregister(SIGQUIT);
819
William Lallemandb3f2be32018-09-11 10:06:18 +0200820 signal_register_fct(SIGTERM, mworker_catch_sigterm, SIGTERM);
821 signal_register_fct(SIGUSR1, mworker_catch_sigterm, SIGUSR1);
Willy Tarreaud26c9f92019-12-11 14:24:07 +0100822 signal_register_fct(SIGTTIN, mworker_broadcast_signal, SIGTTIN);
823 signal_register_fct(SIGTTOU, mworker_broadcast_signal, SIGTTOU);
William Lallemandb3f2be32018-09-11 10:06:18 +0200824 signal_register_fct(SIGINT, mworker_catch_sigterm, SIGINT);
825 signal_register_fct(SIGHUP, mworker_catch_sighup, SIGHUP);
826 signal_register_fct(SIGUSR2, mworker_catch_sighup, SIGUSR2);
827 signal_register_fct(SIGCHLD, mworker_catch_sigchld, SIGCHLD);
828
829 mworker_unblock_signals();
830 mworker_cleanlisteners();
William Lallemand27f3fa52018-12-06 14:05:20 +0100831 mworker_cleantasks();
William Lallemandb3f2be32018-09-11 10:06:18 +0200832
William Lallemandbc193052018-09-11 10:06:26 +0200833 mworker_catch_sigchld(NULL); /* ensure we clean the children in case
834 some SIGCHLD were lost */
835
William Lallemandb3f2be32018-09-11 10:06:18 +0200836 global.nbthread = 1;
837 relative_pid = 1;
838 pid_bit = 1;
Willy Tarreaua38a7172019-02-02 17:11:28 +0100839 all_proc_mask = 1;
William Lallemandb3f2be32018-09-11 10:06:18 +0200840
William Lallemand2672eb92018-12-14 15:52:39 +0100841#ifdef USE_THREAD
842 tid_bit = 1;
843 all_threads_mask = 1;
844#endif
845
William Lallemandb3f2be32018-09-11 10:06:18 +0200846 jobs++; /* this is the "master" job, we want to take care of the
847 signals even if there is no listener so the poll loop don't
848 leave */
849
850 fork_poller();
Willy Tarreaub4f7cc32019-05-03 09:27:30 +0200851 run_thread_poll_loop(0);
William Lallemandb3f2be32018-09-11 10:06:18 +0200852}
William Lallemandcb11fd22017-06-01 17:38:52 +0200853
854/*
855 * Reexec the process in failure mode, instead of exiting
856 */
857void reexec_on_failure()
858{
859 if (!atexit_flag)
860 return;
861
862 setenv("HAPROXY_MWORKER_WAIT_ONLY", "1", 1);
863
Willy Tarreau96d9a7f2022-01-28 18:40:06 +0100864 /* do not keep unused FDs retrieved from the previous process */
865 sock_drop_unused_old_sockets();
866
Christopher Faulet767a84b2017-11-24 16:50:31 +0100867 ha_warning("Reexecuting Master process in waitpid mode\n");
William Lallemandcb11fd22017-06-01 17:38:52 +0200868 mworker_reload();
William Lallemandcb11fd22017-06-01 17:38:52 +0200869}
William Lallemand73b85e72017-06-01 17:38:51 +0200870
871
872/*
Willy Tarreaud0807c32010-08-27 18:26:11 +0200873 * upon SIGUSR1, let's have a soft stop. Note that soft_stop() broadcasts
874 * a signal zero to all subscribers. This means that it's as easy as
875 * subscribing to signal 0 to get informed about an imminent shutdown.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200876 */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100877static void sig_soft_stop(struct sig_handler *sh)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200878{
879 soft_stop();
Willy Tarreau24f4efa2010-08-27 17:56:48 +0200880 signal_unregister_handler(sh);
Willy Tarreaubafbe012017-11-24 17:34:44 +0100881 pool_gc(NULL);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200882}
883
884/*
885 * upon SIGTTOU, we pause everything
886 */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100887static void sig_pause(struct sig_handler *sh)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200888{
Willy Tarreau775e0012020-09-24 16:36:26 +0200889 if (protocol_pause_all() & ERR_FATAL) {
890 const char *msg = "Some proxies refused to pause, performing soft stop now.\n";
Willy Tarreau0a002df2020-10-09 19:26:27 +0200891 ha_warning("%s", msg);
892 send_log(NULL, LOG_WARNING, "%s", msg);
Willy Tarreau775e0012020-09-24 16:36:26 +0200893 soft_stop();
894 }
Willy Tarreaubafbe012017-11-24 17:34:44 +0100895 pool_gc(NULL);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200896}
897
898/*
899 * upon SIGTTIN, let's have a soft stop.
900 */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100901static void sig_listen(struct sig_handler *sh)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200902{
Willy Tarreau775e0012020-09-24 16:36:26 +0200903 if (protocol_resume_all() & ERR_FATAL) {
904 const char *msg = "Some proxies refused to resume, probably due to a conflict on a listening port. You may want to try again after the conflicting application is stopped, otherwise a restart might be needed to resume safe operations.\n";
Willy Tarreau0a002df2020-10-09 19:26:27 +0200905 ha_warning("%s", msg);
906 send_log(NULL, LOG_WARNING, "%s", msg);
Willy Tarreau775e0012020-09-24 16:36:26 +0200907 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200908}
909
910/*
911 * this function dumps every server's state when the process receives SIGHUP.
912 */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100913static void sig_dump_state(struct sig_handler *sh)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200914{
Olivier Houchardfbc74e82017-11-24 16:54:05 +0100915 struct proxy *p = proxies_list;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200916
Christopher Faulet767a84b2017-11-24 16:50:31 +0100917 ha_warning("SIGHUP received, dumping servers states.\n");
Willy Tarreaubaaee002006-06-26 02:48:02 +0200918 while (p) {
919 struct server *s = p->srv;
920
921 send_log(p, LOG_NOTICE, "SIGHUP received, dumping servers states for proxy %s.\n", p->id);
922 while (s) {
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100923 chunk_printf(&trash,
924 "SIGHUP: Server %s/%s is %s. Conn: %d act, %d pend, %lld tot.",
925 p->id, s->id,
Emeric Brun52a91d32017-08-31 14:41:55 +0200926 (s->cur_state != SRV_ST_STOPPED) ? "UP" : "DOWN",
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100927 s->cur_sess, s->nbpend, s->counters.cum_sess);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200928 ha_warning("%s\n", trash.area);
929 send_log(p, LOG_NOTICE, "%s\n", trash.area);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200930 s = s->next;
931 }
932
Willy Tarreau5fcc8f12007-09-17 11:27:09 +0200933 /* FIXME: those info are a bit outdated. We should be able to distinguish between FE and BE. */
934 if (!p->srv) {
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100935 chunk_printf(&trash,
936 "SIGHUP: Proxy %s has no servers. Conn: act(FE+BE): %d+%d, %d pend (%d unass), tot(FE+BE): %lld+%lld.",
937 p->id,
938 p->feconn, p->beconn, p->totpend, p->nbpend, p->fe_counters.cum_conn, p->be_counters.cum_conn);
Willy Tarreau5fcc8f12007-09-17 11:27:09 +0200939 } else if (p->srv_act == 0) {
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100940 chunk_printf(&trash,
941 "SIGHUP: Proxy %s %s ! Conn: act(FE+BE): %d+%d, %d pend (%d unass), tot(FE+BE): %lld+%lld.",
942 p->id,
943 (p->srv_bck) ? "is running on backup servers" : "has no server available",
944 p->feconn, p->beconn, p->totpend, p->nbpend, p->fe_counters.cum_conn, p->be_counters.cum_conn);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200945 } else {
Willy Tarreau19d14ef2012-10-29 16:51:55 +0100946 chunk_printf(&trash,
947 "SIGHUP: Proxy %s has %d active servers and %d backup servers available."
948 " Conn: act(FE+BE): %d+%d, %d pend (%d unass), tot(FE+BE): %lld+%lld.",
949 p->id, p->srv_act, p->srv_bck,
950 p->feconn, p->beconn, p->totpend, p->nbpend, p->fe_counters.cum_conn, p->be_counters.cum_conn);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200951 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200952 ha_warning("%s\n", trash.area);
953 send_log(p, LOG_NOTICE, "%s\n", trash.area);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200954
955 p = p->next;
956 }
Willy Tarreaubaaee002006-06-26 02:48:02 +0200957}
958
Willy Tarreau1b5af7c2016-12-21 18:19:57 +0100959static void dump(struct sig_handler *sh)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200960{
Willy Tarreauc6ca1a02007-05-13 19:43:47 +0200961 /* dump memory usage then free everything possible */
962 dump_pools();
Willy Tarreaubafbe012017-11-24 17:34:44 +0100963 pool_gc(NULL);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200964}
965
William Lallemande1340412017-12-28 16:09:36 +0100966/*
967 * This function dup2 the stdio FDs (0,1,2) with <fd>, then closes <fd>
968 * If <fd> < 0, it opens /dev/null and use it to dup
969 *
970 * In the case of chrooting, you have to open /dev/null before the chroot, and
971 * pass the <fd> to this function
972 */
973static void stdio_quiet(int fd)
974{
975 if (fd < 0)
976 fd = open("/dev/null", O_RDWR, 0);
977
978 if (fd > -1) {
979 fclose(stdin);
980 fclose(stdout);
981 fclose(stderr);
982
983 dup2(fd, 0);
984 dup2(fd, 1);
985 dup2(fd, 2);
986 if (fd > 2)
987 close(fd);
988 return;
989 }
990
991 ha_alert("Cannot open /dev/null\n");
992 exit(EXIT_FAILURE);
993}
994
995
Joseph Herlant03420902018-11-15 10:41:50 -0800996/* This function checks if cfg_cfgfiles contains directories.
997 * If it finds one, it adds all the files (and only files) it contains
998 * in cfg_cfgfiles in place of the directory (and removes the directory).
999 * It adds the files in lexical order.
1000 * It adds only files with .cfg extension.
Maxime de Roucy379d9c72016-05-13 23:52:56 +02001001 * It doesn't add files with name starting with '.'
1002 */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +01001003static void cfgfiles_expand_directories(void)
Maxime de Roucy379d9c72016-05-13 23:52:56 +02001004{
1005 struct wordlist *wl, *wlb;
1006 char *err = NULL;
1007
1008 list_for_each_entry_safe(wl, wlb, &cfg_cfgfiles, list) {
1009 struct stat file_stat;
1010 struct dirent **dir_entries = NULL;
1011 int dir_entries_nb;
1012 int dir_entries_it;
1013
1014 if (stat(wl->s, &file_stat)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001015 ha_alert("Cannot open configuration file/directory %s : %s\n",
1016 wl->s,
1017 strerror(errno));
Maxime de Roucy379d9c72016-05-13 23:52:56 +02001018 exit(1);
1019 }
1020
1021 if (!S_ISDIR(file_stat.st_mode))
1022 continue;
1023
1024 /* from this point wl->s is a directory */
1025
1026 dir_entries_nb = scandir(wl->s, &dir_entries, NULL, alphasort);
1027 if (dir_entries_nb < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001028 ha_alert("Cannot open configuration directory %s : %s\n",
1029 wl->s,
1030 strerror(errno));
Maxime de Roucy379d9c72016-05-13 23:52:56 +02001031 exit(1);
1032 }
1033
1034 /* for each element in the directory wl->s */
1035 for (dir_entries_it = 0; dir_entries_it < dir_entries_nb; dir_entries_it++) {
1036 struct dirent *dir_entry = dir_entries[dir_entries_it];
1037 char *filename = NULL;
1038 char *d_name_cfgext = strstr(dir_entry->d_name, ".cfg");
1039
1040 /* don't add filename that begin with .
Joseph Herlant03420902018-11-15 10:41:50 -08001041 * only add filename with .cfg extension
Maxime de Roucy379d9c72016-05-13 23:52:56 +02001042 */
1043 if (dir_entry->d_name[0] == '.' ||
1044 !(d_name_cfgext && d_name_cfgext[4] == '\0'))
1045 goto next_dir_entry;
1046
1047 if (!memprintf(&filename, "%s/%s", wl->s, dir_entry->d_name)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001048 ha_alert("Cannot load configuration files %s : out of memory.\n",
1049 filename);
Maxime de Roucy379d9c72016-05-13 23:52:56 +02001050 exit(1);
1051 }
1052
1053 if (stat(filename, &file_stat)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001054 ha_alert("Cannot open configuration file %s : %s\n",
1055 wl->s,
1056 strerror(errno));
Maxime de Roucy379d9c72016-05-13 23:52:56 +02001057 exit(1);
1058 }
1059
1060 /* don't add anything else than regular file in cfg_cfgfiles
1061 * this way we avoid loops
1062 */
1063 if (!S_ISREG(file_stat.st_mode))
1064 goto next_dir_entry;
1065
1066 if (!list_append_word(&wl->list, filename, &err)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001067 ha_alert("Cannot load configuration files %s : %s\n",
1068 filename,
1069 err);
Maxime de Roucy379d9c72016-05-13 23:52:56 +02001070 exit(1);
1071 }
1072
1073next_dir_entry:
1074 free(filename);
1075 free(dir_entry);
1076 }
1077
1078 free(dir_entries);
1079
1080 /* remove the current directory (wl) from cfg_cfgfiles */
1081 free(wl->s);
Willy Tarreau2b718102021-04-21 07:32:39 +02001082 LIST_DELETE(&wl->list);
Maxime de Roucy379d9c72016-05-13 23:52:56 +02001083 free(wl);
1084 }
1085
1086 free(err);
1087}
1088
Willy Tarreaubaaee002006-06-26 02:48:02 +02001089/*
William Lallemand73b85e72017-06-01 17:38:51 +02001090 * copy and cleanup the current argv
William Lallemanddf6c5a82020-06-04 17:40:23 +02001091 * Remove the -sf /-st / -x parameters
William Lallemand73b85e72017-06-01 17:38:51 +02001092 * Return an allocated copy of argv
1093 */
1094
1095static char **copy_argv(int argc, char **argv)
1096{
William Lallemanddf6c5a82020-06-04 17:40:23 +02001097 char **newargv, **retargv;
William Lallemand73b85e72017-06-01 17:38:51 +02001098
Tim Duesterhuse52b6e52020-09-12 20:26:43 +02001099 newargv = calloc(argc + 2, sizeof(*newargv));
William Lallemand73b85e72017-06-01 17:38:51 +02001100 if (newargv == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001101 ha_warning("Cannot allocate memory\n");
William Lallemand73b85e72017-06-01 17:38:51 +02001102 return NULL;
1103 }
William Lallemanddf6c5a82020-06-04 17:40:23 +02001104 retargv = newargv;
William Lallemand73b85e72017-06-01 17:38:51 +02001105
William Lallemanddf6c5a82020-06-04 17:40:23 +02001106 /* first copy argv[0] */
1107 *newargv++ = *argv++;
1108 argc--;
1109
1110 while (argc > 0) {
1111 if (**argv != '-') {
1112 /* non options are copied but will fail in the argument parser */
1113 *newargv++ = *argv++;
1114 argc--;
1115
1116 } else {
1117 char *flag;
1118
1119 flag = *argv + 1;
1120
1121 if (flag[0] == '-' && flag[1] == 0) {
1122 /* "--\0" copy every arguments till the end of argv */
1123 *newargv++ = *argv++;
1124 argc--;
1125
1126 while (argc > 0) {
1127 *newargv++ = *argv++;
1128 argc--;
1129 }
1130 } else {
1131 switch (*flag) {
1132 case 's':
1133 /* -sf / -st and their parameters are ignored */
1134 if (flag[1] == 'f' || flag[1] == 't') {
1135 argc--;
1136 argv++;
1137 /* The list can't contain a negative value since the only
1138 way to know the end of this list is by looking for the
1139 next option or the end of the options */
1140 while (argc > 0 && argv[0][0] != '-') {
1141 argc--;
1142 argv++;
1143 }
William Lallemand398da622020-09-02 16:12:23 +02001144 } else {
1145 argc--;
1146 argv++;
1147
William Lallemanddf6c5a82020-06-04 17:40:23 +02001148 }
1149 break;
1150
1151 case 'x':
1152 /* this option and its parameter are ignored */
1153 argc--;
1154 argv++;
1155 if (argc > 0) {
1156 argc--;
1157 argv++;
1158 }
1159 break;
1160
1161 case 'C':
1162 case 'n':
1163 case 'm':
1164 case 'N':
1165 case 'L':
1166 case 'f':
1167 case 'p':
1168 case 'S':
1169 /* these options have only 1 parameter which must be copied and can start with a '-' */
1170 *newargv++ = *argv++;
1171 argc--;
1172 if (argc == 0)
1173 goto error;
1174 *newargv++ = *argv++;
1175 argc--;
1176 break;
1177 default:
1178 /* for other options just copy them without parameters, this is also done
1179 * for options like "--foo", but this will fail in the argument parser.
1180 * */
1181 *newargv++ = *argv++;
1182 argc--;
1183 break;
1184 }
William Lallemand73b85e72017-06-01 17:38:51 +02001185 }
1186 }
William Lallemand73b85e72017-06-01 17:38:51 +02001187 }
William Lallemand2bf6d622017-06-20 11:20:23 +02001188
William Lallemanddf6c5a82020-06-04 17:40:23 +02001189 return retargv;
1190
1191error:
1192 free(retargv);
1193 return NULL;
William Lallemand73b85e72017-06-01 17:38:51 +02001194}
1195
Willy Tarreau6c3a6812020-03-06 18:57:15 +01001196
1197/* Performs basic random seed initialization. The main issue with this is that
1198 * srandom_r() only takes 32 bits and purposely provides a reproducible sequence,
1199 * which means that there will only be 4 billion possible random sequences once
1200 * srandom() is called, regardless of the internal state. Not calling it is
1201 * even worse as we'll always produce the same randoms sequences. What we do
1202 * here is to create an initial sequence from various entropy sources, hash it
1203 * using SHA1 and keep the resulting 160 bits available globally.
1204 *
1205 * We initialize the current process with the first 32 bits before starting the
1206 * polling loop, where all this will be changed to have process specific and
1207 * thread specific sequences.
Willy Tarreau52bf8392020-03-08 00:42:37 +01001208 *
1209 * Before starting threads, it's still possible to call random() as srandom()
1210 * is initialized from this, but after threads and/or processes are started,
1211 * only ha_random() is expected to be used to guarantee distinct sequences.
Willy Tarreau6c3a6812020-03-06 18:57:15 +01001212 */
1213static void ha_random_boot(char *const *argv)
1214{
1215 unsigned char message[256];
1216 unsigned char *m = message;
1217 struct timeval tv;
1218 blk_SHA_CTX ctx;
1219 unsigned long l;
1220 int fd;
1221 int i;
1222
1223 /* start with current time as pseudo-random seed */
1224 gettimeofday(&tv, NULL);
1225 write_u32(m, tv.tv_sec); m += 4;
1226 write_u32(m, tv.tv_usec); m += 4;
1227
1228 /* PID and PPID add some OS-based randomness */
1229 write_u16(m, getpid()); m += 2;
1230 write_u16(m, getppid()); m += 2;
1231
1232 /* take up to 160 bits bytes from /dev/urandom if available (non-blocking) */
1233 fd = open("/dev/urandom", O_RDONLY);
1234 if (fd >= 0) {
1235 i = read(fd, m, 20);
1236 if (i > 0)
1237 m += i;
1238 close(fd);
1239 }
1240
1241 /* take up to 160 bits bytes from openssl (non-blocking) */
1242#ifdef USE_OPENSSL
1243 if (RAND_bytes(m, 20) == 1)
1244 m += 20;
1245#endif
1246
1247 /* take 160 bits from existing random in case it was already initialized */
1248 for (i = 0; i < 5; i++) {
1249 write_u32(m, random());
1250 m += 4;
1251 }
1252
1253 /* stack address (benefit form operating system's ASLR) */
1254 l = (unsigned long)&m;
1255 memcpy(m, &l, sizeof(l)); m += sizeof(l);
1256
1257 /* argv address (benefit form operating system's ASLR) */
1258 l = (unsigned long)&argv;
1259 memcpy(m, &l, sizeof(l)); m += sizeof(l);
1260
1261 /* use tv_usec again after all the operations above */
1262 gettimeofday(&tv, NULL);
1263 write_u32(m, tv.tv_usec); m += 4;
1264
1265 /*
1266 * At this point, ~84-92 bytes have been used
1267 */
1268
1269 /* finish with the hostname */
1270 strncpy((char *)m, hostname, message + sizeof(message) - m);
1271 m += strlen(hostname);
1272
1273 /* total message length */
1274 l = m - message;
1275
1276 memset(&ctx, 0, sizeof(ctx));
1277 blk_SHA1_Init(&ctx);
1278 blk_SHA1_Update(&ctx, message, l);
1279 blk_SHA1_Final(boot_seed, &ctx);
1280
1281 srandom(read_u32(boot_seed));
Willy Tarreau52bf8392020-03-08 00:42:37 +01001282 ha_random_seed(boot_seed, sizeof(boot_seed));
Willy Tarreau6c3a6812020-03-06 18:57:15 +01001283}
1284
Willy Tarreau5a023f02019-03-01 14:19:31 +01001285/* considers splicing proxies' maxconn, computes the ideal global.maxpipes
1286 * setting, and returns it. It may return -1 meaning "unlimited" if some
1287 * unlimited proxies have been found and the global.maxconn value is not yet
1288 * set. It may also return a value greater than maxconn if it's not yet set.
1289 * Note that a value of zero means there is no need for pipes. -1 is never
1290 * returned if global.maxconn is valid.
1291 */
1292static int compute_ideal_maxpipes()
1293{
1294 struct proxy *cur;
1295 int nbfe = 0, nbbe = 0;
1296 int unlimited = 0;
1297 int pipes;
1298 int max;
1299
1300 for (cur = proxies_list; cur; cur = cur->next) {
1301 if (cur->options2 & (PR_O2_SPLIC_ANY)) {
1302 if (cur->cap & PR_CAP_FE) {
1303 max = cur->maxconn;
1304 nbfe += max;
1305 if (!max) {
1306 unlimited = 1;
1307 break;
1308 }
1309 }
1310 if (cur->cap & PR_CAP_BE) {
1311 max = cur->fullconn ? cur->fullconn : global.maxconn;
1312 nbbe += max;
1313 if (!max) {
1314 unlimited = 1;
1315 break;
1316 }
1317 }
1318 }
1319 }
1320
1321 pipes = MAX(nbfe, nbbe);
1322 if (global.maxconn) {
1323 if (pipes > global.maxconn || unlimited)
1324 pipes = global.maxconn;
1325 } else if (unlimited) {
1326 pipes = -1;
1327 }
1328
1329 return pipes >= 4 ? pipes / 4 : pipes;
1330}
1331
Willy Tarreauac350932019-03-01 15:43:14 +01001332/* considers global.maxsocks, global.maxpipes, async engines, SSL frontends and
1333 * rlimits and computes an ideal maxconn. It's meant to be called only when
1334 * maxsock contains the sum of listening FDs, before it is updated based on
Willy Tarreaudf23c0c2019-03-13 10:10:49 +01001335 * maxconn and pipes. If there are not enough FDs left, DEFAULT_MAXCONN (by
1336 * default 100) is returned as it is expected that it will even run on tight
1337 * environments, and will maintain compatibility with previous packages that
1338 * used to rely on this value as the default one. The system will emit a
1339 * warning indicating how many FDs are missing anyway if needed.
Willy Tarreauac350932019-03-01 15:43:14 +01001340 */
1341static int compute_ideal_maxconn()
1342{
1343 int ssl_sides = !!global.ssl_used_frontend + !!global.ssl_used_backend;
1344 int engine_fds = global.ssl_used_async_engines * ssl_sides;
1345 int pipes = compute_ideal_maxpipes();
Willy Tarreaub1beaa32020-03-06 10:25:31 +01001346 int remain = MAX(rlim_fd_cur_at_boot, rlim_fd_max_at_boot);
Willy Tarreauac350932019-03-01 15:43:14 +01001347 int maxconn;
1348
1349 /* we have to take into account these elements :
1350 * - number of engine_fds, which inflates the number of FD needed per
1351 * connection by this number.
1352 * - number of pipes per connection on average : for the unlimited
1353 * case, this is 0.5 pipe FDs per connection, otherwise it's a
1354 * fixed value of 2*pipes.
1355 * - two FDs per connection
1356 */
1357
1358 /* subtract listeners and checks */
1359 remain -= global.maxsock;
1360
Willy Tarreau3f200852019-03-14 19:13:17 +01001361 /* one epoll_fd/kqueue_fd per thread */
1362 remain -= global.nbthread;
1363
1364 /* one wake-up pipe (2 fd) per thread */
1365 remain -= 2 * global.nbthread;
1366
Willy Tarreauac350932019-03-01 15:43:14 +01001367 /* Fixed pipes values : we only subtract them if they're not larger
1368 * than the remaining FDs because pipes are optional.
1369 */
1370 if (pipes >= 0 && pipes * 2 < remain)
1371 remain -= pipes * 2;
1372
1373 if (pipes < 0) {
1374 /* maxsock = maxconn * 2 + maxconn/4 * 2 + maxconn * engine_fds.
1375 * = maxconn * (2 + 0.5 + engine_fds)
1376 * = maxconn * (4 + 1 + 2*engine_fds) / 2
1377 */
1378 maxconn = 2 * remain / (5 + 2 * engine_fds);
1379 } else {
1380 /* maxsock = maxconn * 2 + maxconn * engine_fds.
1381 * = maxconn * (2 + engine_fds)
1382 */
1383 maxconn = remain / (2 + engine_fds);
1384 }
1385
Willy Tarreaudf23c0c2019-03-13 10:10:49 +01001386 return MAX(maxconn, DEFAULT_MAXCONN);
Willy Tarreauac350932019-03-01 15:43:14 +01001387}
1388
Willy Tarreaua409f302020-03-10 17:08:53 +01001389/* computes the estimated maxsock value for the given maxconn based on the
1390 * possibly set global.maxpipes and existing partial global.maxsock. It may
1391 * temporarily change global.maxconn for the time needed to propagate the
1392 * computations, and will reset it.
1393 */
1394static int compute_ideal_maxsock(int maxconn)
1395{
1396 int maxpipes = global.maxpipes;
1397 int maxsock = global.maxsock;
1398
1399
1400 if (!maxpipes) {
1401 int old_maxconn = global.maxconn;
1402
1403 global.maxconn = maxconn;
1404 maxpipes = compute_ideal_maxpipes();
1405 global.maxconn = old_maxconn;
1406 }
1407
1408 maxsock += maxconn * 2; /* each connection needs two sockets */
1409 maxsock += maxpipes * 2; /* each pipe needs two FDs */
1410 maxsock += global.nbthread; /* one epoll_fd/kqueue_fd per thread */
1411 maxsock += 2 * global.nbthread; /* one wake-up pipe (2 fd) per thread */
1412
1413 /* compute fd used by async engines */
1414 if (global.ssl_used_async_engines) {
1415 int sides = !!global.ssl_used_frontend + !!global.ssl_used_backend;
1416
1417 maxsock += maxconn * sides * global.ssl_used_async_engines;
1418 }
1419 return maxsock;
1420}
1421
Thayne McCombs8f0cc5c2021-01-07 21:35:52 -07001422/* Tests if it is possible to set the current process's RLIMIT_NOFILE to
Willy Tarreau304e17e2020-03-10 17:54:54 +01001423 * <maxsock>, then sets it back to the previous value. Returns non-zero if the
1424 * value is accepted, non-zero otherwise. This is used to determine if an
1425 * automatic limit may be applied or not. When it is not, the caller knows that
1426 * the highest we can do is the rlim_max at boot. In case of error, we return
1427 * that the setting is possible, so that we defer the error processing to the
1428 * final stage in charge of enforcing this.
1429 */
1430static int check_if_maxsock_permitted(int maxsock)
1431{
1432 struct rlimit orig_limit, test_limit;
1433 int ret;
1434
1435 if (getrlimit(RLIMIT_NOFILE, &orig_limit) != 0)
1436 return 1;
1437
1438 /* don't go further if we can't even set to what we have */
1439 if (setrlimit(RLIMIT_NOFILE, &orig_limit) != 0)
1440 return 1;
1441
1442 test_limit.rlim_max = MAX(maxsock, orig_limit.rlim_max);
1443 test_limit.rlim_cur = test_limit.rlim_max;
1444 ret = setrlimit(RLIMIT_NOFILE, &test_limit);
1445
1446 if (setrlimit(RLIMIT_NOFILE, &orig_limit) != 0)
1447 return 1;
1448
1449 return ret == 0;
1450}
1451
Amaury Denoyelle484454d2021-05-05 16:18:45 +02001452void mark_tainted(const enum tainted_flags flag)
1453{
1454 HA_ATOMIC_OR(&tainted, flag);
1455}
1456
1457unsigned int get_tainted()
1458{
1459 int tainted_state;
1460 HA_ATOMIC_STORE(&tainted_state, tainted);
1461 return tainted_state;
1462}
Willy Tarreau304e17e2020-03-10 17:54:54 +01001463
William Lallemand73b85e72017-06-01 17:38:51 +02001464/*
Willy Tarreaubaaee002006-06-26 02:48:02 +02001465 * This function initializes all the necessary variables. It only returns
1466 * if everything is OK. If something fails, it exits.
1467 */
Willy Tarreau1b5af7c2016-12-21 18:19:57 +01001468static void init(int argc, char **argv)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001469{
Willy Tarreaubaaee002006-06-26 02:48:02 +02001470 int arg_mode = 0; /* MODE_DEBUG, ... */
Willy Tarreaubaaee002006-06-26 02:48:02 +02001471 char *tmp;
1472 char *cfg_pidfile = NULL;
Willy Tarreau058e9072009-07-20 09:30:05 +02001473 int err_code = 0;
Maxime de Roucy0f503922016-05-13 23:52:55 +02001474 char *err_msg = NULL;
Willy Tarreau477ecd82010-01-03 21:12:30 +01001475 struct wordlist *wl;
Kevinm48936af2010-12-22 16:08:21 +00001476 char *progname;
Willy Tarreau576132e2011-09-10 19:26:56 +02001477 char *change_dir = NULL;
Christopher Fauletd7c91962015-04-30 11:48:27 +02001478 struct proxy *px;
Willy Tarreaue6945732016-12-21 19:57:00 +01001479 struct post_check_fct *pcf;
Willy Tarreauac350932019-03-01 15:43:14 +01001480 int ideal_maxconn;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001481
Christopher Faulete3a5e352017-10-24 13:53:54 +02001482 global.mode = MODE_STARTING;
William Lallemand00417412020-06-05 14:08:41 +02001483 old_argv = copy_argv(argc, argv);
1484 if (!old_argv) {
William Lallemanddf6c5a82020-06-04 17:40:23 +02001485 ha_alert("failed to copy argv.\n");
1486 exit(1);
1487 }
William Lallemand73b85e72017-06-01 17:38:51 +02001488
Christopher Fauletcd7879a2017-10-27 13:53:47 +02001489 if (!init_trash_buffers(1)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001490 ha_alert("failed to initialize trash buffers.\n");
Christopher Faulet748919a2017-07-26 14:59:46 +02001491 exit(1);
1492 }
David du Colombier7af46052012-05-16 14:16:48 +02001493
Emeric Brun2b920a12010-09-23 18:30:22 +02001494 /* NB: POSIX does not make it mandatory for gethostname() to NULL-terminate
1495 * the string in case of truncation, and at least FreeBSD appears not to do
1496 * it.
1497 */
1498 memset(hostname, 0, sizeof(hostname));
1499 gethostname(hostname, sizeof(hostname) - 1);
Dragan Dosen4f014152020-06-18 16:56:47 +02001500
1501 if ((localpeer = strdup(hostname)) == NULL) {
1502 ha_alert("Cannot allocate memory for local peer.\n");
1503 exit(EXIT_FAILURE);
1504 }
William Lallemanddaf4cd22018-04-17 16:46:13 +02001505 setenv("HAPROXY_LOCALPEER", localpeer, 1);
Emeric Brun2b920a12010-09-23 18:30:22 +02001506
William Lallemand24c928c2020-01-14 17:58:18 +01001507 /* we were in mworker mode, we should restart in mworker mode */
1508 if (getenv("HAPROXY_MWORKER_REEXEC") != NULL)
1509 global.mode |= MODE_MWORKER;
1510
Willy Tarreaubaaee002006-06-26 02:48:02 +02001511 /*
1512 * Initialize the previously static variables.
1513 */
Christopher Fauletcd7879a2017-10-27 13:53:47 +02001514
Willy Tarreau173d9952018-01-26 21:48:23 +01001515 totalconn = actconn = listeners = stopping = 0;
Cyril Bonté203ec5a2017-03-23 22:44:13 +01001516 killed = 0;
Christopher Fauletcd7879a2017-10-27 13:53:47 +02001517
Willy Tarreaubaaee002006-06-26 02:48:02 +02001518
1519#ifdef HAPROXY_MEMMAX
Willy Tarreau70060452015-12-14 12:46:07 +01001520 global.rlimit_memmax_all = HAPROXY_MEMMAX;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001521#endif
1522
Benoit GARNIERb413c2a2016-03-27 11:08:03 +02001523 tzset();
Willy Tarreauc4c80fb2021-04-11 15:00:34 +02001524 tv_init_process_date();
Willy Tarreaubaaee002006-06-26 02:48:02 +02001525 start_date = now;
1526
Willy Tarreau6c3a6812020-03-06 18:57:15 +01001527 ha_random_boot(argv);
Willy Tarreau84310e22014-02-14 11:59:04 +01001528
Willy Tarreau8ed669b2013-01-11 15:49:37 +01001529 if (init_acl() != 0)
1530 exit(1);
Willy Tarreaub6b3df32018-11-26 16:31:20 +01001531
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01001532 /* Initialise lua. */
1533 hlua_init();
Thierry FOURNIER6f1fd482015-01-23 14:06:13 +01001534
Christopher Fauletff2613e2016-11-09 11:36:17 +01001535 /* Initialize process vars */
Willy Tarreaucfc4f242021-05-08 11:41:28 +02001536 vars_init(&proc_vars, SCOPE_PROC);
Christopher Fauletff2613e2016-11-09 11:36:17 +01001537
Willy Tarreau43b78992009-01-25 15:42:27 +01001538 global.tune.options |= GTUNE_USE_SELECT; /* select() is always available */
Willy Tarreaue5733232019-05-22 19:24:06 +02001539#if defined(USE_POLL)
Willy Tarreau43b78992009-01-25 15:42:27 +01001540 global.tune.options |= GTUNE_USE_POLL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001541#endif
Willy Tarreaue5733232019-05-22 19:24:06 +02001542#if defined(USE_EPOLL)
Willy Tarreau43b78992009-01-25 15:42:27 +01001543 global.tune.options |= GTUNE_USE_EPOLL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001544#endif
Willy Tarreaue5733232019-05-22 19:24:06 +02001545#if defined(USE_KQUEUE)
Willy Tarreau43b78992009-01-25 15:42:27 +01001546 global.tune.options |= GTUNE_USE_KQUEUE;
Willy Tarreau1e63130a2007-04-09 12:03:06 +02001547#endif
Willy Tarreaue5733232019-05-22 19:24:06 +02001548#if defined(USE_EVPORTS)
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +00001549 global.tune.options |= GTUNE_USE_EVPORTS;
1550#endif
Willy Tarreaue5733232019-05-22 19:24:06 +02001551#if defined(USE_LINUX_SPLICE)
Willy Tarreau3ab68cf2009-01-25 16:03:28 +01001552 global.tune.options |= GTUNE_USE_SPLICE;
1553#endif
Nenad Merdanovic88afe032014-04-14 15:56:58 +02001554#if defined(USE_GETADDRINFO)
1555 global.tune.options |= GTUNE_USE_GAI;
1556#endif
Lukas Tribusa0bcbdc2016-09-12 21:42:20 +00001557#if defined(SO_REUSEPORT)
1558 global.tune.options |= GTUNE_USE_REUSEPORT;
1559#endif
Willy Tarreau76cc6992020-07-01 18:49:24 +02001560#ifdef USE_THREAD
1561 global.tune.options |= GTUNE_IDLE_POOL_SHARED;
1562#endif
William Dauchya5194602020-03-28 19:29:58 +01001563 global.tune.options |= GTUNE_STRICT_LIMITS;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001564
1565 pid = getpid();
1566 progname = *argv;
1567 while ((tmp = strchr(progname, '/')) != NULL)
1568 progname = tmp + 1;
1569
Kevinm48936af2010-12-22 16:08:21 +00001570 /* the process name is used for the logs only */
Eric Salama7cea6062020-10-02 11:58:19 +02001571 chunk_initlen(&global.log_tag, strdup(progname), strlen(progname), strlen(progname));
1572 if (b_orig(&global.log_tag) == NULL) {
1573 chunk_destroy(&global.log_tag);
1574 ha_alert("Cannot allocate memory for log_tag.\n");
1575 exit(EXIT_FAILURE);
1576 }
Kevinm48936af2010-12-22 16:08:21 +00001577
Willy Tarreaubaaee002006-06-26 02:48:02 +02001578 argc--; argv++;
1579 while (argc > 0) {
1580 char *flag;
1581
1582 if (**argv == '-') {
1583 flag = *argv+1;
1584
1585 /* 1 arg */
1586 if (*flag == 'v') {
1587 display_version();
Willy Tarreau7b066db2007-12-02 11:28:59 +01001588 if (flag[1] == 'v') /* -vv */
1589 display_build_opts();
Willy Tarreaubaaee002006-06-26 02:48:02 +02001590 exit(0);
1591 }
Willy Tarreaue5733232019-05-22 19:24:06 +02001592#if defined(USE_EPOLL)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001593 else if (*flag == 'd' && flag[1] == 'e')
Willy Tarreau43b78992009-01-25 15:42:27 +01001594 global.tune.options &= ~GTUNE_USE_EPOLL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001595#endif
Willy Tarreaue5733232019-05-22 19:24:06 +02001596#if defined(USE_POLL)
Willy Tarreaubaaee002006-06-26 02:48:02 +02001597 else if (*flag == 'd' && flag[1] == 'p')
Willy Tarreau43b78992009-01-25 15:42:27 +01001598 global.tune.options &= ~GTUNE_USE_POLL;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001599#endif
Willy Tarreaue5733232019-05-22 19:24:06 +02001600#if defined(USE_KQUEUE)
Willy Tarreau1e63130a2007-04-09 12:03:06 +02001601 else if (*flag == 'd' && flag[1] == 'k')
Willy Tarreau43b78992009-01-25 15:42:27 +01001602 global.tune.options &= ~GTUNE_USE_KQUEUE;
Willy Tarreau1e63130a2007-04-09 12:03:06 +02001603#endif
Willy Tarreaue5733232019-05-22 19:24:06 +02001604#if defined(USE_EVPORTS)
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +00001605 else if (*flag == 'd' && flag[1] == 'v')
1606 global.tune.options &= ~GTUNE_USE_EVPORTS;
1607#endif
Willy Tarreaue5733232019-05-22 19:24:06 +02001608#if defined(USE_LINUX_SPLICE)
Willy Tarreau3ab68cf2009-01-25 16:03:28 +01001609 else if (*flag == 'd' && flag[1] == 'S')
1610 global.tune.options &= ~GTUNE_USE_SPLICE;
1611#endif
Nenad Merdanovic88afe032014-04-14 15:56:58 +02001612#if defined(USE_GETADDRINFO)
1613 else if (*flag == 'd' && flag[1] == 'G')
1614 global.tune.options &= ~GTUNE_USE_GAI;
1615#endif
Lukas Tribusa0bcbdc2016-09-12 21:42:20 +00001616#if defined(SO_REUSEPORT)
1617 else if (*flag == 'd' && flag[1] == 'R')
1618 global.tune.options &= ~GTUNE_USE_REUSEPORT;
1619#endif
Emeric Brun850efd52014-01-29 12:24:34 +01001620 else if (*flag == 'd' && flag[1] == 'V')
1621 global.ssl_server_verify = SSL_SERVER_VERIFY_NONE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001622 else if (*flag == 'V')
1623 arg_mode |= MODE_VERBOSE;
1624 else if (*flag == 'd' && flag[1] == 'b')
1625 arg_mode |= MODE_FOREGROUND;
Amaury Denoyelle7b01a8d2021-03-29 10:29:07 +02001626 else if (*flag == 'd' && flag[1] == 'D')
1627 arg_mode |= MODE_DIAG;
Willy Tarreau3eb10b82020-04-15 16:42:39 +02001628 else if (*flag == 'd' && flag[1] == 'W')
1629 arg_mode |= MODE_ZERO_WARNING;
Willy Tarreau6e064432012-05-08 15:40:42 +02001630 else if (*flag == 'd' && flag[1] == 'M')
1631 mem_poison_byte = flag[2] ? strtol(flag + 2, NULL, 0) : 'P';
Willy Tarreau3eed10e2016-11-07 21:03:16 +01001632 else if (*flag == 'd' && flag[1] == 'r')
1633 global.tune.options |= GTUNE_RESOLVE_DONTFAIL;
Willy Tarreau0aa9dbe2021-12-28 15:43:11 +01001634#if defined(HA_HAVE_DUMP_LIBS)
1635 else if (*flag == 'd' && flag[1] == 'L')
1636 arg_mode |= MODE_DUMP_LIBS;
1637#endif
Willy Tarreaubaaee002006-06-26 02:48:02 +02001638 else if (*flag == 'd')
1639 arg_mode |= MODE_DEBUG;
1640 else if (*flag == 'c')
1641 arg_mode |= MODE_CHECK;
William Lallemand095ba4c2017-06-01 17:38:50 +02001642 else if (*flag == 'D')
Willy Tarreau6bde87b2009-05-18 16:29:51 +02001643 arg_mode |= MODE_DAEMON;
Tim Duesterhusd6942c82017-11-20 15:58:35 +01001644 else if (*flag == 'W' && flag[1] == 's') {
Lukas Tribusf46bf952017-11-21 12:39:34 +01001645 arg_mode |= MODE_MWORKER | MODE_FOREGROUND;
Tim Duesterhusd6942c82017-11-20 15:58:35 +01001646#if defined(USE_SYSTEMD)
1647 global.tune.options |= GTUNE_USE_SYSTEMD;
1648#else
Christopher Faulet767a84b2017-11-24 16:50:31 +01001649 ha_alert("master-worker mode with systemd support (-Ws) requested, but not compiled. Use master-worker mode (-W) if you are not using Type=notify in your unit file or recompile with USE_SYSTEMD=1.\n\n");
Tim Duesterhusd6942c82017-11-20 15:58:35 +01001650 usage(progname);
1651#endif
1652 }
William Lallemand095ba4c2017-06-01 17:38:50 +02001653 else if (*flag == 'W')
1654 arg_mode |= MODE_MWORKER;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001655 else if (*flag == 'q')
1656 arg_mode |= MODE_QUIET;
Olivier Houchardf73629d2017-04-05 22:33:04 +02001657 else if (*flag == 'x') {
William Lallemand4f71d302020-06-04 23:41:29 +02001658 if (argc <= 1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001659 ha_alert("Unix socket path expected with the -x flag\n\n");
William Lallemand45eff442017-06-19 15:57:55 +02001660 usage(progname);
Olivier Houchardf73629d2017-04-05 22:33:04 +02001661 }
William Lallemand4fc09692017-06-19 16:37:19 +02001662 if (old_unixsocket)
Christopher Faulet767a84b2017-11-24 16:50:31 +01001663 ha_warning("-x option already set, overwriting the value\n");
Olivier Houchardf73629d2017-04-05 22:33:04 +02001664 old_unixsocket = argv[1];
William Lallemand4fc09692017-06-19 16:37:19 +02001665
Willy Tarreau7b11b7e2022-02-01 08:47:41 +01001666 /* preset it now for early aborts */
1667 free(cur_unixsocket);
1668 cur_unixsocket = strdup(old_unixsocket);
1669
Olivier Houchardf73629d2017-04-05 22:33:04 +02001670 argv++;
1671 argc--;
1672 }
William Lallemande7361152018-10-26 14:47:36 +02001673 else if (*flag == 'S') {
1674 struct wordlist *c;
1675
William Lallemanda6b32492020-06-04 23:49:20 +02001676 if (argc <= 1) {
William Lallemande7361152018-10-26 14:47:36 +02001677 ha_alert("Socket and optional bind parameters expected with the -S flag\n");
1678 usage(progname);
1679 }
1680 if ((c = malloc(sizeof(*c))) == NULL || (c->s = strdup(argv[1])) == NULL) {
1681 ha_alert("Cannot allocate memory\n");
1682 exit(EXIT_FAILURE);
1683 }
Willy Tarreau2b718102021-04-21 07:32:39 +02001684 LIST_INSERT(&mworker_cli_conf, &c->list);
William Lallemande7361152018-10-26 14:47:36 +02001685
1686 argv++;
1687 argc--;
1688 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001689 else if (*flag == 's' && (flag[1] == 'f' || flag[1] == 't')) {
1690 /* list of pids to finish ('f') or terminate ('t') */
1691
1692 if (flag[1] == 'f')
1693 oldpids_sig = SIGUSR1; /* finish then exit */
1694 else
1695 oldpids_sig = SIGTERM; /* terminate immediately */
Willy Tarreauc6ca1aa2015-10-08 11:32:32 +02001696 while (argc > 1 && argv[1][0] != '-') {
Chris Lane236062f2018-02-05 23:15:44 +00001697 char * endptr = NULL;
Willy Tarreauc6ca1aa2015-10-08 11:32:32 +02001698 oldpids = realloc(oldpids, (nb_oldpids + 1) * sizeof(int));
1699 if (!oldpids) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001700 ha_alert("Cannot allocate old pid : out of memory.\n");
Willy Tarreauc6ca1aa2015-10-08 11:32:32 +02001701 exit(1);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001702 }
Willy Tarreauc6ca1aa2015-10-08 11:32:32 +02001703 argc--; argv++;
Chris Lane236062f2018-02-05 23:15:44 +00001704 errno = 0;
1705 oldpids[nb_oldpids] = strtol(*argv, &endptr, 10);
1706 if (errno) {
1707 ha_alert("-%2s option: failed to parse {%s}: %s\n",
1708 flag,
1709 *argv, strerror(errno));
1710 exit(1);
1711 } else if (endptr && strlen(endptr)) {
Willy Tarreau90807112020-02-25 08:16:33 +01001712 while (isspace((unsigned char)*endptr)) endptr++;
Aurélien Nephtali39b89882018-02-17 20:53:11 +01001713 if (*endptr != 0) {
Chris Lane236062f2018-02-05 23:15:44 +00001714 ha_alert("-%2s option: some bytes unconsumed in PID list {%s}\n",
1715 flag, endptr);
1716 exit(1);
Aurélien Nephtali39b89882018-02-17 20:53:11 +01001717 }
Chris Lane236062f2018-02-05 23:15:44 +00001718 }
Willy Tarreauc6ca1aa2015-10-08 11:32:32 +02001719 if (oldpids[nb_oldpids] <= 0)
1720 usage(progname);
1721 nb_oldpids++;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001722 }
1723 }
Willy Tarreaua088d312015-10-08 11:58:48 +02001724 else if (flag[0] == '-' && flag[1] == 0) { /* "--" */
1725 /* now that's a cfgfile list */
1726 argv++; argc--;
1727 while (argc > 0) {
Maxime de Roucy0f503922016-05-13 23:52:55 +02001728 if (!list_append_word(&cfg_cfgfiles, *argv, &err_msg)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001729 ha_alert("Cannot load configuration file/directory %s : %s\n",
1730 *argv,
1731 err_msg);
Willy Tarreaua088d312015-10-08 11:58:48 +02001732 exit(1);
1733 }
Willy Tarreaua088d312015-10-08 11:58:48 +02001734 argv++; argc--;
1735 }
1736 break;
1737 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001738 else { /* >=2 args */
1739 argv++; argc--;
1740 if (argc == 0)
Willy Tarreau3bafcdc2011-09-10 19:20:23 +02001741 usage(progname);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001742
1743 switch (*flag) {
Willy Tarreau576132e2011-09-10 19:26:56 +02001744 case 'C' : change_dir = *argv; break;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001745 case 'n' : cfg_maxconn = atol(*argv); break;
Willy Tarreau70060452015-12-14 12:46:07 +01001746 case 'm' : global.rlimit_memmax_all = atol(*argv); break;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001747 case 'N' : cfg_maxpconn = atol(*argv); break;
William Lallemanddaf4cd22018-04-17 16:46:13 +02001748 case 'L' :
Dragan Dosen4f014152020-06-18 16:56:47 +02001749 free(localpeer);
1750 if ((localpeer = strdup(*argv)) == NULL) {
1751 ha_alert("Cannot allocate memory for local peer.\n");
1752 exit(EXIT_FAILURE);
1753 }
William Lallemanddaf4cd22018-04-17 16:46:13 +02001754 setenv("HAPROXY_LOCALPEER", localpeer, 1);
Dragan Dosen13cd54c2020-06-18 18:24:05 +02001755 global.localpeer_cmdline = 1;
William Lallemanddaf4cd22018-04-17 16:46:13 +02001756 break;
Willy Tarreau5d01a632009-06-22 16:02:30 +02001757 case 'f' :
Maxime de Roucy0f503922016-05-13 23:52:55 +02001758 if (!list_append_word(&cfg_cfgfiles, *argv, &err_msg)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001759 ha_alert("Cannot load configuration file/directory %s : %s\n",
1760 *argv,
1761 err_msg);
Willy Tarreau5d01a632009-06-22 16:02:30 +02001762 exit(1);
1763 }
Willy Tarreau5d01a632009-06-22 16:02:30 +02001764 break;
Willy Tarreaubaaee002006-06-26 02:48:02 +02001765 case 'p' : cfg_pidfile = *argv; break;
Willy Tarreau3bafcdc2011-09-10 19:20:23 +02001766 default: usage(progname);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001767 }
1768 }
1769 }
1770 else
Willy Tarreau3bafcdc2011-09-10 19:20:23 +02001771 usage(progname);
Willy Tarreaubaaee002006-06-26 02:48:02 +02001772 argv++; argc--;
1773 }
1774
Christopher Faulete3a5e352017-10-24 13:53:54 +02001775 global.mode |= (arg_mode & (MODE_DAEMON | MODE_MWORKER | MODE_FOREGROUND | MODE_VERBOSE
Amaury Denoyelle7b01a8d2021-03-29 10:29:07 +02001776 | MODE_QUIET | MODE_CHECK | MODE_DEBUG | MODE_ZERO_WARNING
Willy Tarreau0aa9dbe2021-12-28 15:43:11 +01001777 | MODE_DIAG | MODE_DUMP_LIBS));
Willy Tarreaubaaee002006-06-26 02:48:02 +02001778
William Lallemand944e6192018-11-21 15:48:31 +01001779 if (getenv("HAPROXY_MWORKER_WAIT_ONLY")) {
William Lallemandcb11fd22017-06-01 17:38:52 +02001780 unsetenv("HAPROXY_MWORKER_WAIT_ONLY");
William Lallemand944e6192018-11-21 15:48:31 +01001781 global.mode |= MODE_MWORKER_WAIT;
1782 global.mode &= ~MODE_MWORKER;
William Lallemandcb11fd22017-06-01 17:38:52 +02001783 }
1784
Willy Tarreau7a534eb2021-07-21 10:01:36 +02001785 if ((global.mode & (MODE_MWORKER | MODE_CHECK)) == MODE_MWORKER &&
1786 (getenv("HAPROXY_MWORKER_REEXEC") != NULL)) {
William Lallemandcb11fd22017-06-01 17:38:52 +02001787 atexit_flag = 1;
1788 atexit(reexec_on_failure);
1789 }
1790
Willy Tarreau576132e2011-09-10 19:26:56 +02001791 if (change_dir && chdir(change_dir) < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001792 ha_alert("Could not change to directory %s : %s\n", change_dir, strerror(errno));
Willy Tarreau576132e2011-09-10 19:26:56 +02001793 exit(1);
1794 }
1795
Willy Tarreaubaaee002006-06-26 02:48:02 +02001796 global.maxsock = 10; /* reserve 10 fds ; will be incremented by socket eaters */
Willy Tarreau915e1eb2009-06-22 15:48:36 +02001797
Amaury Denoyellea6f9c5d2021-04-23 16:58:08 +02001798#ifdef USE_CPU_AFFINITY
1799 {
1800 int i;
1801 for (i = 0; i < MAX_PROCS; ++i) {
Amaury Denoyellefc6ac532021-04-27 10:46:36 +02001802 ha_cpuset_zero(&cpu_map.proc[i]);
1803 ha_cpuset_zero(&cpu_map.proc_t1[i]);
Willy Tarreau26f42a02021-05-14 08:26:38 +02001804 }
1805 for (i = 0; i < MAX_THREADS; ++i) {
Amaury Denoyellefc6ac532021-04-27 10:46:36 +02001806 ha_cpuset_zero(&cpu_map.thread[i]);
Amaury Denoyellea6f9c5d2021-04-23 16:58:08 +02001807 }
Amaury Denoyelle982fb532021-04-21 18:39:58 +02001808 }
Amaury Denoyellea6f9c5d2021-04-23 16:58:08 +02001809#endif
Amaury Denoyelle982fb532021-04-21 18:39:58 +02001810
William Lallemand944e6192018-11-21 15:48:31 +01001811 /* in wait mode, we don't try to read the configuration files */
1812 if (!(global.mode & MODE_MWORKER_WAIT)) {
Christopher Faulet4e366822021-01-12 18:57:38 +01001813 char *env_cfgfiles = NULL;
1814 int env_err = 0;
Willy Tarreauc4382422009-12-06 13:10:44 +01001815
William Lallemand944e6192018-11-21 15:48:31 +01001816 /* handle cfgfiles that are actually directories */
1817 cfgfiles_expand_directories();
1818
1819 if (LIST_ISEMPTY(&cfg_cfgfiles))
1820 usage(progname);
1821
1822
1823 list_for_each_entry(wl, &cfg_cfgfiles, list) {
1824 int ret;
1825
Christopher Faulet4e366822021-01-12 18:57:38 +01001826 if (env_err == 0) {
1827 if (!memprintf(&env_cfgfiles, "%s%s%s",
1828 (env_cfgfiles ? env_cfgfiles : ""),
1829 (env_cfgfiles ? ";" : ""), wl->s))
1830 env_err = 1;
1831 }
William Lallemand7b302d82019-05-20 11:15:37 +02001832
William Lallemand944e6192018-11-21 15:48:31 +01001833 ret = readcfgfile(wl->s);
1834 if (ret == -1) {
1835 ha_alert("Could not open configuration file %s : %s\n",
1836 wl->s, strerror(errno));
Christopher Faulet4e366822021-01-12 18:57:38 +01001837 free(env_cfgfiles);
William Lallemand944e6192018-11-21 15:48:31 +01001838 exit(1);
1839 }
1840 if (ret & (ERR_ABORT|ERR_FATAL))
1841 ha_alert("Error(s) found in configuration file : %s\n", wl->s);
1842 err_code |= ret;
Christopher Faulet4e366822021-01-12 18:57:38 +01001843 if (err_code & ERR_ABORT) {
1844 free(env_cfgfiles);
William Lallemand944e6192018-11-21 15:48:31 +01001845 exit(1);
Christopher Faulet4e366822021-01-12 18:57:38 +01001846 }
Willy Tarreauc4382422009-12-06 13:10:44 +01001847 }
Krzysztof Oledzkib304dc72007-10-14 23:40:01 +02001848
William Lallemand944e6192018-11-21 15:48:31 +01001849 /* do not try to resolve arguments nor to spot inconsistencies when
1850 * the configuration contains fatal errors caused by files not found
1851 * or failed memory allocations.
1852 */
1853 if (err_code & (ERR_ABORT|ERR_FATAL)) {
1854 ha_alert("Fatal errors found in configuration.\n");
Christopher Faulet4e366822021-01-12 18:57:38 +01001855 free(env_cfgfiles);
William Lallemand944e6192018-11-21 15:48:31 +01001856 exit(1);
1857 }
Christopher Faulet4e366822021-01-12 18:57:38 +01001858 if (env_err) {
1859 ha_alert("Could not allocate memory for HAPROXY_CFGFILES env variable\n");
1860 exit(1);
1861 }
1862 setenv("HAPROXY_CFGFILES", env_cfgfiles, 1);
1863 free(env_cfgfiles);
William Lallemand7b302d82019-05-20 11:15:37 +02001864
Willy Tarreaub83dc3d2017-04-19 11:24:07 +02001865 }
William Lallemandce83b4a2018-10-26 14:47:30 +02001866 if (global.mode & MODE_MWORKER) {
1867 int proc;
William Lallemand16dd1b32018-11-19 18:46:18 +01001868 struct mworker_proc *tmproc;
1869
William Lallemand482f9a92019-04-12 16:15:00 +02001870 setenv("HAPROXY_MWORKER", "1", 1);
1871
William Lallemand16dd1b32018-11-19 18:46:18 +01001872 if (getenv("HAPROXY_MWORKER_REEXEC") == NULL) {
1873
William Lallemandf3a86832019-04-01 11:29:58 +02001874 tmproc = calloc(1, sizeof(*tmproc));
William Lallemand16dd1b32018-11-19 18:46:18 +01001875 if (!tmproc) {
1876 ha_alert("Cannot allocate process structures.\n");
1877 exit(EXIT_FAILURE);
1878 }
William Lallemand8f7069a2019-04-12 16:09:23 +02001879 tmproc->options |= PROC_O_TYPE_MASTER; /* master */
William Lallemand16dd1b32018-11-19 18:46:18 +01001880 tmproc->reloads = 0;
1881 tmproc->relative_pid = 0;
1882 tmproc->pid = pid;
1883 tmproc->timestamp = start_date.tv_sec;
1884 tmproc->ipc_fd[0] = -1;
1885 tmproc->ipc_fd[1] = -1;
1886
1887 proc_self = tmproc;
1888
Willy Tarreau2b718102021-04-21 07:32:39 +02001889 LIST_APPEND(&proc_list, &tmproc->list);
William Lallemand16dd1b32018-11-19 18:46:18 +01001890 }
William Lallemandce83b4a2018-10-26 14:47:30 +02001891
1892 for (proc = 0; proc < global.nbproc; proc++) {
William Lallemandce83b4a2018-10-26 14:47:30 +02001893
William Lallemandf3a86832019-04-01 11:29:58 +02001894 tmproc = calloc(1, sizeof(*tmproc));
William Lallemandce83b4a2018-10-26 14:47:30 +02001895 if (!tmproc) {
1896 ha_alert("Cannot allocate process structures.\n");
1897 exit(EXIT_FAILURE);
1898 }
1899
William Lallemand8f7069a2019-04-12 16:09:23 +02001900 tmproc->options |= PROC_O_TYPE_WORKER; /* worker */
William Lallemandce83b4a2018-10-26 14:47:30 +02001901 tmproc->pid = -1;
1902 tmproc->reloads = 0;
William Lallemande3683302018-11-19 18:46:17 +01001903 tmproc->timestamp = -1;
William Lallemandce83b4a2018-10-26 14:47:30 +02001904 tmproc->relative_pid = 1 + proc;
William Lallemand550db6d2018-11-06 17:37:12 +01001905 tmproc->ipc_fd[0] = -1;
1906 tmproc->ipc_fd[1] = -1;
William Lallemandce83b4a2018-10-26 14:47:30 +02001907
1908 if (mworker_cli_sockpair_new(tmproc, proc) < 0) {
1909 exit(EXIT_FAILURE);
1910 }
1911
Willy Tarreau2b718102021-04-21 07:32:39 +02001912 LIST_APPEND(&proc_list, &tmproc->list);
William Lallemandce83b4a2018-10-26 14:47:30 +02001913 }
William Lallemand944e6192018-11-21 15:48:31 +01001914 }
1915 if (global.mode & (MODE_MWORKER|MODE_MWORKER_WAIT)) {
1916 struct wordlist *it, *c;
1917
Remi Tricot-Le Bretond90aa342021-05-19 10:45:12 +02001918 /* get the info of the children in the env */
1919 if (mworker_env_to_proc_list() < 0) {
1920 exit(EXIT_FAILURE);
1921 }
William Lallemande7361152018-10-26 14:47:36 +02001922
William Lallemand550db6d2018-11-06 17:37:12 +01001923 if (!LIST_ISEMPTY(&mworker_cli_conf)) {
William Lallemande7361152018-10-26 14:47:36 +02001924
William Lallemand550db6d2018-11-06 17:37:12 +01001925 if (mworker_cli_proxy_create() < 0) {
William Lallemande7361152018-10-26 14:47:36 +02001926 ha_alert("Can't create the master's CLI.\n");
1927 exit(EXIT_FAILURE);
1928 }
William Lallemande7361152018-10-26 14:47:36 +02001929
William Lallemand550db6d2018-11-06 17:37:12 +01001930 list_for_each_entry_safe(c, it, &mworker_cli_conf, list) {
1931
1932 if (mworker_cli_proxy_new_listener(c->s) < 0) {
1933 ha_alert("Can't create the master's CLI.\n");
1934 exit(EXIT_FAILURE);
1935 }
Willy Tarreau2b718102021-04-21 07:32:39 +02001936 LIST_DELETE(&c->list);
William Lallemand550db6d2018-11-06 17:37:12 +01001937 free(c->s);
1938 free(c);
1939 }
1940 }
William Lallemandce83b4a2018-10-26 14:47:30 +02001941 }
1942
Eric Salama5ba83352021-03-16 15:11:17 +01001943 if (!LIST_ISEMPTY(&mworker_cli_conf) && !(arg_mode & MODE_MWORKER)) {
1944 ha_warning("a master CLI socket was defined, but master-worker mode (-W) is not enabled.\n");
1945 }
1946
Willy Tarreauf42d7942020-10-20 11:54:49 +02001947 if (global.nbproc > 1 && !global.nbthread) {
1948 ha_warning("nbproc is deprecated!\n"
1949 " | For suffering many limitations, the 'nbproc' directive is now deprecated\n"
1950 " | and scheduled for removal in 2.5. Just comment it out: haproxy will use\n"
1951 " | threads and will run on all allocated processors. You may also switch to\n"
1952 " | 'nbthread %d' to keep the same number of processors. If you absolutely\n"
1953 " | want to run in multi-process mode, you can silence this warning by adding\n"
1954 " | 'nbthread 1', but then please report your use case to developers.\n",
1955 global.nbproc);
1956 }
1957
Willy Tarreaue90904d2021-02-12 14:08:31 +01001958 /* defaults sections are not needed anymore */
1959 proxy_destroy_all_defaults();
1960
Willy Tarreaubb925012009-07-23 13:36:36 +02001961 err_code |= check_config_validity();
Christopher Fauletc1692962019-08-12 09:51:07 +02001962 for (px = proxies_list; px; px = px->next) {
1963 struct server *srv;
1964 struct post_proxy_check_fct *ppcf;
1965 struct post_server_check_fct *pscf;
1966
Christopher Fauletd5bd8242020-11-02 16:20:13 +01001967 if (px->disabled)
1968 continue;
1969
Christopher Fauletc1692962019-08-12 09:51:07 +02001970 list_for_each_entry(pscf, &post_server_check_list, list) {
1971 for (srv = px->srv; srv; srv = srv->next)
1972 err_code |= pscf->fct(srv);
1973 }
1974 list_for_each_entry(ppcf, &post_proxy_check_list, list)
1975 err_code |= ppcf->fct(px);
1976 }
Willy Tarreaubb925012009-07-23 13:36:36 +02001977 if (err_code & (ERR_ABORT|ERR_FATAL)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001978 ha_alert("Fatal errors found in configuration.\n");
Willy Tarreau915e1eb2009-06-22 15:48:36 +02001979 exit(1);
1980 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02001981
Carl Henrik Lundef91ac192020-02-27 16:45:50 +01001982 err_code |= pattern_finalize_config();
1983 if (err_code & (ERR_ABORT|ERR_FATAL)) {
1984 ha_alert("Failed to finalize pattern config.\n");
1985 exit(1);
1986 }
Willy Tarreau0f936722019-04-11 14:47:08 +02001987
Willy Tarreau70060452015-12-14 12:46:07 +01001988 /* recompute the amount of per-process memory depending on nbproc and
1989 * the shared SSL cache size (allowed to exist in all processes).
1990 */
1991 if (global.rlimit_memmax_all) {
1992#if defined (USE_OPENSSL) && !defined(USE_PRIVATE_CACHE)
1993 int64_t ssl_cache_bytes = global.tune.sslcachesize * 200LL;
1994
1995 global.rlimit_memmax =
1996 ((((int64_t)global.rlimit_memmax_all * 1048576LL) -
1997 ssl_cache_bytes) / global.nbproc +
1998 ssl_cache_bytes + 1048575LL) / 1048576LL;
1999#else
2000 global.rlimit_memmax = global.rlimit_memmax_all / global.nbproc;
2001#endif
2002 }
2003
Willy Tarreaue5733232019-05-22 19:24:06 +02002004#ifdef USE_NS
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01002005 err_code |= netns_init();
2006 if (err_code & (ERR_ABORT|ERR_FATAL)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002007 ha_alert("Failed to initialize namespace support.\n");
KOVACS Krisztianb3e54fe2014-11-17 15:11:45 +01002008 exit(1);
2009 }
2010#endif
2011
Baptiste Assmann4215d7d2016-11-02 15:33:15 +01002012 /* Apply server states */
2013 apply_server_state();
2014
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002015 for (px = proxies_list; px; px = px->next)
Baptiste Assmann4215d7d2016-11-02 15:33:15 +01002016 srv_compute_all_admin_states(px);
2017
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01002018 /* Apply servers' configured address */
2019 err_code |= srv_init_addr();
2020 if (err_code & (ERR_ABORT|ERR_FATAL)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002021 ha_alert("Failed to initialize server(s) addr.\n");
Baptiste Assmann83cbaa52016-11-02 15:34:05 +01002022 exit(1);
2023 }
2024
Willy Tarreau3eb10b82020-04-15 16:42:39 +02002025 if (warned & WARN_ANY && global.mode & MODE_ZERO_WARNING) {
2026 ha_alert("Some warnings were found and 'zero-warning' is set. Aborting.\n");
2027 exit(1);
2028 }
2029
Willy Tarreau0aa9dbe2021-12-28 15:43:11 +01002030#if defined(HA_HAVE_DUMP_LIBS)
2031 if (global.mode & MODE_DUMP_LIBS) {
2032 qfprintf(stdout, "List of loaded object files:\n");
2033 chunk_reset(&trash);
2034 if (dump_libs(&trash, 0))
2035 printf("%s", trash.area);
2036 }
2037#endif
2038
Willy Tarreaubaaee002006-06-26 02:48:02 +02002039 if (global.mode & MODE_CHECK) {
Willy Tarreau8b15ba12012-02-02 17:48:18 +01002040 struct peers *pr;
2041 struct proxy *px;
2042
Willy Tarreaubebd2122020-04-15 16:06:11 +02002043 if (warned & WARN_ANY)
2044 qfprintf(stdout, "Warnings were found.\n");
2045
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02002046 for (pr = cfg_peers; pr; pr = pr->next)
Willy Tarreau8b15ba12012-02-02 17:48:18 +01002047 if (pr->peers_fe)
2048 break;
2049
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002050 for (px = proxies_list; px; px = px->next)
Willy Tarreauc3914d42020-09-24 08:39:22 +02002051 if (!px->disabled && px->li_all)
Willy Tarreau8b15ba12012-02-02 17:48:18 +01002052 break;
2053
Emeric Brun3a9c0002021-08-13 09:32:50 +02002054 if (!px) {
2055 /* We may only have log-forward section */
2056 for (px = cfg_log_forward; px; px = px->next)
2057 if (!px->disabled && px->li_all)
2058 break;
2059 }
2060
Willy Tarreau8b15ba12012-02-02 17:48:18 +01002061 if (pr || px) {
2062 /* At least one peer or one listener has been found */
2063 qfprintf(stdout, "Configuration file is valid\n");
Tim Duesterhus0a3b43d2020-06-14 00:37:42 +02002064 deinit_and_exit(0);
Willy Tarreau8b15ba12012-02-02 17:48:18 +01002065 }
2066 qfprintf(stdout, "Configuration file has no error but will not start (no listener) => exit(2).\n");
2067 exit(2);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002068 }
Willy Tarreaue9b26022011-08-01 20:57:55 +02002069
Amaury Denoyelle5a6926d2021-03-30 17:34:24 +02002070 if (global.mode & MODE_DIAG) {
2071 cfg_run_diagnostics();
2072 }
2073
Willy Tarreau8263d2b2012-08-28 00:06:31 +02002074 /* now we know the buffer size, we can initialize the channels and buffers */
Willy Tarreau9b28e032012-10-12 23:49:43 +02002075 init_buffer();
Willy Tarreau8280d642009-09-23 23:37:52 +02002076
Willy Tarreaue6945732016-12-21 19:57:00 +01002077 list_for_each_entry(pcf, &post_check_list, list) {
2078 err_code |= pcf->fct();
2079 if (err_code & (ERR_ABORT|ERR_FATAL))
2080 exit(1);
2081 }
2082
William Lallemande9eb2492022-06-21 11:11:50 +02002083 /* set the default maxconn in the master, but let it be rewritable with -n */
2084 if (global.mode & MODE_MWORKER_WAIT)
2085 global.maxconn = DEFAULT_MAXCONN;
2086
Willy Tarreaubaaee002006-06-26 02:48:02 +02002087 if (cfg_maxconn > 0)
2088 global.maxconn = cfg_maxconn;
2089
Willy Tarreau4975d142021-03-13 11:00:33 +01002090 if (global.cli_fe)
2091 global.maxsock += global.cli_fe->maxconn;
Willy Tarreau8d687d82019-03-01 09:39:42 +01002092
2093 if (cfg_peers) {
2094 /* peers also need to bypass global maxconn */
2095 struct peers *p = cfg_peers;
2096
2097 for (p = cfg_peers; p; p = p->next)
2098 if (p->peers_fe)
2099 global.maxsock += p->peers_fe->maxconn;
2100 }
2101
Willy Tarreaubaaee002006-06-26 02:48:02 +02002102 if (cfg_pidfile) {
Willy Tarreaua534fea2008-08-03 12:19:50 +02002103 free(global.pidfile);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002104 global.pidfile = strdup(cfg_pidfile);
2105 }
2106
Willy Tarreaud0256482015-01-15 21:45:22 +01002107 /* Now we want to compute the maxconn and possibly maxsslconn values.
Willy Tarreauac350932019-03-01 15:43:14 +01002108 * It's a bit tricky. Maxconn defaults to the pre-computed value based
2109 * on rlim_fd_cur and the number of FDs in use due to the configuration,
2110 * and maxsslconn defaults to DEFAULT_MAXSSLCONN. On top of that we can
2111 * enforce a lower limit based on memmax.
Willy Tarreaud0256482015-01-15 21:45:22 +01002112 *
2113 * If memmax is set, then it depends on which values are set. If
2114 * maxsslconn is set, we use memmax to determine how many cleartext
2115 * connections may be added, and set maxconn to the sum of the two.
2116 * If maxconn is set and not maxsslconn, maxsslconn is computed from
2117 * the remaining amount of memory between memmax and the cleartext
2118 * connections. If neither are set, then it is considered that all
2119 * connections are SSL-capable, and maxconn is computed based on this,
2120 * then maxsslconn accordingly. We need to know if SSL is used on the
2121 * frontends, backends, or both, because when it's used on both sides,
2122 * we need twice the value for maxsslconn, but we only count the
2123 * handshake once since it is not performed on the two sides at the
2124 * same time (frontend-side is terminated before backend-side begins).
2125 * The SSL stack is supposed to have filled ssl_session_cost and
Willy Tarreau474b96a2015-01-28 19:03:21 +01002126 * ssl_handshake_cost during its initialization. In any case, if
2127 * SYSTEM_MAXCONN is set, we still enforce it as an upper limit for
2128 * maxconn in order to protect the system.
Willy Tarreaud0256482015-01-15 21:45:22 +01002129 */
Willy Tarreauac350932019-03-01 15:43:14 +01002130 ideal_maxconn = compute_ideal_maxconn();
2131
Willy Tarreaud0256482015-01-15 21:45:22 +01002132 if (!global.rlimit_memmax) {
2133 if (global.maxconn == 0) {
Willy Tarreauac350932019-03-01 15:43:14 +01002134 global.maxconn = ideal_maxconn;
Willy Tarreaud0256482015-01-15 21:45:22 +01002135 if (global.mode & (MODE_VERBOSE|MODE_DEBUG))
2136 fprintf(stderr, "Note: setting global.maxconn to %d.\n", global.maxconn);
2137 }
2138 }
2139#ifdef USE_OPENSSL
2140 else if (!global.maxconn && !global.maxsslconn &&
2141 (global.ssl_used_frontend || global.ssl_used_backend)) {
2142 /* memmax is set, compute everything automatically. Here we want
2143 * to ensure that all SSL connections will be served. We take
2144 * care of the number of sides where SSL is used, and consider
2145 * the worst case : SSL used on both sides and doing a handshake
2146 * simultaneously. Note that we can't have more than maxconn
2147 * handshakes at a time by definition, so for the worst case of
2148 * two SSL conns per connection, we count a single handshake.
2149 */
2150 int sides = !!global.ssl_used_frontend + !!global.ssl_used_backend;
2151 int64_t mem = global.rlimit_memmax * 1048576ULL;
Willy Tarreau304e17e2020-03-10 17:54:54 +01002152 int retried = 0;
Willy Tarreaud0256482015-01-15 21:45:22 +01002153
2154 mem -= global.tune.sslcachesize * 200; // about 200 bytes per SSL cache entry
2155 mem -= global.maxzlibmem;
2156 mem = mem * MEM_USABLE_RATIO;
2157
Willy Tarreau304e17e2020-03-10 17:54:54 +01002158 /* Principle: we test once to set maxconn according to the free
2159 * memory. If it results in values the system rejects, we try a
2160 * second time by respecting rlim_fd_max. If it fails again, we
2161 * go back to the initial value and will let the final code
2162 * dealing with rlimit report the error. That's up to 3 attempts.
2163 */
2164 do {
2165 global.maxconn = mem /
2166 ((STREAM_MAX_COST + 2 * global.tune.bufsize) + // stream + 2 buffers per stream
2167 sides * global.ssl_session_max_cost + // SSL buffers, one per side
2168 global.ssl_handshake_max_cost); // 1 handshake per connection max
Willy Tarreaud0256482015-01-15 21:45:22 +01002169
Willy Tarreau304e17e2020-03-10 17:54:54 +01002170 if (retried == 1)
2171 global.maxconn = MIN(global.maxconn, ideal_maxconn);
2172 global.maxconn = round_2dig(global.maxconn);
Willy Tarreau474b96a2015-01-28 19:03:21 +01002173#ifdef SYSTEM_MAXCONN
Willy Tarreau304e17e2020-03-10 17:54:54 +01002174 if (global.maxconn > SYSTEM_MAXCONN)
2175 global.maxconn = SYSTEM_MAXCONN;
Willy Tarreau474b96a2015-01-28 19:03:21 +01002176#endif /* SYSTEM_MAXCONN */
Willy Tarreau304e17e2020-03-10 17:54:54 +01002177 global.maxsslconn = sides * global.maxconn;
2178
2179 if (check_if_maxsock_permitted(compute_ideal_maxsock(global.maxconn)))
2180 break;
2181 } while (retried++ < 2);
2182
Willy Tarreaud0256482015-01-15 21:45:22 +01002183 if (global.mode & (MODE_VERBOSE|MODE_DEBUG))
2184 fprintf(stderr, "Note: setting global.maxconn to %d and global.maxsslconn to %d.\n",
2185 global.maxconn, global.maxsslconn);
2186 }
2187 else if (!global.maxsslconn &&
2188 (global.ssl_used_frontend || global.ssl_used_backend)) {
2189 /* memmax and maxconn are known, compute maxsslconn automatically.
2190 * maxsslconn being forced, we don't know how many of it will be
2191 * on each side if both sides are being used. The worst case is
2192 * when all connections use only one SSL instance because
2193 * handshakes may be on two sides at the same time.
2194 */
2195 int sides = !!global.ssl_used_frontend + !!global.ssl_used_backend;
2196 int64_t mem = global.rlimit_memmax * 1048576ULL;
2197 int64_t sslmem;
2198
2199 mem -= global.tune.sslcachesize * 200; // about 200 bytes per SSL cache entry
2200 mem -= global.maxzlibmem;
2201 mem = mem * MEM_USABLE_RATIO;
2202
Willy Tarreau87b09662015-04-03 00:22:06 +02002203 sslmem = mem - global.maxconn * (int64_t)(STREAM_MAX_COST + 2 * global.tune.bufsize);
Willy Tarreaud0256482015-01-15 21:45:22 +01002204 global.maxsslconn = sslmem / (global.ssl_session_max_cost + global.ssl_handshake_max_cost);
2205 global.maxsslconn = round_2dig(global.maxsslconn);
2206
2207 if (sslmem <= 0 || global.maxsslconn < sides) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002208 ha_alert("Cannot compute the automatic maxsslconn because global.maxconn is already too "
2209 "high for the global.memmax value (%d MB). The absolute maximum possible value "
2210 "without SSL is %d, but %d was found and SSL is in use.\n",
2211 global.rlimit_memmax,
2212 (int)(mem / (STREAM_MAX_COST + 2 * global.tune.bufsize)),
2213 global.maxconn);
Willy Tarreaud0256482015-01-15 21:45:22 +01002214 exit(1);
2215 }
2216
2217 if (global.maxsslconn > sides * global.maxconn)
2218 global.maxsslconn = sides * global.maxconn;
2219
2220 if (global.mode & (MODE_VERBOSE|MODE_DEBUG))
2221 fprintf(stderr, "Note: setting global.maxsslconn to %d\n", global.maxsslconn);
2222 }
2223#endif
2224 else if (!global.maxconn) {
2225 /* memmax and maxsslconn are known/unused, compute maxconn automatically */
2226 int sides = !!global.ssl_used_frontend + !!global.ssl_used_backend;
2227 int64_t mem = global.rlimit_memmax * 1048576ULL;
2228 int64_t clearmem;
Willy Tarreau304e17e2020-03-10 17:54:54 +01002229 int retried = 0;
Willy Tarreaud0256482015-01-15 21:45:22 +01002230
2231 if (global.ssl_used_frontend || global.ssl_used_backend)
2232 mem -= global.tune.sslcachesize * 200; // about 200 bytes per SSL cache entry
2233
2234 mem -= global.maxzlibmem;
2235 mem = mem * MEM_USABLE_RATIO;
2236
2237 clearmem = mem;
2238 if (sides)
2239 clearmem -= (global.ssl_session_max_cost + global.ssl_handshake_max_cost) * (int64_t)global.maxsslconn;
2240
Willy Tarreau304e17e2020-03-10 17:54:54 +01002241 /* Principle: we test once to set maxconn according to the free
2242 * memory. If it results in values the system rejects, we try a
2243 * second time by respecting rlim_fd_max. If it fails again, we
2244 * go back to the initial value and will let the final code
2245 * dealing with rlimit report the error. That's up to 3 attempts.
2246 */
2247 do {
2248 global.maxconn = clearmem / (STREAM_MAX_COST + 2 * global.tune.bufsize);
2249 if (retried == 1)
2250 global.maxconn = MIN(global.maxconn, ideal_maxconn);
2251 global.maxconn = round_2dig(global.maxconn);
Willy Tarreau474b96a2015-01-28 19:03:21 +01002252#ifdef SYSTEM_MAXCONN
Willy Tarreau304e17e2020-03-10 17:54:54 +01002253 if (global.maxconn > SYSTEM_MAXCONN)
2254 global.maxconn = SYSTEM_MAXCONN;
Willy Tarreau474b96a2015-01-28 19:03:21 +01002255#endif /* SYSTEM_MAXCONN */
Willy Tarreaud0256482015-01-15 21:45:22 +01002256
Willy Tarreau304e17e2020-03-10 17:54:54 +01002257 if (clearmem <= 0 || !global.maxconn) {
2258 ha_alert("Cannot compute the automatic maxconn because global.maxsslconn is already too "
2259 "high for the global.memmax value (%d MB). The absolute maximum possible value "
2260 "is %d, but %d was found.\n",
2261 global.rlimit_memmax,
Christopher Faulet767a84b2017-11-24 16:50:31 +01002262 (int)(mem / (global.ssl_session_max_cost + global.ssl_handshake_max_cost)),
Willy Tarreau304e17e2020-03-10 17:54:54 +01002263 global.maxsslconn);
2264 exit(1);
2265 }
2266
2267 if (check_if_maxsock_permitted(compute_ideal_maxsock(global.maxconn)))
2268 break;
2269 } while (retried++ < 2);
Willy Tarreaud0256482015-01-15 21:45:22 +01002270
2271 if (global.mode & (MODE_VERBOSE|MODE_DEBUG)) {
2272 if (sides && global.maxsslconn > sides * global.maxconn) {
2273 fprintf(stderr, "Note: global.maxsslconn is forced to %d which causes global.maxconn "
2274 "to be limited to %d. Better reduce global.maxsslconn to get more "
2275 "room for extra connections.\n", global.maxsslconn, global.maxconn);
2276 }
2277 fprintf(stderr, "Note: setting global.maxconn to %d\n", global.maxconn);
2278 }
Willy Tarreau66aa61f2009-01-18 21:44:07 +01002279 }
2280
Willy Tarreaua409f302020-03-10 17:08:53 +01002281 global.maxsock = compute_ideal_maxsock(global.maxconn);
2282 global.hardmaxconn = global.maxconn;
Willy Tarreaua4818db2020-06-19 16:20:59 +02002283 if (!global.maxpipes)
2284 global.maxpipes = compute_ideal_maxpipes();
Willy Tarreaubaaee002006-06-26 02:48:02 +02002285
Olivier Houchard88698d92019-04-16 19:07:22 +02002286 /* update connection pool thresholds */
2287 global.tune.pool_low_count = ((long long)global.maxsock * global.tune.pool_low_ratio + 99) / 100;
2288 global.tune.pool_high_count = ((long long)global.maxsock * global.tune.pool_high_ratio + 99) / 100;
2289
Willy Tarreauc8d5b952019-02-27 17:25:52 +01002290 proxy_adjust_all_maxconn();
2291
Willy Tarreau1db37712007-06-03 17:16:49 +02002292 if (global.tune.maxpollevents <= 0)
2293 global.tune.maxpollevents = MAX_POLL_EVENTS;
2294
Willy Tarreau060a7612021-03-10 11:06:26 +01002295 if (global.tune.runqueue_depth <= 0) {
2296 /* tests on various thread counts from 1 to 64 have shown an
2297 * optimal queue depth following roughly 1/sqrt(threads).
2298 */
2299 int s = my_flsl(global.nbthread);
2300 s += (global.nbthread / s); // roughly twice the sqrt.
2301 global.tune.runqueue_depth = RUNQUEUE_DEPTH * 2 / s;
2302 }
Olivier Houchard1599b802018-05-24 18:59:04 +02002303
Willy Tarreau6f4a82c2009-03-21 20:43:57 +01002304 if (global.tune.recv_enough == 0)
2305 global.tune.recv_enough = MIN_RECV_AT_ONCE_ENOUGH;
2306
Willy Tarreau27a674e2009-08-17 07:23:33 +02002307 if (global.tune.maxrewrite >= global.tune.bufsize / 2)
2308 global.tune.maxrewrite = global.tune.bufsize / 2;
2309
Willy Tarreaubaaee002006-06-26 02:48:02 +02002310 if (arg_mode & (MODE_DEBUG | MODE_FOREGROUND)) {
2311 /* command line debug mode inhibits configuration mode */
William Lallemand095ba4c2017-06-01 17:38:50 +02002312 global.mode &= ~(MODE_DAEMON | MODE_QUIET);
Willy Tarreau772f0dd2012-10-26 16:04:28 +02002313 global.mode |= (arg_mode & (MODE_DEBUG | MODE_FOREGROUND));
2314 }
2315
William Lallemand095ba4c2017-06-01 17:38:50 +02002316 if (arg_mode & MODE_DAEMON) {
Willy Tarreau772f0dd2012-10-26 16:04:28 +02002317 /* command line daemon mode inhibits foreground and debug modes mode */
2318 global.mode &= ~(MODE_DEBUG | MODE_FOREGROUND);
William Lallemand095ba4c2017-06-01 17:38:50 +02002319 global.mode |= arg_mode & MODE_DAEMON;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002320 }
Willy Tarreau772f0dd2012-10-26 16:04:28 +02002321
2322 global.mode |= (arg_mode & (MODE_QUIET | MODE_VERBOSE));
Willy Tarreaubaaee002006-06-26 02:48:02 +02002323
William Lallemand095ba4c2017-06-01 17:38:50 +02002324 if ((global.mode & MODE_DEBUG) && (global.mode & (MODE_DAEMON | MODE_QUIET))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002325 ha_warning("<debug> mode incompatible with <quiet> and <daemon>. Keeping <debug> only.\n");
William Lallemand095ba4c2017-06-01 17:38:50 +02002326 global.mode &= ~(MODE_DAEMON | MODE_QUIET);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002327 }
2328
William Lallemand095ba4c2017-06-01 17:38:50 +02002329 if ((global.nbproc > 1) && !(global.mode & (MODE_DAEMON | MODE_MWORKER))) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02002330 if (!(global.mode & (MODE_FOREGROUND | MODE_DEBUG)))
Christopher Faulet767a84b2017-11-24 16:50:31 +01002331 ha_warning("<nbproc> is only meaningful in daemon mode or master-worker mode. Setting limit to 1 process.\n");
Willy Tarreaubaaee002006-06-26 02:48:02 +02002332 global.nbproc = 1;
2333 }
2334
2335 if (global.nbproc < 1)
2336 global.nbproc = 1;
2337
Christopher Fauletbe0faa22017-08-29 15:37:10 +02002338 if (global.nbthread < 1)
2339 global.nbthread = 1;
2340
Christopher Faulet3ef26392017-08-29 16:46:57 +02002341 /* Realloc trash buffers because global.tune.bufsize may have changed */
Christopher Fauletcd7879a2017-10-27 13:53:47 +02002342 if (!init_trash_buffers(0)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002343 ha_alert("failed to initialize trash buffers.\n");
Christopher Faulet3ef26392017-08-29 16:46:57 +02002344 exit(1);
2345 }
2346
Christopher Faulet96d44832017-11-14 22:02:30 +01002347 if (!init_log_buffers()) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002348 ha_alert("failed to initialize log buffers.\n");
Christopher Faulet96d44832017-11-14 22:02:30 +01002349 exit(1);
2350 }
2351
Willy Tarreauef1d1f82007-04-16 00:25:25 +02002352 /*
2353 * Note: we could register external pollers here.
2354 * Built-in pollers have been registered before main().
2355 */
Willy Tarreau4f60f162007-04-08 16:39:58 +02002356
Willy Tarreau43b78992009-01-25 15:42:27 +01002357 if (!(global.tune.options & GTUNE_USE_KQUEUE))
Willy Tarreau1e63130a2007-04-09 12:03:06 +02002358 disable_poller("kqueue");
2359
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +00002360 if (!(global.tune.options & GTUNE_USE_EVPORTS))
2361 disable_poller("evports");
2362
Willy Tarreau43b78992009-01-25 15:42:27 +01002363 if (!(global.tune.options & GTUNE_USE_EPOLL))
Willy Tarreau4f60f162007-04-08 16:39:58 +02002364 disable_poller("epoll");
2365
Willy Tarreau43b78992009-01-25 15:42:27 +01002366 if (!(global.tune.options & GTUNE_USE_POLL))
Willy Tarreau4f60f162007-04-08 16:39:58 +02002367 disable_poller("poll");
2368
Willy Tarreau43b78992009-01-25 15:42:27 +01002369 if (!(global.tune.options & GTUNE_USE_SELECT))
Willy Tarreau4f60f162007-04-08 16:39:58 +02002370 disable_poller("select");
2371
2372 /* Note: we could disable any poller by name here */
2373
Christopher Fauletb3f4e142016-03-07 12:46:38 +01002374 if (global.mode & (MODE_VERBOSE|MODE_DEBUG)) {
Willy Tarreau2ff76222007-04-09 19:29:56 +02002375 list_pollers(stderr);
Christopher Fauletb3f4e142016-03-07 12:46:38 +01002376 fprintf(stderr, "\n");
2377 list_filters(stderr);
2378 }
Willy Tarreau2ff76222007-04-09 19:29:56 +02002379
Willy Tarreau4f60f162007-04-08 16:39:58 +02002380 if (!init_pollers()) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002381 ha_alert("No polling mechanism available.\n"
2382 " It is likely that haproxy was built with TARGET=generic and that FD_SETSIZE\n"
2383 " is too low on this platform to support maxconn and the number of listeners\n"
2384 " and servers. You should rebuild haproxy specifying your system using TARGET=\n"
2385 " in order to support other polling systems (poll, epoll, kqueue) or reduce the\n"
2386 " global maxconn setting to accommodate the system's limitation. For reference,\n"
2387 " FD_SETSIZE=%d on this system, global.maxconn=%d resulting in a maximum of\n"
2388 " %d file descriptors. You should thus reduce global.maxconn by %d. Also,\n"
2389 " check build settings using 'haproxy -vv'.\n\n",
2390 FD_SETSIZE, global.maxconn, global.maxsock, (global.maxsock + 1 - FD_SETSIZE) / 2);
Willy Tarreau4f60f162007-04-08 16:39:58 +02002391 exit(1);
2392 }
Willy Tarreau2ff76222007-04-09 19:29:56 +02002393 if (global.mode & (MODE_VERBOSE|MODE_DEBUG)) {
2394 printf("Using %s() as the polling mechanism.\n", cur_poller.name);
Willy Tarreau4f60f162007-04-08 16:39:58 +02002395 }
2396
Krzysztof Piotr Oledzki48cb2ae2009-10-02 22:51:14 +02002397 if (!global.node)
2398 global.node = strdup(hostname);
2399
Willy Tarreau02b092f2020-10-07 18:36:54 +02002400 /* stop disabled proxies */
2401 for (px = proxies_list; px; px = px->next) {
Willy Tarreauc3914d42020-09-24 08:39:22 +02002402 if (px->disabled)
Willy Tarreau02b092f2020-10-07 18:36:54 +02002403 stop_proxy(px);
2404 }
2405
Thierry FOURNIERa4a0f3d2015-01-23 12:08:30 +01002406 if (!hlua_post_init())
2407 exit(1);
Thomas Holmes6abded42015-05-12 16:23:58 +01002408
Maxime de Roucy0f503922016-05-13 23:52:55 +02002409 free(err_msg);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002410}
2411
Cyril Bonté203ec5a2017-03-23 22:44:13 +01002412void deinit(void)
Willy Tarreaubaaee002006-06-26 02:48:02 +02002413{
Olivier Houchardfbc74e82017-11-24 16:54:05 +01002414 struct proxy *p = proxies_list, *p0;
Willy Tarreaudeb9ed82010-01-03 21:03:22 +01002415 struct wordlist *wl, *wlb;
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02002416 struct uri_auth *uap, *ua = NULL;
William Lallemand0f99e342011-10-12 17:50:54 +02002417 struct logsrv *log, *logb;
Willy Tarreaucdb737e2016-12-21 18:43:10 +01002418 struct build_opts_str *bol, *bolb;
Tim Duesterhusfdf904a2020-07-04 11:49:48 +02002419 struct post_deinit_fct *pdf, *pdfb;
Tim Duesterhus17e363f2020-07-04 11:49:47 +02002420 struct proxy_deinit_fct *pxdf, *pxdfb;
Tim Duesterhus0837eb12020-07-04 11:49:49 +02002421 struct server_deinit_fct *srvdf, *srvdfb;
Tim Duesterhusf0c25d22020-09-10 19:46:41 +02002422 struct per_thread_init_fct *tif, *tifb;
2423 struct per_thread_deinit_fct *tdf, *tdfb;
2424 struct per_thread_alloc_fct *taf, *tafb;
2425 struct per_thread_free_fct *tff, *tffb;
Tim Duesterhus34bef072020-07-04 11:49:50 +02002426 struct post_server_check_fct *pscf, *pscfb;
Tim Duesterhusfc854942020-09-10 19:46:42 +02002427 struct post_check_fct *pcf, *pcfb;
Tim Duesterhus53508d62020-09-10 19:46:40 +02002428 struct post_proxy_check_fct *ppcf, *ppcfb;
Willy Tarreauae7bc4a2020-09-23 16:46:22 +02002429 int cur_fd;
2430
2431 /* At this point the listeners state is weird:
2432 * - most listeners are still bound and referenced in their protocol
2433 * - some might be zombies that are not in their proto anymore, but
2434 * still appear in their proxy's listeners with a valid FD.
2435 * - some might be stopped and still appear in their proxy as FD #-1
2436 * - among all of them, some might be inherited hence shared and we're
2437 * not allowed to pause them or whatever, we must just close them.
2438 * - finally some are not listeners (pipes, logs, stdout, etc) and
2439 * must be left intact.
2440 *
2441 * The safe way to proceed is to unbind (and close) whatever is not yet
2442 * unbound so that no more receiver/listener remains alive. Then close
2443 * remaining listener FDs, which correspond to zombie listeners (those
2444 * belonging to disabled proxies that were in another process).
2445 * objt_listener() would be cleaner here but not converted yet.
2446 */
2447 protocol_unbind_all();
2448
2449 for (cur_fd = 0; cur_fd < global.maxsock; cur_fd++) {
Willy Tarreau1a3770c2020-10-14 12:13:51 +02002450 if (!fdtab || !fdtab[cur_fd].owner)
Willy Tarreauae7bc4a2020-09-23 16:46:22 +02002451 continue;
2452
Willy Tarreaua74cb382020-10-15 21:29:49 +02002453 if (fdtab[cur_fd].iocb == &sock_accept_iocb) {
Willy Tarreauae7bc4a2020-09-23 16:46:22 +02002454 struct listener *l = fdtab[cur_fd].owner;
2455
2456 BUG_ON(l->state != LI_INIT);
2457 unbind_listener(l);
2458 }
2459 }
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02002460
Willy Tarreau24f4efa2010-08-27 17:56:48 +02002461 deinit_signals();
Willy Tarreaubaaee002006-06-26 02:48:02 +02002462 while (p) {
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02002463 /* build a list of unique uri_auths */
2464 if (!ua)
2465 ua = p->uri_auth;
2466 else {
2467 /* check if p->uri_auth is unique */
2468 for (uap = ua; uap; uap=uap->next)
2469 if (uap == p->uri_auth)
2470 break;
2471
Willy Tarreauaccc4e12008-06-24 11:14:45 +02002472 if (!uap && p->uri_auth) {
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02002473 /* add it, if it is */
2474 p->uri_auth->next = ua;
2475 ua = p->uri_auth;
2476 }
William Lallemand0f99e342011-10-12 17:50:54 +02002477 }
2478
Willy Tarreau4d2d0982007-05-14 00:39:29 +02002479 p0 = p;
Willy Tarreaubaaee002006-06-26 02:48:02 +02002480 p = p->next;
Amaury Denoyelle27fefa12021-03-24 16:13:20 +01002481 free_proxy(p0);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002482 }/* end while(p) */
Willy Tarreaudd815982007-10-16 12:25:14 +02002483
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02002484 while (ua) {
Tim Duesterhus00f00cf2020-09-10 19:46:38 +02002485 struct stat_scope *scope, *scopep;
2486
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02002487 uap = ua;
2488 ua = ua->next;
2489
Willy Tarreaua534fea2008-08-03 12:19:50 +02002490 free(uap->uri_prefix);
2491 free(uap->auth_realm);
Krzysztof Piotr Oledzki48cb2ae2009-10-02 22:51:14 +02002492 free(uap->node);
2493 free(uap->desc);
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02002494
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002495 userlist_free(uap->userlist);
Amaury Denoyelle68fd7e42021-03-25 17:15:52 +01002496 free_act_rules(&uap->http_req_rules);
Krzysztof Piotr Oledzki8c8bd452010-01-29 19:29:32 +01002497
Tim Duesterhus00f00cf2020-09-10 19:46:38 +02002498 scope = uap->scope;
2499 while (scope) {
2500 scopep = scope;
2501 scope = scope->next;
2502
2503 free(scopep->px_id);
2504 free(scopep);
2505 }
2506
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02002507 free(uap);
2508 }
2509
Krzysztof Piotr Oledzki96105042010-01-29 17:50:44 +01002510 userlist_free(userlist);
2511
David Carlier834cb2e2015-09-25 12:02:25 +01002512 cfg_unregister_sections();
2513
Christopher Faulet0132d062017-07-26 15:33:35 +02002514 deinit_log_buffers();
David Carlier834cb2e2015-09-25 12:02:25 +01002515
Willy Tarreau05554e62016-12-21 20:46:26 +01002516 list_for_each_entry(pdf, &post_deinit_list, list)
2517 pdf->fct();
2518
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002519 ha_free(&global.log_send_hostname);
Dragan Dosen43885c72015-10-01 13:18:13 +02002520 chunk_destroy(&global.log_tag);
Willy Tarreau61cfdf42021-02-20 10:46:51 +01002521 ha_free(&global.chroot);
2522 ha_free(&global.pidfile);
2523 ha_free(&global.node);
2524 ha_free(&global.desc);
2525 ha_free(&oldpids);
2526 ha_free(&old_argv);
2527 ha_free(&localpeer);
2528 ha_free(&global.server_state_base);
2529 ha_free(&global.server_state_file);
Olivier Houchard3f795f72019-04-17 22:51:06 +02002530 task_destroy(idle_conn_task);
Olivier Houchard9ea5d362019-02-14 18:29:09 +01002531 idle_conn_task = NULL;
Krzysztof Piotr Oledzki8001d612008-05-31 13:53:23 +02002532
William Lallemand0f99e342011-10-12 17:50:54 +02002533 list_for_each_entry_safe(log, logb, &global.logsrvs, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02002534 LIST_DELETE(&log->list);
Amaury Denoyelled688e012021-04-20 17:05:47 +02002535 free(log->conf.file);
William Lallemand0f99e342011-10-12 17:50:54 +02002536 free(log);
2537 }
Willy Tarreau477ecd82010-01-03 21:12:30 +01002538 list_for_each_entry_safe(wl, wlb, &cfg_cfgfiles, list) {
Maxime de Roucy0f503922016-05-13 23:52:55 +02002539 free(wl->s);
Willy Tarreau2b718102021-04-21 07:32:39 +02002540 LIST_DELETE(&wl->list);
Willy Tarreau477ecd82010-01-03 21:12:30 +01002541 free(wl);
2542 }
2543
Willy Tarreaucdb737e2016-12-21 18:43:10 +01002544 list_for_each_entry_safe(bol, bolb, &build_opts_list, list) {
2545 if (bol->must_free)
2546 free((void *)bol->str);
Willy Tarreau2b718102021-04-21 07:32:39 +02002547 LIST_DELETE(&bol->list);
Willy Tarreaucdb737e2016-12-21 18:43:10 +01002548 free(bol);
2549 }
2550
Tim Duesterhus17e363f2020-07-04 11:49:47 +02002551 list_for_each_entry_safe(pxdf, pxdfb, &proxy_deinit_list, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02002552 LIST_DELETE(&pxdf->list);
Tim Duesterhus17e363f2020-07-04 11:49:47 +02002553 free(pxdf);
2554 }
2555
Tim Duesterhusfdf904a2020-07-04 11:49:48 +02002556 list_for_each_entry_safe(pdf, pdfb, &post_deinit_list, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02002557 LIST_DELETE(&pdf->list);
Tim Duesterhusfdf904a2020-07-04 11:49:48 +02002558 free(pdf);
2559 }
2560
Tim Duesterhus0837eb12020-07-04 11:49:49 +02002561 list_for_each_entry_safe(srvdf, srvdfb, &server_deinit_list, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02002562 LIST_DELETE(&srvdf->list);
Tim Duesterhus0837eb12020-07-04 11:49:49 +02002563 free(srvdf);
2564 }
2565
Tim Duesterhusfc854942020-09-10 19:46:42 +02002566 list_for_each_entry_safe(pcf, pcfb, &post_check_list, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02002567 LIST_DELETE(&pcf->list);
Tim Duesterhusfc854942020-09-10 19:46:42 +02002568 free(pcf);
2569 }
2570
Tim Duesterhus34bef072020-07-04 11:49:50 +02002571 list_for_each_entry_safe(pscf, pscfb, &post_server_check_list, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02002572 LIST_DELETE(&pscf->list);
Tim Duesterhus34bef072020-07-04 11:49:50 +02002573 free(pscf);
2574 }
2575
Tim Duesterhus53508d62020-09-10 19:46:40 +02002576 list_for_each_entry_safe(ppcf, ppcfb, &post_proxy_check_list, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02002577 LIST_DELETE(&ppcf->list);
Tim Duesterhus53508d62020-09-10 19:46:40 +02002578 free(ppcf);
2579 }
2580
Tim Duesterhusf0c25d22020-09-10 19:46:41 +02002581 list_for_each_entry_safe(tif, tifb, &per_thread_init_list, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02002582 LIST_DELETE(&tif->list);
Tim Duesterhusf0c25d22020-09-10 19:46:41 +02002583 free(tif);
2584 }
2585
2586 list_for_each_entry_safe(tdf, tdfb, &per_thread_deinit_list, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02002587 LIST_DELETE(&tdf->list);
Tim Duesterhusf0c25d22020-09-10 19:46:41 +02002588 free(tdf);
2589 }
2590
2591 list_for_each_entry_safe(taf, tafb, &per_thread_alloc_list, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02002592 LIST_DELETE(&taf->list);
Tim Duesterhusf0c25d22020-09-10 19:46:41 +02002593 free(taf);
2594 }
2595
2596 list_for_each_entry_safe(tff, tffb, &per_thread_free_list, list) {
Willy Tarreau2b718102021-04-21 07:32:39 +02002597 LIST_DELETE(&tff->list);
Tim Duesterhusf0c25d22020-09-10 19:46:41 +02002598 free(tff);
2599 }
2600
Willy Tarreaucfc4f242021-05-08 11:41:28 +02002601 vars_prune(&proc_vars, NULL, NULL);
Willy Tarreau2455ceb2018-11-26 15:57:34 +01002602 pool_destroy_all();
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +02002603 deinit_pollers();
Willy Tarreaubaaee002006-06-26 02:48:02 +02002604} /* end deinit() */
2605
Willy Tarreauf3ca5a02020-06-15 18:43:46 +02002606__attribute__((noreturn)) void deinit_and_exit(int status)
Tim Duesterhus26540552020-06-14 00:37:41 +02002607{
Amaury Denoyelle890f4be2021-08-09 15:02:56 +02002608 global.mode |= MODE_STOPPING;
Tim Duesterhus26540552020-06-14 00:37:41 +02002609 deinit();
2610 exit(status);
2611}
William Lallemand72160322018-11-06 17:37:16 +01002612
Willy Tarreau918ff602011-07-25 16:33:49 +02002613/* Runs the polling loop */
Willy Tarreau3ebd55e2020-03-03 14:59:56 +01002614void run_poll_loop()
Willy Tarreau4f60f162007-04-08 16:39:58 +02002615{
Willy Tarreau2ae84e42019-05-28 16:44:05 +02002616 int next, wake;
Willy Tarreau4f60f162007-04-08 16:39:58 +02002617
Willy Tarreaub0b37bc2008-06-23 14:00:57 +02002618 tv_update_date(0,1);
Willy Tarreau4f60f162007-04-08 16:39:58 +02002619 while (1) {
Willy Tarreauc49ba522019-12-11 08:12:23 +01002620 wake_expired_tasks();
2621
William Lallemand1aab50b2018-06-07 09:46:01 +02002622 /* check if we caught some signals and process them in the
2623 first thread */
Willy Tarreaua7ad4ae2020-06-19 12:06:34 +02002624 if (signal_queue_len && tid == 0) {
2625 activity[tid].wake_signal++;
William Lallemand1aab50b2018-06-07 09:46:01 +02002626 signal_process_queue();
Willy Tarreaua7ad4ae2020-06-19 12:06:34 +02002627 }
2628
2629 /* Process a few tasks */
2630 process_runnable_tasks();
Willy Tarreau29857942009-05-10 09:01:21 +02002631
Willy Tarreau7067b3a2019-06-02 11:11:29 +02002632 /* also stop if we failed to cleanly stop all tasks */
2633 if (killed > 1)
2634 break;
2635
Matthias Wirth6b933fc2022-09-09 10:21:00 +02002636 /* expire immediately if events or signals are pending */
Willy Tarreau2ae84e42019-05-28 16:44:05 +02002637 wake = 1;
Olivier Houchard305d5ab2019-07-24 18:07:06 +02002638 if (thread_has_tasks())
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01002639 activity[tid].wake_tasks++;
Olivier Houchard79321b92018-07-26 17:55:11 +02002640 else {
Olivier Houchardb23a61f2019-03-08 18:51:17 +01002641 _HA_ATOMIC_OR(&sleeping_thread_mask, tid_bit);
2642 __ha_barrier_atomic_store();
Willy Tarreau95abd5b2020-03-23 09:33:32 +01002643 if (thread_has_tasks()) {
Olivier Houchard79321b92018-07-26 17:55:11 +02002644 activity[tid].wake_tasks++;
Olivier Houchardb23a61f2019-03-08 18:51:17 +01002645 _HA_ATOMIC_AND(&sleeping_thread_mask, ~tid_bit);
Matthias Wirth6b933fc2022-09-09 10:21:00 +02002646 } else if (signal_queue_len) {
2647 /* this check is required to avoid
2648 * a race with wakeup on signals using wake_threads() */
2649 _HA_ATOMIC_AND(&sleeping_thread_mask, ~tid_bit);
Olivier Houchard79321b92018-07-26 17:55:11 +02002650 } else
Willy Tarreau2ae84e42019-05-28 16:44:05 +02002651 wake = 0;
Olivier Houchard79321b92018-07-26 17:55:11 +02002652 }
Willy Tarreau10146c92015-04-13 20:44:19 +02002653
Willy Tarreau4f46a352020-03-23 09:27:28 +01002654 if (!wake) {
Willy Tarreaud7a6b2f2020-05-13 13:51:01 +02002655 int i;
2656
2657 if (stopping) {
Ilya Shipitsin3df59892021-05-10 12:50:00 +05002658 /* stop muxes before acknowledging stopping */
Amaury Denoyelled3a88c12021-05-03 10:47:51 +02002659 if (!(stopping_thread_mask & tid_bit)) {
2660 task_wakeup(mux_stopping_data[tid].task, TASK_WOKEN_OTHER);
2661 wake = 1;
2662 }
2663
Willy Tarreau1db42732021-04-06 11:44:07 +02002664 if (_HA_ATOMIC_OR_FETCH(&stopping_thread_mask, tid_bit) == tid_bit) {
Willy Tarreaud6455742020-05-13 14:30:25 +02002665 /* notify all threads that stopping was just set */
2666 for (i = 0; i < global.nbthread; i++)
Willy Tarreau369a2ef2020-06-29 19:23:19 +02002667 if (((all_threads_mask & ~stopping_thread_mask) >> i) & 1)
Willy Tarreaud6455742020-05-13 14:30:25 +02002668 wake_thread(i);
2669 }
Willy Tarreaud7a6b2f2020-05-13 13:51:01 +02002670 }
Willy Tarreau4f46a352020-03-23 09:27:28 +01002671
2672 /* stop when there's nothing left to do */
2673 if ((jobs - unstoppable_jobs) == 0 &&
Willy Tarreaud7a6b2f2020-05-13 13:51:01 +02002674 (stopping_thread_mask & all_threads_mask) == all_threads_mask) {
2675 /* wake all threads waiting on jobs==0 */
2676 for (i = 0; i < global.nbthread; i++)
2677 if (((all_threads_mask & ~tid_bit) >> i) & 1)
2678 wake_thread(i);
Willy Tarreau4f46a352020-03-23 09:27:28 +01002679 break;
Willy Tarreaud7a6b2f2020-05-13 13:51:01 +02002680 }
Willy Tarreau4f46a352020-03-23 09:27:28 +01002681 }
2682
Willy Tarreauc49ba522019-12-11 08:12:23 +01002683 /* If we have to sleep, measure how long */
2684 next = wake ? TICK_ETERNITY : next_timer_expiry();
2685
Willy Tarreau58b458d2008-06-29 22:40:23 +02002686 /* The poller will ensure it returns around <next> */
Willy Tarreau2ae84e42019-05-28 16:44:05 +02002687 cur_poller.poll(&cur_poller, next, wake);
Emeric Brun64cc49c2017-10-03 14:46:45 +02002688
Willy Tarreaud80cb4e2018-01-20 19:30:13 +01002689 activity[tid].loops++;
Willy Tarreau4f60f162007-04-08 16:39:58 +02002690 }
2691}
2692
Christopher Faulet1d17c102017-08-29 15:38:48 +02002693static void *run_thread_poll_loop(void *data)
2694{
Willy Tarreau082b6282019-05-22 14:42:12 +02002695 struct per_thread_alloc_fct *ptaf;
Christopher Faulet1d17c102017-08-29 15:38:48 +02002696 struct per_thread_init_fct *ptif;
2697 struct per_thread_deinit_fct *ptdf;
Willy Tarreau082b6282019-05-22 14:42:12 +02002698 struct per_thread_free_fct *ptff;
Willy Tarreau34a150c2019-06-11 09:16:41 +02002699 static int init_left = 0;
Willy Tarreauaf613e82020-06-05 08:40:51 +02002700 __decl_thread(static pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER);
2701 __decl_thread(static pthread_cond_t init_cond = PTHREAD_COND_INITIALIZER);
Christopher Faulet1d17c102017-08-29 15:38:48 +02002702
Willy Tarreaub4f7cc32019-05-03 09:27:30 +02002703 ha_set_tid((unsigned long)data);
Willy Tarreaud022e9c2019-09-24 08:25:15 +02002704 sched = &task_per_thread[tid];
Willy Tarreau91e6df02019-05-03 17:21:18 +02002705
Willy Tarreauf6178242019-05-21 19:46:58 +02002706#if (_POSIX_TIMERS > 0) && defined(_POSIX_THREAD_CPUTIME)
Willy Tarreau91e6df02019-05-03 17:21:18 +02002707#ifdef USE_THREAD
Willy Tarreau8323a372019-05-20 18:57:53 +02002708 pthread_getcpuclockid(pthread_self(), &ti->clock_id);
Willy Tarreau624dcbf2019-05-20 20:23:06 +02002709#else
Willy Tarreau8323a372019-05-20 18:57:53 +02002710 ti->clock_id = CLOCK_THREAD_CPUTIME_ID;
Willy Tarreau91e6df02019-05-03 17:21:18 +02002711#endif
Willy Tarreau663fda42019-05-21 15:14:08 +02002712#endif
Willy Tarreau6ec902a2019-06-07 14:41:11 +02002713 /* Now, initialize one thread init at a time. This is better since
2714 * some init code is a bit tricky and may release global resources
2715 * after reallocating them locally. This will also ensure there is
2716 * no race on file descriptors allocation.
2717 */
Willy Tarreau34a150c2019-06-11 09:16:41 +02002718#ifdef USE_THREAD
2719 pthread_mutex_lock(&init_mutex);
2720#endif
2721 /* The first thread must set the number of threads left */
2722 if (!init_left)
2723 init_left = global.nbthread;
2724 init_left--;
Willy Tarreau91e6df02019-05-03 17:21:18 +02002725
Willy Tarreauc4c80fb2021-04-11 15:00:34 +02002726 tv_init_thread_date();
Christopher Faulet1d17c102017-08-29 15:38:48 +02002727
Willy Tarreau082b6282019-05-22 14:42:12 +02002728 /* per-thread alloc calls performed here are not allowed to snoop on
2729 * other threads, so they are free to initialize at their own rhythm
2730 * as long as they act as if they were alone. None of them may rely
2731 * on resources initialized by the other ones.
2732 */
2733 list_for_each_entry(ptaf, &per_thread_alloc_list, list) {
2734 if (!ptaf->fct()) {
2735 ha_alert("failed to allocate resources for thread %u.\n", tid);
2736 exit(1);
2737 }
2738 }
2739
Willy Tarreau3078e9f2019-05-20 10:50:43 +02002740 /* per-thread init calls performed here are not allowed to snoop on
2741 * other threads, so they are free to initialize at their own rhythm
2742 * as long as they act as if they were alone.
2743 */
Christopher Faulet1d17c102017-08-29 15:38:48 +02002744 list_for_each_entry(ptif, &per_thread_init_list, list) {
2745 if (!ptif->fct()) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01002746 ha_alert("failed to initialize thread %u.\n", tid);
Christopher Faulet1d17c102017-08-29 15:38:48 +02002747 exit(1);
2748 }
2749 }
2750
Willy Tarreau71092822019-06-10 09:51:04 +02002751 /* enabling protocols will result in fd_insert() calls to be performed,
2752 * we want all threads to have already allocated their local fd tables
Willy Tarreau34a150c2019-06-11 09:16:41 +02002753 * before doing so, thus only the last thread does it.
Willy Tarreau71092822019-06-10 09:51:04 +02002754 */
Willy Tarreau34a150c2019-06-11 09:16:41 +02002755 if (init_left == 0)
Willy Tarreaue4d7c9d2019-06-10 10:14:52 +02002756 protocol_enable_all();
Willy Tarreau6ec902a2019-06-07 14:41:11 +02002757
Willy Tarreau34a150c2019-06-11 09:16:41 +02002758#ifdef USE_THREAD
2759 pthread_cond_broadcast(&init_cond);
2760 pthread_mutex_unlock(&init_mutex);
2761
2762 /* now wait for other threads to finish starting */
2763 pthread_mutex_lock(&init_mutex);
2764 while (init_left)
2765 pthread_cond_wait(&init_cond, &init_mutex);
2766 pthread_mutex_unlock(&init_mutex);
2767#endif
Willy Tarreau3078e9f2019-05-20 10:50:43 +02002768
Willy Tarreaua45a8b52019-12-06 16:31:45 +01002769#if defined(PR_SET_NO_NEW_PRIVS) && defined(USE_PRCTL)
2770 /* Let's refrain from using setuid executables. This way the impact of
2771 * an eventual vulnerability in a library remains limited. It may
2772 * impact external checks but who cares about them anyway ? In the
2773 * worst case it's possible to disable the option. Obviously we do this
2774 * in workers only. We can't hard-fail on this one as it really is
2775 * implementation dependent though we're interested in feedback, hence
2776 * the warning.
2777 */
2778 if (!(global.tune.options & GTUNE_INSECURE_SETUID) && !master) {
2779 static int warn_fail;
Willy Tarreau18515722021-04-06 11:57:41 +02002780 if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) == -1 && !_HA_ATOMIC_FETCH_ADD(&warn_fail, 1)) {
Willy Tarreaua45a8b52019-12-06 16:31:45 +01002781 ha_warning("Failed to disable setuid, please report to developers with detailed "
2782 "information about your operating system. You can silence this warning "
2783 "by adding 'insecure-setuid-wanted' in the 'global' section.\n");
2784 }
2785 }
2786#endif
2787
Willy Tarreaud96f1122019-12-03 07:07:36 +01002788#if defined(RLIMIT_NPROC)
2789 /* all threads have started, it's now time to prevent any new thread
2790 * or process from starting. Obviously we do this in workers only. We
2791 * can't hard-fail on this one as it really is implementation dependent
2792 * though we're interested in feedback, hence the warning.
2793 */
2794 if (!(global.tune.options & GTUNE_INSECURE_FORK) && !master) {
2795 struct rlimit limit = { .rlim_cur = 0, .rlim_max = 0 };
2796 static int warn_fail;
2797
Willy Tarreau18515722021-04-06 11:57:41 +02002798 if (setrlimit(RLIMIT_NPROC, &limit) == -1 && !_HA_ATOMIC_FETCH_ADD(&warn_fail, 1)) {
Willy Tarreaud96f1122019-12-03 07:07:36 +01002799 ha_warning("Failed to disable forks, please report to developers with detailed "
2800 "information about your operating system. You can silence this warning "
2801 "by adding 'insecure-fork-wanted' in the 'global' section.\n");
2802 }
2803 }
2804#endif
Christopher Faulet1d17c102017-08-29 15:38:48 +02002805 run_poll_loop();
2806
2807 list_for_each_entry(ptdf, &per_thread_deinit_list, list)
2808 ptdf->fct();
2809
Willy Tarreau082b6282019-05-22 14:42:12 +02002810 list_for_each_entry(ptff, &per_thread_free_list, list)
2811 ptff->fct();
2812
Christopher Fauletcd7879a2017-10-27 13:53:47 +02002813#ifdef USE_THREAD
Olivier Houchardb23a61f2019-03-08 18:51:17 +01002814 _HA_ATOMIC_AND(&all_threads_mask, ~tid_bit);
Christopher Fauletcd7879a2017-10-27 13:53:47 +02002815 if (tid > 0)
2816 pthread_exit(NULL);
Christopher Faulet1d17c102017-08-29 15:38:48 +02002817#endif
Christopher Fauletcd7879a2017-10-27 13:53:47 +02002818 return NULL;
2819}
Christopher Faulet1d17c102017-08-29 15:38:48 +02002820
William Dauchyf9af9d72019-11-17 15:47:16 +01002821/* set uid/gid depending on global settings */
2822static void set_identity(const char *program_name)
2823{
2824 if (global.gid) {
2825 if (getgroups(0, NULL) > 0 && setgroups(0, NULL) == -1)
2826 ha_warning("[%s.main()] Failed to drop supplementary groups. Using 'gid'/'group'"
2827 " without 'uid'/'user' is generally useless.\n", program_name);
2828
2829 if (setgid(global.gid) == -1) {
2830 ha_alert("[%s.main()] Cannot set gid %d.\n", program_name, global.gid);
2831 protocol_unbind_all();
2832 exit(1);
2833 }
2834 }
2835
2836 if (global.uid && setuid(global.uid) == -1) {
2837 ha_alert("[%s.main()] Cannot set uid %d.\n", program_name, global.uid);
2838 protocol_unbind_all();
2839 exit(1);
2840 }
2841}
2842
Willy Tarreaubaaee002006-06-26 02:48:02 +02002843int main(int argc, char **argv)
2844{
2845 int err, retry;
2846 struct rlimit limit;
Willy Tarreau269ab312012-09-05 08:02:48 +02002847 int pidfd = -1;
Willy Tarreau08293ed2021-07-14 17:54:01 +02002848 int intovf = (unsigned char)argc + 1; /* let the compiler know it's strictly positive */
2849
Willy Tarreaufa32d202022-07-21 09:55:22 +02002850 /* Catch broken toolchains */
2851 if (sizeof(long) != sizeof(void *) || (intovf + 0x7FFFFFFF >= intovf)) {
2852 const char *msg;
2853
2854 if (sizeof(long) != sizeof(void *))
2855 /* Apparently MingW64 was not made for us and can also break openssl */
2856 msg = "The compiler this program was built with uses unsupported integral type sizes.\n"
2857 "Most likely it follows the unsupported LLP64 model. Never try to link HAProxy\n"
2858 "against libraries built with that compiler either! Please only use a compiler\n"
2859 "producing ILP32 or LP64 programs for both programs and libraries.\n";
2860 else if (intovf + 0x7FFFFFFF >= intovf)
2861 /* Catch forced CFLAGS that miss 2-complement integer overflow */
2862 msg = "The source code was miscompiled by the compiler, which usually indicates that\n"
2863 "some of the CFLAGS needed to work around overzealous compiler optimizations\n"
2864 "were overwritten at build time. Please do not force CFLAGS, and read Makefile\n"
2865 "and INSTALL files to decide on the best way to pass your local build options.\n";
2866 else
2867 msg = "Bug in the compiler bug detection code, please report it to developers!\n";
2868
Willy Tarreau08293ed2021-07-14 17:54:01 +02002869 fprintf(stderr,
2870 "FATAL ERROR: invalid code detected -- cannot go further, please recompile!\n"
Willy Tarreaufa32d202022-07-21 09:55:22 +02002871 "%s"
2872 "\nBuild options :"
Willy Tarreau08293ed2021-07-14 17:54:01 +02002873#ifdef BUILD_TARGET
Willy Tarreaufa32d202022-07-21 09:55:22 +02002874 "\n TARGET = " BUILD_TARGET
Willy Tarreau08293ed2021-07-14 17:54:01 +02002875#endif
2876#ifdef BUILD_CPU
Willy Tarreaufa32d202022-07-21 09:55:22 +02002877 "\n CPU = " BUILD_CPU
Willy Tarreau08293ed2021-07-14 17:54:01 +02002878#endif
2879#ifdef BUILD_CC
Willy Tarreaufa32d202022-07-21 09:55:22 +02002880 "\n CC = " BUILD_CC
Willy Tarreau08293ed2021-07-14 17:54:01 +02002881#endif
2882#ifdef BUILD_CFLAGS
Willy Tarreaufa32d202022-07-21 09:55:22 +02002883 "\n CFLAGS = " BUILD_CFLAGS
Willy Tarreau08293ed2021-07-14 17:54:01 +02002884#endif
2885#ifdef BUILD_OPTIONS
Willy Tarreaufa32d202022-07-21 09:55:22 +02002886 "\n OPTIONS = " BUILD_OPTIONS
Willy Tarreau08293ed2021-07-14 17:54:01 +02002887#endif
2888#ifdef BUILD_DEBUG
Willy Tarreaufa32d202022-07-21 09:55:22 +02002889 "\n DEBUG = " BUILD_DEBUG
Willy Tarreau08293ed2021-07-14 17:54:01 +02002890#endif
Willy Tarreaufa32d202022-07-21 09:55:22 +02002891 "\n\n", msg);
2892
Willy Tarreau08293ed2021-07-14 17:54:01 +02002893 return 1;
2894 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02002895
Olivier Houchard5fa300d2018-02-03 15:15:21 +01002896 setvbuf(stdout, NULL, _IONBF, 0);
Willy Tarreau5794fb02018-11-25 18:43:29 +01002897
Willy Tarreauff9c9142019-02-07 10:39:36 +01002898 /* this can only safely be done here, though it's optimized away by
2899 * the compiler.
2900 */
2901 if (MAX_PROCS < 1 || MAX_PROCS > LONGBITS) {
2902 ha_alert("MAX_PROCS value must be between 1 and %d inclusive; "
2903 "HAProxy was built with value %d, please fix it and rebuild.\n",
2904 LONGBITS, MAX_PROCS);
2905 exit(1);
2906 }
2907
Willy Tarreaubf696402019-03-01 10:09:28 +01002908 /* take a copy of initial limits before we possibly change them */
2909 getrlimit(RLIMIT_NOFILE, &limit);
Willy Tarreau2bd0f812020-10-13 15:36:08 +02002910
2911 if (limit.rlim_max == RLIM_INFINITY)
2912 limit.rlim_max = limit.rlim_cur;
Willy Tarreaubf696402019-03-01 10:09:28 +01002913 rlim_fd_cur_at_boot = limit.rlim_cur;
2914 rlim_fd_max_at_boot = limit.rlim_max;
2915
Willy Tarreau5794fb02018-11-25 18:43:29 +01002916 /* process all initcalls in order of potential dependency */
2917 RUN_INITCALLS(STG_PREPARE);
2918 RUN_INITCALLS(STG_LOCK);
2919 RUN_INITCALLS(STG_ALLOC);
2920 RUN_INITCALLS(STG_POOL);
2921 RUN_INITCALLS(STG_REGISTER);
2922 RUN_INITCALLS(STG_INIT);
2923
Emeric Bruncf20bf12010-10-22 16:06:11 +02002924 init(argc, argv);
Willy Tarreau24f4efa2010-08-27 17:56:48 +02002925 signal_register_fct(SIGQUIT, dump, SIGQUIT);
2926 signal_register_fct(SIGUSR1, sig_soft_stop, SIGUSR1);
2927 signal_register_fct(SIGHUP, sig_dump_state, SIGHUP);
William Lallemand73b85e72017-06-01 17:38:51 +02002928 signal_register_fct(SIGUSR2, NULL, 0);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002929
Willy Tarreaue437c442010-03-17 18:02:46 +01002930 /* Always catch SIGPIPE even on platforms which define MSG_NOSIGNAL.
2931 * Some recent FreeBSD setups report broken pipes, and MSG_NOSIGNAL
2932 * was defined there, so let's stay on the safe side.
Willy Tarreaubaaee002006-06-26 02:48:02 +02002933 */
Willy Tarreau24f4efa2010-08-27 17:56:48 +02002934 signal_register_fct(SIGPIPE, NULL, 0);
Willy Tarreaubaaee002006-06-26 02:48:02 +02002935
Willy Tarreaudc23a922011-02-16 11:10:36 +01002936 /* ulimits */
2937 if (!global.rlimit_nofile)
2938 global.rlimit_nofile = global.maxsock;
2939
2940 if (global.rlimit_nofile) {
Willy Tarreaue5cfdac2019-03-01 10:32:05 +01002941 limit.rlim_cur = global.rlimit_nofile;
2942 limit.rlim_max = MAX(rlim_fd_max_at_boot, limit.rlim_cur);
2943
Willy Tarreaudc23a922011-02-16 11:10:36 +01002944 if (setrlimit(RLIMIT_NOFILE, &limit) == -1) {
Willy Tarreauef635472016-06-21 11:48:18 +02002945 getrlimit(RLIMIT_NOFILE, &limit);
William Dauchy0fec3ab2019-10-27 20:08:11 +01002946 if (global.tune.options & GTUNE_STRICT_LIMITS) {
2947 ha_alert("[%s.main()] Cannot raise FD limit to %d, limit is %d.\n",
2948 argv[0], global.rlimit_nofile, (int)limit.rlim_cur);
Jerome Magnin50f757c2021-01-12 20:19:38 +01002949 exit(1);
William Dauchy0fec3ab2019-10-27 20:08:11 +01002950 }
2951 else {
2952 /* try to set it to the max possible at least */
2953 limit.rlim_cur = limit.rlim_max;
2954 if (setrlimit(RLIMIT_NOFILE, &limit) != -1)
2955 getrlimit(RLIMIT_NOFILE, &limit);
Willy Tarreau164dd0b2016-06-21 11:51:59 +02002956
William Dauchya5194602020-03-28 19:29:58 +01002957 ha_warning("[%s.main()] Cannot raise FD limit to %d, limit is %d.\n",
William Dauchy0fec3ab2019-10-27 20:08:11 +01002958 argv[0], global.rlimit_nofile, (int)limit.rlim_cur);
2959 global.rlimit_nofile = limit.rlim_cur;
2960 }
Willy Tarreaudc23a922011-02-16 11:10:36 +01002961 }
2962 }
2963
2964 if (global.rlimit_memmax) {
2965 limit.rlim_cur = limit.rlim_max =
Willy Tarreau70060452015-12-14 12:46:07 +01002966 global.rlimit_memmax * 1048576ULL;
Willy Tarreaudc23a922011-02-16 11:10:36 +01002967#ifdef RLIMIT_AS
2968 if (setrlimit(RLIMIT_AS, &limit) == -1) {
William Dauchy0fec3ab2019-10-27 20:08:11 +01002969 if (global.tune.options & GTUNE_STRICT_LIMITS) {
2970 ha_alert("[%s.main()] Cannot fix MEM limit to %d megs.\n",
2971 argv[0], global.rlimit_memmax);
Jerome Magnin50f757c2021-01-12 20:19:38 +01002972 exit(1);
William Dauchy0fec3ab2019-10-27 20:08:11 +01002973 }
2974 else
William Dauchya5194602020-03-28 19:29:58 +01002975 ha_warning("[%s.main()] Cannot fix MEM limit to %d megs.\n",
William Dauchy0fec3ab2019-10-27 20:08:11 +01002976 argv[0], global.rlimit_memmax);
Willy Tarreaudc23a922011-02-16 11:10:36 +01002977 }
2978#else
2979 if (setrlimit(RLIMIT_DATA, &limit) == -1) {
William Dauchy0fec3ab2019-10-27 20:08:11 +01002980 if (global.tune.options & GTUNE_STRICT_LIMITS) {
2981 ha_alert("[%s.main()] Cannot fix MEM limit to %d megs.\n",
2982 argv[0], global.rlimit_memmax);
Jerome Magnin50f757c2021-01-12 20:19:38 +01002983 exit(1);
William Dauchy0fec3ab2019-10-27 20:08:11 +01002984 }
2985 else
William Dauchya5194602020-03-28 19:29:58 +01002986 ha_warning("[%s.main()] Cannot fix MEM limit to %d megs.\n",
William Dauchy0fec3ab2019-10-27 20:08:11 +01002987 argv[0], global.rlimit_memmax);
Willy Tarreaudc23a922011-02-16 11:10:36 +01002988 }
2989#endif
2990 }
2991
William Lallemand9993c172022-01-07 18:19:42 +01002992 /* Try to get the listeners FD from the previous process using
2993 * _getsocks on the stat socket, it must never been done in wait mode
2994 * and check mode
2995 */
2996 if (old_unixsocket &&
2997 !(global.mode & (MODE_MWORKER_WAIT|MODE_CHECK))) {
William Lallemand85b0bd92017-06-01 17:38:53 +02002998 if (strcmp("/dev/null", old_unixsocket) != 0) {
Willy Tarreau42961742020-08-28 18:42:45 +02002999 if (sock_get_old_sockets(old_unixsocket) != 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003000 ha_alert("Failed to get the sockets from the old process!\n");
William Lallemand85b0bd92017-06-01 17:38:53 +02003001 if (!(global.mode & MODE_MWORKER))
3002 exit(1);
3003 }
Olivier Houchardf73629d2017-04-05 22:33:04 +02003004 }
3005 }
William Lallemand85b0bd92017-06-01 17:38:53 +02003006 get_cur_unixsocket();
3007
Willy Tarreaubaaee002006-06-26 02:48:02 +02003008 /* We will loop at most 100 times with 10 ms delay each time.
3009 * That's at most 1 second. We only send a signal to old pids
3010 * if we cannot grab at least one port.
3011 */
3012 retry = MAX_START_RETRIES;
3013 err = ERR_NONE;
3014 while (retry >= 0) {
3015 struct timeval w;
Willy Tarreaue91bff22020-09-02 11:11:43 +02003016 err = protocol_bind_all(retry == 0 || nb_oldpids == 0);
Willy Tarreaue13e9252007-12-20 23:05:50 +01003017 /* exit the loop on no error or fatal error */
3018 if ((err & (ERR_RETRYABLE|ERR_FATAL)) != ERR_RETRYABLE)
Willy Tarreaubaaee002006-06-26 02:48:02 +02003019 break;
Willy Tarreaubb545b42010-08-25 12:58:59 +02003020 if (nb_oldpids == 0 || retry == 0)
Willy Tarreaubaaee002006-06-26 02:48:02 +02003021 break;
3022
3023 /* FIXME-20060514: Solaris and OpenBSD do not support shutdown() on
3024 * listening sockets. So on those platforms, it would be wiser to
3025 * simply send SIGUSR1, which will not be undoable.
3026 */
Willy Tarreaubb545b42010-08-25 12:58:59 +02003027 if (tell_old_pids(SIGTTOU) == 0) {
3028 /* no need to wait if we can't contact old pids */
3029 retry = 0;
3030 continue;
3031 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02003032 /* give some time to old processes to stop listening */
3033 w.tv_sec = 0;
3034 w.tv_usec = 10*1000;
3035 select(0, NULL, NULL, NULL, &w);
3036 retry--;
3037 }
3038
Willy Tarreaue91bff22020-09-02 11:11:43 +02003039 /* Note: protocol_bind_all() sends an alert when it fails. */
Willy Tarreau0a3b9d92009-02-04 17:05:23 +01003040 if ((err & ~ERR_WARN) != ERR_NONE) {
Willy Tarreaue91bff22020-09-02 11:11:43 +02003041 ha_alert("[%s.main()] Some protocols failed to start their listeners! Exiting.\n", argv[0]);
Willy Tarreauf68da462009-06-09 14:36:00 +02003042 if (retry != MAX_START_RETRIES && nb_oldpids) {
3043 protocol_unbind_all(); /* cleanup everything we can */
Willy Tarreaubaaee002006-06-26 02:48:02 +02003044 tell_old_pids(SIGTTIN);
Willy Tarreauf68da462009-06-09 14:36:00 +02003045 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02003046 exit(1);
3047 }
3048
William Lallemand944e6192018-11-21 15:48:31 +01003049 if (!(global.mode & MODE_MWORKER_WAIT) && listeners == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003050 ha_alert("[%s.main()] No enabled listener found (check for 'bind' directives) ! Exiting.\n", argv[0]);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003051 /* Note: we don't have to send anything to the old pids because we
3052 * never stopped them. */
3053 exit(1);
3054 }
3055
Willy Tarreaue91bff22020-09-02 11:11:43 +02003056 /* Ok, all listeners should now be bound, close any leftover sockets
Olivier Houchardf73629d2017-04-05 22:33:04 +02003057 * the previous process gave us, we don't need them anymore
3058 */
Willy Tarreau9f775762022-01-28 18:28:18 +01003059 sock_drop_unused_old_sockets();
Willy Tarreaudd815982007-10-16 12:25:14 +02003060
Willy Tarreaubaaee002006-06-26 02:48:02 +02003061 /* prepare pause/play signals */
Willy Tarreau24f4efa2010-08-27 17:56:48 +02003062 signal_register_fct(SIGTTOU, sig_pause, SIGTTOU);
3063 signal_register_fct(SIGTTIN, sig_listen, SIGTTIN);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003064
Willy Tarreaubaaee002006-06-26 02:48:02 +02003065 /* MODE_QUIET can inhibit alerts and warnings below this line */
3066
PiBa-NL149a81a2017-12-25 21:03:31 +01003067 if (getenv("HAPROXY_MWORKER_REEXEC") != NULL) {
3068 /* either stdin/out/err are already closed or should stay as they are. */
3069 if ((global.mode & MODE_DAEMON)) {
3070 /* daemon mode re-executing, stdin/stdout/stderr are already closed so keep quiet */
3071 global.mode &= ~MODE_VERBOSE;
3072 global.mode |= MODE_QUIET; /* ensure that we won't say anything from now */
3073 }
3074 } else {
3075 if ((global.mode & MODE_QUIET) && !(global.mode & MODE_VERBOSE)) {
3076 /* detach from the tty */
William Lallemande1340412017-12-28 16:09:36 +01003077 stdio_quiet(-1);
PiBa-NL149a81a2017-12-25 21:03:31 +01003078 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02003079 }
3080
3081 /* open log & pid files before the chroot */
William Lallemand7af8e1d2022-02-14 09:02:14 +01003082 if ((global.mode & MODE_DAEMON || global.mode & MODE_MWORKER) &&
3083 !(global.mode & MODE_MWORKER_WAIT) && global.pidfile != NULL) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02003084 unlink(global.pidfile);
3085 pidfd = open(global.pidfile, O_CREAT | O_WRONLY | O_TRUNC, 0644);
3086 if (pidfd < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003087 ha_alert("[%s.main()] Cannot create pidfile %s\n", argv[0], global.pidfile);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003088 if (nb_oldpids)
3089 tell_old_pids(SIGTTIN);
Willy Tarreaudd815982007-10-16 12:25:14 +02003090 protocol_unbind_all();
Willy Tarreaubaaee002006-06-26 02:48:02 +02003091 exit(1);
3092 }
Willy Tarreaubaaee002006-06-26 02:48:02 +02003093 }
3094
Willy Tarreaub38651a2007-03-24 17:24:39 +01003095 if ((global.last_checks & LSTCHK_NETADM) && global.uid) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003096 ha_alert("[%s.main()] Some configuration options require full privileges, so global.uid cannot be changed.\n"
3097 "", argv[0]);
Willy Tarreaudd815982007-10-16 12:25:14 +02003098 protocol_unbind_all();
Willy Tarreaub38651a2007-03-24 17:24:39 +01003099 exit(1);
3100 }
3101
Jackie Tapia749f74c2020-07-22 18:59:40 -05003102 /* If the user is not root, we'll still let them try the configuration
3103 * but we inform them that unexpected behaviour may occur.
Willy Tarreau4e30ed72009-02-04 18:02:48 +01003104 */
3105 if ((global.last_checks & LSTCHK_NETADM) && getuid())
Christopher Faulet767a84b2017-11-24 16:50:31 +01003106 ha_warning("[%s.main()] Some options which require full privileges"
3107 " might not work well.\n"
3108 "", argv[0]);
Willy Tarreau4e30ed72009-02-04 18:02:48 +01003109
William Lallemand095ba4c2017-06-01 17:38:50 +02003110 if ((global.mode & (MODE_MWORKER|MODE_DAEMON)) == 0) {
3111
3112 /* chroot if needed */
3113 if (global.chroot != NULL) {
3114 if (chroot(global.chroot) == -1 || chdir("/") == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003115 ha_alert("[%s.main()] Cannot chroot(%s).\n", argv[0], global.chroot);
William Lallemand095ba4c2017-06-01 17:38:50 +02003116 if (nb_oldpids)
3117 tell_old_pids(SIGTTIN);
3118 protocol_unbind_all();
3119 exit(1);
3120 }
Willy Tarreauf223cc02007-10-15 18:57:08 +02003121 }
Willy Tarreauf223cc02007-10-15 18:57:08 +02003122 }
3123
William Lallemand944e6192018-11-21 15:48:31 +01003124 if (nb_oldpids && !(global.mode & MODE_MWORKER_WAIT))
Willy Tarreaubb545b42010-08-25 12:58:59 +02003125 nb_oldpids = tell_old_pids(oldpids_sig);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003126
William Lallemand27edc4b2019-05-07 17:49:33 +02003127 /* send a SIGTERM to workers who have a too high reloads number */
3128 if ((global.mode & MODE_MWORKER) && !(global.mode & MODE_MWORKER_WAIT))
3129 mworker_kill_max_reloads(SIGTERM);
3130
Willy Tarreaubaaee002006-06-26 02:48:02 +02003131 /* Note that any error at this stage will be fatal because we will not
3132 * be able to restart the old pids.
3133 */
3134
William Dauchyf9af9d72019-11-17 15:47:16 +01003135 if ((global.mode & (MODE_MWORKER | MODE_DAEMON)) == 0)
3136 set_identity(argv[0]);
Willy Tarreau636848a2019-04-15 19:38:50 +02003137
Willy Tarreaubaaee002006-06-26 02:48:02 +02003138 /* check ulimits */
3139 limit.rlim_cur = limit.rlim_max = 0;
3140 getrlimit(RLIMIT_NOFILE, &limit);
3141 if (limit.rlim_cur < global.maxsock) {
William Dauchy0fec3ab2019-10-27 20:08:11 +01003142 if (global.tune.options & GTUNE_STRICT_LIMITS) {
3143 ha_alert("[%s.main()] FD limit (%d) too low for maxconn=%d/maxsock=%d. "
3144 "Please raise 'ulimit-n' to %d or more to avoid any trouble.\n",
3145 argv[0], (int)limit.rlim_cur, global.maxconn, global.maxsock,
3146 global.maxsock);
Jerome Magnin50f757c2021-01-12 20:19:38 +01003147 exit(1);
William Dauchy0fec3ab2019-10-27 20:08:11 +01003148 }
3149 else
3150 ha_alert("[%s.main()] FD limit (%d) too low for maxconn=%d/maxsock=%d. "
William Dauchya5194602020-03-28 19:29:58 +01003151 "Please raise 'ulimit-n' to %d or more to avoid any trouble.\n",
William Dauchy0fec3ab2019-10-27 20:08:11 +01003152 argv[0], (int)limit.rlim_cur, global.maxconn, global.maxsock,
3153 global.maxsock);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003154 }
3155
William Lallemand944e6192018-11-21 15:48:31 +01003156 if (global.mode & (MODE_DAEMON | MODE_MWORKER | MODE_MWORKER_WAIT)) {
Willy Tarreau0b9c02c2009-02-04 22:05:05 +01003157 struct proxy *px;
Willy Tarreauf83d3fe2015-05-01 19:13:41 +02003158 struct peers *curpeers;
Willy Tarreaubaaee002006-06-26 02:48:02 +02003159 int ret = 0;
3160 int proc;
William Lallemande1340412017-12-28 16:09:36 +01003161 int devnullfd = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +02003162
William Lallemand095ba4c2017-06-01 17:38:50 +02003163 /*
3164 * if daemon + mworker: must fork here to let a master
3165 * process live in background before forking children
3166 */
William Lallemand73b85e72017-06-01 17:38:51 +02003167
3168 if ((getenv("HAPROXY_MWORKER_REEXEC") == NULL)
3169 && (global.mode & MODE_MWORKER)
3170 && (global.mode & MODE_DAEMON)) {
William Lallemand095ba4c2017-06-01 17:38:50 +02003171 ret = fork();
3172 if (ret < 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003173 ha_alert("[%s.main()] Cannot fork.\n", argv[0]);
William Lallemand095ba4c2017-06-01 17:38:50 +02003174 protocol_unbind_all();
3175 exit(1); /* there has been an error */
William Lallemandbfd8eb52018-07-04 15:31:23 +02003176 } else if (ret > 0) { /* parent leave to daemonize */
William Lallemand095ba4c2017-06-01 17:38:50 +02003177 exit(0);
William Lallemandbfd8eb52018-07-04 15:31:23 +02003178 } else /* change the process group ID in the child (master process) */
3179 setsid();
William Lallemand095ba4c2017-06-01 17:38:50 +02003180 }
William Lallemande20b6a62017-06-01 17:38:55 +02003181
William Lallemande20b6a62017-06-01 17:38:55 +02003182
William Lallemanddeed7802017-11-06 11:00:04 +01003183 /* if in master-worker mode, write the PID of the father */
3184 if (global.mode & MODE_MWORKER) {
3185 char pidstr[100];
Willy Tarreau76a80c72019-06-22 07:41:38 +02003186 snprintf(pidstr, sizeof(pidstr), "%d\n", (int)getpid());
Willy Tarreau46ec48b2018-01-23 19:20:19 +01003187 if (pidfd >= 0)
Willy Tarreau2e8ab6b2020-03-14 11:03:20 +01003188 DISGUISE(write(pidfd, pidstr, strlen(pidstr)));
William Lallemanddeed7802017-11-06 11:00:04 +01003189 }
3190
Willy Tarreaubaaee002006-06-26 02:48:02 +02003191 /* the father launches the required number of processes */
William Lallemand944e6192018-11-21 15:48:31 +01003192 if (!(global.mode & MODE_MWORKER_WAIT)) {
William Lallemand9a1ee7a2019-04-01 11:30:02 +02003193 if (global.mode & MODE_MWORKER)
3194 mworker_ext_launch_all();
William Lallemand944e6192018-11-21 15:48:31 +01003195 for (proc = 0; proc < global.nbproc; proc++) {
3196 ret = fork();
3197 if (ret < 0) {
3198 ha_alert("[%s.main()] Cannot fork.\n", argv[0]);
3199 protocol_unbind_all();
3200 exit(1); /* there has been an error */
3201 }
Willy Tarreau52bf8392020-03-08 00:42:37 +01003202 else if (ret == 0) { /* child breaks here */
Willy Tarreaua9274a12021-07-21 10:17:02 +02003203 /* This one must not be exported, it's internal! */
3204 unsetenv("HAPROXY_MWORKER_REEXEC");
Willy Tarreau52bf8392020-03-08 00:42:37 +01003205 ha_random_jump96(relative_pid);
William Lallemand944e6192018-11-21 15:48:31 +01003206 break;
Willy Tarreau52bf8392020-03-08 00:42:37 +01003207 }
William Lallemand944e6192018-11-21 15:48:31 +01003208 if (pidfd >= 0 && !(global.mode & MODE_MWORKER)) {
3209 char pidstr[100];
3210 snprintf(pidstr, sizeof(pidstr), "%d\n", ret);
Willy Tarreau2e8ab6b2020-03-14 11:03:20 +01003211 DISGUISE(write(pidfd, pidstr, strlen(pidstr)));
William Lallemand944e6192018-11-21 15:48:31 +01003212 }
3213 if (global.mode & MODE_MWORKER) {
3214 struct mworker_proc *child;
William Lallemandce83b4a2018-10-26 14:47:30 +02003215
William Lallemand220567e2018-11-21 18:04:53 +01003216 ha_notice("New worker #%d (%d) forked\n", relative_pid, ret);
William Lallemand944e6192018-11-21 15:48:31 +01003217 /* find the right mworker_proc */
3218 list_for_each_entry(child, &proc_list, list) {
3219 if (child->relative_pid == relative_pid &&
William Lallemand7768c2d2022-07-21 00:52:43 +02003220 child->reloads == 0 && child->options & PROC_O_TYPE_WORKER &&
3221 child->pid == -1) {
William Lallemand944e6192018-11-21 15:48:31 +01003222 child->timestamp = now.tv_sec;
3223 child->pid = ret;
William Lallemand1dc69632019-06-12 19:11:33 +02003224 child->version = strdup(haproxy_version);
William Lallemand944e6192018-11-21 15:48:31 +01003225 break;
3226 }
William Lallemandce83b4a2018-10-26 14:47:30 +02003227 }
3228 }
William Lallemandbc193052018-09-11 10:06:26 +02003229
William Lallemand944e6192018-11-21 15:48:31 +01003230 relative_pid++; /* each child will get a different one */
3231 pid_bit <<= 1;
3232 }
3233 } else {
3234 /* wait mode */
3235 global.nbproc = 1;
3236 proc = 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +02003237 }
Willy Tarreaufc6c0322012-11-16 16:12:27 +01003238
3239#ifdef USE_CPU_AFFINITY
3240 if (proc < global.nbproc && /* child */
Willy Tarreauff9c9142019-02-07 10:39:36 +01003241 proc < MAX_PROCS && /* only the first 32/64 processes may be pinned */
Amaury Denoyellefc6ac532021-04-27 10:46:36 +02003242 ha_cpuset_count(&cpu_map.proc[proc])) { /* only do this if the process has a CPU map */
Olivier Houchard97148f62017-08-16 17:29:11 +02003243
Amaury Denoyelle982fb532021-04-21 18:39:58 +02003244#ifdef __FreeBSD__
Amaury Denoyellefc6ac532021-04-27 10:46:36 +02003245 struct hap_cpuset *set = &cpu_map.proc[proc];
Amaury Denoyelle982fb532021-04-21 18:39:58 +02003246 ret = cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, -1, sizeof(set->cpuset), &set->cpuset);
David Carlier2d0493a2020-12-02 21:14:51 +00003247#elif defined(__linux__) || defined(__DragonFly__)
Amaury Denoyellefc6ac532021-04-27 10:46:36 +02003248 struct hap_cpuset *set = &cpu_map.proc[proc];
Amaury Denoyelle982fb532021-04-21 18:39:58 +02003249 sched_setaffinity(0, sizeof(set->cpuset), &set->cpuset);
Willy Tarreaufc6c0322012-11-16 16:12:27 +01003250#endif
Amaury Denoyelle982fb532021-04-21 18:39:58 +02003251 }
Pieter Baauwcaa6a1b2015-09-17 21:26:40 +02003252#endif
Willy Tarreaubaaee002006-06-26 02:48:02 +02003253 /* close the pidfile both in children and father */
Willy Tarreau269ab312012-09-05 08:02:48 +02003254 if (pidfd >= 0) {
3255 //lseek(pidfd, 0, SEEK_SET); /* debug: emulate eglibc bug */
3256 close(pidfd);
3257 }
Willy Tarreaud137dd32010-08-25 12:49:05 +02003258
3259 /* We won't ever use this anymore */
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003260 ha_free(&global.pidfile);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003261
Willy Tarreauedaff0a2015-05-01 17:01:08 +02003262 if (proc == global.nbproc) {
William Lallemand944e6192018-11-21 15:48:31 +01003263 if (global.mode & (MODE_MWORKER|MODE_MWORKER_WAIT)) {
PiBa-NLbaf6ea42017-11-28 23:26:08 +01003264
3265 if ((!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) &&
3266 (global.mode & MODE_DAEMON)) {
3267 /* detach from the tty, this is required to properly daemonize. */
William Lallemande1340412017-12-28 16:09:36 +01003268 if ((getenv("HAPROXY_MWORKER_REEXEC") == NULL))
3269 stdio_quiet(-1);
3270
PiBa-NLbaf6ea42017-11-28 23:26:08 +01003271 global.mode &= ~MODE_VERBOSE;
3272 global.mode |= MODE_QUIET; /* ensure that we won't say anything from now */
PiBa-NLbaf6ea42017-11-28 23:26:08 +01003273 }
3274
William Lallemandb3f2be32018-09-11 10:06:18 +02003275 mworker_loop();
William Lallemand1499b9b2017-06-07 15:04:47 +02003276 /* should never get there */
3277 exit(EXIT_FAILURE);
Willy Tarreauedaff0a2015-05-01 17:01:08 +02003278 }
William Lallemandcf4e4962017-06-08 19:05:48 +02003279#if defined(USE_OPENSSL) && !defined(OPENSSL_NO_DH)
Grant Zhang872f9c22017-01-21 01:10:18 +00003280 ssl_free_dh();
3281#endif
William Lallemand1499b9b2017-06-07 15:04:47 +02003282 exit(0); /* parent must leave */
Willy Tarreauedaff0a2015-05-01 17:01:08 +02003283 }
3284
William Lallemandcb11fd22017-06-01 17:38:52 +02003285 /* child must never use the atexit function */
3286 atexit_flag = 0;
3287
William Lallemandbc193052018-09-11 10:06:26 +02003288 /* close useless master sockets */
3289 if (global.mode & MODE_MWORKER) {
3290 struct mworker_proc *child, *it;
3291 master = 0;
3292
William Lallemand309dc9a2018-10-26 14:47:45 +02003293 mworker_cli_proxy_stop();
3294
William Lallemandbc193052018-09-11 10:06:26 +02003295 /* free proc struct of other processes */
3296 list_for_each_entry_safe(child, it, &proc_list, list) {
William Lallemandce83b4a2018-10-26 14:47:30 +02003297 /* close the FD of the master side for all
3298 * workers, we don't need to close the worker
3299 * side of other workers since it's done with
3300 * the bind_proc */
Tim Duesterhus742e0f92018-11-25 20:03:39 +01003301 if (child->ipc_fd[0] >= 0)
3302 close(child->ipc_fd[0]);
William Lallemandce83b4a2018-10-26 14:47:30 +02003303 if (child->relative_pid == relative_pid &&
William Lallemand7768c2d2022-07-21 00:52:43 +02003304 child->reloads == 0 &&
3305 child->pid == -1) {
William Lallemandce83b4a2018-10-26 14:47:30 +02003306 /* keep this struct if this is our pid */
3307 proc_self = child;
William Lallemandbc193052018-09-11 10:06:26 +02003308 continue;
William Lallemandce83b4a2018-10-26 14:47:30 +02003309 }
Willy Tarreau2b718102021-04-21 07:32:39 +02003310 LIST_DELETE(&child->list);
Tim Duesterhus9b7a9762019-05-16 20:23:22 +02003311 mworker_free_child(child);
3312 child = NULL;
William Lallemandbc193052018-09-11 10:06:26 +02003313 }
3314 }
Willy Tarreau1605c7a2018-01-23 19:01:49 +01003315
William Lallemande1340412017-12-28 16:09:36 +01003316 if (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) {
3317 devnullfd = open("/dev/null", O_RDWR, 0);
3318 if (devnullfd < 0) {
3319 ha_alert("Cannot open /dev/null\n");
3320 exit(EXIT_FAILURE);
3321 }
3322 }
3323
William Lallemand095ba4c2017-06-01 17:38:50 +02003324 /* Must chroot and setgid/setuid in the children */
3325 /* chroot if needed */
3326 if (global.chroot != NULL) {
3327 if (chroot(global.chroot) == -1 || chdir("/") == -1) {
Willy Tarreau46317372021-06-15 08:59:19 +02003328 ha_alert("[%s.main()] Cannot chroot(%s).\n", argv[0], global.chroot);
William Lallemand095ba4c2017-06-01 17:38:50 +02003329 if (nb_oldpids)
3330 tell_old_pids(SIGTTIN);
3331 protocol_unbind_all();
3332 exit(1);
3333 }
3334 }
3335
Willy Tarreau61cfdf42021-02-20 10:46:51 +01003336 ha_free(&global.chroot);
William Dauchyf9af9d72019-11-17 15:47:16 +01003337 set_identity(argv[0]);
William Lallemand095ba4c2017-06-01 17:38:50 +02003338
William Lallemand7f80eb22017-05-26 18:19:55 +02003339 /* pass through every cli socket, and check if it's bound to
3340 * the current process and if it exposes listeners sockets.
3341 * Caution: the GTUNE_SOCKET_TRANSFER is now set after the fork.
3342 * */
3343
Willy Tarreau4975d142021-03-13 11:00:33 +01003344 if (global.cli_fe) {
William Lallemand7f80eb22017-05-26 18:19:55 +02003345 struct bind_conf *bind_conf;
3346
Willy Tarreau4975d142021-03-13 11:00:33 +01003347 list_for_each_entry(bind_conf, &global.cli_fe->conf.bind, by_fe) {
William Lallemand7f80eb22017-05-26 18:19:55 +02003348 if (bind_conf->level & ACCESS_FD_LISTENERS) {
Willy Tarreaue26993c2020-09-03 07:18:55 +02003349 if (!bind_conf->settings.bind_proc || bind_conf->settings.bind_proc & (1UL << proc)) {
William Lallemand7f80eb22017-05-26 18:19:55 +02003350 global.tune.options |= GTUNE_SOCKET_TRANSFER;
3351 break;
3352 }
3353 }
3354 }
3355 }
3356
Willy Tarreau0b9c02c2009-02-04 22:05:05 +01003357 /* we might have to unbind some proxies from some processes */
Olivier Houchardfbc74e82017-11-24 16:54:05 +01003358 px = proxies_list;
Willy Tarreau0b9c02c2009-02-04 22:05:05 +01003359 while (px != NULL) {
Willy Tarreauc3914d42020-09-24 08:39:22 +02003360 if (px->bind_proc && !px->disabled) {
Willy Tarreau337c8352020-09-24 10:51:29 +02003361 if (!(px->bind_proc & (1UL << proc)))
3362 stop_proxy(px);
Willy Tarreau0b9c02c2009-02-04 22:05:05 +01003363 }
3364 px = px->next;
3365 }
3366
Emeric Brunc47ba592020-10-07 10:13:10 +02003367 /* we might have to unbind some log forward proxies from some processes */
3368 px = cfg_log_forward;
3369 while (px != NULL) {
Willy Tarreauc3914d42020-09-24 08:39:22 +02003370 if (px->bind_proc && !px->disabled) {
Willy Tarreau337c8352020-09-24 10:51:29 +02003371 if (!(px->bind_proc & (1UL << proc)))
3372 stop_proxy(px);
Emeric Brunc47ba592020-10-07 10:13:10 +02003373 }
3374 px = px->next;
3375 }
3376
Willy Tarreauf83d3fe2015-05-01 19:13:41 +02003377 /* we might have to unbind some peers sections from some processes */
Frédéric Lécailleed2b4a62017-07-13 09:07:09 +02003378 for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
Willy Tarreauf83d3fe2015-05-01 19:13:41 +02003379 if (!curpeers->peers_fe)
3380 continue;
3381
3382 if (curpeers->peers_fe->bind_proc & (1UL << proc))
3383 continue;
3384
3385 stop_proxy(curpeers->peers_fe);
3386 /* disable this peer section so that it kills itself */
Willy Tarreau47c8c022015-09-28 16:39:25 +02003387 signal_unregister_handler(curpeers->sighandler);
Olivier Houchard3f795f72019-04-17 22:51:06 +02003388 task_destroy(curpeers->sync_task);
Willy Tarreau47c8c022015-09-28 16:39:25 +02003389 curpeers->sync_task = NULL;
Olivier Houchard3f795f72019-04-17 22:51:06 +02003390 task_destroy(curpeers->peers_fe->task);
Willy Tarreau47c8c022015-09-28 16:39:25 +02003391 curpeers->peers_fe->task = NULL;
Willy Tarreauf83d3fe2015-05-01 19:13:41 +02003392 curpeers->peers_fe = NULL;
3393 }
3394
William Lallemand2e8fad92018-11-13 16:18:23 +01003395 /*
3396 * This is only done in daemon mode because we might want the
3397 * logs on stdout in mworker mode. If we're NOT in QUIET mode,
3398 * we should now close the 3 first FDs to ensure that we can
3399 * detach from the TTY. We MUST NOT do it in other cases since
3400 * it would have already be done, and 0-2 would have been
3401 * affected to listening sockets
Willy Tarreaubaaee002006-06-26 02:48:02 +02003402 */
William Lallemand2e8fad92018-11-13 16:18:23 +01003403 if ((global.mode & MODE_DAEMON) &&
3404 (!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE))) {
Willy Tarreaubaaee002006-06-26 02:48:02 +02003405 /* detach from the tty */
William Lallemande1340412017-12-28 16:09:36 +01003406 stdio_quiet(devnullfd);
Willy Tarreau106cb762008-11-16 07:40:34 +01003407 global.mode &= ~MODE_VERBOSE;
Willy Tarreaubaaee002006-06-26 02:48:02 +02003408 global.mode |= MODE_QUIET; /* ensure that we won't say anything from now */
3409 }
3410 pid = getpid(); /* update child's pid */
William Lallemandbfd8eb52018-07-04 15:31:23 +02003411 if (!(global.mode & MODE_MWORKER)) /* in mworker mode we don't want a new pgid for the children */
3412 setsid();
Willy Tarreau2ff76222007-04-09 19:29:56 +02003413 fork_poller();
Willy Tarreaubaaee002006-06-26 02:48:02 +02003414 }
3415
William Dauchye039f262019-11-17 15:47:15 +01003416 /* try our best to re-enable core dumps depending on system capabilities.
3417 * What is addressed here :
3418 * - remove file size limits
3419 * - remove core size limits
3420 * - mark the process dumpable again if it lost it due to user/group
3421 */
3422 if (global.tune.options & GTUNE_SET_DUMPABLE) {
3423 limit.rlim_cur = limit.rlim_max = RLIM_INFINITY;
3424
3425#if defined(RLIMIT_FSIZE)
3426 if (setrlimit(RLIMIT_FSIZE, &limit) == -1) {
3427 if (global.tune.options & GTUNE_STRICT_LIMITS) {
3428 ha_alert("[%s.main()] Failed to set the raise the maximum "
3429 "file size.\n", argv[0]);
Jerome Magnin50f757c2021-01-12 20:19:38 +01003430 exit(1);
William Dauchye039f262019-11-17 15:47:15 +01003431 }
3432 else
3433 ha_warning("[%s.main()] Failed to set the raise the maximum "
William Dauchya5194602020-03-28 19:29:58 +01003434 "file size.\n", argv[0]);
William Dauchye039f262019-11-17 15:47:15 +01003435 }
3436#endif
3437
3438#if defined(RLIMIT_CORE)
3439 if (setrlimit(RLIMIT_CORE, &limit) == -1) {
3440 if (global.tune.options & GTUNE_STRICT_LIMITS) {
3441 ha_alert("[%s.main()] Failed to set the raise the core "
3442 "dump size.\n", argv[0]);
Jerome Magnin50f757c2021-01-12 20:19:38 +01003443 exit(1);
William Dauchye039f262019-11-17 15:47:15 +01003444 }
3445 else
3446 ha_warning("[%s.main()] Failed to set the raise the core "
William Dauchya5194602020-03-28 19:29:58 +01003447 "dump size.\n", argv[0]);
William Dauchye039f262019-11-17 15:47:15 +01003448 }
3449#endif
3450
3451#if defined(USE_PRCTL)
3452 if (prctl(PR_SET_DUMPABLE, 1, 0, 0, 0) == -1)
3453 ha_warning("[%s.main()] Failed to set the dumpable flag, "
3454 "no core will be dumped.\n", argv[0]);
devnexen@gmail.com078062b2021-08-21 09:13:10 +01003455#elif defined(USE_PROCCTL)
3456 int traceable = PROC_TRACE_CTL_ENABLE;
3457 if (procctl(P_PID, getpid(), PROC_TRACE_CTL, &traceable) == -1)
3458 ha_warning("[%s.main()] Failed to set the traceable flag, "
3459 "no core will be dumped.\n", argv[0]);
William Dauchye039f262019-11-17 15:47:15 +01003460#endif
3461 }
3462
Christopher Faulete3a5e352017-10-24 13:53:54 +02003463 global.mode &= ~MODE_STARTING;
Willy Tarreau4f60f162007-04-08 16:39:58 +02003464 /*
3465 * That's it : the central polling loop. Run until we stop.
3466 */
Christopher Faulet1d17c102017-08-29 15:38:48 +02003467#ifdef USE_THREAD
Christopher Fauletcd7879a2017-10-27 13:53:47 +02003468 {
William Lallemand1aab50b2018-06-07 09:46:01 +02003469 sigset_t blocked_sig, old_sig;
Willy Tarreauc40efc12019-05-03 09:22:44 +02003470 int i;
3471
William Lallemand1aab50b2018-06-07 09:46:01 +02003472 /* ensure the signals will be blocked in every thread */
3473 sigfillset(&blocked_sig);
3474 sigdelset(&blocked_sig, SIGPROF);
3475 sigdelset(&blocked_sig, SIGBUS);
3476 sigdelset(&blocked_sig, SIGFPE);
3477 sigdelset(&blocked_sig, SIGILL);
3478 sigdelset(&blocked_sig, SIGSEGV);
3479 pthread_sigmask(SIG_SETMASK, &blocked_sig, &old_sig);
3480
Christopher Fauletcd7879a2017-10-27 13:53:47 +02003481 /* Create nbthread-1 thread. The first thread is the current process */
David Carliera92c5ce2019-09-13 05:03:12 +01003482 ha_thread_info[0].pthread = pthread_self();
Christopher Fauletcd7879a2017-10-27 13:53:47 +02003483 for (i = 1; i < global.nbthread; i++)
David Carliera92c5ce2019-09-13 05:03:12 +01003484 pthread_create(&ha_thread_info[i].pthread, NULL, &run_thread_poll_loop, (void *)(long)i);
Christopher Fauletcd7879a2017-10-27 13:53:47 +02003485
Christopher Faulet62519022017-10-16 15:49:32 +02003486#ifdef USE_CPU_AFFINITY
Christopher Fauletcd7879a2017-10-27 13:53:47 +02003487 /* Now the CPU affinity for all threads */
Amaury Denoyelleaf02c572021-04-15 16:29:58 +02003488
3489 /* If on multiprocess, use proc_t1 except for the first process.
3490 */
3491 if ((relative_pid - 1) > 0)
Amaury Denoyellefc6ac532021-04-27 10:46:36 +02003492 cpu_map.thread[0] = cpu_map.proc_t1[relative_pid-1];
Willy Tarreau7764a572019-07-16 15:10:34 +02003493
Christopher Fauletcd7879a2017-10-27 13:53:47 +02003494 for (i = 0; i < global.nbthread; i++) {
Amaury Denoyellefc6ac532021-04-27 10:46:36 +02003495 if (ha_cpuset_count(&cpu_map.proc[relative_pid-1]))
3496 ha_cpuset_and(&cpu_map.thread[i], &cpu_map.proc[relative_pid-1]);
Christopher Faulet62519022017-10-16 15:49:32 +02003497
Willy Tarreau421f02e2018-01-20 18:19:22 +01003498 if (i < MAX_THREADS && /* only the first 32/64 threads may be pinned */
Amaury Denoyellefc6ac532021-04-27 10:46:36 +02003499 ha_cpuset_count(&cpu_map.thread[i])) {/* only do this if the thread has a THREAD map */
David Carlier5e4c8e22019-09-13 05:12:58 +01003500#if defined(__APPLE__)
3501 int j;
Amaury Denoyelle8f685c12021-04-27 16:45:29 +02003502 unsigned long set = cpu_map.thread[i].cpuset;
David Carlier5e4c8e22019-09-13 05:12:58 +01003503
Amaury Denoyelle8f685c12021-04-27 16:45:29 +02003504 while ((j = ffsl(set)) > 0) {
David Carlier5e4c8e22019-09-13 05:12:58 +01003505 thread_affinity_policy_data_t cpu_set = { j - 1 };
3506 thread_port_t mthread = pthread_mach_thread_np(ha_thread_info[i].pthread);
3507 thread_policy_set(mthread, THREAD_AFFINITY_POLICY, (thread_policy_t)&cpu_set, 1);
Amaury Denoyelle8f685c12021-04-27 16:45:29 +02003508 set &= ~(1UL << (j - 1));
David Carlier5e4c8e22019-09-13 05:12:58 +01003509 }
3510#else
Amaury Denoyellefc6ac532021-04-27 10:46:36 +02003511 struct hap_cpuset *set = &cpu_map.thread[i];
David Carliera92c5ce2019-09-13 05:03:12 +01003512 pthread_setaffinity_np(ha_thread_info[i].pthread,
Amaury Denoyelle982fb532021-04-21 18:39:58 +02003513 sizeof(set->cpuset), &set->cpuset);
David Carlier5e4c8e22019-09-13 05:12:58 +01003514#endif
Olivier Houchard829aa242017-12-01 18:19:43 +01003515 }
Christopher Faulet1d17c102017-08-29 15:38:48 +02003516 }
Christopher Fauletcd7879a2017-10-27 13:53:47 +02003517#endif /* !USE_CPU_AFFINITY */
3518
William Lallemand1aab50b2018-06-07 09:46:01 +02003519 /* when multithreading we need to let only the thread 0 handle the signals */
William Lallemandd3801c12018-09-11 10:06:23 +02003520 haproxy_unblock_signals();
William Lallemand1aab50b2018-06-07 09:46:01 +02003521
Christopher Fauletcd7879a2017-10-27 13:53:47 +02003522 /* Finally, start the poll loop for the first thread */
Willy Tarreaub4f7cc32019-05-03 09:27:30 +02003523 run_thread_poll_loop(0);
Christopher Fauletcd7879a2017-10-27 13:53:47 +02003524
3525 /* Wait the end of other threads */
3526 for (i = 1; i < global.nbthread; i++)
David Carliera92c5ce2019-09-13 05:03:12 +01003527 pthread_join(ha_thread_info[i].pthread, NULL);
Christopher Faulet1d17c102017-08-29 15:38:48 +02003528
Christopher Fauletb79a94c2017-05-30 15:34:30 +02003529#if defined(DEBUG_THREAD) || defined(DEBUG_FULL)
3530 show_lock_stats();
3531#endif
Christopher Faulet1d17c102017-08-29 15:38:48 +02003532 }
Christopher Fauletcd7879a2017-10-27 13:53:47 +02003533#else /* ! USE_THREAD */
William Lallemandd3801c12018-09-11 10:06:23 +02003534 haproxy_unblock_signals();
Willy Tarreaub4f7cc32019-05-03 09:27:30 +02003535 run_thread_poll_loop(0);
Christopher Faulet62519022017-10-16 15:49:32 +02003536#endif
Christopher Faulet1d17c102017-08-29 15:38:48 +02003537
Tim Duesterhus0a3b43d2020-06-14 00:37:42 +02003538 deinit_and_exit(0);
Willy Tarreaubaaee002006-06-26 02:48:02 +02003539}
3540
Willy Tarreaubaaee002006-06-26 02:48:02 +02003541/*
3542 * Local variables:
3543 * c-indent-level: 8
3544 * c-basic-offset: 8
3545 * End:
3546 */