精华内容
下载资源
问答
  • 操作系统课设:Linux二级文件系统

    千次阅读 多人点赞 2020-09-21 14:44:07
    Linux系统设计一个简单的二级文件系统。要求做到以下几点: (1)可以实现下列几条命令 login 用户登录 dir 列文件目录 create 创建文件 delete 删除文件 open 打开文件 close 关闭文件 read 读文件 write ...

    模拟文件管理系统
    为Linux系统设计一个简单的二级文件系统。要求做到以下几点:
    (1)可以实现下列几条命令
    login 用户登录
    dir 列文件目录
    create 创建文件
    delete 删除文件
    open 打开文件
    close 关闭文件
    read 读文件
    write 写文件
    (2)列目录时要列出文件名、物理地址、保护码和文件长度;
    (3)源文件可以进行读写保护。
    提示:
    (1)首先应确定文件系统的数据结构:主目录、子目录及活动文件等。主目录和子目录都以文件的形式存放于磁盘,这样便于查找和修改。
    (2)用户创建的文件,可以编号存储于磁盘上。入file0,file1,file2…并以编号作为物理地址,在目录中进行登记。

    程序流程图:
    在这里插入图片描述
    完整代码:

    1.	#include<iostream>  
    2.	#include<stdio.h>  
    3.	#include<string.h>  
    4.	using namespace std;  
    5.	struct usr     //用户结构体  
    6.	{  
    7.	    char username[8],password[8];  
    8.	};  
    9.	struct fnode    //文件或目录结构  
    10.	{  
    11.	    char filename[10],content[1024],address[10],protect[10];  
    12.	    int isdir,isopen,leng;  
    13.	    fnode* parent,* child,* prev,* next;  
    14.	};  
    15.	usr users[4]={"user1","user1","user2","user2","user3","user3","user4","user4"};    //预先给定的4个用户(用户名,密码)  
    16.	char para[100];    //路径  
    17.	fnode* root,* recent;     //根目录;指向路径的当前目录  
    18.	int  m=0,n=0;    //目录(文件)物理地址里的数字(例如:file0、file1、dir0...)  
    19.	int login(char*username,char*password)       //登录  
    20.	{  
    21.	    for(int i=0;i<4;i++)  
    22.	        if(strcmp(username,users[i].username)==0&&strcmp(password,users[i].password)==0)  
    23.	            {  
    24.	                cout<<"登陆成功!请输入命令"<<endl;  
    25.	                return 1;  
    26.	            }  
    27.	    return 0;  
    28.	}  
    29.	fnode* initfile(char* filename,int isdir)      //初始化文件或目录结构  
    30.	{  
    31.	    fnode* t;  
    32.	    t=new fnode;  
    33.	    strcpy(t->filename,filename);  
    34.	    t->isdir=isdir;  
    35.	    t->isopen=0;  
    36.	    t->parent=t->child=t->prev=t->next=NULL;  
    37.	    t->leng=0;  
    38.	    return t;  
    39.	}  
    40.	void creatroot()    //建立根目录  
    41.	{  
    42.	    char filename[8]="/";     //定义根目录名为"/"  
    43.	    root=initfile(filename,1);  
    44.	    recent=root;     //当前指针指向根目录  
    45.	    strcpy(para,"/");     //初始路径即为根目录  
    46.	}  
    47.	int mkdir()     //建立目录  
    48.	{  
    49.	    fnode* t,* p;  
    50.	    char filename[8];  
    51.	    cin>>filename;  
    52.	    t=initfile(filename,1);  
    53.	    if(recent->child==NULL)    //找出空的位置建立目录  
    54.	        {  
    55.	            recent->child=t;  
    56.	            t->parent=recent;  
    57.	            sprintf(t->address,"%s%d","dir",m);  
    58.	            m++;  
    59.	            cout<<"目录创建成功!"<<endl;  
    60.	        }  
    61.	    else {  
    62.	            p=recent->child;  
    63.	            do{  
    64.	                    if(strcmp(p->filename,t->filename)==0&&p->isdir)    //目录名相同  
    65.	                        {  
    66.	                            cout<<"目录已存在"<<endl;  
    67.	                            return 1;  
    68.	                        }  
    69.	                    else  if(p->next)     //继续往右边查找  
    70.	                        p=p->next;  
    71.	                    else break;    //不存在相同目录名的目录,并且找到了空位置,跳出循环建立目录  
    72.	            }while(1);  
    73.	            p->next=t;  
    74.	            t->prev=p;  
    75.	            sprintf(t->address,"%s%d","dir",m);  
    76.	            m++;  
    77.	            cout<<"目录创建成功!"<<endl;  
    78.	    }  
    79.	}  
    80.	int create()     //建立文件(同mkdir()类似)  
    81.	{  
    82.	    int flag=0;    //检查文件保护码是否正确  
    83.	    fnode* t,* p;  
    84.	    char filename[8];  
    85.	    cin>>filename;  
    86.	    t=initfile(filename,0);  
    87.	    if(recent->child==NULL)     //查找空的位置  
    88.	        {  
    89.	            recent->child=t;  
    90.	            t->parent=recent;  
    91.	            sprintf(t->address,"%s%d","file",n);  
    92.	            n++;  
    93.	            while(!flag)     //设置文件保护码  
    94.	            {  
    95.	                cout<<"请设置4位文件保护码:";  
    96.	                cin>>t->protect;  
    97.	                if(strlen(t->protect)==4)     //文件保护码为4位就设置成功  
    98.	                    flag=1;  
    99.	                else cout<<"请重新设置"<<endl;  
    100.	            }  
    101.	            cout<<"文件创建成功!"<<endl;  
    102.	        }  
    103.	    else {  
    104.	            p=recent->child;  
    105.	            do{  
    106.	                    if(strcmp(p->filename,t->filename)==0&&!p->isdir)    //文件名相同  
    107.	                        {  
    108.	                            cout<<"文件已存在"<<endl;  
    109.	                            return 1;  
    110.	                        }  
    111.	                    else  if(p->next)   //继续往右查找  
    112.	                        p=p->next;  
    113.	                    else break;     //不存在相同文件名的文件,并且找到了空位置,跳出循环建立文件  
    114.	            }while(1);  
    115.	            p->next=t;  
    116.	            t->prev=p;  
    117.	            sprintf(t->address,"%s%d","file",n);  
    118.	            n++;  
    119.	            while(!flag)     //设置文件保护码  
    120.	            {  
    121.	                cout<<"请设置4位文件保护码:";  
    122.	                cin>>t->protect;  
    123.	                if(strlen(t->protect)==4)      //文件保护码为4位就设置成功  
    124.	                    flag=1;  
    125.	                else cout<<"请重新设置"<<endl;  
    126.	            }  
    127.	            cout<<"文件创建成功!"<<endl;  
    128.	    }  
    129.	}  
    130.	void dir()     //列出当前目录中的文件和目录  
    131.	{  
    132.	    int i=0,j=0;     //目录数;文件数  
    133.	    fnode* t;  
    134.	    if(recent->child==NULL)     //该目录下没有文件或目录  
    135.	        cout<<"Total:"<<"     directors     "<<i<<"     files     "<<j<<endl;  
    136.	    else {  
    137.	        t=recent->child;  
    138.	        do{  
    139.	            if(t->isdir)    //找到目录  
    140.	            {  
    141.	                printf("%s  %s\n",t->filename,t->address);  
    142.	                i++;  
    143.	            }  
    144.	            else{       //找到文件  
    145.	                printf("%s  %s  %s%5d\n",t->filename,t->address,t->protect,t->leng);  
    146.	                j++;  
    147.	            }  
    148.	            if(t->next)     //继续往右查找  
    149.	                t=t->next;  
    150.	            else break;    //该目录下已经没有文件或目录  
    151.	        }while(1);  
    152.	        cout<<"Total:"<<"     directors     "<<i<<"     files     "<<j<<endl;  
    153.	    }  
    154.	}  
    155.	int write()     //写入文件  
    156.	{  
    157.	    fnode* t;  
    158.	    char filename[8],cinpro[10];  
    159.	    cin>>filename;  
    160.	    if(recent->child==NULL)    //该目录下没有文件  
    161.	        {  
    162.	            cout<<"文件不存在"<<endl;  
    163.	            return 1;  
    164.	        }  
    165.	    else{  
    166.	        t=recent->child;  
    167.	        do{  
    168.	                if(strcmp(t->filename,filename)==0&&t->isdir==0)   //找到文件  
    169.	                    {  
    170.	                        cout<<"请输入4位文件保护码:";  
    171.	                        cin>>cinpro;  
    172.	                        if(strcmp(cinpro,t->protect)==0)     //文件保护码正确,写入文件内容  
    173.	                        {  
    174.	                            cout<<"请输入文件内容:"<<endl;  
    175.	                            cin>>t->content;  
    176.	                            t->leng=strlen(t->content);  
    177.	                            cout<<"写入成功!"<<endl;  
    178.	                            return 1;  
    179.	                        }  
    180.	                        else{  
    181.	                            cout<<"输入有误,无法进行写入操作"<<endl;  
    182.	                            return 1;  
    183.	                        }  
    184.	                    }  
    185.	                else if(t->next)  
    186.	                            t=t->next;  
    187.	                else {  
    188.	                            cout<<"文件不存在"<<endl;  
    189.	                            return 1;  
    190.	                    }  
    191.	        } while(1);     
    192.	    }  
    193.	}  
    194.	int read()    //读取文件(同write()类似)  
    195.	{  
    196.	    fnode* t;  
    197.	    char filename[8],cinpro[10];  
    198.	    cin>>filename;  
    199.	    if(recent->child==NULL)  
    200.	        {  
    201.	            cout<<"文件不存在"<<endl;  
    202.	            return 1;  
    203.	        }  
    204.	    else{  
    205.	        t=recent->child;  
    206.	        do{  
    207.	                if(strcmp(t->filename,filename)==0&&t->isdir==0)  
    208.	                    {  
    209.	                        cout<<"请输入4位文件保护码:";  
    210.	                        cin>>cinpro;  
    211.	                        if(strcmp(cinpro,t->protect)==0)  
    212.	                        {  
    213.	                            cout<<"文件内容:"<<endl;  
    214.	                            cout<<t->content<<endl;  
    215.	                            return 1;  
    216.	                        }  
    217.	                        else{  
    218.	                            cout<<"输入有误,无法进行读取操作"<<endl;  
    219.	                            return 1;  
    220.	                        }  
    221.	                    }  
    222.	                else if(t->next)  
    223.	                            t=t->next;  
    224.	                else {  
    225.	                            cout<<"文件不存在"<<endl;  
    226.	                            return 1;  
    227.	                    }  
    228.	        } while(1);     
    229.	    }  
    230.	}  
    231.	int cd()     //打开目录  
    232.	{  
    233.	    char topara[30];  
    234.	    cin>>topara;  
    235.	    if(strcmp(topara,"..")==0)      //返回上级目录  
    236.	    {  
    237.	        int i;  
    238.	        while(recent->prev)      //如果有prev指针,不断往左挪动  
    239.	            recent=recent->prev;  
    240.	        if(recent->parent)     //找到上级目录  
    241.	            recent=recent->parent;  
    242.	        i=strlen(para)-1;      //更新路径  
    243.	        while(para[i]!='/'&&i>=0)  
    244.	            i--;  
    245.	        if(i!=0)  
    246.	            para[i]='\0';      //去掉路径中的"/",并且置一位'\0'  
    247.	        else para[i+1]='\0';    //上级目录为根目录  
    248.	    }  
    249.	    else if(strcmp(topara,"/")==0)       //打开根目录  
    250.	    {  
    251.	        recent=root;  
    252.	        strcpy(para,"/");  
    253.	    }  
    254.	    else if(topara[0]=='/')      //打开路径以'/'开头,就从根目录开始查找路径  
    255.	    {  
    256.	        fnode* saver;  
    257.	        char savep[100];  
    258.	        int leng=strlen(topara),i=1;  
    259.	        saver =recent;     //保存当前指向的目录  
    260.	        strcpy(savep,para);     //保存当前路径  
    261.	        recent=root;  
    262.	        strcpy(para,"/");  
    263.	        while(i<leng)    //topara需要打开的路径头从开始查找  
    264.	            {  
    265.	                fnode* t;  
    266.	                int j=0;  
    267.	                char recentpara[8];     //查找的当前目录  
    268.	                if(topara[i]!='/')  
    269.	                {  
    270.	                    while(topara[i]!='/'&&i<leng)     //读取出当前目录  
    271.	                    {  
    272.	                        recentpara[j]=topara[i];  
    273.	                        i++,j++;  
    274.	                    }  
    275.	                    recentpara[j]='\0';  
    276.	                    if(recent->child==NULL)     //查找路径中的当前目录下没有目录  
    277.	                        {  
    278.	                            cout<<"路径错误"<<endl;  
    279.	                            recent=saver;      //还原当前目录  
    280.	                            stpcpy(para,savep);     //还原路径  
    281.	                            return 1;  
    282.	                        }  
    283.	                    else{      //继续查找  
    284.	                        t=recent->child;  
    285.	                        do{  
    286.	                            if(strcmp(t->filename,recentpara)==0&&t->isdir)    //找到需要打开的目录  
    287.	                                {  
    288.	                                    recent=t;  
    289.	                                    strcat(para,recentpara);      //更新路径  
    290.	                                    break;  
    291.	                               }  
    292.	                            else if(t->next)  
    293.	                                t=t->next;  
    294.	                            else {          //找不到目录  
    295.	                                cout<<"路径错误"<<endl;;  
    296.	                                recent=saver;  
    297.	                                stpcpy(para,savep);  
    298.	                                return 1;  
    299.	                            }  
    300.	                        }while(1);  
    301.	                    }  
    302.	                }  
    303.	                else{      //读取到需要打开的目录中的'/',更新路径  
    304.	                    strcat(para,"/");  
    305.	                    i++;    //继续读取下一位  
    306.	                }  
    307.	            }  
    308.	    }  
    309.	    else{      //需要打开的目录不以'/'开头(与上面类似)  
    310.	        int i=0,leng=strlen(topara),flag=0;  
    311.	        fnode* saver;  
    312.	        char savep[100];  
    313.	        saver=recent;  
    314.	        strcpy(savep,para);  
    315.	            while(i<leng)  
    316.	            {  
    317.	                int j=0;  
    318.	                char recentpara[8];  
    319.	                fnode* t;  
    320.	                if(topara[i]!='/')  
    321.	                {  
    322.	                    while(topara[i]!='/'&&i<leng)  
    323.	                    {  
    324.	                        recentpara[j]=topara[i];  
    325.	                        i++,j++;  
    326.	                    }  
    327.	                    recentpara[j]='\0';  
    328.	                    if(recent->child==NULL)  
    329.	                    {  
    330.	                        cout<<"路径错误"<<endl;  
    331.	                        recent=saver;  
    332.	                        stpcpy(para,savep);  
    333.	                        return 1;  
    334.	                    }  
    335.	                    else{  
    336.	                        t=recent->child;  
    337.	                        do{  
    338.	                            if(strcmp(t->filename,recentpara)==0&&t->isdir)  
    339.	                            {  
    340.	                                if(!flag&&recent!=root)  
    341.	                                    strcat(para,"/");  
    342.	                                flag++;  
    343.	                                recent=t;  
    344.	                                strcat(para,recentpara);  
    345.	                                break;  
    346.	                            }  
    347.	                            else if(t->next)  
    348.	                                t=t->next;  
    349.	                            else {  
    350.	                                cout<<"路径错误"<<endl;  
    351.	                                recent=saver;  
    352.	                                stpcpy(para,savep);  
    353.	                                return 1;  
    354.	                            }  
    355.	                        }while(1);  
    356.	                    }  
    357.	                }  
    358.	                else{  
    359.	                    strcat(para,"/");  
    360.	                    i++;  
    361.	                }  
    362.	            }  
    363.	    }  
    364.	}  
    365.	int del()    //删除文件或目录  
    366.	{  
    367.	    fnode* t;  
    368.	    char filename[8];  
    369.	    cin>>filename;  
    370.	    if(recent->child==NULL)  
    371.	        cout<<"文件或目录不存在"<<endl;  
    372.	    else {  
    373.	        t=recent->child;  
    374.	        do{  
    375.	            if(strcmp(t->filename,filename)==0)     //找到该文件或目录,分文件储存结构进行删除  
    376.	            {  
    377.	                if(t->parent)  
    378.	                {  
    379.	                    if(t->next)  
    380.	                        t->next->parent=t->parent;  
    381.	                    t->parent->child=t->next;  
    382.	                    delete t;  
    383.	                    cout<<"文件或目录删除成功"<<endl;  
    384.	                    return 1;  
    385.	                }  
    386.	                else {  
    387.	                    if(t->next)  
    388.	                        t->next->prev=t->prev;  
    389.	                    t->prev->next=t->next;  
    390.	                    delete t;  
    391.	                    cout<<"文件或目录删除成功"<<endl;  
    392.	                    return 1;  
    393.	                }  
    394.	            }  
    395.	            else if(t->next)  
    396.	                t=t->next;  
    397.	            else{  
    398.	                cout<<"文件或目录不存在"<<endl;  
    399.	                return 1;  
    400.	            }  
    401.	        }while(1);  
    402.	    }  
    403.	}  
    404.	int open()     //打开文件  
    405.	{  
    406.	    fnode* t;  
    407.	    char filename[8];  
    408.	    cin>>filename;  
    409.	    if(recent->child==NULL)  
    410.	        cout<<"文件不存在"<<endl;  
    411.	    else {  
    412.	        t=recent->child;  
    413.	        do{  
    414.	            if(strcmp(t->filename,filename)==0&&!t->isdir)  
    415.	                {  
    416.	                    t->isopen=1;     //文件打开标记  
    417.	                    cout<<"文件打开成功!"<<endl;  
    418.	                    return 1;  
    419.	                }  
    420.	            else if(t->next)  
    421.	                t=t->next;  
    422.	            else {  
    423.	                cout<<"文件不存在"<<endl;  
    424.	                return 1;  
    425.	            }  
    426.	        }while(1);  
    427.	    }  
    428.	}  
    429.	int close()     //关闭文件(与open()类似)  
    430.	{      
    431.	    fnode* t;  
    432.	    char filename[8];  
    433.	    cin>>filename;  
    434.	    if(recent->child==NULL)  
    435.	        cout<<"文件不存在"<<endl;  
    436.	    else {  
    437.	        t=recent->child;  
    438.	        do{  
    439.	            if(strcmp(t->filename,filename)==0&&!t->isdir)  
    440.	                {  
    441.	                    t->isopen=0;  
    442.	                    cout<<"文件关闭成功!"<<endl;  
    443.	                    return 1;  
    444.	                }  
    445.	            else if(t->next)  
    446.	                t=t->next;  
    447.	            else {  
    448.	                cout<<"文件不存在"<<endl;  
    449.	                return 1;  
    450.	            }  
    451.	        }while(1);  
    452.	    }  
    453.	}  
    454.	void help()    //命令浏览  
    455.	{  
    456.	    cout<<endl<<"                命令一览                "<<endl;  
    457.	    cout<<"     ---------------------------------    "<<endl;  
    458.	    cout<<"         mkdir  :  新建目录         "<<endl;  
    459.	    cout<<"         create :  新建文件         "<<endl;  
    460.	    cout<<"         write  :  写入文件         "<<endl;  
    461.	    cout<<"         read   :  读出文件         "<<endl;  
    462.	    cout<<"         cd     :  列文件目录         "<<endl;  
    463.	    cout<<"         open   :  打开文件         "<<endl;  
    464.	    cout<<"         close  :  打开文件         "<<endl;  
    465.	    cout<<"         del    :  删除文件或目录         "<<endl;  
    466.	    cout<<"         dir    :  列文件目录         "<<endl;  
    467.	    cout<<"         quit   :  退出系统         "<<endl<<endl;  
    468.	}  
    469.	int run()     //运行文件系统  
    470.	{  
    471.	    char command[10];  
    472.	    cout<<"Linux:"<<para<<">";     //显示路径  
    473.	    cin>>command;       //输入命令  
    474.	    if(strcmp(command,"help")==0)  
    475.	        help();  
    476.	    else if(strcmp(command,"mkdir")==0)  
    477.	            mkdir();  
    478.	    else if(strcmp(command,"create")==0)  
    479.	            create();  
    480.	    else if(strcmp(command,"dir")==0)  
    481.	            dir();  
    482.	    else if(strcmp(command,"write")==0)  
    483.	            write();  
    484.	    else if(strcmp(command,"read")==0)  
    485.	            read();  
    486.	    else if(strcmp(command,"cd")==0)  
    487.	            cd();  
    488.	    else if(strcmp(command,"del")==0)  
    489.	            del();  
    490.	    else if(strcmp(command,"open")==0)  
    491.	            open();  
    492.	    else if(strcmp(command,"close")==0)  
    493.	            close();  
    494.	    else if(strcmp(command,"quit")==0)  
    495.	            return 0;  
    496.	    else cout<<"请参考help提供的命令列表"<<endl;  
    497.	}  
    498.	int main()  
    499.	{  
    500.	    int flag;     //标记用户名密码是否正确  
    501.	    char username[8],password[8];  
    502.	    cout<<"              -----------------------------------------------             "<<endl;  
    503.	    cout<<"                           +++Linux文件系统+++                      "<<endl;  
    504.	    cout<<"                   账号:user1-user4   密码:user1-user4                   "<<endl;  
    505.	    cout<<"                                mkdir  目录名                                 "<<endl;  
    506.	    cout<<"                                create 文件名                                 "<<endl;  
    507.	    cout<<"                                write  文件名                                 "<<endl;  
    508.	    cout<<"                                read   文件名                                 "<<endl;  
    509.	    cout<<"                                cd     目录名                                 "<<endl;  
    510.	    cout<<"                                open   文件名                                 "<<endl;  
    511.	    cout<<"                                close  文件名                                 "<<endl;  
    512.	    cout<<"                                del    文件名或目录名                     "<<endl;  
    513.	    cout<<"                                dir                                 "<<endl;  
    514.	    cout<<"                                quit                                 "<<endl;  
    515.	    cout<<"                             输入help可获得帮助                             "<<endl;  
    516.	    cout<<"              -----------------------------------------------             "<<endl;  
    517.	    cout<<"请输入您的用户名:";  
    518.	    cin>>username;  
    519.	    cout<<"请输入您的密码:";  
    520.	    cin>>password;  
    521.	    flag=login(username,password);    //检验用户输入用户名密码是否正确  
    522.	    while(!flag)  
    523.	    {  
    524.	        cout<<"用户名或密码错误,请重新输入"<<endl;  
    525.	        cout<<"请输入您的用户名:";  
    526.	        cin>>username;  
    527.	       cout<<"请输入您的密码:";  
    528.	       cin>>password;  
    529.	       flag=login(username,password);  
    530.	    }  
    531.	    if(flag)      //登录成功就会建立一个根目录  
    532.	        creatroot();  
    533.	    while(flag)  
    534.	    {  
    535.	        if(!run())    //退出系统  
    536.	            break;  
    537.	    }  
    538.	} 
    
    

    运行结果:
    在这里插入图片描述
    在这里插入图片描述
    注:图二的右边蓝色字体“mkdir()”打错了,应该是“create()”。

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 怎么用linux设计二级文件系统

    千次阅读 2019-06-05 16:52:50
    怎么用linux设计二级文件系统 https://blog.csdn.net/uqapuqap/article/details/5515362

    怎么用linux设计二级文件系统

    https://blog.csdn.net/uqapuqap/article/details/5515362

    展开全文
  • LinuxLinux Ext2文件系统

    千次阅读 2018-08-02 20:21:47
    下面以Linux的Ext2为例介绍文件系统的组成。 Ext2采用了分立式目录结构,即一个文件的目录分为目录项和索引节点两个部分。   Ext2的索引节点 在一个实际分立式目录的文件系统中,索引节点(inode)主要需要两...

    下面以Linux的Ext2为例介绍文件系统的组成。

    Ext2采用了分立式目录结构,即一个文件的目录分为目录项和索引节点两个部分。

     

    Ext2的索引节点

    在一个实际分立式目录的文件系统中,索引节点(inode)主要需要两部分内容来支持:一是inode结构;二是对于节点的操作函数。

    Ext2的索引节点

    Ext2的每个文件(或目录)都有唯一的i节点ext2_inode,它保存了一个文件所有与存储有关的属性。

    Linux在文件include/linux/ext2_fs.h中定义的i节点结构ext2_inode如下:

    struct ext2_inode {
    	__le16	i_mode;		/* 文件模式 */
    	__le16	i_uid;		/* 文件拥有者uid的低16位 */
    	__le32	i_size;		/* 文件大小 */
    	__le32	i_atime;	/* 最后访问时间 */
    	__le32	i_ctime;	/* 创建时间 */
    	__le32	i_mtime;	/* 修改时间 */
    	__le32	i_dtime;	/* 删除时间 */
    	__le16	i_gid;		/* 块组id的低16位 */
    	__le16	i_links_count;	/* 链接计数,即文件别名的数目 */
    	__le32	i_blocks;	/* 文件占用的存储块数 */
    	__le32	i_flags;	/* 标志 */
    	union {
    		struct {
    			__le32  l_i_reserved1;
    		} linux1;
    		struct {
    			__le32  h_i_translator;
    		} hurd1;
    		struct {
    			__le32  m_i_reserved1;
    		} masix1;
    	} osd1;				/* OS dependent 1 */
    	__le32	i_block[EXT2_N_BLOCKS];/* 文件索引表 */
    	__le32	i_generation;	/* File version (for NFS) */
    	__le32	i_file_acl;	/* File ACL */
    	__le32	i_dir_acl;	/* Directory ACL */
    	__le32	i_faddr;	/* 碎片地址 */
    	union {
    		struct {
    			__u8	l_i_frag;	/* 碎片数目 */
    			__u8	l_i_fsize;	/* 碎片大小 */
    			__u16	i_pad1;
    			__le16	l_i_uid_high;	/* these 2 fields    */
    			__le16	l_i_gid_high;	/* were reserved2[0] */
    			__u32	l_i_reserved2;
    		} linux2;
    		struct {
    			__u8	h_i_frag;	/* 碎片数目 */
    			__u8	h_i_fsize;	/* 碎片大小 */
    			__le16	h_i_mode_high;
    			__le16	h_i_uid_high;
    			__le16	h_i_gid_high;
    			__le32	h_i_author;
    		} hurd2;
    		struct {
    			__u8	m_i_frag;	/* 碎片数目 */
    			__u8	m_i_fsize;	/* 碎片大小 */
    			__u16	m_pad1;
    			__u32	m_i_reserved2[2];
    		} masix2;
    	} osd2;				/* 与操作系统相关的数据 */
    };

    其中,最重要的成员i_mode和指针i_block[]。i_mode指定文件类型;而指针数组i_block[]则是文件索引表。

    i_block[]指针数组的示意图如下:

    i_block[]共有15项,其中前12项为直接指向文件数据块的指针,后3项分别为采用多级索引结构的“一次间接指针”、“二次间接指针”和“三次间接指针”。其作用与内存管理中的多级页表类似,便于大型文件的存储处理。

    也就是说:如果文件比较小,其数据块少于12个,其数据块索引就放在i_block[]的前12项中,如果文件比较大,超过12个数据块就需要分配间接块来保存数据块索引。

    Ext2的i节点操作函数

    为了对Ext2的i节点进行操作,系统还定义了Ext2文件i节点的操作函数集:

    struct inode_operations ext2_file_inode_operations = {
        .truncate = ext2_truncate,
    #ifdef CONFIG_EXT2_FS_XATTR
        .setxattr = generic_setxattr,
        .getxattr = generic_getxattr,
        .listxattr = ext2_listxattr,
        .removexattr = generic_removexattr,
    #endif
        .setattr = ext2_setattr,
        .permission = ext2_permission,
    };

    可以看到,这里操作集中没有熟悉的文件操作函数,这是因为这都是对磁盘文件的底层操作,文件还要再经一层乃至多层的封装才能变成我们所熟悉的函数。

     

    Ext2的目录文件及目录项

    Ext2的目录文件实质上是一个目录项列表,其中每一项都是一个ext2_dir_entry_2结构的数据。它所包含的主要信息:

    • 目录项中文件名所对应的文件i节点号;
    • 文件类型;
    • 文件名称。

    在文件include/linux/ext2_fs.h中定义的目录项结构ext2_dir_entry_2如下:

    struct ext2_dir_entry_2 {
    	__le32	inode;			/* 文件的i节点号 */
    	__le16	rec_len;		/* 目录项的长度 */
    	__u8	name_len;		/* 文件名的长度 */
    	__u8	file_type;        //文件类型
    	char	name[EXT2_NAME_LEN];	/* 文件名 */
    };

    结构中的域file_type描述文件类型。不同文件类型的取值用枚举定义如下:

    enum {
    	EXT2_FT_UNKNOWN,
    	EXT2_FT_REG_FILE,            //普通文件
    	EXT2_FT_DIR,                 //目录
    	EXT2_FT_CHRDEV,              //字符设备文件
    	EXT2_FT_BLKDEV,              //块设备文件
    	EXT2_FT_FIFO,                //管道文件
    	EXT2_FT_SOCK,                //Sock文件
    	EXT2_FT_SYMLINK,
    	EXT2_FT_MAX
    };

    按照通常的概念,目录文件应该是ext2_dir_entry_2类型的数组,但Ext2没有这样做。为了用户方便,结构ext2_dir_entry_2中的文件名是一个可以根据文件名的长度变化的数组,这种做法就使得各个目录项的长度并不相等,从而难以用数组来组成目录文件。所以Ext2的目录文件采用一个比较特殊的链表结构,如下图:

    在这种结构中,目录项是连续存放的,而目录项的连接则通过结构ext2_dir_entry_2中的域rec_len来实现的,即程序通过rec_len作为偏移量来查找下一个目录项。

    每个目录文件中的前两项为代表目录自身的“.”和代表其上一级目录(父目录)的“..”。

    每当用户需要打开一个文件需要打开一个文件时,首先要指定待打开文件的路径和名称,文件系统会根据路径和名称搜索对应的目录项;然后用该目录项中的i节点号找到该文件的i节点;最后通过访问i节点结构中的i_block[]数据块来访问文件。

    目录项、索引节点与文件数据块之间的关系如下所示:

     

    Ext2在磁盘上的存储结构

    Ext2文件系统把它所占用的磁盘空间分成若干个块组,如下所示:

    每个块组的内部结构如下图所示:

    每个块组中都有一个内容完全相同的块——超级块,这个块保存着Ext2整个文件系统的信息。在超级块的后面,依次排序有:用来描述本块组信息的块组描述符表、用来表示本组内存储块使用情况的存储块管理位图、用来记录本块组所有i节点被占用情况的i节点管理位图、本块组的i节点表以及用来存储各种文件的数据块五个部分。

    Ext2的超级块

    像一本书需要一个前言一样,文件系统也需要有个类似的说明部分,但它说明的是文件系统基本信息,目的是使文件系统的使用者(操作系统)可以了解文件系统的结构、类型等,这个说明部分叫做文件系统的超级块。不同的文件系统具有不同的超级块。系统管理员及系统可以利用超级块中的信息来对文件系统进行维护。

    照理说,每个文件系统只要有一个超级块就够了,但Ext2为了保险起见,在每一个块组中都配置了一个超级块。在正常情况下,Ext2只使用第一个块组(块组0)中的超级块,而其他块组中的超级块只是一个备份。

    在文件include/linux/ext2_fs.h中定义的超级块数据结构ext2_super_block如下:

    struct ext2_super_block {
    	__le32	s_inodes_count;		/* 文件系统中节点的总数 */
    	__le32	s_blocks_count;		/* 文件系统中块的总数 */
    	__le32	s_r_blocks_count;	/* 超级用户保留块的数目 */
    	__le32	s_free_blocks_count;	/* 空闲块的总数目 */
    	__le32	s_free_inodes_count;	/* 空闲索引节点总数 */
    	__le32	s_first_data_block;	/* 第一个数据块 */
    
    	__le32	s_log_block_size;	/* Block size */
    	__le32	s_log_frag_size;	/* Fragment size */
    
    	__le32	s_blocks_per_group;	/* 每个块组中的块数 */
    	__le32	s_frags_per_group;	/* 每组中的片数 */
    	__le32	s_inodes_per_group;	/* 每组中的节点数 */
    	__le32	s_mtime;		/* 文件系统的安装时间 */
    	__le32	s_wtime;		/* 对超级块写操作的左后时间 */
    	__le16	s_mnt_count;		/* 文件系统的安装计数 */
    	__le16	s_max_mnt_count;	/* 文件系统的最大安装数 */
    	__le16	s_magic;		/* 幻数 */
    	__le16	s_state;		/* 文件系统的状态 */
    	__le16	s_errors;		/* Behaviour when detecting errors */
    	__le16	s_minor_rev_level; 	/* minor revision level */
    	__le32	s_lastcheck;		/* time of last check */
    	__le32	s_checkinterval;	/* max. time between checks */
    	__le32	s_creator_os;		/* OS */
    	__le32	s_rev_level;		/* Revision level */
    	__le16	s_def_resuid;		/* Default uid for reserved blocks */
    	__le16	s_def_resgid;		/* Default gid for reserved blocks */
    	__le32	s_first_ino; 		/* First non-reserved inode */
    	__le16   s_inode_size; 		/* size of inode structure */
    
    	__le16	s_block_group_nr; 	/* 本超级块所在的块组号 */
    
    	__le32	s_feature_compat; 	/* compatible feature set */
    	__le32	s_feature_incompat; 	/* incompatible feature set */
    	__le32	s_feature_ro_compat; 	/* readonly-compatible feature set */
    
    	__u8	s_uuid[16];		/* 卷的128位uuid */
    	char	s_volume_name[16]; 	/* 卷名 */
    
    	char	s_last_mounted[64]; 	/* directory where last mounted */
    	__le32	s_algorithm_usage_bitmap; /* For compression */
    	__u8	s_prealloc_blocks;	/* Nr of blocks to try to preallocate*/
    	__u8	s_prealloc_dir_blocks;	/* Nr to preallocate for dirs */
    	__u16	s_padding1;
    	__u8	s_journal_uuid[16];	/* uuid of journal superblock */
    	__u32	s_journal_inum;		/* inode number of journal file */
    	__u32	s_journal_dev;		/* device number of journal file */
    	__u32	s_last_orphan;		/* start of list of inodes to delete */
    	__u32	s_hash_seed[4];		/* HTREE hash seed */
    	__u8	s_def_hash_version;	/* Default hash version to use */
    	__u8	s_reserved_char_pad;
    	__u16	s_reserved_word_pad;
    	__le32	s_default_mount_opts;
     	__le32	s_first_meta_bg; 	/* First metablock block group */
    	__u32	s_reserved[190];	/* Padding to the end of the block */
    };

    由上述定义中可知,Ext2中的超级块中主要具有如下一些内容:

    • 幻数。文件系统的一个标识,在安装文件系统时用于确认Ext2文件系统;
    • 文件系统的版本号;
    • 文件系统安装计数;
    • 超级块所在的块组号;
    • 数据块的大小;
    • 块组中数据块的数目;
    • 文件系统中空闲块的数目;
    • 文件系统中空闲索引节点的数目;
    • 文件系统中第一个索引节点的号码。

    在Ext2文件系统中,第一个索引节点时根目录的入口。

    块组描述符表

    Ext2的一个块组可以看做文件系统空间的一个分区,与超级块的用途类似,为了向使用者提供块组的相关组织信息,每个块组有一个块组描述符表,其中主要提供块组的位图存放位置和i节点位图存放位置等信息。

    Linux在文件include/linux/ext2_fs.h中定义的块组描述符表结构ext2_group_desc如下:

    struct ext2_group_desc
    {
    	__le32	bg_block_bitmap;		/* 指向块组的块位图的指针 */
    	__le32	bg_inode_bitmap;		/* 指向i节点位图的指针 */
    	__le32	bg_inode_table;		/* i节点表的首地址 */
    	__le16	bg_free_blocks_count;	/* 本组块空闲块的数目 */
    	__le16	bg_free_inodes_count;	/* 本组块空闲i节点的数目 */
    	__le16	bg_used_dirs_count;	/* 本组块分配给目录文件的i节点数目 */
    	__le16	bg_pad;
    	__le32	bg_reserved[3];
    };

    块组的块位图

    Ext2文件系统用位图来记录块组中数据块的使用情况。数据块位图中的每一位表示该块组中每一个块的使用情况,如果为1,则表示该对应块已经被分配占用;如果为0,则表示该位还未被分配,是空闲块。

    块组的i节点位图

    Ext2文件系统用位图来记录块组中i节点使用情况。i节点位图中的每一位表示该块组中每一个i节点的使用情况,如果为1,则表示该结点已被分配占用;如果为0,则表示结点还未被分配,是空闲节点。

    块组的i节点表

    顾名思义,i节点表就是存放文件i节点的表格。每个块组中所有i节点都按i节点号的顺序存储在i节点表中。i节点表通常需要占用若干个数据块。

     

    Ext2文件的用户操作函数集

    作为一个为用户服务的文件系统,Ext2位用户提供的文件操作函数集如下:

    const struct file_operations ext2_file_operations = {
    	.llseek		= generic_file_llseek,
    	.read		= do_sync_read,
    	.write		= do_sync_write,
    	.aio_read	= generic_file_aio_read,
    	.aio_write	= generic_file_aio_write,
    	.unlocked_ioctl = ext2_ioctl,
    #ifdef CONFIG_COMPAT
    	.compat_ioctl	= ext2_compat_ioctl,
    #endif
    	.mmap		= generic_file_mmap,
    	.open		= generic_file_open,
    	.release	= ext2_release_file,
    	.fsync		= ext2_sync_file,
    	.splice_read	= generic_file_splice_read,
    	.splice_write	= generic_file_splice_write,
    };

     

    展开全文
  • 操作系统作为磁盘文件系统和用户之间的中介,必须在内核中建立自己的文件系统,为与磁盘文件系统相区别,我们把它叫做操作系统的文件管理系统,简称文件管理系统。   文件管理系统与磁盘文件系统的关系 与处理器...

    操作系统作为磁盘文件系统和用户之间的中介,必须在内核中建立自己的文件系统,为与磁盘文件系统相区别,我们把它叫做操作系统的文件管理系统,简称文件管理系统。

     

    文件管理系统与磁盘文件系统的关系

    与处理器相比,磁盘是一种工作速度极其缓慢的外部设备,操作系统很难直接利用磁盘文件系统来对文件进行操作。因此,操作系统必须根据磁盘文件系统提供的各种基本信息在内存中建立必要的缓冲数据结构,一方面为了避免频繁地访问磁盘,另一方面也用来记录文件的一些动态信息。与此同时,还要建立一些操作系统自用的文件管理用表。

    文件管理系统中的管理用表及缓冲区主要有:

    • 文件注册表。包含文件系统在磁盘分区中信息的登记表;
    • 全局打开文件表。包含每个打开文件的文件控制块(FCB)的附件以及其他信息;
    • 进程打开文件表。该表为进程所有,它包含一些指针,这些指针指向全局打开文件表中本进程当前所使用的FCB;
    • 目录缓冲区。用来保存近期访问过的目录信息;
    • 索引节点缓冲区;
    • 文件缓冲区。用来保存当前或近期访问文件的内容。

    下图以打开文件和读取文件操作表示了文件管理系统和磁盘文件系统的关系:

    当用户进程使用系统调用open()打开一个文件时,该系统调用会向磁盘驱动器发出驱动命令,在磁盘的目录文件中按用户进程给出的文件名或者文件存储路径搜索该文件的目录节点;找到后将在内存创建一个该节点的数据结构,将磁盘中的目录节点的信息复制过来,并把该文件的i节点(FCB)存放在一个叫做全局打开文件表的表中。

    之所以这么做,是为了使进程可以直接用内存中的数据结构来访问该文件,而不必再去访问慢速的磁盘了。

    从上面的叙述中可知,操作系统的文件管理系统就是磁盘文件系统与用户进程之间的中介。

     

    文件缓冲区

    为提高访问文件的效率,稍微复杂一些的操作系统都在内存中创建了缓冲区。所谓缓冲,是指系统为当前和最近读写操作过的文件内容在内存中保留一份副本,以便再次需要访问这些内容时就不必费时费力地从磁盘中读入了。当需要写磁盘时,可以先写到副本中,待系统较为空闲时再将副本写入磁盘。

    除此之外,文件缓冲区还为多线程共享同一个文件建立了基础。

     

    文件系统的层次结构

    从存储位置来看,文件系统的层次结构如下所示:

    从组织层次来看,文件系统的层次结构如下所示:

    在这种层次结构中,每层都利用底层的功能实现更高级的抽象,甚至把文件变成用户便于理解的方式。

    设备驱动层是由设备驱动程序和中断处理程序组成,它处于文件系统的最底层,负责将上层的命令翻译成设备可以理解的底层命令,以驱动硬件设备的数据读写操作。

    基本文件系统的任务主要是向驱动层发送合适的驱动命令。该层通常与文件组织模块合并成为文件组织系统。

    文件组织模块知道文件及其逻辑块和物理块,知道文件存储块的分配方式和文件的位置,所以文件组织模块负责将上层的逻辑文件操作翻译成实际的驱动命令。另外,文件组织模块还要负责进行空闲块的管理与分配工作。

    逻辑文件系统处于最高层,用来接收应用程序的命令。逻辑文件系统负责管理系统用于文件管理的所有数据结构,向文件组织模块提供组织信息(例如添加、删除目录和节点),并通过文件控制块(FCB)来维护文件结构和文件的保护安全。

     

    虚拟文件系统

    目前,面对各式各样、各具特点的文件系统,能否以同一界面来使用不同的文件系统就成了衡量通用操作系统性能的标准之一,所以现代操作系统大多都是采用虚拟文件系统(Vitual Filesystem Switch,VFS)。

    所谓虚拟文件系统,就是一个本身并没有文件的系统,但它为其他不同的实际文件系统提供了统一的操作界面,也就是说,它相当于一个“书皮”。其设计思想是:既然所有实际文件系统都是用来管理文件的,那么它们总有一些共性,特别是在文件的操作方面,誓如,它们都有文件的打开、关闭、读、写等操作。这样,就可以利用这些共性来构建一个统一的文件系统框架,并用这个框架来容纳实际文件系统,以实现不同文件系统的统一管理。

    虚拟文件系统和实际文件系统的关系示意图如下:

    简单地说,设置虚拟文件系统的目的就是:统一不同的文件系统,并不让用户与实际文件系统直接见面。

     

    展开全文
  • 1、可以实现下列几条命令(至少4...Login 用户登录Dir 列文件目录Create 创建文件Delete 删除文件Open 打开文件Close 关闭文件Read 读文件Write 写文件2、列目录时要列出文件名、物理地址、保护码和文件长度。
  • 因为linux支持模块机制,所以我们可以将文件系统编译为模块,所以文件系统系统类型的注册的注册有多种方式:要么已经包含在内核映像中,要么作为一个模块被动态加载。我们关注的重点是rootfs和sysfs,他们其实在系统...
  • Linux文件系统详解

    千次阅读 2017-09-26 17:47:31
    一、Linux文件系统  在Linux中,所有的设备都是文件。文件的类型是根据文件头字段来判断,而非文件的后缀名。  用户配置文件:~/.bashrc ~/.bash_profile ~/.bash_logout ...Linux文件系统目录结构  linux
  • Linux文件系统目录结构详解

    万次阅读 2017-10-08 13:09:34
    对于每一个Linux学习者来说,了解Linux文件系统的目录结构,是学好Linux的至关重要的一步.,深入了解linux文件目录结构的标准和每个目录的详细功能,对于我们用好linux系统只管重要,下面我们就开始了解一下linux...
  • Linux磁盘与文件系统管理

    千次阅读 2016-06-26 22:26:51
    Linux最传统的磁盘文件系统使用的是EXT2。 磁盘分区与组成 整个磁盘的(物理)组成主要有: ² 圆形的盘片(主要记录数据的部分); ² 机械手臂与机械手臂上的磁头(可读写盘片上的数据); ² 主轴
  • Linux文件系统及文件储存方式

    千次阅读 2017-02-08 20:05:54
    闲来无事复习了下Linux文件系统的基本构成,做下记录。主要涉及的内容有: Ext文件系统的记录方式; Linux文件系统的访问方式; rm删除的原理以及恢复方案。
  • Linux 文件系统

    千次阅读 2011-12-09 15:38:07
    本章主要描叙Linux核心对文件系统的支持, 虚拟文件系统(VFS)以及Linux核心对实际文件系统的支持。 Linux的最重要特征之一就是支持多种文件系统。这样它更加灵活并可以和许多其它种操作系统共存。在本文写作时...
  • 3.1 Linux 支持的文件系统类型

    千次阅读 2018-06-20 17:09:11
    第3章Linux磁盘文件管理本章要点v Linux 支持的文件系统类型v Linux 系统的目录结构v Linux 常用命令 学习要求v 熟悉L inux 支持的文件系统类型v 了解ext2和ext3文件系统之间的异同v 熟悉Linux 系统的目录结构...
  • linux的常用文件系统格式

    千次阅读 2016-08-25 14:53:32
    文件系统指文件存在的物理空间。...Virtual File System(虚拟文件系统)使得Linux可以支持多个不同的文件系统。由于系统已将Linux文件系统的所有细节进行了转换,所以Linux核心的其它部分及系统中运行的程序将看到统一
  • 操作系统: 二级目录文件系统的实现(c/c++语言)

    万次阅读 多人点赞 2015-12-23 19:20:39
    操作系统的一个课程设计,实现一个二级目录文件系统。 用disk.txt模拟磁盘,使用Help查看支持的命令及其操作方式,root为超级用户(写在disk.txt中) 文件的逻辑结构:流式文件。 物理结构:链接文件。 物理空间管理...
  • 一、Linux文件系统 文件系统就是分区或磁盘上的所有文件的逻辑集合。 文件系统不仅包含着文件中的数据而且还有文件系统的结构,所有Linux 用户和程序看到的文件、目录、软连接及文件保护信息等都存储在其中。 不同...
  • Linux 内核】文件系统(概念篇)

    千次阅读 2015-11-01 12:04:46
    一、开篇Linux下的文件系统为树形结构,入口为/(根目录)树形结构下的文件目录,Linux发行版本之间的差别很少,差别主要表现在系统管理的特色工具以及软件包管理方式的不痛,目录结构基本上是一样的。Windows的文件...
  • linux文件系统linuxcache

    千次阅读 2015-12-15 16:00:06
    本章主要描叙Linux核心对文件系统的支持, 虚拟文件系统(VFS)以及Linux核心对实际文件系统的支持。 Linux的最重要特征之一就是支持多种文件系统。这样它更加灵活并可以和许多其它种操作系统共存。在本文写作时...
  • linux 文件系统详解

    千次阅读 2017-10-13 10:59:39
    鸟哥 Linux 磁盘与文件系统管理:http://linux.vbird.org/linux_basic/0230filesystem.php 一、硬盘物理结构及相关概念 硬盘内部视角实物图 硬盘内部视角逻辑图 扇区、磁道、柱面图
  • linux加密文件系统

    千次阅读 2016-01-19 17:33:24
    【导读】本文将详细介绍利用dm-crypt来创建加密文件系统的方法。与其它创建加密文件系统的方 ...Linux使用加密文件系统后,数据的安全能得到很好的保护。在这种情况下,即使把我们的机器送给黑客,只要他们没有密钥,黑
  • linux日志文件系统总结

    千次阅读 2013-09-19 16:13:31
    系统日志(本文参考了ibm网站的linux安全第卷)  在 Linux 下使用各种日志文件,有些用于某些特殊用途,例如:/var/log/xferlog 用于记录文件传输协议 FTP 的信息。其他日志文件,例如 /var/log/messages 文件通常...
  • LinuxLinux文件文件的存储

    万次阅读 2018-07-31 18:39:51
    文件的基本概念 文件就是一组按照某种格式组织的具有完整逻辑意义的信息。 从使用和创建文件的用户角度来看,文件是磁盘的...从操作系统的角度来看,文件是一个逻辑上连续的数据集合,它仅向系统提供文件管理所...
  • Linux操作系统基础

    万次阅读 多人点赞 2018-05-27 12:16:53
    Linux是一种自由和开放源码的操作系统,存在着许多不同的Linux版本,但它们都使用了Linux内核。Linux可安装在各种计算机硬件设备中,比如手机、平板电脑、路由器、台式计算机 Linux介绍 Linux出现于1991年,是...
  • Linux文件系统存储方式

    千次阅读 2014-12-10 10:34:52
    与此同时,Linux和Windows上的文件系统的原理又恰恰是不一样的。Windows中采用的是FAT 表的形式,但是今天我主要的讲的是更为经典的Linux本地文件系统上的存储原理,稍稍分析一下他的结构,作为抛砖引玉。 文件系统...
  • Linux File System(Linux文件系统

    千次阅读 2018-08-24 15:25:31
    Linux File System(Linux文件系统) 一、简介 因为Linux允许不同的厂商及个人修改其操作系统,所以常会造成目录名称不统一的情况,有鉴于此,目前有一套规范文件目录的命名及存放标准——Filesystem Hierarchy...
  • linux文件系统实现浅析

    千次阅读 2013-05-11 19:45:54
    之前有两篇文章整理过linux虚拟文件系统的结构,和linux文件读写的流程。其中一些由具体文件系统类型来实现的地方并没有深入叙述,只是说这是由具体的文件系统来实现的。比如,读写文件的时候,文件的读写位置怎么...
  • Linux环境下几种常用的文件系统

    万次阅读 2018-05-24 11:06:15
    Linux环境下几种常用的文件系统:1、ext2 ext2是为解决ext文件系统的缺陷而设计的可扩展的、高性能的文件系统,又被称为二级扩展文件系统。它是Linux文件系统中使用最多的类型,并且在速度和CPU利用率上较为突出。...
  • linux 文件系统结构

    千次阅读 2008-03-12 15:23:00
    文件系统 转自:http://man.chinaunix.net/tech/lyceum/linuxK/fs/filesystem.html 本章主要描叙Linux核心对文件系统的支持, 虚拟文件系统(VFS)以及Linux核心对实际文件系统的支持。 Linux的最重要特征之一...
  • 4.Linux磁盘与文件系统管理

    千次阅读 2018-09-24 14:37:50
    2.Linux的EXT2文件系统(inode) 3.日志文件系统(Journaling filesystem) 4.文件系统管理 5.磁盘分区: 6.格式化分区(磁盘格式化):  7.磁盘挂载与卸除(mount,umount) 7.1.挂载 :mount 7.2.卸除装置...
  • 解析Linux中的VFS文件系统

    千次阅读 2014-12-10 10:13:45
    Vfs文件系统详解 前言: 本文基于linux kernel 3.14.17来讨论VFS机制,以及内核对VFS的支持,试图从源代码的角度来理解,所以在阅读本文...VFS是Linux中的一个虚拟文件文件系统,也称为虚拟文件系统交换层(Virtual

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 319,717
精华内容 127,886
关键字:

linux二级文件系统

linux 订阅