搜档网
当前位置:搜档网 › 实验四 文件系统实验

实验四 文件系统实验

实验四  文件系统实验
实验四  文件系统实验

实验四文件系统实验

实验目的

1)掌握文件系统的工作机理。

2)理解文件系统的主要数据结构。

3)学习较为复杂的LINUX下的编程

实验内容

1)设计并实现一个一级(单用户)文件系统程序

a.提供以下操作:

文件创建/删除接口命令create/delete

目录创建/删除接口命令mkdir/rmdir

显示目录内容命令ls

b.创建的文件不要求格式和内容

2)设计并实现一个二级文件系统程序

a.提供用户登录;

b.文件、目录要有权限

实验结果及其解释说明

基本上实现了简单文件系统的实现。

创建并读写文件如下图所示:

打开文件、关闭文件、创建并显示子目录、删除子目录如下图所示:

实验中的问题及解决

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

由于对文件系统理解不够深刻,导致程序在一些原理上的迷糊不清,而时间较短,因此采取了简化的方法。在写程序的开始也没有做详细的规划,因此在程序的结构上有些混乱。在后期做了一些调整,但是整体还是有缺陷的。另外程序只是很简单的实现了文件管理系统,只有一些非常简单的功能,而且功能考虑的也不尽全面、严谨,

难免会出现一些Bug。必须对写好的程序进行反复的调试和优化。

实验体会

通过学习基本掌握了文件系统的存储结构,当遇到困难的时候,认真思考和查阅资料可以有很大的帮助。经过这次实验,锻炼了自己的动手的能力和分析问题的能力。在构造函数的时候可以开阔思维,同时加深自己对文件系统实现的理解。在进行理论知识的学习时,我们一定要注意动手应用,这样可以让我们更好地掌握理论知识。

程序清单

#include

#include

#include

#define DIR_LENGTH 1024 /*路径最长可达100字节*/

#define MAX_WRITE 1024*128 /*写入文字可达128k字节*/

#define MEM_D_SIZE 1024*1024 /*1M磁盘空间*/

#define DISKSIZE 1024 /*磁盘快的大小1K*/

#define MSD 5 /*最大子目录数5 (类似五叉树)*/

#define DISK_NUM MEM_D_SIZE/DISKSIZE /*磁盘快数目1024=1M/1K*/

#define FATSIZE DISK_NUM*sizeof(struct fatitem) /*FAT表大小8K=8192B (理想应该是1.5K)*/

#define MOFN 5 /*最大文件打开数5 (即除根以外最大深度为5)*/

#define ROOT_DISK_NO FATSIZE/DISKSIZE+1 /*根目录起始盘快号9*/

#define ROOT_DISK_SIZE sizeof(struct direct)/*根目录大小196*/

/*---------------FAT表项结构-----------------------*/

struct fatitem /* size 8*/

{

int item; /*存放文件下一个磁盘的指针*/

char em_disk; /*磁盘块是否空闲标志位0 空闲*/

};

/*-------------------目录项结构------------------------*/

struct direct /* size 196*/

{

/*-----文件控制快信息-----*/

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 /* size 104*/

{

struct openttableitem /* size 20*/

{

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();

free(fdisk);

}

/*----------------------------------------------------------------------------------------------*/

/*------------------------------------------格式化----------------------------------------------*/ 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

{

fat[i].item=i+1;

fat[i].em_disk='1';

}

fat[ROOT_DISK_NO-1].item=-1;

fat[ROOT_DISK_NO-1].em_disk='1';

fat[ROOT_DISK_NO].item=-1; /*存放根目录的磁盘块号*/

fat[ROOT_DISK_NO].em_disk='1';

for(i=ROOT_DISK_NO+1;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;

for(i=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

{

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_LENGTH*sizeof(char));

strcpy(bufferdir,"Root:"); /*显示根目录为E:*/

}

/*----------------------------------------------------------------------------------------------*/

/*------------------------------------退出文件系统----------------------------------------------*/

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);

for(i=0;i

{

strcpy(u_opentable.openitem[i].name,"");

u_opentable.openitem[i].firstdisk = 0;

u_opentable.openitem[i].size = 0;

}

u_opentable.cur_size = 0; /*用户打开文件数清零*/

return;

}

/*----------------------------------------------------------------------------------------------*/

/*----------------------------------------创建文件----------------------------------------------*/

int create(char *name)

{

int i,j;

if(strlen(name)>8) /*文件名大于8位*/

return(-1);

for(i=2;i

{

if(cur_dir->directitem[i].firstdisk==-1)

break;

}

for(j=2;j

if(!strcmp(cur_dir->directitem[j].name,name))

break;

}

if(i>=MSD+2) /*无空目录项*/

return(-2);

if(u_opentable.cur_size>=MOFN) /*打开文件太多(第五层)*/

return(-3);

if(j

return(-4);

for(j=ROOT_DISK_NO+1;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';

/*cur_dir->directitem[i].sign 丢失*/

/*---------------------------------*/

fd = open(name); /*打开所创建的文件*/

return 0;

}

/*----------------------------------------------------------------------------------------------*/

/*----------------------------------------打开文件----------------------------------------------*/ int open(char *name)

{

int i, j;

for(i=2;i

{

if(!strcmp(cur_dir->directitem[i].name,name))

break;

if(i>=MSD+2) /*文件不存在*/

return(-1);

/*--------是文件还是目录-----------------------*/

if(cur_dir->directitem[i].property=='1')/*是目录,不可打开读写*/

return(-4);

/*--------文件是否打开-----------------------*/

for(j=0;j

{

if(!strcmp(u_opentable.openitem[j].name,name))

break;

}

if(j

return(-2);

if(u_opentable.cur_size>=MOFN) /*文件打开太多*/

return(-3);

/*--------查找一个空闲用户打开表项-----------------------*/

for(j=0;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

if(!strcmp(u_opentable.openitem[i].name,name))

break;

}

if(i>=MOFN) /*--文件没有打开-*/

return(-1);

/*-----------清空该文件的用户打开表项的内容---------------------*/

strcpy(u_opentable.openitem[i].name,"");

u_opentable.openitem[i].firstdisk = -1;

u_opentable.openitem[i].size = 0;

u_opentable.cur_size--;

fd = -1; /*文件打开表的序号为-1 */

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; /*SPACE的ASCII码值*/

char Endter= '\n';

for(i=0;i

{

if(buf[i] == '$') /*用$ 字符作为空格*/

buf[i] = Space;

else if(buf[i] == '#')

buf[i] = Endter;

}

/*----------读取用户打开表对应表项第一个盘块号-----------------------*/

item = u_opentable.openitem[fd].firstdisk;

/*-------------找到当前目录所对应表项的序号-------------------------*/

for(i=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

{

for(i=ROOT_DISK_NO+1;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

}

else/*-如果不是要最后分配的一块--*/

{

for(k=0;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;

if(len>u_opentable.openitem[fd].size) /*--欲读出的文件长度比实际文件长度长-*/ return(-1);

ilen1 = len/DISKSIZE;

modlen = len%DISKSIZE;

if(modlen!=0)

ilen1 = ilen1+1; /*--计算文件所占磁盘的块数-*/

first = fdisk+item*DISKSIZE; /*--计算文件的起始位置-*/

for(i=0;i

if(i==ilen1-1) /*--如果在最后一个磁盘块-*/

{

for(j=0;j

buf[i*DISKSIZE+j] = first[j];

}

else /*--不在最后一块磁盘块-*/

{

for(j=0;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

{

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

{

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(strchr(name,'\\'))/*如果目录名中有'\'字符*/

return(-4);

if(!strcmp(name,"."))

return(-6);

if(!strcmp(name,".."))

return(-6);

if(strlen(name)>8) /*-如果目录名长度大于8位-*/

return(-1);

for(i=2;i

{

if(cur_dir->directitem[i].firstdisk==-1)

break;

}

if(i>=MSD+2) /*-目录/文件已满-*/

return(-2);

for(j=2;j

{

if(!strcmp(cur_dir->directitem[j].name,name))

break;

if(j

return(-3);

for(j=ROOT_DISK_NO+1;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';

/*-sign=1为根标志,这里可以省略-*/

/*-所创目录在虚拟磁盘上的地址(内存物理地址)-*/

cur_mkdir=(struct direct *)(fdisk+cur_dir->directitem[i].firstdisk*DISKSIZE);

/*-初始化目录-*/

/*-指向当前目录的目录项-*/

cur_mkdir->directitem[0].sign=0;

cur_mkdir->directitem[0].firstdisk=cur_dir->directitem[i].firstdisk;

strcpy(cur_mkdir->directitem[0].name,".");

cur_mkdir->directitem[0].next=cur_mkdir->directitem[0].firstdisk;

cur_mkdir->directitem[0].property='1';

cur_mkdir->directitem[0].size=ROOT_DISK_SIZE;

/*-指向上一级目录的目录项-*/

cur_mkdir->directitem[1].sign=cur_dir->directitem[0].sign;/*-指向上一级目录的目录项-*/ cur_mkdir->directitem[1].firstdisk=cur_dir->directitem[0].firstdisk;

strcpy(cur_mkdir->directitem[1].name,"..");

cur_mkdir->directitem[1].next=cur_mkdir->directitem[1].firstdisk;

cur_mkdir->directitem[1].property='1';

cur_mkdir->directitem[1].size=ROOT_DISK_SIZE;

for(i=2;i

{

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

{

if(!strcmp(cur_dir->directitem[i].name,name))

break;

}

if(cur_dir->directitem[i].property!='1')/*-删除的不是目录-*/

return(-3);

if(i>=MSD+2) /*-没有这个文件或目录-*/

return(-1);

/*-判断要删除的目录有无子目录-*/

/*-要删除的目录起始地址-*/

temp_dir=(struct direct *)(fdisk+cur_dir->directitem[i].next*DISKSIZE);

for(j=2;j

{

if(temp_dir->directitem[j].next!=-1)

break;

}

if(j

return(-2); /*-有关联则报错,也可以采取级联删除,像Windows-*/

/*------------找到起始盘块号,并将其释放----------------*/

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=0;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);

else /*-目录-*/

printf("\t

\t\n");

}

}

}

/*----------------------------------------------------------------------------------------------*/

/*---------------------------------------更改当前目录-------------------------------------------*/

int cd(char *name)

{

int i,j,item;

char *str,*str1;

char *temp,*point,*point1;

struct direct *temp_dir;

temp_dir=cur_dir; /*-先用临时目录代替当前目录-*/

str=name; /*-str用来记录下次查找的起始地址-*/

if(!strcmp("\\",name)) /*如果输入"\" ,回根目录*/

{

cur_dir = root;

strcpy(bufferdir,"Root:");

return 0;

}

j=0;

for(i=0;i<(int)strlen(str);i++)/*查找有两个连续是"\",即"\\",退出*/

{

if(name[i]=='\\')

j++;

if(j>=2)

{

return -3;

}

}

else

j=0;

}

if(name[0]=='\\') /*如果最后一个是"\" ,去掉这个"\"*/

{

temp_dir = root;

strcpy(bufferdir,"Root:");

str++;

}

if(str[strlen(str)-1] == '\\')

{

str[strlen(str)-1] = '\0';

}

str1=strchr(str,'\\'); /*-找到'\'字符的位置-*/

temp = (char *)malloc(DIR_LENGTH*sizeof(char));/*-为子目录的名字分配空间-*/ while(str1!=NULL) /*-找到-*/

{

for(i=0;i

{

temp[i]=str[i];

}

temp[i]='\0';

for(j=2;j

{

if(!strcmp(temp_dir->directitem[j].name,temp))

break;

}

if(j>=MSD+2) /*-不在当前目录-*/

return(-1);

item=temp_dir->directitem[j].firstdisk;

temp_dir=(struct direct *)(fdisk+item*DISKSIZE); /*-计算当前目录物理位置-*/

str=str1+1;

str1=strchr(str,'\\');

//free(temp);

}

str1=str1+strlen(str);

for(i=0;i<(int)strlen(str);i++)

temp[i]=str[i];

temp[i]='\0';

for(j=0;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,'\\');

while(point!=NULL)

{

point1=point+1; /*-减去'\'所占的空间,记录下次查找的起始地址-*/ point=strchr(point1,'\\');

}

*(point1-1)='\0'; /*-将上一级目录删除-*/

}

else

{

}

}

else if(!strcmp(".",name))

文件系统实验报告

嵌入式系统实验报告(二) --嵌入式文件系统的构建 138352019陈霖坤一实验目的 了解嵌入式操作系统中文件系统的类型和作用 了解JFFS2文件系统的优点及其在嵌入式系统中的作用 掌握利用Busybox软件制作嵌入式文件系统的方法 掌握嵌入式linux文件系统的挂载过程 二实验内容与要求 编译BusyBox,以BusyBox为基础,构建一个适合的文件系统; 制作ramdisk文件系统映像,用你的文件系统启动到正常工作状态; 研究NFS作为根文件系统的启动过程。 三Busybox介绍 BusyBox最初是由Bruce Perens在1996年为Debian GNU/Linux安装盘编写的,其原始构想是希望在一张软盘上能放入一个开机系统,以作为急救盘和安装盘。后来它变成了嵌入式Linux设备和系统和Linux发布版安装程序的实质标准,因为每个Linux可执行文件需要数Kb的空间,而集成两百多个程序的BusyBox可以节省大量空间。Busybox集成了包括mini-vi编辑器、/sbin/init、文件操作、目录操作、系统配置等应用程序。 Busybox支持多种体系结构,可以选择静态或动态链接,以满足不同需要。 四linux文件系统 文件系统是对一个存储设备上的数据和元数据进行组织的机制,linux文件系统接口设计为分层的体系结构,从而将用户接口层、文件系统实现层和操作存储设备的驱动程序分隔开。 在文件系统方面,linux可以算得上操作系统中的“瑞士军刀”。Linux支持许多种文件系统,从日志型文件系统到集群文件系统和加密文件系统,而且对于使用标准的和比较奇特的文件系统以及开发文件系统来说,linux是极好的平台,这得益于linux内核中的虚拟文件系统(VFS,也称虚拟文件系统交换器)。 文件结构 Windows的文件结构是多个并列的树状结构,不同的磁盘分区各对应一个树。Linux的文件结构是单个的树,最上层是根目录,其它目录都从根目录生成。不同的linux发行版集

实验三 文件系统实验

实验三文件系统实验 一.目的要求 1. 用高级语言编写和调试一个简单的文件系统,模拟文件管理的工作过程。从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。 2. 要求设计一个n个用户的文件系统,每次用户可保存m个文件,用户在一次运行中只能打开一个文件,对文件必须设置保护措施,且至少有Create、delete、open、close、read、write等命令。 二.例题: ●设计一个10个用户的文件系统,每次用户可保存10个文件,一次运行 用户可以打开5个文件。 ●程序采用二级文件目录(即设置主目录[MFD])和用户文件目录(UED)。 另外,为打开文件设置了运行文件目录(AFD)。 ●为了便于实现,对文件的读写作了简化,在执行读写命令时,只需改读 写指针,并不进行实际的读写操作 ●算法与框图: 1.因系统小,文件目录的检索使用了简单的线性搜索。 2.文件保护简单使用了三位保护码:允许读写执行、对应位为1,对应位 为0,则表示不允许读写、执行。 3.程序中使用的主要设计结构如下: ●主文件目录和用户文件目录(MFD、UFD) ●打开文件目录(AFD)(即运行文件目录) MDF: (1)用户名 (2)文件目录指针 (3)用户名 (4)文件目录指针 UFD (1)文件名

(2)保护码 (3)文件长度 (4)文件名 AFD (1)打开文件名 (2)打开保护码 (3)读写指针 文件系统算法的流程图如下:

三.实验题: 1.增加2~3个文件操作命令,并加以实现。(如移动读写指针,改变文件属性, 更换文件名,改变文件保护级别)。 2.编一个通过屏幕选择命令的文件管理系统,每屏要为用户提供足够的选择信 息,不需要打入冗长的命令。 3.设计一个树型目录结构的文件系统,其根目录为root,各分支可以是目录, 也可以是文件,最后的叶子都是文件。 4.根据学校各级机构,编制一文件系统。

实验六 文件系统设计结果

实验六文件系统设计 1.目的和要求 本实验的目的是通过一个简单多用户文件系统的设计,加深理解文件系统的内部功能和内部实现。 2.实验内容 为DOS系统设计一个简单的二级文件系统,可以实现下列几条命令DIR 列文件目录 CREATE 创建文件 DELETE 删除文件 MODIFY 修改文件 OPEN 打开文件 CLOSE 关闭文件 列目录时要列出文件名,物理地址,保护码和文件长度。 3.实验环境 ①PC兼容机 ②Windows、DOS系统、Turbo c 2.0 ③C语言 4.实验提示 ①首先应确定文件系统的数据结构:主目录、活动文件等。主目录文件的形式存放于磁盘,这样便于查找和修改。 主目录结构: Ufdname 用户名 Ufdfile 指向用户的活动文件 活动文件结构: Fpaddr 文件物理地址 Flength 文件长度 Fmode 文件属性(file mode:0-Read Only;1-Write Only;2-Read and Write(default)) Fname 文件名称 ②用户创建的文件,可以编号存储于磁盘上。如:file0,file1,file2…并

以编号作为物理地址,在目录中进行登记。

③本程序需要在c:下建一个名为osfile的目录及一个名为file的子目录,在利用程序创建了文件系统后,可以在这个文件夹下查看到相关的内容。5.实验程序 #include "stdio.h" #include "string.h" #include "conio.h" #include "stdlib.h" #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;

Linux文件系统实验报告

黄冈师学院 提高型实验报告 实验课题文件系统的设计与实现(实验类型:□综合性 设计性□应用性) 实验课程操作系统原理 实验时间2015-2016 第二学期 学生何正发 专业班级软件工程1401 学号07

成绩: 一、实验目的和要求 1、熟悉操作系统设计的过程,巩固操作系统的基本知识,加深对操作原理、功能及各种不同的存储管理方法理解与应用; 2、学会运用各种语言、软件开发新软件的基本方法; 3、增强实际应用能力和动手操作能力。 二、实验条件 Win7 /Windows 8.1/Linux等操作系统,装有java、C、C++、C#等语言工具的环境。 三、实验原理分析 可以选择最佳适应算法,按照从小到大的次序组成空闲区自由链,当用户作业或进程申请一个空闲区时,存储管理 程序从表头开始查找,当找到第一个満足要求的空闲区时,停止查找。如果该空闲区大于请求表中的请求长 度,将减去请求长度后的剩余空闲区部分留在可用表中。回收时,从作链中删去要回收的作业块,同时在空 闲链中插入该作业大小的空闲区,并按顺序排列 四、实验方案或步骤 1、应用环境、需求分析 本模拟系统主要针对文件的管理和操作名主要有:创建用户、文件、文件夹,读文件,写文件,执行文件,关闭文件,删除用户、文件夹、文件的功能。 创建用户、文件、文件夹:在对系统发出操作命令之前必须先登录用户,然而登录之前必须创建该用户。在创建完后,可通过登录用户来创建文件和文件夹。在创建文件时可设置文件的属性和输入文件的容。 读文件:读取任何已创建的只读或读写文件的容;如果所要读的文件不是可读文件时,系统会显示该文件不可读;如果所读文件不存在,系统会显示文件不存在。 写文件用户可写或重写读写文件中的容,并保存文件中的重写容,以供下次读取;当所要写的文件不是可写的文件时,系统会显示该文件不可写;当所要写的文件并不存在时,系统会显示该文件不存在。

(完整版)linux文件系统管理-权限管理实验4报告

实验报告 课程Linux系统应用与开发教程实验名称linux文件系统管理-权限管理(高级设置) 一、实验目的 1、掌握Linux文件系统权限的设置 2、掌握linux用户帐号与组管理 3、掌握linux 文件共享的设置方法 4、掌握linux 文件共享的权限设置方法 二、实验内容 1、使用root帐号通过系统提供的6个虚拟控制台登陆到linux,或在x-windows开启一个终端。 2、完成以下的实验内容 (1)、假设你是系统管理员:现要在公司linux服务器系统中新增一些用户与一个用户组。 ?使用groupadd account 添加一个名为account的组 ?使用useradd -G account acc-user1,(该命令将添加一个用户名为acc-user1的用户, 同时会建立一个与用户名同名的私有组(该私有组为用户的默认组,这个组中只有一个用户名),并把该用户将加入account的标准组,同时,按同样的方法建立acc-user2、acc-user3、acc-user4。 ?建立用户后,请使用x-window中的用户与组管理工具查看用户与组建立情况,检查用户与组的归属情况。 (2)、开启多个控制台,分别使用acc-user1、acc-user2、acc-user3登陆系统(可以在控制台分别登陆,也可以在X-windows中多开几个终端程序,默认使用root登陆,然后使用su命令通过切换用户的方式登陆,其语法为“su - user-name”,提示可以在登陆成功后运行命令“id”查看当前登陆的用户属于哪些组,当前的默认组是什么?) (3)、为account组建立一个公共共享目录/home/account-share,满足以下的权限设定要求,以及设置何种的umask: ?该目录的拥有者为acc-user1,所属组为account。 ?在该目录下建立一个/home/account-share/full-share的子目录,修改该目录的权限,使得account组的成员均能在对该目录有完全控制权限,account组外的其他用户没有任何权限,即account组的成员都可以在该目录下建立文件,同时在该子目录full-share下建立的文件,只有文件建立者有权限删除,并且每个用户在该子目录full-share下建立的文件也能自动与该account组成员可读共享。 ?在/home/account-share/为每个用户建立一个与用户名同名的子目录(如/home/account-share/acc-user1为用户acc-user1的目录,其拥有者为acc-user1,所在的组为account),配置该子目录的拥有者有完全控制权限,而同组用户只能读取,同时在用户在该目录下建立的文件,可供同组用户读。 (4)、考虑完成以上的共享目录权限设置,应注意哪些设置。包括目录的权限,目录的拥有者,目录所在的组,具体文件的权限,umask设置等。 (5)、实验报告应体现出使用不同身份的用户对所配置目录的访问测试过程。 三、实验环境 安装有vmware或visual pc软件的window主机,系统中有提供turbolinux或redhat的硬盘

实验四 文件系统实验

实验四文件系统实验 一 . 目的要求 1、用高级语言编写和调试一个简单的文件系统,模拟文件管理的工作过程。从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。 2、要求设计一个 n个用户的文件系统,每次用户可保存m个文件,用户在一次运行中只能打开一个文件,对文件必须设置保护措施,且至少有Create、delete、open、close、read、write等命令。 二 . 例题: 1、设计一个10个用户的文件系统,每次用户可保存10个文件,一次运行用户可以打开5个文件。 2、程序采用二级文件目录(即设置主目录[MFD])和用户文件目录(UED)。另外,为打开文件设置了运行文件目录(AFD)。 3、为了便于实现,对文件的读写作了简化,在执行读写命令时,只需改读写指针,并不进行实际的读写操作。 4、算法与框图: ①因系统小,文件目录的检索使用了简单的线性搜索。 ②文件保护简单使用了三位保护码:允许读写执行、对应位为 1,对应位为0,则表示不允许读写、执行。 ③程序中使用的主要设计结构如下: 主文件目录和用户文件目录( MFD、UFD) 打开文件目录( AFD)(即运行文件目录)

文件系统算法的流程图如下: 三 . 实验题: 1、增加 2~3个文件操作命令,并加以实现。(如移动读写指针,改变文件属 性,更换文件名,改变文件保护级别)。 #include #include #include #define getpch(type) (type*)malloc(sizeof(type)) int userNum=0; struct mdf {

FAT文件系统操作系统课程设计实验报告

操作系统课程设计之三 设计任务:模拟OS文件系统 在任一OS(Window或者Dos;也可以是在Linux下,但要求能将结果演示给老 师看)下,建立一个大文件,把它假象成一张盘,在其中实现一个简单的模拟OS 字 ,第 ⑤、每个目录实际能放下文件或子目录30项。 ⑸、文件系统空间分配: ①、第0个盘块(1k)存放磁盘信息(可以设定为格式说明“FAT32”、盘块大小,盘块数等 内容) ②、第1个盘块起,至125盘块,共125个盘块(125k)存放FAT内容 ③、第126、127(2个)盘块,存放位示图

④、从第128盘块至10000盘块,皆为数据(区)盘块,其逻辑编号从0开始,至 9872号数据盘块,即第0数据盘块为128号盘块,第1数据盘块为129号盘块,… ⑤、第0数据盘块(即128号盘块),存放根目录(同样只用一个盘块作根目录), 由于第0、1目录项为“.”(本目录), “..”(父目录),因此根目录下同样只能存放30个文件或目录,并且从第2个目录项开始。 ⑥、文件或子目录数据,放在第1数据盘块及以后的数据盘块中,由用户按需要使 用。 内容 ⑺、删除文件 #DelFile 文件名.扩展名,在文件所在的目录项中,将第一个字节变为0xE5,并同时修改FAT内容和位示图内容;如果文件不存在,给出出错信息 ⑻、文件拷贝 #CopyFile 老文件,新文件,为新文件创建一个目录项,并将老文件内容复制到新文件中,并同时修改FAT内容和位示图内容 ⑼、显示位示图内容

#ShowBitMP,将位示图内容(已有信息部分),显示在屏幕上(按十六进制)⑽、显示FAT内容 #ShowFAT,将FAT内容(已有信息部分),显示在屏幕上(按十六进制) 4、程序的总体流程为: ⑴、输出提示符#,等待接受命令,分析键入的命令; ⑵、对合法的命令,执行相应的处理程序,否则输出错误信息,继续等待新命令 关于对FAT表和MAP表的用法 1.当要用到数据块是,查询MAP表(因为只做比较查询即可),查询到的未用位置 置1,然后在FAT表上进行相应记录,在本程序做出的规定是,当文件夹FAT 表做-1,若是文件则按照FAT做对应的顺序记录,最后一块同样是-1结束,2.回收的时候,是按照FAT表的首项,做顺序置0,然后MAP也在相应位置置0

实验4 文件操作

齐鲁工业大学实验报告成绩 一、实验目的及要求 1.熟悉Linux下常用的操作指令。 2.加深对文件,目录,文件系统等概念的理解。 3.掌握Linux文件系统的目录结构。 4.掌握有关Linux文件系统操作的常用命令。 5.了解有关文件安全方面的知识。 二、实验过程及结果 1.浏览文件系统 〈1〉运行pwd命令,确定你当前的工作目录。 〈2〉利用以下命令显示当前工作目录的内容:(理解各字段彻底意义。) 〈3〉运行以下命令:(反馈信息中.代表本身目录,..代表其父目录;选项a可以显示隐藏文件;选项i可以显示文件的I节点号) ls –ai 〈4〉使用mkdir命令建立一个子目录subdir,并用ls查看当前目录。 〈5〉使用带-d选项的ls命令,你只能看到有关子目录的信息(.表示本身目录)。 〈6〉使用cd命令,将工作目录改到根目录(/)上。 ①用相对路径将工作目录改到根目录。 ②用绝对路径将工作目录改到根目录。

2.查看你的文件 〈1〉利用cd命令,将工作目录改到你的主目录上。 〈2〉将工作目录改到你的子目录subdir,然后运行命令: date > file1 将当前日期和时间存放到新建文件file1中。 Ls –l 反馈信息中有新文件 file1。 〈3〉使用cat命令查看file1文件的内容。 〈4〉利用man命令显示date命令的用法(说明文件): 〈5〉将date命令的用法(说明文件内容)附加到文件file1的后面: 3.文件存取权限 mv file_a file1 恢复文件file1; ls –l 显示文件file1的权限为 rw-rw-r—; 1).取消同组用户g和其他用户o 对文件可读的权利; 2).显示文件file1的权限。 3).恢复同组用户g和其他用户o 对文件可读的权利;

Linux文件系统实验

实验编号与实验名称: 文件系统实验 实验目的: 熟悉文件和目录的基本操作;了解Linux的/proc文件系统 实验内容及要求(详见实验讲义与实验指导书): 内容: 1)在/usr目录下创建一个目录usr_test和文本文件test,并建立一个test文件的链接 test02。通过修改test文件中的内容查看test和test02中内容的情况,并分析原因。 2)编写程序,从/proc文件中抽取内核参数(任意的2个参数即可,如CPU时钟速度信 息等) 3)实现文件的拷贝,即把一个文件内容复制到另一个文件 要求: 对于内容1),给出操作步骤和结果分析,需回顾第二次实验中练习过的Shell命令和教材中的文件和目录操作系统调用 对于内容2)和3)给出完整C语言代码或者代码截图和代码执行结果,可参考本文件“实验预读”中相关内容和教材P.149/266图4-5相关代码 实验用到的软件(:) VMware 实验内容及关键步骤(代码)Q2(60分) 1)在/usr目录下创建一个目录usr_test和文本文件test,并建立一个test文件的链接 test02。通过修改test文件中的内容查看test和test02中内容的情况,并分析原因。

分析:在linux系统中通过link连接就可以通过第三方的查询,通过link函数后test01被绑定给test02中,所以可以通过test02去查询。 2.编写程序,从/proc文件中抽取内核参数(任意的2个参数即可,如CPU时钟速度信息等)

3.实现文件的拷贝,即把一个文件内容复制到另一个文件

实验过程中遇到的问题解决办法与实验体会Q3(10分)得分: 评阅教师特殊评语: 评阅教师: 日期:

文件系统实验报告

实验二文件系统实验报告

一.实验简介 本实验要求在假设的I/O 系统之上开发一个简单的文件系统,这样做既能让实验者对文件系统有整体了解,又避免了涉及过多细节。用户通过create, open, read 等命令与文件系统交互。文件系统把磁盘视为顺序编号的逻辑块序列,逻辑块的编号为0 至L-1。I/O 系统利用内存中的数组模拟磁盘。 实际物理磁盘的结构是多维的:有柱面、磁道、扇区等概念。I/O 系统的任务是隐藏磁盘的结构细节,把磁盘以逻辑块的面目呈现给文件系统。逻辑块顺序编号,编号取值范围为0 至L .. 1,其中L 表示磁盘的存储块总数。实验中,我们可以利用字符数组ldisk[L][B] 构建磁盘模型,其中 B 表示每个存储块的长度。I/O 系统从文件系统接收命令,根据命令指定的逻辑块号把磁盘块的内容读入命令指定的内存区域,或者把命令指定的内存区域内容写入磁盘块。 我设计的文件系统拥有三个用户。 二.具体说明 1.文件系统的组织:磁盘的前k 个块是保留区,其中包含如下信息:位图和文件描述符。位图用来描述磁盘块的分配情况。位图中的每一位对应一个逻辑块。创建或者删除文件,以及文件的长度发生变化时,文件系统都需要进行位图操作。前k 个块的剩余部分包含一组文件描述符。每个文件描述符包含如下信息: ?文件长度,单位字节 ?文件分配到的磁盘块号数组。该数组的长度是一个系统参数。在实验中我们可以把它设置为一个比较小的数,例如3。 2.目录:我们的文件系统中仅设置一个目录,该目录包含文件系统中的所有文件。除了不需要显示地创建和删除之外,目录在很多方面和普通文件相像。目录对应0 号文件描述符。初始状态下,目录中没有文件,所有,目录对应的描述符中记录的长度应为0,而且也没有分配磁盘块。每创建一个文件,目录文件的长度便增加一分。目录文件的内容由一系列的目录项组成,其中每个目录项由如下内容组成: ?文件名 ?文件描述符序号 3.对文件的操作: 文件系统需提供如下函数;create, destroy, open, read, write。 ?create(filename): 根据指定的文件名创建新文件。 ?destroy(filename): 删除指定文件。 ?open(filename): 打开文件。该函数返回的索引号可用于后续的read, write, lseek, 或close 操作。 ?close(index): 关闭制定文件。 ?read(index, mem_area, count): 从指定文件顺序读入count 个字节mem_area 指定的内存位

操作系统实验5文件系统:Linux文件管理

实验5 文件系统:Linux文件管理 1.实验目的 (1)掌握Linux提供的文件系统调用的使用方法; (2)熟悉文件和目录操作的系统调用用户接口; (3)了解操作系统文件系统的工作原理和工作方式。 2.实验内容 (1)利用Linux有关系统调用函数编写一个文件工具filetools,要求具有下列功能:*********** 0. 退出 1. 创建新文件 2. 写文件 3. 读文件 4. 复制文件 5. 修改文件权限 6. 查看文件权限 7. 创建子目录 8. 删除子目录 9. 改变当前目录到指定目录 10. 链接操作 *********** 代码: #include #include #include #include #include #include #include #include void menu(void); void openfile(void); void writefile(void); void readfile(void); void copyfile(void); void chmd(void); void ckqx(void); void cjml(void); void scml(void); void ggml(void); void ylj(void); int main() { int choose; int suliangjin=1;

menu(); scanf("%d",&choose); while(choose!=0) { switch(choose) { case 1:openfile();break; case 2:writefile();break; case 3:readfile();break; case 4:copyfile();break; case 5:chmd();break; case 6:ckqx();break; case 7:cjml();break; case 8:scml();break; case 9:ggml();break; case 10:ylj();break; } menu(); scanf("%d",&choose); } return 0; } void menu(void) { printf("文件系统\n"); printf("1.创建新文件\n"); printf("2.写文件\n"); printf("3.读文件\n"); printf("4.复制文件\n"); printf("5.修改文件权限\n"); printf("6.查看文件权限\n"); printf("7.创建子目录\n"); printf("8.删除子目录\n"); printf("9.改变目前目录到指定目录\n"); printf("10.链接操作\n"); printf("0.退出\n"); printf("请输入您的选择...\n"); } void openfile(void) { int fd; if((fd=open("/tmp/hello.c",O_CREAT|O_TRUNC|O_RDWR,0666))<0) perror("open");

实验5添加一个文件系统

实验5 添加一个文件系统 实验目的 文件系统是操作系统中最直观的部分,因为用户可以通过文件直接地和操作系统交互,操作系统也必须为用户提供数据计算、数据存储的功能。本实验通过添加一个文件系统,进一步理解Linux中的文件系统原理及其实现。 深入理解操作系统文件系统原理 学习理解Linux的VFS文件系统管理技术 学习理解Linux的ext2文件系统实现技术 设计和实现自定义文件系统 实验内容 添加一个类似于ext2的自定义文件系统myext2。实验主要内容: 添加一个和ext2完全相同的文件系统myext2 修改myext2的magic number 修改文件系统操作 添加文件系统创建工具 实验指导 1. 问题描述

本实验的内容是要添加一个类似于ext2的自定义文件系统myext2。myext2文件系统的描述如下: 1、myext2文件系统的物理格式定义与ext2基本一致,除了myext2的magic number 是0x6666,而ext2的magic number是0xEF53。 2、myext2是ext2的定制版本,它只支持原来ext2文件系统的部分操作,以及修改了部分操作。 2. 实验步骤 提示:下面的操作步骤以3.6.6版本的内核为例,2.6.15版本的内核请参照教材,其它版本内核可能会有所区别。 2.1 添加一个和ext2完全相同的文件系统myext2 要添加一个与ext2完全相同的文件系统myext2,首先是确定实现ext2文件系统的内核源码是由哪些文件组成。Linux源代码结构很清楚地告诉我们:fs/ext2目录下的所有文件是属于ext2文件系统的。再检查一下这些文件所包含的头文件,可以初步总结出来Linux 源代码中属于ext2文件系统的有: fs/ext2/acl.c fs/ext2/acl.h fs/ext2/balloc.c fs/ext2/bitmap.c fs/ext2/dir.c

实验二--文件系统及磁盘管理

实验二文件系统及磁盘管理 1.文件系统管理 一、实验目的 ●掌握Linux下文件系统的创建、挂载与卸载。 ●掌握文件系统的自动挂载。 二、项目背景 某企业的Linux服务器中新增了一块硬盘/dev/sdb,请使用fdisk命令新建/dev/sdb1主分区和/dev/sdb2扩展分区,并在扩展分区中新建逻辑分区/dev/sdb5,并使用mkfs命令分别创建vfat和ext3文件系统。然后用fsck命令检查这两个文件系统;最后,把这两个文件系统挂载到系统上。 三、实验内容 练习Linux系统下文件系统的创建、挂载与卸载及自动挂载的实现。 四、实验步骤 子项目1.创建/dev/sdb1和/dev/sdb5 ●使用fdisk命令创建/dev/sdb1主分区。 ●使用fdisk命令创建/dev/sdb2扩展分区。

●使用fdisk命令创建/dev/sdb5逻辑分区。 ●输入子命令w,把设置写入硬盘分区表,退出fdisk并重新启动系统。 ●用mkfs命令在上述刚刚创建的分区上创建ext3文件系统和vfat文件系统。 ●用fsck命令检查上面创建的文件系统。 子项目2.挂载/dev/sdb1和/dev/sdb5 ●利用mkdir命令,在/mnt目录下建立挂载点,mountpoint1和mountpoint2。 ●把上述新创建的ext3分区挂载到/mnt/mountpoint1上。

●把上述新创建的vfat分区挂载到/mnt/mountpoint2上。 ●利用mount命令列出挂载到系统上的分区,查看挂载是否成功。 ●利用umount命令卸载上面的两个分区。 子项目3.实现/dev/sdb1和/dev/sdb5的自动挂载 ●编辑系统文件/etc/fstab文件,把上面两个分区加入此文件中。 ●重新启动系统,显示已经挂载到系统上的分区,检查设置是否成功。 子项目4.挂载光盘和U盘 ●取一张光盘放入光驱中,将光盘挂载到/media/cdrom目录下。查看光盘中的文件。 ●利用与上述相似的命令完成U盘的挂载与卸载。 五、实验思考题 1. 在Linux下能创建Windows 的分区吗?在Linux下能创建Windows的文件系统吗? Windows操作系统可以识别ext3文件系统吗? 2.系统挂装表的文件名?系统挂装表的作用是什么?其文件格式使什么? 3.利用mount命令挂装一个文件系统和将其写入/etc/fstab文件的区别是什么?

文件系统存储空间管理模拟实验报告

课程名称计算机操作系统实验名称文件系统存储空间管理模拟姓名学号 专业班级实验日期 成绩指导老师 一、实验目的 根据提出的文件分配和释放请求,动态显示磁盘空闲空间的 态以及文件目录的变化,以位示图和索引分配为例:每次执行请求后要求显示或打印位示图的修改位置、分配和回收磁盘的物理块地址、更新的位示图、目录。 二、实验原理 用数组表示位示图,其中的每一位对应磁盘一个物理块的状态,0表示、空闲,1表示分配;当请求分配一个磁盘块时,寻找到数组中为0的位,计算相对磁盘块号,并计算其在磁盘中的物理地址(柱面号、磁道号、物理块号),并将其状态由0变到1。当释放某一物理块时,已知其在磁盘中的物理地址,计算其相对磁盘块号,再找到位示图数组中的相应位,将其状态由1变为0。 三、主要仪器设备 PC机(含有VC) 四、实验容与步骤 实验容:1. 模拟文件空间分配、释放过程,可选择连续分配、链式分配、索引分配法;2. 文件空闲空间管理,可采用空白块链、空白目录、位示图法; 步骤如下: 1. 输入磁盘基本信息参数,计算位示图大小,并随机初始化位示图; (1)磁盘基本信息:磁盘柱面数m, 每柱面磁道数p, 每磁道物理块数q; (2)假设采用整数数组存放位示图,则数组大小为: Size= ceil((柱面数*每柱面磁道数*每磁道物理块数)/(sizeof(int)*8))(3)申请大小为size的整数数组map,并对其进行随机初始化。 例如:假设m=2, p=4, q=8, 共有64个磁盘块,若sizeof(int)=2, 则位示图大小为4,map[4]如下: 地址到高地址位上。即map[0]的第0位到第15位分别对应0号磁盘块到15号磁盘块的状态,map[1]的第0位到第15位对应16号磁盘块到31号磁盘块的状

实验4(文件系统)

实验4 文件系统 一、目的与要求 1. 目的 文件系统是操作系统的一个重要组成部分,也是与用户关系极为密切的部分。学生应独立的用高级语言编写和调试一个简单的文件系统,模拟文件管理的工作过程,从而对各种文件操作命令的实质内容和执行过程有比较深入的了解,掌握它们的实施方法,加深对教材中有关内容的理解。 2. 要求 (1)设计一个n个用户的文件系统,每个用户最多可保存m个文件。 (2)限制用户在一次运行中只能打开一个文件。 (3)系统应能检查输入命令的正确性,出错时要能显示出错原因。 (4)对文件必须设置保护措施,如只能执行,允许读,允许写等。在每次打开文件时,根据本次打开的要求,再次设置保护级别,即可有二级保护。 (5)对文件的操作至少应有下面几条命令: create 建立文件 delete 删除文件 open 打开文件 close 关闭文件 read 读文件 write 写文件 (6)本次实验的上机时间为2~4学时。 二、实验内容 1. 题目 (1)本次实验设计一个共有10个用户的文件系统,每个用户最多可保存10个文件,一次运行过程中用户可同时打开5个文件。 (2)程序采用二级文件目录,即设置了主文件目录(MFD)和用户文件目录(UFD)。前者应包含文件主(即用户)及他们的目录区指针;后者应给出每个文件主占有的文件目录,即文件名、保护码、文件长度以及它们存放的位置等。另外为打开文件设置了运行文件目录(AFD),在文件打开时应填入打开文件号,本次打开保护码和读写指针等。 (3)为了便于实现,对文件的读写作了简化,在执行读写命令时,只修改读写指针,并不进行实际文件的读写操作。 2. 算法与框图

实验 文件系统管理

实训项目4 文件系统管理 一、实训目的 ●掌握Linux下文件系统的创建、挂载与卸载。 ●掌握文件系统的自动挂载。 二、项目背景 某企业的Linux服务器中新增了一块硬盘/dev/sdb,请使用fdisk命令新建/dev/sdb1主分区和/dev/sdb2扩展分区,并在扩展分区中新建逻辑分区/dev/sdb5,并使用mkfs命令分别创建vfat和ext3文件系统。然后用fsck命令检查这两个文件系统;最后,把这两个文件系统挂载到系统上。 三、实训内容 练习Linux系统下文件系统的创建、挂载与卸载及自动挂载的实现。 四、实训步骤 子项目1.创建/dev/sdb1和/dev/sdb5 ●使用fdisk命令创建/dev/sdb1主分区。 ●使用fdisk命令创建/dev/sdb2扩展分区。

●使用fdisk命令创建/dev/sdb5逻辑分区。 ●输入子命令w,把设置写入硬盘分区表,退出fdisk并重新启动系统。 ●用mkfs命令在上述刚刚创建的分区上创建ext3文件系统和vfat文件系统。 ●用fsck命令检查上面创建的文件系统。 子项目2.挂载/dev/sdb1和/dev/sdb5 ●利用mkdir命令,在/mnt目录下建立挂载点,mountpoint1和mountpoint2。

●把上述新创建的ext3分区挂载到/mnt/mountpoint1上。 ●把上述新创建的vfat分区挂载到/mnt/mountpoint2上。 ●利用mount命令列出挂载到系统上的分区,查看挂载是否成功。 ●利用umount命令卸载上面的两个分区。 子项目3.实现/dev/sdb1和/dev/sdb5的自动挂载 ●编辑系统文件/etc/fstab文件,把上面两个分区加入此文件中。 ●重新启动系统,显示已经挂载到系统上的分区,检查设置是否成功。 子项目4.挂载光盘和U盘 ●取一张光盘放入光驱中,将光盘挂载到/media/cdrom目录下。查看光盘中的文件。 ●利用与上述相似的命令完成U盘的挂载与卸载。 五、实训思考题 1. 在Linux下能创建Windows 的分区吗?在Linux下能创建Windows的文件系统吗?Windows操作

操作系统实验报告-实验四

操作系统实验报告-实验四

实验四:进程管理(二) 实验内容: 1.编写一个程序,打印进程的如下信息:进程标识符,父进程标识符,真实用户ID,有效用户ID,真实用户组ID,有效用户组ID。并分析真实用户ID和有效用户ID的区别。 源代码及结果: 真实用户ID和有效用户ID的区别: 真实用户ID:这个ID就是我们登陆unix 系统时的身份ID。 有效用户ID:定义了操作者的权限。有效用户ID是进程的属性,决定了该进程对文件的访问权限。 2.阅读如下程序,编译并运行,分析进程执行过程的时间消耗(总共消耗的时间和CPU

消耗的时间),并解释执行结果。再编写一个计算密集型的程序替代grep,比较两次时间的花销。注释程序主要语句。 /* process using time */ #include #include #include #include #include void time_print(char *,clock_t); int main(void){ //取得进程运行相关的时间 clock_t start,end; struct tms t_start,t_end; start = times(&t_start); system(“grep the /usr/doc/*/* > /dev/null 2> /dev/null”); /*command >/dev/null的作用是将是command命令的标准输出丢弃,而标准错误输出还是在屏幕上。一般来讲标准输出和标准

计算机操作系统体系结构实验报告

操作系统实验报告 实验目的: 随着操作系统应用领域的扩大,以及操作系统硬件平台的多样化,操作系统的体系结构和开发方式都在不断更新,目前通用机上常见操作系统的体系结构有如下几种:模块组合结构、层次结构、虚拟机结构和微内核结构。为了更好的了解计算机操作系统体系结构,以及linux 的体系结构,特作此报告。 实验内容: 计算机操作系统体系结构 一、模块组合结构 操作系统刚开始发展时是以建立一个简单的小系统为目标来实现的,但是为了满足其他需求又陆续加入一些新的功能,其结构渐渐变得复杂而无法掌握。以前我们使用的MS-DOS 就是这种结构最典型的例子。这种操作系统是一个有多种功能的系统程序,也可以看成是一个大的可执行体,即整个操作系统是一些过程的集合。系统中的每一个过程模块根据它们要完成的功能进行划分,然后按照一定的结构方式组合起来,协同完成整个系统的功能。如图1所示: 在模块组合结构中,没有一致的系统调用界面,模块之间通过对外提供的接口传递信息,模块内部实现隐藏的程序单元,使其对其它过程模块来说是透明的。但是,随着功能的增加,模块组合结构变得越来越复杂而难以控制,模块间不加控制地相互调用和转移,以及信息传递方式的随意性,使系统存在一定隐患。 二、层次结构 为了弥补模块组合结构中模块间调用存在的固有不足之处,就必须减少模块间毫无规则的相互调用、相互依赖的关系,尤其要清除模块间的循环调用。从这一点出发,层次结构的设计采用了高层建筑结构的理念,将操作系统或软件系统中的全部构成模块进行分类:将基础的模块放在基层(或称底层、一层),在此基础上,再将某些模块放在二层,二层的模块在基础模块提供的环境中工作;它只能调用基层的模块为其工作,反之不行。严格的层次结构,第N+l层只能在N层模块提供的基础上建立,只能在N层提供的环境中工作,也只能向N 层的模块发调用请求。 在采用层次结构的操作系统中,各个模块都有相对固定的位置、相对固定的层次。处在同一层次的各模块,其相对位置的概念可以不非常明确。处于不同层次的各模块,一般而言,不可以互相交换位置,只存在单向调用和单向依赖。Unix/Linux系统采用的就是这种体系结构。 在层次结构中,强调的是系统中各组成部分所处的位置,但是想要让系统正常运作,不得不协调两种关系,即依赖关系和调用关系。 依赖关系是指处于上层(或外层)的软件成分依赖下层软件的存在、依赖下层软件的运行而运行。例如,浏览器这部分软件就依赖GUI的存在和运行,GUI又依赖操作系统的存在和运行。在操作系统内部,外围部分依赖内核的存在而存在,依赖内核的运行而运行,内核又依赖HAL而运行。处在同层之内的软件成分可以是相对独立的,相互之间一般不存在相互依赖关系。 三、虚拟机结构 虚拟机的基本思想是系统能提供两个功能:①多道程序处理能力;②提供一个比裸机有更方便扩展界面的计算机。操作系统是覆盖在硬件裸机上的一层软件,它通过系统调用向位于

实验四_文件系统实验

实验四文件系统实验 一 .目的要求 1、用高级语言编写和调试一个简单的文件系统,模拟文件管理的工作过程。从而对各种文件操作命令的实质内容和执行过程有比较深入的了解。 2、要求设计一个 n个用户的文件系统,每次用户可保存m个文件,用户在一次运行中只能打开一个文件,对文件必须设置保护措施,且至少有Create、delete、open、close、read、write等命令。 二 .例题: 1、设计一个10个用户的文件系统,每次用户可保存10个文件,一次运行用户可以打开5个文件。 2、程序采用二级文件目录(即设置主目录[MFD])和用户文件目录(UED)。另外,为打开文件设置了运行文件目录(AFD)。 3、为了便于实现,对文件的读写作了简化,在执行读写命令时,只需改读写指针,并不进行实际的读写操作。 4、算法与框图: ①因系统小,文件目录的检索使用了简单的线性搜索。 ②文件保护简单使用了三位保护码:允许读写执行、对应位为 1,对应位为0,则表示不允许读写、执行。 ③程序中使用的主要设计结构如下: 主文件目录和用户文件目录( MFD、UFD) 打开文件目录( AFD)(即运行文件目录)

文件系统算法的流程图如下: 三 .实验题: 1、增加 2~3个文件操作命令,并加以实现。(如移动读写指针,改变文件属性,更换文件名,改变文件保护级别)。 #include #include #include using namespace std; struct TYPE_UFD {

string File_Name; bool Read; bool Write; bool Execute; int Length_File; }; struct TYPE_MFD { string User_Name; TYPE_UFD *Pointer; }; struct TYPE_AFD { int File_ID; bool Read; bool Write; bool Execute; int Pointer; }; class TYPE_FILE_SYSTEM { public: void Initial( void ); void Start( void ); private: int _Number_Users; int _Number_Files; int _MaxNumber_Open_Files; TYPE_MFD *_MFD; TYPE_UFD *_UFD; TYPE_AFD *_AFD; }; void TYPE_FILE_SYSTEM::Initial( void ) { _Number_Users = 10; _Number_Files = 10; _MaxNumber_Open_Files = 5; _UFD = new TYPE_UFD [_Number_Users*_Number_Files]; _MFD = new TYPE_MFD [_Number_Users]; int i=0;

相关主题