<< lib/cpu/SLHypervisor.sleela SLeeLa Standard Library Definition. Definition: Defines SLHypervisor — a type-2 (hosted) hypervisor running on the Sleela OS. It creates and schedules guest virtual machines, each with its own virtual CPU view, guest physical memory window, and trap-based exit handling. This is the layer that lets a guest operating system — e.g. a Linux-style kernel — run on top of the Sleela CPU model. Virtualization model: each guest gets a memory window carved from host RAM translated by a real MMU (SLMMU, page tables + protection), a device model (SLGuestDeviceBus: timer, console, block device) exposed via guest MMIO, and the host core's TRAP vector as the VM-exit path (a guest privileged op/page fault/MMIO traps to the hypervisor, which emulates it and resumes the guest). Guest code runs on the guest's own SLSleelaVM opcode substrate. SCOPE NOTE: this is an architectural model of hosted virtualization, not a hardware-virtualization (VT-x/AMD-V) implementation and not a bootable upstream Linux. See CPU.md and EXECUTION.md for the exact boundary. Family: cpu. Composes SLCPU/SLCore, SLRAM, SLGuestVM, SLMMU, SLGuestDeviceBus. >> #sleela 2.5 material; class SLHypervisor { < ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- > << Eleven catalogued attributes with getter/setter pairs, so a GUI, loader, or catalog can read and (where appropriate) override this record. Values are faithful to the subject's real origin where publicly known. >> String metaVersion = "1.0.0"; int metaId = 10247; String metaAuthor = "Kiro Agent"; String metaDate = "2026-10-16"; String metaCopyright = "SLeeLa project"; String metaTrademark = "none"; String metaCorporation = "none"; < metaOrigin: National | | International | Galactic > String metaOrigin = "International"; String metaBirthDate = "2026-10-06"; < metaScienceRating: maturity/robustness on a 1..10 scale > int metaScienceRating = 9; < metaNationalSchedule: a real, citable instrument or "none" > String metaNationalSchedule = "none"; String getMetaVersion() { return metaVersion; } void setMetaVersion(String v) { metaVersion = v; } int getMetaId() { return metaId; } void setMetaId(int v) { metaId = v; } String getAuthor() { return metaAuthor; } void setAuthor(String v) { metaAuthor = v; } String getDate() { return metaDate; } void setDate(String v) { metaDate = v; } String getCopyright() { return metaCopyright; } void setCopyright(String v) { metaCopyright = v; } String getTrademark() { return metaTrademark; } void setTrademark(String v) { metaTrademark = v; } String getCorporation() { return metaCorporation; } void setCorporation(String v) { metaCorporation = v; } String getOrigin() { return metaOrigin; } void setOrigin(String v) { metaOrigin = v; } String getBirthDate() { return metaBirthDate; } void setBirthDate(String v) { metaBirthDate = v; } int getScienceRating() { return metaScienceRating; } void setScienceRating(int v) { metaScienceRating = v; } String getNationalSchedule() { return metaNationalSchedule; } void setNationalSchedule(String v) { metaNationalSchedule = v; } SLCPU host; SLRAM hostMemory; < host-backed drive the guest block device uses > SLHardDrive bootDisk; SLGuestVM g0; SLGuestVM g1; SLGuestVM g2; SLGuestVM g3; int guestCount; < total VM-exits handled > int exits; int current; void configure(SLCPU hostCpu, SLRAM ram) { host = hostCpu; hostMemory = ram; guestCount = 0; exits = 0; current = -1; } < Optionally provide a host drive to back guests' virtual block devices. > void attachBootDisk(SLHardDrive drive) { bootDisk = drive; } < Create a guest VM with a guest-physical window [base, base+size) in host RAM. > < A per-guest MMU identity-maps the window with full permissions as the boot > < address space (the guest kernel may install its own page tables after). > SLGuestVM createGuest(String name, int base, int size, int guestEntry) { SLGuestVM vm = new SLGuestVM(); vm.configure(name, host.bootCore(), hostMemory, base, size, guestEntry); SLMMU mmu = new SLMMU(); int pageSize = 256; int pages = (size / pageSize) + 1; mmu.configure(pageSize, pages); mmu.identityMap(pages, base / pageSize, mmu.PERM_WRITE + mmu.PERM_EXEC); vm.attachMMU(mmu); < Guest device model (step 3): timer (IRQ0), console, block device (IRQ2), > < and a guest interrupt controller aggregating their lines. > SLGuestTimer timer = new SLGuestTimer(); timer.init(57344, 0); SLGuestConsole con = new SLGuestConsole(); con.init(57360); SLGuestBlockDevice blk = new SLGuestBlockDevice(); blk.init(57376, 2, bootDisk); SLInterruptController gpic = new SLInterruptController(); gpic.configure(60000); SLGuestDeviceBus bus = new SLGuestDeviceBus(); bus.configure(timer, con, blk, gpic); vm.attachDevices(bus); int idx = guestCount; if (idx == 0) { g0 = vm; } if (idx == 1) { g1 = vm; } if (idx == 2) { g2 = vm; } if (idx == 3) { g3 = vm; } guestCount = guestCount + 1; < The host core's TRAP vector is the VM-exit entry. > host.bootCore().controlUnit().installTrapVector(0); return vm; } SLGuestVM guest(int idx) { if (idx == 0) { return g0; } if (idx == 1) { return g1; } if (idx == 2) { return g2; } if (idx == 3) { return g3; } return g0; } < Run a guest for a bounded number of guest instructions, handling VM-exits. > int runGuest(int idx, int budget) { SLGuestVM vm = guest(idx); if (vm == null) { return 0; } current = idx; int ran = vm.run(budget); exits = exits + vm.exitCount(); return ran; } int guests() { return guestCount; } int vmExits() { return exits; } }