文件

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 nlog;       // Number of log blocks
  uint logstart;   // Block number of first log block
  uint inodestart; // Block number of first inode block
  uint bmapstart;  // Block number of first free map block
};

read(fd, buf, n)                                [用户]
└─ sys_read                                     [系统调用层] 取参、argfd 找 struct file
   └─ fileread(f, addr, n)                      [文件描述符层] 按 f->type 分发，走 FD_INODE 分支
      ├─ ilock(f->ip)                           [inode 层] 上睡眠锁，valid==0 时读 dinode
      ├─ readi(ip, 1, addr, f->off, n)          [inode 层] 按字节偏移逐块读
      │  └─ 循环每块
      │     ├─ bmap(ip, off/BSIZE)              [inode 层] 文件块号 -> 磁盘块号（读路径不分配）
      │     ├─ bread(ip->dev, addr)             [缓冲层] 命中直接用，miss 才 virtio_disk_rw 读盘
      │     ├─ either_copyout(...)              块内容 -> 用户地址
      │     └─ brelse(bp)                       [缓冲层] 放回 LRU
      ├─ iunlock(f->ip)                         [inode 层]
      └─ f->off += r                            [文件描述符层] 偏移在这里更新，不在 inode 层

write(fd, buf, n)
└─ sys_write                                    [系统调用层]
   └─ filewrite(f, addr, n)                     [文件描述符层]
      └─ 循环分批（每批 <= max）
         ├─ begin_op()                          [日志层] 进入事务
         ├─ ilock(f->ip)                        [inode 层]
         ├─ writei(ip, 1, src, off, n1)         [inode 层] 逐块写
         │  ├─ 循环每块
         │  │  ├─ bmap(ip, off/BSIZE)           [inode 层] 块不存在 -> balloc
         │  │  │  └─ balloc                     [inode 层] bread 位图 -> 置位 -> bzero
         │  │  │     └─ log_write(位图块)       [日志层]
         │  │  ├─ bread(ip->dev, addr)          [缓冲层]
         │  │  ├─ either_copyin(...)            用户数据 -> 块内容
         │  │  ├─ log_write(bp)                 [日志层] 登记数据块
         │  │  └─ brelse(bp)                    [缓冲层]
         │  └─ ip->size=off; iupdate(ip)        [inode 层] 登记 inode 块
         ├─ iunlock(f->ip)                      [inode 层]
         └─ end_op()                            [日志层] 最后一个 outstanding 触发 commit
            └─ commit()                         [日志层]
               ├─ write_log()                   缓存 -> 日志区
               ├─ write_head()                  真正提交点
               ├─ install_trans()               日志区 -> 实际块号
               └─ write_head()                  清空日志

open(path, O_CREATE) / mkdir(path) / mknod(path, ...)
└─ sys_open / sys_mkdir / sys_mknod             [系统调用层] 先 begin_op()
   ├─ create(path, type, major, minor)          [系统调用层, static]
   │  ├─ nameiparent(path, name)                [路径名层] 父目录 inode + 最后一段名字
   │  ├─ ilock(dp)                              [inode 层] 锁父目录，让"查重+分配+链接"原子
   │  ├─ dirlookup(dp, name, 0)                 [目录层] 先查有没有重名
   │  ├─ ialloc(dp->dev, type)                  [inode 层] 找空闲 dinode -> 标 type -> iget
   │  │  └─ log_write(dinode 块)                [日志层]
   │  ├─ ilock(ip)
   │  ├─ ip->nlink=1; iupdate(ip)               [inode 层]
   │  ├─ 若 type == T_DIR
   │  │  ├─ dirlink(ip, ".",  ip->inum)         [目录层]
   │  │  └─ dirlink(ip, "..", dp->inum)         [目录层]
   │  ├─ dirlink(dp, name, ip->inum)            [目录层] 写一条 dirent
   │  │  └─ writei(dp, ...)                     [inode 层] 目录也是文件
   │  │     └─ bmap / bread / log_write / brelse [inode 层 + 日志层 + 缓冲层]
   │  └─ iunlockput(dp)                         [inode 层]
   ├─ filealloc()                               [文件描述符层] 分配 struct file
   ├─ fdalloc(f)                                [系统调用层] 进程 ofile[] 找空 fd
   ├─ f->type=FD_INODE; f->off=0; f->ip=ip
   ├─ 若 O_TRUNC: itrunc(ip)                    [inode 层]
   ├─ iunlock(ip)                               [inode 层]
   └─ end_op()                                  [日志层]

unlink(path)
└─ sys_unlink                                   [系统调用层] begin_op()
   ├─ nameiparent(path, name)                   [路径名层] 父目录 dp + 名字
   ├─ ilock(dp)                                 [inode 层]
   ├─ dirlookup(dp, name, &off)                 [目录层] 找到目标 ip + 目录项偏移 off
   ├─ ilock(ip)                                 [inode 层]
   ├─ 检查 nlink>=1；若目录还需 isdirempty
   ├─ writei(dp, 0, &空dirent, off, ...)        [inode 层] 把目录项清零（删"名字"）
   ├─ 若是目录: dp->nlink--; iupdate(dp)        [inode 层]
   ├─ iunlockput(dp)                            [inode 层]
   ├─ ip->nlink--; iupdate(ip)                  [inode 层] 只把磁盘链接数 -1
   ├─ iunlockput(ip)                            [inode 层] -> iput，真正的释放在这里
   │  └─ iput: 若 ref==1 && valid && nlink==0
   │     ├─ itrunc(ip)                          [inode 层] bfree 直接块 + 间接块，size=0
   │     └─ ifree(dev, inum)                    [inode 层] 磁盘 dinode type=0
   └─ end_op()                                  [日志层]

struct {
  struct spinlock lock;
  struct buf buf[NBUF];   // 30 块缓存
 
  // Linked list of all buffers, through prev/next.
  // Sorted by how recently the buffer was used.
  // head.next is most recent, head.prev is least.
  struct buf head;        // 哨兵节点，不存数据
} bcache;

struct buf {
  int valid;        // 内存副本是否有效
  int disk;         // 磁盘是否正占用它
  uint dev;         // 设备号
  uint blockno;     // 块号
  struct sleeplock lock;  // 睡眠锁，保护 data
  uint refcnt;      // 引用计数：多少人在用
  struct buf *prev;
  struct buf *next;
  uchar data[BSIZE];// 块内容，BSIZE=1024
};

void
binit(void)
{
  struct buf *b;
 
  initlock(&bcache.lock, "bcache");
 
  // 哨兵节点先自己成环
  bcache.head.prev = &bcache.head;
  bcache.head.next = &bcache.head;
  // 遍历数组中的所有buf
  for (b = bcache.buf; b < bcache.buf + NBUF; b++) {
    // 将buf插入链表头部，也就是哨兵节点的下一位
    b->next = bcache.head.next;
    b->prev = &bcache.head;
    // 初始化睡眠锁
    initsleeplock(&b->lock, "buffer");
    bcache.head.next->prev = b;
    bcache.head.next = b;
  }
}

static struct buf *
bget(uint dev, uint blockno)
{
  struct buf *b;
 
  acquire(&bcache.lock);            // 全程持锁
 
  // 判断是否已经被缓存过
  // 从链表头往后走
  for (b = bcache.head.next; b != &bcache.head; b = b->next) {
    if (b->dev == dev && b->blockno == blockno) {
      b->refcnt++;                  // 命中：引用 +1
      release(&bcache.lock);
      acquiresleep(&b->lock);       // 先释放大锁，再拿该buf的睡眠锁
      return b;
    }
  }
 
  // 找不到，没有被缓存
  // 从链表尾往前走，head.prev即为链表尾部
  for (b = bcache.head.prev; b != &bcache.head; b = b->prev) {
    if (b->refcnt == 0) {           // 找空闲块
      b->dev = dev;
      b->blockno = blockno;
      b->valid = 0;                 // 关键：迫使 bread 重新读盘
      b->refcnt = 1;
      release(&bcache.lock);
      acquiresleep(&b->lock);
      return b;
    }
  }
  panic("bget: no buffers");
}

struct buf *
bread(uint dev, uint blockno)
{
  struct buf *b;
 
  b = bget(dev, blockno);
  if (!b->valid) {
    virtio_disk_rw(b, 0);   // 0 = 读，真正和磁盘交互
    b->valid = 1;
  }
  return b;                  // 返回已加锁的 buf
}

// Write b's contents to disk.  Must be locked.
// Only the log calls bwrite.
void
bwrite(struct buf *b)
{
  if (!holdingsleep(&b->lock))
    panic("bwrite");
  virtio_disk_rw(b, 1);      // 1 = 写
}

void
brelse(struct buf *b)
{
  if (!holdingsleep(&b->lock))
    panic("brelse");
 
  releasesleep(&b->lock);       // 释放睡眠锁
 
  acquire(&bcache.lock);
  b->refcnt--;                  // 引用 -1
  if (b->refcnt == 0) {
    // no one is waiting for it.
    b->next->prev = b->prev;    // 从当前位置摘下
    b->prev->next = b->next;
    b->next = bcache.head.next; // 插到 head 后面（最近使用端）
    b->prev = &bcache.head;
    bcache.head.next->prev = b;
    bcache.head.next = b;
  }
  release(&bcache.lock);
}

#define BPB (BSIZE * 8)                          // 8192
#define BBLOCK(b, sb) ((b) / BPB + sb.bmapstart) // 块 b 的位在哪个位图块

// Allocate a zeroed disk block.
// returns 0 if out of disk space.
static uint
balloc(uint dev)
{
  int b, bi, m;
  struct buf *bp;
 
  bp = 0;
  for (b = 0; b < sb.size; b += BPB) {              // 外层：逐个位图块
    bp = bread(dev, BBLOCK(b, sb));                 // 读入位图块（已加锁）
    for (bi = 0; bi < BPB && b + bi < sb.size; bi++) { // 内层：逐位
      m = 1 << (bi % 8);                            // 字节内掩码
      if ((bp->data[bi / 8] & m) == 0) {            // 该位为 0 => 空闲
        bp->data[bi / 8] |= m;                      // 置 1：标记占用
        log_write(bp);                              // 登记进事务
        brelse(bp);
        bzero(dev, b + bi);                         // 清零新块
        return b + bi;                              // 返回块号
      }
    }
    brelse(bp);
  }
  printk("balloc: out of blocks\n");
  return 0;                                          // 0 = 失败哨兵
}

// Free a disk block.
static void
bfree(int dev, uint b)
{
  struct buf *bp;
  int bi, m;
 
  bp = bread(dev, BBLOCK(b, sb));   // 找到该块所属的位图块
  bi = b % BPB;
  m = 1 << (bi % 8);
  if ((bp->data[bi / 8] & m) == 0)
    panic("freeing free block");     // 二次释放检测
  bp->data[bi / 8] &= ~m;            // 清 0：标记空闲
  log_write(bp);
  brelse(bp);
}

struct dinode {
  short type;              // 文件类型；0 = 空闲
  short major;             // 主设备号（仅设备文件）
  short minor;             // 次设备号（仅设备文件）
  short nlink;             // 链接数：多少目录项指向它
  uint size;               // 内容字节数
  uint addrs[NDIRECT + 1]; // 数据块地址（12 直接 + 1 间接）
};

#define IPB (BSIZE / sizeof(struct dinode))       // 16
#define IBLOCK(i, sb) ((i) / IPB + sb.inodestart) // 第 i 个 inode 所在块

struct inode {
  uint dev;              // 设备号
  uint inum;             // inode 号
  int ref;               // 引用计数（内存指针数）
  struct sleeplock lock; // 保护下面所有字段
  int valid;             // 是否已从磁盘读入
 
  short type; // 以下都是 dinode 的副本
  short major;
  short minor;
  short nlink;
  uint size;
  uint addrs[NDIRECT + 1];
};

struct {
  struct spinlock lock;
  struct inode inode[NINODE];   // NINODE = 50
} itable;

// Allocate an inode on device dev.
struct inode *
ialloc(uint dev, short type)
{
  int inum;
  struct buf *bp;
  struct dinode *dip;
 
  for (inum = 1; inum < sb.ninodes; inum++) {   // 从 1 号扫到最后一个
    bp = bread(dev, IBLOCK(inum, sb));          // IBLOCK 计算出该 inode 所在块号
    // bp->data读出整块的数据，有16个dinode，将其转为dinode *类型加上偏移得到该dinode的指针
    // data是uchar*类型，转为dinode *就指向第0个dinode
    dip = (struct dinode *)bp->data + inum % IPB; 
    if (dip->type == 0) { // a free inode
      memset(dip, 0, sizeof(*dip));
      dip->type = type;                          // 标记类型
      log_write(bp);                             // 登记写盘
      brelse(bp);
      return iget(dev, inum);                    // 返回内存条目
    }
    brelse(bp);
  }
  printk("ialloc: no inodes\n");
  return 0;
}

static struct inode *
iget(uint dev, uint inum)
{
  struct inode *ip, *empty;
 
  acquire(&itable.lock);
 
  // Is the inode already in the table?
  empty = 0;
  for (ip = &itable.inode[0]; ip < &itable.inode[NINODE]; ip++) {
    if (ip->ref > 0 && ip->dev == dev && ip->inum == inum) {
      ip->ref++;                     // 命中：返回一个新引用
      release(&itable.lock);
      return ip;
    }
    if (empty == 0 && ip->ref == 0)  // 记住第一个空槽
      empty = ip;
  }
 
  if (empty == 0)
    panic("iget: no inodes");        // 表满
 
  ip = empty;                        // 复用空槽
  ip->dev = dev;
  ip->inum = inum;
  ip->ref = 1;
  ip->valid = 0;                     // 还没从磁盘读入
  release(&itable.lock);
  return ip;
}

void
ilock(struct inode *ip)
{
  struct buf *bp;
  struct dinode *dip;
 
  if (ip == 0 || ip->ref < 1)
    panic("ilock");
 
  acquiresleep(&ip->lock);      // 先拿睡眠锁
 
  if (ip->valid == 0) {         // 只在没读过时读盘
    bp = bread(ip->dev, IBLOCK(ip->inum, sb));
    dip = (struct dinode *)bp->data + ip->inum % IPB;  // 和ialloc的指针操作一致
    ip->type = dip->type;       // dinode -> 内存 inode
    ip->major = dip->major;
    ip->minor = dip->minor;
    ip->nlink = dip->nlink;
    ip->size = dip->size;
    memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
    brelse(bp);
    ip->valid = 1;
    if (ip->type == 0)
      panic("ilock: no type");
  }
}

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;                  // 内存 inode -> dinode
  dip->major = ip->major;
  dip->minor = ip->minor;
  dip->nlink = ip->nlink;
  dip->size = ip->size;
  memmove(dip->addrs, ip->addrs, sizeof(ip->addrs));
  log_write(bp);
  brelse(bp);
}

void
iput(struct inode *ip)
{
  acquire(&itable.lock);
 
  int last = (ip->ref == 1 && ip->valid && ip->nlink == 0); // 最后引用且无链接
  uint dev = ip->dev, inum = ip->inum;   // 先捕获，ref 归零后槽位可能被复用
 
  if (last) {
    acquiresleep(&ip->lock);
    release(&itable.lock);
 
    itrunc(ip);        // 释放数据块（磁盘上 type 暂时保留）
    ip->valid = 0;
 
    releasesleep(&ip->lock);
 
    acquire(&itable.lock);
  }
 
  ip->ref--;           // 放引用
  release(&itable.lock);
 
  if (last)
    ifree(dev, inum);  // 现在再把磁盘 dinode 的 type 清 0
}

static uint
bmap(struct inode *ip, uint bn)
{
  uint addr, *a;
  struct buf *bp;
 
  if (bn < NDIRECT) {                 // 直接块区
    if ((addr = ip->addrs[bn]) == 0) {  // 槽是空的？
      addr = balloc(ip->dev);           // 分配一块
      if (addr == 0)
        return 0;                       // 磁盘满了
      ip->addrs[bn] = addr;             // 记下来
    }
    return addr;
  }
  bn -= NDIRECT;                      // 换成间接区下标，减12
 
  if (bn < NINDIRECT) {               // 间接块区，不能超过256
    // Load indirect block, allocating if necessary.
    if ((addr = ip->addrs[NDIRECT]) == 0) { // 还没有间接块？
      addr = balloc(ip->dev);         // 分配的新块都会清0
      if (addr == 0)
        return 0;
      ip->addrs[NDIRECT] = addr;
    }
    bp = bread(ip->dev, addr);            // 读入间接块
    a = (uint *)bp->data;                 // 当作 uint 数组
    if ((addr = a[bn]) == 0) {            // 该槽为空？
      addr = balloc(ip->dev);
      if (addr) {
        a[bn] = addr;                     // 写入新块号
        log_write(bp);                    // 记入日志
      }
    }
    brelse(bp);
    return addr;
  }
 
  panic("bmap: out of range");
}

void
itrunc(struct inode *ip)
{
  int i, j;
  struct buf *bp;
  uint *a;
 
  for (i = 0; i < NDIRECT; i++) {        // 先释放直接块
    if (ip->addrs[i]) {
      bfree(ip->dev, ip->addrs[i]);
      ip->addrs[i] = 0;                  // 清 0
    }
  }
 
  if (ip->addrs[NDIRECT]) {              // 有间接块吗？
    bp = bread(ip->dev, ip->addrs[NDIRECT]);
    a = (uint *)bp->data;
    for (j = 0; j < NINDIRECT; j++) {    // 释放间接块指向的数据块
      if (a[j])
        bfree(ip->dev, a[j]);
    }
    brelse(bp);
    bfree(ip->dev, ip->addrs[NDIRECT]);  // 最后释放间接块本身
    ip->addrs[NDIRECT] = 0;
  }
 
  ip->size = 0;
  iupdate(ip);
}

void
stati(struct inode *ip, struct stat *st)
{
  st->dev   = ip->dev;
  st->ino   = ip->inum;
  st->type  = ip->type;
  st->nlink = ip->nlink;
  st->size  = ip->size;
}

int
readi(struct inode *ip, int user_dst, uint64 dst, uint off, uint n)
{
  uint tot, m;
  struct buf *bp;
 
  if (off > ip->size || off + n < off)  // 起点越界，或 n 溢出
    return 0;
  if (off + n > ip->size)               // 读过了文件末尾
    n = ip->size - off;                 // 缩短读取长度
 
  for (tot = 0; tot < n; tot += m, off += m, dst += m) {  // 主循环
    uint addr = bmap(ip, off / BSIZE);  // 文件块号 -> 磁盘块号
    if (addr == 0)
      break;                            // 分配失败就停
    bp = bread(ip->dev, addr);          // 读磁盘块
    m = min(n - tot, BSIZE - off % BSIZE);  // 本次能拷多少字节
    if (either_copyout(user_dst, dst, bp->data + (off % BSIZE), m) == -1) {
      brelse(bp);                       // 用户地址非法
      tot = -1;
      break;
    }
    brelse(bp);
  }
  return tot;                           // 实际读到的字节数
}

int
writei(struct inode *ip, int user_src, uint64 src, uint off, uint n)
{
  uint tot, m;
  struct buf *bp;
 
  if (off > ip->size || off + n < off)
    return -1;
  if (off + n > MAXFILE * BSIZE)        // 不能超过文件最大长度
    return -1;
 
  for (tot = 0; tot < n; tot += m, off += m, src += m) {
    uint addr = bmap(ip, off / BSIZE);
    if (addr == 0)
      break;
    bp = bread(ip->dev, addr);
    m = min(n - tot, BSIZE - off % BSIZE);
    if (either_copyin(bp->data + (off % BSIZE), user_src, src, m) == -1) {
      log_write(bp);                    // 可能已改了半个块，要记日志
      brelse(bp);
      break;
    }
    log_write(bp);                      // 把修改记入日志
    brelse(bp);
  }
 
  if (off > ip->size)                   // 写使文件长大了？
    ip->size = off;                     // 更新大小
  iupdate(ip);                          // 写回 inode
  return tot;
}

#define DIRSIZ 14
 
struct dirent {
  ushort inum;                            // 2 字节
  char name[DIRSIZ] __attribute__((nonstring)); // 14 字节
};

int namecmp(const char *s, const char *t) {
  return strncmp(s, t, DIRSIZ);   // 固定只比 14 字节，不靠 \0
}

struct inode *
dirlookup(struct inode *dp, char *name, uint *poff)
{
  uint off, inum;
  struct dirent de;
 
  if (dp->type != T_DIR)
    panic("dirlookup not DIR");
 
  for (off = 0; off < dp->size; off += sizeof(de)) {
    if (readi(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
      panic("dirlookup read");
    if (de.inum == 0)
      continue;                       // 空槽，跳过
    if (namecmp(name, de.name) == 0) {
      if (poff)
        *poff = off;                  // 告诉调用者：条目在第 off 字节
      inum = de.inum;
      return iget(dp->dev, inum);     // 返回"已引用但未锁定"的 inode
    }
  }
 
  return 0;                           // 没找到
}

int
dirlink(struct inode *dp, char *name, uint inum)
{
  int off;
  struct dirent de;
  struct inode *ip;
 
  // 1) 先查重：名字已存在就报错
  if ((ip = dirlookup(dp, name, 0)) != 0) {
    iput(ip);
    return -1;
  }
 
  // 2) 找一个空闲槽位
  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;                          // 找到空槽，off 停在它的偏移
  }
 
  // 3) 写进去
  strncpy(de.name, name, DIRSIZ);
  de.inum = inum;
  if (writei(dp, 0, (uint64)&de, off, sizeof(de)) != sizeof(de))
    return -1;
 
  return 0;
}

static struct inode *
namex(char *path, int nameiparent, char *name)
{
  struct inode *ip, *next;
 
  // 起点
  if (*path == '/')
    ip = iget(ROOTDEV, ROOTINO);      // 绝对路径：根目录 inode 1
  else
    ip = idup(myproc()->cwd);         // 相对路径：当前工作目录
 
  // 一个元素一个元素地走
  while ((path = skipelem(path, name)) != 0) {
    ilock(ip);                        // 锁住当前目录
    if (ip->type != T_DIR) {          // 必须是目录
      iunlockput(ip);
      return 0;
    }
    if (ip->nlink == 0) {             // 已被删除的目录
      iunlockput(ip);
      return 0;
    }
    if (nameiparent && *path == '\0') {  // 最后一个元素就停
      iunlock(ip);
      return ip;
    }
    if ((next = dirlookup(ip, name, 0)) == 0) {  // 找下一层
      iunlockput(ip);
      return 0;
    }
    iunlockput(ip);                   // 先放当前，再
    ip = next;                        // 把 next 留到下一轮再锁
  }
 
  if (nameiparent) {                  // 走到头却不是最后一个元素
    iput(ip);
    return 0;
  }
  return ip;
}

struct file {
  enum { FD_NONE, FD_PIPE, FD_INODE, FD_DEVICE } type;
  int ref;              // reference count  引用计数
  char readable;
  char writable;
  struct pipe *pipe;    // FD_PIPE
  struct inode *ip;     // FD_INODE and FD_DEVICE
  uint off;             // FD_INODE   读写偏移量
  short major;          // FD_DEVICE
};

struct file *ofile[NOFILE]

struct file file[NFILE]