Ext系列⽂件系统详解

一、磁盘

1.1 磁盘物理结构

磁盘的主要结构包括:盘片、主轴、磁头、磁头臂

在计算机运行的时候,盘片会在主轴的带动下高速旋转,当计算机想要在磁盘上读取或写入数据时,会把要找的数据的地址传给磁盘,之后磁头臂会带动磁头去磁盘的相应位置找到数据。磁头到达指定位置后,会通过磁力对盘片进行读取或写入信息

那么磁头如何找到指定位置呢?

我们需要先了解一下磁盘真正存储数据的部分的组成:

如上图所示,在一个机械硬盘中,往往有不止一个盘片,而是多个盘片垂直叠在一起,每个盘片有两面,而盘片之间都有磁头,分别读取磁盘某一面上的信息

而我们把一个盘面上的一个圆周叫作一个磁道,以一个磁道为底,沿主轴方向延伸的一个圆柱面叫作柱面,而我们把一个磁道分词角度相同的几块,分出的圆弧叫作扇区

1.2 磁盘寻址方法

对于CHS(Cylinder-Head-Sector)寻址方式的磁盘来说,即使外层的扇区更长,每个扇区能存储数据的大小是相同的,一般为512B或者4KB

而在我们寻找数据之前,可以先给磁盘的磁头、柱面、扇区编号,可以想到,这样编好号之后,我们就可以为硬盘中的每一个扇区确定唯一的编号了

等到要读取数据的时候,计算机给磁盘发送一个编号,也就是地址,磁盘可以直接根据地址找到对应的扇区,然后直接把整个扇区的数据读取下来,返回给计算机

具体来说,现代操作系统使用的寻址方式是一维线性数组寻址------LBA(Logical Block Addressing)。

我们先把视线放到一个磁道上,我们就可以把一个磁道上的每一个扇区看作是一个数组的一个元素,而整个磁道就是一个一维数组。

之后,把范围扩大到一个柱面,而一个柱面包含多个磁道,这不就是二维数组吗

最后,我们再次扩大范围到整个磁盘,一个磁盘又包含多个柱面,这是否能看成一个三维数组?

而用我们c语言学过的数组的知识,我们知道,其实多维数组本质上也还是一个一维数组,

所以,每一个扇区都是这整个数组上的一个元素,而这个数组的数组下标就是LBA地址了

这样,我们的操作系统就可以直接使用LBA地址来进行对磁盘的管理了

但是,硬盘使用的还是CHS地址,所以,我们需要进行CHS地址和LBA地址之间的转换:

我们可以从偏移量的角度对这个地址转换进行理解:

首先,我们在CHS寻址时,要先找到扇区所在的柱面,我们把要找的扇区在柱面上的位置作为偏移量,又因为柱面号和磁头号是从0开始的,所以,目标扇区的偏移量就是:扇区所在盘面的磁头号*每个磁道的扇区数+目标扇区在目标磁道上的偏移量

而扇区号是从1开始的,所以目标扇区在目标磁道上的偏移量就是: 扇区号-1

这样我们就得到了目标扇区在当前柱面上的偏移量,而我们再把这个结果加上当前柱面相对于0地址的偏移量,就得到了目标扇区在整个磁盘上的地址了

因为柱面号也是从0开始,所以当前柱面的偏移量就是:柱面号*单个柱面的扇区数

而单个柱面的扇区数=磁头数*每个磁道的扇区数

从而最终目标扇区的LBA地址就是:**柱面号*磁头数*每个磁道的扇区数+**扇区所在盘面的磁头号*每个磁道的扇区数+扇区号-1

而要从LBA地址转换成CHS地址,我们可以直接用取模和取余:
柱⾯号C = LBA // (磁头数*每磁道扇区数)【就是单个柱⾯的扇区总数】
磁头号H = (LBA % (磁头数*每磁道扇区数)) // 每磁道扇区数
扇区号S = (LBA % 每磁道扇区数) + 1

二、引入文件系统

2.1 "块"

硬盘是典型的"块"设备。操作系统读取硬盘数据的时候,不会一个块一个块地读取 ,这样效率太低了。操作系统会一次读取连续的多个扇区,即一个"块"

块的大小是操作系统对硬盘格式化的时候确定的,不能随时更改,一个块一般是4KB,即八个连续的扇区

结合前面LBA地址的知识,我们知道,每一个LBA地址对应的都是一个扇区,那么,我们直接用LBA地址/8,也就可以得到块号

2.2 分区

当我们买了新电脑,往往需要把电脑的磁盘分成多个:

这就是磁盘的分区

而Linux系统下,磁盘也是以文件的形式存在的,那要怎么分区呢?

从操作系统和硬件底层来看,"分区"并不是对物理介质做物理切割,而是一种纯粹的数据结构约定。

分区的物理本质,就是在磁盘保留的固定扇区中写入结构化的元数据,记录每个逻辑区域的起始 LBA(逻辑块地址)与扇区总数。操作系统内核在启动或探测设备时,读取并解析该数据结构,进而在内存中实例化出对应的子块设备(Sub-block Device)。

也就是说,操作系统会在磁盘开头部分保存对磁盘分区的信息,记录下来磁盘每一个分区的起始LBA和每个磁盘的扇区数量,这样,在访问指定分区的时候,就可以直接拿到目标分区的起始地址了

2.3 inode

我们知道,文件=数据+属性,在我们输入ls -l的时候,不止会显示出来文件的文件名,还有文件的其他信息

这些分别是:模式、硬链接数、文件所有者、所属组、大小、最后修改时间、文件名

我们也可以通过stat命令获取更多信息

既然文件数据都存储在块中,那文件属性存在哪呢?

就存在inode里。inode中文名是"索引节点",每个文件都有一个inode文件的所有信息

inode实际上就是一个结构体对象,我们可以看一下这个结构体的内容:

cpp 复制代码
/*
 * Structure of an inode on the disk
 */
struct ext2_inode
{
    __le16 i_mode;        /* File mode */
    __le16 i_uid;         /* Low 16 bits of Owner Uid */
    __le32 i_size;        /* Size in bytes */
    __le32 i_atime;       /* Access time */
    __le32 i_ctime;       /* Creation time */
    __le32 i_mtime;       /* Modification time */
    __le32 i_dtime;       /* Deletion Time */
    __le16 i_gid;         /* Low 16 bits of Group Id */
    __le16 i_links_count; /* Links count */
    __le32 i_blocks;      /* Blocks count */
    __le32 i_flags;       /* File 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]; /* Pointers to blocks */
    __le32 i_generation;           /* File version (for NFS) */
    __le32 i_file_acl;             /* File ACL */
    __le32 i_dir_acl;              /* Directory ACL */
    __le32 i_faddr;                /* Fragment address */
    union
    {
        struct
        {
            __u8 l_i_frag;  /* Fragment number */
            __u8 l_i_fsize; /* Fragment size */
            __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;  /* Fragment number */
            __u8 h_i_fsize; /* Fragment size */
            __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;  /* Fragment number */
            __u8 m_i_fsize; /* Fragment size */
            __u16 m_pad1;
            __u32 m_i_reserved2[2];
        } masix2;
    } osd2; /* OS dependent 2 */
};
/*
 * Constants relative to the data blocks
 */
#define EXT2_NDIR_BLOCKS 12
#define EXT2_IND_BLOCK EXT2_NDIR_BLOCKS
#define EXT2_DIND_BLOCK (EXT2_IND_BLOCK + 1)
#define EXT2_TIND_BLOCK (EXT2_DIND_BLOCK + 1)
#define EXT2_N_BLOCKS (EXT2_TIND_BLOCK + 1)

可以看到,这里面包含了许多的属性成员

注意看这一行:

__le32 i_blockEXT2_N_BLOCKS; /* Pointers to blocks */

这是一个文件数据块指针,指向文件的数据的位置,操作系统其实是通过inode来找到文件数据的

当然这里还有很多内容,我们放到下一小节讲

三、ext2 ⽂件系统

3.1 宏观认识

这里我们使用ext2系统为例,学习ext2系统已经完全够用了,ext3和ext4也都是在ext2的基础上进行了升级而已

前面说过,分区需要在磁盘的开头单独存放一部分数据。那么,这个数据是什么时候存放的呢?

就是格式化的时候。那么格式化又是什么时候进行的呢?

在下载操作系统时,操作系统会讲硬盘格式化,把用来管理硬盘的数据写入磁盘,而这种管理硬盘的数据我们叫作元数据,这时写入的就是元数据骨架

下面是几个格式化的时机:

  1. 磁盘划分分区之后、首次投入使用之前(必经阶段):全新硬盘写入分区表(MBR/GPT)后,扇区里全是一片混沌的无序字节,操作系统无法识别,必须格式化才能挂载使用。

  2. 安装操作系统时:系统安装向导会自动对选定的根分区进行格式化,写入该系统支持的文件系统结构。

  3. 数据彻底清空或重置系统时:需要快速清空盘内成千上万个文件时,格式化比递归删除文件要快得多。

  4. 更换文件系统类型时:例如想把一个原本是 NTFS 的移动硬盘改为 ext4 或 exFAT 时进行。

ext2文件系统会将一个分区再次分成多个大小相同的块组,如下图:

这里的block group就是一个个块组,每个block group都有着相同的结构

而上面的boot sector(引导扇区)存储了跳转指令、BPB、引导加载程序和结束魔数

下面是他们的具体作用:

  • 跳转指令(Jump Instruction,通常 3 字节): 例如 EB 58 90(JMP + NOP)。CPU 跳入该扇区执行时,第一条指令不是直接执行数据,而是直接"跳过"紧随其后的参数结构体,跳到后面的引导代码部分执行。

  • BPB(BIOS Parameter Block,BIOS 参数块): 这是极其关键的元数据,不是引导程序。它告诉引导代码和操作系统这个分区具体长什么样:

    • OEM 名称(如 MSDOS5.0 或 NTFS )

    • 每个扇区字节数(如 512B)

    • 每簇扇区数(Cluster Size,如 8 个扇区 = 4KB)

    • 保留扇区数(Reserved Sectors)

    • FAT 表个数与大小(FAT 文件系统)或 MFT(主文件表)的起始簇号(NTFS)

    • 分区总扇区数、隐藏扇区数

  • 引导加载程序(Boot Code): 利用前面的 BPB 参数解析文件系统,寻找并加载第二阶段引导器(如 bootmgr、ntldr)。引导程序就像"交接棒":主板通电后自己搞不定复杂系统,就靠它把操作系统内核从硬盘揪出来放进内存,并启动起来。

  • 结束魔数(0x55 0xAA,2 字节): 标记该扇区合法可引导。

3.2 块组内部构成

块组内部包含六个核心组件:超级块、块组描述符表、块位图、inode图、inode表、数据块

3.2.1 超级块

超级块存放文件系统本身的结构信息,描述整个分区的文件系统信息。

其中包含的关键信息有:

  • 文件系统中 Block 的总数与空闲数;

    • inode 的总数与空闲数;

    • 块大小(如 1KB、2KB、4KB);

    • 每个块组包含的块数(s_blocks_per_group)与 inode 数(s_inodes_per_group);

    • 文件系统挂载次数、最后挂载时间、校验标志等。

  • 分布规则 :早期的 ext2 会在每个 块组都完整备份一份 Superblock。现代 ext4 默认开启了 sparse_super(稀疏超级块)特性,Superblock 仅存在于 块组 0 以及编号为 3、5、7 的幂次方块组(如 Group 0, 1, 3, 5, 7, 9, 25...)中,其余普通块组直接省去此项,以节省空间。

超级块在每个块组的开头都有一份,并且一个文件系统中的每个超级块都相同

如果把文件系统比作一个大型图书馆,inode 是图书检索卡,数据块是书架上的具体书本,那么超级块就是整座图书馆的总体建筑图纸与资产登记总账。

一旦超级块损坏,整个分区就无法使用了。所以,每个块组内都会有一份超级块的备份。这样,如果文件系统的主超级块(整个分区第一个块组的超级块),在系统挂在时,会进行对主超级块的检验,如果发现超级块损坏,会直接中断挂载,并提示用户进行手动修复,修复方法如下:

  1. 查询该分区的所有备份超级块位置:

    复制代码
    sudo mke2fs -n /dev/sda1

    (注:-n 参数表示仅模拟执行,绝对不真正格式化磁盘,它会打印出该分区当年格式化时规划的备份超级块编号,如 32768, 98304, 163840 等)

  2. 使用指定备份块进行修复覆盖:

    复制代码
    sudo fsck.ext4 -b 32768 -y /dev/sda1

    fsck 会读取 32768 块处的干净备份,用它来重建和修复第 0 块组的主超级块,随后扫描全盘修复引用链。

下面是超级块在内核中的结构体对象:

复制代码
/*
 * Structure of the super block
 */
struct ext2_super_block
{
    __le32 s_inodes_count;      /* Inodes count */
    __le32 s_blocks_count;      /* Blocks count */
    __le32 s_r_blocks_count;    /* Reserved blocks count */
    __le32 s_free_blocks_count; /* Free blocks count */
    __le32 s_free_inodes_count; /* Free inodes count */
    __le32 s_first_data_block;  /* First Data Block */
    __le32 s_log_block_size;    /* Block size */
    __le32 s_log_frag_size;     /* Fragment size */
    __le32 s_blocks_per_group;  /* # Blocks per group */
    __le32 s_frags_per_group;   /* # Fragments per group */
    __le32 s_inodes_per_group;  /* # Inodes per group */
    __le32 s_mtime;             /* Mount time */
    __le32 s_wtime;             /* Write time */
    __le16 s_mnt_count;         /* Mount count */
    __le16 s_max_mnt_count;     /* Maximal mount count */
    __le16 s_magic;             /* Magic signature */
    __le16 s_state;             /* File system 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 */
    /*
     * These fields are for EXT2_DYNAMIC_REV superblocks only.
     *
     * Note: the difference between the compatible feature set and
     * the incompatible feature set is that if there is a bit set
     * in the incompatible feature set that the kernel doesn't
     * know about, it should refuse to mount the filesystem.
     *
     * e2fsck's requirements are more strict; if it doesn't know
     * about a feature in either the compatible or incompatible
     * feature set, it must abort and not try to meddle with
     * things it doesn't understand...
     */
    __le32 s_first_ino;              /* First non-reserved inode */
    __le16 s_inode_size;             /* size of inode structure */
    __le16 s_block_group_nr;         /* block group # of this superblock */
    __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-bit uuid for volume */
    char s_volume_name[16];          /* volume name */
    char s_last_mounted[64];         /* directory where last mounted */
    __le32 s_algorithm_usage_bitmap; /* For compression */
    /*
     * Performance hints. Directory preallocation should only
     * happen if the EXT2_COMPAT_PREALLOC flag is on.
     */
    __u8 s_prealloc_blocks;     /* Nr of blocks to try to preallocate*/
    __u8 s_prealloc_dir_blocks; /* Nr to preallocate for dirs */
    __u16 s_padding1;
    /*
     * Journaling support valid if EXT3_FEATURE_COMPAT_HAS_JOURNAL set.
     */
    __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 */
};

3.2.2 块组描述符表

块组描述符表(GDT)描述块组的属性信息,每个块组都有其自己的块组描述符,下面是结构:

复制代码
// 磁盘级blockgroup的数据结构
/*
 * Structure of a blocks group descriptor
 */
struct ext2_group_desc
{
    __le32 bg_block_bitmap;      /* Blocks bitmap block */
    __le32 bg_inode_bitmap;      /* Inodes bitmap */
    __le32 bg_inode_table;       /* Inodes table block*/
    __le16 bg_free_blocks_count; /* Free blocks count */
    __le16 bg_free_inodes_count; /* Free inodes count */
    __le16 bg_used_dirs_count;   /* Directories count */
    __le16 bg_pad;
    __le32 bg_reserved[3];
};

这里记录了块组各个结构的起始位置、块组空闲的inode和数据块还有多少等信息;

而块组描述符表会记录整个文件系统的块组描述符

块组描述符表和超级块一样,也会在每个块组里有一份备份,并且紧跟在超级块后面

值得注意的是,并没有块组描述符表这样一个单独的数据结构在系统中,GDT本质上是由多个ext2_group_desc构成的连续数组

3.2.3 块位图

占用空间 :固定占用 1 个块(例如 4KB)。

块位图(Block Bitmap)中记录着块组每个数据块的占用信息,在进行写入时,可以快速获得块组中哪个数据块被占用,哪个数据块没有被占用。

0 表示该块空闲可用,1 表示该块已被分配(存放元数据或文件数据)。

3.2.4 inode位图

占用空间 :固定占用 1 个块(例如 4KB)。

inode位图(Inode Bitmap)记录本块组分配的inode的使用状态。

0 表示空闲未分配,1 表示已绑定某个文件或目录。

当创建一个新文件时,内核扫描该位图找到第一个为 0 的 bit,置为 1 并将该编号分配给该文件。

3.2.5 inode表

占用空间:占用多个连续的物理块(通常为几百个块,格式化时确定)。

inode表(Inode Table)集中线性存放本块组所有的inode结构体,和前面的块组描述符表类似,并没有一个真正的结构体叫作inode_table,

3.2.6 数据块

数据块(DataBlocks)是真正存放文件数据内容的部分。但是,对于不同的文件,存储的数据也不同:

1.对于普通文件,存放文件的内容

2.对于目录文件,存放该目录下所有文件的文件名和其中的文件绑定的inode编号:

复制代码
struct ext2_dir_entry_2 {
    __le32  inode;     /* 对应的 inode 编号 (4 字节) */
    __le16  rec_len;   /* 本目录项占用的实际总字节数 (2 字节) */
    __u8    name_len;  /* 文件名实际长度 (1 字节) */
    __u8    file_type; /* 文件类型: 1=普通文件, 2=目录, 7=软链接等 (1 字节) */
    char    name[];    /* 文件名字符串 (变长数组,最大 255 字节,不以 \0 结尾) */
};

如果inode编号为0,表示这时一个已经被删除的但尚未被合并清理的空闲项

3.对于软链接文件,存放目标路径字符串

3.3 inode和datablock映射

我们再次回到inode.首先,我们再来看一下inode的结构:

cpp 复制代码
/*
 * Structure of an inode on the disk
 */
struct ext2_inode
{
    __le16 i_mode;        /* File mode */
    __le16 i_uid;         /* Low 16 bits of Owner Uid */
    __le32 i_size;        /* Size in bytes */
    __le32 i_atime;       /* Access time */
    __le32 i_ctime;       /* Creation time */
    __le32 i_mtime;       /* Modification time */
    __le32 i_dtime;       /* Deletion Time */
    __le16 i_gid;         /* Low 16 bits of Group Id */
    __le16 i_links_count; /* Links count */
    __le32 i_blocks;      /* Blocks count */
    __le32 i_flags;       /* File 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]; /* Pointers to blocks */
    __le32 i_generation;           /* File version (for NFS) */
    __le32 i_file_acl;             /* File ACL */
    __le32 i_dir_acl;              /* Directory ACL */
    __le32 i_faddr;                /* Fragment address */
    union
    {
        struct
        {
            __u8 l_i_frag;  /* Fragment number */
            __u8 l_i_fsize; /* Fragment size */
            __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;  /* Fragment number */
            __u8 h_i_fsize; /* Fragment size */
            __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;  /* Fragment number */
            __u8 m_i_fsize; /* Fragment size */
            __u16 m_pad1;
            __u32 m_i_reserved2[2];
        } masix2;
    } osd2; /* OS dependent 2 */
};
/*
 * Constants relative to the data blocks
 */
#define EXT2_NDIR_BLOCKS 12
#define EXT2_IND_BLOCK EXT2_NDIR_BLOCKS
#define EXT2_DIND_BLOCK (EXT2_IND_BLOCK + 1)
#define EXT2_TIND_BLOCK (EXT2_DIND_BLOCK + 1)
#define EXT2_N_BLOCKS (EXT2_TIND_BLOCK + 1)

看到这一行

__le32 i_blockEXT2_N_BLOCKS;/* Pointers to blocks */

这里就是用来进行inode和datablock映射的,当我们通过inode表找到了inode,就可以直接再通过inode找到对应的数据块了

那么inode中的这个成员是如何进行映射的呢?

ext2系统下,inode通过多级间接块指针映射,这里的多级一共有三级

说白了就是三层指针数组

对于第一层数组,前12个元素存放的是真实数据块的地址,这部分叫作直接块。

直接块可以映射到12*4kb=48kb的数据

而后三个位置每一项都存放了一个指针,分别是一级间接块索引表指针、二级间接块索引表指针、三级间接块索引表指针

一级间接块索引表指针指向的是一个索引块,这个索引块里面存放着1024个32位的块地址(就是一个有1024个元素的数组)。这样,当直接块大小不够用时,更多的指针存放在这里。这样就扩展出了1024*4kb=4MB大小的容量

而当一级间接块索引表指针也不够时,数据就会存到二级间接块索引表指针中,这个指针指向的是一个存放1024个索引块指针的顶级索引块,这个索引块中的每个指针都指向一个和一级索引块一样的索引块。这样,就又扩展出来了1024*1024*4kb=4GB大小的容量

而如果二级还是不够用,就有了三级间接块索引表指针。和上面的二级一样,这个就是再多了一层索引块。这样就又拓展了1024*1024*1024*4kb=4TB大小的容量

而当我们要用数据块号读取文件时,就需要进行数据块的偏移量计算了,步骤如下:

  • 算得逻辑块编号:L = P / 4096$。

  • 依据 L 的区间做出常数阶判断:

    • 0 <= L < 12:直接从 i_block[L] 取出物理块号。

    • 12 <= L < (12 + 1024):读 i_block[12] 的索引块,取其中第 (L - 12) 项。

    • (12 + 1024) <= L < (12 + 1024 + 1024^2):进入二级间接块寻址,进行两次除模运算逐级找块。

所以,前面我们提到的格式化操作,本质上就是对整个分区进行分组,在每个分组内写入SuperBlock、GDT、BlockBitmap等管理信息,进行整个分区管理信息的初始化

管辖"某个分区内部具体如何存文件"的管理信息,就是文件系统(元数据)

而当我们创建一个新文件时,会经历一下步骤:

1.存储属性

内核先找去inode位图中到一个空闲的(为0)inode节点置为1,把文件的属性信息记录到inode里面

2.在父目录中插入目录项

加载父目录的数据块,将文件的文件名和inode等信息写入目录项

3.存储数据

如果文件创建的同时写入了数据。计算该文件需要的数据块数量,找到对应数量的数据块,把缓冲区中要存储的数据拷贝到数据块中

在ext4中,执行写入操作时,通常不会立即去磁盘找数据块,而是将数据先写入内存的Page Cacher(页缓存),并把对应的页标为"脏页"。

只有在系统调用fsync()、内存紧张或者内核后台回写线程出发刷盘时,才会去扫描块位图,分配连续的物理数据块进行从内存向磁盘的写入,这样能将多次写入合并,减少磁盘碎片(就是让磁盘上存储的数据更连续,中间不要有间隔)

4.更新映射

在inode的映射表中写入数据块的映射情况

3.4 目录与文件名

前面我们知道,目录也是一种文件,不过其数据块存的是目录中所有文件的inode编号和文件名等信息。

所以,我们平时在Linux下访问文件一直都用文件名进行就可以解释了。

当我们进行文件的访问时,系统会对路径进行解析。从根目录开始,系统逐级向下进行文件名的查找,找到文件名对应的inode,通过inode找到下一级文件的位置。不断类似递归地(实现上是循环实现的)执行这个过程,最终就找到了目标文件了。

现在还有一个问题:每次访问一个文件都需要重新进行路径解析吗?如果我每次都访问同一个文件,那每次都要解析不是太浪费时间了?

对于这个问题,Linux系统也有解决方案:路径缓存

路径缓存机制主要由虚拟文件系统(VFS)的dentry缓存(Directory Entry Cache),简称dcache实现

核心数据结构dentry的内容如下:

复制代码
struct dentry {
    unsigned int        d_flags;
    struct qstr         d_name;        /* 当前节点的文件名(含快速哈希值) */
    struct inode        *d_inode;      /* 关联的具体 inode(NULL 表示负缓存) */
    struct dentry       *d_parent;     /* 指向父目录的 dentry 指针 */
    struct list_head    d_subdirs;     /* 子目录/子文件链表 */
    struct hlist_bl_node d_hash;       /* 挂入全局 dentry 哈希表的节点 */
    struct list_head    d_lru;         /* 挂入内存回收 LRU 链表的节点 */
    struct dentry_operations *d_op;
    ...
};

可以看到,这里的d_name记录的就是文件名,下面的*d_inode记录的就是对应文件的inode指针,这样,当我们访问文件时,系统会先去dcache中查找,如果已经有了重复的文件,那就直接拿到对应的inode进行访问;如果没有,那就进行路径解析,并把最后找到的文件放到dcache中

当然,这里记录的不单纯是文件名,而是一个结构体,结构体中存储了哈希值,以确保这是一个唯一的文件

并且,为了满足不同操作的需求,dentry会被同时放到三种数据结构中进行组织管理

1.全局哈希表(dentry_hashtable)

只要知道父目录是谁,并在当前目录下找某个名字(如在 user 目录下找 news.txt),通过该哈希表可以在常数时间 O(1) 判定该目录项是否已在内存中

而这个哈希表的哈希值主要根据父目录的 dentry 内存指针 和 当前分量的名字字符串来计算,确保了文件的唯一性

2.树状引用网(Trees of Dentries)

用于维护拓扑关系,每个 dentry 都持有指向父目录的 d_parent 指针,以及串联所有子项(该目录下所有下一级文件或子目录)的 d_subdirs 链表

保证了可以通过任一节点向上迅速回溯完整绝对路径(如 getcwd 系统调用的实现),也能在父节点删除时递归清理下属节点

  1. 双向链表(LRU 链表)

负责内存老化与回收。dcache不可能记录所有访问过的文件而不进行删除。

当进程关闭了文件,该文件的 dentry 引用计数可能降为 0(处于 unused 状态)

内核不会立刻销毁它,而是将其挂到系统的 LRU(Least Recently Used,最近最少使用)双向链表 中。

当内存紧张时,内核的内存回收机制会优先删除LRU表尾部长期未被访问的目录

并且,还有一个特殊机制------负缓存

程序运行时,可能会经常去探测一个不存在的文件,而如果这个文件一直不存在,进而dcache中也一直查找不到这个文件,这样每次探测这个文件就都要进行一遍完整的路径解析了

为了减少这种情况对运行效率的影响,就引入了负缓存这样一个机制:

当内核读取父目录数据块确认某个文件确实不存在 时,仍会分配一个 struct dentry 并插入全局哈希表,但其内部的指针明确设为:

dentry->d_inode = NULL;

这样,之后有进程再次尝试访问这个不存在的文件,内核查dcache发现dentry->d_inode = NULL,会直接向用户态返回-ENOENT(No such file or directory),这样就减少了对磁盘的I/O

3.5 挂载分区

3.5.1 概念

"挂载分区"(Mounting a Partition)在本质上就是将磁盘分区上的文件系统层级结构,嫁接到当前系统的根文件系统树(VFS 树)的某个具体目录节点上。

简单地说,就是把一块物理硬盘上的分区(不一定是空的)绑定到一个目录中,将挂载的目录变成一个新的硬盘,不过在这个目录中写入新的文件时,文件会存储到挂载的物理分区上

也可以看作是把对这个目录的操作重定向到了被挂载的分区上

并且,如果原目录不是空的,挂载后,原目录中的数据并不会消失,只是因为这个重定向导致我们访问不到了,删除挂载后,我们依然可以访问到原来的数据

下面是进行挂载的方法:

3.5.2 挂载方法

首先,我们可以输入下面的命令来确认一下分区的设备名称和文件系统:

lsblk -f

下面,创建一个用于挂载的目录,这个目录一般选在/mnt或者/media下,必须是一个已存在的空目录:

sudo mkdir -p /mnt/mydisk

下面,因为云服务器硬盘已经全部分配完毕,所以没法划出新的分区,我们需要使用 回环设备,用文件来模拟出一块独立分区:

创建一个 1GB 的空镜像文件(充当虚拟裸硬盘):

dd if=/dev/zero of=~/disk.img bs=1M count=1024

将这个镜像文件格式化为 ext4 文件系统:

mkfs.ext4 ~/disk.img

下面进行挂载命令

基础语法为 mount -t [类型] [设备分区] [挂载点]:

sudo mount ~/disk.img /mnt/mydisk

(通常内核能自动识别文件系统,-t ext4 可以省略为 sudo mount /dev/sdb1 /mnt/mydisk)

验证挂载与写入重定向:

查看挂载状态与文件系统

df -h /mnt/test_disk

在挂载目录下新建文件测试写入

sudo touch /mnt/test_disk/hello.txt

ls -l /mnt/test_disk

实验完成后安全卸载:

sudo umount /mnt/mydisk

验证卸载后目录是否变回空目录

ls -l /mnt/test_disk

删除测试镜像文件

rm ~/disk.img

但是,手动 mount 在系统重启后会失效。若要持久化,需将其写入 /etc/fstab

下面是永久挂载的方法:

1. 获取分区的 UUID

为避免盘符(如 /dev/sdb1)在重启后因插槽顺序改变而错乱,必须使用分区的全局唯一标识符 UUID:

复制代码
sudo blkid /dev/sdb1

记下输出中的 UUID="..." 和 TYPE="..."。

2. 编辑 /etc/fstab
复制代码
sudo nano /etc/fstab

在文件末尾追加一行,包含 6 个字段(以空格或 Tab 分隔):

复制代码
UUID=4f8a3c21-7b9e-4c12-8e34-123456789abc  /mnt/mydisk  ext4  defaults  0  2
  • 第 1 列:分区的 UUID。

  • 第 2 列:挂载点绝对路径。

  • 第 3 列:文件系统类型(ext4、xfs、vfat、ntfs 等)。

  • 第 4 列 :挂载选项(常规使用 defaults,含 rw, suid, dev, exec, auto, nouser, async)。

  • 第 5 列 :dump 备份标志,一般填 0(不备份)。

  • 第 6 列 :开机 fsck 检查顺序(根分区填 1,其它分区填 2,网络存储或无需检查填 0)。

3. 校验配置(关键步骤)

修改完 /etc/fstab 切勿直接重启,必须执行以下命令测试语法:

复制代码
sudo mount -a
  • 如果命令直接静默返回,说明配置无误,所有在 /etc/fstab 中声明但未挂载的分区已全部成功挂载。

  • 如果输出报错,需立即修正,否则会导致机器下次重启时进入紧急维护模式(Emergency Mode)。

四、 卸载分区(umount)

当不再使用或需要拔出设备前,必须卸载以触发内存缓存刷盘:

复制代码
sudo umount /mnt/mydisk
# 或者通过设备名卸载:sudo umount /dev/sdb1

常见报错处理:target is busy 如果提示目标繁忙,说明有进程正在该目录中工作或打开了其中的文件:

  1. 检查谁在占用:

    复制代码
    sudo fuser -mv /mnt/mydisk
    # 或
    sudo lsof +D /mnt/mydisk
  2. 退出对应的终端目录或结束相关进程后,再次尝试卸载。

  3. 若设备已强行拔出或卡死,可使用延迟卸载:

    复制代码
    sudo umount -l /mnt/mydisk

四、软硬链接

4.1 硬链接

我们在前面可以知道,操作系统真正用来找到磁盘上文件的是inode,并不是文件名

其实,我们可以把多个文件名对应于同一个inode:

touch abc

ln abc def //创建硬链接的方法

ls -li abc def

我们可以看到,abc和def的inode都是1048671,他们的链接状态完全相同,他们被称为指向文件的硬链接,这里权限后面的2就是当前文件链接的inode的硬连接数

因为硬链接本质上是记录目标文件的inode。所以,硬链接不能跨文件系统

并且,硬链接可以说大小为0

因为他没有分配新的inode和数据块,只是在父目录中写入了一条新的目录项,只占几十字节的大小

我们平时在目录中看到的.和..其实就是硬链接

可以看到,这里的.有3个链接,分别是父目录记录的test目录项,当前目录自身的.目录项和子目录中的..目录项

..有33个链接也同理
我们在删除⽂件时⼲了两件事情:
1.在⽬录中将对应的记录删除
2.将硬连接数-1,如果为0,则将对应的磁盘释放

4.2 软链接

硬链接是通过inode引用另一个文件,软链接则是通过名字引用另一个文件。

但是,软链接的文件的inode和被引用的文件不同,我们可以把软链接看作是目标文件的一个"快捷方式"

软链接本质上是一个独立的文件(所以可以跨文件系统),本质上是通过inode中记录目标文件的路径来去找到目标文件

并且,如果路径过长(>=60字节)那文件系统会为它分配一个数据块来存储路径,inode中会有一个指向这个数据块的指针。路径长度没有超过60时,就直接存在inode->i_block 数组内存区域

创建软链接的方法:

ln -s abc cba

4.3 软硬链接的对比

对比维度 硬链接 (Hard Link) 软链接 (Symbolic / Soft Link)
底层本质 目录项中的别名,与源文件共享同一个 Inode 独立特殊文件,拥有专属的新 Inode
内容存储 指向源文件现有的物理数据块(Block) 仅存储目标文件的路径字符串(短路径存 Inode,长路径占 Block)
Inode 编号 与源文件的 Inode 编号完全相同 拥有与源文件不同的独立 Inode 编号
链接数 (i_links_count) 创建后源文件的硬链接计数 +1 ;删除时 -1 不影响源文件的硬链接计数(计数保持不变)
文件大小展示 显示为源文件的实际大小 (读取共享 Inode 的 i_size) 严格等于目标路径字符串的字节数 (例如指向 abc 大小为 3)
源文件被删除的影响 完全不受影响,只要链接数 > 0 即可正常读取原数据 立即断链失效 (出现红字闪烁提示,读取报 No such file)
跨文件系统 / 跨分区 不支持(Inode 仅在当前物理分区内唯一,无法跨越) 完全支持(本质是通过 VFS 重新按路径寻址)
对目录创建 普通用户不允许(防止目录成环引发无限死循环) 允许(可以随时链接到任意目录)
创建命令 ln 源文件 链接名 ln -s 源文件 链接名
相关推荐
你住过的屋檐3 小时前
【SeaweedFS】Linux上搭建SeaweedFS文件存储服务完整教程
linux·运维·服务器
少司府4 小时前
嵌入式外设篇(三)GPIO·三:MCU系统结构、总线与统一编制
linux·python·stm32·单片机·嵌入式硬件·mcu·嵌入式软件
不积跬步无以至千里mmbb264 小时前
Rust三大核心:Trait Crate Mod详解
linux·rust
2401_868534786 小时前
天融信网络安全面试题
服务器·网络
无忧.芙桃19 小时前
Linux系统编程(四):用户与权限管理
linux·运维·服务器
最强小杰20 小时前
某 OpenAI 兼容网关上的 `kimi-k3.1-pro`:Cline、Zed 接入与 SSE 排错示例
java·服务器·网络·ai
戊本菌1 天前
进程(三)进程优先级:谁先上 CPU
linux·c语言·硬件架构
aningx1 天前
Arch 系用 greetd 实现开机自动进 Plasma Wayland,注销自动回桌面
linux
张小姐的猫1 天前
【基于 WebSocket 的多用户网页五子棋】—— 整合封装服务器模块设计实现2️⃣
服务器·websocket·网络协议