/
niceSOFT
/
util-linux
Обзор
Документация
Войти
/
niceSOFT
/
util-linux
Код
Задачи
Вики
Пакеты
0
Релизы
0
Аналитика
Безопасность
v2.42
lib/loopdev.c
2 052 строки
44 KB
Karel Zak
loopdev: add LOOPDEV_FL_NOFOLLOW to prevent symlink attacks
01 апр 2026, 12:55
01 апр 2026, 12:55
0ba0f14
Код
Авторство
О чём код?
/* * No copyright is claimed. This code is in the public domain; do with * it what you wish. * * Written by Karel Zak <kzak@redhat.com> * * -- based on mount/losetup.c * * Simple library for work with loop devices. * * - requires kernel 2.6.x * - reads info from /sys/block/loop<N>/loop/<attr> (new kernels) * - reads info by ioctl * - supports *unlimited* number of loop devices * - supports /dev/loop<N> as well as /dev/loop/<N> * - minimize overhead (fd, loopinfo, ... are shared for all operations) * - setup (associate device and backing file) * - delete (dis-associate file) * - old LOOP_{SET,GET}_STATUS (32bit) ioctls are unsupported * - extendible */ #include <stdio.h> #include <stdint.h> #include <string.h> #include <ctype.h> #include <fcntl.h> #include <stdlib.h> #include <unistd.h> #include <sys/ioctl.h> #include <sys/stat.h> #include <sys/mman.h> #include <inttypes.h> #include <dirent.h> #include "linux_version.h" #include "c.h" #include "sysfs.h" #include "pathnames.h" #include "loopdev.h" #include "canonicalize.h" #include "blkdev.h" #include "debug.h" #include "fileutils.h" #define LOOPDEV_MAX_TRIES 10 /* * Debug stuff (based on include/debug.h) */ static UL_DEBUG_DEFINE_MASK(loopdev); UL_DEBUG_DEFINE_MASKNAMES(loopdev) = UL_DEBUG_EMPTY_MASKNAMES; #define LOOPDEV_DEBUG_INIT (1 << 1) #define LOOPDEV_DEBUG_CXT (1 << 2) #define LOOPDEV_DEBUG_ITER (1 << 3) #define LOOPDEV_DEBUG_SETUP (1 << 4) #define DBG(m, x) __UL_DBG(loopdev, LOOPDEV_DEBUG_, m, x) #define ON_DBG(m, x) __UL_DBG_CALL(loopdev, LOOPDEV_DEBUG_, m, x) #define UL_DEBUG_CURRENT_MASK UL_DEBUG_MASK(loopdev) #include "debugobj.h" static void loopdev_init_debug(void) { if (loopdev_debug_mask) return; __UL_INIT_DEBUG_FROM_ENV(loopdev, LOOPDEV_DEBUG_, 0, LOOPDEV_DEBUG); } /* * see loopcxt_init() */ #define loopcxt_ioctl_enabled(_lc) (!((_lc)->flags & LOOPDEV_FL_NOIOCTL)) #define loopcxt_sysfs_available(_lc) (!((_lc)->flags & LOOPDEV_FL_NOSYSFS)) \ && !loopcxt_ioctl_enabled(_lc) /* * Calls @x and repeat on EAGAIN */ #define repeat_on_eagain(x) __extension__ ({ \ int _c = 0, _e; \ do { \ errno = 0; \ _e = x; \ if (_e == 0 || errno != EAGAIN) \ break; \ if (_c >= LOOPDEV_MAX_TRIES) \ break; \ xusleep(250000); \ _c++; \ } while (1); \ _e == 0 ? 0 : errno ? -errno : -1; \ }) /* * @lc: context * @device: device name, absolute device path or NULL to reset the current setting * * Sets device, absolute paths (e.g. "/dev/loop<N>") are unchanged, device * names ("loop<N>") are converted to the path (/dev/loop<N> or to * /dev/loop/<N>) * * This sets the device name, but does not check if the device exists! * * Returns: <0 on error, 0 on success */ int loopcxt_set_device(struct loopdev_cxt *lc, const char *device) { if (!lc) return -EINVAL; if (lc->fd >= 0) { close(lc->fd); DBG(CXT, ul_debugobj(lc, "closing old open fd")); } lc->fd = -1; lc->is_lost = 0; lc->devno = 0; lc->mode = O_RDONLY; lc->blocksize = 0; lc->has_info = 0; lc->info_failed = 0; *lc->device = '\0'; memset(&lc->config, 0, sizeof(lc->config)); /* set new */ if (device) { if (*device != '/') { const char *dir = _PATH_DEV; /* compose device name for /dev/loop<n> or /dev/loop/<n> */ if (lc->flags & LOOPDEV_FL_DEVSUBDIR) { if (strlen(device) < 5) return -1; device += 4; dir = _PATH_DEV_LOOP "/"; /* _PATH_DEV uses trailing slash */ } snprintf(lc->device, sizeof(lc->device), "%s%s", dir, device); } else xstrncpy(lc->device, device, sizeof(lc->device)); DBG(CXT, ul_debugobj(lc, "%s name assigned", device)); } ul_unref_path(lc->sysfs); lc->sysfs = NULL; return 0; } int loopcxt_has_device(struct loopdev_cxt *lc) { return lc && *lc->device; } dev_t loopcxt_get_devno(struct loopdev_cxt *lc) { if (!lc || !loopcxt_has_device(lc)) return 0; if (!lc->devno) lc->devno = sysfs_devname_to_devno(lc->device); return lc->devno; } int loopcxt_is_lost(struct loopdev_cxt *lc) { if (!lc || !loopcxt_has_device(lc)) return 0; if (lc->is_lost) return 1; lc->is_lost = access(lc->device, F_OK) != 0 && loopcxt_get_devno(lc) != 0; return lc->is_lost; } /* * @lc: context * @flags: LOOPDEV_FL_* flags * * Initialize loop handler. * * We have two sets of the flags: * * * LOOPDEV_FL_* flags control loopcxt_* API behavior * * * LO_FLAGS_* are kernel flags used for LOOP_{SET,GET}_STAT64 ioctls * * Returns: <0 on error, 0 on success. */ int loopcxt_init(struct loopdev_cxt *lc, int flags) { int rc; struct stat st; struct loopdev_cxt dummy = UL_LOOPDEVCXT_EMPTY; if (!lc) return -EINVAL; loopdev_init_debug(); DBG(CXT, ul_debugobj(lc, "initialize context")); memcpy(lc, &dummy, sizeof(dummy)); lc->flags = flags; rc = loopcxt_set_device(lc, NULL); if (rc) return rc; if (stat(_PATH_SYS_BLOCK, &st) || !S_ISDIR(st.st_mode)) { lc->flags |= LOOPDEV_FL_NOSYSFS; lc->flags &= ~LOOPDEV_FL_NOIOCTL; DBG(CXT, ul_debugobj(lc, "init: disable /sys usage")); } if (!(lc->flags & LOOPDEV_FL_NOSYSFS) && get_linux_version() >= KERNEL_VERSION(2,6,37)) { /* * Use only sysfs for basic information about loop devices */ lc->flags |= LOOPDEV_FL_NOIOCTL; DBG(CXT, ul_debugobj(lc, "init: ignore ioctls")); } if (!(lc->flags & LOOPDEV_FL_CONTROL) && !stat(_PATH_DEV_LOOPCTL, &st)) { lc->flags |= LOOPDEV_FL_CONTROL; DBG(CXT, ul_debugobj(lc, "init: loop-control detected ")); } return 0; } /* * @lc: context * * Deinitialize loop context */ void loopcxt_deinit(struct loopdev_cxt *lc) { int errsv = errno; if (!lc) return; DBG(CXT, ul_debugobj(lc, "de-initialize")); free(lc->filename); lc->filename = NULL; ignore_result( loopcxt_set_device(lc, NULL) ); loopcxt_deinit_iterator(lc); errno = errsv; } /* * @lc: context * * Returns newly allocated device path. */ char *loopcxt_strdup_device(struct loopdev_cxt *lc) { if (!lc || !*lc->device) return NULL; return strdup(lc->device); } /* * @lc: context * * Returns pointer device name in the @lc struct. */ const char *loopcxt_get_device(struct loopdev_cxt *lc) { return lc && *lc->device ? lc->device : NULL; } /* * @lc: context * * Returns pointer to the sysfs context (see lib/sysfs.c) */ static struct path_cxt *loopcxt_get_sysfs(struct loopdev_cxt *lc) { if (!lc || !*lc->device || (lc->flags & LOOPDEV_FL_NOSYSFS)) return NULL; if (!lc->sysfs) { dev_t devno = loopcxt_get_devno(lc); if (!devno) { DBG(CXT, ul_debugobj(lc, "sysfs: failed devname to devno")); return NULL; } lc->sysfs = ul_new_sysfs_path(devno, NULL, NULL); if (!lc->sysfs) DBG(CXT, ul_debugobj(lc, "sysfs: init failed")); } return lc->sysfs; } static int __loopcxt_get_fd(struct loopdev_cxt *lc, mode_t mode) { int old = -1; if (!lc || !*lc->device) return -EINVAL; /* It's okay to return a FD with read-write permissions if someone * asked for read-only, but you shouldn't do the opposite. * * (O_RDONLY is a widely usable default.) */ if (lc->fd >= 0 && mode == O_RDWR && lc->mode == O_RDONLY) { DBG(CXT, ul_debugobj(lc, "closing already open device (mode mismatch)")); old = lc->fd; lc->fd = -1; } if (lc->fd < 0) { lc->mode = mode; lc->fd = open(lc->device, lc->mode | O_CLOEXEC); DBG(CXT, ul_debugobj(lc, "open %s [%s]: %m", lc->device, mode == O_RDONLY ? "ro" : mode == O_RDWR ? "rw" : "??")); if (lc->fd < 0 && old >= 0) { /* restore original on error */ lc->fd = old; old = -1; } } if (old >= 0) close(old); return lc->fd; } /* default is read-only file descriptor, it's enough for all ioctls */ int loopcxt_get_fd(struct loopdev_cxt *lc) { return __loopcxt_get_fd(lc, O_RDONLY); } /* * @lc: context * @flags: LOOPITER_FL_* flags * * Iterator can be used to scan list of the free or used loop devices. * * Returns: <0 on error, 0 on success */ int loopcxt_init_iterator(struct loopdev_cxt *lc, int flags) { struct loopdev_iter *iter; struct stat st; if (!lc) return -EINVAL; iter = &lc->iter; DBG(ITER, ul_debugobj(iter, "initialize")); /* always zeroize */ memset(iter, 0, sizeof(*iter)); iter->ncur = -1; iter->flags = flags; iter->default_check = 1; if (!lc->extra_check) { /* * Check for /dev/loop/<N> subdirectory */ if (!(lc->flags & LOOPDEV_FL_DEVSUBDIR) && stat(_PATH_DEV_LOOP, &st) == 0 && S_ISDIR(st.st_mode)) lc->flags |= LOOPDEV_FL_DEVSUBDIR; lc->extra_check = 1; } return 0; } /* * @lc: context * * Returns: <0 on error, 0 on success */ int loopcxt_deinit_iterator(struct loopdev_cxt *lc) { struct loopdev_iter *iter; if (!lc) return -EINVAL; iter = &lc->iter; DBG(ITER, ul_debugobj(iter, "de-initialize")); free(iter->minors); if (iter->proc) fclose(iter->proc); if (iter->sysblock) closedir(iter->sysblock); memset(iter, 0, sizeof(*iter)); return 0; } /* * Same as loopcxt_set_device, but also checks if the device is * associated with any file. * * Returns: <0 on error, 0 on success, 1 device does not match with * LOOPITER_FL_{USED,FREE} flags. */ static int loopiter_set_device(struct loopdev_cxt *lc, const char *device) { int rc = loopcxt_set_device(lc, device); int used; if (rc) return rc; if (!(lc->iter.flags & LOOPITER_FL_USED) && !(lc->iter.flags & LOOPITER_FL_FREE)) return 0; /* caller does not care about device status */ used = loopcxt_get_offset(lc, NULL) == 0; if ((lc->iter.flags & LOOPITER_FL_USED) && used) return 0; if ((lc->iter.flags & LOOPITER_FL_FREE) && !used) return 0; DBG(ITER, ul_debugobj(&lc->iter, "failed to use %s device", lc->device)); ignore_result( loopcxt_set_device(lc, NULL) ); return 1; } static int cmpnum(const void *p1, const void *p2) { return (((* (const int *) p1) > (* (const int *) p2)) - ((* (const int *) p1) < (* (const int *) p2))); } /* * The classic scandir() is more expensive and less portable. * We needn't full loop device names -- loop numbers (loop<N>) * are enough. */ static int loop_scandir(const char *dirname, int **ary, int hasprefix) { DIR *dir; struct dirent *d; unsigned int n, count = 0, arylen = 0; if (!dirname || !ary) return 0; DBG(ITER, ul_debug("scan dir: %s", dirname)); dir = opendir(dirname); if (!dir) return 0; free(*ary); *ary = NULL; while((d = readdir(dir))) { #ifdef _DIRENT_HAVE_D_TYPE if (d->d_type != DT_BLK && d->d_type != DT_UNKNOWN && d->d_type != DT_LNK) continue; #endif if (is_dotdir_dirent(d)) continue; if (hasprefix) { /* /dev/loop<N> */ if (sscanf(d->d_name, "loop%u", &n) != 1) continue; } else { /* /dev/loop/<N> */ char *end = NULL; errno = 0; n = strtol(d->d_name, &end, 10); if (d->d_name == end || (end && *end) || errno) continue; } if (n < LOOPDEV_DEFAULT_NNODES) continue; /* ignore loop<0..7> */ if (count + 1 > arylen) { int *tmp; arylen += 1; tmp = reallocarray(*ary, arylen, sizeof(int)); if (!tmp) { free(*ary); *ary = NULL; closedir(dir); return -1; } *ary = tmp; } if (*ary) (*ary)[count++] = n; } if (count && *ary) qsort(*ary, count, sizeof(int), cmpnum); closedir(dir); return count; } /* * Set the next *used* loop device according to /proc/partitions. * * Loop devices smaller than 512 bytes are invisible for this function. */ static int loopcxt_next_from_proc(struct loopdev_cxt *lc) { struct loopdev_iter *iter = &lc->iter; char buf[BUFSIZ]; DBG(ITER, ul_debugobj(iter, "scan /proc/partitions")); if (!iter->proc) iter->proc = fopen(_PATH_PROC_PARTITIONS, "r" UL_CLOEXECSTR); if (!iter->proc) return 1; while (fgets(buf, sizeof(buf), iter->proc)) { unsigned int m; char name[128 + 1]; if (sscanf(buf, " %u %*s %*s %128[^\n ]", &m, name) != 2 || m != LOOPDEV_MAJOR) continue; DBG(ITER, ul_debugobj(iter, "checking %s", name)); if (loopiter_set_device(lc, name) == 0) return 0; } return 1; } /* * Set the next *used* loop device according to * /sys/block/loopN/loop/backing_file (kernel >= 2.6.37 is required). * * This is preferred method. */ static int loopcxt_next_from_sysfs(struct loopdev_cxt *lc) { struct loopdev_iter *iter = &lc->iter; struct dirent *d; int fd; DBG(ITER, ul_debugobj(iter, "scanning /sys/block")); if (!iter->sysblock) iter->sysblock = opendir(_PATH_SYS_BLOCK); if (!iter->sysblock) return 1; fd = dirfd(iter->sysblock); while ((d = readdir(iter->sysblock))) { char name[NAME_MAX + 18 + 1]; struct stat st; DBG(ITER, ul_debugobj(iter, "check %s", d->d_name)); if (is_dotdir_dirent(d) || strncmp(d->d_name, "loop", 4) != 0) continue; snprintf(name, sizeof(name), "%s/loop/backing_file", d->d_name); if (fstatat(fd, name, &st, 0) != 0) continue; if (loopiter_set_device(lc, d->d_name) == 0) return 0; } return 1; } /* * @lc: context, has to initialized by loopcxt_init_iterator() * * Returns: 0 on success, < 0 on error, 1 at the end of scanning. The details * about the current loop device are available by * loopcxt_get_{fd,backing_file,device,offset, ...} functions. */ int loopcxt_next(struct loopdev_cxt *lc) { struct loopdev_iter *iter; if (!lc) return -EINVAL; iter = &lc->iter; if (iter->done) return 1; DBG(ITER, ul_debugobj(iter, "next")); /* A) Look for used loop devices in /proc/partitions ("losetup -a" only) */ if (iter->flags & LOOPITER_FL_USED) { int rc; if (loopcxt_sysfs_available(lc)) rc = loopcxt_next_from_sysfs(lc); else rc = loopcxt_next_from_proc(lc); if (rc == 0) return 0; goto done; } /* B) Classic way, try first eight loop devices (default number * of loop devices). This is enough for 99% of all cases. */ if (iter->default_check) { DBG(ITER, ul_debugobj(iter, "next: default check")); for (++iter->ncur; iter->ncur < LOOPDEV_DEFAULT_NNODES; iter->ncur++) { char name[16]; snprintf(name, sizeof(name), "loop%d", iter->ncur); if (loopiter_set_device(lc, name) == 0) return 0; } iter->default_check = 0; } /* C) the worst possibility, scan whole /dev or /dev/loop/<N> */ if (!iter->minors) { DBG(ITER, ul_debugobj(iter, "next: scanning /dev")); iter->nminors = (lc->flags & LOOPDEV_FL_DEVSUBDIR) ? loop_scandir(_PATH_DEV_LOOP, &iter->minors, 0) : loop_scandir(_PATH_DEV, &iter->minors, 1); iter->ncur = -1; } for (++iter->ncur; iter->ncur < iter->nminors; iter->ncur++) { char name[16]; snprintf(name, sizeof(name), "loop%d", iter->minors[iter->ncur]); if (loopiter_set_device(lc, name) == 0) return 0; } done: loopcxt_deinit_iterator(lc); return 1; } /* * @device: path to device */ int is_loopdev(const char *device) { struct stat st; int rc = 0; if (!device || stat(device, &st) != 0 || !S_ISBLK(st.st_mode)) rc = 0; else if (major(st.st_rdev) == LOOPDEV_MAJOR) rc = 1; else if (sysfs_devno_is_wholedisk(st.st_rdev)) { /* It's possible that kernel creates a device with a different * major number ... check by /sys it's really loop device. */ char name[PATH_MAX], *cn, *p = NULL; snprintf(name, sizeof(name), _PATH_SYS_DEVBLOCK "/%d:%d", major(st.st_rdev), minor(st.st_rdev)); cn = ul_canonicalize_path(name); if (cn) p = stripoff_last_component(cn); rc = p && ul_startswith(p, "loop"); free(cn); } if (rc == 0) errno = ENODEV; return rc; } /* * @lc: context * * Returns result from LOOP_GET_STAT64 ioctl or NULL on error. */ struct loop_info64 *loopcxt_get_info(struct loopdev_cxt *lc) { int fd; if (!lc || lc->info_failed) { errno = EINVAL; return NULL; } errno = 0; if (lc->has_info) return &lc->config.info; fd = loopcxt_get_fd(lc); if (fd < 0) return NULL; if (ioctl(fd, LOOP_GET_STATUS64, &lc->config.info) == 0) { lc->has_info = 1; lc->info_failed = 0; DBG(CXT, ul_debugobj(lc, "reading loop_info64 OK")); return &lc->config.info; } lc->info_failed = 1; DBG(CXT, ul_debugobj(lc, "reading loop_info64 FAILED")); return NULL; } /* * @lc: context * * Returns (allocated) string with path to the file associated * with the current loop device. */ char *loopcxt_get_backing_file(struct loopdev_cxt *lc) { struct path_cxt *sysfs = loopcxt_get_sysfs(lc); char *res = NULL; if (sysfs) /* * This is always preferred, the loop_info64 * has too small buffer for the filename. */ ul_path_read_string(sysfs, &res, "loop/backing_file"); if (!res && loopcxt_ioctl_enabled(lc)) { struct loop_info64 *lo = loopcxt_get_info(lc); if (lo) { lo->lo_file_name[LO_NAME_SIZE - 2] = '*'; lo->lo_file_name[LO_NAME_SIZE - 1] = '\0'; res = strdup((char *) lo->lo_file_name); } } DBG(CXT, ul_debugobj(lc, "get_backing_file [%s]", res)); return res; } /* * @lc: context * * Returns (allocated) string with loop reference. The same as backing file by * default. */ char *loopcxt_get_refname(struct loopdev_cxt *lc) { char *res = NULL; struct loop_info64 *lo = loopcxt_get_info(lc); if (lo) { lo->lo_file_name[LO_NAME_SIZE - 1] = '\0'; res = strdup((char *) lo->lo_file_name); } DBG(CXT, ul_debugobj(lc, "get_refname [%s]", res)); return res; } /* * @lc: context * @offset: returns offset number for the given device * * Returns: <0 on error, 0 on success */ int loopcxt_get_offset(struct loopdev_cxt *lc, uint64_t *offset) { struct path_cxt *sysfs = loopcxt_get_sysfs(lc); int rc = -EINVAL; if (sysfs) if (ul_path_read_u64(sysfs, offset, "loop/offset") == 0) rc = 0; if (rc && loopcxt_ioctl_enabled(lc)) { struct loop_info64 *lo = loopcxt_get_info(lc); if (lo) { if (offset) *offset = lo->lo_offset; rc = 0; } else rc = -errno; } DBG(CXT, ul_debugobj(lc, "get_offset [rc=%d]", rc)); return rc; } /* * @lc: context * @blocksize: returns logical blocksize for the given device * * Returns: <0 on error, 0 on success */ int loopcxt_get_blocksize(struct loopdev_cxt *lc, uint64_t *blocksize) { struct path_cxt *sysfs = loopcxt_get_sysfs(lc); int rc = -EINVAL; if (sysfs) if (ul_path_read_u64(sysfs, blocksize, "queue/logical_block_size") == 0) rc = 0; /* Fallback based on BLKSSZGET ioctl */ if (rc) { int fd = loopcxt_get_fd(lc); int sz = 0; if (fd < 0) return -EINVAL; rc = blkdev_get_sector_size(fd, &sz); if (rc) return rc; *blocksize = sz; } DBG(CXT, ul_debugobj(lc, "get_blocksize [rc=%d]", rc)); return rc; } /* * @lc: context * @sizelimit: returns size limit for the given device * * Returns: <0 on error, 0 on success */ int loopcxt_get_sizelimit(struct loopdev_cxt *lc, uint64_t *size) { struct path_cxt *sysfs = loopcxt_get_sysfs(lc); int rc = -EINVAL; if (sysfs) if (ul_path_read_u64(sysfs, size, "loop/sizelimit") == 0) rc = 0; if (rc && loopcxt_ioctl_enabled(lc)) { struct loop_info64 *lo = loopcxt_get_info(lc); if (lo) { if (size) *size = lo->lo_sizelimit; rc = 0; } else rc = -errno; } DBG(CXT, ul_debugobj(lc, "get_sizelimit [rc=%d]", rc)); return rc; } /* * @lc: context * @type: returns encryption type * * Cryptoloop is DEPRECATED! * * Returns: <0 on error, 0 on success */ int loopcxt_get_encrypt_type(struct loopdev_cxt *lc, uint32_t *type) { struct loop_info64 *lo = loopcxt_get_info(lc); int rc; /* not provided by sysfs */ if (lo) { if (type) *type = lo->lo_encrypt_type; rc = 0; } else rc = -errno; DBG(CXT, ul_debugobj(lc, "get_encrypt_type [rc=%d]", rc)); return rc; } /* * @lc: context * * Cryptoloop is DEPRECATED! * * Returns: <0 on error, 0 on success */ const char *loopcxt_get_crypt_name(struct loopdev_cxt *lc) { struct loop_info64 *lo = loopcxt_get_info(lc); if (lo) return (char *) lo->lo_crypt_name; DBG(CXT, ul_debugobj(lc, "get_crypt_name failed")); return NULL; } /* * @lc: context * @devno: returns backing file devno * * Returns: <0 on error, 0 on success */ int loopcxt_get_backing_devno(struct loopdev_cxt *lc, dev_t *devno) { struct loop_info64 *lo = loopcxt_get_info(lc); int rc; if (lo) { if (devno) *devno = lo->lo_device; rc = 0; } else rc = -errno; DBG(CXT, ul_debugobj(lc, "get_backing_devno [rc=%d]", rc)); return rc; } /* * @lc: context * @ino: returns backing file inode * * Returns: <0 on error, 0 on success */ int loopcxt_get_backing_inode(struct loopdev_cxt *lc, ino_t *ino) { struct loop_info64 *lo = loopcxt_get_info(lc); int rc; if (lo) { if (ino) *ino = lo->lo_inode; rc = 0; } else rc = -errno; DBG(CXT, ul_debugobj(lc, "get_backing_inode [rc=%d]", rc)); return rc; } /* * Check if the kernel supports partitioned loop devices. * * Notes: * - kernels < 3.2 support partitioned loop devices and PT scanning * only if max_part= module parameter is non-zero * * - kernels >= 3.2 always support partitioned loop devices * * - kernels >= 3.2 always support BLKPG_{ADD,DEL}_PARTITION ioctls * * - kernels >= 3.2 enable PT scanner only if max_part= is non-zero or if the * LO_FLAGS_PARTSCAN flag is set for the device. The PT scanner is disabled * by default. * * See kernel commit e03c8dd14915fabc101aa495828d58598dc5af98. */ int loopmod_supports_partscan(void) { int rc, ret = 0; FILE *f; if (get_linux_version() >= KERNEL_VERSION(3,2,0)) return 1; f = fopen("/sys/module/loop/parameters/max_part", "r" UL_CLOEXECSTR); if (!f) return 0; rc = fscanf(f, "%d", &ret); fclose(f); return rc == 1 ? ret : 0; } /* * @lc: context * * Returns: 1 if the partscan flags is set *or* (for old kernels) partitions * scanning is enabled for all loop devices. */ int loopcxt_is_partscan(struct loopdev_cxt *lc) { struct path_cxt *sysfs = loopcxt_get_sysfs(lc); if (sysfs) { /* kernel >= 3.2 */ int fl; if (ul_path_read_s32(sysfs, &fl, "loop/partscan") == 0) return fl; } /* old kernels (including kernels without loopN/loop/<flags> directory */ return loopmod_supports_partscan(); } /* * @lc: context * * Returns: 1 if the autoclear flags is set. */ int loopcxt_is_autoclear(struct loopdev_cxt *lc) { struct path_cxt *sysfs = loopcxt_get_sysfs(lc); if (sysfs) { int fl; if (ul_path_read_s32(sysfs, &fl, "loop/autoclear") == 0) return fl; } if (loopcxt_ioctl_enabled(lc)) { struct loop_info64 *lo = loopcxt_get_info(lc); if (lo) return lo->lo_flags & LO_FLAGS_AUTOCLEAR; } return 0; } /* * @lc: context * * Returns: 1 if the readonly flags is set. */ int loopcxt_is_readonly(struct loopdev_cxt *lc) { struct path_cxt *sysfs = loopcxt_get_sysfs(lc); if (sysfs) { int fl; if (ul_path_read_s32(sysfs, &fl, "ro") == 0) return fl; } if (loopcxt_ioctl_enabled(lc)) { struct loop_info64 *lo = loopcxt_get_info(lc); if (lo) return lo->lo_flags & LO_FLAGS_READ_ONLY; } return 0; } /* * @lc: context * * Returns: 1 if the dio flags is set. */ int loopcxt_is_dio(struct loopdev_cxt *lc) { struct path_cxt *sysfs = loopcxt_get_sysfs(lc); if (sysfs) { int fl; if (ul_path_read_s32(sysfs, &fl, "loop/dio") == 0) return fl; } if (loopcxt_ioctl_enabled(lc)) { struct loop_info64 *lo = loopcxt_get_info(lc); if (lo) return lo->lo_flags & LO_FLAGS_DIRECT_IO; } return 0; } /* * @lc: context * @st: backing file stat or NULL * @backing_file: filename * @offset: offset (use LOOPDEV_FL_OFFSET if specified) * @sizelimit: size limit (use LOOPDEV_FL_SIZELIMIT if specified) * @flags: LOOPDEV_FL_{OFFSET,SIZELIMIT} * * Returns 1 if the current @lc loopdev is associated with the given backing * file. Note that the preferred way is to use devno and inode number rather * than filename. The @backing_file filename is poor solution usable in case * that you don't have rights to call stat(). * * LOOPDEV_FL_SIZELIMIT requires LOOPDEV_FL_OFFSET being set as well. * * Don't forget that old kernels provide very restricted (in size) backing * filename by LOOP_GET_STAT64 ioctl only. */ int loopcxt_is_used(struct loopdev_cxt *lc, struct stat *st, const char *backing_file, uint64_t offset, uint64_t sizelimit, int flags) { ino_t ino = 0; dev_t dev = 0; if (!lc) return 0; DBG(CXT, ul_debugobj(lc, "checking %s vs. %s", loopcxt_get_device(lc), backing_file)); if (st && loopcxt_get_backing_inode(lc, &ino) == 0 && loopcxt_get_backing_devno(lc, &dev) == 0) { if (ino == st->st_ino && dev == st->st_dev) goto found; /* don't use filename if we have devno and inode */ return 0; } /* poor man's solution */ if (backing_file) { char *name = loopcxt_get_backing_file(lc); int rc = name && strcmp(name, backing_file) == 0; free(name); if (rc) goto found; } return 0; found: if (flags & LOOPDEV_FL_OFFSET) { uint64_t off = 0; int rc = loopcxt_get_offset(lc, &off) == 0 && off == offset; if (rc && flags & LOOPDEV_FL_SIZELIMIT) { uint64_t sz = 0; return loopcxt_get_sizelimit(lc, &sz) == 0 && sz == sizelimit; } return rc; } return 1; } /* * The setting is removed by loopcxt_set_device() loopcxt_next()! */ int loopcxt_set_offset(struct loopdev_cxt *lc, uint64_t offset) { if (!lc) return -EINVAL; lc->config.info.lo_offset = offset; DBG(CXT, ul_debugobj(lc, "set offset=%jd", offset)); return 0; } /* * The setting is removed by loopcxt_set_device() loopcxt_next()! */ int loopcxt_set_sizelimit(struct loopdev_cxt *lc, uint64_t sizelimit) { if (!lc) return -EINVAL; lc->config.info.lo_sizelimit = sizelimit; DBG(CXT, ul_debugobj(lc, "set sizelimit=%jd", sizelimit)); return 0; } /* * The blocksize will be used by loopcxt_set_device(). For already exiting * devices use loopcxt_ioctl_blocksize(). * * The setting is removed by loopcxt_set_device() loopcxt_next()! */ int loopcxt_set_blocksize(struct loopdev_cxt *lc, uint64_t blocksize) { if (!lc) return -EINVAL; lc->blocksize = blocksize; DBG(CXT, ul_debugobj(lc, "set blocksize=%jd", blocksize)); return 0; } /* * @lc: context * @flags: kernel LO_FLAGS_{READ_ONLY,USE_AOPS,AUTOCLEAR} flags * * The setting is removed by loopcxt_set_device() loopcxt_next()! * * Returns: 0 on success, <0 on error. */ int loopcxt_set_flags(struct loopdev_cxt *lc, uint32_t flags) { if (!lc) return -EINVAL; lc->config.info.lo_flags = flags; DBG(CXT, ul_debugobj(lc, "set flags=%u", (unsigned) flags)); return 0; } /* * @lc: context * @refname: reference name (used to overwrite lo_file_name where is backing * file by default) * * The setting is removed by loopcxt_set_device() loopcxt_next()! * * Returns: 0 on success, <0 on error. */ int loopcxt_set_refname(struct loopdev_cxt *lc, const char *refname) { if (!lc) return -EINVAL; memset(lc->config.info.lo_file_name, 0, sizeof(lc->config.info.lo_file_name)); if (refname) xstrncpy((char *)lc->config.info.lo_file_name, refname, LO_NAME_SIZE); DBG(CXT, ul_debugobj(lc, "set refname=%s", (char *)lc->config.info.lo_file_name)); return 0; } /* * @lc: context * @filename: backing file path (the path will be canonicalized) * * The setting is removed by loopcxt_set_device() loopcxt_next()! * * Returns: 0 on success, <0 on error. */ int loopcxt_set_backing_file(struct loopdev_cxt *lc, const char *filename) { if (!lc) return -EINVAL; if (lc->flags & LOOPDEV_FL_NOFOLLOW) lc->filename = strdup(filename); else lc->filename = ul_canonicalize_path(filename); if (!lc->filename) return -errno; if (!lc->config.info.lo_file_name[0]) loopcxt_set_refname(lc, lc->filename); DBG(CXT, ul_debugobj(lc, "set backing file=%s", lc->filename)); return 0; } /* * In kernels prior to v3.9, if the offset or sizelimit options * are used, the block device's size won't be synced automatically. * blockdev --getsize64 and filesystems will use the backing * file size until the block device has been re-opened or the * LOOP_SET_CAPACITY ioctl is called to sync the sizes. * * Since mount -oloop uses the LO_FLAGS_AUTOCLEAR option and passes * the open file descriptor to the mount system call, we need to use * the ioctl. Calling losetup directly doesn't have this problem since * it closes the device when it exits and whatever consumes the device * next will re-open it, causing the resync. */ static int loopcxt_check_size(struct loopdev_cxt *lc, int file_fd) { uint64_t size, expected_size; int dev_fd; struct stat st; if (!lc->config.info.lo_offset && !lc->config.info.lo_sizelimit) return 0; if (fstat(file_fd, &st)) { DBG(CXT, ul_debugobj(lc, "failed to fstat backing file")); return -errno; } if (S_ISBLK(st.st_mode)) { if (blkdev_get_size(file_fd, (unsigned long long *) &expected_size)) { DBG(CXT, ul_debugobj(lc, "failed to determine device size")); return -errno; } } else expected_size = st.st_size; if (expected_size == 0 || expected_size <= lc->config.info.lo_offset) { DBG(CXT, ul_debugobj(lc, "failed to determine expected size")); return 0; /* ignore this error */ } if (lc->config.info.lo_offset > 0) expected_size -= lc->config.info.lo_offset; if (lc->config.info.lo_sizelimit > 0 && lc->config.info.lo_sizelimit < expected_size) expected_size = lc->config.info.lo_sizelimit; dev_fd = loopcxt_get_fd(lc); if (dev_fd < 0) { DBG(CXT, ul_debugobj(lc, "failed to get loop FD")); return -errno; } if (blkdev_get_size(dev_fd, (unsigned long long *) &size)) { DBG(CXT, ul_debugobj(lc, "failed to determine loopdev size")); return -errno; } /* It's block device, so, align to 512-byte sectors */ if (expected_size % 512) { DBG(CXT, ul_debugobj(lc, "expected size misaligned to 512-byte sectors")); expected_size = (expected_size >> 9) << 9; } if (expected_size != size) { DBG(CXT, ul_debugobj(lc, "warning: loopdev and expected " "size mismatch (%ju/%ju)", size, expected_size)); if (loopcxt_ioctl_capacity(lc)) { /* ioctl not available */ if (errno == ENOTTY || errno == EINVAL) errno = ERANGE; return -errno; } if (blkdev_get_size(dev_fd, (unsigned long long *) &size)) return -errno; if (expected_size != size) { errno = ERANGE; DBG(CXT, ul_debugobj(lc, "failed to set loopdev size, " "size: %ju, expected: %ju", size, expected_size)); return -errno; } } return 0; } /* * @lc: context * * Associate the current device (see loopcxt_{set,get}_device()) with * a file (see loopcxt_set_backing_file()). * * The device is initialized read-write by default. If you want read-only * device then set LO_FLAGS_READ_ONLY by loopcxt_set_flags(). The LOOPDEV_FL_* * flags are ignored and modified according to LO_FLAGS_*. * * If the device is already open by loopcxt_get_fd() then this setup device * function will re-open the device to fix read/write mode. * * The device is also initialized read-only if the backing file is not * possible to open read-write (e.g. read-only FS). * * Returns: <0 on error, 0 on success. */ int loopcxt_setup_device(struct loopdev_cxt *lc) { int file_fd, dev_fd; mode_t flags = O_CLOEXEC, mode = O_RDWR; int rc = -1, cnt = 0; int errsv = 0; int fallback = 0; if (!lc || !*lc->device || !lc->filename) return -EINVAL; DBG(SETUP, ul_debugobj(lc, "device setup requested")); /* * Open backing file and device */ if (lc->config.info.lo_flags & LO_FLAGS_READ_ONLY) mode = O_RDONLY; if (lc->config.info.lo_flags & LO_FLAGS_DIRECT_IO) flags |= O_DIRECT; if (lc->flags & LOOPDEV_FL_NOFOLLOW) flags |= O_NOFOLLOW; if ((file_fd = open(lc->filename, mode | flags)) < 0) { if (mode != O_RDONLY && (errno == EROFS || errno == EACCES)) file_fd = open(lc->filename, (mode = O_RDONLY) | flags); if (file_fd < 0) { DBG(SETUP, ul_debugobj(lc, "open backing file failed: %m")); return -errno; } } DBG(SETUP, ul_debugobj(lc, "backing file open: OK")); if (mode == O_RDONLY) lc->config.info.lo_flags |= LO_FLAGS_READ_ONLY; /* kernel loopdev mode */ else lc->config.info.lo_flags &= ~LO_FLAGS_READ_ONLY; do { errno = 0; dev_fd = __loopcxt_get_fd(lc, mode); if (dev_fd >= 0 || lc->control_ok == 0) break; if (errno != EACCES && errno != ENOENT) break; /* We have permissions to open /dev/loop-control, but open * /dev/loopN failed with EACCES, it's probably because udevd * does not applied chown yet. Let's wait a moment. */ xusleep(25000); } while (cnt++ < 16); if (dev_fd < 0) { rc = -errno; goto err; } DBG(SETUP, ul_debugobj(lc, "device open: OK")); /* * Atomic way to configure all by one ioctl call * -- since Linux v5.8-rc1, commit 3448914e8cc550ba792d4ccc74471d1ca4293aae */ lc->config.fd = file_fd; if (lc->blocksize > 0) lc->config.block_size = lc->blocksize; rc = repeat_on_eagain( ioctl(dev_fd, LOOP_CONFIGURE, &lc->config) ); if (rc != 0) { errsv = errno; if (errno != EINVAL && errno != ENOTTY && errno != ENOSYS) { DBG(SETUP, ul_debugobj(lc, "LOOP_CONFIGURE failed: %m")); goto err; } fallback = 1; } else { DBG(SETUP, ul_debugobj(lc, "LOOP_CONFIGURE: OK")); } /* * Old deprecated way; first assign backing file FD and then in the * second step set loop device properties. */ if (fallback) { if (ioctl(dev_fd, LOOP_SET_FD, file_fd) < 0) { rc = -errno; errsv = errno; DBG(SETUP, ul_debugobj(lc, "LOOP_SET_FD failed: %m")); goto err; } DBG(SETUP, ul_debugobj(lc, "LOOP_SET_FD: OK")); if (lc->blocksize > 0 && (rc = loopcxt_ioctl_blocksize(lc, lc->blocksize)) < 0) { errsv = -rc; goto err; } if ((rc = loopcxt_ioctl_status(lc)) < 0) { errsv = -rc; goto err; } } if ((rc = loopcxt_check_size(lc, file_fd))) goto err; close(file_fd); memset(&lc->config, 0, sizeof(lc->config)); lc->has_info = 0; lc->info_failed = 0; DBG(SETUP, ul_debugobj(lc, "success [rc=0]")); return 0; err: if (file_fd >= 0) close(file_fd); if (dev_fd >= 0 && rc != -EBUSY) ioctl(dev_fd, LOOP_CLR_FD, 0); if (errsv) errno = errsv; DBG(SETUP, ul_debugobj(lc, "failed [rc=%d]", rc)); return rc; } /* * @lc: context * * Update status of the current device (see loopcxt_{set,get}_device()). * * Note that once initialized, kernel accepts only selected changes: * LO_FLAGS_AUTOCLEAR and LO_FLAGS_PARTSCAN * For more see linux/drivers/block/loop.c:loop_set_status() * * Returns: <0 on error, 0 on success. */ int loopcxt_ioctl_status(struct loopdev_cxt *lc) { int dev_fd, rc; errno = 0; dev_fd = loopcxt_get_fd(lc); if (dev_fd < 0) return -errno; DBG(SETUP, ul_debugobj(lc, "calling LOOP_SET_STATUS64")); rc = repeat_on_eagain( ioctl(dev_fd, LOOP_SET_STATUS64, &lc->config.info) ); if (rc != 0) { DBG(SETUP, ul_debugobj(lc, "LOOP_SET_STATUS64 failed: %m")); return rc; } DBG(SETUP, ul_debugobj(lc, "LOOP_SET_STATUS64: OK")); return 0; } int loopcxt_ioctl_capacity(struct loopdev_cxt *lc) { int rc, fd = loopcxt_get_fd(lc); if (fd < 0) return -EINVAL; DBG(SETUP, ul_debugobj(lc, "calling LOOP_SET_CAPACITY")); /* Kernels prior to v2.6.30 don't support this ioctl */ rc = repeat_on_eagain( ioctl(fd, LOOP_SET_CAPACITY, 0) ); if (rc != 0) { DBG(CXT, ul_debugobj(lc, "LOOP_SET_CAPACITY failed: %m")); return rc; } DBG(CXT, ul_debugobj(lc, "capacity set")); return 0; } int loopcxt_ioctl_dio(struct loopdev_cxt *lc, unsigned long use_dio) { int rc, fd = loopcxt_get_fd(lc); if (fd < 0) return -EINVAL; DBG(SETUP, ul_debugobj(lc, "calling LOOP_SET_DIRECT_IO")); /* Kernels prior to v4.4 don't support this ioctl */ rc = repeat_on_eagain( ioctl(fd, LOOP_SET_DIRECT_IO, use_dio) ); if (rc != 0) { DBG(CXT, ul_debugobj(lc, "LOOP_SET_DIRECT_IO failed: %m")); return rc; } DBG(CXT, ul_debugobj(lc, "direct io set")); return 0; } /* * Kernel uses "unsigned long" as ioctl arg, but we use u64 for all sizes to * keep loopdev internal API simple. */ int loopcxt_ioctl_blocksize(struct loopdev_cxt *lc, uint64_t blocksize) { int rc, fd = loopcxt_get_fd(lc); if (fd < 0) return -EINVAL; DBG(SETUP, ul_debugobj(lc, "calling LOOP_SET_BLOCK_SIZE")); rc = repeat_on_eagain( ioctl(fd, LOOP_SET_BLOCK_SIZE, (unsigned long) blocksize) ); if (rc != 0) { DBG(CXT, ul_debugobj(lc, "LOOP_SET_BLOCK_SIZE failed: %m")); return rc; } DBG(CXT, ul_debugobj(lc, "logical block size set")); return 0; } /* * @lc: context * @nr: returns loop device number * * Extracts the loop device number from the device path. * Supports both /dev/loop<N> and /dev/loop/<N> formats. * * Returns: 0 on success, <0 on error */ static int loopcxt_get_device_nr(struct loopdev_cxt *lc, int *nr) { const char *p, *dev; int rc = -EINVAL; errno = 0; if (!lc || !nr) return rc; dev = loopcxt_get_device(lc); if (!dev) goto done; p = strrchr(dev, '/'); if (!p) goto done; if (sscanf(p, "/loop%d", nr) != 1 && sscanf(p, "/%d", nr) != 1) goto done; if (*nr < 0) goto done; rc = 0; done: if (rc && !errno) errno = -rc; DBG(CXT, ul_debugobj(lc, "get_device_nr [nr=%d]", *nr)); return rc; } int loopcxt_detach_device(struct loopdev_cxt *lc) { int rc, fd = loopcxt_get_fd(lc); if (fd < 0) return -EINVAL; DBG(SETUP, ul_debugobj(lc, "calling LOOP_CLR_FD")); rc = repeat_on_eagain( ioctl(fd, LOOP_CLR_FD, 0) ); if (rc != 0) { DBG(CXT, ul_debugobj(lc, "LOOP_CLR_FD failed: %m")); return rc; } DBG(CXT, ul_debugobj(lc, "device removed")); return 0; } int loopcxt_remove_device(struct loopdev_cxt *lc) { int rc = -EINVAL; int ctl, nr = -1; if (!(lc->flags & LOOPDEV_FL_CONTROL)) { rc = -ENOSYS; goto done; } rc = loopcxt_get_device_nr(lc, &nr); if (rc) goto done; ctl = open(_PATH_DEV_LOOPCTL, O_RDWR|O_CLOEXEC); if (ctl >= 0) { DBG(CXT, ul_debugobj(lc, "remove_device %d", nr)); rc = ioctl(ctl, LOOP_CTL_REMOVE, nr); close(ctl); } lc->control_ok = rc >= 0 ? 1 : 0; done: DBG(CXT, ul_debugobj(lc, "remove_device done [rc=%d]", rc)); return rc; } int loopcxt_add_device(struct loopdev_cxt *lc) { int rc = -EINVAL; int ctl, nr = -1; if (!(lc->flags & LOOPDEV_FL_CONTROL)) { rc = -ENOSYS; goto done; } rc = loopcxt_get_device_nr(lc, &nr); if (rc) goto done; ctl = open(_PATH_DEV_LOOPCTL, O_RDWR|O_CLOEXEC); if (ctl >= 0) { DBG(CXT, ul_debugobj(lc, "add_device %d", nr)); rc = ioctl(ctl, LOOP_CTL_ADD, nr); close(ctl); } lc->control_ok = rc >= 0 ? 1 : 0; done: DBG(CXT, ul_debugobj(lc, "add_device done [rc=%d]", rc)); return rc; } /* * Note that LOOP_CTL_GET_FREE ioctl is supported since kernel 3.1. In older * kernels we have to check all loop devices to found unused one. * * See kernel commit 770fe30a46a12b6fb6b63fbe1737654d28e8484. * * Returns: 0 = success, < 0 error */ int loopcxt_find_unused(struct loopdev_cxt *lc) { int rc = -1; DBG(CXT, ul_debugobj(lc, "find_unused requested")); if (lc->flags & LOOPDEV_FL_CONTROL) { int ctl; DBG(CXT, ul_debugobj(lc, "using loop-control")); ctl = open(_PATH_DEV_LOOPCTL, O_RDWR|O_CLOEXEC); if (ctl >= 0) rc = ioctl(ctl, LOOP_CTL_GET_FREE); else rc = -errno; if (rc >= 0) { char name[16]; snprintf(name, sizeof(name), "loop%d", rc); rc = loopiter_set_device(lc, name); } lc->control_ok = ctl >= 0 && rc == 0 ? 1 : 0; if (ctl >= 0) close(ctl); DBG(CXT, ul_debugobj(lc, "find_unused by loop-control [rc=%d]", rc)); } if (rc < 0 && rc != -EACCES) { DBG(CXT, ul_debugobj(lc, "using loop scan")); rc = loopcxt_init_iterator(lc, LOOPITER_FL_FREE); if (rc) return rc; rc = loopcxt_next(lc); loopcxt_deinit_iterator(lc); DBG(CXT, ul_debugobj(lc, "find_unused by scan [rc=%d]", rc)); if (rc) return -ENOENT; } return rc; } /* * Return: TRUE/FALSE */ int loopdev_is_autoclear(const char *device) { struct loopdev_cxt lc; int rc; if (!device) return 0; rc = loopcxt_init(&lc, 0); if (!rc) rc = loopcxt_set_device(&lc, device); if (!rc) rc = loopcxt_is_autoclear(&lc); loopcxt_deinit(&lc); return rc; } char *loopdev_get_backing_file(const char *device) { struct loopdev_cxt lc; char *res = NULL; if (!device) return NULL; if (loopcxt_init(&lc, 0)) return NULL; if (loopcxt_set_device(&lc, device) == 0) res = loopcxt_get_backing_file(&lc); loopcxt_deinit(&lc); return res; } /* * Returns: TRUE/FALSE */ int loopdev_has_backing_file(const char *device) { char *tmp = loopdev_get_backing_file(device); if (tmp) { free(tmp); return 1; } return 0; } /* * Returns: TRUE/FALSE */ int loopdev_is_used(const char *device, const char *filename, uint64_t offset, uint64_t sizelimit, int flags) { struct loopdev_cxt lc; struct stat st; int rc = 0; if (!device || !filename) return 0; rc = loopcxt_init(&lc, 0); if (!rc) rc = loopcxt_set_device(&lc, device); if (rc) return rc; rc = !stat(filename, &st); rc = loopcxt_is_used(&lc, rc ? &st : NULL, filename, offset, sizelimit, flags); loopcxt_deinit(&lc); return rc; } /* * Returns: 0 = success, < 0 error */ int loopdev_detach(const char *device) { struct loopdev_cxt lc; int rc; if (!device) return -EINVAL; rc = loopcxt_init(&lc, 0); if (!rc) rc = loopcxt_set_device(&lc, device); if (!rc) rc = loopcxt_detach_device(&lc); loopcxt_deinit(&lc); return rc; } /* * Returns: 0 = success, < 0 error, 1 not found */ int loopcxt_find_by_backing_file(struct loopdev_cxt *lc, const char *filename, uint64_t offset, uint64_t sizelimit, int flags) { int rc, hasst; struct stat st; if (!filename) return -EINVAL; hasst = !stat(filename, &st); rc = loopcxt_init_iterator(lc, LOOPITER_FL_USED); if (rc) return rc; while ((rc = loopcxt_next(lc)) == 0) { if (loopcxt_is_used(lc, hasst ? &st : NULL, filename, offset, sizelimit, flags)) break; } loopcxt_deinit_iterator(lc); return rc; } /* * Returns: 0 = not found, < 0 error, 1 found, 2 found full size and offset match */ int loopcxt_find_overlap(struct loopdev_cxt *lc, const char *filename, uint64_t offset, uint64_t sizelimit) { int rc, hasst; struct stat st; if (!filename) return -EINVAL; DBG(CXT, ul_debugobj(lc, "find_overlap requested")); hasst = !stat(filename, &st); rc = loopcxt_init_iterator(lc, LOOPITER_FL_USED); if (rc) return rc; while ((rc = loopcxt_next(lc)) == 0) { uint64_t lc_sizelimit, lc_offset; rc = loopcxt_is_used(lc, hasst ? &st : NULL, filename, offset, sizelimit, 0); /* * Either the loopdev is unused or we've got an error which can * happen when we are racing with device autoclear. Just ignore * this loopdev... */ if (rc <= 0) continue; DBG(CXT, ul_debugobj(lc, "found %s backed by %s", loopcxt_get_device(lc), filename)); rc = loopcxt_get_offset(lc, &lc_offset); if (rc) { DBG(CXT, ul_debugobj(lc, "failed to get offset for device %s", loopcxt_get_device(lc))); continue; } rc = loopcxt_get_sizelimit(lc, &lc_sizelimit); if (rc) { DBG(CXT, ul_debugobj(lc, "failed to get sizelimit for device %s", loopcxt_get_device(lc))); continue; } /* full match */ if (lc_sizelimit == sizelimit && lc_offset == offset) { DBG(CXT, ul_debugobj(lc, "overlapping loop device %s (full match)", loopcxt_get_device(lc))); rc = 2; goto found; } /* overlap */ if (lc_sizelimit != 0 && offset >= lc_offset + lc_sizelimit) continue; if (sizelimit != 0 && offset + sizelimit <= lc_offset) continue; DBG(CXT, ul_debugobj(lc, "overlapping loop device %s", loopcxt_get_device(lc))); rc = 1; goto found; } if (rc == 1) rc = 0; /* not found */ found: loopcxt_deinit_iterator(lc); DBG(CXT, ul_debugobj(lc, "find_overlap done [rc=%d]", rc)); return rc; } /* * Returns allocated string with device name */ char *loopdev_find_by_backing_file(const char *filename, uint64_t offset, uint64_t sizelimit, int flags) { struct loopdev_cxt lc; char *res = NULL; if (!filename) return NULL; if (loopcxt_init(&lc, 0)) return NULL; if (loopcxt_find_by_backing_file(&lc, filename, offset, sizelimit, flags) == 0) res = loopcxt_strdup_device(&lc); loopcxt_deinit(&lc); return res; } /* * Returns number of loop devices associated with @file, if only one loop * device is associated with the given @filename and @loopdev is not NULL then * @loopdev returns name of the device. */ int loopdev_count_by_backing_file(const char *filename, char **loopdev) { struct loopdev_cxt lc; int count = 0, rc; if (!filename) return -1; rc = loopcxt_init(&lc, 0); if (rc) return rc; if (loopcxt_init_iterator(&lc, LOOPITER_FL_USED)) return -1; while(loopcxt_next(&lc) == 0) { char *backing = loopcxt_get_backing_file(&lc); if (!backing || strcmp(backing, filename) != 0) { free(backing); continue; } free(backing); if (loopdev && count == 0) *loopdev = loopcxt_strdup_device(&lc); count++; } loopcxt_deinit(&lc); if (loopdev && count > 1) { free(*loopdev); *loopdev = NULL; } return count; } #ifdef TEST_PROGRAM_LOOPDEV int main(int argc, char *argv[]) { if (argc < 2) goto usage; if (strcmp(argv[1], "--is-loopdev") == 0 && argc == 3) printf("%s: %s\n", argv[2], is_loopdev(argv[2]) ? "OK" : "FAIL"); else goto usage; return EXIT_SUCCESS; usage: fprintf(stderr, "usage: %1$s --is-loopdev <dev>\n", program_invocation_short_name); return EXIT_FAILURE; } #endif