`
`Moberg et al.
`
`(10) Patent N0.:
`
`(45) Date of Patent:
`
`US 6,460,146 B1
`*Oct. 1, 2002
`
`US006460146B1
`
`.............. .. 364/187
`380/21
`. . . .. 709/224
`.. 370/254
`................ .. 714/9
`
`
`
`5,963,448 A * 10/1999 Flood et al.
`6,023,507 A *
`2/2000 Wookey
`6,085,244 A *
`7/2000 Wookey . . . . . .
`6,118,768 A
`9/2000 Bhatia et al.
`6,263,452 B1 *
`7/2001 Jewett et al.
`
`OTHER PUBLICATIONS
`
`Jack Jenney, “Dual RSP—High System Availability SW
`Functional Spec”, Oct. 6, 1995, Cisco Systems, Inc.
`
`* cited by examiner
`
`Primary Examiner—Scott Baderman
`Assistant Examiner—Rita A Ziemer
`
`(74) Attorney, Agent, or Firm—Van Pelt & Yi LLP
`
`(57)
`
`ABSTRACT
`
`The present invention relates to providing processor redun-
`dancy in a system such as a router. According to an embodi-
`ment of the present invention, in a system having two or
`more processors, initialization sequence is started. During
`the initialization sequence, a redundancy subsystem is ini-
`tialized. The redundancy subsystem identifies the projects or
`assignments that are to be off loaded from the primary
`processor to the secondary processor. According to an
`embodiment of the present
`invention,
`the initialization
`sequence is then suspended and a discovery process is
`performed. During the discovery process, it is determined
`whether the processor running the initialization sequence is
`a primary or a secondary processor. If it is a secondary
`processor,
`then the initialization sequence remains sus-
`pended and the secondary processor monitors the health of
`the primary processor until a failure of the primary processor
`occurs. If a primary processor failure occurs,
`then the
`initialization process is resumed for the secondary processor,
`hence establishing the secondary processor as the new
`primary processor.
`
`19 Claims, 8 Drawing Sheets
`300
`J
`
`(54)
`
`(75)
`
`SYSTEM AND METHOD FOR
`ESTABLISHING PROCESSOR
`REDUNDANCY
`
`Inventors: Kenneth Moberg, Boulder Creek, CA
`(US); William May, Sunnyvale, CA
`(US)
`
`(73)
`
`Assignee: Cisco Technology, Inc., San Jose, CA
`(US)
`
`C“)
`
`Notice:
`
`Subject to any disclaimer, the term of this
`patent is extended or adjusted under 35
`U.S.C. 154(b) by 0 days.
`
`(21)
`
`(22)
`
`(51)
`(52)
`(58)
`
`(56)
`
`Appl. No.: 09/205,577
`
`Filed:
`
`Dec. 4, 1998
`
`Int. Cl.7 ................................................ .. H02H 3/05
`U.S. Cl.
`.......................... .. 714/10; 712/20; 709/222
`Field of Search .......................... .. 714/10; 709/222,
`709/238; 712/11, 14, 15, 20
`
`References Cited
`
`U.S. PATENT DOCUMENTS
`
`.............. .. 714/10
`4/1989 Bishop et al.
`4,823,256 A *
`..... ..
`395/575
`2/1992 Horton et al.
`5,089,958 A
`
`8/1992 McLaughlin et al.
`364/184
`5,136,498 A *
`5,157,663 A * 10/1992 Major et al.
`............... .. 371/9.1
`5,455,932 A * 10/1995 Major et al.
`.............. .. 395/489
`5,473,599 A
`12/1995 Li etal.
`370/16
`5,572,528 A * 11/1996 Shuen ........ ..
`370/402
`5,590,724 A
`1/1997 Verdgikovsky
`...... .. 175/57
`5,790,777 A *
`8/1998 Izuta et al.
`.......... .. 395/183.21
`5,815,668 A
`9/1998 Hashimoto ........... .. 395/200.68
`5,870,557 A
`2/1999 Bellovin et al.
`..... .. 395/200.54
`5,914,953 A
`6/1999 Krause et al.
`. . . .
`. . . . . .. 370/392
`5,919,266 A *
`7/1999 Sud et al.
`.... ..
`714/13
`5,928,332 A *
`7/1999 Pierce
`709/242
`
`
`
`
`
`Start initialization sequence
`
`Y
`Subsystem initialization including initializing
`secondary project subsystem
`
`V
`Suspend initialization sequence and perform
`discovery process
`
`302
`J
`
`304
`J
`
`Remain
`suspended
`
`l
`Monitor
`health ol
`Primary
`
`ARISTA 1106
`
`
`
`ls
`this
`processor
`secondary
`
`
`
`306
`
`
`
`
`
`Initialize driver subsystems
`
`V
`Finish initialization sequence
`
`0
`
`K3
`
`\2
`
`Run
`
`1
`
`ARISTA 1106
`
`
`
`U.S. Patent
`
`Oct. 1, 2002
`
`Sheet 1 of 8
`
`US 6,460,146 B1
`
`UJ
`(D
`
`<u
`
`.
`an
`UJ
`
`FIG.1
`
`2
`
`
`
`U.S. Patent
`
`Oct. 1, 2002
`
`Sheet 2 of 8
`
`US 6,460,146 B1
`
`100
`
`Power on
`
`HW discovery and boot IOS
`
`ROM reads HW register (NVRAM)
`
`is
`th'
`procegor a
`secondary
`
`Boot primary image
`
`Bootsecondary
`"nage
`
`Initiate secondary
`
`processor
`
`Initiateprimaryprocessor Ma
`
`processor
`failure ?
`
`Reboot I03 and
`establish this
`processor as
`primary
`
`3
`
`
`
`U.S. Patent
`
`Oct. 1, 2002
`
`Sheet 3 of 8
`
`US 6,460,146 B1
`
`SERIAL
`COMM.
`INTERFACE
`
`MU LTIPORT
`ETHERNET
`
`MULTIPORT
`COMMUNICATIONS
`INTERFACE
`
`%
`
`FDDI
`WTERFACE
`
`168
`
`130
`
`PRIMARY
`
`CONTROLLER
`
`SECONDARY
`GP”
`
`REGISTERS _
`
`182
`184
`
`4
`
`
`
`U.S. Patent
`
`Oct. 1, 2002
`
`Sheet 4 of 8
`
`US 6,460,146 B1
`
`200
`
`Power on
`
`HW discovery and boot IOS
`
`ROM reads HW register (NVRAM)
`
`Initialization sequence
`
`5
`
`
`
`U.S. Patent
`
`Oct. 1, 2002
`
`Sheet 5 of 8
`
`US 6,460,146 B1
`
`Start initialization sequence
`
`Subsystem initialization including initializing
`secondary project subsystem
`
`Suspend initialization sequence and perform
`discovery process
`
`300
`
`’/
`
`302
`
`304
`
`Remain
`
`suspended
`
`Monitor
`
`health of
`Primary
`
`is
`this
`
`processor
`
`secondary
`
`N
`
`310
`
`312
`
`_
`_
`_
`_
`Initialize driver subsystems
`
`Finish initialization sequence
`
`314
`
`6
`
`
`
`U.S. Patent
`
`Oct. 1, 2002
`
`Sheet 6 of 8
`
`US 6,460,146 B1
`
`Is
`there
`
`.nother processor
`
`this
`processor a
`primary
`9
`
`Start secondary background process
`
`410
`
`Receive
`command to switch
`
`with primary
`
`Stand alone
`
`processor
`
`procedure
`
`Start primary
`background
`process
`
`Resume
`initialization
`
`process
`
`Primary
`card
`removed
`?
`
`N
`
`Remain
`
`suspended
`
`7
`
`
`
`U.S. Patent
`
`Oct. 1, 2002
`
`Sheet 7 of 8
`
`US 6,460,146 B1
`
`Establish communication with secondary
`
`500
`
`Initiate monitoring of health of secondary
`
`Resume initialization
`
`314
`
`Is
`
`secondary
`healthy
`?
`
`Change state to stand alone
`
`8
`
`
`
`U.S. Patent
`
`Oct. 1, 2002
`
`Sheet 3 of 8
`
`US 6,460,146 B1
`
`Establish communication to primary processor
`
`600
`
`}/
`
`Initiate health monitoring of primary
`
`there any
`processing which
`primary wants to
`offload
`
`?
`
`Y
`
`Primary offloads processing to secondary
`
`Suspend initialization process
`
`Continue monitoring health
`
`9
`
`
`
`US 6,460,146 Bl
`
`1
`SYSTEM AND METHOD FOR
`ESTABLISHING PROCESSOR
`REDUNDANCY
`
`FIELD OF THE INVENTION
`
`The present invention relates to computer networks. In
`particular, the present invention relates to establishing pro-
`cessor redundancy.
`BACKGROUND OF THE INVENTION
`
`A network is a communication system that allows users to
`access resources on other computers and exchange messages
`with other users. A network is typically a data co1nmunica-
`tion system that links two or more computers and peripheral
`devices. It allows users to share resources on their own
`systems with other network users and to access information
`on centrally located systems or systems that are located at
`remote oflices. It may provide connections to the Internet or
`the networks of other organizations. The network typically
`includes a cable that attaches to network interface cards '
`(NIC) in each of the devices within the network. Users may
`interact with network-enabled software applications to make
`a network request (such as to get a file or print on a network
`printer). The application may also communicate with the I
`network software and network software then may interact
`with the network hardware to transmit information to other
`devices attached to the network.
`
`An example of a network is a local area network
`ALAN is a network that is located in a relatively small area,
`such as a department or building. A I.AN typically includes
`a shared medium to which workstations attach and commu-
`nicate with one another by using broadcast methods. With
`broadcasting, any device on the LAN can transmit a message
`that all other devices on the LAN can listen to. The device
`to which the message is addressed actually receives the
`message. Data is typically packaged into frames for trans-
`mission on the LAN.
`
`FIG. 1 is a block diagram illustrating a network connec-
`tion between a user 10 and a particular web page 20. This
`FIG is an example which may be consistent with any type
`of network, including a LAN, a wide are network (WAN), or
`a combination of networks, such as the Internet.
`VVhen a user 10 connects to a particular destination, such
`as a requested web page 20, the connection from the user 10
`to the web page 20 is typically routed through several routers
`12A—12D. Routers are internetworking devices. They are
`typically used to connect similar and heterogeneous network
`segments into internctworks. For example, two LANs may
`be connected across a dial—up, integrated services digital
`network (ISDN), or a leased line via routers. Routers may
`also be found throughout
`the Internet. End users may
`connect
`to a local Internet service provider (ISP) (not
`shown), which are typically connected via routers to
`regional ISPs, which are in turn typically connected via
`routers to national ISPs.
`If a router, such as router 12C, fails and is no longer able
`to route the desired connection, then the desired connection
`between the user 10 the desired web page 20 may be
`significantly delayed or unable to connect at all. To avoid
`this problem, a solution has been implemented by router
`manufacturers, such as Cisco Systems,
`that
`include two
`processors, a primary processor and a secondary processor,
`such that the secondary processor may take over as the main
`processor if the primary processor has either a hardware or
`software failure. Accordingly, such a solution provides
`redundancy to avoid failure of the router.
`
`,
`
`2
`If the secondary processor is required to switch itself over
`to the primary processor,
`then the secondary processor
`typically reboots, establishes itself as the primary processor,
`and re-initializes the entire router to become the primary
`processor. The re—booting and re—initializing process can
`take a substantial amount of time, such as minutes, since
`software is typically reloaded from either the network or
`flash memory and the new primary processor needs to run
`through the router configuration. The router configuration
`typically controls how the router moves data traffic. The
`configuration typically controls the path of network packets
`on their way to their final destination. The router configu-
`ration can be highly complex. The more complex the router
`configuration, the longer it typically takes to configure the
`router. Re-booting the router may take approximately 30
`seconds to 5 minutes.
`Although such redundancy routers may contain two
`processors, the secondary processor is typically unavailable
`for any work which is normally assigned to the primary
`processor. The secondary processor typically runs an image
`that is separate and different from the image which is run by
`the primary processor. Accordingly, the secondary processor
`is typically unavailable for offloading any work from the
`primary processor.
`It would be desirable for a router to provide redundancy
`without a substantial amount of down time for re-bootin g. It
`would also be desirable for such a router o offer an option
`of the secondary processor being able to o
`load work from
`the primary processor, thus making use of both processors
`simultaneously. The present invention addresses such needs.
`SUMMARY OF THE INVENTION
`
`invention relates to providing processor
`The present
`redundancy in a system such as a router. According to an
`embodiment of the present invention, in a system having two
`or more processors, initialization sequence is started. During
`the initialization sequence, a redundancy subsystem is ini-
`tialized. The redundancy subsystem identifies the projects or
`assignments that are to be off loaded from the primary
`processor to the secondary processor. According to an
`embodiment of the present
`invention,
`the initialization
`sequence is then suspended and a discovery process is
`performed. During the discovery process, it is determined
`whether the processor running the initialization sequence is
`a primary or a secondary processor. If it is a secondary
`processor,
`then the initialization sequence remains sus-
`pended and the secondary processor monitors the health of
`the primary processor until a failure of the primary processor
`occurs. If a primary processor failure occurs,
`then the
`initialization process is resumed for the secondary processor,
`hence establishing the secondary processor as the new
`primary processor.
`According to an embodiment of the present invention, if
`the processor running the initialization sequence is the
`primary processor, then the initialization process is resumed.
`Also according to an embodiment of the present invention,
`the suspension of the initialization sequence and perfor-
`mance of the discovery process preferably occurs prior to
`initialization of the driver subsystems. The remaining ini-
`tialization sequence is then finished, and the system is run.
`According to an embodiment of the present invention,
`each processor, both secondary and primary have the same
`image such that the same initialization sequence and sus-
`pension with the discovery process is performed in both the
`primary and secondary processors.
`A method according to an embodiment of the present
`invention for establishing processor
`redundancy is pre-
`
`10
`
`
`
`US 6,460,146 B1
`
`3
`sented. The method comprises providing a processor and
`suspending an initialization sequence of the processor. The
`method also determines whether the processor is a second-
`ary processor; and resumes the initialization sequence if the
`processor is not a secondary processor.
`A system according to an embodiment of the present
`invention for establishing processor
`redundancy is also
`presented. The system comprises a processor configured to
`suspend an initialization sequence of the processor. The
`processor is also configured to determine whether it is a
`secondary processor, and resumes the initialization sequence
`if the processor is not a secondary processor. The system
`also includes a memory coupled to the processor, and the
`memory is configured to provide instructions to the proces-
`sor.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`F G. 1 is a block diagram of an example of a network
`connection between a user and a web page.
`F G. 2 is a flow diagram of a conventional method for
`providing redundant processors in a router.
`F G. 3 is a block diagram of an example of a router
`suitable for implementing an embodiment of the present
`invention.
`
`F G. 4 is a flow diagrarri of a me hod according to an
`embodiment of the present invention for providing processor
`redundancy in a system such as a router.
`F G. 5 is a flow diagram of a me hod according to an
`embodiment of the present invention for initializing a pro-
`cessor in a redundant system.
`F G. 6 is a flow diagram of a me hod according to an
`embodiment of the present
`invention for performing a
`discovery process.
`F G. 7 is a How diagram of a me hod according to an
`embodiment of the present invention or running a primary
`processor background.
`F G. 8 is a flow diagram of a me hod according to an
`embodiment of the present invention or running a second-
`ary processor background.
`
`DETAILED DESCRIPTION OF THE
`PREFERRJJD JJMB()Dl\/IJJNTS
`
`The following description is presented to enable one of
`ordinary skill in the art to make and to use the invention and
`is provided in the context of a patent application and its
`requirements. Various modifications to the preferred
`embodiments will be readily apparent to those skilled in the >
`art and the generic principles herein may be applied to other
`embodiments. Thus, the present invention is not intended to
`be limited to the embodiment shown but is to be accorded
`the widest scope consistent with the principles and features
`described herein.
`
`FIG. 2 is a flow diagram of a conventional method for
`establishing processor redundancy in a router. When power
`is turned on (step 100), hardware discovery is performed as
`Well as booting up of an operating system (such as an
`Internet operating system (IOS)) for the router (step 102).
`Memory, such as read-only-memory (ROM) then reads
`hardware registers, such as registers in non-volatile random
`access memory (NVRAM) (step 104).
`the
`It
`is then determined whether this processor (i.e.
`processor that was powered on and is running this software)
`is a secondary processor (step 106). If this processor is not
`a secondary processor, then a primary image is booted up for
`
`4
`this processor (primary processor) (step 110). An initializa-
`tion sequence is then performed for the primary processor
`(step 114).
`If this processor is determined to be a secondary processor
`(step 106),
`then a secondary image is booted up for the
`secondary processor (step 108). An initialization sequence is
`then performed for the secondary processor (step 112). It is
`then determined whether the primary processor has had a
`failure (step 116). The primary processor’s health is moni-
`tored until it is determined that the primary processor has
`had a failure. Once the primary processor fails, then the
`Internet operating system (IOS) of the router is re-booted
`and this processor (formally the secondary processor‘) is then
`established as the primary processor (step ll8). Thereafter,
`the ROM reads the hardware registers (step 104),
`it
`is
`determined that this processor is now a primary processor
`(step 106), and a primary image is then booted up (step 110).
`As previously mentioned, a potential drawback with this
`conventional method is that if the primary fails and the
`secondary processor takes over the function of the primary
`processor,
`then the entire router system is typically
`re-booted and a primary image, different from the secondary
`image,
`is booted and a primary processor initialization
`sequence is performed. This process of the secondary pro-
`cessor taking over the functions of the primary processor
`may be substantially time consuming. Additionally, since the
`primary processor and the secondary processor each boot a
`different image, the secondary processor typically performs
`no function other than monitoring the health of the primary
`processor and acting as a standby processor.
`It would be desirable to provide processor redundancy in
`a system such as a router that significantly reduces the time
`required for the secondary processor to take over the func-
`tions of the primary processor in case of a failure of the
`primary processor. It would also be desirable for the sec-
`ondary processor to have the ability to perform some func-
`tions that are conventionally the duties of the primary
`processor. The present invention addresses such needs.
`FIG. 3 is a block diagram of an example of a router
`suitable for implementing an embodiment of the present
`invention. The router 150 is shown to include a primary
`central processing unit (CPU) 166, low and medium speed
`interfaces 158, and high speed interfaces 162. The primary
`CPU 166, may be responsible for such router tasks as
`routing table computations and network management. It
`may include one or more microprocessor chips selected
`from complex instruction set computer (CISC) chips (such
`as the Motorola 68040 Microprocessor), reduced instruc-
`tions sct computer (RISC) chips, or other available chips.
`Non-volatile RAM and/or ROM may also form part of the
`primary CPU 166. However, there are many different ways
`in which memory can be coupled to the system. For
`example, a memory 182 may be coupled with the primary
`CPU 166 Via a bus 168. The memory 182 may also be
`coupled with a secondary CPU 180 via the bus 168.
`The memory 182 may include registers 184 which may be
`used for communication between the primary CPU 166 and
`the secondary CPU 180. For example, the registers 184 may
`indicate whether a global lock has been acquired by either
`the primary CPU 166 or the secondary CPU 180; indicate
`states of the processors 166 and 180 such as primary,
`secondary, non-participant, or there are no processor cards
`present; and indicate whether either of the processors 166
`and 180 have had a failure.
`
`The interfaces 158 and 162 are typically provided as
`interface cards. Generally,
`they control
`the sending and
`
`11
`
`
`
`US 6,460,146 Bl
`
`5
`receipt of data packets over the network and sometimes
`support other peripherals used with the router 150.
`Examples of interfaces that may be included in the low and
`medium interfaces 158 include a multiport communications
`interface 152, a serial communications interface 154, and a
`token ring interface 156. Examples ofinterfaces that may be
`included in the high speed interfaces 162 include a fiber
`distributed data interface (FDDI) 164 and a multiport Eth-
`ernet interface 160. Each of these interfaces (low/medium
`and high speed) may include (1) a plurality of ports appro-
`priate for communication with the appropriate media, and
`(2) an independent processor such as the 2901 bit slice
`processor (available from Advanced Micro Devices Corpo-
`ration of Santa Clara, Calif), and in some instances
`volatile RAM. The independent processors control such
`communication intensive tasks as packet switching and
`filtering, and media control and management. By providing
`separate processors for the communication intensive tasks,
`this architecture permits the primary microprocessor 166 to
`efficiently perform routing computations, network
`diagnostics, security functions, etc.
`The low and medium speed interfaces are shown to be
`coupled to the master CPU 166 through a data, control, and
`address bus 168. High speed interfaces 162 are shown to be
`connected to the bus 168 through a fast data, control, and ,
`address bus 172 wl1icl1 is in turn connected to a bus
`controller 170. The bus controller functions are provided by
`a processor such as a 2901 bit slice processor.
`Although the system shown in FIG. 3 is an example of a
`router suitable for implementing an embodiment of the
`present invention, it is by no means the only router archi-
`tecture on which the present invention can be implemented.
`For example, an architecture having a single processor that
`handles communications as well as routing computations,
`etc. would also be acceptable. Further, other types of inter-
`faces and media could also be used with the router.
`FIG. 4 is a flow diagram of a method according to an
`embodiment of the present invention for providing processor
`redundancy in a system such as a router. According to an
`embodiment of the present invention, the method shown in
`FIG. 4 is performed for each processor, both primary and
`secondary.
`\Vhen the power is turned on (step 200), hardware dis-
`covery is performed and the Internet operating system of the
`router is booted up (step 202). Memory, such as a read-only
`memory,
`then reads hardware registers, which may be
`located in memory such as non-volatile random access
`memory (NVRAM) (step 204). Initialization sequence ofthe
`processor is then performed (step 206), and the router
`system is then run (step 208).
`FIG. 5 is a flow diagram of a method according to an
`embodiment of the present invention for performing an
`initialization sequence such as the initialization sequence of
`step 206 shown in FIG. 4. Initialization sequence is started
`(step 300). As part of the initialization sequence, subsystems
`are also initialized, including a redundancy subsystem (step
`302). There may be several items initialized between the
`start of the initialization sequence and the subsystem ini-
`tialization. For example, items included in the initialization
`sequence may include the system clock, platform hardware
`interrupt, CPU type and CPU family discovery, ehecksum
`for text segment, memory list manager, memory manager,
`platform exception handler, and console initialization. These
`initialization items and their sequence are well known to
`those of average skill in the art.
`Examples of events occurring during the subsystem ini-
`tialization include finding all subsystems, searching for
`
`6
`subsystems, enabling interrupts, starting the scheduler, and
`initiating several items such as a kernel subsystem, generic
`network support services, generic system services, system
`logger, platform console lines and auxiliary lines, platform
`interfaces, platform specific memory, platform hardware,
`and communication support. These subsystem initialization
`functions are also well known to those of average skill in the
`art,
`According to an embodiment of the present invention, the
`subsystem initialization also includes initializing a redun-
`dancy subsystem. The redundancy subsystem may be a list
`of projects or functions that are to be assigned to and
`performed by the secondary processor. These functions and
`projects may include functions and projects typically per-
`formed by the primary processor. The software designer may
`determine which functions are to be per ormed by the
`secondary processor rather than the primary processor.
`These functions are listed in the redundancy subsystem.
`Preferably, the redundancy subsystem should be initialized
`prior to initialization of the driver subsys ems since the
`initialization sequence for the secondary processor is sus-
`pended prior to the initialization of the driver subsystems
`according to an embodiment of the present
`invention.
`Accordingly, any function that is to be o -loaded to the
`secondary processor should be assigned prior to the suspen-
`sion of the initialization sequence for the secondary proces-
`sor.
`
`Initialization sequence is then suspended ‘or both primary
`and secondary processors and a discovery process is per-
`formed (step 304). One of the primary purposes of the
`discovery process is to determine whether the processor
`running this initialization sequence is a primary processor or
`a secondary processor. Further details of the discovery
`process will later be discussed in conjunction with FIG. 6.
`It is then determined whether this processor is a secondary
`processor (step 306). If it
`is a secondary processor,
`the
`initialization sequence remains suspended (step 308). The
`secondary processor then monitors the health of the primary
`processor (step 316).
`If it is determined that this processor is not a secondary
`processor (step 306), then driver subsystems are initialized
`(step 310). Thereafter,
`the remainder of the initialization
`sequence is completed (step 312), and the router system is
`run (step 314). Examples of the remainder of the initializa-
`tion sequence includes initializing the protocol subsystems,
`library subsystems, management subsystems, print hardware
`configuration on the console, reading stored configuration,
`executing configuration, and ending the initialization pro-
`cess.
`
`FIG. 6 is a flow diagram of a method according to an
`embodiment of the present
`invention for performing a
`discovery process such as the discovery process of step 304
`of FIG. 5. It is determined whether there is another processor
`other than the one executing this method (step 400). If there
`is no other processor, then the processor acts as a stand alone
`processor (step 402). Astand alone processor procedure may
`simply be a conventional router with a single processor. If,
`however, there is another processor, then it is determined
`whether this processor is a primary processor (step 404).
`One example of how this processor may be determined to be
`a primary processor is by reading one of the registers in the
`memory, such as register 184 of FIG. 3. If this processor is
`a primary processor, then a primary background process is
`initiated (step 406). Further details of the primary back-
`ground process will later be discussed in conjunction with
`FIG. 7.
`
`12
`
`
`
`US 6,460,146 B1
`
`7
`If, however, this processor is not a primary processor (step
`404), then a secondary background process is initiated (step
`406). Details of the secondary background process will later
`be discussed in conjunction with FIG. 8.
`It is then determined whether the secondary processor
`receives a command to switch with the primary processor
`(step 410). The command to switch with the primary pro-
`cessor may be initiated by a user or designed into the
`program under certain conditions by the designer. If the
`coinr11a.r1d to switch with the primary processor is received,
`then initialization process is resumed for the secondary
`processor (step 412). Thereafter, step 306 of FIG. 5 may be
`executed.
`If, however, a command to switch with the primary
`processor is not received, then it is determined whether the
`primary processor has failed (step 414). Examples of the
`failure of the primary processor include either a hardware
`failure or a software failure. If the primary processor has
`failed,
`then the initialization process is resumed for the
`secondary processor (step 412), and step 306 of FIG. 5 is
`then executed.
`If the primary processor has not failed, then it is deter-
`mined whether the primary processor card has been removed
`(step 416). If the primary processor has been removed, then
`the initialization process of this processor is resumed (step ,
`412), and step 306 of FIG. 5 is then executed.
`If the primary processor card has not been removed (step
`416), then the initialization sequence remains suspended for
`the secondary processor (step 418). A command to switch
`with the primary processor,
`the failure of the primary
`processor, and the removal of the primary processor card are
`merely examples of events that may trigger the secondary
`processor taking over the functions of the primary processor.
`Other events may be used as a trigger for the secondary
`processor to take over the functions of the primary proces-
`sor. Accordingly, if there is no event triggering the secondary
`processor taking over the functions of the primary processor,
`then the initialization sequence of the secondary processor
`remains suspended indefinitely. However, if an event trig-
`gers the taking over of the primary processor functions by
`the secondary processor at any time While the router is
`functioning, the initialization process of the secondary pro-
`cessor is resumed and the secondary processor automatically
`functions as the primary processor without
`the need to
`re—boot the system.
`FIG. 7 is a flow diagram of a method according to an
`embodiment of the present
`invention for performing a
`primary background process, such as that described in step
`406 of FIG. 6. The primary background process is performed
`for the primary processor. The primary processor establishes ,
`communication with the secondary processor (step 500).
`The primary processor also initiates the monitoring of the
`health of the secondary processor (step 502). The initializa-
`tion sequence is then resumed (step 504), and the operating
`system of the primary processor is run (step 314). The
`resumption of the initialization sequence (step 504) and
`running of the system (step 314) are equivalent to steps
`310-314 of FIG. 5.
`The primary processor then continually checks the health
`of the secondary processor (step 508). If the health of the
`secondary processor fails,
`then the state of the primary
`processor changes to a stand alone processor (step 510).
`According to an embodiment of the present
`invention, a
`processor may have multiple states, examples of these states
`include stand alone, primary, and secondary.
`FIG. 8 is a flow diagram of a method according to an
`embodiment of the present
`invention for performing a
`
`8
`secondary background process, such as that described in
`step 408 of FIG. 6. 'lhe secondary background process is run
`by the secondary processor. An example of the way the
`health of the other processor is monitored is through the use
`of registers in memory, such as registers 184 of FIG. 3. One
`of the registers may indicate whether the primary processor
`has had a failure, while another register indicates whether
`the secondary processor has had a failure.
`The secondary processor establishes communication with
`the primary processor (step 600). Health monitoring of the
`primary processor is then initiated (step 602). It is then
`determined whether there is any processing which the pri-
`mary processor is off loading to the secondary processor
`(step 604). This determination may be made by reviewing
`the list in the redundancy subsystem of step 302 of FIG. 5.
`As previously mentioned, the hst of functions in the redun-
`dancy subsystem may be created by the software developer
`and should be initialized prior to the suspension of the
`initialization sequence which preferably occurs prior to
`initializing the driver subsystems. If there is processing that
`the primary processor is off loading to the secondary
`processor,
`then these functions listed in the redundancy
`subsystem are off loaded to the secondary processor (step
`606).
`The initialization sequence then remains suspended (step
`608), however, anything that was off—loaded from the pri-
`mary processor to the secondary processor is run by the
`secondary processor. If there is no processing to be off-
`loaded from the primary processor to the secondary
`processor,
`then the initialization sequence also remains
`suspended (step 608). Thereafter, the secondary processor
`continues to monitor the health of the primary processor
`(step 610), and step 410 of FIG. 6 is executed.
`A method and system for establishing processor redun-
`dancy in a system such as a router has been disclosed.
`Software written ac