Switch from Real Mode to Protected Mode

Topic Overview

Leaving Real Mode

Protected mode enables paging, segmentation with descriptors, and ring separation. Switch requires loading a GDT, setting CR0.PE, far jumping to 32-bit code segment, and initializing segments.

Mode Switch Sequence

Steps:

• Load GDT with lgdt
• Set PE bit in CR0
• Far jump to 32-bit code selector
• Reload segment registers with data segment selectors

For example, after the far jump, CS points at a descriptor with D/B flags for 32-bit operations while DS/ES/SS use flat data selectors.

Why This Matters in Production

Every OS you've ever booted on real x86 hardware , from DOS-era systems to modern Linux , passes through this exact real-mode-to-protected-mode transition, and forgetting the far jump after setting CR0.PE is a rite-of-passage bug that leaves the CPU executing stale real-mode instructions until it triple-faults. This is also the turning point where early teaching kernels like xv6's x86 predecessors first became genuinely 32-bit.

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 implement the mode transition assembly and verify 32-bit code runs. This exercise requires explaining why a near jump immediately after setting PE is illegal on x86.

Your Task

Simulate the real-mode to protected-mode switch as a CPU sees it. In real mode, loading a segment register just sets base = selector × 16, and with the A20 line disabled, addresses wrap at 1 MiB. After lgdt and setting CR0.PE, the CPU is in protected mode, but every segment register still holds its cached real-mode descriptor until it's reloaded. The far jump reloads CS, and moves into DS/ES/SS reload the others. Each of these loads now goes through the GDT, with protection checks that raise faults.

Commands

Loading a segment register

• Real mode: base = SEL × 16, limit = 0xFFFF, never faults.

• Protected mode (checked in this order, for selector SEL with index SEL >> 3):

  1. bit 2 (TI) set → #GP (LDT selector, no LDT loaded);
  2. index 0: for CS or SS → #GP (null selector); for DS/ES the load succeeds, but any later access through it is #GP (null segment);
  3. no GDT loaded, index beyond it, or entry undefined → #GP (selector beyond GDT limit);
  4. CS needs a code segment, DS/ES/SS a data segment → #GP (not a code segment) / #GP (not a data segment);
  5. not present → #NP (segment not present), or #SS (segment not present) for SS;
  6. otherwise copy base and limit into the register's cache.

  A faulting load leaves the register unchanged. mov cs, … always prints mov cs: #UD (cannot load cs with mov).

• access: an offset above the cached limit → #GP (offset beyond limit L). Otherwise linear = base + offset, masked to 20 bits in real mode with A20 off (report (wrapped, A20 off) when the mask changed it).

Output

cCopy
Loading…

Faults replace the success text: ljmp 0x18:0x0: #GP (not a code segment), mov ss, 0x0: #GP (null selector). Numbers print in lower-case hex without leading zeros, except where widths are shown.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Each segment register keeps a selector plus a cached base/limit (and whether a null selector was loaded). access uses only the cache, which is why the CPU keeps running right after setpe.
2. The protected-mode checks live in one load_segment function shared by ljmp and mov.

Hidden tests cover every fault (LDT selector, null CS/SS, index beyond the GDT, wrong segment type, not-present data and stack segments), a limit violation, a non-zero segment base, and accessing through a stale real-mode cache after setpe.