mit6.828 - lab5笔记（上）

文件系统结构

unix的文件系统相关知识

• unix将可用的磁盘空间划分为两种主要类型的区域：inode区域和数据区域。
• unix为每个文件分配一个inode，其中保存文件的关键元数据，如文件的stat属性和指向文件数据块的指针。
• 数据区域中的空间会被分成大小相同的数据块（就像内存管理中的分页）。数据块中存储文件数据和目录元数据。
• 目录条目包含文件名和指向inode的指针

jos的文件系统
jos对文件系统进行了简化——不使用inode。文件的所有元数据存储在目录条目中。
jos中的数据区域也会被划分为“块”

磁盘上的数据结构

磁盘不可能以字节为单位进行读写，而是以扇区为单位进行读写。jos 中扇区为512字节。
硬件层面，磁盘驱动以扇区为单位进行数据读写。
软件层面，操作系统以“块”为单位进行数据分配。
jos 中块的大小为4096字节。

超级块 superblocks

如上文所述，jos 的数据区域被划分为块。
jos 还会有一个超级块，位于磁盘的第1个块（第0个块中存放 引导加载器和分区表），由 inc/fs.h 中的 struct super 定义。内容如下：

struct Super {
	uint32_t s_magic;		// Magic number: FS_MAGIC
	uint32_t s_nblocks;		// Total number of blocks on disk
	struct File s_root;		// Root directory node
};

其中包含磁盘中存放的块的总量和文件系统的根目录。
超级块可能一个块存不下，所以会占据多个块。

文件元数据 File Meta data

文件元数据定义在 inc/fs.h 中的 struct File ， 内容如下：

struct File {
	char f_name[MAXNAMELEN];	// filename
	off_t f_size;			// file size in bytes
	uint32_t f_type;		// file type

	// Block pointers.
	// A block is allocated iff its value is != 0.
	uint32_t f_direct[NDIRECT];	// direct blocks
	uint32_t f_indirect;		// indirect block

	// Pad out to 256 bytes; must do arithmetic in case we're compiling
	// fsformat on a 64-bit machine.
	uint8_t f_pad[256 - MAXNAMELEN - 8 - 4*NDIRECT - 4];
} __attribute__((packed));	// required only on some 64-bit machines

其中包含文件名、大小、类型、数据块指针，以及pad（该结构保持256字节大小）。
一个 File struct 对应的数据块分为两种：直接块、间接块。

• 直接块有10个，可以存储40kb的文件，存储在 File struct 的数据块指针数组 f_direct 中。
• 间接块最多可以有1024个，如果直接块不够用， File struct 会被分配一个数据块（地址存储在 f_indirect )，里面全都用于保存数据块指针。（一个数据块大小为4096字节，一个数据块指针占据4字节，故间接块可以有4096/4=1024个）
  因此 jos 的文件最多可以 1034个块， 可以存储 $1034 \times 4096kb$ 的数据。
  File的结构体的情况可以用下面的图片来理解：

目录文件和普通文件

jos 的 File struct 既可以用来表示普通文件，也可以代表目录文件，由 File struct 的 f_type 字段来区分。
文件系统管理普通文件和目录文件的方式完全相同，具体来说，文件系统不解析普通文件内的数据，但解析目录文件内的数据，因为其中是该目录下的文件的数据。
超级块中包含一个 File struct ， 其中包含了文件系统根目录的元数据。

文件系统

磁盘访问

在之前的 lab 中，我们通过汇编的 in 和 out 指令，向磁盘设备发送读写信号。但是这样果然还是好麻烦， jos 将 IDE 磁盘驱动程序作为用户级进程来实现。（传统的策略是将磁盘驱动加入至内核，然后以系统调用的形式供进程调用）。
为了能够让用户级进程在不使用磁盘中断的前提下，拥有执行特殊设备I/O指令的权限，需要使用 EFLAG 寄存器中的 IOPL 位。
因此，操作系统在创建我们的 用户级文件系统 进程时，应该对其 env struct 中的 eflag 成员置位。因此，我们需要对 lab3 编写的 env_create 进行修改。由于我们只允许 用户及文件系统进程 进行磁盘IO，所以需要将其他进程和 用户级文件系统进程 进行区分， jos 的方案是专为 用户及文件系统进程 设立一个 ENV_TYPE_FS 。具体任务见练习1.

块缓存(练习2@fs/bc.c)

在之前的 lab 中，我们访问磁盘是通过分区号来访问的。但是这样果然好麻烦，要是能像内存一样用线性地址访问就好了。

块缓存的编址
为了实现上面的目标， jos 将 用户级文件系统进程的虚拟地址空间中 0x1000_0000 (DISKMAP) 到 0xD000_0000 (DISKMAP+DISKMAX) 部分用于和磁盘的存储空间进行映射。

具体来说，首先将块号和内存地址进行映射，当我们访问块缓存中的地址时，先将地址转化为块号，然后再进行读写。然后将块缓存的地址通过页表、页目录进行管理。

顺带一提，DISKMAX 大小为 0xC000_0000B = 3GB ， 因此 jos 仅支持 3GB 大小的磁盘存储空间。

块缓存的同步方案
为了同步内存中的磁盘数据，和磁盘中实际存储的数据，我们利用 PTE 的 PTE_D 位追踪数据是否被改动。（当内存地址addr所指页被改动时，MMU会将其对应的PTE中的 PTE_D 置位）。

将整个磁盘都读入内存很浪费时间，我们可以参考“写时复制”实现一种“读时加载”的页错误处理程序。当程序读取的块缓存地址对应的数据尚未被加载时，触发页错误，然后将对应的数据从磁盘中加载到其块缓存地址。

块缓存的是同步的实现，即是练习2的内容。

块缓存的实现
jos 对块缓存的实现，主要位于 fs/bc.c 中。其中包含如下函数：

void * diskaddr(uint32_t blockno)

将块号转化为对应的块缓存地址

void*
diskaddr(uint32_t blockno)
{
	if (blockno == 0 || (super && blockno >= super->s_nblocks))
		panic("bad block number %08x in diskaddr", blockno);
	return (char*) (DISKMAP + blockno * BLKSIZE);
}

bool va_is_mapped(void *va)

检查块缓存 va 是否已经被映射到页目录。
具体方法：检查 va 对应的 PDE 和 PTE 的 PTE_P 是否置位。

bool
va_is_mapped(void *va)
{
	return (uvpd[PDX(va)] & PTE_P) && (uvpt[PGNUM(va)] & PTE_P);
}

bool va_is_dirty(void *va)

检查块缓存 VA 是否"脏"。脏指的是数据是否被改动。
具体方法：检查 va 对应的 PTE 的 PTE_D 是否置位。

bool
va_is_dirty(void *va)
{
	return (uvpt[PGNUM(va)] & PTE_D) != 0;
}

static void bc_pgfault(struct UTrapframe *utf)

缺页中断，当块缓存范围内地址触发页错误时会被调用。

static void
bc_pgfault(struct UTrapframe *utf)
{
    void *addr = (void *) utf->utf_fault_va;                    //取出引发错误的地址
    uint32_t blockno = ((uint32_t)addr - DISKMAP) / BLKSIZE;    //转化为块号
	int r;

	// 检查地址是否越界
	if (addr < (void*)DISKMAP || addr >= (void*)(DISKMAP + DISKSIZE))
		panic("page fault in FS: eip %08x, va %08x, err %04x",
		      utf->utf_eip, addr, utf->utf_err);

	// 检查块号是否越界
	if (super && blockno >= super->s_nblocks)
		panic("reading non-existent block %08x\n", blockno);

	// Allocate a page in the disk map region, read the contents
	// of the block from the disk into that page.
	// Hint: first round addr to page boundary. fs/ide.c has code to read
	// the disk.
	//
	// LAB 5: you code here:
	//申请一块物理页，将其映射到addr处
	addr  = ROUNDDOWN(addr, PGSIZE);		//对齐需要读取的地址
	sys_page_alloc(0, addr, PTE_W|PTE_U|PTE_P);	//调用page_alloc的syscall，申请内存页
	// 将磁盘中的数据读入内存
	// 磁盘以扇区为单位读取数据，一个扇区512字节
	// 文件系统以块为单位管理数据，一个块4096字节（一页）
	if((r=ide_read(blockno * BLKSECTS, addr, BLKSECTS))<0)	//从硬盘读取数据到内存页
		panic("ide_read: %e" ,r);
	
	//由于，上面的操作对addr进行内存写操作，PTE_D被置位
	//如果坐视不管，后面会被文件系统认为，需要写回磁盘，这肯定是不合理的
	//因此通过sys_page_map的方式清空脏位（？为什么sys_page_map可以清空脏位）
	if ((r = sys_page_map(0, addr, 0, addr, uvpt[PGNUM(addr)] & PTE_SYSCALL)) < 0)
		panic("in bc_pgfault, sys_page_map: %e", r);

	// Check that the block we read was allocated. (exercise for
	// the reader: why do we do this *after* reading the block
	// in?)
	//（这里我不是很明白）
	if (bitmap && block_is_free(blockno))
		panic("reading free block %08x\n", blockno);
}

void flush_block(void *addr)

刷新块缓存地址 addr

void
flush_block(void *addr)
{
	//将addr转换位块号
	uint32_t blockno = ((uint32_t)addr - DISKMAP) / BLKSIZE;

	//检查addr是否越界
	if (addr < (void*)DISKMAP || addr >= (void*)(DISKMAP + DISKSIZE))
		panic("flush_block of bad va %08x", addr);

	// LAB 5: Your code here.
	// panic("flush_block not implemented");
	//addr向下对齐
	addr = ROUNDDOWN(addr, PGSIZE);

	//检查数据是否已经读入，数据页是否有脏位
	if(!va_is_mapped(addr) || !va_is_dirty(addr))
	{
		return ;
	}
	int r = 0;
	//将数据写回至磁盘
	if((r = ide_write(blockno*BLKSECTS, addr, BLKSECTS))<0)
	{
		panic("in flush_block, ide_write() : %e",r);
	}
	//清空脏位
	if((r=sys_page_map(0, addr, 0, addr, uvpt[PGNUM(addr)] & PTE_SYSCALL))<0)
		panic("in bc_pgfault, sys_page_map: %e", r);
}

boid bc_init(void)

初始化块缓存

void
bc_init(void)
{
	struct Super super;
	//设置文件系统的缺页处理函数
	set_pgfault_handler(bc_pgfault);
	check_bc();

	// cache the super block by reading it once
	// 对super块的块缓存地址读取，并给super
	// 首先会触发缺页中断，将block#1加载至diskaddr(1)处
	// 然后再进行memmove，将读取到的数据填充super struct
	memmove(&super, diskaddr(1), sizeof super);
}

块位图

为什么需要块位图？

块缓存实现之后，我们拥有了从磁盘中读写、改写数据块的能力。接下来考虑一个问题，我们如何删除某个块的内容？将其数据用0覆盖吗？磁盘的磁头听到这种方案内心一定是麻的。一种简单的方案是用一个位图来表示所有块的状态，每个位代表一个块，1代表空闲，0代表占用。这样，当我们要"删除"一个块的数据时，只要在位图中将对应位置0即可。

块位图本身也是占用磁盘数据空间的， jos 的块位图存储在磁盘的第2个块以及之后，块位图一个块存不下。（手册中只有一张示意图提到这个点）

jos 的位图是一个u32int型数组，一个u32int有32个位，对应32个块。3GB磁盘空间共有 $$\frac{3\times 1024 \times 1024 \times 1024 B}{4\times 1024 B} = 768\times 1024 个$$一个块共有 $4096\times 8bit = 32 \times 1024 bit$ 因此，bitmap应该占据 $\frac{768}{32} = 24$ 个块
磁盘的存储空间示意图如下：

维护块位图 （练习3@fs/fs.c）

当我们想要使用 free 的块时，需要将对应位置0。当我们想释放 non-free 块时，应将对应位置1。 练习3 让我们实现 fs/fs.c 中的 free_block 和 alloc_block 来实现这些内容。值得注意的是，无论是 free_block 还是 alloc_block 我们一定都会影响 bitmap 占用的block，因此需要调用 flush_block 刷新 bitmap 占用的 block。

void free_block(uint32_t blockno)

void
free_block(uint32_t blockno)
{
	// Blockno zero is the null pointer of block numbers.
	if (blockno == 0)
		panic("attempt to free zero block");
	bitmap[blockno/32] |= 1<<(blockno%32);			//修改bitmap，标记为未使用
}

free_block 中最核心的就是 bitmap[blockno/32] |= 1<<(blockno%32);
blockno/32 得到 blockno 在bitmap 的哪个uint32_t，因为 bitmap 的定义如下：

//bitmap 是一个uint32_t类型的数组
uint32_t *bitmap;       // bitmap blocks mapped in memory

blockno%32 得到 blockno 位于这个uint32_t 的哪一位

int alloc_block(void)

allock_block 根据块位图寻找一个空闲块，返回这个空闲块的块号，并更新块位图

int
alloc_block(void)
{
	uint32_t bitmap_start = 2;
	//一个block大小为4096B，bitmap的一项是uint32_t，大小为4B,故一个block够装下4096/4项
	uint32_t bitmap_item_num_in_block = 4096/4;

	for (uint32_t blockno = 0; blockno < super->s_nblocks; blockno++) {//遍历整个bitmap，寻找空闲块
		if(block_is_free(blockno)){
			bitmap[blockno / 32] &= ~(1 << (blockno % 32));	//将该块置位"已使用"
			
			//blockno/32 得到该block在bitmap的下标位置
			uint32_t bitmap_item = blockno / 32;
			//blockno % 32 得到block在 bitmap_item 中的第几个比特位
			uint32_t bitmap_item_bit = blockno % 32;
			//1 << bitmap_item_bit 得到 bitmap_item_bit 的掩码
			bitmap[bitmap_item] &= ~(1 << bitmap_item_bit);	

			//bitmap_item / bitmap_item_num_in_block 得到 bitmap_item 位于bitmap后的第几个block
			//然后调用flush_block把该项所在的bitmap块写回
			flush_block(diskaddr(bitmap_start + bitmap_item / bitmap_item_num_in_block));
			return blockno;
		}
	}
	//没有找到空闲block, 则返回-E_NO_SIAK
	return -E_NO_DISK;
}

文件操作(练习4@fs/fs.c)

有了块缓存和块位图机制，我们现在有了以块为单位的读写硬盘数据的能力。但是块中的数据是以文件的形式存储。jos 在 fs/fs.c 中还有一些函数，用来实现对文件的基本操作。包括：

• 从块中解析文件结构
• 扫描目录中的文件条目
• 从根目录寻找指定文件
  练习4 让我们实现 file_block_walk 、 file_get_block，并且通读 fs/fs.c

file_block_walk : 从文件中的快便宜映射到结构文件中该块的指针或间接块
file_get_block : 映射到实际的磁盘块

static int file_block_walk

根据文件 File f 内的块号 filebno，寻找该块对应的硬盘块号 ppdiskbno
如果 File f 的 indirects 没有初始化，且 alloc 置位，则初始化 indirects
如果输入合法，这个函数保证一定完成 filebno 到 diskbno 的映射，但不保证 diskbno 所指的块已经在块位图中申请。
申请工作由 file_get_block 负责

static int
file_block_walk(struct File *f, uint32_t filebno, uint32_t **ppdiskbno, bool alloc)
{
	uint32_t * indirects;
	if(filebno >= NDIRECT + NINDIRECT)		//检查 filebno 是否超出 File结构体 能存储的上限
		return -E_NO_DISK;

	if(filebno < NDIRECT)
	{
		*ppdiskbno = &(f->f_direct[filebno]);	//如果 filebno 位于 直接块内，直接返回
	}
	else if(f->f_indirect)						// 如果 filebno 位于 非直接块，且该File已经申请了直接块
	{
		indirects = diskaddr(f->f_indirect);	//获取非直接块所在的地址
		*ppdiskbno = &(indirects[filebno - NDIRECT]);
	}
	else if(alloc)								// 如果 filebno 位于 非直接块，且该File未申请非直接块，且alloc置位
	{
		int bn;
		if ((bn = alloc_block()) < 0)
			return bn;		//如果没有剩余空闲块，返回E_NO_DISK
		f->f_indirect = bn;	//初始化 indirect
		flush_block(diskaddr(bn));	//刷新 indirect块 不太理解为什么要刷新这个块，这个块应该是未修改的
		indirects = diskaddr(bn);
		*ppdiskbno = &(indirects[filebno - NDIRECT]);
	}
	else										// 如果 filebno 位于 非直接块，且该File未申请非直接块，且alloc未置位
	{
		return -E_NOT_FOUND;
	}
	return 0;
}

file_get_block

负责读取文件 File f 的第 filebnoe 个块，将数据存储在 blk 所指内存地址。

int
file_get_block(struct File *f, uint32_t filebno, char **blk)
{
	uint32_t * pdiskbno;
	int r;
	//先通过 file_block_walk 获取 filebno 对应的 diskbno
	if((r = file_block_walk(f, filebno, &pdiskbno, true)) < 0)
		return r;
	
	int bn;
	//如果 filebno 对应的块尚未申请，则通过 alloc_block 进行申请
	if(*pdiskbno == 0)	
	{
		if((bn = alloc_block()) < 0)
			return bn;
		*pdiskbno = bn;
		flush_block(diskaddr(bn));
	}
	//将块中的数据读取到 blk 所指空间
	*blk = diskaddr(*pdiskbno);

	return 0;
}

static int dir_lookup

查找 dir 中文件名为 name 的文件，保存在 file 中。

static int
dir_lookup(struct File *dir, const char *name, struct File **file)
{
	int r;
	uint32_t i, j, nblock;
	char *blk;
	struct File *f;

	assert((dir->f_size % BLKSIZE) == 0);
	nblock = dir->f_size / BLKSIZE;			//dir中共有 nblock 个块
	for (i = 0; i < nblock; i++) {
		if ((r = file_get_block(dir, i, &blk)) < 0)	//从dir中获取第i个块
			return r;
		f = (struct File*) blk;						
		for (j = 0; j < BLKFILES; j++)				//遍历 当前blk中存放的所有 File结构体
			if (strcmp(f[j].f_name, name) == 0) {	//顺找是否存在这个name
				*file = &f[j];
				return 0;
			}
	}
	return -E_NOT_FOUND;
}

static int dir_alloc_file

在目录 dir 下申请一个文件 file

static int
dir_alloc_file(struct File *dir, struct File **file)
{
	int r;
	uint32_t nblock, i, j;
	char *blk;
	struct File *f;

	assert((dir->f_size % BLKSIZE) == 0);
	nblock = dir->f_size / BLKSIZE;
	//遍历 dir 中所有的块
	for (i = 0; i < nblock; i++) {
		if ((r = file_get_block(dir, i, &blk)) < 0)
			return r;
		f = (struct File*) blk;
		//遍历块中的所有 File
		for (j = 0; j < BLKFILES; j++)
			//如果存在空闲的 File ，则保存至 f 并返回
			if (f[j].f_name[0] == '\0') {	
				*file = &f[j];
				return 0;
			}
	}
	//如果 dir 中已申请的块没有空闲空间，则申请块并更新 f_size
	dir->f_size += BLKSIZE;
	if ((r = file_get_block(dir, i, &blk)) < 0)
		return r;
	//返回新块 blk 的第一个 File 的地址
	f = (struct File*) blk;
	*file = &f[0];
	return 0;
}

static int walk_path

从根目录搜索 path 所指的文件，将最终搜索结果的最底层目录存放在 pdir ， 文件则存放在 pf ，

static int
walk_path(const char *path, struct File **pdir, struct File **pf, char *lastelem)
{
	const char *p;
	char name[MAXNAMELEN];
	struct File *dir, *f;
	int r;

	path = skip_slash(path);	//跳过一开始的 '/'
	f = &super->s_root;			//从 super 中读取根目录文件
	dir = 0;					//dir 指向上层目录，dir应当是个目录类型
	name[0] = 0;

	if (pdir)
		*pdir = 0;
	*pf = 0;
	while (*path != '\0') {
		dir = f;
		p = path;								//自顶向下地处理 path ，p 指向当前层次目录名的开头
		while (*path != '/' && *path != '\0')	//用path指向当前层次目录名的尾后
			path++;
		if (path - p >= MAXNAMELEN)
			return -E_BAD_PATH;
		memmove(name, p, path - p);				//用p和path切下当前层次目录名，copy到name
		name[path - p] = '\0';
		path = skip_slash(path);				//更新path，让path指向下一个层次地目录名开头

		if (dir->f_type != FTYPE_DIR)			//检查dir是否是目录类型
			return -E_NOT_FOUND;

		if ((r = dir_lookup(dir, name, &f)) < 0) {		//在dir中寻找name
			if (r == -E_NOT_FOUND && *path == '\0') {	//如果没找到，就将 pdir 设置为最后有效的目录，
				if (pdir)								//lastelem 设置为最后遍历到的条目
					*pdir = dir;
				if (lastelem)							
					strcpy(lastelem, name);
				*pf = 0;
			}
			return r;
		}
	}

	if (pdir)
		*pdir = dir;
	*pf = f;
	return 0;
}

int file_create

int file_create(const char *path, struct File **pf)
在 path 处创建文件 pf

int
file_create(const char *path, struct File **pf)
{
	char name[MAXNAMELEN];
	int r;
	struct File *dir, *f;

	if ((r = walk_path(path, &dir, &f, name)) == 0)		//尝试获取 path 所指文件的 File结构体
		return -E_FILE_EXISTS;							//如果那个位置已经存在则返回错误码 E_FILE_EXISTS
	if (r != -E_NOT_FOUND || dir == 0)					//如果存在其他问题，则返回对应错误码
		return r;
	if ((r = dir_alloc_file(dir, &f)) < 0)				//申请一个 File结构体，并将它记录在 dir 之下
		return r;

	strcpy(f->f_name, name);							//file_create 只负责填充 File结构体的 name字段
	*pf = f;
	file_flush(dir);									//file_create 只改动了磁盘中的 dir 所指文件的 File结构体
	return 0;											//因此只需要刷新该部分
}

file_open

打开 path 所在的文件，其实就是直接调用 walk_path

int
file_open(const char *path, struct File **pf)
{
	return walk_path(path, 0, pf, 0);
}

file_read

将 File 的数据中第 offset 个字节后 count 个字节存储到 buf 中

ssize_t
file_read(struct File *f, void *buf, size_t count, off_t offset)
{
	int r, bn;
	off_t pos;
	char *blk;

	if (offset >= f->f_size)
		return 0;

	count = MIN(count, f->f_size - offset);

	for (pos = offset; pos < offset + count; ) {
		// 获取 pos 所在的块
		// pos/BLKSIZE 可以得到需要读的数据在第几个块
		if ((r = file_get_block(f, pos / BLKSIZE, &blk)) < 0)		
			return r;
		// bn为当前块剩余全部字节，或读取count还未读完的字节
		bn = MIN(BLKSIZE - pos % BLKSIZE, offset + count - pos);	
		memmove(buf, blk + pos % BLKSIZE, bn);
		pos += bn;
		buf += bn;
	}

	return count;
}

file_write

int
file_write(struct File *f, const void *buf, size_t count, off_t offset)
{
	int r, bn;
	off_t pos;
	char *blk;

	// Extend file if necessary
	if (offset + count > f->f_size)						//如果文件不够大，扩展文件大小
		if ((r = file_set_size(f, offset + count)) < 0)
			return r;

	for (pos = offset; pos < offset + count; ) {
		if ((r = file_get_block(f, pos / BLKSIZE, &blk)) < 0)
			return r;
		bn = MIN(BLKSIZE - pos % BLKSIZE, offset + count - pos);
		memmove(blk + pos % BLKSIZE, buf, bn);
		pos += bn;
		buf += bn;
	}

	return count;
}

file_free_block

static int
file_free_block(struct File *f, uint32_t filebno)
{
	int r;
	uint32_t *ptr;

	if ((r = file_block_walk(f, filebno, &ptr, 0)) < 0)		//获取目标块所在的位置
		return r;
	if (*ptr) {
		free_block(*ptr);									//释放掉块
		*ptr = 0;
	}
	return 0;
}

static void file_truncate_blocks

将 File 的块数量调整到 newsize 大小

static void
file_truncate_blocks(struct File *f, off_t newsize)
{
	int r;
	uint32_t bno, old_nblocks, new_nblocks;

	old_nblocks = (f->f_size + BLKSIZE - 1) / BLKSIZE;
	new_nblocks = (newsize + BLKSIZE - 1) / BLKSIZE;
	for (bno = new_nblocks; bno < old_nblocks; bno++)
		if ((r = file_free_block(f, bno)) < 0)
			cprintf("warning: file_free_block: %e", r);

	if (new_nblocks <= NDIRECT && f->f_indirect) {
		free_block(f->f_indirect);
		f->f_indirect = 0;
	}
}

int file_set_size

设置 File f 的大小为 newsize

int
file_set_size(struct File *f, off_t newsize)
{
	if (f->f_size > newsize)
		file_truncate_blocks(f, newsize);
	f->f_size = newsize;
	flush_block(f);
	return 0;
}

void file_flush

刷新 f 中的所有块

void
file_flush(struct File *f)
{
	int i;
	uint32_t *pdiskbno;

	for (i = 0; i < (f->f_size + BLKSIZE - 1) / BLKSIZE; i++) {
		if (file_block_walk(f, i, &pdiskbno, 0) < 0 ||
		    pdiskbno == NULL || *pdiskbno == 0)
			continue;
		flush_block(diskaddr(*pdiskbno));
	}
	flush_block(f);			//刷新f所在的块
	if (f->f_indirect)
		flush_block(diskaddr(f->f_indirect));	//刷新f_indirect所在的块
}

void fs_sync(void)

刷新整个根目录

void
fs_sync(void)
{
	int i;
	for (i = 1; i < super->s_nblocks; i++)
		flush_block(diskaddr(i));
}

文件系统接口

jos 的文件系统是一个用户级进程，以 RPC 的形式，开放给客户端调用。

文件系统架构和文件客户端

文件系统提供 read 、 write 、 stat 等接口。这些接口可以对所有类型的文件进行操作，这些函数组成了文件操作的客户端。
如下图：

read 会根据文件的具体类型，调用不同的处理函数，其工作内容只是简单地将读取任务分发给 与文件描述符类型 对应的设备读取函数。（file 类型的设备读取函数是 devfile_read ， pipe 类型的设备读取函数是 devpipe_read ）如下图：

这些设备处理函数的操作方式基本相同：

1. 将上层接口函数（ read 、write 、 stat ）的形参，填写到请求专用的结构体中，
2. 然后将这个结构体作为参数调用 fsipc ，
3. fsipc 以 ipc 的形式，将 IPC 请求发送给 fs_server
4. fsipc 接收 fs_server 的处理结果，返回给设备处理函数。
   文件系统的相关调用的结构如下图所示：

      Regular env           FS env
   +---------------+   +---------------+
   |      read     |   |   file_read   |
   |   (lib/fd.c)  |   |   (fs/fs.c)   |
...|.......|.......|...|.......^.......|...............
   |       v       |   |       |       | RPC mechanism
   |  devfile_read |   |  serve_read   |
   |  (lib/file.c) |   |  (fs/serv.c)  |
   |       |       |   |       ^       |
   |       v       |   |       |       |
   |     fsipc     |   |     serve     |
   |  (lib/file.c) |   |  (fs/serv.c)  |
   |       |       |   |       ^       |
   |       v       |   |       |       |
   |   ipc_send    |   |   ipc_recv    |
   |       |       |   |       ^       |
   +-------|-------+   +-------|-------+
           |                   |
           +-------------------+

客户端函数 lab 直接提供了，没要求编写代码，但是。相关文件如下：

文件系统服务（练习5@fs/serv.c fs/fs.c）

文件系统的维护三种数据结构： struct File 、 struct Fd 、 struct OpenFile

struct File 的结构我们已经很熟悉了，struct File 会被映射到内存中，用于映射磁盘。

struct Fd 位于 /inc/fd.h ，对于每一个 jos 中打开了的文件，文件系统都会为它维护一个 struct Fd，从 FILEVA 0xD000_0000 开始的内存被用来存储 Fd ，定义如下：

struct FdFile {
	int id;
};

struct Fd {
	int fd_dev_id;    //设备类型
	off_t fd_offset;  //文件偏移
	int fd_omode;     //文件模式
	union {
		// File server files
		struct FdFile fd_file;
	};
};

struct OpenFile 将 struct File 和 struct Fd 关联起来。服务器维护一个打开所有文件的数组，通过 file ID 索引起来。客户端使用 file ID 来与服务器通信。 openfile_lookup 可以将文件的 ID 传递给 struct OpenFile

OpenFile 以全局数组的形式定义于 serv.c ，如下：

// Max number of open files in the file system at once
#define MAXOPEN		1024
#define FILEVA		0xD0000000

// initialize to force into data section
struct OpenFile opentab[MAXOPEN] = {
	{ 0, 0, 1, 0 }
};

void serv_init

文件系统在 serve_init从 FILEVA 0xD000_0000 开始的内存被用来存储为 Fd ，定义如下：

void
serve_init(void)
{
	int i;
	uintptr_t va = FILEVA;
	for (i = 0; i < MAXOPEN; i++) {
		opentab[i].o_fileid = i;
		opentab[i].o_fd = (struct Fd*) va;	//没有使用 fd_alloc ,而是直接分配空间
		va += PGSIZE;						//一个fd占用一页
	}
}

int openfile_alloc

serve_init 在初始化 opentab 的时候给每一个 struct OpenFile 的 Fd 成员分配地址，但这些地址可能还没有被分配物理页。
openfile_alloc 负责从 opentab 中申请一个空闲的 struct OpenFile ， 同时将对应的 Fd 初始化：

• 如果没有映射物理页，则先申请物理页。
• 将页面内容置零。

int
openfile_alloc(struct OpenFile **o)
{
	int i, r;

	// Find an available open-file table entry
	for (i = 0; i < MAXOPEN; i++) {
		switch (pageref(opentab[i].o_fd)) {
		case 0://如果这个页还没有映射，说明该 struct OpenFile 是空闲的，先申请物理页
			if ((r = sys_page_alloc(0, opentab[i].o_fd, PTE_P|PTE_U|PTE_W)) < 0)
				return r;
			/* fall through */
		case 1:
			opentab[i].o_fileid += MAXOPEN;
			*o = &opentab[i];
			memset(opentab[i].o_fd, 0, PGSIZE);		//整个内存页清零
			return (*o)->o_fileid;
		}
	}
	return -E_MAX_OPEN;
}

int openfile_lookup

获取 fileid 所指的 struct OpenFile

int
openfile_lookup(envid_t envid, uint32_t fileid, struct OpenFile **po)
{
	struct OpenFile *o;

	o = &opentab[fileid % MAXOPEN];
	if (pageref(o->o_fd) <= 1 || o->o_fileid != fileid)
		return -E_INVAL;
	*po = o;
	return 0;
}

int serve_read（练习 5）

根据 union Fsipc 的参数，读取指定文件的数据

int
serve_read(envid_t envid, union Fsipc *ipc)
{
	struct Fsreq_read *req = &ipc->read;
	struct Fsret_read *ret = &ipc->readRet;
	int r;
	if (debug)
		cprintf("serve_read %08x %08x %08x\n", envid, req->req_fileid, req->req_n);

	// Lab 5: Your code here:
	int fileid = req->req_fileid;
	int count = req->req_n;

	struct OpenFile * o;
	if((r = openfile_lookup(envid, fileid, &o))<0)
		return r;
	
	if((r = file_read(o->o_file, ret->ret_buf, count, o->o_fd->fd_offset))<0)
		return r;
	count = r;
	o->o_fd->fd_offset += count;
	return count;
}

int serve_write

int
serve_write(envid_t envid, struct Fsreq_write *req)
{
	if (debug)
		cprintf("serve_write %08x %08x %08x\n", envid, req->req_fileid, req->req_n);

	// LAB 5: Your code here.
	// panic("serve_write not implemented");
	int r;
	struct OpenFile * o;
	if((r = openfile_lookup(envid, o->o_fileid, &o)) < 0)
		return r;

	//调用 file_write 将 req 中所指 buf 的数据写入 File 的 offset 所指内存中
	if((r = file_write(o->o_file, req->req_buf, req->req_n, o->o_fd->fd_offset)) < 0)
		return r;

	o->o_fd->fd_offset += r;
	return r;
}

理解open的过程

open调用后，会从客户端的 fd_table 中取一个空闲槽 fd_table[n]，然后由文件系统的 serv_open 来分配物理页，同时文件西痛的地址空间中也会映射这个 fd 页面。

本栏目推荐文章
• 2024/1/13 算法笔记
• Python学习笔记
• HDP 笔记
• 学习进度笔记2
• 微软企业库Unity学习笔记(一)
• 微软企业库Unity学习笔记(二)
• kepware关于U-CON的使用笔记 (串口_非主动问答式)
• Anaconda使用笔记
• SHARPNESS-AWARE MINIMIZATION FOR EFFICIENTLY IMPROVING GENERALIZATION论文阅读笔记
• 【做题笔记】数论做题笔记

笔记 mit6 lab5 mit 828笔记mit6 lab5 mit mit6 lab2 mit 828 笔记mit6 lab3 mit 笔记mit6 1810 mit 笔记mit6 mit 081 笔记mit6 lab2 raft mit6 6.828 lab1 mit 828 mit6 2023 mit 081 mit6 mit 081 lec