Provided by: manpages-ru_4.27.0-1_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, "Usage: %s backing-file\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> и Kirill Rekhov <krekhov.dev@gmail.com>

       Этот перевод является свободной программной документацией; он распространяется на условиях  общедоступной
       лицензии  GNU  (GNU  General Public License - GPL, https://www.gnu.org/licenses/gpl-3.0.html версии 3 или
       более поздней) в отношении авторского права, но БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ.

       Если вы обнаружите какие-либо ошибки в переводе этой страницы руководства, пожалуйста, сообщите  об  этом
       разработчику(ам)   по   его(их)  адресу(ам)  электронной  почты  или  по  адресу  списка рассылки русских
       переводчиков.

Справочные страницы Linux 6.9.1                  15 июня 2024 г.                                         loop(4)