Merge pull request #105 from KaiNorberg/develop

feat(kernel:sysfs): add sysfs, move acpi to sysfs, add filesystem int…

Author: KaiNorberg

Makefile

@@ -8,7 +8,7 @@ BOXES = $(shell find src/boxes/ -name "*.mk")
 PROGRAMS = $(shell find src/programs/ -name "*.mk")
 MODULES = $(shell find src/modules/ -name "*.mk")
 
-ROOT_DIRS = acpi base base/bin base/lib base/include base/data box cfg dev efi efi/boot kernel kernel/modules kernel/modules/$(VERSION_STRING) net proc sbin tmp
+ROOT_DIRS = acpi base base/bin base/lib base/include base/data box cfg dev efi efi/boot kernel kernel/modules kernel/modules/$(VERSION_STRING) net proc sbin sys tmp
 
 # Programs to copy to /sbin
 SBIN_PROGRAMS = init boxd

include/kernel/fs/devfs.h

@@ -15,6 +15,9 @@ typedef struct superblock_ops superblock_ops_t;
  * @ingroup kernel_fs
  * @defgroup kernel_fs_devfs Device Filesystem
  *
+ * The devfs is a virtual filesystem that provides access to devices and resources.
+ *
+ * @{
  */
 
 /**
@@ -30,8 +33,6 @@ void devfs_init(void);
 /**
  * @brief Create a new directory inside a mounted devfs instance.
  *
- * Used to, for example, create a new directory for a device or resource inside `/dev` or `/proc`.
- *
  * @param parent The parent directory, if `NULL` then the root is used.
  * @param name The name of the new directory.
  * @param inodeOps The inode operations for the new directory, can be `NULL`.
@@ -43,8 +44,6 @@ dentry_t* devfs_dir_new(dentry_t* parent, const char* name, const inode_ops_t* i
 /**
  * @brief Create a new file inside a mounted devfs instance.
  *
- * Used to, for example, create a new file for a device or resource inside `/dev` or `/proc`.
- *
  * @param parent The parent directory, if `NULL` then the root is used.
  * @param name The name of the new file.
  * @param inodeOps The inode operations for the new file, can be `NULL`.

include/kernel/fs/filesystem.h

@@ -18,9 +18,29 @@
 
 /**
  * @brief Filesystem interface.
- * @defgroup kernel_fs_filesystem Filesystem
+ * @defgroup kernel_fs_filesystem Filesystem.
  * @ingroup kernel_fs
  *
+ * The filesystem interface represents a filesystem type, e.g. fat32, tmpfs, devfs, etc. Each filesystem is exposed in a
+ * directory within the `fs` sysfs directory named after the filesystem.
+ *
+ * The directory itself can be used to mount instances of that filesystem type.
+ *
+ * Within each filesystem directory are readable files representing each mounted instance of that filesystem type, named
+ * after the superblock ID, containing the following information:
+ *
+ * ```
+ * id: %llu
+ * block_size: %llu
+ * max_file_size: %llu
+ *
+ * ```
+ *
+ * Where the `id` is the superblock ID, `block_size` is the block size of the superblock, and `max_file_size` is the
+ * maximum size of a file on this superblock.
+ *
+ * @see kernel_fs_sysfs
+ *
  * @{
  */
 
@@ -31,13 +51,21 @@
  */
 typedef struct filesystem
 {
+    list_entry_t entry;   ///< Used internally.
     map_entry_t mapEntry; ///< Used internally.
     list_t superblocks;   ///< Used internally.
     rwlock_t lock;        ///< Used internally.
     const char* name;
     dentry_t* (*mount)(filesystem_t* fs, block_device_t* device, void* private);
 } filesystem_t;
 
+/**
+ * @brief Exposes the sysfs `fs` directory.
+ *
+ * Must be called before `filesystem_get_by_path()` can be used.
+ */
+void filesystem_expose(void);
+
 /**
  * @brief Registers a filesystem.
  *
@@ -61,6 +89,20 @@ void filesystem_unregister(filesystem_t* fs);
  * @param name The name of the filesystem.
  * @return On success, the filesystem. On failure, returns `NULL`.
  */
-filesystem_t* filesystem_get(const char* name);
+filesystem_t* filesystem_get_by_name(const char* name);
+
+/**
+ * @brief Gets a filesystem by path.
+ *
+ * The path should point to a directory in the `fs` sysfs directory.
+ *
+ * @param path The path to check.
+ * @param process The process whose namespace to use.
+ * @return On success, the filesystem. On failure, returns `NULL` and `errno` is set to:
+ * - `ENOENT`: The path does not exist.
+ * - `ENOMEM`: Out of memory.
+ * - `EINVAL`: The path is not a directory in the `fs` sysfs directory.
+ */
+filesystem_t* filesystem_get_by_path(const char* path, process_t* process);
 
 /** @} */

include/kernel/fs/namespace.h

@@ -113,7 +113,7 @@ bool namespace_traverse(namespace_t* ns, path_t* path);
  *
  * @param ns The namespace containing the namespace to mount to.
  * @param target The target path to mount to, can be `NULL` to mount to root.
- * @param fsName The filesystem name.
+ * @param fs The filesystem to mount.
  * @param deviceName The device name, or `NULL` for no device.
  * @param flags Mount flags.
  * @param mode The mode specifying permissions and mount behaviour.
@@ -128,7 +128,7 @@ bool namespace_traverse(namespace_t* ns, path_t* path);
  * - `ENOENT`: The root does not exist or the target is negative.
  * - Other errors as returned by the filesystem's `mount()` function or `mount_new()`.
  */
-mount_t* namespace_mount(namespace_t* ns, path_t* target, const char* fsName, const char* deviceName, mode_t mode,
+mount_t* namespace_mount(namespace_t* ns, path_t* target, filesystem_t* fs, const char* deviceName, mode_t mode,
     void* private);
 
 /**

include/kernel/fs/procfs.h

@@ -158,6 +158,8 @@
  *
  * Mounts a filesystem at the specified mountpoint in the process's namespace, optionally with a device.
  *
+ * The filesystem should be specified as a path to a directory in the `fs` sysfs directory.
+ *
  * @see kernel_fs_path for information on path flags.
  *
  * ### touch <path>

include/kernel/fs/sysfs.h

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <kernel/fs/dentry.h>
+#include <kernel/fs/inode.h>
+#include <sys/io.h>
+
+typedef struct file file_t;
+typedef struct file_ops file_ops_t;
+
+typedef struct superblock superblock_t;
+typedef struct superblock_ops superblock_ops_t;
+
+/**
+ * @brief System Filesystem.
+ * @ingroup kernel_fs
+ * @defgroup kernel_fs_sysfs System Filesystem
+ *
+ * The sysfs is a virtual filesystem that provides information about devices and kernel modules.
+ *
+ * @{
+ */
+
+/**
+ * @brief The name of the system filesystem.
+ */
+#define SYSFS_NAME "sysfs"
+
+/**
+ * @brief Initializes the sysfs and mount an instance at `/sys`.
+ *
+ * The System Filesystem is one of the few filesystem that will be mounted automatically by the kernel, this is
+ * necessary as otherwise user space would be unable to access the `fs` sysfs directory and thus unable to mount any
+ * filesystem.
+ *
+ */
+void sysfs_init(void);
+
+/**
+ * @brief Create a new directory inside a mounted sysfs instance.
+ *
+ * @param parent The parent directory, if `NULL` then the root is used.
+ * @param name The name of the new directory.
+ * @param inodeOps The inode operations for the new directory, can be `NULL`.
+ * @param private Private data to store in the inode of the new directory, can be `NULL`.
+ * @return On success, the new sysfs directory. On failure, `NULL` and `errno` is set.
+ */
+dentry_t* sysfs_dir_new(dentry_t* parent, const char* name, const inode_ops_t* inodeOps, void* private);
+
+/**
+ * @brief Create a new file inside a mounted sysfs instance.
+ *
+ * @param parent The parent directory, if `NULL` then the root is used.
+ * @param name The name of the new file.
+ * @param inodeOps The inode operations for the new file, can be `NULL`.
+ * @param fileOps The file operations for the new file, can be `NULL`.
+ * @param private Private data to store in the inode of the new file, can be `NULL`.
+ * @return On success, the new sysfs file. On failure, `NULL` and `errno` is set.
+ */
+dentry_t* sysfs_file_new(dentry_t* parent, const char* name, const inode_ops_t* inodeOps, const file_ops_t* fileOps,
+    void* private);
+
+/**
+ * @brief Create a new symbolic link inside a mounted sysfs instance.
+ *
+ * @param parent The parent directory, if `NULL` then the root is used.
+ * @param name The name of the new symbolic link.
+ * @param inodeOps The inode operations for the new symbolic link.
+ * @param private Private data to store in the inode of the new symbolic link, can be `NULL`.
+ * @return On success, the new sysfs symbolic link. On failure, `NULL` and `errno` is set.
+ */
+dentry_t* sysfs_symlink_new(dentry_t* parent, const char* name, const inode_ops_t* inodeOps, void* private);
+
+/**
+ * @brief Descriptor for batch file creation.
+ * @struct sysfs_file_desc_t
+ */
+typedef struct sysfs_file_desc
+{
+    const char* name;            ///< Name of the file, `NULL` marks end of array.
+    const inode_ops_t* inodeOps; ///< Inode operations, can be `NULL`.
+    const file_ops_t* fileOps;   ///< File operations, can be `NULL`.
+    void* private;               ///< Private data to store in the inode of the file.
+} sysfs_file_desc_t;
+
+/**
+ * @brief Create multiple files in a sysfs directory.
+ *
+ * @param out Output list to store created dentries, can be `NULL`. The dentries use the `otherEntry` list entry.
+ * @param parent The parent directory, if `NULL` then the root is used.
+ * @param descs Array of file descriptors, terminated by an entry with `name == NULL`.
+ * @return On success, the number of files created. On failure, `ERR` and `errno` is set.
+ */
+uint64_t sysfs_files_new(list_t* out, dentry_t* parent, const sysfs_file_desc_t* descs);
+
+/**
+ * @brief Free all files in a list created by `sysfs_files_new()`.
+ *
+ * @param files The list of files to free.
+ */
+void sysfs_files_free(list_t* files);
+
+/** @} */

include/libstd/sys/io.h

@@ -560,7 +560,7 @@ uint64_t bind(const char* mountpoint, fd_t source);
  * @brief System call for mounting a filesystem.
  *
  * @param mountpoint The target path to mount to.
- * @param fs The filesystem name.
+ * @param fs The path to the desired filesystem in the `fs` sysfs directory.
  * @param device The device name, or `NULL` for no device.
  * @return On success, `0`. On failure, `ERR` and `errno` is set.
  */

root/box/terminal/manifest

@@ -22,3 +22,5 @@ PATH = /base/bin
 /dev:rw = /dev
 /net:rw = /net
 /proc:rw = /proc
+/sys:rw = /sys
+/tmp:rwL = /tmp