Provided by: manpages-fr_4.27.0-1_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, "Utilisation : %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.
Pages du manuel de Linux 6.9.1 15 juin 2024 loop(4)