rewrite procfs

Author: ilobilo

kernel/interfaces/drivers/fs/procfs.cppm

@@ -8,13 +8,84 @@ import std;
 
 export namespace fs::procfs
 {
-    using gen_fn = std::string (*)(sched::process_t *);
+    enum class node_type { file, dir, symlink };
 
-    // /proc/<name>
-    bool register_global(std::string name, gen_fn gen, mode_t mode, bool is_symlink = false);
+    struct node_ops;
+    struct node_t
+    {
+        std::string name;
+        mode_t mode;
+        node_type type;
+        std::shared_ptr<node_ops> ops;
+    };
 
-    // /proc/[pid]/<name>
-    bool register_per_pid(std::string name, gen_fn gen, mode_t mode, bool is_symlink = false);
+    struct node_ops
+    {
+        virtual ~node_ops() = default;
+
+        virtual bool can_trunc() { return false; }
+
+        virtual lib::expect<std::string> generate(sched::process_t *proc)
+        {
+            lib::unused(proc);
+            return std::unexpected { lib::err::not_supported };
+        }
+
+        virtual lib::expect<void> write(sched::process_t *proc, std::string_view data)
+        {
+            lib::unused(proc, data);
+            return std::unexpected { lib::err::read_only_fs };
+        }
+
+        virtual lib::expect<lib::path> readlink(sched::process_t *proc)
+        {
+            lib::unused(proc);
+            return std::unexpected { lib::err::not_supported };
+        }
+
+        virtual lib::expect<lib::list<node_t>> readdir(sched::process_t *proc)
+        {
+            lib::unused(proc);
+            return std::unexpected { lib::err::not_supported };
+        }
+
+        virtual lib::expect<node_t> lookup(sched::process_t *proc, std::string_view name)
+        {
+            lib::unused(proc, name);
+            return std::unexpected { lib::err::not_supported };
+        }
+
+        virtual bool revalidate(sched::process_t *proc)
+        {
+            lib::unused(proc);
+            return true;
+        }
+    };
+
+    // I hate myself
+    using gen_fn = std::function<lib::expect<std::string> (sched::process_t *)>;
+    using write_fn = std::function<lib::expect<void> (sched::process_t *, std::string_view)>;
+    using readlink_fn = std::function<lib::expect<lib::path> (sched::process_t *)>;
+    using lookup_fn = std::function<lib::expect<node_t> (sched::process_t *, std::string_view)>;
+    using readdir_fn = std::function<lib::expect<lib::list<node_t>> (sched::process_t *)>;
+    using revalidate_fn = std::function<bool (sched::process_t *)>;
+
+    std::shared_ptr<node_ops> make_file_ops(gen_fn gfn, write_fn wfn = nullptr);
+    std::shared_ptr<node_ops> make_symlink_ops(readlink_fn rdlfn, revalidate_fn rvfn = nullptr);
+
+    std::shared_ptr<node_ops> make_dir_ops(lookup_fn lfn = nullptr, readdir_fn rfn = nullptr);
+
+    // /proc/<path>
+    bool register_global(
+        lib::path path, std::shared_ptr<node_ops> ops,
+        node_type type, mode_t mode
+    );
+
+    // /proc/[pid]/<path>
+    bool register_per_pid(
+        lib::path path, std::shared_ptr<node_ops> ops,
+        node_type type, mode_t mode
+    );
 
     lib::initgraph::stage *registered_stage();
     lib::initgraph::stage *mounted_stage();

kernel/interfaces/drivers/fs/tmpfs.cppm

@@ -72,7 +72,7 @@ export namespace fs::tmpfs
                 -> lib::expect<lib::list<vfs::dir_entry>> override;
 
             auto lookup(std::shared_ptr<vfs::dentry> dir,std::string_view name)
-                -> lib::expect<std::optional<vfs::dir_entry>> override;
+                -> lib::expect<vfs::dir_entry> override;
 
             auto write_inode(std::shared_ptr<vfs::inode> &inode) -> lib::expect<void> override;
             auto dirty_inode(std::shared_ptr<vfs::inode> &inode) -> lib::expect<void> override;

kernel/interfaces/system/proc/scheduler.cppm

@@ -158,7 +158,7 @@ export namespace sched
 
     std::size_t process_count();
 
-    void for_each_process(std::function<bool(process_t *)> func);
+    void for_each_process(std::function<bool (process_t *)> func);
 
     // called from a timer interrupt
     void tick(bool from_user);

kernel/interfaces/system/sysctl.cppm

@@ -12,25 +12,8 @@ export namespace sysctl
     using int_read_fn = std::function<int ()>;
     using int_write_fn = std::function<lib::expect<void> (int)>;
 
-    struct entry
-    {
-        read_fn read;
-        write_fn write;
-        mode_t mode;
-    };
-
-    bool register_entry(std::string path, read_fn read, write_fn write, mode_t mode);
-    bool register_ro(std::string path, read_fn read, mode_t mode = 0444);
-    bool register_int(std::string path, int_read_fn read, int_write_fn write, mode_t mode = 0644);
-    bool register_int_stub(std::string path, int default_value, mode_t mode = 0644);
-
-    std::optional<entry> find(std::string_view path);
-
-    struct dirent
-    {
-        std::string name;
-        bool is_dir;
-    };
-    std::vector<dirent> list(std::string_view dir);
-    bool dir_exists(std::string_view path);
+    bool register_entry(std::string_view path, read_fn read, write_fn write, mode_t mode);
+    bool register_ro(std::string_view path, read_fn read, mode_t mode = 0444);
+    bool register_int(std::string_view path, int_read_fn read, int_write_fn write, mode_t mode = 0644);
+    bool register_int_stub(std::string_view path, int default_value, mode_t mode = 0644);
 } // export namespace sysctl

kernel/interfaces/system/system.cppm

@@ -15,7 +15,6 @@ export import system.pci;
 export import system.random;
 export import system.sched;
 export import system.syscall;
-export import system.sysctl;
 export import system.vfs;
 export import system.vfs.dev;
 export import system.vfs.pipe;

kernel/interfaces/system/vfs/socket/base.cppm

@@ -383,4 +383,6 @@ export namespace vfs::socket
     auto create_anon(std::shared_ptr<socket_t> sock, int flags) -> lib::expect<int>;
 
     std::shared_ptr<vfs::ops> get_ops();
+
+    lib::initgraph::stage *registered_procfs_stage();
 } // export namespace vfs::socket

kernel/interfaces/system/vfs/vfs.cppm

@@ -318,7 +318,7 @@ export namespace vfs
                 -> lib::expect<lib::list<dir_entry>> = 0;
 
             virtual auto lookup(std::shared_ptr<dentry> dir,std::string_view name)
-                -> lib::expect<std::optional<dir_entry>>;
+                -> lib::expect<dir_entry>;
 
             virtual auto readlink(std::shared_ptr<dentry> dentry) -> lib::expect<lib::path>;