p15-initproc: First Process Execution with Segmentation-Based Isolation

[Yash-Rawat-IIT-D]

p15-initproc First Process Execution

---

Branch: p14-segments (merged p14 + implemented p15)
Type: Original implementation
Impact: Process management infrastructure with first user-space process

Context:
Built on p14-segments (PR #24). Implements complete process management infrastructure to create and run the first user-space process with proper memory isolation using x86 segmentation and privilege levels.

---

Changes Made:

1. Process Management Core (src/proc.rs - 235 lines, NEW)

   // Data structures
   - Context: Callee-saved registers for context switching
   - ProcState: Process states (Unused, Embryo, Runnable, Running)
   - Proc: Per-process state (stack, pid, trapframe, context, cwd, name)
   - Cpu: Per-CPU state with scheduler context and current proc pointer
   
   // Functions
   - cpuid(): Returns current CPU ID (single CPU: 0)
   - mycpu(): Returns current CPU structure
   - myproc(): Returns current process (Option wrapper for safety)
   - allocproc(): Finds unused process, initializes trapframe/context
   - pinit(): Creates first process from initcode binary
   - scheduler(): Round-robin process scheduler (never returns)

   • Static process table with OnceCell<PTable> (64 processes max)
   • Uses addr_of_mut!() for Rust compatibility (no static mut warnings)
   • Stack layout: Process memory high → Trapframe → Context → stack grows down

2. Context Switching (swtch.S - 22 lines, NEW)

   swtch:
     movl 4(%esp), %eax      # Get new context pointer
     movl %eax, %esp         # Switch stacks
     movl $0, %eax           # Clear return value
     popl %edi               # Restore callee-saved registers
     popl %esi
     popl %ebx
     popl %ebp
     ret                     # Return to new context's eip

   • Saves/restores callee-saved registers (edi, esi, ebx, ebp)
   • Caller-saved registers (eax, ecx, edx) handled by C calling convention

3. First User Process (initcode.S - 10 lines, NEW)

   .globl start
   start:
     add $1, %eax            # Increment counter
     movl %eax, 0x10001      # Write to fixed address
     jmp start               # Infinite loop

   • Runs at user privilege level (ring 3)
   • Address 0x10001 maps to physical 0x210001 (STARTPROC + offset)
   • Verifiable in QEMU monitor: x /8xb 0x210001 shows incrementing values

4. Trap Frame Extension (src/x86.rs)

   pub struct TrapFrame {
       // General purpose registers (pusha)
       pub edi: u32, pub esi: u32, pub ebp: u32, pub oesp: u32,
       pub ebx: u32, pub edx: u32, pub ecx: u32, pub eax: u32,
       
       // Segment registers (NEW - added for user/kernel transitions)
       pub gs: u16, pub padding1: u16,
       pub fs: u16, pub padding2: u16,
       pub es: u16, pub padding3: u16,
       pub ds: u16, pub padding4: u16,
       pub trapno: u32,
       
       // Hardware-pushed registers
       pub err: u32, pub eip: u32, pub cs: u16, pub padding5: u16,
       pub eflags: u32, pub esp: u32, pub ss: u16, pub padding6: u16,
   }

   • Matches C trapframe layout exactly
   • Added helper functions: rcr2(), stosb(), stosl(), loadgs()
   • Added paging helpers: pdx(), ptx(), pgaddr(), pte_addr(), pte_flags()

5. Trap Assembly Updates (trapasm.S)

   alltraps:
     pushl %ds               # NEW: Save segment registers
     pushl %es
     pushl %fs
     pushl %gs
     pushal
     movw $(SEG_KDATA<<3), %ax  # NEW: Set kernel segments
     movw %ax, %ds
     movw %ax, %es
     ...
   
   trapret:
     popal
     popl %gs                # NEW: Restore segment registers
     popl %fs
     popl %es
     popl %ds
     addl $0x8, %esp
     iret

   • Properly saves/restores segment registers for user/kernel transitions

6. Segment Descriptor Updates (src/vm.rs)

   // Updated with user privilege level and correct size calculation
   c.gdt[SEG_UCODE] = SegDesc::seg(
       STA_X | STA_R,           // Executable, readable
       STARTPROC,               // Base: 2MB
       PROCSIZE << 12,          // Limit: 1MB (in bytes)
       DPL_USER                 // NEW: User privilege level (ring 3)
   );
   c.gdt[SEG_UDATA] = SegDesc::seg(
       STA_W,                   // Writeable
       STARTPROC,
       PROCSIZE << 12,
       DPL_USER                 // NEW: User privilege level (ring 3)
   );

7. Constants Organization (src/constants.rs)

   // Memory layout constants
   pub const EXTMEM: u32 = 0x100000;      // Start of extended memory
   pub const PHYSTOP: u32 = 0xE000000;    // Top physical memory
   pub const DEVSPACE: u32 = 0xFE000000;  // Devices at high addresses
   pub const KERNBASE: u32 = 0x0;         // Kernel virtual address start
   pub const KERNLINK: u32 = KERNBASE + EXTMEM;
   
   // Process memory
   pub const STARTPROC: u32 = 0x200000;   // Process start (2MB)
   pub const PROCSIZE: u32 = 0x100;       // Process size (256 pages = 1MB)
   
   // Privilege and paging
   pub const DPL_USER: u8 = 0x3;          // User privilege level
   pub const PGSIZE: u32 = 4096;
   pub const NPDENTRIES: usize = 1024;
   pub const NPTENTRIES: usize = 1024;
   pub const PTXSHIFT: u32 = 12;
   pub const PDXSHIFT: u32 = 22;
   
   // Page table entry flags
   pub const PTE_P: u32 = 0x001;   // Present
   pub const PTE_W: u32 = 0x002;   // Writeable
   pub const PTE_U: u32 = 0x004;   // User
   pub const PTE_PS: u32 = 0x080;  // Page Size

8. Parameter Updates (src/param.rs)

   pub const NPROC: usize = 64;     // Maximum number of processes
   pub const NOFILE: usize = 16;    // Open files per process

9. Debugging Support (src/spinlock.rs - 30 lines, NEW)

   pub fn getcallerpcs(v: *const u32, pcs: &mut [u32; 10]) {
       unsafe {
           let mut ebp = v.offset(-2) as *const u32;
           for i in 0..10 {
               if ebp.is_null() || ebp == 0xffffffff as *const u32 {
                   break;
               }
               pcs[i] = *ebp.offset(1);  // saved %eip
               ebp = *ebp as *const u32;  // saved %ebp
           }
       }
   }

   • Walks stack frame pointers to collect return addresses
   • Enhanced panic handler now prints stack traces

10. Main Control Flow (src/lib.rs)

    // Removed welcome() and infinite wfi() loop
    vm::seginit();       // Setup segment descriptors
    proc::pinit();       // Create first process
    proc::scheduler();   // Start scheduler (never returns)

11. Timer Configuration (src/lapic.rs)

    // Timer interrupts disabled for p15 (re-enabled in future parts)
    // lapicw(TDCR, X1);
    // lapicw(TIMER, PERIODIC | (T_IRQ0 + IRQ_TIMER));
    // lapicw(TICR, 10000000);

12. Build System (Makefile)

    OBJS = entry.o vectors.o trapasm.o swtch.o  # Added swtch.o
    
    initcode: initcode.S                         # NEW: Build initcode binary
        $(CC) $(CFLAGS) -nostdinc -I. -c initcode.S
        $(LD) $(LDFLAGS) -N -e start -Ttext 0 -o initcode.out initcode.o
        $(OBJCOPY) -S -O binary initcode.out initcode
        $(OBJDUMP) -S initcode.o > initcode.asm
    
    kernel: $(OBJS) entry.o kernel.ld initcode   # Added initcode dependency
        $(LD) -m elf_i386 -T ./linkers/kernel.ld -o kernel $(OBJS) kernel.a \
            -b binary initcode                    # Link initcode as binary

13. Minor Changes

    • .gdbinit.tmpl: Commented out layout split for cleaner debugging
    • console.rs: Added comment placeholder for future myproc integration
    • kernel.ld: Whitespace fix (tabs vs spaces)

---

Privilege Level Isolation:

• Kernel runs at ring 0 (CPL=0) with full hardware access
• User processes run at ring 3 (CPL=3) with restricted access
• Segment descriptors enforce DPL=3 for user code/data
• Privileged instructions (lgdt, lidt, cli, etc.) cause #GP if attempted from ring 3
• Interrupts/traps transition from ring 3 → ring 0 automatically via IDT

Constraints Met:

• Semantic equivalence with C implementation
• Zero compilation warnings (Rust compatible)
• Minimal unsafe code (only for raw pointer manipulation)
• #[repr(C)] for hardware-visible structures
• Clean separation: kernel (ring 0) vs user (ring 3)

---

Testing:

• Platform: WSL (Windows Subsystem for Linux)
• Toolchain: Rust nightly with build-std
• Build: make clean && make completes with 0 warnings, 0 errors
• Runtime: make qemu boots and enters scheduler
• Expected: System runs indefinitely (no timer interrupts, no way to regain control)

[Yash-Rawat-IIT-D]

Back-propagated correctness fixes discovered during p19 syscall implementation:

• Fixed incorrect write_bytes usage (was writing sizeof(T)^2 bytes).
• Replaced dynamic PTABLE initialization with static initialization to avoid unintended memory copy during boot.