操作系统2014课程设计

《操作系统》课程设计

学习完《操作系统》课程，通过一个具体的课程设计实践，可使学生对操作系统原理有更进一步的理解与应用，通过设计对操作系统有一个实现的尝试和创新的思维，同时发挥团队协作精神和个人创造能力。

选题：以下四题可任选一个或两个，选一，二题的可以选一个，选三，四的要选两个。还可以自由选择其他操作系统相关的内容做课程设计，难度不能与所出题目差别太大。

分组：每组不可超过两人，一人也可以。每人设计系统中的一部分。 要求：界面自行设计，语言自行选择。每组需写一份课程设计报告，内容包括：小组成员及分工，系统采用的语言、支撑平台、程序的模块功能分析、程序的流程图、程序功能段的说明及代码解释；实验体会与软件评价。报告提交后，将系统代码及说明压缩成文件以所有组员学号组合命名发于指定邮箱（xchliu@chd.edu.cn）。（如：2011240203＋0102（班号＋四个组员学号）。

题目一：支持多个进程（线程）并发运行的简单进程（线程）管理模拟系统 1．实验内容

学习进程管理的设计与实现，学习和运用操作系统原理，设计一个操作系统子系统的模拟系统。通过该系统的设计调试可增加对操作系统实现的感知性。设计一个允许n个进程并发运行的进程管理的模拟系统。该系统包括简单的进程控制、同步及通信机构，其进程调度算法可任意选择。分析系统所需的数据结构、算法的流程以及划分各个功能模块。

2．实验原理

进程管理包括进程的控制、阻塞、唤醒与撤消。进程在运行过程中状态在不断的变化。进程运行过程中，因为竞争资源而需对它们进行同步控制。所有这些在操作系统中用数据结构PCB来记录，系统通过PCB控制进程的运行。

在单处理机系统中，多道程序的引入，需要进程的调度程序来选择一个进程进行运行。比如常用的先来先服务、短进程优先和优先级优先等等，也可以选择它们的结合调度算法。

题目二：文件系统设计 1．实验内容

通过一个简单的二级文件系统设计，加深对文件系统的内部功能以及内部实现的理解。要求模拟采用二级目录结构的磁盘文件系统的文件操作，能实现以下几条命令，用输入命令来模拟用户程序中调用的文件操作： Login 用户登录

Dir 列文件目录（列出文件名、物理地址、保护码和文件长度） Create 创建文件 Delete 删除文件 Open 打开文件 Close 关闭文件 Read 读文件 Write 写文件

源文件可以进行读写保护 2．实验原理

文件系统管理中用到的数据结构有：

①首先应确定文件系统的数据结构：主目录、子目录及活动文件等。主目录和子目录都以文件的形式存放于磁盘，这样便于查找和修改。

②用户创建的文件，可以编号存储于磁盘上。如：file0,file1,file2?并以编号作为物理地址，在目录中进行登记。

题目三：磁盘调度模拟系统 1．实验内容

设计一个磁盘调度模拟系统，从而使磁盘调度算法更加形象化，容易使人理解，使磁盘调度的特点更简单明了，能使使用者加深对先来先服务算法、最短寻道时间优先算法、扫描算法以及循环扫描算法等磁盘调度算法的理解。系统主界面可以灵活选择某种算法，算法包括：先来先服务算法（FCFS）、最短寻道时间优先算法（SSTF）、扫描算法（SCAN）、循环扫描算法（CSCAN）。

2．实验原理

（1）先来先服务算法（FCFS）

这是一种比较简单的磁盘调度算法。它根据进程请求访问磁盘的先后次序进行调度。此算法的优点是公平、简单，且每个进程的请求都能依次得到处理，不

会出现某一进程的请求长期得不到满足的情况。此算法由于未对寻道进行优化，在对磁盘的访问请求比较多的情况下，此算法将降低设备服务的吞吐量，致使平均寻道时间可能较长，但各进程得到服务的响应时间的变化幅度较小。 （2）最短寻道时间优先算法（SSTF）

该算法选择这样的进程，其要求访问的磁道与当前磁头所在的磁道距离最近，以使每次的寻道时间最短，该算法可以得到比较好的吞吐量，但却不能保证平均寻道时间最短。其缺点是对用户的服务请求的响应机会不是均等的，因而导致响应时间的变化幅度很大。在服务请求很多的情况下，对内外边缘磁道的请求将会无限期的被延迟，有些请求的响应时间将不可预期。 （3）扫描算法（SCAN）

扫描算法不仅考虑到欲访问的磁道与当前磁道的距离，更优先考虑的是磁头的当前移动方向。例如，当磁头正在自里向外移动时，扫描算法所选择的下一个访问对象应是其欲访问的磁道既在当前磁道之外，又是距离最近的。这样自里向外地访问，直到再无更外的磁道需要访问才将磁臂换向，自外向里移动。这时，同样也是每次选择这样的进程来调度，即其要访问的磁道，在当前磁道之内，从而避免了饥饿现象的出现。由于这种算法中磁头移动的规律颇似电梯的运行，故又称为电梯调度算法。此算法基本上克服了最短寻道时间优先算法的服务集中于中间磁道和响应时间变化比较大的缺点，而具有最短寻道时间优先算法的优点即吞吐量较大，平均响应时间较小，但由于是摆动式的扫描方法，两侧磁道被访问的频率仍低于中间磁道。 （4）循环扫描算法（CSCAN）

循环扫描算法是对扫描算法的改进。如果对磁道的访问请求是均匀分布的，当磁头到达磁盘的一端，并反向运动时落在磁头之后的访问请求相对较少。这是由于这些磁道刚被处理，而磁盘另一端的请求密度相当高，且这些访问请求等待的时间较长，为了解决这种情况，循环扫描算法规定磁头单向移动。例如，只自里向外移动，当磁头移到最外的被访问磁道时，磁头立即返回到最里的欲访磁道，即将最小磁道号紧接着最大磁道号构成循环，进行扫描。

题目三：银行家算法 1．实验内容

本设计的目的是通过编写和调试一个系统动态分配资源的简单模拟程序，观察死锁产生的条件，并采用适当的算法，有效地防止和避免死锁地发生。要求如下：

（1） 模拟一个银行家算法；

（2） 初始化时让系统拥有一定的资源； （3） 用键盘输入的方式申请资源；

（4） 如果预分配后，系统处于安全状态，则修改系统的资源分配情况； （5） 如果预分配后，系统处于不安全状态，则提示不能满足请求， 设计的主要内容是模拟实现动态资源分配。同时编写和调试一个系统动态资源的简单模拟程序，观察死锁产生的条件，并使用适当的算法，有效的防止和避免死锁的发生。

2．实验原理

银行家算法， 顾名思义是来源于银行的借贷业务，一定数量的本金要应多个客户的借贷周转，为了防止银行加资金无法周转而倒闭，对每一笔贷款，必须考察其是否能限期归还。在操作系统中研究资源分配策略时也有类似问题，系统中有限的资源要供多个进程使用，必须保证得到的资源的进程能在有限的时间内归还资源，以供其他进程使用资源。如果资源分配不得到就会发生进程循环等待资源，则进程都无法继续执行下去的死锁现象。

把一个进程需要和已占有资源的情况记录在进程控制中，假定进程控制块PCB其中“状态”有就绪态、等待态和完成态。当进程在处于等待态时，表示系统不能满足该进程当前的资源申请。“资源需求总量”表示进程在整个执行过程中总共要申请的资源量。显然，，每个进程的资源需求总量不能超过系统拥有的资源总数, 银行算法进行资源分配可以避免死锁。

例：//下例只是参考（每组可自行设计数据结构和程序功能，只需能演示进程管理的功能，如用多线程）

1．程管理模拟系统。

（1）问题描述

本系统的同步机构采用的信号量上的P、V操作的机制；控制机构包括阻塞和唤醒操作；时间片中断处理程序处理模拟的时间片中断；进程调度程序负责为各进程分配处理机。

系统中设计了3个并发进程．它们之间有如下同步关系：3个进程需要互斥使用临界资源s2，进程1和进程2又需互斥使用临界资源s1。本系统在运行过程中随机打印出各进程的状态变换过程，系统的调度过程及公共交量的变化情况。

（2）算法

系统为进程设置了5种运行状态：e——执行态；r——高就绪态；t——低就绪态(执行进程因时间片到限而转入)：w——等待态；c——完成态。各进程的初始状态均设置为r。

系统分时执行各进程。通过产生随机数x来模拟时间片（每一个时间片并不相同）。当进程processl访问随机数x时，若x≥0．33；当进程proccss2访问x时，若x<0.33或x≥0.66；当进程process3访问x时，若x<0.66，则分别认为各进程的执行时间片到限，产生“时间片中断”面转入低就绪态t。

进程调度算法采用剥夺式最高优先数法。各进程的优先数通过键盘输入予以静态设置。调度程序每次总是选择优先数最小(优先权最高)的就绪进程投入执行。先从r状态进程中选择，再从t状态进程中选择。当现行进程唤醒某个等待进程，且被唤醒进程的比先数小于现行进程时，则剥夺现行进程的执行权。

各进程在使用临界资源s1和s2时，通过调用信号量sem1和sem2上的P、V操作来实现同步。阻塞和唤醒操作负责完成从进程的执行态到等待态以及从就绪态的转变。

系统启动后，在完成必要的系统初始化后便执行进程调度程序。当执行因“时间片中断”，或者被排斥使用临界资源，或唤醒某个等待进程时，立即进行进程调度。当3个进程都处于完成状态后，系统退出运行。

（3）数据结构

①每个进程一个PCB，内容： id 进程标识

status 进程状态 priority 进程优先数

nextwr 等待队链指针，指示在同一信号量上等待的下一个进程的标识。 ②信号量。对应于临界资源s1和s2分别有sem1和sem2，均为互斥号量，内容包括：

value 信号量值，初值为1

firstwr 等待链指针，指示在该信号量上第一个等待进程的标识数。 ③保留区。用数组saveaera[3][4]表示。即每个进程都有一个大小为4个单元的保留区，用来保存被“中断”时的现场信息，如通用寄存器的内容和断点地址等。

④全程变量。

exe 执行进程指针，其值为进程标识数 i 用来模拟一个通用寄存器。

（4）用Turbo C编写的程序代码： #include #include #include #define TRUE 1 #define FALSE 0 #define MAXPRI 100 #define NIL -1 struct{ int id; char status;

int nextwr; //*等待链指针，指示在同一信号量上等待的下一个进行进程的标识符*

int priority; }pcb[3]; struct

{

int value;

int firstwr; /*等待链首指针，指示该信号量上第一个等待进程的标识数*/

}sem[2];

char savearea[3][4],addr; int i,s1=0,s2=0,seed,exe=NIL; init( ) { int j;

for(j=0;j<3;j++) {

pcb[j].id=j; pcb[j].status='r'; pcb[j].nextwr=NIL;

printf(\ scanf(\ pcb[j].priority=i; }

sem[0].value=1; sem[0].firstwr=NIL; sem[1].value=1; sem[1].firstwr=NIL; for(i=0;i<3;i++) for(j=0;j<4;j++) savearea[i][j]='0'; }

float random() { float m; srand(time(0)); m=(1+rand()%3)%3-0.1;

printf(\ getchar(); return(m); }

timeint(ad) /*time slice interupt*/ char ad; { float x; x=random();

if((x<0.33)&&(exe==0))return(FALSE); if((x<0.66)&&(exe==1))return(FALSE); if((x<1.0)&&(exe==2))return(FALSE); savearea[exe][0]=i; savearea[exe][1]=ad; pcb[exe].status='t';

printf(\ times slice interrupt exe=NIL; return(TRUE); }

scheduler( ) {

int pd;

if((pd=find())==NIL&&exe==NIL) return(NIL); /*quit system*/ if(pd!=NIL) {

if(exe==NIL) {

pcb[pd].status='e';

process%d enter into ready\\n\

exe=pd;

printf(\ }

else if(pcb[pd].priority

pcb[exe].status='r';

printf(\ pcb[pd].status='e'; exe=pd;

printf(\ } }

i=savearea[exe][0]; addr=savearea[exe][1]; return(exe); } find( ) {

int j,pd=NIL,w=MAXPRI; for(j=0;j<3;j++) {

if(pcb[j].status=='r') if(pcb[j].priority

w=pcb[j].priority; pd=j; } }

if (pd==NIL) for(j=0;j<3;j++)

{

if(pcb[j].status=='t') if(pcb[j].priority

w=pcb[j].priority; pd=j; } }

return(pd); } p(se,ad) int se; char ad; {

if(--sem[se].value>=0) return(FALSE); block(se);

savearea[exe][0]=i; savearea[exe][1]=ad; exe=NIL; return(TRUE); }

block(se) int se; { int w;

printf(\ pcb[exe].status='w'; pcb[exe].nextwr=NIL;

if((w=sem[se].firstwr)==NIL) sem[se].firstwr=exe; else {

while(pcb[w].nextwr!=NIL) w=pcb[w].nextwr; pcb[w].nextwr=exe; } } v(se,ad) int se; char ad; {

if(++sem[se].value>0) return(FALSE); wakeup(se);

savearea[exe][1]=ad; savearea[exe][0]=i; return(TRUE); }

wakeup(se) int se; { int w;

w=sem[se].firstwr; if(w!=NIL) {

sem[se].firstwr=pcb[w].nextwr; pcb[w].status='r';

printf(\ } }

process1() {

if(addr=='a') goto a1; if(addr=='b') goto b1; if(addr=='c') goto c1; if(addr=='d') goto d1; if(addr=='e') goto e1; if(addr=='f') goto f1;

for(i=0; i<3;i++)/*如果程序执行超过５次，则*/ {

printf(\ if(p(0,'a')) break; /*process 1 is blocked*/

a1: printf(\ if(timeint('b')) break; /*time silce interrupt*/ b1: printf(\

printf(\calls V on semaphorel and quit cretical section 1.\\n\

if(v(0,'c')) break; /*wake up a blocked process*/ c1: printf(\ if(p(1,'d')) break;

d1: printf(\ if(timeint('e')) break; e1: printf(\

printf(\calls V on semaphore2 and quit cretical section2.\\n\

if(v(1,'f')) break; /*wake up a block process*/ f1: printf(\

}

if(i<3) return; eexit(0); }

process2() {

if(addr=='a') goto a2; if(addr=='b') goto b2; if(addr=='c') goto c2; if(addr=='d') goto d2; if(addr=='e') goto e2; if(addr=='f') goto f2; for(i=1;i<6;++i) {

printf(\ if(p(1,'a')) break; /*process2 is blocked*/

a2: printf(\ if(timeint('b')) break; b2: printf(\

printf(\section2.\\n\

if(v(1,'c')) break; /*wake up a blocked process*/ c2: printf(\ if(p(0,'d')) break; /*process2 is blocked*/ d2: printf(\ if(timeint('e')) break; e2: printf(\

printf(\call V on semaphorel and quit cretical setion2\\n\

if(v(0,'f')) break; /*wkup up a block process*/

f2: printf(\ }

if(i<6) return; eexit(1); }

process3() {

if(addr=='a') goto a3; if(addr=='b') goto b3; if(addr=='c') goto c3; for(i=1;i<6;++i) {

printf(\ if(p(1,'a')) break; /*process3 is blocked*/

a3: printf(\ if(timeint('b')) break; b3: printf(\

printf(\ calls V on semaphore and quit cretical section.\\n\

if(v(1,'c')) break; /*wake up a blocked process */ c3: printf(\ }

if(i<6) return; eexit(2); } eexit(n) int n; {

pcb[n].status='c';

printf(\ exe=NIL; } main() {

int j=0; int k; char m;

printf(\ init();

printf(\

printf(\ for(;;) {

j=j+1;

printf(\ //scanf(\ getchar();

if((k=scheduler())!=NIL) {

switch(k) {

case 0: process1(); break;

case 1: process2(); break;

case 2: process3(); break;

default: printf(\ break; } }

else break; }

printf(\ printf(\ }

2．文件系统

参考程序见下（本程序需要在c:下建一个名为osfile的目录及一个名为file的子目录）：

#include \#include \#include \#include \

#define MAXNAME 25 /*the largest length of mfdname,ufdname,filename*/ #define MAXCHILD 50 /*the largest child*/

#define MAX (MAXCHILD*MAXCHILD) /*the size of fpaddrno*/

typedef struct /*the structure of OSFILE*/

{int fpaddr; /*file physical address*/ int flength; /*file length*/

int fmode; /*file mode:0-Read Only;1-Write Only;2-Read and Write(default);*/ char fname[MAXNAME]; /*file name*/ } OSFILE;

typedef struct /*the structure of OSUFD*/ {char ufdname[MAXNAME]; /*ufd name*/ OSFILE ufdfile[MAXCHILD]; /*ufd own file*/ }OSUFD;

typedef struct /*the structure of OSUFD'LOGIN*/ {char ufdname[MAXNAME]; /*ufd name*/ char ufdpword[8]; /*ufd password*/ } OSUFD_LOGIN;

typedef struct /*file open mode*/ {int ifopen; /*ifopen:0-close,1-open*/

int openmode; /*0-read only,1-write only,2-read and write,3-initial*/ }OSUFD_OPENMODE;

OSUFD *ufd[MAXCHILD]; /*ufd and ufd own files*/ OSUFD_LOGIN ufd_lp;

int ucount=0; /*the count of mfd's ufds*/

int fcount[MAXCHILD]; /*the count of ufd's files*/ int loginsuc=0; /*whether login successfully*/

char username[MAXNAME]; /*record login user's name22*/ char dirname[MAXNAME];/*record current directory*/ int fpaddrno[MAX]; /*record file physical address num*/

OSUFD_OPENMODE ifopen[MAXCHILD][MAXCHILD]; /*record file open/close*/ int wgetchar; /*whether getchar()*/

FILE *fp_mfd,*fp_ufd,*fp_file_p,*fp_file;

void main() {int i,j,choice1;

char choice[50]; /*choice

operation:dir,create,delete,open,delete,modify,read,write*/ int choiceend=1; /*whether choice end*/

char *rtrim(char *str); /*remove the trailing blanks.*/ char *ltrim(char *str); /*remove the heading blanks.*/ void LoginF(); /*LOGIN FileSystem*/ void DirF(); /*Dir FileSystem*/ void CdF(); /*Change Dir*/ void CreateF(); /*Create File*/ void DeleteF(); /*Delete File*/ void ModifyFM(); /*Modify FileMode*/ void OpenF(); /*Open File*/ void CloseF(); /*Close File*/ void ReadF(); /*Read File*/ void WriteF(); /*Write File*/ void QuitF(); /*Quit FileSystem*/ void help();

if((fp_mfd=fopen(\ {fp_mfd=fopen(\fclose(fp_mfd); }

for(i=0;i

textattr(BLACK*16|WHITE); clrscr(); /*clear screen*/ LoginF(); /*user login*/ clrscr();

if(loginsuc==1) /*Login Successfully*/ {while (1) {wgetchar=0; if (choiceend==1)

{printf(\

else printf(\ gets(choice);

strcpy(choice,ltrim(rtrim(strlwr(choice)))); if (strcmp(choice,\ else if(strcmp(choice,\ else if(strcmp(choice,\ else if(strcmp(choice,\ else if(strcmp(choice,\ else if(strcmp(choice,\ else if(strcmp(choice,\ else if(strcmp(choice,\ else if(strcmp(choice,\ else if(strcmp(choice,\ else if(strcmp(choice,\ else if(strcmp(choice,\ else choice1=12; switch(choice1)

{case 1:DirF();choiceend=1;break;

case 2:CreateF();choiceend=1;if(!wgetchar) getchar();break; case 3:DeleteF();choiceend=1;if(!wgetchar)getchar();break; case 4:ModifyFM();choiceend=1;if(!wgetchar) getchar();break; case 5:choiceend=1;OpenF();if (!wgetchar) getchar();break; case 6:choiceend=1;CloseF();if (!wgetchar) getchar();break; case 7:choiceend=1;ReadF();if (!wgetchar) getchar();break; case 8:choiceend=1;WriteF();if (!wgetchar) getchar();break; case 9:printf(\ QuitF();exit(0);break;

case 10:choiceend=1;clrscr();break; case 11:CdF();choiceend=1;break; case 20:help();choiceend=1;break; default:choiceend=0; } } }

else printf(\}

void help(void) {

printf(\

printf(\}

char *rtrim(char *str) /*remove the trailing blanks.*/ {int n=strlen(str)-1; while(n>=0) {if(*(str+n)!=' ') {*(str+n+1)='\\0'; break; }

else n--; }

if (n<0) str[0]='\\0'; return str; }

char *ltrim(char *str) /*remove the heading blanks.*/ {char *rtrim(char *str); strrev(str); rtrim(str); strrev(str); return str; }

void LoginF() /*LOGIN FileSystem*/

{char loginame[MAXNAME],loginpw[9],logincpw[9],str[50]; int i,j,flag=1; char a[25];

int findout; /*login user not exist*/

char *rtrim(char *str); /*remove the trailing blanks.*/ char *ltrim(char *str); /*remove the heading blanks.*/

void InputPW(char *password); /*input password,use '*' replace*/ void SetPANo(int RorW); /*Set physical address num*/ while(1) {findout=0;

printf(\ gets(loginame);

ltrim(rtrim(loginame));

fp_mfd=fopen(\

for(i=0;fread(&ufd_lp,sizeof(OSUFD_LOGIN),1,fp_mfd)!=0;i++) if (strcmp(strupr(ufd_lp.ufdname),strupr(loginame))==0) {findout=1;

strcpy(logincpw,ufd_lp.ufdpword); }

fclose(fp_mfd);

if (findout==1) /*user exist*/ {printf(\

InputPW(loginpw); /*input password,use '*' replace*/ if (strcmp(loginpw,logincpw)==0) {strcpy(username,strupr(loginame)); strcpy(dirname,username);

fp_mfd=fopen(\

for(j=0;fread(&ufd_lp,sizeof(OSUFD_LOGIN),1,fp_mfd)!=0;j++) {strcpy(str,\ strcat(str,ufd_lp.ufdname);

ufd[j]=(OSUFD*)malloc(sizeof(OSUFD));

strcpy(ufd[j]->ufdname,strupr(ufd_lp.ufdname)); fp_ufd=fopen(str,\ fcount[j]=0;

for(i=0;fread(&ufd[j]->ufdfile[i],sizeof(OSFILE),1,fp_ufd)!=0;i++,fcount[j]++) {ifopen[j][i].ifopen=0; ifopen[j][i].openmode=4;} fclose(fp_ufd);} fclose(fp_mfd); ucount=j; SetPANo(0);

printf(\ loginsuc=1; return;} else

{printf(\ flag=1; while(flag)

{printf(\ gets(a);

ltrim(rtrim(a));

if (strcmp(strupr(a),\

else if(strcmp(strupr(a),\ } } } else

{printf(\

InputPW(loginpw); /*input new password,use '*' replace*/

printf(\ InputPW(logincpw);

if (strcmp(loginpw,logincpw)==0)

{strcpy(ufd_lp.ufdname,strupr(loginame)); strcpy(ufd_lp.ufdpword,loginpw); fp_mfd=fopen(\

fwrite(&ufd_lp,sizeof(OSUFD_LOGIN),1,fp_mfd); fclose(fp_mfd);

strcpy(username,strupr(loginame)); strcpy(dirname,loginame); strcpy(str,\ strcat(str,username);

if((fp_ufd=fopen(str,\{fp_ufd=fopen(str,\ fclose(fp_ufd); }

fp_mfd=fopen(\

for(j=0;fread(&ufd_lp,sizeof(OSUFD_LOGIN),1,fp_mfd)!=0;j++) {strcpy(str,\ strcat(str,ufd_lp.ufdname);

ufd[j]=(OSUFD*)malloc(sizeof(OSUFD));

strcpy(ufd[j]->ufdname,strupr(ufd_lp.ufdname)); fp_ufd=fopen(str,\

for(i=0;fread(&ufd[j]->ufdfile[i],sizeof(OSFILE),1,fp_ufd)!=0;i++,fcount[j]++) {ifopen[j][i].ifopen=0; ifopen[j][i].openmode=4;} fclose(fp_ufd);} fclose(fp_mfd); ucount=j; SetPANo(0);

printf(\ loginsuc=1; return; } else

{printf(\ flag=1; while(flag)

{printf(\ gets(a);

ltrim(rtrim(a));

if (strcmp(strupr(a),\

else if(strcmp(strupr(a),\

} } } } }

void SetPANo(int RorW) /*Set physical address num,0-read,1-write*/ {int i,j; if (RorW==0)

{if((fp_file_p=fopen(\ {fp_file_p=fopen(\ fclose(fp_file_p); }

fp_file_p=fopen(\ for(i=0;fread(&j,sizeof(int),1,fp_file_p)!=0;i++) fpaddrno[j]=1; /*for(i=1;i

if ((i)==0) fpaddrno[i]=1;*/ } else

{fp_file_p=fopen(\ /*for(i=1;i

if((i)==0) fpaddrno[i]=0;*/ for(i=0;i

fwrite(&i,sizeof(int),1,fp_file_p); }

fclose(fp_file_p); }

void InputPW(char *password) /*input password,use '*' replace*/ {int j;

for(j=0;j<=7;j++) {password[j]=getch(); if ((int)(password[j])!=13) {if((int)(password[j])!=8) putchar('*'); else {if (j>0) {j--;j--;

putchar('\\b');putchar(' ');putchar('\\b'); }

else j--; }

} else

{password[j]='\\0'; break; } }

password[j]='\\0'; }

void DirF() /*Dir FileSystem*/ {int i,j,count=0;

char sfmode[25],sfpaddr[25],str[25];

int ExistD(char *dirname); /*Whether DirName Exist,Exist-i,Not Exist-0*/ clrscr();

if (strcmp(strupr(ltrim(rtrim(dirname))),\ {printf(\

printf(\eMode\

j=ExistD(dirname); for(i=0;i

{printf(\ getch(); clrscr();

printf(\eMode\ }

itoa(ufd[j]->ufdfile[i].fpaddr,str,10); strcpy(sfpaddr,\strcat(sfpaddr,str);

if (ufd[j]->ufdfile[i].fmode==0) strcpy(sfmode,\else if(ufd[j]->ufdfile[i].fmode==1) strcpy(sfmode,\else if(ufd[j]->ufdfile[i].fmode==2)strcpy(sfmode,\else strcpy(sfmode,\

printf(\.flength,\ }

printf(\ else

{printf(\

printf(\ for(i=0;i

{if ((i==0)&&(i!=0))

{printf(\ getch(); clrscr();

printf(\}

printf(\count=count+fcount[i]; }

printf(\ } }

int ExistD(char *dirname) /*Whether DirName Exist,Exist-i,Not Exist-0*/ {int i; int exist=0;

for(i=0;i

if (strcmp(strupr(ufd[i]->ufdname),strupr(dirname))==0) {exist=1; break; }

if (exist) return(i); else return(-1); }

void CdF() /*Exchange Dir*/ {char dname[MAXNAME];

char *rtrim(char *str); /*remove the trailing blanks.*/ char *ltrim(char *str); /*remove the heading blanks.*/

int ExistD(char *filename); /*Whether FileName Exist,Exist-i,Not Exist-0*/ printf(\ gets(dname);

ltrim(rtrim(dname));

if (ExistD(dname)>=0) strcpy(dirname,strupr(dname));

else if(strcmp(strupr(dname),\ else printf(\}

void CreateF() /*Create File*/ {int fpaddrno,flag=1,i;

char fname[MAXNAME],str[50],str1[50],strtext[255],a[25]; char fmode[25];

char *rtrim(char *str); /*remove the trailing blanks.*/

char *ltrim(char *str); /*remove the heading blanks.*/ int FindPANo(); /*find out physical address num*/ int WriteF1(); /*write file*/

int ExistF(char *filename); /*Whether FileName Exist,Exist-i,Not Exist-0*/ int ExistD(char *dirname);

if (strcmp(strupr(dirname),strupr(username))!=0)

{printf(\ else {

printf(\ gets(fname);

ltrim(rtrim(fname)); if (ExistF(fname)>=0)

{printf(\wgetchar=1; } else

{printf(\3-Protect):\gets(fmode);

ltrim(rtrim(fmode));

if((strcmp(fmode,\fmode,\

{fpaddrno=FindPANo(); if (fpaddrno>=0) {i=ExistD(username);

strcpy(ufd[i]->ufdfile[fcount[i]].fname,fname); ufd[i]->ufdfile[fcount[i]].fpaddr=fpaddrno; ufd[i]->ufdfile[fcount[i]].fmode=atoi(fmode); ifopen[i][fcount[i]].ifopen=0; ifopen[i][fcount[i]].openmode=4; strcpy(str,\ itoa(fpaddrno,str1,10); strcat(str,str1); fp_file=fopen(str,\ fclose(fp_file); fcount[i]++; while(flag)

{printf(\ gets(a);

ltrim(rtrim(a));

ufd[i]->ufdfile[fcount[i]-1].flength=0; if(strcmp(strupr(a),\{fp_file=fopen(str,\

ufd[i]->ufdfile[fcount[i]-1].flength=WriteF1(); flag=0; }

else if(strcmp(strupr(a),\ }

printf(\ } else

{printf(\ }

else {printf(\ }} }

int ExistF(char *filename) /*Whether FileName Exist,Exist-i,Not Exist-0*/ {int i,j; int exist=0;

int ExistD(char *dirname); j=ExistD(dirname); for(i=0;i

if (strcmp(strupr(ufd[j]->ufdfile[i].fname),strupr(filename))==0) {exist=1; break; }

if (exist) return(i); else return(-1); }

int FindPANo() /*find out physical address num*/ {int i;

for(i=0;i

if (fpaddrno[i]==0) {fpaddrno[i]=1;break;} if (i

int WriteF1() /*write file*/ {int length=0; char c;

printf(\ while((c=getchar())!='#') {fprintf(fp_file,\ if (c!='\\n') length++; }

fprintf(fp_file,\ fclose(fp_file); return(length); }

void DeleteF() /*Delete File*/ {char fname[MAXNAME]; char str[50],str1[50]; int i,j,k,flag=1;

char a[25]; /*whether delete*/

char *rtrim(char *str); /*remove the trailing blanks.*/ char *ltrim(char *str); /*remove the heading blanks.*/

int ExistF(char *filename); /*Whether FileName Exist,Exist-i,Not Exist-0*/ int ExistD(char *dirname);

if (strcmp(strupr(dirname),strupr(username))!=0)

{printf(\ else

{printf(\ gets(fname);

ltrim(rtrim(fname)); i=ExistF(fname); if (i>=0)

{k=ExistD(username); if(ifopen[k][i].ifopen==1)

{printf(\delete.\\n\ else {

while(flag)

{printf(\gets(a);

ltrim(rtrim(a));

if(strcmp(strupr(a),\

{fpaddrno[ufd[k]->ufdfile[i].fpaddr]=0; itoa(ufd[k]->ufdfile[i].fpaddr,str,10); for(j=i;j

{strcpy(ufd[k]->ufdfile[j].fname,ufd[k]->ufdfile[j+1].fname); ufd[k]->ufdfile[j].fpaddr=ufd[k]->ufdfile[j+1].fpaddr; ufd[k]->ufdfile[j].flength=ufd[k]->ufdfile[j+1].flength; ufd[k]->ufdfile[j].fmode=ufd[k]->ufdfile[j+1].fmode; ifopen[k][j]=ifopen[k][j+1]; }

fcount[k]--;

strcpy(str1,\

strcat(str1,str); remove(str1); flag=0;

printf(\wgetchar=1; }

else if(strcmp(strupr(a),\

{printf(\ wgetchar=1; flag=0;} }}} else

{printf(\}

void ModifyFM() /*Modify FileMode*/ {char fname[MAXNAME],str[50]; int i,j,k,flag;

char fmode[25]; /*whether delete*/

char *rtrim(char *str); /*remove the trailing blanks.*/ char *ltrim(char *str); /*remove the heading blanks.*/

void InputPW(char *password); /*input password,use '*' replace*/ void SetPANo(int RorW); /*Set physical address num*/

int ExistF(char *filename); /*Whether FileName Exist,Exist-i,Not Exist-0*/ int ExistD(char *dirname);

if (strcmp(strupr(dirname),strupr(username))!=0) {printf(\modify filemode in yourself dir.\\n\ else

{ printf(\ gets(fname);

ltrim(rtrim(fname)); i=ExistF(fname); if (i>=0)

{k=ExistD(username); if(ifopen[k][i].ifopen==1)

{printf(\modify.\\n\ else {

if(ufd[k]->ufdfile[i].fmode==0) strcpy(str,\ else if(ufd[k]->ufdfile[i].fmode==1) strcpy(str,\ else if(ufd[k]->ufdfile[i].fmode==2) strcpy(str,\ else strcpy(str,\

printf(\

printf(\ gets(fmode);

ltrim(rtrim(fmode)); if(strcmp(fmode,\ {ufd[k]->ufdfile[i].fmode=0;

printf(\wgetchar=1; }

else if(strcmp(fmode,\ {ufd[k]->ufdfile[i].fmode=1;

printf(\wgetchar=1; }

else if(strcmp(fmode,\ {ufd[k]->ufdfile[i].fmode=2;

printf(\wgetchar=1; }

else if(strcmp(fmode,\ {ufd[k]->ufdfile[i].fmode=3;

printf(\wgetchar=1; }

else {printf(\ } } else

{printf(\}

void OpenF() /*Open File*/ {char fname[MAXNAME];

char str[25],str1[25],fmode[25]; int i,k;

char *rtrim(char *str); /*remove the trailing blanks.*/ char *ltrim(char *str); /*remove the heading blanks.*/

int ExistF(char *filename); /*Whether FileName Exist,Exist-i,Not Exist-0*/ int ExistD(char *dirname);

if (strcmp(strupr(ltrim(rtrim(dirname))),\

{printf(\ printf(\ gets(fname);

ltrim(rtrim(fname)); i=ExistF(fname); if (i>=0)

{k=ExistD(dirname); if(!ifopen[k][i].ifopen)

{if (ufd[k]->ufdfile[i].fmode==3)

{printf(\ else

{printf(\input FileOpenMode(0-Read Only,1-Write Only,2-Read and Write):\ gets(fmode);

ltrim(rtrim(fmode));

if((strcmp(fmode,\ {if(fmode[0]=='0') /*open file with read only mode*/ {strcpy(str,\

if((ufd[k]->ufdfile[i].fmode==0)||(ufd[k]->ufdfile[i].fmode==2)) ifopen[k][i].ifopen=1; }

else if(fmode[0]=='1') /*open file with write only mode*/ {strcpy(str,\

if((ufd[k]->ufdfile[i].fmode==1)||(ufd[k]->ufdfile[i].fmode==2)) ifopen[k][i].ifopen=1; }

else if(fmode[0]=='2') /*open file with read and write mode*/ {strcpy(str,\

if(ufd[k]->ufdfile[i].fmode==2) ifopen[k][i].ifopen=1; }

if(ufd[k]->ufdfile[i].fmode==0) strcpy(str1,\ else if(ufd[k]->ufdfile[i].fmode==1) strcpy(str1,\ else if(ufd[k]->ufdfile[i].fmode==2) strcpy(str1,\ if(ifopen[k][i].ifopen==1) {ifopen[k][i].openmode=atoi(fmode);

if (ifopen[k][i].openmode==0) strcpy(str,\ else if(ifopen[k][i].openmode==1) strcpy(str,\ else if(ifopen[k][i].openmode==2) strcpy(str,\ printf(\is %s\\n\ wgetchar=1; }

else

{printf(\FileMode is %s\\n\ }

else {printf(\ }}

else {printf(\ } else

{printf(\}

void CloseF() /*Close File*/ {int i,k,n=0;

char fname[MAXNAME];

char *rtrim(char *str); /*remove the trailing blanks.*/ char *ltrim(char *str); /*remove the heading blanks.*/

int ExistF(char *filename); /*Whether FileName Exist,Exist-i,Not Exist-0*/ int ExistD(char *dirname);

if (strcmp(strupr(ltrim(rtrim(dirname))),\

{printf(\ k=ExistD(dirname);

printf(\ for(i=0;i

{if (ifopen[k][i].ifopen==1) {printf(\ if((n%4==0)&&(n!=0)) printf(\ }

printf(\ if (n==0) wgetchar=1; if(n!=0)

{printf(\ gets(fname);

ltrim(rtrim(fname)); i=ExistF(fname); if(i>=0)

{if(ifopen[k][i].ifopen==1) {ifopen[k][i].ifopen=0; ifopen[k][i].openmode=4;

printf(\ wgetchar=1; }

else {printf(\ }

else {printf(\} }

void ReadF() /*Read File*/ {int i,k,n=0;

char fname[MAXNAME];

char str[255],str1[255],c;

char *rtrim(char *str); /*remove the trailing blanks.*/ char *ltrim(char *str); /*remove the heading blanks.*/

int ExistF(char *filename); /*Whether FileName Exist,Exist-i,Not Exist-0*/ int ExistD(char *dirname);

if (strcmp(strupr(ltrim(rtrim(dirname))),%ufd dir before read.\\n\ printf(\ printf(\ k=ExistD(dirname); for(i=0;i

if ((ifopen[k][i].openmode==0) ||(ifopen[k][i].openmode==2)) {printf(\if((n%4==0)&&(n!=0)) printf(\ }

printf(\ if (n==0) wgetchar=1; if(n!=0)

{printf(\ gets(fname);

ltrim(rtrim(fname)); i=ExistF(fname); if(i>=0)

{if(ifopen[k][i].ifopen==1)

{if((ifopen[k][i].openmode==0) ||(ifopen[k][i].openmode==2)) {itoa(ufd[k]->ufdfile[i].fpaddr,str,10); strcpy(str1,\ strcat(str1,str);

strcpy(str,\ strcat(str,str1); fp_file=fopen(str,\ fseek(fp_file,0,0);

printf(\ printf(\

while(fscanf(fp_file,\ if (c=='\\n') printf(\ else printf(\

printf(\ fclose(fp_file); wgetchar=1; } else

{printf(\

read.\\n\ }

else {printf(\read\\n\ }

else {printf(\} }

void WriteF() /*Write File*/ {int i,k,n=0;

char fname[MAXNAME];

char str[50],str1[50],a[50];

char *rtrim(char *str); /*remove the trailing blanks.*/ char *ltrim(char *str); /*remove the heading blanks.*/

int ExistF(char *filename); /*Whether FileName Exist,Exist-i,Not Exist-0*/ int ExistD(char *dirname); int WriteF1(); /*write file*/

if (strcmp(strupr(ltrim(rtrim(dirname))),\{printf(\Please convert to ufd dir before write.\\n\ k=ExistD(dirname);

printf(\openned files with writable mode*/ for(i=0;i

if ((ifopen[k][i].openmode==1) ||(ifopen[k][i].openmode==2)) {printf(\if((n%4==0)&&(n!=0)) printf(\ }

printf(\ if (n==0) wgetchar=1; if(n!=0)

{printf(\ gets(fname);

ltrim(rtrim(fname)); i=ExistF(fname); if(i>=0)

{if(ifopen[k][i].ifopen==1)

{if((ifopen[k][i].openmode==1) ||(ifopen[k][i].openmode==2)) {itoa(ufd[k]->ufdfile[i].fpaddr,str,10); strcpy(str1,\ strcat(str1,str);

strcpy(str,\ strcat(str,str1);

if (ufd[k]->ufdfile[i].flength!=0)

{printf(\write):\ gets(a);

ltrim(rtrim(a));

if (fp_file!=NULL) fclose(fp_file); if (strcmp(strupr(a),\ {printf(\fp_file=fopen(str,%ufd[k]->ufdfile[i].flength=0;

ufd[k]->ufdfile[i].flength=WriteF1(); }

else if(strcmp(strupr(a),\ {printf(\fp_file=fopen(str,\

ufd[k]->ufdfile[i].flength=ufd[k]->ufdfile[i].flength+WriteF1(); } else

{printf(\fclose(fp_file); wgetchar=1; } }

else

{fp_file=fopen(str,\

ufd[k]->ufdfile[i].flength=WriteF1(); } } else

{printf(\writed.\\n\ } else

{printf(\write\\n\ } else

{printf(\} }

void QuitF() /*Quit FileSystem*/ {int i,j; char str[50];

void SetPANo(int RorW); /*Set physical address num,0-read,1-write*/ SetPANo(1);

if (fp_mfd!=NULL) fclose(fp_mfd); if (fp_ufd!=NULL) fclose(fp_ufd); if (fp_file!=NULL) fclose(fp_file); for(j=0;jufdname); ltrim(rtrim(str)); fp_ufd=fopen(str,\ fclose(fp_ufd);

fp_ufd=fopen(str,\ for(i=0;i

fwrite(&ufd[j]->ufdfile[i],sizeof(OSFILE),1,fp_ufd); fclose(fp_ufd);} }

本文来源：https://www.bwwdw.com/article/qklw.html