CPU如何在上下文切换中保存寄存器状态？汇编实现问询

Great question! Context switching is one of those core OS concepts that clicks once you get hands-on with the assembly behind it. Let’s break down how you’d save register state to a PCB (Process Control Block) using x86 assembly—since it’s the most common architecture taught in OS courses.

First, let’s set the stage: a PCB is just a block of memory that holds all the critical state a process needs to resume later. We’ll define a simple memory layout for our PCB so we know exactly where to store each register.

Step 1: Define Your PCB Memory Layout #

First, we’ll assign offsets for each register in the PCB. This tells our assembly code where to write each register’s value:

; Simple PCB structure offsets (x86 32-bit)
PCB_EAX      equ 0       ; Offset for EAX register
PCB_EBX      equ 4       ; Offset for EBX register
PCB_ECX      equ 8       ; Offset for ECX register
PCB_EDX      equ 12      ; Offset for EDX register
PCB_EBP      equ 16      ; Offset for EBP (base pointer)
PCB_ESP      equ 20      ; Offset for ESP (stack pointer)
PCB_EIP      equ 24      ; Offset for EIP (instruction pointer)
PCB_EFLAGS   equ 28      ; Offset for FLAGS register
PCB_CS       equ 32      ; Offset for CS (code segment)
PCB_DS       equ 34      ; Offset for DS (data segment)

Step 2: Load the PCB’s Base Address #

Before we can write to the PCB, we need its starting memory address in a register (since assembly requires a base register to access memory). Let’s assume we have a global variable pointing to the current process’s PCB:

mov ebx, [current_pcb]  ; Load address of current PCB into EBX

Step 3: Save General-Purpose Registers #

Now we’ll write each register’s value to its corresponding offset in the PCB. A quick note: since EBX holds our PCB address, we’ll save it last (or stash it in a temporary register first to avoid overwriting it):

; Save EAX, ECX, EDX first
mov [ebx + PCB_EAX], eax
mov [ebx + PCB_ECX], ecx
mov [ebx + PCB_EDX], edx

; Save stack and base pointers
mov [ebx + PCB_EBP], ebp
mov [ebx + PCB_ESP], esp  ; Important: saves the current stack top

; Now save EBX (we can use ESI as a temporary holder)
mov esi, ebx
mov [esi + PCB_EBX], ebx

Step 4: Save Special Registers (EIP, FLAGS, Segments) #

These registers need extra care because they’re not just general-purpose:

• EIP: The instruction pointer tells us where the process left off. When a context switch is triggered (like an interrupt), the CPU automatically pushes EIP (along with CS and FLAGS) onto the stack. We can grab it from there:

  ; In an interrupt handler, the stack holds: EFLAGS → CS → EIP (top to bottom)
  mov eax, [esp + 8]       ; Fetch EIP from the interrupt stack frame
  mov [ebx + PCB_EIP], eax
  

• FLAGS: This register holds CPU status (like carry, interrupt flags). We can grab it directly or from the stack:

  mov eax, [esp]           ; Fetch EFLAGS from the stack
  mov [ebx + PCB_EFLAGS], eax
  

• Segment Registers: In protected mode, segments define memory access permissions—we need to save these too:

  mov ax, cs
  mov [ebx + PCB_CS], ax
  mov ax, ds
  mov [ebx + PCB_DS], ax
  

Key Notes for Real-World Use #

• Architecture Differences: If you’re working with x86_64 or ARM, the register set is larger (e.g., R0-R15 in ARM), but the core logic stays the same: map each register to a PCB offset and write the value.
• CPU-Assisted Saving: Most context switches are triggered by interrupts, and modern CPUs automatically save a subset of registers to the stack before jumping to the interrupt handler. You only need to save the remaining ones.
• Stack Safety: Always double-check that you’re saving the correct ESP value—this is critical for restoring the process’s stack later.

内容的提问来源于stack exchange，提问作者user129137