loop(4) Device Drivers Manual loop(4) NOM loop, loop-control -- Peripheriques boucle SYNOPSIS #include DESCRIPTION Un peripherique boucle est un peripherique bloc qui mappe ses blocs de donnees non sur un peripherique physique tel qu'un disque dur ou un support optique, mais sur les blocs d'un fichier normal dans un systeme de fichiers ou sur ceux d'un autre peripherique bloc. Cela peut etre utile pour fournir un peripherique bloc pour un stockage d'image de systeme de fichiers, de facon a 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 etre specifiee pour chaque peripherique boucle dans un but de chiffrement et de dechiffrement. Les operations ioctl(2) suivantes sont fournies par le peripherique boucle : LOOP_SET_FD Associer le peripherique boucle avec le fichier ouvert dont le descripteur de fichier est passe comme (troisieme) argument d'ioctl(2). LOOP_CLR_FD Dissocier le peripherique boucle de n'importe quel descripteur de fichier. LOOP_SET_STATUS Regler l'etat du peripherique boucle en utilisant le (troisieme) argument d'ioctl(2). Cet argument est un pointeur vers une structure loop_info, definie dans 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 etre 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 zero ou plus des drapeaux suivants : LO_FLAGS_READ_ONLY Le peripherique boucle est en lecture seule. LO_FLAGS_AUTOCLEAR (depuis Linux 2.6.25) Le peripherique boucle s'autodetruira lors de la derniere 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 acceder au fichier de sauvegarde. Les seuls lo_flags pouvant etre modifies par LOOP_SET_STATUS sont LO_FLAGS_AUTOCLEAR et LO_FLAGS_PARTSCAN. LOOP_GET_STATUS Obtention de l'etat du peripherique boucle ; le (troisieme) argument d'ioctl(2) doit etre un pointeur vers une struct loop_info. LOOP_CHANGE_FD (depuis Linux 2.6.5) Basculement du stockage de sauvegarde du peripherique boucle vers le nouveau fichier identifie par le descripteur de fichier specifie dans le (troisieme) argument d'ioctl(2), qui est un entier. Cette operation est possible si le peripherique boucle est en lecture seule et que le nouveau stockage de sauvegarde est de la meme taille et du meme type que l'ancien stockage de sauvegarde. LOOP_SET_CAPACITY (depuis Linux 2.6.30) Redimensionnement d'un peripherique boucle actif. Il est possible de changer la taille du stockage de sauvegarde sous-jacent et puis d'utiliser cette operation de facon que le pilote de boucle connaisse la nouvelle taille. Cette operation ne prend pas d'argument. LOOP_SET_DIRECT_IO (depuis Linux 4.10) Regler le mode E/S direct sur le peripherique boucle, de facon a ce qu'il puisse etre utilise pour ouvrir un fichier de sauvegarde. Le (troisieme) argument d'ioctl(2) est une valeur << unsigned long >>. Une valeur differente de zero represente le mode E/S direct. LOOP_SET_BLOCK_SIZE (depuis Linux 4.14) Regler la taille de bloc de peripherique boucle. Le (troisieme) argument d'ioctl(2) est une valeur << unsigned long >>. Cette valeur doit etre une puissance de deux dans l'intervalle [512,taille_page], sinon une erreur EINVAL en resultera. LOOP_CONFIGURE (depuis Linux 5.8) Regler et configurer tous les parametres du peripherique boucle en une seule etape en utilisant le (troisieme) argument d'ioctl(2). Cet argument est un pointeur vers une structure loop_config, definie dans 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 etre utilise pour faire les choses suivantes : - regler la taille correcte de bloc immediatement en reglant loop_config.block_size ; - requerir explicitement le mode E/S direct en reglant LO_FLAGS_DIRECT_IO dans loop_config.info.lo_flags ; - requerir explicitement le mode lecture seule en reglant LO_FLAGS_READ_ONLY dans loop_config.info.lo_flags. Depuis Linux 2.6, deux nouvelles operations ioctl(2) existent : LOOP_SET_STATUS64 LOOP_GET_STATUS64 Elles sont similaires a LOOP_SET_STATUS et LOOP_GET_STATUS decrites ci-dessus, mais utilisent la structure loop_info64 qui a quelques champs supplementaires 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 peripherique /dev/loop-control qui permet a une application de trouver de maniere dynamique un peripherique libre et d'ajouter ou de retirer des peripheriques boucle du systeme. Pour realiser ces operations, l'utilisateur doit d'abord ouvrir /dev/loop-control, puis employer une des operations ioctl(2) suivantes : LOOP_CTL_GET_FREE Allocation ou recuperation d'un peripherique boucle libre pour une utilisation. En cas de succes, le numero du peripherique est renvoye comme resultat de l'appel. Cette operation ne necessite aucun argument. LOOP_CTL_ADD Ajout du nouveau peripherique boucle dont le numero de peripherique est specifie comme entier << long >> dans le troisieme argument d'ioctl(2). En cas de succes, l'indice du peripherique est renvoye comme resultat de l'appel. Si le peripherique est deja alloue, l'appel echoue avec l'erreur EEXIST. LOOP_CTL_REMOVE Retrait du peripherique boucle dont le numero de peripherique est specifie comme entier << long >> dans le troisieme argument d'ioctl(2). En cas de succes, le numero du peripherique est renvoye comme le resultat de l'appel. Si le peripherique est deja utilise, l'appel echoue avec l'erreur EBUSY. FICHIERS /dev/loop* Les fichiers du peripherique bloc special de boucle. EXEMPLES Le programme ci-dessous utilise le peripherique /dev/loop-control pour trouver un peripherique boucle libre, ouvre le peripherique boucle, ouvre un fichier a utiliser comme stockage sous-jacent du peripherique et alors associe le peripherique boucle avec le stockage de sauvegarde. La session d'interpreteur suivante fait une demonstration 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) copies, 0.00609385 s, 1.7 Gio/s $ sudo ./mnt_loop fich.img nomboucle = /dev/loop5 Source du programme #include #include #include #include #include #include #define errExit(msg) do { perror(msg); exit(EXIT_FAILURE); \ } while (0) int main(int argc, char *argv[]) { int ddfloopctl, ddfloop, fichsauv; long nper; 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"); nper = ioctl(ddfloopctl, LOOP_CTL_GET_FREE); if (npr == -1) errExit("ioctl-LOOP_CTL_GET_FREE"); sprintf(nomboucle, "/dev/loop%ld", nper); 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 francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot et Jean-Paul Guillonneau Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.12 15 juin 2024 loop(4)