Linux文件系统

明白硬件

磁盘、服务器、机柜、机房
 机械磁盘是计算机中唯一的一个机械装备
磁盘--- 外设，慢，容量大，代价便宜

 磁盘物理布局

• 扇区是从磁盘读出和写入信息的最小单位，通常巨细为 512 字节。
  
• 磁头（head）数：每个盘片一样平常有上下两面，分别对应1个磁头，共2个磁头
  
• 磁道（track）数：磁道是从盘片外圈往内圈编号0磁道，1磁道...，靠近主轴的同心圆用于停靠磁头，不存储数据
  
•  柱面（cylinder）数：磁道构成柱面，数目上等同于磁道个数
  
• 扇区（sector）数：每个磁道都被切分成很多扇形地区，每道的扇区数目相同
  
• 圆盘（platter）数：就是盘片的数目
  
• 磁盘容量=磁头数 × 磁道(柱面)数 × 每道扇区数 × 每扇区字节数 
  

磁盘的存储布局
 

扇区：是磁盘存储数据的基本单位，512字节，块装备

 怎样定位一个扇区呢？

• 可以先定位磁头（header）
  
• 确定磁头要访问哪一个柱面(磁道)（cylinder）
  
• 定位一个扇区(sector)
  
• CHS地点定位
  

柱面（cylinder），磁头（head），扇区（sector），显然可以定位数据了，这就是数据定位(寻址)方式之一，CHS寻址方式。
 磁盘的逻辑布局

 磁带上面可以存储数据，我们可以把磁带“拉直”，形成线性布局

 那么磁盘本质上虽然是硬质的，但是逻辑上我们可以把磁盘想象成为卷在一起的磁带，那么磁盘的逻辑存储布局我们也可以雷同于：

 这样每一个扇区，就有了⼀个线性地点(着实就是数组下标)，这种地点叫做LBA

以是，磁盘的真实情况是：
磁道：
某一盘面的某一个磁道展开：

即：一维数组

柱面：
整个磁盘所有盘面的同一个磁道，即柱面展开： 

柱面上的每个磁道，扇区个数是一样的 
整盘：

整个磁盘不就是多张二维的扇区数组表(三维数组？)
所有，寻址一个扇区：先找到哪一个柱面(Cylinder) ,在确定柱面内哪一个磁道(着实就是磁头位置，Head)，在确定扇区（Sector），以是就有了CHS。

以是，每一个扇区都有一个下标，我们叫做LBA(Logical Block Address)地点,着实就是线性地点。以是怎么计算得到这个LBA地点呢？

 LBA，1000，CHS 必须要！ LBA地点转成CHS地点，CHS怎样转换成为LBA地点。

OS只必要使用LBA就可以了！！LBA地点转成CHS地点，CHS怎样转换成为LBA地点。谁做啊？？磁盘自己来做！固件(硬件电路，伺服系统)
CHS && LBA地点 
CHS转成LBA：

• 磁头数*每磁道扇区数 = 单个柱面的扇区总数
  
• LBA = 柱面号C*单个柱面的扇区总数 + 磁头号H*每磁道扇区数 + 扇区号S - 1
  
• 即：LBA = 柱面号C*(磁头数*每磁道扇区数) + 磁头号H*每磁道扇区数 + 扇区号S - 1
  
• 扇区号通常是从1开始的，而在LBA中，地点是从0开始的
  
• 柱面和磁道都是从0开始编号的
  
• 总柱面，磁道个数，扇区总数等信息，在磁盘内部会自动维护，上层开机的时候，会获取到这些参数。
  

LBA转成CHS：

• 柱⾯号C = LBA // (磁头数*每磁道扇区数)【就是单个柱面的扇区总数】
  
• 磁头号H = (LBA % (磁头数*每磁道扇区数)) // 每磁道扇区数
  
• 扇区号S = (LBA % 每磁道扇区数) + 1
  
• "//": 表示除取整
  

以是：从此今后，在磁盘使用者看来，根本就不关心CHS地点，而是直接使用LBA地点，磁盘内部自己转换。以是：
从现在开始，磁盘就是一个 元素为扇区 的一维数组，数组的下标就是每一个扇区的LBA地点。OS使用磁盘，就可以用一个数字访问磁盘扇区了。
引入文件系统

引入"块"概念
着实硬盘是典型的“块”装备，操作系统读取硬盘数据的时候，着实是不会一个个扇区地读取，这样
服从太低，而是一次性连续读取多个扇区，即一次性读取一个”块”（block）。
硬盘的每个分区是被划分为一个个的”块”。一个”块”的巨细是由格式化的时候确定的，而且不可
以更改，最常见的是4KB，即连续八个扇区组成一个 ”块”。”块”是文件存取的最小单位

• 磁盘就是一个三维数组，我们把它对待成为一个"一维数组"，数组下标就是LBA，每个元素都是扇区
  
• 每个扇区都有LBA，那么8个扇区一个块，每一个块的地点我们也能算出来。
  
• 知道LBA：块号 = LBA/8
  
• 知道块号：LAB=块号*8 + n. (n是块内第几个扇区)
  

 引入"分区"概念
着实磁盘是可以被分成多个分区（partition）的，以Windows观点来看，你大概会有一块磁盘而且将它分区成C,D,E盘。谁人C,D,E就是分区。分区从实质上说就是对硬盘的⼀种格式化。但是Linux的装备都是以⽂件形式存在，那是怎么分区的呢？
柱面是分区的最小单位，我们可以利用参考柱面号码的方式来进行分区，其本质就是设置每个区的起始柱面和竣事柱面号码。 此时我们可以将硬盘上的柱面（分区）进行平铺，将其想象成一个大的平面，如下图所示：

柱面巨细划一，扇区个位划一，那么着实只要知道每个分区的起始和竣事柱面号，知道每
一个柱面多少个扇区，那么该分区多大，着实和解释LBA是多少也就清晰了. 

引入"inode"概念 
之前我们说过 文件=数据+属性 ，我们使用 ls -l 的时候看到的除了看到文件名，还能看到文件元
数据（属性）。

每行包罗7列：

• 模式
  
• 硬链接数
  
• 文件所有者
  
• 组
  
• 巨细
  
• 末了修改时间
  
• 文件名
  

ls -l读取存储在磁盘上的文件信息，然后表现出来 

实这个信息除了通过这种方式来读取，还有一个stat下令能够看到更多信息 

 到这我们要思索一个问题，文件数据都储存在”块”中，那么很显然，我们还必须找到一个地方储存
文件的元信息（属性信息），好比文件的创建者、文件的创建日期、文件的巨细等等。这种储存文件元信息的地区就叫做inode，中文译名为”索引节点”。

 每一个文件都有对应的inode，里面包罗了与该文件有关的一些信息。为了能解释清晰inode，我们必要是深入相识⼀下文件系统。
注意：

• Linux下文件的存储是属性和内容分离存储的
  
• Linux下，生存文件属性的集合叫做inode，一个文件，一个inode，inode内有一个唯一
  
• 的标识符，叫做inode号
  

以是一个文件的属性inode长什么样子呢？

1. /*
2. * Structure of an inode on the disk
3. */
4. struct ext2_inode {
5. __le16 i_mode;
6. /* File mode */
7. __le16 i_uid;
8. /* Low 16 bits of Owner Uid */
9. __le32 i_size;
10. /* Size in bytes */
11. __le32 i_atime;
12. /* Access time */
13. __le32 i_ctime;
14. /* Creation time */
15. __le32 i_mtime;
16. /* Modification time */
17. __le32 i_dtime;
18. /* Deletion Time */
19. __le16 i_gid;
20. /* Low 16 bits of Group Id */
21. __le16 i_links_count; /* Links count */
22. __le32 i_blocks;
23. /* Blocks count */
24. __le32 i_flags;
25. /* File flags */
26. union {
27. struct {
28. __le32 l_i_reserved1;
29. } linux1;
30. struct {
31. __le32 h_i_translator;
32. } hurd1;
33. struct {
34. __le32 m_i_reserved1;
35. } masix1;
36. } osd1;
37. /* OS dependent 1 */
38. __le32 i_block[EXT2_N_BLOCKS];/* Pointers to blocks */
39. __le32 i_generation;
40. /* File version (for NFS) */
41. __le32 i_file_acl; /* File ACL */
42. __le32 i_dir_acl; /* Directory ACL */
43. __le32 i_faddr;
44. /* Fragment address */
45. union {
46. struct {
47. __u8
48. l_i_frag;
49. /* Fragment number */
50. __u8
51. l_i_fsize; /* Fragment size */
52. __u16
53. i_pad1;
54. __le16 l_i_uid_high;
55. /* these 2 fields
56. */
57. __le16 l_i_gid_high;
58. /* were reserved2[0] */
59. __u32
60. l_i_reserved2;
61. } linux2;
62. struct {
63. __u8
64. h_i_frag;
65. /* Fragment number */
66. __u8
67. h_i_fsize; /* Fragment size */
68. __le16 h_i_mode_high;
69. __le16 h_i_uid_high;
70. __le16 h_i_gid_high;
71. __le32 h_i_author;
72. } hurd2;
73. struct {
74. __u8
75. m_i_frag;
76. /* Fragment number */
77. __u8
78. m_i_fsize; /* Fragment size */
79. __u16
80. m_pad1;
81. __u32
82. m_i_reserved2[2];
83. } masix2;
84. } osd2;
85. /* OS dependent 2 */
86. };
87. /*
88. * Constants relative to the data blocks
89. */
90. #define EXT2_NDIR_BLOCKS
91. 12
92. #define EXT2_IND_BLOCK
93. EXT2_NDIR_BLOCKS
94. #define EXT2_DIND_BLOCK
95. (EXT2_IND_BLOCK + 1)
96. #define EXT2_TIND_BLOCK
97. (EXT2_DIND_BLOCK + 1)
98. #define EXT2_N_BLOCKS
99. (EXT2_TIND_BLOCK + 1)
100. 备注：EXT2_N_BLOCKS = 15

复制代码

文件名属性并未纳入到inode数据布局内部

• inode的巨细一样平常是128字节大概256，我们后面统一128字节
  
• 任何文件的内容巨细可以不同，但是属性巨细肯定是相同的
  

ext2 文件系统

所有的准备工作都已经做完，是时候熟悉下文件系统了。我们想要在硬盘上储文件，必须先把硬盘格式化为某种格式的文件系统，才能存储文件。文件系统的目标就是组织和管理硬盘中的文件。在
Linux 系统中，最常见的是 ext2 系列的文件系统。其早期版本为 ext2，厥后又发展出 ext3 和 ext4。
ext3 和 ext4 虽然对 ext2 进行了增强，但是其核心操持并没有发生变革，我们还是以较老的 ext2 作为演示对象。
ext2文件系统将整个分区划分成若干个同样巨细的块组 (Block Group)，如下图所示。只要能管理一个分区就能管理所有分区，也就能管理所有磁盘文件。

 上图中启动块（Boot Block/Sector）的巨细是确定的，为1KB，由PC标准规定，用来存储磁盘分区信息和启动信息，任何文件系统都不能修改启动块。启动块之后才是ext2文件系统的开始。
Block Group
ext2文件系统会根据分区的巨细划分为数个Block Group。而每个Block Group都有着相同的布局组
成。
Super Block（超级块）
存放文件系统本身的布局信息，形貌整个分区的文件系统信息。记录的信息主要有：bolck 和 inode的总量，未使用的block和inode的数目，一个block和inode的巨细，近来一次挂载的时间，近来一次写入数据的时间，近来一次检验磁盘的时间等其他文件系统的相关信息。Super Block的信息被破坏，可以说整个文件系统布局就被破坏了
超级块在每个块组的开头都有一份拷贝（第一个块组必须有，后面的块组可以没有）。 为了保证文件系统在磁盘部门扇区出现物理问题的情况下还能正常工作，就必须保证文件系统的super block信息在这种情况下也能正常访问。以是一个文件系统的super block会在多个block group中进行备份，这些super block地区的数据保持划一。

1. /*
2. * Structure of the super block
3. */
4. struct ext2_super_block {
5. __le32 s_inodes_count;
6. /* Inodes count */
7. __le32 s_blocks_count;
8. /* Blocks count */
9. __le32 s_r_blocks_count;
10. /* Reserved blocks count */
11. __le32 s_free_blocks_count;
12. /* Free blocks count */
13. __le32 s_free_inodes_count;
14. /* Free inodes count */
15. __le32 s_first_data_block; /* First Data Block */
16. __le32 s_log_block_size;
17. /* Block size */
18. __le32 s_log_frag_size;
19. /* Fragment size */
20. __le32 s_blocks_per_group; /* # Blocks per group */
21. __le32 s_frags_per_group; /* # Fragments per group */
22. __le32 s_inodes_per_group; /* # Inodes per group */
23. __le32 s_mtime;
24. /* Mount time */
25. __le32 s_wtime;
26. /* Write time */
27. __le16 s_mnt_count;
28. /* Mount count */
29. __le16 s_max_mnt_count;
30. /* Maximal mount count */
31. __le16 s_magic;
32. /* Magic signature */
33. __le16 s_state;
34. /* File system state */
35. __le16 s_errors;
36. /* Behaviour when detecting errors */
37. __le16 s_minor_rev_level; /* minor revision level */
38. __le32 s_lastcheck;
39. /* time of last check */
40. __le32 s_checkinterval;
41. /* max. time between checks */
42. __le32 s_creator_os;
43. /* OS */
44. __le32 s_rev_level;
45. /* Revision level */
46. __le16 s_def_resuid;
47. /* Default uid for reserved blocks */
48. __le16 s_def_resgid;
49. /* Default gid for reserved blocks */
50. /*
51. * These fields are for EXT2_DYNAMIC_REV superblocks only.
52. *
53. * Note: the difference between the compatible feature set and
54. * the incompatible feature set is that if there is a bit set
55. * in the incompatible feature set that the kernel doesn't
56. * know about, it should refuse to mount the filesystem.
57. *
58. * e2fsck's requirements are more strict; if it doesn't know
59. * about a feature in either the compatible or incompatible
60. * feature set, it must abort and not try to meddle with
61. * things it doesn't understand...
62. */
63. __le32 s_first_ino;
64. /* First non-reserved inode */
65. __le16
66. s_inode_size;
67. /* size of inode structure */
68. __le16 s_block_group_nr;
69. /* block group # of this superblock */
70. __le32 s_feature_compat;
71. /* compatible feature set */
72. __le32 s_feature_incompat;
73. /* incompatible feature set */
74. __le32 s_feature_ro_compat;
75. /* readonly-compatible feature set */
76. __u8
77. s_uuid[16];
78. /* 128-bit uuid for volume */
79. char
80. s_volume_name[16]; /* volume name */
81. char
82. s_last_mounted[64];
83. /* directory where last mounted */
84. __le32 s_algorithm_usage_bitmap; /* For compression */
85. /*
86. * Performance hints. Directory preallocation should only
87. * happen if the EXT2_COMPAT_PREALLOC flag is on.
88. */
89. __u8
90. s_prealloc_blocks; /* Nr of blocks to try to preallocate*/
91. __u8
92. s_prealloc_dir_blocks; /* Nr to preallocate for dirs */
93. __u16
94. s_padding1;
95. /*
96. * Journaling support valid if EXT3_FEATURE_COMPAT_HAS_JOURNAL set.
97. */
98. __u8
99. s_journal_uuid[16]; /* uuid of journal superblock */
100. __u32
101. s_journal_inum;
102. /* inode number of journal file */
103. __u32
104. s_journal_dev;
105. /* device number of journal file */
106. __u32
107. s_last_orphan;
108. /* start of list of inodes to delete */
109. __u32
110. s_hash_seed[4];
111. /* HTREE hash seed */
112. __u8
113. s_def_hash_version; /* Default hash version to use */
114. __u8
115. s_reserved_char_pad;
116. __u16
117. s_reserved_word_pad;
118. __le32 s_default_mount_opts;
119. __le32 s_first_meta_bg;
120. /* First metablock block group */
121. __u32
122. s_reserved[190];
123. /* Padding to the end of the block */
124. };

复制代码

GDT（Group Descriptor Table）
块组形貌符表，形貌块组属性信息，整个分区分成多个块组就对应有多少个块组形貌符。每个块组形貌符存储一个块组 的形貌信息，如在这个块组中从那里开始是inode Table，从那里开始是Data
Blocks，空闲的inode和数据块还有多少个等等。块组形貌符在每个块组的开头都有一份拷贝。

1. // 磁盘级blockgroup的数据结构
2. /*
3. * Structure of a blocks group descriptor
4. */
5. struct ext2_group_desc
6. {
7. __le32 bg_block_bitmap;
8. /* Blocks bitmap block */
9. __le32 bg_inode_bitmap;
10. /* Inodes bitmap */
11. __le32 bg_inode_table;
12. /* Inodes table block*/
13. __le16 bg_free_blocks_count;
14. /* Free blocks count */
15. __le16 bg_free_inodes_count;
16. /* Free inodes count */
17. __le16 bg_used_dirs_count; /* Directories count */
18. __le16 bg_pad;
19. __le32 bg_reserved[3];
20. };

复制代码

块位图（Block Bitmap）
Block Bitmap中记录着Data Block中哪个数据块已经被占用，哪个数据块没有被占用
inode位图（Inode Bitmap）
每个bit位表示一个inode是否空闲可用。

i节点表(Inode Table)

• 存放文件属性 如 文件巨细，所有者，近来修改时间等
  
• 当前分组所有Inode属性的集合
  
• inode编号以分区为单位，团体划分，不可跨分区
  

Data Block
数据区：存放文件内容，也就是一个一个的Block。根据不同的文件范例有以下几种情况：

• 对于普通文件，文件的数据存储在数据块中。
  
• 对于目录，该目录下的所有文件名和目录名存储在地点目录的数据块中，除了文件名外，ls -l下令
  
• 看到的别的信息生存在该文件的inode中。
  
• Block 号按照分区划分，不可跨分区
  

 inode和datablock映射(弱化)

• inode内部存在 __le32 i_block[EXT2_N_BLOCKS];/* Pointers to blocks */ ,EXT2_N_BLOCKS =15,就是用来进行inode和block映射的
  
• 这样文件=内容+属性，就都能找到了。
  

 

知道inode号的情况下，在指定分区，请解释：对文件进行增、删、查、改是在
做什么？ 

1. [root@localhost linux]# touch abc
2. [root@localhost linux]# ls -i abc
3. 263466 abc

复制代码

 为了说明问题，我们将上图简化：

创建一个新文件主要有以下4个操作： 
存储属性
内核先找到⼀个空闲的i节点（这⾥是263466）。内核把文件信息记录到此中。
存储数据
该文件必要存储在三个磁盘块，内核找到了三个空闲块：300,500，800。将内核缓冲区的第一块
数据复制到300，下⼀块复制到500，以此类推。
记录分配情况
文件内容按顺序300,500,800存放。内核在inode上的磁盘分布区记录了上述块列表。
添加文件名到目录
新的文件名abc。linux怎样在当前的目录中记录这个文件？内核将入口（263466，abc）添加到
目录文件。文件名和inode之间的对应关系将文件名和文件的内容及属性连接起来。
 目录与文件名
问题：
我们访问文件，都是用的文件名，没用过inode号啊？目录是文件吗？怎样明白？
答案：
目录也是文件，但是磁盘上没有目录的概念，只有文件属性+文件内容的概念。目录的属性不消多说，内容生存的是：文件名和Inode号的映射关系
访问文件，必须打开当前目录，根据文件名，获得对应的inode号，然后进行文件访问
访问文件必须要知道当前工作目录，本质是必须能打开当前工作目录文件，查看目录文件的
内容！

路径解析
问题：
  打开当前工作目录⽂件，查看当前工作目录文件的内容?当前工作目录不也是文件吗？我们访问当前工作目录不也是只知道当前工作目录的文件名吗？要访问它，不也得知道当前工作目录的inode吗？
以是也要打开：当前工作目录的上级目录，额....，上级目录不也是目录吗？？不照旧上面的问题吗？
以是雷同"递归"，必要把路径中所有的目录全部解析，出口是"/"根目录。
而现实上，任何文件，都有路径，访问目标文件，好比:/home/whb/code/test/test/test.c
都要从根目录开始，依次打开每一个目录，根据目录名，依次访问每个目录下指定的目录，直到访问到test.c。这个过程叫做Linux路径解析。

要找到一个aa文件，就得找到对应的inode，通过映射关系打开文件(以是inode唯一，文件名字也唯一，不可重复)，而该文件的inode又存放在它的上一级目录【学习代码】文件下，而要找到上一级的inode才能打开上一级目录，而上一级目录的inode又存放在上上一级目录【113】下，以是会一直递归找下去直到根目录，而根目录是操纵系统在开机下固定打开的，以是，系统找文件是从左向右依次找的，直到找到要打开的aa文件，打开home目录，找到xm目录的inode，通过映射关系打开，然后依次路径解析，再找113，再找学习代码，末了打开aa
我们找文件必须要有路径！平时我们创建文件大概ls找文件没有带路径是因为操作系统给我们记录下文件路径了

我们平时访问文件，操作指令等，但凡动一下都是通过转化给操作系统来完成，操作系统把用户操作转化位进程，而进程再pcb中就会维护自己的情况变量，而进程的cwd又是从bash中来的，而bash又是从系统中来的，以是，我们可以明白：文件名由用户提供，文件路径由进程提供！  
注意：
以是，我们知道了：访问文件必须要有目录+文件名=路径的缘故起因
根目录固定无件名，inode号，无需查找，系统开机之后就必须知道
可是路径谁提供？

• 访问文件，都是指令/工具访问，本质是进程访问，进程有CWD！进程提供路径。
  
• open文件，提供了路径
  

上面所有行为：本质就是在磁盘文件系统中，新建目录文件。而你新建的任何文件，都在你大概系
统指定的目录下新建，这不就是天然就有路径了嘛！系统+用户共同构建Linux路径布局.
路径缓存
问题1：Linux磁盘中，存在真正的目录吗？
答案：不存在，只有文件。只生存文件属性+文件内容
问题2：访问任何文件，都要从/目录开始进行路径解析？
答案：原则上是，但是这样太慢，以是Linux会缓存历史路径布局
问题2：Linux目录的概念，怎么产生的？
答案：打开的文件是目录的话，由OS自己在内存中进行路径维护

 Linux中，在内核中维护树状路径布局的内核布局体叫做： struct dentry

1. struct dentry {
2. atomic_t d_count;
3. unsigned int d_flags;
4. /* protected by d_lock */
5. spinlock_t d_lock;
6. /* per dentry lock */
7. struct inode *d_inode;
8. /* Where the name belongs to - NULL is
9. * negative */
10. /*
11. * The next three fields are touched by __d_lookup. Place them here
12. * so they all fit in a cache line.
13. */
14. struct hlist_node d_hash;
15. /* lookup hash list */
16. struct dentry *d_parent;
17. /* parent directory */
18. struct qstr d_name;
19. struct list_head d_lru;
20. /* LRU list */
21. /*
22. * d_child and d_rcu can share memory
23. */
24. union {
25. struct list_head d_child;
26. /* child of parent list */
27. struct rcu_head d_rcu;
28. } d_u;
29. struct list_head d_subdirs; /* our children */
30. struct list_head d_alias;
31. /* inode alias list */
32. unsigned long d_time;
33. /* used by d_revalidate */
34. struct dentry_operations *d_op;
35. struct super_block *d_sb;
36. /* The root of the dentry tree */
37. void *d_fsdata;
38. /* fs-specific data */
39. #ifdef CONFIG_PROFILING
40. struct dcookie_struct *d_cookie; /* cookie, if any */
41. #endif
42. int d_mounted;
43. unsigned char d_iname[DNAME_INLINE_LEN_MIN];
44. /* small names */
45. };

复制代码

 注意：

• 每个文件着实都要有对应的dentry布局，包括普通文件。这样所有被打开的文件，就可以在内存中形成整个树形布局
  
• 整个树形节点也同时会⾪属于LRU(Least Recently Used，近来最少使用)布局中，进行节点淘汰整个树形节点也同时会⾪属于Hash，方便快速查找
  
• 更告急的是，这个树形布局，团体构成了Linux的路径缓存布局，打开访问任何⽂件，都在先在这棵树下根据路径进行查找，找到就返回属性inode和内容，没找到就从磁盘加载路径，添加dentry布局，缓存新路径
  

文件系统总结

 软硬连接
1.硬链接
我们看到，真正找到磁盘上文件的并不是文件名，而是inode。着实在linux中可以让多个文件名对应于同一个inode。

inode一样，硬链接不是一个独立的文件，相比软连接，权限后面的数字不再是1 ，后面数字代表映射数目，文件名指向链接文件，叫硬连接数。
2.软链接
硬链接是通过inode引用别的一个文件，软链接是通过名字引用别的一个文件，但现实上，新的文件和被引用的文件的inode不同，应用常见上可以想象成一个快捷方式。在shell中的做法

 创建了一个独立文件，雷同于快捷方式，对code.c修改，code-soft运行也会变

 下面解释一下文件的三个时间：

• Access 末了访问时间
  
• Modify 文件内容末了修改时间
  
• Change 属性末了修改时间
  

软硬连接对比

• 软连接是独立文件
• 硬链接只是文件名和目标文件inode的映射关系
软硬连接的用途：
硬链接
• .和.. 就是硬链接
• 文件备份
软连接
• 雷同快捷方式

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。