lay down framework for [v]fork and clone[3]

Author: ilobilo

kernel/interfaces/system/memory/pmm.cppm

@@ -51,7 +51,9 @@ export namespace pmm
     memory info();
 
     page *page_for(std::uintptr_t addr);
-    inline page *page_for(auto ptr)
+
+    template<typename Type> requires (std::is_pointer_v<Type>)
+    inline page *page_for(Type ptr)
     {
         return page_for(reinterpret_cast<std::uintptr_t>(ptr));
     }

kernel/interfaces/system/syscall/proc.cppm

@@ -42,5 +42,11 @@ export namespace syscall::proc
 
     int prlimit(pid_t pid, int resource, const struct rlimit __user *new_limit, struct rlimit __user *old_limit);
 
+    long clone(unsigned long flags, void __user *stack, int __user *parent_tid, int __user *child_tid, unsigned long tls);
+    long clone3(struct clone_args __user *cl_args, std::size_t size);
+
+    pid_t fork();
+    pid_t vfork();
+
     [[noreturn]] void exit_group(int status);
 } // export namespace syscall::proc

kernel/source/arch/x86_64/system/syscall.cpp

@@ -50,6 +50,9 @@ namespace x86_64::syscall
         [32] = { "dup", vfs::dup },
         [33] = { "dup2", vfs::dup2 },
         [39] = { "getpid", proc::getpid },
+        [56] = { "clone", proc::clone },
+        [57] = { "fork", proc::fork },
+        [58] = { "vfork", proc::vfork },
         [63] = { "uname", misc::uname },
         [72] = { "fcntl", vfs::fcntl },
         [79] = { "getcwd", vfs::getcwd, [](std::uintptr_t val) { return val == 0; } },
@@ -86,6 +89,7 @@ namespace x86_64::syscall
         [302] = { "prlimit", proc::prlimit },
         [318] = { "getrandom", misc::getrandom },
         [334] = { "rseq", proc::rseq },
+        [435] = { "clone3", proc::clone3 }
     };
 
     cpu_local<bool> in_syscall;

kernel/source/system/syscall/proc.cpp

@@ -355,6 +355,162 @@ namespace syscall::proc
         return (errno = ENOSYS, -1);
     }
 
+    namespace
+    {
+        struct kclone_args
+        {
+            std::uint64_t flags;
+            int __user *pidfd;
+            int __user *child_tid;
+            int __user *parent_tid;
+            int exit_signal;
+            std::uint64_t stack;
+            std::uint64_t stack_size;
+            std::uint64_t tls;
+            pid_t *set_tid;
+            std::size_t set_tid_size;
+            int cgroup;
+        };
+
+        enum clone_flags : std::uint64_t
+        {
+            csignal = 0x000000FF, // signal mask to be sent at exit
+            clone_vm = 0x00000100, // set if VM shared between processes
+            clone_fs = 0x00000200, // set if fs info shared between processes
+            clone_files = 0x00000400, // set if open files shared between processes
+            clone_sighand = 0x00000800, // set if signal handlers and blocked signals shared
+            clone_pidfd = 0x00001000, // set if a pidfd should be placed in parent
+            clone_ptrace = 0x00002000, // set if we want to let tracing continue on the child too
+            clone_vfork = 0x00004000, // set if the parent wants the child to wake it up on mm_release
+            clone_parent = 0x00008000, // set if we want to have the same parent as the cloner
+            clone_thread = 0x00010000, // same thread group?
+            clone_newns = 0x00020000, // new mount namespace group
+            clone_sysvsem = 0x00040000, // share system V SEM_UNDO semantics
+            clone_settls = 0x00080000, // create a new TLS for the child
+            clone_parent_settid = 0x00100000, // set the TID in the parent
+            clone_child_cleartid = 0x00200000, // clear the TID in the child
+            clone_detached = 0x00400000, // unused, ignored
+            clone_untraced = 0x00800000, // set if the tracing process can't force CLONE_PTRACE on this clone
+            clone_child_settid = 0x01000000, // set the TID in the child
+            clone_newcgroup = 0x02000000, // new cgroup namespace
+            clone_newuts = 0x04000000, // new utsname namespace
+            clone_newipc = 0x08000000, // new ipc namespace
+            clone_newuser = 0x10000000, // new user namespace
+            clone_newpid = 0x20000000, // new pid namespace
+            clone_newnet = 0x40000000, // new network namespace
+            clone_io = 0x80000000, // clone io context
+            clone_clear_sighand = 0x100000000ull, // clear any signal handler and reset to SIG_DFL.
+            clone_into_cgroup = 0x200000000ull, // clone into a specific cgroup given the right permissions.
+            clone_newtime = 0x00000080 // new time namespace
+
+        };
+
+        pid_t kclone(const kclone_args &args)
+        {
+            // TODO
+            lib::unused(args);
+            return (errno = ENOSYS, -1);
+        }
+    } // namespace
+
+    long clone(unsigned long flags, void __user *stack, int __user *parent_tid, int __user *child_tid, unsigned long tls)
+    {
+        return kclone({
+            .flags = (flags & 0xFFFFFFFF) & ~csignal,
+            .pidfd = parent_tid,
+            .child_tid = child_tid,
+            .parent_tid = parent_tid,
+            .exit_signal = static_cast<int>((flags & 0xFFFFFFFF) & csignal),
+            .stack = reinterpret_cast<std::uintptr_t>(stack),
+            .stack_size = 0,
+            .tls = tls,
+            .set_tid = nullptr,
+            .set_tid_size = 0,
+            .cgroup = -1,
+        });
+    }
+
+    struct clone_args
+    {
+        std::uint64_t flags;
+        std::uint64_t pidfd;
+        std::uint64_t child_tid;
+        std::uint64_t parent_tid;
+        std::uint64_t exit_signal;
+        std::uint64_t stack;
+        std::uint64_t stack_size;
+        std::uint64_t tls;
+        std::uint64_t set_tid;
+        std::uint64_t set_tid_size;
+        std::uint64_t cgroup;
+    };
+
+    long clone3(clone_args __user *cl_args, std::size_t size)
+    {
+        pid_t set_tid[32] { };
+
+        clone_args uargs { };
+        if (size < 64 || size > sizeof(clone_args))
+            return (errno = EINVAL, -1);
+
+        if (!lib::copy_from_user(&uargs, cl_args, size))
+            return (errno = EFAULT, -1);
+
+        if (uargs.set_tid_size > 32)
+            return (errno = EINVAL, -1);
+
+        if (!uargs.set_tid && uargs.set_tid_size > 0)
+            return (errno = EINVAL, -1);
+
+        if (uargs.set_tid && uargs.set_tid_size == 0)
+            return (errno = EINVAL, -1);
+
+        if ((uargs.exit_signal & ~csignal) || uargs.exit_signal > 64 /* _NSIG */)
+		    return -EINVAL;
+
+        if ((uargs.flags & clone_into_cgroup) && (uargs.cgroup > std::numeric_limits<int>::max() || size < sizeof(clone_args)))
+		    return -EINVAL;
+
+        kclone_args kargs
+        {
+            .flags = uargs.flags,
+            .pidfd = reinterpret_cast<int __user *>(uargs.pidfd),
+            .child_tid = reinterpret_cast<int __user *>(uargs.child_tid),
+            .parent_tid = reinterpret_cast<int __user *>(uargs.parent_tid),
+            .exit_signal = static_cast<int>(uargs.exit_signal),
+            .stack = uargs.stack,
+            .stack_size = uargs.stack_size,
+            .tls = uargs.tls,
+            .set_tid = set_tid,
+            .set_tid_size = uargs.set_tid_size,
+            .cgroup = static_cast<int>(uargs.cgroup),
+        };
+
+        const auto uset_tid = reinterpret_cast<int __user *>(uargs.set_tid);
+        const auto uset_tid_size_bytes = uargs.set_tid_size * sizeof(pid_t);
+        if (uargs.set_tid && !lib::copy_from_user(set_tid, uset_tid, uset_tid_size_bytes))
+            return (errno = EFAULT, -1);
+
+        return kclone(kargs);
+    }
+
+    pid_t fork()
+    {
+        kclone_args args { };
+        // TODO
+        // args.exit_signal = sigchld;
+        return kclone(args);
+    }
+
+    pid_t vfork()
+    {
+        kclone_args args { };
+        args.flags = clone_vfork | clone_vm;
+        // TODO
+        // args.exit_signal = sigchld;
+        return kclone(args);
+    }
+
     [[noreturn]] void exit_group(int status)
     {
         // TODO