loop(4)

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_STATUS są LO_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 <err.h>
    #include <fcntl.h>
    #include <linux/loop.h>
    #include <sys/ioctl.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <unistd.h>

    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)
            err(EXIT_FAILURE, "open: /dev/loop-control");

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

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

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

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

        if (ioctl(loopfd, LOOP_SET_FD, backingfile) == -1)
            err(EXIT_FAILURE, "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 (https://www.gnu.org/licenses/gpl-3.0.html) 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.