操作系统磁盘文件管理源码
msdos源码解读
MS-DOS（Microsoft Disk Operating System）是微软公司开发的操作系统，最早于1981年发布。
由于MS-DOS的源代码并非公开可用，因此我们无法直接提供完整的MS-DOS源码解读。
然而，我可以向您介绍一些关于MS-DOS的基本原理和结构。
MS-DOS是一个基于命令行界面的操作系统，主要设计用于IBM PC和兼容机。
它的源代码在编写时主要使用汇编语言（如8086汇编语言），以及部分C语言。
MS-DOS的源码包含了各种功能和模块，其中一些重要的部分包括：
1. 引导扇区（Boot Sector）：这是引导操作系统的第一个扇区，通常位于存储介质的起始位置。
它包含了启动加载程序，用于加载操作系统的其他部分。
2. 文件系统：MS-DOS使用FAT（File Allocation Table）文件系统，它负责管理磁盘上文件的存储和组织。
FAT文件系统的源代码涉及到文件的创建、读取、写入、删除等操作。
3. 命令解释器（Command Interpreter）：MS-DOS提供了一个命令行解释器，用户可以通过命令行输入来与系统交互。
命令解释器的源码包括命令解析、执行和输出等功能。
4. 设备驱动程序：MS-DOS的源代码还包括了与硬件设备交互的驱动程序，如磁盘驱动器、键盘驱动器等。
这些驱动程序负责向应用程序提供对设备的访问接口。
需要注意的是，由于MS-DOS的源码并非公开可用，因此一般人无法直接查看和解读其完整的源代码。
然而，通过学习操作系统原理、汇编语言和相关文档，可以深入理解MS-DOS的工作原理和内部结构。
1。
文件系统课程设计源代码
文件系统课程设计源代码一、教学目标本课程的教学目标是使学生掌握文件系统的基本概念、原理和操作方法。
具体包括：1.知识目标：学生能够理解文件系统的定义、作用和基本组成；掌握文件、目录和磁盘空间的管理方法；了解文件系统的性能优化和安全性措施。
2.技能目标：学生能够熟练使用文件系统进行文件操作，如创建、删除、移动和权限设置；能够运用文件系统进行数据管理和备份；能够分析和解决文件系统在使用过程中遇到的问题。
3.情感态度价值观目标：培养学生对文件系统的安全意识，使其能够正确处理文件隐私和数据安全问题；培养学生珍惜资源、节约空间的意识，提高其信息技术素养。
二、教学内容教学内容主要包括以下几个部分：1.文件系统概述：介绍文件系统的基本概念、作用和组成，使学生了解文件系统在操作系统中的重要性。
2.文件和目录管理：讲解文件和目录的定义、操作方法和形式，培养学生熟练使用文件系统进行文件管理的能力。
3.磁盘空间管理：介绍磁盘空间分配策略、回收方法和优化手段，使学生掌握磁盘空间的有效利用技巧。
4.文件系统性能优化：讲解文件系统的性能指标、优化策略和调整方法，培养学生提高文件系统性能的能力。
5.文件系统安全性：介绍文件系统的安全特性、权限管理和加密方法，使学生具备较强的文件安全意识。
6.实践操作：通过实际操作演练，使学生熟练掌握文件系统的使用方法，提高实际应用能力。
三、教学方法本课程采用多种教学方法相结合的方式，以激发学生的学习兴趣和主动性：1.讲授法：教师讲解文件系统的基本概念、原理和操作方法，使学生掌握文件系统的理论知识。
2.案例分析法：分析实际案例，使学生了解文件系统在实际应用中的问题和解决方法。
3.实验法：安排上机实验，让学生亲自动手操作，提高实际应用能力。
4.讨论法：学生进行小组讨论，分享学习心得和经验，培养学生的合作精神。
四、教学资源本课程所需教学资源包括：1.教材：选用权威、实用的教材，为学生提供系统的理论知识。
Linux 0.1.1文件系统的源码阅读
Linux 0.11文件系统的源码阅读总结1.minix文件系统对于linux 0.11内核的文件系统的开发，Linus主要参考了Andrew S.Tanenbaum 所写的《MINIX操作系统设计与实现》，使用的是其中的1.0版本的MINIX文件系统。
而高速缓冲区的工作原理参见M.J.Bach的《UNIX操作系统设计》第三章内容。
通过对源代码的分析，我们可以将minix文件系统分为四个部分，如下如1-1。
●高速缓冲区的管理程序。
主要实现了对硬盘等块设备进行数据高速存取的函数。
●文件系统的底层通用函数。
包括文件索引节点的管理、磁盘数据块的分配和释放以及文件名与i节点的转换算法。
●有关对文件中的数据进行读写操作的函数。
包括字符设备、块设备、管道、常规文件的读写操作，由read_write.c函数进行总调度。
●涉及到文件的系统调用接口的实现，这里主要涉及文件的打开、关闭、创建以及文件目录等系统调用，分布在namei和inode等文件中。
图1-1 文件系统四部分之间关系图1.1超级块首先我们了解一下MINIX文件系统的组成，主要包括六部分。
对于一个360K软盘，其各部分的分布如下图1-2所示：图 1-2 建有MINIX文件系统的一个360K软盘中文件系统各部分的布局示意图注释1：硬盘的一个扇区是512B，而文件系统的数据块正好是两个扇区。
注释2：引导块是计算机自动加电启动时可由ROM BIOS自动读入得执行代码和数据。
注释3：逻辑块一般是数据块的2幂次方倍数。
MINIX文件系统的逻辑块和数据块同等大小对于硬盘块设备，通常会划分几个分区，每个分区所存放的不同的文件系统。
硬盘的第一个扇区是主引导扇区，其中存放着硬盘引导程序和分区表信息。
分区表中得信息指明了硬盘上每个分区的类型、在硬盘中其实位置参数和结束位置参数以及占用的扇区总数。
其结构如下图1-3所示。
图1-3 硬盘设备上的分区和文件系统对于可以建立不同的多个文件系统的硬盘设备来说，minix文件系统引入超级块进行管理硬盘的文件系统结构信息。
xv6操作系统整体报告
前言操作系统是一种复杂的系统软件。
本书通过介绍操作系统的基本概念和原理，并结合操作系统原理来分析一个小型但全面的操作系统xv6，并进一步进行各种基于xv6操作系统的实验，来让读者了解和掌握操作系统的设计与实现。
xv6是一个运行在基于x86架构的计算机系统上的类似UNIX的教学用操作系统。
xv6起源于MIT。
在2002年秋季，Frans Kaashoek, Josh Cates, and Emil Sit在MIT开设了一门新的实验型课程“操作系统工程”，英文名称是“Operating Systems Engineering”，课程代号是“6.097”，后改为“6.828”，在此课程上，一开始采用了“莱昂氏UNIX源代码分析”（英文书名是“Lion'Cornmentary on UNIX 6th Edition With Source Code”）作为参考资料。
此参考资料描述的UNIX v6（简称V6）是运行在古老的PDP-11计算机系统上。
为了让学生更好地理解V6的实现，Frans Kaashoek等从2006年夏季开始，参考V6的架构，在x86计算机系统上重新实现了一个支持多处理器计算机系统的类似UNIX的教学用操作系统，称为为xv6。
在目前的MIT本科生课程“6.828:Operating Systems Engineering”中，xv6主要用于讲课，而另一个基于exokernel架构的JOS主要用于做试验。
目前xv6在MIT的网址在/6.828/xv6/第零章安装使用如果是Linux初学者，请看附录F，了解如何安装、使用Ubuntu Linux，如何在Ubuntu Linux下编程。
编译[need update]安装Ubuntu Linux 8.10，具体安装方法可以参考附录C。
并通过apt工具进一步安装相关软件包$ sudo apt-get install gcc binutils libc 6-devgdb然后解压xv6软件包，到某一目录，然后到此目录下执行$make就可以生成相关执行文件和镜像，包括xv6.img(包含bootloader和xv6 kernel)和fs.img(包含应用程序)运行[need update]安装Ubuntu Linux 8.10，并通过apt工具进一步安装相关软件包$sudo apt-get install qemu bochsbios vgabios libsdl1.2debian kvm如果通过qemu执行，可执行如下命令qemu -smp 4 -parallel stdio -hdb fs.img -hda xv6.img如果通过kvm执行，可执行如下命令kvm -smp 4 -parallel stdio -hdb fs.img xv6.imgqemu和kvm的相关运行参数的含义可参考附录B。
计算机基础第4章操作系统和文件管理
用来保存文件及文件夹。有：
二、 文件分类 系统文件 按性质分 按用途分： 库文件 用户文件
光盘驱动器
普通文件 目录与文件夹 设备文件
计算机基础
第二节 文件和文件管理
三、DOS文件目录管理
A的文件 DOS文件 程序文件
B的文件
Windows文件
……
数据文件
成磁 千盘 上上 万可 个以 文存 件放
如何在磁盘上查找文件？ 不同系统文件重名怎么办？
计算机基础
第一节 操作系统基础知识
• • • •
操作系统的功能
软件和硬件 资源管理
操作系统的分类 •单\多用户 •单机\网络 •单任务\多任务 特征：
•并发性 •共享性 •虚拟性 •不确定性
•
处理机管理 存储管理 设备管理 文件管理 作业管理
计算机基础 计算机基础
第一节 操作系统基础知识 第一节 操作系统基础知识
计算机基础
第二节 文件和文件管理
四、Windows文件夹管理
与DOS相同，文件存储也是树型结构，只是文 件目录换成文件夹。 例如： D:\dzh\hlp\dzh.hlp
一级文 件夹
二级文 件夹
文件
长文件名 文件名组成与DOS相同，但文件名字符个数可以为 1--255个（可区分大小写字母），每个文件有两个 文件名：长文件名和8.3格式的别名。而DOS系统中 只能是8.3格式。
以windows 基本元素:窗口、菜单、对话框、图标、帮助 为例介绍
图形用户界面的基本元素
最小化
一、窗口
菜单栏
最大化
关闭 滚动条
文件夹图 标 状态栏
计算机基础
第三节 常用操作系统
二、菜单
GlusterFS源代码解析——GlusterFS简单介绍
GlusterFS源代码解析——GlusterFS简单介绍—— —— 本系列博客源代码是基于GlusterFS 3.4.3 版本号1. Glusterfs简单介绍是Scale-Out存储解决⽅式的核⼼，它是⼀个开源的分布式⽂件系统，具有强⼤的横向扩展能⼒，通过扩展可以⽀持数PB存储容量和处理数千client。
GlusterFS借助TCP/IP或InfiniBandRDMA⽹络将物理分布的存储资源聚集在⼀起，使⽤单⼀全局命名空间来管理数据。
GlusterFS基于可堆叠的⽤户空间设计，可为各种不同的数据负载提供优异的性能。
2. Glusterfs特点2.1 扩展性和⾼性能GlusterFS利⽤双重特性来提供⼏TB⾄数PB的⾼扩展存储解决⽅式。
Scale-Out架构同意通过简单地添加资源来提⾼存储容量和性能，磁盘、计算和I/O资源都能够独⽴添加，⽀持10GbE和InfiniBand等快速⽹络互联。
Gluster弹性哈希（ElasticHash）解除了GlusterFS对元数据server的需求，消除了单点故障和性能瓶颈，真正实现了并⾏化数据訪问。
2.2 ⾼可⽤性GlusterFS能够对⽂件进⾏⾃⼰主动复制，如镜像或多次复制，从⽽确保数据总是能够訪问，甚⾄是在硬件故障的情况下也能正常訪问。
⾃我修复功能能够把数据恢复到正确的状态，并且修复是以增量的⽅式在后台运⾏，差点⼉不会产⽣性能负载。
GlusterFS没有设计⾃⼰的私有数据⽂件格式，⽽是採⽤操作系统中主流标准的磁盘⽂件系统（如EXT3、ZFS）来存储⽂件，因此数据能够使⽤各种标准⼯具进⾏复制和訪问。
2.3全局统⼀命名空间全局统⼀命名空间将磁盘和内存资源聚集成⼀个单⼀的虚拟存储池，对上层⽤户和应⽤屏蔽了底层的物理硬件。
存储资源能够依据须要在虚拟存储池中进⾏弹性扩展，⽐⽅扩容或收缩。
当存储虚拟机映像时，存储的虚拟映像⽂件没有数量限制，成千虚拟机均通过单⼀挂载点进⾏数据共享。
操作系统 6、磁盘和文件系统
2. 3.
4.
按名存取：用户只须向系统提供所需访问文件的名字， 就能快速准确地找到指定文件在外存上的存储位臵。 加快目录的检索速度，从而提高对文件的存取速度。 文件共享：多用户系统中，允许多个用户共享一个文 件。 允许文件重名：系统应允许不同用户对不同文件采用 相同的名字。
文件控制块FCB
6、磁盘和文件系统
磁盘和文件系统
文件系统 磁盘管理 输入输出系统
文件
保存在磁盘、磁带、光盘中 文件的类型：源代码、可执行代码、文本 数据、影像、音乐、病毒 文件的属性：名称、标识符、类型、位臵、 大小、保护… 文件的操作：创建、读、写、定位、删除、 清空 文件的组织方式：顺序、索引、索引顺序
处理“冲突”（n个文件对应1个Hash值）的规则：
1. 2.
3.
如果文件名使用通配符？*，则只能使用线性方法。
文件共享
定义 ：一个文件被多个用户或程序使用 目的
节省时间和存储空间，减少用户工作量 进程间通过文件交换信息
基于有向无循环图的文件共享
基于有向无循环图的文件共享
如何建立父目录D5与共享文件F8的链接？
多级索引组织方式混合索引组织方式如果盘块的大小为4kb小文件4kb40kb的每一个盘块地址都直接放入fcb中中等文件5kb4mb采用单级索引组织方式先从fcb中找到该文件的索引表从中获得该文件的盘块地址大型文件采用两级和三级索引组织方式文件存储空间管理空闲表法属于连续分配方式为每个文件分配一块连续的存储空间外存上所有空闲区建立一张空闲表按其起始盘块号递增的次序排列
简单的文件目录
2.
Linux操作系统应用编程课件(完整版)
2．Linux操作系统的发行版
Linux操作系统发行版实际就是Linux内核加上外围实用程序 组成的一个大软件包。相对于Linux操作系统的内核版本，发行版 的版本号随发布者的不同而不同，与Linux操作系统内核的版本号 是相对独立的。因此把SUSE、RedHat、Ubuntu、Slackware等直 接称为Linux是不确切的，它们是Linux操作系统的发行版。更确 切地说，应该将它们称为“以Linux为核心的操作系统软件包”。
Shell是Linux操作系统的一种用户界面，它作为操作系统 的“外壳”，为用户提供使用操作系统的接口。Shell主要有以 下两大功能特点。
（1）Shell是一个命令解释器，它拥有自己内建的Shell命令集。 （2）Shell的另一个重要特性是它自身就是一种解释型的程序设 计语言。
当用户成功登录Linux系统后，系统将执行一个Shell程序。 正是Shell进程提供了命令提示符。作为默认值，Shell对普通用 户用“$”作提示符，对超级用户（root）用“#”作提示符。
1.4.4 联机手册
联机手册命令man可向用户提供系统中各种命令、系统调用、 库函数和重要系统文件的详细说明，包括名字、使用语法、功能 描述、应用实例和相关参考文件等。其格式如下：
$ man [拥有哪个级别的帮助。 -k：查看和命令相关的所有帮助。
查看who命令的详细说明示例如下。 $ man who
Linux操作系统 应用编程
本章主要介绍Linux文件系统，包括文件系统的结构、文 件的定义与分类、目录与文件操作命令、文件的权限管理等， 让读者对Linux文件系统有一定的认识和理解，为后文的学习 打下基础。
2.1.1 组织结构
Linux操作系统中所有文件存储在文件系统中，文件被组织 到一棵“目录树”中，其文件系统层次结构（树状目录结构）如 图2.1所示。树根在该层次结构的顶部，树根的下方衍生出子目 录分支。
centos 查看磁盘空间大小的命令
centos 查看磁盘空间大小的命令CentOS是一种基于Linux内核的操作系统，它是一个免费开放源代码的平台，用于构建现代化的网络服务器和个人计算机。
在CentOS中，可以使用一些命令来查看磁盘空间的大小。
接下来，我们将一步一步回答“centos查看磁盘空间大小的命令”，以指导您如何查找和管理磁盘空间。
步骤1：登录到CentOS系统首先，您需要登录到CentOS系统。
您可以通过使用SSH客户端（如PuTTY）或直接在本地访问控制台来完成。
步骤2：打开终端在登录到CentOS系统后，您需要打开一个终端窗口。
可以在“应用程序”菜单中找到终端或使用快捷键Ctrl + Alt + T打开。
步骤3：使用df命令查看磁盘空间CentOS系统提供了df命令，用于查看文件系统磁盘空间的使用情况。
该命令的基本语法如下：df [options] [directory]可以使用以下命令中的选项和参数之一：- -h：以可读性较好的方式显示输出结果。
- -H：基于1000（而不是1024）进行磁盘空间计算。
如果未指定目录参数，则显示所有与文件系统相关的信息。
如果指定了目录参数，则只显示指定目录的磁盘空间信息。
例如，要查看所有文件系统的磁盘空间信息，请运行以下命令：df -h此命令会显示每个文件系统的名称、挂载点、已用空间、可用空间和文件系统类型等信息。
以人类可读的格式显示磁盘空间大小，如G（GB）或M（MB）。
步骤4：使用du命令查看目录的磁盘空间df命令主要用于查看文件系统的磁盘空间。
如果您想查看某个特定目录的详细信息，包括子目录和文件的大小，可以使用du命令。
du命令的基本语法如下：du [options] [directory]使用以下选项之一：- -h：以可读性较好的方式显示输出结果。
- -s：只显示目录的总大小，而不显示子目录的详细信息。
例如，要查看当前目录的详细信息，请运行以下命令：du -h这将显示当前目录以及其中每个子目录和文件的大小。
LINUX操作系统配置规范
LINUX操作系统配置规范Linux操作系统是一种开放源代码的操作系统，相对于其他操作系统，Linux具有较大的灵活性和可定制性。
在实际应用中，为了保证Linux系统的性能和安全性，需要按照一定的规范进行配置。
下面将介绍一些常见的Linux操作系统配置规范。
1.安全性配置：- 禁止使用root账户远程登录，使用普通用户登录系统。
-设置复杂的用户密码，定期修改用户密码。
-安装并启用防火墙，限制网络访问权限。
-安装常用的安全软件，如杀毒软件和入侵检测系统。
-定期更新操作系统和软件包，修复安全漏洞。
2.网络配置：-配置正确的IP地址、子网掩码和网关。
- 禁止使用未加密的传输协议，如Telnet，使用SSH进行远程登录。
- 使用iptables配置防火墙规则，限制网络访问权限。
-配置DNS服务器，加速域名解析。
3.磁盘和文件系统配置：- 对磁盘进行分区，并将关键目录（如/, /usr, /var等）挂载到单独的分区上，以提高系统性能和安全性。
-使用LVM（逻辑卷管理器）对磁盘进行管理，方便动态扩展和迁移。
4.内核参数配置：-调整文件描述符限制，避免文件打开过多导致系统崩溃。
-调整内核参数，优化系统性能，如内存管理、磁盘I/O等参数。
-禁用不必要的内核模块，减少潜在的安全隐患。
5.日志监控与管理：-配置系统日志，记录关键操作和事件。
-定期检查日志文件，及时发现异常情况。
-使用日志分析工具，对日志文件进行分析，提取有用信息。
6.服务配置：-禁止不必要的服务和进程，减少安全风险。
-配置开机自启动的服务，确保系统正常运行。
-设置服务的资源限制，避免资源占用过多导致系统宕机。
7.软件包管理：-使用包管理器安装软件包，避免从源代码编译安装。
-定期更新软件包，修复漏洞和提升性能。
-删除不必要的软件包，减少系统资源占用。
8.工作目录和文件权限：-限制普通用户对系统核心文件的访问权限。
-设置用户家目录的权限，确保用户的私密数据不会被其他用户读取。
MINIX实现
调度相关函数（kernel\proc.c）
三级进程队列：rdy_head[NQ]、rdy_tail[NQ]（kernel\proc.h） proc_ptr：全局变量，指向当前应该运行的进程
关于进程调度机制实现过程的思考
选择合适的进程运行：pick_proc函数（7176行） 进程状态转化：变为就绪态和被阻塞，ready函数和unready函数 （7207行） 用户进程的时间片轮转：sched函数（7308行）
7
操作系统课程讲义
代码结构与数据结构
与硬件环境相关的头文件
针对CPU和设备驱动的宏定义
include/minix/config.h（2600行）
针对键盘布局、硬盘分区的头文件
include/minix/keymap.h、partition.h
针对IBM硬件平台的专有头文件
include/ibm/diskparm.h，partition.h
Minix中的系统任务结构
kernel\table.c中定义，注意Extern的用法
20
操作系统课程讲义
内容提要
内容提要
代码结构组织与数据结构定义 专题1——操作系统的启动过程 专题2——操作系统的进程管理 专题3——操作系统的设备管理 专题4——操作系统的内存管理 专题5——操作系统的文件管理
如何启动进程调度机制呢？ 如何实现进程状态的自动转化呢？ 如何保证OS运行的稳定呢？（关中断的锁变量）
23
操作系统课程讲义
操作系统的进程管理
Minix中的进程通信
进程通信的基本知识
操作系统对中断（硬件中断和软件中断）的响应机制 消息传递的运行机制（还记得消息机制的实现方法吗）
文件系统的目录结构
文件系统的目录结构在Linux下，用户所见到的文件空间是基于树状结构的，树的根在顶部。
在这个空间中的各种目录和文件从树根向下分支，顶层目录(/)被称为根目录。
Linux操作系统由一些目录和许多文件组成。
根据用户选择的安装不同，这些目录可能是不同的文件系统。
通常，大多数操作系统都驻存在两个文件系统上：即称为/的根文件系统和安装在/usr下的文件系统。
如果你用cd /命令将当前目录改变到根目录，并用ls命令列出目录清单，你就会看到一些目录。
这些目录组成了根文件系统的内容，它们也为其他文件系统提供了安装点。
/bin目录包含称为二进制(binary)文件的可执行程序(事实上，名为/bin的目录是binary的缩写)。
这些程序是必需的系统文件，许多Linux命令(如ls)放在该目录中。
/sbin目录也用于存储系统二进制文件。
这个目录中的大多数文件用于管理系统。
/etc目录非常重要，它包含许多Linux系统配置文件。
从本质上说，这些文件使你的Linux系统具有自己的个性。
口令文件(口令)就放在这里，在启动时安装的文件系统列表(fstab)也放在这里。
另外，这个目录还包括Linux的启动脚本、你想要永久记录的、带IP地址的主机列表和许多其他类型的配置信息。
/lib目录中存储着程序运行时使用的共享库被存储在此。
通过共享库，许多程序可以重复使用相同的代码，并且这些库可以存储在一个公共的位置上，因此能减小运行程序的大小。
/dev目录包含称为设备文件的特殊文件，这些文件用于访问系统上所有不同类型的硬件。
例如，/dev/mouse文件是用于读取鼠标输入的。
通过用这种方法组织对硬件设备的访问，Linux有效地使硬件设备的接口看起来就象一个文件。
这意味着在许多情况下，你可以用对软件使用的相同语法来对计算机的硬设备进行操作。
例如，为了在软盘驱动器上建立你的起始目录的磁盘档案，你可以使用下面的命令：tar -cdf /dev/fd0 tackett/dev目录中的许多设备都放在逻辑组中，下表列出了/dev目录中一些最常用/proc目录实际上是一个虚拟文件系统，它被用于从内存中读取处理信息。
linux操作系统教程-实训与项目案例原稿
进行应用调试、测试和发布，确保应用在各种设备和平台上运行 稳定、性能良好。
THANKS
感谢观看
• 源代码编译安装：除了使用软件包管理工具外，还可以从源代码编译安装软件 。这种方法需要手动下载源代码、配置编译选项、编译源代码并安装程序。虽 然比较繁琐，但可以获得最新版本或定制化安装的需求。
进程管理
进程概述
进程是Linux系统中正在运行的程序的实例。每个进程都有相应的进程ID（PID）和其他属性， 如父进程ID（PPID）、进程状态等。
自动化测试与日志分析
使用工具如Selenium或ELK Stack，实现自动化测试和日志分析， 提高运维效率和质量。
移动应用开发环境搭建
移动开发框架选择
根据开发需求选择合适的移动开发框架，如React Native或 Flutter。
开发环境搭建
安装开发工具、配置开发环境、安装依赖库等，确保移动应用开 发顺利进行。
历史发展
Linux经历了从最初的小型项目到 全球广泛使用的操作系统的转变 ，对计算机技术的发展产生了深 远影响。
Linux的特点和优势
特点
Linux是一款自由和开放源代码的操 作系统，具有强大的可定、高可靠性 和强大的网络功能，广泛应用于服务 器、云计算、移动设备和物联网等领 域。
用户和权限管理
用户管理
用户组管理
权限管理
sudo的使用
Linux系统中，用户是独立的 实体，每个用户都有自己的用 户名、密码和主目录等属性。 管理员可以创建、删除、禁用 或启用用户账户，并设置相应 的权限和属性。
用户组是具有相同权限的一组 用户的集合。通过将用户添加 到不同的用户组，可以方便地 管理用户的权限和访问控制。
天脉操作系统文件系统编译
天脉操作系统文件系统编译天脉操作系统是一款面向服务器和大型计算机的高性能操作系统，具有高度可靠性和可扩展性。
其文件系统是天脉操作系统的一个重要组成部分，用于管理和存储文件和目录。
文件系统的编译是为了将文件系统的源代码转换成可执行文件，以便在操作系统中运行。
文件系统的编译过程主要包括以下几个步骤：预处理、编译、汇编和链接。
首先是预处理阶段，预处理器将源代码中的宏定义、条件编译和包含其他文件等预处理指令进行展开和处理，生成经过预处理后的源代码。
预处理的目的是为了减少代码的复杂性，准备好编译器所需的源代码。
接下来是编译阶段，编译器将预处理后的源代码翻译成汇编代码，这个过程主要包括词法分析、语法分析、语义分析和代码生成等步骤。
编译器会检查代码的语法错误和语义错误，并生成对应的汇编代码。
然后是汇编阶段，汇编器将汇编代码转换成机器码，生成目标文件。
目标文件是一种中间文件，它包含了汇编代码的二进制表示和一些必要的元信息。
汇编器会对汇编代码进行符号解析、地址计算和重定位等处理，生成可执行文件的最后一部分。
最后是链接阶段，链接器将目标文件和其他必要的库文件进行合并，生成最终的可执行文件。
链接过程主要包括符号解析、地址空间分配、重定位和符号表生成等步骤。
链接器会解析目标文件中的符号引用，将其与定义进行关联，并设置合适的地址。
在天脉操作系统的文件系统编译过程中，还需要针对特定的硬件平台进行优化处理，以提高文件系统的性能和可靠性。
这可能涉及到文件系统的存储结构设计、磁盘分配策略和文件索引方式等方面的调优。
总结起来，天脉操作系统文件系统的编译过程包括预处理、编译、汇编和链接四个主要的阶段。
预处理阶段主要是对源代码中的预处理指令进行展开和处理；编译阶段将预处理后的源代码翻译成汇编代码；汇编阶段将汇编代码转换成目标文件；链接阶段将目标文件和库文件合并生成可执行文件。
编译过程中还需要进行硬件平台的优化处理，以达到更高的性能和可靠性。
文件管理系统源代码
文件管理系统一、实验目的通过设计一个多用户文件系统，了解操作系统中文件的组织与管理，熟悉文件管理所用的数据结构，加深对文件系统内部功能实现过程的理解。
二、实验内容1．用C语言或C++语言设计一个最多包括N个用户的多用户文件系统，约定每个用户最多保存M个文件。
同时限制一个用户在进入系统后，最多打开L个文件。
2．系统应具备一定的健壮性。
即能够检查用户所输入命令的正确性，出错时显示出必要的信息。
另外，对文件需设置必要的保护措施。
3．文件目录结构采用两级目录结构：主文件目录和用户文件目录#include"io.h"#include"conio.h"#include"stdio.h"#include"stdlib.h"#include"malloc.h"#include"string.h"#include"ctype.h"#define N 30 /*用户数*/#define M 20 /*一个用户可保存M个文件*/#define L 5 /*用户只能一次打开L个文件*/typedef struct MFD /*主文件目录*/{char username[100];char password[100];FILE fp; /*文件指针*/}MFD;///////////typedef struct UFD /*用户文件目录*/{char filename[256];char protect; /*保护码*/int length; /*文件长度*/}UFD;//////////typedef struct OFD /*打开文件目录*/{char filename[256];char opencode; /*打开保护码*/int fp; /*读写指针*/}OFD;//////////typedef struct COMM /*命令串*/{char string[256]; /*命令*/struct COMM *next;/*后继指针*/}COMM;////////////MFD mainfd[N]; /*主文件目录数组*/UFD userfd[M]; /*用户文件目录数组*/OFD openfd[L]; /*打开文件目录数组*/////////COMM*command; /*命令串指针*/char username[10];int usernum,savenum,opennum;int workfile;void init();void init_ufd(char *username);/*初始化用户文件目录*/ void mesg(char *str); /*消息*/char *getpass(); /*设置口令函数声明*/ char *getuser(); /*设置用户函数声明*/ COMM *readcommand(); /*读命令串函数声明*/ void login(); /*用户登录*/void logout(); /*用户注销*/void setpass(); /*设置口令*/void create(); /*创建文件*/void mydelete(); /*删除文件*/void myread(); /*读文件*/void myopen(); /*打开文件*/void myclose(); /*关闭文件*/void mywrite(); /*写文件*/void help(); /*帮助*/void dir(); /*列文件目录*/void mycopy(); /*复制文件*/void myrename(); /*重命名文件名*//////////////void main(){init();for(;;){readcommand();if(strcmp(command->string,"create")==0)create();else if(strcmp(command->string,"delete")==0)mydelete();else if(strcmp(command->string,"open")==0)myopen();else if(strcmp(command->string,"close")==0)myclose();else if(strcmp(command->string,"read")==0)myread();else if(strcmp(command->string,"write")==0)mywrite();else if(strcmp(command->string,"copy")==0)mycopy();else if(strcmp(command->string,"rename")==0)myrename();else if(strcmp(command->string,"login")==0)login();else if(strcmp(command->string,"setpass")==0)setpass();else if(strcmp(command->string,"logout")==0)logout();else if(strcmp(command->string,"help")==0)help();else if(strcmp(command->string,"dir")==0)dir();else if(strcmp(command->string,"exit")==0)break;elsemesg("Bad command!");}}///////////////////void init(){FILE *fp;char tempname[20],temppass[20];int i=0;usernum=0;savenum=0;opennum=0;strcpy(username,"");if((fp=fopen("mainfile.txt","r"))!=NULL){while(!feof(fp)){strcpy(tempname,"");fgets(tempname,20,fp);if(strcmp(tempname,"")!=0){fgets(temppass,20,fp);tempname[strlen(tempname)-1]='\0';temppass[strlen(tempname)-1]='\0';strcpy(mainfd[usernum].username,tempname);strcpy(mainfd[usernum].password,tempname);usernum++;}}fclose(fp);}}///////////////////////void init_ufd(char *username)/*初始化用户文件目录*/{FILE *fp;char tempfile[100],tempprot;int templength;savenum=0;opennum=0;workfile=-1;if((fp=fopen(username,"w+"))!=NULL){while(!feof(fp)){strcpy(tempfile,"");fgets(tempfile,50,fp);if(strcmp(tempfile,"")!=0){fscanf(fp,"%c",&tempprot);fscanf(fp,"%d",&templength);tempfile[strlen(tempfile)-1]='\0';strcpy(userfd[savenum].filename,tempfile);userfd[savenum].protect=tempprot;userfd[savenum].length=templength;savenum++;fgets(tempfile,50,fp);}}}fclose(fp);}////////////////////void mesg(char *str){printf("\n %s\n",str);}////////////////////////////char *getuser(){char username[20];char temp;int i;username[0]='\0';for(i=0;i<10;){while(!kbhit());temp=getch();if(isalnum(temp)||temp=='_'||temp==13){username[i]=temp;if(username[i]==13){username[i]='\0';break;}putchar(temp);i++;username[i]='\0';}}return(username);}///////////////////char *getpass(){char password[20];char temp;int i;password[0]='\0';for(i=0;i<10;){while(!kbhit());temp=getch();if(isalnum(temp)||temp=='_'||temp==13){password[i]=temp;if(password[i]==13){password[i]='\0';break;}putchar('*');i++;password[i]='\0';}}return(password);}///////////////COMM *readcommand(){char temp[256];char line[256];int i,end;COMM *newp,*p;command=NULL;strcpy(line,"");while(strcmp(line,"")==0){printf("\nc:\\>");gets(line);}for(i=0;i<=strlen(line);i++){if(line[i]==' ')i++;end=0;while(line[i]!='\0'&&line[i]!=' '){temp[end]=line[i];end++;i++;}if(end>0){temp[end]='\0';newp=(COMM *)malloc(sizeof(COMM *));strcpy(newp->string,temp);newp->next=NULL;if(command==NULL)command=newp;else{p=command;while(p->next!=NULL)p=p->next;p->next=newp;}}}p=command;return(command);}/////////////////////////////void login() /*用户注册*/{FILE *fp;int i;char password[20],confirm[20],tempname[20];if(command->next==NULL){printf("\n User Name:");strcpy(tempname,getuser());}else if(command->next->next!=NULL){mesg("Too many parameters!");return;}elsestrcpy(tempname,command->next->string);for(i=0;i<usernum;i++)if(strcmp(mainfd[i].username,tempname)==0)break; /*从mainfd表中查找要注册的用户*/ if(i>=usernum) /*新用户*/{printf("\n new user account,enter your password twice!");printf("\n Password:");strcpy(password,getpass());/*输入口令且返回之*/printf("\n Password:");strcpy(confirm,getpass()); /*第二次输入口令*/if(strcmp(password,confirm)==0)/*用户数不能超过N*/{if(usernum>=N)mesg("Create new account false!number of user asscount limited.\n login fasle!");else{strcpy(mainfd[usernum].username,tempname);/*把新用户和口令填入mainfd中*/strcpy(mainfd[usernum].password,password);usernum++;strcpy(username,tempname);mesg("Create a new user!\n login success!");init_ufd(username); /*初始化用户文件目录*/fp=fopen("mainfile.txt","w+"); /*把新用户填入mainfile.txt文件中*/for(i=0;i<usernum;i++){fputs(mainfd[i].username,fp);fputs("\n",fp);fputs(mainfd[i].password,fp);fputs("\n",fp);}fclose(fp);}}else{mesg("Create new account false! Error password.");mesg("login false!");}}else{printf("\n Password:");strcpy(password,getpass());if(strcmp(mainfd[i].password,password)!=0)mesg("Login false! Error password.");else{mesg("Login success!");strcpy(username,tempname);init_ufd(username);}}}/////////////////////////void logout() /*用户注销*/{if(command->next!=NULL)mesg("Too many parameters!");else if(strcmp(username,"")==0)mesg("No user login!");else{strcpy(username,"");opennum=0;savenum=0;workfile=-1;mesg("User logout!");}}////////////////////void setpass() /*修改口令*/{int i=0;FILE *fp;char oldpass[20],newpass[20],confirm[20];if(strcmp(username,"")==0)mesg("No user login!");else{printf("\n Old password:");strcpy(oldpass,getpass());for(int i=0;i<usernum;i++){if(strcmp(mainfd[i].username,username)==0)break;}if(strcmp(mainfd[i].password,oldpass)!=0)mesg("Old password error!");else{printf("\n New password:");strcpy(newpass,getpass());printf("\n Confirm password:");strcpy(confirm,getpass());if(strcmp(newpass,confirm)!=0)mesg("Password not change! confirm different.");else{strcpy(mainfd[i].password,newpass);mesg(" Password change !");fp=fopen("mainfile.txt","w+");for(i=0;i<usernum;i++){fputs(mainfd[i].username,fp);fputs("\n",fp);fputs(mainfd[i].password,fp);fputs("\n",fp);}fclose(fp);}}}}////////////////void create(){int i=0;FILE *fp;if(strcmp(username,"")==0)mesg("No user lgoin!");else if(command->next==NULL)mesg("Too few parametets!");else if(command->next->next!=NULL)mesg("Too many parameters!");else{for(i=0;i<savenum;i++){if(strcmp(userfd[i].filename,command->next->string)==0)break;}if(i<savenum)mesg("Error! the file already existed!");else if(savenum>=M)mesg("Error! connot create file! number of files limited!");else{strcpy(userfd[savenum].filename,command->next->string);userfd[i].protect='r';userfd[i].length=rand();savenum++;mesg("Create file success!");fp=fopen(username,"w+");for(i=0;i<savenum;i++){fputs(userfd[i].filename,fp);fputs("\n",fp);fprintf(fp,"%c\n%d\n",userfd[i].protect,userfd[i].length);}fclose(fp);}}}/////////////////void mydelete() /*删除*/{int i=0;int tempsave=0;FILE *fp;if(strcmp(username,"")==0)mesg("No user lgoin!");else if(command->next==NULL)mesg("Too few parametets!");else if(command->next->next!=NULL)mesg("Too many parameters!");else{for(i=0;i<savenum;i++){if(strcmp(userfd[i].filename,command->next->string)==0)break;}if(i>=savenum)mesg("Error! the file not existed!");else{tempsave=i;for(i=0;i<opennum;i++){if(strcmp(command->next->string,openfd[i].filename)==0)break;}if(i>=opennum)mesg("File not open");////////////////////////////////////////////else{if(tempsave==savenum-1)savenum--;else{for(;tempsave<savenum-1;tempsave++){strcpy(userfd[tempsave].filename,userfd[tempsave+1].filename);userfd[tempsave].protect=userfd[tempsave+1].protect;userfd[tempsave].length=userfd[tempsave+1].length;}savenum--;}mesg("Delete file success!");fp=fopen(username,"w+");for(i=0;i<savenum;i++){fputs(userfd[i].filename,fp);fputs("\n",fp);fprintf(fp,"%c\n%d\n",userfd[i].protect,userfd[i].length);}fclose(fp);}}}}//////////////////void myread() /*读*/{int i=0;int tempsave=0;char tempfile[100];if(strcmp(username,"")==0)mesg("No user lgoin!");else if(command->next==NULL)mesg("Too few parametets!");else if(command->next->next!=NULL)mesg("Too many parameters!");elsestrcpy(tempfile,command->next->string);for(i=0;i<savenum;i++){if(strcmp(tempfile,userfd[i].filename)==0)break;}if(i>=savenum)mesg("File not existed!");else{tempsave=i;for(i=0;i<opennum;i++){if(strcmp(tempfile,openfd[i].filename)==0)break;}if(i>=opennum)mesg("File not opened");else{if(userfd[tempsave].length<1000)printf("\n The file size is %d KB",userfd[tempsave].length);else if(userfd[tempsave].length==1000)printf("\n The file size is 1000 KB");elseprintf("\n The file size is %d,%d KB",userfd[tempsave].length/1000,userfd[tempsave].length%1000);mesg("File read");}}}}/////////////////void myopen()/*打开*/{int i=0;int type=0;char tempcode;char tempfile[100];if(strcmp(username,"")==0)mesg("No user login!");else if(command->next==NULL)mesg("Too few parameters!");{strcpy(tempfile,"");tempcode='r';if(strcmp(command->next->string,"/r")==0){tempcode='r';type=1;}else if(strcmp(command->next->string,"/w")==0){tempcode='w';type=1;}else if(strcmp(command->next->string,"/d")==0){tempcode='d';type=1;}else if(command->next->string[0]=='/')mesg("Error! /r/w/d request!");else if(command->next->next!=NULL)mesg("Too many parameters!");elsestrcpy(tempfile,command->next->string);if(type==1){if(command->next->next!=NULL){if(command->next->next->next!=NULL)mesg("Too many parameters!");elsestrcpy(tempfile,command->next->next->string);}elsemesg("Too few parameters!");}if(strcmp(tempfile,"")){for(i=0;i<savenum;i++){if(strcmp(tempfile,userfd[i].filename)==0)break;}if(i>=savenum)mesg("File not existed!");else{for(i=0;i<opennum;i++){if(strcmp(tempfile,openfd[i].filename)==0)break;}if(i<opennum){mesg("File already opened!");if(openfd[i].opencode!=tempcode){openfd[i].opencode=tempcode;mesg("File permission changed!");}}else if(opennum>=L){mesg("Error! connot open file! number of opened files limited!");}else{strcpy(openfd[opennum].filename,tempfile);openfd[opennum].opencode=tempcode;workfile=opennum;opennum++;mesg("File open success!");}}}}}///////////////////////void myclose()/*关闭*/{int i=0;int tempsave=0;char tempfile[100];if(strcmp(username,"")==0)mesg("No user lgoin!");else if(command->next==NULL)mesg("Too few parametets!");else if(command->next->next!=NULL)mesg("Too many parameters!");else{strcpy(tempfile,command->next->string);for(i=0;i<savenum;i++){if(strcmp(tempfile,userfd[i].filename)==0)break;}if(i>=savenum)mesg("File not existed!");else{for(i=0;i<opennum;i++){if(strcmp(tempfile,openfd[i].filename)==0)break;}if(i>=opennum)mesg("File not opened");else{if(i==opennum-1)opennum--;else{for(;i<opennum-1;i++){strcpy(openfd[i].filename,openfd[i+1].filename);openfd[i].opencode=openfd[i+1].opencode;}opennum--;}mesg("Close file success!");}}}}/////////////////////////void mywrite()/*写*/{int i=0;int tempsave=0;char tempfile[100];if(strcmp(username,"")==0)mesg("No user lgoin!");else if(command->next==NULL)mesg("Too few parametets!");else if(command->next->next!=NULL)mesg("Too many parameters!");else{strcpy(tempfile,command->next->string);for(i=0;i<savenum;i++){if(strcmp(tempfile,userfd[i].filename)==0)break;}if(i>=savenum)mesg("File not existed!");else{tempsave=i;for(i=0;i<opennum;i++){if(strcmp(tempfile,openfd[i].filename)==0)break;}if(i>=opennum)mesg("File not opened");else{mesg("File write");int tt=rand();if(userfd[tempsave].length<=1000)printf("\n The file size from %d KB to %d KB",userfd[tempsave].length,userfd[tempsave].length+tt);/* else if(userfd[tempsave].lenght=1000)printf("\n The file size from 1000 KB");*/elseprintf("\n The file size form %d,%d KB to %d,%d KB",userfd[tempsave].length/1000,userfd[tempsave].length%1000,userfd[tempsave].length+tt/10 00,userfd[tempsave].length+tt%1000);userfd[tempsave].length=userfd[tempsave].length+tt;}}}}///////////////////void help()/*帮助*/{static char *cmd[]={"login","setpass","logout","create","open","read","write","close","delete","dir","help","exit","copy","rename"};static char *cmdhlp[]={"aommand format: login [<username>]","command format:setpass","command format:logout","command format:create <filename>","command format:open [/r/w/d] <filename>","command format:read <filename>","command format:write <filename>","command format:close <filename>","command format:delete <filename>","command format:dir [/u/o/f]","command format:help [<command>]","command format:exit","command format:copy <source filename> <destination filename>","command format:rename <old filename> <new filename>"};static char *detail[]={"explain:user login in the file system.","explain:modify the user password.","explain:user logout the file system.","explain:creat a new file.","explain:/r -- read only [deflaut]\n\t /w -- list opened files \n\t /d --read,modify and delete.","explain:read the file.","explain:modify the file.","explain:close the file.","explain:delete the file.","explain:/u -- list the user account\n\t /0 -- list opened files\n\t /f --list user file[deflaut].","explain:<command> -- list the command detail format and explain.\n\t [deflaut] list the command.","explain:exit from the file sysytem.","explain:copy from one file to another file.","explain:modify the file name."};int helpnum=14;int i=0;if(command->next==NULL){mesg(cmdhlp[10]);mesg(detail[10]);mesg("step 1: login");printf("\t if old user then login,if user not exist then create new user");mesg("step 2: open the file for read(/r),write(/w)or delete(/d)");printf("\t you can open one or more files.one command can open one file");mesg("step 3: read,write or delete some one file");printf("\t you can operate one of the opened files.one command can open one file");mesg("step 4: close the open file");printf("\t you can close one of the opened files.one command can open one file");mesg("step 5: user logout.close all the user opened files");printf("\n command list:");for(i=0;i<helpnum;i++){if(i%4==0)printf("\n");printf(" %-10s",cmd[i]);}}else if(command->next->next!=NULL)mesg("Too many parameters!");else{for(i=0;i<helpnum;i++){if(strcmp(command->next->string,cmd[i])==0)break;}if(i>=helpnum)mesg("the command not existed!");else{mesg(cmdhlp[i]);mesg(detail[i]);}}}//////////////////////void dir()/*列目录文件*/{int i=0;int type=0;char tempcode;if(strcmp(username,"")==0)mesg("No user login!");else{if(command->next==NULL){tempcode='f';}else{if(strcmp(command->next->string,"/u")==0){tempcode='u';}else if(strcmp(command->next->string,"/o")==0){tempcode='o';}else if(strcmp(command->next->string,"/f")==0){tempcode='f';}else if(command->next->string[0]=='/')mesg("Error! /u/o/f request!");else if(command->next->next!=NULL)mesg("Too many parameters!");}if('u'==tempcode){printf("list the user account\n");printf("usename\n");for(i=0;i<usernum;i++){printf("%s\n",mainfd[i].username);}}else if('f'==tempcode){printf("list opened files\n");printf("filename length protect\n");for(i=0;i<savenum;i++){printf("%s%s%d%s%s%c\n",userfd[i].filename," ",userfd[i].length,"KB"," ",userfd[i].protect);}}else if('o'==tempcode){printf("list user files\n");printf("filename opencode\n");for(i=0;i<opennum;i++){printf("%s%s%c\n",openfd[i].filename," ",openfd[i].opencode);}}}}/////////////////////////void mycopy()/*复制*/{char sourfile[256],destfile[256];int i=0,j=0,temp=0;FILE *fp;char tempchar;if(strcmp(username,"")==0)mesg("No user lgoin!");else if(command->next==NULL)mesg("Too few parametets!");else if(command->next->next==NULL)mesg("Too few parametets!");else if(command->next->next->next!=NULL)mesg("Too many parameters!");else{strcpy(sourfile,command->next->string);strcpy(destfile,command->next->next->string);for(i=0;i<savenum;i++){if(strcmp(sourfile,userfd[i].filename)==0)break;}temp=i;if(i>=savenum)printf("\n the source file not eixsted!");else{for(i=0;i<opennum;i++){if(strcmp(sourfile,openfd[i].filename)==0)break;}if(i>=opennum)printf("\n the source file not opened!");else{for(j=0;j<opennum;j++){if(strcmp(destfile,openfd[i].filename)==0)break;}if(j<opennum)mesg("Error! the destination file opened,you must close it first.");else{for(j=0;j<savenum;j++){if(strcmp(destfile,userfd[i].filename)==0)break;}if(j<savenum){mesg("Warning! the destination file exist!");printf("\n Are you sure to recover if ? [Y/N]");while(!kbhit());tempchar=getch();if(tempchar=='N'||tempchar=='n')mesg("Cancel! file not copy.");else if(tempchar=='Y'||tempchar=='y'){mesg("File copy success!file recovered!");userfd[j].length=userfd[i].length;userfd[j].protect=userfd[i].protect;fp=fopen(username,"w+");for(i=0;i<savenum;i++){fputs(userfd[i].filename,fp);fputs("\n",fp);fprintf(fp,"%C\n%d\n",userfd[i].protect,userfd[i].length);}fclose(fp);}}else if(savenum>=M)mesg("copy false! file total limited.");else{strcpy(userfd[savenum].filename,destfile);userfd[savenum].length=userfd[temp].length;userfd[savenum].protect=userfd[temp].protect;savenum++;fp=fopen(username,"w+");for(i=0;i<savenum;i++){fputs(userfd[i].filename,fp);fputs("\n",fp);fprintf(fp,"%c\n%d\n",userfd[i].protect,userfd[i].length);}fclose(fp);mesg("File copy success!");}}}}}}///////////////////////void myrename()/*文件重命名*/{char oldfile[256],newfile[256];int i=0,temp=0;if(strcmp(username,"")==0)mesg("No user lgoin!");else if(command->next==NULL)mesg("Too few parametets!");else if(command->next->next==NULL)mesg("Too few parametets!");else if(command->next->next->next!=NULL)mesg("Too many parameters!");else{strcpy(oldfile,command->next->string);strcpy(newfile,command->next->next->string);for(i=0;i<savenum;i++){if(strcmp(oldfile,userfd[i].filename)==0)break;}temp=i;if(temp>=savenum)printf("\n the source file not eixsted!");else if(temp!=i&&i<savenum){printf("\n newfile and the existing files is the same name, please re-naming!");}else{for(i=0;i<opennum;i++){if(strcmp(oldfile,openfd[i].filename)==0)break;}if(i>=opennum)printf("\n the source file not opened!");else if(strcmp(oldfile,newfile)==0){printf("Rename false! oldfile and newfile can not be the same.");}else{strcpy(openfd[i].filename,newfile);strcpy(userfd[temp].filename,newfile);mesg("Rename file success!\n");}}}}。
ucore文件系统详解
ucore⽂件系统详解最近⼀直在mooc上学习清华⼤学的操作系统课程，也算是复习下基本概念和原理，为接下来的找⼯作做准备。
每次深⼊底层源码都让我深感操作系统实现的琐碎，即使像ucore这样简单的kernel也让我烦躁不已，⽂件系统相⽐于中断⼦系统、调度⼦系统、进程管理⼦系统等等，要复杂很多，因此被称为⽂件系统⽽不是⽂件⼦系统。
参看⽹络上的资料有时会增加我的困惑，很多⼈只是简单转载，很多细节描述的很模糊，实验环境也各不相同，最终很难深⼊理解⽂件系统的本质，参考源码我觉得有点像从三维世界进⼊到⼆维世界，⼀切变得清晰但是却需要消耗更多精⼒，我觉得这样做是值得的，因为如果不能深⼊⽽只是泛泛的理解，对于操作系统这样偏向于⼯程学的东西来说意义不⼤，本⽂的研究内容主要是根据清华⼤学陈渝副教授、向勇副教授在mooc上所讲，以及实验参考书的内容和我⾃⼰在系统上打的log验证过的，如果有读者发现错误还请批评指正。
本篇博客希望尽可能照顾到初学者，但是有些简单原理默认读者已经掌握，很多细节不会展开叙述，读者请⾃⾏Google或者参看Intel Development Manual，实验⽤的源码来⾃于清华⼤学教学操作系统，读者可在github上搜索ucore_os_lab。
附上ucore的实验参考书.综述最初实现⽂件系统是为了实现对磁盘数据的⾼效管理，使得⽤户可以⾼效、快速的读取磁盘上的数据内容。
其实我个⼈觉得⽂件系统就是操作系统内核和外设之间的⼀套输⼊输出协议，我们所采⽤的算法和索引结点的建⽴⽅式都是为了根据实际应⽤情况所设计的⼀套⾼效的协议。
在实现的过程中，我们还要将⽂件系统进⾏分层抽象，也就是实现我们的虚拟⽂件系统，虚拟⽂件系统有对上和对下两个⽅⾯，对上是为了向上层应⽤提供⼀套通⽤的访问接⼝，可以⽤相同的⽅式去访问磁盘上的⽂件（包括⽬录，后⾯会介绍）和外设；对下兼容不同的⽂件系统和外设。
虚拟⽂件系统的层次和依赖关系如下图所⽰：对照上⾯的层次我们再⼤致介绍⼀下⽂件系统的访问处理过程，加深对⽂件系统的总体理解。
操作系统的作用与功能
操作系统的作用与功能操作系统的作用与功能一、引言操作系统（Operating System）是指控制和管理计算机硬件与软件资源，合理地组织和调度计算机系统资源的一种系统软件。
它是计算机系统中最基本、最重要的部分，负责管理计算机的硬件资源和软件资源，为用户提供良好的计算环境。
二、作用1：硬件管理：操作系统负责管理计算机的硬件资源，包括中央处理器（CPU）、内存、磁盘、输入/输出设备等。
它通过分配和调度这些资源，使其能够高效地工作和协同运行。
1.1 CPU管理：操作系统决定把CPU分配给哪个进程，调度多个进程同时运行，避免进程之间的冲突和竞争。
1.2 内存管理：操作系统管理内存的分配、回收、共享，保证每个进程都能够得到足够的内存空间。
1.3 磁盘管理：操作系统管理磁盘上的文件系统，包括文件的存储、组织和读写操作。
1.4 设备管理：操作系统管理输入/输出设备的分配和调度，使多个设备能够高效地工作，提高系统的可用性和吞吐率。
2：资源管理：操作系统负责管理计算机系统的各种资源，包括处理器、内存、文件、设备等。
它通过对资源的分配和调度，合理利用有限的资源，提高系统的性能和效率。
2.1 进程管理：操作系统创建、销毁和调度进程，管理进程之间的通信和同步，确保多个进程能够安全地并发执行。
2.2 内存管理：操作系统管理内存的分配和回收，调度内存中的进程和数据，提高内存的利用率和效率。
2.3 文件管理：操作系统管理文件的存储、组织和访问，为用户提供方便的文件操作界面和文件系统接口。
2.4 设备管理：操作系统管理输入/输出设备的分配和调度，提供设备驱动程序和设备管理接口，使设备能够高效地工作。
3：用户接口：操作系统为用户提供了一种与计算机系统交互的方式，使用户能够操作和管理计算机系统，实现自己的计算需求。
3.1 命令行界面：操作系统提供命令行界面，用户可以通过命令输入和操作文件、进程等。
3.2 图形界面：操作系统提供图形界面，用户可以通过鼠标和图形化的窗口操作和管理计算机系统。
什么是操作系统列举一些常见的操作系统
什么是操作系统列举一些常见的操作系统操作系统是计算机系统中最核心的软件之一，它负责管理计算机硬件和软件资源，为用户和应用程序提供方便的接口和环境。
在这篇文章中，我们将介绍什么是操作系统，并列举一些常见的操作系统。
一、什么是操作系统操作系统是一种系统软件，它是计算机系统中最基本、最核心的一部分。
它充当计算机硬件和应用软件之间的接口，负责管理和调度计算机系统的各种资源，提供统一的用户接口和环境，使计算机能够高效地工作。
操作系统的功能主要包括以下几个方面：1.进程管理：操作系统负责创建、调度、终止和管理进程。
它为每个进程分配资源，包括内存、CPU时间和其他设备等，以保证它们能够正常运行。
2.内存管理：操作系统管理计算机的内存资源，包括内存的分配、回收和保护等。
它为每个进程分配一定的内存空间，并实现内存的虚拟化，使每个进程都能够独立地访问一定的内存空间。
3.文件系统：操作系统负责管理和组织计算机上的文件和目录。
它提供了一种统一的方式来访问和管理文件，使用户能够方便地进行文件的创建、读取、写入和删除等操作。
4.设备管理：操作系统管理和控制计算机的各种硬件设备，包括输入输出设备、磁盘、打印机等。
它负责分配和调度设备资源，并提供相应的接口和驱动程序，以便用户和应用程序可以方便地使用这些设备。
5.用户接口：操作系统为用户提供了一种统一的用户接口，使用户可以通过命令行或图形界面与计算机进行交互。
它还提供了一些系统工具和实用程序，以方便用户进行操作和管理。
二、常见的操作系统目前，市场上存在着多种操作系统，下面列举一些常见的操作系统：1. Windows：Windows是由微软公司开发的一款广泛使用的操作系统。
它提供了直观的用户界面和丰富的应用程序支持，适用于个人电脑和服务器等各种场景。
2. Mac OS：Mac OS是由苹果公司开发的操作系统，专门用于苹果的Mac电脑。
它以其稳定性和出色的用户体验而闻名，广受苹果用户的喜爱。
mkfs.ext4 精简编译
mkfs.ext4 精简编译目录1. 前言2. mkfs.ext4 简介3. mkfs.ext4 编译步骤4. mkfs.ext4 参数解释5. 结语1. 前言在计算机领域，文件系统是操作系统用来管理文件在存储设备上的组织和存储的一种机制。
其中，ext4 是一种用于 Linux 操作系统的文件系统类型，是 ext3 文件系统的后继者。
在使用 ext4 文件系统之前需要进行格式化，而 mkfs.ext4 则是 Linux 上用来格式化 ext4 文件系统的命令。
2. mkfs.ext4 简介mkfs.ext4 是 Linux 系统上用于创建 ext4 文件系统的命令，通常情况下需要在格式化新建硬盘分区或者使用已有分区之前使用。
mkfs.ext4 命令可以在终端中直接执行，其基本格式为：mkfs.ext4 [选项] 设备在执行 mkfs.ext4 命令时，用户可以根据需要使用不同的选项来设置文件系统的参数，以满足特定的需求。
下面将介绍 mkfs.ext4 的编译步骤以及常用的参数解释。
3. mkfs.ext4 编译步骤编译 mkfs.ext4 命令需要经过以下步骤：- 下载源代码用户可以从 Linux 官方全球信息湾或者其他可信赖的源获取mkfs.ext4 的源代码，通常以 tar.gz 格式进行压缩。
解压源代码后，用户可以进入源代码目录进行后续操作。
- 配置在源代码目录中执行 ./configure 命令，用于配置编译参数和检查编译环境。
该步骤会生成 Makefile 文件，其中包含了编译 mkfs.ext4 所需的详细信息。
- 编译在配置完成后，用户可以执行 make 命令来进行编译，该步骤会生成可执行的 mkfs.ext4 文件。
- 安装用户可以执行 make install 命令来将编译生成的 mkfs.ext4 安装到指定的系统目录中，以便在任何位置都可以直接执行该命令。
通过以上步骤，用户可以成功编译并安装 mkfs.ext4 命令，从而在系统中使用该命令进行 ext4 文件系统的格式化。
dos 6.0 源代码注解
dos 6.0 源代码注解全文共四篇示例，供您参考第一篇示例：DOS（Disk Operating System，磁盘操作系统）是早期个人计算机上应用最广泛的操作系统之一，而DOS 6.0则是其发展的一个重要版本。
DOS 6.0自发布之后，便成为当时广泛使用的操作系统之一，该系统不仅在个人计算机，还被广泛应用于商业环境中。
其源代码注解的研究与分析不仅有助于理解计算机操作系统的发展历程，还有利于理解当时计算机行业的技术发展和软件工程的发展过程。
DOS 6.0的源代码注解是一项涉及庞大而复杂的工程，需要对该操作系统的源代码进行深入的研究与分析。
在对DOS 6.0源代码进行注解的过程中，我们可以深入了解DOS 6.0的设计思想、系统架构、关键模块的实现方式等方面的内容，从而更好地把握当时的计算机技术水平与软件工程水平。
通过源代码注解，我们还可以深入了解DOS 6.0的功能特性、性能优化以及错误处理等方面的内容，这些对于理解操作系统的工作原理和设计思想有着重要意义。
在DOS 6.0源代码注解的研究中，我们可以首先从系统的启动过程入手。
DOS 6.0的启动过程主要包括硬件的初始化、引导加载器的加载与执行、内存管理和文件系统的初始化等步骤，通过对这些步骤进行源代码注解，我们可以深入了解DOS 6.0是如何进行系统初始化和加载的。
我们可以进一步研究DOS 6.0的文件系统、进程管理、设备管理等核心功能的实现方式，这些内容对于理解操作系统的核心功能和机制有着重要意义。
在进行DOS 6.0源代码注解的研究中，我们还可以深入了解DOS 6.0的设计思想与实现方式。
DOS 6.0作为一个早期的个人计算机操作系统，其设计思想和实现方式具有一定的特殊性，通过源代码注解，我们可以更好地把握当时计算机操作系统的设计与实现的特点。
通过对DOS 6.0源代码进行注解，我们还可以了解到当时的软件工程技术水平与开发实践，这对于理解当时计算机行业的技术发展过程有着重要意义。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include<stdio.h>#include<string.h>#include<stdlib.h>#define MEM_D_SIZE 1024*1024 //总磁盘空间为1M#define DISKSIZE 1024 //磁盘块的大小1K#define DISK_NUM 1024 //磁盘块数目1K#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 //路径最大长度为1KB#define MSD 5 //最大子目录数5#define MOFN 5 //最大文件深度为5#define MAX_WRITE 1024*128 //最大写入文字长度128KBstruct 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))}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))}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].firstdi sk;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].firstdi sk;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");}void 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;}}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;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");}else{printf("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();}}}。