pyOS-kernel 0.1.0__py3-none-any.whl

pyos/kernel.py

@@ -0,0 +1,288 @@
+"""
+pyOS Kernel - The core of your operating system
+"""
+
+from typing import Callable, Optional, List, Dict, Any
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class Architecture(Enum):
+    X86 = "x86"
+    X86_64 = "x86_64"
+
+
+@dataclass
+class KernelConfig:
+    """Configuration for the kernel"""
+    arch: Architecture = Architecture.X86
+    stack_size: int = 16384  # 16KB stack
+    heap_size: int = 1048576  # 1MB heap
+    video_mode: str = "text"  # text or graphics
+    enable_interrupts: bool = True
+    enable_gdt: bool = True
+    enable_paging: bool = False
+
+
+@dataclass
+class KernelFunction:
+    """Represents a registered kernel function"""
+    name: str
+    func: Callable
+    event: str
+    priority: int = 0
+
+
+class Kernel:
+    """
+    The main Kernel class for building operating systems.
+    
+    Example:
+        kernel = Kernel(arch="x86")
+        
+        @kernel.on_boot
+        def main():
+            Screen.print("Hello from MyOS!")
+        
+        kernel.build("myos.iso")
+    """
+    
+    def __init__(
+        self,
+        arch: str = "x86",
+        stack_size: int = 16384,
+        heap_size: int = 1048576,
+        enable_interrupts: bool = True,
+        enable_gdt: bool = True,
+    ):
+        """
+        Initialize a new Kernel.
+        
+        Args:
+            arch: Target architecture ("x86" or "x86_64")
+            stack_size: Stack size in bytes (default 16KB)
+            heap_size: Heap size in bytes (default 1MB)
+            enable_interrupts: Enable interrupt handling
+            enable_gdt: Enable Global Descriptor Table
+        """
+        self.config = KernelConfig(
+            arch=Architecture(arch),
+            stack_size=stack_size,
+            heap_size=heap_size,
+            enable_interrupts=enable_interrupts,
+            enable_gdt=enable_gdt,
+        )
+        
+        self._boot_functions: List[KernelFunction] = []
+        self._interrupt_handlers: Dict[int, KernelFunction] = {}
+        self._syscall_handlers: Dict[int, KernelFunction] = {}
+        self._keypress_handlers: List[KernelFunction] = []
+        self._timer_handlers: List[KernelFunction] = []
+        self._custom_handlers: Dict[str, List[KernelFunction]] = {}
+        
+        self._compiled_asm: Optional[str] = None
+        self._compiled_binary: Optional[bytes] = None
+    
+    def on_boot(self, func: Callable = None, *, priority: int = 0):
+        """
+        Decorator to register a function to run at boot.
+        
+        Example:
+            @kernel.on_boot
+            def start():
+                Screen.print("Booting...")
+        """
+        def decorator(f: Callable) -> Callable:
+            self._boot_functions.append(KernelFunction(
+                name=f.__name__,
+                func=f,
+                event="boot",
+                priority=priority,
+            ))
+            # Sort by priority (higher first)
+            self._boot_functions.sort(key=lambda x: -x.priority)
+            return f
+        
+        if func is not None:
+            return decorator(func)
+        return decorator
+    
+    def on_keypress(self, func: Callable = None, *, key: str = None):
+        """
+        Decorator to handle keyboard input.
+        
+        Example:
+            @kernel.on_keypress
+            def handle_key(key):
+                Screen.print(f"Pressed: {key}")
+        """
+        def decorator(f: Callable) -> Callable:
+            self._keypress_handlers.append(KernelFunction(
+                name=f.__name__,
+                func=f,
+                event="keypress",
+            ))
+            return f
+        
+        if func is not None:
+            return decorator(func)
+        return decorator
+    
+    def on_interrupt(self, interrupt_number: int):
+        """
+        Decorator to handle a specific interrupt.
+        
+        Example:
+            @kernel.on_interrupt(0x21)  # Keyboard interrupt
+            def keyboard_handler():
+                pass
+        """
+        def decorator(func: Callable) -> Callable:
+            self._interrupt_handlers[interrupt_number] = KernelFunction(
+                name=func.__name__,
+                func=func,
+                event=f"interrupt_{interrupt_number}",
+            )
+            return func
+        return decorator
+    
+    def on_syscall(self, syscall_number: int):
+        """
+        Decorator to register a system call handler.
+        
+        Example:
+            @kernel.on_syscall(1)  # sys_write
+            def sys_write(fd, buf, count):
+                pass
+        """
+        def decorator(func: Callable) -> Callable:
+            self._syscall_handlers[syscall_number] = KernelFunction(
+                name=func.__name__,
+                func=func,
+                event=f"syscall_{syscall_number}",
+            )
+            return func
+        return decorator
+    
+    def on_timer(self, interval_ms: int = 1000):
+        """
+        Decorator to register a timer handler.
+        
+        Example:
+            @kernel.on_timer(interval_ms=1000)
+            def every_second():
+                pass
+        """
+        def decorator(func: Callable) -> Callable:
+            handler = KernelFunction(
+                name=func.__name__,
+                func=func,
+                event="timer",
+            )
+            handler.interval_ms = interval_ms
+            self._timer_handlers.append(handler)
+            return func
+        return decorator
+    
+    def on_event(self, event_name: str):
+        """
+        Decorator to register a custom event handler.
+        
+        Example:
+            @kernel.on_event("custom_event")
+            def handle_custom():
+                pass
+        """
+        def decorator(func: Callable) -> Callable:
+            if event_name not in self._custom_handlers:
+                self._custom_handlers[event_name] = []
+            self._custom_handlers[event_name].append(KernelFunction(
+                name=func.__name__,
+                func=func,
+                event=event_name,
+            ))
+            return func
+        return decorator
+    
+    def compile(self) -> str:
+        """
+        Compile the kernel to Assembly code.
+        
+        Returns:
+            The generated Assembly code as a string.
+        """
+        from .compiler.codegen import CodeGenerator
+        
+        generator = CodeGenerator(self)
+        self._compiled_asm = generator.generate()
+        return self._compiled_asm
+    
+    def assemble(self) -> bytes:
+        """
+        Assemble the kernel to machine code.
+        
+        Returns:
+            The binary machine code.
+        """
+        if self._compiled_asm is None:
+            self.compile()
+        
+        from .compiler.assembler import Assembler
+        
+        assembler = Assembler(self.config.arch)
+        self._compiled_binary = assembler.assemble(self._compiled_asm)
+        return self._compiled_binary
+    
+    def build(self, output: str, format: str = "iso") -> str:
+        """
+        Build the complete OS image.
+        
+        Args:
+            output: Output file path
+            format: Output format ("iso" or "bin")
+        
+        Returns:
+            Path to the generated file.
+        """
+        from .builder import OSBuilder
+        
+        if self._compiled_binary is None:
+            self.assemble()
+        
+        builder = OSBuilder(self)
+        
+        if format == "iso":
+            return builder.build_iso(output)
+        elif format == "bin":
+            return builder.build_bin(output)
+        else:
+            raise ValueError(f"Unknown format: {format}")
+    
+    def run(self, image_path: str = None, debug: bool = False):
+        """
+        Run the OS in QEMU.
+        
+        Args:
+            image_path: Path to the OS image (builds if None)
+            debug: Enable QEMU debug mode
+        """
+        from .emulator import QEMURunner
+        
+        if image_path is None:
+            image_path = self.build("temp_os.iso")
+        
+        runner = QEMURunner(self.config.arch)
+        runner.run(image_path, debug=debug)
+    
+    def get_info(self) -> Dict[str, Any]:
+        """Get information about the kernel configuration."""
+        return {
+            "architecture": self.config.arch.value,
+            "stack_size": self.config.stack_size,
+            "heap_size": self.config.heap_size,
+            "interrupts_enabled": self.config.enable_interrupts,
+            "gdt_enabled": self.config.enable_gdt,
+            "boot_functions": len(self._boot_functions),
+            "interrupt_handlers": len(self._interrupt_handlers),
+            "syscall_handlers": len(self._syscall_handlers),
+        }

pyos/memory/__init__.py

@@ -0,0 +1,8 @@
+"""
+pyOS Memory Management
+"""
+
+from .manager import Memory
+from .gdt import GDT
+
+__all__ = ["Memory", "GDT"]

pyos/memory/gdt.py

@@ -0,0 +1,295 @@
+"""
+pyOS GDT (Global Descriptor Table) Management
+"""
+
+from typing import List, Optional
+from dataclasses import dataclass
+from enum import Enum, Flag
+
+
+class SegmentType(Enum):
+    """Segment types for GDT entries"""
+    NULL = 0
+    CODE_EXECUTE_ONLY = 0x8
+    CODE_EXECUTE_READ = 0xA
+    CODE_CONFORMING_EXECUTE_ONLY = 0xC
+    CODE_CONFORMING_EXECUTE_READ = 0xE
+    DATA_READ_ONLY = 0x0
+    DATA_READ_WRITE = 0x2
+    DATA_EXPAND_DOWN_READ_ONLY = 0x4
+    DATA_EXPAND_DOWN_READ_WRITE = 0x6
+
+
+class PrivilegeLevel(Enum):
+    """CPU privilege levels (rings)"""
+    RING0 = 0  # Kernel mode
+    RING1 = 1
+    RING2 = 2
+    RING3 = 3  # User mode
+
+
+@dataclass
+class GDTEntry:
+    """
+    Represents a single GDT entry.
+    
+    Attributes:
+        base: Base address of the segment
+        limit: Size of the segment
+        segment_type: Type of segment (code/data)
+        privilege: Privilege level (ring)
+        present: Is segment present in memory
+        granularity: Limit granularity (byte or 4KB)
+        is_32bit: 32-bit or 16-bit segment
+    """
+    base: int = 0
+    limit: int = 0xFFFFF
+    segment_type: SegmentType = SegmentType.DATA_READ_WRITE
+    privilege: PrivilegeLevel = PrivilegeLevel.RING0
+    present: bool = True
+    granularity: bool = True  # True = 4KB, False = 1 byte
+    is_32bit: bool = True
+    
+    def to_bytes(self) -> bytes:
+        """Convert GDT entry to 8-byte descriptor."""
+        # Limit (bits 0-15)
+        limit_low = self.limit & 0xFFFF
+        # Base (bits 0-15)
+        base_low = self.base & 0xFFFF
+        # Base (bits 16-23)
+        base_mid = (self.base >> 16) & 0xFF
+        
+        # Access byte
+        access = 0
+        if self.present:
+            access |= 0x80  # Present bit
+        access |= (self.privilege.value << 5)  # DPL
+        access |= 0x10  # Descriptor type (1 = code/data)
+        access |= self.segment_type.value
+        
+        # Flags + Limit (bits 16-19)
+        flags_limit = (self.limit >> 16) & 0x0F
+        if self.granularity:
+            flags_limit |= 0x80  # Granularity
+        if self.is_32bit:
+            flags_limit |= 0x40  # 32-bit
+        
+        # Base (bits 24-31)
+        base_high = (self.base >> 24) & 0xFF
+        
+        return bytes([
+            limit_low & 0xFF,
+            (limit_low >> 8) & 0xFF,
+            base_low & 0xFF,
+            (base_low >> 8) & 0xFF,
+            base_mid,
+            access,
+            flags_limit,
+            base_high,
+        ])
+
+
+class GDT:
+    """
+    Global Descriptor Table Manager.
+    
+    The GDT defines memory segments for the CPU.
+    
+    Example:
+        gdt = GDT()
+        gdt.add_null_descriptor()
+        gdt.add_code_segment(base=0, limit=0xFFFFF, ring=0)
+        gdt.add_data_segment(base=0, limit=0xFFFFF, ring=0)
+        gdt.install()
+    """
+    
+    _entries: List[GDTEntry] = []
+    _operations: list = []
+    
+    def __init__(self):
+        """Initialize GDT with empty entries."""
+        self._entries = []
+        self._operations = []
+    
+    def add_null_descriptor(self) -> 'GDT':
+        """
+        Add the required null descriptor (first entry).
+        
+        Returns:
+            Self for chaining.
+        
+        Example:
+            gdt.add_null_descriptor()
+        """
+        self._entries.append(GDTEntry(
+            base=0,
+            limit=0,
+            segment_type=SegmentType.NULL,
+            present=False,
+        ))
+        self._operations.append({"type": "add_null"})
+        return self
+    
+    def add_code_segment(
+        self,
+        base: int = 0,
+        limit: int = 0xFFFFF,
+        ring: int = 0,
+        readable: bool = True,
+    ) -> 'GDT':
+        """
+        Add a code segment descriptor.
+        
+        Args:
+            base: Base address (default: 0)
+            limit: Segment limit (default: 4GB)
+            ring: Privilege level 0-3 (default: 0 = kernel)
+            readable: Allow reading code (default: True)
+        
+        Returns:
+            Self for chaining.
+        
+        Example:
+            gdt.add_code_segment(ring=0)  # Kernel code
+            gdt.add_code_segment(ring=3)  # User code
+        """
+        seg_type = SegmentType.CODE_EXECUTE_READ if readable else SegmentType.CODE_EXECUTE_ONLY
+        
+        self._entries.append(GDTEntry(
+            base=base,
+            limit=limit,
+            segment_type=seg_type,
+            privilege=PrivilegeLevel(ring),
+        ))
+        self._operations.append({
+            "type": "add_code",
+            "base": base,
+            "limit": limit,
+            "ring": ring,
+        })
+        return self
+    
+    def add_data_segment(
+        self,
+        base: int = 0,
+        limit: int = 0xFFFFF,
+        ring: int = 0,
+        writable: bool = True,
+    ) -> 'GDT':
+        """
+        Add a data segment descriptor.
+        
+        Args:
+            base: Base address (default: 0)
+            limit: Segment limit (default: 4GB)
+            ring: Privilege level 0-3 (default: 0 = kernel)
+            writable: Allow writing (default: True)
+        
+        Returns:
+            Self for chaining.
+        
+        Example:
+            gdt.add_data_segment(ring=0)  # Kernel data
+            gdt.add_data_segment(ring=3)  # User data
+        """
+        seg_type = SegmentType.DATA_READ_WRITE if writable else SegmentType.DATA_READ_ONLY
+        
+        self._entries.append(GDTEntry(
+            base=base,
+            limit=limit,
+            segment_type=seg_type,
+            privilege=PrivilegeLevel(ring),
+        ))
+        self._operations.append({
+            "type": "add_data",
+            "base": base,
+            "limit": limit,
+            "ring": ring,
+        })
+        return self
+    
+    def add_tss_segment(self, base: int, limit: int) -> 'GDT':
+        """
+        Add a Task State Segment descriptor.
+        
+        Args:
+            base: TSS base address
+            limit: TSS size
+        
+        Returns:
+            Self for chaining.
+        """
+        # TSS descriptor has special format
+        self._entries.append(GDTEntry(
+            base=base,
+            limit=limit,
+            segment_type=SegmentType.CODE_EXECUTE_ONLY,  # Will be modified
+            privilege=PrivilegeLevel.RING0,
+        ))
+        self._operations.append({
+            "type": "add_tss",
+            "base": base,
+            "limit": limit,
+        })
+        return self
+    
+    def install(self) -> None:
+        """
+        Install the GDT and reload segment registers.
+        
+        This must be called after adding all segments.
+        
+        Example:
+            gdt.install()
+        """
+        self._operations.append({"type": "install"})
+    
+    def get_selector(self, index: int, ring: int = 0) -> int:
+        """
+        Get the segment selector for an entry.
+        
+        Args:
+            index: GDT entry index
+            ring: Requested privilege level
+        
+        Returns:
+            The segment selector value.
+        """
+        return (index << 3) | ring
+    
+    def to_bytes(self) -> bytes:
+        """Convert entire GDT to bytes."""
+        result = b''
+        for entry in self._entries:
+            result += entry.to_bytes()
+        return result
+    
+    def get_size(self) -> int:
+        """Get GDT size in bytes."""
+        return len(self._entries) * 8
+    
+    def _get_operations(self) -> list:
+        """Get all recorded operations (used by compiler)."""
+        return self._operations.copy()
+    
+    @classmethod
+    def create_flat_model(cls) -> 'GDT':
+        """
+        Create a standard flat memory model GDT.
+        
+        This is the most common setup for modern OS.
+        
+        Returns:
+            Configured GDT instance.
+        
+        Example:
+            gdt = GDT.create_flat_model()
+            gdt.install()
+        """
+        gdt = cls()
+        gdt.add_null_descriptor()
+        gdt.add_code_segment(ring=0)  # Kernel code
+        gdt.add_data_segment(ring=0)  # Kernel data
+        gdt.add_code_segment(ring=3)  # User code
+        gdt.add_data_segment(ring=3)  # User data
+        return gdt