操作系统文件系统实验

合集下载

操作系统文件管理实验报告

操作系统文件管理实验报告

操作系统文件管理实验报告操作系统文件管理实验报告一、实验目的操作系统是计算机系统中的核心软件之一,负责管理计算机硬件资源和提供用户与计算机硬件之间的接口。

文件管理是操作系统的重要功能之一,它涉及到文件的创建、读取、写入、删除等操作。

本次实验旨在通过编写简单的文件管理程序,加深对操作系统文件管理机制的理解。

二、实验环境本次实验使用C语言编写,运行在Linux操作系统上。

实验过程中使用了gcc 编译器和Linux系统提供的文件管理函数。

三、实验内容1. 文件的创建在操作系统中,文件是存储在存储介质上的数据集合。

文件的创建是指在存储介质上分配一块空间,并为其分配一个唯一的文件名。

在本次实验中,我们使用了Linux系统提供的open函数来创建文件。

open函数接受两个参数,第一个参数是文件名,第二个参数是文件的打开模式。

通过调用open函数,我们可以在指定的路径下创建一个文件。

2. 文件的读取和写入文件的读取和写入是文件管理的核心操作。

在本次实验中,我们使用了Linux 系统提供的read和write函数来实现文件的读取和写入。

read函数接受三个参数,第一个参数是文件描述符,第二个参数是存储读取数据的缓冲区,第三个参数是要读取的数据的长度。

write函数也接受三个参数,第一个参数是文件描述符,第二个参数是要写入的数据的缓冲区,第三个参数是要写入的数据的长度。

通过调用read和write函数,我们可以实现对文件的读取和写入操作。

3. 文件的删除文件的删除是指在存储介质上释放文件占用的空间,并删除文件的相关信息。

在本次实验中,我们使用了Linux系统提供的unlink函数来删除文件。

unlink函数接受一个参数,即要删除的文件名。

通过调用unlink函数,我们可以删除指定的文件。

四、实验步骤1. 创建文件首先,我们使用open函数创建一个文件。

在调用open函数时,需要指定文件的路径和文件的打开模式。

文件的路径可以是绝对路径或相对路径,文件的打开模式可以是只读、只写、读写等。

操作系统-第四次实验报告-文件系统

操作系统-第四次实验报告-文件系统
操作系统实验报告 文件系统
全部代码可执行
实验介绍
本实验要求在假设的I/O 系统之上开发一个简单的文件系统, 这样做既能让实验者对文 件系统有整体了解,又避免了涉及过多细节。用户通过create, open, read 等命令与文件系统 交互。文件系统把磁盘视为顺序编号的逻辑块序列,逻辑块的编号为0 至L-1。I/O 系统利 用内存中的数组模拟磁盘。 实际物理磁盘的结构是多维的:有柱面、磁道、扇区等概念。I/O 系统的任务是隐藏磁 盘的结构细节,把磁盘以逻辑块的面目呈现给文件系统。逻辑块顺序编号,编号取值范围为 0 至L -1,其中L 表示磁盘的存储块总数。实验中,我们可以利用字符数组ldisk[L][B] 构 建磁盘模型,其中B 表示每个存储块的长度。I/O 系统从文件系统接收命令,根据命令指定 的逻辑块号把磁盘块的内容读入命令指定的内存区域, 或者把命令指定的内存区域内容写入 磁盘块。内存区域内容写入磁盘块。
整体组织
注:我定义的文件系统中,磁盘分为两大部分:数据区和保留区。其中保留区中又包含位图区和文件 描述符区,数据区的首部是文件的目录项,也就是说,文件的目录项在文件创建时会创建相应的目录 项在数据区的文件首部;而位图区用于表征数据的占用情况,例如数据区的第 N 块被分配了,那么位 图区中也要做相应的改变。
struct filesign { int file_length; int filesign_flag; int file_block;
int file_block_ary[FILE_BLOCK_LENGTH]; }; struct contents { char filename[FILE_NAME_LENGTH];
文件的读 int read(int,int,int)

操作系统文件管理实验报告

操作系统文件管理实验报告

操作系统文件管理实验报告电大教师评语教师签字日期成绩学生姓名学号实验名称操作系统文件管理实验实验报告一、实验目的1、加深对文件、目录、文件系统等概念的理角2、掌握 Llnu_ 文件系统的目录结构3、掌握有关 Llnu_ 文件系统操作的常用命令4、了解有关文件案例性方面的知识二、实验要求:1、正确使用文件管理命令,能熟练地对文件进行浏览、拷贝、移动和删除。

2、能熟练地确定和更改工作目录,查看内容和文件属性,创建和删除目录。

3、正确地理解文件的权限,并能进行相应更改。

4、理解文件的类型及其表示形式。

5、理解文件名的表示形式,在模式匹配中能正确使用通配符。

三、实验步骤( 一) 浏览文件系统 1、运行 pwd 命令。

确定当前的工作目录。

2、文件列表。

使用 ls 命令显示当前工作目录的内容。

使用 ls-l 命令显示文件列表,对照屏幕上的显示信息,理解各字段的含义。

使用 ls-ai 命令显示文件列表,观察显示的信息。

注意列出的前两项,它们分别表示当前目录和父目录。

看一下,是否还有其他隐藏的文件? 运行不带-a 选项的 ls 命令。

注意,文件的 I 节点号不再出现。

运行不带-i 选项的 ls 命令,注意,怎么不再显示隐藏文件了。

3、目录操作。

使用 mkdir 命令建立一个子目录。

执行带 ls-d 命令,观察有关子目录的信息。

执行 cd/命令,将工作目录改到根目录(/)上。

使用绝对路径和相对路径两种方式,并执行 pwd 命令确认当前工作目录。

执行 ls/命令列出根目录的内容,再分别列出各子目录的内容。

体会各子目录的作用以及访问权限。

执行 ls-l /dev 命令列出/dev 的内容,注意各行第一个字符 b 和c 的含义以及规定的访问权限。

执行不带参数的命令 cd,然后用 pwd 命令确认当前的工作目录是什么。

执行命令 cd../...工作目录移到什么地方了? ( 二) 查看文件执行 cd 命令,将工作目录改到主目录上。

操作系统文件管理系统模拟实验

操作系统文件管理系统模拟实验

操作系统文件管理系统模拟实验在计算机科学中,操作系统是一种系统软件,负责管理计算机硬件和软件资源,并为用户和应用程序提供接口。

文件管理系统是操作系统的一个重要组成部分,它负责管理计算机系统中的文件和目录,以及提供对它们的访问和操作。

本次实验旨在模拟操作系统中文件管理系统的基本功能和操作。

我们将使用一个虚拟的文件系统,通过命令行界面来模拟用户与文件系统的交互。

以下是实验的具体内容和步骤:1. 创建虚拟文件系统首先,我们需要创建一个虚拟的文件系统。

文件系统由文件和目录组成,可以通过树状结构来表示。

我们可以使用一个数据结构来模拟文件系统的存储和管理。

2. 初始化文件系统在开始操作文件系统之前,我们需要初始化文件系统。

这包括创建根目录和设置当前目录为根目录。

3. 文件和目录的创建与删除文件和目录是文件系统的基本单位。

我们可以通过命令来创建和删除文件和目录。

例如,使用"mkdir"命令创建一个目录,使用"touch"命令创建一个空文件,使用"rm"命令删除文件或目录。

4. 文件和目录的访问权限文件和目录可以设置不同的访问权限,以保护文件系统的安全性。

我们可以使用"chmod"命令来修改文件或目录的权限。

权限通常包括读、写和执行权限。

5. 文件和目录的重命名和移动我们可以使用"mv"命令来重命名文件或目录,使用"cp"命令来复制文件或目录,使用"mv"命令来移动文件或目录。

6. 文件和目录的查找和显示我们可以使用"ls"命令来显示当前目录下的文件和目录,使用"cd"命令来切换当前目录,使用"pwd"命令来显示当前目录的路径。

此外,我们还可以使用"find"命令来查找文件或目录。

7. 文件和目录的读写操作文件可以被读取和写入。

操作系统文件管理系统模拟实验

操作系统文件管理系统模拟实验

操作系统文件管理系统模拟实验操作系统文件管理系统模拟实验一、实验目的本实验旨在通过模拟操作系统的文件管理系统,加深对操作系统文件管理的理解,锻炼操作系统的应用能力。

二、实验环境1、操作系统:Windows/Linux/MacOS2、编程语言:C/C++/Java/Python等三、实验内容1、初始化文件管理系统1.1 创建根目录,并初始化空文件目录1.2 初始化用户目录和权限设置2、文件操作2.1 创建文件2.1.1 检查文件名合法性2.1.2 检查文件是否已存在2.1.3 为新文件分配磁盘空间2.1.4 添加文件元数据信息2.2 打开文件2.2.1 检查文件是否存在2.2.2 检查用户权限2.3 读取文件内容2.3.1 读取文件权限检查2.3.2 读取文件内容2.4 写入文件内容2.4.1 写入文件权限检查2.4.2 写入文件内容2.5 删除文件2.5.1 检查文件是否存在2.5.2 检查用户权限2.5.3 释放文件占用的磁盘空间2.5.4 删除文件元数据信息3、目录操作3.1 创建子目录3.1.1 检查目录名合法性3.1.2 检查目录是否已存在3.1.3 添加目录元数据信息3.2 打开目录3.2.1 检查目录是否存在3.2.2 检查用户权限3.3 列出目录内容3.3.1 列出目录权限检查3.3.2 列出目录内容3.4 删除目录3.4.1 检查目录是否存在3.4.2 检查用户权限3.4.3 递归删除目录下所有文件和子目录3.4.4 删除目录元数据信息四、实验步骤1、根据实验环境的要求配置操作系统和编程语言环境。

2、初始化文件管理系统,创建根目录,并初始化用户目录和权限设置。

3、进行文件操作和目录操作。

五、实验结果分析根据实验步骤进行文件操作和目录操作,观察系统的运行情况并记录相关实验结果。

六、实验结论通过本实验,深入了解了操作系统中文件管理系统的相关原理和实现方式,并且通过实验操作进一步巩固了相应的应用能力。

操作系统文件管理系统模拟实验

操作系统文件管理系统模拟实验

操作系统文件管理系统模拟实验文件管理系统模拟1.实验目的通过一个简单多用户文件系统的设计,加深理解文件系统的内部功能及内部实现 2.实验内容为Linux系统设计一个简单的二级文件系统。

要求做到以下几点:(1)可以实现下列几条命令(至少4条)login 用户登录dir 列文件目录create 创建文件delete 删除文件open 打开文件close 关闭文件read 读文件write 写文件(2)列目录时要列出文件名、物理地址、保护码和文件长度;(3)源文件可以进行读写保护。

3.实验提示(1)首先应确定文件系统的数据结构:主目录、子目录及活动文件等。

主目录和子目录都以文件的形式存放于磁盘,这样便于查找和修改。

(2)用户创建的文件,可以编号存储于磁盘上。

入file0,file1,file2…并以编号作为物理地址,在目录中进行登记。

4.源代码#include<stdio.h> DISK_NUM*sizeof(struct fatitem)#include<string.h> //FAT表大小#include<stdlib.h> #define ROOT_DISK_NOFATSIZE/DISKSIZE+1 #define MEM_D_SIZE 1024*1024 //根目录起始盘块号//总磁盘空间为1M #define ROOT_DISK_SIZE #define DISKSIZE 1024sizeof(struct direct) //根//磁盘块的大小1K 目录大小#define DISK_NUM 1024 #define DIR_MAXSIZE 1024//磁盘块数目1K //路径最大长度为1KB #define FATSIZE #define MSD 5 //最大子目录数5 }openitem[MOFN]; #define MOFN 5 int cur_size; /*当前打文件的//最大文件深度为5 数目*/#define MAX_WRITE 1024*128 };//最大写入文字长度128KBstruct fatitem *fat; /*FAT表*/ struct fatitem /* size 8*/ struct direct *root; /*根目录*/ { struct direct *cur_dir; /*当前int item; /*存放文件下一个磁目录*/盘的指针*/ struct opentable u_opentable; /*char em_disk; /*磁盘块是否空闲文件打开表*/标志位 0 空闲*/ int fd=-1; /*文件打开表的序}; 号*/char *bufferdir; /*记录当前路struct direct 径的名称*/{ char *fdisk; /*虚拟磁盘起始地/*-----文件控制快信息-----*/ 址*/struct FCB{ void initfile();char name[9]; /*文件/目录void format();8位*/ void enter(); 名char property; /*属性 1位void halt(); 目录 0位普通文件*/ int create(char *name);int size; /*文件/目录字int open(char *name); 节数、盘块数)*/ int close(char *name);int firstdisk; /*文件/目int write(int fd,char *buf,int 录起始盘块号*/ len);int next; /*子目录起始盘int read(int fd,char *buf); 块号*/ intdel(char *name);int sign; /*1是根目录 0int mkdir(char *name); 不是根目录*/ int rmdir(char *name);void dir();}directitem[MSD+2]; int cd(char *name);void print();}; void show();struct opentable void initfile() { {struct openttableitem fdisk = (char{ *)malloc(MEM_D_SIZE*sizeof(char)char name[9]; /*文件名*/ ); /*申请 1M空间*/int firstdisk; /*起始盘块 format();号*/int size; /*文件的大小*/ }me,".");void format() root->directitem[0].next = { root->directitem[0].firstdisk;int i; root->directitem[0].propertyFILE *fp; = '1';root->directitem[0].size =fat = (struct fatitem ROOT_DISK_SIZE;*)(fdisk+DISKSIZE); /*计算FAT表-------指向上一级目录的目录 /*地址,引导区向后偏移 1k)*/ 项---------*//*-----初始化FAT表 root->directitem[1].sign = 1; ------------*/ root->directitem[1].firstdiskfat[0].item=-1; /*引导块*/ = ROOT_DISK_NO;fat[0].em_disk='1'; strcpy(root->directitem[1].name,"..");for(i=1;i<ROOT_DISK_NO-1;i++) root->directitem[1].next = /*存放 FAT 表的磁盘块号*/ root->directitem[0].firstdisk;{ root->directitem[1].propertyfat[i].item=i+1; = '1';fat[i].em_disk='1'; root->directitem[1].size =} ROOT_DISK_SIZE;if((fp =fat[ROOT_DISK_NO].item=-1; fopen("disk.dat","wb"))==NULL) /*存放根目录的磁盘块号*/ {fat[ROOT_DISK_NO].em_disk='1' printf("Error:\n Cannot ; open file \n");return;for(i=ROOT_DISK_NO+1;i<DISK_N }UM;i++) for(i=2;i<MSD+2;i++) /*-子目{ 录初始化为空-*/fat[i].item = -1; {fat[i].em_disk = '0'; root->directitem[i].sign =} 0;/*-----------------------------------------------*/ root->directitem[i].firstdiskroot = (struct direct = -1;*)(fdisk+DISKSIZE+FATSIZE); /*根目录的地址*/ strcpy(root->directitem[i].na/*初始化目录*/ me,"");/*---------指向当前目录的目录 root->directitem[i].next = 项---------*/ -1;root->directitem[0].sign = 1;root->directitem[0].firstdisk root->directitem[i].property =ROOT_DISK_NO; = '0';strcpy(root->directitem[0].na root->directitem[i].size =0; }} fat = (struct fatitem*)(fdisk+DISKSIZE); /*找到FAT表地址*/root = (struct direct if((fp =fopen("disk.dat","wb"))==NULL) *)(fdisk+DISKSIZE+FATSIZE);/*找{ 到根目录地址*/printf("Error:\n Cannot fclose(fp);open file \n"); /*--------------初始化用户打return; 开表------------------*/} for(i=0;i<MOFN;i++)if(fwrite(fdisk,MEM_D_SIZE,1, {fp)!=1) /*把虚拟磁盘空间保存到磁盘文件中*/ strcpy(u_opentable.openitem[i{ ].name,"");printf("Error:\n Fileu_opentable.openitem[i].firstwrite error! \n");disk = -1; }fclose(fp); u_opentable.openitem[i].size= 0; } }void enter() u_opentable.cur_size = 0; {FILE *fp; cur_dir = root; /*当前目录为根int i; 目录*/bufferdir = (charfdisk = (char*)malloc(DIR_MAXSIZE*sizeof(char*)malloc(MEM_D_SIZE*sizeof(char)));); /*申请 1M空间*/ strcpy(bufferdir,"Root:");if((fp=fopen("disk.dat","rb")})==NULL){ void halt()printf("Error:\nCannot {open file\n"); FILE *fp;return; int i;}if(!fread(fdisk,MEM_D_SIZE,1, if((fp=fopen("disk.dat","wb")fp)) /*把磁盘文件disk.dat 读入)==NULL)虚拟磁盘空间(内存)*/ {{ printf("Error:\nCannotprintf("Error:\nCannot open file\n");read file\n"); return;exit(0); }if(!fwrite(fdisk,MEM_D_SIZE,1 return(-2);,fp)) /*把虚拟磁盘空间(内存)内容读入磁盘文件disk.dat */ if(u_opentable.cur_size>=MOFN) /*{ 打开文件太多*/printf("Error:\nFile write return(-3);error!\n");}fclose(fp);for(j=ROOT_DISK_NO+1;j<DISK_NUM;free(fdisk); j++) /*找到空闲盘块 j 后退出*/free(bufferdir); {return; if(fat[j].em_disk=='0') } break;}int create(char *name) if(j>=DISK_NUM){ return(-5);fat[j].em_disk = '1'; /*将空int i,j; 闲块置为已经分配*//*-----------填写目录项if(strlen(name)>8) /*文件名大-----------------*/于 8位*/return(-1); strcpy(cur_dir->directitem[i].name,name);for(j=2;j<MSD+2;j++) /*检查创建文件是否与已存在的文件重名*/ cur_dir->directitem[i].firstdisk{ = j;cur_dir->directitem[i].size =if(!strcmp(cur_dir->directite0;m[j].name,name)) cur_dir->directitem[i].next =break; j;}if(j<MSD+2) /*文件已经存cur_dir->directitem[i].property = 在*/ '0'; return(-4);/*------------------------------for(i=2;i<MSD+2;i++) /*找到第---*/一个空闲子目录*/ fd = open(name);{ return 0;if(cur_dir->directitem[i].fir}stdisk==-1)break; int open(char *name)} {if(i>=MSD+2) /*无空目录项*/ int i, j;/*--------------填写表项的相for(i=2;i<MSD+2;i++) /*文件是关信息------------------------*/ 否存在*/{ u_opentable.openitem[j].firstdisk =if(!strcmp(cur_dir->directitecur_dir->directitem[i].firstdiskm[i].name,name)) ;break;} strcpy(u_opentable.openitem[j].nif(i>=MSD+2) ame,name);return(-1); u_opentable.openitem[j].size/*--------是文件还是目录= cur_dir->directitem[i].size; -----------------------*/ u_opentable.cur_size++;if(cur_dir->directitem[i].pro /*----------返回用户打开表表perty=='1') 项的序号return(-4); --------------------------*/return(j);件是否打开 /*--------文}-----------------------*/for(j=0;j<MOFN;j++) int close(char *name){ {int i;if(!strcmp(u_opentable.openitem[j].name,name)) for(i=0;i<MOFN;i++)break; {}if(j<MOFN) /*文件已经打开*/ if(!strcmp(u_opentable.openitreturn(-2); em[i].name,name))break;}if(i>=MOFN)if(u_opentable.cur_size>=MOFN) /* return(-1);文件打开太多*/ /*-----------清空该文件的用return(-3); 户打开表项的内容---------------------*//*--------查找一个空闲用户打开表项-----------------------*/ strcpy(u_opentable.openitem[i].n for(j=0;j<MOFN;j++) ame,"");{u_opentable.openitem[i].firstdisif(u_opentable.openitem[j].fik = -1;rstdisk==-1) u_opentable.openitem[i].sizebreak; = 0;} u_opentable.cur_size--;下标-*//*------找到的item 是该文件的return 0; 最后一块磁盘块} -------------------*/while(fat[item].item!=-1) int write(int fd, char *buf, int { len) item =fat[item].item; /*-*/ { 查找该文件的下一盘块--} char *first;int item, i, j, k;int ilen1, ilen2, modlen, temp; /*-----计算出该文件的最末地址/*----------用 $ 字符作为空格 -------*/# 字符作为换行符 first =-----------------------*/ fdisk+item*DISKSIZE+u_opentable. char Space = 32; openitem[fd].size%DISKSIZE;char Endter= '\n';/* -----如果最后磁盘块剩余的大for(i=0;i<len;i++) 小大于要写入的文件的大小{ -------*/if(buf[i] == '$') if(DISKSIZE-u_opentable.openibuf[i] = Space; tem[fd].size%DISKSIZE>len)else if(buf[i] == '#') {buf[i] = Endter; strcpy(first,buf);}u_opentable.openitem[fd].size/*----------读取用户打开表对=应表项第一个盘块号u_opentable.openitem[fd].size+le-----------------------*/ n;item = cur_dir->directitem[temp].sizu_opentable.openitem[fd].firstdie = sk; cur_dir->directitem[temp].size+len;/*-------------找到当前目录所 }对应表项的序号 else-------------------------*/ {for(i=2;i<MSD+2;i++){ for(i=0;i<(DISKSIZE-u_opentable.openitem[fd].size%DISKSIZE);iif(cur_dir->directitem[i].fir++)stdisk==item) {/*写一部分内容到最后一块break; 磁盘块的剩余空间(字节)*/} first[i] = buf [i];temp = i; /*-存放当前目录项的 }/*-----计算分配完最后一块=buf[k];磁盘的剩余空间(字节) 还剩下多少 }字节未存储-------*/ilen1 = fat[item].item = i; len-(DISKSIZE-u_opentable.openit--找到一块后将它的序号存放在上/*em[fd].size%DISKSIZE); 一块的指针中-*/ilen2 = ilen1/DISKSIZE; fat[i].em_disk = '1';modlen = ilen1%DISKSIZE; --置找到的磁盘快的空闲标志位为/*if(modlen>0) 已分配-*/ilen2 = ilen2+1; /*-- fat[i].item = -1; /*--还需要多少块磁盘块-*/ 它的指针为 -1 (即没有下一块)-*/}for(j=0;j<ilen2;j++) /*--修改长度-*/{u_opentable.openitem[fd].sizefor(i=ROOT_DISK_NO+1;i<DISK_N=UM;i++)/*寻找空闲磁盘块*/ u_opentable.openitem[fd].size+len; {cur_dir->directitem[temp].siz if(fat[i].em_disk=='0')break; e =} cur_dir->directitem[temp].size+lif(i>=DISK_NUM) /*--如en;果磁盘块已经分配完了-*/ }return(-1); return 0;first = }fdisk+i*DISKSIZE; /*--找到的那块空闲磁盘块的起始地址-*/ int read(int fd, char *buf)if(j==ilen2-1) /*--如{果是最后要分配的一块-*/ int len ={ u_opentable.openitem[fd].size;char *first;for(k=0;k<len-(DISKSIZE-u_ope int i, j, item;ntable.openitem[fd].size%DISKSIZ int ilen1, modlen; E)-j*DISKSIZE;k++) first[k] = item =buf[k]; u_opentable.openitem[fd].firstdi} sk;else/*-如果不是要最后分配的一块--*/{ ilen1 = len/DISKSIZE;modlen = len%DISKSIZE;for(k=0;k<DISKSIZE;k++) if(modlen!=0)first[k] ilen1 = ilen1+1; /*--计算文件所占磁盘的块数-*/ 项的序号,供释放目录中-*/first = fdisk+item*DISKSIZE; if(i>=MSD+2) /*--如果不在当前/*--计算文件的起始位置-*/ 目录中-*/return(-1);for(i=0;i<ilen1;i++){ if(cur_dir->directitem[cur_itif(i==ilen1-1) /*--如果在em].property!='0') /*--如果删除的最后一个磁盘块-*/ (不)是目录-*/{ return(-3);for(j=0;j<len-i*DISKSIZE;j++) for(i=0;i<MOFN;i++) /*--如果buf[i*DISKSIZE+j] = 文件打开,则不能删除,退出-*/first[j]; {}else /*--不在最后一块磁盘 if(!strcmp(u_opentable.openit块-*/ em[i].name,name)){ return(-2);}for(j=0;j<len-i*DISKSIZE;j++) item =cur_dir->directitem[cur_item].fi buf[i*DISKSIZE+j] =first[j]; rstdisk;/*--该文件的起始盘块号item = fat[item].item; -*//*-查找下一盘块-*/ while(item!=-1) /*--释放空间,first = 将FAT表对应项进行修改-*/fdisk+item*DISKSIZE; {} temp = fat[item].item;} fat[item].item = -1;return 0; fat[item].em_disk = '0'; } item = temp;}int del(char *name) /*-----------------释放目录项{ -----------------------*/int i,cur_item,item,temp; cur_dir->directitem[cur_item].sign = 0;for(i=2;i<MSD+2;i++) /*--查找 cur_dir->directitem[cur_item]要删除文件是否在当前目录中-*/ .firstdisk = -1;{ strcpy(u_opentable.openitem[cur_item].name,"");if(!strcmp(cur_dir->directitem[i].name,name)) cur_dir->directitem[cur_item].nebreak; xt = -1;}cur_item = i; /*--用来保存目录cur_dir->directitem[cur_item].pr operty = '0'; {cur_dir->directitem[cur_item] if(fat[j].em_disk=='0') .size = 0; break;}if(j>=DISK_NUM) return 0;} return(-5);fat[j].em_disk='1'; /*-将该空int mkdir(char *name) 闲块设置为已分配-*/{int i,j; /*-------------填写目录项struct direct *cur_mkdir; ----------*/strcpy(cur_dir->directitem[i]if(!strcmp(name,".")) .name,name);return(-4); cur_dir->directitem[i].firstdif(!strcmp(name,"..")) isk=j;return(-4); cur_dir->directitem[i].size=Rif(strlen(name)>8) /*-如果目OOT_DISK_SIZE;8位-*/ 录名长度大于 cur_dir->directitem[i].next=jreturn(-1); ;cur_dir->directitem[i].properfor(i=2;i<MSD+2;i++) /*-如果ty='1';有空闲目录项退出-*/{/*-所创目录在虚拟磁盘上的地址if(cur_dir->directitem[i].fir(内存物理地址)-*/stdisk==-1) cur_mkdir=(struct directbreak; *)(fdisk+cur_dir->directitem[i].} firstdisk*DISKSIZE);if(i>=MSD+2) /*-目录/文件已满-*/ /*-初始化目录-*/return(-2); /*-指向当前目录的目录项-*/for(j=2;j<MSD+2;j++) /*-判断 cur_mkdir->directitem[0].sign是否有重名-*/ =0;{ cur_mkdir->directitem[0].firstdisk=cur_dir->directitem[i].firif(!strcmp(cur_dir->directitestdisk;m[j].name,name)) strcpy(cur_mkdir->directitem[break; 0].name,".");} cur_mkdir->directitem[0].nextif(j<MSD+2) /*-如果有重名-*/ =cur_mkdir->directitem[0].firstdreturn(-3); isk;for(j=ROOT_DISK_NO+1;j<DISK_N cur_mkdir->directitem[0].propUM;j++) /*-找到空闲磁盘块 j 后退erty='1';出-*/ cur_mkdir->directitem[0].size=ROOT_DISK_SIZE; int i,j,item;struct direct *temp_dir;/*-指向上一级目录的目录项-*/ /*-检查当前目录项中有无该目录cur_mkdir->directitem[1].sign-*/=cur_dir->directitem[0].sign; for(i=2;i<MSD+2;i++)cur_mkdir->directitem[1].firs {tdisk=cur_dir->directitem[0].firstdisk; if(!strcmp(cur_dir->directitestrcpy(cur_mkdir->directitem[m[i].name,name))1].name,".."); break;cur_mkdir->directitem[1].next }=cur_mkdir->directitem[1].firstd if(i>=MSD+2) /*-没有这个文件isk; 或目录-*/cur_mkdir->directitem[1].prop return(-1);erty='1'; if(cur_dir->directitem[i].procur_mkdir->directitem[1].sizeperty!='1')/*-删除的不是目录-*/=ROOT_DISK_SIZE; return(-3);for(i=2;i<MSD+2;i++) /*-子目录都初始化为空-*/ /*-判断要删除的目录有无子目录{ -*/cur_mkdir->directitem[i].sign temp_dir=(struct direct =0;*)(fdisk+cur_dir->directitem[i].next*DISKSIZE);cur_mkdir->directitem[i].firs for(j=2;j<MSD+2;j++) tdisk=-1; { strcpy(cur_mkdir->directitem[ if(temp_dir->directitem[j].nei].name,""); xt!=-1)break;cur_mkdir->directitem[i].next }=-1; if(j<MSD+2) /*-有子目录或文件-*/cur_mkdir->directitem[i].prop return(-2);erty='0'; /*------------找到起始盘块号,并将其释放----------------*/cur_mkdir->directitem[i].size item=cur_dir->directitem[i].f=0; irstdisk;} fat[item].em_disk='0';return 0; /*-修改目录项-*/} cur_dir->directitem[i].sign=0;int rmdir(char *name) cur_dir->directitem[i].firstd{ isk=-1;strcpy(cur_dir->directitem[i] str=name;.name,"");cur_dir->directitem[i].next=- if(!strcmp("\\",name)) 1; {cur_dir->directitem[i].proper cur_dir = root; ty='0';cur_dir->directitem[i].size=0 strcpy(bufferdir,"Root:"); ; return 0;}return 0;} temp = (char*)malloc(DIR_MAXSIZE*sizeof(charvoid dir() ));/*-最长路径名字分配空间-*/ {int i; for(i=0;i<(int)strlen(str);i+for(i=2;i<MSD+2;i++) +){ temp[i]=str[i];temp[i]='\0';if(cur_dir->directitem[i].firfor(j=0;j<MSD+2;j++) /*-查找stdisk!=-1) /*-如果存在子目录-*/该子目录是否在当前目录中-*/ {{printf("%s\t",cur_dir->directitem[i].name); if(!strcmp(temp_dir->directitem[j].name,temp))if(cur_dir->directitem[i].pro break;perty=='0') /*-文件-*/ }printf("%d\t\t\n",cur_dir->di free(temp);/*释放申请的临时空rectitem[i].size); 间*/else //if(temp_dir->directitem[j].printf("\t<目property!='1') /*-打开的不是目录录>\t\n"); -*/} //return(-2);} if(j>=MSD+2) /*-不在当前目录} -*/return(-1);int cd(char *name){ item=temp_dir->directitem[j].int i,j,item; firstdisk;char *str; /*-当前目录在磁盘中位置-*/char *temp,*point,*point1; temp_dir=(struct directstruct direct *temp_dir; *)(fdisk+item*DISKSIZE);temp_dir=cur_dir;}if(!strcmp("..",name)){ void print(){if(cur_dir->directitem[j-1].s printf("*********************ign!=1) /*-如果上级目录不是根目录******************************** -*/ ****\n");printf("********************* {*文件系统设计point=strchr(bufferdir,'\\'); ***********************\n");//查找字符串bufferdir中首次出现 printf("*\t命令格式说明字符\ 的位置 *\n");printf("*\tcd 目录名更改while(point!=NULL) 当前目录 *\n");{ printf("*\tmkdir 目录名point1=point+1; /*- 创建子目录 *\n"); 减去'\'所占的空间,记录下次查找的 printf("*\trmdir 目录名*/ \n"); 起始地址- 删除子目录 *printf("*\tdir 显示point=strchr(point1,'\\当前目录的子目录 *'); \n");文件名 } printf("*\tcreate*(point1-1)='\0'; /*- 创建文件 *\n"); 将上一级目录删除-*/printf("*\tdel 文件名} 删除文件 *\n");printf("*\topen 文件名} 打开文件 *\n");printf("*\tclose 文件名else 关闭文件 *\n");{ printf("*\tread 读文//if(name[0] !='\\') 件 *\n");bufferdir = printf("*\twrite 写文strcat(bufferdir,"\\"); /*-修改当件*\n"); 前目录-*/ printf("*\texit 退出bufferdir = 系统 *\n"); strcat(bufferdir,name);printf("*********************} ********************************cur_dir=temp_dir; /*-将当前****\n"); 目录确定下来-*/return 0; }}void main() void show() {{ FILE *fp;printf("%s>",bufferdir); char ch;char a[100];char code[11][10]; while(1)char name[10]; {int i,flag,r_size; scanf("%s",a);char *contect; for(i=0;i<11;i++){contect = (char if(!strcmp(code[i],a))*)malloc(MAX_WRITE*sizeof(char)) break;} ;if((fp=fopen("disk.dat","rb") switch(i))==NULL) {{ case 0: //退出文件系统printf("You have not free(contect); format,Do you want format?(y/n)"); halt();return; scanf("%c",&ch);case 1: //创建文件if(ch=='y') scanf("%s",name);{ flag = create(name);initfile(); if(flag==-1)printf("Successfully {format! \n"); printf("Error: \n} The length is too long !\n");else }{ else if(flag==-2)return; {} printf("Error: \n} The direct item is alreadyfull !\n");enter(); }print(); else if(flag==-3)show(); {printf("Error: \nstrcpy(code[0],"exit"); The number of openfile is too strcpy(code[1],"create"); much !\n");strcpy(code[2],"open"); }strcpy(code[3],"close"); else if(flag==-4)strcpy(code[4],"write"); {strcpy(code[5],"read"); printf("Error: \nstrcpy(code[6],"del"); The name is already in the strcpy(code[7],"mkdir"); direct !\n");strcpy(code[8],"rmdir"); }strcpy(code[9],"dir"); else if(flag==-5)strcpy(code[10],"cd"); {printf("Error: \n show();The disk space is full!\n"); break;}else case 3://关闭文件scanf("%s",name); {flag = close(name);printf("Successfully create a if(flag == -1) { file! \n");} printf("Error:\nThe file is not opened ! \n");show(); }break; else{case 2://打开文件scanf("%s",name); printf("Successfully closed! fd = open(name); \n");if(fd == -1) }{ show();printf("Error: \n break;The open file not exit! \n");case 4://写文件 }else if(fd == -2) if(fd ==-1){ {printf("Error: \n printf("Error:\n The file have already opened!\n"); The file is not opened ! \n");} }else if(fd == -3) else{ {printf("Error: \n printf("Please The number of open file is too much! input the file contect:"); \n");} scanf("%s",contect);else if(fd == -4){ flag=write(fd,contect,strlen(printf("Error: \n contect));It is a direct,can not open for read if(flag == 0) or write! \n"); { }else printf("Successfully write!{ \n");}printf("Successfully opened! else\n"); {}printf("Error:\n The disk size close it ! \n"); is not enough!\n"); }} else if(flag == -3)} {show(); printf("Error:\nbreak; The delete is not file ! \n");}case 5://读文件 elseif(fd ==-1) {{printf("Error:\n printf("Successfully delete! The file is not opened ! \n"); \n");} }else show();{ break;flag =read(fd,contect); case 7://创建子目录if(flag == 0) scanf("%s",name);{ flag = mkdir(name);if(flag == -1)for(i=0;i<u_opentable.openite {m[fd].size;i++) printf("Error:\n{ The length of name is to long! \n");}printf("%c",contect[i]); else if(flag == -2)} {printf("\t\n"); printf("Error:\n} The direct item is already full !} \n");show(); }break; else if(flag == -3){case 6://删除文件 printf("Error:\nscanf("%s",name); The name is already in the direct !flag = del(name); \n");if(flag == -1) }{ else if(flag == -4)printf("Error:\n {The file not exit! \n"); printf("Error: \n} '..' or '.' can not as the name ofelse if(flag == -2) the direct!\n");{ }printf("Error:\n else if(flag == -5) The file is opened,please first {printf("Error: \n }The disk space is full!\n"); show();} break;else if(flag == 0)case 9://显示当前子目录 {dir();printf("Successfully make show();break; dircet! \n");}show(); case 10://更改当前目录break; scanf("%s",name);flag = cd(name);case 8://删除子目录 if(flag == -1)scanf("%s",name); {flag = rmdir(name); printf("Error:\nif(flag == -1) The path no correct!\n");{ }printf("Error:\n else if(flag == -2) The direct is not exist! \n"); {}else if(flag == -2) printf("Error:\nThe opened is{ not direct!\n");}printf("Error:\nThe direct hasson direct ,please first remove the show();son dircct!\n"); break;}else if(flag == -3) default:{ printf("\n Error!\n Theprintf("Error:\n command is wrong! \n"); The remove is not direct ! \n"); show();}else if(flag == 0) }{ }}printf("Successfully removedircet! \n");5.程序运行截图6.实验总结通过这一次计算机操作系统的上机实验,使我对不同环境下的操作系统有了进一步的了解,使我学到了很多关于Linux的操作和相关知识。

操作系统 文件系统 实验程序

操作系统 文件系统 实验程序

一 . 实验目的用高级语言编写和调试一个简单的文件系统,模拟文件管理的工作过程。

从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。

二、实验要求要求设计一个n个用户的文件系统,每次用户可保存m个文件,用户在一次运行中只能打开一个文件,对文件必须设置保护措施,且至少有Create、delete、open、close、read、write等命令。

程序采用二级文件目录(即设置主目录[MFD])和用户文件目录(UFD)。

另外,为打开文件设置了运行文件目录(AFD)。

在执行读写命令时,需改读写指针。

因系统小,文件目录的检索使用了简单的线性搜索。

文件保护简单使用了三位保护码:允许读写执行、对应位为1,对应位为0,则表示不允许读写、执行。

程序中使用的主要设计结构如下:主文件目录和用户文件目录(MFD、UFD)、打开文件目录(AFD)(即运行文件目录)文件系统算法的流程图如下:#include<stdio.h>#include<string.h>#define N 10#define L 10#define S 6struct mfd_type{char uname[20];int uaddr;};struct ufd_type{char fname[20];char fattr[10];int recordl;int addrf;};struct uof_type{char fname[20];char fattr[10];int recordl;char fstatue;//1:建立0:打开int readp;int writep;};int fdph[N*L];//存放文件在磁盘上的第一个空间编号int fdpt[N*L];//存放文件在磁盘上的最末一个空间编号int disk[400];//存放磁盘空闲块号int diskt,diskh;//空闲块的尾、首指针最末struct mfd_type mfd[N];struct ufd_type ufd[N *L];struct uof_type uof[N *S];int temp,mi,ni,uno ,ucounter;void create(char cfname[20],int crecordl,char cfattr[10]){int cltemp1=uno*L,cltemp2=(uno+1)*L,frd;while ((cltemp1<cltemp2)&&(strcmp(ufd[cltemp1].fname,cfname)!=0))cltemp1++;if(strcmp(ufd[cltemp1].fname,cfname)!=0){cltemp1=uno*L;while ((cltemp1<cltemp2)&&(strcmp(ufd[cltemp1].fname,"")!=0)) cltemp1++;if(strcmp(ufd[cltemp1].fname,"")==0){frd=cltemp1;cltemp1=uno*S;cltemp2=(uno+1)*S;while ((cltemp1<cltemp2)&&(strcmp(uof[cltemp1].fname,"")!=0)) cltemp1++;if(strcmp(uof[cltemp1].fname,"")==0){if (disk[diskh]!=-1){strcpy(uof[cltemp1].fname,cfname);strcpy(uof[cltemp1].fattr,cfattr);uof[cltemp1].recordl=crecordl;uof[cltemp1].fstatue=1;uof[cltemp1].readp=disk[diskh];uof[cltemp1].writep=disk[diskh];fdph[frd]=disk[diskh];fdpt[frd]=disk[diskh];strcpy(ufd[frd].fname,cfname);strcpy(ufd[frd].fattr,cfattr);ufd[frd].recordl=crecordl;ufd[frd].addrf=disk[diskh];diskh=disk[diskh];printf("%s\n","文件建立成功!");}else printf("%s\n","磁盘没有空间,不能建文件!");}else printf("%s\n","没有空的登记拦1,不能建文件");}else printf("%s\n","没有空的登记拦2,不能建文件");}else printf("%s\n","同名文件不能建立!");};void open(char pfname[20],char ooptype[10]){int cltemp1=uno*L,cltemp2=(uno+1)*L;int cltemp3=uno*S,cltemp4=(uno+1)*S;while ((cltemp1<cltemp2)&&(strcmp(ufd[cltemp1].fname,pfname)!=0)) cltemp1++;if(strcmp(ufd[cltemp1].fname,pfname)==0){while ((cltemp3<cltemp4)&&(strcmp(uof[cltemp3].fname,pfname)!=0)) cltemp3++;if(strcmp(uof[cltemp3].fname,pfname)==0)//有文件{if(uof[cltemp3].fstatue==0) printf("%s\n","文件已打开!");else printf("%s\n","此文件正在建立,不能打开!");}else//无文件{if(strcmp(ufd[cltemp1].fattr,ooptype)!=0) printf("%s\n","操作不合法,不能打开!");else{cltemp3=uno*S;while ((cltemp3<cltemp4)&&(strcmp(uof[cltemp3].fname,"")!=0)) cltemp3++;if(strcmp(uof[cltemp3].fname,""))printf("%s\n","在已开表中没有空拦,不能打开文件!");else{strcpy(uof[cltemp3].fname,pfname);uof[cltemp3].recordl=ufd[cltemp1].recordl;strcpy(uof[cltemp3].fattr,ufd[cltemp1].fattr);uof[cltemp3].readp=ufd[cltemp1].addrf;uof[cltemp3].writep=ufd[cltemp1].addrf;uof[cltemp3].fstatue=0;printf("%s\n","打开文件成功!");}}}}elseprintf("%s\n","此文件已不存在,不能打开!");};void write(char wfname[20],int wrecordno){int cltemp1=uno*L,cltemp2=(uno+1)*L;int cltemp3=uno*S,cltemp4=(uno+1)*S;while ((cltemp3<cltemp4)&&(strcmp(uof[cltemp3].fname,wfname)!=0)) cltemp3++;if(strcmp(uof[cltemp3].fname,wfname)) printf("文件没有建立或打开,不能写");//在已开文件中没有次文件,不能写else//文件建立或打开{if(uof[cltemp3].fstatue)//建立{printf("%s%d%s","写第",uof[cltemp3].writep,"块空间!");if(disk[diskt]==-1)printf("%s\n","没有空闲块不能写!");else{uof[cltemp3].writep=disk[diskt];diskt=disk[diskt];printf("%s\n","写文件成功!");}}else//打开{if(strcmp(uof[cltemp3].fattr,"r")==0)printf("%s\n","操作不合法,不能写!");else{if(disk[diskt]==-1)printf("%s\n","没有空闲块不能写!");else{printf("%s%d%s\n","写第",uof[cltemp3].writep,"块空间!");uof[cltemp3].writep=disk[uof[cltemp3].writep];printf("%s\n","写文件成功!");}}}}};void read(char rfname[20],int rreadl){int cltemp1=uno*S,cltemp2=(uno+1)*S,frd;while ((cltemp1<cltemp2)&&(strcmp(uof[cltemp1].fname,rfname)!=0)) cltemp1++;if(strcmp(uof[cltemp1].fname,rfname)==0){printf("%s%d%s\n"," 第",uof[cltemp1].readp,"块读");frd=fdph[uno*L];while ((cltemp2!=disk[frd])&&(disk[frd]!=-1)) frd=disk[frd];uof[cltemp1].readp=disk[frd];printf("%s\n","文件读成功"); }else printf("%s\n","文件未打开不能读");};void close(char cofname[20]){int cltemp1=uno*S,cltemp2=(uno+1)*S;while ((cltemp1<cltemp2)&&(strcmp(uof[cltemp1].fname,cofname)!=0)) cltemp1++;if(strcmp(uof[cltemp1].fname,cofname)==0){printf("uof[cltemp1].fname=%s,cofname%s\n",uof[cltemp1].fname,cofname);cltemp2=uof[cltemp1].fstatue;printf("uof[cltemp1].fstatue=%d\n",cltemp2);switch (cltemp2){case 1:printf("%s\n","写文件结束符。

操作系统文件管理实验报告

操作系统文件管理实验报告

操作系统文件管理实验报告操作系统文件管理实验报告1:引言本实验报告旨在详细描述操作系统文件管理实验的设计、实施和结果。

文件管理是操作系统的重要组成部分,负责对计算机中的文件进行组织、存储和访问。

本实验通过模拟文件管理的过程,加深对文件管理的理解和实践。

2:实验目的本实验的主要目的是:- 理解文件系统的概念和原理- 掌握文件的创建、读取、写入和删除等基本操作- 实施并测试文件的分配和回收算法- 评估不同的文件分配算法对系统性能的影响3:实验环境本实验的实施环境如下:- 操作系统:Windows 10- 开发环境:C++ 编程语言4:实验内容4.1 文件系统设计在文件系统设计中,首先确定文件的基本单位,例如块或扇区。

然后,定义文件控制块(FCB)结构,用于存储文件的元数据信息,如文件名、大小、创建时间、权限等。

接下来,设计文件分配表,记录系统中每个块的使用情况,用于实现文件的分配和回收。

4.2 文件的创建和删除在文件的创建过程中,首先为文件分配空间,并更新文件分配表。

然后,创建文件的FCB,并将其到目录项中。

在文件的删除过程中,首先释放文件的空间,并更新文件分配表。

然后,删除文件的FCB,并从目录项中移除。

4.3 文件的读写操作文件的读写操作是用户对文件进行读取和修改的过程。

在文件读取操作中,首先找到要读取的文件的FCB,获取文件的起始块地址,并从起始块中读取数据。

在文件写入操作中,首先找到要写入的文件的FCB,获取文件的起始块地址,并将数据写入起始块。

若文件大小超过起始块的容量,则按照一定的分配算法继续分配空间。

4.4 文件分配算法文件分配算法决定了操作系统如何管理文件的空间分配。

常用的文件分配算法包括顺序分配、分配和索引分配。

顺序分配将文件连续地存储在磁盘上,易于实现但可能产生外部碎片。

分配使用链表结构将文件存储在磁盘的不连续块中,不易产生外部碎片但可能引起存取时间增长。

索引分配使用索引表将文件存储在磁盘的不连续块中,不易产生外部碎片且存取时间相对较短,但索引表本身需要占用存储空间。

操作系统课程实验报告-实验六文件系统

操作系统课程实验报告-实验六文件系统
if __name__ == '__main__': if len(sys.argv) != 3: Usage() exit(1)
hierarchy, filesCompareOutput = diffDir(sys.argv[1], sys.argv[2])
print('{0}\n 比较文件结构:\n{0}'.format(' '*10)) PrintHierarchy(hierarchy) print() if len(filesCompareOutput) != 0:
subname[1])
# 合并结果
filesCompareOutput += subCompareOutput
sameFileHierarchy.append(('{0}'.format(name),
subFileHierarchy))
elif ( os.path.isfile(subname[0])
华南理工大学 操作系统课程实验报告
实验概述
【实验目的及要求】
加深对 linux 文件系统的理解。 实现一个“difftree”命令,其功能是比较两个目录下的文件结构和文件信 息。当在命令行方式下执行“difftree <dir1> <dir2>”命令时,能够比较目录 dir1 和 目录 dir2 是否具有相同的结构,对相同的部分,进一步比较相同文件名的 文件内容。列出比较的文件系统结构图。 本实验是对单个文件比较的扩展,设计中需要考虑目录操作。
for item in hierarchy: if isinstance(item, tuple): print(' '*level*3 + ' ' + item[0] + '/') PrintHierarchy(item[1], level+1) else: print(' '*level*3 + ' ' + item)

操作系统文件管理系统模拟实验

操作系统文件管理系统模拟实验

操作系统文件管理系统模拟实验1. 实验目的本实验旨在通过模拟操作系统的文件管理系统,深入理解操作系统中文件的组织结构、文件的创建、读写和删除操作,以及文件系统的管理策略。

2. 实验背景操作系统是计算机系统中的核心软件,负责管理计算机的资源并提供用户与计算机硬件之间的接口。

文件管理系统是操作系统的重要组成部分,用于管理计算机中的文件和目录结构,提供文件的读写、创建和删除等操作。

3. 实验环境本实验可以在任何支持操作系统模拟的计算机上进行,如使用虚拟机软件搭建的操作系统环境或在线操作系统模拟器。

4. 实验步骤4.1 文件系统初始化在模拟实验开始之前,需要对文件系统进行初始化。

可以选择创建一个空的文件系统或使用预先定义好的文件系统。

4.2 文件的创建在文件系统中创建一个新文件。

可以指定文件的名称、大小、属性等信息。

文件创建成功后,可以在文件系统中查看该文件的相关信息。

4.3 文件的读取选择一个已经存在的文件,并从文件系统中读取该文件的内容。

可以通过指定文件的路径或名称来进行读取操作。

读取文件时,可以选择按字节、按行或按块进行读取。

4.4 文件的写入选择一个已经存在的文件,并向该文件中写入内容。

可以选择覆盖原有内容或在文件末尾追加新内容。

写入文件时,可以选择按字节、按行或按块进行写入。

4.5 文件的删除选择一个已经存在的文件,并从文件系统中删除该文件。

删除文件后,文件系统中将不再存在该文件的相关信息。

5. 实验结果分析在完成实验步骤后,可以对实验结果进行分析和总结。

可以比较不同文件的读写操作所消耗的时间和资源,评估不同文件系统管理策略的性能优劣。

6. 实验注意事项6.1 在进行文件操作时,务必注意文件的权限和保护机制,避免误操作导致数据丢失或系统崩溃。

6.2 在进行文件读写操作时,要注意文件的大小和系统资源的限制,避免因为文件过大或系统资源不足而导致操作失败。

6.3 在进行文件删除操作时,要谨慎操作,避免误删重要文件或系统关键文件,导致系统无法正常运行。

操作系统实验-文件系统扩展实验报告

操作系统实验-文件系统扩展实验报告

实验报告要求1.实验名称:文件系统扩展实验2.实验要求:对【程序5_9】进行扩展,要求参数为目录名,且其下至少有三层目录,分别用深度遍历及广度遍历两种方法对此目录进行遍历,输出此目录下所有文件的大小及修改时间。

3.实验目的:(在实验过程中应用的操作系统理论知识)1.熟悉和应用深度优先和广度优先遍历算法2.熟练掌握linux 系统下关于文件系统的API3.掌握有关数据结构和指针的应用4.掌握使用gdb 调试的方法5.掌握实际运用中堆栈的内存分配4.实验内容:(为完成实验,如何进行程序设计)DFS:整体思路: 从所给的目录进入,按照reddir打开指针的顺序开始逐个遍历,遇到文件就按照规定格式输出信息。

遇到目录就对该目录进行DFS,之后返回上一级继续遍历。

当当前目录没有文件时返回流程图:重点部分: 重点是DFS 对退出循环和回溯时间点的把握。

这里退出循环的时间点是当前目录没有可读文件或者目录。

回溯时间点是当读到的文件为目录时,进入下一层DFS BFS:整体思路:利用队列,参考二叉树的层次遍历。

先将根目录入队,循环出队列。

进入目录后,当读取到文件时,输出信息;当读取到目录时,将目录入队,继续读取下一个文件;当当前目录的文件遍历完成时,退出此目录循环,从队列中弹出一个目录,再进入循环。

当队列为空时,退出。

流程图:重点部分: 1. 队列的建立,队列使用链表连接,存放字符串数据,要注意内存的分配和释放2.入队出队的时机;先将根目录入队,退出循环的条件为队列为空。

入队的条件为当前文件为目录。

出队的条件为一个目录遍历完毕。

5.程序:(较之已有程序有修改的、新增的程序段加下划线)#include<unistd.h>#include<stdio.h>#include<stdlib.h>#include<errno.h>#include<sys/types.h>#include<sys/stat.h>#include<dirent.h>#include<time.h>#include<string.h>#include<ctype.h>/*辅助函数输出文件的大小和最后修改时间*/static int get_file_size_time(const char *filename){struct stat statbuf;if(stat(filename,&statbuf)==-1) //取filename 的状态{printf("Get stat on %s Error:%s\n",filename,strerror(errno));return(-1);}if(S_ISDIR(statbuf.st_mode))return(1); //判断是否是目录文件if(S_ISREG(statbuf.st_mode)) //判断是否是普通文件printf("\t size:%ld bytes\t modifiedate: %s\n",statbuf.st_size,ctime(&statbuf.st _mtime)); //输出文件的大小和最后修改时间return(0);}/******************************** BFS 利用队列********************************************/// 在strcpy 指针前要先申请空间struct node {char* data;struct node* next;// struct node* pre;} *head,*tail,*tmp; // 头节点,尾节点,临时节点count++; }6.运行结果:(进行反白处理后截图)DFS:BFS7.实验总结:编程、调试过程中遇到的问题及解决办法。

2023年最新的操作系统文件管理实验报告三篇

2023年最新的操作系统文件管理实验报告三篇

2023年最新的操作系统文件管理实验报告三篇操作系统文件管理实验报告一篇一、实训主要内容Word排版,表格制作与编辑。

Powerpoint的制作,初步认识计算机办公应用OFFICE。

二、实训过程第一天:初步熟悉计算机的性能和认识Word;第二天:练习Word题;第三天:认识Powerpoint并对昨天的Word练习予以测试;Excel实训作业第四天:将Word表格与Powerpoint的制作熟悉巩固;第五天:老师再次对我们Word与Powerpoint测验以及教我们一些有用的技能与方法,初步认识计算机办公应用。

OFFICE。

三、实训心得体会很快的,一个假期又过来了,面对本学期最后一次的校园生活实训,想着刚刚过去的最后一个周,紧张沉默之后更多的是感慨,印在脑海里的每一个足迹都是那么的深,真的说不出是什么感觉,伴着时间,就像是在和自己的影子赛跑,不可能从真实的两面去看清它,只是经意不经意的感受着有种东西在过去,也许更适合的只有那句话:时不待我,怎可驻足一周,短短的一周,我学到了很多不知道的东西,实在是感受颇深。

当今企业竞争范围的伴随社会市场经济的发展以及信息化程度的不断提高而日益扩大,这样就要求企业在各个方面加强管理,要求企业有更高的信息化集成来实现对企业的整体资源进行集成管理。

现代企业都意识到,企业之间的竞争是综合实力的竞争,要求企业有更强的资金实力,具备强有力的管理能力和更快的市场响应速度。

因此,引入计算机系统的意义是非常重大的。

在社会主义市场经济高速发展的今天,如果计算机的各项管理运做仍然停滞在以纸、笔为主要工具的阶段,就会因为信息量的快速增长而无法迅速、准确的运用计算机完成各项工作,这样,必将成为企业各方面发展的一个瓶颈。

而在当代这个以信息时代为主题的社会里,计算机技术高速发展,将信息技术应用于对现代企业的管理日益普及。

计算机技术不但可以提高信息的处理速度和提高信息处理的准确性,更重要的是,可以进一步的解放劳动力,将他们分配到更需要人力资源的岗位上去,从而加快社会工作的现代化、综合化的发展步伐。

实验四 操作系统_文件系统实验

实验四 操作系统_文件系统实验

1实验目的通过实验了解linux的文件系统结构。

通过练习使用linux命令查看文件系统信息;通过编程掌握文件操作函数使用。

2实验内容●学习通过linux命令查看文件系统信息状况●通过编程掌握文件系统调用操作3实验步骤3.1l inux文件及目录命令操作,熟悉常见linux文件操作命令,如:使用ls查看当前目录,使用cd改变当前工作目录,使用pwd 显示当前工作目录等3.2使用df、du命令查看文件系统及文件磁盘空间状况。

查阅资料简述命令输出包含哪些内容。

3.3使用ls –i及stat命令查看文件inod e信息,查阅资料简述stat命令输出包含哪些内容。

3.4文件系统创建3.5用dd 命令创建一个指定大小的文件(使用/dev/zero 作为源进行文件复制)3.5.1用mke2fs 在这个文件上创建一个文件系统,查阅资料总结mke2fs的功能说明,并简述输出所描述的信息。

3.5.2用dump2fs查看fs相关信息,查阅资料简述dump2fs的功能说明。

3.5.3使用od查看fs文件系统“磁盘”内容,并查阅ext2文件系统格式说明,了解其中的数据组成。

3.5.3.1查看超级快内容:od -tx1 -Ax fs -N1024 -j10243.5.3.2查看GDT块:od -tx1 -Ax fs -N1024 -j20483.5.3.3查看bl ock bitmap:od -tx1 -Ad fs -N1024 -j6144 查看inodebitmap:od -tx1 -Ad fs -N1024 -j71683.5.3.4查看inode tabl e:od -tx1 -Ad fs -N1024 -j8192查看databl ock:od -tx1 -Ad fs -N1024 -j245763.5.4使用mount 命令将新建的文件系统fs关联到一个回环设备后挂装到挂装点/mnt3.5.5在/mnt目录中创建子目录、文件后再使用dump2fs查看fs的free bl ocks等的信息变化或使用od命令查看信息变化。

操作系统文件系统实验报告

操作系统文件系统实验报告

操作系统文件系统实验报告操作系统文件系统实验报告引言操作系统是计算机系统中的重要组成部分,负责管理计算机的硬件和软件资源,为用户提供一个友好的界面和高效的资源管理。

文件系统作为操作系统的一个重要组成部分,负责管理计算机中的文件和目录,提供文件的读写和存储功能。

本实验旨在深入了解操作系统文件系统的原理和实现方式,并通过实际操作来加深对文件系统的理解。

一、实验背景操作系统中的文件系统是一个层次化的结构,它将计算机中的存储空间划分为若干个逻辑单元,用来存储和管理文件和目录。

文件系统的设计和实现涉及到文件的组织方式、文件的存储结构、文件的访问方式等多个方面。

本实验将以Linux操作系统为例,通过使用Linux文件系统的一些基本命令和操作,来深入了解文件系统的原理和实现方式。

二、实验目的1. 了解文件系统的基本概念和原理。

2. 掌握Linux文件系统的基本命令和操作。

3. 熟悉文件的读写和存储方式。

4. 加深对文件系统的理解和应用。

三、实验内容1. 文件系统的基本概念和原理文件系统是操作系统中用来管理文件和目录的一种机制,它将计算机中的存储空间划分为若干个逻辑单元,用来存储和管理文件和目录。

文件系统的基本概念包括文件、目录、路径等,文件是计算机中存储数据的基本单位,目录是用来组织和管理文件的一种方式,路径是用来定位文件和目录的一种方式。

2. Linux文件系统的基本命令和操作Linux操作系统是一个开源的操作系统,它提供了丰富的文件系统命令和操作。

通过使用这些命令和操作,可以对文件和目录进行创建、删除、复制、移动等操作。

例如,可以使用"mkdir"命令来创建一个新的目录,使用"rm"命令来删除一个文件,使用"cp"命令来复制一个文件,使用"mv"命令来移动一个文件等。

3. 文件的读写和存储方式文件的读写是文件系统的一项重要功能,它可以通过读取和写入文件来实现对文件内容的访问和修改。

操作系统文件管理系统模拟实验

操作系统文件管理系统模拟实验

操作系统文件管理系统模拟实验近年来,随着计算机技术的飞速发展,操作系统的重要性日益凸显。

作为计算机的核心软件之一,操作系统负责管理计算机的硬件和软件资源,提供良好的用户界面和文件管理功能。

为了更好地理解和掌握操作系统的文件管理系统,我们进行了一次模拟实验。

实验的目的是通过模拟操作系统的文件管理系统,深入了解文件的创建、读取、写入、删除等操作。

我们使用了一台虚拟机作为实验平台,并在其上安装了一个基于Linux的操作系统。

虚拟机的使用使得我们能够在一个相对封闭的环境中进行实验,不会对真实的计算机系统造成任何影响。

在实验开始之前,我们对文件管理系统的基本概念进行了学习和了解。

文件管理系统是操作系统中的一个重要模块,负责对计算机中的文件进行管理和控制。

它包括了文件的创建、读写、删除等功能,并提供了对文件进行组织和访问的接口。

了解这些基本概念对于我们后续的实验非常重要。

在实验过程中,我们首先进行了文件的创建和读写操作。

通过使用命令行界面,我们成功地创建了一个新的文件,并向其中写入了一些内容。

接着,我们使用读取命令来读取文件的内容,并验证了文件的创建和读写操作的正确性。

这一步的实验让我们更加熟悉了文件的创建和读写过程,加深了对文件管理系统的理解。

接下来,我们进行了文件的删除操作。

通过使用删除命令,我们成功地删除了之前创建的文件,并再次验证了删除操作的正确性。

文件的删除是文件管理系统中的一个重要操作,需要谨慎操作,以免误删重要文件。

通过这一实验,我们进一步加深了对文件管理系统的理解,并学会了正确地进行文件的删除操作。

除了基本的文件管理操作外,我们还进行了一些高级操作的实验。

比如,我们尝试了文件的复制和移动操作。

通过使用相应的命令,我们成功地将一个文件复制到了另一个目录,并将一个文件移动到了另一个目录。

这些高级操作的实验使我们更加熟悉了文件管理系统的各种功能和操作,提高了我们的操作技能。

通过这次模拟实验,我们对操作系统的文件管理系统有了更深入的了解和掌握。

操作系统实验-文件系统

操作系统实验-文件系统
->abc.c
用rm命令分别删除这三个文件,再用ls命令看看有何变化?
实例:Ls的功能实现
#include<sys/types.h>
#include<dirent.h>
#include<unistd.h>
int main(int argc,char * argv[ ])
{ DIR * dp;
struct dirent * dirp;
if(argc!=2)
perror(“a single argumen(the directory name) is required”);
if((dp=opendir(argv[1]))==NULL)
perror(“Can’t open %s\n”,argv[1]);
while((dirp=readdir(dp))!=NULL)
西北师范大学计算机科学与工程学院学生实验报告
学号
专业
计算机科学与技术
姓名
课程名称
操作系统
班级
实验名称
文件系统
课程类型
专业课
实验目的:
(1)熟悉和理解文件系统的概念和文件系统的类型。
(2)了解文件系统的功能及实现。
(3)学习文件系统的系统调用及命令。
(4)熟悉和理解文件的共享。
实验内容:
1.使用creat、open、read、write等系统调用,实现cp命令的功能。
324550 -rwx------ 2 sarwar faculty 380 mar 11 14:20 abc.hard
$ ln -s abc.c abc.soft
$ ls -il
324550 -rwx------ 1 sarwar faculty 380 mar 11 14:20 abc.c

操作系统实验三--文件操作

操作系统实验三--文件操作

一、试验目的理解操作系统文件系统设计的原理二、试验要求1、模拟实现一个1M大小的文件系统,其中512B为一个扇区2、要求实现打开文件,关闭文件,创建文件,创建目录,删除文件,删除目录,显示目录下的文件等操作。

3、实验平台不限,linux和windows均可。

三、试验环境Windows XP ,vc++6.0四、试验内容本次实验内容是文件系统,因为windows多用图形用户界面操作,对其具体的文件系统不了解,所以本次实验模仿了linux下的文件指令。

首先强调一点,linux的所有文件和目录都在根目录——"/"下程序实现的顶层操作列表如下:1 目录指令指令作用mkdir name 创建名为name的目录,可以包含路径cd name 进入名为name的目录,可以包含路径如果name = ".."为返回上一级目录ls 列出当前目录下的所有文件和目录ll 列出当前目录下的所有文件和目录,并显示具体信息pwd 显示当前目录的路径rm name 删除当前目录下的目录及其子目录和目录下的所有文件,不支持绝对路径2 文件指令指令作用touch name 在当前目录下建立名为name的文件,支持列出绝对路径cat name 显示目录下名为name的文件内容,支持绝对路径vi name 编辑名为name的文件,这里是模仿linux下vi编辑器,但是本程序只能编辑已经存在的文件编辑后,输入"q"退出(相当于关闭文件)d name 删除当前目录下名为name的文件,不支持绝对路径3 系统指令指令作用tree folder_name 列出指定目录的树形图exit 退出文件系统date 显示当前时间日期h 显示帮助文档df 查看磁盘剩余空间对于底层的功能,程序中表示磁盘的数据结构为一数组名为inf的数组为一个信息表,其中包含了该空间是否可用以及下个单元的位置这里要说明一下,此模拟的磁盘是仿照链式存储做的,每一块都记录下一条内容的位置的信息结构如图:代码太长,还是看一个运行的例子吧构建一个如下所示的文件系统要输入的指令如下:mkdir amkdir btouch acd atouch bmkdir ccd ..cd bmkdir dcd dmkdir emkdir ftouch ccd /tree /运行结果:接下来是编辑三个文件a、b、c的内容在这里我们可以先查看一下文件夹和文件的大小: 用ll指令我们可用看到目前所有的文件和文件夹大小都为0接下来我们给图中的三个文件输入内容从上图看到,当再次输入"ll"指令时,文件和文件夹大小均改变,且文件的改动时间也更新了接下来我们试一下删除文件夹的指令,首先看一下当前磁盘的剩余空间“df”指令然后执行删除后再看磁盘剩余空间我们发现,磁盘恢复了原来b占用的6kb大小,切树形图显示b已经被删除接下来我们删除a文件试一下运行结果正如预料到的现在我们尝试一下pwd指令和cat指令吧至此,实验要求的文件及目录的操作均演示完成至于具体的代码解释,代码太长了,解释起来实在不方便,望老师谅解五、心得体会本次实验有很多遗憾1、实验开始的时候,本来想把父母节点叶节点分为两种数据结构,以便节约内存空间和效率,但最后因为删除、显示列表等操作过于复杂,所以就没有采用这种方法2、很多指令没有支持绝对路径进入,且vi指令不能在没有同名文件的情况下创建一个文件。

操作系统实验四 文件系统实验

操作系统实验四 文件系统实验

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;

操作系统实验报告

操作系统实验报告

操作系统实验报告一、实验目的本次操作系统实验的主要目的是通过实际操作和观察,深入理解操作系统的工作原理和关键机制,包括进程管理、内存管理、文件系统以及设备管理等方面。

同时,培养我们解决实际问题的能力,提高对操作系统相关知识的综合运用水平。

二、实验环境本次实验使用的操作系统为 Windows 10 和 Linux(Ubuntu 2004 LTS),实验所使用的编程工具包括 Visual Studio Code、gcc 编译器等。

三、实验内容及步骤(一)进程管理实验1、进程创建与终止在 Windows 系统中,使用 C++语言编写程序,通过调用系统 API函数创建新的进程,并观察进程的创建和终止过程。

在 Linux 系统中,使用 C 语言编写程序,通过 fork()系统调用创建子进程,并通过 wait()函数等待子进程的终止。

2、进程调度观察Windows 和Linux 系统中进程的调度策略,包括时间片轮转、优先级调度等。

通过编写程序模拟进程的执行,设置不同的优先级和执行时间,观察系统的调度效果。

(二)内存管理实验1、内存分配与释放在 Windows 系统中,使用 C++语言的 new 和 delete 操作符进行内存的动态分配和释放,并观察内存使用情况。

在 Linux 系统中,使用 C 语言的 malloc()和 free()函数进行内存的分配和释放,通过查看系统的内存使用信息来验证内存管理的效果。

2、虚拟内存管理研究 Windows 和 Linux 系统中的虚拟内存机制,包括页表、地址转换等。

通过编写程序访问虚拟内存地址,观察系统的处理方式和内存映射情况。

(三)文件系统实验1、文件操作在 Windows 和 Linux 系统中,使用编程语言对文件进行创建、读取、写入、删除等操作。

观察文件的属性、权限设置以及文件在磁盘上的存储方式。

2、目录操作实现对目录的创建、删除、遍历等操作。

研究目录结构和文件路径的表示方法。

操作系统文件系统性能与安全实验报告

操作系统文件系统性能与安全实验报告

操作系统文件系统性能与安全实验报告1. 概述文件系统是操作系统中的重要组成部分,它负责管理文件的存储、组织和访问。

本次实验旨在研究操作系统文件系统的性能和安全性,并通过实验数据和分析得出结论。

2. 实验设计与环境为了评估文件系统的性能和安全性,我们选择了常用的三种文件系统进行实验:FAT32、NTFS和ext4。

实验环境搭建在一台具有充足资源的计算机上,操作系统为Windows 10和Linux。

3. 性能实验3.1 文件读取性能测试通过在不同文件系统上读取不同大小的文件,并记录读取时间,以评估文件系统在读取大文件和小文件时的性能差异。

3.2 文件写入性能测试同样地,在不同文件系统上写入不同大小的文件,并记录写入时间,以评估文件系统在写入大文件和小文件时的性能差异。

3.3 目录操作性能测试通过在不同文件系统上进行目录的创建、删除、重命名等操作,并记录所花费的时间,以评估文件系统在目录操作上的性能差异。

4. 安全性实验4.1 文件权限测试我们通过在不同文件系统上设置不同的文件权限,并测试用户对文件的读取、写入和执行权限,以评估文件系统对文件安全性的保护程度。

4.2 数据恢复测试在实验中,我们模拟文件系统崩溃等意外情况,测试文件系统的数据恢复能力,以评估文件系统对数据的安全性和可靠性。

4.3 密码保护测试通过在不同文件系统上设置文件加密功能,并测试文件系统的密码保护机制,以评估文件系统对数据隐私和安全的保护程度。

5. 实验结果与分析根据我们的实验数据和分析,我们得出以下结论:5.1 性能方面:- 在大文件读写性能方面,NTFS和ext4相对较好,而FAT32性能相对较差。

- 在小文件读写性能方面,ext4表现出色,NTFS次之,而FAT32仍然性能较差。

- 目录操作性能方面,ext4表现最佳,NTFS次之,而FAT32仍然相对较差。

5.2 安全性方面:- 在文件权限控制方面,NTFS和ext4提供了更加精细的权限设置,相对而言更安全可靠。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

实验四文件系统实验一.实验题目:文件系统实验二.实验目的:阅读并调试一个简单的文件系统,模拟文件管理的工作过程。

从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。

了解设计一个n个用户的文件系统,每个用户可以保存M个文件。

用户在一次运行中只能打开一个文件,对文件必须设置保护措施,且至少有create、delete、open、close、read、write等命令.三.实验设备及环境:1. 硬件设备:PC机一台2. 软件环境:安装Windows操作系统,C语言软件。

四.实验内容及要求:在阅读所给文件系统源程序的基础上,画出其实现的详细流程图,并给出有关的数据结构和说明。

五. 实验方法内容1.算法流程图(2)void Execute(int i,int len,int cmdset)执行命令函数流程图(3)创建文件(4)写文件流程图(5)修改文件执行权限(62.主要的常量变量char cmd[64]; //存放用户输入命令char buffer[36];char user[32];//存放当前登陆的用户名typedef char ALFA[12];ALFA KWORD[keynum];struct UFD{//用户文件管理模块char filename[32]; //文件名int safecode; //文件保护码long length; //文件长度}*curfile = NULL;struct MFD{//用户登陆信息管理模块char username[32]; //用户名bool filepoint; //用户目录下的文件指针,false表示目录为空,true为该用户目录中有文件}*curuser = NULL,*elseuser=NULL;typedef UFD UFD;typedef MFD MFD;3.主要模块void KeyWord()//初始化命令关键字int LoginDisplay() //登陆选项操作函数bool Login(int SELETE)//用户登陆,注册函数void DisplayUFD()//打印用户信息,包括用户的各个文件//名称、长度和操作权限的设置信息void ByeFile(bool BOOL)//注销函数,调用次函数用户可以退出系统bool ClearUserFile()//用户要将自己的注册目录从系统彻底删除//首先将该用户目录下的全部文件删除void ClearUserMes()//删除用户全部信息void CreatFile()//在当前用户目录下创建文件void DeleteFile() //删除当前目录下一个文件的操作void ListAllFile()//显示当前用户目录下的文件信息bool QueryModElse(bool BOOL,bool &flag)//查询其它用户目录下文件的文件//当该文件的权限允许当前用户对其执行有关操作时,返回turebool QueryMod(bool BOOL)//查询权限bool WriteRight(int len,bool BOOL)//查看是否已经正确地写入到该文件信息中void WriteLengthToFile(int Len,bool BOOL)//将文件长度写入文件管理模块中void WriteFile()//向文件写入信息的操作void ReadFile()//读文件函数void ChangeMod()//修改某文件的执行权限void Execute(int i,int len,int cmdset)//执行命令函数void Command()//读取用户输入的命令,并将其转换成系统能识别的命令void main()4.代码/***************************************************************** * 文件名: Simple_file_system.c* 功能: 简单文件管理系统模拟程序*******************************************************************/#include<iostream.h>#include<stdio.h>#include<stdlib.h>#include<string.h>#include "conio.h"#include<dos.h>#define NULL 0#define keynum 10#define getspace(type) (type*)malloc(sizeof(type))char cmd[64]; //存放用户输入命令char buffer[36];//char user[32];//存放当前登陆的用户名typedef char ALFA[12];ALFA KWORD[keynum];//------------------------------------------------------------------------------------------------struct UFD{//用户文件管理模块char filename[32]; //文件名int safecode; //文件保护码long length; //文件长度}*curfile = NULL;//------------------------------------------------------------------------------------------------struct MFD{//用户登陆信息管理模块char username[32]; //用户名bool filepoint; //用户目录下的文件指针,false表示目录为空,true为该用户目录中有文件}*curuser = NULL,*elseuser=NULL;typedef UFD UFD;typedef MFD MFD;void main();//------------------------------------------------------------------------------------------------void KeyWord()//初始化命令关键字{strcpy(KWORD[ 1],"bye"); strcpy(KWORD[ 2],"chmod");strcpy(KWORD[ 3],"close"); strcpy(KWORD[ 4],"create");strcpy(KWORD[ 5],"delete"); strcpy(KWORD[ 6],"list");strcpy(KWORD[ 7],"open"); strcpy(KWORD[ 8],"read");strcpy(KWORD[ 9],"write");}//------------------------------------------------------------------------------------------------int LoginDisplay() //登陆选项操作函数{int SELETE_1 = 0;do{cout<<" *****请选择操作*****\n1、用户登陆 2、用户注册 0、退出"<<endl;cin>>SELETE_1;}while(SELETE_1<0 || SELETE_1>2);system("cls");return SELETE_1;}//------------------------------------------------------------------------------------------------bool Login(int SELETE)//用户登陆,注册函数{FILE *fp,*fp1,*fp2;char name[12];switch(SELETE){case 1://用户登陆if((fp = fopen("LOGIN.exe","rb")) == NULL)//打开用户注册目录管理文件{cout<<"\n错误:不能打开登陆文件。

"<<endl;getch();system("cls");return false;}curuser = getspace(MFD);cout<<"\n*****登陆*****\n用户名:";cin>>name; //输入用户登陆名while(!feof(fp)) //检查该用户是否合法{fread(curuser,sizeof(MFD),1,fp);if(strcmp(curuser->username,name)==0)break;}if(feof(fp)) //如果没有找到跟当前登陆用户名相同的管理信息,提示出错{cout<<"\n错误:该用户不存在。

"<<endl;fclose(fp);return false;}else{fclose(fp);return true;}break;case 2: //新用户注册if((fp=fopen("LOGIN.exe","ab"))==NULL)//如果登陆信息管理文件不存在fp=fopen("LOGIN.exe","wb+"); //创建该信息管理文件char name[12];curuser = getspace(MFD);while(1){cout<<"\n *****新用户注册*****"<<endl;cout<<"用户名:";cin>>name; //输入用户注册名fp1 = fopen("LOGIN.exe","rb");while(!feof(fp1))//查看该用户名是否被别的用户占用{fread(curuser,sizeof(MFD),1,fp1);if(strcmp(curuser->username,name) == 0) //该名称已经被使用{cout<<"\n该用户已经存在,请重新输入!"<<endl;getch();break;}}if(feof(fp1))//该名称没有被别的用户占用{strcpy(curuser->username,name);curuser->filepoint = NULL;fwrite(curuser,sizeof(MFD),1,fp);strcpy(user,curuser->username); //生成用户文件管理模块strcat(user,".exe"); //用于管理用户目录下的各个文件fp2=fopen(user,"wb+");fclose(fp2);cout<<"\n注册成功!"<<endl; //提示注册成功fclose(fp1);fclose(fp);break;}}fp = fopen("LOGIN.exe","rb"); //显示当前注册用户的名称while(1){fread(curuser,sizeof(MFD),1,fp);if(feof(fp))break;cout<<curuser->username<<endl;getch();}fclose(fp);return true;break;default:return false;break;}}//------------------------------------------------------------------------------------------------void DisplayUFD()//打印用户信息,包括用户的各个文件//名称、长度和操作权限的设置信息{if(curuser->filepoint == false) //当前用户目录下没有任何文件存在cout<<"\n用户 "<<curuser->username<<" 文件夹是空的"<<endl;else{//存在文件,将所有文件信息打印在终端FILE *fp;char filename[12];strcpy(filename,curuser->username);strcat(filename,".exe");if((fp=fopen(filename,"rb"))==NULL) //打开用户文件信息管理模块{cout<<"\n无法打开用户:"<<curuser->username<<" 的文件!"<<endl;getch();return;}else{//读入并将用户全部文件信息打印在终端cout<<"用户:"<<curuser->username<<"目录下的文件:"<<endl;UFD *ufd;int i=0;ufd = getspace(UFD); //申请存放用户文件模块的空间while(1){fread(ufd,sizeof(UFD),1,fp);if(feof(fp))//全部输出完毕,结束break;else//打印信息cout<<ufd->filename<<"\t"<<ufd->length<<"\t"<<ufd->safecode<<endl;}}fclose(fp);}}//------------------------------------------------------------------------------------------------void ByeFile(bool BOOL)//注销函数,调用次函数用户可以退出系统{FILE *infile,*outfile;char out[50];strcpy(out,"outfilelocate.exe");if((infile=fopen("LOGIN.exe","rb"))==NULL){cout<<"\n保存错误。

相关文档
最新文档