KR100420268B1 - Kernel scheduling method using stacks - Google Patents

Abstract

The present invention relates to a kernel scheduling method using a stack.

According to the present invention, a step in which an application process is waiting for data processing and a read process waiting on a read stack (S10), a kernel process starts an activity, wakes up a read process waiting on the read stack, and transfers desired data to the application process. Waiting for the interruption of the write process after transmission (S20, S30, S40) and the application process processing a predetermined task based on the received data and responding to the kernel process through the write process (S50), and the write process wakes up the kernel process waiting on the write stack, and sends a response data and then terminates the process,

Accordingly, when the process is held in a security system that must determine the priority of the kernel process in real time, the system can be operated efficiently by changing the execution order of the processes.

Description

Kernel scheduling method using stack {KERNEL SCHEDULING METHOD USING STACKS}

The present invention relates to a kernel scheduling method of a computer network system, and more particularly, a kernel using a stack that provides a predetermined service by prioritizing kernel processes in real time using a stack mechanism using a last-in-first-out (LIFO) method. It relates to a scheduling method.

In general, a stacking technique used in a computer network system is one application process is used to control access to the same type of data, or multiple application processes are used to establish synchronization with each other. This is used when allocating memory or saving processes in an application program or system that you write yourself.

In particular, all communication used between the application and the kernel of the computer network system is subject to the LILO principle based on the concept that the process that first requested the service is legitimate and efficient, and the kernel exceptions. Only some localized processes, such as processing, have the highest priority and receive service regardless of the priority of the request.

In other words, the kernel scheduling method used in the conventional computer network system basically has a process in which a process first inputted through a last-in, last-out (LILO) technique is first provided with a service.

For example, a system having a client / server structure such as a firewall, an intrusion detection system, a security system such as a backtracking system, or an IPsec system uses a kernel that processes a process using a kernel scheduling method of the last-in, last-out method.

However, using the kernel scheduling method of the last-in, last-out method, there is an advantage that the system can provide a service in a legitimate flow according to the priority, but since the service is provided in the order of request, the priority in real time. There is a drawback to provide only one-dimensional services without determining.

In fact, in the system using the kernel scheduling method of the last-in, last-out method, since the priorities of kernel processes are not determined dynamically, they are specified in advance in system construction.

In particular, in the case of the IPsec system, although it is frequently required to transmit an IKE (Internet Key Exchange) packet to be transmitted later, there is a disadvantage that this problem cannot be solved.

Accordingly, the present invention is to overcome the above-mentioned conventional problems, and an object of the present invention is to have a high priority by using a stack mechanism using a last-in first-out method with a queue structure provided by the kernel as an internal element as an argument. The process provides a kernel scheduling method using a stack providing a predetermined service by determining the priority of the kernel process in real time by allowing the service to be received first regardless of the service request order.

In the kernel scheduling method using a stack to achieve the object of the present invention, the application process is waiting for data processing, the read process is waiting on the read stack, the kernel process starts the activity and waits on the read stack Wake up the current read process, transfer the desired data to the application process, and wait on the write stack waiting for the interruption of the write process, and after the application process processes a predetermined task by the received data, the kernel through the write process Responding to the process, and waking up the kernel process waiting for the write process on the write stack, transmitting the response data, and terminating the process.

1 is a conceptual diagram illustrating a kernel scheduling method using a stack according to the present invention;

2 is a flowchart illustrating a kernel scheduling method using a stack according to the present invention.

Hereinafter, a kernel scheduling method using a stack according to the present invention will be described in detail with reference to the accompanying drawings.

1 and 2, in an initial state of a system in which a kernel scheduling method using a stack according to the present invention is executed, an application process waits for data processing and a read process waits on a read stack read_stack ( S10).

At this time, the read process waits in a read queue in synchronization with a known sleep_on function and a signal.

When a kernel process starts to be active, such as sending a packet to the network in the initial state of such a system, the kernel process generates an interrupt in synchronization with a known wake_up_ function and a signal to wait on the read stack. The read process is awakened (S20), and thus the read process is synchronized with a known copy_to_user function and a signal to transmit the desired data to the application process and waits again in the read stack ( S30).

At the same time, the kernel process waits for the interruption of the write process and waits in the write stack (write_stack) using the last-in, first-out method with the queue structure provided by the kernel as an argument (S40).

In this case, the kernel process registers its process ID in the write stack, determines whether the process to be executed is a preprocessing process having a higher priority than the previously arrived process, and waits in the write stack if the process is a preprocessing process. If there is a non-processing process that has not been previously processed, it waits in a write queue (write_queue) of the write stack provided by the kernel, and waits in the write stack if not present.

When a predetermined data is transmitted to the application process as described above, the application process performs a predetermined task based on the received data, and accordingly, the writing process is synchronized by a known copy_from_user function and signal. Then, the response data is transmitted to the kernel process (S50).

At this time, the write process is synchronized with a copy_prompt_user function and a signal to take out the highest write queue of the write stack, generate an interrupt, and transmit response data to the kernel process.

At the same time as sending the response data to the kernel process, the write process wakes up the kernel process waiting on the write stack in synchronization with a known wake_up function and signal (S60).

At this time, the write process wakes up the kernel process according to a result of determining whether the write queue is empty by executing a dequeue to extract a process ID for the write queue.

If it is determined that the write queue is empty, another newly created kernel process is woken up. If the write queue is not empty, the kernel process waiting for the write stack is woken up.

In the kernel scheduling method using the stack according to the present invention performed as described above, if another kernel process is generated while the application process performs the corresponding task and requests another task from the application process, the application process first After performing the requested operation, do the later work.

However, since a kernel process waiting on the write stack uses the first-in-first-out method with the queue stack as a parameter, a later requested kernel process may be provided with a service first. In such a case, in a conventional IPsec system This can be applied to cases in which IKE negotiation is required before sending a packet.

As described above, in the kernel scheduling method using the stack according to the present invention, a process having a high priority by using a stack mechanism using a last-in first-out method with the queue structure provided by the kernel as an internal element has a service request sequence and Regardless of whether a process is held in a security system that needs to determine the priority of the kernel process in real time, it is necessary to determine the priority of the kernel process in real time so that the service can be received first. By changing the order of execution, the system can be operated efficiently.

In addition, it can be applied to the communication between the kernel and the application of the system that must forcibly determine the process priority, such as an IPsec system, and in a distributed Internet environment where it is practically impossible to restrict all network nodes, all network nodes are kernels in real time. Scheduling provides a basis for systems to operate organically.

In particular, in terms of network traffic, if a kernel process needs to be held in order to provide appropriate network services, the administrator and the user can be transparent since the time at which the kernel process should wake up can be determined as the end of the process. You can control the system and network reliably.

What has been described above is only one embodiment for implementing a kernel scheduling method using a stack according to the present invention, and the present invention is not limited to the above-described embodiment, and is claimed in the following claims. Without departing from the gist of the present invention, one of ordinary skill in the art will have the technical spirit of the present invention to the extent that various modifications can be made.

Claims (3)

The application process is waiting for data processing and the reading process is waiting on the read stack; When a kernel process wakes up a read process waiting on the read stack, the read process sends the desired data to the application process, the kernel process waits on the write stack waiting for the interrupt of the write process, When the application process processes a predetermined task according to the received data, the writing process generates an interrupt and transmits response data to the kernel process, and At the same time as sending the response data to the kernel process, the write process wakes up another kernel process waiting on the write stack and terminates the process, The kernel process takes a queue structure provided by the kernel as an argument and waits on a write stack using a last-in-first-out (LIFO) method. The kernel process waits in the write-in-first-out (LIFO) write stack if the process to be executed is a preprocessing process with higher priority than the previously arrived process, and in the write queue of the write stack provided by the kernel in the case of a non-processing process. Kernel scheduling method using a stack, characterized in that waiting. delete delete