6.828(2018) hw: big file

最新推荐文章于 2023-04-10 20:03:01 发布

mdzzname

最新推荐文章于 2023-04-10 20:03:01 发布

阅读量426

点赞数

分类专栏： 6.828 文章标签：操作系统 6.828

本文链接：https://blog.csdn.net/mdzzname/article/details/113245734

版权

6.828 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

这个作业主要就是让你熟悉xv6的文件系统，并能做出一些修改，主要的任务是让你增加一个二级页来增加一个文件最大的大小。

准备工作

修改 Makefile中的 CPUS := 2 为 CPUS := 2，并在后面加一行 QEMUEXTRA = -snapshot，修改这两项可以让后面的测试更快。
下载 big.c，并在Makefile的 UPROGS 加一行 _big\，这个文件主要用来测试。
修改 param.h 的宏定义为 #define FSSIZE 20000 // size of file system in blocks，增加文件系统的最大块数。

任务

我们的任务是修改bmap函数，使其实现二级页。xv6现有的文件地址结构如图示

xv6 inode

一个文件的inode共有13个地址项，前12个为直接块，最后一个为一级间接块。

在这个文件系统中，一个块为512B，一个地址占4B，所以一个文件最多有12个直接块和(512B / 4B = 128)个一级间接块，共为140个块，共为140 * 512B = 71680 B，为70KB

任务要求inode大小不变，所以我们要修改成前11个为直接块，第12个为一级间接块，最后一个为二级简洁块。

在修改后的文件系统中，一个文件最多有11个直接块和，128个一级间接块， (128 * 128 = 16384)个二级间接块，共为 16523个块，共为 16523 * 512B = 8459776B，为8MB。

实现

我们只需要修改bmap函数来实现二级间接块的映射，而不需要处理二级间接块的删除。

相关的宏定义在 fs.h 中，修改如下：


#define NDIRECT 11                                    // 直接块个数

#define NINDIRECT (BSIZE / sizeof(uint))              // 一级间接块个数

#define NDINDIRECT (NINDIRECT * NINDIRECT)            // 二级间接块个数

#define MAXFILE (NDIRECT + NINDIRECT + NDINDIRECT)    // 一个文件最大的块数

还要修改下面的dinode结构体

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

最后修改bmap函数

// Inode content
//
// The content (data) associated with each inode is stored
// in blocks on the disk. The first NDIRECT block numbers
// are listed in ip->addrs[].  The next NINDIRECT blocks are
// listed in block ip->addrs[NDIRECT].

// Return the disk block address of the nth block in inode ip.
// If there is no such block, bmap allocates one.
static uint
bmap(struct inode *ip, uint bn)
{
  uint addr, *a;
  struct buf *bp;

  // 如果块号在直接块中
  if(bn < NDIRECT){
    // 如该块没有分配，那就直接分配一个
    if((addr = ip->addrs[bn]) == 0)
      ip->addrs[bn] = addr = balloc(ip->dev);
    return addr;
  }
  bn -= NDIRECT;

  // 如果块号在一级间接块中
  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);
      log_write(bp);
    }
    brelse(bp);
    return addr;
  }
  bn -= NINDIRECT;

  // support doubly-indirect block
  // 如果块号在二级间接块中
  if (bn < NDINDIRECT) {
    // 如果第一个目录块没有分配，那就分配一个
    if((addr = ip->addrs[NDIRECT+1]) == 0)
      ip->addrs[NDIRECT+1] = addr = balloc(ip->dev);
    // 读入第一级的块
    bp = bread(ip->dev, addr);
    a = (uint*)bp->data;
    // 计算第一级块所在的索引和第一级块所在的索引
    uint idx1 = bn / (BSIZE / sizeof(uint));
    uint idx2 = bn % (BSIZE / sizeof(uint));
    // 如果第二级索引块没有分配， 那就分配一个
    if((addr = a[idx1]) == 0){
      a[idx1] = addr = balloc(ip->dev);
      log_write(bp);
    }
    // 这里要记得释放掉第一级的块
    brelse(bp);
    // 读入第二级的块
    bp = bread(ip->dev, addr);
    a = (uint*)bp->data;
    // 如果最终要映射的块没有分配，那就分配一个
    if((addr = a[idx2]) == 0){
      a[idx2] = addr = balloc(ip->dev);
      log_write(bp);
    }
    // 释放第二级的块
    brelse(bp);
    return addr;
  }