kpartx/lopart.c

   1 /* Taken from Ted's losetup.c - Mitch <m.dsouza@mrc-apu.cam.ac.uk> */
   2 /* Added vfs mount options - aeb - 960223 */
   3 /* Removed lomount - aeb - 960224 */
   4
   5 /* 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
   6  * - added Native Language Support
   7  * Sun Mar 21 1999 - Arnaldo Carvalho de Melo <acme@conectiva.com.br>
   8  * - fixed strerr(errno) in gettext calls
   9  */
  10
  11 #define PROC_DEVICES    "/proc/devices"
  12
  13 /*
  14  * losetup.c - setup and control loop devices
  15  */
  16
  17 #include "kpartx.h"
  18 #include <stdio.h>
  19 #include <string.h>
  20 #include <ctype.h>
  21 #include <fcntl.h>
  22 #include <errno.h>
  23 #include <stdlib.h>
  24 #include <stdint.h>
  25 #include <unistd.h>
  26 #include <sys/ioctl.h>
  27 #include <sys/stat.h>
  28 #include <sys/mman.h>
  29 #include <sys/types.h>
  30 #include <dirent.h>
  31 #include <sys/sysmacros.h>
  32 #include <linux/loop.h>
  33 #include <limits.h>
  34
  35 #include "lopart.h"
  36 #include "xstrncpy.h"
  37
  38 #ifndef LOOP_CTL_GET_FREE
  39 #define LOOP_CTL_GET_FREE       0x4C82
  40 #endif
  41
  42 static char *
  43 xstrdup (const char *s)
  44 {
  45         char *t;
  46
  47         if (s == NULL)
  48                 return NULL;
  49
  50         t = strdup (s);
  51
  52         if (t == NULL) {
  53                 fprintf(stderr, "not enough memory");
  54                 exit(1);
  55         }
  56
  57         return t;
  58 }
  59
  60 #define SIZE(a) (sizeof(a)/sizeof(a[0]))
  61
  62 char *find_loop_by_file(const char *filename)
  63 {
  64         DIR *dir;
  65         struct dirent *dent;
  66         char dev[64], *found = NULL, *p;
  67         int fd;
  68         struct stat statbuf;
  69         struct loop_info loopinfo;
  70         const char VIRT_BLOCK[] = "/sys/devices/virtual/block";
  71         char path[PATH_MAX];
  72
  73         dir = opendir(VIRT_BLOCK);
  74         if (!dir)
  75                 return NULL;
  76
  77         while ((dent = readdir(dir)) != NULL) {
  78                 if (strncmp(dent->d_name,"loop",4))
  79                         continue;
  80
  81                 if (snprintf(path, PATH_MAX, "%s/%s/dev", VIRT_BLOCK,
  82                              dent->d_name) >= PATH_MAX)
  83                         continue;
  84
  85                 fd = open(path, O_RDONLY);
  86                 if (fd < 0)
  87                         continue;
  88
  89                 if (read(fd, dev, sizeof(dev)) <= 0) {
  90                         close(fd);
  91                         continue;
  92                 }
  93
  94                 close(fd);
  95
  96                 dev[sizeof(dev)-1] = '\0';
  97                 p = strchr(dev, '\n');
  98                 if (p != NULL)
  99                         *p = '\0';
 100                 if (snprintf(path, PATH_MAX, "/dev/block/%s", dev) >= PATH_MAX)
 101                         continue;
 102
 103                 fd = open (path, O_RDONLY);
 104                 if (fd < 0)
 105                         continue;
 106
 107                 if (fstat (fd, &statbuf) != 0 ||
 108                     !S_ISBLK(statbuf.st_mode)) {
 109                         close (fd);
 110                         continue;
 111                 }
 112
 113                 if (ioctl (fd, LOOP_GET_STATUS, &loopinfo) != 0) {
 114                         close (fd);
 115                         continue;
 116                 }
 117
 118                 close (fd);
 119
 120                 if (0 == strcmp(filename, loopinfo.lo_name)) {
 121                         found = realpath(path, NULL);
 122                         break;
 123                 }
 124         }
 125         closedir(dir);
 126         return found;
 127 }
 128
 129 char *find_unused_loop_device(void)
 130 {
 131         char dev[20], *next_loop_dev = NULL;
 132         int fd, next_loop = 0, somedev = 0, someloop = 0, loop_known = 0;
 133         struct stat statbuf;
 134         struct loop_info loopinfo;
 135         FILE *procdev;
 136
 137         while (next_loop_dev == NULL) {
 138                 if (stat("/dev/loop-control", &statbuf) == 0 &&
 139                     S_ISCHR(statbuf.st_mode)) {
 140                         int next_loop_fd;
 141
 142                         next_loop_fd = open("/dev/loop-control", O_RDWR);
 143                         if (next_loop_fd < 0)
 144                                 return NULL;
 145                         next_loop = ioctl(next_loop_fd, LOOP_CTL_GET_FREE);
 146                         close(next_loop_fd);
 147                         if (next_loop < 0)
 148                                 return NULL;
 149                 }
 150
 151                 sprintf(dev, "/dev/loop%d", next_loop);
 152
 153                 fd = open (dev, O_RDONLY);
 154                 if (fd >= 0) {
 155                         if (fstat (fd, &statbuf) == 0 &&
 156                             S_ISBLK(statbuf.st_mode)) {
 157                                 somedev++;
 158                                 if(ioctl (fd, LOOP_GET_STATUS, &loopinfo) == 0)
 159                                         someloop++;             /* in use */
 160                                 else if (errno == ENXIO)
 161                                         next_loop_dev = xstrdup(dev);
 162
 163                         }
 164                         close (fd);
 165
 166                         /* continue trying as long as devices exist */
 167                         continue;
 168                 }
 169                 break;
 170         }
 171         if (next_loop_dev)
 172                 return next_loop_dev;
 173
 174         /* Nothing found. Why not? */
 175         if ((procdev = fopen(PROC_DEVICES, "r")) != NULL) {
 176                 char line[100];
 177
 178                 while (fgets (line, sizeof(line), procdev))
 179
 180                         if (strstr (line, " loop\n")) {
 181                                 loop_known = 1;
 182                                 break;
 183                         }
 184
 185                 fclose(procdev);
 186
 187                 if (!loop_known)
 188                         loop_known = -1;
 189         }
 190
 191         if (!somedev)
 192                 fprintf(stderr, "mount: could not find any device /dev/loop#");
 193
 194         else if (!someloop) {
 195                 if (loop_known == 1)
 196                         fprintf(stderr,
 197                                 "mount: Could not find any loop device.\n"
 198                                 "       Maybe /dev/loop# has a wrong major number?");
 199                 else if (loop_known == -1)
 200                         fprintf(stderr,
 201                                 "mount: Could not find any loop device, and, according to %s,\n"
 202                                 "       this kernel does not know about the loop device.\n"
 203                                 "       (If so, then recompile or `modprobe loop'.)",
 204                                 PROC_DEVICES);
 205                 else
 206                         fprintf(stderr,
 207                                 "mount: Could not find any loop device. Maybe this kernel does not know\n"
 208                                 "       about the loop device (then recompile or `modprobe loop'), or\n"
 209                                 "       maybe /dev/loop# has the wrong major number?");
 210         } else
 211                 fprintf(stderr, "mount: could not find any free loop device");
 212         return NULL;
 213 }
 214
 215 int set_loop(const char *device, const char *file, int offset, int *loopro)
 216 {
 217         struct loop_info loopinfo;
 218         int fd, ffd, mode;
 219
 220         mode = (*loopro ? O_RDONLY : O_RDWR);
 221
 222         if ((ffd = open (file, mode)) < 0) {
 223
 224                 if (!*loopro && (errno == EROFS || errno == EACCES))
 225                         ffd = open (file, mode = O_RDONLY);
 226
 227                 if (ffd < 0) {
 228                         perror (file);
 229                         return 1;
 230                 }
 231         }
 232
 233         if ((fd = open (device, mode)) < 0) {
 234                 close(ffd);
 235                 perror (device);
 236                 return 1;
 237         }
 238
 239         *loopro = (mode == O_RDONLY);
 240         memset (&loopinfo, 0, sizeof (loopinfo));
 241
 242         xstrncpy (loopinfo.lo_name, file, LO_NAME_SIZE);
 243         loopinfo.lo_offset = offset;
 244         loopinfo.lo_encrypt_type = LO_CRYPT_NONE;
 245         loopinfo.lo_encrypt_key_size = 0;
 246
 247         if (ioctl(fd, LOOP_SET_FD, (void*)(uintptr_t)(ffd)) < 0) {
 248                 perror ("ioctl: LOOP_SET_FD");
 249                 close (fd);
 250                 close (ffd);
 251                 return 1;
 252         }
 253
 254         if (ioctl (fd, LOOP_SET_STATUS, &loopinfo) < 0) {
 255                 (void) ioctl (fd, LOOP_CLR_FD, 0);
 256                 perror ("ioctl: LOOP_SET_STATUS");
 257                 close (fd);
 258                 close (ffd);
 259                 return 1;
 260         }
 261
 262         close (fd);
 263         close (ffd);
 264         return 0;
 265 }
 266
 267 int del_loop(const char *device)
 268 {
 269         int retries = 5;
 270         int fd;
 271
 272         if ((fd = open (device, O_RDONLY)) < 0) {
 273                 int errsv = errno;
 274                 fprintf(stderr, "loop: can't delete device %s: %s\n",
 275                         device, strerror (errsv));
 276                 return 1;
 277         }
 278
 279         while (ioctl (fd, LOOP_CLR_FD, 0) < 0) {
 280                 if (errno != EBUSY || retries-- <= 0) {
 281                         perror ("ioctl: LOOP_CLR_FD");
 282                         close (fd);
 283                         return 1;
 284                 }
 285                 fprintf(stderr,
 286                         "loop: device %s still in use, retrying delete\n",
 287                         device);
 288                 sleep(1);
 289                 continue;
 290         }
 291
 292         close (fd);
 293         return 0;
 294 }