《操作系统》课程设计说明书

河南城建学院

《操作系统》课程设计说明书

设计题目：UNIX/Linux文件系统分析

专业：计算机科学与技术

指导教师：邵国金耿永军陈红军

班级：0614082

学号：061408261

姓名：贠炳森

同组人：叶矿辉、陈宇

计算机科学与工程系

2011年1月7日

前言

在现在计算机更新如此迅速的时代要学好计算机软件技术，特别是操作系统的学习，不仅要努力学好课本上的基础知识，还要经常在图书馆看些有关这方面的书籍，而更重要的是要有足够的实践经验，也要注重和同学的交流，经常尝试性的做些小的操作系统，对自己技术的提升会有很大的帮助。

同时，学习计算机操作系统技术，除了需要刻苦努力外，还需要掌握软件和操作系统的原理与设计技巧。如何学习和掌握操作系统技术的原理与实际技巧呢?除了听课和读书之外，最好的方法恐怕就是在实践中练习。例如，自己设计一个小型操作系统，多使用操作系统，多阅读和分析操作源代码等。但由于我们的条件和学时有限，在理论学习过程中没有给同学们提供更多的实验机会。本操作系统课程设计，是给同学提供一个集中实验的机会。希望同学们通过该设计加深对所学习课程的理解。

本设计是基于课程中学到的UNIX系统调用，使用操作系统环境是Red Hat Linux 9，言语开发环境是Linux的GNU C或C++。

我做的课程设计是：Linux/Unix文件系统分析。在Linux系统下，使用与文件相关的系统调用实现对物理设备文件的读写，参照Linux系统源代码以及Grub 系统的源代码，对不同介质上的FAT格式文件系统进行分析。要求在Linux环境下设计出C语言程序，实现以下功能：

1)分析UNIX SysV/Linux系统引导记录的作用;

2)分析UNIX SysV/Linux的超级块及其结构，并建立相关数据结构，通过编程

实现UNIX SysV/Linux文件系统内各部分的定位。

3)至少要实现对给定i节点文件的只读访问

目录

一．系统环境 (3)

1.1硬件环境 (3)

1.2软件环境 (3)

二．设计目的及要求 (3)

三．总体设计 (5)

四．详细设计 (6)

五．调试与测试 (6)

六．设计中遇到的问题及解决方法 (6)

七．Linux/Unix文件系统分析源程序清单 (7)

7.1 头文件 (7)

7.2 示例程序 (10)

八．运行结果及分析 (16)

8.1 linux文件系统读取 (16)

8.2 UNIX文件系统读取 (18)

九．心得体会 (19)

十．参考文献 (20)

Linux/Unix文件系统分析

一．系统环境

1.1硬件环境

cpu为pentium4双线程技术，频率为2.8GHZ，内存为256MB。

1.2软件环境

使用操作系统环境是Red Hat Linux 9，言语开发环境是Linux的 GNU C或C++。

二．设计目的及要求

1、设计目的

学习计算机软件技术，特别是计算机操作系统技术，除了需要刻苦努力外，还需要掌握软件和操作系统的原理与设计技巧。如何学习和掌握操作系统技术的原理与实际技巧呢?除了听课和读书之外，最好的方法恐怕就是在实践中练习。例如，自己设计一个小型操作系统，多使用操作系统，多阅读和分析操作源代码等。但由于条件和学时有限，在理论学习过程中没有给提供更多的实验机会。本操作系统课程设计，是提供了一个集中实验的机会。应该通过该设计加深对所学习课程的理解。

2、设计要求

按软件工程的思想和方法进行设计，并把它作为一个工程来做。设计的每一步都有要形成文档，“成品”出来以后要有使用说明书和测试报告。最后按院方统一要求整理出软件实习“论文”，并分别以电子和书面文档的形式上交。最后，设计的程序要编译通过，并在验收时进行演示。

本设计的内容是基于《操作系统原理》教材的，但同学们必须对以前的《C 语言程序设计》和《数据结构》等内容进行认真的复习。

本设计是基于课程中学到的UNIX系统调用，使用操作系统环境是Red Hat Linux 9，言语开发环境是Linux的GNU C或C++。因此，要求课程设计者对Linux 操作系统和GNU C或C++有一定的了解。

3、设计内容

在Linux系统下，使用与文件相关的系统调用实现对物理设备文件的读写，参照Linux系统源代码以及Grub系统的源代码，对不同介质上的FAT格式文件系统进行分析。要求在Linux环境下设计出C语言程序，实现以下功能：1）分析UNIX SysV/Linux系统引导记录的作用;

2）分析UNIX SysV/Linux的超级块及其结构，并建立相关数据结构，通过编程实现UNIX SysV/Linux文件系统内各部分的定位。

3）至少要实现对给定i节点文件的只读访问。

4）建议根据文件读取文件。

文件系统必须完成下列工作：

1)为了合理的存放文件，必须对磁盘等辅助空间（或称文件空间）进行

统一管理。在用户创新新文件时为其分配空闲区，而在用户删除或修

改某个文件时，回收和调整存储区。

2)为了实现按名存取，需要有一个用户可见的文件逻辑结构，用户按照

文件逻辑结构所给定的方式进行信息的存取和加工。这种逻辑结构时

独立于物理存储设备的。

3)为了便于存放和加工信息，文件在存储和设备上应按一定的顺序存

放。这种存放方式被称为文件物理结构。

4)完成对存放在存储设备上的文件信息的查找。

5)完成文件的共享和提供保护功能。

三．总体设计

程序开始

读取超级快内容到buff

读取判断参数，打开文件系统，设置文件指针到超级快开头

判断第二个参数

UNIX 超级快内容解释程序段 LINUX 超级快内容解释程序段

显示超级快内部包含的文件系统信 显示超级块内部包含的文件系统信息

是否有第四参数 是否有第四参数

解释为i 节点号 提示输入i 节点

提示输入i 节点解释为i 节点号 根据i 节点读i 节点信息及i 节点所指向盘快信息并显示

根据i 节点读i 节点信息及i 节点所指向盘快信息并显示

四．详细设计

分析UNIX SysV/Linux系统引导记录的作用

UNIX SysV/Linux系统引导记录存放于整个硬盘的第一个扇区，即0柱面0磁头l扇区，也叫做MBR(MaserBoot Reoofd)扇区，即主引导记录。

主引导记录在计算机引导过程中起着举足轻重的作用，计算机在按下电源键以后，开始执行主板BI0S程序，进行完一系列检测和配置以后，开始按BI0S 中设定的系统引导顺序引导系统。BIOS执行完自己的程序后如何把执行投交给硬盘呢。交给硬盘后叉执行存储在哪里的程序呢?其实，称为MBR的扇区中的一段代码起着举足轻重的作用。 MBR不随操作系统的不同而小同，即不同的操作系统町能会存在相同的MBR．即使不同，MBR也不会夹带操作系统的性质，具有公共引导的特性。

对文件系统的操作参看程序源代码。

实现对磁盘文件的访问，实现读写、查看文件系统的存取信息，对应各个i节点的相关信息，以及各个i节点的排列情况，使用户能清楚的看到文件系统磁盘结构。更加了解计算机文件系统的工作流程。

五．调试与测试

（1）通过输入命令cc chengxu.c将文件编译为可执行文件a.out，通过输入命令./a.out加参数执行文件。

（2）判断命令行参数进行操作，当参数为./a.out u s51k .img时进行Linux文件系统读取，当参数为../a.out x xenix.img时进行Unix文件系统读取。

（3）判断是否有第四个参数，若没有，则提示输入i节点号并实现对给定i节点文件的只读访问。

六．设计中遇到的问题及解决方法

在设计程序时。我们按自己的理解编写了一个超级块和inode节点的结构体。然后放在主程序中去读取信息，但是运行的结果大出我们的预料。没有按我们的预期读出文件系统的信息，而是输出了一堆乱码，我们有经过查资料最后终于解决了问题，程序输出正常。

七．Linux/Unix文件系统分析源程序清单

7.1 头文件

#include

typedef __s16 s16;

typedef __u16 u16;

typedef __s32 s32;

typedef __u32 u32;

typedef u16 sysv_ino_t;

/* Block numbers are 24 bit, sometimes stored in 32 bit.

On Coherent FS, they are always stored in PDP-11 manner: the least

significant 16 bits come last.

*/

typedef u32 sysv_zone_t;

/* Among the blocks ... */

/* Xenix FS, Coherent FS: block 0 is the boot block, block 1 the super-block.

SystemV FS: block 0 contains both the boot sector and the super-block. */

/* The first inode zone is sb->sv_firstinodezone (1 or 2). */

/* Among the inodes ... */

/* 0 is non-existent */

#define SYSV_BADBL_INO 1/* inode of bad blocks file */

#define SYSV_ROOT_INO 2 /* inode of root directory */

/* Xenix super-block data on disk */

#define XENIX_NICINOD 100 /* number of inode cache entries */

#define XENIX_NICFREE 100 /* number of free block list chunk entries */

struct xenix_super_block {

u16 s_isize; /* index of first data zone */

u32 s_fsize;// __packed2__; /* total number of zones of this fs */

/* the start of the free block list: */

u16 s_nfree;/* number of free blocks in s_free, <= XENIX_NICFREE */

u32 s_free[XENIX_NICFREE]; /* first free block list chunk */

/* the cache of free inodes: */

u16 s_ninode; /* number of free inodes in s_inode, <= XENIX_NICINOD */

sysv_ino_t s_inode[XENIX_NICINOD]; /* some free inodes */

/* locks, not used by Linux: */

char s_flock;/* lock during free block list manipulation */

char s_ilock;/* lock during inode cache manipulation */

char s_fmod; /* super-block modified flag */

char s_ronly;/* flag whether fs is mounted read-only */

u32 s_time;//__packed2__;/*time of last super block update*/

u32 s_tfree;// __packed2__; /* total number of free zones */

u16 s_tinode; /* total number of free inodes */

s16 s_dinfo[4]; /* device information ?? */

char s_fname[6]; /* file system volume name */

char s_fpack[6]; /* file system pack name */

char s_clean; /* set to 0x46 when filesystem is properly unmounted */ char s_fill[371];

s32 s_magic; /* version of file system */

s32 s_type; /* type of file system: 1 for 512 byte blocks

2 for 1024 byte blocks

3 for 2048 byte blocks */

};

/* SystemV FS comes in two variants:

* sysv2: System V Release 2 (e.g. Microport), structure elements aligned(2).

* sysv4: System V Release 4 (e.g. Consensys), structure elements aligned(4). */

#define SYSV_NICINOD 100 /* number of inode cache entries */

#define SYSV_NICFREE 50 /* number of free block list chunk entries */

/* SystemV4 super-block data on disk */

struct sysv4_super_block {

u16 s_isize; /* index of first data zone */

u16 s_pad0;

u32 s_fsize; /* total number of zones of this fs */

/* the start of the free block list: */

u16 s_nfree;/* number of free blocks in s_free, <= SYSV_NICFREE */

u16 s_pad1;

u32 s_free[SYSV_NICFREE]; /* first free block list chunk */

/* the cache of free inodes: */

u16 s_ninode;/* number of free inodes in s_inode, <= SYSV_NICINOD */ u16 s_pad2;

sysv_ino_t s_inode[SYSV_NICINOD]; /* some free inodes */

/* locks, not used by Linux: */

char s_flock; /* lock during free block list manipulation */

char s_ilock; /* lock during inode cache manipulation */

char s_fmod; /* super-block modified flag */

char s_ronly; /* flag whether fs is mounted read-only */

u32 s_time; /* time of last super block update */

s16 s_dinfo[4]; /* device information ?? */

u32 s_tfree; /* total number of free zones */

u16 s_tinode; /* total number of free inodes */

u16 s_pad3;

char s_fname[6]; /* file system volume name */

char s_fpack[6]; /* file system pack name */

s32 s_fill[12];

s32 s_state;/* file system state: 0x7c269d38-s_time means clean */

s32 s_magic; /* version of file system */

s32 s_type; /* type of file system: 1 for 512 byte blocks

2 for 1024 byte blocks */

};

/* SystemV/Coherent inode data on disk */

struct sysv_inode {

u16 i_mode;

u16 i_nlink;

u16 i_uid;

u16 i_gid;

u32 i_size;

union { /* directories, regular files, ... */

unsigned char i_addb[3*(10+1+1+1)+1]; /* zone numbers: max. 10 data blocks, * then 1 indirection block,

* then 1 double indirection block,

* then 1 triple indirection block.

* Then maybe a "file generation number" ??

*/

/* named pipes on Coherent */

struct {

char p_addp[30];

s16 p_pnc;

s16 p_prx;

s16 p_pwx;

} i_p;

} i_a;

u32 i_atime; /* time of last access */

u32 i_mtime; /* time of last modification */

u32 i_ctime; /* time of creation */

};

/*

* SystemV/V7/Coherent FS inode data in memory

*/

struct sysv_inode_info {

u32 i_data[10+1+1+1]; /* zone numbers: max. 10 data blocks,

* then 1 indirection block,

* then 1 double indirection block,

* then 1 triple indirection block.

*/

};

7.2 示例程序

#include

#include

#include

#include

#include

#include"sysvfs.h"

#include

main(int argc, char **argv)

{

int i,j,k,typ,fd,L=5;

char*file_sys,*tmp,buff[1024],buff_i[1025];

struct sysv4_super_block *sbu;

struct xenix_super_block *sbx;

struct sysv_inode *inode;

int inode_size, inode_no,blk_size;

int i_start,d_start;

long ll;

ulong i_add[13];

if(argc<3) {

fprintf(stderr,"Usage:\n\t%argv[0] u|x filesystem\n",argv[0]);

exit(1);

}

switch(argv[1][0]){

case'U':

case'u':

typ=1;

break;

case'X':

case'x':

typ=2;

break;

default:

typ=0;

}

file_sys=argv[2];

if((fd=open(file_sys, O_RDONLY))==-1){

fprintf(stderr,"File System '%s' OPEN error!\a\n",file_sys);

exit(2);

}

if(lseek(fd,typ*512,SEEK_SET)!=typ*512){

fprintf(stderr,"File System '%s' SEEK error!\a\n",file_sys);

close(fd);exit(3);

}

if(read(fd,buff,512*typ)!=512*typ){

fprintf(stderr,"File System '%s' READ error!\a\n",file_sys);

close(fd);exit(4);

}

if(typ==1) goto unix_;

if(typ==2) goto xenix_;

exit(100);

unix_:

sbu=(struct sysv4_super_block *)buff;

printf("index of first data zone:%x\n",sbu->s_isize);

printf("s_pad0:%x\n", sbu->s_pad0);

printf("total number of zones of this fs:%x\n",sbu->s_fsize);

printf("/* the start of the free block list: */\n");

printf("number of free blocks in s_free, <= SYSV_NICFREE:%x\n",sbu->s_nfree);

printf("s_pad1:%x\t%ud\n", sbu->s_pad1, sbu->s_pad1);

printf("/* the cache of free inodes: */\n");

printf("number of free inodes in s_inode, <= SYSV_NICINOD:%x\n",sbu->s_ninode);

printf("s_pad2:%x\n" ,sbu->s_pad2);

printf("some free inodes:\n");

printf("/* locks, not used by Linux: */\n");

printf("time of last super block update:%x\n" ,sbu->s_time);

printf("total number of free zones:%x\n" ,sbu->s_tfree);

printf("total number of free inodes:%x\n" ,sbu->s_tinode);

printf("file system volume name:%x\n" ,sbu->s_fname);

char s_fpack[6]; /* file system pack name */

printf("s_state:%x\n" ,sbu->s_state);

/* file system state: 0x7c269d38-s_time means clean */

printf("s_magic:%x\n" ,sbu->s_magic);

/* version of file system */

/* type of file system: 1 for 512 byte blocks */

blk_size=512*sbu->s_type;

i_start=2;d_start=sbu->s_isize;//+i_start-1;

printf("Inode_from:%x\n",2*512*i_start);

printf("Data_from:%x\n",2*512*d_start);

inode_size=sizeof(struct sysv_inode);

printf("Size of INODE struct= %d\n",inode_size);

// get inode_no

if(argc>=4){

if(!isnum(argv[3])) inode_no=atoi(argv[3]);

else{

fprintf(stderr,"%s is not a INT");

close(fd);exit(9);

}

}

else {

printf("\n\n\tPlease input INODE_NO:");

scanf("%d",&inode_no);

}

printf("=========== inode=%d ==============\n",inode_no);

--inode_no;

j=inode_no*inode_size/1024;

k=(inode_no*inode_size/*-1*/)%1024;

j+=i_start;

if((ll=lseek(fd,blk_size*j,SEEK_SET))!=blk_size*j){

fprintf(stderr,"File System '%s' SEEK error!\a\n",file_sys);

close(fd);exit(5);

}

printf("LL=%dl\n",ll);

if(read(fd,buff_i,blk_size)!=blk_size){

fprintf(stderr,"File System '%s' READ error!\a\n",file_sys);

close(fd);exit(6);

}

tmp=buff_i+k;

inode=(struct sysv_inode *)tmp;

printf("i_mode=%x\n" ,inode->i_mode);

printf("i_link=%x\n" ,inode->i_nlink);

printf("I_ADDR:\n");

for(i=0;i<40;i++) printf("%x| " ,inode->i_a.i_addb[i]);

printf("I_ADDR_ALL:\n");

for(i=0;i<64;i++) printf("%x| " ,tmp[i]);

printf("\n");

i=0;

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

i_add[i]=inode->i_a.i_addb[j]+256*inode->i_a.i_addb[j+1]+256*256*inode->i_a .i_addb[j+2];

++i;

}

for(i=0;i<13;i++) printf("i_add[%d]=%d |", i,i_add[i]);

printf("\n");

// direct Block

for(i=0;i<10;i++){

if((ll=lseek(fd,blk_size*i_add[i],SEEK_SET))!=blk_size*i_add[i]){ fprintf(stderr,"File System '%s' SEEK error!\a\n",file_sys);

close(fd);exit(7);

}

if(read(fd,buff_i,blk_size)!=blk_size){

fprintf(stderr,"File System '%s' READ error!\a\n",file_sys);

close(fd);exit(8);

}

buff_i[blk_size]='\0';

fprintf(stderr,"%s",buff_i);

}

close(fd);

exit('U');

xenix_:

sbx=(struct xenix_super_block *)buff;

uint isize,nfree,ninode,tinode,*ii;

ulong fsize,*ul;

tmp=buff;isize=sbx->s_isize;

tmp+=2;ul=(ulong *)tmp;fsize=*ul;

printf("index of first data zone:%x\n",sbx->s_isize);

printf("total number of zones of this fs:%lx\n",fsize);

printf("/* the start of the free block list: */\n");

tmp=buff;tmp+=6;nfree=tmp[0]+256*tmp[1];

printf("number of free blocks in s_free, <= SYSV_NICFREE:%x\n",nfree);

tmp=buff+1024-4;

ll=*(long *)tmp;

/* type of file system: 1 for 512 byte blocks */

blk_size=512*ll;

printf("blk_size=%d\n",blk_size);

i_start=2;d_start=sbx->s_isize;//+i_start-1;

printf("Inode_from:%x\n",2*512*i_start);

printf("Data_from:%x\n",2*512*d_start);

inode_size=sizeof(struct sysv_inode);

printf("Size of INODE struct= %d\n",inode_size);

// get inode_no

if(argc>=4){

if(!isnum(argv[3])) inode_no=atoi(argv[3]);

else{

fprintf(stderr,"%s is not a INT");

close(fd);exit(9);

}

}

else {

printf("\n\n\tPlease input INODE_NO:");

scanf("%d",&inode_no);

}

printf("=========== inode=%d ==============\n",inode_no);

--inode_no;

j=inode_no*inode_size/1024;

k=(inode_no*inode_size)%1024;

j+=i_start;

if((ll=lseek(fd,blk_size*j,SEEK_SET))!=blk_size*j){

fprintf(stderr,"File System '%s' SEEK error!\a\n",file_sys);

close(fd);exit(5);

}

printf("LL=%dl\n",ll);

if(read(fd,buff_i,blk_size)!=blk_size){

fprintf(stderr,"File System '%s' READ error!\a\n",file_sys);

close(fd);exit(6);

}

tmp=buff_i+k;

printf("\n\n");

for(i=0;i

inode=(struct sysv_inode *)tmp;

printf("i_mode=%x\n" ,inode->i_mode);

printf("i_link=%x\n" ,inode->i_nlink);

printf("I_ADDR:\n");

for(i=0;i<40;i++) printf("%x| " ,inode->i_a.i_addb[i]);

printf("I_ADDR_ALL:\n");

for(i=0;i<64;i++) printf("%x| " ,tmp[i]);

printf("\n");

i=0;

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

i_add[i]=inode->i_a.i_addb[j]+256*inode->i_a.i_addb[j+1]+256*256*inode->i_a .i_addb[j+2];

++i;

}

for(i=0;i<13;i++) printf("i_add[%d]=%d |", i,i_add[i]);

printf("\n");

// direct Block

for(i=0;i<10;i++){

if((ll=lseek(fd,blk_size*i_add[i],SEEK_SET))!=blk_size*i_add[i]){ fprintf(stderr,"File System '%s' SEEK error!\a\n",file_sys);

close(fd);exit(7);

}

if(read(fd,buff_i,blk_size)!=blk_size){

fprintf(stderr,"File System '%s' READ error!\a\n",file_sys);

close(fd);exit(8);

}

fprintf(stderr,"%s",buff_i); // Maybe write to a file

}

close(fd);

exit('X');

}

isnum(char *s)

{

int i;

for(i=0;s[i]!='\0';i++)

if(!isdigit(s[i])) return 1;

return 0;

}

八．运行结果及分析

8.1 linux文件系统读取

8.2 UNIX文件系统读取

九．心得体会

为期一周的课程设计即将告一段落，这次课程设计中，我收获了很多。由于之前学的并不十分扎实，再加上准备不够充足，刚接到题目时感觉无从下手，不知所措。于是开始查阅资料，回顾学过的知识，不知不觉中初步掌握了计算的基本要领。

这次的课程设计中，我们组一共有三个人，分工明确，合作顺利。接下来就是分工和设计，由全组人来共同完成这项任务。通过与同组同学的合作，加强了我们的团体合作能力。通过对Linux这种大型软件代码的分析，看到大型软件的编程习惯，我们组成员深感我们平时的编程习惯与良好的编程习惯相差甚远，小组成员决定在以后的编程过程中养成良好的编程习惯，这样有助于自己所编的程序清晰明了便于该错还有助于别人来立解你的程序。同时通过这次课程设计我们形成了通过从各方面查找资料来丰富的知识的能力。学习了一个学期的操作系统课程，感觉这是一门理论性很强的课程。但是这次课程设计改变了我的看法。通过这次课程设计，我认识到操作系统也是一门实践性很强的课程

这次我们课程设计的题目是Linux/Unix文件系统分析。虽然在课本上学洗了ext2文件系统的基本结构。但是在课程设计的时候感到所学知识的严重不足。首先虽然我知道ext2文件系统的大致结构分为引导区、超级块以及索引节点等，但是并不清楚它们内部的信息以及相关的存储结构。通过查阅资料与向老师和同学请教。终于解决了许多疑惑。顺利进入程序设计阶段。

这次紧张又充实的的课程设计让我认识到课本上的知识是机械的，表面的。

此次的课程设计，使我对于UNIX/Linux文件系统有了更深刻的理解。对于理论