← Back to branch summary

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

« back to all changes in this revision

Viewing changes to keepalived/vrrp/vrrp_scheduler.c

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2009-05-12 20:26:15 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20090512202615-k850bw35qpuvpq4p
Tags: 1.1.17-1ubuntu1
* Merge from debian unstable, remaining changes:
  - debian/rules: DEB_UPDATE_RCD_PARAMS := expicit init start/stop
    parameters (don't stop at 0 and 6)
  - debian/init.d: init script header adapted to stop rule
  - debian/keepalived.postinst: Remove shutdown and reboot links

Show diffs side-by-side

added added

removed removed

Lines of Context:
keepalived/vrrp/vrrp_scheduler.c
5
5
 *
6
6
 * Part:        Sheduling framework for vrrp code.
7
7
 *
8
 
 * Version:     $Id: vrrp_scheduler.c,v 1.1.15 2007/09/15 04:07:41 acassen Exp $
 
8
 * Version:     $Id: vrrp_scheduler.c,v 1.1.17 2009/03/05 01:31:12 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-2007 Alexandre Cassen, <acassen@freebox.fr>
 
22
 * Copyright (C) 2001-2009 Alexandre Cassen, <acassen@freebox.fr>
23
23
 */
24
24
 
25
25
#include "vrrp_scheduler.h"
35
35
#include "memory.h"
36
36
#include "notify.h"
37
37
#include "list.h"
 
38
#include "logger.h"
38
39
#include "main.h"
39
40
#include "smtp.h"
 
41
#include "signals.h"
40
42
 
41
43
/* VRRP FSM (Finite State Machine) design.
42
44
 *
157
159
static void vrrp_log_int_down(vrrp_rt *vrrp)
158
160
{
159
161
        if (!IF_ISUP(vrrp->ifp))
160
 
                syslog(LOG_INFO, "Kernel is reporting: interface %s DOWN",
 
162
                log_message(LOG_INFO, "Kernel is reporting: interface %s DOWN",
161
163
                       IF_NAME(vrrp->ifp));
162
164
        if (!LIST_ISEMPTY(vrrp->track_ifp))
163
165
                vrrp_log_tracked_down(vrrp->track_ifp);
166
168
static void vrrp_log_int_up(vrrp_rt *vrrp)
167
169
{
168
170
        if (IF_ISUP(vrrp->ifp))
169
 
                syslog(LOG_INFO, "Kernel is reporting: interface %s UP",
 
171
                log_message(LOG_INFO, "Kernel is reporting: interface %s UP",
170
172
                       IF_NAME(vrrp->ifp));
171
173
        if (!LIST_ISEMPTY(vrrp->track_ifp))
172
 
                syslog(LOG_INFO, "Kernel is reporting: tracked interface are UP");
 
174
                log_message(LOG_INFO, "Kernel is reporting: tracked interface are UP");
173
175
}
174
176
 
175
177
/*
218
220
                        }
219
221
 
220
222
                        if (warning > 0) {
221
 
                                syslog(LOG_INFO, "VRRP_Instance(%s) : ignoring "
 
223
                                log_message(LOG_INFO, "VRRP_Instance(%s) : ignoring "
222
224
                                                 "track weights due to SYNC group",
223
225
                                       vrrp->iname);
224
226
                        }
248
250
                                               vrrp->lvs_syncd_if, IPVS_BACKUP,
249
251
                                               vrrp->vrid);
250
252
#endif
251
 
                        syslog(LOG_INFO, "VRRP_Instance(%s) Entering BACKUP STATE",
 
253
                        log_message(LOG_INFO, "VRRP_Instance(%s) Entering BACKUP STATE",
252
254
                               vrrp->iname);
253
255
 
254
256
                        /* Set BACKUP state */
297
299
 
298
300
                if (vscript->result == VRRP_SCRIPT_STATUS_INIT) {
299
301
                        vscript->result = VRRP_SCRIPT_STATUS_NONE;
300
 
                        thread_add_timer(master, vrrp_script_thread,
301
 
                                         vscript, vscript->interval);
 
302
                        thread_add_event(master, vrrp_script_thread, vscript, vscript->interval);
 
303
                } else if (vscript->result == VRRP_SCRIPT_STATUS_INIT_GOOD) {
 
304
                        vscript->result = VRRP_SCRIPT_STATUS_GOOD;
 
305
                        thread_add_event(master, vrrp_script_thread, vscript, vscript->interval);
302
306
                }
303
307
        }
304
308
}
562
566
         * with the remote IPSEC AH VRRP instance counter.
563
567
         */
564
568
        if (iph->protocol == IPPROTO_IPSEC_AH) {
565
 
                syslog(LOG_INFO, "VRRP_Instance(%s) IPSEC-AH : seq_num sync",
 
569
                log_message(LOG_INFO, "VRRP_Instance(%s) IPSEC-AH : seq_num sync",
566
570
                       vrrp->iname);
567
571
                ah = (ipsec_ah *) (buffer + sizeof (struct iphdr));
568
572
                vrrp->ipsecah_counter->seq_number = ntohl(ah->seq_number) + 1;
594
598
         * Transition to BACKUP state for AH
595
599
         * seq number synchronization.
596
600
         */
597
 
        syslog(LOG_INFO, "VRRP_Instance(%s) in FAULT state jump to AH sync",
 
601
        log_message(LOG_INFO, "VRRP_Instance(%s) in FAULT state jump to AH sync",
598
602
               vrrp->iname);
599
603
        vrrp->wantstate = VRRP_STATE_BACK;
600
604
        vrrp_state_leave_master(vrrp);
609
613
        if (vrrp_state_fault_rx(vrrp, buffer, len)) {
610
614
                if (vrrp->sync) {
611
615
                        if (vrrp_sync_leave_fault(vrrp)) {
612
 
                                syslog(LOG_INFO,
 
616
                                log_message(LOG_INFO,
613
617
                                       "VRRP_Instance(%s) prio is higher than received advert",
614
618
                                       vrrp->iname);
615
619
                                vrrp_become_master(vrrp, buffer, len);
616
620
                        }
617
621
                } else {
618
 
                        syslog(LOG_INFO,
 
622
                        log_message(LOG_INFO,
619
623
                               "VRRP_Instance(%s) prio is higher than received advert",
620
624
                               vrrp->iname);
621
625
                        vrrp_become_master(vrrp, buffer, len);
623
627
        } else {
624
628
                if (vrrp->sync) {
625
629
                        if (vrrp_sync_leave_fault(vrrp)) {
626
 
                                syslog(LOG_INFO, "VRRP_Instance(%s) Entering BACKUP STATE",
 
630
                                log_message(LOG_INFO, "VRRP_Instance(%s) Entering BACKUP STATE",
627
631
                                       vrrp->iname);
628
632
                                vrrp->state = VRRP_STATE_BACK;
629
633
                                vrrp_smtp_notifier(vrrp);
630
634
                                notify_instance_exec(vrrp, VRRP_STATE_BACK);
631
635
                        }
632
636
                } else {
633
 
                        syslog(LOG_INFO, "VRRP_Instance(%s) Entering BACKUP STATE",
 
637
                        log_message(LOG_INFO, "VRRP_Instance(%s) Entering BACKUP STATE",
634
638
                               vrrp->iname);
635
639
                        vrrp->state = VRRP_STATE_BACK;
636
640
                        vrrp_smtp_notifier(vrrp);
644
648
{
645
649
        if (!VRRP_ISUP(vrrp)) {
646
650
                vrrp_log_int_down(vrrp);
647
 
                syslog(LOG_INFO, "VRRP_Instance(%s) Now in FAULT state",
 
651
                log_message(LOG_INFO, "VRRP_Instance(%s) Now in FAULT state",
648
652
                       vrrp->iname);
649
 
                if(vrrp->state != VRRP_STATE_FAULT) {
650
 
                        notify_instance_exec(vrrp, VRRP_STATE_FAULT);
651
 
                }
652
653
                vrrp->state = VRRP_STATE_FAULT;
653
654
                vrrp->ms_down_timer = 3 * vrrp->adver_int + VRRP_TIMER_SKEW(vrrp);
654
655
                notify_instance_exec(vrrp, VRRP_STATE_FAULT);
731
732
        if (vrrp->wantstate == VRRP_STATE_GOTO_FAULT ||
732
733
            vrrp->wantstate == VRRP_STATE_BACK ||
733
734
            vrrp->ipsecah_counter->cycle) {
734
 
                vrrp->ms_down_timer =
735
 
                    3 * vrrp->adver_int + VRRP_TIMER_SKEW(vrrp);
 
735
                vrrp->ms_down_timer = 3 * vrrp->adver_int + VRRP_TIMER_SKEW(vrrp);
736
736
 
737
737
                /* handle backup state transition */
738
738
                vrrp_state_leave_master(vrrp);
739
739
 
740
740
                if (vrrp->state == VRRP_STATE_BACK)
741
 
                        syslog(LOG_INFO,
742
 
                               "VRRP_Instance(%s) Now in BACKUP state",
743
 
                               vrrp->iname);
 
741
                        log_message(LOG_INFO, "VRRP_Instance(%s) Now in BACKUP state",
 
742
                                    vrrp->iname);
744
743
                if (vrrp->state == VRRP_STATE_FAULT)
745
 
                        syslog(LOG_INFO, "VRRP_Instance(%s) Now in FAULT state",
746
 
                               vrrp->iname);
 
744
                        log_message(LOG_INFO, "VRRP_Instance(%s) Now in FAULT state",
 
745
                                    vrrp->iname);
747
746
        } else if (vrrp->state == VRRP_STATE_MAST) {
748
747
                /*
749
748
                 * Send the VRRP advert.
925
924
 
926
925
        /* In case of fork is error. */
927
926
        if (pid < 0) {
928
 
                syslog(LOG_INFO, "Failed fork process");
 
927
                log_message(LOG_INFO, "Failed fork process");
929
928
                return -1;
930
929
        }
931
930
 
939
938
        }
940
939
 
941
940
        /* Child part */
 
941
        signal_handler_destroy();
942
942
        closeall(0);
943
943
        open("/dev/null", O_RDWR);
944
944
        dup(0);
945
945
        dup(0);
946
946
 
947
 
        /* Also need to reset the signal state */
948
 
        {
949
 
                sigset_t empty_set;
950
 
                sigemptyset(&empty_set);
951
 
                sigprocmask(SIG_SETMASK, &empty_set, NULL);
952
 
 
953
 
                signal(SIGHUP, SIG_DFL);
954
 
                signal(SIGINT, SIG_DFL);
955
 
                signal(SIGTERM, SIG_DFL);
956
 
                signal(SIGKILL, SIG_DFL);
957
 
        }
958
 
 
959
947
        status = system_call(vscript->script);
960
948
 
961
949
        if (status < 0 || !WIFEXITED(status))
991
979
                int status;
992
980
                status = WEXITSTATUS(wait_status);
993
981
                if (status == 0 && vscript->result != VRRP_SCRIPT_STATUS_GOOD) {
994
 
                        syslog(LOG_INFO, "VRRP_Script(%s) succeeded", vscript->sname);
 
982
                        log_message(LOG_INFO, "VRRP_Script(%s) succeeded", vscript->sname);
995
983
                }
996
984
                if (status != 0 && vscript->result != VRRP_SCRIPT_STATUS_NONE) {
997
 
                        syslog(LOG_INFO, "VRRP_Script(%s) failed", vscript->sname);
 
985
                        log_message(LOG_INFO, "VRRP_Script(%s) failed", vscript->sname);
998
986
                }
999
987
                vscript->result = (status == 0) ?  VRRP_SCRIPT_STATUS_GOOD :
1000
988
                                                   VRRP_SCRIPT_STATUS_NONE;
1020
1008
                return 0;
1021
1009
        }
1022
1010
 
1023
 
        syslog(LOG_WARNING, "Process [%d] didn't respond to SIGTERM", pid);
 
1011
        log_message(LOG_WARNING, "Process [%d] didn't respond to SIGTERM", pid);
1024
1012
        waitpid(pid, NULL, 0);
1025
1013
 
1026
1014
        return 0;