简单文件系统的实现
实现一个简单的文件系统
实现一个简单的文件系统一个简单的文件系统是指一个用于管理文件和文件夹的系统，可以进行基本的文件和文件夹的创建、删除、重命名、查找、打开、关闭等操作。
以下是一个简单文件系统的实现，主要包括文件和文件夹的数据结构和相关操作。
1.数据结构：- 文件(File)：包含文件名、文件内容、创建时间、修改时间等属性。
- 文件夹(Folder)：包含文件夹名、文件夹路径、创建时间、修改时间等属性，以及包括的文件和文件夹列表。
2.操作：-创建文件夹：可以根据输入的文件夹名和路径，在对应的位置创建一个新的文件夹对象，并将其添加到上级文件夹的文件夹列表中。
-创建文件：可以根据输入的文件名和路径，在对应的位置创建一个新的文件对象，并将其添加到对应的文件夹的文件列表中。
-删除文件夹：可以根据输入的文件夹名和路径，将对应的文件夹对象从上级文件夹的文件夹列表中删除，并删除其包含的所有文件和文件夹。
-删除文件：可以根据输入的文件名和路径，将对应的文件对象从所在文件夹的文件列表中删除。
-重命名文件夹：可以根据输入的原文件夹名和路径以及新文件夹名，将对应的文件夹对象重命名。
-重命名文件：可以根据输入的原文件名和路径以及新文件名，将对应的文件对象重命名。
-查找文件夹/文件：可以根据输入的文件夹名和路径，查找对应的文件夹对象。
-打开文件：可以根据输入的文件名和路径，打开对应的文件对象，并显示其内容。
-关闭文件：可以关闭当前打开的文件。
3.实现：- 定义一个文件夹类(Folder)，包含文件夹名、文件夹路径、创建时间、修改时间等属性，以及一个存储文件夹对象的列表。
- 定义一个文件类(File)，包含文件名、文件内容、创建时间、修改时间等属性。
- 实现创建文件夹的方法(createFolder)，在对应的位置创建一个新的文件夹对象，并将其添加到上级文件夹的文件夹列表中。
- 实现创建文件的方法(createFile)，在对应的位置创建一个新的文件对象，并将其添加到对应的文件夹的文件列表中。
操作系统课程设计-一个简单的文件系统的详细设计
计算机系课程设计实验报告课程名称操作系统课程设计实验学期 2012 至 2013 学年第 1 学期学生所在系部计算机与信息管理系年级 2010 专业班级计算机001班学生姓名学号任课教师实验成绩计算机系制一个简单的文件系统的详细设计一、实验目的（1）阅读并调试一个简单的文件系统，模拟文件管理的工作过程。
从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。
（2）了解设计一个n个用户的文件系统，每个用户可以保存M个文件。
用户在一次运行中只能打开一个文件，对文件必须设置保护措施，且至少有create、delete、open、close、read、write等命令。
二、实验要求1、阅读所给文件系统源程序，并加注释（注释量达60%），2、修改、完善该系统，画出所设计的文件系统的详细流程图。
三、文件系统功能设计1. 功能设计该文件系统是一个多用户、多任务的文件系统。
对用户和用户的文件数目并没有上限。
也就是说该系统允许任何用户申请空间，而且在其目录下的文件数目并不做任何的限制。
该系统可以支持的操作命令如下：①bye——用户注销命令。
当使用该命令时，用户退出系统，注销该用户功能设计并回到登陆界面。
命令格式：bye②close——删除用户注册信息命令。
执行该命令后，用户在系统中的所有信息，包括该用户目录下的所有文件都被删除。
命令执行完成后返回登陆界面。
命令格式：close③create——在当前目录下创建一个文件，且该文件不能跟当前已有的文件重名。
该文件的管理信息登记在用户文件信息管理模块中。
执行完该命令后回到执行命令行。
命令格式：create>file1其中：“>”符为提示符，file1为要创建的文件名。
④delete——删除当前用户目录下的一个文件，命令执行完毕返回至命令行。
命令格式：delete>file1其中：file1为要删除的文件名。
⑤list——显示当前注册目录下的所有文件信息，包括文件名、文件长度、文件操作权限。
怎样写一个简单的操作系统
怎样写一个简单的操作系统写一个简单的操作系统需要涉及到多个层面的知识和技能，包括计算机体系结构、汇编语言、系统编程、驱动程序开发等等。
由于篇幅限制，下面我将以几个主要步骤简要介绍一个简单的操作系统的开发过程。
1.设计操作系统的结构和功能首先，你需要明确你的操作系统要实现的功能和为哪种类型的硬件系统提供服务。
然后，你可以设计出操作系统的基本结构和模块，例如核心内核、文件系统、进程管理和用户界面等。
2.学习汇编语言和体系结构计算机操作系统的底层是依托机器语言编写的，所以你需要了解机器的体系结构并学习汇编语言编程。
汇编语言是一种直接操作硬件的语言，理解它将有助于你编写底层驱动和实现系统调用等操作系统的核心功能。
3.编写启动代码和引导扇区操作系统运行时需要加载到计算机的内存中，所以你需要编写一个引导扇区代码来启动和加载操作系统。
引导扇区是计算机启动时加载的第一个扇区，它的任务是读取操作系统的其他部分并将其加载到内存中。
4.实现内核功能在操作系统的内核中，你需要实现一些核心功能，如中断处理、进程管理、内存管理、文件系统等。
对于每个模块，你需要编写对应的代码，并确保它们能够相互协调工作。
5.开发驱动程序驱动程序是操作系统与硬件之间的桥梁，它们负责管理和控制硬件设备的工作。
你需要了解硬件的特性和接口规范，并编写对应的驱动程序来支持所需硬件设备。
6.编写用户界面和应用程序7.测试和调试在完成操作系统的开发后，你需要对其进行测试和调试，确保系统的稳定性和性能。
你可以编写一些测试用例来验证系统的功能，并对可能出现的错误进行调试和修复。
需要注意的是，编写一个完整和稳定的操作系统是一个庞大的工程，仅用1200字无法详尽地讲述所有的细节。
以上只是一个简要的介绍，如果你对操作系统开发感兴趣，建议你深入学习相关领域的知识，并参考相关书籍和教程进行进一步的学习和实践。
OSUNIT 文件系统的实现
件都需要在该目录中
进行线性检索。 单级目录结构的特点是实现简单，但当目录中含有大量目录项时，要查找一个文件相当费
时，且它无法解决文件重名问题，这对用户是很不方便的。因此，这种目录结构只用在单用户 环境中。
文件的物理组织 文件目录的结构 文件的共享 磁盘空间的管理 文件的访问控制 文件系统的注册与挂载 内核的文件管理机制
§1 文件的物理组织
◆连续结构 ◆链接结构 ◆索引结构
一个文件的空间在逻辑上可看成是连续的，即一个文件由若干连续的盘块所组成。但在磁 盘上可以有多种方式来组成一个文件，换言之，文件有多种物理的存储结构，常用的是：连 续结构、链接结构、索引结构。
USER2的UFD
…
… 图9-6 二级目录结构
普通文件 … …
一个MFD和若干并列的UFD便构成了二级目录结构。当要访问一个文件时，先根据用户名 检索MFD，找出相应的UFD；再用文件名检索UFD，找出对应的FCB，从而就可以得到文件 的具体物理地址。
二级目录结构基本上克服了单目录结构的缺点，其优点如下：
一个目录由若干等长的目录项（记录）组成，目录本身也作为文件来处理，它是一种等长 记录式文件。
目录项的组成有两种方式：FCB目录项和名号目录项。
1. FCB目录项 这是简单直观的目录项组成方式，目录项就是FCB，即一个目录由若干顺序排列的FCB所
构成。当用路径名和文件名访问某个文件时，文件系统对目录进行线性检索，找到文件名对 应的FCB，就可获取该文件的物理位置等信息，完成文件名到文件物理位置的映射。
文件的物理存储结构决定了文件的逻辑地址空间到文件的物理地址空间的映射方法。
华科操作系统实验报告
华科操作系统实验报告一、实验目的操作系统是计算机系统的核心组成部分，对于理解计算机的工作原理和提高计算机应用能力具有重要意义。
本次华科操作系统实验的主要目的是通过实际操作和实践，深入理解操作系统的基本概念、原理和功能，掌握操作系统的核心技术和应用方法，提高我们的实践能力和问题解决能力。
二、实验环境本次实验使用的操作系统为Windows 10 和Linux（Ubuntu 2004），开发工具包括 Visual Studio Code、GCC 编译器等。
实验硬件环境为个人计算机，配置为英特尔酷睿 i7 处理器、16GB 内存、512GB 固态硬盘。
三、实验内容1、进程管理进程创建与销毁进程调度算法模拟进程同步与互斥2、内存管理内存分配与回收算法实现虚拟内存管理3、文件系统文件操作与管理文件系统的实现与优化4、设备管理设备驱动程序编写设备分配与回收四、实验步骤及结果1、进程管理实验进程创建与销毁首先，使用 C 语言编写程序，通过系统调用创建新的进程。
在程序中，使用 fork(）函数创建子进程，并在子进程和父进程中分别输出不同的信息，以验证进程的创建和执行。
实验结果表明，子进程和父进程能够独立运行，并输出相应的信息。
进程调度算法模拟实现了先来先服务（FCFS）、短作业优先（SJF）和时间片轮转（RR）三种进程调度算法。
通过模拟多个进程的到达时间、服务时间和优先级等参数，计算不同调度算法下的平均周转时间和平均等待时间。
实验结果显示，SJF 算法在平均周转时间和平均等待时间方面表现较好，而 RR 算法能够提供较好的响应时间和公平性。
进程同步与互斥使用信号量和互斥锁实现了进程的同步与互斥。
编写了生产者消费者问题的程序，通过信号量控制生产者和消费者对缓冲区的访问，避免了数据竞争和不一致的情况。
实验结果表明，信号量和互斥锁能够有效地实现进程间的同步与互斥，保证程序的正确性。
2、内存管理实验内存分配与回收算法实现实现了首次适应（First Fit）、最佳适应（Best Fit）和最坏适应（Worst Fit）三种内存分配算法。
如何实现一个文件系统
如何实现一个文件系统本文作者：康华：计算机硕士，主要从事Linux操作系统内核、Linux技术标准、计算机安全、软件测试等领域的研究与开发工作，现就职于信息产业部软件与集成电路促进中心所属的MII-HP Linux软件实验室。
如果需要可以联系通过kanghua151@联系他。
摘要：本文目的是分析在Linux系统中如何实现新的文件系统。
在介绍文件系统具体实现前先介绍文件系统的概念和作用，抽象出了文件系统概念模型。
熟悉文件系统的内涵后，我们再近一步讨论Linux系统中和文件系统的特殊风格和具体文件系统在Linux中组成结构，为读者勾画出Linux中文件系统工作的全景图。
最后，我们再通过Linux中最简单的Romfs 作实例分析实现文件系统的普遍步骤。
（我们假定读者已经对Linux文件系统初步了解）什么是文件系统首先要谈的概念就是什么是文件系统，它的作用到底是什么。
文件系统的概念虽然许多人都认为是再清晰不过的了，但其实我们往往在谈论中或多或少地夸大或片缩小了它的实际概念（至少我时常混淆），或者说，有时借用了其它概念，有时说的又不够全面。
比如在操作系统中，文件系统这个术语往往既被用来描述磁盘中的物理布局，比如有时我们说磁盘中的“文件系统”是EXT2或说把磁盘格式化成FAT32格式的“文件系统”等——这时所说的“文件系统”是指磁盘数据的物理布局格式；另外，文件系统也被用来描述内核中的逻辑文件结构，比如有时说的“文件系统”的接口或内核支持Ext2等“文件系统”——这时所说的文件系统都是内存中的数据组织结构而并非磁盘物理布局。
还有些时候说“文件系统”负责管理用户读写文件——这时所说的“文件系统”往往描述操作系统中的“文件管理系统”，也就是文件子系统。
虽然上面我们列举了混用文件系统的概念的几种情形，但是却也不能说上述说法就是错误的，因为文件系统概念本身就囊括众多概念，几乎可以说在操作系统中自内存管理、系统调度到I/O系统、设备驱动等各个部分都和文件系统联系密切，有些部分和文件系统甚至未必能明确划分——所以不能只知道文件系统是系统中数据的存储结构，一定要全面认识文件系统在操作系统中的角色，才能具备自己开发新文件系统的能力。
简单文件系统的实现实验报告
操作系统课程设计报告简单文件系统的实现专业：班级：姓名：学号：老师：一、课程设计的目的1. 通过具体的文件存储空间的管理、文件的物理结构、目录结构和文件操作的实现，加深对文件系统内部数据结构、功能以及实现过程的理解。
二、课程设计要求1. 在内存中开辟一个虚拟磁盘空间作为文件存储分区，在其上实现一个简单的基于多级目录的单用户单任务系统中的文件系统。
在退出该文件系统的使用时，应将该虚拟文件系统以一个Windows 文件的方式保存到磁盘上，以便下次可以再将它恢复到内存的虚拟磁盘空间中。
2文件存储空间的分配可采用显式链接分配或其他的办法。
3空闲磁盘空间的管理可选择位示图或其他的办法。
如果采用位示图来管理文件存储空间，并采用显式链接分配方式，那么可以将位示图合并到FAT中。
文件目录结构采用多级目录结构。
为了简单起见，可以不使用索引结点，其中的每个目录项应包含文件名、物理地址、长度等信息，还可以通过目录项实现对文件的读和写的保护。
要求提供以下有关的操作命令：my_format：对文件存储器进行格式化，即按照文件系统的结构对虚拟磁盘空间进行布局，并在其上创建根目录以及用于管理文件存储空间等的数据结构。
my_mkdir：用于创建子目录。
my_rmdir：用于删除子目录。
my_ls：用于显示目录中的内容。
my_cd：用于更改当前目录。
my_create：用于创建文件。
my_open：用于打开文件。
my_close：用于关闭文件。
my_write：用于写文件。
my_read：用于读文件。
my_rm：用于删除文件。
my_exitsys：用于退出文件系统。
三、程序的设计细想和框图1．打开文件函数fopen()（1）格式：FILE *fopen(const char *filename,const char *mode)（2）功能：按照指定打开方式打开指定文件。
（3）输入参数说明：filename：待打开的文件名，如果不存在就创建该文件。
实现实时FAT文件系统的一种简单方法
Ａｂ ｔ ａ ｔ Ｍ０ ｔ ｅ ｅ ｄ ｄ ｍａｔ ｄ ｖｃ ｓ ｎ ｈ ｍａ ｋ ｔ ｏ ｕ ｅ ｔ ｅ Ａ ｆ ｅ ｙ ｔ ｍ ｂ ｃ ｕ ｅ ｆ ｉ ｃ ｍｐ ｔ ｉ ｔ ． ｗ ｖ ｒ ｔ ｅ ｓｒ ｃ ： ｓ ｍｂ ｄ ｅ ｓ ｒ ｅ ｉｅ ｉ ｔ ｅ ｒ ｅ ｎ ｗ ｓ ｈ Ｆ Ｔ ｉ ｓ ｓｅ ｌ ｅ ａ ｓ ｏ ｔ ｏ ａｉ ｌ ｙ Ｈｏ ｅ ｅ ，ｈ ｓ ｂｉ Ｆ ｗａ ｎ ｔ ｅ ｌ ｅ ｉｎ ｄ ｏ ＡＴ ｓ ｏ ｗ ｌ ｄ ｓｇ ｅ ｔ ｍｅ ｔ ｅ ｌ ｉ ｒ ｑ ｉ ｍｅ ｔ． ｈ ｓ ｒｉｌ ｐ ｏ ｏ ｅ ａ ｉ ｌ ｓ ｌ ｔ ｎ ｈ ｔ ｒ ａｌ ｉ ｒ ｖ ｓ ｈ ｅ ｒ ａ ｔ ｍｅ ｅ ｕ ｒ ｅ ｎｓ ｉ Ｔ ａ ｔ ｅ ｒ ｐ ｓ ｓ ｓｍｐ ｅ ｏ ｕｉ ｔ ａ ｇ ｅ ｔ ｃ ｏ ｙ ｍｐ ｏ ｅ ｔ ｅ ｒ ｓ ｏ ｓ ｉ ｆ ｔ ｅ ＡＴ ｆ ｅ ｓ ｓｅ ｗｉ ｏ ｔ ｕ ｉ ｇ ｉ ｏ ａｉ ｉ ｔ ． ｅｐ ｎｅ ｔ ｍｅ ｏ ｈ Ｆ ｌ ｙ ｔ ｍ， ｔ ｕ ｈ ｒ ｎ ｔ ｃ ｍｐ ｔ ｌｙ ｉ ｈ ｔ ｓ ｂｉ Ｋｅ ｒ ｓ Ｆ ｙ ｗｏ ｄ ： ＡＴ； ｌ ｙ ｔｍ ；ｅ ｌ ｔ ｉ ｆｅｓｓ ｅ ｒ ａ ｉ ｍｅ； ｏ ｒｓ ｅ ＡＴ；ｒ ｅ ｃ ｕ ｔｒ ｉ ｄ ｘ ｃ ｍｐ ｅ ｓ ｄ Ｆ ｆｅ — ｌ ｓｅ ｎ ｅ
读写文件时文件系统经常需要进行文件逻辑簇号即这个文件中的第几个簇到物理簇号整个文件系统中的实际簇号的转换在这种链表结构中要进行这种转换必须对fat表进行遍历操作所以响应时间与读写位置呈线性关系时间复杂度为on其中n为要访问的数据所在的逻辑簇号
维普资讯
fuse用法
fuse用法Fuse是一种开源框架，用于在用户空间中实现文件系统，允许用户创建自己的文件系统接口，而不需要在内核中进行更改。
它广泛用于云存储、分布式文件系统、加密文件系统等应用中。
Fuse使用一种称为File Operation的API，通过这个API，Fuse将文件系统操作转换为用户空间中的函数调用，然后将它们映射到内核API上。
使用Fuse开发文件系统，一般需要完成以下步骤：1. 安装Fuse：首先需要安装Fuse库和Fuse开发包，可以通过操作系统包管理器进行安装，也可以直接从Fuse官方网站下载源代码进行编译安装。
2. 编写Fuse文件系统驱动程序：Fuse的核心是文件系统驱动程序，根据自己的需求编写文件系统驱动程序，实现操作系统与文件系统的交互和控制。
3. 编译链接：将开发好的驱动程序文件与Fuse库链接，生成可执行文件。
4. 挂载文件系统：将可执行文件作为用户空间的文件系统接口，挂载在Linux系统中。
Fuse使用的API包括Fuse.h、Fuse\_common.h和Fuse\_operations.h等文件。
Fuse.h文件包含一些定义和类型声明，如文件系统的操作模式、文件系统的指针类型等。
Fuse_common.h文件包含与文件系统通信、打开/关闭文件、生成新节点等函数的函数定义。
Fuse_operations.h文件定义了要实现的文件系统操作，包括文件的读写、文件夹的遍历、文件的属性、读写锁等。
其具体用法如下：```c#include <fuse.h>static struct fuse_operations hello_oper = {.getattr = hello_getattr,.readdir = hello_readdir,.open = hello_open,.read = hello_read,};int main(int argc, char *argv[]){return fuse_main(argc, argv, &hello_oper, NULL);}```代码中的hello\_oper是向操作系统提供的Fuse\_operations结构体，这里包括了需要实现的文件系统操作，如getattr、readdir、open和read函数。
虚拟文件系统的实现
实验六文件系统一、目的要求1、用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程。
从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。
二、实验内容创建文件：创建一个新文件时，系统首先要为新文件申请必要的外存空间，并在FAT 中为文件分配一个目录项。
目录项中应记录新建文件的文件名、文件总容量、当前已经使用的容量、文件属性、文件在磁盘中的起始位置。
删除文件：当已不在需要某文件时，可将它从文件系统中删除。
在删除时，首先在FAT的文件链表中找到与该文件对应的文件结点，然后确认文件是否处于关闭状态，若以上条件都满足，则系统就可以把结点从文件链表中删除，然后回收改结点对应的磁盘空间。
打开文件：只有处于打开状态的文件才能被读取、写入、重复关闭且不能被删除。
关闭文件：只有处于关闭状态的文件才能被删除，且不能被重复关闭。
列文件目录：用户只能获取自己建立的文件或其他用户共享的文件的列表,并可以查看所用户建立的文件列表。
写文件：用户可以把相关数据写入到用户自定义的文件中（磁盘上）；待写文件必须处于打开状态，且不能是其他用户共享的文件。
读文件：用户可以把文件中存储的数据读取出来；待读文件必须处于打开状态；用户既可以读取自己建立的文件，也可以读取其他用户共享的文件。
建子目录：输入目录名，若存在于该文件名相同的目录，这创建失败；若无，则查找空闲的磁盘，将该磁盘置为分配状态，填写目录项，分配地址后，子目录创建成功。
删除目录：输入名字，查找是否存在该文件或目录，若为文件，则不能删除；若存在，找到起始盘块号，并将其释放，修改目录项，删除成功。
附录主要代码源程序：#include<stdio.h>#include<string.h>#include<stdlib.h>#define MEM_D_SIZE 1024*1024 //总磁盘空间为M#define DISKSIZE 1024 //磁盘块的大小K#define DISK_NUM 1024 //磁盘块数目K#define FATSIZE DISK_NUM*sizeof(struct fatitem) //FAT表大小#define ROOT_DISK_NO FATSIZE/DISKSIZE+1 //根目录起始盘块号#define ROOT_DISK_SIZE sizeof(struct direct) //根目录大小#define DIR_MAXSIZE 1024 //路径最大长度为KB#define MSD 5 //最大子目录数#define MOFN 5 //最大文件深度为#define MAX_WRITE 1024*128 //最大写入文字长度KBstruct fatitem /* size 8*/{int item; /*存放文件下一个磁盘的指针*/char em_disk; /*磁盘块是否空闲标志位0 空闲*/};struct direct{/*-----文件控制快信息-----*/struct FCB{char name[9]; /*文件/目录名8位*/char property; /*属性1位目录0位普通文件*/int size; /*文件/目录字节数、盘块数)*/int firstdisk; /*文件/目录起始盘块号*/int next; /*子目录起始盘块号*/int sign; /*1是根目录0不是根目录*/}directitem[MSD+2];};struct opentable{struct openttableitem{char name[9]; /*文件名*/int firstdisk; /*起始盘块号*/int size; /*文件的大小*/}openitem[MOFN];int cur_size; /*当前打文件的数目*/};struct fatitem *fat; /*FAT表*/struct direct *root; /*根目录*/struct direct *cur_dir; /*当前目录*/struct opentable u_opentable; /*文件打开表*/int fd=-1; /*文件打开表的序号*/char *bufferdir; /*记录当前路径的名称*/char *fdisk; /*虚拟磁盘起始地址*/void initfile();void format();void enter();void halt();int create(char *name);int open(char *name);int close(char *name);int write(int fd,char *buf,int len);int read(int fd,char *buf);int del(char *name);int mkdir(char *name);int rmdir(char *name);void dir();int cd(char *name);void print();void show();void initfile(){fdisk = (char *)malloc(MEM_D_SIZE*sizeof(char)); /*申请1M空间*/format();}void format(){int i;FILE *fp;fat = (struct fatitem *)(fdisk+DISKSIZE); /*计算FAT表地址，引导区向后偏移1k)*/ /*-----初始化FAT表------------*/fat[0].item=-1; /*引导块*/fat[0].em_disk='1';for(i=1;i<ROOT_DISK_NO-1;i++) /*存放FAT表的磁盘块号*/{fat[i].item=i+1;fat[i].em_disk='1';}fat[ROOT_DISK_NO].item=-1; /*存放根目录的磁盘块号*/fat[ROOT_DISK_NO].em_disk='1';for(i=ROOT_DISK_NO+1;i<DISK_NUM;i++){fat[i].item = -1;fat[i].em_disk = '0';}/*-----------------------------------------------*/root = (struct direct *)(fdisk+DISKSIZE+FATSIZE); /*根目录的地址*/ /*初始化目录*//*---------指向当前目录的目录项---------*/root->directitem[0].sign = 1;root->directitem[0].firstdisk = ROOT_DISK_NO;strcpy(root->directitem[0].name,".");root->directitem[0].next = root->directitem[0].firstdisk;root->directitem[0].property = '1';root->directitem[0].size = ROOT_DISK_SIZE;/*-------指向上一级目录的目录项---------*/root->directitem[1].sign = 1;root->directitem[1].firstdisk = ROOT_DISK_NO;strcpy(root->directitem[1].name,"..");root->directitem[1].next = root->directitem[0].firstdisk;root->directitem[1].property = '1';root->directitem[1].size = ROOT_DISK_SIZE;if((fp = fopen("disk.dat","wb"))==NULL){printf("Error:\n Cannot open file \n");return;}for(i=2;i<MSD+2;i++) /*-子目录初始化为空-*/{root->directitem[i].sign = 0;root->directitem[i].firstdisk = -1;strcpy(root->directitem[i].name,"");root->directitem[i].next = -1;root->directitem[i].property = '0';root->directitem[i].size = 0;}if((fp = fopen("disk.dat","wb"))==NULL){printf("Error:\n Cannot open file \n");return;}if(fwrite(fdisk,MEM_D_SIZE,1,fp)!=1) /*把虚拟磁盘空间保存到磁盘文件中*/{printf("Error:\n File write error! \n");}fclose(fp);}void enter(){FILE *fp;int i;fdisk = (char *)malloc(MEM_D_SIZE*sizeof(char)); /*申请1M空间*/if((fp=fopen("disk.dat","rb"))==NULL){printf("Error:\nCannot open file\n");return;}if(!fread(fdisk,MEM_D_SIZE,1,fp)) /*把磁盘文件disk.dat 读入虚拟磁盘空间(内存)*/ {printf("Error:\nCannot read file\n");exit(0);}fat = (struct fatitem *)(fdisk+DISKSIZE); /*找到FAT表地址*/root = (struct direct *)(fdisk+DISKSIZE+FATSIZE);/*找到根目录地址*/fclose(fp);/*--------------初始化用户打开表------------------*/for(i=0;i<MOFN;i++){strcpy(u_opentable.openitem[i].name,"");u_opentable.openitem[i].firstdisk = -1;u_opentable.openitem[i].size = 0;}u_opentable.cur_size = 0;cur_dir = root; /*当前目录为根目录*/bufferdir = (char *)malloc(DIR_MAXSIZE*sizeof(char));strcpy(bufferdir,"Root:");}void halt(){FILE *fp;int i;if((fp=fopen("disk.dat","wb"))==NULL){printf("Error:\nCannot open file\n");return;}if(!fwrite(fdisk,MEM_D_SIZE,1,fp)) /*把虚拟磁盘空间(内存)内容读入磁盘文件disk.dat */ {printf("Error:\nFile write error!\n");}fclose(fp);free(fdisk);free(bufferdir);return;}int create(char *name){int i,j;if(strlen(name)>8) /*文件名大于8位*/return(-1);for(j=2;j<MSD+2;j++) /*检查创建文件是否与已存在的文件重名*/{if(!strcmp(cur_dir->directitem[j].name,name))break;}if(j<MSD+2) /*文件已经存在*/return(-4);for(i=2;i<MSD+2;i++) /*找到第一个空闲子目录*/{if(cur_dir->directitem[i].firstdisk==-1)break;}if(i>=MSD+2) /*无空目录项*/return(-2);if(u_opentable.cur_size>=MOFN) /*打开文件太多*/return(-3);for(j=ROOT_DISK_NO+1;j<DISK_NUM;j++) /*找到空闲盘块j 后退出*/ {if(fat[j].em_disk=='0')break;}if(j>=DISK_NUM)return(-5);fat[j].em_disk = '1'; /*将空闲块置为已经分配*//*-----------填写目录项-----------------*/strcpy(cur_dir->directitem[i].name,name);cur_dir->directitem[i].firstdisk = j;cur_dir->directitem[i].size = 0;cur_dir->directitem[i].next = j;cur_dir->directitem[i].property = '0';/*---------------------------------*/fd = open(name);return 0;}int open(char *name){int i, j;for(i=2;i<MSD+2;i++) /*文件是否存在*/{if(!strcmp(cur_dir->directitem[i].name,name))break;}if(i>=MSD+2)return(-1);/*--------是文件还是目录-----------------------*/if(cur_dir->directitem[i].property=='1')return(-4);/*--------文件是否打开-----------------------*/for(j=0;j<MOFN;j++){if(!strcmp(u_opentable.openitem[j].name,name))break;}if(j<MOFN) /*文件已经打开*/return(-2);if(u_opentable.cur_size>=MOFN) /*文件打开太多*/return(-3);/*--------查找一个空闲用户打开表项-----------------------*/for(j=0;j<MOFN;j++){if(u_opentable.openitem[j].firstdisk==-1)break;}/*--------------填写表项的相关信息------------------------*/u_opentable.openitem[j].firstdisk = cur_dir->directitem[i].firstdisk;strcpy(u_opentable.openitem[j].name,name);u_opentable.openitem[j].size = cur_dir->directitem[i].size;u_opentable.cur_size++;/*----------返回用户打开表表项的序号--------------------------*/return(j);}int close(char *name){int i;for(i=0;i<MOFN;i++){if(!strcmp(u_opentable.openitem[i].name,name))break;}if(i>=MOFN)return(-1);/*-----------清空该文件的用户打开表项的内容---------------------*/ strcpy(u_opentable.openitem[i].name,"");u_opentable.openitem[i].firstdisk = -1;u_opentable.openitem[i].size = 0;u_opentable.cur_size--;return 0;}int write(int fd, char *buf, int len){char *first;int item, i, j, k;int ilen1, ilen2, modlen, temp;/*----------用$ 字符作为空格# 字符作为换行符-----------------------*/char Space = 32;char Endter= '\n';for(i=0;i<len;i++){if(buf[i] == '$')buf[i] = Space;else if(buf[i] == '#')buf[i] = Endter;}/*----------读取用户打开表对应表项第一个盘块号-----------------------*/ item = u_opentable.openitem[fd].firstdisk;/*-------------找到当前目录所对应表项的序号-------------------------*/for(i=2;i<MSD+2;i++){if(cur_dir->directitem[i].firstdisk==item)break;}temp = i; /*-存放当前目录项的下标-*//*------找到的item 是该文件的最后一块磁盘块-------------------*/while(fat[item].item!=-1){item =fat[item].item; /*-查找该文件的下一盘块--*/}/*-----计算出该文件的最末地址-------*/first = fdisk+item*DISKSIZE+u_opentable.openitem[fd].size%DISKSIZE;/*-----如果最后磁盘块剩余的大小大于要写入的文件的大小-------*/if(DISKSIZE-u_opentable.openitem[fd].size%DISKSIZE>len){strcpy(first,buf);u_opentable.openitem[fd].size = u_opentable.openitem[fd].size+len;cur_dir->directitem[temp].size = cur_dir->directitem[temp].size+len;}else{for(i=0;i<(DISKSIZE-u_opentable.openitem[fd].size%DISKSIZE);i++){/*写一部分内容到最后一块磁盘块的剩余空间(字节)*/first[i] = buf [i];}/*-----计算分配完最后一块磁盘的剩余空间(字节) 还剩下多少字节未存储-------*/ ilen1 = len-(DISKSIZE-u_opentable.openitem[fd].size%DISKSIZE);ilen2 = ilen1/DISKSIZE;modlen = ilen1%DISKSIZE;if(modlen>0)ilen2 = ilen2+1; /*--还需要多少块磁盘块-*/for(j=0;j<ilen2;j++){for(i=ROOT_DISK_NO+1;i<DISK_NUM;i++)/*寻找空闲磁盘块*/{if(fat[i].em_disk=='0')break;}if(i>=DISK_NUM) /*--如果磁盘块已经分配完了-*/return(-1);first = fdisk+i*DISKSIZE; /*--找到的那块空闲磁盘块的起始地址-*/if(j==ilen2-1) /*--如果是最后要分配的一块-*/{for(k=0;k<len-(DISKSIZE-u_opentable.openitem[fd].size%DISKSIZE)-j*DISKSIZE;k++) first[k] = buf[k];}else/*-如果不是要最后分配的一块--*/{for(k=0;k<DISKSIZE;k++)first[k] =buf[k];}fat[item].item = i; /*--找到一块后将它的序号存放在上一块的指针中-*/fat[i].em_disk = '1'; /*--置找到的磁盘快的空闲标志位为已分配-*/fat[i].item = -1; /*--它的指针为-1 (即没有下一块)-*/ }/*--修改长度-*/u_opentable.openitem[fd].size = u_opentable.openitem[fd].size+len;cur_dir->directitem[temp].size = cur_dir->directitem[temp].size+len;}return 0;}int read(int fd, char *buf){int len = u_opentable.openitem[fd].size;char *first;int i, j, item;int ilen1, modlen;item = u_opentable.openitem[fd].firstdisk;ilen1 = len/DISKSIZE;modlen = len%DISKSIZE;if(modlen!=0)ilen1 = ilen1+1; /*--计算文件所占磁盘的块数-*/first = fdisk+item*DISKSIZE; /*--计算文件的起始位置-*/for(i=0;i<ilen1;i++){if(i==ilen1-1) /*--如果在最后一个磁盘块-*/{for(j=0;j<len-i*DISKSIZE;j++)buf[i*DISKSIZE+j] = first[j];}else /*--不在最后一块磁盘块-*/{for(j=0;j<len-i*DISKSIZE;j++)buf[i*DISKSIZE+j] = first[j];item = fat[item].item; /*-查找下一盘块-*/first = fdisk+item*DISKSIZE;}}return 0;}int del(char *name){int i,cur_item,item,temp;for(i=2;i<MSD+2;i++) /*--查找要删除文件是否在当前目录中-*/{if(!strcmp(cur_dir->directitem[i].name,name))break;}cur_item = i; /*--用来保存目录项的序号,供释放目录中-*/if(i>=MSD+2) /*--如果不在当前目录中-*/return(-1);if(cur_dir->directitem[cur_item].property!='0') /*--如果删除的(不)是目录-*/ return(-3);for(i=0;i<MOFN;i++) /*--如果文件打开,则不能删除,退出-*/{if(!strcmp(u_opentable.openitem[i].name,name))return(-2);}item = cur_dir->directitem[cur_item].firstdisk;/*--该文件的起始盘块号-*/ while(item!=-1) /*--释放空间,将FAT表对应项进行修改-*/{temp = fat[item].item;fat[item].item = -1;fat[item].em_disk = '0';item = temp;}/*-----------------释放目录项-----------------------*/cur_dir->directitem[cur_item].sign = 0;cur_dir->directitem[cur_item].firstdisk = -1;strcpy(u_opentable.openitem[cur_item].name,"");cur_dir->directitem[cur_item].next = -1;cur_dir->directitem[cur_item].property = '0';cur_dir->directitem[cur_item].size = 0;return 0;}int mkdir(char *name){int i,j;struct direct *cur_mkdir;if(!strcmp(name,"."))return(-4);if(!strcmp(name,".."))return(-4);if(strlen(name)>8) /*-如果目录名长度大于8位-*/return(-1);for(i=2;i<MSD+2;i++) /*-如果有空闲目录项退出-*/{if(cur_dir->directitem[i].firstdisk==-1)break;}if(i>=MSD+2) /*-目录/文件已满-*/return(-2);for(j=2;j<MSD+2;j++) /*-判断是否有重名-*/{if(!strcmp(cur_dir->directitem[j].name,name))break;}if(j<MSD+2) /*-如果有重名-*/return(-3);for(j=ROOT_DISK_NO+1;j<DISK_NUM;j++) /*-找到空闲磁盘块j 后退出-*/ {if(fat[j].em_disk=='0')break;}if(j>=DISK_NUM)return(-5);fat[j].em_disk='1'; /*-将该空闲块设置为已分配-*//*-------------填写目录项----------*/strcpy(cur_dir->directitem[i].name,name);cur_dir->directitem[i].firstdisk=j;cur_dir->directitem[i].size=ROOT_DISK_SIZE;cur_dir->directitem[i].next=j;cur_dir->directitem[i].property='1';/*-所创目录在虚拟磁盘上的地址(内存物理地址)-*/cur_mkdir=(struct direct *)(fdisk+cur_dir->directitem[i].firstdisk*DISKSIZE); /*-初始化目录-*//*-指向当前目录的目录项-*/cur_mkdir->directitem[0].sign=0;cur_mkdir->directitem[0].firstdisk=cur_dir->directitem[i].firstdisk;strcpy(cur_mkdir->directitem[0].name,".");cur_mkdir->directitem[0].next=cur_mkdir->directitem[0].firstdisk;cur_mkdir->directitem[0].property='1';cur_mkdir->directitem[0].size=ROOT_DISK_SIZE;/*-指向上一级目录的目录项-*/cur_mkdir->directitem[1].sign=cur_dir->directitem[0].sign;cur_mkdir->directitem[1].firstdisk=cur_dir->directitem[0].firstdisk;strcpy(cur_mkdir->directitem[1].name,"..");cur_mkdir->directitem[1].next=cur_mkdir->directitem[1].firstdisk;cur_mkdir->directitem[1].property='1';cur_mkdir->directitem[1].size=ROOT_DISK_SIZE;for(i=2;i<MSD+2;i++) /*-子目录都初始化为空-*/{cur_mkdir->directitem[i].sign=0;cur_mkdir->directitem[i].firstdisk=-1;strcpy(cur_mkdir->directitem[i].name,"");cur_mkdir->directitem[i].next=-1;cur_mkdir->directitem[i].property='0';cur_mkdir->directitem[i].size=0;}return 0;}int rmdir(char *name){int i,j,item;struct direct *temp_dir;/*-检查当前目录项中有无该目录-*/for(i=2;i<MSD+2;i++){if(!strcmp(cur_dir->directitem[i].name,name))break;}if(i>=MSD+2) /*-没有这个文件或目录-*/return(-1);if(cur_dir->directitem[i].property!='1')/*-删除的不是目录-*/ return(-3);/*-判断要删除的目录有无子目录-*/temp_dir=(struct direct *)(fdisk+cur_dir->directitem[i].next*DISKSIZE);for(j=2;j<MSD+2;j++){if(temp_dir->directitem[j].next!=-1)break;}if(j<MSD+2) /*-有子目录或文件-*/return(-2);/*------------找到起始盘块号,并将其释放----------------*/item=cur_dir->directitem[i].firstdisk;fat[item].em_disk='0';/*-修改目录项-*/cur_dir->directitem[i].sign=0;cur_dir->directitem[i].firstdisk=-1;strcpy(cur_dir->directitem[i].name,"");cur_dir->directitem[i].next=-1;cur_dir->directitem[i].property='0';cur_dir->directitem[i].size=0;return 0;}void dir(){int i;for(i=2;i<MSD+2;i++){if(cur_dir->directitem[i].firstdisk!=-1) /*-如果存在子目录-*/{printf("%s\t",cur_dir->directitem[i].name);if(cur_dir->directitem[i].property=='0') /*-文件-*/printf("%d\t\t\n",cur_dir->directitem[i].size);elseprintf("\t<目录>\t\n");}}}int cd(char *name){int i,j,item;char *str;char *temp,*point,*point1;struct direct *temp_dir;temp_dir=cur_dir;str=name;if(!strcmp("\\",name)){cur_dir = root;strcpy(bufferdir,"Root:");return 0;}temp = (char *)malloc(DIR_MAXSIZE*sizeof(char));/*-最长路径名字分配空间-*/for(i=0;i<(int)strlen(str);i++)temp[i]=str[i];temp[i]='\0';for(j=0;j<MSD+2;j++) /*-查找该子目录是否在当前目录中-*/{if(!strcmp(temp_dir->directitem[j].name,temp))break;}free(temp);/*释放申请的临时空间*///if(temp_dir->directitem[j].property!='1') /*-打开的不是目录-*///return(-2);if(j>=MSD+2) /*-不在当前目录-*/return(-1);item=temp_dir->directitem[j].firstdisk;/*-当前目录在磁盘中位置-*/temp_dir=(struct direct *)(fdisk+item*DISKSIZE);if(!strcmp("..",name)){if(cur_dir->directitem[j-1].sign!=1) /*-如果上级目录不是根目录-*/{point=strchr(bufferdir,'\\'); //查找字符串bufferdir中首次出现字符\ 的位置while(point!=NULL){point1=point+1; /*-减去'\'所占的空间,记录下次查找的起始地址-*/point=strchr(point1,'\\');}*(point1-1)='\0'; /*-将上一级目录删除-*/}}else{//if(name[0] !='\\')bufferdir = strcat(bufferdir,"\\"); /*-修改当前目录-*/bufferdir = strcat(bufferdir,name);}cur_dir=temp_dir; /*-将当前目录确定下来-*/return 0;}void show(){printf("%s>",bufferdir);}void print(){printf("*********************************************************\n");printf("**********************文件系统设计***********************\n");printf("*\t命令格式说明*\n");printf("*\tcd 目录名更改当前目录*\n");printf("*\tmkdir 目录名创建子目录*\n");printf("*\trmdir 目录名删除子目录*\n");printf("*\tdir 显示当前目录的子目录*\n");printf("*\tcreate 文件名创建文件*\n");printf("*\tdel 文件名删除文件*\n");printf("*\topen 文件名打开文件*\n");printf("*\tclose 文件名关闭文件*\n");printf("*\tread 读文件*\n");printf("*\twrite 写文件*\n");printf("*\texit 退出系统*\n");printf("*********************************************************\n"); }main(){FILE *fp;char ch;char a[100];char code[11][10];char name[10];int i,flag,r_size;char *contect;contect = (char *)malloc(MAX_WRITE*sizeof(char));if((fp=fopen("disk.dat","rb"))==NULL){printf("You have not format,Do you want format?(y/n)");scanf("%c",&ch);if(ch=='y'){initfile();printf("Successfully format! \n");}else{return 0;}}enter();print();show();strcpy(code[0],"exit");strcpy(code[1],"create");strcpy(code[2],"open");strcpy(code[3],"close");strcpy(code[4],"write");strcpy(code[5],"read");strcpy(code[6],"del");strcpy(code[7],"mkdir");strcpy(code[8],"rmdir");strcpy(code[9],"dir");strcpy(code[10],"cd");while(1){scanf("%s",a);for(i=0;i<11;i++){if(!strcmp(code[i],a))break;}switch(i){case 0: //退出文件系统free(contect);halt();return 0;case 1: //创建文件scanf("%s",name);flag = create(name);if(flag==-1){printf("Error: \n The length is too long !\n");}else if(flag==-2){printf("Error: \n The direct item is already full !\n");}else if(flag==-3){printf("Error: \n The number of openfile is too much !\n");}else if(flag==-4){printf("Error: \n The name is already in the direct !\n");}else if(flag==-5){printf("Error: \n The disk space is full!\n");}else{printf("Successfully create a file! \n");}show();break;case 2://打开文件scanf("%s",name);fd = open(name);if(fd == -1){printf("Error: \n The open file not exit! \n");}else if(fd == -2){printf("Error: \n The file have already opened! \n");}else if(fd == -3){printf("Error: \n The number of open file is too much! \n");}else if(fd == -4){printf("Error: \n It is a direct,can not open for read or write! \n");}else{printf("Successfully opened! \n");}show();break;case 3://关闭文件scanf("%s",name);flag = close(name);if(flag == -1){printf("Error:\n The file is not opened ! \n");}else{printf("Successfully closed! \n");}show();break;case 4://写文件if(fd ==-1){printf("Error:\n The file is not opened ! \n");}elseprintf("Please input the file contect:");scanf("%s",contect);flag=write(fd,contect,strlen(contect));if(flag == 0){printf("Successfully write! \n");}else{printf("Error:\n The disk size is not enough! \n");}}show();break;case 5://读文件if(fd ==-1){printf("Error:\n The file is not opened ! \n");}else{flag = read(fd,contect);if(flag == 0){for(i=0;i<u_opentable.openitem[fd].size;i++){printf("%c",contect[i]);}printf("\t\n");}}show();break;case 6://删除文件scanf("%s",name);flag = del(name);if(flag == -1){printf("Error:\n The file not exit! \n");}else if(flag == -2)printf("Error:\n The file is opened,please first close it ! \n");}else if(flag == -3){printf("Error:\n The delete is not file ! \n");}else{printf("Successfully delete! \n");}show();break;case 7://创建子目录scanf("%s",name);flag = mkdir(name);if(flag == -1){printf("Error:\n The length of name is to long! \n");}else if(flag == -2){printf("Error:\n The direct item is already full ! \n");}else if(flag == -3){printf("Error:\n The name is already in the direct ! \n");}else if(flag == -4){printf("Error: \n '..' or '.' can not as the name of the direct!\n");}else if(flag == -5){printf("Error: \n The disk space is full!\n");}else if(flag == 0){printf("Successfully make dircet! \n");}show();break;case 8://删除子目录scanf("%s",name);flag = rmdir(name);if(flag == -1){printf("Error:\n The direct is not exist! \n");}else if(flag == -2){printf("Error:\nThe direct has son direct ,please first remove the son dircct!\n");}else if(flag == -3){printf("Error:\n The remove is not direct ! \n");}else if(flag == 0){printf("Successfully remove dircet! \n");}show();break;case 9://显示当前子目录dir();show();break;case 10://更改当前目录scanf("%s",name);flag = cd(name);if(flag == -1){printf("Error:\n The path no correct!\n");}else if(flag == -2){printf("Error:\nThe opened is not direct!\n");}show();break;default:printf("\n Error!\n The command is wrong! \n");show();}}}。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
简单文件系统的实现Company Document number：WUUT-WUUY-WBBGB-BWYTT-1982GT第三章简单文件系统的实现设计目的和内容要求1.设计目的通过具体的文件存储空间的管理、文件的物理结构、目录结构和文件操作的实现，加深对文件系统内部数据结构、功能以及实现过程的理解。
2．内容要求(1)在内存中开辟一个虚拟磁盘空间作为文件存储分区，在其上实现一个简单的基于多级目录的单用户单任务系统中的文件系统。
在退出该文件系统的使用时，应将该虚拟文件系统以一个Windows文件的方式保存到磁盘上，以便下次可以再将它恢复到内存的虚拟磁盘空间中。
(2)文件存储空间的分配可采用显式链接分配或其他的办法。
(3)空闲磁盘空间的管理可选择位示图或其他的办法。
如果采用位示图来管理文件存储空间，并采用显式链接分配方式，那么可以将位示图合并到FAT 中。
(4)文件目录结构采用多级目录结构。
为了简单起见，可以不使用索引结点，其中的每个目录项应包含文件名、物理地址、长度等信息，还可以通过目录项实现对文件的读和写的保护。
(5)要求提供以下操作命令：my_format：对文件存储器进行格式化，即按照文件系统的结构对虚拟磁盘空间进行布局，并在其上创建根目录以及用于管理文件存储空间等的数据结构。
●my_mkdir：用于创建子目录。
●my_rmdir：用于删除子目录。
●my_ls：用于显示目录中的内容。
●my_cd：用于更改当前目录。
●my_create：用于创建文件。
●my_open：用于打开文件。
●my_close：用于关闭文件。
●my_write：用于写文件。
●my_read：用于读文件。
●my_rm：用于删除文件。
●my_exitsys：用于退出文件系统。
3．学时安排授课2学时，上机9学时。
4．开发平台C或C++均可。
5．思考(1)我们的数据结构中的文件物理地址信息是使用C语言的指针类型、还是整型，为什么(2)如果引入磁盘索引结点，上述实现过程需要作哪些修改(3)如果设计的是一个单用户多任务文件系统，则系统需要进行哪些扩充（尤其要考虑读写指针问题）如果设计的是一个多用户文件系统，则又要进行哪些扩充预备知识文件系统介绍1．概述FAT文件系统是微软公司在其早期的操作系统MS-DOS及Windows9x中采用的文件系统，它被设计用来管理小容量的磁盘空间。
FAT文件系统是以他的文件组织方式——文件分配表（fileallocationtable，FAT）命名的，文件分配表的每个表项中存放某文件的下一个盘块号，而该文件的起始盘块号则保存在它的文件控制块FCB中。
在文件分配表中，一般用FFFF来标识文件的结束；用0000来标识某个逻辑块未被分配，即是空闲块。
为了提高文件系统的可靠性，在逻辑磁盘上通常设置两张文件分配表，它们互为备份。
此外，文件分配表必须存放在逻辑磁盘上的固定位置，而根目录区通常位于FAT2之后，以便操作系统在启动时能够定位所需的文件，其磁盘布局如图3-1所示：图3-1FAT文件系统磁盘布局上述磁盘布局中，引导块中主要存放了用于描述分区的各种信息，包括逻辑块的大小、文件分配表的大小及位置、根目录的大小及位置等。
除此之外，用于加载操作系统内核的引导程序也存储在引导块中。
FAT文件系统家族又分为FAT12、FAT16、FAT32三种类型，这里的数字表示文件分配表中每个表项（即簇号）所占的位数，即FAT12中每个表项占个字节（12位），FAT16中每个表项占2个字节（16位），FAT32中每个表项占4个字节（32位）。
由于FAT文件系统是以簇为单位为文件分配磁盘空间的（一个簇是一组连续的扇区，通常包含2n个扇区），因此，FAT32比FAT12和FAT16支持更多的簇数、更小的簇大小和更大的磁盘容量，从而大大提高磁盘空间的利用率。
通常，FAT12适用于小容量磁盘，如软盘；FAT16是MS-DOS的文件系统；FAT32是Windows9x中的主要文件系统，开始支持大容量磁盘。
2．文件控制块FCB为了正确、方便地操作文件，必须设置相应的数据结构用于存放文件的描述和控制信息，常用的数据结构有文件控制块（简称FCB）和索引节点（简称i节点）。
在FAT文件系统中使用文件控制块。
文件与文件控制块一一对应，而文件控制块的有序集合就称为文件目录，即一个文件控制块就是一个文件目录项。
虽然不同文件系统的文件控制块的内容和格式不完全相同，但通常都包括以下三类信息：基本信息、存取控制信息和使用信息。
（1）基本信息。
包括文件名、用户名、文件类型、文件的物理地址、文件长度、文件的逻辑结构和物理结构等。
（2）存取控制信息。
一般分别给出文件主、伙伴用户、一般用户的存取权限。
（3）使用信息。
包括文件的建立日期及时间、上次存取文件的日期及时间、当前的使用信息等。
以MS-DOS（使用FAT16文件系统）为例，它的每个文件控制块包括32个字节，其字节分配情况如图3-2所示：图3-2MS-DOS的文件控制块其中属性字段占一个字节，它的每一位用来表示该文件是否具有某种属性，如果某一位的值为1，则表示该文件具有该属性。
各位所表示的属性如表3-1所示：表3-1文件属性对照表3．根目录区FAT12、FAT16的根目录区是固定区域、固定大小的，位于第二个FAT之后，如图3-1所示，且占据若干连续扇区，其中FAT12占14个扇区，一共224个根目录项；而FAT16占32个扇区，最多保存512个目录项，作为系统区的一部分。
FAT32的根目录是作为文件处理的，采用与子目录文件相同的管理方式，其位置不是固定的，不过一般情况也是位于第二个FAT之后的，其大小可视需要增加，因此根目录下的文件数目不再受最多512个的限制。
几个C语言库函数介绍由于我们的文件系统是建立在内存的虚拟磁盘上的，在退出文件系统的时候必须以一个文件的形式保存到磁盘上；而在启动文件系统的时候必须从磁盘上将该文件读入到内存的虚拟磁盘中。
下面介绍几个可能会用到的C库函数，在使用这些库函数之前必须包含头文件“”。
1．打开文件函数fopen()（1）格式：FILE*fopen(constchar*filename,constchar*mode)（2）功能：按照指定打开方式打开指定文件。
（3）输入参数说明：filename：待打开的文件名，如果不存在就创建该文件。
mode：文件打开方式，常用的有：●"r"：为读而打开文本文件（不存在则出错）。
●"w"：为写而打开文本文件（若不存在则创建该文件；反之，则从文件起始位置写,原内容将被覆盖）。
●"a"：为在文件末尾添加数据而打开文本文件。
（若不存在则创建该文件；反之,在原文件末尾追加）。
●"r+"：为读和写而打开文本文件。
（读时，从头开始；在写数据时,新数据只覆盖所占的空间，其后不变)。
●"w+"：首先建立一个新文件，进行写操作，随后可以从头开始读。
(若文件存在，原内容将全部消失)。
●"a+"：功能与"a"相同；只是在文件末尾添加新的数据后，可以从头开始读。
另外，上述模式字符串中都可以加一个“b”字符，如rb、wb、ab、rb+、wb+、ab+等组合，字符“b”表示fopen()函数打开的文件为二进制文件，而非纯文字文件。
（4）输出：一个指向FILE类型的指针。
2．关闭文件函数fclose()（1）格式：intfclose(FILE*stream);（2）功能：用来关闭先前fopen()打开的一个文件。
此动作会让缓冲区内的数据写入文件中，并释放系统所提供的文件资源。
（3）输入参数说明：stream：指向要关闭文件的指针，它是先前执行fopen()函数的返回值。
（4）输出：若关闭文件成功则返回0；有错误发生时则返回EOF并把错误代码存到errno。
3．读文件函数fread()（1）格式：size_tfread(void*buffer,size_tsize,size_tcount,FILE*stream)；（2）功能：读二进制文件到内存。
（3）输入参数说明：buffer：用于存放输入数据的缓冲区的首地址；stream：使用fopen()打开的文件的指针，用于指示要读取的文件；size：每个数据块的字节数；count：要读入的数据块的个数；size*count：表示要求读取的字节数。
（4）输出：实际读取的数据块的个数。
4．写文件函数fwrite()（1）格式：size_tfwite(constvoid*buffer,size_tsize,size_tcount,FILE*stream)；（2）功能：将数据写到二进制文件中。
（3）输入参数说明：buffer：用于存放输出数据的缓冲区的首地址；stream：使用fopen()打开的文件的指针，用于指示要写出的文件；size：每个数据块的字节数；count：要写出的数据块的个数；size*count：表示要求写出的字符数。
（4）输出：实际写出的数据块的个数。
5．判断文件结束函数feof()（1）格式：intfeof(FILE*stream)（2）功能：用来判断是否已读取到文件末尾。
（3）输入参数说明：stream：使用fopen()打开的文件的指针，用于指示要判断的文件。
（4）输出：如果已读到文件尾则返回非零值，其他情况返回0。
6．定位文件函数fseek()（1）格式：intfseek(FILE*stream,longoffset,intorigin)；（2）功能：移动文件读写指针在文件中的位置。
（3）输入参数说明：stream：使用fopen()打开的文件的指针，用于指示要定位读写指针的文件；offset：位移量，以字节为单位；origin：初始位置，有三个常量：SEEK_CUR：读写指针当前位置；SEEK_SET：文件开头；SEEK_END：文件末尾。
当origin值为SEEK_CUR或SEEK_END时，参数offset可以为负值。
实例系统的设计与实现本实例系统是仿照FAT16文件系统来设计实现的，但根目录没有采用FAT16的固定位置、固定大小的根目录区，而是以根目录文件的形式来实现的，这也是目前主流文件系统对根目录的处理方式。
数据结构设计1．需要包含的头文件（1）#include<>（2）#include<>（3）#include<>（4）#include<>2．定义的常量（1）#defineBLOCKSIZE1024磁盘块大小（2）#defineSIZE1024000虚拟磁盘空间大小（3）#defineEND65535FAT中的文件结束标志（4）#defineFREE0FAT中盘块空闲标志（5）#defineROOTBLOCKNUM2根目录区所占盘块总数（6）#defineMAXOPENFILE10最多同时打开文件个数3．数据结构（1）文件控制块FCB用于记录文件的描述和控制信息，每个文件设置一个FCB，它也是文件的目录项的内容。