Implement Context Switch in Assembly

Topic Overview

Kernel Thread Switch

Your mini-kernel switches between tasks using the same callee-saved register contract as userspace schedulers, but on kernel stacks allocated per task. Save rsp, switch page tables if processes differ, restore and return into the next task.

Per-Task Kernel Stack

Switch steps:

• Push flags and callee-saved regs on current stack
• Store rsp in task struct
• Load next rsp, pop registers, iret or ret depending on model

For example, task A stack top at 0xC0401000, task B at 0xC0402000; only rsp and CR3 change between them.

Why This Matters in Production

The pusha/popa register save-and-restore sequence you're simulating here is exactly what xv6's swtch.S and every real x86 kernel's context switch does to move the CPU from one task's stack to another's. Forgetting to save ESP separately (pusha doesn't cover it) is a classic bug that corrupts a task's entire stack the moment it resumes, wiping out every local variable it had in flight.

Debugging Checklist

Before you call the implementation done, walk failure modes on purpose. Test empty structures, single-element edge cases, maximum concurrency, and errno paths that must not crash the program. OS code usually fails in production when happy-path tests pass but invariants break under contention or memory pressure.

Implementation Notes

Keep structures small and name fields after kernel counterparts when possible. That lets you read man pages and kernel source side by side while you work. Print observable events during development; remove noisy logs once tests pass reliably.

For This Exercise

You will write switch_to in assembly integrated with your scheduler queue. This exercise requires verifying that FPU/SSE state policy is documented (lazy vs eager).

Your Task

Trace the 32-bit x86 context switch that every kernel scheduler ends up calling:

asmCopy
Loading…

The caller-saved registers are already saved by the caller, so the switch only has to save the four callee-saved ones. It then swaps stacks, and ret "returns" into the other task. A task that has never run gets a fake frame on its stack, so the same pop/ret sequence launches it at its entry point.

Input

cCopy
Loading…

At start, task boot is running with eip 0x7c00, esp 0x9000, and all four registers zero.

Rules

• spawn writes ENTRY at STACKTOP-4 and four zero words below it, and sets the saved esp to STACKTOP-20.
• switch pushes RETADDR (the effect of call), then pushes ebp, ebx, esi and edi. It saves esp into the old task, loads the new task's saved esp, pops edi, esi, ebx and ebp, and finally ret pops eip. Every push decrements esp by 4 before storing. Memory that was never written reads as 0.
• Switching to the running task prints switch N -> N: already running, nothing to do. An unknown name prints switch N: no such task.
• stack shows the five saved words of a task that is not running, starting at its saved esp. For the running task it prints stack N: running (esp 0x...).
• set on any other register prints set R: only ebp, ebx, esi and edi can be set. A duplicate spawn prints spawn N: name taken or too many tasks (the limit is 8 tasks).

Output

cCopy
Loading…

Every value is printed as 0x followed by 8 hex digits. The columns match the example exactly.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Model the stacks as memory (address → 32-bit word). Keep only the saved esp in each task, not a copy of its registers, because the registers live on the task's own stack.
2. Build the fake frame so that the normal pop/ret path starts a new task. Do not add a special case for the first run.

Hidden tests cover three tasks switching round-robin with different register values, a task resuming at the return address of its last call, the saved frames of sleeping tasks, switching to the running task, unknown task names, setting a caller-saved register, duplicate spawns, and stack on the running task.