一、磁盘
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的基础上进行了升级而已
前面说过,分区需要在磁盘的开头单独存放一部分数据。那么,这个数据是什么时候存放的呢?
就是格式化的时候。那么格式化又是什么时候进行的呢?
在下载操作系统时,操作系统会讲硬盘格式化,把用来管理硬盘的数据写入磁盘,而这种管理硬盘的数据我们叫作元数据,这时写入的就是元数据骨架
下面是几个格式化的时机:
-
磁盘划分分区之后、首次投入使用之前(必经阶段):全新硬盘写入分区表(MBR/GPT)后,扇区里全是一片混沌的无序字节,操作系统无法识别,必须格式化才能挂载使用。
-
安装操作系统时:系统安装向导会自动对选定的根分区进行格式化,写入该系统支持的文件系统结构。
-
数据彻底清空或重置系统时:需要快速清空盘内成千上万个文件时,格式化比递归删除文件要快得多。
-
更换文件系统类型时:例如想把一个原本是 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 是图书检索卡,数据块是书架上的具体书本,那么超级块就是整座图书馆的总体建筑图纸与资产登记总账。
一旦超级块损坏,整个分区就无法使用了。所以,每个块组内都会有一份超级块的备份。这样,如果文件系统的主超级块(整个分区第一个块组的超级块),在系统挂在时,会进行对主超级块的检验,如果发现超级块损坏,会直接中断挂载,并提示用户进行手动修复,修复方法如下:
查询该分区的所有备份超级块位置:
sudo mke2fs -n /dev/sda1(注:
-n参数表示仅模拟执行,绝对不真正格式化磁盘,它会打印出该分区当年格式化时规划的备份超级块编号,如 32768, 98304, 163840 等)使用指定备份块进行修复覆盖:
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 系统调用的实现),也能在父节点删除时递归清理下属节点
- 双向链表(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如果提示目标繁忙,说明有进程正在该目录中工作或打开了其中的文件:
检查谁在占用:
sudo fuser -mv /mnt/mydisk # 或 sudo lsof +D /mnt/mydisk退出对应的终端目录或结束相关进程后,再次尝试卸载。
若设备已强行拔出或卡死,可使用延迟卸载:
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 源文件 链接名 |
