Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 1 | /* vi: set sw=4 ts=4: */ |
| 2 | /* |
| 3 | * Utility routines. |
| 4 | * |
Bernhard Reutner-Fischer | 7547a6e | 2005-10-15 20:56:31 +0000 | [diff] [blame] | 5 | * Copyright (C) 1999-2004 by Erik Andersen <andersen@codepoet.org> |
Rob Landley | 5343747 | 2006-07-16 08:14:35 +0000 | [diff] [blame] | 6 | * Copyright (C) 2005 by Rob Landley <rob@landley.net> |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 7 | * |
Denys Vlasenko | 0ef64bd | 2010-08-16 20:14:46 +0200 | [diff] [blame] | 8 | * Licensed under GPLv2 or later, see file LICENSE in this source tree. |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 9 | */ |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 10 | #include "libbb.h" |
Denys Vlasenko | 9b1b62a | 2009-07-05 03:34:12 +0200 | [diff] [blame] | 11 | #include <linux/version.h> |
| 12 | |
| 13 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) |
Eric Andersen | ef8cd3b | 2004-02-06 07:16:36 +0000 | [diff] [blame] | 14 | |
Rob Landley | 6a6798b | 2005-08-10 20:35:54 +0000 | [diff] [blame] | 15 | /* For 2.6, use the cleaned up header to get the 64 bit API. */ |
Denys Vlasenko | 98f1dc1 | 2010-03-18 14:38:21 +0100 | [diff] [blame] | 16 | // Commented out per Rob's request |
| 17 | //# include "fix_u32.h" /* some old toolchains need __u64 for linux/loop.h */ |
Denys Vlasenko | 9b1b62a | 2009-07-05 03:34:12 +0200 | [diff] [blame] | 18 | # include <linux/loop.h> |
Rob Landley | 6a6798b | 2005-08-10 20:35:54 +0000 | [diff] [blame] | 19 | typedef struct loop_info64 bb_loop_info; |
Denys Vlasenko | 9b1b62a | 2009-07-05 03:34:12 +0200 | [diff] [blame] | 20 | # define BB_LOOP_SET_STATUS LOOP_SET_STATUS64 |
| 21 | # define BB_LOOP_GET_STATUS LOOP_GET_STATUS64 |
| 22 | |
| 23 | #else |
Eric Andersen | ef8cd3b | 2004-02-06 07:16:36 +0000 | [diff] [blame] | 24 | |
Rob Landley | 6a6798b | 2005-08-10 20:35:54 +0000 | [diff] [blame] | 25 | /* For 2.4 and earlier, use the 32 bit API (and don't trust the headers) */ |
Denys Vlasenko | 9b1b62a | 2009-07-05 03:34:12 +0200 | [diff] [blame] | 26 | /* Stuff stolen from linux/loop.h for 2.4 and earlier kernels */ |
| 27 | # include <linux/posix_types.h> |
| 28 | # define LO_NAME_SIZE 64 |
| 29 | # define LO_KEY_SIZE 32 |
| 30 | # define LOOP_SET_FD 0x4C00 |
| 31 | # define LOOP_CLR_FD 0x4C01 |
| 32 | # define BB_LOOP_SET_STATUS 0x4C02 |
| 33 | # define BB_LOOP_GET_STATUS 0x4C03 |
Rob Landley | 6a6798b | 2005-08-10 20:35:54 +0000 | [diff] [blame] | 34 | typedef struct { |
Eric Andersen | ef8cd3b | 2004-02-06 07:16:36 +0000 | [diff] [blame] | 35 | int lo_number; |
Rob Landley | 6a6798b | 2005-08-10 20:35:54 +0000 | [diff] [blame] | 36 | __kernel_dev_t lo_device; |
Eric Andersen | ef8cd3b | 2004-02-06 07:16:36 +0000 | [diff] [blame] | 37 | unsigned long lo_inode; |
Rob Landley | 6a6798b | 2005-08-10 20:35:54 +0000 | [diff] [blame] | 38 | __kernel_dev_t lo_rdevice; |
Eric Andersen | ef8cd3b | 2004-02-06 07:16:36 +0000 | [diff] [blame] | 39 | int lo_offset; |
| 40 | int lo_encrypt_type; |
| 41 | int lo_encrypt_key_size; |
| 42 | int lo_flags; |
Rob Landley | 6a6798b | 2005-08-10 20:35:54 +0000 | [diff] [blame] | 43 | char lo_file_name[LO_NAME_SIZE]; |
Eric Andersen | ef8cd3b | 2004-02-06 07:16:36 +0000 | [diff] [blame] | 44 | unsigned char lo_encrypt_key[LO_KEY_SIZE]; |
| 45 | unsigned long lo_init[2]; |
| 46 | char reserved[4]; |
Rob Landley | 6a6798b | 2005-08-10 20:35:54 +0000 | [diff] [blame] | 47 | } bb_loop_info; |
| 48 | #endif |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 49 | |
Denis Vlasenko | defc1ea | 2008-06-27 02:52:20 +0000 | [diff] [blame] | 50 | char* FAST_FUNC query_loop(const char *device) |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 51 | { |
Rob Landley | 1d589b2 | 2005-11-29 23:47:10 +0000 | [diff] [blame] | 52 | int fd; |
| 53 | bb_loop_info loopinfo; |
Denys Vlasenko | 44fbfa7 | 2010-03-05 13:20:28 +0100 | [diff] [blame] | 54 | char *dev = NULL; |
Tim Riker | c1ef7bd | 2006-01-25 00:08:53 +0000 | [diff] [blame] | 55 | |
Denis Vlasenko | 1385899 | 2006-10-08 12:49:22 +0000 | [diff] [blame] | 56 | fd = open(device, O_RDONLY); |
Denys Vlasenko | 44fbfa7 | 2010-03-05 13:20:28 +0100 | [diff] [blame] | 57 | if (fd >= 0) { |
| 58 | if (ioctl(fd, BB_LOOP_GET_STATUS, &loopinfo) == 0) { |
Denys Vlasenko | 9251014 | 2010-05-19 00:39:17 +0200 | [diff] [blame] | 59 | dev = xasprintf("%"OFF_FMT"u %s", (off_t) loopinfo.lo_offset, |
Denys Vlasenko | 44fbfa7 | 2010-03-05 13:20:28 +0100 | [diff] [blame] | 60 | (char *)loopinfo.lo_file_name); |
| 61 | } |
| 62 | close(fd); |
| 63 | } |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 64 | |
Rob Landley | 1d589b2 | 2005-11-29 23:47:10 +0000 | [diff] [blame] | 65 | return dev; |
Tim Riker | c1ef7bd | 2006-01-25 00:08:53 +0000 | [diff] [blame] | 66 | } |
Rob Landley | 1d589b2 | 2005-11-29 23:47:10 +0000 | [diff] [blame] | 67 | |
Denis Vlasenko | defc1ea | 2008-06-27 02:52:20 +0000 | [diff] [blame] | 68 | int FAST_FUNC del_loop(const char *device) |
Rob Landley | 1d589b2 | 2005-11-29 23:47:10 +0000 | [diff] [blame] | 69 | { |
| 70 | int fd, rc; |
| 71 | |
Denis Vlasenko | 1385899 | 2006-10-08 12:49:22 +0000 | [diff] [blame] | 72 | fd = open(device, O_RDONLY); |
Denys Vlasenko | 44fbfa7 | 2010-03-05 13:20:28 +0100 | [diff] [blame] | 73 | if (fd < 0) |
| 74 | return 1; |
Denis Vlasenko | 1385899 | 2006-10-08 12:49:22 +0000 | [diff] [blame] | 75 | rc = ioctl(fd, LOOP_CLR_FD, 0); |
Rob Landley | 1d589b2 | 2005-11-29 23:47:10 +0000 | [diff] [blame] | 76 | close(fd); |
Tim Riker | c1ef7bd | 2006-01-25 00:08:53 +0000 | [diff] [blame] | 77 | |
Rob Landley | 6a6798b | 2005-08-10 20:35:54 +0000 | [diff] [blame] | 78 | return rc; |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 79 | } |
| 80 | |
Denys Vlasenko | 3b69ba7 | 2019-06-09 23:20:49 +0200 | [diff] [blame] | 81 | /* Obtain an unused loop device number */ |
| 82 | int FAST_FUNC get_free_loop(void) |
| 83 | { |
| 84 | int fd; |
| 85 | int loopdevno; |
| 86 | |
| 87 | fd = open("/dev/loop-control", O_RDWR | O_CLOEXEC); |
| 88 | if (fd == -1) |
| 89 | return fd - 1; /* -2: "no /dev/loop-control" */ |
| 90 | |
| 91 | #ifndef LOOP_CTL_GET_FREE |
| 92 | # define LOOP_CTL_GET_FREE 0x4C82 |
| 93 | #endif |
| 94 | loopdevno = ioctl(fd, LOOP_CTL_GET_FREE); |
| 95 | close(fd); |
| 96 | return loopdevno; /* can be -1 if error */ |
| 97 | } |
| 98 | |
Denys Vlasenko | ab518ee | 2017-03-16 16:49:37 +0100 | [diff] [blame] | 99 | /* Returns opened fd to the loop device, <0 on error. |
| 100 | * *device is loop device to use, or if *device==NULL finds a loop device to |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 101 | * mount it on and sets *device to a strdup of that loop device name. |
Bernhard Reutner-Fischer | 94c3331 | 2005-10-15 14:13:09 +0000 | [diff] [blame] | 102 | */ |
Steffen Trumtrar | 6561e07 | 2020-07-29 10:43:53 +0200 | [diff] [blame] | 103 | int FAST_FUNC set_loop(char **device, const char *file, unsigned long long offset, |
| 104 | unsigned long long sizelimit, unsigned flags) |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 105 | { |
Denis Vlasenko | 0e2c9fb | 2007-08-03 14:16:24 +0000 | [diff] [blame] | 106 | char dev[LOOP_NAMESIZE]; |
| 107 | char *try; |
Rob Landley | 6a6798b | 2005-08-10 20:35:54 +0000 | [diff] [blame] | 108 | bb_loop_info loopinfo; |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 109 | struct stat statbuf; |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 110 | int i, lfd, ffd, mode, rc; |
Denis Vlasenko | 9213a9e | 2006-09-17 16:28:10 +0000 | [diff] [blame] | 111 | |
Bernhard Reutner-Fischer | 94c3331 | 2005-10-15 14:13:09 +0000 | [diff] [blame] | 112 | /* Open the file. Barf if this doesn't work. */ |
Denys Vlasenko | ab518ee | 2017-03-16 16:49:37 +0100 | [diff] [blame] | 113 | mode = (flags & BB_LO_FLAGS_READ_ONLY) ? O_RDONLY : O_RDWR; |
Denys Vlasenko | fa6ab56 | 2014-01-21 13:44:21 +0100 | [diff] [blame] | 114 | open_ffd: |
Denis Vlasenko | 1385899 | 2006-10-08 12:49:22 +0000 | [diff] [blame] | 115 | ffd = open(file, mode); |
| 116 | if (ffd < 0) { |
Denys Vlasenko | 13e709c | 2011-09-12 02:13:47 +0200 | [diff] [blame] | 117 | if (mode != O_RDONLY) { |
| 118 | mode = O_RDONLY; |
Denys Vlasenko | fa6ab56 | 2014-01-21 13:44:21 +0100 | [diff] [blame] | 119 | goto open_ffd; |
Denys Vlasenko | 13e709c | 2011-09-12 02:13:47 +0200 | [diff] [blame] | 120 | } |
Denys Vlasenko | fa6ab56 | 2014-01-21 13:44:21 +0100 | [diff] [blame] | 121 | return -errno; |
Denis Vlasenko | 1385899 | 2006-10-08 12:49:22 +0000 | [diff] [blame] | 122 | } |
Bernhard Reutner-Fischer | 94c3331 | 2005-10-15 14:13:09 +0000 | [diff] [blame] | 123 | |
Denys Vlasenko | 3b69ba7 | 2019-06-09 23:20:49 +0200 | [diff] [blame] | 124 | try = *device; |
| 125 | if (!try) { |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 126 | get_free_loopN: |
Denys Vlasenko | 3b69ba7 | 2019-06-09 23:20:49 +0200 | [diff] [blame] | 127 | i = get_free_loop(); |
Denys Vlasenko | 3b69ba7 | 2019-06-09 23:20:49 +0200 | [diff] [blame] | 128 | if (i == -1) { |
| 129 | close(ffd); |
| 130 | return -1; /* no free loop devices */ |
| 131 | } |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 132 | if (i >= 0) { |
| 133 | try = xasprintf(LOOP_FORMAT, i); |
| 134 | goto open_lfd; |
| 135 | } |
| 136 | /* i == -2: no /dev/loop-control. Do an old-style search for a free device */ |
| 137 | try = dev; |
Denys Vlasenko | 3b69ba7 | 2019-06-09 23:20:49 +0200 | [diff] [blame] | 138 | } |
| 139 | |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 140 | /* Find a loop device */ |
| 141 | /* 0xfffff is a max possible minor number in Linux circa 2010 */ |
| 142 | for (i = 0; i <= 0xfffff; i++) { |
Rob Landley | b70ccd9 | 2006-01-22 23:17:18 +0000 | [diff] [blame] | 143 | sprintf(dev, LOOP_FORMAT, i); |
Rob Landley | aae8b34 | 2006-03-18 02:38:10 +0000 | [diff] [blame] | 144 | |
Lauri Kasanen | 375a8ef | 2010-04-14 12:31:26 -0700 | [diff] [blame] | 145 | IF_FEATURE_MOUNT_LOOP_CREATE(errno = 0;) |
Denys Vlasenko | 44fbfa7 | 2010-03-05 13:20:28 +0100 | [diff] [blame] | 146 | if (stat(try, &statbuf) != 0 || !S_ISBLK(statbuf.st_mode)) { |
Lauri Kasanen | 375a8ef | 2010-04-14 12:31:26 -0700 | [diff] [blame] | 147 | if (ENABLE_FEATURE_MOUNT_LOOP_CREATE |
| 148 | && errno == ENOENT |
| 149 | && try == dev |
| 150 | ) { |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 151 | /* Node doesn't exist, try to create it */ |
Lauri Kasanen | 375a8ef | 2010-04-14 12:31:26 -0700 | [diff] [blame] | 152 | if (mknod(dev, S_IFBLK|0644, makedev(7, i)) == 0) |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 153 | goto open_lfd; |
Lauri Kasanen | 375a8ef | 2010-04-14 12:31:26 -0700 | [diff] [blame] | 154 | } |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 155 | /* Ran out of block devices, return failure */ |
Denys Vlasenko | fa6ab56 | 2014-01-21 13:44:21 +0100 | [diff] [blame] | 156 | rc = -1; |
Rob Landley | 6a6798b | 2005-08-10 20:35:54 +0000 | [diff] [blame] | 157 | break; |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 158 | } |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 159 | open_lfd: |
| 160 | /* Open the sucker and check its loopiness */ |
| 161 | lfd = rc = open(try, mode); |
| 162 | if (lfd < 0 && errno == EROFS) { |
Denis Vlasenko | 1385899 | 2006-10-08 12:49:22 +0000 | [diff] [blame] | 163 | mode = O_RDONLY; |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 164 | lfd = rc = open(try, mode); |
Denis Vlasenko | 1385899 | 2006-10-08 12:49:22 +0000 | [diff] [blame] | 165 | } |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 166 | if (lfd < 0) { |
Denys Vlasenko | fa6ab56 | 2014-01-21 13:44:21 +0100 | [diff] [blame] | 167 | if (errno == ENXIO) { |
| 168 | /* Happens if loop module is not loaded */ |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 169 | /* rc is -1; */ |
Denys Vlasenko | fa6ab56 | 2014-01-21 13:44:21 +0100 | [diff] [blame] | 170 | break; |
| 171 | } |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 172 | goto try_next_loopN; |
Denys Vlasenko | fa6ab56 | 2014-01-21 13:44:21 +0100 | [diff] [blame] | 173 | } |
Eric Andersen | aad1a88 | 2001-03-16 22:47:14 +0000 | [diff] [blame] | 174 | |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 175 | rc = ioctl(lfd, BB_LOOP_GET_STATUS, &loopinfo); |
Rob Landley | 1d589b2 | 2005-11-29 23:47:10 +0000 | [diff] [blame] | 176 | |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 177 | /* If device is free, try to claim it */ |
Denis Vlasenko | 1385899 | 2006-10-08 12:49:22 +0000 | [diff] [blame] | 178 | if (rc && errno == ENXIO) { |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 179 | /* Associate free loop device with file */ |
| 180 | if (ioctl(lfd, LOOP_SET_FD, ffd)) { |
| 181 | /* Ouch. Are we racing with other mount? */ |
| 182 | if (!*device /* yes */ |
| 183 | && try != dev /* tried a _kernel-offered_ loopN? */ |
| 184 | ) { |
| 185 | free(try); |
| 186 | close(lfd); |
| 187 | //TODO: add "if (--failcount != 0) ..."? |
| 188 | goto get_free_loopN; |
Denys Vlasenko | ab518ee | 2017-03-16 16:49:37 +0100 | [diff] [blame] | 189 | } |
Denys Vlasenko | 15733cb | 2020-12-17 23:38:06 +0100 | [diff] [blame] | 190 | goto close_and_try_next_loopN; |
Rob Landley | 934da82 | 2006-06-25 15:29:12 +0000 | [diff] [blame] | 191 | } |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 192 | memset(&loopinfo, 0, sizeof(loopinfo)); |
| 193 | safe_strncpy((char *)loopinfo.lo_file_name, file, LO_NAME_SIZE); |
| 194 | loopinfo.lo_offset = offset; |
| 195 | loopinfo.lo_sizelimit = sizelimit; |
| 196 | /* |
| 197 | * Used by mount to set LO_FLAGS_AUTOCLEAR. |
| 198 | * LO_FLAGS_READ_ONLY is not set because RO is controlled by open type of the file. |
| 199 | * Note that closing LO_FLAGS_AUTOCLEARed lfd before mount |
| 200 | * is wrong (would free the loop device!) |
| 201 | */ |
| 202 | loopinfo.lo_flags = (flags & ~BB_LO_FLAGS_READ_ONLY); |
| 203 | rc = ioctl(lfd, BB_LOOP_SET_STATUS, &loopinfo); |
| 204 | if (rc != 0 && (loopinfo.lo_flags & BB_LO_FLAGS_AUTOCLEAR)) { |
| 205 | /* Old kernel, does not support LO_FLAGS_AUTOCLEAR? */ |
| 206 | /* (this code path is not tested) */ |
| 207 | loopinfo.lo_flags -= BB_LO_FLAGS_AUTOCLEAR; |
| 208 | rc = ioctl(lfd, BB_LOOP_SET_STATUS, &loopinfo); |
| 209 | } |
| 210 | if (rc == 0) { |
| 211 | /* SUCCESS! */ |
| 212 | if (try != dev) /* tried a kernel-offered free loopN? */ |
| 213 | *device = try; /* malloced */ |
| 214 | if (!*device) /* was looping in search of free "/dev/loopN"? */ |
| 215 | *device = xstrdup(dev); |
| 216 | rc = lfd; /* return this */ |
| 217 | break; |
| 218 | } |
| 219 | /* failure, undo LOOP_SET_FD */ |
| 220 | ioctl(lfd, LOOP_CLR_FD, 0); // actually, 0 param is unnecessary |
Denis Vlasenko | 7039a66 | 2006-10-08 17:54:47 +0000 | [diff] [blame] | 221 | } |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 222 | /* else: device is not free (rc == 0) or error other than ENXIO */ |
Denys Vlasenko | 15733cb | 2020-12-17 23:38:06 +0100 | [diff] [blame] | 223 | close_and_try_next_loopN: |
Denys Vlasenko | 4bc59a4 | 2020-12-17 15:05:14 +0100 | [diff] [blame] | 224 | close(lfd); |
| 225 | try_next_loopN: |
| 226 | rc = -1; |
| 227 | if (*device) /* was looking for a particular "/dev/loopN"? */ |
| 228 | break; /* yes, do not try other names */ |
| 229 | } /* for() */ |
| 230 | |
Rob Landley | 6a6798b | 2005-08-10 20:35:54 +0000 | [diff] [blame] | 231 | close(ffd); |
Denis Vlasenko | 1385899 | 2006-10-08 12:49:22 +0000 | [diff] [blame] | 232 | return rc; |
Rob Landley | 6a6798b | 2005-08-10 20:35:54 +0000 | [diff] [blame] | 233 | } |