ul_file.cpp

类似Linux操作系统0.11版文件系统的文件系统设计和Windows下的操作程序

/*
 * UNIX Like (UL)文件系统 File 处理模块
 */

#include "stdafx.h"
#include "UL_FileSys.h"
#include "UL_Buffer.h"
#include "UL_Super.h"
#include "UL_Inode.h"
#include "UL_NameI.h"
#include "UL_File.h"

struct file file_table[NR_FILE];	// 文件表数组(64 项)

struct file* current_filp[NR_FILE] = {0};

#define MIN(a,b) (((a)<(b))?(a):(b))	// 取a,b 中的最小值。
#define MAX(a,b) (((a)>(b))?(a):(b))	// 取a,b 中的最大值。

//// 文件读函数 - 根据i 节点和文件结构，读设备数据。
// 由i 节点可以知道设备号，由filp 结构可以知道文件中当前读写指针位置。buf 指定用户态中
// 缓冲区的位置，count 为需要读取的字节数。返回值是实际读取的字节数，或出错号(小于0)。
int file_read (struct m_inode *inode, struct file *filp, char *buf, int count)
{
	int left, chars, nr;
	struct buffer_head *bh;

	// 若需要读取的字节计数值小于等于零，则返回。
	if ((left = count) <= 0)
		return 0;
	// 若还需要读取的字节数不等于0，就循环执行以下操作，直到全部读出。
	while (left)
	{
		// 根据i 节点和文件表结构信息，取数据块文件当前读写位置在设备上对应的逻辑块号nr。若nr 不
		// 为0，则从i 节点指定的设备上读取该逻辑块，如果读操作失败则退出循环。若nr 为0，表示指定
		// 的数据块不存在，置缓冲块指针为NULL。
		if (nr = bmap (inode, (filp->f_pos) / BLOCK_SIZE))
		{
			if (!(bh = bread (inode->i_dev, nr)))
				break;
		}
		else
			bh = NULL;
		// 计算文件读写指针在数据块中的偏移值nr，则该块中可读字节数为(BLOCK_SIZE-nr)，然后与还需
		// 读取的字节数left 作比较，其中小值即为本次需读的字节数chars。若(BLOCK_SIZE-nr)大则说明
		// 该块是需要读取的最后一块数据，反之则还需要读取一块数据。
		nr = filp->f_pos % BLOCK_SIZE;
		chars = MIN (BLOCK_SIZE - nr, left);
		// 调整读写文件指针。指针前移此次将读取的字节数chars。剩余字节计数相应减去chars。
		filp->f_pos += chars;
		left -= chars;
		// 若从设备上读到了数据，则将p 指向读出数据块缓冲区中开始读取的位置，并且复制chars 字节
		// 到用户缓冲区buf 中。否则往用户缓冲区中填入chars 个0 值字节。
		if (bh)
		{
			char *p = nr + bh->b_data;
			while (chars-- > 0)
				put_byte (*(p++), buf++);
			brelse (bh);
		}
		else
		{
			while (chars-- > 0)
				put_byte (0, buf++);
		}
	}
	// 修改该i 节点的访问时间为当前时间。返回读取的字节数，若读取字节数为0，则返回出错号。
	inode->i_atime = CURRENT_TIME;
	return (count - left) ? (count - left) : -ERROR;
}

//// 文件写函数 - 根据i 节点和文件结构信息，将用户数据写入指定设备。
// 由i 节点可以知道设备号，由filp 结构可以知道文件中当前读写指针位置。buf 指定用户态中
// 缓冲区的位置，count 为需要写入的字节数。返回值是实际写入的字节数，或出错号(小于0)。
int file_write (struct m_inode *inode, struct file *filp, char *buf, int count)
{
	unsigned long pos;
	int block, c;
	struct buffer_head *bh;
	char *p;
	int i = 0;
	/*
	* ok，当许多进程同时写时，append 操作可能不行，但那又怎样。不管怎样那样做会
	* 导致混乱一团。
	*/
	// 如果是要向文件后添加数据，则将文件读写指针移到文件尾部。否则就将在文件读写指针处写入。
	if (filp->f_flags & O_APPEND)
		pos = inode->i_size;
	else
		pos = filp->f_pos;
	// 若已写入字节数i 小于需要写入的字节数count，则循环执行以下操作。
	while (i < count)
	{
		// 创建数据块号(pos/BLOCK_SIZE)在设备上对应的逻辑块，并返回在设备上的逻辑块号。如果逻辑
		// 块号=0，则表示创建失败，退出循环。
		if (!(block = create_block (inode, pos / BLOCK_SIZE)))
		{
			break;
		}
		// 根据该逻辑块号读取设备上的相应数据块，若出错则退出循环。
		if (!(bh = bread (inode->i_dev, block)))
			break;
		// 求出文件读写指针在数据块中的偏移值c，将p 指向读出数据块缓冲区中开始读取的位置。置该
		// 缓冲区已修改标志。
		c = pos % BLOCK_SIZE;
		p = c + bh->b_data;
		bh->b_dirt = 1;
		// 从开始读写位置到块末共可写入c=(BLOCK_SIZE-c)个字节。若c 大于剩余还需写入的字节数
		// (count-i)，则此次只需再写入c=(count-i)即可。
		c = BLOCK_SIZE - c;
		if (c > count - i)
			c = count - i;
		// 文件读写指针前移此次需写入的字节数。如果当前文件读写指针位置值超过了文件的大小，则
		// 修改i 节点中文件大小字段，并置i 节点已修改标志。
		pos += c;
		if (pos > inode->i_size)
		{
			inode->i_size = pos;
			inode->i_dirt = 1;
		}
		// 已写入字节计数累加此次写入的字节数c。从用户缓冲区buf 中复制c 个字节到高速缓冲区中p
		// 指向开始的位置处。然后释放该缓冲区。
		i += c;
		while (c-- > 0)
			*(p++) = get_byte (buf++);
		brelse (bh);
	}
	// 更改文件修改时间为当前时间。
	inode->i_mtime = CURRENT_TIME;
	// 如果此次操作不是在文件尾添加数据，则把文件读写指针调整到当前读写位置，并更改i 节点修改
	// 时间为当前时间。
	if (!(filp->f_flags & O_APPEND))
	{
		filp->f_pos = pos;
		inode->i_ctime = CURRENT_TIME;
	}
	// 返回写入的字节数，若写入字节数为0，则返回出错号-1。
	return (i ? i : -1);
}


//// 打开（或创建）文件
// 参数filename 是文件名，flag 是打开文件标志：只读O_RDONLY、只写O_WRONLY 或读写O_RDWR，
// 以及O_CREAT、O_EXCL、O_APPEND 等其它一些标志的组合，若本函数创建了一个新文件，则mode
// 用于指定使用文件的许可属性，这些属性有S_IRWXU(文件宿主具有读、写和执行权限)、S_IRUSR
// (用户具有读文件权限)、S_IRWXG(组成员具有读、写和执行权限)等等。对于新创建的文件，这些
// 属性只应用于将来对文件的访问，创建了只读文件的打开调用也将返回一个可读写的文件句柄。
// 若操作成功则返回文件句柄(文件描述符)，否则返回出错码
int UL_open (const char *filename, int flag, int mode)
{
	struct m_inode *inode;
	struct file *f;
	int i, fd;
	
	// 搜索进程结构中文件结构指针数组，查找一个空闲项，若已经没有空闲项，则返回出错码。
	for (fd = 0; fd < NR_OPEN; fd++)
		if (!current_filp[fd])
			break;

	if (fd >= NR_OPEN)
		return -EINVAL;

	// 令f 指向文件表数组开始处。搜索空闲文件结构项(句柄引用计数为0 的项)，若已经没有空闲
	// 文件表结构项，则返回出错码。
	f = 0 + file_table;
	for (i = 0; i < NR_FILE; i++, f++)
		if (!f->f_count)
			break;
	if (i >= NR_FILE)
		return -EINVAL;

	// 让进程的对应文件句柄的文件结构指针指向搜索到的文件结构，并令句柄引用计数递增1。
	(current_filp[fd] = f)->f_count++;

	// 调用函数执行打开操作，若返回值小于0，则说明出错，释放刚申请到的文件结构，返回出错码。
	if ((i = open_namei (filename, flag, mode, &inode)) < 0)
	{
		current_filp[fd] = NULL;
		f->f_count = 0;
		return i;
	}

	// 初始化文件结构。置文件结构属性和标志，置句柄引用计数为1，设置i 节点字段，文件读写指针
	// 初始化为0。返回文件句柄。
	f->f_mode = inode->i_mode;
	f->f_flags = flag;
	f->f_count = 1;
	f->f_inode = inode;
	f->f_pos = 0;
	return (fd);
}

//// 创建文件
// 参数pathname 是路径名，mode 与上面的sys_open()函数相同。
// 成功则返回文件句柄，否则返回出错码。
int UL_creat (const char *pathname, int mode)
{
	return UL_open (pathname, O_CREAT | O_TRUNC, mode);
}

// 从文件系统删除一个名字。如果是一个文件的最后一个连接，并且没有进程正打开该文件，则该文件
// 也将被删除，并释放所占用的设备空间。
// 参数：name - 文件名。
// 返回：成功则返回0，否则返回出错号。
int UL_delete (const char *name)
{
	const char *basename;
	int namelen;
	struct m_inode *dir, *inode;
	struct buffer_head *bh;
	struct dir_entry *de;

	// 如果找不到对应路径名目录的i 节点，则返回出错码。
	if (!(dir = dir_namei (name, &namelen, &basename)))
		return -ENOENT;
	// 如果最顶端的文件名长度为0，则说明给出的路径名最后没有指定文件名，释放该目录i 节点，返回
	// 出错码，退出。
	if (!namelen)
	{
		iput (dir);
		return -ENOENT;
	}
	/*
	// 如果在该目录中没有写的权限，则释放该目录的i 节点，返回访问许可出错码，退出。
	if (!permission (dir, MAY_WRITE))
	{
		iput (dir);
		return -EPERM;
	}
	*/
	// 如果对应路径名上最后的文件名的目录项不存在，则释放包含该目录项的高速缓冲区，释放目录
	// 的i 节点，返回文件已经存在出错码，退出。否则dir 是包含要被删除目录名的目录i 节点，de
	// 是要被删除目录的目录项结构。