Landlock LSM: kernel documentation


Mickaël Salaün


February 2021

Landlock’s goal is to create scoped access-control (i.e. sandboxing). To harden a whole system, this feature should be available to any process, including unprivileged ones. Because such process may be compromised or backdoored (i.e. untrusted), Landlock’s features must be safe to use from the kernel and other processes point of view. Landlock’s interface must therefore expose a minimal attack surface.

Landlock is designed to be usable by unprivileged processes while following the system security policy enforced by other access control mechanisms (e.g. DAC, LSM). Indeed, a Landlock rule shall not interfere with other access-controls enforced on the system, only add more restrictions.

Any user can enforce Landlock rulesets on their processes. They are merged and evaluated according to the inherited ones in a way that ensures that only more constraints can be added.

User space documentation can be found here: Landlock: unprivileged access control.

Guiding principles for safe access controls

  • A Landlock rule shall be focused on access control on kernel objects instead of syscall filtering (i.e. syscall arguments), which is the purpose of seccomp-bpf.

  • To avoid multiple kinds of side-channel attacks (e.g. leak of security policies, CPU-based attacks), Landlock rules shall not be able to programmatically communicate with user space.

  • Kernel access check shall not slow down access request from unsandboxed processes.

  • Computation related to Landlock operations (e.g. enforcing a ruleset) shall only impact the processes requesting them.


Userspace tests for backward compatibility, ptrace restrictions and filesystem support can be found here: tools/testing/selftests/landlock/.

Kernel structures


struct landlock_object_underops

Operations on an underlying object


struct landlock_object_underops {
  void (*release)(struct landlock_object *const object) __releases(object->lock);



Releases the underlying object (e.g. iput() for an inode).

struct landlock_object

Security blob tied to a kernel object


struct landlock_object {
  refcount_t usage;
  spinlock_t lock;
  void *underobj;
  union {
    struct rcu_head rcu_free;
    const struct landlock_object_underops *underops;



This counter is used to tie an object to the rules matching it or to keep it alive while adding a new rule. If this counter reaches zero, this struct must not be modified, but this counter can still be read from within an RCU read-side critical section. When adding a new rule to an object with a usage counter of zero, we must wait until the pointer to this object is set to NULL (or recycled).


Protects against concurrent modifications. This lock must be held from the time usage drops to zero until any weak references from underobj to this object have been cleaned up.

Lock ordering: inode->i_lock nests inside this.


Used when cleaning up an object and to mark an object as tied to its underlying kernel structure. This pointer is protected by lock. Cf. landlock_release_inodes() and release_inode().




Enables lockless use of usage, lock and underobj from within an RCU read-side critical section. rcu_free and underops are only used by landlock_put_object().


Enables landlock_put_object() to release the underlying object (e.g. inode).


The goal of this structure is to enable to tie a set of ephemeral access rights (pertaining to different domains) to a kernel object (e.g an inode) in a safe way. This implies to handle concurrent use and modification.

The lifetime of a struct landlock_object depends of the rules referring to it.

Ruleset and domain

A domain is a read-only ruleset tied to a set of subjects (i.e. tasks’ credentials). Each time a ruleset is enforced on a task, the current domain is duplicated and the ruleset is imported as a new layer of rules in the new domain. Indeed, once in a domain, each rule is tied to a layer level. To grant access to an object, at least one rule of each layer must allow the requested action on the object. A task can then only transit to a new domain that is the intersection of the constraints from the current domain and those of a ruleset provided by the task.

The definition of a subject is implicit for a task sandboxing itself, which makes the reasoning much easier and helps avoid pitfalls.

struct landlock_layer

Access rights for a given layer


struct landlock_layer {
  u16 level;
  u16 access;



Position of this layer in the layer stack.


Bitfield of allowed actions on the kernel object. They are relative to the object type (e.g. LANDLOCK_ACTION_FS_READ).

struct landlock_rule

Access rights tied to an object


struct landlock_rule {
  struct rb_node node;
  struct landlock_object *object;
  u32 num_layers;
  struct landlock_layer layers[];



Node in the ruleset’s red-black tree.


Pointer to identify a kernel object (e.g. an inode). This is used as a key for this ruleset element. This pointer is set once and never modified. It always points to an allocated object because each rule increments the refcount of its object.


Number of entries in layers.


Stack of layers, from the latest to the newest, implemented as a flexible array member (FAM).

struct landlock_hierarchy

Node in a ruleset hierarchy


struct landlock_hierarchy {
  struct landlock_hierarchy *parent;
  refcount_t usage;



Pointer to the parent node, or NULL if it is a root Landlock domain.


Number of potential children domains plus their parent domain.

struct landlock_ruleset

Landlock ruleset


struct landlock_ruleset {
  struct rb_root root;
  struct landlock_hierarchy *hierarchy;
  union {
    struct work_struct work_free;
    struct {
      struct mutex lock;
      refcount_t usage;
      u32 num_rules;
      u32 num_layers;
      u16 fs_access_masks[];



Root of a red-black tree containing struct landlock_rule nodes. Once a ruleset is tied to a process (i.e. as a domain), this tree is immutable until usage reaches zero.


Enables hierarchy identification even when a parent domain vanishes. This is needed for the ptrace protection.




Enables to free a ruleset within a lockless section. This is only used by landlock_put_ruleset_deferred() when usage reaches zero. The fields lock, usage, num_rules, num_layers and fs_access_masks are then unused.




Protects against concurrent modifications of root, if usage is greater than zero.


Number of processes (i.e. domains) or file descriptors referencing this ruleset.


Number of non-overlapping (i.e. not for the same object) rules in this ruleset.


Number of layers that are used in this ruleset. This enables to check that all the layers allow an access request. A value of 0 identifies a non-merged ruleset (i.e. not a domain).


Contains the subset of filesystem actions that are restricted by a ruleset. A domain saves all layers of merged rulesets in a stack (FAM), starting from the first layer to the last one. These layers are used when merging rulesets, for user space backward compatibility (i.e. future-proof), and to properly handle merged rulesets without overlapping access rights. These layers are set once and never changed for the lifetime of the ruleset.


This data structure must contain unique entries, be updatable, and quick to match an object.