UNSHARE(2)

NOM
unshare - Désassocier certaines parties du contexte d'exécution

SYNOPSIS
#define _GNU_SOURCE
#include <sched.h>

int unshare(int flags);

DESCRIPTION
unshare() allows a process (or thread) to disassociate parts of its execution context that are currently being shared with other processes (or threads). Part of the execution context, such as the mount namespace, is shared implicitly when a new process is created using fork(2) or vfork(2), while other parts, such as virtual memory, may be shared by explicit request when creating a process or thread using clone(2).

L'intérêt principal de unshare() est de permettre à un processus de contrôler son contexte d'exécution partagé sans avoir à créer un nouveau processus.

L'argument flags est un masque qui indique quelles parties du contexte d'exécution doivent être désassociées. Cet argument est construit comme un OU binaire entre les constantes suivantes :

CLONE_FILES
    A l'effet inverse de l'attribut CLONE_FILES de clone(2). Supprime le partage de la table des descripteurs de fichier, afin que le processus appelant ne partage plus ses descripteurs de fichier avec d'autres processus.

CLONE_FS
    Annuler l'effet de l'attribut CLONE_FS de clone(2). Supprime le partage des attributs de système de fichiers, afin que le processus appelant ne partage plus son répertoire racine (chroot(2)), son répertoire courant (chdir(2)) et sa valeur d'umask (umask(2)) avec d'autres processus.

CLONE_NEWCGROUP (depuis Linux 4.6)
    This flag has the same effect as the clone(2) CLONE_NEWCGROUP flag. Unshare the cgroup namespace. Use of CLONE_NEWCGROUP requires the CAP_SYS_ADMIN capability.

CLONE_NEWIPC (depuis Linux 2.6.19)
    This flag has the same effect as the clone(2) CLONE_NEWIPC flag. Unshare the IPC namespace, so that the calling process has a private copy of the IPC namespace which is not shared with any other process. Specifying this flag automatically implies CLONE_SYSVSEM as well. Use of CLONE_NEWIPC requires the CAP_SYS_ADMIN capability.

CLONE_NEWNET (depuis Linux 2.6.24)
    Cet attribut a le même effet que l'attribut CLONE_NEWNET de clone(2). Supprime le partage de l'espace de noms de réseau, afin que le processus appelant soit déplacé dans un nouvel espace de noms de réseau qui n'est pas partagé avec d'autres processus. CLONE_NEWNET nécessite la capacité CAP_SYS_ADMIN.

CLONE_NEWNS
    This flag has the same effect as the clone(2) CLONE_NEWNS flag. Unshare the mount namespace, so that the calling process has a private copy of its namespace which is not shared with any other process. Specifying this flag automatically implies CLONE_FS as well. Use of CLONE_NEWNS requires the CAP_SYS_ADMIN capability. For further information, see mount_namespaces(7).

CLONE_NEWPID (depuis Linux 3.8)
    Cet attribut a le même effet que l'attribut CLONE_NEWNS de clone(2). Supprime le partage l'espace de noms PID, afin que le processus génère un nouvel espace de noms PID qui ne soit pas partagé avec d'autres processus antérieurs et qui sera celui de ses fils. Le processus appelant ne change pas d'espace de noms. Le premier fils créé par le processus appelant aura l'identifiant 1 et sera init(1) dans le nouvel espace de noms. CLONE_NEWPID implique automatiquement CLONE_THREAD. L'utilisation de CLONE_NEWPID nécessite de disposer de la capacité CAP_SYS_ADMIN. Pour plus d'informations, consultez CAP_SYS_ADMIN.

CLONE_NEWTIME (since Linux 5.6)
    Unshare the time namespace, so that the calling process has a new time namespace for its children which is not shared with any previously existing process. The calling process is not moved into the new namespace. Use of CLONE_NEWTIME requires the CAP_SYS_ADMIN capability. For further information, see time_namespaces(7).

CLONE_NEWUSER (depuis Linux 3.8)
    Cet attribut a le même effet que l'attribut CLONE_NEWUSER de clone(2). Supprime le partage de l'espace de noms de réseau, afin que le processus appelant soit déplacé dans un nouvel espace de noms utilisateur qui n'est pas partagé avec d'autres processus. Comme pour les fils créés par clone(2) avec l'attribut CLONE_NEWUSER, l'appelant obtient un ensemble de capacité dans le nouvel espace de noms.

    CLONE_NEWUSER nécessite que le processus appelant ne soit pas multi-threadé ; si CLONE_NEWUSER est spécifié, CLONE_THREAD l'est automatiquement. À partir de Linux 3.9, CLONE_NEWUSER implique également automatiquement CLONE_FS. CLONE_NEWUSER nécessite que les identifiants utilisateur et groupe du processus appelant correspondent aux identifiants utilisateur et groupe dans l'espace de noms utilisateur du processus appelant au moment de l'appel.

    Pour obtenir plus d'informations sur les espaces de noms utilisateur, consultez user_namespaces(7).

CLONE_NEWUTS (depuis Linux 2.6.19)
    Cet attribut a le même effet que l'attribut CLONE_NEWUTS de clone(2). Départager l'espace de noms IPC UTS, afin que le processus appelant ait une copie privée de l'espace de noms UTS qui ne soit pas partagée avec d'autres processus. L'utilisation de CLONE_NEWUTS nécessite la capacité CAP_SYS_ADMIN.

CLONE_SYSVSEM (depuis Linux 2.6.26)
    Cet attribut inverse l'effet de l'attribut CLONE_SYSVSEM de clone(2). Supprime le partage des valeurs d'ajustement des sémaphores System V (semadj), afin que le processus appelant ait une nouvelle liste semadj vide qui ne soit partagée avec aucun autre processus. S'il s'agit du dernier processus ayant une référence à la liste (semadj) du processus courant, alors les ajustements de cette liste sont appliqués au sémaphore correspondant, tel que décrit dans semop(2).

De plus, CLONE_THREAD, CLONE_SIGHAND et CLONE_VM peuvent être invoqués dans flags si l'appelant est mono-threadé (c'est-à-dire s'il ne partage pas son espace d'adressage avec un autre processus ou un autre thread). Dans ce cas, ces attributs sont sans effet. Notez également que spécifier CLONE_THREAD implique automatiquement CLONE_VM, et que spécifier CLONE_VM implique automatiquement CLONE_SIGHAND. Si le processus est multi-threadé, alors ces attributs restent sans effet.

Si flags est nul, unshare() n'a aucun effet : le contexte d'exécution du processus appelant n'est pas modifié.

VALEUR RENVOYÉE
S'il réussit l'appel renvoie zéro, sinon il renvoie -1 et remplit errno avec le code d'erreur.

ERREURS

EINVAL
    Un attribut invalide est indiqué dans flags.

EINVAL
    CLONE_THREAD, CLONE_SIGHAND ou CLONE_VM figurait dans flags, et l'appelant était multi-threadé.

EINVAL
    CLONE_NEWIPC a été spécifié dans flags, mais le noyau n'a pas été configuré avec les options CONFIG_SYSVIPC et CONFIG_IPC_NS.

EINVAL
    CLONE_NEWNET a été spécifié dans flags, mais le noyau n'a pas été configuré avec l'option CONFIG_NET_NS.

EINVAL
    CLONE_NEWPID a été spécifié dans flags, mais le noyau n'a pas été configuré avec l'option CONFIG_PID_NS.

EINVAL
    CLONE_NEWUSER was specified in flags, but the kernel was not configured with the CONFIG_USER_NS option.

EINVAL
    CLONE_NEWUTS was specified in flags, but the kernel was not configured with the CONFIG_UTS_NS option.

EINVAL
    CLONE_NEWPID was specified in flags, but the process has previously called unshare() with the CLONE_NEWPID flag.

ENOMEM
    Impossible d'allouer suffisamment de mémoire pour copier les parties du contexte de l'appelant qui doivent être rendues privées.

ENOSPC (depuis Linux 3.7)
    CLONE_NEWPID was specified in flags, but the limit on the nesting depth of PID namespaces would have been exceeded; see pid_namespaces(7).

ENOSPC (depuis Linux 4.9 ; auparavant EUSERS)
    CLONE_NEWUSER a été spécifié dans flags, et l'appel provoquerait un dépassement de la limite du nombre maximum d'espace de noms utilisateur imbriqués. Consultez user_namespaces(7).

    De Linux 3.11 à Linux 4.8, l'erreur indiquée dans ce cas était EUSERS.

ENOSPC (depuis Linux 4.9)
    One of the values in flags specified the creation of a new user namespace, but doing so would have caused the limit defined by the corresponding file in /proc/sys/user to be exceeded. For further details, see namespaces(7).

EPERM
    Le processus appelant n'avait pas les privilèges appropriés pour effectuer cette opération.

EPERM
    CLONE_NEWUSER a été spécifié dans flags, mais l'identifiant utilisateur effectif ou l'identifiant groupe effectif de l'appelant n'a pas de correspondance dans l'espace de noms père (consultez user_namespaces(7)).

EPERM (depuis Linux 3.9)
    CLONE_NEWUSER was specified in flags and the caller is in a chroot environment (i.e., the caller's root directory does not match the root directory of the mount namespace in which it resides).

EUSERS (from Linux 3.11 to Linux 4.8)
    CLONE_NEWUSER was specified in flags, and the limit on the number of nested user namespaces would be exceeded. See the discussion of the ENOSPC error above.

VERSIONS
L'appel système unshare() est apparu dans Linux 2.6.16.

CONFORMITÉ
L'appel système unshare() est spécifique à Linux.

NOTES
Tous les attributs de processus qui peuvent être partagés lorsqu'un processus est créé avec clone(2) ne peuvent pas être rendus privés avec unshare(). En particulier, dans le noyau 3.8, unshare() n'implémente pas de drapeaux inversant les effets de CLONE_SIGHAND, CLONE_THREAD ou CLONE_VM. Cette fonctionnalité pourra être ajoutée plus tard si nécessaire.

EXEMPLES
Le programme ci-dessous est une implémentation simple de la commande unshare(1), qui supprime le partage d'un ou plusieurs espaces de noms et exécute la commande fournie en argument. Voici un exemple d'utilisation du programme qui exécute un shell dans un nouvel espace de noms de montage, puis vérifie que le shell initial et le nouveau shell sont bien dans les espaces de noms séparés :

    $ readlink /proc/$$/ns/mnt
    mnt:[4026531840]
    $ sudo ./unshare -m /bin/bash
    # readlink /proc/$$/ns/mnt
    mnt:[4026532325]

Les deux chaînes renvoyées par readlink(1) sont différentes, ce qui montre que les deux shells se trouvent dans des espaces de noms de montage différents.

  Source du programme
    /* unshare.c
       Une implémentation simple de la commande unshare(1): supprime
       le partage des espaces de noms et exécute une commande.
    */
    #define _GNU_SOURCE
    #include <sched.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <stdio.h>
    /* Une fonction simple de gestion des erreurs : affiche un message
       d'erreur basé sur la valeur 'errno' et termine le processus
       appelant */
    #define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \
                            } while (0)
    static void
    usage(char *pname)
    {
        fprintf(stderr, "Usage: %s [options] program [arg...]\n", pname);
        fprintf(stderr, "Options can be:\n");
        fprintf(stderr, "    -C   unshare cgroup namespace\n");
        fprintf(stderr, "    -i   unshare IPC namespace\n");
        fprintf(stderr, "    -m   unshare mount namespace\n");
        fprintf(stderr, "    -n   unshare network namespace\n");
        fprintf(stderr, "    -p   unshare PID namespace\n");
        fprintf(stderr, "    -t   unshare time namespace\n");
        fprintf(stderr, "    -u   unshare UTS namespace\n");
        fprintf(stderr, "    -U   unshare user namespace\n");
        exit(EXIT_FAILURE);
    }
    int
    main(int argc, char *argv[])
    {
        int flags, opt;
        flags = 0;
        while ((opt = getopt(argc, argv, "CimnptuU")) != -1) {
            switch (opt) {
            case 'C': flags |= CLONE_NEWCGROUP;      break;
            case 'i': flags |= CLONE_NEWIPC;        break;
            case 'm': flags |= CLONE_NEWNS;         break;
            case 'n': flags |= CLONE_NEWNET;        break;
            case 'p': flags |= CLONE_NEWPID;        break;
            case 't': flags |= CLONE_NEWTIME;        break;
            case 'u': flags |= CLONE_NEWUTS;        break;
            case 'U': flags |= CLONE_NEWUSER;       break;
            default:  usage(argv[0]);
            }
        }
        if (optind >= argc)
            usage(argv[0]);
        if (unshare(flags) == -1)
            errExit("unshare");
        execvp(argv[optind], &argv[optind]);
        errExit("execvp");
    }

VOIR AUSSI
unshare(1), clone(2), fork(2), kcmp(2), setns(2), vfork(2), namespaces(7)

Documentation/userspace-api/unshare.rst in the Linux kernel source tree (or Documentation/unshare.txt before Linux 4.12)

COLOPHON
Cette page fait partie de la publication 5.10 du projet man-pages Linux. Une description du projet et des instructions pour signaler des anomalies et la dernière version de cette page peuvent être trouvées à l'adresse https://www.kernel.org/doc/man-pages/.

TRADUCTION
La traduction française de cette page de manuel a été créée par Christophe Blaess <https://www.blaess.fr/christophe/>, Stéphan Rafin <stephan.rafin@laposte.net>, Thierry Vignaud <tvignaud@mandriva.com>, François Micaux, Alain Portal <aportal@univ-montp2.fr>, Jean-Philippe Guérard <fevrier@tigreraye.org>, Jean-Luc Coulon (f5ibh) <jean-luc.coulon@wanadoo.fr>, Julien Cristau <jcristau@debian.org>, Thomas Huriaux <thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>, Denis Barbier <barbier@debian.org>, David Prévot <david@tilapin.org>, Cédric Boutillier <cedric.boutillier@gmail.com> et Frédéric Hantrais <fhantrais@gmail.com> Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General Public License version 3 (https://www.gnu.org/licenses/gpl-3.0.html) concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE. Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à debian-l10n-french@lists.debian.org.