feat: add inherited sessions and desktop session teardown

kernel/src/Api/Process.hpp

@@ -159,6 +159,14 @@ namespace montauk::abi {
         return Sched::KillProcess(pid);
     }
 
+    static int Sys_SetSession() {
+        return Sched::CreateSession();
+    }
+
+    static int Sys_KillSession(int sessionId) {
+        return Sched::KillSession(sessionId);
+    }
+
     static int Sys_SetUser(int pid, const char* name) {
         if (name == nullptr) return -1;
         auto* target = Sched::GetProcessByPid(pid);

kernel/src/Api/Syscall.cpp

@@ -359,6 +359,10 @@ namespace montauk::abi {
                 return (int64_t)Sys_ProcList((ProcInfo*)frame->arg1, (int)frame->arg2);
             case SYS_KILL:
                 return (int64_t)Sys_Kill((int)frame->arg1);
+            case SYS_SETSESSION:
+                return (int64_t)Sys_SetSession();
+            case SYS_KILLSESSION:
+                return (int64_t)Sys_KillSession((int)frame->arg1);
             case SYS_DEVLIST:
                 if ((int64_t)frame->arg2 < 0) return -1;
                 if (!UserMemory::Range(frame->arg1, (uint64_t)frame->arg2 * sizeof(DevInfo), true)) return -1;

kernel/src/Api/Syscall.hpp

@@ -194,6 +194,8 @@ namespace montauk::abi {
     /* Process.hpp */
     static constexpr uint64_t SYS_SETUSER       = 92;
     static constexpr uint64_t SYS_GETUSER       = 93;
+    static constexpr uint64_t SYS_SETSESSION    = 174;
+    static constexpr uint64_t SYS_KILLSESSION   = 175;
 
     /* Filesystem.hpp */
     static constexpr uint64_t SYS_FRENAME       = 94;

kernel/src/Sched/Scheduler.cpp

@@ -297,6 +297,7 @@ namespace Sched {
             processTable[i].environment[0] = '\0';
             processTable[i].environmentLength = 1;
             processTable[i].user[0] = '\0';
+            processTable[i].sessionId = -1;
             processTable[i].cwd[0] = '\0';
             processTable[i].runningOnCpu = -1;
             processTable[i].killPending = false;
@@ -560,6 +561,13 @@ namespace Sched {
             }
         }
 
+        // Process sessions are explicit groups used by supervisors such as
+        // login.elf. A session leader opts in with CreateSession(); all of its
+        // subsequently spawned descendants inherit the same stable ID.
+        proc.sessionId = (parentPrimarySlot >= 0)
+            ? processTable[parentPrimarySlot].sessionId
+            : -1;
+
         {
             if (parentSlot >= 0 && processTable[parentSlot].cwd[0]) {
                 int i = 0;
@@ -1747,6 +1755,68 @@ namespace Sched {
         return 0;
     }
 
+    int CreateSession() {
+        schedLock.Acquire();
+        Process* proc = GetCurrentProcessPtr();
+        if (proc == nullptr) {
+            schedLock.Release();
+            return -1;
+        }
+        proc->sessionId = proc->pid;
+        int sessionId = proc->sessionId;
+        schedLock.Release();
+        return sessionId;
+    }
+
+    int KillSession(int sessionId) {
+        if (sessionId < 0) return -1;
+
+        int callerPid = GetCurrentPid();
+        int killed = 0;
+
+        // Mark the complete group in one scheduler-lock transaction. New
+        // children inherit sessionId, so a supervisor can repeat this call
+        // until zero is returned to close the small spawn/exit race cleanly.
+        schedLock.Acquire();
+        for (int i = 0; i < MaxProcesses; i++) {
+            Process& primary = processTable[i];
+            if (primary.primarySlot != i || primary.pid == callerPid ||
+                primary.sessionId != sessionId) {
+                continue;
+            }
+            auto state = primary.state;
+            if (state != ProcessState::Ready && state != ProcessState::Running &&
+                state != ProcessState::Blocked) {
+                continue;
+            }
+
+            primary.exitCode = 256 + 9; /* killed (SIGKILL) */
+            primary.killPending = true;
+            if (primary.state == ProcessState::Blocked) {
+                primary.state = ProcessState::Ready;
+                readyCount++;
+                primary.waitingForPid = -1;
+                primary.waitingOnObject = nullptr;
+                primary.sleepUntilTick = 0;
+            }
+
+            for (int j = 0; j < MaxProcesses; j++) {
+                if (j == i || processTable[j].primarySlot != i) continue;
+                if (processTable[j].state == ProcessState::Running) {
+                    processTable[j].killPending = true;
+                }
+            }
+            killed++;
+        }
+        schedLock.Release();
+
+        if (killed > 0) {
+            KickOneIdleCpu(Smp::GetCurrentCpuData()
+                ? Smp::GetCurrentCpuData()->cpuIndex : -1);
+        }
+        return killed;
+    }
+
     int LookupExitCode(int pid) {
         schedLock.Acquire();
         int code = 0;

kernel/src/Sched/Scheduler.hpp

@@ -86,6 +86,7 @@ namespace Sched {
         char environment[EnvironmentBytes]; // NUL-separated NAME=VALUE entries
         uint32_t environmentLength;
         char user[32];            // Owner user name (inherited from parent on spawn)
+        int sessionId;            // Process-session leader PID (inherited on spawn)
         char cwd[256];            // Absolute current working directory
 
         // Thread-local storage. fsBase is loaded into IA32_FS_BASE when
@@ -252,6 +253,12 @@ namespace Sched {
     // Returns 0 on success, -1 on failure.
     int KillProcess(int pid);
 
+    // Start a new process session for the caller, or terminate every process
+    // belonging to a session. KillSession returns the number of live members
+    // it signalled; callers can repeat until it returns zero.
+    int CreateSession();
+    int KillSession(int sessionId);
+
     // Find a process by PID (returns nullptr if not found or not alive)
     Process* GetProcessByPid(int pid);