EN
en direct

Josef Bacik propose de faire des conteneurs des objets noyau à part entière avec l’API cells

Le 26 octobre 2026, Josef Bacik publie la version 2 de sa RFC « cells » : elle transforme le conteneur en objet noyau scellé, vide par défaut, dont les processus ne peuvent plus jamais sortir. Les mainteneurs de runtimes doivent suivre cette proposition — si elle aboutit, le contrat de confinement au niveau des appels système change.

Un panneau alvéolaire de compartiments hexagonaux identiques et fermés, un seul compartiment dont le joint de bord est fendu, laissant passer un mince filet ambre.

26 octobre 2026. Josef Bacik, mainteneur du système de fichiers Btrfs, publie la version 2 de sa RFC « cells » sur la liste linux-fsdevel. 29 octobre 2026. Jonathan Corbet en livre l’analyse dans LWN. Un constat. Le noyau Linux n’a toujours pas d’abstraction de conteneur : il fournit des namespaces, des cgroups et un mode d’emploi implicite qui dit, en substance, « assemblage requis ». Pourquoi c’est important : la proposition attaque à la racine une classe de bugs que les runtimes compensent aujourd’hui à coups de couches — et elle pourrait redéfinir le contrat de confinement au niveau des appels système.

Le problème : l’assemblage est la source des bugs

Aujourd’hui, un conteneur n’existe pas en tant qu’objet dans le noyau. Il est fabriqué par cloisonnement : on crée des namespaces, on y entre, on démonte ou surmonte des systèmes de fichiers pour les rendre inaccessibles, et ainsi de suite. La conséquence, selon Bacik, est brutale : « c’est là que naît un nombre déprimant de nos bugs ». À tout moment, un processus peut n’être que partiellement dans un conteneur — à mi-chemin entre deux namespaces — et cette fenêtre ouvre la porte aux fuites de ressources ou de descripteurs.

Le noyau ne peut pas non plus répondre à une question simple : à quel conteneur appartient ce processus ? Il n’a aucune notion de l’objet, donc aucune propriété à appliquer, aucune frontière à faire respecter. Les tentatives pour corriger cela — citées par LWN dès 2017 puis 2019 — n’ont jamais abouti. Bacik retente l’exercice avec une idée inverse : au lieu d’isoler une partie du système, on crée un objet vide par défaut, et on n’y place que ce qu’on décide explicitement.

L’API cells : un objet scellé, vide par défaut

Une cell naît par un appel unique, et sa vie est gouvernée par trois appels système dont les signatures figurent dans la RFC :

c
int cell_create(int parent, unsigned int flags);
int cell_kill(int cellfd, unsigned int flags);
int cell_configure(int cellfd, unsigned int cmd, const char *key,
                   const void *value, int aux);

cell_create() retourne un cellfd, un descripteur spécial qui sert de poignée pour toutes les autres opérations — et qu’il est impossible de dupliquer avec les mêmes capacités. Fermer le cellfd tue immédiatement la cellule et tout ce qu’elle contient. La création est une opération non privilégiée : n’importe quel processus peut fabriquer sa propre cellule.

cell_configure() applique une configuration à la cellule, clé par clé. La commande CELL_SET_FD accepte trois descripteurs : root (le système de fichiers racine), net (le namespace réseau) et budget — un répertoire de cgroup obligatoire, chaque cellule devant disposer de son propre cgroup. La commande CELL_SET_BINARY définit les identifiants utilisateur : soit les processus tournent avec l’identifiant du créateur, soit la cellule reçoit un bloc de 65 536 identifiants alloués dans la partie haute de l’espace 32 bits, uniques sur la machine et hors de tout contrôle du créateur.

La clé de voûte est CELL_CMD_SEAL. Une fois la configuration terminée, cette commande scelle la cellule : plus aucun changement de configuration n’est possible. La cellule est alors dotée de son arborescence de fichiers, de son cgroup et du reste de ses namespaces — mais elle reste vide de processus. Et c’est là que la proposition rompt avec l’existant : setns() ne peut pas entrer dans ses namespaces. Un processus existant ne peut pas pénétrer dans une cellule ; un processus né dedans ne peut jamais en sortir.

Des processus « embryons », nés dans la cellule

Pour démarrer quelque chose dans une cellule, il faut un autre mécanisme, lui aussi nouveau. On crée d’abord un processus vide — un « embryon » — via pidfd_open() avec le drapeau PIDFD_EMPTY, en passant le cellfd plutôt qu’un PID :

c
int pidfd_configure(int pidfd, unsigned int cmd, const char *key,
                    const void *value, int aux);

pidfd_configure() renseigne l’embryon : PIDFD_SET_STRING avec la clé exec désigne l’exécutable à lancer, PIDFD_SET_BINARY transporte argv, envp et cred, et PIDFD_SET_FD installe les descripteurs — les seuls que le processus possédera, puisqu’aucun descripteur ne fuit par accident. PIDFD_CMD_START met le processus en marche. Le premier processus lancé devient l’init de la cellule : s’il meurt, la cellule meurt avec lui.

La frontière est verrouillée par une série de restrictions : chaque processus tourne avec le drapeau no_new_privs (il ne peut acquérir de nouvelles capacités), il est impossible de faire passer un descripteur de fichier à travers la frontière via les sockets Unix-domain, et une cellule ne peut partager son cgroup avec aucun autre processus. Le tout vise un confinement « aussi étanche que possible », de l’aveu même de l’auteur.

Pourquoi maintenant, et pourquoi c’est différent

La question évidente : pourquoi cette proposition aboutirait-elle là où celles de 2017 et 2019 ont échoué ? Deux choses ont changé. D’abord, l’infrastructure d’accueil existe : Bacik s’appuie sur pidfd_open() et les pidfds, introduits depuis, plutôt que de bâtir un nouveau mécanisme de A à Z. Ensuite, le poids des conteneurs a changé de nature : ils ne sont plus un outil de développement, ils sont la frontière de sécurité par défaut du cloud, et chaque évasion documentée remet en cause une promesse de confinement que les namespaces n’ont jamais réellement tenue.

Reste que la proposition est jeune. Postée sur une seule liste, elle n’a pas encore subi l’épreuve du débat transversal — scheduler, cgroups, sécurité. Et plusieurs choix, comme le bloc d’identifiants de 65 536, sont explicitement marqués comme susceptibles de changer. La RFC est un point de départ, pas une feuille de route.

Le verdict

Si vous maintenez un runtime — Docker, containerd, Podman, systemd — suivez cette RFC de près, sans rien en attendre à court terme. Bacik le dit lui-même : la proposition « existe pour qu’il y ait du code à débattre », pas pour être intégrée. C’est une RFC avec une longue liste de problèmes ouverts, postée pour l’instant sur une seule liste, et qui touche à des sujets historiquement controversés — le même type de débat qui a fait échouer les tentatives précédentes.

Si vous consommez des conteneurs sans les implémenter, ne changez rien : la valeur immédiate de cette lecture est d’expliquer pourquoi vos runtimes portent tant de couches. Le passage par des objets cells ne concernerait que le niveau noyau et les runtimes. Mais gardez l’enjeu en tête : une frontière de conteneur qui serait un objet de première classe — au lieu d’un empilement de namespaces qu’un processus peut n’habiter qu’à moitié — refermerait une classe de bugs d’évasion que ETTAYEB a déjà documentée sous l’angle du distroless. C’est le même combat, mené un étage plus bas.

Références

Le brief cyber, chaque mardi

Les failles qui comptent, les correctifs à appliquer, en dix minutes de lecture.

Pas de spam. Désinscription en un clic.
à lire ensuite

Sur le même sujet

AMD apporte le Capacity Aware Scheduling à Linux pour ses processeurs hybrides

Le 15 novembre 2026, AMD publie une série de correctifs pour que l’ordonnanceur Linux mesure la capacité réelle de chaque cœur et place correctement les tâches sur ses processeurs hybrides, qui mêlent cœurs Zen 5 et cœurs compacts Zen 5c. Comprenez ce que cela change pour vos charges de travail avant que le support ne soit fusionné dans un futur noyau.

← Retour au fil

Tapez au moins deux caractères.

↑ ↓ naviguer ↵ ouvrir esc fermer