Linux failfs makes implicit path lookups fail by default
Linux 7.3 adds failfs and descriptor-based fchroot(), letting a process discard its ordinary root and working directory. This is a narrow kernel mechanism for removing ambient filesystem access, with strict entry and exit constraints—not a general-purpose sandbox.
A filesystem whose useful property is failure
Linux 7.3 incorporates failfs and the new fchroot() system call. The change entered Linus Torvalds’s development tree on 17 August 2026 and shipped with the 7.3 source release dated 19 October. Failfs is deliberately unlike a normal filesystem: it is kernel-internal, cannot be mounted from userspace, and causes every operation that reaches it to fail with EOPNOTSUPP. Its root is not an ordinary directory that a process can open and inspect. [1] [2] [3]
The design makes sense when filesystem state itself is the thing a task should stop inheriting. A process normally has a root directory and a current working directory. Those references make absolute paths and AT_FDCWD-relative paths meaningful even when a function receives no directory handle. Code can therefore reach ambient parts of the filesystem without being passed an explicit capability for each lookup. Failfs supplies an intentionally unusable root or working directory, so accidental name-based lookups fail instead of quietly resolving somewhere.
Failing lookups is different from an empty directory
The important behavior is not just that names are absent. A lookup through failfs fails with EOPNOTSUPP before the path component is parsed; even . fails. If the process uses failfs as its working directory, lookups that rely on AT_FDCWD fail. If it uses failfs as its root, absolute paths fail too, including absolute symlinks and the interpreter lookup needed to execute a dynamically linked program. The error expresses “this namespace does not support this operation,” rather than “the requested file was not found.” [2]
Explicit directory descriptors remain useful. A process that already holds a descriptor to a directory can anchor an operation there, while operations that depend on ambient root or current-directory state are rejected. This is a different shape of control from checking a path string for a permitted prefix: the process changes the default filesystem context, and code that needs filesystem access must carry a handle to the place it intends to use. The handle still grants whatever access it represents; failfs does not revoke or audit inherited descriptors.
The entry rules are part of the security boundary
The FD_FAILFS_ROOT sentinel is accepted by fchdir() and fchroot(). The documented privileged path requires CAP_SYS_CHROOT in the caller’s user namespace. An unprivileged task can enter only under additional conditions: no_new_privs must be set, the task must not already be chrooted, and its filesystem state (fs_struct) must not be shared with another task. These checks address concrete escape and privilege interactions, not merely API convenience. For example, requiring an unshared filesystem state prevents a sibling that did not set no_new_privs from using shared root state to execute a setuid program. [2]
This makes failfs a carefully constrained primitive, not a drop-in replacement for a container runtime. It cannot decide which inherited file descriptors are safe, map a network identity to a user, or restrict system calls unrelated to path lookup. A service would still need to construct its descriptor set intentionally and apply its other isolation and authorization policies. The capability boundary becomes easier to reason about only if the surrounding process setup respects it.
Entering can be easier than leaving
The current documentation warns that backing out is hard. A task that enters failfs is treated as chrooted; ordinary chroot() or fchroot() back out requires CAP_SYS_CHROOT. The documented escape route uses setns() with a mount-namespace descriptor and requires capabilities in the relevant namespaces. A process that holds no such descriptor and has restricted the relevant calls with seccomp may have no route out under the current implementation. The documentation explicitly says this is current behavior, not a guaranteed permanent interface. [2]
That changes how callers should stage the transition. Decide how the task will be supervised and recovered before entering, retain only the namespace handles the recovery design needs, and test the exact privilege and thread-sharing conditions on the target kernel. “Fail closed” is not automatically “safe to enter”: a lost recovery path can turn a desired confinement step into a stuck worker. This is an operational property that should be reviewed like any other irreversible state transition.
Use it when ambient lookup is the problem
The useful question is whether a component should be able to resolve names merely because the process has a root and current directory. If the answer is no, failfs makes that default visible: implicit absolute and current-directory-relative lookups stop working, while code must use explicit directory handles. That can help make filesystem dependencies auditable and reduce accidental reachability. It does not make the remaining handles harmless, and it does not replace authorization at the object or application layer.
Linux 7.3’s change is therefore best understood as a primitive for removing ambient filesystem context. Its narrow failure semantics are the feature. Review the kernel documentation for the exact entry and recovery rules, inventory descriptors before transition, and test both the operations expected to keep working and the implicit lookups that should now fail. [2]