1
static int sfs_read(inode_t *inode, void *buf, uint32_t offset, uint32_t size)
2
{
3
    if (!inode || !buf) return -1;
4
    sfs_file_t *f = &sfs.files[inode->ino];
5

6
    /* 检查边界条件 */
7
    if (!f->in_use || offset >= f->size) return 0;
8

9
    /* 计算可读字节数 */
10
    uint32_t avail = f->size - offset;
11
    uint32_t n = (size < avail) ? size : avail;
12

13
    /* 从内存中复制数据 */
14
    if (f->data) memcpy(buf, (uint8_t *)f->data + offset, n);
15
    f->atime = getTick();  /* 更新访问时间 */
16
    return (int)n;
17
}

1
static int sfs_write(inode_t *inode, const void *buf, uint32_t offset, uint32_t size)
2
{
3
    if (!inode || !buf) return -1;
4
    sfs_file_t *f = &sfs.files[inode->ino];
5
    if (!f->in_use) return -1;
6

7
    uint32_t new_end = offset + size;
8

9
    /* 如果需要扩展内存容量 */
10
    if (new_end > f->capacity) {
11
        /* 新容量至少512字节，或者直接分配到new_end */
12
        uint32_t new_cap = new_end < 512 ? 512 : new_end;
13
        void *nd = kmalloc(new_cap);
14
        if (!nd) return -1;
15

16
        memset(nd, 0, new_cap);
17

18
        /* 复制旧数据到新内存 */
19
        if (f->data && f->size > 0) memcpy(nd, f->data, f->size);
20

21
        /* 释放旧内存 */
22
        if (f->data) kfree(f->data);
23

24
        f->data = nd;
25
        f->capacity = new_cap;
26
    }
27

28
    /* 写入新数据 */
29
    memcpy((uint8_t *)f->data + offset, buf, size);
30

31
    /* 更新文件大小 */
32
    if (new_end > f->size) f->size = new_end;
33
    f->blocks = (f->size + SFS_BLOCK_SIZE - 1) / SFS_BLOCK_SIZE;
34
    f->mtime = getTick();  /* 更新修改时间 */
35

36
    return (int)size;
37
}

1
/* 超级块 - 描述文件系统整体信息 */
2
typedef struct superblock {
3
    fs_type_t type;           /* 文件系统类型 */
4
    block_device_t *device;    /* 块设备（SimpleFS不使用） */
5
    uint32_t block_size;       /* 块大小 */
6
    uint32_t total_blocks;     /* 总块数 */
7
    uint32_t free_blocks;      /* 空闲块数 */
8
    uint32_t total_inodes;     /* 总inode数 */
9
    uint32_t free_inodes;      /* 空闲inode数 */
10
    void *private;            /* 私有数据，指向simple_fs_t */
11
} superblock_t;
12

13
/* Inode - 索引节点，描述文件的元数据 */
14
typedef struct inode {
15
    uint32_t ino;             /* Inode号（对应sfs.files数组索引） */
16
    file_type_t type;         /* 文件类型 */
17
    uint32_t mode;            /* 权限模式 */
18
    uint32_t size;            /* 文件大小 */
19
    uint32_t blocks;          /* 占用块数 */
20
    uint32_t atime;           /* 访问时间 */
21
    uint32_t mtime;           /* 修改时间 */
22
    uint32_t ctime;           /* 创建时间 */
23
    uint32_t links;           /* 链接数 */
24
    uint32_t uid;             /* 用户ID */
25
    uint32_t gid;             /* 组ID */
26
    uint32_t direct_blocks[12]; /* 直接块指针（SimpleFS不使用） */
27
    uint32_t indirect_block;   /* 一级间接块（SimpleFS不使用） */
28
    uint32_t double_indirect;  /* 二级间接块（SimpleFS不使用） */
29
    superblock_t *sb;        /* 所属超级块 */
30
    void *private;           /* 私有数据 */
31
} inode_t;
32

33
/* 文件描述符 */
34
typedef struct file {
35
    inode_t *inode;          /* 关联的inode */
36
    uint32_t offset;          /* 当前读写偏移 */
37
    uint32_t flags;           /* 打开标志 */
38
    int refcount;            /* 引用计数 */
39
} file_t;
40

41
/* 目录项 */
42
typedef struct dirent {
43
    uint32_t ino;             /* Inode号 */
44
    char name[256];           /* 文件名 */
45
    file_type_t type;         /* 文件类型 */
46
} dirent_t;

1
/* SimpleFS文件系统整体结构 */
2
typedef struct simple_fs {
3
    superblock_t sb;                  /* 超级块 */
4
    sfs_file_t files[SFS_MAX_FILES];  /* 平面文件表 */
5
    int mounted;                      /* 是否已挂载 */
6
} simple_fs_t;

1
/* 在指定目录中查找文件名 */
2
static int sfs_find_in_dir(uint32_t parent_ino, const char *name)
3
{
4
    for (int i = 0; i < SFS_MAX_FILES; i++) {
5
        if (sfs.files[i].in_use &&
6
            sfs.files[i].parent_ino == parent_ino &&
7
            strcmp(sfs.files[i].name, name) == 0) {
8
            return i;  /* 返回文件索引 */
9
        }
10
    }
11
    return -1;  /* 未找到 */
12
}

1
static dirent_t *sfs_readdir(inode_t *dir, uint32_t index)
2
{
3
    uint32_t count = 0;
4
    for (int i = 0; i < SFS_MAX_FILES; i++) {
5
        /* 查找属于该目录的所有文件 */
6
        if (sfs.files[i].in_use && sfs.files[i].parent_ino == dir->ino) {
7
            if (count == index) {
8
                /* 找到第index个目录项 */
9
                static dirent_t de;
10
                de.ino = i;
11
                strncpy(de.name, sfs.files[i].name, 255);
12
                de.name[255] = '\0';
13
                de.type = sfs.files[i].type;
14
                return &de;
15
            }
16
            count++;
17
        }
18
    }
19
    return NULL;  /* 索引超出范围 */
20
}

1
ssize_t fs_read(int fd, void *buf, size_t count)
2
{
3
    /* 参数检查 */
4
    if (fd < 0 || fd >= MAX_OPEN_FILES || !fd_table[fd].inode) return -1;
5

6
    /* 获取文件系统操作函数 */
7
    filesystem_t *fs = registered_fs[0];
8
    if (!fs || !fs->ops->read_inode) return -1;
9

10
    /* 调用具体文件系统的读取函数 */
11
    int n = fs->ops->read_inode(fd_table[fd].inode, buf,
12
                                 fd_table[fd].offset, count);
13
    /* 更新文件偏移 */
14
    if (n > 0) fd_table[fd].offset += n;
15
    return n;
16
}