linux为什么不能硬链接目录？

在 Linux 文件系统中，一个普遍的规则是：目录（directory）不能被硬链接（hard link）。这背后涉及到了文件系统设计、数据一致性以及循环引用的问题。我们来深入剖析一下其中的原因。

什么是硬链接？

在深入目录的限制之前，先回顾一下硬链接是什么。

简单来说，硬链接是同一个文件在文件系统中的另一个名字。它们指向同一个 inode（index node），inode 包含了文件的元数据，比如文件的权限、所有者、大小、创建时间以及指向文件数据块的指针。

多个文件名，同一个 inode：当你创建一个文件的硬链接时，你实际上是在文件系统的某个位置创建了一个新的目录项（目录项就是文件名与 inode 号的映射关系），这个新的目录项指向了与原始文件相同的 inode。
引用计数：每个 inode 都有一个“链接计数”（link count）的字段，用来记录有多少个硬链接指向这个 inode。创建一个硬链接会使链接计数加一，删除一个硬链接会使链接计数减一。当链接计数变为零时，文件系统才会真正地删除文件数据块，并回收 inode。

为什么目录不能被硬链接？

现在，我们来看看为什么这个机制不适用于目录。主要有以下几个原因：

1. 维护文件系统的层级结构和路径查找

Linux 文件系统（如 ext4, XFS 等）的核心是树状结构。每个目录都是父目录中的一个条目，而目录本身可以包含更多的子目录和文件。

`.` 和 `..` 的特殊性：每个目录都包含两个特殊的条目：
`.` (点)：表示当前目录自身。
`..` (点点)：表示父目录。
这两个条目都是硬链接。比如，在你创建的 `/home/user/documents` 目录中，`documents` 目录项指向一个 inode。在这个 inode 内部，就有 `. ` 条目指向 `documents` 自己的 inode，以及 `..` 条目指向 `documents` 的父目录 `/home/user` 的 inode。

硬链接目录的连锁效应：如果允许硬链接目录，设想一下会发生什么：
假设我们有一个目录 `/dir_a`。
我们创建了一个指向 `/dir_a` 的硬链接，命名为 `/dir_b`。
此时，`/dir_a` 和 `/dir_b` 都指向同一个 inode。
现在，`/dir_a` 内部包含 `.` 指向自身 inode，`..` 指向其父目录 inode。
`/dir_b` 内部也应该包含 `.` 指向自身 inode，`..` 指向其父目录 inode。
问题来了：`/dir_a` 的 `.` 条目指向 `/dir_a` 的 inode。如果 `/dir_b` 是 `/dir_a` 的硬链接，那么 `/dir_b` 的 `.` 也应该指向同一个 inode。
更关键的是 `..` 条目。如果 `/dir_a` 的父目录是 `/parent`，那么 `/dir_a` 内部的 `..` 条目会指向 `/parent` 的 inode。如果 `/dir_b` 也是 `/dir_a` 的硬链接，它也需要一个 `..` 条目。
思考一下：如果 `/dir_a` 的父目录是 `/parent`，而 `/dir_b` 是 `/dir_a` 的硬链接，那么 `/dir_b` 的 `..` 条目应该指向哪里？按照硬链接的定义，它应该指向 `/dir_a` 的父目录，也就是 `/parent`。
潜在的灾难：如果 `/dir_a` 位于 `/home/user/data`，而 `/dir_b` 也是 `/home/user/data` 的硬链接，并且我们假设 `/dir_b` 存在于 `/home/user` 目录本身。那么 `/home/user/data` 的 `..` 条目指向 `/home/user` 的 inode。而 `/home/user` 目录的 inode 中，`..` 条目指向 `/home` 的 inode。
悖论出现：如果 `/home/user` 目录也有一个硬链接，比如 `/user_link`，并且它也指向 `/home/user` 的 inode。那么 `/home/user/data` 的 `..` 条目指向 `/home/user` 的 inode，而 `/home/user` 的 `..` 条目指向 `/home` 的 inode。
最致命的是：如果 `/dir_a` 的父目录是 `/parent`，并且我们创建了一个硬链接 `/parent/dir_b` 指向 `/dir_a`。那么 `/dir_a` 内部的 `..` 条目会指向 `/parent` 的 inode。而 `/dir_b` 内部的 `..` 条目也应该指向 `/parent` 的 inode。
循环依赖：问题在于，如果 `/dir_a` 的 `..` 指向 `/parent`，而 `/parent` 目录里又有一个名为 `dir_b` 的条目，它实际上是 `/dir_a` 的硬链接。这意味着，从 `/dir_a` 往上走，你会进入 `/parent`，然后通过 `dir_b` 又可以回到 `/dir_a`。这形成了一个目录循环。

2. 导致文件系统遍历和操作的复杂性与不确定性

`rm r` 的噩梦：如果允许硬链接目录，`rm r` 命令将变得异常危险。当 `rm r /dir_a` 执行时，它会删除 `/dir_a`。由于 `/dir_b` 是 `/dir_a` 的硬链接，删除 `/dir_a` 意味着链接计数减一。但如果 `/dir_b` 也是一个目录，它内部又包含 `..` 指向 `/dir_a` 的父目录。
如果 `/dir_a` 的父目录是 `/parent`，并且 `/dir_b` 是 `/parent` 目录下的一个链接指向 `/dir_a` 的 inode。
当执行 `rm r /dir_a` 时，会尝试删除 `/dir_a` 及其内容。
如果 `/dir_a` 还有其他硬链接（比如 `/dir_b`），`rm r` 需要非常小心地处理 `..` 条目，确保不会在删除一个目录时，因为其 `..` 条目指向了另一个正在被处理的目录而导致无限循环或数据丢失。
文件系统的深度遍历算法（如 `du`、`find`、`rm r`）通常依赖于一个无环的树结构。如果存在目录循环，这些算法可能会陷入死循环，或者错误地计算文件大小、遍历整个文件系统。

路径解析的歧义： `/` 是文件系统的根。假设 `/a/b` 是一个目录，我们创建 `/a/c` 作为 `/a/b` 的硬链接。
`/a/b/..` 指向 `/a` 的 inode。
`/a/c/..` 也应该指向 `/a` 的 inode。
如果 `/a` 目录本身也被硬链接为 `/d`，那么 `/a/b/..` 和 `/a/c/..` 都指向 `/a` 的 inode，而 `/d` 也指向 `/a` 的 inode。
这种情况下，`/a/b/..` 和 `/d/..` 都指向 `/a` 的 inode。这并不是问题。
真正的问题在于：如果 `/a` 是 `/parent/a_link` 的硬链接，而 `/parent/a_link` 是 `/parent` 目录下的一个目录，指向 `/a` 的 inode。那么 `/a/b/..` 指向 `/a` 的 inode。而 `/parent/a_link/..` 也指向 `/parent` 的 inode。
关键：如果 `/a` 目录的 inode 中，`..` 条目指向 `/parent` 的 inode。而 `/parent` 目录下存在一个名为 `a_link` 的目录项，它指向 `/a` 的 inode。
此时，`/a` 目录的 `..` 条目指向 `/parent`。而 `/parent` 目录下有一个 `a_link` 条目，它指向 `/a` 的 inode。
如果再创建 `/a/b`，那么 `/a/b` 的 `..` 条目指向 `/a` 的 inode。
如果 `/a` 被硬链接为 `/another_parent/a_hardlink`，那么 `/another_parent/a_hardlink` 的 `..` 条目也应该指向 `/another_parent` 的 inode。
关键的循环：如果 `/a` 的父目录是 `/parent`，并且我们创建了 `/parent/subdir/a_link` 这个硬链接，指向 `/a` 的 inode。
`/a` 目录内部，`.` 指向 `/a` 的 inode。
`/a` 目录内部，`..` 指向 `/parent` 的 inode。
`/parent/subdir/a_link` 目录内部，`.` 指向 `/a` 的 inode。
`/parent/subdir/a_link` 目录内部，`..` 指向 `/parent/subdir` 的 inode。
这里就出现了问题：`/a` 的 `..` 指向 `/parent`。但是，在 `/parent` 目录下，我们有一个 `subdir` 目录，而 `subdir` 目录里面有一个 `a_link`，它又指向 `/a`。
更直接的理解：设想一个目录 `/dir1`。它的父目录是 `/`. 那么 `/dir1` 内部的 `..` 指向 `/` 的 inode。
现在，我们在 `/` 目录下创建一个名为 `dir2` 的目录，并将其硬链接到 `/dir1`。
`/dir1` 目录内部：`.` 指向 `/dir1` 的 inode，`..` 指向 `/` 的 inode。
`/dir2` 目录内部：`.` 指向 `/dir1` 的 inode（因为是硬链接）。
`/dir2` 目录内部：`..` 应该指向 `/dir2` 的父目录，也就是 `/` 的 inode。
问题出现：如果 `/dir1` 目录本身就存在于 `/` 目录下，并且我们尝试创建 `/dir2` 硬链接到 `/dir1`，那我们就是在 `/` 目录下创建了一个指向 `/dir1` inode 的新目录项。
关键的 `..` 指向：文件系统在创建目录时，会在新目录下自动创建 `.` 和 `..` 条目。
对于 `/dir1`，其 `..` 条目指向其父目录 `/` 的 inode。
如果 `/dir2` 是 `/dir1` 的硬链接，那么 `/dir2` 也指向 `/dir1` 的 inode。
现在，当访问 `/dir2` 时，它的 `..` 条目也必须指向 `/dir1` 的父目录。
矛盾：如果 `/dir1` 和 `/dir2` 都是 `/parent` 目录的子目录，并且它们都指向同一个 inode。那么 `/dir1/..` 指向 `/parent` 的 inode，`/dir2/..` 也应该指向 `/parent` 的 inode。
真正的循环：假设我们有一个目录 `/a`。其父目录是 `/`. `..` 指向 `/` 的 inode。
我们创建 `/b` 作为 `/a` 的硬链接。`/b` 也在 `/` 目录下。
`/a` 的 `..` 指向 `/` 的 inode。
`/b` 的 `..` 也应该指向 `/` 的 inode。
这看起来没问题，但如果我们允许在 `/a` 内部创建 `c`，它是一个指向 `/b` 的硬链接目录。
`/a/c` 是一个指向 `/b` inode 的目录。
`/a/c` 的 `..` 条目指向 `/a` 的 inode。
问题： `/a` 的 `..` 条目指向 `/` 的 inode。而 `/a` 目录的 inode 中，存在一个名为 `c` 的条目，它指向 `/b` 的 inode。而 `/b` 的 `..` 条目指向 `/` 的 inode。
最容易理解的循环：
`/root_dir/subdir1` （inode A）
`/root_dir/subdir2` （inode B）
创建 `/root_dir/subdir1/link_to_subdir2`，这是一个指向 `subdir2` (inode B) 的硬链接。
现在 `/root_dir/subdir1` 目录的 inode (A) 里，有一个 `..` 指向 `/root_dir` 的 inode。
`/root_dir/subdir1/link_to_subdir2` 这个目录的 inode 也是 B。
这个新目录 (`link_to_subdir2`) 的 `..` 条目，应该指向 `/root_dir/subdir1` 的 inode (A)。
但是，inode B 的 `..` 条目本来就指向 `/root_dir` 的 inode。
这就导致了 `/root_dir/subdir1/link_to_subdir2/..` 指向 `/root_dir/subdir1` 的 inode (A)，而 `/root_dir/subdir1` 的 `..` 指向 `/root_dir` 的 inode。
更可怕的循环：
`mkdir /a`
`mkdir /b`
`ln s /a /b/a_link` （软链接，忽略）
关键：`ln /a /b/a_link_hard` （这是不允许的）
假设我们允许 `ln /a /b/a_link_hard`
`/a` 目录的 inode 是 `inode_A`
`/b` 目录的 inode 是 `inode_B`
`/b/a_link_hard` 这个目录项指向 `inode_A`
`/a` 目录内容：`.` > `inode_A`, `..` > `/` 的 inode (假设 `/a` 在根目录)
`/b` 目录内容：`.` > `inode_B`, `..` > `/` 的 inode (假设 `/b` 在根目录)
`/b/a_link_hard` 目录内容：`.` > `inode_A`, `..` > `/b` 的 inode
问题： `/b/a_link_hard` 这个目录的 `..` 条目指向 `/b` 的 inode (`inode_B`)。而 `/b` 目录在 `/` 下。
如果 `/a` 在 `/parent` 下，`/b` 也在 `/parent` 下。
`/a` 的 inode 是 `inode_A`
`/b` 的 inode 是 `inode_B`
`/a` 的 `..` 指向 `/parent` 的 inode (`inode_P`)。
`/b` 的 `..` 指向 `/parent` 的 inode (`inode_P`)。
创建 `/parent/a_hard_link` 指向 `/a` 的 inode (`inode_A`)。
`/parent/a_hard_link` 目录的 `..` 条目指向 `/parent` 的 inode (`inode_P`)。
现在，如果 `/a` 内部有一个 `. .` 指向 `/parent` 的 inode (`inode_P`)。而 `/parent` 目录本身就有一个 `a_hard_link` 条目，它指向 `/a` 的 inode (`inode_A`)。
这就是一个循环！从 `/a` 往上走，通过 `..` 到达 `/parent`，然后从 `/parent` 目录进入 `a_hard_link`，又回到了 `/a` 的 inode。

3. 简化系统设计和维护

避免了复杂的检测机制：如果允许目录硬链接，文件系统内核需要在进行任何涉及目录的操作（创建、删除、遍历）时，都要进行复杂的循环检测。这会显著增加内核的复杂性和开销。
保持唯一父目录的语义：目录的层次结构通常被设计成一个有向无环图（DAG），但更具体地说，它被设计成一个有根的树。每个节点（目录）都有一个唯一的父节点。硬链接目录会破坏这种“唯一父目录”的语义，使得树结构变成一个图结构。

4. 引用计数的副作用

删除的歧义：当一个目录被删除时，其所有内容（文件和子目录）的链接计数都会相应减少。如果目录可以被硬链接，那么删除一个目录实例（比如 `rmdir /a`）时，我们是应该删除所有指向其 inode 的硬链接，还是只删除一个？
如果只删除 `/a`，但 `/b` 是 `/a` 的硬链接，并且 `/b` 仍然存在，那么 `/a` 的 inode 链接计数不会归零，文件数据不会被删除。
更糟糕的是，如果 `/a` 和 `/b` 是相互的硬链接（不可能直接做到，但如果目录可以硬链接，理论上可以通过 `..` 来构造），那么删除其中一个会导致另一个失效，或者发生不可预测的行为。

总结

Linux 不允许硬链接目录，主要是为了：

1. 防止目录循环：硬链接目录会破坏文件系统的树状结构，形成循环，这会给文件系统遍历（如 `ls`、`cd`、`du`、`find`、`rm r`）带来巨大的麻烦，甚至可能导致死循环或数据丢失。
2. 维护 `.` 和 `..` 的一致性：目录中的 `.` 和 `..` 条目必须正确指向当前目录和父目录。目录硬链接会使得 `..` 指向的父目录与其自身之间的关系变得复杂和矛盾。
3. 简化文件系统设计：避免了复杂的循环检测机制，使得文件系统的内核代码更简洁、更高效、更易于维护。
4. 保持目录结构的清晰性：目录被设计为层级结构，每个目录只有一个唯一的父目录。硬链接会引入不确定性。

虽然不能硬链接目录，但 Linux 提供了软链接（Symbolic Link），它是一种指向文件或目录路径的特殊文件。软链接不会直接指向 inode，而是包含一个字符串，即它所指向的路径。这提供了灵活的链接方式，但当被链接的文件或目录被移动或删除时，软链接会失效。而且，软链接也同样要警惕循环引用的问题，但其实现机制和影响与硬链接不同。

最近正在学习linux系统，看资料说目录不能被硬链接，不懂，百度了一下也没看到说的比较清楚详细的，没看懂，有哪位大神了解的能详细解释下吗？