Provided by: manpages-fr_4.21.0-2_all 
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 :
LOOP_SET_FD
Associer le périphérique boucle avec le fichier ouvert dont le descripteur de
fichier est passé comme (troisième) argument d’ioctl(2).
LOOP_CLR_FD
Dissocier le périphérique boucle de n’importe quel descripteur de fichier.
LOOP_SET_STATUS
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 :
LO_FLAGS_READ_ONLY
Le périphérique boucle est en lecture seule.
LO_FLAGS_AUTOCLEAR (depuis Linux 2.6.25)
Le périphérique boucle s’autodétruira lors de la dernière fermeture.
LO_FLAGS_PARTSCAN (depuis Linux 3.2)
Permission de l’analyse automatique des partitions.
LO_FLAGS_DIRECT_IO (depuis Linux 4.10)
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.
LOOP_GET_STATUS
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.
LOOP_CHANGE_FD (depuis Linux 2.6.5)
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.
LOOP_SET_CAPACITY (depuis Linux 2.6.30)
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.
LOOP_SET_DIRECT_IO (depuis Linux 4.10)
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.
LOOP_SET_BLOCK_SIZE (depuis Linux 4.14)
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.
LOOP_CONFIGURE (depuis Linux 5.8)
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 :
LOOP_SET_STATUS64, LOOP_GET_STATUS64
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 :
LOOP_CTL_GET_FREE
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.
LOOP_CTL_ADD
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.
LOOP_CTL_REMOVE
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 ⟨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⟩.