16281005操作系统第五次作业

实验五文件系统

1、实验简介

本实验要求在模拟的I/O系统之上开发一个简单的文件系统。用户通过create, open, read等命令与文件系统交互。文件系统把磁盘视为顺序编号的逻辑块序列，逻辑块的编号为0至L − 1。I/O系统利用内存中的数组模拟磁盘。

2、I/O系统

实际物理磁盘的结构是多维的：有柱面、磁头、扇区等概念。I/O系统的任务是隐藏磁盘的结构细节，把磁盘以逻辑块的面目呈现给文件系统。逻辑块顺序编号，编号取值范围为0至L−1，其中L表示磁盘的存储块总数。实验中，我们可以利用数组ldisk[C][H][B]构建磁盘模型，其中CHB 分别表示柱面号，磁头号和扇区号。每个扇区大小为512字节。I/O系统从文件系统接收命令，根据命令指定的逻辑块号把磁盘块的内容读入命令指定的内存区域，或者把命令指定的内存区域内容写入磁盘块。文件系统和I/O系统之间的接口由如下两个函数定义：
• read_block(int i, char *p);
该函数把逻辑块i的内容读入到指针p指向的内存位置，拷贝的字符个数为存储块的长度B。
• write block(int i, char *p);
该函数把指针p指向的内容写入逻辑块i，拷贝的字符个数为存储块的长度B。此外，为了方便测试，我们还需要实现另外两个函数：一个用来把数组ldisk 存储到文件；另一个用来把文件内容恢复到数组。

3、文件系统

文件系统位于I/O系统之上。

3.1用户与文件系统之间的接口

文件系统需提供如下函数；create, destroy, open, read, write。

• create(filename): 根据指定的文件名创建新文件。
• destroy(filename): 删除指定文件。
• open(filename): 打开文件。该函数返回的索引号可用于后续的read, write, lseek,或close操作。
• close(index): 关闭制定文件。
• read(index, mem_area, count): 从指定文件顺序读入count个字节memarea指定的内存位置。读操作从文件的读写指针指示的位置开始。
• write(index, mem_area, count): 把memarea指定的内存位置开始的count个字节顺序写入指定文件。写操作从文件的读写指针指示的位置开始。
• lseek(index, pos): 把文件的读写指针移动到pos指定的位置。pos是一个整数，表示从文件开始位置的偏移量。文件打开时，读写指针自动设置为0。每次读写操作之后，它指向最后被访问的字节的下一个位置。lseek能够在不进行读写操作的情况下改变读写指针能位置。
• directory: 列表显示所有文件及其长度。

3.2 文件系统的组织

磁盘的前k个块是保留区，其中包含如下信息：位图和文件描述符。位图用来描述磁盘块的分配情况。位图中的每一位对应一个逻辑块。创建或者删除文件，以及文件的长度发生变化时，文件系统都需要进行位图操作。前k个块的剩余部分包含一组文件描述符。每个文件描述符包含如下信息：
• 文件长度，单位字节
• 文件分配到的磁盘块号数组。该数组的长度是一个系统参数。在实验中我们可以把它设置为一个比较小的数，例如3。

3.3 目录

我们的文件系统中仅设置一个目录，该目录包含文件系统中的所有文件。除了不需要显示地创建和删除之外，目录在很多方面和普通文件相像。目录对应0号文件描述符。初始状态下，目录中没有文件，所有，目录对应的描述符中记录的长度应为0，而且也没有分配磁盘块。每创建一个文件，目录文件的长度便增加一分。目录文件的内容由一系列的目录项组成，其中每个目录项由如下内容组成：
• 文件名
• 文件描述符序号

3.4 文件的创建与删除

创建文件时需要进行如下操作；
• 找一个空闲文件描述符(扫描ldisk [0]～ldisk [k - 1])
• 在文件目录里为新创建的文件分配一个目录项（可能需要为目录文件分配新的磁盘块）
• 在分配到的目录项里记录文件名及描述符编号．
• 返回状态信息（如有无错误发生等）

删除文件时需要进行如下操作（假设文件没有被打开）：
• 在目录里搜索该文件的描述符编号
• 删除该文件对应的目录项并更新位图
• 释放文件描述符
• 返回状态信息

3.5 文件的打开与关闭

文件系统维护一张打开文件表．打开文件表的长度固定，其表目包含如下信息：
• 读写缓冲区
• 读写指针
• 文件描述符号
文件被打开时，便在打开文件表中为其分配一个表目；文件被关闭时，其对应的表目被释放。读写缓冲区的大小等于一个磁盘存储块。打开文件时需要进行的操作如下：
• 搜索目录找到文件对应的描述符编号
• 在打开文件表中分配一个表目
• 在分配到的表目中把读写指针置为０，并记录描述符编号
• 读入文件的第一块到读写缓冲区中
• 返回分配到的表目在打开文件表中的索引号
关闭文件时需要进行的操作如下：
• 把缓冲区的内容写入磁盘
• 释放该文件在打开文件表中对应的表目
• 返回状态信息

3.6 读写

文件打开之后才能进行读写操作．读操作需要完成的任务如下：

1. 计算读写指针对应的位置在读写缓冲区中的偏移
2. 把缓冲区中的内容拷贝到指定的内存位置，直到发生下列事件之一：
   • 到达文件尾或者已经拷贝了指定的字节数。这时，更新读写指针并返回相应信息
   • 到达缓冲区末尾。这时，把缓冲区内容写入磁盘，然后把文件下一块的内容读入磁盘。最后返回第2步。

4、实验分析

4.1、数据结构

实验中，利用数组ldisk[C][H][B]构建磁盘模型，其中CHB分别表示柱面号、磁头号和扇区号。
当每个扇区大小为512B，且CHB分别为2、80和18时，一共占用空间大小为：

即相当于1.44MB大小的软盘空间。

4.2、系统结构

系统结构如下图所示。可见系统的框架可以分为两部分，一部分是文件系统，另一部分是I/O系统。系统通过外壳程序与系统用户进行交互，接受用户命令或者反馈操作的结果，通过相应的命令对文件系统进行操作。文件系统再进而通过I/O系统对模拟磁盘进行读写操作。

5、代码设计

5.1、文件操作

根据实验题目要求，将文件操作的过程实现如下：

5.1.1数据结构

首先将表征文件的数据结构展示如下：

typedef struct files
{
	//文件编号
    int number;
	//文件名
    char *filename;
	//文件大小
    int size;
	//文件偏移指针
    int pos;
	//3个直接地址
    INDIRECT *addr[3];
	//存放文件中的所有内容
    char *content;
}FILES;

其中，INDIRECT记录地址项，用于存储磁盘的逻辑扇区号。

5.1.2 文件创建

在这里插入代码片int create(char *filename)
{
    DIC *dic = dicHead;
    int flag = 0;
    for(int i = 0; i < countOfFiles; i ++)
    {
        if(strcmp(dic->filename, filename) == 0)
        {
            flag = 1;
            break;
        }
        dic = dic->next;
    }
    if(flag == 1)
    {
        printf("文件名已存在!\n");
        return NULL;
    }
    int a = M;
    int start = K;
    int size = L - K;
    countOfFiles ++;
    // 生成随机数
    int blockNumber = createRandomNUmber(start, size);
    // 查询位图
    while(map[blockNumber / a][blockNumber % a] == 1)
	{
        blockNumber = createRandomNUmber(start, size);
	}
    // 置位图为1
    map[blockNumber / a][blockNumber % a] = 1;
    // 建立目录
    createDirectory(filename, blockNumber);
	printf("成功创建!\n"); 
	return 0;
}

5.1.3 文件删除

int destroy(char *filename)
{
    DIC *dic = dicHead;

    int flag = 0;
    for(int i = 0; i < countOfFiles; i ++)
    {
        if(strcmp(dic->filename, filename) == 0)
        {
            flag = 1;
            break;
        }

        dic = dic->next;
    }

    if(flag == 0)
    {
        printf("文件不存在!\n");
        return -1;
    }

    //删除文件
    int blockNumber = dic->index1->size / SIZE;
    
	if(dic->index1->size % SIZE > 0)
	{
        blockNumber ++;
	}
    //删除所有块里的元素
    for(i = 0; i < blockNumber; i ++)
    {
        write_block(dic->index1->addr[i]->diskNum, "\0");
    }
    //删除目录
    destoryDirectory(filename);
    
	countOfFiles --;

	printf("成功删除!\n");

    return 0;
}

5.1.4 文件打开

FILES *open(char *filename)
{
    DIC *dic = dicHead;
	// 缓冲区
    char buffer[512] = ""; 
    
	int flag = 0;
    
	for(int i = 0; i < countOfFiles; i ++)
    {
        if(strcmp(dic->filename, filename) == 0)
        {
            flag = 1;
            break;
        }

        dic = dic->next;
    }

    if(flag == 0)
    {
        printf("文件不存在!\n");
        return NULL;
    }

	// 打开文件
    FILES *file = NULL;
    
	file = (FILES *)malloc(sizeof(FILES));
    
	file->number = dic->index1->number;
    
	for(i = 0; i < 3; i ++)
	{
        file->addr[i] = (INDIRECT *)malloc(sizeof(INDIRECT));
	}
    for(i = 0; i < 3; i ++)
	{
        memcpy(file->addr[i], dic->index1->addr[i], sizeof(INDIRECT));
	}
    file->size = dic->index1->size;
    
	file->filename = (char *)malloc(strlen(filename) * sizeof(char));
    
	memcpy(file->filename, filename, strlen(filename));
    
	file->pos = 0;
    
	//将磁盘中的内容读到file中   
	int block = file->size / SIZE;
    
	int offset = file->size % SIZE;
    
	file->content = (char *)malloc(file->size * sizeof(char));
    
	if(offset > 0)
	{
        block ++;
    }
	for(i = 0; i < block; i ++)
    {
        read_block(dic->index1->addr[i]->diskNum, buffer);
        
		strcpy(&file->content[i * SIZE], buffer);
    }

    return file;
}

5.1.5 文件关闭

int close(FILES *file)
{
    for(int i = 0; i < 3; i ++)
        free(file->addr[i]);
    for(i = 0; i < 3; i ++)
        file->addr[i] = NULL;
    //释放文件名
    if(file->filename != NULL)
    {
        free(file->filename);
        
		file->filename = NULL;
    }
    //释放文件内容
    if(file->content != NULL)
    {
        free(file->content);
        
		file->content = NULL;
    }
    //释放file指针
    free(file);
    
	printf("成功关闭!\n");
    
	return 0;
}

5.1.6 文件读

FILES *read(FILES *file, char *mem_area, int count)
{
    char buffer[512] = ""; //缓冲区
    
	if((count + file->pos) > file->size)
        return NULL; //越界错误
    
	int a = count / SIZE;
    
	for(int i = 0; i < a; i ++)
    {
        memcpy(buffer, &file->content[file->pos + i * SIZE], SIZE * sizeof(char));
        strcpy(&mem_area[i * SIZE], buffer);
    }
    
	memcpy(buffer, &file->content[file->pos + a * SIZE], (count % SIZE) * sizeof(char));
    
	strcpy(&mem_area[a * SIZE], buffer);
    
	file->pos = file->pos + count;
    
	printf("成功读入!\n");
    return file;
}

5.1.7 文件写

FILES *write (FILES *file, char *mem_area, int count)
{
    DIC *dic = dicHead;
    
	char *buffer = NULL; //缓冲区
    
	buffer = (char *)malloc(SIZE * sizeof(char));
    
	if(file->pos + count > 3 * SIZE)
        return NULL; //越界

    //清除原先磁盘扇区中的数据
    int m = M;
    
	int blocknumber = file->size / SIZE;
   
	if((file->size % SIZE) > 0)
	{
        blocknumber ++;
    }
	for(int i = 0; i < blocknumber; i ++)
	{
        strcpy(disk[file->addr[i]->diskNum].content, "\0");
    }
	for(i = 1; i < blocknumber; i ++)
	{
        //改位图
        map[file->addr[i]->diskNum / m][file->addr[i]->diskNum % m] = 0;
    }
	//找到目录
    for(i = 0; i < countOfFiles; i ++)
    {
        if(dic->index1->number == file->number)
            break;
        dic = dic->next;
    }
    //更改目录中的内容
    for(i = 1; i < blocknumber; i ++)
        dic->index1->addr[i]->diskNum= 0;
    for(i = 0; i < 3; i ++)
        dic->index1->addr[i]->count = 0;
    for(i = 1; i < 3; i ++)
        dic->index1->addr[i]->diskNum = -1;
    //更改file指针中文件的内容
    file->size = file->pos + count;
    //重新分配空间
    char *s;
    
	s = (char *)malloc(strlen(file->content) *sizeof(char));
    
	memcpy(s, file->content, strlen(file->content) *sizeof(char));
    
	file->content = (char *)realloc(file->content, file->size * sizeof(char));
    
	memcpy(file->content, s, sizeof(file->pos) *sizeof(char));
    	
	memcpy(&file->content[file->pos], mem_area, count * sizeof(char));
    
	//将file中的内容通过buffer写入磁盘
    blocknumber = file->size / SIZE;
    
	if(file->size % SIZE > 0)
        blocknumber ++;
    //生成随机的磁盘扇区块
    int start = K;
    
	int size = L - K;
    
	for(i = 1; i < blocknumber; i ++)
    {
        file->addr[i]->diskNum = createRandomNUmber(start, size);
        
		while(map[file->addr[i]->diskNum / m][file->addr[i]->diskNum % m] != 0)
            file->addr[i]->diskNum = createRandomNUmber(start, size);
    }
    //从buffer中写入扇区
    for(i = 0; i < blocknumber - 1; i ++)
    {
        //存入缓冲区
        memcpy(buffer, &file->content[i * SIZE], (SIZE) * sizeof(char));
        //缓冲区存入磁盘
        write_block(file->addr[i]->diskNum, buffer);
    }
    if(count % SIZE > 0)
    {
        strcpy(buffer, &file->content[(blocknumber - 1) * SIZE]);
        write_block(file->addr[blocknumber - 1]->diskNum, buffer);
    }
    else if(count % SIZE == 0)
    {
        memcpy(buffer, &file->content[(blocknumber - 1) * SIZE], SIZE * sizeof(char));
        write_block(file->addr[blocknumber - 1]->diskNum, buffer);
    }
    for(i = 0; i < blocknumber - 1; i ++)
	{
        file->addr[i]->count = SIZE;
    }
	if(file->size == SIZE)
	{
        file->addr[blocknumber - 1]->count = file->size;
    }
	else
	{
        file->addr[blocknumber - 1]->count = file->size % SIZE;
    }
	//写回目录
    for(i = 0; i < 3; i ++)
	{
        memcpy(dic->index1->addr[i], file->addr[i], sizeof(INDIRECT));
    }
	dic->index1->size = file->size;
    
	file->pos = file->size;
    
	printf("成功写入!\n");
    
	free(buffer);
    
	return file;
}

5.2磁盘I/O操作

5.2.1 数据结构

磁盘的数据结构实现如题目要求：

typedef struct ldisk
{	
	//柱面
    int C; 
    //磁头
	int H; 
    //扇区
	int B; 
	//扇区中的内容
    char content[SIZE + 1]; 

}LDISK;

5.2.2 初始化磁盘序列

int initDisk()
{
    int m = M;
    int n = N;
    //初始化磁盘
    disk = (LDISK *)malloc(L * sizeof(LDISK));
    //申请位图空间
    map = (int **)malloc(m * sizeof(int *));
    for(int i = 0; i < m; i ++)
        map[i] = (int *)malloc(n * sizeof(int));
    //初始化位图
    for(i = 0; i < m; i ++)
    {
        for(int j = 0; j < n; j ++)
        {
            map[i][j] = 0;
        }
    }
    //将位图写入磁盘
    char map_char[M][N];

    for(i = 0; i < m; i ++)
    {
        for(int j = 0; j < n; j ++)
        {
            map_char[i][j] = (char) (map[i][j] + '0');
        }
    }

    int sizeOfMap = m * n * sizeof(char);

    if(sizeOfMap % SIZE > 0)
        blockOfMap = sizeOfMap / SIZE + 1;
    else
        blockOfMap = sizeOfMap / SIZE;

    int d = 0;
    int c = 0;
    for(int a = 0; a < m; a ++)
    {
        for(int b = 0; b < m; b ++)
        {
            strcpy(&disk[d].content[c], &map_char[a][b]);
            c ++;
            if(c == SIZE - 1)
            {
                d ++;
                c = 0;
            }
        }
    }
    return 0;
}

5.2.3 磁盘写

int write_block(int i, char *p)
{
    int y = i / sectorsPerTrack;
    //扇区号
    disk[i].B = i % sectorsPerTrack + 1;
    //柱面号
    disk[i].C = y >> 1;
    //磁头号
    disk[i].H = y & 1;
    strcpy(disk[i].content, p);
    return 0;
}

5.2.4 磁盘读

int read_block(int i, char *p)
{
    int y = i / sectorsPerTrack;
    //扇区号
    disk[i].B = i % sectorsPerTrack + 1;
    //柱面号
    disk[i].C = y >> 1;
    //磁头号
    disk[i].H = y & 1;
    strcpy(p, disk[i].content);
    return 0;
}

5.3 内存分配过程实现

根据题目要求内容，将分配过程实现如下：

// return the times of finding a block
int memApply(int algorithmID, int size){

	int allocAdd;

	// choose the algorithm
	switch(algorithmID){
	
	case 1:

		allocAdd = firstFit(size);

		break;

	case 2:

		allocAdd = nextFit(size);
		
		break;

	case 3:

		allocAdd = bestFit(size);

		// reset the list
		bestHead->next = NULL;

		break;

	case 4:

		allocAdd = worstFit(size);

		// reset the list
		worstHead->next = NULL;

		break;
	}

	//  means that the algorithm cannot alloc a memnry for a block
	if (allocAdd == -1){

		printf("Memory apply failed! The required size: %d is too big!\n", size);

		return -1;
	}
	else{

		// malloc a new block
		AllocBlock *allocBlock;

		allocBlock = (AllocBlock *)malloc(sizeof(AllocBlock));

		allocBlock->startAdd = allocAdd;

		allocBlock->size = size;

		// find a place to insert
		AllocBlock *index = allocBlockHead;

		while(index->next != NULL && index->next->startAdd < allocAdd){
			
			index = index->next;
		}

		// insert
		allocBlock->next = index->next;

		index->next = allocBlock;

		return COUNT;
	}	
}

6、实验结果

将实验系统展示如下，其中图3展示的是文件的创建和删除操作，下图展示的是文件的打开文件的写入文件的读取文件的关闭一系列操作。

7、实验体会

通过上述实验内容，我对文件管理的整体流程有了更加清晰和深刻的认识，然而受于实验时间的限制，很多功能只是简单的完成，且不支持文件内容写入到本地，即第二次运行程序时，无法打开之前所创建的文件和写入的内容，所以只是一个不完备的文件管理系统，希望以后有时间且有精力的时候，可以实现一个更贴近实际的文件管理系统。

githup源码链接.