Provided by: manpages-pl_4.27.0-1_all bug

NAZWA

       loop, loop-control - urządzenia pętli

SKŁADNIA

       #include <linux/loop.h>

OPIS

       Urządzenie  pętli  jest  urządzeniem  blokowym,  które  przypisuje  swoje  bloki danych nie do urządzenia
       fizycznego, takiego jak dysk twardy lub napęd dysku optycznego, lecz do bloków zwykłego pliku w  systemie
       plików  lub  do  innego  urządzenia  blokowego. Może być to przydatne np. w celu udostępnienia urządzenia
       blokowego dla obrazu systemu plików przechowywanego w pliku, dzięki czemu można go zamontować  poleceniem
       mount(8). Można wykonać:

           $ dd if=/dev/zero of=obraz.img bs=1MiB count=10
           $ sudo losetup /dev/loop4 plik.img
           $ sudo mkfs -t ext4 /dev/loop4
           $ sudo mkdir /moje-urzadzenie-loop
           $ sudo mount /dev/loop4 /moje-urzadzenie-loop

       Inny przykład opisano w podręczniku losetup(8).

       Dla każdego urządzenia pętli można określić funkcję transferu, służącą do szyfrowania i odszyfrowywania.

       Urządzenie blokowe pętli udostępnia następujące operacje ioctl(2):

       LOOP_SET_FD
              Przypisuje  urządzenie pętli do otwartego pliku, którego deskryptor pliku podaje się jako (trzeci)
              argument ioctl(2).

       LOOP_CLR_FD
              Usuwa przypisanie urządzenia pętli ze wszystkimi deskryptorami plików.

       LOOP_SET_STATUS
              Ustawia stan urządzenia  pętli  za  pomocą  (trzeciego)  argumentu  ioctl(2).  Argument  ten  jest
              wskaźnikiem do struktury loop_info, zdefiniowanej w <linux/loop.h> jako:

                  struct loop_info {
                      int           lo_number;      /* ioctl tylko do odczytu */
                      dev_t         lo_device;      /* ioctl tylko do odczytu */
                      unsigned long lo_inode;       /* ioctl tylko do odczytu */
                      dev_t         lo_rdevice;     /* ioctl tylko do odczytu */
                      int           lo_offset;
                      int           lo_encrypt_type;
                      int           lo_encrypt_key_size;  /* ioctl do zapisu i odczytu */
                      int           lo_flags;       /* ioctl do zapisu i odczytu (tylko
                                                       do odczytu przed Linuksem 2.6.25) */
                      char          lo_name[LO_NAME_SIZE];
                      unsigned char lo_encrypt_key[LO_KEY_SIZE];
                                                    /* ioctl tylko do zapisu */
                      unsigned long lo_init[2];
                      char          reserved[4];
                  };

              Typem   szyfrowania   (lo_encrypt_type)   powinien   być  jeden  z:  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 lub (od Linuksa 2.6.0) LO_CRYPT_CRYPTOAPI.

              Pole lo_flags jest maską bitową mogącą zawierać zero lub więcej z poniższych znaczników:

              LO_FLAGS_READ_ONLY
                     Urządzenie pętli zwrotnej jest tylko do odczytu.

              LO_FLAGS_AUTOCLEAR (od Linuksa 2.6.25)
                     Urządzenie pętli zwrotnej zostanie automatycznie zniszczone po ostatnim zamknięciu.

              LO_FLAGS_PARTSCAN (od Linuksa 3.2)
                     Zezwala na automatyczne skanowanie partycji.

              LO_FLAGS_DIRECT_IO (od Linuksa 4.10)
                     Używa  bezpośredniego  wejścia/wyjścia  przy  dostępie  do  pliku,  do którego odwołuje się
                     urządzenie.

              Jedynymi lo_flags, które mogą być zmodyfikowane  przez  LOOP_SET_STATUSLO_FLAGS_AUTOCLEAR  i
              LO_FLAGS_PARTSCAN.

       LOOP_GET_STATUS
              Pobiera  stan  urządzenia  pętli.  (Trzecim)  argumentem  ioctl(2)  musi  być  wskaźnik  do struct
              loop_info.

       LOOP_CHANGE_FD (od Linuksa 2.6.5)
              Przełącza  magazyn  danych,  do  którego  odwołuje  się  urządzenie  pętli,   do   nowego   pliku,
              identyfikowanego  deskryptorem pliku określonym w (trzecim) argumencie ioctl(2), który jest liczbą
              typu integer. Operacja ta jest dopuszczalna tylko  wtedy,  gdy  urządzenie  pętli  jest  tylko  do
              odczytu, a nowy magazyn danych ma ten sam rozmiar i typ, co dotychczasowy.

       LOOP_SET_CAPACITY (od Linuksa 2.6.30)
              Zmienia  rozmiar  działającego urządzenia pętli. Można zmienić rozmiar magazynu danych, do którego
              odwołuje się urządzenie pętli, a następnie skorzystać z  tej  operacji,  dzięki  której  sterownik
              pętli dowie się o nowym rozmiarze. Ta operacja nie przyjmuje argumentów.

       LOOP_SET_DIRECT_IO (od Linuksa 4.10)
              Ustawia  tryb  DIRECT  I/O  (bezpośredniego  wejścia/wyjścia)  na  urządzeniu  pętli, dzięki czemu
              zostanie on użyty w stosunku do pliku, do którego odwołuje się urządzenie pętli. (Trzeci) argument
              ioctl(2) jest wartością typu long bez  znaku.  Wartość  niezerowa  reprezentuje  bezpośredni  tryb
              wejścia/wyjścia.

       LOOP_SET_BLOCK_SIZE (od Linuksa 4.14)
              Ustawia  rozmiar  bloku  urządzenia pętli. (Trzeci) argument ioctl(2) jest wartością typu long bez
              znaku. Wartość ta musi być potęgą dwójki w  przedziale  [512,rozmiar-strony];  w  innym  przypadku
              wystąpi błąd EINVAL.

       LOOP_CONFIGURE (od Linuksa 5.8)
              Ustawia  i  konfiguruje  wszystkie  parametry  urządzenia  pętli  w  pojedynczym  kroku, za pomocą
              (trzeciego)  argumentu  ioctl(2).  Argument  ten  jest  wskaźnikiem  do   struktury   loop_config,
              zdefiniowanej w <linux/loop.h> jako:

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

              Oprócz  dokonania  tego,  co  można  zrobić  za  pomocą LOOP_SET_STATUS, LOOP_CONFIGURE można użyć
              dodatkowo do:

              •  ustawienia prawidłowego rozmiaru bloku, bezpośredniego po ustawieniu loop_config.block_size;

              •  jawnego  zażądania  trybu  bezpośredniego  wejścia/wyjścia,  ustawiając  LO_FLAGS_DIRECT_IO   w
                 loop_config.info.lo_flags; oraz

              •  jawnego    zażądania    trybu    tylko    do    odczytu,    ustawiając   LO_FLAGS_READ_ONLY   w
                 loop_config.info.lo_flags.

       Od Linuksa 2.6, istnieją dwie nowe operacje ioctl(2):

       LOOP_SET_STATUS64
       LOOP_GET_STATUS64
              Są podobne do opisanych wyżej LOOP_SET_STATUS i  LOOP_GET_STATUS,  lecz  korzystają  ze  struktury
              loop_info64, która ma pewne dodatkowe pola i większy zakres niektórych innych pól:

                  struct loop_info64 {
                      uint64_t lo_device;           /* ioctl tylko do odczytu */
                      uint64_t lo_inode;            /* ioctl tylko do odczytu */
                      uint64_t lo_rdevice;          /* ioctl tylko do odczytu */
                      uint64_t lo_offset;
                      uint64_t lo_sizelimit;  /* bajtów, 0 == możliwie najwięcej */
                      uint32_t lo_number;           /* ioctl tylko do odczytu */
                      uint32_t lo_encrypt_type;
                      uint32_t lo_encrypt_key_size; /* ioctl tylko do zapisu */
                      uint32_t lo_flags; i          /* ioctl do odczytu i zapisu (tylko
                                                       do odczytu przed Linuksem 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 tylko do zapisu */
                      uint64_t lo_init[2];
                  };

   /dev/loop-control
       Od  Linuksa  3.1,  jądro  udostępnia urządzenie /dev/loop-control, które pozwala aplikacjom na dynamiczne
       odnalezienie wolnego urządzenia oraz na dodawanie i usuwanie urządzeń pętli z systemu. Do przeprowadzenia
       tych operacji, najpierw otwiera się  /dev/loop-control,  a  następnie  korzysta  z  jednej  z  poniższych
       operacji ioctl(2):

       LOOP_CTL_GET_FREE
              Przydziela  lub  odnajduje  wolne  urządzenie  pętli do wykorzystania. Przy powodzeniu, jako wynik
              wywołania zwracany jest numer urządzenia. Ta operacja nie przyjmuje argumentów.

       LOOP_CTL_ADD
              Dodaje nowe urządzenie pętli, którego numer  podano  jako  liczba  typu  long  integer  w  trzecim
              argumencie  ioctl(2). Przy powodzeniu, jako wynik wywołania zwracany jest indeks urządzenia. Jeśli
              urządzenie zostało już przydzielone, wywołanie zawodzi z błędem EEXIST.

       LOOP_CTL_REMOVE
              Usuwa urządzenie pętli, którego numer podano jako liczba typu long integer  w  trzecim  argumencie
              ioctl(2).  Przy  powodzeniu, jako wynik wywołania zwracany jest numer urządzenia. Jeśli urządzenie
              jest w użyciu, wywołanie zawodzi z błędem EBUSY.

PLIKI

       /dev/loop*
              Specjalne pliki urządzeń blokowych pętli.

PRZYKŁADY

       Poniższy program korzysta z  urządzenia  /dev/loop-control  do  odnalezienia  wolnego  urządzenia  pętli,
       otwiera  urządzenie  pętli, otwiera plik przeznaczony do użycia przez urządzenie pętli, a następnie wiąże
       urządzenie pętli z tym plikiem. Poniższa sesja powłoki demonstruje użycie programu:

           $ dd if=/dev/zero of=plik.img bs=1MiB count=10
           10+0 przeczytanych rekordów
           10+0 zapisanych rekordów
           10485760 bajtów (10 MB) skopiowano, 0.00609385 s, 1.7 GB/s
           $ sudo ./mnt_loop obraz.img
           loopname = /dev/loop5

   Kod źródłowy programu

       #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, "Użycie: %s plik-dla-pętli\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);
       }

ZOBACZ TAKŻE

       losetup(8), mount(8)

TŁUMACZENIE

       Tłumaczenie niniejszej strony podręcznika: Michał Kułach <michal.kulach@gmail.com>

       Niniejsze tłumaczenie jest wolną dokumentacją. Bliższe informacje  o  warunkach  licencji  można  uzyskać
       zapoznając   się   z   GNU General Public License w wersji 3   lub  nowszej.  Nie  przyjmuje  się  ŻADNEJ
       ODPOWIEDZIALNOŚCI.

       Błędy w  tłumaczeniu  strony  podręcznika  prosimy  zgłaszać  na  adres  listy  dyskusyjnej  manpages-pl-
       list@lists.sourceforge.net.

Linux man-pages 6.9.1                          15 czerwca 2024 r.                                        loop(4)