Scroll to navigation

loop(4) Device Drivers Manual loop(4)

NOM

loop, loop-control — Périphériques boucle

SYNOPSIS

#include <linux/loop.h>

DESCRIPTION

Un périphérique boucle est un périphérique bloc qui mappe ses blocs de données non sur un périphérique physique tel qu’un disque dur ou un support optique, mais sur les blocs d’un fichier normal dans un système de fichiers ou sur ceux d’un autre périphérique bloc. Cela peut être utile pour fournir un périphérique bloc pour un stockage d’image de système de fichiers, de façon à pouvoir le monter avec la commande mount(8). Il est possible de faire :


$ dd if=/dev/zero of=fich.img bs=1MiB count=10
$ sudo losetup /dev/loop4 fich.img
$ sudo mkfs -t ext4 /dev/loop4
$ sudo mkdir /monperboucle
$ sudo mount /dev/loop4 /monperboucle

Consulter losetup(8) pour un autre exemple.

Une fonction de transfert peut être spécifiée pour chaque périphérique boucle dans un but de chiffrement et de déchiffrement.

Les opérations ioctl(2) suivantes sont fournies par le périphérique boucle :

Associer le périphérique boucle avec le fichier ouvert dont le descripteur de fichier est passé comme (troisième) argument d’ioctl(2).
Dissocier le périphérique boucle de n’importe quel descripteur de fichier.
Régler l’état du périphérique boucle en utilisant le (troisième) argument d’ioctl(2). Cet argument est un pointeur vers une structure loop_info, définie dans <linux/loop.h> ainsi :

struct loop_info {


    int           lo_number;      /* ioctl r/o */


    dev_t         lo_device;      /* ioctl r/o */


    unsigned long lo_inode;       /* ioctl r/o */


    dev_t         lo_rdevice;     /* ioctl r/o */


    int           lo_offset;


    int           lo_encrypt_type;


    int           lo_encrypt_key_size;  /* ioctl w/o */


    int           lo_flags;       /* ioctl r/w (r/o avant


                                     Linux 2.6.25) */


    char          lo_name[LO_NAME_SIZE];


    unsigned char lo_encrypt_key[LO_KEY_SIZE];


                                  /* ioctl w/o */


    unsigned long lo_init[2];


    char          reserved[4];
};

Le type de chiffrement (lo_encrypt_type) devrait être soit LO_CRYPT_NONE, LO_CRYPT_XOR, LO_CRYPT_DES, LO_CRYPT_FISH2, LO_CRYPT_BLOW, LO_CRYPT_CAST128, LO_CRYPT_IDEA, LO_CRYPT_DUMMY, LO_CRYPT_SKIPJACK ou (depuis Linux 2.6.0) LO_CRYPT_CRYPTOAPI.
Le champ lo_flags est un masque de bits qui peut inclure zéro ou plus des drapeaux suivants :
Le périphérique boucle est en lecture seule.
Le périphérique boucle s’autodétruira lors de la dernière fermeture.
Permission de l’analyse automatique des partitions.
Utilisation du mode E/S direct pour accéder au fichier de sauvegarde.
Les seuls lo_flags pouvant être modifiés par LOOP_SET_STATUS sont LO_FLAGS_AUTOCLEAR et LO_FLAGS_PARTSCAN.
Obtention de l’état du périphérique boucle ; le (troisième) argument d’ioctl(2) doit être un pointeur vers une struct loop_info.
Basculement du stockage de sauvegarde du périphérique boucle vers le nouveau fichier identifié par le descripteur de fichier spécifié dans le (troisième) argument d’ioctl(2), qui est un entier. Cette opération est possible si le périphérique boucle est en lecture seule et que le nouveau stockage de sauvegarde est de la même taille et du même type que l’ancien stockage de sauvegarde.
Redimensionnement d’un périphérique boucle actif. Il est possible de changer la taille du stockage de sauvegarde sous-jacent et puis d’utiliser cette opération de façon que le pilote de boucle connaisse la nouvelle taille. Cette opération ne prend pas d’argument.
Régler le mode E/S direct sur le périphérique boucle, de façon à ce qu’il puisse être utilisé pour ouvrir un fichier de sauvegarde. Le (troisième) argument d’ioctl(2) est une valeur « unsigned long ». Une valeur différente de zéro représente le mode E/S direct.
Régler la taille de bloc de périphérique boucle. Le (troisième) argument d’ioctl(2) est une valeur « unsigned long ». Cette valeur doit être une puissance de deux dans l’intervalle [512,taille_page], sinon une erreur EINVAL en résultera.
Régler et configurer tous les paramètres du périphérique boucle en une seule étape en utilisant le (troisième) argument d’ioctl(2). Cet argument est un pointeur vers une structure loop_config, définie dans <linux/loop.h> ainsi :

struct loop_config {


    __u32               fd;


    __u32               block_size;


    struct loop_info64  info;


    __u64               __reserved[8];
};

En plus de faire ce que LOOP_SET_STATUS peut faire, LOOP_CONFIGURE peut aussi être utilisé pour faire les choses suivantes :
  • régler la taille correcte de bloc immédiatement en réglant loop_config.block_size ;
  • requérir explicitement le mode E/S direct en réglant LO_FLAGS_DIRECT_IO dans loop_config.info.lo_flags ;
  • requérir explicitement le mode lecture seule en réglant LO_FLAGS_READ_ONLY dans loop_config.info.lo_flags.

Depuis Linux 2.6, deux nouvelles opérations ioctl(2) existent :

Elles sont similaires à LOOP_SET_STATUS et LOOP_GET_STATUS décrites ci-dessus, mais utilisent la structure loop_info64 qui a quelques champs supplémentaires et des intervalles plus grands pour quelques autres champs :

struct loop_info64 {


    uint64_t lo_device;           /* ioctl r/o */


    uint64_t lo_inode;            /* ioctl r/o */


    uint64_t lo_rdevice;          /* ioctl r/o */


    uint64_t lo_offset;


    uint64_t lo_sizelimit;  /* octets, 0 == max dispo. */


    uint32_t lo_number;           /* ioctl r/o */


    uint32_t lo_encrypt_type;


    uint32_t lo_encrypt_key_size; /* ioctl w/o */


    uint32_t lo_flags; i          /* ioctl r/w (r/o avant


                                     Linux 2.6.25) */


    uint8_t  lo_file_name[LO_NAME_SIZE];


    uint8_t  lo_crypt_name[LO_NAME_SIZE];


    uint8_t  lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */


    uint64_t lo_init[2];
};

/dev/loop-control

Depuis Linux 3.1, le noyau fournit le périphérique /dev/loop-control qui permet à une application de trouver de manière dynamique un périphérique libre et d’ajouter ou de retirer des périphériques boucle du système. Pour réaliser ces opérations, l’utilisateur doit d’abord ouvrir /dev/loop-control, puis employer une des opérations ioctl(2) suivantes :

Allocation ou récupération d’un périphérique boucle libre pour une utilisation. En cas de succès, le numéro du périphérique est renvoyé comme résultat de l’appel. Cette opération ne nécessite aucun argument.
Ajout du nouveau périphérique boucle dont le numéro de périphérique est spécifié comme entier « long » dans le troisième argument d’ioctl(2). En cas de succès, l’indice du périphérique est renvoyé comme résultat de l’appel. Si le périphérique est déjà alloué, l’appel échoue avec l’erreur EEXIST.
Retrait du périphérique boucle dont le numéro de périphérique est spécifié comme entier « long » dans le troisième argument d’ioctl(2). En cas de succès, le numéro du périphérique est renvoyé comme le résultat de l’appel. Si le périphérique est déjà utilisé, l’appel échoue avec l’erreur EBUSY.

FICHIERS

/dev/loop*
Les fichiers du périphérique bloc spécial de boucle.

EXEMPLES

Le programme ci-dessous utilise le périphérique /dev/loop-control pour trouver un périphérique boucle libre, ouvre le périphérique boucle, ouvre un fichier à utiliser comme stockage sous-jacent du périphérique et alors associe le périphérique boucle avec le stockage de sauvegarde. La session d’interpréteur suivante fait une démonstration de l’utilisation de ce programme :


$ dd if=/dev/zero of=fich.img bs=1MiB count=10
10+0 enregistrements in
10+0 enregistrement out
10485760 octets (10 Mio) copiés, 0.00609385 s, 1.7 Gio/s
$ sudo ./mnt_loop fich.img
nomboucle = /dev/loop5

Source du programme

#include <fcntl.h>
#include <linux/loop.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define errExit(msg)    do { perror(msg); exit(EXIT_FAILURE); \


                        } while (0)
int
main(int argc, char *argv[])
{


    int ddfloopctl, ddfloop, fichsauv;


    long n°per;


    char nomboucle[4096];


    if (argc != 2) {


        fprintf(stderr, "Usage : %s fichsauv\n", argv[0]);


        exit(EXIT_FAILURE);


    }


    ddfloopctl = open("/dev/loop-control", O_RDWR);


    if (ddfloopctl == -1)


        errExit("open: /dev/loop-control");


    n°per = ioctl(ddfloopctl, LOOP_CTL_GET_FREE);


    if (n°pr == -1)


        errExit("ioctl-LOOP_CTL_GET_FREE");


    sprintf(nomboucle, "/dev/loop%ld", n°per);


    printf("nomboucle = %s\n", nomboucle);


    loopfd = open(nomboucle, O_RDWR);


    if (ddfloop == -1)


        errExit("open: nomboucle");


    fichsauv = open(argv[1], O_RDWR);


    if (fichsauv == -1)


        errExit("open: fichsauv");


    if (ioctl(ddfloop, LOOP_SET_FD, fichsauv) == -1)


        errExit("ioctl-LOOP_SET_FD");


    exit(EXIT_SUCCESS);
}

VOIR AUSSI

losetup(8), mount(8)

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> et Jean-Paul Guillonneau <guillonneau.jeanpaul@free.fr>

Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General Public License version 3 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.

5 février 2023 Pages du manuel de Linux 6.03