pyOS-kernel 0.1.0__py3-none-any.whl

pyos/emulator.py

@@ -0,0 +1,195 @@
+"""
+pyOS QEMU Emulator Integration
+"""
+
+import subprocess
+import shutil
+from typing import Optional, List
+from pathlib import Path
+
+
+class QEMUError(Exception):
+    """Raised when QEMU fails."""
+    pass
+
+
+class QEMURunner:
+    """
+    QEMU emulator integration for running pyOS.
+    """
+    
+    def __init__(self, arch: str = "x86"):
+        """
+        Initialize QEMU runner.
+        
+        Args:
+            arch: Target architecture ("x86" or "x86_64")
+        """
+        self.arch = arch
+        self.qemu_path = self._find_qemu()
+    
+    def _find_qemu(self) -> str:
+        """Find QEMU executable."""
+        if self.arch == "x86_64":
+            names = ["qemu-system-x86_64", "qemu-system-x86_64.exe"]
+        else:
+            names = ["qemu-system-i386", "qemu-system-x86_64", 
+                     "qemu-system-i386.exe", "qemu-system-x86_64.exe"]
+        
+        for name in names:
+            path = shutil.which(name)
+            if path:
+                return path
+        
+        # Return default and hope it works
+        return "qemu-system-i386" if self.arch == "x86" else "qemu-system-x86_64"
+    
+    def run(
+        self,
+        image_path: str,
+        memory: int = 128,
+        debug: bool = False,
+        extra_args: Optional[List[str]] = None,
+    ) -> subprocess.Popen:
+        """
+        Run OS image in QEMU.
+        
+        Args:
+            image_path: Path to OS image (ISO or BIN)
+            memory: Memory in MB (default: 128)
+            debug: Enable debug mode
+            extra_args: Additional QEMU arguments
+        
+        Returns:
+            QEMU process handle.
+        """
+        cmd = [self.qemu_path]
+        
+        # Boot as floppy disk (works best for small OS images)
+        cmd.extend(["-fda", image_path])
+        
+        # Memory
+        cmd.extend(["-m", str(memory)])
+        
+        # Debug mode
+        if debug:
+            cmd.extend([
+                "-s",           # GDB server on port 1234
+                "-S",           # Pause at startup
+                "-d", "int,cpu_reset",
+                "-no-reboot",
+                "-no-shutdown",
+            ])
+        
+        # Extra arguments
+        if extra_args:
+            cmd.extend(extra_args)
+        
+        # Run QEMU
+        try:
+            process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            return process
+        except FileNotFoundError:
+            raise QEMUError(
+                f"QEMU not found. Please install QEMU:\n"
+                f"  Windows: Download from https://www.qemu.org/download/#windows\n"
+                f"  Linux: sudo apt install qemu-system-x86\n"
+                f"  macOS: brew install qemu"
+            )
+    
+    def run_and_wait(
+        self,
+        image_path: str,
+        memory: int = 128,
+        timeout: Optional[int] = None,
+    ) -> int:
+        """
+        Run OS and wait for completion.
+        
+        Args:
+            image_path: Path to OS image
+            memory: Memory in MB
+            timeout: Timeout in seconds
+        
+        Returns:
+            QEMU exit code.
+        """
+        process = self.run(image_path, memory)
+        
+        try:
+            return process.wait(timeout=timeout)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            return -1
+    
+    def run_with_serial(
+        self,
+        image_path: str,
+        memory: int = 128,
+    ) -> subprocess.Popen:
+        """
+        Run OS with serial output to console.
+        
+        Args:
+            image_path: Path to OS image
+            memory: Memory in MB
+        
+        Returns:
+            QEMU process handle.
+        """
+        return self.run(
+            image_path,
+            memory,
+            extra_args=["-serial", "stdio", "-display", "none"],
+        )
+    
+    def run_headless(
+        self,
+        image_path: str,
+        memory: int = 128,
+    ) -> subprocess.Popen:
+        """
+        Run OS without display (headless).
+        
+        Args:
+            image_path: Path to OS image
+            memory: Memory in MB
+        
+        Returns:
+            QEMU process handle.
+        """
+        return self.run(
+            image_path,
+            memory,
+            extra_args=["-display", "none", "-serial", "stdio"],
+        )
+    
+    @staticmethod
+    def is_available() -> bool:
+        """Check if QEMU is available."""
+        for name in ["qemu-system-i386", "qemu-system-x86_64"]:
+            if shutil.which(name):
+                return True
+        return False
+    
+    @staticmethod
+    def get_version() -> Optional[str]:
+        """Get QEMU version string."""
+        for name in ["qemu-system-i386", "qemu-system-x86_64"]:
+            path = shutil.which(name)
+            if path:
+                try:
+                    result = subprocess.run(
+                        [path, "--version"],
+                        capture_output=True,
+                        text=True,
+                    )
+                    if result.returncode == 0:
+                        return result.stdout.split('\n')[0]
+                except:
+                    pass
+        return None

pyos/interrupts/__init__.py

@@ -0,0 +1,8 @@
+"""
+pyOS Interrupt Handling
+"""
+
+from .handler import Interrupts, InterruptType
+from .idt import IDT
+
+__all__ = ["Interrupts", "InterruptType", "IDT"]

pyos/interrupts/handler.py

@@ -0,0 +1,237 @@
+"""
+pyOS Interrupt Handler
+"""
+
+from typing import Callable, Dict, Optional
+from dataclasses import dataclass
+from enum import Enum
+
+
+class InterruptType(Enum):
+    """Common interrupt types"""
+    # CPU Exceptions (0-31)
+    DIVIDE_ERROR = 0
+    DEBUG = 1
+    NMI = 2
+    BREAKPOINT = 3
+    OVERFLOW = 4
+    BOUND_RANGE = 5
+    INVALID_OPCODE = 6
+    DEVICE_NOT_AVAILABLE = 7
+    DOUBLE_FAULT = 8
+    COPROCESSOR_SEGMENT = 9
+    INVALID_TSS = 10
+    SEGMENT_NOT_PRESENT = 11
+    STACK_FAULT = 12
+    GENERAL_PROTECTION = 13
+    PAGE_FAULT = 14
+    X87_FPU_ERROR = 16
+    ALIGNMENT_CHECK = 17
+    MACHINE_CHECK = 18
+    SIMD_FPU_ERROR = 19
+    
+    # Hardware IRQs (32-47)
+    IRQ_TIMER = 32          # IRQ0 - PIT Timer
+    IRQ_KEYBOARD = 33       # IRQ1 - Keyboard
+    IRQ_CASCADE = 34        # IRQ2 - Cascade
+    IRQ_COM2 = 35           # IRQ3 - COM2
+    IRQ_COM1 = 36           # IRQ4 - COM1
+    IRQ_LPT2 = 37           # IRQ5 - LPT2
+    IRQ_FLOPPY = 38         # IRQ6 - Floppy
+    IRQ_LPT1 = 39           # IRQ7 - LPT1
+    IRQ_RTC = 40            # IRQ8 - RTC
+    IRQ_FREE1 = 41          # IRQ9
+    IRQ_FREE2 = 42          # IRQ10
+    IRQ_FREE3 = 43          # IRQ11
+    IRQ_MOUSE = 44          # IRQ12 - PS/2 Mouse
+    IRQ_FPU = 45            # IRQ13 - FPU
+    IRQ_PRIMARY_ATA = 46    # IRQ14 - Primary ATA
+    IRQ_SECONDARY_ATA = 47  # IRQ15 - Secondary ATA
+    
+    # System Call
+    SYSCALL = 0x80
+
+
+@dataclass
+class InterruptFrame:
+    """CPU state when interrupt occurred"""
+    eip: int = 0
+    cs: int = 0
+    eflags: int = 0
+    esp: int = 0
+    ss: int = 0
+    error_code: int = 0
+    interrupt_number: int = 0
+
+
+class Interrupts:
+    """
+    Interrupt Handler Manager.
+    
+    Provides methods to register and handle interrupts.
+    
+    Example:
+        @Interrupts.handler(InterruptType.IRQ_KEYBOARD)
+        def keyboard_handler(frame):
+            key = Keyboard.read_key()
+            Screen.print(f"Key: {key}")
+    """
+    
+    _handlers: Dict[int, Callable] = {}
+    _enabled: bool = False
+    _operations: list = []
+    
+    @classmethod
+    def handler(cls, interrupt: InterruptType):
+        """
+        Decorator to register an interrupt handler.
+        
+        Args:
+            interrupt: The interrupt type to handle
+        
+        Example:
+            @Interrupts.handler(InterruptType.IRQ_TIMER)
+            def timer_handler(frame):
+                pass
+        """
+        def decorator(func: Callable) -> Callable:
+            cls._handlers[interrupt.value] = func
+            cls._operations.append({
+                "type": "register_handler",
+                "interrupt": interrupt.value,
+                "name": func.__name__,
+            })
+            return func
+        return decorator
+    
+    @classmethod
+    def register(cls, interrupt_number: int, handler: Callable) -> None:
+        """
+        Register an interrupt handler by number.
+        
+        Args:
+            interrupt_number: Interrupt number (0-255)
+            handler: Handler function
+        
+        Example:
+            def my_handler(frame):
+                pass
+            Interrupts.register(0x21, my_handler)
+        """
+        cls._handlers[interrupt_number] = handler
+        cls._operations.append({
+            "type": "register_handler",
+            "interrupt": interrupt_number,
+            "name": handler.__name__,
+        })
+    
+    @classmethod
+    def unregister(cls, interrupt_number: int) -> None:
+        """
+        Unregister an interrupt handler.
+        
+        Args:
+            interrupt_number: Interrupt number to unregister
+        """
+        if interrupt_number in cls._handlers:
+            del cls._handlers[interrupt_number]
+        cls._operations.append({
+            "type": "unregister_handler",
+            "interrupt": interrupt_number,
+        })
+    
+    @classmethod
+    def enable(cls) -> None:
+        """
+        Enable interrupts (STI instruction).
+        
+        Example:
+            Interrupts.enable()
+        """
+        cls._enabled = True
+        cls._operations.append({"type": "enable"})
+    
+    @classmethod
+    def disable(cls) -> None:
+        """
+        Disable interrupts (CLI instruction).
+        
+        Example:
+            Interrupts.disable()
+        """
+        cls._enabled = False
+        cls._operations.append({"type": "disable"})
+    
+    @classmethod
+    def is_enabled(cls) -> bool:
+        """Check if interrupts are enabled."""
+        return cls._enabled
+    
+    @classmethod
+    def send_eoi(cls, irq: int) -> None:
+        """
+        Send End of Interrupt to PIC.
+        
+        Args:
+            irq: IRQ number (0-15)
+        """
+        cls._operations.append({
+            "type": "send_eoi",
+            "irq": irq,
+        })
+    
+    @classmethod
+    def mask_irq(cls, irq: int) -> None:
+        """
+        Mask (disable) a specific IRQ.
+        
+        Args:
+            irq: IRQ number (0-15)
+        """
+        cls._operations.append({
+            "type": "mask_irq",
+            "irq": irq,
+        })
+    
+    @classmethod
+    def unmask_irq(cls, irq: int) -> None:
+        """
+        Unmask (enable) a specific IRQ.
+        
+        Args:
+            irq: IRQ number (0-15)
+        """
+        cls._operations.append({
+            "type": "unmask_irq",
+            "irq": irq,
+        })
+    
+    @classmethod
+    def trigger_software_interrupt(cls, interrupt_number: int) -> None:
+        """
+        Trigger a software interrupt.
+        
+        Args:
+            interrupt_number: Interrupt number to trigger
+        """
+        cls._operations.append({
+            "type": "trigger",
+            "interrupt": interrupt_number,
+        })
+    
+    @classmethod
+    def get_handler(cls, interrupt_number: int) -> Optional[Callable]:
+        """Get the handler for an interrupt."""
+        return cls._handlers.get(interrupt_number)
+    
+    @classmethod
+    def _reset(cls) -> None:
+        """Reset interrupt state (used internally)."""
+        cls._handlers = {}
+        cls._enabled = False
+        cls._operations = []
+    
+    @classmethod
+    def _get_operations(cls) -> list:
+        """Get all recorded operations (used by compiler)."""
+        return cls._operations.copy()

pyos/interrupts/idt.py

@@ -0,0 +1,165 @@
+"""
+pyOS IDT (Interrupt Descriptor Table)
+"""
+
+from typing import List, Optional
+from dataclasses import dataclass
+from enum import Enum
+
+
+class GateType(Enum):
+    """IDT Gate Types"""
+    TASK_GATE = 0x5
+    INTERRUPT_GATE_16 = 0x6
+    TRAP_GATE_16 = 0x7
+    INTERRUPT_GATE_32 = 0xE
+    TRAP_GATE_32 = 0xF
+
+
+@dataclass
+class IDTEntry:
+    """
+    Represents a single IDT entry.
+    
+    Attributes:
+        offset: Handler function address
+        selector: Code segment selector
+        gate_type: Type of gate
+        privilege: Required privilege level to call
+        present: Is entry present
+    """
+    offset: int = 0
+    selector: int = 0x08  # Kernel code segment
+    gate_type: GateType = GateType.INTERRUPT_GATE_32
+    privilege: int = 0
+    present: bool = True
+    
+    def to_bytes(self) -> bytes:
+        """Convert IDT entry to 8-byte descriptor."""
+        offset_low = self.offset & 0xFFFF
+        offset_high = (self.offset >> 16) & 0xFFFF
+        
+        # Type and attributes byte
+        type_attr = self.gate_type.value
+        if self.present:
+            type_attr |= 0x80
+        type_attr |= (self.privilege << 5)
+        
+        return bytes([
+            offset_low & 0xFF,
+            (offset_low >> 8) & 0xFF,
+            self.selector & 0xFF,
+            (self.selector >> 8) & 0xFF,
+            0,  # Reserved
+            type_attr,
+            offset_high & 0xFF,
+            (offset_high >> 8) & 0xFF,
+        ])
+
+
+class IDT:
+    """
+    Interrupt Descriptor Table Manager.
+    
+    The IDT maps interrupt numbers to handler functions.
+    
+    Example:
+        idt = IDT()
+        idt.set_gate(0, divide_error_handler, GateType.TRAP_GATE_32)
+        idt.set_gate(33, keyboard_handler, GateType.INTERRUPT_GATE_32)
+        idt.install()
+    """
+    
+    MAX_ENTRIES = 256
+    
+    def __init__(self):
+        """Initialize IDT with empty entries."""
+        self._entries: List[Optional[IDTEntry]] = [None] * self.MAX_ENTRIES
+        self._operations: list = []
+    
+    def set_gate(
+        self,
+        index: int,
+        handler_address: int,
+        gate_type: GateType = GateType.INTERRUPT_GATE_32,
+        selector: int = 0x08,
+        privilege: int = 0,
+    ) -> 'IDT':
+        """
+        Set an IDT gate entry.
+        
+        Args:
+            index: Interrupt number (0-255)
+            handler_address: Address of handler function
+            gate_type: Type of gate (default: interrupt gate)
+            selector: Code segment selector (default: kernel code)
+            privilege: Required privilege level (default: 0)
+        
+        Returns:
+            Self for chaining.
+        
+        Example:
+            idt.set_gate(0, 0x1000, GateType.TRAP_GATE_32)
+        """
+        if 0 <= index < self.MAX_ENTRIES:
+            self._entries[index] = IDTEntry(
+                offset=handler_address,
+                selector=selector,
+                gate_type=gate_type,
+                privilege=privilege,
+                present=True,
+            )
+            self._operations.append({
+                "type": "set_gate",
+                "index": index,
+                "handler": handler_address,
+                "gate_type": gate_type.name,
+            })
+        return self
+    
+    def clear_gate(self, index: int) -> 'IDT':
+        """
+        Clear an IDT gate entry.
+        
+        Args:
+            index: Interrupt number to clear
+        
+        Returns:
+            Self for chaining.
+        """
+        if 0 <= index < self.MAX_ENTRIES:
+            self._entries[index] = None
+            self._operations.append({
+                "type": "clear_gate",
+                "index": index,
+            })
+        return self
+    
+    def install(self) -> None:
+        """
+        Install the IDT using LIDT instruction.
+        
+        This must be called after setting up all gates.
+        
+        Example:
+            idt.install()
+        """
+        self._operations.append({"type": "install"})
+    
+    def to_bytes(self) -> bytes:
+        """Convert entire IDT to bytes."""
+        result = b''
+        for entry in self._entries:
+            if entry:
+                result += entry.to_bytes()
+            else:
+                result += bytes(8)  # Empty entry
+        return result
+    
+    def get_size(self) -> int:
+        """Get IDT size in bytes."""
+        return self.MAX_ENTRIES * 8
+    
+    def _get_operations(self) -> list:
+        """Get all recorded operations (used by compiler)."""
+        return self._operations.copy()