← Back to branch summary

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

« back to all changes in this revision

Viewing changes to keepalived/vrrp/vrrp_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/vrrp/vrrp_daemon.c
5
5
 *
6
6
 * Part:        VRRP child process handling.
7
7
 *
8
 
 * Version:     $Id: vrrp_daemon.c,v 1.1.7 2004/04/04 23:28:05 acassen Exp $
 
8
 * Version:     $Id: vrrp_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 "vrrp_daemon.h"
35
35
#include "global_data.h"
36
36
#include "pidfile.h"
37
37
#include "daemon.h"
 
38
#include "signals.h"
38
39
#ifdef _WITH_LVS_
39
40
  #include "ipvswrapper.h"
40
41
#endif
41
42
#include "list.h"
 
43
#include "main.h"
42
44
#include "memory.h"
43
45
#include "parser.h"
44
 
#include "watchdog.h"
45
 
 
46
 
/* Global vars */
47
 
vrrp_conf_data *vrrp_data;
48
 
vrrp_conf_data *old_vrrp_data;
49
 
int vrrp_wdog_sd = -1;
50
 
 
51
 
/* VRRP watchdog data */
52
 
wdog_data vrrp_wdog_data = {
53
 
        "VRRP Child",
54
 
        WDOG_VRRP,
55
 
        -1,
56
 
        -1,
57
 
        start_vrrp_child
58
 
};
59
 
 
60
 
/* Externals vars */
61
 
extern thread_master *master;
62
 
extern conf_data *data;
63
 
extern unsigned int debug;
64
 
extern int reload;
65
 
extern pid_t vrrp_child;
66
 
extern char *conf_file;
67
 
extern int wdog_delay_vrrp;
68
46
 
69
47
/* Daemon stop sequence */
70
48
static void
74
52
        thread_destroy_master(master);
75
53
 
76
54
        /* Clear static entries */
 
55
        netlink_rtlist_ipv4(vrrp_data->static_routes, IPROUTE_DEL);
77
56
        netlink_iplist_ipv4(vrrp_data->static_addresses, IPADDRESS_DEL);
78
 
        netlink_rtlist_ipv4(vrrp_data->static_routes, IPROUTE_DEL);
79
57
 
80
58
        if (!(debug & 8))
81
59
                shutdown_vrrp_instances();
88
66
        /* Clean data */
89
67
        free_global_data(data);
90
68
        free_vrrp_data(vrrp_data);
 
69
        free_vrrp_buffer();
91
70
 
92
71
#ifdef _WITH_LVS_
93
72
        /* Clean ipvs related */
98
77
        keepalived_free_final("VRRP Child process");
99
78
#endif
100
79
 
101
 
        /* free watchdog sd */
102
 
        wdog_close(vrrp_wdog_sd, WDOG_VRRP);
103
 
 
104
80
        /*
105
81
         * Reached when terminate signal catched.
106
82
         * finally return to parent process.
157
133
                dump_vrrp_data(vrrp_data);
158
134
        }
159
135
 
160
 
        /* Register vrrp software watchdog */
161
 
        vrrp_wdog_sd = wdog_init(WDOG_VRRP);
162
 
 
163
136
        /* Init & start the VRRP packet dispatcher */
164
137
        thread_add_event(master, vrrp_dispatcher_init, NULL,
165
138
                         VRRP_DISPATCHER);
167
140
 
168
141
/* Reload handler */
169
142
int
170
 
reload_vrrp_thread(thread * thread)
 
143
reload_vrrp_thread(thread * thread_obj)
171
144
{
172
145
        /* set the reloading flag */
173
146
        SET_RELOAD;
180
153
        free_vrrp_buffer();
181
154
        gratuitous_arp_close();
182
155
 
183
 
        /* free watchdog sd */
184
 
        wdog_close(vrrp_wdog_sd, WDOG_VRRP);
185
 
 
186
156
        /* Save previous conf data */
187
157
        old_vrrp_data = vrrp_data;
188
158
        vrrp_data = NULL;
207
177
void
208
178
sighup_vrrp(int sig)
209
179
{
210
 
        syslog(LOG_INFO, "Reloading VRRP child process on signal");
 
180
        syslog(LOG_INFO, "Reloading VRRP child process(%d) on signal",
 
181
               vrrp_child);
211
182
        thread_add_event(master, reload_vrrp_thread, NULL, 0);
212
183
}
213
184
 
224
195
void
225
196
vrrp_signal_init(void)
226
197
{
 
198
        signal_handler_init();
227
199
        signal_set(SIGHUP, sighup_vrrp);
228
200
        signal_set(SIGINT, sigend_vrrp);
229
201
        signal_set(SIGTERM, sigend_vrrp);
230
 
        signal_set(SIGKILL, sigend_vrrp);
 
202
        signal_ignore(SIGPIPE);
231
203
        signal_noignore_sigchld();
232
204
}
233
205
 
 
206
/* VRRP Child respawning thread */
 
207
int
 
208
vrrp_respawn_thread(thread * thread_obj)
 
209
{
 
210
        pid_t pid;
 
211
 
 
212
        /* Fetch thread args */
 
213
        pid = THREAD_CHILD_PID(thread_obj);
 
214
 
 
215
        /* Restart respawning thread */
 
216
        if (thread_obj->type == THREAD_CHILD_TIMEOUT) {
 
217
                thread_add_child(master, vrrp_respawn_thread, NULL,
 
218
                                 pid, RESPAWN_TIMER);
 
219
                return 0;
 
220
        }
 
221
 
 
222
        /* We catch a SIGCHLD, handle it */
 
223
        syslog(LOG_INFO, "VRRP child process(%d) died: Respawning", pid);
 
224
        start_vrrp_child();
 
225
        return 0;
 
226
}
 
227
 
234
228
/* Register VRRP thread */
235
229
int
236
230
start_vrrp_child(void)
237
231
{
 
232
#ifndef _DEBUG_
238
233
        pid_t pid;
 
234
#endif
239
235
 
240
236
        /* Dont start if pid is already running */
241
237
        if (vrrp_running()) {
243
239
                return -1;
244
240
        }
245
241
 
 
242
#ifndef _DEBUG_
246
243
        /* Initialize child process */
247
244
        pid = fork();
248
245
 
251
248
                               , strerror(errno));
252
249
                return -1;
253
250
        } else if (pid) {
254
 
                long poll_delay = (wdog_delay_vrrp) ? wdog_delay_vrrp : WATCHDOG_DELAY;
255
251
                vrrp_child = pid;
256
252
                syslog(LOG_INFO, "Starting VRRP child process, pid=%d"
257
253
                               , pid);
258
 
                /* Connect child watchdog */
259
 
                vrrp_wdog_data.wdog_pid = pid;
260
 
                thread_add_timer(master, wdog_boot_thread, &vrrp_wdog_data,
261
 
                                 poll_delay);
 
254
 
 
255
                /* Start respawning thread */
 
256
                thread_add_child(master, vrrp_respawn_thread, NULL,
 
257
                                 pid, RESPAWN_TIMER);
262
258
                return 0;
263
259
        }
264
260
 
265
261
        /* Opening local VRRP syslog channel */
266
 
        openlog(PROG_VRRP, LOG_PID | (debug & 1) ? LOG_CONS : 0, LOG_LOCAL1);
 
262
        openlog(PROG_VRRP, LOG_PID | (debug & 1) ? LOG_CONS : 0,
 
263
                (log_facility==LOG_DAEMON) ? LOG_LOCAL1 : log_facility);
267
264
 
268
265
        /* Child process part, write pidfile */
269
266
        if (!pidfile_write(VRRP_PID_FILE, getpid())) {
276
273
        thread_destroy_master(master);
277
274
        master = thread_make_master();
278
275
 
279
 
        /* Signal handling initialization */
280
 
        vrrp_signal_init();
281
 
 
282
276
        /* change to / dir */
283
277
        chdir("/");
284
278
 
285
279
        /* Set mask */
286
280
        umask(0);
 
281
#endif
 
282
 
 
283
        /* Signal handling initialization */
 
284
        vrrp_signal_init();
287
285
 
288
286
        /* Start VRRP daemon */
289
287
        start_vrrp();