Implement virtio-fs filesystem in semu

Implement virtio-fs filesystem with FUSE core operations in semu.
Add key configs in /configs/linux.config to enable required features (e.g., virtio-fs) for kernel build.
Add config options to generate /proc/config.gz for verifying kernel parameters in semu.
Map MMIO region at 0xF48____ for virtio-fs device in semu.
Introduce special-case logic for char tag in virtio_fs config handling in semu.
Add inode_map hash table for mapping inodes to file paths.
Implement FUSE core operations:
- INIT
- GETATTR
- OPENDIR
- READDIRPLUS
- LOOKUP
- FORGET
- RELEASEDIR
- OPEN
- READ
- RELEASE
- FLUSH
- DESTROY
to make semu supports commands:`cd`, `cat`, `ls`.
Set default mount tag to "myfs" and mount directory to "./shared".

Author: MikazukiHikari

Makefile

@@ -41,6 +41,14 @@ ifeq ($(call has, VIRTIORNG), 1)
     OBJS_EXTRA += virtio-rng.o
 endif
 
+# virtio-fs
+ENABLE_VIRTIOFS ?= 1
+$(call set-feature, VIRTIOFS)
+ifeq ($(call has, VIRTIOFS), 1)
+    OBJS_EXTRA += virtio-fs.o
+    OPTS += -s ./shared
+endif
+
 NETDEV ?= tap
 # virtio-net
 ENABLE_VIRTIONET ?= 1

configs/linux.config

@@ -102,7 +102,8 @@ CONFIG_SRCU=y
 CONFIG_TINY_SRCU=y
 # end of RCU Subsystem
 
-# CONFIG_IKCONFIG is not set
+CONFIG_IKCONFIG=y
+CONFIG_IKCONFIG_PROC=y
 # CONFIG_IKHEADERS is not set
 CONFIG_LOG_BUF_SHIFT=16
 CONFIG_PRINTK_SAFE_LOG_BUF_SHIFT=12
@@ -947,6 +948,10 @@ CONFIG_SND=y
 CONFIG_SND_VIRTIO=y
 CONFIG_SND_HRTIMER=y
 
+CONFIG_CUSE=y
+CONFIG_FUSE_FS=y
+CONFIG_VIRTIO_FS=y
+
 #
 # HID support
 #
@@ -1257,7 +1262,7 @@ CONFIG_INOTIFY_USER=y
 # CONFIG_QUOTA is not set
 CONFIG_AUTOFS4_FS=y
 CONFIG_AUTOFS_FS=y
-# CONFIG_FUSE_FS is not set
+
 # CONFIG_OVERLAY_FS is not set
 
 #

device.h

@@ -3,6 +3,7 @@
 #if SEMU_HAS(VIRTIONET)
 #include "netdev.h"
 #endif
+#include <uthash.h>
 #include "riscv.h"
 #include "virtio.h"
 
@@ -357,6 +358,70 @@ void virtio_snd_write(hart_t *core,
 bool virtio_snd_init(virtio_snd_state_t *vsnd);
 #endif /* SEMU_HAS(VIRTIOSND) */
 
+/* VirtIO-File-System */
+
+#if SEMU_HAS(VIRTIOFS)
+#define IRQ_VFS 6
+#define IRQ_VFS_BIT (1 << IRQ_VFS)
+
+typedef struct {
+    uint64_t ino;
+    char path[4096];
+    UT_hash_handle hh;
+} inode_map_entry;
+
+typedef struct {
+    uint32_t QueueNum;
+    uint32_t QueueDesc;
+    uint32_t QueueAvail;
+    uint32_t QueueUsed;
+    uint16_t last_avail;
+    bool ready;
+} virtio_fs_queue_t;
+
+typedef struct {
+    /* feature negotiation */
+    uint32_t DeviceFeaturesSel;
+    uint32_t DriverFeatures;
+    uint32_t DriverFeaturesSel;
+
+    /* queue config */
+    uint32_t QueueSel;
+    virtio_fs_queue_t queues[3];
+
+    /* status */
+    uint32_t Status;
+    uint32_t InterruptStatus;
+
+    /* guest memory base */
+    uint32_t *ram;
+
+    char *mount_tag;  // guest sees this tag
+    char shared_dir[4096];
+
+    inode_map_entry *inode_map;
+
+    /* optional implementation-specific */
+    void *priv;
+} virtio_fs_state_t;
+
+/* MMIO read/write */
+void virtio_fs_read(hart_t *core,
+                    virtio_fs_state_t *vfs,
+                    uint32_t addr,
+                    uint8_t width,
+                    uint32_t *value);
+
+void virtio_fs_write(hart_t *core,
+                     virtio_fs_state_t *vfs,
+                     uint32_t addr,
+                     uint8_t width,
+                     uint32_t value);
+
+bool virtio_fs_init(virtio_fs_state_t *vfs, char *mtag, char *dir);
+
+#endif /* SEMU_HAS(VIRTIOFS) */
+
 /* memory mapping */
 typedef struct {
     bool debug;
@@ -382,6 +447,9 @@ typedef struct {
 #if SEMU_HAS(VIRTIOSND)
     virtio_snd_state_t vsnd;
 #endif
+#if SEMU_HAS(VIRTIOFS)
+    virtio_fs_state_t vfs;
+#endif
 
     uint32_t peripheral_update_ctr;
 

feature.h

@@ -17,5 +17,10 @@
 #define SEMU_FEATURE_VIRTIOSND 1
 #endif
 
+/* virtio-fs */
+#ifndef SEMU_FEATURE_VIRTIOFS
+#define SEMU_FEATURE_VIRTIOFS 1
+#endif
+
 /* Feature test macro */
 #define SEMU_HAS(x) SEMU_FEATURE_##x

fuse.h

@@ -0,0 +1,162 @@
+#include "riscv.h"
+#include "virtio.h"
+
+#define FUSE_REC_ALIGN(x) \
+    (((x) + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1))
+#define FUSE_DIRENT_ALIGN(x) FUSE_REC_ALIGN(x)
+
+struct fuse_in_header {
+    uint32_t len;
+    uint32_t opcode;
+    uint64_t unique;
+    uint64_t nodeid;
+    uint32_t uid;
+    uint32_t gid;
+    uint32_t pid;
+    uint32_t padding;
+};
+
+struct fuse_out_header {
+    uint32_t len;
+    int32_t error;
+    uint64_t unique;
+};
+
+
+struct vfs_req_header {
+    struct fuse_in_header in;
+};
+
+struct vfs_resp_header {
+    struct fuse_out_header out;
+};
+
+struct fuse_init_in {
+    uint32_t major;  // FUSE major version supported by the guest (typically 7)
+    uint32_t minor;  // FUSE minor version supported by the guest (e.g., 31, 26)
+    uint32_t max_readahead;  // Maximum readahead size supported by the guest
+                             // (e.g., 0x10000)
+    uint32_t flags;          // Flags requested by the guest (e.g., support for
+                             // writeback cache)
+};
+
+struct fuse_init_out {
+    uint32_t major;          // FUSE major version supported by the device
+    uint32_t minor;          // FUSE minor version supported by the device
+    uint32_t max_readahead;  // Maximum readahead size accepted by the device
+    uint32_t
+        flags;  // Flags supported by the device (negotiated with the guest)
+    uint16_t max_background;  // Maximum number of background requests
+    uint16_t
+        congestion_threshold;  // Threshold for marking the connection congested
+    uint32_t max_write;        // Maximum write size the device can handle
+    uint32_t time_gran;        // Time granularity (in nanoseconds)
+    uint32_t unused[11];       // Reserved
+};
+
+struct fuse_getattr_in {
+    uint32_t getattr_flags;  // bitmask for valid fields (e.g. FUSE_GETATTR_FH)
+    uint32_t padding;        // unused, reserved for alignment
+    uint64_t fh;  // optional: file handle (used when getattr_flags has
+                  // FUSE_GETATTR_FH)
+};
+
+struct fuse_attr {
+    uint64_t ino;        // inode number
+    uint64_t size;       // file size in bytes
+    uint64_t blocks;     // number of 512B blocks allocated
+    uint64_t atime;      // last access time (UNIX time)
+    uint64_t mtime;      // last modification time
+    uint64_t ctime;      // last status change time
+    uint32_t atimensec;  // nanoseconds part
+    uint32_t mtimensec;
+    uint32_t ctimensec;
+    uint32_t mode;     // file mode (e.g. S_IFDIR | 0755)
+    uint32_t nlink;    // number of hard links
+    uint32_t uid;      // owner uid
+    uint32_t gid;      // owner gid
+    uint32_t rdev;     // device ID (if special file)
+    uint32_t blksize;  // block size
+    uint32_t flags;    // reserved
+};
+
+struct fuse_attr_out {
+    uint64_t attr_valid;       // seconds the attributes are valid
+    uint32_t attr_valid_nsec;  // nanoseconds part of attr_valid
+    uint32_t dummy;            // padding for alignment
+    struct fuse_attr attr;     // actual attributes
+};
+
+struct fuse_open_in {
+    uint32_t flags;
+    uint32_t open_flags; /* FUSE_OPEN_... */
+};
+
+struct fuse_open_out {
+    uint64_t fh;  // file handle
+    uint32_t open_flags;
+    int32_t backing_id;
+};
+
+struct fuse_read_in {
+    uint64_t fh;
+    uint64_t offset;
+    uint32_t size;
+    uint32_t read_flags;
+    uint64_t lock_owner;
+    uint32_t flags;
+    uint32_t padding;
+};
+
+struct fuse_entry_out {
+    uint64_t nodeid;            // inode number
+    uint64_t generation;        // inode generation
+    uint64_t entry_valid;       // cache timeout (sec)
+    uint64_t attr_valid;        // attr cache timeout (sec)
+    uint32_t entry_valid_nsec;  // cache timeout (nsec)
+    uint32_t attr_valid_nsec;   // attr cache timeout (nsec)
+    struct fuse_attr attr;      // file attributes (與 stat 結構相似)
+};
+
+struct fuse_dirent {
+    uint64_t ino;      // inode number
+    uint64_t off;      // offset to next entry
+    uint32_t namelen;  // length of the entry name
+    uint32_t type;     // file type (DT_REG, DT_DIR, etc.)
+    char name[];       // name (not null-terminated)
+};
+
+struct fuse_direntplus {
+    struct fuse_entry_out entry_out;
+    struct fuse_dirent dirent;
+};
+
+struct fuse_lookup_in {
+    uint64_t parent;  // inode of parent dir
+    // char name[];     // followed by name (not null-terminated!)
+};
+
+struct fuse_forget_in {
+    uint64_t nlookup;
+};
+
+struct fuse_create_in {
+    uint32_t flags;
+    uint32_t mode;
+    uint32_t umask;
+    uint32_t open_flags; /* FUSE_OPEN_... */
+};
+
+struct fuse_release_in {
+    uint64_t fh;
+    uint32_t flags;
+    uint32_t release_flags;
+    uint64_t lock_owner;
+};
+
+struct fuse_flush_in {
+    uint64_t fh;
+    uint32_t unused;
+    uint32_t padding;
+    uint64_t lock_owner;
+};