Function setup_kernel_vm

tests/integration/kernel_integration.rs:85–121

Boot the kernel, optionally injecting an FS image and a pid-1 user binary, and optionally pre-loading a UART session. Returns the VM (for post-run peeks), the final outcome, and the captured UART output. Set up a booted kernel VM (RAM layout + optional FS image + pid-1 user binary + front-loaded UART input) without running it, so callers can either run it in one shot (boot_kernel) or step it manua

(
    kernel: &AssembledOutput,
    user: Option<&AssembledOutput>,
    fs_image: Option<&[u8]>,
    input: &str,
)

            .expect("write fs image PA");
        vm.write_ram(FS_META_PA + 8, &(image.len() as u64).to_le_bytes())
            .expect("write fs image size");
        vm.write_ram(FS_IMAGE_PA, image).expect("write fs image");
    }

    if let Some(u) = user {
        let mut flat = u.to_flat_binary();
        let page = 4096usize;
        flat.resize(flat.len().div_ceil(page) * page, 0u8);
        let entry_off = u.symbol_address("_start").expect("_start missing");
        let entry_va = USER_CODE_VA + entry_off;
        let user_size = flat.len() as u64;
        vm.write_ram(USER_META_PA, &entry_va.to_le_bytes())
            .expect("write user entry VA");
        vm.write_ram(USER_META_PA + 8, &user_size.to_le_bytes())
            .expect("write user size");
        vm.write_ram(USER_BINARY_PA, &flat)
            .expect("write user binary");
    }

    for b in input.bytes() {
        vm.push_uart_rx(b);
    }

    vm
}

fn boot_kernel(
    kernel: &AssembledOutput,
    user: Option<&AssembledOutput>,
    fs_image: Option<&[u8]>,
    input: &str,
    max_steps: u64,
) -> (VirtualMachine, StepOutcome, String) {
    let mut vm = setup_kernel_vm(kernel, user, fs_image, input);
    let run = vm.run(max_steps);
    (vm, run.outcome, run.uart_output)
}

// A hosted user program injected as pid 1 must spawn and exit with code 0.
fn assert_user_exit_ok(uart: &str, outcome: &StepOutcome, label: &str) {