← Back to branch summary

~ubuntu-branches/ubuntu/trusty/keepalived/trusty

« back to all changes in this revision

Viewing changes to keepalived/check/check_daemon.c

  • Committer: Bazaar Package Importer
  • Author(s): Alexander Wirt
  • Date: 2005-04-29 23:22:40 UTC
  • mfrom: (1.1.1 upstream) (2.1.1 hoary)
  • Revision ID: james.westby@ubuntu.com-20050429232240-a8m3jtpi3cvuyyy2
Tags: 1.1.11-3
Added a warning about sarge kernels to README.Debian and 
the package description 

Show diffs side-by-side

added added

removed removed

Lines of Context:
keepalived/check/check_daemon.c
5
5
 *
6
6
 * Part:        Healthcheckrs child process handling.
7
7
 *
8
 
 * Version:     $Id: check_daemon.c,v 1.1.7 2004/04/04 23:28:05 acassen Exp $
 
8
 * Version:     $Id: check_daemon.c,v 1.1.11 2005/03/01 01:22:13 acassen Exp $
9
9
 *
10
10
 * Author:      Alexandre Cassen, <acassen@linux-vs.org>
11
11
 *
19
19
 *              as published by the Free Software Foundation; either version
20
20
 *              2 of the License, or (at your option) any later version.
21
21
 *
22
 
 * Copyright (C) 2001-2004 Alexandre Cassen, <acassen@linux-vs.org>
 
22
 * Copyright (C) 2001-2005 Alexandre Cassen, <acassen@linux-vs.org>
23
23
 */
24
24
 
25
25
#include "check_daemon.h"
26
26
#include "check_parser.h"
27
27
#include "check_data.h"
 
28
#include "check_ssl.h"
28
29
#include "check_api.h"
29
30
#include "global_data.h"
30
31
#include "ipwrapper.h"
31
32
#include "ipvswrapper.h"
32
33
#include "pidfile.h"
33
34
#include "daemon.h"
 
35
#include "signals.h"
34
36
#include "list.h"
 
37
#include "main.h"
35
38
#include "memory.h"
36
39
#include "parser.h"
37
 
#include "watchdog.h"
38
40
#include "vrrp_netlink.h"
39
41
#include "vrrp_if.h"
40
42
 
41
 
/* Global vars */
42
 
check_conf_data *check_data;
43
 
check_conf_data *old_check_data;
44
 
int check_wdog_sd = -1;
45
 
 
46
 
/* Healthchecker watchdog data */
47
 
wdog_data check_wdog_data = {
48
 
        "Healthcheck Child",
49
 
        WDOG_CHECK,
50
 
        -1,
51
 
        -1,
52
 
        start_check_child
53
 
};
54
 
 
55
 
/* Externals vars */
56
 
extern thread_master *master;
57
 
extern conf_data *data;
58
 
extern unsigned int debug;
59
 
extern int reload;
60
 
extern pid_t checkers_child;
61
 
extern char *conf_file;
62
 
extern int init_ssl_ctx(void);
63
 
extern int wdog_delay_check;
64
 
 
65
43
/* Daemon stop sequence */
66
44
static void
67
45
stop_check(void)
88
66
        keepalived_free_final("Healthcheck child process");
89
67
#endif
90
68
 
91
 
        /* free watchdog sd */
92
 
        wdog_close(check_wdog_sd, WDOG_CHECK);
93
 
 
94
69
        /*
95
70
         * Reached when terminate signal catched.
96
71
         * finally return to parent process.
145
120
                dump_check_data(check_data);
146
121
        }
147
122
 
148
 
        /* Register healthcheckers software watchdog */
149
 
        check_wdog_sd = wdog_init(WDOG_CHECK);
150
 
 
151
123
        /* Register checkers thread */
152
124
        register_checkers_thread();
153
125
}
154
126
 
155
127
/* Reload handler */
156
128
int
157
 
reload_check_thread(thread * thread)
 
129
reload_check_thread(thread * thread_obj)
158
130
{
159
131
        /* set the reloading flag */
160
132
        SET_RELOAD;
164
136
        master = thread_make_master();
165
137
        free_global_data(data);
166
138
        free_checkers_queue();
 
139
#ifdef _WITH_VRRP_
 
140
        free_interface_queue();
 
141
#endif
167
142
        free_ssl();
168
143
        ipvs_stop();
169
144
 
170
 
        /* free watchdog sd */
171
 
        wdog_close(check_wdog_sd, WDOG_CHECK);
172
 
 
173
145
        /* Save previous conf data */
174
146
        old_check_data = check_data;
175
147
        check_data = NULL;
189
161
void
190
162
sighup_check(int sig)
191
163
{
192
 
        syslog(LOG_INFO, "Reloading Healthchecker child process on signal");
 
164
        syslog(LOG_INFO, "Reloading Healthchecker child processi(%d) on signal",
 
165
               checkers_child);
193
166
        thread_add_event(master, reload_check_thread, NULL, 0);
194
167
}
195
168
 
202
175
                thread_add_terminate_event(master);
203
176
}
204
177
 
205
 
/* VRRP Child signal handling */
 
178
/* CHECK Child signal handling */
206
179
void
207
180
check_signal_init(void)
208
181
{
 
182
        signal_handler_init();
209
183
        signal_set(SIGHUP, sighup_check);
210
184
        signal_set(SIGINT, sigend_check);
211
185
        signal_set(SIGTERM, sigend_check);
212
 
        signal_set(SIGKILL, sigend_check);
 
186
        signal_ignore(SIGPIPE);
213
187
        signal_noignore_sigchld();
214
188
}
215
189
 
216
 
/* Register VRRP thread */
 
190
/* CHECK Child respawning thread */
 
191
int
 
192
check_respawn_thread(thread * thread_obj)
 
193
{
 
194
        pid_t pid;
 
195
 
 
196
        /* Fetch thread args */
 
197
        pid = THREAD_CHILD_PID(thread_obj);
 
198
 
 
199
        /* Restart respawning thread */
 
200
        if (thread_obj->type == THREAD_CHILD_TIMEOUT) {
 
201
                thread_add_child(master, check_respawn_thread, NULL,
 
202
                                 pid, RESPAWN_TIMER);
 
203
                return 0;
 
204
        }
 
205
 
 
206
        /* We catch a SIGCHLD, handle it */
 
207
        syslog(LOG_INFO, "Healthcheck child process(%d) died: Respawning", pid);
 
208
        start_check_child();
 
209
        return 0;
 
210
}
 
211
 
 
212
/* Register CHECK thread */
217
213
int
218
214
start_check_child(void)
219
215
{
225
221
                return -1;
226
222
        }
227
223
 
 
224
#ifndef _DEBUG_
228
225
        /* Initialize child process */
229
226
        pid = fork();
230
227
 
233
230
                               , strerror(errno));
234
231
                return -1;
235
232
        } else if (pid) {
236
 
                long poll_delay = (wdog_delay_check) ? wdog_delay_check : WATCHDOG_DELAY;
237
233
                checkers_child = pid;
238
234
                syslog(LOG_INFO, "Starting Healthcheck child process, pid=%d"
239
235
                               , pid);
240
 
                /* Connect child watchdog */
241
 
                check_wdog_data.wdog_pid = pid;
242
 
                thread_add_timer(master, wdog_boot_thread, &check_wdog_data,
243
 
                                 poll_delay);
 
236
 
 
237
                /* Start respawning thread */
 
238
                thread_add_child(master, check_respawn_thread, NULL,
 
239
                                 pid, RESPAWN_TIMER);
244
240
                return 0;
245
241
        }
246
242
 
247
 
        /* Opening local VRRP syslog channel */
248
 
        openlog(PROG_CHECK, LOG_PID | (debug & 1) ? LOG_CONS : 0, LOG_LOCAL2);
 
243
        /* Opening local CHECK syslog channel */
 
244
        openlog(PROG_CHECK, LOG_PID | (debug & 1) ? LOG_CONS : 0, 
 
245
                (log_facility==LOG_DAEMON) ? LOG_LOCAL2 : log_facility);
249
246
 
250
247
        /* Child process part, write pidfile */
251
248
        if (!pidfile_write(CHECKERS_PID_FILE, getpid())) {
257
254
        thread_destroy_master(master);
258
255
        master = thread_make_master();
259
256
 
260
 
        /* Signal handling initialization */
261
 
        check_signal_init();
262
 
 
263
257
        /* change to / dir */
264
258
        chdir("/");
265
259
 
266
260
        /* Set mask */
267
261
        umask(0);
 
262
#endif
 
263
 
 
264
        /* Signal handling initialization */
 
265
        check_signal_init();
268
266
 
269
267
        /* Start Healthcheck daemon */
270
268
        start_check();