Context switch internals

by

At a high level, there are two separate mechanisms to understand. The first is the kernel entry/exit mechanism: this switches a single running thread from running usermode code to running kernel code in the context of that thread, and back again. The second is the context switch mechanism itself, which switches in kernel mode from running in the context of one thread to another.

So, when Thread A calls sched_yield() and is replaced by Thread B, what happens is:

  1. Thread A enters the kernel, changing from user mode to kernel mode;
  2. Thread A in the kernel context-switches to Thread B in the kernel;
  3. Thread B exits the kernel, changing from kernel mode back to user mode.

Each user thread has both a user-mode stack and a kernel-mode stack. When a thread enters the kernel, the current value of the user-mode stack (SS:ESP) and instruction pointer (CS:EIP) are saved to the thread’s kernel-mode stack, and the CPU switches to the kernel-mode stack – with the int $80 syscall mechanism, this is done by the CPU itself. The remaining register values and flags are then also saved to the kernel stack.

When a thread returns from the kernel to user-mode, the register values and flags are popped from the kernel-mode stack, then the user-mode stack and instruction pointer values are restored from the saved values on the kernel-mode stack.

When a thread context-switches, it calls into the scheduler (the scheduler does not run as a separate thread – it always runs in the context of the current thread). The scheduler code selects a process to run next, and calls the switch_to() function. This function essentially just switches the kernel stacks – it saves the current value of the stack pointer into the TCB for the current thread (called struct task_struct in Linux), and loads a previously-saved stack pointer from the TCB for the next thread. At this point it also saves and restores some other thread state that isn’t usually used by the kernel – things like floating point/SSE registers. If the threads being switched don’t share the same virtual memory space (ie. they’re in different processes), the page tables are also switched.

So you can see that the core user-mode state of a thread isn’t saved and restored at context-switch time – it’s saved and restored to the thread’s kernel stack when you enter and leave the kernel. The context-switch code doesn’t have to worry about clobbering the user-mode register values – those are already safely saved away in the kernel stack by that point.

More Related Contents:

  1. What is the difference between the kernel space and the user space?
  2. What are vdso and vsyscall?
  3. Image vs zImage vs uImage
  4. adding i2c client devices on x86_64
  5. How is Linux kernel live debugging done and what tools are used?
  6. Linux kernel ARM exception stack init
  7. $(uname -a) returning the same in docker host or any docker container
  8. How do I find ARM Linux entry point when it fails to uncompress?
  9. What are the implications of the linux __user macro?
  10. How does Linux determine the next PID?
  11. How does ARM Linux emulate the dirty, accessed, and file bits of a PTE?
  12. Why does Linux favor 0x7f mappings?
  13. Why my kernel log is not showing the latest output?
  14. How can Docker run distros with different kernels?
  15. Why kernel code/thread executing in interrupt context cannot sleep?
  16. Difference between physical/logical/virtual memory address
  17. Adding new driver code to linux source code
  18. How to create a new Linux kernel scheduler
  19. module_init() vs. core_initcall() vs. early_initcall()
  20. addr2line on kernel module
  21. How to use lockdep feature in linux kernel for deadlock detection
  22. What is the difference between module_init and subsys_initcall while initializing the driver?
  23. Building kernel uImage using LOADADDR
  24. Handling ARM TrustZones
  25. Sending UDP packets from the Linux Kernel
  26. Use of floating point in the Linux kernel
  27. Unexpected output when printing directly to text video memory
  28. How to continuously monitor the directory using dnotify /inotify command
  29. What is the difference between a Linux platform driver and normal device driver?
  30. Testing @Scheduled in spring

Leave a Comment