LOOP(4)                    Linux Programmer's Manual                   LOOP(4)

       loop, loop-control - loop devices

       #include <linux/loop.h>

       The  loop  device  is a block device that maps its data blocks not to a
       physical device such as a hard disk or optical disk drive, but  to  the
       blocks  of  a  regular file in a filesystem or to another block device.
       This can be useful for example to provide a block device for a filesys-
       tem image stored in a file, so that it can be mounted with the mount(8)
       command.  You could do

           $ 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

       See losetup(8) for another example.

       A transfer function can be specified for each loop device  for  encryp-
       tion and decryption purposes.

       The  following  ioctl(2)  operations are provided by the loop block de-

              Associate the loop device with the open file whose file descrip-
              tor is passed as the (third) ioctl(2) argument.

              Disassociate the loop device from any file descriptor.

              Set the status of the loop device using the (third) ioctl(2) ar-
              gument.  This argument is a pointer to loop_info structure,  de-
              fined in <linux/loop.h> as:

                  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/o */
                      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];

              The   encryption   type   (lo_encrypt_type)  should  be  one  of
              LO_CRYPT_SKIPJACK, or (since Linux 2.6.0) LO_CRYPT_CRYPTOAPI.

              The lo_flags field is a bit mask that can include zero  or  more
              of the following:

                     The loopback device is read-only.

              LO_FLAGS_AUTOCLEAR (since Linux 2.6.25)
                     The loopback device will autodestruct on last close.

              LO_FLAGS_PARTSCAN (since Linux 3.2)
                     Allow automatic partition scanning.

              Get  the  status of the loop device.  The (third) ioctl(2) argu-
              ment must be a pointer to a struct loop_info.

       LOOP_CHANGE_FD (since Linux 2.6.5)
              Switch the backing store of the loop  device  to  the  new  file
              identified file descriptor specified in the (third) ioctl(2) ar-
              gument, which is an integer.  This operation is possible only if
              the  loop  device  is read-only and the new backing store is the
              same size and type as the old backing store.

       LOOP_SET_CAPACITY (since Linux 2.6.30)
              Resize a live loop device.  One can change the size of  the  un-
              derlying  backing  store and then use this operation so that the
              loop driver learns about the new size.  This operation takes  no

       LOOP_SET_DIRECT_IO (since 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  un-
              signed long value.  A non-zero represents direct I/O mode.

       LOOP_SET_BLOCK_SIZE (since Linux 4.14)
              Set the block size of the loop device.  The (third) ioctl(2) ar-
              gument is an unsigned long value.  This value must be a power of
              two  in the range [512,pagesize]; otherwise, an EINVAL error re-

       Since Linux 2.6, there are two new ioctl(2) operations:

              These are similar to  LOOP_SET_STATUS  and  LOOP_GET_STATUS  de-
              scribed  above but use the loop_info64 structure, which has some
              additional fields and a larger range for some other fields:

                  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;                    /* ioctl r/o */
                      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];

       Since Linux 3.1, the  kernel  provides  the  /dev/loop-control  device,
       which  permits an application to dynamically find a free device, and to
       add and remove loop devices from the system.  To perform  these  opera-
       tions,  one  first  opens /dev/loop-control and then employs one of the
       following ioctl(2) operations:

              Allocate or find a free loop device for use.   On  success,  the
              device number is returned as the result of the call.  This oper-
              ation takes no argument.

              Add the new loop device whose device number is  specified  as  a
              long  integer  in  the third ioctl(2) argument.  On success, the
              device index is returned as the result of the call.  If the  de-
              vice is already allocated, the call fails with the error EEXIST.

              Remove  the  loop  device  whose device number is specified as a
              long integer in the third ioctl(2) argument.   On  success,  the
              device number is returned as the result of the call.  If the de-
              vice is in use, the call fails with the error EBUSY.

              The loop block special device files.

       The program below uses the /dev/loop-control device to find a free loop
       device,  opens the loop device, opens a file to be used as the underly-
       ing storage for the device, and then associates the  loop  device  with
       the backing store.  The following shell session demonstrates the use of
       the program:

           $ 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

   Program source

       #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)

       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]);

           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)

           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)


       losetup(8), mount(8)

       This page is part of release 5.05 of the Linux  man-pages  project.   A
       description  of  the project, information about reporting bugs, and the
       latest    version    of    this    page,    can     be     found     at

Linux                             2020-02-09                           LOOP(4)
Man Pages Copyright Respective Owners. Site Copyright (C) 1994 - 2024 Hurricane Electric. All Rights Reserved.