/* * Copyright (C) 2001-2004 Sistina Software, Inc. All rights reserved. * Copyright (C) 2004-2012 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "libdm/misc/dmlib.h" #include "libdm-targets.h" #include "libdm-common.h" #include "libdm/misc/kdev_t.h" #include "libdm/misc/dm-ioctl.h" #include #include #include #include #include #ifdef UDEV_SYNC_SUPPORT # include # include # include # include #endif #ifdef __linux__ # include #endif #ifdef HAVE_SELINUX # include #endif #ifdef HAVE_SELINUX_LABEL_H # include #endif #define DM_DEFAULT_NAME_MANGLING_MODE_ENV_VAR_NAME "DM_DEFAULT_NAME_MANGLING_MODE" #define DEV_DIR "/dev/" #ifdef UDEV_SYNC_SUPPORT #ifdef _SEM_SEMUN_UNDEFINED union semun { int val; /* value for SETVAL */ struct semid_ds *buf; /* buffer for IPC_STAT & IPC_SET */ unsigned short int *array; /* array for GETALL & SETALL */ struct seminfo *__buf; /* buffer for IPC_INFO */ }; #endif #endif static char _dm_dir[PATH_MAX] = DEV_DIR DM_DIR; static char _sysfs_dir[PATH_MAX] = "/sys/"; static char _path0[PATH_MAX]; /* path buffer, safe 4kB on stack */ static const char _mountinfo[] = "/proc/self/mountinfo"; #define DM_MAX_UUID_PREFIX_LEN 15 static char _default_uuid_prefix[DM_MAX_UUID_PREFIX_LEN + 1] = "LVM-"; static int _verbose = 0; static int _suspended_dev_counter = 0; static dm_string_mangling_t _name_mangling_mode = DEFAULT_DM_NAME_MANGLING; #ifdef HAVE_SELINUX_LABEL_H static struct selabel_handle *_selabel_handle = NULL; #endif static int _udev_disabled = 0; #ifdef UDEV_SYNC_SUPPORT static int _semaphore_supported = -1; static int _udev_running = -1; static int _sync_with_udev = 1; static int _udev_checking = 1; #endif void dm_lib_init(void) { const char *env; if (getenv("DM_DISABLE_UDEV")) _udev_disabled = 1; _name_mangling_mode = DEFAULT_DM_NAME_MANGLING; if ((env = getenv(DM_DEFAULT_NAME_MANGLING_MODE_ENV_VAR_NAME))) { if (!strcasecmp(env, "none")) _name_mangling_mode = DM_STRING_MANGLING_NONE; else if (!strcasecmp(env, "auto")) _name_mangling_mode = DM_STRING_MANGLING_AUTO; else if (!strcasecmp(env, "hex")) _name_mangling_mode = DM_STRING_MANGLING_HEX; } } /* * Library users can provide their own logging * function. */ __attribute__((format(printf, 5, 0))) static void _default_log_line(int level, const char *file, int line, int dm_errno_or_class, const char *f, va_list ap) { static int _abort_on_internal_errors = -1; static int _debug_with_line_numbers = -1; FILE *out = log_stderr(level) ? stderr : stdout; level = log_level(level); if (level <= _LOG_WARN || _verbose) { if (level < _LOG_WARN) out = stderr; if (_debug_with_line_numbers < 0) /* Set when env DM_DEBUG_WITH_LINE_NUMBERS is not "0" */ _debug_with_line_numbers = strcmp(getenv("DM_DEBUG_WITH_LINE_NUMBERS") ? : "0", "0"); if (_debug_with_line_numbers) fprintf(out, "%s:%d ", file, line); vfprintf(out, f, ap); fputc('\n', out); } if (_abort_on_internal_errors < 0) /* Set when env DM_ABORT_ON_INTERNAL_ERRORS is not "0" */ _abort_on_internal_errors = strcmp(getenv("DM_ABORT_ON_INTERNAL_ERRORS") ? : "0", "0"); if (_abort_on_internal_errors && !strncmp(f, INTERNAL_ERROR, sizeof(INTERNAL_ERROR) - 1)) abort(); } __attribute__((format(printf, 5, 6))) static void _default_log_with_errno(int level, const char *file, int line, int dm_errno_or_class, const char *f, ...) { va_list ap; va_start(ap, f); _default_log_line(level, file, line, dm_errno_or_class, f, ap); va_end(ap); } __attribute__((format(printf, 4, 5))) static void _default_log(int level, const char *file, int line, const char *f, ...) { va_list ap; va_start(ap, f); _default_log_line(level, file, line, 0, f, ap); va_end(ap); } dm_log_fn dm_log = _default_log; dm_log_with_errno_fn dm_log_with_errno = _default_log_with_errno; /* * Wrapper function to reformat new messages to and * old style logging which had not used errno parameter * * As we cannot simply pass '...' to old function we * need to process arg list locally and just pass '%s' + buffer */ __attribute__((format(printf, 5, 6))) static void _log_to_default_log(int level, const char *file, int line, int dm_errno_or_class, const char *f, ...) { int n; va_list ap; char buf[2 * PATH_MAX + 256]; /* big enough for most messages */ va_start(ap, f); n = vsnprintf(buf, sizeof(buf), f, ap); va_end(ap); if (n > 0) /* Could be truncated */ dm_log(level, file, line, "%s", buf); } /* * Wrapper function take 'old' style message without errno * and log it via new logging function with errno arg * * This minor case may happen if new libdm is used with old * recompiled tool that would decided to use new logging, * but still would like to use old binary plugins. */ __attribute__((format(printf, 4, 5))) static void _log_to_default_log_with_errno(int level, const char *file, int line, const char *f, ...) { int n; va_list ap; char buf[2 * PATH_MAX + 256]; /* big enough for most messages */ va_start(ap, f); n = vsnprintf(buf, sizeof(buf), f, ap); va_end(ap); if (n > 0) /* Could be truncated */ dm_log_with_errno(level, file, line, 0, "%s", buf); } void dm_log_init(dm_log_fn fn) { if (fn) { dm_log = fn; dm_log_with_errno = _log_to_default_log; } else { dm_log = _default_log; dm_log_with_errno = _default_log_with_errno; } } int dm_log_is_non_default(void) { return (dm_log == _default_log && dm_log_with_errno == _default_log_with_errno) ? 0 : 1; } void dm_log_with_errno_init(dm_log_with_errno_fn fn) { if (fn) { dm_log = _log_to_default_log_with_errno; dm_log_with_errno = fn; } else { dm_log = _default_log; dm_log_with_errno = _default_log_with_errno; } } void dm_log_init_verbose(int level) { _verbose = level; } static int _build_dev_path(char *buffer, size_t len, const char *dev_name) { int r; /* If there's a /, assume caller knows what they're doing */ if (strchr(dev_name, '/')) r = dm_strncpy(buffer, dev_name, len); else r = (dm_snprintf(buffer, len, "%s/%s", _dm_dir, dev_name) < 0) ? 0 : 1; if (!r) log_error("Failed to build dev path for \"%s\".", dev_name); return r; } int dm_get_library_version(char *version, size_t size) { return dm_strncpy(version, DM_LIB_VERSION, size); } void inc_suspended(void) { _suspended_dev_counter++; log_debug_activation("Suspended device counter increased to %d", _suspended_dev_counter); } void dec_suspended(void) { if (!_suspended_dev_counter) { log_error("Attempted to decrement suspended device counter below zero."); return; } _suspended_dev_counter--; log_debug_activation("Suspended device counter reduced to %d", _suspended_dev_counter); } int dm_get_suspended_counter(void) { return _suspended_dev_counter; } int dm_set_name_mangling_mode(dm_string_mangling_t name_mangling_mode) { _name_mangling_mode = name_mangling_mode; return 1; } dm_string_mangling_t dm_get_name_mangling_mode(void) { return _name_mangling_mode; } struct dm_task *dm_task_create(int type) { struct dm_task *dmt = dm_zalloc(sizeof(*dmt)); if (!dmt) { log_error("dm_task_create: malloc(%" PRIsize_t ") failed", sizeof(*dmt)); return NULL; } if (!dm_check_version()) { dm_free(dmt); return_NULL; } dmt->type = type; dmt->minor = -1; dmt->major = -1; dmt->allow_default_major_fallback = 1; dmt->uid = DM_DEVICE_UID; dmt->gid = DM_DEVICE_GID; dmt->mode = DM_DEVICE_MODE; dmt->no_open_count = 0; dmt->read_ahead = DM_READ_AHEAD_AUTO; dmt->read_ahead_flags = 0; dmt->event_nr = 0; dmt->cookie_set = 0; dmt->query_inactive_table = 0; dmt->new_uuid = 0; dmt->secure_data = 0; dmt->record_timestamp = 0; dmt->ima_measurement = 0; return dmt; } /* * Find the name associated with a given device number by scanning _dm_dir. */ static int _find_dm_name_of_device(dev_t st_rdev, char *buf, size_t buf_len) { const char *name; char path[PATH_MAX]; struct dirent *dirent; DIR *d; struct stat st; int r = 0; if (!(d = opendir(_dm_dir))) { log_sys_error("opendir", _dm_dir); return 0; } while ((dirent = readdir(d))) { name = dirent->d_name; if (!strcmp(name, ".") || !strcmp(name, "..")) continue; if (dm_snprintf(path, sizeof(path), "%s/%s", _dm_dir, name) == -1) { log_error("Couldn't create path for %s", name); continue; } if (stat(path, &st)) continue; if (st.st_rdev == st_rdev) { strncpy(buf, name, buf_len); r = 1; break; } } if (closedir(d)) log_sys_debug("closedir", _dm_dir); return r; } static int _is_whitelisted_char(char c) { /* * Actually, DM supports any character in a device name. * This whitelist is just for proper integration with udev. */ if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || strchr("#+-.:=@_", c) != NULL) return 1; return 0; } int check_multiple_mangled_string_allowed(const char *str, const char *str_name, dm_string_mangling_t mode) { if (mode == DM_STRING_MANGLING_AUTO && strstr(str, "\\x5cx")) { log_error("The %s \"%s\" seems to be mangled more than once. " "This is not allowed in auto mode.", str_name, str); return 0; } return 1; } /* * Mangle all characters in the input string which are not on a whitelist * with '\xNN' format where NN is the hex value of the character. */ int mangle_string(const char *str, const char *str_name, size_t len, char *buf, size_t buf_len, dm_string_mangling_t mode) { int need_mangling = -1; /* -1 don't know yet, 0 no, 1 yes */ size_t i, j; if (!str || !buf) return -1; /* Is there anything to do at all? */ if (!*str || !len) return 0; if (buf_len < DM_NAME_LEN) { log_error(INTERNAL_ERROR "mangle_string: supplied buffer too small"); return -1; } if (mode == DM_STRING_MANGLING_NONE) mode = DM_STRING_MANGLING_AUTO; for (i = 0, j = 0; str[i]; i++) { if (mode == DM_STRING_MANGLING_AUTO) { /* * Detect already mangled part of the string and keep it. * Return error on mixture of mangled/not mangled! */ if (str[i] == '\\' && str[i+1] == 'x') { if ((len - i < 4) || (need_mangling == 1)) goto bad1; if (buf_len - j < 4) goto bad2; memcpy(&buf[j], &str[i], 4); i+=3; j+=4; need_mangling = 0; continue; } } if (_is_whitelisted_char(str[i])) { /* whitelisted, keep it. */ if (buf_len - j < 1) goto bad2; buf[j] = str[i]; j++; } else { /* * Not on a whitelist, mangle it. * Return error on mixture of mangled/not mangled * unless a DM_STRING_MANGLING_HEX is used!. */ if ((mode != DM_STRING_MANGLING_HEX) && (need_mangling == 0)) goto bad1; if (buf_len - j < 4) goto bad2; sprintf(&buf[j], "\\x%02x", (unsigned char) str[i]); j+=4; need_mangling = 1; } } if (buf_len - j < 1) goto bad2; buf[j] = '\0'; /* All chars in the string whitelisted? */ if (need_mangling == -1) need_mangling = 0; return need_mangling; bad1: log_error("The %s \"%s\" contains mixed mangled and unmangled " "characters or it's already mangled improperly.", str_name, str); return -1; bad2: log_error("Mangled form of the %s too long for \"%s\".", str_name, str); return -1; } /* * Try to unmangle supplied string. * Return value: -1 on error, 0 when no unmangling needed, 1 when unmangling applied */ int unmangle_string(const char *str, const char *str_name, size_t len, char *buf, size_t buf_len, dm_string_mangling_t mode) { int strict = mode != DM_STRING_MANGLING_NONE; char str_rest[DM_NAME_LEN]; size_t i, j; unsigned int code; int r = 0; if (!str || !buf) return -1; /* Is there anything to do at all? */ if (!*str || !len) return 0; if (buf_len < DM_NAME_LEN) { log_error(INTERNAL_ERROR "unmangle_string: supplied buffer too small"); return -1; } for (i = 0, j = 0; str[i]; i++, j++) { if (strict && !(_is_whitelisted_char(str[i]) || str[i]=='\\')) { log_error("The %s \"%s\" should be mangled but " "it contains blacklisted characters.", str_name, str); j=0; r=-1; goto out; } if (str[i] == '\\' && str[i+1] == 'x') { if (!sscanf(&str[i+2], "%2x%" DM_TO_STRING(DM_NAME_LEN) "s", &code, str_rest)) { log_debug_activation("Hex encoding mismatch detected in %s \"%s\" " "while trying to unmangle it.", str_name, str); goto out; } buf[j] = (unsigned char) code; /* skip the encoded part we've just decoded! */ i+= 3; /* unmangling applied */ r = 1; } else buf[j] = str[i]; } out: buf[j] = '\0'; return r; } static int _dm_task_set_name(struct dm_task *dmt, const char *name, dm_string_mangling_t mangling_mode) { char mangled_name[DM_NAME_LEN]; int r = 0; dm_free(dmt->dev_name); dmt->dev_name = NULL; dm_free(dmt->mangled_dev_name); dmt->mangled_dev_name = NULL; if (strlen(name) >= DM_NAME_LEN) { log_error("Name \"%s\" too long.", name); return 0; } if (!check_multiple_mangled_string_allowed(name, "name", mangling_mode)) return_0; if (mangling_mode != DM_STRING_MANGLING_NONE && (r = mangle_string(name, "name", strlen(name), mangled_name, sizeof(mangled_name), mangling_mode)) < 0) { log_error("Failed to mangle device name \"%s\".", name); return 0; } /* Store mangled_dev_name only if it differs from dev_name! */ if (r) { log_debug_activation("Device name mangled [%s]: %s --> %s", mangling_mode == DM_STRING_MANGLING_AUTO ? "auto" : "hex", name, mangled_name); if (!(dmt->mangled_dev_name = dm_strdup(mangled_name))) { log_error("_dm_task_set_name: dm_strdup(%s) failed", mangled_name); return 0; } } if (!(dmt->dev_name = dm_strdup(name))) { log_error("_dm_task_set_name: strdup(%s) failed", name); return 0; } return 1; } static int _dm_task_set_name_from_path(struct dm_task *dmt, const char *path, const char *name) { char buf[PATH_MAX]; struct stat st1, st2; const char *final_name = NULL; size_t len; if (dmt->type == DM_DEVICE_CREATE) { log_error("Name \"%s\" invalid. It contains \"/\".", path); return 0; } if (!stat(path, &st1)) { /* * Found directly. * If supplied path points to same device as last component * under /dev/mapper, use that name directly. */ if (dm_snprintf(buf, sizeof(buf), "%s/%s", _dm_dir, name) == -1) { log_error("Couldn't create path for %s", name); return 0; } if (!stat(buf, &st2) && (st1.st_rdev == st2.st_rdev)) final_name = name; } else { /* Not found. */ /* If there is exactly one '/' try a prefix of /dev */ if ((len = strlen(path)) < 3 || path[0] == '/' || dm_count_chars(path, len, '/') != 1) { log_error("Device %s not found", path); return 0; } if (dm_snprintf(buf, sizeof(buf), "%s/../%s", _dm_dir, path) == -1) { log_error("Couldn't create /dev path for %s", path); return 0; } if (stat(buf, &st1)) { log_error("Device %s not found", path); return 0; } /* Found */ } /* * If we don't have the dm name yet, Call _find_dm_name_of_device() to * scan _dm_dir for a match. */ if (!final_name) { if (_find_dm_name_of_device(st1.st_rdev, buf, sizeof(buf))) final_name = buf; else { log_error("Device %s not found", name); return 0; } } /* This is an already existing path - do not mangle! */ return _dm_task_set_name(dmt, final_name, DM_STRING_MANGLING_NONE); } int dm_task_set_name(struct dm_task *dmt, const char *name) { char *pos; /* Path supplied for existing device? */ if ((pos = strrchr(name, '/'))) return _dm_task_set_name_from_path(dmt, name, pos + 1); return _dm_task_set_name(dmt, name, dm_get_name_mangling_mode()); } const char *dm_task_get_name(const struct dm_task *dmt) { return (dmt->dmi.v4->name); } static char *_task_get_string_mangled(const char *str, const char *str_name, char *buf, size_t buf_size, dm_string_mangling_t mode) { char *rs; int r; if ((r = mangle_string(str, str_name, strlen(str), buf, buf_size, mode)) < 0) return NULL; if (!(rs = r ? dm_strdup(buf) : dm_strdup(str))) log_error("_task_get_string_mangled: dm_strdup failed"); return rs; } static char *_task_get_string_unmangled(const char *str, const char *str_name, char *buf, size_t buf_size, dm_string_mangling_t mode) { char *rs; int r = 0; /* * Unless the mode used is 'none', the string * is *already* unmangled on ioctl return! */ if (mode == DM_STRING_MANGLING_NONE && (r = unmangle_string(str, str_name, strlen(str), buf, buf_size, mode)) < 0) return NULL; if (!(rs = r ? dm_strdup(buf) : dm_strdup(str))) log_error("_task_get_string_unmangled: dm_strdup failed"); return rs; } char *dm_task_get_name_mangled(const struct dm_task *dmt) { const char *s = dm_task_get_name(dmt); char buf[DM_NAME_LEN]; char *rs; if (!(rs = _task_get_string_mangled(s, "name", buf, sizeof(buf), dm_get_name_mangling_mode()))) log_error("Failed to mangle device name \"%s\".", s); return rs; } char *dm_task_get_name_unmangled(const struct dm_task *dmt) { const char *s = dm_task_get_name(dmt); char buf[DM_NAME_LEN]; char *rs; if (!(rs = _task_get_string_unmangled(s, "name", buf, sizeof(buf), dm_get_name_mangling_mode()))) log_error("Failed to unmangle device name \"%s\".", s); return rs; } const char *dm_task_get_uuid(const struct dm_task *dmt) { return (dmt->dmi.v4->uuid); } char *dm_task_get_uuid_mangled(const struct dm_task *dmt) { const char *s = dm_task_get_uuid(dmt); char buf[DM_UUID_LEN]; char *rs; if (!(rs = _task_get_string_mangled(s, "UUID", buf, sizeof(buf), dm_get_name_mangling_mode()))) log_error("Failed to mangle device uuid \"%s\".", s); return rs; } char *dm_task_get_uuid_unmangled(const struct dm_task *dmt) { const char *s = dm_task_get_uuid(dmt); char buf[DM_UUID_LEN]; char *rs; if (!(rs = _task_get_string_unmangled(s, "UUID", buf, sizeof(buf), dm_get_name_mangling_mode()))) log_error("Failed to unmangle device uuid \"%s\".", s); return rs; } int dm_task_set_newname(struct dm_task *dmt, const char *newname) { dm_string_mangling_t mangling_mode = dm_get_name_mangling_mode(); char mangled_name[DM_NAME_LEN]; int r = 0; 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 (!*newname) { log_error("Non empty new name is required."); return 0; } if (!check_multiple_mangled_string_allowed(newname, "new name", mangling_mode)) return_0; if (mangling_mode != DM_STRING_MANGLING_NONE && (r = mangle_string(newname, "new name", strlen(newname), mangled_name, sizeof(mangled_name), mangling_mode)) < 0) { log_error("Failed to mangle new device name \"%s\"", newname); return 0; } if (r) { log_debug_activation("New device name mangled [%s]: %s --> %s", mangling_mode == DM_STRING_MANGLING_AUTO ? "auto" : "hex", newname, mangled_name); newname = mangled_name; } dm_free(dmt->newname); if (!(dmt->newname = dm_strdup(newname))) { log_error("dm_task_set_newname: strdup(%s) failed", newname); return 0; } dmt->new_uuid = 0; return 1; } int dm_task_set_uuid(struct dm_task *dmt, const char *uuid) { char mangled_uuid[DM_UUID_LEN]; dm_string_mangling_t mangling_mode = dm_get_name_mangling_mode(); int r = 0; dm_free(dmt->uuid); dmt->uuid = NULL; dm_free(dmt->mangled_uuid); dmt->mangled_uuid = NULL; if (!check_multiple_mangled_string_allowed(uuid, "UUID", mangling_mode)) return_0; if (mangling_mode != DM_STRING_MANGLING_NONE && (r = mangle_string(uuid, "UUID", strlen(uuid), mangled_uuid, sizeof(mangled_uuid), mangling_mode)) < 0) { log_error("Failed to mangle device uuid \"%s\".", uuid); return 0; } if (r) { log_debug_activation("Device uuid mangled [%s]: %s --> %s", mangling_mode == DM_STRING_MANGLING_AUTO ? "auto" : "hex", uuid, mangled_uuid); if (!(dmt->mangled_uuid = dm_strdup(mangled_uuid))) { log_error("dm_task_set_uuid: dm_strdup(%s) failed", mangled_uuid); return 0; } } if (!(dmt->uuid = dm_strdup(uuid))) { log_error("dm_task_set_uuid: strdup(%s) failed", uuid); return 0; } return 1; } int dm_task_set_major(struct dm_task *dmt, int major) { dmt->major = major; dmt->allow_default_major_fallback = 0; return 1; } int dm_task_set_minor(struct dm_task *dmt, int minor) { dmt->minor = minor; return 1; } int dm_task_set_major_minor(struct dm_task *dmt, int major, int minor, int allow_default_major_fallback) { dmt->major = major; dmt->minor = minor; dmt->allow_default_major_fallback = allow_default_major_fallback; return 1; } int dm_task_set_uid(struct dm_task *dmt, uid_t uid) { dmt->uid = uid; return 1; } int dm_task_set_gid(struct dm_task *dmt, gid_t gid) { dmt->gid = gid; return 1; } int dm_task_set_mode(struct dm_task *dmt, mode_t mode) { dmt->mode = mode; return 1; } int dm_task_enable_checks(struct dm_task *dmt) { dmt->enable_checks = 1; return 1; } int dm_task_add_target(struct dm_task *dmt, uint64_t start, uint64_t size, const char *ttype, const char *params) { struct target *t = create_target(start, size, ttype, params); if (!t) return_0; if (!dmt->head) dmt->head = dmt->tail = t; else { dmt->tail->next = t; dmt->tail = t; } return 1; } #ifdef HAVE_SELINUX static int _selabel_lookup(const char *path, mode_t mode, char **scontext) { #ifdef HAVE_SELINUX_LABEL_H if (!_selabel_handle && !(_selabel_handle = selabel_open(SELABEL_CTX_FILE, NULL, 0))) { log_error("selabel_open failed: %s", strerror(errno)); return 0; } if (selabel_lookup(_selabel_handle, scontext, path, mode)) { log_debug_activation("selabel_lookup failed for %s: %s", path, strerror(errno)); return 0; } #else if (matchpathcon(path, mode, scontext)) { log_debug_activation("matchpathcon failed for %s: %s", path, strerror(errno)); return 0; } #endif return 1; } #endif #ifdef HAVE_SELINUX static int _is_selinux_enabled(void) { static int _tested = 0; static int _enabled; if (!_tested) { _tested = 1; _enabled = is_selinux_enabled(); } return _enabled; } #endif int dm_prepare_selinux_context(const char *path, mode_t mode) { #ifdef HAVE_SELINUX char *scontext = NULL; if (_is_selinux_enabled() <= 0) return 1; if (path) { if (!_selabel_lookup(path, mode, &scontext)) return_0; log_debug_activation("Preparing SELinux context for %s to %s.", path, scontext); } else log_debug_activation("Resetting SELinux context to default value."); if (setfscreatecon(scontext) < 0) { log_sys_error("setfscreatecon", (path ? : "SELinux context reset")); freecon(scontext); return 0; } freecon(scontext); #endif return 1; } int dm_set_selinux_context(const char *path, mode_t mode) { #ifdef HAVE_SELINUX char *scontext = NULL; if (_is_selinux_enabled() <= 0) return 1; if (!_selabel_lookup(path, mode, &scontext)) return_0; log_debug_activation("Setting SELinux context for %s to %s.", path, scontext); if ((lsetfilecon(path, scontext) < 0) && (errno != ENOTSUP)) { log_sys_error("lsetfilecon", path); freecon(scontext); return 0; } freecon(scontext); #endif return 1; } void selinux_release(void) { #ifdef HAVE_SELINUX_LABEL_H if (_selabel_handle) selabel_close(_selabel_handle); _selabel_handle = NULL; #endif } static int _warn_if_op_needed(int warn_if_udev_failed) { return warn_if_udev_failed && dm_udev_get_sync_support() && dm_udev_get_checking(); } static int _add_dev_node(const char *dev_name, uint32_t major, uint32_t minor, uid_t uid, gid_t gid, mode_t mode, int warn_if_udev_failed) { char path[PATH_MAX]; struct stat info; dev_t dev = MKDEV(major, minor); mode_t old_mask; if (!_build_dev_path(path, sizeof(path), dev_name)) return_0; if (stat(path, &info) >= 0) { if (!S_ISBLK(info.st_mode)) { log_error("A non-block device file at '%s' " "is already present", path); return 0; } /* If right inode already exists we don't touch uid etc. */ if (info.st_rdev == dev) return 1; if (unlink(path) && (errno != ENOENT)) { log_sys_error("unlink", path); return 0; } } else if (_warn_if_op_needed(warn_if_udev_failed)) log_warn("%s not set up by udev: Falling back to direct " "node creation.", path); (void) dm_prepare_selinux_context(path, S_IFBLK); old_mask = umask(0); /* The node may already have been created by udev. So ignore EEXIST. */ if (mknod(path, S_IFBLK | mode, dev) < 0 && errno != EEXIST) { log_error("%s: mknod for %s failed: %s", path, dev_name, strerror(errno)); umask(old_mask); (void) dm_prepare_selinux_context(NULL, 0); return 0; } umask(old_mask); (void) dm_prepare_selinux_context(NULL, 0); if (chown(path, uid, gid) < 0) { log_sys_error("chown", path); return 0; } log_debug_activation("Created %s", path); return 1; } static int _rm_dev_node(const char *dev_name, int warn_if_udev_failed) { char path[PATH_MAX]; struct stat info; if (!_build_dev_path(path, sizeof(path), dev_name)) return_0; if (lstat(path, &info) < 0) return 1; else if (_warn_if_op_needed(warn_if_udev_failed)) log_warn("Node %s was not removed by udev. " "Falling back to direct node removal.", path); /* udev may already have deleted the node. Ignore ENOENT. */ if (unlink(path) && (errno != ENOENT)) { log_sys_error("unlink", path); return 0; } log_debug_activation("Removed %s", path); return 1; } static int _rename_dev_node(const char *old_name, const char *new_name, int warn_if_udev_failed) { char oldpath[PATH_MAX]; char newpath[PATH_MAX]; struct stat info, info2; struct stat *info_block_dev; if (!_build_dev_path(oldpath, sizeof(oldpath), old_name) || !_build_dev_path(newpath, sizeof(newpath), new_name)) return_0; if (lstat(newpath, &info) == 0) { if (S_ISLNK(info.st_mode)) { if (stat(newpath, &info2) == 0) info_block_dev = &info2; else { log_sys_error("stat", newpath); return 0; } } else info_block_dev = &info; if (!S_ISBLK(info_block_dev->st_mode)) { log_error("A non-block device file at '%s' " "is already present", newpath); return 0; } else if (_warn_if_op_needed(warn_if_udev_failed)) { if (lstat(oldpath, &info) < 0 && errno == ENOENT) /* assume udev already deleted this */ return 1; log_warn("The node %s should have been renamed to %s " "by udev but old node is still present. " "Falling back to direct old node removal.", oldpath, newpath); return _rm_dev_node(old_name, 0); } if (unlink(newpath) < 0) { if (errno == EPERM) { /* devfs, entry has already been renamed */ return 1; } log_error("Unable to unlink device node for '%s'", new_name); return 0; } } else if (_warn_if_op_needed(warn_if_udev_failed)) log_warn("The node %s should have been renamed to %s " "by udev but new node is not present. " "Falling back to direct node rename.", oldpath, newpath); /* udev may already have renamed the node. Ignore ENOENT. */ /* FIXME: when renaming to target mangling mode "none" with udev * while there are some blacklisted characters in the node name, * udev will remove the old_node, but fails to properly rename * to new_node. The libdevmapper code tries to call * rename(old_node,new_node), but that won't do anything * since the old node is already removed by udev. * For example renaming 'a\x20b' to 'a b': * - udev removes 'a\x20b' * - udev creates 'a' and 'b' (since it considers the ' ' as a delimiter * - libdevmapper checks udev has done the rename properly * - libdevmapper calls stat(new_node) and it does not see it * - libdevmapper calls rename(old_node,new_node) * - the rename is a NOP since the old_node does not exist anymore * * However, this situation is very rare - why would anyone need * to rename to an unsupported mode??? So a fix for this would be * just for completeness. */ if (rename(oldpath, newpath) < 0 && errno != ENOENT) { log_error("Unable to rename device node from '%s' to '%s'", old_name, new_name); return 0; } log_debug_activation("Renamed %s to %s", oldpath, newpath); return 1; } #ifdef __linux__ static int _open_dev_node(const char *dev_name) { int fd = -1; char path[PATH_MAX]; if (!_build_dev_path(path, sizeof(path), dev_name)) return fd; if ((fd = open(path, O_RDONLY, 0)) < 0) log_sys_error("open", path); return fd; } int get_dev_node_read_ahead(const char *dev_name, uint32_t major, uint32_t minor, uint32_t *read_ahead) { char buf[24]; int len; int r = 1; int fd; long read_ahead_long = 0; /* * If we know the device number, use sysfs if we can. * Otherwise use BLKRAGET ioctl. */ if (*_sysfs_dir && major != 0) { if (dm_snprintf(_path0, sizeof(_path0), "%sdev/block/%" PRIu32 ":%" PRIu32 "/bdi/read_ahead_kb", _sysfs_dir, major, minor) < 0) { log_error("Failed to build sysfs_path."); return 0; } if ((fd = open(_path0, O_RDONLY, 0)) != -1) { /* Reading from sysfs, expecting number\n */ if ((len = read(fd, buf, sizeof(buf) - 1)) < 1) { log_sys_error("read", _path0); r = 0; } else { buf[len] = 0; /* kill \n and ensure \0 */ *read_ahead = atoi(buf) * 2; log_debug_activation("%s (%d:%d): read ahead is %" PRIu32, dev_name, major, minor, *read_ahead); } if (close(fd)) log_sys_debug("close", _path0); return r; } log_sys_debug("open", _path0); /* Fall back to use dev_name */ } /* * Open/close dev_name may block the process * (i.e. overfilled thin pool volume) */ if (!*dev_name) { log_error("Empty device name passed to BLKRAGET"); return 0; } if ((fd = _open_dev_node(dev_name)) < 0) return_0; if (ioctl(fd, BLKRAGET, &read_ahead_long)) { log_sys_error("BLKRAGET", dev_name); *read_ahead = 0; r = 0; } else { *read_ahead = (uint32_t) read_ahead_long; log_debug_activation("%s: read ahead is %" PRIu32, dev_name, *read_ahead); } if (close(fd)) log_sys_debug("close", dev_name); return r; } static int _set_read_ahead(const char *dev_name, uint32_t major, uint32_t minor, uint32_t read_ahead) { char buf[24]; int len; int r = 1; int fd; long read_ahead_long = (long) read_ahead; log_debug_activation("%s (%d:%d): Setting read ahead to %" PRIu32, dev_name, major, minor, read_ahead); /* * If we know the device number, use sysfs if we can. * Otherwise use BLKRASET ioctl. RA is set after resume. */ if (*_sysfs_dir && major != 0) { if (dm_snprintf(_path0, sizeof(_path0), "%sdev/block/%" PRIu32 ":%" PRIu32 "/bdi/read_ahead_kb", _sysfs_dir, major, minor) < 0) { log_error("Failed to build sysfs_path."); return 0; } /* Sysfs is kB based, round up to kB */ if ((len = dm_snprintf(buf, sizeof(buf), FMTu32, (read_ahead + 1) / 2)) < 0) { log_error("Failed to build size in kB."); return 0; } if ((fd = open(_path0, O_WRONLY, 0)) != -1) { if (write(fd, buf, len) < len) { log_sys_error("write", _path0); r = 0; } if (close(fd)) log_sys_debug("close", _path0); return r; } log_sys_debug("open", _path0); /* Fall back to use dev_name */ } if (!*dev_name) { log_error("Empty device name passed to BLKRAGET"); return 0; } if ((fd = _open_dev_node(dev_name)) < 0) return_0; if (ioctl(fd, BLKRASET, read_ahead_long)) { log_sys_error("BLKRASET", dev_name); r = 0; } if (close(fd)) log_sys_debug("close", dev_name); return r; } static int _set_dev_node_read_ahead(const char *dev_name, uint32_t major, uint32_t minor, uint32_t read_ahead, uint32_t read_ahead_flags) { uint32_t current_read_ahead; if (read_ahead == DM_READ_AHEAD_AUTO) return 1; if (read_ahead == DM_READ_AHEAD_NONE) read_ahead = 0; if (read_ahead_flags & DM_READ_AHEAD_MINIMUM_FLAG) { if (!get_dev_node_read_ahead(dev_name, major, minor, ¤t_read_ahead)) return_0; if (current_read_ahead >= read_ahead) { log_debug_activation("%s: retaining kernel read ahead of %" PRIu32 " (requested %" PRIu32 ")", dev_name, current_read_ahead, read_ahead); return 1; } } return _set_read_ahead(dev_name, major, minor, read_ahead); } #else int get_dev_node_read_ahead(const char *dev_name, uint32_t *read_ahead) { *read_ahead = 0; return 1; } static int _set_dev_node_read_ahead(const char *dev_name, uint32_t major, uint32_t minor, uint32_t read_ahead, uint32_t read_ahead_flags) { return 1; } #endif typedef enum { NODE_ADD, NODE_DEL, NODE_RENAME, NODE_READ_AHEAD, NUM_NODES } node_op_t; static int _do_node_op(node_op_t type, const char *dev_name, uint32_t major, uint32_t minor, uid_t uid, gid_t gid, mode_t mode, const char *old_name, uint32_t read_ahead, uint32_t read_ahead_flags, int warn_if_udev_failed) { switch (type) { case NODE_ADD: return _add_dev_node(dev_name, major, minor, uid, gid, mode, warn_if_udev_failed); case NODE_DEL: return _rm_dev_node(dev_name, warn_if_udev_failed); case NODE_RENAME: return _rename_dev_node(old_name, dev_name, warn_if_udev_failed); case NODE_READ_AHEAD: return _set_dev_node_read_ahead(dev_name, major, minor, read_ahead, read_ahead_flags); default: ; /* NOTREACHED */ } return 1; } static DM_LIST_INIT(_node_ops); static int _count_node_ops[NUM_NODES]; struct node_op_parms { struct dm_list list; node_op_t type; char *dev_name; uint32_t major; uint32_t minor; uid_t uid; gid_t gid; mode_t mode; uint32_t read_ahead; uint32_t read_ahead_flags; char *old_name; int warn_if_udev_failed; unsigned rely_on_udev; char names[0]; }; static void _store_str(char **pos, char **ptr, const char *str) { size_t len = strlen(str) + 1; memcpy(*pos, str, len); *ptr = *pos; *pos += len; } static void _del_node_op(struct node_op_parms *nop) { _count_node_ops[nop->type]--; dm_list_del(&nop->list); dm_free(nop); } /* Check if there is other the type of node operation stacked */ static int _other_node_ops(node_op_t type) { unsigned i; for (i = 0; i < NUM_NODES; i++) if (type != i && _count_node_ops[i]) return 1; return 0; } static void _log_node_op(const char *action_str, struct node_op_parms *nop) { const char *rely = nop->rely_on_udev ? " [trust_udev]" : "" ; const char *verify = nop->warn_if_udev_failed ? " [verify_udev]" : ""; switch (nop->type) { case NODE_ADD: log_debug_activation("%s: %s NODE_ADD (%" PRIu32 ",%" PRIu32 ") %u:%u 0%o%s%s", nop->dev_name, action_str, nop->major, nop->minor, nop->uid, nop->gid, nop->mode, rely, verify); break; case NODE_DEL: log_debug_activation("%s: %s NODE_DEL%s%s", nop->dev_name, action_str, rely, verify); break; case NODE_RENAME: log_debug_activation("%s: %s NODE_RENAME to %s%s%s", nop->old_name, action_str, nop->dev_name, rely, verify); break; case NODE_READ_AHEAD: log_debug_activation("%s: %s NODE_READ_AHEAD %" PRIu32 " (flags=%" PRIu32 ")%s%s", nop->dev_name, action_str, nop->read_ahead, nop->read_ahead_flags, rely, verify); break; default: ; /* NOTREACHED */ } } static int _stack_node_op(node_op_t type, const char *dev_name, uint32_t major, uint32_t minor, uid_t uid, gid_t gid, mode_t mode, const char *old_name, uint32_t read_ahead, uint32_t read_ahead_flags, int warn_if_udev_failed, unsigned rely_on_udev) { struct node_op_parms *nop; struct dm_list *noph, *nopht; size_t len = strlen(dev_name) + strlen(old_name) + 2; char *pos; /* * Note: warn_if_udev_failed must have valid content */ if ((type == NODE_DEL) && _other_node_ops(type)) /* * Ignore any outstanding operations on the node if deleting it. */ dm_list_iterate_safe(noph, nopht, &_node_ops) { nop = dm_list_item(noph, struct node_op_parms); if (!strcmp(dev_name, nop->dev_name)) { _log_node_op("Unstacking", nop); _del_node_op(nop); if (!_other_node_ops(type)) break; /* no other non DEL ops */ } } else if ((type == NODE_ADD) && _count_node_ops[NODE_DEL]) /* * Ignore previous DEL operation on added node. * (No other operations for this device then DEL could be stacked here). */ dm_list_iterate_safe(noph, nopht, &_node_ops) { nop = dm_list_item(noph, struct node_op_parms); if ((nop->type == NODE_DEL) && !strcmp(dev_name, nop->dev_name)) { _log_node_op("Unstacking", nop); _del_node_op(nop); break; /* no other DEL ops */ } } else if (type == NODE_RENAME) /* * Ignore any outstanding operations if renaming it. * * Currently RENAME operation happens through 'suspend -> resume'. * On 'resume' device is added with read_ahead settings, so it is * safe to remove any stacked ADD, RENAME, READ_AHEAD operation * There cannot be any DEL operation on the renamed device. */ dm_list_iterate_safe(noph, nopht, &_node_ops) { nop = dm_list_item(noph, struct node_op_parms); if (!strcmp(old_name, nop->dev_name)) { _log_node_op("Unstacking", nop); _del_node_op(nop); } } else if (type == NODE_READ_AHEAD) { /* udev doesn't process readahead */ rely_on_udev = 0; warn_if_udev_failed = 0; } if (!(nop = dm_malloc(sizeof(*nop) + len))) { log_error("Insufficient memory to stack mknod operation"); return 0; } pos = nop->names; nop->type = type; nop->major = major; nop->minor = minor; nop->uid = uid; nop->gid = gid; nop->mode = mode; nop->read_ahead = read_ahead; nop->read_ahead_flags = read_ahead_flags; nop->rely_on_udev = rely_on_udev; /* * Clear warn_if_udev_failed if rely_on_udev is set. It doesn't get * checked in this case - this just removes the flag from log messages. */ nop->warn_if_udev_failed = rely_on_udev ? 0 : warn_if_udev_failed; _store_str(&pos, &nop->dev_name, dev_name); _store_str(&pos, &nop->old_name, old_name); _count_node_ops[type]++; dm_list_add(&_node_ops, &nop->list); _log_node_op("Stacking", nop); return 1; } static void _pop_node_ops(void) { struct dm_list *noph, *nopht; struct node_op_parms *nop; dm_list_iterate_safe(noph, nopht, &_node_ops) { nop = dm_list_item(noph, struct node_op_parms); if (!nop->rely_on_udev) { _log_node_op("Processing", nop); _do_node_op(nop->type, nop->dev_name, nop->major, nop->minor, nop->uid, nop->gid, nop->mode, nop->old_name, nop->read_ahead, nop->read_ahead_flags, nop->warn_if_udev_failed); } else _log_node_op("Skipping", nop); _del_node_op(nop); } } int add_dev_node(const char *dev_name, uint32_t major, uint32_t minor, uid_t uid, gid_t gid, mode_t mode, int check_udev, unsigned rely_on_udev) { return _stack_node_op(NODE_ADD, dev_name, major, minor, uid, gid, mode, "", 0, 0, check_udev, rely_on_udev); } int rename_dev_node(const char *old_name, const char *new_name, int check_udev, unsigned rely_on_udev) { return _stack_node_op(NODE_RENAME, new_name, 0, 0, 0, 0, 0, old_name, 0, 0, check_udev, rely_on_udev); } int rm_dev_node(const char *dev_name, int check_udev, unsigned rely_on_udev) { return _stack_node_op(NODE_DEL, dev_name, 0, 0, 0, 0, 0, "", 0, 0, check_udev, rely_on_udev); } int set_dev_node_read_ahead(const char *dev_name, uint32_t major, uint32_t minor, uint32_t read_ahead, uint32_t read_ahead_flags) { if (read_ahead == DM_READ_AHEAD_AUTO) return 1; return _stack_node_op(NODE_READ_AHEAD, dev_name, major, minor, 0, 0, 0, "", read_ahead, read_ahead_flags, 0, 0); } void update_devs(void) { _pop_node_ops(); } static int _canonicalize_and_set_dir(const char *src, const char *suffix, size_t max_len, char *dir) { size_t len; const char *slash; if (*src != '/') { log_debug_activation("Invalid directory value, %s: " "not an absolute name.", src); return 0; } len = strlen(src); slash = src[len-1] == '/' ? "" : "/"; if (dm_snprintf(dir, max_len, "%s%s%s", src, slash, suffix ? suffix : "") < 0) { log_debug_activation("Invalid directory value, %s: name too long.", src); return 0; } return 1; } int dm_set_dev_dir(const char *dev_dir) { return _canonicalize_and_set_dir(dev_dir, DM_DIR, sizeof _dm_dir, _dm_dir); } const char *dm_dir(void) { return _dm_dir; } int dm_set_sysfs_dir(const char *sysfs_dir) { if (!sysfs_dir || !*sysfs_dir) { _sysfs_dir[0] = '\0'; return 1; } return _canonicalize_and_set_dir(sysfs_dir, NULL, sizeof _sysfs_dir, _sysfs_dir); } const char *dm_sysfs_dir(void) { return _sysfs_dir; } /* * Replace existing uuid_prefix provided it isn't too long. */ int dm_set_uuid_prefix(const char *uuid_prefix) { size_t len; if (!uuid_prefix) return_0; if ((len = strlen(uuid_prefix)) > DM_MAX_UUID_PREFIX_LEN) { log_error("New uuid prefix %s too long.", uuid_prefix); return 0; } memcpy(_default_uuid_prefix, uuid_prefix, len + 1); return 1; } const char *dm_uuid_prefix(void) { return _default_uuid_prefix; } static int _is_octal(int a) { return (((a) & ~7) == '0'); } /* Convert mangled mountinfo into normal ASCII string */ static void _unmangle_mountinfo_string(const char *src, char *buf) { while (*src) { if ((*src == '\\') && _is_octal(src[1]) && _is_octal(src[2]) && _is_octal(src[3])) { *buf++ = 64 * (src[1] & 7) + 8 * (src[2] & 7) + (src[3] & 7); src += 4; } else *buf++ = *src++; } *buf = '\0'; } /* coverity[+tainted_string_sanitize_content:arg-0] */ static int _sanitize_line(const char *line) { return 1; } /* Parse one line of mountinfo and unmangled target line */ static int _mountinfo_parse_line(const char *line, unsigned *maj, unsigned *min, char *buf) { char root[PATH_MAX + 1]; /* sscanf needs extra '\0' */ char target[PATH_MAX + 1]; char *devmapper; struct dm_task *dmt; struct dm_info info; unsigned i; /* TODO: maybe detect availability of %ms glib support ? */ if (sscanf(line, "%*u %*u %u:%u %" DM_TO_STRING(PATH_MAX) "s %" DM_TO_STRING(PATH_MAX) "s", maj, min, root, target) < 4) { log_error("Failed to parse mountinfo line."); return 0; } /* btrfs fakes device numbers, but there is still /dev/mapper name * placed in mountinfo, so try to detect proper major:minor via this */ if (*maj == 0 && (devmapper = strstr(line, "/dev/mapper/"))) { if (!(dmt = dm_task_create(DM_DEVICE_INFO))) { log_error("Mount info task creation failed."); return 0; } devmapper += 12; /* skip fixed prefix */ for (i = 0; devmapper[i] && devmapper[i] != ' ' && i < sizeof(root)-1; ++i) root[i] = devmapper[i]; root[i] = 0; _unmangle_mountinfo_string(root, buf); buf[DM_NAME_LEN] = 0; /* cut away */ if (dm_task_set_name(dmt, buf) && dm_task_no_open_count(dmt) && dm_task_run(dmt) && dm_task_get_info(dmt, &info)) { log_debug("Replacing mountinfo device (%u:%u) with matching DM device %s (%u:%u).", *maj, *min, buf, info.major, info.minor); *maj = info.major; *min = info.minor; } dm_task_destroy(dmt); } _unmangle_mountinfo_string(target, buf); return 1; } /* * Function to operate on individual mountinfo line, * minor, major and mount target are parsed and unmangled */ int dm_mountinfo_read(dm_mountinfo_line_callback_fn read_fn, void *cb_data) { FILE *minfo; char buffer[2 * PATH_MAX]; char target[PATH_MAX]; unsigned maj, min; int r = 1; if (!(minfo = fopen(_mountinfo, "r"))) { if (errno != ENOENT) log_sys_error("fopen", _mountinfo); else log_sys_debug("fopen", _mountinfo); return 0; } while (!feof(minfo) && fgets(buffer, sizeof(buffer), minfo)) if (!_sanitize_line(buffer) || !_mountinfo_parse_line(buffer, &maj, &min, target) || !read_fn(buffer, maj, min, target, cb_data)) { stack; r = 0; break; } if (fclose(minfo)) log_sys_error("fclose", _mountinfo); return r; } static int _sysfs_get_dm_name(uint32_t major, uint32_t minor, char *buf, size_t buf_size) { char *sysfs_path, *temp_buf = NULL; FILE *fp = NULL; int r = 0; size_t len; if (!(sysfs_path = dm_malloc(PATH_MAX)) || !(temp_buf = dm_malloc(PATH_MAX))) { log_error("_sysfs_get_dm_name: failed to allocate temporary buffers"); goto bad; } if (dm_snprintf(sysfs_path, PATH_MAX, "%sdev/block/%" PRIu32 ":%" PRIu32 "/dm/name", _sysfs_dir, major, minor) < 0) { log_error("_sysfs_get_dm_name: dm_snprintf failed"); goto bad; } if (!(fp = fopen(sysfs_path, "r"))) { if (errno != ENOENT) log_sys_error("fopen", sysfs_path); else log_sys_debug("fopen", sysfs_path); goto bad; } if (!fgets(temp_buf, PATH_MAX, fp)) { log_sys_error("fgets", sysfs_path); goto bad; } len = strlen(temp_buf); if (len > buf_size) { log_error("_sysfs_get_dm_name: supplied buffer too small"); goto bad; } temp_buf[len ? len - 1 : 0] = '\0'; /* \n */ strcpy(buf, temp_buf); r = 1; bad: if (fp && fclose(fp)) log_sys_error("fclose", sysfs_path); dm_free(temp_buf); dm_free(sysfs_path); return r; } static int _sysfs_get_dev_major_minor(const char *path, uint32_t major, uint32_t minor) { FILE *fp; uint32_t ma, mi; int r; if (!(fp = fopen(path, "r"))) return 0; r = (fscanf(fp, "%" PRIu32 ":%" PRIu32 , &ma, &mi) == 2) && (ma == major) && (mi == minor); // log_debug("Checking %s %u:%u -> %d", path, ma, mi, r); if (fclose(fp)) log_sys_error("fclose", path); return r; } static int _sysfs_find_kernel_name(uint32_t major, uint32_t minor, char *buf, size_t buf_size) { const char *name, *name_dev; char path[PATH_MAX]; struct dirent *dirent, *dirent_dev; DIR *d, *d_dev; struct stat st; int r = 0, sz; if (!*_sysfs_dir || dm_snprintf(path, sizeof(path), "%s/block/", _sysfs_dir) < 0) { log_error("Failed to build sysfs_path."); return 0; } if (!(d = opendir(path))) { log_sys_error("opendir", path); return 0; } while (!r && (dirent = readdir(d))) { name = dirent->d_name; if (!strcmp(name, ".") || !strcmp(name, "..")) continue; if ((sz = dm_snprintf(path, sizeof(path), "%sblock/%s/dev", _sysfs_dir, name)) < 5) { log_warn("Couldn't create path for %s.", name); continue; } if (_sysfs_get_dev_major_minor(path, major, minor)) { r = dm_strncpy(buf, name, buf_size); break; /* found */ } path[sz - 4] = 0; /* strip /dev from end of path string */ if (stat(path, &st)) continue; if (S_ISDIR(st.st_mode)) { /* let's assume there is no tree-complex device in past systems */ if (!(d_dev = opendir(path))) { log_sys_debug("opendir", path); continue; } while ((dirent_dev = readdir(d_dev))) { name_dev = dirent_dev->d_name; /* skip known ignorable paths */ if (!strcmp(name_dev, ".") || !strcmp(name_dev, "..") || !strcmp(name_dev, "bdi") || !strcmp(name_dev, "dev") || !strcmp(name_dev, "device") || !strcmp(name_dev, "holders") || !strcmp(name_dev, "integrity") || !strcmp(name_dev, "loop") || !strcmp(name_dev, "queue") || !strcmp(name_dev, "md") || !strcmp(name_dev, "mq") || !strcmp(name_dev, "power") || !strcmp(name_dev, "removable") || !strcmp(name_dev, "slave") || !strcmp(name_dev, "slaves") || !strcmp(name_dev, "subsystem") || !strcmp(name_dev, "trace") || !strcmp(name_dev, "uevent")) continue; if (dm_snprintf(path, sizeof(path), "%sblock/%s/%s/dev", _sysfs_dir, name, name_dev) == -1) { log_warn("Couldn't create path for %s/%s.", name, name_dev); continue; } if (_sysfs_get_dev_major_minor(path, major, minor)) { r = dm_strncpy(buf, name_dev, buf_size); break; /* found */ } } if (closedir(d_dev)) log_sys_debug("closedir", name); } } if (closedir(d)) log_sys_debug("closedir", path); return r; } static int _sysfs_get_kernel_name(uint32_t major, uint32_t minor, char *buf, size_t buf_size) { char *name, *sysfs_path, *temp_buf = NULL; ssize_t size; size_t len; int r = 0; if (!(sysfs_path = dm_malloc(PATH_MAX)) || !(temp_buf = dm_malloc(PATH_MAX))) { log_error("_sysfs_get_kernel_name: failed to allocate temporary buffers"); goto bad; } if (dm_snprintf(sysfs_path, PATH_MAX, "%sdev/block/%" PRIu32 ":%" PRIu32, _sysfs_dir, major, minor) < 0) { log_error("_sysfs_get_kernel_name: dm_snprintf failed"); goto bad; } if ((size = readlink(sysfs_path, temp_buf, PATH_MAX - 1)) < 0) { if (errno != ENOENT) log_sys_error("readlink", sysfs_path); else { log_sys_debug("readlink", sysfs_path); r = _sysfs_find_kernel_name(major, minor, buf, buf_size); goto out; } goto bad; } temp_buf[size] = '\0'; if (!(name = strrchr(temp_buf, '/'))) { log_error("Could not locate device kernel name in sysfs path %s", temp_buf); goto bad; } name += 1; len = size - (name - temp_buf) + 1; if (len > buf_size) { log_error("_sysfs_get_kernel_name: output buffer too small"); goto bad; } strcpy(buf, name); r = 1; bad: out: dm_free(temp_buf); dm_free(sysfs_path); return r; } int dm_device_get_name(uint32_t major, uint32_t minor, int prefer_kernel_name, char *buf, size_t buf_size) { if (!*_sysfs_dir) return 0; /* * device-mapper devices and prefer_kernel_name = 0 * get dm name by reading /sys/dev/block/major:minor/dm/name, * fallback to _sysfs_get_kernel_name if not successful */ if (dm_is_dm_major(major) && !prefer_kernel_name) { if (_sysfs_get_dm_name(major, minor, buf, buf_size)) return 1; else stack; } /* * non-device-mapper devices or prefer_kernel_name = 1 * get kernel name using readlink /sys/dev/block/major:minor -> .../dm-X */ return _sysfs_get_kernel_name(major, minor, buf, buf_size); } int dm_device_has_holders(uint32_t major, uint32_t minor) { char sysfs_path[PATH_MAX]; struct stat st; if (!*_sysfs_dir) return 0; if (dm_snprintf(sysfs_path, PATH_MAX, "%sdev/block/%" PRIu32 ":%" PRIu32 "/holders", _sysfs_dir, major, minor) < 0) { log_warn("WARNING: sysfs_path dm_snprintf failed."); return 0; } if (stat(sysfs_path, &st)) { if (errno != ENOENT) log_sys_debug("stat", sysfs_path); return 0; } return !dm_is_empty_dir(sysfs_path); } static int _mounted_fs_on_device(const char *kernel_dev_name) { char sysfs_path[PATH_MAX]; struct dirent *dirent; DIR *d; struct stat st; int r = 0; if (dm_snprintf(sysfs_path, PATH_MAX, "%sfs", _sysfs_dir) < 0) { log_warn("WARNING: sysfs_path dm_snprintf failed."); return 0; } if (!(d = opendir(sysfs_path))) { if (errno != ENOENT) log_sys_debug("opendir", sysfs_path); return 0; } while ((dirent = readdir(d))) { if (!strcmp(dirent->d_name, ".") || !strcmp(dirent->d_name, "..")) continue; if (dm_snprintf(sysfs_path, PATH_MAX, "%sfs/%s/%s", _sysfs_dir, dirent->d_name, kernel_dev_name) < 0) { log_warn("WARNING: sysfs_path dm_snprintf failed."); break; } if (!stat(sysfs_path, &st)) { /* found! */ r = 1; break; } else if (errno != ENOENT) { log_sys_debug("stat", sysfs_path); break; } } if (closedir(d)) log_sys_debug("closedir", kernel_dev_name); return r; } struct mountinfo_s { unsigned maj; unsigned min; int mounted; }; static int _device_has_mounted_fs(char *buffer, unsigned major, unsigned minor, char *target, void *cb_data) { struct mountinfo_s *data = cb_data; char kernel_dev_name[PATH_MAX]; if ((major == data->maj) && (minor == data->min)) { if (!dm_device_get_name(major, minor, 1, kernel_dev_name, sizeof(kernel_dev_name))) { stack; *kernel_dev_name = '\0'; } log_verbose("Device %s (%u:%u) appears to be mounted on %s.", kernel_dev_name, major, minor, target); data->mounted = 1; } return 1; } int dm_device_has_mounted_fs(uint32_t major, uint32_t minor) { char kernel_dev_name[PATH_MAX]; struct mountinfo_s data = { .maj = major, .min = minor, }; if (!dm_mountinfo_read(_device_has_mounted_fs, &data)) stack; if (data.mounted) return 1; /* * TODO: Verify dm_mountinfo_read() is superset * and remove sysfs check (namespaces) */ /* Get kernel device name first */ if (!dm_device_get_name(major, minor, 1, kernel_dev_name, PATH_MAX)) return 0; /* Check /sys/fs// presence */ return _mounted_fs_on_device(kernel_dev_name); } int dm_mknodes(const char *name) { struct dm_task *dmt; int r = 0; if (!(dmt = dm_task_create(DM_DEVICE_MKNODES))) return_0; if (name && !dm_task_set_name(dmt, name)) goto out; if (!dm_task_no_open_count(dmt)) goto out; r = dm_task_run(dmt); out: dm_task_destroy(dmt); return r; } int dm_driver_version(char *version, size_t size) { struct dm_task *dmt; int r = 0; if (!(dmt = dm_task_create(DM_DEVICE_VERSION))) return_0; if (!dm_task_run(dmt)) log_error("Failed to get driver version"); if (!dm_task_get_driver_version(dmt, version, size)) goto out; r = 1; out: dm_task_destroy(dmt); return r; } static void _set_cookie_flags(struct dm_task *dmt, uint16_t flags) { if (!dm_cookie_supported()) return; if (_udev_disabled) { /* * If udev is disabled, hardcode this functionality: * - we want libdm to create the nodes * - we don't want the /dev/mapper and any subsystem * related content to be created by udev if udev * rules are installed */ flags &= ~DM_UDEV_DISABLE_LIBRARY_FALLBACK; flags |= DM_UDEV_DISABLE_DM_RULES_FLAG | DM_UDEV_DISABLE_SUBSYSTEM_RULES_FLAG; } dmt->event_nr = flags << DM_UDEV_FLAGS_SHIFT; } #ifndef UDEV_SYNC_SUPPORT void dm_udev_set_sync_support(int sync_with_udev) { } int dm_udev_get_sync_support(void) { return 0; } void dm_udev_set_checking(int checking) { } int dm_udev_get_checking(void) { return 0; } int dm_task_set_cookie(struct dm_task *dmt, uint32_t *cookie, uint16_t flags) { _set_cookie_flags(dmt, flags); *cookie = 0; dmt->cookie_set = 1; return 1; } int dm_udev_complete(uint32_t cookie) { return 1; } int dm_udev_wait(uint32_t cookie) { update_devs(); return 1; } int dm_udev_wait_immediate(uint32_t cookie, int *ready) { update_devs(); *ready = 1; return 1; } #else /* UDEV_SYNC_SUPPORT */ static int _check_semaphore_is_supported(void) { int maxid; union semun arg; struct seminfo seminfo; arg.__buf = &seminfo; maxid = semctl(0, 0, SEM_INFO, arg); if (maxid < 0) { log_warn("Kernel not configured for semaphores (System V IPC). " "Not using udev synchronization code."); return 0; } return 1; } static int _check_udev_is_running(void) { struct udev *udev; struct udev_queue *udev_queue; int r; if (!(udev = udev_new())) goto_bad; if (!(udev_queue = udev_queue_new(udev))) { udev_unref(udev); goto_bad; } if (!(r = udev_queue_get_udev_is_active(udev_queue))) log_debug_activation("Udev is not running. " "Not using udev synchronization code."); udev_queue_unref(udev_queue); udev_unref(udev); return r; bad: log_error("Could not get udev state. Assuming udev is not running."); return 0; } static void _check_udev_sync_requirements_once(void) { if (_semaphore_supported < 0) _semaphore_supported = _check_semaphore_is_supported(); if (_udev_running < 0) { _udev_running = _check_udev_is_running(); if (_udev_disabled && _udev_running) log_warn("Udev is running and DM_DISABLE_UDEV environment variable is set. " "Bypassing udev, device-mapper library will manage device " "nodes in device directory."); } } void dm_udev_set_sync_support(int sync_with_udev) { _check_udev_sync_requirements_once(); _sync_with_udev = sync_with_udev; } int dm_udev_get_sync_support(void) { _check_udev_sync_requirements_once(); return !_udev_disabled && _semaphore_supported && dm_cookie_supported() &&_udev_running && _sync_with_udev; } void dm_udev_set_checking(int checking) { if ((_udev_checking = checking)) log_debug_activation("DM udev checking enabled"); else log_debug_activation("DM udev checking disabled"); } int dm_udev_get_checking(void) { return _udev_checking; } static int _get_cookie_sem(uint32_t cookie, int *semid) { if (cookie >> 16 != DM_COOKIE_MAGIC) { log_error("Could not continue to access notification " "semaphore identified by cookie value %" PRIu32 " (0x%x). Incorrect cookie prefix.", cookie, cookie); return 0; } if ((*semid = semget((key_t) cookie, 1, 0)) >= 0) return 1; switch (errno) { case ENOENT: log_error("Could not find notification " "semaphore identified by cookie " "value %" PRIu32 " (0x%x)", cookie, cookie); break; case EACCES: log_error("No permission to access " "notification semaphore identified " "by cookie value %" PRIu32 " (0x%x)", cookie, cookie); break; default: log_error("Failed to access notification " "semaphore identified by cookie " "value %" PRIu32 " (0x%x): %s", cookie, cookie, strerror(errno)); break; } return 0; } static int _udev_notify_sem_inc(uint32_t cookie, int semid) { struct sembuf sb = {0, 1, 0}; int val; if (semop(semid, &sb, 1) < 0) { log_error("cookie inc: semid %d: semop failed for cookie 0x%" PRIx32 ": %s", semid, cookie, strerror(errno)); return 0; } if ((val = semctl(semid, 0, GETVAL)) < 0) { log_warn("cookie inc: semid %d: sem_ctl GETVAL failed for " "cookie 0x%" PRIx32 ": %s", semid, cookie, strerror(errno)); log_debug_activation("Udev cookie 0x%" PRIx32 " (semid %d) incremented.", cookie, semid); } else log_debug_activation("Udev cookie 0x%" PRIx32 " (semid %d) incremented to %d", cookie, semid, val); return 1; } static int _udev_notify_sem_dec(uint32_t cookie, int semid) { struct sembuf sb = {0, -1, IPC_NOWAIT}; int val; if ((val = semctl(semid, 0, GETVAL)) < 0) log_warn("cookie dec: semid %d: sem_ctl GETVAL failed for " "cookie 0x%" PRIx32 ": %s", semid, cookie, strerror(errno)); if (semop(semid, &sb, 1) < 0) { switch (errno) { case EAGAIN: log_error("cookie dec: semid %d: semop failed for cookie " "0x%" PRIx32 ": " "incorrect semaphore state", semid, cookie); break; default: log_error("cookie dec: semid %d: semop failed for cookie " "0x%" PRIx32 ": %s", semid, cookie, strerror(errno)); break; } return 0; } if (val < 0) log_debug_activation("Udev cookie 0x%" PRIx32 " (semid %d) decremented.", cookie, semid); else log_debug_activation("Udev cookie 0x%" PRIx32 " (semid %d) decremented to %d", cookie, semid, val - 1); return 1; } static int _udev_notify_sem_destroy(uint32_t cookie, int semid) { if (semctl(semid, 0, IPC_RMID, 0) < 0) { log_error("Could not cleanup notification semaphore " "identified by cookie value %" PRIu32 " (0x%x): %s", cookie, cookie, strerror(errno)); return 0; } log_debug_activation("Udev cookie 0x%" PRIx32 " (semid %d) destroyed", cookie, semid); return 1; } static int _udev_notify_sem_create(uint32_t *cookie, int *semid) { int fd; int gen_semid; int val; uint16_t base_cookie; uint32_t gen_cookie; union semun sem_arg; if ((fd = open("/dev/urandom", O_RDONLY)) < 0) { log_error("Failed to open /dev/urandom " "to create random cookie value"); *cookie = 0; return 0; } /* Generate random cookie value. Be sure it is unique and non-zero. */ do { /* FIXME Handle non-error returns from read(). Move _io() into libdm? */ if (read(fd, &base_cookie, sizeof(base_cookie)) != sizeof(base_cookie)) { log_error("Failed to initialize notification cookie"); goto bad; } gen_cookie = DM_COOKIE_MAGIC << 16 | base_cookie; if (base_cookie && (gen_semid = semget((key_t) gen_cookie, 1, 0600 | IPC_CREAT | IPC_EXCL)) < 0) { switch (errno) { case EEXIST: /* if the semaphore key exists, we * simply generate another random one */ base_cookie = 0; break; case ENOMEM: log_error("Not enough memory to create " "notification semaphore"); goto bad; case ENOSPC: log_error("Limit for the maximum number " "of semaphores reached. You can " "check and set the limits in " "/proc/sys/kernel/sem."); goto bad; default: log_error("Failed to create notification " "semaphore: %s", strerror(errno)); goto bad; } } } while (!base_cookie); log_debug_activation("Udev cookie 0x%" PRIx32 " (semid %d) created", gen_cookie, gen_semid); sem_arg.val = 1; if (semctl(gen_semid, 0, SETVAL, sem_arg) < 0) { log_error("cookie create: semid %d: semctl failed: %s", gen_semid, strerror(errno)); /* We have to destroy just created semaphore * so it won't stay in the system. */ (void) _udev_notify_sem_destroy(gen_cookie, gen_semid); goto bad; } if ((val = semctl(gen_semid, 0, GETVAL)) < 0) { log_error("cookie create: semid %d: sem_ctl GETVAL failed for " "cookie 0x%" PRIx32 ": %s", gen_semid, gen_cookie, strerror(errno)); (void) _udev_notify_sem_destroy(gen_cookie, gen_semid); goto bad; } log_debug_activation("Udev cookie 0x%" PRIx32 " (semid %d) incremented to %d", gen_cookie, gen_semid, val); if (close(fd)) stack; *semid = gen_semid; *cookie = gen_cookie; return 1; bad: if (close(fd)) stack; *cookie = 0; return 0; } int dm_udev_create_cookie(uint32_t *cookie) { int semid; if (!dm_udev_get_sync_support()) { *cookie = 0; return 1; } return _udev_notify_sem_create(cookie, &semid); } static const char *_task_type_disp(int type) { switch(type) { case DM_DEVICE_CREATE: return "CREATE"; case DM_DEVICE_RELOAD: return "RELOAD"; case DM_DEVICE_REMOVE: return "REMOVE"; case DM_DEVICE_REMOVE_ALL: return "REMOVE_ALL"; case DM_DEVICE_SUSPEND: return "SUSPEND"; case DM_DEVICE_RESUME: return "RESUME"; case DM_DEVICE_INFO: return "INFO"; case DM_DEVICE_DEPS: return "DEPS"; case DM_DEVICE_RENAME: return "RENAME"; case DM_DEVICE_VERSION: return "VERSION"; case DM_DEVICE_STATUS: return "STATUS"; case DM_DEVICE_TABLE: return "TABLE"; case DM_DEVICE_WAITEVENT: return "WAITEVENT"; case DM_DEVICE_LIST: return "LIST"; case DM_DEVICE_CLEAR: return "CLEAR"; case DM_DEVICE_MKNODES: return "MKNODES"; case DM_DEVICE_LIST_VERSIONS: return "LIST_VERSIONS"; case DM_DEVICE_TARGET_MSG: return "TARGET_MSG"; case DM_DEVICE_SET_GEOMETRY: return "SET_GEOMETRY"; } return "unknown"; } int dm_task_set_cookie(struct dm_task *dmt, uint32_t *cookie, uint16_t flags) { int semid; _set_cookie_flags(dmt, flags); if (!dm_udev_get_sync_support()) { *cookie = 0; dmt->cookie_set = 1; return 1; } if (*cookie) { if (!_get_cookie_sem(*cookie, &semid)) goto_bad; } else if (!_udev_notify_sem_create(cookie, &semid)) goto_bad; if (!_udev_notify_sem_inc(*cookie, semid)) { log_error("Could not set notification semaphore " "identified by cookie value %" PRIu32 " (0x%x)", *cookie, *cookie); goto bad; } dmt->event_nr |= ~DM_UDEV_FLAGS_MASK & *cookie; dmt->cookie_set = 1; log_debug_activation("Udev cookie 0x%" PRIx32 " (semid %d) assigned to " "%s task(%d) with flags%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s (0x%" PRIx16 ")", *cookie, semid, _task_type_disp(dmt->type), dmt->type, (flags & DM_UDEV_DISABLE_DM_RULES_FLAG) ? " DISABLE_DM_RULES" : "", (flags & DM_UDEV_DISABLE_SUBSYSTEM_RULES_FLAG) ? " DISABLE_SUBSYSTEM_RULES" : "", (flags & DM_UDEV_DISABLE_DISK_RULES_FLAG) ? " DISABLE_DISK_RULES" : "", (flags & DM_UDEV_DISABLE_OTHER_RULES_FLAG) ? " DISABLE_OTHER_RULES" : "", (flags & DM_UDEV_LOW_PRIORITY_FLAG) ? " LOW_PRIORITY" : "", (flags & DM_UDEV_DISABLE_LIBRARY_FALLBACK) ? " DISABLE_LIBRARY_FALLBACK" : "", (flags & DM_UDEV_PRIMARY_SOURCE_FLAG) ? " PRIMARY_SOURCE" : "", (flags & DM_SUBSYSTEM_UDEV_FLAG0) ? " SUBSYSTEM_0" : " ", (flags & DM_SUBSYSTEM_UDEV_FLAG1) ? " SUBSYSTEM_1" : " ", (flags & DM_SUBSYSTEM_UDEV_FLAG2) ? " SUBSYSTEM_2" : " ", (flags & DM_SUBSYSTEM_UDEV_FLAG3) ? " SUBSYSTEM_3" : " ", (flags & DM_SUBSYSTEM_UDEV_FLAG4) ? " SUBSYSTEM_4" : " ", (flags & DM_SUBSYSTEM_UDEV_FLAG5) ? " SUBSYSTEM_5" : " ", (flags & DM_SUBSYSTEM_UDEV_FLAG6) ? " SUBSYSTEM_6" : " ", (flags & DM_SUBSYSTEM_UDEV_FLAG7) ? " SUBSYSTEM_7" : " ", flags); return 1; bad: dmt->event_nr = 0; return 0; } int dm_udev_complete(uint32_t cookie) { int semid; if (!cookie || !dm_udev_get_sync_support()) return 1; if (!_get_cookie_sem(cookie, &semid)) return_0; if (!_udev_notify_sem_dec(cookie, semid)) { log_error("Could not signal waiting process using notification " "semaphore identified by cookie value %" PRIu32 " (0x%x)", cookie, cookie); return 0; } return 1; } /* * If *nowait is set, return immediately leaving it set if the semaphore * is not ready to be decremented to 0. *nowait is cleared if the wait * succeeds. */ static int _udev_wait(uint32_t cookie, int *nowait) { int semid; struct sembuf sb = {0, 0, 0}; int val; if (!cookie || !dm_udev_get_sync_support()) return 1; if (!_get_cookie_sem(cookie, &semid)) return_0; /* Return immediately if the semaphore value exceeds 1? */ if (*nowait) { if ((val = semctl(semid, 0, GETVAL)) < 0) { log_error("semid %d: sem_ctl GETVAL failed for " "cookie 0x%" PRIx32 ": %s", semid, cookie, strerror(errno)); return 0; } if (val > 1) return 1; *nowait = 0; } if (!_udev_notify_sem_dec(cookie, semid)) { log_error("Failed to set a proper state for notification " "semaphore identified by cookie value %" PRIu32 " (0x%x) " "to initialize waiting for incoming notifications.", cookie, cookie); (void) _udev_notify_sem_destroy(cookie, semid); return 0; } log_debug_activation("Udev cookie 0x%" PRIx32 " (semid %d) waiting for zero", cookie, semid); repeat_wait: if (semop(semid, &sb, 1) < 0) { if (errno == EINTR) goto repeat_wait; else if (errno == EIDRM) return 1; log_error("Could not set wait state for notification semaphore " "identified by cookie value %" PRIu32 " (0x%x): %s", cookie, cookie, strerror(errno)); (void) _udev_notify_sem_destroy(cookie, semid); return 0; } return _udev_notify_sem_destroy(cookie, semid); } int dm_udev_wait(uint32_t cookie) { int nowait = 0; int r = _udev_wait(cookie, &nowait); update_devs(); return r; } int dm_udev_wait_immediate(uint32_t cookie, int *ready) { int nowait = 1; int r = _udev_wait(cookie, &nowait); if (r && nowait) { *ready = 0; return 1; } update_devs(); *ready = 1; return r; } #endif /* UDEV_SYNC_SUPPORT */