Switching and general execution of processes

Zhu Hengzhi + Original works reproduced please specify the source + "Linux kernel analysis" MOOC course http://mooc.study.163.com/course/USTC-1000029000 "

Scheduling timing of processes and switching of processes

The principle of operating system describes a large number of process scheduling algorithms, these algorithms from the perspective of implementation is only to choose a new process from the run queue, the process of selecting the use of different strategies.

It is more important to understand the working mechanism of the operating system than the process scheduling timing and process switching mechanism.

Timing of process scheduling

Interrupt processing (including clock interrupts, I/O interrupts, system calls, and exceptions), call schedule () directly, or call schedule () based on the need_resched tag when returning to the user state;

Kernel threads can directly call schedule () for process switching, or in the process of interrupt processing, which means that kernel threads as a special kind of process can be active scheduling, but also can be passively dispatched;

The user-state process is not able to implement active scheduling, only can be dispatched by a certain point in time after the kernel state, that is, scheduling during interrupt processing

Switching of processes

To control the execution of the process, the kernel must have the ability to suspend a process that is executing on the CPU and resume execution of a previously suspended process called process switching, task switching, context switching;

Suspending a process that is executing on the CPU is different from saving the scene at the time of the outage, before and after the interrupt is in the same process context, but only by the user-state to the kernel state execution;

The process context contains all the information required by the process execution

User address space:
Including program code, data, user stack, etc.

Control information
: Process descriptor, kernel stack, etc.

Hardware context (note that interrupts are also saved by the hardware context only if the method is saved differently)

The schedule () function selects a new process to run and invokes Context_switch for context switching, a macro called SWITCH_TO for critical context switching

Next = Pick_next_task (RQ, prev);//process scheduling algorithms encapsulate this function inside

Context_switch (RQ, Prev, next);//process Context switch

Switch_to takes advantage of the prev and next two parameters: Prev points to the current process, and next points to the scheduled process

general execution of Linux systems

The most common scenario: The running user-state process x switches to the process of running user-state process y

1. Running user-state process X

2. An interrupt occurred--save cs:eip/esp/eflags (current) to kernel Stack,then load Cs:eip (entry of a specific ISR) and SS:ESP (point to Kernel Stack).

3. Save_all//Save site

4. Schedule () is called during interrupt processing or before an interrupt is returned, where SWITCH_TO does a critical process context switch

5. The user-state process y is started after the label 1 (where Y has been switched out through the above steps so it can continue from label 1)

6. Restore_all//Recovery site

7. Iret-pop cs:eip/ss:esp/eflags from kernel stack

8. Continue to run user-state process y

Several special cases

• By interrupting the timing of the processing process, the user-state process and kernel threads switch between each other and the kernel threads switch to each other, very similar to the most common situation, but the kernel thread is running in the process of interruption without process user state and kernel state conversion;

• Kernel thread actively calls schedule (), only the process context of the switch, there is no interrupt context switch, and the most general situation is slightly abbreviated;

• The system call that creates the child process starts in the subprocess and returns the user state, such as fork;

• A situation in which a new executable program is loaded and returned to the user state, such as EXECVE;

Experimental section:

The process of understanding process scheduling and process switching during the time-tracking analysis process

1. To understand the timing of process scheduling in Linux, you can search the kernel code for the schedule () function, see where the schedule () is called, and determine whether the summary of our course content is accurate;

2. Use GDB trace to analyze a schedule () function to verify your understanding of Linux system process scheduling and process switching process, and recommend to complete the experiment in the lab Building Linux virtual Machine environment.

3. Special attention and careful analysis of the assembly code in the Switch_to, understanding the process context of the switching mechanism, as well as the relationship with the interrupt context switch;

4. Based on this week's knowledge analysis and understanding of Linux process scheduling and process switching process, write a signed blog, and in the blog post "real name (and the name of the final application certificate must be consistent) + Original works reproduced please specify the source +" Linux kernel Analysis "MOOC Course/http mooc.study.163.com/course/ustc-1000029000 ", the specific requirements of the blog content are as follows:

1. The topic is self-proposed, and the content revolves around the timing and process switching of the process scheduling;

2. Can combine key code, experiment, stack state, CPU register state, etc.

3. The blog content needs to carefully analyze the scheduling timing of the process, switch_to and corresponding stack state.

4. The summary section needs to clarify your understanding of the "Linux system General execution process"

Switching and general execution of processes