blob: 7a8feda980cc051c559b477af79ddeb615e82e8f [file] [log] [blame]
William Lallemand48dfbbd2019-04-01 11:29:53 +02001/*
2 * Master Worker
3 *
4 * Copyright HAProxy Technologies 2019 - William Lallemand <wlallemand@haproxy.com>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Bertrand Jacquin25439de2021-01-21 01:31:46 +000013#define _GNU_SOURCE
14
William Lallemand3fa724d2019-04-01 11:29:55 +020015#include <errno.h>
16#include <fcntl.h>
17#include <signal.h>
William Lallemand48dfbbd2019-04-01 11:29:53 +020018#include <stdlib.h>
19#include <string.h>
William Lallemande25473c2019-04-01 11:29:56 +020020#include <sys/wait.h>
William Lallemand48dfbbd2019-04-01 11:29:53 +020021
Willy Tarreaub2551052020-06-09 09:07:15 +020022#if defined(USE_SYSTEMD)
23#include <systemd/sd-daemon.h>
24#endif
25
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020026#include <haproxy/api.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020027#include <haproxy/cfgparse.h>
Willy Tarreau83487a82020-06-04 20:19:54 +020028#include <haproxy/cli.h>
Willy Tarreau36979d92020-06-05 17:27:29 +020029#include <haproxy/errors.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020030#include <haproxy/fd.h>
31#include <haproxy/global.h>
Willy Tarreau853b2972020-05-27 18:01:47 +020032#include <haproxy/list.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020033#include <haproxy/listener.h>
Willy Tarreaub5abe5b2020-06-04 14:07:37 +020034#include <haproxy/mworker.h>
Willy Tarreau3c2a7c22020-06-04 18:38:21 +020035#include <haproxy/peers.h>
Willy Tarreau7c668572021-05-08 20:21:31 +020036#include <haproxy/proxy.h>
Willy Tarreau3727a8a2020-06-04 17:37:26 +020037#include <haproxy/signal.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020038#include <haproxy/stream.h>
Willy Tarreau5e539c92020-06-04 20:45:39 +020039#include <haproxy/stream_interface.h>
Willy Tarreau745e98c2021-05-08 13:58:19 +020040#include <haproxy/tools.h>
Willy Tarreaud6788052020-05-27 15:59:00 +020041#include <haproxy/version.h>
William Lallemand48dfbbd2019-04-01 11:29:53 +020042
William Lallemand48dfbbd2019-04-01 11:29:53 +020043
William Lallemande25473c2019-04-01 11:29:56 +020044static int exitcode = -1;
William Lallemand27edc4b2019-05-07 17:49:33 +020045static int max_reloads = -1; /* number max of reloads a worker can have until they are killed */
Willy Tarreau15f9ac32021-05-08 12:30:50 +020046struct mworker_proc *proc_self = NULL; /* process structure of current process */
William Lallemande25473c2019-04-01 11:29:56 +020047
William Lallemande25473c2019-04-01 11:29:56 +020048/* ----- children processes handling ----- */
William Lallemand48dfbbd2019-04-01 11:29:53 +020049
William Lallemand48dfbbd2019-04-01 11:29:53 +020050/*
William Lallemande25473c2019-04-01 11:29:56 +020051 * Send signal to every known children.
52 */
53
54static void mworker_kill(int sig)
55{
William Lallemand3f128872019-04-01 11:29:59 +020056 struct mworker_proc *child;
William Lallemande25473c2019-04-01 11:29:56 +020057
William Lallemand3f128872019-04-01 11:29:59 +020058 list_for_each_entry(child, &proc_list, list) {
59 /* careful there, we must be sure that the pid > 0, we don't want to emit a kill -1 */
William Lallemand32b69012019-04-16 17:42:42 +020060 if ((child->options & (PROC_O_TYPE_WORKER|PROC_O_TYPE_PROG)) && (child->pid > 0))
William Lallemand3f128872019-04-01 11:29:59 +020061 kill(child->pid, sig);
William Lallemande25473c2019-04-01 11:29:56 +020062 }
63}
64
William Lallemand27edc4b2019-05-07 17:49:33 +020065void mworker_kill_max_reloads(int sig)
66{
67 struct mworker_proc *child;
68
69 list_for_each_entry(child, &proc_list, list) {
70 if (max_reloads != -1 && (child->options & PROC_O_TYPE_WORKER) &&
71 (child->pid > 0) && (child->reloads > max_reloads))
72 kill(child->pid, sig);
73 }
74}
William Lallemande25473c2019-04-01 11:29:56 +020075
76/* return 1 if a pid is a current child otherwise 0 */
William Lallemand3f128872019-04-01 11:29:59 +020077int mworker_current_child(int pid)
William Lallemande25473c2019-04-01 11:29:56 +020078{
William Lallemand3f128872019-04-01 11:29:59 +020079 struct mworker_proc *child;
William Lallemande25473c2019-04-01 11:29:56 +020080
William Lallemand3f128872019-04-01 11:29:59 +020081 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +020082 if ((child->options & (PROC_O_TYPE_WORKER|PROC_O_TYPE_PROG)) && (!(child->options & PROC_O_LEAVING)) && (child->pid == pid))
William Lallemande25473c2019-04-01 11:29:56 +020083 return 1;
84 }
85 return 0;
86}
87
William Lallemand3f128872019-04-01 11:29:59 +020088/*
89 * Return the number of new and old children (including workers and external
90 * processes)
91 */
92int mworker_child_nb()
93{
94 struct mworker_proc *child;
95 int ret = 0;
96
97 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +020098 if (child->options & (PROC_O_TYPE_WORKER|PROC_O_TYPE_PROG))
William Lallemand3f128872019-04-01 11:29:59 +020099 ret++;
100 }
101
102 return ret;
103}
104
105
William Lallemande25473c2019-04-01 11:29:56 +0200106/*
William Lallemand48dfbbd2019-04-01 11:29:53 +0200107 * serialize the proc list and put it in the environment
108 */
109void mworker_proc_list_to_env()
110{
111 char *msg = NULL;
112 struct mworker_proc *child;
113
114 list_for_each_entry(child, &proc_list, list) {
William Lallemand8f7069a2019-04-12 16:09:23 +0200115 char type = '?';
116
117 if (child->options & PROC_O_TYPE_MASTER)
118 type = 'm';
119 else if (child->options & PROC_O_TYPE_PROG)
120 type = 'e';
121 else if (child->options &= PROC_O_TYPE_WORKER)
122 type = 'w';
123
William Lallemand48dfbbd2019-04-01 11:29:53 +0200124 if (child->pid > -1)
William Lallemand1dc69632019-06-12 19:11:33 +0200125 memprintf(&msg, "%s|type=%c;fd=%d;pid=%d;rpid=%d;reloads=%d;timestamp=%d;id=%s;version=%s", msg ? msg : "", type, child->ipc_fd[0], child->pid, child->relative_pid, child->reloads, child->timestamp, child->id ? child->id : "", child->version);
William Lallemand48dfbbd2019-04-01 11:29:53 +0200126 }
127 if (msg)
128 setenv("HAPROXY_PROCESSES", msg, 1);
129}
130
131/*
132 * unserialize the proc list from the environment
133 */
Remi Tricot-Le Bretond90aa342021-05-19 10:45:12 +0200134int mworker_env_to_proc_list()
William Lallemand48dfbbd2019-04-01 11:29:53 +0200135{
136 char *msg, *token = NULL, *s1;
137
138 msg = getenv("HAPROXY_PROCESSES");
139 if (!msg)
Remi Tricot-Le Bretond90aa342021-05-19 10:45:12 +0200140 return 0;
William Lallemand48dfbbd2019-04-01 11:29:53 +0200141
142 while ((token = strtok_r(msg, "|", &s1))) {
143 struct mworker_proc *child;
144 char *subtoken = NULL;
145 char *s2;
146
147 msg = NULL;
148
149 child = calloc(1, sizeof(*child));
Remi Tricot-Le Bretond90aa342021-05-19 10:45:12 +0200150 if (!child) {
151 ha_alert("Out of memory while trying to allocate a worker process structure.");
152 return -1;
153 }
William Lallemand48dfbbd2019-04-01 11:29:53 +0200154
155 while ((subtoken = strtok_r(token, ";", &s2))) {
156
157 token = NULL;
158
159 if (strncmp(subtoken, "type=", 5) == 0) {
William Lallemand8f7069a2019-04-12 16:09:23 +0200160 char type;
161
162 type = *(subtoken+5);
163 if (type == 'm') { /* we are in the master, assign it */
William Lallemand48dfbbd2019-04-01 11:29:53 +0200164 proc_self = child;
William Lallemand8f7069a2019-04-12 16:09:23 +0200165 child->options |= PROC_O_TYPE_MASTER;
166 } else if (type == 'e') {
167 child->options |= PROC_O_TYPE_PROG;
168 } else if (type == 'w') {
169 child->options |= PROC_O_TYPE_WORKER;
170 }
171
William Lallemand48dfbbd2019-04-01 11:29:53 +0200172 } else if (strncmp(subtoken, "fd=", 3) == 0) {
173 child->ipc_fd[0] = atoi(subtoken+3);
174 } else if (strncmp(subtoken, "pid=", 4) == 0) {
175 child->pid = atoi(subtoken+4);
176 } else if (strncmp(subtoken, "rpid=", 5) == 0) {
177 child->relative_pid = atoi(subtoken+5);
178 } else if (strncmp(subtoken, "reloads=", 8) == 0) {
179 /* we reloaded this process once more */
180 child->reloads = atoi(subtoken+8) + 1;
181 } else if (strncmp(subtoken, "timestamp=", 10) == 0) {
182 child->timestamp = atoi(subtoken+10);
William Lallemand9a1ee7a2019-04-01 11:30:02 +0200183 } else if (strncmp(subtoken, "id=", 3) == 0) {
184 child->id = strdup(subtoken+3);
William Lallemand1dc69632019-06-12 19:11:33 +0200185 } else if (strncmp(subtoken, "version=", 8) == 0) {
186 child->version = strdup(subtoken+8);
William Lallemand48dfbbd2019-04-01 11:29:53 +0200187 }
188 }
William Lallemand9a1ee7a2019-04-01 11:30:02 +0200189 if (child->pid) {
William Lallemand920fc8b2019-05-14 11:15:18 +0200190 /* this is a process inherited from a reload that should be leaving */
191 child->options |= PROC_O_LEAVING;
192
Willy Tarreau2b718102021-04-21 07:32:39 +0200193 LIST_APPEND(&proc_list, &child->list);
William Lallemand9a1ee7a2019-04-01 11:30:02 +0200194 } else {
Tim Duesterhus9b7a9762019-05-16 20:23:22 +0200195 mworker_free_child(child);
William Lallemand9a1ee7a2019-04-01 11:30:02 +0200196 }
William Lallemand48dfbbd2019-04-01 11:29:53 +0200197 }
198
199 unsetenv("HAPROXY_PROCESSES");
Remi Tricot-Le Bretond90aa342021-05-19 10:45:12 +0200200
201 return 0;
William Lallemand48dfbbd2019-04-01 11:29:53 +0200202}
William Lallemand3cd95d22019-04-01 11:29:54 +0200203
204/* Signal blocking and unblocking */
205
206void mworker_block_signals()
207{
208 sigset_t set;
209
210 sigemptyset(&set);
211 sigaddset(&set, SIGUSR1);
212 sigaddset(&set, SIGUSR2);
Willy Tarreaud26c9f92019-12-11 14:24:07 +0100213 sigaddset(&set, SIGTTIN);
214 sigaddset(&set, SIGTTOU);
William Lallemand3cd95d22019-04-01 11:29:54 +0200215 sigaddset(&set, SIGHUP);
216 sigaddset(&set, SIGCHLD);
217 ha_sigmask(SIG_SETMASK, &set, NULL);
218}
219
220void mworker_unblock_signals()
221{
222 haproxy_unblock_signals();
223}
William Lallemand3fa724d2019-04-01 11:29:55 +0200224
William Lallemande25473c2019-04-01 11:29:56 +0200225/* ----- mworker signal handlers ----- */
226
Willy Tarreaud26c9f92019-12-11 14:24:07 +0100227/* broadcast the configured signal to the workers */
228void mworker_broadcast_signal(struct sig_handler *sh)
229{
230 mworker_kill(sh->arg);
231}
232
William Lallemande25473c2019-04-01 11:29:56 +0200233/*
234 * When called, this function reexec haproxy with -sf followed by current
235 * children PIDs and possibly old children PIDs if they didn't leave yet.
236 */
237void mworker_catch_sighup(struct sig_handler *sh)
238{
239 mworker_reload();
240}
241
242void mworker_catch_sigterm(struct sig_handler *sh)
243{
244 int sig = sh->arg;
245
246#if defined(USE_SYSTEMD)
247 if (global.tune.options & GTUNE_USE_SYSTEMD) {
248 sd_notify(0, "STOPPING=1");
249 }
250#endif
251 ha_warning("Exiting Master process...\n");
252 mworker_kill(sig);
253}
254
255/*
256 * Wait for every children to exit
257 */
258
259void mworker_catch_sigchld(struct sig_handler *sh)
260{
261 int exitpid = -1;
262 int status = 0;
William Lallemande25473c2019-04-01 11:29:56 +0200263 int childfound;
264
265restart_wait:
266
267 childfound = 0;
268
269 exitpid = waitpid(-1, &status, WNOHANG);
270 if (exitpid > 0) {
Tim Duesterhus9b7a9762019-05-16 20:23:22 +0200271 struct mworker_proc *child, *it;
272
William Lallemande25473c2019-04-01 11:29:56 +0200273 if (WIFEXITED(status))
274 status = WEXITSTATUS(status);
275 else if (WIFSIGNALED(status))
276 status = 128 + WTERMSIG(status);
277 else if (WIFSTOPPED(status))
278 status = 128 + WSTOPSIG(status);
279 else
280 status = 255;
281
William Lallemand3f128872019-04-01 11:29:59 +0200282 /* delete the child from the process list */
William Lallemande25473c2019-04-01 11:29:56 +0200283 list_for_each_entry_safe(child, it, &proc_list, list) {
284 if (child->pid != exitpid)
285 continue;
286
Willy Tarreau2b718102021-04-21 07:32:39 +0200287 LIST_DELETE(&child->list);
William Lallemande25473c2019-04-01 11:29:56 +0200288 close(child->ipc_fd[0]);
289 childfound = 1;
290 break;
291 }
292
William Lallemand3f128872019-04-01 11:29:59 +0200293 if (!childfound) {
294 /* We didn't find the PID in the list, that shouldn't happen but we can emit a warning */
William Lallemand9a1ee7a2019-04-01 11:30:02 +0200295 ha_warning("Process %d exited with code %d (%s)\n", exitpid, status, (status >= 128) ? strsignal(status - 128) : "Exit");
William Lallemande25473c2019-04-01 11:29:56 +0200296 } else {
William Lallemand9a1ee7a2019-04-01 11:30:02 +0200297 /* check if exited child is a current child */
William Lallemand45286112019-04-12 16:09:21 +0200298 if (!(child->options & PROC_O_LEAVING)) {
William Lallemanda655ba42020-05-06 17:27:03 +0200299 if (child->options & PROC_O_TYPE_WORKER) {
300 if (status < 128)
301 ha_warning("Current worker #%d (%d) exited with code %d (%s)\n", child->relative_pid, exitpid, status, "Exit");
302 else
303 ha_alert("Current worker #%d (%d) exited with code %d (%s)\n", child->relative_pid, exitpid, status, strsignal(status - 128));
304 }
William Lallemand8f7069a2019-04-12 16:09:23 +0200305 else if (child->options & PROC_O_TYPE_PROG)
William Lallemand9a1ee7a2019-04-01 11:30:02 +0200306 ha_alert("Current program '%s' (%d) exited with code %d (%s)\n", child->id, exitpid, status, (status >= 128) ? strsignal(status - 128) : "Exit");
William Lallemand3f128872019-04-01 11:29:59 +0200307
William Lallemande25473c2019-04-01 11:29:56 +0200308 if (status != 0 && status != 130 && status != 143
309 && !(global.tune.options & GTUNE_NOEXIT_ONFAILURE)) {
William Lallemand9a1ee7a2019-04-01 11:30:02 +0200310 ha_alert("exit-on-failure: killing every processes with SIGTERM\n");
William Lallemande25473c2019-04-01 11:29:56 +0200311 mworker_kill(SIGTERM);
312 }
William Lallemand74f0ec32019-04-16 17:42:44 +0200313 /* 0 & SIGTERM (143) are normal, but we should report SIGINT (130) and other signals */
314 if (exitcode < 0 && status != 0 && status != 143)
315 exitcode = status;
William Lallemande25473c2019-04-01 11:29:56 +0200316 } else {
William Lallemand8f7069a2019-04-12 16:09:23 +0200317 if (child->options & PROC_O_TYPE_WORKER) {
William Lallemand3f128872019-04-01 11:29:59 +0200318 ha_warning("Former worker #%d (%d) exited with code %d (%s)\n", child->relative_pid, exitpid, status, (status >= 128) ? strsignal(status - 128) : "Exit");
319 delete_oldpid(exitpid);
William Lallemand8f7069a2019-04-12 16:09:23 +0200320 } else if (child->options & PROC_O_TYPE_PROG) {
William Lallemand9a1ee7a2019-04-01 11:30:02 +0200321 ha_warning("Former program '%s' (%d) exited with code %d (%s)\n", child->id, exitpid, status, (status >= 128) ? strsignal(status - 128) : "Exit");
William Lallemand3f128872019-04-01 11:29:59 +0200322 }
William Lallemande25473c2019-04-01 11:29:56 +0200323 }
Tim Duesterhus9b7a9762019-05-16 20:23:22 +0200324 mworker_free_child(child);
325 child = NULL;
William Lallemande25473c2019-04-01 11:29:56 +0200326 }
327
328 /* do it again to check if it was the last worker */
329 goto restart_wait;
330 }
331 /* Better rely on the system than on a list of process to check if it was the last one */
332 else if (exitpid == -1 && errno == ECHILD) {
William Lallemand4cf4b332019-04-16 17:42:43 +0200333 ha_warning("All workers exited. Exiting... (%d)\n", (exitcode > 0) ? exitcode : EXIT_SUCCESS);
William Lallemande25473c2019-04-01 11:29:56 +0200334 atexit_flag = 0;
335 if (exitcode > 0)
William Lallemand4cf4b332019-04-16 17:42:43 +0200336 exit(exitcode); /* parent must leave using the status code that provoked the exit */
337 exit(EXIT_SUCCESS);
William Lallemande25473c2019-04-01 11:29:56 +0200338 }
339
340}
341
William Lallemand3fa724d2019-04-01 11:29:55 +0200342/* ----- IPC FD (sockpair) related ----- */
343
344/* This wrapper is called from the workers. It is registered instead of the
345 * normal listener_accept() so the worker can exit() when it detects that the
346 * master closed the IPC FD. If it's not a close, we just call the regular
Willy Tarreaua74cb382020-10-15 21:29:49 +0200347 * listener_accept() function.
348 */
William Lallemand3fa724d2019-04-01 11:29:55 +0200349void mworker_accept_wrapper(int fd)
350{
351 char c;
352 int ret;
353
354 while (1) {
355 ret = recv(fd, &c, 1, MSG_PEEK);
356 if (ret == -1) {
357 if (errno == EINTR)
358 continue;
359 if (errno == EAGAIN) {
360 fd_cant_recv(fd);
361 return;
362 }
363 break;
364 } else if (ret > 0) {
Willy Tarreaua74cb382020-10-15 21:29:49 +0200365 struct listener *l = fdtab[fd].owner;
366
367 if (l)
368 listener_accept(l);
William Lallemand3fa724d2019-04-01 11:29:55 +0200369 return;
370 } else if (ret == 0) {
371 /* At this step the master is down before
372 * this worker perform a 'normal' exit.
373 * So we want to exit with an error but
374 * other threads could currently process
375 * some stuff so we can't perform a clean
376 * deinit().
377 */
378 exit(EXIT_FAILURE);
379 }
380 }
381 return;
382}
383
384/*
Willy Tarreau619a95f2019-05-20 11:12:15 +0200385 * This function registers the accept wrapper for the sockpair of the master
386 * worker. It's only handled by worker thread #0. Other threads and master do
387 * nothing here. It always returns 1 (success).
William Lallemand3fa724d2019-04-01 11:29:55 +0200388 */
Willy Tarreau619a95f2019-05-20 11:12:15 +0200389static int mworker_pipe_register_per_thread()
William Lallemand3fa724d2019-04-01 11:29:55 +0200390{
Willy Tarreau619a95f2019-05-20 11:12:15 +0200391 if (!(global.mode & MODE_MWORKER) || master)
392 return 1;
393
394 if (tid != 0)
395 return 1;
William Lallemand3fa724d2019-04-01 11:29:55 +0200396
397 fcntl(proc_self->ipc_fd[1], F_SETFL, O_NONBLOCK);
398 /* In multi-tread, we need only one thread to process
399 * events on the pipe with master
400 */
Willy Tarreau619a95f2019-05-20 11:12:15 +0200401 fd_insert(proc_self->ipc_fd[1], fdtab[proc_self->ipc_fd[1]].owner, mworker_accept_wrapper, tid_bit);
William Lallemand3fa724d2019-04-01 11:29:55 +0200402 fd_want_recv(proc_self->ipc_fd[1]);
Willy Tarreau619a95f2019-05-20 11:12:15 +0200403 return 1;
William Lallemand3fa724d2019-04-01 11:29:55 +0200404}
William Lallemand9001ce82019-04-01 11:29:57 +0200405
Willy Tarreau619a95f2019-05-20 11:12:15 +0200406REGISTER_PER_THREAD_INIT(mworker_pipe_register_per_thread);
407
William Lallemand9001ce82019-04-01 11:29:57 +0200408/* ----- proxies ----- */
409/*
410 * Upon a reload, the master worker needs to close all listeners FDs but the mworker_pipe
411 * fd, and the FD provided by fd@
412 */
413void mworker_cleanlisteners()
414{
415 struct listener *l, *l_next;
416 struct proxy *curproxy;
417 struct peers *curpeers;
418
419 /* we might have to unbind some peers sections from some processes */
420 for (curpeers = cfg_peers; curpeers; curpeers = curpeers->next) {
421 if (!curpeers->peers_fe)
422 continue;
423
424 stop_proxy(curpeers->peers_fe);
425 /* disable this peer section so that it kills itself */
426 signal_unregister_handler(curpeers->sighandler);
Olivier Houchard3f795f72019-04-17 22:51:06 +0200427 task_destroy(curpeers->sync_task);
William Lallemand9001ce82019-04-01 11:29:57 +0200428 curpeers->sync_task = NULL;
Olivier Houchard3f795f72019-04-17 22:51:06 +0200429 task_destroy(curpeers->peers_fe->task);
William Lallemand9001ce82019-04-01 11:29:57 +0200430 curpeers->peers_fe->task = NULL;
431 curpeers->peers_fe = NULL;
432 }
433
434 for (curproxy = proxies_list; curproxy; curproxy = curproxy->next) {
435 int listen_in_master = 0;
436
437 list_for_each_entry_safe(l, l_next, &curproxy->conf.listeners, by_fe) {
438 /* remove the listener, but not those we need in the master... */
Willy Tarreau18c20d22020-10-09 16:11:46 +0200439 if (!(l->rx.flags & RX_F_MWORKER)) {
Willy Tarreau75c98d12020-10-09 15:55:23 +0200440 unbind_listener(l);
William Lallemand9001ce82019-04-01 11:29:57 +0200441 delete_listener(l);
442 } else {
443 listen_in_master = 1;
444 }
445 }
446 /* if the proxy shouldn't be in the master, we stop it */
447 if (!listen_in_master)
Willy Tarreauc3914d42020-09-24 08:39:22 +0200448 curproxy->disabled = 1;
William Lallemand9001ce82019-04-01 11:29:57 +0200449 }
William Lallemand88dc7c52019-04-01 11:30:01 +0200450}
451
William Lallemand030571a2022-01-28 21:17:30 +0100452/* Upon a configuration loading error some mworker_proc and FDs/server were
453 * assigned but the worker was never forked, we must close the FDs and
454 * remove the server
455 */
456void mworker_cleanup_proc()
457{
458 struct mworker_proc *child, *it;
459
460 list_for_each_entry_safe(child, it, &proc_list, list) {
461
462 if (child->pid == -1) {
463 /* Close the socketpair master side. We don't need to
464 * close the worker side, because it's stored in the
465 * GLOBAL cli listener which was supposed to be in the
466 * worker and which will be closed in
467 * mworker_cleanlisteners()
468 */
469 if (child->ipc_fd[0] > -1)
470 close(child->ipc_fd[0]);
471 if (child->srv) {
472 /* only exists if we created a master CLI listener */
473 free_server(child->srv);
474 }
475 LIST_DELETE(&child->list);
476 mworker_free_child(child);
477 }
478 }
479}
480
481
William Lallemand88dc7c52019-04-01 11:30:01 +0200482/* Displays workers and processes */
483static int cli_io_handler_show_proc(struct appctx *appctx)
484{
485 struct stream_interface *si = appctx->owner;
486 struct mworker_proc *child;
487 int old = 0;
488 int up = now.tv_sec - proc_self->timestamp;
William Lallemande8669fc2019-06-12 18:21:17 +0200489 char *uptime = NULL;
William Lallemand88dc7c52019-04-01 11:30:01 +0200490
491 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
492 return 1;
493
494 chunk_reset(&trash);
495
William Lallemand1dc69632019-06-12 19:11:33 +0200496 chunk_printf(&trash, "#%-14s %-15s %-15s %-15s %-15s %-15s\n", "<PID>", "<type>", "<relative PID>", "<reloads>", "<uptime>", "<version>");
William Lallemande8669fc2019-06-12 18:21:17 +0200497 memprintf(&uptime, "%dd%02dh%02dm%02ds", up / 86400, (up % 86400) / 3600, (up % 3600) / 60, (up % 60));
Willy Tarreau76a80c72019-06-22 07:41:38 +0200498 chunk_appendf(&trash, "%-15u %-15s %-15u %-15d %-15s %-15s\n", (unsigned int)getpid(), "master", 0, proc_self->reloads, uptime, haproxy_version);
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100499 ha_free(&uptime);
William Lallemand88dc7c52019-04-01 11:30:01 +0200500
501 /* displays current processes */
502
503 chunk_appendf(&trash, "# workers\n");
504 list_for_each_entry(child, &proc_list, list) {
505 up = now.tv_sec - child->timestamp;
506
William Lallemand8f7069a2019-04-12 16:09:23 +0200507 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand88dc7c52019-04-01 11:30:01 +0200508 continue;
509
William Lallemand45286112019-04-12 16:09:21 +0200510 if (child->options & PROC_O_LEAVING) {
William Lallemand88dc7c52019-04-01 11:30:01 +0200511 old++;
512 continue;
513 }
William Lallemande8669fc2019-06-12 18:21:17 +0200514 memprintf(&uptime, "%dd%02dh%02dm%02ds", up / 86400, (up % 86400) / 3600, (up % 3600) / 60, (up % 60));
William Lallemand1dc69632019-06-12 19:11:33 +0200515 chunk_appendf(&trash, "%-15u %-15s %-15u %-15d %-15s %-15s\n", child->pid, "worker", child->relative_pid, child->reloads, uptime, child->version);
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100516 ha_free(&uptime);
William Lallemand88dc7c52019-04-01 11:30:01 +0200517 }
518
519 /* displays old processes */
520
521 if (old) {
522 char *msg = NULL;
523
524 chunk_appendf(&trash, "# old workers\n");
525 list_for_each_entry(child, &proc_list, list) {
526 up = now.tv_sec - child->timestamp;
527
William Lallemand8f7069a2019-04-12 16:09:23 +0200528 if (!(child->options & PROC_O_TYPE_WORKER))
William Lallemand88dc7c52019-04-01 11:30:01 +0200529 continue;
530
William Lallemand45286112019-04-12 16:09:21 +0200531 if (child->options & PROC_O_LEAVING) {
William Lallemand88dc7c52019-04-01 11:30:01 +0200532 memprintf(&msg, "[was: %u]", child->relative_pid);
William Lallemande8669fc2019-06-12 18:21:17 +0200533 memprintf(&uptime, "%dd%02dh%02dm%02ds", up / 86400, (up % 86400) / 3600, (up % 3600) / 60, (up % 60));
William Lallemand1dc69632019-06-12 19:11:33 +0200534 chunk_appendf(&trash, "%-15u %-15s %-15s %-15d %-15s %-15s\n", child->pid, "worker", msg, child->reloads, uptime, child->version);
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100535 ha_free(&uptime);
William Lallemand88dc7c52019-04-01 11:30:01 +0200536 }
537 }
538 free(msg);
539 }
540
William Lallemandad53d6d2019-04-01 11:30:03 +0200541 /* displays external process */
542 chunk_appendf(&trash, "# programs\n");
543 old = 0;
544 list_for_each_entry(child, &proc_list, list) {
545 up = now.tv_sec - child->timestamp;
546
William Lallemand8f7069a2019-04-12 16:09:23 +0200547 if (!(child->options & PROC_O_TYPE_PROG))
William Lallemandad53d6d2019-04-01 11:30:03 +0200548 continue;
549
William Lallemand45286112019-04-12 16:09:21 +0200550 if (child->options & PROC_O_LEAVING) {
William Lallemandad53d6d2019-04-01 11:30:03 +0200551 old++;
552 continue;
553 }
William Lallemande8669fc2019-06-12 18:21:17 +0200554 memprintf(&uptime, "%dd%02dh%02dm%02ds", up / 86400, (up % 86400) / 3600, (up % 3600) / 60, (up % 60));
William Lallemand1dc69632019-06-12 19:11:33 +0200555 chunk_appendf(&trash, "%-15u %-15s %-15s %-15d %-15s %-15s\n", child->pid, child->id, "-", child->reloads, uptime, "-");
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100556 ha_free(&uptime);
William Lallemandad53d6d2019-04-01 11:30:03 +0200557 }
558
559 if (old) {
560 chunk_appendf(&trash, "# old programs\n");
561 list_for_each_entry(child, &proc_list, list) {
562 up = now.tv_sec - child->timestamp;
563
William Lallemand8f7069a2019-04-12 16:09:23 +0200564 if (!(child->options & PROC_O_TYPE_PROG))
William Lallemandad53d6d2019-04-01 11:30:03 +0200565 continue;
566
William Lallemand45286112019-04-12 16:09:21 +0200567 if (child->options & PROC_O_LEAVING) {
William Lallemande8669fc2019-06-12 18:21:17 +0200568 memprintf(&uptime, "%dd%02dh%02dm%02ds", up / 86400, (up % 86400) / 3600, (up % 3600) / 60, (up % 60));
William Lallemand1dc69632019-06-12 19:11:33 +0200569 chunk_appendf(&trash, "%-15u %-15s %-15s %-15d %-15s %-15s\n", child->pid, child->id, "-", child->reloads, uptime, "-");
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100570 ha_free(&uptime);
William Lallemandad53d6d2019-04-01 11:30:03 +0200571 }
572 }
573 }
574
575
576
William Lallemand88dc7c52019-04-01 11:30:01 +0200577 if (ci_putchk(si_ic(si), &trash) == -1) {
578 si_rx_room_blk(si);
579 return 0;
580 }
581
582 /* dump complete */
583 return 1;
William Lallemand9001ce82019-04-01 11:29:57 +0200584}
William Lallemand88dc7c52019-04-01 11:30:01 +0200585
586/* reload the master process */
587static int cli_parse_reload(char **args, char *payload, struct appctx *appctx, void *private)
588{
589 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
590 return 1;
591
592 mworker_reload();
593
594 return 1;
595}
596
597
William Lallemand27edc4b2019-05-07 17:49:33 +0200598static int mworker_parse_global_max_reloads(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +0100599 const struct proxy *defpx, const char *file, int linenum, char **err)
William Lallemand27edc4b2019-05-07 17:49:33 +0200600{
601
602 int err_code = 0;
603
604 if (alertif_too_many_args(1, file, linenum, args, &err_code))
605 goto out;
606
607 if (*(args[1]) == 0) {
608 memprintf(err, "%sparsing [%s:%d] : '%s' expects an integer argument.\n", *err, file, linenum, args[0]);
609 err_code |= ERR_ALERT | ERR_FATAL;
610 goto out;
611 }
612
613 max_reloads = atol(args[1]);
614 if (max_reloads < 0) {
615 memprintf(err, "%sparsing [%s:%d] '%s' : invalid value %d, must be >= 0", *err, file, linenum, args[0], max_reloads);
616 err_code |= ERR_ALERT | ERR_FATAL;
617 goto out;
618 }
619
620out:
621 return err_code;
622}
623
Tim Duesterhus9b7a9762019-05-16 20:23:22 +0200624void mworker_free_child(struct mworker_proc *child)
625{
626 if (child == NULL)
627 return;
628
629 if (child->command) {
630 int i;
631
632 for (i = 0; child->command[i]; i++) {
633 if (child->command[i]) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100634 ha_free(&child->command[i]);
Tim Duesterhus9b7a9762019-05-16 20:23:22 +0200635 }
William Lallemande8669fc2019-06-12 18:21:17 +0200636
Tim Duesterhus9b7a9762019-05-16 20:23:22 +0200637 }
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100638 ha_free(&child->command);
Tim Duesterhus9b7a9762019-05-16 20:23:22 +0200639 }
640 if (child->id) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100641 ha_free(&child->id);
Tim Duesterhus9b7a9762019-05-16 20:23:22 +0200642 }
William Lallemand1dc69632019-06-12 19:11:33 +0200643 if (child->version) {
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100644 ha_free(&child->version);
William Lallemand1dc69632019-06-12 19:11:33 +0200645 }
Tim Duesterhus9b7a9762019-05-16 20:23:22 +0200646 free(child);
647}
William Lallemand27edc4b2019-05-07 17:49:33 +0200648
649static struct cfg_kw_list mworker_kws = {{ }, {
650 { CFG_GLOBAL, "mworker-max-reloads", mworker_parse_global_max_reloads },
651 { 0, NULL, NULL },
652}};
653
654INITCALL1(STG_REGISTER, cfg_register_keywords, &mworker_kws);
655
656
William Lallemand88dc7c52019-04-01 11:30:01 +0200657/* register cli keywords */
658static struct cli_kw_list cli_kws = {{ },{
Willy Tarreau23c740e2021-05-09 22:49:44 +0200659 { { "@<relative pid>", NULL }, "@<relative pid> : send a command to the <relative pid> process", NULL, cli_io_handler_show_proc, NULL, NULL, ACCESS_MASTER_ONLY},
660 { { "@!<pid>", NULL }, "@!<pid> : send a command to the <pid> process", cli_parse_default, NULL, NULL, NULL, ACCESS_MASTER_ONLY},
661 { { "@master", NULL }, "@master : send a command to the master process", cli_parse_default, NULL, NULL, NULL, ACCESS_MASTER_ONLY},
662 { { "show", "proc", NULL }, "show proc : show processes status", cli_parse_default, cli_io_handler_show_proc, NULL, NULL, ACCESS_MASTER_ONLY},
663 { { "reload", NULL }, "reload : reload haproxy", cli_parse_reload, NULL, NULL, NULL, ACCESS_MASTER_ONLY},
William Lallemand88dc7c52019-04-01 11:30:01 +0200664 {{},}
665}};
666
667INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);