nfs文件系统
=======================================
本节导读
---------------------------------------
本节我们简单介绍一下我们实现的nfs操作系统。本章中新增加的代码很多，但是大家如果想研读的话理解起来不太困难。很多函数只看名字也可以知道其功效，不需要再探究其实现的方式。
文件系统布局
---------------------------------------
导言中提到，我们的nfs文件系统十分类似ext4文件系统，下面我们可以看一下nfs文件系统的布局::
// 基本信息：块大小 BSIZE = 1024B，总容量 FSSIZE = 1000 个 block = 1000 * 1024 B。
// Layout:
// 0号块留待后续拓展，可以忽略。superblock 固定为 1 号块，size 固定为一个块。
// 其后是储存 inode 的若干个块，占用块数 = inode 上限 / 每个块上可以容纳的 inode 数量，
// 其中 inode 上限固定为 200，每个块的容量 = BSIZE / sizeof(struct disk_inode)
// 再之后是数据块相关内容，包含一个 储存空闲块位置的 bitmap 和 实际的数据块，bitmap 块
// 数量固定为 NBITMAP = FSSIZE / (BSIZE * 8) + 1 = 1000 / 8 + 1 = 126 块。
// [ boot block | sb block | inode blocks | free bit map | data blocks ]
注意：不推荐同学们修改该布局，除非你完全看懂了 fs 的逻辑，所以最好不要改变 disk_inode 这个结构的大小，如果想要增删字段，一定使用 pad。这个布局具体定义的位置在nfs/fs.c之中。
我们定义的inode和data blocks实际上和ext4中同名的结构功能几乎是一样的。**索引节点** (Inode, Index Node) 是文件系统中的一种重要数据结构。逻辑目录树结构中的每个文件和目录都对应一个 inode ，我们前面提到的在文件系统实现中文件/目录的底层编号实际上就是指 inode 编号。在 inode 中不仅包含了我们通过 ``stat`` 工具能够看到的文件/目录的元数据（大小/访问权限/类型等信息），还包含实际保存对应文件/目录数据的数据块（位于最后的数据块区域中）的索引信息，从而能够找到文件/目录的数据被保存在磁盘的哪些块中。从索引方式上看，同时支持直接索引和间接索引。
下面我们看一下它们在我们C中对应的具体结构体:
.. code-block:: c
// 超级块位置固定，用来指示文件系统的一些元数据，这里最重要的是 inodestart 和 bmapstart
struct superblock {
uint magic; // Must be FSMAGIC
uint size; // Size of file system image (blocks)
uint nblocks; // Number of data blocks
uint ninodes; // Number of inodes.
uint inodestart;// Block number of first inode block
uint bmapstart; // Block number of first free map block
};
// On-disk inode structure
// 储存磁盘 inode 信息，主要是文件类型和数据块的索引，其大小影响磁盘布局，不要乱改，可以用 pad
struct dinode {
short type; // File type
short pad[3];
uint size; // Size of file (bytes)
uint addrs[NDIRECT + 1];// Data block addresses
};
// in-memory copy of an inode
// dinode 的内存缓存，为了方便，增加了 dev, inum, ref, valid 四项管理信息，大小无所谓，可以随便改。
struct inode {
uint dev; // Device number
uint inum; // Inode number
int ref; // Reference count
int valid; // inode has been read from disk?
short type; // copy of disk inode
uint size;
uint addrs[NDIRECT+1]; // data block num
};
// 目录对应的数据块的内容本质是 filename 到 file inode_num 的一个 map，这里为了简单，就存为一个 `dirent` 数组，查找的时候遍历对比
struct dirent {
ushort inum;
char name[DIRSIZ];
};
// 数据块缓存结构体。
struct buf {
int valid; // has data been read from disk?
int disk; // does disk "own" buf?
uint dev;
uint blockno;
uint refcnt;
struct buf *prev; // LRU cache list
struct buf *next;
uchar data[BSIZE];
};
注意几个量的概念:
- block num: 表示某一个磁盘块的编号。我们操作数据块会把它读入内存的数据块缓存之中，其结构体见上。
- inode num: 表示某一个 inode 在所有 inode 项里的编号。注意 inode blocks 其实就是一个 inode 的大数组。
同时，目录本身是一个 filename 到 file对应的inode_num的map，可以完成 filename 到 inode_num 的转化。
OS启动后是没有inode的内存缓存的。下面我们自底向上走一遍OS打开已存在在磁盘上文件的过程，让大家熟悉一下nfs的具体实现方式。
virtio 磁盘驱动
---------------------------------------
注意：这一部分代码不需要同学们详细了解细节，但需要知道大概的过程。
在 uCore-Tutorial 中磁盘块的读写是通过中断处理的。在 virtio.h 和 virtio-disk.c 中我们按照 qemu 对 virtio 的定义，实现了 virtio_disk_init 和 virtio_disk_rw 两个函数，前者完成磁盘设备的初始化和对其管理的初始化。virtio_disk_rw 实际完成磁盘IO，当设定好读写信息后会通过 MMIO 的方式通知磁盘开始写。然后，os 会开启中断并开始死等磁盘读写完成。当磁盘完成 IO 后，磁盘会触发一个外部中断，在中断处理中会把死循环条件解除。内核态只会在处理磁盘读写的时候短暂开启中断，之后会马上关闭。
.. code-block:: c
virtio_disk_rw(struct buf *b, int write) {
/// ... set IO config
*R(VIRTIO_MMIO_QUEUE_NOTIFY) = 0; // notify the disk to carry out IO
struct buf volatile * _b = b; // Make sure complier will load 'b' form memory
intr_on();
while(_b->disk == 1); // _b->disk == 0 means that this IO is done
intr_off();
}
// 开启和关闭中断的函数。
static inline void intr_on() { w_sstatus(r_sstatus() | SSTATUS_SIE); }
// disable device interrupts
static inline void intr_off() { w_sstatus(r_sstatus() & ~SSTATUS_SIE); }
对于内核中断处理的修改在trap.c之中。之前我们的trap from kernel会直接panic，现在我们需要添加对外部中断的处理。kerneltrap也需要类似usertrap的保存上下文以及回到原处的kernelvec以及kernelret函数。进入内核之后要单独设置stvec指向kernelvec处。
.. code-block:: riscv64
# kernelvec.S
kernelvec:
// make room to save registers.
addi sp, sp, -256
// save the registers expect x0
sd ra, 0(sp)
sd sp, 8(sp)
sd gp, 16(sp)
// ...
sd t4, 224(sp)
sd t5, 232(sp)
sd t6, 240(sp)
call kerneltrap
kernelret:
// restore registers.
// 思考：为什么直接就使用了sp？
ld ra, 0(sp)
ld sp, 8(sp)
ld gp, 16(sp)
// restore all registers expect x0
ld t4, 224(sp)
ld t5, 232(sp)
ld t6, 240(sp)
addi sp, sp, 256
sret
kerneltrap具体的修改如下:
.. code-block:: c
void kerneltrap() {
// 老三样，不过在这里把处理放到了 C 代码中
uint64 sepc = r_sepc();
uint64 sstatus = r_sstatus();
uint64 scause = r_scause();
if ((sstatus & SSTATUS_SPP) == 0)
panic("kerneltrap: not from supervisor mode");
if (scause & (1ULL << 63)) {
// 可能发生时钟中断和外部中断，我们的主要目标是处理外部中断
devintr(scause & 0xff);
} else {
// kernel 发生异常就挣扎了，肯定出问题了，杀掉用户线程跑路
error("invalid trap from kernel: %p, stval = %p sepc = %p\n", scause, r_stval(), sepc);
exit(-1);
}
}
// 外部中断处理函数
void devintr(uint64 cause) {
int irq;
switch (cause) {
case SupervisorTimer:
set_next_timer();
// 时钟中断如果发生在内核态，不切换进程，原因分析在下面
// 如果发生在用户态，照常处理
if((r_sstatus() & SSTATUS_SPP) == 0) {
yield();
}
break;
case SupervisorExternal:
irq = plic_claim();
if (irq == UART0_IRQ) { // UART 串口的终端不需要处理，这个 rustsbi 替我们处理好了
// do nothing
} else if (irq == VIRTIO0_IRQ) { // 我们等的就是这个中断
virtio_disk_intr();
}
if (irq)
plic_complete(irq); // 表明中断已经处理完毕
break;
}
}
virtio_disk_intr() 会把 buf->disk 置零，这样中断返回后死循环条件解除，程序可以继续运行。具体代码在 virtio-disk.c 中。
这里还需要注意的一点是，为什么始终不允许内核发生进程切换呢？只是由于我们的内核并没有并发的支持，相关的数据结构没有锁或者其他机制保护。考虑这样一种情况，一个进程读写一个文件，内核处理等待磁盘相应时，发生时钟中断切换到了其他进程，然而另一个进程也要读写同一个文件，这就可能发生数据访问上的冲突，甚至导致磁盘出现错误的行为。这也是为什么内核态一直不处理时钟中断，我们必须保证每一次内核的操作都是原子的，不能被打断。大家可以想一想，如果内核可以随时切换，当前有那些数据结构可能被破坏。提示：想想 kalloc 分配到一半，进程 switch 切换到一半之类的。
磁盘块缓存
---------------------------------------
为了加快磁盘访问的速度，在内核中设置了磁盘缓存 struct buf，一个 buf 对应一个磁盘 block，这一部分代码也不要求同学们深入掌握。大致的作用机制是，对磁盘的读写都会被转化为对 buf 的读写，当 buf 有效时，读写 buf，buf 无效时（类似页表缺页和 TLB 缺失），就实际读写磁盘，将 buf 变得有效，然后继续读写 buf。详细的内容在 buf.h 和 bio.c 中。buf 写回的时机是 buf 池满需要替换的时候(类似内存的 swap 策略) 手动写回。如果 buf 没有写回，一但掉电就 GG 了，所以手动写回还是挺重要的。
.. code-block:: c
// os/bio.c
struct buf *
bread(uint dev, uint blockno) {
struct buf *b;
b = bget(dev, blockno);
if (!b->valid) {
virtio_disk_rw(b, R);
b->valid = 1;
}
return b;
}
// Write b's contents to disk.
void bwrite(struct buf *b) {
virtio_disk_rw(b, W);
}
读取文件数据实际就是读取文件inode指向数据块的数据。读数据块到缓存的数据需要使用bread，而写回缓存需要用到bwrite函数。文件系统首先使用bget去查缓存中是否已有对应的block，如果没有会分配内存来缓存对应的块。之后会调用bread/bwrite进行从磁盘读数据块、写回数据块。要注意释放块缓存的brelse函数。
.. code-block:: c
// os/bio.c
void brelse(struct buf *b) {
b->refcnt--;
if (b->refcnt == 0) {
b->next->prev = b->prev;
b->prev->next = b->next;
b->next = bcache.head.next;
b->prev = &bcache.head;
bcache.head.next->prev = b;
bcache.head.next = b;
}
}
需要特别注意的是 brelse 不会真的如字面意思释放一个 buf。它的准确含义是暂时不操作该 buf 了并把它放置在bcache链表的首部，buf 的真正释放会被推迟到 buf 池满，无法分配的时候，就会把最近最久未使用的 buf 释放掉（释放 = 写回 + 清空）。这是为了尽可能保留内存缓存，因为读写磁盘真的太太太太慢了。
此外，brelse 的数量必须和 bget 相同，因为 bget 会使得引用计数加一。如果没有相匹配的 brelse，就好比 new 了之后没有 delete。千万注意。
inode的操作
---------------------------------------
现在我们来看看nfs如何读取磁盘上的dinode到内存之中。我们通过file name对应的inode num去从磁盘读取对应的inode。为了解决共享问题（不同进程可以打开同一个磁盘文件），也有一个全局的 inode table，每当新打开一个文件的时候，会把一个空闲的 inode 绑定为对应 dinode 的缓存，这一步通过 iget 完成。
.. code-block:: c
// 找到 inum 号 dinode 绑定的 inode，如果不存在新绑定一个
static struct inode *iget(uint dev, uint inum) {
struct inode *ip, *empty;
// 遍历查找 inode table
for (ip = &itable.inode[0]; ip < &itable.inode[NINODE]; ip++) {
// 如果有对应的，引用计数 +1并返回
if (ip->ref > 0 && ip->dev == dev && ip->inum == inum) {
ip->ref++;
return ip;
}
}
// 如果没有对于的，找一个空闲 inode 完成绑定
empty = find_empty()
// GG，inode 表满了，果断自杀.lab7正常不会出现这个情况。
if (empty == 0)
panic("iget: no inodes");
// 注意这里仅仅是写了元数据，没有实际读取，实际读取推迟到后面
ip = empty;
ip->dev = dev;
ip->inum = inum;
ip->ref = 1;
ip->valid = 0; // 没有实际读取，valid = 0
return ip;
}
当已经得到一个文件对应的 inode 后，可以通过 ivalid 函数确保其是有效的。
.. code-block:: c
// Reads the inode from disk if necessary.
void ivalid(struct inode *ip) {
struct buf *bp;
struct dinode *dip;
if (ip->valid == 0) {
// bread 可以完成一个块的读取，这个在将 buf 的时候说过了
// IBLOCK 可以计算 inum 在几个 block
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
// 得到 dinode 内容
dip = (struct dinode *) bp->data + ip->inum % IPB;
// 完成实际读取
ip->type = dip->type;
ip->size = dip->size;
memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
// buf 暂时没用了
brelse(bp);
// 现在有效了
ip->valid = 1;
}
}
在 inode 有效之后，可以通过 writei, readi 完成读写。这又是bwrite和bread的上级接口了。和其他OS支持的文件系统一样，我们首先计算出文件的偏移量，并通过bmap得到对应的block num。之后调用bwrite/bread来进行文件的读写操作。
.. code-block:: c
// 从 ip 对应文件读取 [off, off+n) 这一段数据到 dst
int readi(struct inode *ip, char* dst, uint off, uint n) {
uint tot, m;
// 还记得 buf 吗？
struct buf *bp;
for (tot = 0; tot < n; tot += m, off += m, dst += m) {
// bmap 完成 off 到 block num 的对应，见下
bp = bread(ip->dev, bmap(ip, off / BSIZE));
// 一次最多读一个块，实际读取长度为 m
m = MIN(n - tot, BSIZE - off % BSIZE);
memmove(dst, (char*)bp->data + (off % BSIZE), m);
brelse(bp);
}
return tot;
}
// 同 readi
int writei(struct inode *ip, char* src, uint off, uint n) {
uint tot, m;
struct buf *bp;
for (tot = 0; tot < n; tot += m, off += m, src += m) {
bp = bread(ip->dev, bmap(ip, off / BSIZE));
m = MIN(n - tot, BSIZE - off % BSIZE);
memmove(src, (char*)bp->data + (off % BSIZE), m);
bwrite(bp);
brelse(bp);
}
// 文件长度变长，需要更新 inode 里的 size 字段
if (off > ip->size)
ip->size = off;
// 有可能 inode 信息被更新了，写回
iupdate(ip);
return tot;
}
其中bmap函数是连接inode和block的重要函数。但由于我们支持了间接索引，同时还涉及到文件大小的改变，所以也拉出来看看:
.. code-block:: c
// bn = off / BSIZE
uint bmap(struct inode *ip, uint bn) {
uint addr, *a;
struct buf *bp;
// 如果 bn < 12，属于直接索引, block num = ip->addr[bn]
if (bn < NDIRECT) {
// 如果对应的 addr, 也就是 block num = 0，表明文件大小增加，需要给文件分配新的 data block
// 这是通过 balloc 实现的，具体做法是在 bitmap 中找一个空闲 block，置位后返回其编号
if ((addr = ip->addrs[bn]) == 0)
ip->addrs[bn] = addr = balloc(ip->dev);
return addr;
}
bn -= NDIRECT;
// 间接索引块，那么对应的数据块就是一个大 addr 数组。
if (bn < NINDIRECT) {
// Load indirect block, allocating if necessary.
if ((addr = ip->addrs[NDIRECT]) == 0)
ip->addrs[NDIRECT] = addr = balloc(ip->dev);
bp = bread(ip->dev, addr);
a = (uint *) bp->data;
if ((addr = a[bn]) == 0) {
a[bn] = addr = balloc(ip->dev);
bwrite(bp);
}
brelse(bp);
return addr;
}
panic("bmap: out of range");
return 0;
}
balloc(位于nfs/fs.c)会分配一个新的buf缓存。而iupdate函数则是把修改之后的inode重新写回到磁盘上。不然掉电了就凉了。
.. code-block:: c
// Copy a modified in-memory inode to disk.
// Must be called after every change to an ip->xxx field
// that lives on disk.
void iupdate(struct inode *ip) {
struct buf *bp;
struct dinode *dip;
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
dip = (struct dinode *) bp->data + ip->inum % IPB;
dip->type = ip->type;
dip->size = ip->size;
memmove(dip->addrs, ip->addrs, sizeof(ip->addrs));
bwrite(bp);
brelse(bp);
}
文件在进程中的结构
---------------------------------------
inode是由操作系统统一控制的dinode在内存中的映射，但是每个进程在具体使用文件的时候，除了需要考虑使用的是哪个inode对应的文件外，还需要根据对文件的使用情况来记录其它特性，因此，在进程中我们使用file结构体来标识一个被进程使用的文件：
.. code-block:: c
// Defines a file in memory that provides information about the current use of the file and the corresponding inode location
struct file {
enum { FD_NONE = 0,FD_INODE, FD_STDIO } type;
int ref; // reference count
char readable;
char writable;
struct inode *ip; // FD_INODE
uint off;
};
struct file filepool[FILEPOOLSIZE];
我们采用预分配的方式来对file进行分配，每一个需要使用的file都要与filepool中的某一个file完成绑定。file结构中，ref记录了其引用次数,type表示了文件的类型，在本章中我们主要使用FD_NONE和FD_INODE属性，其中FD_INODE表示file已经绑定了一个文件（可能是目录或普通文件），FD_NONE表示该file还没完成绑定，FD_STDIO用来做标准输入输出，这里不做讨论；readbale和writeble规定了进程对文件的读写权限；ip标识了file所对应的磁盘中的inode编号，off即文件指针，用作记录文件读写时的偏移量。
分配文件时，我们从filepool中寻找还没有被分配的file进行分配：
.. code-block:: c
// os/file.c
struct file* filealloc() {
for(int i = 0; i < FILE_MAX; ++i) {
if(filepool[i].ref == 0) {
filepool[i].ref = 1;
return &filepool[i];
}
}
return 0;
}
进程关闭文件时，也要去filepool中放回：（注意需要根据ref来判断是否需要回收该file）
.. code-block:: c
void fileclose(struct file *f)
{
if (f->ref < 1)
panic("fileclose");
if (--f->ref > 0) {
return;
}
switch (f->type) {
case FD_STDIO:
// Do nothing
break;
case FD_INODE:
iput(f->ip);
break;
default:
panic("unknown file type %d\n", f->type);
}
f->off = 0;
f->readable = 0;
f->writable = 0;
f->ref = 0;
f->type = FD_NONE;
}
注意文件对于进程而言也是其需要记录的一种资源，因此我们在进程对应的PCB结构体之中也需要记录进程打开的文件信息。我们给PCB增加文件指针数组。
.. code-block:: c
// proc.h
// Per-process state
struct proc {
// ...
+ struct file* files[16];
};
// os/proc.c
int fdalloc(struct file* f) {
struct proc* p = curr_proc();
// fd = 0,1,2 is reserved for stdio/stdout/stderr
for(int i = 3; i < FD_MAX; ++i) {
if(p->files[i] == 0) {
p->files[i] = f;
return i;
}
}
return -1;
}
一个进程能打开的文件是有限的（我们设置为16）。一个进程如果要打开某一个文件，其文件指针数组必须有空位。如果有，就把下标做为文件的fd，并把指定文件指针存入数组之中。
获取文件对应的inode
---------------------------------------
现在我们回到文件-inode的关系上。我们怎么获取文件对应的inode呢？上文中提到了我们是去查file name对应inode的表来实现这个过程的。这个功能由目录来提供。我们看一下代码是如何实现这个过程的。
首先用户程序要打开指定文件名文件，发起系统调用sys_openat:
.. code-block:: c
#define O_RDONLY 0x000 // 只读
#define O_WRONLY 0x001 // 只写
#define O_RDWR 0x002 // 可读可写
#define O_CREATE 0x200 // 如果不存在，创建
#define O_TRUNC 0x400 // 舍弃原有内容，从头开始写
uint64 sys_openat(uint64 va, uint64 omode, uint64 _flags) {
// 还记得flags的定义吗？看看上面。
struct proc *p = curr_proc();
char path[200];
copyinstr(p->pagetable, path, va, 200);
return fileopen(path, omode);
}
int fileopen(char *path, uint64 omode) {
int fd;
struct file *f;
struct inode *ip;
if (omode & O_CREATE) {
// 新常见一个路径为 path 的文件
ip = create(path, T_FILE);
} else {
// 尝试寻找一个路径为 path 的文件
ip = namei(path);
ivalid(ip);
}
// 还记得吗？从全局文件池和进程 fd 池中找一个空闲的出来，参考 lab6
f = filealloc();
fd = fdalloc(f);
// 初始化
f->type = FD_INODE;
f->off = 0;
f->ip = ip;
f->readable = !(omode & O_WRONLY);
f->writable = (omode & O_WRONLY) || (omode & O_RDWR);
if ((omode & O_TRUNC) && ip->type == T_FILE) {
itrunc(ip);
}
return fd;
}
打开文件的方式根据flags有很多种。我们先来看最简单的，就是打开已经存在的文件的方法。fileopen在处理这类打开时调用了namei这个函数。
.. code-block:: c
// namei = 获得根目录，然后在其中遍历查找 path
struct inode *namei(char *path) {
struct inode *dp = root_dir();
return dirlookup(dp, path, 0);
}
// root_dir 位置固定
struct inode *root_dir() {
struct inode* r = iget(ROOTDEV, ROOTINO);
ivalid(r);
return r;
}
// 遍历根目录所有的 dirent，找到 name 一样的 inode。
struct inode *dirlookup(struct inode *dp, char *name, uint *poff) {
uint off, inum;
struct dirent de;
// 每次迭代处理一个 block，注意根目录可能有多个 data block
for (off = 0; off < dp->size; off += sizeof(de)) {
readi(dp, 0, (uint64) &de, off, sizeof(de));
if (strncmp(name, de.name, DIRSIZ) == 0) {
if (poff)
*poff = off;
inum = de.inum;
// 找到之后，绑定一个内存 inode 然后返回
return iget(dp->dev, inum);
}
}
return 0;
}
由于我们是单目录结构。因此首先我们调用root_dir获取根目录对应的inode。之后就遍历这个inode索引的数据块中存储的文件信息到dirent结构体之中，比较名称和给定的文件名是否一致。dirlookup的逻辑对于我们本章的练习十分重要。
fileopen 还可能会导致文件 truncate，也就是截断，具体做法是舍弃全部现有内容，释放inode所有 data block 并添加到 free bitmap 里。这也是目前 nfs 中唯一的文件变短方式。
比较复杂的就是使用fileopen以创建的方式打开一个文件。fileopen函数调用了create这个函数。
.. code-block:: c
static struct inode *create(char *path, short type) {
struct inode *ip, *dp;
if(ip = namei(path) != 0) {
// 已经存在，直接返回
return ip;
}
// 创建一个文件,首先分配一个空闲的 disk inode, 绑定内存 inode 之后返回
ip = ialloc(dp->dev, type);
// 注意 ialloc 不会执行实际读取，必须有 ivalid
ivalid(ip);
// 在根目录创建一个 dirent 指向刚才创建的 inode
dirlink(dp, path, ip->inum);
// dp 不用了，iput 就是释放内存 inode，和 iget 正好相反。
iput(dp);
return ip;
}
// nfs/fs.c
uint ialloc(ushort type) {
uint inum = freeinode++;
struct dinode din;
bzero(&din, sizeof(din));
din.type = xshort(type);
din.size = xint(0);
winode(inum, &din);
return inum;
}
// os/fs.c
// Write a new directory entry (name, inum) into the directory dp.
int dirlink(struct inode *dp, char *name, uint inum)
{
int off;
struct dirent de;
struct inode *ip;
// Check that name is not present.
if((ip = dirlookup(dp, name, 0)) != 0){
iput(ip);
return -1;
}
// Look for an empty dirent.
for(off = 0; off < dp->size; off += sizeof(de)){
if(readi(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
panic("dirlink read");
if(de.inum == 0)
break;
}
strncpy(de.name, name, DIRSIZ);
de.inum = inum;
if(writei(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
panic("dirlink");
return 0;
}
ialloc 干的事情：遍历 inode blocks 找到一个空闲的inode，初始化并返回。dirlink对于本章的练习也十分重要。和dirlookup不同，我们没有现成的dirent存储在磁盘上，而是要在磁盘上创建一个新的dirent。他遍历根目录数据块，找到一个空的 dirent，设置 dirent = {inum, filename} 然后返回，注意这一步可能找不到空位，这时需要找一个新的数据块，并扩大 root_dir size，这是由 bmap 自动完成的。需要注意本章创建硬链接时对应inode num的处理。
文件关闭
---------------------------------------
文件读写结束后需要fclose释放掉其inode，同时释放OS中对应的file结构体和fd。其实 inode 文件的关闭只需要调用 iput 就好了，iput 的实现简单到让人感觉迷惑，就是 inode 引用计数减一。诶？为什么没有计数为 0 就写回然后释放 inode 的操作？和 buf 的释放同理，这里会等 inode 池满了之后自行被替换出去，重新读磁盘实在太太太太慢了。对了，千万记得 iput 和 iget 数量相同，一定要一一对应，否则你懂的。
.. code-block:: c
void fileclose(struct file *f)
{
if(--f->ref > 0) {
return;
}
// 暂时不支持标准输入输出文件的关闭
if(f->type == FD_INODE) {
iput(f->ip);
}
f->off = 0;
f->readable = 0;
f->writable = 0;
f->ref = 0;
f->type = FD_NONE;
}
void iput(struct inode *ip) {
ip->ref--;
}