Provided by: manpages-ru_4.21.0-2_all bug

ИМЯ

       loop, loop-control - закольцованные устройства

СИНТАКСИС

       #include <linux/loop.h>

ОПИСАНИЕ

       Закольцованное  устройство  —  это  блочное  устройство,  которое  отображает блоки данных
       обычного файла в файловой системе или другое блочное устройство. Это может  быть  полезно,
       например,  для  получения  образа  файловой  системы, хранящегося в файле, в виде блочного
       устройства, которое может быть смонтировано с помощью команды mount(8). Это можно  сделать
       так:

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

       Другой пример смотрите в losetup(8).

       Для  шифрования  и  расшифровки  каждому  закольцованному  устройству может быть назначена
       функция обмена.

       Для закольцованного блочного устройства доступны следующие операции ioctl(2):

       LOOP_SET_FD
              Связывает закольцованное устройство с  открытым  файлом,  чей  файловый  дескриптор
              передаётся в третьем аргументе ioctl(2).

       LOOP_CLR_FD
              Отвязывает закольцованное устройство от файлового дескриптора.

       LOOP_SET_STATUS
              Назначает  состояние  (передаваемое  в  третьем аргументе ioctl(2)) закольцованному
              устройству. Данный аргумент представляет собой указатель  на  структуру  loop_info,
              определённую в <linux/loop.h> следующим образом:

                  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 before
                                                       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];
                  };

              Типом  шифрования  (lo_encrypt_type)  должно  быть одно из значений: 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 или LO_CRYPT_CRYPTOAPI (начиная с
              Linux 2.6.0).

              Поле lo_flags представляет собой битовую маску,  в  которой  может  быть  ноль  или
              несколько следующих значений:

              LO_FLAGS_READ_ONLY
                     Закольцованное устройство доступно только для чтения.

              LO_FLAGS_AUTOCLEAR (начиная с Linux 2.6.25)
                     Закольцованное устройство автоматически уничтожится после закрытия.

              LO_FLAGS_PARTSCAN (начиная с Linux 3.2)
                     Разрешено автоматическое сканирования разделов.

              LO_FLAGS_DIRECT_IO (начиная с Linux 4.10)
                     Use direct I/O mode to access the backing file.

              The  only  lo_flags  that can be modified by LOOP_SET_STATUS are LO_FLAGS_AUTOCLEAR
              and LO_FLAGS_PARTSCAN.

       LOOP_GET_STATUS
              Получить состояние закольцованного устройства. В третьем аргументе ioctl(2)  должен
              быть задан указатель на структуру struct loop_info.

       LOOP_CHANGE_FD (начиная с Linux 2.6.5)
              Поменять  источник данных (backing store) закольцованного устройства на новый файл,
              определяемый  файловым  дескриптором,  указанным  в  третьем  аргументе   ioctl(2),
              представленный  целым числом. Данная операция допустима только, если закольцованное
              устройство доступно только на чтение и новый источник данных имеет тот же размер  и
              тип, использованный ранее.

       LOOP_SET_CAPACITY (начиная с Linux 2.6.30)
              Изменить  размер  используемого  (live)  закольцованного устройства. Можно изменить
              размер используемого источника данных, а затем применить  эту  операцию  для  того,
              чтобы  драйвер  закольцованных  устройств  учёл  новый  размер. У этой операции нет
              аргументов.

       LOOP_SET_DIRECT_IO (начиная с Linux 4.10)
              Set DIRECT I/O mode on the loop device, so that it can  be  used  to  open  backing
              file.   The  (third)   ioctl(2)   argument  is  an  unsigned long value.  A nonzero
              represents direct I/O mode.

       LOOP_SET_BLOCK_SIZE (начиная с Linux 4.14)
              Set the block size of the loop device.   The  (third)   ioctl(2)   argument  is  an
              unsigned   long   value.   This  value  must  be  a  power  of  two  in  the  range
              [512,pagesize]; otherwise, an EINVAL error results.

       LOOP_CONFIGURE (начиная с Linux 5.8)
              Setup and configure all loop device parameters in a single step using  the  (third)
              ioctl(2)  argument.  This argument is a pointer to a loop_config structure, defined
              in <linux/loop.h> as:

                  struct loop_config {
                      __u32               fd;
                      __u32               block_size;
                      struct loop_info64  info;
                      __u64               __reserved[8];
                  };

              In addition to doing what LOOP_SET_STATUS can do, LOOP_CONFIGURE can also  be  used
              to do the following:

              •  set the correct block size immediately by setting loop_config.block_size;

              •  explicitly   request   direct   I/O   mode   by  setting  LO_FLAGS_DIRECT_IO  in
                 loop_config.info.lo_flags; and

              •  explicitly   request   read-only   mode   by   setting   LO_FLAGS_READ_ONLY   in
                 loop_config.info.lo_flags.

       Начиная с Linux 2.6, появилось две новые операции ioctl(2):

       LOOP_SET_STATUS64, LOOP_GET_STATUS64
              Они  подобны  описанным  выше  LOOP_SET_STATUS  и  LOOP_GET_STATUS,  но  используют
              структуру loop_info64, в которой есть несколько дополнительных полей,  а  некоторым
              другим полям назначены типы с большим диапазоном значений:

                  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;  /* bytes, 0 == max available */
                      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 before
                                                       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
       Начиная  с  Linux  3.1, ядро предоставляет устройство /dev/loop-control, которое позволяет
       приложению динамически находить свободное устройство, добавлять и  удалять  закольцованные
       устройства из системы. Для выполнения этих операций сначала открывается /dev/loop-control,
       а затем выполняется одна из следующих операций ioctl(2):

       LOOP_CTL_GET_FREE
              Выделяет или ищет свободное закольцованное  устройства  для  работы.  При  успешном
              выполнении возвращается номер устройства. У операции нет аргументов.

       LOOP_CTL_ADD
              Добавляет  новое  закольцованное  устройство;  номер  устройства  передаётся в виде
              длинного целого в третьем аргументе ioctl(2). При успешном выполнении  возвращается
              индекс  устройства.  Если  устройство  уже выделено, то вызов завершается с ошибкой
              EEXIST.

       LOOP_CTL_REMOVE
              Удаляет закольцованное устройство; номер  устройства  передаётся  в  виде  длинного
              целого  в  третьем  аргументе  ioctl(2). При успешном выполнении возвращается номер
              устройства. Если устройство используется, то вызов завершается с ошибкой EBUSY.

ФАЙЛЫ

       /dev/loop*
              Специальные закольцованные файлы устройств.

ПРИМЕРЫ

       Программа, представленная  ниже,  используется  устройство  /dev/loop-control  для  поиска
       свободного  закольцованного  устройства,  открывает  закольцованное  устройство, открывает
       файл, который нужно использовать в качестве источника данных, и  связывает  закольцованное
       устройство с источником. Демонстрация работы программы:

           $ dd if=/dev/zero of=file.img bs=1MiB count=10
           10+0 records in
           10+0 records out
           10485760 bytes (10 MB) copied, 0.00609385 s, 1.7 GB/s
           $ sudo ./mnt_loop file.img
           loopname = /dev/loop5

   Исходный код программы

       #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 loopctlfd, loopfd, backingfile;
           long devnr;
           char loopname[4096];

           if (argc != 2) {
               fprintf(stderr, "Использование: %s файл-источник\n", argv[0]);
               exit(EXIT_FAILURE);
           }

           loopctlfd = open("/dev/loop-control", O_RDWR);
           if (loopctlfd == -1)
               errExit("open: /dev/loop-control");

           devnr = ioctl(loopctlfd, LOOP_CTL_GET_FREE);
           if (devnr == -1)
               errExit("ioctl-LOOP_CTL_GET_FREE");

           sprintf(loopname, "/dev/loop%ld", devnr);
           printf("loopname = %s\n", loopname);

           loopfd = open(loopname, O_RDWR);
           if (loopfd == -1)
               errExit("open: loopname");

           backingfile = open(argv[1], O_RDWR);
           if (backingfile == -1)
               errExit("open: backing-file");

           if (ioctl(loopfd, LOOP_SET_FD, backingfile) == -1)
               errExit("ioctl-LOOP_SET_FD");

           exit(EXIT_SUCCESS);
       }

СМ. ТАКЖЕ

       losetup(8), mount(8)

ПЕРЕВОД

       Русский    перевод    этой    страницы    руководства    был    сделан    Artyom    Kunyov
       <artkun@guitarplayer.ru>, Azamat Hackimov <azamat.hackimov@gmail.com>, Dmitry Bolkhovskikh
       <d20052005@yandex.ru>,  Katrin  Kutepova  <blackkatelv@gmail.com>, Konstantin Shvaykovskiy
       <kot.shv@gmail.com>, Yuri Kozlov <yuray@komyakino.ru> и Иван Павлов <pavia00@gmail.com>

       Этот  перевод  является  бесплатной  документацией;  прочитайте  Стандартную  общественную
       лицензию GNU версии 3 ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ или более позднюю, чтобы
       узнать об условиях авторского права. Мы не несем НИКАКОЙ ОТВЕТСТВЕННОСТИ.

       Если вы обнаружите ошибки в переводе  этой  страницы  руководства,  пожалуйста,  отправьте
       электронное письмо на ⟨man-pages-ru-talks@lists.sourceforge.net⟩.