use smart pointers for threads and processes

Author: ilobilo

kernel/interfaces/drivers/fs/dev/tty.cppm

@@ -430,7 +430,7 @@ export namespace fs::dev::tty
 
         std::atomic_bool stopped;
 
-        sched::thread_t *worker_thread;
+        std::weak_ptr<sched::thread_t> worker_thread;
         std::atomic_bool should_work;
         std::atomic_bool shut_down;
         sched::wait_queue_t hung_wq;
@@ -485,7 +485,7 @@ export namespace fs::dev::tty
 
         lib::rbspscd<std::byte, raw_buffer_size> raw_buffer;
         sched::wait_queue_t raw_wq;
-        sched::thread_t *worker_thread;
+        std::weak_ptr<sched::thread_t> worker_thread;
         std::atomic_bool raw_should_work;
 
         std::weak_ptr<instance> link;

kernel/interfaces/system/bin/exec.cppm

@@ -30,7 +30,7 @@ export namespace bin::exec
         public:
         virtual ~image() = default;
 
-        virtual sched::thread_t *load(const request &req) const = 0;
+        virtual std::shared_ptr<sched::thread_t> load(const request &req) const = 0;
 
         virtual std::string_view format_name() const = 0;
     };

kernel/interfaces/system/proc/mutex.cppm

@@ -45,7 +45,7 @@ export namespace sched
                         lib::panic("mutex deadlock");
                 }
 
-                _waiters.wait_unint();
+                _waiters.wait_unkillable();
             }
         }
 
@@ -67,7 +67,8 @@ export namespace sched
                         lib::panic("mutex deadlock");
                 }
 
-                if (_waiters.wait().interrupted)
+                const auto res = _waiters.wait();
+                if (res.interrupted || res.killed)
                     return false;
             }
         }
@@ -121,7 +122,8 @@ export namespace sched
                 if (now >= deadline)
                     return false;
 
-                if (_waiters.wait(deadline - now).interrupted)
+                const auto res = _waiters.wait(deadline - now);
+                if (res.interrupted || res.killed)
                     return false;
             }
         }
@@ -173,7 +175,7 @@ export namespace sched
                     }
                 }
 
-                _waiters.wait_unint();
+                _waiters.wait_unkillable();
             }
         }
 
@@ -200,7 +202,8 @@ export namespace sched
                     }
                 }
 
-                if (_waiters.wait().interrupted)
+                const auto res = _waiters.wait();
+                if (res.interrupted || res.killed)
                     return false;
             }
         }
@@ -281,7 +284,8 @@ export namespace sched
                 if (now >= deadline)
                     return false;
 
-                if (_waiters.wait(deadline - now).interrupted)
+                const auto res = _waiters.wait(deadline - now);
+                if (res.interrupted || res.killed)
                     return false;
             }
         }

kernel/interfaces/system/proc/process.cppm

@@ -33,16 +33,16 @@ export namespace sched
         root = 2
     };
 
-    struct process_t
+    struct process_t : std::enable_shared_from_this<process_t>
     {
         pid_t pid;
 
-        process_t *parent;
+        std::weak_ptr<process_t> parent;
 
         lib::locker<
             lib::map::flat_hash<
                 pid_t,
-                process_t *
+                std::shared_ptr<process_t>
             >, mutex
         > children;
 
@@ -78,12 +78,11 @@ export namespace sched
         lib::locker<
             lib::map::flat_hash<
                 pid_t,
-                thread_t *
+                std::shared_ptr<thread_t>
             >, mutex
         > threads;
 
         std::atomic<std::size_t> alive_threads = 0;
-        std::atomic<std::size_t> to_quiesce = 0;
 
         std::atomic<dumpable_t> dumpable = dumpable_t::user;
 
@@ -123,7 +122,7 @@ export namespace sched
         lib::locker<
             lib::map::flat_hash<
                 pid_t,
-                process_t *
+                std::weak_ptr<process_t>
             >, mutex
         > members;
 

kernel/interfaces/system/proc/run_queue.cppm

@@ -46,7 +46,7 @@ export namespace sched
         std::uint64_t nr_running;
 
         thread_t *current;
-        thread_t *idle;
+        std::shared_ptr<thread_t> idle;
 
         std::uint64_t nr_switches;
 

kernel/interfaces/system/proc/scheduler.cppm

@@ -104,14 +104,14 @@ export namespace sched
     // called on yield, block, timer or wake up
     void schedule();
 
-    process_t *create_process(process_t *parent);
+    std::shared_ptr<process_t> create_process(const std::shared_ptr<process_t> &parent);
 
     // create a new kernel thread under pid 0
-    thread_t *create_kthread(std::uintptr_t ip, std::uintptr_t arg, nice_t nice = default_nice);
+    std::shared_ptr<thread_t> create_kthread(std::uintptr_t ip, std::uintptr_t arg, nice_t nice = default_nice);
 
     // create a user thread
-    thread_t *create_uthread(
-        process_t *proc, std::uintptr_t ip, std::uintptr_t arg,
+    std::shared_ptr<thread_t> create_uthread(
+        const std::shared_ptr<process_t> &proc, std::uintptr_t ip, std::uintptr_t arg,
         bool is_trampoline, bool is_clone,
         std::uintptr_t stack, nice_t nice = default_nice
     );
@@ -120,17 +120,17 @@ export namespace sched
     void enqueue_new(thread_t *thread);
 
     // create a new kernel thread and enqueue it
-    thread_t *spawn(std::uintptr_t ip, std::uintptr_t arg = 0, nice_t nice = default_nice);
+    std::shared_ptr<thread_t> spawn(std::uintptr_t ip, std::uintptr_t arg = 0, nice_t nice = default_nice);
 
     template<typename Func>
-    inline thread_t *spawn(Func &&func, std::uintptr_t arg = 0, nice_t nice = default_nice)
+    inline std::shared_ptr<thread_t> spawn(Func &&func, std::uintptr_t arg = 0, nice_t nice = default_nice)
     {
         return spawn(reinterpret_cast<std::uintptr_t>(func), arg, nice);
     }
 
     template<typename Func, typename Arg>
         requires (!std::convertible_to<Arg, std::uintptr_t>)
-    inline thread_t *spawn(Func &&func, Arg arg, nice_t nice = default_nice)
+    inline std::shared_ptr<thread_t> spawn(Func &&func, Arg arg, nice_t nice = default_nice)
     {
         return spawn(
             reinterpret_cast<std::uintptr_t>(func),
@@ -142,6 +142,9 @@ export namespace sched
 
     bool yield();
 
+    void request_kill(thread_t *thread, int exit_code);
+    void die_if_kill_pending();
+
     // exit the current thread
     // if this is the last thread, process becomes a zombie
     [[noreturn]] void thread_exit(int exit_code);
@@ -153,12 +156,12 @@ export namespace sched
     // status reported to waitpid will have WIFSIGNALED set
     [[noreturn]] void process_exit_signal(int signo, bool core_dumped = false);
 
-    process_t *get_process(pid_t pid);
-    thread_t *get_thread(pid_t tid);
+    std::shared_ptr<process_t> get_process(pid_t pid);
+    std::shared_ptr<thread_t> get_thread(pid_t tid);
 
     std::size_t process_count();
 
-    void for_each_process(std::function<bool (process_t *)> func);
+    void for_each_process(std::function<bool (const std::shared_ptr<process_t> &)> func);
 
     // called from a timer interrupt
     void tick(bool from_user);

kernel/interfaces/system/proc/signal.cppm

@@ -281,6 +281,8 @@ export namespace sched
     bool send_signal(thread_t *thread, const siginfo_t &info);
     bool send_signal(process_t *process, const siginfo_t &info);
 
+    bool signal_pending_for(thread_t *thread);
+
     void flush_signal(process_t *proc, int sig);
 
     void handle_pending_signals(cpu::registers *regs);

kernel/interfaces/system/proc/thread.cppm

@@ -36,7 +36,7 @@ export namespace sched
         needs_resched = (1 << 2),
         interrupted = (1 << 3),
         signal_pending = (1 << 4),
-        quiesce_pending = (1 << 5)
+        kill_pending = (1 << 5)
     };
 
     using namespace magic_enum::bitwise_operators;
@@ -63,6 +63,7 @@ export namespace sched
         std::atomic<thread_state> prev_state = thread_state::runnable;
         std::atomic<std::uint8_t> flags = 0;
         int exit_code = 0;
+        std::atomic<int> pending_exit_code = 0;
 
         std::uint64_t vruntime = 0;
         std::uint64_t total_runtime = 0;
@@ -76,16 +77,12 @@ export namespace sched
         void *on_rq = nullptr;
         lib::rbtree_hook<thread_t> hook;
 
-        lib::intrusive_list_hook<thread_t> dead_hook;
-
         std::atomic_bool *was_in_interrupt = nullptr;
         lib::spinlock_irq *needs_unlock = nullptr;
 
         std::atomic<wait_queue_t *> on_wait_queue = nullptr;
         std::atomic<wait_queue_entry_t *> wait_entry = nullptr;
 
-        std::atomic<bool> dead_listed = false;
-
         std::atomic<bool> on_cpu = false;
         thread_t *prev_to_release = nullptr;
 

kernel/interfaces/system/proc/wait_queue.cppm

@@ -9,6 +9,13 @@ import std;
 
 export namespace sched
 {
+    enum class wait_mode
+    {
+        interruptible, // woken by signals and kill
+        killable,      // woken by kill
+        unkillable     // uninterruptible
+    };
+
     struct wait_queue_entry_t
     {
         private:
@@ -56,14 +63,22 @@ export namespace sched
         {
             bool interrupted;
             bool expired;
+            bool killed;
         };
 
+        private:
+        wait_result_t wait_common(std::size_t gen, std::uint64_t ns, wait_mode mode);
+
+        public:
         wait_result_t wait(std::uint64_t ns = 0);
-        wait_result_t wait_unint(std::uint64_t ns = 0);
+        // ignores signals
+        wait_result_t wait_killable(std::uint64_t ns = 0);
+        wait_result_t wait_unkillable(std::uint64_t ns = 0);
 
         std::size_t snapshot_gen() const;
         wait_result_t wait_prepared(std::size_t gen, std::uint64_t ns = 0);
-        wait_result_t wait_unint_prepared(std::size_t gen, std::uint64_t ns = 0);
+        wait_result_t wait_killable_prepared(std::size_t gen, std::uint64_t ns = 0);
+        wait_result_t wait_unkillable_prepared(std::size_t gen, std::uint64_t ns = 0);
 
         void wake_one(bool drop = false);
         void wake_all();

kernel/interfaces/system/syscall/proc.cppm

@@ -72,6 +72,7 @@ export namespace syscall::proc
         const sched::sigset_t __user *uthese, sched::siginfo_t __user *uinfo,
         const timespec __user *uts, std::size_t sigsetsize
     );
+    int rt_sigsuspend(const sched::sigset_t __user *set, std::size_t sigsetsize);
     int sigaltstack(const sched::stack_t __user *ss, sched::stack_t __user *old_ss);
 
     std::uintptr_t rt_sigreturn();