/* $NetBSD: libdm-iface.c,v 1.3 2010/12/26 14:48:34 christos Exp $ */ /* * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved. * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved. * * This file is part of the device-mapper userspace tools. * * This copyrighted material is made available to anyone wishing to use, * modify, copy, or redistribute it subject to the terms and conditions * of the GNU Lesser General Public License v.2.1. * * You should have received a copy of the GNU Lesser General Public License * along with this program; if not, write to the Free Software Foundation, * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "dmlib.h" #include "libdm-targets.h" #include "libdm-common.h" #ifdef DM_COMPAT # include "libdm-compat.h" #endif #include #include #include #include #include #ifdef linux # include "kdev_t.h" # include #else # define MAJOR(x) major((x)) # define MINOR(x) minor((x)) # define MKDEV(x,y) makedev((x),(y)) #endif #include "dm-ioctl.h" /* * Ensure build compatibility. * The hard-coded versions here are the highest present * in the _cmd_data arrays. */ #if !((DM_VERSION_MAJOR == 1 && DM_VERSION_MINOR >= 0) || \ (DM_VERSION_MAJOR == 4 && DM_VERSION_MINOR >= 0)) #error The version of dm-ioctl.h included is incompatible. #endif /* FIXME This should be exported in device-mapper.h */ #define DM_NAME "device-mapper" #define PROC_MISC "/proc/misc" #define PROC_DEVICES "/proc/devices" #define MISC_NAME "misc" #define NUMBER_OF_MAJORS 4096 /* dm major version no for running kernel */ static unsigned _dm_version = DM_VERSION_MAJOR; static unsigned _dm_version_minor = 0; static unsigned _dm_version_patchlevel = 0; static int _log_suppress = 0; /* * If the kernel dm driver only supports one major number * we store it in _dm_device_major. Otherwise we indicate * which major numbers have been claimed by device-mapper * in _dm_bitset. */ static unsigned _dm_multiple_major_support = 1; static dm_bitset_t _dm_bitset = NULL; static uint32_t _dm_device_major = 0; static int _control_fd = -1; static int _version_checked = 0; static int _version_ok = 1; static unsigned _ioctl_buffer_double_factor = 0; /* * Support both old and new major numbers to ease the transition. * Clumsy, but only temporary. */ #if DM_VERSION_MAJOR == 4 && defined(DM_COMPAT) const int _dm_compat = 1; #else const int _dm_compat = 0; #endif /* *INDENT-OFF* */ static struct cmd_data _cmd_data_v4[] = { {"create", DM_DEV_CREATE, {4, 0, 0}}, {"reload", DM_TABLE_LOAD, {4, 0, 0}}, {"remove", DM_DEV_REMOVE, {4, 0, 0}}, {"remove_all", DM_REMOVE_ALL, {4, 0, 0}}, {"suspend", DM_DEV_SUSPEND, {4, 0, 0}}, {"resume", DM_DEV_SUSPEND, {4, 0, 0}}, {"info", DM_DEV_STATUS, {4, 0, 0}}, {"deps", DM_TABLE_DEPS, {4, 0, 0}}, {"rename", DM_DEV_RENAME, {4, 0, 0}}, {"version", DM_VERSION, {4, 0, 0}}, {"status", DM_TABLE_STATUS, {4, 0, 0}}, {"table", DM_TABLE_STATUS, {4, 0, 0}}, {"waitevent", DM_DEV_WAIT, {4, 0, 0}}, {"names", DM_LIST_DEVICES, {4, 0, 0}}, {"clear", DM_TABLE_CLEAR, {4, 0, 0}}, {"mknodes", DM_DEV_STATUS, {4, 0, 0}}, #ifdef DM_LIST_VERSIONS {"versions", DM_LIST_VERSIONS, {4, 1, 0}}, #endif #ifdef DM_TARGET_MSG {"message", DM_TARGET_MSG, {4, 2, 0}}, #endif #ifdef DM_DEV_SET_GEOMETRY {"setgeometry", DM_DEV_SET_GEOMETRY, {4, 6, 0}}, #endif }; /* *INDENT-ON* */ #define ALIGNMENT_V1 sizeof(int) #define ALIGNMENT 8 /* FIXME Rejig library to record & use errno instead */ #ifndef DM_EXISTS_FLAG # define DM_EXISTS_FLAG 0x00000004 #endif static void *_align(void *ptr, unsigned int a) { register unsigned long agn = --a; return (void *) (((unsigned long) ptr + agn) & ~agn); } #ifdef DM_IOCTLS /* * Set number to NULL to populate _dm_bitset - otherwise first * match is returned. */ static int _get_proc_number(const char *file, const char *name, uint32_t *number) { FILE *fl; char nm[256]; int c; uint32_t num; if (!(fl = fopen(file, "r"))) { log_sys_error("fopen", file); return 0; } while (!feof(fl)) { if (fscanf(fl, "%d %255s\n", &num, &nm[0]) == 2) { if (!strcmp(name, nm)) { if (number) { *number = num; if (fclose(fl)) log_sys_error("fclose", file); return 1; } dm_bit_set(_dm_bitset, num); } } else do { c = fgetc(fl); } while (c != EOF && c != '\n'); } if (fclose(fl)) log_sys_error("fclose", file); if (number) { log_error("%s: No entry for %s found", file, name); return 0; } return 1; } static int _control_device_number(uint32_t *major, uint32_t *minor) { if (!_get_proc_number(PROC_DEVICES, MISC_NAME, major) || !_get_proc_number(PROC_MISC, DM_NAME, minor)) { *major = 0; return 0; } return 1; } /* * Returns 1 if exists; 0 if it doesn't; -1 if it's wrong */ static int _control_exists(const char *control, uint32_t major, uint32_t minor) { struct stat buf; if (stat(control, &buf) < 0) { if (errno != ENOENT) log_sys_error("stat", control); return 0; } if (!S_ISCHR(buf.st_mode)) { log_verbose("%s: Wrong inode type", control); if (!unlink(control)) return 0; log_sys_error("unlink", control); return -1; } if (major && buf.st_rdev != MKDEV(major, minor)) { log_verbose("%s: Wrong device number: (%u, %u) instead of " "(%u, %u)", control, MAJOR(buf.st_mode), MINOR(buf.st_mode), major, minor); if (!unlink(control)) return 0; log_sys_error("unlink", control); return -1; } return 1; } static int _create_control(const char *control, uint32_t major, uint32_t minor) { int ret; mode_t old_umask; if (!major) return 0; old_umask = umask(DM_DEV_DIR_UMASK); ret = dm_create_dir(dm_dir()); umask(old_umask); if (!ret) return 0; log_verbose("Creating device %s (%u, %u)", control, major, minor); old_umask = umask(0); if (mknod(control, S_IFCHR | DM_DEVICE_MODE, MKDEV(major, minor)) < 0) { umask(old_umask); log_sys_error("mknod", control); return 0; } umask(old_umask); if (chown(control, DM_DEVICE_UID, DM_DEVICE_GID) == -1) { log_sys_error("cbown", control); return 0; } #ifdef HAVE_SELINUX if (!dm_set_selinux_context(control, S_IFCHR)) { stack; return 0; } #endif return 1; } #endif /* * FIXME Update bitset in long-running process if dm claims new major numbers. */ static int _create_dm_bitset(void) { #ifdef DM_IOCTLS struct utsname uts; if (_dm_bitset || _dm_device_major) return 1; if (uname(&uts)) return 0; /* * 2.6 kernels are limited to one major number. * Assume 2.4 kernels are patched not to. * FIXME Check _dm_version and _dm_version_minor if 2.6 changes this. */ if (!strncmp(uts.release, "2.6.", 4)) _dm_multiple_major_support = 0; if (!_dm_multiple_major_support) { if (!_get_proc_number(PROC_DEVICES, DM_NAME, &_dm_device_major)) return 0; return 1; } /* Multiple major numbers supported */ if (!(_dm_bitset = dm_bitset_create(NULL, NUMBER_OF_MAJORS))) return 0; if (!_get_proc_number(PROC_DEVICES, DM_NAME, NULL)) { dm_bitset_destroy(_dm_bitset); _dm_bitset = NULL; return 0; } return 1; #else return 0; #endif } int dm_is_dm_major(uint32_t major) { if (!_create_dm_bitset()) return 0; if (_dm_multiple_major_support) return dm_bit(_dm_bitset, major) ? 1 : 0; else return (major == _dm_device_major) ? 1 : 0; } static int _open_control(void) { #ifdef DM_IOCTLS char control[PATH_MAX]; uint32_t major = 0, minor; if (_control_fd != -1) return 1; snprintf(control, sizeof(control), "%s/control", dm_dir()); if (!_control_device_number(&major, &minor)) log_error("Is device-mapper driver missing from kernel?"); if (!_control_exists(control, major, minor) && !_create_control(control, major, minor)) goto error; if ((_control_fd = open(control, O_RDWR)) < 0) { log_sys_error("open", control); goto error; } if (!_create_dm_bitset()) { log_error("Failed to set up list of device-mapper major numbers"); return 0; } return 1; error: log_error("Failure to communicate with kernel device-mapper driver."); return 0; #else return 1; #endif } void dm_task_destroy(struct dm_task *dmt) { struct target *t, *n; for (t = dmt->head; t; t = n) { n = t->next; dm_free(t->params); dm_free(t->type); dm_free(t); } if (dmt->dev_name) dm_free(dmt->dev_name); if (dmt->newname) dm_free(dmt->newname); if (dmt->message) dm_free(dmt->message); if (dmt->dmi.v4) dm_free(dmt->dmi.v4); if (dmt->uuid) dm_free(dmt->uuid); dm_free(dmt); } /* * Protocol Version 1 compatibility functions. */ #ifdef DM_COMPAT static int _dm_task_get_driver_version_v1(struct dm_task *dmt, char *version, size_t size) { unsigned int *v; if (!dmt->dmi.v1) { version[0] = '\0'; return 0; } v = dmt->dmi.v1->version; snprintf(version, size, "%u.%u.%u", v[0], v[1], v[2]); return 1; } /* Unmarshall the target info returned from a status call */ static int _unmarshal_status_v1(struct dm_task *dmt, struct dm_ioctl_v1 *dmi) { char *outbuf = (char *) dmi + dmi->data_start; char *outptr = outbuf; int32_t i; struct dm_target_spec_v1 *spec; for (i = 0; i < dmi->target_count; i++) { spec = (struct dm_target_spec_v1 *) outptr; if (!dm_task_add_target(dmt, spec->sector_start, (uint64_t) spec->length, spec->target_type, outptr + sizeof(*spec))) { return 0; } outptr = outbuf + spec->next; } return 1; } static int _dm_format_dev_v1(char *buf, int bufsize, uint32_t dev_major, uint32_t dev_minor) { int r; if (bufsize < 8) return 0; r = snprintf(buf, bufsize, "%03x:%03x", dev_major, dev_minor); if (r < 0 || r > bufsize - 1) return 0; return 1; } static int _dm_task_get_info_v1(struct dm_task *dmt, struct dm_info *info) { if (!dmt->dmi.v1) return 0; memset(info, 0, sizeof(*info)); info->exists = dmt->dmi.v1->flags & DM_EXISTS_FLAG ? 1 : 0; if (!info->exists) return 1; info->suspended = dmt->dmi.v1->flags & DM_SUSPEND_FLAG ? 1 : 0; info->read_only = dmt->dmi.v1->flags & DM_READONLY_FLAG ? 1 : 0; info->target_count = dmt->dmi.v1->target_count; info->open_count = dmt->dmi.v1->open_count; info->event_nr = 0; info->major = MAJOR(dmt->dmi.v1->dev); info->minor = MINOR(dmt->dmi.v1->dev); info->live_table = 1; info->inactive_table = 0; return 1; } static const char *_dm_task_get_name_v1(const struct dm_task *dmt) { return (dmt->dmi.v1->name); } static const char *_dm_task_get_uuid_v1(const struct dm_task *dmt) { return (dmt->dmi.v1->uuid); } static struct dm_deps *_dm_task_get_deps_v1(struct dm_task *dmt) { log_error("deps version 1 no longer supported by libdevmapper"); return NULL; } static struct dm_names *_dm_task_get_names_v1(struct dm_task *dmt) { return (struct dm_names *) (((void *) dmt->dmi.v1) + dmt->dmi.v1->data_start); } static void *_add_target_v1(struct target *t, void *out, void *end) { void *out_sp = out; struct dm_target_spec_v1 sp; size_t sp_size = sizeof(struct dm_target_spec_v1); int len; const char no_space[] = "Ran out of memory building ioctl parameter"; out += sp_size; if (out >= end) { log_error(no_space); return NULL; } sp.status = 0; sp.sector_start = t->start; sp.length = t->length; strncpy(sp.target_type, t->type, sizeof(sp.target_type)); len = strlen(t->params); if ((out + len + 1) >= end) { log_error(no_space); log_error("t->params= '%s'", t->params); return NULL; } strcpy((char *) out, t->params); out += len + 1; /* align next block */ out = _align(out, ALIGNMENT_V1); sp.next = out - out_sp; memcpy(out_sp, &sp, sp_size); return out; } static struct dm_ioctl_v1 *_flatten_v1(struct dm_task *dmt) { const size_t min_size = 16 * 1024; const int (*version)[3]; struct dm_ioctl_v1 *dmi; struct target *t; size_t len = sizeof(struct dm_ioctl_v1); void *b, *e; int count = 0; for (t = dmt->head; t; t = t->next) { len += sizeof(struct dm_target_spec_v1); len += strlen(t->params) + 1 + ALIGNMENT_V1; count++; } if (count && dmt->newname) { log_error("targets and newname are incompatible"); return NULL; } if (dmt->newname) len += strlen(dmt->newname) + 1; /* * Give len a minimum size so that we have space to store * dependencies or status information. */ if (len < min_size) len = min_size; if (!(dmi = dm_malloc(len))) return NULL; memset(dmi, 0, len); version = &_cmd_data_v1[dmt->type].version; dmi->version[0] = (*version)[0]; dmi->version[1] = (*version)[1]; dmi->version[2] = (*version)[2]; dmi->data_size = len; dmi->data_start = sizeof(struct dm_ioctl_v1); if (dmt->dev_name) strncpy(dmi->name, dmt->dev_name, sizeof(dmi->name)); if (dmt->type == DM_DEVICE_SUSPEND) dmi->flags |= DM_SUSPEND_FLAG; if (dmt->read_only) dmi->flags |= DM_READONLY_FLAG; if (dmt->minor >= 0) { if (dmt->major <= 0) { log_error("Missing major number for persistent device"); return NULL; } dmi->flags |= DM_PERSISTENT_DEV_FLAG; dmi->dev = MKDEV(dmt->major, dmt->minor); } if (dmt->uuid) strncpy(dmi->uuid, dmt->uuid, sizeof(dmi->uuid)); dmi->target_count = count; b = (void *) (dmi + 1); e = (void *) ((char *) dmi + len); for (t = dmt->head; t; t = t->next) if (!(b = _add_target_v1(t, b, e))) goto bad; if (dmt->newname) strcpy(b, dmt->newname); return dmi; bad: dm_free(dmi); return NULL; } static int _dm_names_v1(struct dm_ioctl_v1 *dmi) { const char *dev_dir = dm_dir(); int r = 1, len; const char *name; struct dirent *dirent; DIR *d; struct dm_names *names, *old_names = NULL; void *end = (void *) dmi + dmi->data_size; struct stat buf; char path[PATH_MAX]; log_warn("WARNING: Device list may be incomplete with interface " "version 1."); log_warn("Please upgrade your kernel device-mapper driver."); if (!(d = opendir(dev_dir))) { log_sys_error("opendir", dev_dir); return 0; } names = (struct dm_names *) ((void *) dmi + dmi->data_start); names->dev = 0; /* Flags no data */ while ((dirent = readdir(d))) { name = dirent->d_name; if (name[0] == '.' || !strcmp(name, "control")) continue; if (old_names) old_names->next = (uint32_t) ((void *) names - (void *) old_names); snprintf(path, sizeof(path), "%s/%s", dev_dir, name); if (stat(path, &buf)) { log_sys_error("stat", path); continue; } if (!S_ISBLK(buf.st_mode)) continue; names->dev = (uint64_t) buf.st_rdev; names->next = 0; len = strlen(name); if (((void *) (names + 1) + len + 1) >= end) { log_error("Insufficient buffer space for device list"); r = 0; break; } strcpy(names->name, name); old_names = names; names = _align((void *) ++names + len + 1, ALIGNMENT); } if (closedir(d)) log_sys_error("closedir", dev_dir); return r; } static int _dm_task_run_v1(struct dm_task *dmt) { struct dm_ioctl_v1 *dmi; unsigned int command; dmi = _flatten_v1(dmt); if (!dmi) { log_error("Couldn't create ioctl argument."); return 0; } if (!_open_control()) return 0; if ((unsigned) dmt->type >= (sizeof(_cmd_data_v1) / sizeof(*_cmd_data_v1))) { log_error("Internal error: unknown device-mapper task %d", dmt->type); goto bad; } command = _cmd_data_v1[dmt->type].cmd; if (dmt->type == DM_DEVICE_TABLE) dmi->flags |= DM_STATUS_TABLE_FLAG; log_debug("dm %s %s %s%s%s [%u]", _cmd_data_v1[dmt->type].name, dmi->name, dmi->uuid, dmt->newname ? " " : "", dmt->newname ? dmt->newname : "", dmi->data_size); if (dmt->type == DM_DEVICE_LIST) { if (!_dm_names_v1(dmi)) goto bad; } #ifdef DM_IOCTLS else if (ioctl(_control_fd, command, dmi) < 0) { if (_log_suppress) log_verbose("device-mapper: %s ioctl failed: %s", _cmd_data_v1[dmt->type].name, strerror(errno)); else log_error("device-mapper: %s ioctl failed: %s", _cmd_data_v1[dmt->type].name, strerror(errno)); goto bad; } #else /* Userspace alternative for testing */ #endif if (dmi->flags & DM_BUFFER_FULL_FLAG) /* FIXME Increase buffer size and retry operation (if query) */ log_error("WARNING: libdevmapper buffer too small for data"); switch (dmt->type) { case DM_DEVICE_CREATE: add_dev_node(dmt->dev_name, MAJOR(dmi->dev), MINOR(dmi->dev), dmt->uid, dmt->gid, dmt->mode, 0); break; case DM_DEVICE_REMOVE: rm_dev_node(dmt->dev_name, 0); break; case DM_DEVICE_RENAME: rename_dev_node(dmt->dev_name, dmt->newname, 0); break; case DM_DEVICE_MKNODES: if (dmi->flags & DM_EXISTS_FLAG) add_dev_node(dmt->dev_name, MAJOR(dmi->dev), MINOR(dmi->dev), dmt->uid, dmt->gid, dmt->mode, 0); else rm_dev_node(dmt->dev_name, 0); break; case DM_DEVICE_STATUS: case DM_DEVICE_TABLE: if (!_unmarshal_status_v1(dmt, dmi)) goto bad; break; case DM_DEVICE_SUSPEND: case DM_DEVICE_RESUME: dmt->type = DM_DEVICE_INFO; if (!dm_task_run(dmt)) goto bad; dm_free(dmi); /* We'll use what info returned */ return 1; } dmt->dmi.v1 = dmi; return 1; bad: dm_free(dmi); return 0; } #endif /* * Protocol Version 4 functions. */ int dm_task_get_driver_version(struct dm_task *dmt, char *version, size_t size) { unsigned *v; #ifdef DM_COMPAT if (_dm_version == 1) return _dm_task_get_driver_version_v1(dmt, version, size); #endif if (!dmt->dmi.v4) { version[0] = '\0'; return 0; } v = dmt->dmi.v4->version; snprintf(version, size, "%u.%u.%u", v[0], v[1], v[2]); _dm_version_minor = v[1]; _dm_version_patchlevel = v[2]; return 1; } static int _check_version(char *version, size_t size, int log_suppress) { struct dm_task *task; int r; if (!(task = dm_task_create(DM_DEVICE_VERSION))) { log_error("Failed to get device-mapper version"); version[0] = '\0'; return 0; } if (log_suppress) _log_suppress = 1; r = dm_task_run(task); dm_task_get_driver_version(task, version, size); dm_task_destroy(task); _log_suppress = 0; return r; } /* * Find out device-mapper's major version number the first time * this is called and whether or not we support it. */ int dm_check_version(void) { char libversion[64], dmversion[64]; const char *compat = ""; if (_version_checked) return _version_ok; _version_checked = 1; if (_check_version(dmversion, sizeof(dmversion), _dm_compat)) return 1; if (!_dm_compat) goto bad; log_verbose("device-mapper ioctl protocol version %u failed. " "Trying protocol version 1.", _dm_version); _dm_version = 1; if (_check_version(dmversion, sizeof(dmversion), 0)) { log_verbose("Using device-mapper ioctl protocol version 1"); return 1; } compat = "(compat)"; dm_get_library_version(libversion, sizeof(libversion)); log_error("Incompatible libdevmapper %s%s and kernel driver %s", libversion, compat, dmversion); bad: _version_ok = 0; return 0; } int dm_cookie_supported(void) { return (dm_check_version() && _dm_version >= 4 && _dm_version_minor >= 15); } void *dm_get_next_target(struct dm_task *dmt, void *next, uint64_t *start, uint64_t *length, char **target_type, char **params) { struct target *t = (struct target *) next; if (!t) t = dmt->head; if (!t) return NULL; *start = t->start; *length = t->length; *target_type = t->type; *params = t->params; return t->next; } /* Unmarshall the target info returned from a status call */ static int _unmarshal_status(struct dm_task *dmt, struct dm_ioctl *dmi) { char *outbuf = (char *) dmi + dmi->data_start; char *outptr = outbuf; uint32_t i; struct dm_target_spec *spec; for (i = 0; i < dmi->target_count; i++) { spec = (struct dm_target_spec *) outptr; if (!dm_task_add_target(dmt, spec->sector_start, spec->length, spec->target_type, outptr + sizeof(*spec))) { return 0; } outptr = outbuf + spec->next; } return 1; } int dm_format_dev(char *buf, int bufsize, uint32_t dev_major, uint32_t dev_minor) { int r; #ifdef DM_COMPAT if (_dm_version == 1) return _dm_format_dev_v1(buf, bufsize, dev_major, dev_minor); #endif if (bufsize < 8) return 0; r = snprintf(buf, (size_t) bufsize, "%u:%u", dev_major, dev_minor); if (r < 0 || r > bufsize - 1) return 0; return 1; } int dm_task_get_info(struct dm_task *dmt, struct dm_info *info) { #ifdef DM_COMPAT if (_dm_version == 1) return _dm_task_get_info_v1(dmt, info); #endif if (!dmt->dmi.v4) return 0; memset(info, 0, sizeof(*info)); info->exists = dmt->dmi.v4->flags & DM_EXISTS_FLAG ? 1 : 0; if (!info->exists) return 1; info->suspended = dmt->dmi.v4->flags & DM_SUSPEND_FLAG ? 1 : 0; info->read_only = dmt->dmi.v4->flags & DM_READONLY_FLAG ? 1 : 0; info->live_table = dmt->dmi.v4->flags & DM_ACTIVE_PRESENT_FLAG ? 1 : 0; info->inactive_table = dmt->dmi.v4->flags & DM_INACTIVE_PRESENT_FLAG ? 1 : 0; info->target_count = dmt->dmi.v4->target_count; info->open_count = dmt->dmi.v4->open_count; info->event_nr = dmt->dmi.v4->event_nr; info->major = MAJOR(dmt->dmi.v4->dev); info->minor = MINOR(dmt->dmi.v4->dev); return 1; } uint32_t dm_task_get_read_ahead(const struct dm_task *dmt, uint32_t *read_ahead) { const char *dev_name; *read_ahead = 0; #ifdef DM_COMPAT /* Not supporting this */ if (_dm_version == 1) return 1; #endif if (!dmt->dmi.v4 || !(dmt->dmi.v4->flags & DM_EXISTS_FLAG)) return 0; if (*dmt->dmi.v4->name) dev_name = dmt->dmi.v4->name; else if (dmt->dev_name) dev_name = dmt->dev_name; else { log_error("Get read ahead request failed: device name unrecorded."); return 0; } return get_dev_node_read_ahead(dev_name, read_ahead); } const char *dm_task_get_name(const struct dm_task *dmt) { #ifdef DM_COMPAT if (_dm_version == 1) return _dm_task_get_name_v1(dmt); #endif return (dmt->dmi.v4->name); } const char *dm_task_get_uuid(const struct dm_task *dmt) { #ifdef DM_COMPAT if (_dm_version == 1) return _dm_task_get_uuid_v1(dmt); #endif return (dmt->dmi.v4->uuid); } struct dm_deps *dm_task_get_deps(struct dm_task *dmt) { #ifdef DM_COMPAT if (_dm_version == 1) return _dm_task_get_deps_v1(dmt); #endif return (struct dm_deps *) (((void *) dmt->dmi.v4) + dmt->dmi.v4->data_start); } struct dm_names *dm_task_get_names(struct dm_task *dmt) { #ifdef DM_COMPAT if (_dm_version == 1) return _dm_task_get_names_v1(dmt); #endif return (struct dm_names *) (((void *) dmt->dmi.v4) + dmt->dmi.v4->data_start); } struct dm_versions *dm_task_get_versions(struct dm_task *dmt) { return (struct dm_versions *) (((void *) dmt->dmi.v4) + dmt->dmi.v4->data_start); } int dm_task_set_ro(struct dm_task *dmt) { dmt->read_only = 1; return 1; } int dm_task_set_read_ahead(struct dm_task *dmt, uint32_t read_ahead, uint32_t read_ahead_flags) { dmt->read_ahead = read_ahead; dmt->read_ahead_flags = read_ahead_flags; return 1; } int dm_task_suppress_identical_reload(struct dm_task *dmt) { dmt->suppress_identical_reload = 1; return 1; } int dm_task_set_newname(struct dm_task *dmt, const char *newname) { if (strchr(newname, '/')) { log_error("Name \"%s\" invalid. It contains \"/\".", newname); return 0; } if (strlen(newname) >= DM_NAME_LEN) { log_error("Name \"%s\" too long", newname); return 0; } if (!(dmt->newname = dm_strdup(newname))) { log_error("dm_task_set_newname: strdup(%s) failed", newname); return 0; } return 1; } int dm_task_set_message(struct dm_task *dmt, const char *message) { if (!(dmt->message = dm_strdup(message))) { log_error("dm_task_set_message: strdup(%s) failed", message); return 0; } return 1; } int dm_task_set_sector(struct dm_task *dmt, uint64_t sector) { dmt->sector = sector; return 1; } int dm_task_set_geometry(struct dm_task *dmt, const char *cylinders, const char *heads, const char *sectors, const char *start) { size_t len = strlen(cylinders) + 1 + strlen(heads) + 1 + strlen(sectors) + 1 + strlen(start) + 1; if (!(dmt->geometry = dm_malloc(len))) { log_error("dm_task_set_geometry: dm_malloc failed"); return 0; } if (sprintf(dmt->geometry, "%s %s %s %s", cylinders, heads, sectors, start) < 0) { log_error("dm_task_set_geometry: sprintf failed"); return 0; } return 1; } int dm_task_no_flush(struct dm_task *dmt) { dmt->no_flush = 1; return 1; } int dm_task_no_open_count(struct dm_task *dmt) { dmt->no_open_count = 1; return 1; } int dm_task_skip_lockfs(struct dm_task *dmt) { dmt->skip_lockfs = 1; return 1; } int dm_task_query_inactive_table(struct dm_task *dmt) { dmt->query_inactive_table = 1; return 1; } int dm_task_set_event_nr(struct dm_task *dmt, uint32_t event_nr) { dmt->event_nr = event_nr; return 1; } struct target *create_target(uint64_t start, uint64_t len, const char *type, const char *params) { struct target *t = dm_malloc(sizeof(*t)); if (!t) { log_error("create_target: malloc(%" PRIsize_t ") failed", sizeof(*t)); return NULL; } memset(t, 0, sizeof(*t)); if (!(t->params = dm_strdup(params))) { log_error("create_target: strdup(params) failed"); goto bad; } if (!(t->type = dm_strdup(type))) { log_error("create_target: strdup(type) failed"); goto bad; } t->start = start; t->length = len; return t; bad: dm_free(t->params); dm_free(t->type); dm_free(t); return NULL; } static void *_add_target(struct target *t, void *out, void *end) { void *out_sp = out; struct dm_target_spec sp; size_t sp_size = sizeof(struct dm_target_spec); int len; const char no_space[] = "Ran out of memory building ioctl parameter"; out += sp_size; if (out >= end) { log_error(no_space); return NULL; } sp.status = 0; sp.sector_start = t->start; sp.length = t->length; strncpy(sp.target_type, t->type, sizeof(sp.target_type)); len = strlen(t->params); if ((out + len + 1) >= end) { log_error(no_space); log_error("t->params= '%s'", t->params); return NULL; } strcpy((char *) out, t->params); out += len + 1; /* align next block */ out = _align(out, ALIGNMENT); sp.next = out - out_sp; memcpy(out_sp, &sp, sp_size); return out; } static int _lookup_dev_name(uint64_t dev, char *buf, size_t len) { struct dm_names *names; unsigned next = 0; struct dm_task *dmt; int r = 0; if (!(dmt = dm_task_create(DM_DEVICE_LIST))) return 0; if (!dm_task_run(dmt)) goto out; if (!(names = dm_task_get_names(dmt))) goto out; if (!names->dev) goto out; do { names = (void *) names + next; if (names->dev == dev) { strncpy(buf, names->name, len); r = 1; break; } next = names->next; } while (next); out: dm_task_destroy(dmt); return r; } static struct dm_ioctl *_flatten(struct dm_task *dmt, unsigned repeat_count) { const size_t min_size = 16 * 1024; const int (*version)[3]; struct dm_ioctl *dmi; struct target *t; struct dm_target_msg *tmsg; size_t len = sizeof(struct dm_ioctl); void *b, *e; int count = 0; for (t = dmt->head; t; t = t->next) { len += sizeof(struct dm_target_spec); len += strlen(t->params) + 1 + ALIGNMENT; count++; } if (count && (dmt->sector || dmt->message)) { log_error("targets and message are incompatible"); return NULL; } if (count && dmt->newname) { log_error("targets and newname are incompatible"); return NULL; } if (count && dmt->geometry) { log_error("targets and geometry are incompatible"); return NULL; } if (dmt->newname && (dmt->sector || dmt->message)) { log_error("message and newname are incompatible"); return NULL; } if (dmt->newname && dmt->geometry) { log_error("geometry and newname are incompatible"); return NULL; } if (dmt->geometry && (dmt->sector || dmt->message)) { log_error("geometry and message are incompatible"); return NULL; } if (dmt->sector && !dmt->message) { log_error("message is required with sector"); return NULL; } if (dmt->newname) len += strlen(dmt->newname) + 1; if (dmt->message) len += sizeof(struct dm_target_msg) + strlen(dmt->message) + 1; if (dmt->geometry) len += strlen(dmt->geometry) + 1; /* * Give len a minimum size so that we have space to store * dependencies or status information. */ if (len < min_size) len = min_size; /* Increase buffer size if repeating because buffer was too small */ while (repeat_count--) len *= 2; if (!(dmi = dm_malloc(len))) return NULL; memset(dmi, 0, len); version = &_cmd_data_v4[dmt->type].version; dmi->version[0] = (*version)[0]; dmi->version[1] = (*version)[1]; dmi->version[2] = (*version)[2]; dmi->data_size = len; dmi->data_start = sizeof(struct dm_ioctl); if (dmt->minor >= 0) { if (dmt->major <= 0) { log_error("Missing major number for persistent device."); goto bad; } if (!_dm_multiple_major_support && dmt->allow_default_major_fallback && dmt->major != _dm_device_major) { log_verbose("Overriding major number of %" PRIu32 " with %" PRIu32 " for persistent device.", dmt->major, _dm_device_major); dmt->major = _dm_device_major; } dmi->flags |= DM_PERSISTENT_DEV_FLAG; dmi->dev = MKDEV(dmt->major, dmt->minor); } /* Does driver support device number referencing? */ if (_dm_version_minor < 3 && !dmt->dev_name && !dmt->uuid && dmi->dev) { if (!_lookup_dev_name(dmi->dev, dmi->name, sizeof(dmi->name))) { log_error("Unable to find name for device (%" PRIu32 ":%" PRIu32 ")", dmt->major, dmt->minor); goto bad; } log_verbose("device (%" PRIu32 ":%" PRIu32 ") is %s " "for compatibility with old kernel", dmt->major, dmt->minor, dmi->name); } /* FIXME Until resume ioctl supplies name, use dev_name for readahead */ if (dmt->dev_name && (dmt->type != DM_DEVICE_RESUME || dmt->minor < 0 || dmt->major < 0)) strncpy(dmi->name, dmt->dev_name, sizeof(dmi->name)); if (dmt->uuid) strncpy(dmi->uuid, dmt->uuid, sizeof(dmi->uuid)); if (dmt->type == DM_DEVICE_SUSPEND) dmi->flags |= DM_SUSPEND_FLAG; if (dmt->no_flush) dmi->flags |= DM_NOFLUSH_FLAG; if (dmt->read_only) dmi->flags |= DM_READONLY_FLAG; if (dmt->skip_lockfs) dmi->flags |= DM_SKIP_LOCKFS_FLAG; if (dmt->query_inactive_table) { if (_dm_version_minor < 16) log_warn("WARNING: Inactive table query unsupported " "by kernel. It will use live table."); dmi->flags |= DM_QUERY_INACTIVE_TABLE_FLAG; } dmi->target_count = count; dmi->event_nr = dmt->event_nr; b = (void *) (dmi + 1); e = (void *) ((char *) dmi + len); for (t = dmt->head; t; t = t->next) if (!(b = _add_target(t, b, e))) goto bad; if (dmt->newname) strcpy(b, dmt->newname); if (dmt->message) { tmsg = (struct dm_target_msg *) b; tmsg->sector = dmt->sector; strcpy(tmsg->message, dmt->message); } if (dmt->geometry) strcpy(b, dmt->geometry); return dmi; bad: dm_free(dmi); return NULL; } static int _process_mapper_dir(struct dm_task *dmt) { struct dirent *dirent; DIR *d; const char *dir; int r = 1; dir = dm_dir(); if (!(d = opendir(dir))) { log_sys_error("opendir", dir); return 0; } while ((dirent = readdir(d))) { if (!strcmp(dirent->d_name, ".") || !strcmp(dirent->d_name, "..") || !strcmp(dirent->d_name, "control")) continue; dm_task_set_name(dmt, dirent->d_name); dm_task_run(dmt); } if (closedir(d)) log_sys_error("closedir", dir); return r; } static int _process_all_v4(struct dm_task *dmt) { struct dm_task *task; struct dm_names *names; unsigned next = 0; int r = 1; if (!(task = dm_task_create(DM_DEVICE_LIST))) return 0; if (!dm_task_run(task)) { r = 0; goto out; } if (!(names = dm_task_get_names(task))) { r = 0; goto out; } if (!names->dev) goto out; do { names = (void *) names + next; if (!dm_task_set_name(dmt, names->name)) { r = 0; goto out; } if (!dm_task_run(dmt)) r = 0; next = names->next; } while (next); out: dm_task_destroy(task); return r; } static int _mknodes_v4(struct dm_task *dmt) { (void) _process_mapper_dir(dmt); return _process_all_v4(dmt); } /* * If an operation that uses a cookie fails, decrement the * semaphore instead of udev. */ static int _udev_complete(struct dm_task *dmt) { uint32_t cookie; if (dmt->cookie_set) { /* strip flags from the cookie and use cookie magic instead */ cookie = (dmt->event_nr & ~DM_UDEV_FLAGS_MASK) | (DM_COOKIE_MAGIC << DM_UDEV_FLAGS_SHIFT); return dm_udev_complete(cookie); } return 1; } static int _create_and_load_v4(struct dm_task *dmt) { struct dm_task *task; int r; /* Use new task struct to create the device */ if (!(task = dm_task_create(DM_DEVICE_CREATE))) { log_error("Failed to create device-mapper task struct"); _udev_complete(dmt); return 0; } /* Copy across relevant fields */ if (dmt->dev_name && !dm_task_set_name(task, dmt->dev_name)) { dm_task_destroy(task); _udev_complete(dmt); return 0; } if (dmt->uuid && !dm_task_set_uuid(task, dmt->uuid)) { dm_task_destroy(task); _udev_complete(dmt); return 0; } task->major = dmt->major; task->minor = dmt->minor; task->uid = dmt->uid; task->gid = dmt->gid; task->mode = dmt->mode; /* FIXME: Just for udev_check in dm_task_run. Can we avoid this? */ task->event_nr = dmt->event_nr & DM_UDEV_FLAGS_MASK; task->cookie_set = dmt->cookie_set; r = dm_task_run(task); dm_task_destroy(task); if (!r) { _udev_complete(dmt); return 0; } /* Next load the table */ if (!(task = dm_task_create(DM_DEVICE_RELOAD))) { log_error("Failed to create device-mapper task struct"); _udev_complete(dmt); return 0; } /* Copy across relevant fields */ if (dmt->dev_name && !dm_task_set_name(task, dmt->dev_name)) { dm_task_destroy(task); _udev_complete(dmt); return 0; } task->read_only = dmt->read_only; task->head = dmt->head; task->tail = dmt->tail; r = dm_task_run(task); task->head = NULL; task->tail = NULL; dm_task_destroy(task); if (!r) { _udev_complete(dmt); goto revert; } /* Use the original structure last so the info will be correct */ dmt->type = DM_DEVICE_RESUME; dm_free(dmt->uuid); dmt->uuid = NULL; r = dm_task_run(dmt); if (r) return r; revert: dmt->type = DM_DEVICE_REMOVE; dm_free(dmt->uuid); dmt->uuid = NULL; dmt->cookie_set = 0; if (!dm_task_run(dmt)) log_error("Failed to revert device creation."); return r; } uint64_t dm_task_get_existing_table_size(struct dm_task *dmt) { return dmt->existing_table_size; } static int _reload_with_suppression_v4(struct dm_task *dmt) { struct dm_task *task; struct target *t1, *t2; int r; /* New task to get existing table information */ if (!(task = dm_task_create(DM_DEVICE_TABLE))) { log_error("Failed to create device-mapper task struct"); return 0; } /* Copy across relevant fields */ if (dmt->dev_name && !dm_task_set_name(task, dmt->dev_name)) { dm_task_destroy(task); return 0; } if (dmt->uuid && !dm_task_set_uuid(task, dmt->uuid)) { dm_task_destroy(task); return 0; } task->major = dmt->major; task->minor = dmt->minor; r = dm_task_run(task); if (!r) { dm_task_destroy(task); return r; } /* Store existing table size */ t2 = task->head; while (t2 && t2->next) t2 = t2->next; dmt->existing_table_size = t2 ? t2->start + t2->length : 0; if ((task->dmi.v4->flags & DM_READONLY_FLAG) ? 1 : 0 != dmt->read_only) goto no_match; t1 = dmt->head; t2 = task->head; while (t1 && t2) { while (t2->params[strlen(t2->params) - 1] == ' ') t2->params[strlen(t2->params) - 1] = '\0'; if ((t1->start != t2->start) || (t1->length != t2->length) || (strcmp(t1->type, t2->type)) || (strcmp(t1->params, t2->params))) goto no_match; t1 = t1->next; t2 = t2->next; } if (!t1 && !t2) { dmt->dmi.v4 = task->dmi.v4; task->dmi.v4 = NULL; dm_task_destroy(task); return 1; } no_match: dm_task_destroy(task); /* Now do the original reload */ dmt->suppress_identical_reload = 0; r = dm_task_run(dmt); return r; } static struct dm_ioctl *_do_dm_ioctl(struct dm_task *dmt, unsigned command, unsigned repeat_count) { struct dm_ioctl *dmi; dmi = _flatten(dmt, repeat_count); if (!dmi) { log_error("Couldn't create ioctl argument."); return NULL; } if (dmt->type == DM_DEVICE_TABLE) dmi->flags |= DM_STATUS_TABLE_FLAG; dmi->flags |= DM_EXISTS_FLAG; /* FIXME */ if (dmt->no_open_count) dmi->flags |= DM_SKIP_BDGET_FLAG; /* * Prevent udev vs. libdevmapper race when processing nodes and * symlinks. This can happen when the udev rules are installed and * udev synchronisation code is enabled in libdevmapper but the * software using libdevmapper does not make use of it (by not calling * dm_task_set_cookie before). We need to instruct the udev rules not * to be applied at all in this situation so we can gracefully fallback * to libdevmapper's node and symlink creation code. */ if (dm_udev_get_sync_support() && !dmt->cookie_set && (dmt->type == DM_DEVICE_RESUME || dmt->type == DM_DEVICE_REMOVE || dmt->type == DM_DEVICE_RENAME)) { log_debug("Cookie value is not set while trying to call " "DM_DEVICE_RESUME, DM_DEVICE_REMOVE or DM_DEVICE_RENAME " "ioctl. Please, consider using libdevmapper's udev " "synchronisation interface or disable it explicitly " "by calling dm_udev_set_sync_support(0)."); log_debug("Switching off device-mapper and all subsystem related " "udev rules. Falling back to libdevmapper node creation."); /* * Disable general dm and subsystem rules but keep dm disk rules * if not flagged out explicitly before. We need /dev/disk content * for the software that expects it. */ dmi->event_nr |= (DM_UDEV_DISABLE_DM_RULES_FLAG | DM_UDEV_DISABLE_SUBSYSTEM_RULES_FLAG) << DM_UDEV_FLAGS_SHIFT; } log_debug("dm %s %s %s%s%s %s%.0d%s%.0d%s" "%s%c%c%s%s %.0" PRIu64 " %s [%u]", _cmd_data_v4[dmt->type].name, dmi->name, dmi->uuid, dmt->newname ? " " : "", dmt->newname ? dmt->newname : "", dmt->major > 0 ? "(" : "", dmt->major > 0 ? dmt->major : 0, dmt->major > 0 ? ":" : "", dmt->minor > 0 ? dmt->minor : 0, dmt->major > 0 && dmt->minor == 0 ? "0" : "", dmt->major > 0 ? ") " : "", dmt->no_open_count ? 'N' : 'O', dmt->no_flush ? 'N' : 'F', dmt->skip_lockfs ? "S " : "", dmt->query_inactive_table ? "I " : "", dmt->sector, dmt->message ? dmt->message : "", dmi->data_size); #ifdef DM_IOCTLS if (ioctl(_control_fd, command, dmi) < 0) { if (errno == ENXIO && ((dmt->type == DM_DEVICE_INFO) || (dmt->type == DM_DEVICE_MKNODES) || (dmt->type == DM_DEVICE_STATUS))) dmi->flags &= ~DM_EXISTS_FLAG; /* FIXME */ else { if (_log_suppress) log_verbose("device-mapper: %s ioctl " "failed: %s", _cmd_data_v4[dmt->type].name, strerror(errno)); else log_error("device-mapper: %s ioctl " "failed: %s", _cmd_data_v4[dmt->type].name, strerror(errno)); dm_free(dmi); return NULL; } } #else /* Userspace alternative for testing */ #endif return dmi; } void dm_task_update_nodes(void) { update_devs(); } int dm_task_run(struct dm_task *dmt) { struct dm_ioctl *dmi; unsigned command; int check_udev; #ifdef DM_COMPAT if (_dm_version == 1) return _dm_task_run_v1(dmt); #endif if ((unsigned) dmt->type >= (sizeof(_cmd_data_v4) / sizeof(*_cmd_data_v4))) { log_error("Internal error: unknown device-mapper task %d", dmt->type); return 0; } command = _cmd_data_v4[dmt->type].cmd; /* Old-style creation had a table supplied */ if (dmt->type == DM_DEVICE_CREATE && dmt->head) return _create_and_load_v4(dmt); if (dmt->type == DM_DEVICE_MKNODES && !dmt->dev_name && !dmt->uuid && dmt->major <= 0) return _mknodes_v4(dmt); if ((dmt->type == DM_DEVICE_RELOAD) && dmt->suppress_identical_reload) return _reload_with_suppression_v4(dmt); if (!_open_control()) { _udev_complete(dmt); return 0; } /* FIXME Detect and warn if cookie set but should not be. */ repeat_ioctl: if (!(dmi = _do_dm_ioctl(dmt, command, _ioctl_buffer_double_factor))) { _udev_complete(dmt); return 0; } if (dmi->flags & DM_BUFFER_FULL_FLAG) { switch (dmt->type) { case DM_DEVICE_LIST_VERSIONS: case DM_DEVICE_LIST: case DM_DEVICE_DEPS: case DM_DEVICE_STATUS: case DM_DEVICE_TABLE: case DM_DEVICE_WAITEVENT: _ioctl_buffer_double_factor++; dm_free(dmi); goto repeat_ioctl; default: log_error("WARNING: libdevmapper buffer too small for data"); } } check_udev = dmt->cookie_set && !(dmt->event_nr >> DM_UDEV_FLAGS_SHIFT & DM_UDEV_DISABLE_DM_RULES_FLAG); switch (dmt->type) { case DM_DEVICE_CREATE: if (dmt->dev_name && *dmt->dev_name) add_dev_node(dmt->dev_name, MAJOR(dmi->dev), MINOR(dmi->dev), dmt->uid, dmt->gid, dmt->mode, check_udev); break; case DM_DEVICE_REMOVE: /* FIXME Kernel needs to fill in dmi->name */ if (dmt->dev_name) rm_dev_node(dmt->dev_name, check_udev); break; case DM_DEVICE_RENAME: /* FIXME Kernel needs to fill in dmi->name */ if (dmt->dev_name) rename_dev_node(dmt->dev_name, dmt->newname, check_udev); break; case DM_DEVICE_RESUME: /* FIXME Kernel needs to fill in dmi->name */ set_dev_node_read_ahead(dmt->dev_name, dmt->read_ahead, dmt->read_ahead_flags); break; case DM_DEVICE_MKNODES: if (dmi->flags & DM_EXISTS_FLAG) add_dev_node(dmi->name, MAJOR(dmi->dev), MINOR(dmi->dev), dmt->uid, dmt->gid, dmt->mode, 0); else if (dmt->dev_name) rm_dev_node(dmt->dev_name, 0); break; case DM_DEVICE_STATUS: case DM_DEVICE_TABLE: case DM_DEVICE_WAITEVENT: if (!_unmarshal_status(dmt, dmi)) goto bad; break; } /* Was structure reused? */ if (dmt->dmi.v4) dm_free(dmt->dmi.v4); dmt->dmi.v4 = dmi; return 1; bad: dm_free(dmi); return 0; } void dm_lib_release(void) { if (_control_fd != -1) { close(_control_fd); _control_fd = -1; } update_devs(); } void dm_pools_check_leaks(void); void dm_lib_exit(void) { dm_lib_release(); if (_dm_bitset) dm_bitset_destroy(_dm_bitset); _dm_bitset = NULL; dm_pools_check_leaks(); dm_dump_memory(); _version_ok = 1; _version_checked = 0; }