libbb/loop.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Utility routines.
   4  *
   5  * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org>
   6  * Copyright (C) 2005 by Rob Landley <rob@landley.net>
   7  *
   8  * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
   9  */
  10 #include "libbb.h"
  11 #include <linux/version.h>
  12
  13 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0)
  14
  15 /* For 2.6, use the cleaned up header to get the 64 bit API. */
  16 /* linux/loop.h relies on __u64. Make sure we have that as a proper type
  17  * until userspace is widely fixed. */
  18 # if (defined __INTEL_COMPILER && !defined __GNUC__) \
  19   || (defined __GNUC__ && defined __STRICT_ANSI__)
  20 __extension__ typedef long long __s64;
  21 __extension__ typedef unsigned long long __u64;
  22 # endif
  23 # include <linux/loop.h>
  24 typedef struct loop_info64 bb_loop_info;
  25 # define BB_LOOP_SET_STATUS LOOP_SET_STATUS64
  26 # define BB_LOOP_GET_STATUS LOOP_GET_STATUS64
  27
  28 #else
  29
  30 /* For 2.4 and earlier, use the 32 bit API (and don't trust the headers) */
  31 /* Stuff stolen from linux/loop.h for 2.4 and earlier kernels */
  32 # include <linux/posix_types.h>
  33 # define LO_NAME_SIZE        64
  34 # define LO_KEY_SIZE         32
  35 # define LOOP_SET_FD         0x4C00
  36 # define LOOP_CLR_FD         0x4C01
  37 # define BB_LOOP_SET_STATUS  0x4C02
  38 # define BB_LOOP_GET_STATUS  0x4C03
  39 typedef struct {
  40         int                lo_number;
  41         __kernel_dev_t     lo_device;
  42         unsigned long      lo_inode;
  43         __kernel_dev_t     lo_rdevice;
  44         int                lo_offset;
  45         int                lo_encrypt_type;
  46         int                lo_encrypt_key_size;
  47         int                lo_flags;
  48         char               lo_file_name[LO_NAME_SIZE];
  49         unsigned char      lo_encrypt_key[LO_KEY_SIZE];
  50         unsigned long      lo_init[2];
  51         char               reserved[4];
  52 } bb_loop_info;
  53 #endif
  54
  55 char* FAST_FUNC query_loop(const char *device)
  56 {
  57         int fd;
  58         bb_loop_info loopinfo;
  59         char *dev = 0;
  60
  61         fd = open(device, O_RDONLY);
  62         if (fd < 0) return 0;
  63         if (!ioctl(fd, BB_LOOP_GET_STATUS, &loopinfo))
  64                 dev = xasprintf("%ld %s", (long) loopinfo.lo_offset,
  65                                 (char *)loopinfo.lo_file_name);
  66         close(fd);
  67
  68         return dev;
  69 }
  70
  71 int FAST_FUNC del_loop(const char *device)
  72 {
  73         int fd, rc;
  74
  75         fd = open(device, O_RDONLY);
  76         if (fd < 0) return 1;
  77         rc = ioctl(fd, LOOP_CLR_FD, 0);
  78         close(fd);
  79
  80         return rc;
  81 }
  82
  83 /* Returns 0 if mounted RW, 1 if mounted read-only, <0 for error.
  84    *device is loop device to use, or if *device==NULL finds a loop device to
  85    mount it on and sets *device to a strdup of that loop device name.  This
  86    search will re-use an existing loop device already bound to that
  87    file/offset if it finds one.
  88  */
  89 int FAST_FUNC set_loop(char **device, const char *file, unsigned long long offset)
  90 {
  91         char dev[LOOP_NAMESIZE];
  92         char *try;
  93         bb_loop_info loopinfo;
  94         struct stat statbuf;
  95         int i, dfd, ffd, mode, rc = -1;
  96
  97         /* Open the file.  Barf if this doesn't work.  */
  98         mode = O_RDWR;
  99         ffd = open(file, mode);
 100         if (ffd < 0) {
 101                 mode = O_RDONLY;
 102                 ffd = open(file, mode);
 103                 if (ffd < 0)
 104                         return -errno;
 105         }
 106
 107         /* Find a loop device.  */
 108         try = *device ? *device : dev;
 109         for (i = 0; rc; i++) {
 110                 sprintf(dev, LOOP_FORMAT, i);
 111
 112                 /* Ran out of block devices, return failure.  */
 113                 if (stat(try, &statbuf) || !S_ISBLK(statbuf.st_mode)) {
 114                         rc = -ENOENT;
 115                         break;
 116                 }
 117                 /* Open the sucker and check its loopiness.  */
 118                 dfd = open(try, mode);
 119                 if (dfd < 0 && errno == EROFS) {
 120                         mode = O_RDONLY;
 121                         dfd = open(try, mode);
 122                 }
 123                 if (dfd < 0)
 124                         goto try_again;
 125
 126                 rc = ioctl(dfd, BB_LOOP_GET_STATUS, &loopinfo);
 127
 128                 /* If device is free, claim it.  */
 129                 if (rc && errno == ENXIO) {
 130                         memset(&loopinfo, 0, sizeof(loopinfo));
 131                         safe_strncpy((char *)loopinfo.lo_file_name, file, LO_NAME_SIZE);
 132                         loopinfo.lo_offset = offset;
 133                         /* Associate free loop device with file.  */
 134                         if (!ioctl(dfd, LOOP_SET_FD, ffd)) {
 135                                 if (!ioctl(dfd, BB_LOOP_SET_STATUS, &loopinfo))
 136                                         rc = 0;
 137                                 else
 138                                         ioctl(dfd, LOOP_CLR_FD, 0);
 139                         }
 140
 141                 /* If this block device already set up right, re-use it.
 142                    (Yes this is racy, but associating two loop devices with the same
 143                    file isn't pretty either.  In general, mounting the same file twice
 144                    without using losetup manually is problematic.)
 145                  */
 146                 } else if (strcmp(file, (char *)loopinfo.lo_file_name) != 0
 147                 || offset != loopinfo.lo_offset) {
 148                         rc = -1;
 149                 }
 150                 close(dfd);
 151  try_again:
 152                 if (*device) break;
 153         }
 154         close(ffd);
 155         if (!rc) {
 156                 if (!*device)
 157                         *device = xstrdup(dev);
 158                 return (mode == O_RDONLY); /* 1:ro, 0:rw */
 159         }
 160         return rc;
 161 }