linux二级文件系统的设计

A. linux文件系统中包括的主要文件类型有哪些

主要文件类型包括如下：

1. ext： ext 是第一个专门为 Linux 的文件系统类型,叫做扩展文件系统。

2. ext2：ext2 是为解决 ext 文件系统的缺陷而设计的可扩展的高性能的文件系统.又被称为 二级扩展文件系统

3. ext3： ext3 是由开放资源社区开发的日志文件系统,. ext3 被设计成是 ext2 的升级版本。

4. jsf： jsf 提供了基于日志的字节级文件系统,该文件系统是为面向事务的高性能系统而开发的。

5. ReiserFS： ReiserFS 基于平 衡树结构的 、ReiserFS 文件系统在网上公手氏戚布.ReiserFS 3.6.x(作为 Linux 2.4 一部分 的版本)，设计成员相信最好的文件系统是那些能够有助于创建独立的共享环境或者命名空间的文件系统。

6. Xfs： xfs 是一种非常优秀的日志文件系统,它是 SGI 公司设计的.xfs 被称为业界最先进 的,最具可升级性的文件系统技术.它是一个全 64 位,快速,稳固的日志文件系统,
   

B. 求Linux和windows下不同的文件系统比较

查看/Lib/moles/内核版本/kernel/fs文件夹下的内容，表明当前系统支持那些文件系统，即linux的磁盘分区格式。

ext 是第一个专门为Linux的文件系统类型，叫做扩展文件系统，缺陷很多。

ext2 是为解决ext文件系统的缺陷而设计的可扩展的高性能的文件系统。又被称为二级扩展文件系统。2000年以前几乎所有的Linux发行版都用ext2作为默认的文件系统。ext2的缺点：ext2的设计者主要考虑的是文件系统性能方面的问题。ext2在写入文件内容的同时并没有同时写入文件的有关的信息，例郑猛没如：权限、所有者以及创建和访问时间。换句话说，Linux先写入文件的内容，然后等到有空的时候才写入文件的相关信息。这样若出现写入文件内容之后系统突然断电，就可能造成在文件系统就会处于不一致的状态。

ext3 是一种日志式文件系统，是在保有目前 ext2 的格式之下再加上日志功能。日志式文件系统的优越性在于：由于文件系统都有快取层参与运作，知空如不使用时必须将文件系统卸下，以便将快取层的资料写回磁盘中。因此每当系统要关机时，必须将其所有的文件系统全部卸下后才能进行关机。如果在文件系统尚未卸下前就关机 (如停电) 时，下次重开机后会造成文件系统的资料不一致，故这时必须做文件系统的重整工作，将不一致与错误的地方修复。然而，此一重整的工作是相当耗时的，特别是容 量大的文件系统，而且也不能百分之百保证所有的资料都不会流失。故这在大型的服务器上可能会造成问题。

jsf 提供了基于日志的字节级文件系统，该文件系统是为面向事务的高性喊纳能系统而开发的。是一个有大量用户安装使用的企业级文件系统。它具有可伸缩性和健壮性，与非日志文件系统相比，它的优点是其快速重启能力：jsf 能够在几秒或几分钟内就把文件系统恢复到一致状态。jsf的缺点：使用jsf日志文件系统，性能上会有一定损失，系统资源占用的比率也偏高。是因为当它保持一个日志时，系统需要写许多数据。

xfs 是一种非常优秀的日志文件系统，它是一个全64位,快速、稳固的日志文件系统，可以支持超大数量的文件（9g× 1gb，甚至更大的18g×1gb），可在大型 2d 和 3d 数据方面提供显着的性能。xfs有能力预测其它文件系统薄弱环节，同时xfs提供了在不妨碍性能的情况下增强可靠性和快速的事故恢复。由于xfs比较复杂，实施起来有一些难度，所以目前xfs主要应用于Linux企业应用的高端。

nfs 是Sun公司推出的网络文件系统，允许多台计算机之间共享同一文件系统，易于从所有这些计算机上存取文件。

NTFS 是微软Windows NT内核的系列操作系统支持的、一个特别为网络和磁盘配额、文件加密等管理安全特性设计的磁盘格式。

C. 操作系统linux 二级文件系统具体是怎么实现的

说通俗一点就类似于数组加上链表的结构，i_addr[8]数组中每一个元素都指向了一个磁盘块，如果那个磁盘块中也存放了一个虚团i_addr[8]数组，并且那个数组中的渣誉薯每个元素也指向了一个磁盘块，那么这就是二级的索引文件结构如者了～
建议看一下操作系统原理（庞丽萍）一书中的文件系统一章
这个东西是Unix V的一种典型的文件系统～呵呵～

D. 安装linux 硬盘分区的时候应该选哪个文件系统

安装linux硬盘分区格式一般以ext3，etx4为主。

ext是为linux核心所做的第一个文件系统。采用Unix文件系统（UFS）的元数据结构，以克服MINIX文件系统性能不佳的问题。它是在linux上，第一个利用虚拟文件系统实现出的文件系统，在linux核心0.96c版中首次加入支持，最大可支持2GB的文件。

(4)linux二级文件系统的设计扩展阅读

Ext4文件系统的特点

1、更大的文件系统和更大的文件

Ext3文件系昌判统最多只能支持32TB的文件系统和2TB的文件，根据使用的具体架构和系统设置，实际容量上限可能宏迅冲比这个数字还要低，即只能容纳2TB的文件系统和16GB的文件。而Ext4的文件系统容量蔽歼达到1EB，而文件容量则达到16TB。

2、更多的子目录数量

Ext3目前只支持32000个子目录，而Ext4取消了这一限制，理论上支持无限数量的子目录。

3、更多的块和i-节点数量

Ext3文件系统使用32位空间记录块数量和i-节点数量，而Ext4文件系统将它们扩充到64位。

E. Linux文件系统中包括的主要文件类型有哪些

主要文件类型包括如下：
ext：
ext
是第一个专门为
Linux
的文件系统类型,叫做扩展文件系统。
ext2：ext2
是为解决
ext
文件系统的缺陷而设计的可扩展的高性能的文件系统.又被称为
二级扩展文件系统
ext3：
ext3
是由开放资源社区开发的日志文件系统,.
ext3
被设计成是
ext2
的升级版本。
jsf：
jsf
提供了基于日志的字节级文件系统,该文件系统是为面向事务的高性能系统而开发的。
ReiserFS：
ReiserFS
基于平
衡树结构的
、ReiserFS
文件系统在网上公布.ReiserFS
3.6.x(作为
Linux
2.4
一部分
的版本)，设计成员相信最好的文件系统是那些能够有助于创建独立的共享环境或者命名空间的文件系统。
Xfs：
xfs
是一种非常优秀的日志文件系统,它是
SGI
公司设计的.xfs
被称为业界最先进
的,最具可升级性的文件系统技术.它是一个全
64
位,快速,稳固的日志文件系统,
Linux文件系统中的文件是数据的集合，文件系统不仅包含着文件中的数据而且还有文件系统的结构，所有Linux
用户和程序看到的文件、目录、软连接及文件保护信息等都存储在其中。
很详细地了解某个操作系统的实际工作方式是非常困难的，因为大多数操作系统的源代码都是严格保密的。在以实际使用为目标的操作系统中，让任何人都可以自由获取系统源代码，无论目的是要了解、学习还是修改，这样的系统并不多。本论文的主题就是这些少数操作系统中的一个：Linux。

F. 为linux系统设计一个简单的二级文件系统。要求做到以下几点：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

#define MEM_D_SIZE 1024*1024 //总磁盘空间让弊为1M
#define DISKSIZE 1024 //磁盘块的大小1K
#define DISK_NUM 1024 //磁盘块数目1K
#define FATSIZE DISK_NUM*sizeof(struct fatitem) //FAT表大小
#define ROOT_DISK_NO FATSIZE/DISKSIZE+1 //根目录起始盘块号
#define ROOT_DISK_SIZE sizeof(struct direct) //根目录大小
#define DIR_MAXSIZE 1024 //路径最大长度为1KB
#define MSD 5 //最大子目录数5
#define MOFN 5 //最大文件深度为5
#define MAX_WRITE 1024*128 //最大写入文字长度128KB

struct fatitem /* size 8*/
{
int item; /*存放文件下一个磁盘的指针*/
char em_disk; /*磁盘块是否空闲标志位 0 空闲*/
};

struct direct
{
/*-----文件控制快信息-----*/
struct FCB
{
char name[9]; /*文件/目录名 8位*/
char property; /*属性 1位目录 0位普通文件*/
int size; /*文件/目录字节数、盘块数颤配)*/
int firstdisk; /*文件/目录 起始盘块号*/
int next; /*子目录起始盘块号*/
int sign; /*1是根目录 0不是根目录*/

}directitem[MSD+2];

};

struct opentable
{
struct openttableitem
{
char name[9]; /*文件名*/
int firstdisk; /*起始盘块号*/
int size; /*文件的大小*/
}openitem[MOFN];
int cur_size; /*当前打文件的数目*/
};

struct fatitem *fat; /*FAT表*/
struct direct *root; /*根目录*/
struct direct *cur_dir; /*当前目录*/
struct opentable u_opentable; /*文件打开表*/
int fd=-1; /*文件打开表的序号*/
char *bufferdir; /*记录当前路径的名称*/
char *fdisk; /*虚拟磁盘起始地址*/

void initfile();
void format();
void enter();
void halt();
int create(char *name);
int open(char *name);
int close(char *name);
int write(int fd,char *buf,int len);
int read(int fd,char *buf);
int del(char *name);
int mkdir(char *name);
int rmdir(char *name);
void dir();
int cd(char *name);
void print();
void show();

void initfile()
{
fdisk = (char *)malloc(MEM_D_SIZE*sizeof(char)); /*申请 1M空间*/
format();

}

void format()
{
int i;
FILE *fp;

fat = (struct fatitem *)(fdisk+DISKSIZE); /*计算FAT表地址，引坦洞族导区向后偏移 1k)*/
/*-----初始化FAT表------------*/
fat[0].item=-1; /*引导块*/
fat[0].em_disk='1';

for(i=1;i<ROOT_DISK_NO-1;i++) /*存放 FAT表的磁盘块号*/
{
fat[i].item=i+1;
fat[i].em_disk='1';
}

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

for(i=ROOT_DISK_NO+1;i<DISK_NUM;i++)
{
fat[i].item = -1;
fat[i].em_disk = '0';
}
/*-----------------------------------------------*/
root = (struct direct *)(fdisk+DISKSIZE+FATSIZE); /*根目录的地址*/
/*初始化目录*/
/*---------指向当前目录的目录项---------*/
root->directitem[0].sign = 1;
root->directitem[0].firstdisk = ROOT_DISK_NO;
strcpy(root->directitem[0].name,".");
root->directitem[0].next = root->directitem[0].firstdisk;
root->directitem[0].property = '1';
root->directitem[0].size = ROOT_DISK_SIZE;
/*-------指向上一级目录的目录项---------*/
root->directitem[1].sign = 1;
root->directitem[1].firstdisk = ROOT_DISK_NO;
strcpy(root->directitem[1].name,"..");
root->directitem[1].next = root->directitem[0].firstdisk;
root->directitem[1].property = '1';
root->directitem[1].size = ROOT_DISK_SIZE;
if((fp = fopen("disk.dat","wb"))==NULL)
{
printf("Error:\n Cannot open file \n");
return;
}
for(i=2;i<MSD+2;i++) /*-子目录初始化为空-*/
{
root->directitem[i].sign = 0;
root->directitem[i].firstdisk = -1;
strcpy(root->directitem[i].name,"");
root->directitem[i].next = -1;
root->directitem[i].property = '0';
root->directitem[i].size = 0;
}

if((fp = fopen("disk.dat","wb"))==NULL)
{
printf("Error:\n Cannot open file \n");
return;
}
if(fwrite(fdisk,MEM_D_SIZE,1,fp)!=1) /*把虚拟磁盘空间保存到磁盘文件中*/
{
printf("Error:\n File write error! \n");
}

fclose(fp);

}
void enter()
{
FILE *fp;
int i;

fdisk = (char *)malloc(MEM_D_SIZE*sizeof(char)); /*申请 1M空间*/
if((fp=fopen("disk.dat","rb"))==NULL)
{
printf("Error:\nCannot open file\n");
return;
}
if(!fread(fdisk,MEM_D_SIZE,1,fp)) /*把磁盘文件disk.dat 读入虚拟磁盘空间(内存)*/
{
printf("Error:\nCannot read file\n");
exit(0);
}
fat = (struct fatitem *)(fdisk+DISKSIZE); /*找到FAT表地址*/
root = (struct direct *)(fdisk+DISKSIZE+FATSIZE);/*找到根目录地址*/
fclose(fp);
/*--------------初始化用户打开表------------------*/
for(i=0;i<MOFN;i++)
{
strcpy(u_opentable.openitem[i].name,"");
u_opentable.openitem[i].firstdisk = -1;
u_opentable.openitem[i].size = 0;
}
u_opentable.cur_size = 0;

cur_dir = root; /*当前目录为根目录*/
bufferdir = (char *)malloc(DIR_MAXSIZE*sizeof(char));
strcpy(bufferdir,"Root:");
}

void halt()
{
FILE *fp;
int i;

if((fp=fopen("disk.dat","wb"))==NULL)
{
printf("Error:\nCannot open file\n");
return;
}
if(!fwrite(fdisk,MEM_D_SIZE,1,fp)) /*把虚拟磁盘空间(内存)内容读入磁盘文件disk.dat */
{
printf("Error:\nFile write error!\n");
}
fclose(fp);

free(fdisk);
free(bufferdir);
return;
}

int create(char *name)
{

int i,j;

if(strlen(name)>8) /*文件名大于 8位*/
return(-1);

for(j=2;j<MSD+2;j++) /*检查创建文件是否与已存在的文件重名*/
{
if(!strcmp(cur_dir->directitem[j].name,name))
break;
}
if(j<MSD+2) /*文件已经存在*/
return(-4);

for(i=2;i<MSD+2;i++) /*找到第一个空闲子目录*/
{
if(cur_dir->directitem[i].firstdisk==-1)
break;
}
if(i>=MSD+2) /*无空目录项*/
return(-2);
if(u_opentable.cur_size>=MOFN) /*打开文件太多*/
return(-3);

for(j=ROOT_DISK_NO+1;j<DISK_NUM;j++) /*找到空闲盘块 j 后退出*/
{
if(fat[j].em_disk=='0')
break;
}
if(j>=DISK_NUM)
return(-5);
fat[j].em_disk = '1'; /*将空闲块置为已经分配*/
/*-----------填写目录项-----------------*/
strcpy(cur_dir->directitem[i].name,name);
cur_dir->directitem[i].firstdisk = j;
cur_dir->directitem[i].size = 0;
cur_dir->directitem[i].next = j;
cur_dir->directitem[i].property = '0';
/*---------------------------------*/
fd = open(name);
return 0;

}

int open(char *name)
{
int i, j;

for(i=2;i<MSD+2;i++) /*文件是否存在*/
{
if(!strcmp(cur_dir->directitem[i].name,name))
break;
}
if(i>=MSD+2)
return(-1);
/*--------是文件还是目录-----------------------*/
if(cur_dir->directitem[i].property=='1')
return(-4);

/*--------文件是否打开-----------------------*/
for(j=0;j<MOFN;j++)
{
if(!strcmp(u_opentable.openitem[j].name,name))
break;
}
if(j<MOFN) /*文件已经打开*/
return(-2);

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

/*--------查找一个空闲用户打开表项-----------------------*/
for(j=0;j<MOFN;j++)
{
if(u_opentable.openitem[j].firstdisk==-1)
break;
}
/*--------------填写表项的相关信息------------------------*/
u_opentable.openitem[j].firstdisk = cur_dir->directitem[i].firstdisk;
strcpy(u_opentable.openitem[j].name,name);
u_opentable.openitem[j].size = cur_dir->directitem[i].size;
u_opentable.cur_size++;
/*----------返回用户打开表表项的序号--------------------------*/
return(j);
}

int close(char *name)
{
int i;

for(i=0;i<MOFN;i++)
{
if(!strcmp(u_opentable.openitem[i].name,name))
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--;

return 0;
}

int write(int fd, char *buf, int len)
{
char *first;
int item, i, j, k;
int ilen1, ilen2, modlen, temp;
/*----------用 $ 字符作为空格 # 字符作为换行符-----------------------*/
char Space = 32;
char Endter= '\n';

for(i=0;i<len;i++)
{
if(buf[i] == '$')
buf[i] = Space;
else if(buf[i] == '#')
buf[i] = Endter;
}

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

item = u_opentable.openitem[fd].firstdisk;

/*-------------找到当前目录所对应表项的序号-------------------------*/
for(i=2;i<MSD+2;i++)
{
if(cur_dir->directitem[i].firstdisk==item)
break;
}
temp = i; /*-存放当前目录项的下标-*/
/*------找到的item 是该文件的最后一块磁盘块-------------------*/
while(fat[item].item!=-1)
{
item =fat[item].item; /*-查找该文件的下一盘块--*/
}

/*-----计算出该文件的最末地址-------*/
first = fdisk+item*DISKSIZE+u_opentable.openitem[fd].size%DISKSIZE;

/*-----如果最后磁盘块剩余的大小大于要写入的文件的大小-------*/
if(DISKSIZE-u_opentable.openitem[fd].size%DISKSIZE>len)
{
strcpy(first,buf);
u_opentable.openitem[fd].size = u_opentable.openitem[fd].size+len;
cur_dir->directitem[temp].size = cur_dir->directitem[temp].size+len;
}
else
{
for(i=0;i<(DISKSIZE-u_opentable.openitem[fd].size%DISKSIZE);i++)
{/*写一部分内容到最后一块磁盘块的剩余空间(字节)*/
first[i] = buf [i];
}
/*-----计算分配完最后一块磁盘的剩余空间(字节) 还剩下多少字节未存储-------*/
ilen1 = len-(DISKSIZE-u_opentable.openitem[fd].size%DISKSIZE);
ilen2 = ilen1/DISKSIZE;
modlen = ilen1%DISKSIZE;
if(modlen>0)
ilen2 = ilen2+1; /*--还需要多少块磁盘块-*/

for(j=0;j<ilen2;j++)
{
for(i=ROOT_DISK_NO+1;i<DISK_NUM;i++)/*寻找空闲磁盘块*/
{
if(fat[i].em_disk=='0')
break;
}
if(i>=DISK_NUM) /*--如果磁盘块已经分配完了-*/
return(-1);
first = fdisk+i*DISKSIZE; /*--找到的那块空闲磁盘块的起始地址-*/
if(j==ilen2-1) /*--如果是最后要分配的一块-*/
{
for(k=0;k<len-(DISKSIZE-u_opentable.openitem[fd].size%DISKSIZE)-j*DISKSIZE;k++)
first[k] = buf[k];
}
else/*-如果不是要最后分配的一块--*/
{
for(k=0;k<DISKSIZE;k++)
first[k] =buf[k];
}

fat[item].item = i; /*--找到一块后将它的序号存放在上一块的指针中-*/
fat[i].em_disk = '1'; /*--置找到的磁盘快的空闲标志位为已分配-*/
fat[i].item = -1; /*--它的指针为 -1 (即没有下一块)-*/
}
/*--修改长度-*/
u_opentable.openitem[fd].size = u_opentable.openitem[fd].size+len;
cur_dir->directitem[temp].size = cur_dir->directitem[temp].size+len;
}
return 0;
}

int read(int fd, char *buf)
{
int len = u_opentable.openitem[fd].size;
char *first;
int i, j, item;
int ilen1, modlen;

item = u_opentable.openitem[fd].firstdisk;

ilen1 = len/DISKSIZE;
modlen = len%DISKSIZE;
if(modlen!=0)
ilen1 = ilen1+1; /*--计算文件所占磁盘的块数-*/

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

for(i=0;i<ilen1;i++)
{
if(i==ilen1-1) /*--如果在最后一个磁盘块-*/
{
for(j=0;j<len-i*DISKSIZE;j++)
buf[i*DISKSIZE+j] = first[j];
}
else /*--不在最后一块磁盘块-*/
{
for(j=0;j<len-i*DISKSIZE;j++)
buf[i*DISKSIZE+j] = first[j];
item = fat[item].item; /*-查找下一盘块-*/
first = fdisk+item*DISKSIZE;
}
}
return 0;
}

int del(char *name)
{
int i,cur_item,item,temp;

for(i=2;i<MSD+2;i++) /*--查找要删除文件是否在当前目录中-*/
{
if(!strcmp(cur_dir->directitem[i].name,name))
break;
}

G. linux文件系统程序

直接mkdir就行
标准C++绝对可以
必要的时候加上system的命令

H. Linux根文件系统基本包括哪些内容

通常情况下，Linux内核启动后期，会寻找并挂载根文件系缓毕统。根文件系统可以存在于磁盘上，也可以是存在于内存中的映扰唤芹像，其中包含了Linux系统正常运行所必须的库和程序等等，按照链誉一定的目录结构存放。Linux根文件系统基本包括如下内容：

基本的目录结构：/bin、/sbin、/dev、/etc、/lib、/var、/proc、/sys、/tmp等；整个根文件系统都是挂在根目录（/）下，FHS对顶层目录的要求和说明如下表所列。

基本程序运行所需的库文件，如glibc等；

基本的系统配置文件，如inittab、rc等；

必要的设备文件，如/dev/ttyS0、/dev/console等；

基本应用程序，如sh、ls、cd、mv等。

你可以去【周立功】那边了解一下的，蛮多信息的。

I. linux文件系统基础知识

linux文件系统基础知识汇总

1、linux文件系统分配策略

块分配( block allocation ) 和 扩展分配 ( extent allocation )

块分配：磁盘上的文件块根据需要分配给文件，避免了存储空间的浪费。但当文件扩充时，会造成文件中文件块的不连续，从而导致过多的磁盘寻道时间。

每一次文件扩展时，块分配算法就需要写入文件块的结构信息，也就是 meta-dada 。meta-data总是与文件一起写入存储设备，改变文件的操作要等到所有meta-data的操作都完成后才能进行，

因此，meta-data的操作会明显降低整个文件系统的性能。

扩展分配： 文件创建时，一次性分配一连串连续的块，当文件扩展时，也一次分配很多块。meta-data在文件创建时写入，当文件大小没有超过所有已分配文件块大小时，就不用写入meta-data，直到需要再分配文件块的时候。

扩展分配采用成组分配块的方式，减少了SCSI设备写数据的时间，在读取顺序文件时具有良好的性能，但随机读取文件时，就和块分配类似了。

文件块的组或块簇 ( block cluster) 的大小是在编译时确定的。簇的大小对文件系统的性能有很大的影响。

注： meta-data 元信息：和文件有关的信息，比如权限、所有者以及创建、访问或更改时间等。

2、文件的记录形式

linux文家系统使用索引节点(inode)来记录文件信息。索引节点是一种数据结构，它包含了一个文件的长度、创建及修改时间、权限、所属关系、磁盘中的位置等信息。

一个文件系统维护了一个索引节点的数组，每个文件或目录都与索引节点数组中的唯一的元素对应。每个索引节点在数组中的索引号，称为索引节点号。

linux文件系统将文件索引节点号和文件名同时保存在目录中，所以，目录只是将文件的名称和它的索引节点号结合在一起的一张表，目录中每一对文件名称和索引节点号称为一个连接。

对于一个文件来说，有一个索引节点号与之对应;而对于一个索引节点号，却可以对应多个文件名。

连接分为软连接和硬连接，其中软连接又叫符号连接。

硬连接： 原文件名和连接文件名都指向相同的物理地址。目录不能有硬连接;硬连接不能跨文件系统(不能跨越不同的分区)，文件在磁盘中只有一个拷贝。

由于删除文件要在同一个索引节点属于唯一的连接时才能成功，因此硬连接可以防止不必要的误删除。

软连接： 用 ln -s 命令建立文件的符号连接。符号连接是linux特殊文件的.一种，作为一个文件，它的数据是它所连接的文件的路径名。没有防止误删除的功能。

3、文件系统类型：

ext2 ： 早期linux中常用的文件系统

ext3 ： ext2的升级版，带日志功能

RAMFS ： 内存文件系统，速度很快

NFS ： 网络文件系统，由SUN发明，主要用于远程文件共享

MS-DOS ： MS-DOS文件系统

VFAT ： Windows 95/98 操作系统采用的文件系统

FAT ： Windows XP 操作系统采用的文件系统

NTFS ： Windows NT/XP 操作系统采用的文件系统

HPFS ： OS/2 操作系统采用的文件系统

PROC : 虚拟的进程文件系统

ISO9660 ： 大部分光盘所采用的文件系统

ufsSun : OS 所采用的文件系统

NCPFS ： Novell 服务器所采用的文件系统

SMBFS ： Samba 的共享文件系统

XFS ： 由SGI开发的先进的日志文件系统，支持超大容量文件

JFS ：IBM的AIX使用的日志文件系统

ReiserFS : 基于平衡树结构的文件系统

udf: 可擦写的数据光盘文件系统

4、虚拟文件系统VFS

linux支持的所有文件系统称为逻辑文件系统，而linux在传统的逻辑文件系统的基础上增加料一个蓄念文件系统( Vitual File System ,VFS) 的接口层。

虚拟文件系统(VFS) 位于文件系统的最上层，管理各种逻辑文件系统，并可以屏蔽各种逻辑文件系统之间的差异，提供统一文件和设备的访问接口。

5、文件的逻辑结构

文件的逻辑结构可分为两大类： 字节流式的无结构文件 和 记录式的有结构文件。

由字节流(字节序列)组成的文件是一种无结构文件或流式文件 ，不考虑文件内部的逻辑结构，只是简单地看作是一系列字节的序列，便于在文件的任意位置添加内容。

由记录组成的文件称为记录式文件 ，记录是这种文件类型的基本信息单位，记录式文件通用于信息管理。

6、文件类型

普通文件 ： 通常是流式文件

目录文件 ： 用于表示和管理系统中的全部文件

连接文件 ： 用于不同目录下文件的共享

设备文件 ： 包括块设备文件和字符设备文件，块设备文件表示磁盘文件、光盘等，字符设备文件按照字符操作终端、键盘等设备。

管道(FIFO)文件 : 提供进程建通信的一种方式

套接字(socket) 文件： 该文件类型与网络通信有关

7、文件结构： 包括索引节点和数据

索引节点 ： 又称 I 节点，在文件系统结构中，包含有关相应文件的信息的一个记录，这些信息包括文件权限、文件名、文件大小、存放位置、建立日期等。文件系统中所有文件的索引节点保存在索引节点表中。

数据 ： 文件的实际内容。可以是空的，也可以非常大，并且拥有自己的结构。

8、ext2文件系统

ext2文件系统的数据块大小一般为 1024B、2048B 或 4096B

ext2文件系统采用的索引节点(inode)：

索引节点采用了多重索引结构，主要体现在直接指针和3个间接指针。直接指针包含12个直接指针块，它们直接指向包含文件数据的数据块，紧接在后面的3个间接指针是为了适应文件的大小变化而设计的。

e.g： 假设数据块大小为1024B ，利用12个直接指针，可以保存最大为12KB的文件，当文件超过12KB时，则要利用单级间接指针，该指针指向的数据块保存有一组数据块指针，这些指针依次指向包含有实际数据的数据块，

假如每个指针占用4B，则每个单级指针数据块可保存 1024/4=256 个数据指针，因此利用直接指针和单级间接指针可保存 1024*12+1024*256=268 KB的文件。当文件超过268KB时，再利用二级间接指针，直到使用三级间接指针。

利用直接指针、单级间接指针、二级间接指针、三级间接指针可保存的最大文件大小为：

1024*12+1024*256+1024*256*256+1024*256*256*256=16843020 KB，约 16GB

若数据块大小为2048B，指针占4B，则最大文件大小为： 2048*12+2048*512+2048*512*512+2048*512*512*512=268,960,792 KB 约 268GB

若数据块大小为4096B，指针占4B，则最大文件大小为： 4096*12+4096*1024+4096*1024*1024+4096*1024*1024*1024=4,299,165,744 KB ，约 4TB

注： 命令 tune2fs -l /dev/sda5 可查看文件系统

ext2文件系统最大文件名长度： 255个字符

ext2文件系统的缺点：

ext2在写入文件内容的同时并没有同时写入文件meta-data， 其工作顺序是先写入文件的内容，然后等空闲时候才写入文件的meta-data。若发生意外，则文件系统就会处于不一致状态。

在重新启动系统的时候，linux会启动 fsk ( file system check) 的程序，扫描整个文件系统并试图修复，但不提供保证。

9、ext3文件系统：

ext3基于ext2的代码，所以磁盘格式与ext2相同，使用相同的元数据。

ext2文件系统无损转化为ext3文件系统： tune2fs -j /dev/sda6

日志块设备( Journaling block device layer,JBD)完成ext3文件系统日志功能。JBD不是ext3文件系统所特有的，它的设计目标是为了向一个块设备添加日志功能。

当一个文件修改执行时，ext3文件系统代码将通知JBD，称为一个事务(transaction)。发生意外时，日志功能具有的重放功能，能重新执行中断的事务。

日志中的3种数据模式：

1)、data=writeback ：不处理任何形式的日志数据，给用户整体上的最高性能

2)、data=odered ：只记录元数据日志，但将元数据和数据组成一个单元称为事务(transaction) 。此模式保持所句句的可靠性与文件系统的一致性，性能远低于data=writeback模式，但比data=journal模式快

3)、data=journal ：提供完整的数据及元数据日志，所有新数据首先被写入日志，然后才被定位。意外发生过后，日志可以被重放，将数据与元数据带回一致状态。这种模式整体性能最慢，但数据需要从磁盘读取和写入磁盘时却是3种模式中最快的。

ext3文件系统最大文件名长度： 255个字符

ext3文件系统的优点：可用性、数据完整性、速度、兼容性

10、ReiserFS文件系统

ReiserFS文件系统是由Hans Reiser和他领导的开发小组共同开发的，整个文件系统完全是从头设计的，是一个非常优秀的文件系统。也是最早用于Linux的日志文件系统之一。

ReiserFS的特点

先进的日志机制

ReiserFS有先进的日志(Journaling/logging)功能 机制。日志机制保证了在每个实际数据修改之前，相应的日志已经写入硬盘。文件与数据的安全性有了很大提高。

高效的磁盘空间利用

Reiserfs对一些小文件不分配inode。而是将这些文件打包，存放在同一个磁盘分块中。而其它文件系统则为每个小文件分别放置到一个磁盘分块中。

独特的搜寻方式

ReiserFS基于快速平衡树(balanced tree)搜索，平衡树在性能上非常卓越，这是一种非常高效的算法。ReiserFS搜索大量文件时，搜索速度要比ext2快得多。Reiserfs文件 系统使用B*Tree存储文件，而其它文件系统使用B+Tree树。B*Tree查询速度比B+Tree要快很多。Reiserfs在文件定位上速度非常 快。

在实际运用中，ReiserFS 在处理小于 4k 的文件时，比ext2 快 5 倍;带尾文件压缩功能(默认)的ReiserFS 比ext2文件系统多存储6%的数据。

支持海量磁盘

ReiserFS是一个非常优秀的文件系统，一直被用在高端UNIX系统上，可轻松管理上百G的文件系统，ReiserFS文件系统最大支持的文件系统尺寸为16TB。这非常适合企业级应用中。

优异的性能

由于它的高效存储和快速小文件I/O特点，使用ReiserFs文件系统的PC，在启动X窗口系统时，所花的时间要比在同一台机器上使用ext2文 件系统少1/3。另外，ReiserFS文件系统支持单个文件尺寸为4G的文件，这为大型数据库系统在linux上的应用提供了更好的选择。