src/contextswitcher.pas

@@ -12,15 +12,121 @@
 //  See the License for the specific language governing permissions and
 //  limitations under the License.
 
-{ 
-	ContextSwitcher - Switch Process Contexts when preempted.
-	
-	@author(Kieron Morris <[email protected]>)
+{
+    ContextSwitcher - Custom IRQ0 handler for preemptive context switching.
+
+    Replaces the default ISR_32 with a naked assembly stub that saves the
+    interrupted context (PUSHAD + segment regs), calls a Pascal helper to
+    dispatch timer hooks, send EOI, and run the scheduler, then restores
+    the next process context (or idles) via the returned ESP.
+
+    @author(Kieron Morris <[email protected]>)
 }
 unit contextswitcher;
 
+{$ASMMODE intel}
+
 interface
 
-implementation;
+uses
+    idt, isrmanager, processmanager, proctypes, util, syslog, tracer;
+
+{ Initialise: overwrite IDT gate 32 with our custom ISR. }
+procedure init;
+
+{ No idle ESP variable needed — idle is now a formal process (PID 0)
+  with its SavedESP managed like any other process. }
+
+implementation
+
+{ -----------------------------------------------------------------------
+  do_context_switch_work
+  Pascal helper called from the assembly ISR.  Receives the current ESP
+  (pointing to the GS..EFLAGS save area), dispatches timer hooks, sends
+  EOI, runs the scheduler and returns the ESP for the next context.
+  Uses register calling convention: saved_esp in EAX, result in EAX.
+  ----------------------------------------------------------------------- }
+function do_context_switch_work(saved_esp : uint32) : uint32;
+var
+    next : PProcessContext;
+begin
+    { 1. Save ESP into the current process }
+    processmanager.CurrentProcess^.SavedESP := saved_esp;
+
+    { 2. Dispatch all hooks registered on interrupt 32 (timer hooks).
+         This fires TMR_0_ISR.Main which in turn fires BDA tick,
+         graphics refresh, USB hotplug, etc. }
+    isrmanager.dispatchHooks(32);
+
+    { 3. Send End-Of-Interrupt to the master PIC }
+    outb($20, $20);
+
+    { 4. Pick the next process to run (always returns non-nil; idle as fallback) }
+    next := processmanager.scheduler_pick_next;
+    processmanager.CurrentProcess := next;
+
+    { 5. Return the selected process ESP }
+    do_context_switch_work := next^.SavedESP;
+end;
+
+{ -----------------------------------------------------------------------
+  context_switch_isr
+  Naked assembly ISR that replaces ISR_32 (IRQ0 / PIT timer).
+
+  Stack on entry (pushed by CPU):
+      [ESP+8] EFLAGS
+      [ESP+4] CS
+      [ESP+0] EIP
+
+  We push general-purpose and segment registers, call the Pascal helper,
+  switch ESP to the returned value, pop registers and IRETD.
+  ----------------------------------------------------------------------- }
+procedure context_switch_isr; assembler; nostackframe;
+asm
+    { Save all general-purpose registers (EAX,ECX,EDX,EBX,ESP,EBP,ESI,EDI) }
+    pushad
+
+    { Save segment registers }
+    push ds
+    push es
+    push fs
+    push gs
+
+    { Load kernel data segments }
+    mov ax, $10
+    mov ds, ax
+    mov es, ax
+    mov fs, ax
+    mov gs, ax
+
+    { Call Pascal helper: EAX = current ESP (register calling convention).
+      Returns new ESP in EAX. }
+    mov eax, esp
+    call do_context_switch_work
+    mov esp, eax
+
+    { Restore segment registers }
+    pop gs
+    pop fs
+    pop es
+    pop ds
+
+    { Restore general-purpose registers }
+    popad
+
+    { Return from interrupt }
+    iretd
+end;
+
+{ -----------------------------------------------------------------------
+  init
+  Override IDT gate 32 with our custom ISR.  Must be called AFTER
+  isrmanager.init so that the default gate has been set up first.
+  ----------------------------------------------------------------------- }
+procedure init;
+begin
+    idt.set_gate(32, uint32(@context_switch_isr), $08, ISR_RING_0);
+    tracer.push_trace('contextswitcher.init');
+end;
 
 end.

src/cpu.pas

@@ -22,7 +22,7 @@ unit cpu;
 interface
 
 uses
-    util, RTC;
+    util, RTC, stdio;
 
 type
     PCapabilities_Old = ^TCapabilities_Old;
@@ -113,12 +113,10 @@ var
     CAP_OLD, CAP_NEW : uint32;
 
 procedure init();
+procedure Terminal_Command_CPU(Params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
 
 implementation
 
-uses
-    stdio;
-
 procedure getCPUIdentifier;
 var
     id0, id1, id2 : uint32;
@@ -325,7 +323,6 @@ end;
 
 procedure init();
 begin
-    stdio.registerCommand('CPU', @Terminal_Command_CPU, 'CPU Info.');
     CPUID.Capabilities0:= PCapabilities_Old(@CAP_OLD);
     CPUID.Capabilities1:= PCapabilities_New(@CAP_NEW); 
     getCPUIdentifier;

src/driver/bus/usb/usbcore.pas

@@ -158,6 +158,9 @@ procedure init;
 { Unit Tests }
 procedure UnitTest;
 
+{ Terminal command }
+procedure terminal_command_usb(params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
+
 implementation
 
 { ========================= Globals ========================= }
@@ -1100,7 +1103,6 @@ begin
     CompletionHookCount := 0;
     for i := 0 to MAX_COMPLETION_HOOKS - 1 do
         CompletionHooks[i] := nil;
-    stdio.registerCommand('USB', @terminal_command_usb, 'USB subsystem information.');
     syslog.logln('USB Core', 'INIT END.');
     pop_trace;
 end;

src/driver/net/include/nettypes.pas

@@ -256,6 +256,7 @@ type
         OnReceive : TTCPReceiveCallback;
         OnEvent   : TTCPEventCallback;
         UserData  : void;
+        OwnerPID  : uint32;           { PID of owning process, 0 if none }
     end;
 
     TTCB = record

src/driver/net/l3/arp.pas

@@ -25,7 +25,7 @@ uses
     tracer, lmemorymanager,
     util, lists,
     net, nettypes, netutils,
-    eth2, ipv4;
+    eth2, ipv4, stdio;
 
 type
     PARPCacheRecord = ^TARPCacheRecord;
@@ -41,11 +41,12 @@ procedure sendGratuitous;
 procedure sendRequest(ip : puint8);
 procedure send(hType : uint16; pType : uint16; op : uint16; p_context : PPacketContext);
 function resolveIP(ip : puint8) : puint8;
+procedure terminal_command_arp(Params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
 
 implementation
 
 uses
-    stdio, strings;
+    strings;
 
 var
     Registered : Boolean = false;
@@ -309,7 +310,6 @@ begin
         writeToLogLn('      L3/ARP: register');
         Cache:= LL_New(sizeof(TARPCacheRecord));
         eth2.registerTypePromisc($0806, @recv);
-        stdio.registerCommand('ARP', @terminal_command_arp, 'Get ARP Table.');
         Registered:= true;
     end;
     pop_trace;

src/driver/net/l3/ipv4.pas

@@ -26,17 +26,18 @@ uses
     util, strings,
     net, nettypes, netutils,
     lists,
-    eth2;
+    eth2, stdio;
 
 procedure send(p_data : void; p_len : uint16; p_context : PPacketContext);
 procedure registerProtocol(Protocol_ID : uint8; recv_callback : TRecvCallback);
 function  getIPv4Config : PIPv4Configuration;
 procedure register;
+procedure terminal_command_ifconfig(params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
 
 implementation
 
 uses
-    arp, stdio;
+    arp;
 
 var
     Registered : Boolean = false;
@@ -211,7 +212,6 @@ begin
         end;
         Config.UP:= false;
         eth2.registerType($0800, @recv);
-        stdio.registerCommand('IFCONFIG', @terminal_command_ifconfig, 'Configure Network Settings.');
         Registered:= true;
     end;
     pop_trace;

src/driver/net/l4/tcp.pas

@@ -22,7 +22,7 @@ unit tcp;
 interface
 
 uses
-    tracer,
+    tracer, stdio,
     nettypes, netutils,
     ipv4;
 
@@ -33,13 +33,17 @@ function  accept(listener : PTCPSocket) : PTCPSocket;
 function  send(socket : PTCPSocket; p_data : void; p_len : uint16) : TTCPError;
 function  close(socket : PTCPSocket) : TTCPError;
 function  abort_connection(socket : PTCPSocket) : TTCPError;
+procedure terminal_command_tcpconnect(params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
+procedure terminal_command_tcplisten(params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
+procedure terminal_command_tcphttp(params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
 
 implementation
 
 uses
     lmemorymanager, util, syslog, rand, lists,
     net, TMR_0_ISR, bios_data_area,
-    stdio, strings, arp;
+    strings, arp,
+    processmanager, proctypes;
 
 const
     TCP_PROTOCOL_ID     = $06;
@@ -225,6 +229,7 @@ begin
     sock^.OnReceive := onRecv;
     sock^.OnEvent := onEvt;
     sock^.UserData := userData;
+    sock^.OwnerPID := 0;
     tcb^.Socket := sock;
     CreateSocket := sock;
 end;
@@ -251,10 +256,29 @@ begin
     end;
 end;
 
+procedure socket_cleanup(handle : void);
+var
+    sock : PTCPSocket;
+begin
+    sock := PTCPSocket(handle);
+    if sock = nil then exit;
+    sock^.OwnerPID := 0;  { Prevent DestroySocket from trying to unbind again }
+    abort_connection(sock);
+end;
+
 procedure DestroySocket(sock : PTCPSocket);
+var
+    owner : PProcessContext;
 begin
     push_trace('tcp.DestroySocket');
     if sock <> nil then begin
+        { Remove resource binding from owning process }
+        if sock^.OwnerPID <> 0 then begin
+            owner := processmanager.findByID(sock^.OwnerPID);
+            sock^.OwnerPID := 0;
+            if owner <> nil then
+                processmanager.unbindResourceNoCleanup(owner, void(sock));
+        end;
         if sock^.TCB <> nil then begin
             sock^.TCB^.Socket := nil;
             DestroyTCB(sock^.TCB);
@@ -1369,6 +1393,12 @@ begin
 
     sock := CreateSocket(tcb, context^.OnReceive, context^.OnEvent, context^.UserData);
 
+    { Auto-bind socket to calling process for cleanup on process death }
+    if processmanager.CurrentProcess <> nil then begin
+        sock^.OwnerPID := processmanager.CurrentProcess^.ProcessID;
+        processmanager.bindResource(processmanager.CurrentProcess, rkSocket, void(sock), @socket_cleanup);
+    end;
+
     AddTCB(tcb);
 
     { Send SYN (includes MSS option via SendSegment) }
@@ -1402,6 +1432,13 @@ begin
     if tcb^.BacklogMax = 0 then tcb^.BacklogMax := 5; { default backlog }
 
     sock := CreateSocket(tcb, context^.OnReceive, context^.OnEvent, context^.UserData);
+
+    { Auto-bind socket to calling process for cleanup on process death }
+    if processmanager.CurrentProcess <> nil then begin
+        sock^.OwnerPID := processmanager.CurrentProcess^.ProcessID;
+        processmanager.bindResource(processmanager.CurrentProcess, rkSocket, void(sock), @socket_cleanup);
+    end;
+
     AddTCB(tcb);
 
     listen := sock;
@@ -1866,9 +1903,6 @@ begin
         Connections := DL_New(sizeof(uint32));
         ipv4.registerProtocol(TCP_PROTOCOL_ID, @ProcessPacket);
         TMR_0_ISR.hook(uint32(@TimerTick));
-        stdio.registerCommand('TCPCONNECT', @terminal_command_tcpconnect, 'Connect to a TCP host and send Hello World.');
-        stdio.registerCommand('TCPLISTEN', @terminal_command_tcplisten, 'Listen on a TCP port and log received data.');
-        stdio.registerCommand('TCPHTTP', @terminal_command_tcphttp, 'Send HTTP GET to a host IP (port 80 default).');
         Registered := true;
         syslog.logln('TCP', 'TCP registered.');
     end;

src/driver/storage/storagemanagement.pas

@@ -112,6 +112,7 @@ function get_device_list() : PLinkedListBase;
 procedure register_filesystem(filesystem : PFilesystem);
 
 procedure register_volume(device : PStorage_Device; volume : PStorage_Volume);
+procedure disk_command(params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
 //function writeNewFile(fileName : pchar; extension : pchar; buffer : puint32; size : uint32) : uint32;
 //function readFile(fileName : pchar; extension : pchar; buffer : puint32; byteCount : puint32) : puint32;
 
@@ -231,7 +232,6 @@ begin
     setworkingdirectory('.');
     storageDevices:= ll_new(sizeof(TStorage_Device));
     fileSystems:= ll_New(sizeof(TFilesystem));
-    stdio.registerCommand('DISK', @disk_command, 'Disk utility');
 
     pop_trace();
 end; 

src/driver/storage/vfs.pas

@@ -104,6 +104,10 @@ function GetDirectories(Handle : uint32; Path : pchar) : PHashMap;
 function PathValid(Path : pchar) : TIsPathValid;
 function changeDirectory(Path : pchar) : TIsPathValid;
 function getWorkingDirectory : pchar;
+function makeAbsolutePathFrom(Path : pchar; BaseDir : pchar) : pchar;
+function resolvePathFrom(Path : pchar; BaseDir : pchar) : TIsPathValid;
+function GetDirectoryListingFrom(Path : pchar; BaseDir : pchar) : PHashMap;
+function changeDirectoryFrom(Path : pchar; BaseDir : pchar; var NewDir : pchar) : TIsPathValid;
 
 //VFS Functions
 function newVirtualDirectory(Path : pchar) : TError;
@@ -608,6 +612,67 @@ begin
     tracer.push_trace('vfs.getWorkingDirectory.exit');
 end;
 
+function makeAbsolutePathFrom(Path : pchar; BaseDir : pchar) : pchar;
+var
+    AbsPath  : pchar;
+    TempPath : pchar;
+begin
+    if Path[0] = '/' then
+        AbsPath := stringCopy(Path)
+    else begin
+        if BaseDir[StringSize(BaseDir)-1] <> '/' then
+            TempPath := StringConcat(BaseDir, '/')
+        else
+            TempPath := stringCopy(BaseDir);
+        AbsPath := StringConcat(TempPath, Path);
+        kfree(void(TempPath));
+    end;
+    makeAbsolutePathFrom := AbsPath;
+end;
+
+function resolvePathFrom(Path : pchar; BaseDir : pchar) : TIsPathValid;
+var
+    TempPath : pchar;
+    AbsPath  : pchar;
+begin
+    TempPath := makeAbsolutePathFrom(Path, BaseDir);
+    AbsPath := evaluatePath(TempPath);
+    kfree(void(TempPath));
+    resolvePathFrom := PathValid(AbsPath);
+    kfree(void(AbsPath));
+end;
+
+function GetDirectoryListingFrom(Path : pchar; BaseDir : pchar) : PHashMap;
+var
+    TempPath : pchar;
+    AbsPath  : pchar;
+begin
+    TempPath := makeAbsolutePathFrom(Path, BaseDir);
+    AbsPath := evaluatePath(TempPath);
+    kfree(void(TempPath));
+    GetDirectoryListingFrom := GetDirectoryListing(AbsPath);
+    kfree(void(AbsPath));
+end;
+
+function changeDirectoryFrom(Path : pchar; BaseDir : pchar; var NewDir : pchar) : TIsPathValid;
+var
+    TempPath : pchar;
+    AbsPath  : pchar;
+    Validity : TIsPathValid;
+begin
+    TempPath := makeAbsolutePathFrom(Path, BaseDir);
+    AbsPath := evaluatePath(TempPath);
+    kfree(void(TempPath));
+    Validity := PathValid(AbsPath);
+    if Validity = pvDirectory then
+        NewDir := AbsPath
+    else begin
+        NewDir := nil;
+        kfree(void(AbsPath));
+    end;
+    changeDirectoryFrom := Validity;
+end;
+
 { Terminal Commands }
 
 procedure VFS_COMMAND_PUSHD(params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
@@ -746,11 +811,8 @@ begin
     //outputln('VFS', makeRelative('/test/mydisk/mything', '/test/mydisk'));
     //while true do begin end;
 
-    { Register Terminal Commands }
-    stdio.registerCommand('LS',      @VFS_COMMAND_LS,    'List directory contents.');
-    stdio.registerCommand('CD',      @VFS_COMMAND_CD,    'Set working directory.');
-    stdio.registerCommand('PUSHD',   @VFS_COMMAND_PUSHD, 'Push the working directory.');
-    stdio.registerCommand('POPD',    @VFS_COMMAND_POPD,  'Pop the working directory.');
+    { LS, CD, PUSHD, POPD are now handled as per-terminal builtins
+      in vterminal.pas so each terminal has its own working directory. }
 
     //ht:= PHashMap(Root^.Reference);
     //hashmap.add(ht, 'VDirectory', void(newDummyObject(otVDIRECTORY)));

src/driver/timers/graphicsrefresh.pas

@@ -21,6 +21,7 @@ uses
     uidebug,
     lvgl,
     video,
+    windows,
     syslog;
 
 const
@@ -35,6 +36,7 @@ begin
     TickCounter := TickCounter + 1;
     if TickCounter >= TICKS_PER_FRAME then begin
         TickCounter := 0;
+        windows.reapOrphanedWindows;
         desktop.update;
         uidebug.update;
         lvgl_handler;

src/driver/video/lvgl.pas

@@ -467,6 +467,7 @@ const
     LV_KEY_PREV      = 11;
     LV_KEY_HOME      = 2;
     LV_KEY_END       = 3;
+    LV_KEY_CTRLC     = 128;   { Ctrl+C — terminal interrupt }
 
     { Arc mode }
     LV_ARC_MODE_NORMAL      = 0;
@@ -1861,6 +1862,16 @@ begin
         exit;
     end;
 
+    { Ctrl+C — inject custom key code so focused terminal can handle it }
+    if key_info.is_down_code and key_info.CTRL_DOWN and (key_info.key_code = ord('c')) then begin
+        next_head := (kb_head + 1) mod KB_BUF_SIZE;
+        if next_head <> kb_tail then begin
+            kb_buf[kb_head] := LV_KEY_CTRLC;
+            kb_head := next_head;
+        end;
+        exit;
+    end;
+
     { Map Asuro key codes to LVGL key codes }
     case key_info.key_code of
         $1B: k := LV_KEY_ESC;

src/driver/video/windows.pas

@@ -11,7 +11,7 @@ unit windows;
 interface
 
 uses
-    lvgl, mouse, serial, tracer;
+    lvgl, mouse, serial, tracer, processmanager, proctypes;
 
 const
     MAX_WINDOWS      = 16;
@@ -55,6 +55,7 @@ type
         on_close     : TWinCloseCallback;
         on_resize    : TWinResizeCallback;
         cursor_obj   : Plv_obj;   { cursor to keep on top }
+        owner_pid    : uint32;    { owning process PID; 0 = unowned }
     end;
 
 { Create a new window. Returns window ID (0 = failure). }
@@ -81,6 +82,15 @@ function  getWindowCount: uint32;
 { Set a callback to be notified when a window is resized. }
 procedure setWindowResizeCallback(win_id: uint32; cb: TWinResizeCallback);
 
+{ Assign an owning process to a window.
+  When reapOrphanedWindows detects the process has died, the window
+  is automatically closed via its on_close callback. }
+procedure setWindowOwner(win_id: uint32; pid: uint32);
+
+{ Check all windows for dead owner processes and close them.
+  Called once per frame from graphicsrefresh. }
+procedure reapOrphanedWindows;
+
 implementation
 
 var
@@ -641,6 +651,7 @@ begin
     wins[id].on_close     := closeCB;
     wins[id].on_resize    := nil;
     wins[id].cursor_obj   := cursor;
+    wins[id].owner_pid    := 0;
 
     { Bring to front }
     bringToFront(id);
@@ -698,6 +709,7 @@ begin
     wins[win_id].on_close  := nil;
     wins[win_id].on_resize := nil;
     wins[win_id].cursor_obj := nil;
+    wins[win_id].owner_pid := 0;
 
     tracer.pop_trace;
 end;
@@ -746,4 +758,36 @@ begin
     wins[win_id].on_resize := cb;
 end;
 
+{ ============================================================
+  Public: set window owner PID
+  ============================================================ }
+procedure setWindowOwner(win_id: uint32; pid: uint32);
+begin
+    if (win_id < 1) or (win_id > MAX_WINDOWS) then exit;
+    if wins[win_id].state = wsNone then exit;
+    wins[win_id].owner_pid := pid;
+end;
+
+{ ============================================================
+  Public: reap windows whose owning process has died
+  ============================================================ }
+procedure reapOrphanedWindows;
+var
+    i   : uint32;
+    ctx : PProcessContext;
+begin
+    for i := 1 to MAX_WINDOWS do begin
+        if wins[i].state = wsNone then continue;
+        if wins[i].owner_pid = 0 then continue;
+        ctx := processmanager.findByID(wins[i].owner_pid);
+        if (ctx = nil) or (ctx^.State = psFinished) or (ctx^.State = psError) then begin
+            { Owner is dead — trigger close callback or destroy directly }
+            if wins[i].on_close <> nil then
+                wins[i].on_close(i)
+            else
+                destroyWindow(i);
+        end;
+    end;
+end;
+
 end.

src/drivermanagement.pas

@@ -72,6 +72,8 @@ procedure register_driver(Driver_Name : PChar; DeviceID : PDeviceIdentifier; Loa
 procedure register_driver_ex(Driver_Name : PChar; DeviceID : PDeviceIdentifier; Load_Callback : TDriverLoadCallback; force_load : boolean);
 procedure register_device(Device_Name : PChar; DeviceID : PDeviceIdentifier; ptr : void);
 
+procedure terminal_command_dev(Params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
+
 var
     Root : PDriverRegistration = nil;
     Dev  : PDeviceRegistration = nil;
@@ -328,10 +330,6 @@ end;
 procedure init;
 begin
     push_trace('driver_management.init');
-    stdio.registerCommand('DEV', @terminal_command_dev, 'Driver Management Interface.');
-    //stdio.registerCommand('DRIVERSEX', @terminal_command_driversex, 'List all available drivers.');
-    //stdio.registerCommand('DRIVERS', @terminal_command_drivers, 'List loaded drivers.');
-    //stdio.registerCommand('DEVICES', @terminal_command_devices, 'List devices.');
     pop_trace;
 end;
 

src/include/proctypes.pas

@@ -0,0 +1,114 @@
+{
+    ProcTypes - Type definitions for the preemptive process management system.
+
+    Defines process states, system messages, context records, and resource
+    bindings used by processmanager.pas and contextswitcher.pas.
+
+    @author(Kieron Morris <kjm@kieronmorris.me>)
+}
+unit proctypes;
+
+interface
+
+uses
+    stdio;
+
+const
+    { 8 KB per-process kernel stack }
+    PROCESS_STACK_SIZE = 8192;
+
+    { Base quantum multiplier: quantum = Priority * BASE_QUANTUM ticks }
+    BASE_QUANTUM = 8;
+
+type
+    { Forward declaration }
+    PProcessContext = ^TProcessContext;
+
+    { Process states }
+    TProcessState = (
+        psCreated,      { Allocated, stack prepared, not yet scheduled }
+        psRunning,      { Currently executing on the main thread }
+        psReady,        { Runnable but not the current process }
+        psSuspended,    { Paused - will not be scheduled }
+        psAwaiting,     { Blocked on I/O or event - will not be scheduled }
+        psFinished,     { Terminal state - safe to reap }
+        psError         { Unrecoverable error - safe to reap }
+    );
+
+    { System messages delivered to processes }
+    TProcessSysMsg = (
+        smNone,         { No message }
+        smTerminate,    { Graceful shutdown requested }
+        smKill,         { Immediate forced shutdown }
+        smSuspend,      { Pause execution }
+        smResume,       { Resume from suspended }
+        smInput,        { New data available on stdin }
+        smChildExited,  { A child process has exited }
+        smCustom        { User-defined message (payload in MsgData) }
+    );
+
+    { Process entry point - a procedure that IS the process.
+      When this procedure returns, the process is finished. }
+    TProcessEntryPoint = procedure(ctx : PProcessContext);
+
+    { Resource binding types }
+    TResourceKind = (
+        rkSocket,       { TCP/UDP socket }
+        rkTimer,        { A timer hook }
+        rkFileHandle,   { VFS file descriptor }
+        rkCustom        { Arbitrary pointer }
+    );
+
+    { Resource cleanup callback }
+    TResourceCleanup = procedure(handle : void);
+
+    PResourceBinding = ^TResourceBinding;
+    TResourceBinding = record
+        Kind    : TResourceKind;
+        Handle  : void;
+        Cleanup : TResourceCleanup;
+    end;
+
+    { Process context - the core data structure for each process }
+    TProcessContext = record
+        { Identity }
+        ProcessID   : uint32;
+        Name        : array[0..31] of char;
+        ParentID    : uint32;
+
+        { State }
+        State       : TProcessState;
+        ExitCode    : uint32;
+
+        { StdIO - per-process I/O buffers }
+        StdIn       : POutBuf;
+        StdOut      : POutBuf;
+        StdErr      : POutBuf;
+
+        { Entry point }
+        EntryPoint  : TProcessEntryPoint;
+
+        { Context switch state }
+        SavedESP    : uint32;
+        StackBase   : void;
+        StackTop    : uint32;
+
+        { Scheduling }
+        Priority    : uint8;
+        Quantum     : uint16;
+        TicksUsed   : uint16;
+
+        { System messages }
+        PendingMsg  : TProcessSysMsg;
+        MsgData     : void;
+
+        { Resource bindings (PDList of TResourceBinding) }
+        Resources   : void;
+
+        { User-defined state }
+        Local       : void;
+    end;
+
+implementation
+
+end.

src/isr/isrmanager.pas

@@ -31,6 +31,7 @@ type
 
 procedure init;
 procedure registerISR(INT_N : uint8; callback : TISRHook);
+procedure dispatchHooks(INT_N : uint8);
 
 implementation
 
@@ -51,6 +52,15 @@ begin
     end;
 end;
 
+procedure dispatchHooks(INT_N : uint8);
+var
+    i : uint8;
+begin
+    for i:=0 to MAX_HOOKS do begin
+        if Hooks[INT_N][i] <> nil then Hooks[INT_N][i]();
+    end;
+end;
+
 procedure ISR_N(INT_N : uint8);
 var
     i : uint8;

src/kernel.pas

@@ -35,6 +35,8 @@ uses
      drivermanagement,
      scheduler,
      progmanager,
+     processmanager, contextswitcher,
+     testprocs,
      PCI,
      strings,
      USB,
@@ -227,6 +229,9 @@ begin
      { Init Progs }
      progmanager.init();
 
+     { Init process manager }
+     processmanager.init;
+
      { Seed RNG }
      rand.srand((getDateTime.Seconds SHL 24) OR (getDateTime.Minutes SHL 16) OR (getDateTime.Hours SHL 8) OR (getDateTime.Day));
 
@@ -267,6 +272,12 @@ begin
      graphicsrefresh.init;
      usbhotplug.init;
 
+     { Spawn test processes (before preemption is enabled) }
+     //testprocs.init;
+
+     { Enable preemptive context switching (replaces ISR_32) }
+     contextswitcher.init;
+
      { All work is now driven by timer interrupts — idle the CPU }
      syslog.logln('KERNEL', 'All tasks registered. Halting into idle.');
      kernel.yield();

src/prog/ping.pas

@@ -0,0 +1,145 @@
+{
+    Prog->Ping - ICMP Ping command.
+
+    Sends 10 ICMP echo requests to a host, printing round-trip time
+    for each reply. Sleeps 1 second between pings. Each invocation
+    uses a heap-allocated state record so multiple terminals can ping
+    concurrently without corrupting each other.
+
+    @author(Kieron Morris <kjm@kieronmorris.me>)
+}
+unit ping;
+
+interface
+
+uses
+    stdio, tracer;
+
+procedure init();
+
+implementation
+
+uses
+    bios_data_area, nettypes, icmp, netutils, strings,
+    processmanager, util, lmemorymanager;
+
+const
+    PING_TIMEOUT_MS = 5000;  { 5-second timeout per ping }
+
+type
+    TPingResult = (prWaiting, prGotReply, prGotError);
+    PPingState  = ^TPingState;
+    TPingState  = record
+        Result      : TPingResult;
+        ReplyTimeMS : uint64;
+        ErrorReason : TARPErrorCode;
+        SendTime    : uint64;
+    end;
+
+{ ---- ICMP callbacks (called from network recv context) ---- }
+
+procedure on_reply(hdr : PICMPHeader; userData : void);
+var
+    st : PPingState;
+    t2 : uint64;
+begin
+    st := PPingState(userData);
+    if st = nil then exit;
+    t2 := Counters.c64;
+    st^.ReplyTimeMS := t2 - st^.SendTime;
+    st^.Result := prGotReply;
+end;
+
+procedure on_error(hdr : PICMPHeader; Reason : TARPErrorCode; userData : void);
+var
+    st : PPingState;
+begin
+    st := PPingState(userData);
+    if st = nil then exit;
+    st^.ErrorReason := Reason;
+    st^.Result := prGotError;
+end;
+
+{ ---- Command entry point (runs as a process) ---- }
+
+procedure run(Params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
+var
+    ip_str   : pchar;
+    ip       : puint8;
+    i        : uint16;
+    st       : PPingState;
+    tStart   : uint32;
+    tNow     : uint32;
+    elapsed  : uint32;
+    timeoutTicks : uint32;
+begin
+    if ParamCount(Params) < 1 then begin
+        stdio.bufWriteStrLn(stderr_buf, 'Usage: PING <ip>');
+        exit;
+    end;
+
+    ip_str := getParam(0, Params);
+    ip := stringToIPv4(ip_str);
+    if ip = nil then begin
+        stdio.bufWriteStrLn(stderr_buf, 'Invalid IP address.');
+        exit;
+    end;
+
+    { Allocate per-invocation state so concurrent pings are safe }
+    st := PPingState(kalloc(sizeof(TPingState)));
+    timeoutTicks := (PING_TIMEOUT_MS * 1024) div 1000;
+
+    for i := 0 to 9 do begin
+        { Send ICMP echo request }
+        st^.Result := prWaiting;
+        st^.SendTime := Counters.c64;
+        icmp.sendICMPRequest(ip, i, 128, @on_reply, @on_error, void(st));
+
+        { Spin-yield until callback fires or timeout }
+        tStart := Counters.c32;
+        while st^.Result = prWaiting do begin
+            processmanager.proc_yield;
+            tNow := Counters.c32;
+            if tNow >= tStart then
+                elapsed := tNow - tStart
+            else
+                elapsed := ($FFFFFFFF - tStart) + tNow + 1;
+            if elapsed >= timeoutTicks then begin
+                st^.Result := prGotError;
+                st^.ErrorReason := aecTimeout;
+                break;
+            end;
+        end;
+
+        { Display result }
+        if st^.Result = prGotReply then begin
+            stdio.bufWriteStr(stdout_buf, 'Ping Reply: ');
+            stdio.bufWriteInt(stdout_buf, st^.ReplyTimeMS);
+            stdio.bufWriteStrLn(stdout_buf, 'ms.');
+        end else begin
+            stdio.bufWriteStr(stderr_buf, 'Ping Error: ');
+            case st^.ErrorReason of
+                aecFailedToResolveHost: stdio.bufWriteStrLn(stderr_buf, 'Failed to resolve host.');
+                aecNoRouteToHost:       stdio.bufWriteStrLn(stderr_buf, 'No route to host.');
+                aecTimeout:             stdio.bufWriteStrLn(stderr_buf, 'Timeout expired.');
+                aecTTLExpired:          stdio.bufWriteStrLn(stderr_buf, 'TTL Expired.');
+            end;
+        end;
+
+        { Sleep 1 second between pings (except after last) }
+        if i < 9 then
+            processmanager.proc_sleep_ms(1000);
+    end;
+
+    { Clean up }
+    kfree(void(st));
+    kfree(void(ip));
+end;
+
+procedure init();
+begin
+    tracer.push_trace('ping.init');
+    stdio.registerCommand('PING', @run, 'Ping a host.');
+end;
+
+end.

src/prog/testcmd.pas

@@ -0,0 +1,42 @@
+{
+    Prog->TestCmd - Test command that prints 5 lines with 1-second delays.
+
+    Demonstrates a long-running command that writes incrementally to stdout.
+
+    @author(Kieron Morris <kjm@kieronmorris.me>)
+}
+unit testcmd;
+
+interface
+
+uses
+    stdio, processmanager, tracer;
+
+procedure init();
+
+implementation
+
+procedure run(Params : PParamList; stdin_buf, stdout_buf, stderr_buf : POutBuf);
+var
+    i : uint32;
+begin
+    for i := 1 to 5 do begin
+        case i of
+            1: stdio.bufWriteStrLn(stdout_buf, 'Test output 1 of 5');
+            2: stdio.bufWriteStrLn(stdout_buf, 'Test output 2 of 5');
+            3: stdio.bufWriteStrLn(stdout_buf, 'Test output 3 of 5');
+            4: stdio.bufWriteStrLn(stdout_buf, 'Test output 4 of 5');
+            5: stdio.bufWriteStrLn(stdout_buf, 'Test output 5 of 5');
+        end;
+        if i < 5 then
+            processmanager.proc_sleep_ms(1000);
+    end;
+end;
+
+procedure init();
+begin
+    tracer.push_trace('testcmd.init');
+    stdio.registerCommand('TEST', @run, 'Print 5 lines with 1-second delays.');
+end;
+
+end.