CN101794242B - Fault-tolerant computer system data comparing method serving operating system core layer - Google Patents

Abstract

The data comparison method of the fault-tolerant computer system serving the core layer of the operating system provides data comparison services for the dual-mode redundant process in the fault-tolerant computer system by starting the kernel daemon process in the Linux operating system and executing the data comparator logic. Add an event linked list in the kernel as a message channel, the redundant process and the data comparator work in a production-consumption mode, the redundant process encapsulates the data to be written into a message packet and inserts it into the message linked list, and the comparator removes the message package from the message linked list , parse the message packet according to the defined format and compare the data to be written by the redundant process, and finally return the result to the redundant process. The invention is implemented at the core layer of the operating system without hardware customization, and is simple to implement, and is suitable for a process-level dual-mode redundant fault-tolerant system based on a common hardware architecture, and has good versatility. All comparison logic is automatically completed at the core layer of the operating system, without the participation of the application program, and has good transparency to the application.

Description

Data comparison method of fault-tolerant computer system serving operating system core layer

technical field

The invention belongs to the field of computers, and relates to computer fault-tolerant technology and data comparison technology, in particular to a fault-tolerant computer system data comparison method serving the core layer of an operating system.

Background technique

With the rapid development of computer and Internet technology, informatization has penetrated into all aspects of society. Computer technology has greatly changed people's lifestyles in terms of improving work efficiency and promoting information exchange. With more and more dependence, a failure of a computer system may bring immeasurable losses. For those institutions that need to ensure information security and provide uninterrupted information services, such as securities, manufacturing, communications, banking, and transportation, the reliability and uninterruptibility of business systems are particularly important. How to improve the reliability and availability of computer systems, so as to ensure the continuous operation of various key applications and achieve a virtuous cycle of sustainable operation, has become an important issue in the information field. Fault-tolerant computers and related technologies emerge at the historic moment under such objective demands. The use of fault-tolerant computers can avoid tens of thousands of economic losses caused by server failures.

Fault-tolerant computer is based on redundant resources (hardware redundancy, time redundancy, information redundancy, software redundancy), through the design of a reasonable architecture, and under the effective management of system software, it is highly reliable and highly available. computer. Fault detection is one of the key technologies to realize fault-tolerant computer system, and the comparison and voting of task data are the main means of fault discovery.

There are mainly two methods for data comparison and voting: hardware-based and software-based. The hardware-based method adds a comparison chip to the system. The chip contains comparison or voting logic to compare and vote on all the data to be written. This method finds errors in a timely manner, but the design is complicated and the implementation cost is high. The software-based method sets comparison and voting points in the library function or application program, and makes a consistency judgment on the intermediate results and final output of the task. This method is simple in system design, but has poor transparency to applications, which brings great harm to programmers and users. additional burden.

Contents of the invention

The purpose of the present invention is to provide a kind of fault-tolerant computer system data comparison method serving the core layer of the operating system in view of the shortcomings and deficiencies of the above-mentioned prior art. Sexual comparison, while recording the synchronous comparison information of redundant tasks.

In order to realize above-mentioned task, the present invention adopts following technical solution: create kernel mode daemon process ft_syner in Linux operating system kernel, execute comparator logic, provide data comparison service for redundant process; When redundant process is carrying out write operation, Prepare the data to be written separately, and then the main process encapsulates the data to be written into a message packet, and then adds the message packet to the redundant process and the data comparator communication channel, and actively wakes up the data comparator ft_syner for data comparison. After the ft_syner completes the data comparison, the redundant process obtains the comparison result by checking the comparison result field in the message packet.

The implementation of the communication channel is as follows: an event chain list ft_syner_event_list is created in the Linux operating system kernel, and the redundant process and the data comparator realize communication through the event chain list ft_syner_event_list.

The data comparator and the redundant process work in a survivor-consumer mode. The redundant process organizes the data to be compared into a message packet according to the protocol format and then hooks it into the event chain list ft_syner_event_list, and the comparator removes it from the event chain list ft_syner_event_list A message package from which data information is extracted for comparison.

The format of the message packet is:

typedef struct{

struct list_head list;

short ft_msg_type;

struct task_struct*p1;

struct task_struct*p2;

void *master_data;

long master_data_len;

void *slave_data;

long slave_data_len;

short error;

} ft_syner_event_msg;

Among them, list is the head of the linked list, which is used to hang the message package into the event linked list. The list_head is used as the general linked list structure of the Linux kernel. The insertion and deletion of the message package are completed using list_add() and list_del() in the kernel;

ft_msg_type is the message type, indicating which type of system call the message packet comes from. The specific values are defined as follows:

#define FT_WRITE 1 //write() system call

#define FT_WRITEV 2 //writev() system call

#define FT_SEND 3 //send() system call

#define FT_SENDTO 4 //sendto() system call

#define FT_SENDMSG 5 //sendmsg() system call

The comparator judges which type of system call the message packet is generated from according to the value of the ft_msg_type message type, and the above definition can be expanded or cut according to requirements;

p1, p2 are the process control block pointers of the redundant process pair that generates the message packet, p1 is the master process, and p2 is the slave process, and the comparator obtains the process control block of the redundant process pair through these two pointers;

master_data is the data buffer pointer of the master process in the redundant process pair, and master_data_len is the buffer length;

slave_data is the data buffer pointer of the slave process in the redundant process pair, and slave_data_len is the buffer length;

error records the comparison result, a value of 1 indicates that the data is consistent, and a value of 0 indicates that the data is inconsistent.

The data comparator is a kernel-mode daemon process ft_syner created in the Linux operating system kernel, which resides in the operating system kernel, executes comparator logic, and provides data comparison services for redundant processes. The kernel state daemon ft_syner is in a waiting state when it is idle, and can be woken up by redundant processes when there are tasks, or it can be woken up periodically by itself. After each wake-up, the kernel state daemon ft_syner traverses the event list ft_syner_event_list and removes each event in the list. The message packets are parsed and the data is compared. After parsing all the message packets in the current event chain list, the kernel state daemon process ft_syner calls the function sleep_on_timeout() to enter the waiting state. In this function, the waiting period is set to 5 seconds. After the waiting time is exhausted, the kernel state daemon process ft_syner is awakened and enters the next state. A round of traversal.

The redundant process needs to increase the master-slave attribute. When the redundant process executes the write operation, it prepares the data to be written respectively, and then the master process encapsulates the data to be written into a message packet, and passes list_add(&(msg->list ), &ft_syner_event_list) add the message packet to the event chain list ft_syner_event_list, and actively wake up the kernel-mode daemon process ft_syner, after the kernel-mode daemon process ft_syner completes the data comparison, the redundant process can obtain the comparison result by detecting msg->error.

Data comparator of the present invention provides data comparison service in the mode of kernel daemon process, and redundant process utilizes data comparator when calling write (), writev (), send (), sendto (), sendmsg () relevant write operation The service completes the comparison of the data to be written in the operation. That is, by starting the kernel daemon process ft_syner in the Linux operating system, the process executes the data comparator logic to provide data comparison services for the dual-mode redundant process in the fault-tolerant computer system. The event list ft_syner_event_list added in the kernel is used as a message channel. The redundant process and the data comparator work in a production-consumption mode. The redundant process encapsulates the data to be written into a message packet and inserts it into the message list. The comparator is removed from the message list. Parse the message packet and perform data comparison, and finally return the result to the redundant process. The invention simply and reliably completes the data comparison of redundant processes in the dual-mode fault-tolerant system in the mode of software at the core layer of the operating system. This method is implemented at the core layer of the operating system without hardware customization. It is suitable for process-level dual-mode redundant fault-tolerant systems based on general hardware architecture. All logic is automatically completed at the core layer of the operating system without the participation of application programs. It has a good impact on applications. transparency.

Description of drawings

Fig. 1 is the working flow chart of data comparator among the present invention;

Fig. 2 is a schematic diagram of the interaction between the redundant process and the data comparator in the present invention.

Detailed ways

The present invention will be described in further detail below in conjunction with the accompanying drawings.

Method of the present invention is as follows:

Create a kernel state daemon process ft_syner in the kernel of the Linux operating system, execute comparator logic, and provide data comparison services for redundant processes; when redundant processes perform write operations, they prepare data to be written, and then the main process writes the data to be written The data is encapsulated into a message packet, and then the message packet is added to the redundant process and the data comparator communication channel, and the data comparator ft_syner is actively awakened to perform data comparison. After the data comparator ft_syner completes the data comparison, the redundant process passes the detection message packet The comparison result field in to get the comparison result.

The implementation of the communication channel is as follows: an event chain list ft_syner_event_list is created in the Linux operating system kernel, and the redundant process and the data comparator realize communication through the event chain list ft_syner_event_list.

The data comparator and the redundant process work in a survivor-consumer mode. The redundant process organizes the data to be compared into a message packet according to the protocol format and then hooks it into the event chain list ft_syner_event_list, and the comparator removes it from the event chain list ft_syner_event_list A message package from which data information is extracted for comparison.

The format of the message packet is:

typedef struct{

struct list_head list;

short ft_msg_type;

struct task_struct*p1;

struct task_struct*p2;

void *master_data;

long master_data_len;

void *slave_data;

long slave_data_len;

short error;

} ft_syner_event_msg;

Among them, list is the head of the linked list, which is used to hang the message package into the event linked list, using list_head as the general linked list structure of the Linux kernel, and the insertion and deletion of the message package are completed using list_add() and list_del() in the kernel;

ft_msg_type is the message type, indicating which type of system call the message packet comes from. The specific values are defined as follows:

#define FT_WRITE 1 //write() system call

#define FT_WRITEV 2 //writev() system call

#define FT_SEND 3 //send() system call

#define FT_SENDTO 4 //sendto() system call

#define FT_SENDMSG 5 //sendmsg() system call

The comparator judges which type of system call the message packet is generated from according to the value of the ft_msg_type message type, and the above definition can be expanded or cut according to requirements;

p1, p2 are the process control block pointers of the redundant process pair that generates the message packet, p1 is the master process, and p2 is the slave process, and the comparator obtains the process control block of the redundant process pair through these two pointers;

master_data is the data buffer pointer of the master process in the redundant process pair, and master_data_len is the buffer length;

slave_data is the data buffer pointer of the slave process in the redundant process pair, and slave_data_len is the buffer length;

error records the comparison result, a value of 1 indicates that the data is consistent, and a value of 0 indicates that the data is inconsistent.

The data comparator is a kernel-mode daemon process ft_syner created in the Linux operating system kernel, which resides in the operating system kernel, executes comparator logic, and provides data comparison services for redundant processes. The kernel state daemon ft_syner is in a waiting state when it is idle, and can be woken up by redundant processes when there are tasks, or it can be woken up periodically by itself. After each wake-up, the kernel state daemon ft_syner traverses the event list ft_syner_event_list and removes each event in the list. The message packets are parsed and the data is compared. After parsing all the message packets in the current event chain list, ft_syner calls the function sleep_on_timeout() to enter the waiting state. In this function, the waiting period is set to 5 seconds. After the waiting time is exhausted, ft_syner is awakened to enter the next round of traversal.

The redundant process needs to increase the master-slave attribute. When the redundant process executes the write operation, it prepares the data to be written respectively, and then the master process encapsulates the data to be written into a message packet, and passes list_add(&(msg->list ), &ft_syner_event_list) add the message packet to the event chain list ft_syner_event_list, and actively wake up the data comparator ft_syner, after the data comparator ft_syner completes the data comparison, the redundant process can obtain the comparison result by detecting msg->error.

The workflow of the data comparator shown in Figure 1 is:

(1) The comparator process ft_syner calls spin_lock() to obtain the spin lock of the message list;

(2) Judge whether the message linked list ft_syner_event_list is empty, if it is idling (6), if it is not idling (3);

(3) Obtain a message packet msg in the linked list, parse the message packet and complete data comparison;

(4) Use list_add() in the kernel to delete the processed message packet from the message list;

(5) If there are unprocessed remaining message packets in the message linked list, turn to (3), otherwise turn to (6);

(6) Call spin_unlock() to release the spin lock of the message list;

(7) The comparator process ft_syner calls sleep_on_timeout() to enter sleep and wait;

(8) The process ft_syner wakes up passively after the waiting time period arrives, or is actively woken up by a redundant process;

(9) Judge the flag bit finish, if finish is 1, it means that the request to end the comparator service is received, ft_syner ends, if finish is 0, turn to (1) to enter the next round of service.

Figure 2 shows the interaction process between the redundant process and the data comparator. The figure takes the write() operation as an example. The redundant processes P1 and P2 need to perform data comparison when executing the write() operation. The redundant process encapsulates the data to be compared in the message packet msg, inserts it into the message list, and wakes up data comparator. The comparator removes the message package from the message list, parses the message package according to the format definition, and compares the two data in the package for consistency, and stores the comparison result in msg->error. Finally, the redundant process obtains the comparison result by looking at the value of msg->error.

Claims (1)

1. The operating system core layer system data comparison method serving a fault-tolerant computer is characterized in that, at first, a kernel state daemon process ft_syner is created in the Linux operating system kernel, and its effect is to perform comparator logic to provide data comparison services for redundant processes ; Secondly, when the redundant process prepares the data to be written respectively during the execution of the write operation, the main process encapsulates the data to be written into a message packet and adds the message packet into the communication channel between the redundant process and the data comparator, and actively Wake up data comparator and carry out data comparison; Finally data comparator completes data comparison, redundant process obtains comparison result by detecting the comparison result field in the message packet; Described communication channel, implementation is as follows: create event in Linux operating system kernel The linked list ft_syner_event_list, the redundant process and the data comparator communicate through the event linked list ft_syner_event_list; the data comparator and the redundant process work in a survivor-consumer mode, and the redundant process organizes the data to be compared into message packets according to the protocol format and then hangs Connected in the event chain list ft_syner_event_list, the comparator takes off the message packet from the event chain list ft_syner_event_list and extracts data information therefrom for comparison; the data comparator is a kernel state daemon process ft_syner created in the Linux operating system kernel, It resides in the kernel of the operating system, executes the comparator logic, and provides data comparison services for redundant processes. The kernel state daemon process ft_syner is in a waiting state when it is idle, and is awakened by the redundant process when there is a task, or wakes up periodically by itself. The kernel state daemon process After the process ft_syner wakes up each time, it traverses the event chain list ft_syner_event_list, removes each message packet in the chain list for analysis, and compares the data. After parsing all the message packets in the current event chain list, the kernel state daemon process ft_syner calls the function sleep_on_timeout enters the waiting state, and the waiting period is set to 5 seconds in this function. After the waiting time is exhausted, the kernel state daemon process ft_syner is awakened to enter the next round of traversal; the redundant process needs to increase the master-slave attribute, and the redundant process is executing During the write operation, the data to be written is prepared separately, and then the main process encapsulates the data to be written into a message packet, and adds the message packet to the event chain list ft_syner_event_list through the function list_add, and actively wakes up the kernel mode daemon process ft_syner, in the kernel mode daemon process After ft_syner completes the data comparison, the redundant process obtains the comparison result by checking the value of msg.

Images