MIT6.S081

MIT6.S081笔记-14.0文件系统

一、初见

我们每天无时无刻都在接触文件系统，但是我们不知道文件系统什么原理，他是怎么实现的，就像亲密的朋友，一些东西总是觉得是自然而然的，没有剖析他的底层。

文件系统的特点：

文件目录的层级结构
随意更改文件名
持久化

文件系统背后机制：

文件系统对硬件的抽像
系统奔溃的文件保护，数据是天价或者是无价的，要有完善的保护机制。
磁盘是系统读写最慢的部件，所以尽量避免磁盘读写，通过并行化（多线程+异步）增强文件系统的性能。

二、实现

抽象的叙述往往不能很好让人理解表达的事物，所以我们一个例子来切入。

fd = open("user/peter");
write(fd,"abc", 3)

接口的路径是可读的名字，用户可以指定
write 系统调用隐式含有偏置，会默认从未使用位置进行操作。

此外，UNIX特殊的地方在于可以给一个文件指定多个名字，通过link进行调用，这里其实link 名称应该与文件的inode 有关系，所以link是对inode进行操作。

link("x/y", "x/z")

那么文件系统用怎样的结构实现数据持久化的API呢？

以inode为中心，围绕他有两个数据维护。一个link count，一个openfd count，当没有名称指向且没有打开这个文件时这个inode 将会被释放。

文件最核心的数据结构 inode 以及 file descriptor，一个与存储交互，一个与进程交互。很多东西合起来看很困难，但是分层看起来会好很多。

	name [fd]
	inode （read and write）
	icache—>同步
	logging
	buf cache
	disk

最底层磁盘提供了持久化设备
block cache 或者说 buf cache 将数据保存在内存中，避免磁盘的频繁读写。
数据保护至关重要，logging是为了恢复文件产生的机制。
inode 是实现读写文件的媒介
直观的文件操作**fd*

三、磁盘使用

设备

SSD 和HDD是现在最常用的存储设备，hdd延迟10ms， SSD 0.1ms ，所以对磁盘的读写是非常耗时的。

我们现在有一个问题，文件系统是怎么操作磁盘的，就像我们的仓库一样怎么存放数据呢？

所以我要区分下这些单位：

Sector：硬盘级别最小的物理存储单位
Block：文件系统级别的逻辑存储单位

我们可以将磁盘看成一个巨大的数组：

如果我们用过diskgenius，就可以看到关于系统启动的相关分区，windos linux都有相关启动的分区文件。

block 0 用作boot sector来启动操作系统
block 1 表示 superblock ，描述了磁盘的布局，块的大小，块的总数，起始位置等等。
block 2 - block 32 日志区域存储待写入数据，node 的数量是有限的，需要有一个表，来表示他是否占用。
bitmap block 标识哪些数据块是否占用。
最后data 区，保存文件和目录的内容。

四、inode

文件

首先我们看下inode 的代码：

struct dinode {
  short type;           // File type
  short major;          // Major device number (T_DEVICE only)
  short minor;          // Minor device number (T_DEVICE only)
  short nlink;          // Number of links to inode in file system
  uint size;            // Size of file (bytes)
  uint addrs[NDIRECT+1];   // Data block addresses
};

其中 uint addrs[NDIRECT+1] 是数据块的地址，前面的bitmap 只是表示是否占用，并没有存储block得实际地址，无法定位数据块位置, 而在XV6.0 中有12个直接块， 256 个间接块，addrs[NDIRECT+1]; 存储的是间接块地址。

q1:为什么每个block存储256个block编号？

一个block的1024字节，一个地址信息是4字节，所以该block可以保存256个块地址。

q2:如果实现read系统调用，需要读取文件的第8000个字节，那么你该读取哪个block呢？从inode的数据结构中该如何计算呢？

计算block数：取整8000/1024 = 7

block内的偏置：取余 8000%1024 =832

工作实例

修改XV6.0 makefs 文件打印出磁盘的block信息

boot block
super block
30个log block
13个inode block
1个bitmap block

运行实例：

$ echo"hi">X
createthefile
write:33
write:33
write:46
write:32
write:33
write"hi" to file
write:45
write:595
write: 595
write:33
--write "\n" tofile
write:595
write:33

所以我们把写入文件过程分为三个阶段

文件创建阶段
将"hi" 写入文件
将"\n"换行符写入文件

文件创建阶段其实就是分配 inode 阶段，我们继续回看inode 的数据结构：

struct dinode {
  short type;           // File type
  short major;          // Major device number (T_DEVICE only)
  short minor;          // Minor device number (T_DEVICE only)
  short nlink;          // Number of links to inode in file system
  uint size;            // Size of file (bytes)
  uint addrs[NDIRECT+1];   // Data block addresses
};

我们的inode表分布在32-45

所以第一次"write 33" inode 来标识他是否空闲以及文件的类型。

第二次"write 33" 写入 inode 的其他内容，相当于补全信息。

write 46 46其实已经到了填写 bitmap 的时机了。

最后为什么又重新些了 block 32 32呢？

其实在inode table 里面排第一位的 root inode，所以最后的更新是新建文件之后的重新更新root 目录。

block 32	...........	block 45
root		file inode

write"hi" to file
write:45    
write:595   "write h"
write: 595  "write i"
write:33

write 45 45之后都是bitmap 就是我们分配data block ，找到后将bitmap 对应的值置为1。
write 595 在data block 区域里面分别写入write 的单个字符内容
write 33 再次更改33 是更新文件元数据inode 中的size大小。

五、inode 代码流程分析

XV 6.0包含了文件系统所有函数，其中inode的分配发生在sys_open函数中

uint64 sys_open(void) {
    char path[MAXPATH];  // 用于存储文件路径的缓冲区
    int fd, omode;       // 文件描述符和打开模式
    struct file *f;      // 文件结构体指针
    struct inode* ip;    // i节点（inode）结构体指针
    int n;

    // 从用户空间获取参数：文件路径和打开模式
    // argstr 用于复制字符串参数到内核空间
    // largint 用于读取整数参数
    if ((n = argstr(0, path, MAXPATH)) < 0 || largint(1, &omode) < 0)
        return -1;  // 如果任何参数无效，则返回-1表示错误

    begin_op();  // 开始一个新的文件操作序列，可能涉及锁等

    // 检查是否设置了 O_CREATE 标志，表示需要创建新文件
    if (omode & O_CREATE) {
        // 尝试创建指定路径的新文件
        ip = create(path, T_FILE, 0, 0);
        if (ip == 0) {  // 如果创建失败
            end_op();   // 结束操作序列
            return -1;  // 返回-1表示错误
        }
    } else {
        // 如果不是创建新文件，尝试查找已存在的文件
        if ((ip = namei(path)) == 0) {  // namei 函数根据路径查找对应的 i 节点
            end_op();  // 如果找不到文件，结束操作序列
            return -1;  // 返回-1表示错误
        }
    }

    // 这里应该有更多代码来完成文件打开过程，例如：
    // - 检查权限
    // - 分配文件描述符
    // - 初始化文件结构体
    // - 将文件结构体与 i 节点关联
    // - 更新文件状态标志
    // - 等等

    // 假设所有这些步骤都成功了，最后应该结束操作序列并返回文件描述符
    end_op();
    // 下面是假设的返回值，实际代码中应该有相应的逻辑来确定fd
    return fd;
}

上面创建的核心函数是create 函数

主要功能概括：

解析路径：查找最后一个目录名称。
检查重复：确目录中没有同名条目。
分配 i 节点：为新文件或目录分配一个新的 i 节点。
初始化属性：设置新 i 节点的类型、设备号等属性。
创建链接：在父目录中创建指向新 i 节点的条目；如果是目录，还会创建 "." 和 ".." 条目。
返回结果：成功时返回新的 i 节点指针，失败时返回错误。

static struct inode* create(char *path, short type, short major, short minor) {
    struct inode *ip, *dp;  // ip: 新创建的i节点指针；dp: 父目录的i节点指针
    char name[DIRSIZ];      // 用于存储文件名的缓冲区

    // 使用nameiparent解析路径，返回父目录的i节点，并将文件名存入name
    if ((dp = nameiparent(path, name)) == 0)
        return 0;  // 如果路径无效或父目录不存在，则返回空指针

    ilock(dp);  // 锁定父目录的i节点以防止并发修改

    // 检查是否已经存在同名文件或目录
    if ((ip = dirlookup(dp, name, 0)) != 0) {  // 查找是否存在同名条目
        iunlockput(dp);  // 解锁并释放父目录的引用
        ilock(ip);       // 锁定找到的i节点
        // 如果要创建的是普通文件，且找到的i节点也是普通文件或设备文件，则返回该i节点
        if (type == T_FILE && (ip->type == T_FILE || ip->type == T_DEVICE))
            return ip;
        iunlockput(ip);  // 否则解锁并释放找到的i节点
        return 0;  // 返回空指针表示错误
    }

    // 分配新的i节点
    if ((ip = ialloc(dp->dev, type)) == 0)  // 在指定设备上分配新的i节点
        panic("create: ialloc");  // 如果分配失败，触发内核恐慌

    ilock(ip);  // 锁定新分配的i节点

    // 设置新i节点的属性
    ip->major = major;  // 主设备号（对于设备文件）
    ip->minor = minor;  // 次设备号（对于设备文件）
    ip->nlink = 1;      // 初始化硬链接计数为1

    iupdate(ip);  // 更新i节点到磁盘

    if (type == T_DIR) {  // 如果创建的是目录
        dp->nlink++;  // 增加父目录的硬链接计数，因为新目录会有一个"."指向自己
        iupdate(dp);  // 更新父目录的i节点

        // 创建目录中的 "." 和 ".." 条目
        // 注意：这里没有增加ip->nlink，以避免循环引用计数
        if (dirlink(ip, ".", ip->inum) < 0 || dirlink(ip, "..", dp->inum) < 0)
            panic("create dots");  // 如果创建"."或".."失败，触发内核恐慌

        // 将新目录链接到父目录中
        if (dirlink(dp, name, ip->inum) < 0)
            panic("create: dirlink");  // 如果链接失败，触发内核恐慌
    }

    iunlockput(dp);  // 解锁并释放父目录的引用
    return ip;  // 返回新创建的i节点指针
}

那XV6.0 是怎么分配inode 呢？这个实现在inode ialloc函数中

遍历 i 节点表：在设备的 i 节点表中查找未使用的 i 节点。
分配 i 节点：找到一个未使用的 i 节点后，初始化它，并将其标记为已分配。
返回 i 节点：返回一个指向新分配且已引用但未锁定的 i 节点的指针。

// 在设备 dev 上分配一个 i 节点
// 将其标记为已分配，并返回一个未锁定但已引用的 i 节点
struct inode* ialloc(uint dev, short type) {
    int inum;  // i 节点编号
    struct buf *bp;  // 缓冲区指针
    struct dinode *dip;  // 磁盘 i 节点指针

    // 遍历所有可能的 i 节点编号
    for (inum = 1; inum < sb.ninodes; inum++) {
        // 读取包含 i 节点的块到缓冲区 bp
        bp = bread(dev, IBLOCK(inum, sb));
        
        // 计算当前 i 节点在缓冲区中的位置
        dip = (struct dinode*)bp->data + inum % IPB;

        // 检查 i 节点是否为空闲（type == 0 表示空闲）
        if (dip->type == 0) {  // 找到一个空闲的 i 节点
            // 初始化新的 i 节点
            memset(dip, 0, sizeof(*dip));  // 清零整个 i 节点结构
            log_write(bp);  // 将缓冲区内容写入日志（用于崩溃恢复）

            // 设置 i 节点类型
            dip->type = type;
            
            // 释放缓冲区，但不写回磁盘（因为已经通过日志记录）
            brelse(bp);

            // 返回新分配的 i 节点（未锁定但已引用）
            return iget(dev, inum);
        }

        // 如果当前 i 节点不是空闲的，释放缓冲区
        brelse(bp);
    }

    // 如果没有找到空闲的 i 节点，触发内核恐慌
    panic("ialloc: no inodes");
}