简单文件系统的实现实验报告
文件管理系统实验报告
一、实验目的本次实验旨在通过设计和实现一个简单的文件管理系统，加深对文件管理原理的理解，掌握文件系统的基本操作，包括文件的创建、删除、修改、查询等，并了解文件系统的目录结构和管理机制。
二、实验环境1. 操作系统：Windows 102. 开发工具：Visual Studio 20193. 编程语言：C++4. 实验时间：2023年10月25日三、实验内容1. 文件系统的目录结构设计2. 文件的基本操作实现3. 文件系统的存储管理4. 文件系统的安全机制四、实验步骤1. 目录结构设计根据文件系统的需求，设计以下目录结构：```根目录│├── 文件夹A│ ├── 文件1.txt│ └── 文件2.txt│├── 文件夹B│ └── 文件3.txt│└── 文件夹C```2. 文件的基本操作实现（1）文件创建```cppvoid CreateFile(const std::string& filePath, const std::string& content) {// 检查文件是否存在if (CheckFileExist(filePath)) {std::cout << "文件已存在！" << std::endl;return;}// 创建文件std::ofstream file(filePath);if (file.is_open()) {file << content;file.close();std::cout << "文件创建成功！" << std::endl;} else {std::cout << "文件创建失败！" << std::endl;}}```（2）文件删除```cppvoid DeleteFile(const std::string& filePath) {// 检查文件是否存在if (!CheckFileExist(filePath)) {std::cout << "文件不存在！" << std::endl;return;}// 删除文件if (remove(filePath) == 0) {std::cout << "文件删除成功！" << std::endl;} else {std::cout << "文件删除失败！" << std::endl;}}```（3）文件修改```cppvoid ModifyFile(const std::string& filePath, const std::string& newContent) {// 检查文件是否存在if (!CheckFileExist(filePath)) {std::cout << "文件不存在！" << std::endl; return;}// 修改文件内容std::ofstream file(filePath, std::ios::trunc); if (file.is_open()) {file << newContent;file.close();std::cout << "文件修改成功！" << std::endl; } else {std::cout << "文件修改失败！" << std::endl; }}```（4）文件查询```cppvoid QueryFile(const std::string& filePath) {// 检查文件是否存在if (!CheckFileExist(filePath)) {std::cout << "文件不存在！" << std::endl; return;}// 读取文件内容std::ifstream file(filePath);if (file.is_open()) {std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());std::cout << "文件内容：" << content << std::endl;file.close();} else {std::cout << "文件读取失败！" << std::endl;}}```3. 文件系统的存储管理文件系统采用磁盘文件作为存储介质，通过文件操作实现对文件的读写。
文件管理的实验报告(3篇)
第1篇一、实验目的1. 理解文件管理的概念和重要性。
2. 掌握文件系统的基本结构和工作原理。
3. 学会使用文件管理工具进行文件操作。
4. 了解文件系统优化和故障处理方法。
二、实验环境1. 操作系统：Windows 102. 文件管理工具：Windows资源管理器3. 实验数据：实验过程中所创建和操作的文件、文件夹三、实验内容1. 文件系统的基本概念（1）文件：文件是存储在存储设备上的数据集合，具有特定的文件名和文件属性。
（2）文件夹：文件夹是用于组织和管理文件的容器，可以包含多个文件和子文件夹。
（3）文件系统：文件系统是操作系统用于管理存储设备上的文件和文件夹的机制。
2. 文件系统的基本操作（1）创建文件：在资源管理器中，右键单击目标位置，选择“新建”->“文本文档”或“新建”->“文件夹”等操作创建文件或文件夹。
（2）重命名文件：选中文件或文件夹，右键单击，选择“重命名”进行修改。
（3）移动文件：选中文件或文件夹，右键单击，选择“剪切”或“复制”，然后在目标位置粘贴。
（4）复制文件：选中文件或文件夹，右键单击，选择“复制”，然后在目标位置粘贴。
（5）删除文件：选中文件或文件夹，右键单击，选择“删除”。
（6）恢复文件：在回收站中，右键单击已删除的文件或文件夹，选择“还原”。
3. 文件系统的目录结构（1）单级目录结构：所有文件和文件夹都存储在一个根目录下，易于管理，但存在文件名冲突、文件查找效率低等问题。
（2）多级目录结构：将文件和文件夹组织成树状结构，便于管理和查找，解决了单级目录结构的缺点。
4. 文件系统优化（1）定期清理磁盘碎片：磁盘碎片会影响文件读写速度，可以通过磁盘清理工具或系统自带的磁盘碎片整理程序进行优化。
（2）合理分配磁盘空间：根据实际需求，将磁盘空间分配给不同分区，提高磁盘利用率。
（3）限制文件权限：设置文件和文件夹的访问权限，保护数据安全。
5. 文件系统故障处理（1）磁盘损坏：使用数据恢复软件尝试恢复数据，或更换磁盘。
文件系统设计实验报告
文件系统设计实验报告文件系统设计实验报告一、引言在计算机科学领域，文件系统是操作系统中的一个重要组成部分，用于管理和组织计算机存储设备上的文件和目录。
一个高效稳定的文件系统对于计算机系统的正常运行至关重要。
本实验旨在设计一个简单但功能完善的文件系统，并通过实验验证其性能和可靠性。
二、实验背景文件系统是计算机操作系统的核心组成部分之一，它负责管理计算机存储设备上的文件和目录。
一个好的文件系统应该具备以下特点：高效的文件存取速度、可靠的数据完整性、良好的扩展性和灵活性。
三、实验目标本实验的主要目标是设计一个简单但功能完善的文件系统，并通过实验验证其性能和可靠性。
具体而言，我们将实现以下功能：1. 文件的创建、读取、写入和删除。
2. 目录的创建、删除和遍历。
3. 文件和目录的权限管理。
4. 文件系统的容量管理。
5. 文件系统的备份和恢复。
四、实验设计与实现1. 文件和目录的创建、读取、写入和删除在文件系统中，文件和目录都是通过数据块来存储的。
我们可以使用链表或树的数据结构来组织文件和目录之间的关系。
为了提高文件的读取和写入效率，可以采用缓存机制，将最近访问的文件块缓存在内存中。
2. 目录的创建、删除和遍历目录是文件系统中用于组织和管理文件的一种特殊文件。
为了实现目录的创建、删除和遍历功能，我们可以使用树的数据结构来表示目录结构，并通过递归算法来实现目录的遍历。
3. 文件和目录的权限管理为了保护文件和目录的安全，我们可以为每个文件和目录设置权限。
权限可以分为读、写和执行三种类型。
通过权限管理，可以限制用户对文件和目录的操作，提高文件系统的安全性。
4. 文件系统的容量管理文件系统的容量管理是指对文件和目录所占用的存储空间进行管理。
为了有效利用存储空间，我们可以使用位图或链表等数据结构来管理存储空间的分配和释放。
5. 文件系统的备份和恢复为了保证文件系统的可靠性，我们可以定期对文件系统进行备份。
备份可以通过复制文件和目录的数据块来实现。
文件系统 实验报告
文件系统实验报告引言文件系统是操作系统中的一部分，用于管理计算机中的文件和目录。
它提供了数据的存储、访问、组织和管理功能，是操作系统的基础之一。
本实验通过实现一个简单的文件系统来深入理解文件系统的原理和实现方式。
实验目的1. 了解文件系统的基本概念和原理；2. 学习文件系统的设计和实现方法；3. 掌握文件系统的基本操作。
实验环境本次实验使用的是Ubuntu 20.04操作系统。
实验步骤1. 文件系统的设计在开始实现文件系统之前，我们首先需要设计文件系统的结构和功能。
1.1 文件系统的结构文件系统通常由三个主要部分组成：文件控制块、目录和数据块。
文件控制块用于存储文件的属性和元数据，目录用于组织文件和子目录，数据块用于存储文件的实际内容。
1.2 文件系统的功能文件系统需要提供以下功能：- 文件的创建、读取、修改和删除；- 目录的创建、读取、修改和删除；- 文件和目录的查找；- 文件的权限管理。
2. 文件系统的实现2.1 文件系统的初始化在实现文件系统之前，我们首先需要初始化文件系统。
包括创建超级块、位图和根目录，并将它们写入磁盘。
2.2 文件和目录的操作在文件系统中，我们需要实现文件和目录的基本操作，包括创建文件、创建目录、读取文件内容、修改文件内容和删除文件。
2.3 文件系统的其他操作除了基本的文件和目录操作之外，文件系统还需要实现其他一些功能，如文件查找、权限管理等。
3. 文件系统的测试在完成文件系统的实现后，我们需要对其进行测试，以验证其功能是否正常。
3.1 创建文件和目录我们首先创建一些文件和目录，检查它们是否被正确地写入磁盘，并且能够被正确地读取。
3.2 读取和修改文件我们随机选择一些文件，读取它们的内容，并对其内容进行修改。
修改后，我们再次读取文件，确保修改成功。
3.3 删除文件和目录我们尝试删除一些文件和目录，并检查它们是否被成功地删除。
4. 结果与讨论经过测试，我们发现我们实现的文件系统功能正常，能够按照我们的预期进行文件和目录的创建、读取、修改和删除等操作。
简单文件系统模拟实验
简单文件系统模拟实验实验目的通过具体的文件存储空间的管理、文件的物理结构、目录结构和文件操作的实现，加深对文件系统功能和实现过程的理解。
实验内容▪在内存中开辟一个虚拟磁盘空间作为文件存储器，在其上实现一个简单的单用户文件系统。
在退出这个简单文件系统时，应将该虚拟文件系统保存到磁盘上，以便下次可以再将它恢复到内存的虚拟磁盘上。
▪文件存储空间的分配可以采用显式链接分配或其它方法。
▪空闲空间的管理可以选择位示图或其它方法。
如果采用位示图来管理文件存储空间，并采用显式链接分配方式，可以将位示图合并到FAT中。
▪文件目录结构采用多级目录结构。
为简单起见，可以不使用索引结点，其中的每个目录项包含文件名、物理地址、文件长度等信息，还可以通过目录项实现对文件读和写的保护。
▪要求提供以下有关的文件操作：✧Format：对文件存储器进行格式化，即按照文件系统的结构对虚拟磁盘空间进行布局，并在其上创建根目录以及用于管理文件存储空间等的数据结构。
✧Mkdir：用于创建子目录。
✧Rmdir：用于删除子目录。
✧Ls：用于显示目录。
✧Cd：用于更改当前目录。
✧Create：用于创建文件。
✧Open：用于打开文件。
✧Close：用于关闭文件。
✧Write：用于写文件。
✧Read：用于读文件。
✧Rm：用于删除文件。
数据结构设计磁盘：整个磁盘为一个char数组，数组中的每一个元素当做是一个扇区，每个扇区可以存储1个字节的信息，簇大小为8字节。
FAT表：存储的是指定编号的簇的下一个簇的编号是什么，因为文件是有可能分散在很多的簇里。
文件和文件夹链表：设计为静态链表，每个文件夹都会有一个子目录列表，存在链表中。
文件和目录表：文件和目录相同对待，信息存放在文件目录表中，为一个数组类型。
以上所有的信息存放在一个fs结构体中，所有的结构都为静态实现，所以需要将文件系统存放到磁盘中的时候只需要将整个结构体以二进制性质存放到文件中或者是将从文件中以二进制形式读取。
文件系统的构建实验报告
文件系统的构建实验报告 实验名称：文件系统的构建实验目的：掌握磁盘的工作原理和操作系统进行文件管理的原理实验原理：硬盘的MBR ：MBR （Main Boot Record ）,按其字面上的理解即为主引导记录区，位于整个硬盘的0磁道0柱面1扇区。
在总共512字节的主引导扇区中，MBR 只占用了其中的446个字节（偏移0000--偏移01BD ），另外的64个字节（偏移01BE--偏移01FD ）交给了DPT(Disk Partition Table 硬盘分区表),最后两个字节"55，AA"（偏移01FE- 偏移01FF ）是分区的结束标志。
这个整体构成了硬盘的主引导扇区。
硬盘依据分区表中的信息把硬盘划分为最多四个分区（对于扩展分区，可进一步划分为多个逻辑分区）。
U 盘采用类似的方法划分分区。
每个分区或软盘上可建立独立的文件系统。
下图是FAT 文件系统空间分布结构。
实验内容：在掌握磁盘的工作原理和操作系统进行文件管理原理的基础上，自行设计实现在磁盘上建立文件系统的软件，该软件应该具有与Format 类似的功能，至少支持一种文件系统格式，如FAT 、NTFS 或EXT2，至少能够对一种媒体进行格式化，如软盘，U 盘或硬盘（不得在实验室的机器上进行硬盘格式化的实验）等。
不能直接调用操作系统提供的格式化工具或类似SHFormatDrive （）的高层系统函数实现该软件。
在Windows 环境可使用biosdisk()函数完成底层盘操作，在Linux 环境上可参考format 的源代码。
比较自己设计实现的软件.与FORMAT ，分析存在什么异同。
背景知识介绍 一个分区或磁盘能作为文件系统使用前，需要初始化，并将记录数据结构写到磁盘上。
这个过程就叫建立文件系统。
大部分linux 文件系统种类具有类似的通用结构。
其中心概念是超级块superblock, i 节点inode, 数据块data block,目录块directory block, 和间接块indirection block 。
文件管理系统实验报告
文件管理系统实验报告文件管理系统实验报告一、引言文件管理系统是现代社会中不可或缺的一部分。
随着信息技术的迅猛发展，文件的产生和管理变得越来越重要。
本实验旨在通过设计和实现一个简单的文件管理系统，探索文件管理的原理和方法。
二、实验目的1.了解文件管理系统的基本概念和功能；2.掌握文件的创建、读取、修改和删除等操作；3.熟悉文件的组织和存储结构；4.实践文件管理系统的设计和实现。
三、实验内容1.文件的创建和读取在文件管理系统中，文件的创建和读取是最基本的操作。
通过调用系统函数，我们可以创建一个新文件，并向其中写入数据。
而读取文件则是通过指定文件路径和文件名来获取文件的内容。
2.文件的修改和删除文件的修改和删除是文件管理系统中的常见操作。
通过系统函数，我们可以打开一个已有的文件，并对其进行修改。
而删除文件则是通过指定文件路径和文件名来删除一个文件。
3.文件的组织和存储结构文件管理系统中，文件的组织和存储结构对于文件的管理和访问有着重要的影响。
常见的文件组织结构包括顺序文件、索引文件和哈希文件等。
在本实验中，我们将选择适合的文件组织结构，并实现相应的存储和检索算法。
四、实验步骤1.设计文件管理系统的数据结构在开始实验之前，我们需要先设计文件管理系统的数据结构。
这包括文件控制块（FCB）、目录项（Directory Entry）和文件块（File Block）等。
通过合理的数据结构设计，可以提高文件管理系统的性能和效率。
2.实现文件的创建和读取功能根据文件管理系统的设计，我们可以开始实现文件的创建和读取功能。
通过调用系统函数，我们可以创建一个新的文件，并向其中写入数据。
而读取文件则是通过指定文件路径和文件名来获取文件的内容。
3.实现文件的修改和删除功能文件的修改和删除是文件管理系统中的常见操作。
通过调用系统函数，我们可以打开一个已有的文件，并对其进行修改。
而删除文件则是通过指定文件路径和文件名来删除一个文件。
文件管理实验报告结果(3篇)
第1篇一、实验目的本次实验旨在通过实际操作，验证文件管理的有效性和可行性，并对文件管理系统的性能进行评估。
通过实验，了解文件管理的相关原理和方法，提高文件管理的实践能力。
二、实验环境1. 操作系统：Windows 102. 文件管理系统：Windows文件管理器3. 实验数据：实验过程中产生的文件和数据三、实验内容1. 文件创建与删除2. 文件夹创建与删除3. 文件与文件夹的复制、移动、重命名4. 文件属性的设置与修改5. 文件搜索与查找6. 文件权限管理7. 文件压缩与解压四、实验步骤1. 文件创建与删除（1）在Windows文件管理器中，新建一个名为“实验文件.txt”的文本文件。
（2）在“实验文件.txt”上右击，选择“删除”，确认删除。
2. 文件夹创建与删除（1）在Windows文件管理器中，新建一个名为“实验文件夹”的文件夹。
（2）在“实验文件夹”上右击，选择“删除”，确认删除。
3. 文件与文件夹的复制、移动、重命名（1）将“实验文件.txt”复制到“实验文件夹”中。
（2）将“实验文件.txt”移动到桌面。
（3）将“实验文件.txt”重命名为“实验文件修改.txt”。
4. 文件属性的设置与修改（1）在“实验文件修改.txt”上右击，选择“属性”，设置文件属性为“只读”。
（2）修改“实验文件修改.txt”的属性为“隐藏”。
5. 文件搜索与查找（1）在Windows文件管理器中，输入“实验文件”进行搜索。
（2）使用“查找”功能，查找“实验文件修改.txt”。
6. 文件权限管理（1）在“实验文件夹”上右击，选择“属性”，点击“安全”标签。
（2）添加用户权限，设置权限为“完全控制”。
7. 文件压缩与解压（1）将“实验文件夹”压缩为“实验文件夹.zip”。
（2）解压“实验文件夹.zip”到指定位置。
五、实验结果与分析1. 文件创建与删除：实验成功创建和删除了文件，验证了文件管理的可行性。
2. 文件夹创建与删除：实验成功创建和删除了文件夹，验证了文件管理的可行性。
文件系统实验报告
一、实验目的1. 理解文件系统的基本概念和组成。
2. 掌握文件系统的创建、删除、修改和查询等基本操作。
3. 了解文件系统的性能分析和优化方法。
4. 提高对文件系统原理的理解和实际操作能力。
二、实验环境1. 操作系统：Windows 102. 文件系统：NTFS3. 实验软件：Windows资源管理器、Notepad++等三、实验内容1. 文件系统的基本概念和组成（1）文件：存储在文件系统中的数据单元，可以是程序、文档、图片等。
（2）目录：用于组织文件的结构，类似于文件夹。
（3）文件系统：管理存储设备上文件和目录的数据结构。
2. 文件系统的创建、删除、修改和查询等基本操作（1）创建文件：使用Notepad++创建一个名为“test.txt”的文本文件。
（2）创建目录：在Windows资源管理器中，创建一个名为“test”的目录。
（3）删除文件：选中“test.txt”文件，按Delete键删除。
（4）删除目录：选中“test”目录，按Delete键删除。
（5）修改文件：使用Notepad++打开“test.txt”文件，修改内容后保存。
（6）查询文件：在Windows资源管理器中，通过路径或搜索功能查找“test.txt”文件。
3. 文件系统的性能分析和优化方法（1）查看磁盘空间使用情况：在Windows资源管理器中，选中磁盘分区，查看磁盘空间使用情况。
（2）清理磁盘：使用Windows自带的磁盘清理工具清理磁盘垃圾文件。
（3）优化文件系统：使用Windows自带的磁盘碎片整理工具优化文件系统。
四、实验结果与分析1. 创建文件和目录实验结果显示，使用Notepad++创建了一个名为“test.txt”的文本文件，使用Windows资源管理器创建了一个名为“test”的目录。
2. 删除文件和目录实验结果显示，成功删除了“test.txt”文件和“test”目录。
3. 修改文件实验结果显示，使用Notepad++修改了“test.txt”文件的内容，并成功保存。
文件系统实验报告
文件系统实验报告文件系统实验报告一、引言文件系统是计算机操作系统中的重要组成部分，负责管理计算机中的文件和目录，提供对数据的存储、访问和管理功能。
本实验旨在通过实际操作和实验验证，深入了解文件系统的原理和工作机制。
二、实验目的1. 了解文件系统的基本概念和组成结构；2. 掌握文件系统的创建、格式化和挂载过程；3. 实践文件和目录的创建、读写和删除操作；4. 理解文件系统的性能和安全性。
三、实验环境1. 操作系统：Linux；2. 实验工具：命令行终端、文件编辑器。
四、实验步骤1. 文件系统创建与格式化在实验环境中，使用命令行终端创建一个新的文件系统。
首先，使用fdisk命令创建一个新的分区，然后使用mkfs命令对分区进行格式化。
格式化过程中可以选择文件系统的类型，如ext4、NTFS等。
2. 文件系统挂载将新创建的文件系统挂载到操作系统中的某个目录下。
使用mount命令指定文件系统的设备和挂载点，实现文件系统的访问。
3. 文件和目录的创建与读写在挂载的文件系统中，使用文件编辑器创建一个新的文本文件，并写入一些内容。
然后，使用cat命令查看文件的内容，确认写入操作是否成功。
接着，使用mkdir命令创建一个新的目录，并将文件移动到该目录下，验证目录的创建和文件的移动操作。
4. 文件和目录的删除使用rm命令删除之前创建的文件和目录，观察文件系统的变化。
可以通过ls命令查看文件系统中的文件和目录列表，确认删除操作是否生效。
五、实验结果与分析通过实验步骤中的操作，成功创建了一个新的文件系统，并进行了格式化和挂载。
在文件系统中创建了一个文本文件，并写入了内容。
通过查看文件的内容，确认写入操作成功。
接着，创建了一个新的目录，并将文件移动到该目录下，验证了目录的创建和文件的移动操作。
最后，成功删除了之前创建的文件和目录。
六、实验总结本实验通过实际操作和实验验证，深入了解了文件系统的原理和工作机制。
通过创建、格式化和挂载文件系统，掌握了文件系统的基本操作。
文件系统设计实验报告
文件系统设计试验报告班级：10网工三班学生姓名：谢昊天学号：1215134046实验目的和要求：通过一个简单多用户文件系统的设计，加深理解文件系统的内部功能及内部实现。
实验内容与分析设计：为linux系统设计一个简单的二级文件系统。
要求做到以下几点：（1）可以实现下列几条命令（至少4条）；login 用户登陆dir 列文件目录create 创建文件delete 删除文件open 打开文件close 关闭文件read 读文件write 写文件（2）列目录时要列出文件名、物理地址、保护码和文件长度；（3）源文件可以进行读写保护。
实验提示（1）首先应确定文件系统的数据结构：主目录、子目录及活动文件等。
主目录和子目录都以文件的形式存放于磁盘，这样便于查找和修改。
（2）用户创建的文件，可以编号存储于磁盘上。
如file0，file1,file2...并以编号作为物理地址，在目录中进行登记。
实验步骤与调试过程：用两级目录，其中第一级对应于用户账号，第二级对应于用户帐号下的文件。
另外，为了简便文件系统未考虑文件共享，文件系统安全以及管道文件与设备文件等特殊内容。
主要数据结构：1.I节点 2.磁盘i结点 3.目录项结构 4.超级块 5.用户密码 6．目录 7.查找i 内存节点的hash表 8.系统打开表 9.用户打开表设置：主要函数1.i节点内容获取函数iget()（详细描述略）。
2.节点内容释放函数iput()（详细描述略）。
3.目录创建函数mkdir()（详细描述略）。
4.目录搜索函数namei()（详细描述略）。
5.磁盘块分配函数balloc()（详细描述略）。
6.磁盘块释放函数bfree()（详细描述略）。
7.分配i节点区函数ialloc()（详细描述略）。
8.解释结点区函数ifree（）（详（详细描述略）。
10.访问控制函数access 细描述略）。
9.搜索当前目录下文件的函数iname（）（）（详细描述略）。
简单文件系统的实现实验报告
操作系统课程设计报告简单文件系统的实现专业：班级：姓名：学号：老师：一、课程设计的目的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：待打开的文件名，如果不存在就创建该文件。
简单文件系统的实现的实验报告
杭州电子科技大学操作系统课程设计课程设计题目：简单文件系统的实现姓名：庄严班级：09056011学号：09056012学院：计算机学院专业：计算机科学与技术（2+2）负责老师：胡志凌完成日期：2012-5-28简单文件系统的实现一，课程设计的目的1，通过具体的文件爱你存储空间的管理、文件的物理结构、目录结构和文件操作的实现，加深对文件系统内部数据结、功能及实现过程的理解二，设计要求1，在内存中开辟一个虚拟磁盘空间作为文件存储分区，在其上实现一个简单的基于多级目录的但用户单任务系统的文件系统。
在退出文件系统的使用时，应将虚拟文件系统一个Windows文件的方式保存到磁盘中，以便下次再将它恢复到内存的虚拟磁盘空间中2，文件存储空间的分配可采用显示链接分配或其它方法3，空闲磁盘空间的管理可选择位示图或其它方法4，文件目录结构采用多级目录结构5，需要提供一以下操作命令i.Formatii.Mkdiriii.Rmdiriv.Lsv.Cdvi.Createvii.Openviii.Closeix.Writex.Readxi.Rmxii.Exit三，程序设计思想以及总流程图1，程序设计思想i.首先，在文件系统启动时，申请一块较大的内存，用来当作文件系统的磁盘空间ii.然后，对其进行格式化，虚拟磁盘的空间布局是仿照FA T16文件系统，结构如下：1块2块2块995块引导块 FA T1 FA T2 数据区格式化时，主要包括引导块，FA T1，FA T2，的一些初始化工作例如设置文件魔数，文件系统的信息，FA T1，FA T2的信息等等iii.根据用户输入的命令，调用对应的函数.2，程序流程图四，系统各个功能的实现思想1，创建目录a)调用do_read读入当前目录文件到内存，检查新建文件目录是否重名b)分配一个空闲的打开文件表项c)分配一个空闲的盘块d)在当前目录中问新建目录寻找一个空闲的目录项e)设置FCB，文件的属性信息f)创建特殊的两个目录项‘.’,‘..’g)返回2，Cd命令a)Open指定的目录名，调用read读入该父目录到内存b)检查新的当前目录名是否存在c)关闭原当前目录d)设置当前目录为该目录3，Rmdir命令a)Read读入当前目录文件内容到内存，检查要删除的文件目录是否存在b)检查该目录是否为空c)检查是否已经打开，打开用close则关闭d)回收给目录文件的磁盘块e)修改该目录文件的目录项f)修改用户打开表项的长度信息g)返回4，Ls命令a)Read当前目录到内存b)读出目录文件的信息，显示到屏幕上c)返回5，Create命令a)分配一个空闲的打开文件表项b)检查新文件的父目录是否打开c)Read该父目录的文件到内存，并检测新建的文件名是否重名d)检查是否有空闲盘块e)寻找空闲的目录项f)准备好新文件的F CBg)调用close关闭打开的父目录文件h)返回6，Rm命令a)检查要删除的文件的父目录是否已打开b)Read父目录到内存c)检查文件是否打开d)回收磁盘快e)清空该文件的目录项f)修改用户打开文件表项中的长度信息g)返回7，Open命令a)检查该文件名是否存在b)Read该父目录到内存c)检查用户打开的文件表中是否有空闲表项d)为该文件填写空白用户打开文件表项内容e)返回8，Closea)检查fd的有效性b)检查用户打开文件表表项的fcbstate字段c)回收该文件占据的用户打开文件表表项d)返回9，Write命令a)检查fd的有效性b)提示用户输入写方式c)提示用户输入内容d)调用do_write（）将键入的内容写入到文件中e)返回写入的字节数五，系统的详细过程#include<stdio.h>#include<malloc.h>#include<time.h>#include<stdlib.h>#include<str ing.h>#define BLOCKSIZE 1024#define SIZE 1024000#define END 65535#define FREE 0#define ROOT_BLOC KNUM 2#define MAX_OPEN_FILE 10#define MAX_TXT_SIZE 10000typedef struct FCB{char filename[8]; /*8B文件名*/char exname[3]; /*3B扩展名*/unsigned char attr ibute; /*文件属性字段*/char retainbyte[10] ; /*10B保留字*/unsigned short time; /*文件创建时间*/unsigned short date; /*文件创建日期*/unsigned short first; /*首块号*/unsigned long length; /*文件大小*/}fcb;/*文件分配表file allocation table*/typedef struct FAT{unsigned short id;}fat;/*属性对照表位7 6 5 4 3 2 1 0属性保留保留存档子目录卷标系统文件隐藏只读*/typedef struct USEROPEN{char filename[8]; /*8B文件名*/char exname[3]; /*3B扩展名*/unsigned char attr ibute; /*文件属性字段*/char retainbyte[10] ; /*10B保留字*/unsigned short time; /*文件创建时间*/unsigned short date; /*文件创建日期*/unsigned short first; /*首块号*/unsigned long length; /*文件大小*/char free; /*表示目录项是否为空0空1分配*/int father; /*父目录的文件描述符*/int dirno; /*相应打开文件的目录项在父目录文件中的盘块号*/int diroff; /*相应打开文件的目录项在父目录文件的dirno盘块中的目录项序号*/ char dir[MAX_OPEN_FILE][80];/*相应打开文件所在的目录*/int count; /*读写指针在文件中的位置*/char fcbstate; /*是否修改了文件的FCB内容，修改置1，否则为0*/char topenfile; /*表示该用户打开的表项是否为空，若值为0，表示为空*/}useropen;typedef struct BLOCK0{unsigned short fbnum;char information[200];unsigned short root;unsigned char *startblock;}block0;/*全局变量定义*/unsigned char *myvhard; /*指向虚拟磁盘的起始地址*/useropen openfilelist[MAX_OPEN_FILE]; /*用户打开文件表数组*/useropen *ptrcurdir; /*指向用户打开文件表中的当前目录所在打开文件表项的位置*/ int curfd;char currentdir[80]; /*记录当前目录的文件名*/unsigned char *startp; /*记录虚拟磁盘上数据区开始位置*/char filename[]="c:\\myfilesys"; /*虚拟空间保存路径*/unsigned char buffer[SIZE];/*函数声明*/void startsys();void my_for mat();void my_cd(char *dirname);void my_mkdir(char *dirname);void my_rmdir(char *dir name);void my_ls();void my_create(char *filename);void my_rm(char *filename);int my_open(char *filename);int my_close(int fd);int my_wr ite(int fd);int do_write(int fd,char *text,int len,char wstyle);unsigned short findFree();int my_read(int fd,int len);int do_read(int fd,int len,char *text);void my_exitsys();/*函数设计*//*文件系统初始化*//*原型声明: void startsys()功能描述：文件系统初始化,初始化所建立的文件系统输入：无输出：无函数功能实现算法描述：1）申请磁盘空间2）打开系统磁盘，若不存在，创建新的系统磁盘，并格式化3）初始化用户打开文件表，将表项0分配给根目录文件使用并填写根目录文件的相关信息4）将ptrcurdir指向该用户打开文件表项5）将当前目录设置为根目录*/void startsys(){FILE *fp;int i;myvhard=(unsigned char *)malloc(SIZE);memset(myvhard,0,SIZE);fp=fopen(filename,"r");if(fp){fread(buffer,SIZE,1,fp);fclose(fp);if(buffer[0]!=0xaa||buffer[1]!=0xaa){printf("myfilesys is not exist,begin to creat the file...\n");my_for mat();}else{for(i=0;i<SIZE;i++)myvhard[i]=buffer[i];}}else{printf("myfilesys is not exist,begin to creat the file...\n");my_for mat();}strcpy(openfilelist[0].filename,"root");strcpy(openfilelist[0].exname,"di");openfilelist[0].attribute=0x2d;openfilelist[0].time=((fcb *)(myvhard+5*BLOCKSIZE))->time;openfilelist[0].date=((fcb *)(myvhard+5*BLOC KSIZE))->date;openfilelist[0].first=((fcb *)(myvhard+5*BLOCKSIZE))->first;openfilelist[0].length=((fcb *)(myvhard+5*BLOCKSIZE))->length; openfilelist[0].free=1;openfilelist[0].dirno=5;openfilelist[0].diroff=0;openfilelist[0].count=0;openfilelist[0].fcbstate=0;openfilelist[0].topenfile=0;openfilelist[0].father=0;memset(currentdir,0,sizeof(currentdir));strcpy(currentdir,"\\root\\");strcpy(openfilelist->dir[0],currentdir);startp=((block0 *)myvhard)->startblock;ptrcurdir=&openfilelist[0];curfd=0;}/*原型声明: void my_for mat()功能描述：对虚拟磁盘进行格式化，布局虚拟磁盘，建立根目录文件输入：无输出：无函数功能实现算法描述：虚拟磁盘空间布局1块2块2块995块引导块FAT1 FAT2 数据区虚拟磁盘一共划分成1000个磁盘块每块1024个字节，磁盘空间布局如上将数据区的第一块（即虚拟磁盘的第6块）分配给根目录文件*/void my_for mat(){FILE *fp;fat *fat1,*fat2;block0 *b0;time_t *now;struct tm *nowtime;unsigned char *p;fcb *root;int i;p=myvhard;b0=(block0 *)p;fat1=(fat *)(p+BLOCKSIZE);fat2=(fat*)(p+3*BLOCKSIZE);/*引导块*/b0->fbnum=0xaaaa; /*文件系统魔数10101010*/b0->root = 5;strcpy(b0->information,"My FileSystem Ver 1.0 \n Blocksize=1KB Whole size=1000KB Blocknum=1000 RootBlocknum=2\n");/*FAT1,FAT2前面五个磁盘块已分配，标记为END*/fat1->id=END;fat2->id=END;fat1++;fat2++;fat1->id=END;fat2->id=END;fat1++;fat2++;fat1->id=END;fat2->id=END;fat1++;fat2++;fat1->id=END;fat2->id=END;fat1++;fat2++;fat1->id=END;fat2->id=END;fat1++;fat2++;fat1->id=6;fat2->id=6;fat1++;fat2++;fat1->id=END;fat2->id=END;fat1++;fat2++;/*将数据区的标记为空闲状态*/for(i=7;i<SIZE/BLOC KSIZE;i++){(*fat1).id=FREE;(*fat2).id=FREE;fat1++;fat2++;}/*创建根目录文件root，将数据区的第一块分配给根目录区在给磁盘上创建两个特殊的目录项：".",".."，除了文件名之外，其它都相同*/p+=BLOCKSIZE*5;root=(fcb *)p;strcpy(root->filename,".");strcpy(root->exname,"di");root->attr ibute=40;now=(time_t *)malloc(sizeof(time_t));time(now);nowtime=localtime(now);root->time=nowtime->tm_hour*2048+nowtime->tm_min*32+nowtime->tm_sec/2;root->date=(nowtime->tm_year-80)*512+(nowtime->tm_mon+1)*32+nowtime->tm_mday; root->first=5;root->length=2*sizeof(fcb);root++;strcpy(root->filename,"..");strcpy(root->exname,"di");root->attr ibute=40;time(now);nowtime=localtime(now);root->time=nowtime->tm_hour*2048+nowtime->tm_min*32+nowtime->tm_sec/2;root->date=(nowtime->tm_year-80)*512+(nowtime->tm_mon+1)*32+nowtime->tm_mday; root->first=5;root->length=2*sizeof(fcb);root++;for(i=2;i<BLOC KSIZE*2/sizeof(fcb);i++,root++){root->filename[0]='\0';}fp=fopen(filename,"w");b0->startblock=p+BLOCKSIZE*4;fwrite(myvhard,SIZE,1,fp);free(now);fclose(fp);}/**//*原型声明: void my_exitsys()功能描述：退出文件系统输入：无输出：无函数功能实现算法描述：*/void my_exitsys(){FILE *fp;fcb *rootfcb;char text[MAX_TXT_SIZE];while(curfd)curfd=my_close(curfd);if(openfilelist[curfd].fcbstate){openfilelist[curfd].count=0;do_read(curfd,openfilelist[curfd].length,text);rootfcb=(char *)text;rootfcb->length=openfilelist[curfd].length;openfilelist[curfd].count=0;do_write(curfd,text,openfilelist[curfd].length,2);}fp=fopen(filename,"w");fwrite(myvhard,SIZE,1,fp);free(myvhard);fclose(fp);}/*原型声明: int do_read(int fd,int len,char *text)功能描述：实际读文件函数，读出指定文件中从指定指针开始的长度为len的内容到用户空间的text中输入：fd open（）函数的返回值，文件的描述符len 要求从文件中读出的字节数text 指向存放读出数据的用户区地址输出：实际读出的字节数函数功能实现算法描述：*/int do_read(int fd,int len,char *text){unsigned char *buf;unsigned short bknum;int off,i,lentmp;unsigned char *bkptr;char *txtmp,*p;fat *fat1,*fatptr;fat1=(fat *)(myvhard+BLOC KSIZE);lentmp = len;txtmp=text;/*申请1024B空间作为缓冲区buffer*/buf=(unsigned char *)malloc(1024);if(buf==NULL){printf("malloc failed!\n");return -1;}off = openfilelist[fd].count;bknum = openfilelist[fd].first;fatptr = fat1+bknum;while(off >= BLOC KSIZE){off=off-BLOCKSIZE;bknum=fatptr->id;fatptr=fat1+bknum;if(bknum == END){printf("Error,the block is not exist.\n");return -1;}}bkptr=(unsigned char *)(myvhard+bknum*BLOCKSIZE);//strncpy(buf,bkptr,BLOCKSIZE);for(i=0;i<BLOC KSIZE;i++){buf[i]=bkptr[i];}while(len > 0){if(BLOCKSIZE-off > len){//strncpy(txtmp,buf+off,len);//len=len-len;//openfilelist[fd].count+=len;//off+=len;for(p=buf+off;len>0;p++,txtmp++){*txtmp=*p;len--;off++;openfilelist[fd].count++;}}else{//strncpy(txtmp,buf+off,BLOCKSIZE-off);//len=len-(BLOCKSIZE-off);//openfilelist[fd].count+=(BLOCKSIZE-off);for(p=buf+off;p<buf+BLOCKSIZE;p++,txtmp++){*txtmp=*p;len--;openfilelist[fd].count++;}off=0;//txtmp+=(BLOCKSIZE-off);bknum =fatptr->id;fatptr = fat1+bknum;bkptr=(unsigned char *)(myvhard+bknum*BLOCKSIZE);//strncpy(buf,bkptr,BLOCKSIZE);for(i=0;i<BLOC KSIZE;i++){buf[i]=bkptr[i];}}}free(buf);return lentmp-len;}/**//*原型声明: int my_read(int fd,int len) 功能描述：读文件函数输入：fd 打开文件的idlen 要读出字符的个数输出：返回实际读的字符的个数函数功能实现算法描述：*/int my_read(int fd,int len){char text[MAX_TXT_SIZE];if(fd > MAX_OPEN_FILE){printf("The File is not exist!\n");return -1;}openfilelist[curfd].count=0;if(do_read(fd,len,text)>0){text[len]='\0';printf("%s\n",text);}else{printf("Read Error!\n");return -1;}return len;}/**//*原型声明: int do_write(int fd,char *text,int len,char wstyle) 功能描述：实际写文件函数输入：fd 当前打开的文件的idtext 指向要写入的内容的指针len 本次要写入字节数wstyle写方式输出：实际写入的字节数函数功能实现算法描述：*/int do_write(int fd,char *text,int len,char wstyle){unsigned char *buf;unsigned short bknum;int off,tmplen=0,tmplen2=0,i,rwptr;unsigned char *bkptr,*p;char *txtmp,flag=0;fat *fat1,*fatptr;fat1=(fat *)(myvhard+BLOC KSIZE);txtmp=text;/*申请临时1024B的buffer*/buf=(unsigned char *)malloc(BLOCKSIZE);if(buf==NULL){printf("malloc failed!\n");return -1;}rwptr = off = openfilelist[fd].count;bknum = openfilelist[fd].first;fatptr=fat1+bknum;while(off >= BLOC KSIZE ){off=off-BLOCKSIZE;bknum=fatptr->id;if(bknum == END){bknum=fatptr->id=findFree();if(bknum==END) retur n -1;fatptr=fat1+bknum;fatptr->id=END;}fatptr=fat1+bknum;}fatptr->id=END;bkptr=(unsigned char *)(myvhard+bknum*BLOCKSIZE); while(tmplen<len){for(i=0;i<BLOC KSIZE;i++){buf[i]=0;}//if(off)//{for(i=0;i<BLOC KSIZE;i++){buf[i]=bkptr[i];tmplen2++;if(tmplen2==openfilelist[curfd].length)break;}//}//else//{//for(i=0;i<BLOCKSIZE;i++)//{// buf[i]=0;//}//}for(p=buf+off;p<buf+BLOCKSIZE;p++){*p=*txtmp;tmplen++;txtmp++;off++;if(tmplen==len)break;/*if((*p)==NULL){break;}*/}for(i=0;i<BLOC KSIZE;i++){bkptr[i]=buf[i];}openfilelist[fd].count=rwptr+tmplen;if(off>=BLOCKSIZE){off=off-BLOCKSIZE;bknum=fatptr->id;if(bknum==END){bknum=fatptr->id=findFree();if(bknum==END) retur n -1;fatptr=fat1+bknum;fatptr->id=END;}fatptr=fat1+bknum;bkptr=(unsigned char *)(myvhard+bknum*BLOCKSIZE);}}free(buf);if(openfilelist[fd].count>openfilelist[fd].length){openfilelist[fd].length=openfilelist[fd].count;}openfilelist[fd].fcbstate=1;return tmplen;}/**//*原型声明: unsigned short findFree()功能描述：寻找下一个空闲盘块输入：无输出：返回空闲盘块的id函数功能实现算法描述：*/unsigned short findFree(){unsigned short i;fat *fat1,*fatptr;fat1=(fat *)(myvhard+BLOC KSIZE);for(i=6; i<END; i++){fatptr=fat1+i;if(fatptr->id == FREE){return i;}}printf("Error,Can't find free block!\n"); return END;}/*原型声明: int findFreeO()功能描述：寻找空闲文件表项输入：无输出：返回空闲文件表项的id 函数功能实现算法描述：*/int findFreeO(){int i;for(i=0;i<MAX_OPEN_FILE;i++){if(openfilelist[i].free==0){return i;}}printf("Error,open too many files!\n"); return -1;}/**//*原型声明: int my_wr ite(int fd)功能描述：写文件函数输入：fd 打开文件的id输出：返回实际写的长度函数功能实现算法描述：*/int my_wr ite(int fd){int wstyle=0,wlen=0;fat *fat1,*fatptr;unsigned short bknum;unsigned char *bkptr;char text[MAX_TXT_SIZE];fat1=(fat *)(myvhard+BLOC KSIZE);if(fd>MAX_OPEN_FILE){printf("The file is not exist!\n");return -1;}while(wstyle<1||wstyle>3){printf("Please enter the number of wr ite style:\n1.cut wr ite\t2.cover write\t3.add write\n");scanf("%d",&wstyle);getchar();switch(wstyle){case 1://截断写{bknum=openfilelist[fd].first;fatptr=fat1+bknum;while(fatptr->id!=END){bknum=fatptr->id;fatptr->id=FREE;fatptr=fat1+bknum;}fatptr->id=FREE;bknum=openfilelist[fd].first;fatptr=fat1+bknum;fatptr->id=END;openfilelist[fd].length=0;openfilelist[fd].count=0;break;}case 2://覆盖写{openfilelist[fd].count=0;break;}case 3://追加写{bknum=openfilelist[fd].first;fatptr=fat1+bknum;openfilelist[fd].count=0;while(fatptr->id!=END){bknum=fatptr->id;fatptr=fat1+bknum;openfilelist[fd].count+=BLOCKSIZE;}bkptr=(unsigned char *)(myvhard+bknum*BLOCKSIZE);while(*bkptr !=0){bkptr++;openfilelist[fd].count++;}break;}default:break;}}printf("please input write data:\n");gets(text);if(do_write(fd,text,str len(text),wstyle)>0){wlen+=strlen(text);}else{return -1;}if(openfilelist[fd].count>openfilelist[fd].length){openfilelist[fd].length=openfilelist[fd].count;}openfilelist[fd].fcbstate=1;return w len;}/*原型声明: void my_mkdir(char *dirname)功能描述：创建子目录函数,在当前目录下创建名为dirname的目录输入：dirname 指向新建目录的名字的指针输出：无函数功能实现算法描述：*/void my_mkdir(char *dirname){fcb *dirfcb,*pcbtmp;int rbn,i,fd;unsigned short bknum;char text[MAX_TXT_SIZE],*p;time_t *now;struct tm *nowtime;/*将当前的文件信息读到text中rbn 是实际读取的字节数*/openfilelist[curfd].count=0;rbn = do_read(curfd,openfilelist[curfd].length,text);dirfcb=(fcb *)text;/*检测是否有相同的目录名*/for(i=0;i<rbn/sizeof(fcb);i++){if(strcmp(dirname,dirfcb->filename)==0){printf("Error,the dirname is alr eady exist!\n");return -1;}dirfcb++;}/*分配一个空闲的打开文件表项*/dirfcb=(fcb *)text;for(i=0;i<rbn/sizeof(fcb);i++){if(strcmp(dirfcb->filename,"")==0)break;dirfcb++;}openfilelist[curfd].count=i*sizeof(fcb);fd=findFreeO();if(fd<0){return -1;}/*寻找空闲盘块*/bknum = findFree();if(bknum == END ){return -1;}pcbtmp=(fcb *)malloc(sizeof(fcb));now=(time_t *)malloc(sizeof(time_t));//在当前目录下新建目录项pcbtmp->attribute=0x30;time(now);nowtime=localtime(now);pcbtmp->time=nowtime->tm_hour*2048+nowtime->tm_min*32+nowtime->tm_sec/2; pcbtmp->date=(nowtime->tm_year-80)*512+(nowtime->tm_mon+1)*32+nowtime->tm_mday; strcpy(pcbtmp->filename,dirname);strcpy(pcbtmp->exname,"di");pcbtmp->first=bknum;pcbtmp->length=2*sizeof(fcb);openfilelist[fd].attribute=pcbtmp->attribute;openfilelist[fd].count=0;openfilelist[fd].date=pcbtmp->date;strcpy(openfilelist[fd].dir[fd],openfilelist[curfd].dir[curfd]);p=openfilelist[fd].dir[fd];while(*p!='\0')p++;strcpy(p,dirname);while(*p!='\0') p++;*p='\\';p++;*p='\0';openfilelist[fd].dirno=openfilelist[curfd].first;openfilelist[fd].diroff=i;strcpy(openfilelist[fd].exname,pcbtmp->exname);strcpy(openfilelist[fd].filename,pcbtmp->filename);openfilelist[fd].fcbstate=1;openfilelist[fd].first=pcbtmp->first;openfilelist[fd].length=pcbtmp->length;openfilelist[fd].free=1;openfilelist[fd].time=pcbtmp->time;openfilelist[fd].topenfile=1;do_write(curfd,(char *)pcbtmp,sizeof(fcb),2);pcbtmp->attribute=0x28;time(now);nowtime=localtime(now);pcbtmp->time=nowtime->tm_hour*2048+nowtime->tm_min*32+nowtime->tm_sec/2; pcbtmp->date=(nowtime->tm_year-80)*512+(nowtime->tm_mon+1)*32+nowtime->tm_mday; strcpy(pcbtmp->filename,".");strcpy(pcbtmp->exname,"di");pcbtmp->first=bknum;pcbtmp->length=2*sizeof(fcb);do_write(fd,(char *)pcbtmp,sizeof(fcb),2);pcbtmp->attribute=0x28;time(now);nowtime=localtime(now);pcbtmp->time=nowtime->tm_hour*2048+nowtime->tm_min*32+nowtime->tm_sec/2; pcbtmp->date=(nowtime->tm_year-80)*512+(nowtime->tm_mon+1)*32+nowtime->tm_mday; strcpy(pcbtmp->filename,"..");strcpy(pcbtmp->exname,"di");pcbtmp->first=openfilelist[curfd].first;pcbtmp->length=openfilelist[curfd].length;do_write(fd,(char *)pcbtmp,sizeof(fcb),2);openfilelist[curfd].count=0;do_read(curfd,openfilelist[curfd].length,text);pcbtmp=(fcb *)text;pcbtmp->length=openfilelist[curfd].length;my_close(fd);openfilelist[curfd].count=0;do_write(curfd,text,pcbtmp->length,2);}/**//*原型声明: void my_ls()功能描述：显示目录函数输入：无输出：无函数功能实现算法描述：*/void my_ls(){fcb *fcbptr;int i;char text[MAX_TXT_SIZE];unsigned short bknum;openfilelist[curfd].count=0;do_read(curfd,openfilelist[curfd].length,text);fcbptr=(fcb *)text;for(i=0;i<(int)(openfilelist[curfd].length/sizeof(fcb));i++){if(fcbptr->filename[0]!='\0'){if(fcbptr->attr ibute&0x20){printf("%s\\\t\t<DIR>\t\t%d/%d/%d\t%02d:%02d:%02d\n",fcbptr->filename,((fcbptr->date)>>9)+1980,((fcbptr->date)>>5) &0x000f,(fcbptr->date)&0x001f,fcbptr->time>>11,(fcbptr->time>>5)&0x003f,fcbptr->time&0x001f*2);}else{printf("%s.%s\t\t%dB\t\t%d/%d/%d\t%02d:%02d:%02d\t\n",fcbptr->filename,fcbptr->exname,fcbptr->length,((fcbptr->da te)>>9)+1980,(fcbptr->date>>5)&0x000f,fcbptr->date&0x1f,fcbptr->time>>11,(fcbptr->time>>5)&0x3f,fcbptr->time&0x1f*2);}}fcbptr++;}openfilelist[curfd].count=0;}/**//*原型声明: void my_rmdir(char *dir name)功能描述：删除子目录函数输入：dirname 指向新建目录的名字的指针输出：无函数功能实现算法描述：*/void my_rmdir(char *dir name){int rbn,fd;char text[MAX_TXT_SIZE];fcb *fcbptr,*fcbtmp,*fcbtmp2;unsigned short bknum;int i,j;fat *fat1,*fatptr;if(strcmp(dirname,".")==0 || strcmp(dirname,"..")==0) {printf("Error,can't remove this directory.\n");return -1;}fat1=(fat *)(myvhard+BLOC KSIZE);openfilelist[curfd].count=0;rbn=do_read(curfd,openfilelist[curfd].length,text); fcbptr=(fcb *)text;for(i=0;i<rbn/sizeof(fcb);i++){if(strcmp(dirname,fcbptr->filename)==0){break;}fcbptr++;}if(i >= rbn/sizeof(fcb)){printf("Error,the directory is not exist.\n");return -1;}bknum=fcbptr->first;fcbtmp2=fcbtmp=(fcb *)(myvhard+bknum*BLOCKSIZE);for(j=0;j<fcbtmp->length/sizeof(fcb);j++){if(strcmp(fcbtmp2->filename,".") && strcmp(fcbtmp2->filename,"..") && fcbtmp2->filename[0]!='\0') {printf("Error,the directory is not empty.\n");return -1;}fcbtmp2++;}while(bknum!=END){fatptr=fat1+bknum;bknum=fatptr->id;fatptr->id=FREE;}strcpy(fcbptr->filename,"");strcpy(fcbptr->exname,"");fcbptr->first=END;openfilelist[curfd].count=0;do_write(curfd,text,openfilelist[curfd].length,2);}/*原型声明: int my_open(char *filename)功能描述：打开文件函数输入：filename 指向要打开的文件的名字的指针输出：返回打开的文件的id函数功能实现算法描述：*/int my_open(char *filename){int i,fd,rbn;char text[MAX_TXT_SIZE],*p,*fname,*exname;fcb *fcbptr;char exnamed=0;fname=strtok(filename,".");exname=strtok(NULL,".");if(!exname){exname=(char *)malloc(3);strcpy(exname,"di");exnamed=1;}for(i=0;i<MAX_OPEN_FILE;i++){if(strcmp(openfilelist[i].filename,filename)==0 &&strcmp(openfilelist[i].exname,exname)==0&& i!=curfd) {printf("Error,the file is already open.\n");return -1;}}openfilelist[curfd].count=0;rbn=do_read(curfd,openfilelist[curfd].length,text);fcbptr=(fcb *)text;for(i=0;i<rbn/sizeof(fcb);i++){if(strcmp(filename,fcbptr->filename)==0 && strcmp(fcbptr->exname,exname)==0){break;}fcbptr++;}if(i>=rbn/sizeof(fcb)){printf("Error,the file is not exist.\n");return curfd;}if(exnamed){free(exname);}fd=findFreeO();if(fd==-1){return -1;}strcpy(openfilelist[fd].filename,fcbptr->filename); strcpy(openfilelist[fd].exname,fcbptr->exname); openfilelist[fd].attribute=fcbptr->attribute;openfilelist[fd].count=0;openfilelist[fd].date=fcbptr->date;openfilelist[fd].first=fcbptr->first;openfilelist[fd].length=fcbptr->length;openfilelist[fd].time=fcbptr->time;openfilelist[fd].father=curfd;openfilelist[fd].dirno=openfilelist[curfd].first; openfilelist[fd].diroff=i;openfilelist[fd].fcbstate=0;openfilelist[fd].free=1;openfilelist[fd].topenfile=1;strcpy(openfilelist[fd].dir[fd],openfilelist[curfd].dir[curfd]); p=openfilelist[fd].dir[fd];while(*p!='\0')p++;strcpy(p,filename);while(*p!='\0') p++;if(openfilelist[fd].attribute&0x20){*p='\\';p++; *p='\0';}else{*p='.';p++;strcpy(p,openfilelist[fd].exname);}return fd;}/**//*原型声明: int my_close(int fd)功能描述：关闭文件函数输入：fd 打开文件的id输出：返回fd的father的id函数功能实现算法描述：*/int my_close(int fd){fcb *fafcb;char text[MAX_TXT_SIZE];int fa;/*检查fd的有效性*/if(fd > MAX_OPEN_FILE || fd<=0){printf("Error,the file is not exist.\n");return -1;}fa=openfilelist[fd].father;if(openfilelist[fd].fcbstate){fa=openfilelist[fd].father;openfilelist[fa].count=0;do_read(fa,openfilelist[fa].length,text);fafcb=(fcb *)(text+sizeof(fcb)*openfilelist[fd].diroff);fafcb->attribute=openfilelist[fd].attr ibute;fafcb->date=openfilelist[fd].date;fafcb->first=openfilelist[fd].first;fafcb->length=openfilelist[fd].length;fafcb->time=openfilelist[fd].time;strcpy(fafcb->filename,openfilelist[fd].filename);strcpy(fafcb->exname,openfilelist[fd].exname);openfilelist[fa].count=0;do_write(fa,text,openfilelist[fa].length,2);}openfilelist[fd].attribute=0;openfilelist[fd].count=0;openfilelist[fd].date=0;strcpy(openfilelist[fd].dir[fd],"");strcpy(openfilelist[fd].filename,"");strcpy(openfilelist[fd].exname,"");openfilelist[fd].length=0;openfilelist[fd].time=0;openfilelist[fd].free=0;openfilelist[fd].topenfile=0;return fa;}/**//*原型声明: void my_cd(char *dirname) 功能描述：更改当前目录函数输入：dirname 指向目录名的指针输出：无函数功能实现算法描述：*/void my_cd(char *dirname){char *p,text[MAX_TXT_SIZE];int fd,i;p=strtok(dirname,"\\");if(strcmp(p,".")==0)return;if(strcmp(p,"..")==0){fd=openfilelist[curfd].father;my_close(curfd);curfd=fd;ptrcurdir=&openfilelist[curfd];return;}if(strcmp(p,"r oot")==0){for(i=1;i<MAX_OPEN_FILE;i++){if(openfilelist[i].free)my_close(i);}ptrcurdir=&openfilelist[0];curfd=0;p=strtok(NULL,"\\");}while(p){fd=my_open(p);if(fd>0){ptrcurdir=&openfilelist[fd];curfd=fd;}elsereturn -1;p=strtok(NULL,"\\");}}/**//*原型声明: void my_create(char *filename)功能描述：创建文件函数输入：filename 指向文件名的指针输出：无函数功能实现算法描述：*/void my_create(char *filename){char *fname,*exname,text[MAX_TXT_SIZE];int fd,rbn,i;fcb *filefcb,*fcbtmp;time_t *now;struct tm *nowtime;unsigned short bknum;fat *fat1,*fatptr;fat1=(fat *)(myvhard+BLOC KSIZE);fname=strtok(filename,".");exname=strtok(NULL,".");if(strcmp(fname,"")==0){printf("Error,creating file must have a right name.\n");return -1;}if(!exname){printf("Error,creating file must have a extern name.\n");return -1;}openfilelist[curfd].count=0;rbn=do_read(curfd,openfilelist[curfd].length,text);filefcb=(fcb *)text;for(i=0;i<rbn/sizeof(fcb);i++){if(strcmp(fname,filefcb->filename)==0 && strcmp(exname,filefcb->exname)==0){printf("Error,the filename is already exist!\n");return -1;}filefcb++;}filefcb=(fcb *)text;for(i=0;i<rbn/sizeof(fcb);i++){if(strcmp(filefcb->filename,"")==0)break;filefcb++;}openfilelist[curfd].count=i*sizeof(fcb);bknum=findFree();if(bknum==END){return -1;}fcbtmp=(fcb *)malloc(sizeof(fcb));now=(time_t *)malloc(sizeof(time_t));fcbtmp->attribute=0x00;time(now);nowtime=localtime(now);fcbtmp->time=nowtime->tm_hour*2048+nowtime->tm_min*32+nowtime->tm_sec/2;fcbtmp->date=(nowtime->tm_year-80)*512+(nowtime->tm_mon+1)*32+nowtime->tm_mday; strcpy(fcbtmp->filename,fname);。
实验8文件系统
接着是创建一个test.txt文件，输入vi test.txt命令回车后，接着在里面
输入一些内容，如下所示：
保存后，返回到user_test目录下，输入ls后，如下所示：
然后建立一个test.txt文件的链接test02，输入link test.txt test02回车后，如下
然后我们输入ls命令，发现user目录下，没有如何东西，如是我们创建一个叫user_test的目录，输入mkdir user_test命令回车后，如下所示：
然后输入ls后，可以看到/user下，有了一个叫user_test的目录，如下所示：
然后打开user_test目录，输入cd user_test命令回车后，如下所示：
以上的显示结果，我们就可以知道MemTotal和Cached获取出来的数
据都是对的，这个实验大概完成。
3）实现文件的拷贝，即把一个文件内容复制到另一个文件。
答：这这个实验中，首先在student下建一个名字叫test1.txt的文件，并在里面添加相关的内容，用于作为被拷贝的文件，如下所示：
接着是创建一个copy.c文件，输入vi copy.c，并输入相关的代码后，实现文件
答：首先在linux下输入su -，如下所示：
然后输入密码：123456回车后，进入系统根目录，并获得超级用户的权利，
如下所示：
然后输入ls查看目录后，发现没有user目录，如下所示：
所以我给系统创建一个叫user的目录，如下所示：
输入ls查看目录后，可以看到已经有user目录存在了，如下所示：
然后我们进入到user下，输入cd user命令进入，如下所示：
接着我们查看test2.txt文件的内容，输入cat test2.txt回车后，显示如下
操作系统实验文件系统报告
操作系统实验文件系统报告简介本文档是操作系统实验报告的文件系统部分。
在这个实验中，我们将通过实现一个简单的文件系统来了解文件系统的基本原理和实现方式。
本文档将介绍文件系统的设计和实现，以及在实验中遇到的问题和解决方案。
设计和实现文件系统结构我们的文件系统采用了简单的单级目录结构。
每个文件都有一个唯一的文件名和文件扩展名，以及相应的文件内容。
文件系统中的所有文件都存储在一个文件中，我们通过偏移量来访问每个文件。
文件系统接口我们实现了以下文件系统接口来对文件系统进行操作：•create_file(filename, extension): 创建一个新文件。
•delete_file(filename, extension): 删除一个文件。
•open_file(filename, extension): 打开一个文件。
•close_file(file): 关闭一个文件。
•read_file(file, offset, length): 从文件中读取数据。
•write_file(file, data): 向文件中写入数据。
•seek_file(file, offset): 设置文件指针的位置。
通过这些接口，我们可以对文件进行创建、删除、读取和写入操作，以及设置文件指针的位置。
文件系统实现我们的文件系统是在操作系统内核中进行实现的。
在内存中维护了一个文件控制块（FCB）表，用于记录文件的元数据信息，比如文件名、扩展名、大小和位置等。
文件内容存储在一个独立的数据块中。
为了实现文件的持久化，我们将文件系统的存储映射到了一个文件中。
在系统启动时，我们会将这个文件读取到内存中，并建立起文件控制块表和数据块的映射关系。
文件的创建、删除和读写操作都是通过操作文件控制块表和数据块来完成的。
具体实现涉及到文件的分配和释放，以及文件指针的管理等问题。
遇到的问题和解决方案在实验中，我们遇到了一些问题，主要集中在文件的读写和文件指针的管理方面。
构建文件系统的实验报告
（2学年度第2学期）课程名称嵌入式系统设计与开发实验题目构建文件系统实验【实验目的】1．了解UP-TECHPXA270板的文件系统结构。
2．了解文件系统的生成过程3．完成一个简单的文件系统生产步骤4．了解busybox、mkfs.jffs2工具【实验内容】使用busybox生产文件系统中的命令部分，使用mkfs.jffs2工具制作文件系统，并完成将文件系统放置到开发板的烧写工作。
【实验设备及工具】硬件：UP-TECHPXA270实验平台，PC机pentium500以上，硬盘10G 以上。
软件：PC机操作系统RedHat Linux9.0+MiniCOM+ARM-Linux开发环境。
【实验原理】Linux支持多种文件系统，包括ext2、ext3、vfat、ntfs、iso9660、jffs、romfs和nfs等，为了对各类文件系统进行统一管理，Linux引入了虚拟文件系统VFS(Virtual File System)，为各类文件系统提供一个统一的操作界面和应用编程接口。
Linux启动时，第一个必须挂载的是根文件系统；若系统不能从指定设备上挂载根文件系统，则系统会出错而退出启动。
之后可以自动或手动挂载其他的文件系统。
因此，一个系统中可以同时存在不同的文件系统。
不同的文件系统类型有不同的特点，因而根据存储设备的硬件特性、系统需求等有不同的应用场合。
在嵌入式Linux应用中，主要的存储设备为RAM(DRAM, SDRAM)和ROM(常采用FLASH存储器)，常用的基于存储设备的文件系统类型包括：jffs2, yaffs, cramfs, romfs, ramdisk, ramfs/tmpfs等。
Flash(闪存)作为嵌入式系统的主要存储媒介，有其自身的特性。
Flash 的写入操作只能把对应位置的1修改为0，而不能把0修改为1(擦除Flash就是把对应存储块的内容恢复为1)，因此，一般情况下，向Flash 写入内容时，需要先擦除对应的存储区间，这种擦除是以块(block)为单位进行的。
简单文件资料系统的实现实验报告材料
操作系统课程设计报告简单文件系统的实现专业：班级：：学号：老师：一、课程设计的目的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：待打开的文件名，如果不存在就创建该文件。
mode：文件打开方式，常用的有："r"：为读而打开文本文件（不存在则出错）。
操作系统实验四 文件系统实验
return
scanf("%s",s); strcpy(t->fileName,s); printf("\n 请输入该文件基本信息："); scanf("%s",s); strcpy(t->file,s); t->brother=t->child=NULL; if(p->child==NULL) {
goto label; } p=p->next; } printf("文件不存在！\n"); goto label; } else if(i==8) { show(f); goto label; } else { goto label; } } void Select() { char username[20]; int i; printf("请输入用户名：\n"); scanf("%s",username); for(i=0; i<userNum; i++) { if(!strcmp(mdf[i].userName,username)) { fp= mdf[i].p; if(fp!=NULL) {
printf("该用户已创建文件：\n"); while(fp!=NULL) {
fp=fp->next; printf("%s\n",fp->fileName); } } else { printf("该用户尚未创建任何文件！\n"); } fp= mdf[i].p; Operation(fp); }
#include <stdio.h> #include <stdlib.h> #include <string.h> #define getpch(type) (type*)malloc(sizeof(type)) int userNum=0;
文件系统实验报告
文件系统实验报告实验四文件系统实验一.目的要求1、用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程。
从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。
2、要求设计一个n个用户的文件系统，每次用户可保存m 个文件，用户在一次运行中只能打开一个文件，对文件必须设置保护措施，且至少有Create、delete、open、close、read、write等命令。
二.例题：1、设计一个10个用户的文件系统，每次用户可保存10个文件，一次运行用户可以打开5个文件。
2、程序采用二级文件目录和用户文件目录。
另外，为打开文件设置了运行文件目录。
3、为了便于实现，对文件的读写作了简化，在执行读写命令时，只需改读写指针，并不进行实际的读写操作。
4、算法与框图：①因系统小，文件目录的检索使用了简单的线性搜索。
②文件保护简单使用了三位保护码：允许读写执行、对应位为1，对应位为0，则表示不允许读写、执行。
③程序中使用的主要设计结构如下：主文件目录和用户文件目录打开文件目录文件系统算法的流程图如下：三. 实验题：1、增加2～3个文件操作命令，并加以实现。
#include#include#include#include#define MAXSIZE 100#define ADDSIZE 50#define PT elem+l-> length#define N 4typedef struct term{/*班级和学期的结构体*/char class1[10];char term1[10];}term;typedef struct student{/*学生成绩信息的结构体*/ term st;/*班级和学期结构体放于此结构体中*/ char num[10];char name[12];float course[4];float total;float average;int bit;}lnode,*stu;typedef struct{lnode *elem;/*指向上个结构体的指针*/int size;/*最大能放lnode结构体成员的个数*/ int length;/*当前长度*/}sqack,*sq;sqack *l;void init/*动态分配存储空间*/{l-> elem=malloc);l-> length =0;l-> size=MAXSIZE;}void input/*输入学生的信息*/{lnode *newbase,*p;char cla[10],ter[10],ch;int n,i;if{newbase=realloc*sizeof);/*追加存储空间*/ l-> elem =newbase;l-> size +=ADDSIZE;}p=l-> elem;do{printf;gets;gets;printf;scanf;printf;for{scanf;strcpy;strcpy;++l-> length ;}printf “);ch=getchar;}while;}void change/*修改学生的信息*/{lnode *p;lnode e;int flag=1,i;char s1[10],num1[10];printf:\n “);gets;gets;p=l-> elem ;while && flag==1)/*查找要修改的学生的信息*/ {if==0&&strcmp==0)flag=0;/*找到了*/p++;}p--;if printf;printf;forprintf;printf;printf;scanf;forscanf;*p=e;}void same /*把学期和班级相同的学生信息放在结构体数组tt 中*/ {int i=0;lnode *p,*q;q=t;p=l-> elem ;while{if==0&&strcmp==0){*q=*p;q++;i++;}p++;*k=i;}void sort/*按学生成绩从高到低排序函数*/ {int i;lnode *q,temp;for{q-> total =0;forq-> total =q-> total +q-> course [i];q-> average =q-> total /N;}forforif-> total){temp=*q;*q=*;*=temp;}}void print/*输出学生的成绩*/lnode *p;p=q;for{printf;forprintf;printf;printf;}}void stat/*统计学生的成绩*/ {lnode tt[50];char ter[10],clas[10];int i,k;printf:\n “);forter[i]=getchar;forclas[i]=getchar;same;/*把学期和班级相同的学生信息放在结构体数组tt中*/ sort;/*按学生成绩从高到低排序函数*/print;/*输出学生的成绩*/}void search1/*按学号查*/{lnode *p;char ter1[10];int i,flag=1;p=l-> elem;printf;gets;for{if==0){flag=0;printf;printf;forprintf;printf;printf;}}if printf;}void search2/*按姓名查*/ {lnode *p;char ter1[10];int i,flag=1;p=l-> elem;printf;gets;for{if==0){flag=0;printf;printf;forprintf;printf;}}if printf ;}void search/*查找学生的成绩*/ {char ch;do{printf;ch=getchar;switch{case ‘1 ‘:search1;break;case ‘2 ‘:search2;break;default:}printf “);ch=getchar;} while;}void fail/*查找不及格及学生名单*/ {int i;lnode *p;for{forif{printf;forprintf;printf;printf;}}}void output/*按班级输出学生的成绩单*/{lnode tt[50];int k;char clas[10],ter1[10];printf; gets;gets;same;/*把学期和班级相同的学生信息放在结构体数组tt中*/ print;/*输出学生的成绩*/}试验四文件系统一、实验目的1、用高级语言编写和调试一个简单的文件系统，模拟文件管理的工作过程。
文件系统实验报告
char name[12];
curuser = getspace(MFD);
while(1)
{
cout<<"\n ;<endl;
cout<<"用户名：";
cin>>name; //输入用户注册名
}
}
void DisplayUFD()//打印用户信息，包括用户的各个文件
//名称、长度和操作权限的设置信息
{
if(curuser->filepoint == false)//当前用户目录下没有任何文件存在
cout<<"\n用户 "<<curuser->username<<" 文件夹是空的"<<endl;
二、实验题目:
采用二级目录结构实现磁盘文件操作。
要求：
1．普通文件的目录项包括文件名，文件类型，文件长度，指向文件内容的指针内容。
2．目录文件的目录项包括目录名，指向下一级目录块的指针内容。假定每个目录文件最多只能占用一个块；
3．程序功能方面的要求： 需要实现一个命令行操作界面，包含如下命令：
4．程序实现方面的要求：
{
cout<<"\n保存错误。";//fclose(infile);
return;
}
else
{
if((outfile=fopen(out,"wb+"))==NULL)//申请一个缓冲区管理模块
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
操作系统课程设计报告简单文件系统的实现专业：班级：姓名：学号：老师：一、课程设计的目的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：待打开的文件名，如果不存在就创建该文件。
mode：文件打开方式，常用的有："r"：为读而打开文本文件（不存在则出错）。
"w"：为写而打开文本文件（若不存在则创建该文件；反之，则从文件起始位置写,原内容将被覆盖）。
"a"：为在文件末尾添加数据而打开文本文件。
（若不存在则创建该文件；反之,在原文件末尾追加）。
"r+"：为读和写而打开文本文件。
（读时，从头开始；在写数据时,新数据只覆盖所占的空间，其后不变) 。
"w+"：首先建立一个新文件，进行写操作，随后可以从头开始读。
(若文件存在，原内容将全部消失) 。
"a+"：功能与"a"相同；只是在文件末尾添加新的数据后，可以从头开始读。
另外，上述模式字符串中都可以加一个“b”字符，如rb、wb、ab、rb+、wb+、ab+等组合，字符“b”表示fopen() 函数打开的文件为二进制文件，而非纯文字文件。
（4）输出：一个指向FILE类型的指针。
2．关闭文件函数fclose()（1）格式：int fclose(FILE * stream);（2）功能：用来关闭先前fopen()打开的一个文件。
此动作会让缓冲区内的数据写入文件中，并释放系统所提供的文件资源。
（3）输入参数说明：stream：指向要关闭文件的指针，它是先前执行fopen()函数的返回值。
（4）输出：若关闭文件成功则返回0；有错误发生时则返回EOF并把错误代码存到errno。
3．读文件函数fread()（1）格式：size_t fread( void *buffer, size_t size, size_t count, FILE *stream )；（2）功能：读二进制文件到内存。
（3）输入参数说明：buffer：用于存放输入数据的缓冲区的首地址；stream：使用fopen()打开的文件的指针，用于指示要读取的文件；size：每个数据块的字节数；count：要读入的数据块的个数；size*count：表示要求读取的字节数。
（4）输出：实际读取的数据块的个数。
4．写文件函数fwrite()（1）格式：size_t fwite(const void *buffer,size_t size,size_t count,FILE *stream)；（2）功能：将数据写到二进制文件中。
（3）输入参数说明：buffer：用于存放输出数据的缓冲区的首地址；stream：使用fopen()打开的文件的指针，用于指示要写出的文件；size：每个数据块的字节数；count：要写出的数据块的个数；size*count：表示要求写出的字符数。
（4）输出：实际写出的数据块的个数。
5．判断文件结束函数feof ()（1）格式：int feof(FILE * stream)（2）功能：用来判断是否已读取到文件末尾。
（3）输入参数说明：stream：使用fopen()打开的文件的指针，用于指示要判断的文件。
（4）输出：如果已读到文件尾则返回非零值，其他情况返回0。
6 主要函数功能实现:int format(); atherBlockNum = -1;ype=GENERAL;}}};struct dirFile/*-------------目录文件结构---------------*/{struct FCB fcb[BlockFcbCount];void init(int _FatherBlockNum,int _CurrentBlockNum,char *name)name,name); atherBlockNum=_FatherBlockNum;fcb[0].currentBlockNum=_CurrentBlockNum;fcb[0].type=DIRECTORY; atherBlockNum=_CurrentBlockNum; ype=Zero; ype==DIRECTORY && strcmp(dir->fcb[i].fname,sonfname)==0 ){printf("该文件夹下已经有同名的文件夹存在了!\n");return 0;}}for(i = 1;i < BlockFcbCount; i++){ype==Zero)break;}if(i == BlockFcbCount){printf("该目录已满!请选择新的目录下创建!\n");return 0;}temp = i;for(i = 3;i < BlockCount;i++) {if(osPoint->FAT1[i] == 0)break;}if(i == BlockCount){printf("磁盘已满!\n");return 0;}iFAT=i;/*-------------接下来进行分配----------*/osPoint->FAT1[iFAT]=osPoint->FAT2[iFAT] = 2; name,sonfname);dir->fcb[temp].type=DIRECTORY;dir->fcb[temp].fatherBlockNum=current;dir->fcb[temp].currentBlockNum=iFAT;ype==DIRECTORY && strcmp(dir->fcb[i].fname,sonfname)==0){break;}}temp=i;if(i==BlockFcbCount){printf("当前目录下不存在该子目录!\n");return 0;}j = dir->fcb[temp].currentBlockNum;struct dirFile *sonDir; ype!=Zero){printf("该文件夹为非空文件夹,为确保安全，请清空后再删除!\n");return 0;}}/*开始删除子目录操作*/osPoint->FAT1[j] = osPoint->FAT2[j]=0; nitialize(); ype == Zero && isFound == 0) {emptyNum = i;isFound = 1;}else if(dir->fcb[i].type==GENERAL && strcmp(dir->fcb[i].fname,name)==0 ){ printf("无法在同一目录下创建同名文件!\n");return 0;}}if(emptyNum == 0){printf("已经达到目录项容纳上限，无法创建新目录!\n");return 0;}for(i = 3;i<BlockCount;i++)name,name);dir->fcb[emptyNum].type=GENERAL;dir->fcb[emptyNum].fatherBlockNum=current;dir->fcb[emptyNum].currentBlockNum=iFAT;dir->fcb[emptyNum].size =0;char* p = osPoint->data[iFAT -3];memset(p,4,BlockSize);printf("在当前目录下创建文本文件成功！\n");return 1;}/*-------查询子目录------------*/int listshow(){int i,DirCount=0,FileCount=0;ype==GENERAL){ n",dir->fcb[i].fname);}if(dir->fcb[i].type==DIRECTORY){ n",dir->fcb[i].fname);}printf("\n该目录下共有 %d 个文本文件, %d 个文件夹\n\n",FileCount,DirCount);return 1;}/*---------在当前目录下删除文件-----------*/int delfile(char *name){int i,temp,j;ype==GENERAL && strcmp(dir->fcb[i].fname,name)==0){break;}}if(i == BlockFcbCount){printf("当前目录下不存在该文件!\n");return 0;}int k;for(k=0;k<OPEN_MAX;k++){if((openlist->f [k].type = GENERAL)&&(strcmp(openlist->f [k].fname,name)==0)){if(openlist->f[k].fatherBlockNum == current){break;}else{printf("该文件未在当前目录下!\n");return 0;}}}if(k!=OPEN_MAX){close(name);}urrentBlockNum ; nitialize(); ")==0){if(current==2){printf("你现已经在根目录下!\n");return 0;current = dir->fcb[0].fatherBlockNum ;currentPath = (0,() - strlen(dir->fcb[0].fname )-1);return 1;}/*进入子目录*ype==DIRECTORY&&strcmp(dir->fcb[i].fname,sonfname)==0){temp=i;break;}}if(i==BlockFcbCount){printf("不存在该目录!\n");return 0;}urrentBlockNum ;currentPath = currentPath+dir->fcb [temp].fname +"\\";printf("进入当前目录下的子目录成功！\n");return 1;}int exit(){name,name)==0 ){if(openlist->f[i].fatherBlockNum ==current){break;}else{printf("该文件处于打开列表中，本系统只能改写当前目录下文件!\n");return 0;}}}if(i==OPEN_MAX){printf("该文件尚未打开,请先打开后写入信息!!\n");return 0;}int active=i;int fileStartNum = openlist->f[active].currentBlockNum - 3 ;startPoint = osPoint->data[fileStartNum];endPoint = osPoint->data[fileStartNum + 1];printf("请输入文本以Ctrl D号结束:\t");char input;while(((input=getchar())!=4)) {if(startPoint < endPoint-1) {*startPoint++ = input;}else{printf("达到单体文件最大容量！");*startPoint++ = 4;break;}}return 1;}int read(char *file)/*---------选择一个打开的文件读取信息----------*/{int i,fileStartNum;char *startPoint,*endPoint;name,file)==0 ){if(openlist->f[i].fatherBlockNum ==current){break;}else{printf("该文件处于打开列表中，本系统只能阅读当前目录下文件!\n");return 0;}}}if(i==OPEN_MAX){printf("该文件尚未打开,请先打开后读取信息!\n");return 0;}int active=i;urrentBlockNum - 3 ;startPoint = osPoint->data[fileStartNum];endPoint = osPoint->data[fileStartNum + 1];printf("该文件的内容为: ");while((*startPoint)!=4&& (startPoint < endPoint)){putchar(*startPoint++);}printf("\n");return 1;}int open(char *file)ype ==GENERAL && strcmp(openlist->f [i].fname,file)==0&&openlist->f[i].fatherBlockNum == current){printf("该文件已经被打开!\n");return 0;}}n");return 0;}ype==GENERAL && strcmp(dir->fcb[i].fname,file)==0 ) {FcbIndex=i;break;}}if(i==BlockFcbCount){printf("当前目录下不存在该文件!\n");return 0;}ype = GENERAL)&&(strcmp(openlist->f [i].fname,file)==0)){if(openlist->f[i].fatherBlockNum == current) {break;}else{printf("该文件已打开，但未在当前目录下，无法关闭!\n");return 0;}}}if(i==OPEN_MAX){printf("该文件未在打开列表中!\n");return 0;}int active=i;openlist->files --;openlist->f[active].initialize();OpenFileCount--;printf("该文件已关闭!\n");return 1;}int main(){printf("@ Welcome To My Operate System Of File(FAT) @n");printf("\n 以下是使用说明书：\n"); @ \n");printf("@ exit :安全退出该文件系统,保存信息. @ \n");printf("@ mkdir dirname :创建子目录. @ \n");printf("@ rmdir dirname :删除子目录. @ \n");printf("@ ls dirname :显示当前目录下信息. @ \n");printf("@ cd dirname :更改当前目录. @ \n");printf("@ create filename :创建一个新文件,并且打开. @ \n");printf("@ write filename :选择一个打开的文件写入信息 @ \n");printf("@ read filename :选择一个打开的文件读取信息. @ \n");printf("@ rm filename :删除文件. @ \n");printf("@ open filename :打开文件. @\n");printf("@ close filename :关闭文件. @\n");printf("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n");openlist=new OPENLIST;.\n");format();printf("初始化已经完成,现在可以进行操作了!\n\n");}while(1){cout<<currentPath;cin>>cmd;if(cmd=="format"){format();}else if(cmd=="mkdir"){cin>>command;mkdir(command);}else if(cmd=="rmdir"){cin>>command;rmdir(command);}else if(cmd=="ls"){listshow();}else if(cmd=="cd"){cin>>command;changePath(command);}else if(cmd=="create"){cin>>command;create(command);}else if(cmd=="write"){cin>>command;write(command);}else if(cmd=="read"){cin>>command;read(command);}else if(cmd=="rm"){cin>>command;delfile(command);}else if(cmd=="open"){cin>>command;open(command);}else if(cmd=="close"){cin>>command;close(command);}else if(cmd=="exit"){exit();break;}else cout<<"无效指令,请重新输入:"<<endl;}printf("Thank you for using my file system!\n");return 1;}11。