diff options
Diffstat (limited to 'lib/libdm/libdm_ioctl.c')
| -rw-r--r-- | lib/libdm/libdm_ioctl.c | 895 |
1 files changed, 895 insertions, 0 deletions
diff --git a/lib/libdm/libdm_ioctl.c b/lib/libdm/libdm_ioctl.c new file mode 100644 index 00000000000..5528844a6b5 --- /dev/null +++ b/lib/libdm/libdm_ioctl.c @@ -0,0 +1,895 @@ +/* + * Copyright (c) 2010 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Adam Hamsik. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ + +#include <sys/types.h> +#include <sys/param.h> +#include <sys/ioctl.h> + +#include <errno.h> +#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include <prop/proplib.h> + +#include <dev/dm/netbsd-dm.h> + +#include "dm.h" + +/* + * Libdm library works like interface between device-mapper driver and + * NetBSD userspace. For start it uses same set of commands like linux + * libdevmapper, but in later stage if we introduce NetBSD device-mapper + * extensions we don't need to change libdevmapper. + * + * LIBDM basically creates one proplib dictionary with everything what is + * needed to work with device-mapper devices. + * + * Basic element of libdm is libdm_task which contains version and command + * string with another dictionary cmd. + */ + +struct libdm_cmd { + prop_array_t ldm_cmd; +}; + +struct libdm_iter { + prop_object_iterator_t ldm_obji; +}; + +struct libdm_task { + prop_dictionary_t ldm_task; +}; + +struct libdm_table { + prop_dictionary_t ldm_tbl; +}; + +struct libdm_target { + prop_dictionary_t ldm_trgt; +}; + +struct libdm_dev { + prop_dictionary_t ldm_dev; +}; + +struct cmd_version cmd_ver[] = { + {"version", {4, 0, 0}}, + {"targets", {4, 0, 0}}, + {"create", {4, 0, 0}}, + {"info", {4, 0, 0}}, + {"mknodes",{4, 0, 0}}, + {"names", {4, 0, 0}}, + {"suspend",{4, 0, 0}}, + {"remove", {4, 0, 0}}, + {"rename", {4, 0, 0}}, + {"resume", {4, 0, 0}}, + {"clear", {4, 0, 0}}, + {"deps", {4, 0, 0}}, + {"reload", {4, 0, 0}}, + {"status", {4, 0, 0}}, + {"table", {4, 0, 0}}, + /* NetBSD device-mapper command extension goes here */ + {NULL, {0, 0, 0}} +}; + +/* /dev/mapper/control managing routines */ +static int libdm_control_open(const char *); +static int libdm_control_close(int); + +static int +libdm_control_open(const char *path) +{ + int fd; +#ifdef RUMP_ACTION + if ((fd = rump_sys_open(path, O_RDWR)) < 0) + return -1; +#else + if ((fd = open(path, O_RDWR)) < 0) + return -1; +#endif + return fd; +} + +static int +libdm_control_close(int fd) +{ + +#ifdef RUMP_ACTION + return rump_sys_close(fd); +#else + return close(fd); +#endif +} + +/* Destroy iterator for arrays such as version strings, cmd_data. */ +void +libdm_iter_destroy(libdm_iter_t libdm_iter) +{ + + prop_object_iterator_release(libdm_iter->ldm_obji); + free(libdm_iter); +} + +/* + * Issue ioctl call to kernel, releasing both dictionaries is + * left on callers. + */ +int +libdm_task_run(libdm_task_t libdm_task) +{ + prop_dictionary_t dict; + int libdm_control_fd = -1; + int error; +#ifdef RUMP_ACTION + struct plistref prefp; +#endif + error = 0; + + if (libdm_task == NULL) + return ENOENT; + + if ((libdm_control_fd = libdm_control_open(DM_DEVICE_PATH)) < 0) + return errno; +#ifdef RUMP_ACTION + prop_dictionary_externalize_to_pref(libdm_task->ldm_task, + &prefp); + + error = rump_sys_ioctl(libdm_control_fd, NETBSD_DM_IOCTL, &prefp); + if (error < 0) { + libdm_task_destroy(libdm_task); + libdm_task = NULL; + libdm_control_close(libdm_control_fd); + + return error; + } + dict = prop_dictionary_internalize(prefp.pref_plist); +#else + prop_dictionary_externalize_to_file(libdm_task->ldm_task, "/tmp/libdm_in"); + error = prop_dictionary_sendrecv_ioctl(libdm_task->ldm_task, + libdm_control_fd, NETBSD_DM_IOCTL, &dict); + if ( error != 0) { + libdm_task_destroy(libdm_task); + libdm_task = NULL; + libdm_control_close(libdm_control_fd); + return error; + } + prop_dictionary_externalize_to_file(dict, "/tmp/libdm_out"); +#endif + + libdm_control_close(libdm_control_fd); + prop_object_retain(dict); + prop_object_release(libdm_task->ldm_task); + libdm_task->ldm_task = dict; + + return EXIT_SUCCESS; +} + + +/* Create libdm General task structure */ +libdm_task_t +libdm_task_create(const char *command) +{ + libdm_task_t task; + size_t i,len,slen; + prop_array_t ver; + + task = NULL; + + task = malloc(sizeof(*task)); + if (task == NULL) + return NULL; + + if ((task->ldm_task = prop_dictionary_create()) == NULL) { + free(task); + return NULL; + } + + if ((prop_dictionary_set_cstring(task->ldm_task, DM_IOCTL_COMMAND, + command)) == false) { + prop_object_release(task->ldm_task); + free(task); + return NULL; + } + + len = strlen(command); + + for (i = 0; cmd_ver[i].cmd != NULL; i++) { + slen = strlen(cmd_ver[i].cmd); + + if (len != slen) + continue; + + if ((strncmp(command, cmd_ver[i].cmd, slen)) == 0) { + ver = prop_array_create(); + prop_array_add_uint32(ver, cmd_ver[i].version[0]); + prop_array_add_uint32(ver, cmd_ver[i].version[1]); + prop_array_add_uint32(ver, cmd_ver[i].version[2]); + + prop_dictionary_set(task->ldm_task, DM_IOCTL_VERSION, + ver); + + prop_object_release(ver); + break; + } + } + + return task; +} + +void +libdm_task_destroy(libdm_task_t libdm_task) +{ + + if (libdm_task != NULL) + prop_object_release(libdm_task->ldm_task); + free(libdm_task); +} + +/* Set device name */ +int +libdm_task_set_name(const char *name, libdm_task_t libdm_task) +{ + + if ((prop_dictionary_set_cstring(libdm_task->ldm_task, + DM_IOCTL_NAME, name)) == false) + return ENOENT; + + return 0; +} + +/* Set device name */ +char * +libdm_task_get_name(libdm_task_t libdm_task) +{ + char *name; + + if (!prop_dictionary_get_cstring_nocopy(libdm_task->ldm_task, + DM_IOCTL_NAME, (const char **)&name)) + return NULL; + + return name; +} + +/* Set device uuid */ +int +libdm_task_set_uuid(const char *uuid, libdm_task_t libdm_task) +{ + + if ((prop_dictionary_set_cstring(libdm_task->ldm_task, + DM_IOCTL_NAME, uuid)) == false) + return ENOENT; + + return 0; +} + +/* Set device name */ +char * +libdm_task_get_uuid(libdm_task_t libdm_task) +{ + char *uuid; + + if (!prop_dictionary_get_cstring_nocopy(libdm_task->ldm_task, + DM_IOCTL_UUID, (const char **)&uuid)) + return NULL; + + return uuid; +} + +/* Get command name */ +char * +libdm_task_get_command(libdm_task_t libdm_task) +{ + char *command; + + if (!prop_dictionary_get_cstring_nocopy(libdm_task->ldm_task, + DM_IOCTL_COMMAND, (const char **)&command)) + return NULL; + + return command; +} + +int32_t +libdm_task_get_cmd_version(libdm_task_t libdm_task, uint32_t *ver, size_t size) +{ + prop_array_t prop_ver; + size_t i; + + prop_ver = prop_dictionary_get(libdm_task->ldm_task, + DM_IOCTL_VERSION); + + i = prop_array_count(prop_ver); + + if (i > size) + return -i; + + for (i = 0; i < size; i++) + prop_array_get_uint32(prop_ver, i, &ver[i]); + + return i; +} + +/* Select device minor number. */ +int +libdm_task_set_minor(uint32_t minor, libdm_task_t libdm_task) +{ + + if ((prop_dictionary_set_uint32(libdm_task->ldm_task, + DM_IOCTL_MINOR, minor)) == false) + return ENOENT; + + return 0; +} + +/* Select device minor number. */ +uint32_t +libdm_task_get_minor(libdm_task_t libdm_task) +{ + uint32_t minor; + + minor = 0; + + (void)prop_dictionary_get_uint32(libdm_task->ldm_task, + DM_IOCTL_MINOR, &minor); + + return minor; +} + +/* Set/Del DM_SUSPEND_FLAG for caller. */ +void +libdm_task_set_suspend_flag(libdm_task_t libdm_task) +{ + uint32_t flags; + + flags = 0; + + (void)prop_dictionary_get_uint32(libdm_task->ldm_task, + DM_IOCTL_FLAGS, &flags); + + flags |= DM_SUSPEND_FLAG; + + (void)prop_dictionary_set_uint32(libdm_task->ldm_task, + DM_IOCTL_FLAGS, flags); +} + +void +libdm_task_del_suspend_flag(libdm_task_t libdm_task) +{ + uint32_t flags; + + (void)prop_dictionary_get_uint32(libdm_task->ldm_task, + DM_IOCTL_FLAGS, &flags); + + flags &= ~DM_SUSPEND_FLAG; + + (void)prop_dictionary_set_uint32(libdm_task->ldm_task, + DM_IOCTL_FLAGS, flags); +} + +/* Set/Del DM_STATUS_FLAG for caller. */ +void +libdm_task_set_status_flag(libdm_task_t libdm_task) +{ + uint32_t flags; + + flags = 0; + + (void)prop_dictionary_get_uint32(libdm_task->ldm_task, + DM_IOCTL_FLAGS, &flags); + + flags |= DM_STATUS_TABLE_FLAG; + + (void)prop_dictionary_set_uint32(libdm_task->ldm_task, + DM_IOCTL_FLAGS, flags); +} + +void +libdm_task_del_status_flag(libdm_task_t libdm_task) +{ + uint32_t flags; + + (void)prop_dictionary_get_uint32(libdm_task->ldm_task, + DM_IOCTL_FLAGS, &flags); + + flags &= ~DM_STATUS_TABLE_FLAG; + + (void)prop_dictionary_set_uint32(libdm_task->ldm_task, + DM_IOCTL_FLAGS, flags); +} + +/* Set/Del DM_EXISTS_FLAG for caller. */ +void +libdm_task_set_exists_flag(libdm_task_t libdm_task) +{ + uint32_t flags; + + flags = 0; + + (void)prop_dictionary_get_uint32(libdm_task->ldm_task, + DM_IOCTL_FLAGS, &flags); + + flags |= DM_EXISTS_FLAG; + + (void)prop_dictionary_set_uint32(libdm_task->ldm_task, + DM_IOCTL_FLAGS, flags); +} + +void +libdm_task_del_exists_flag(libdm_task_t libdm_task) +{ + uint32_t flags; + + (void)prop_dictionary_get_uint32(libdm_task->ldm_task, + DM_IOCTL_FLAGS, &flags); + + flags &= ~DM_EXISTS_FLAG; + + (void)prop_dictionary_set_uint32(libdm_task->ldm_task, + DM_IOCTL_FLAGS, flags); +} + +/* Set flags used by LVM this is shortcut and should not be used + by anyone else. */ +void +libdm_task_set_flags(libdm_task_t libdm_task, uint32_t flags) +{ + + (void)prop_dictionary_set_uint32(libdm_task->ldm_task, + DM_IOCTL_FLAGS, flags); +} + +/* Get ioctl protocol status flags. */ +uint32_t +libdm_task_get_flags(libdm_task_t libdm_task) +{ + uint32_t flags; + + (void)prop_dictionary_get_uint32(libdm_task->ldm_task, + DM_IOCTL_FLAGS, &flags); + + return flags; +} + +/* Set ioctl protocol status flags. */ +uint32_t +libdm_task_get_target_num(libdm_task_t libdm_task) +{ + uint32_t count; + + (void)prop_dictionary_get_uint32(libdm_task->ldm_task, + DM_IOCTL_TARGET_COUNT, &count); + + return count; +} + +int32_t +libdm_task_get_open_num(libdm_task_t libdm_task) +{ + int32_t count; + + (void)prop_dictionary_get_int32(libdm_task->ldm_task, + DM_IOCTL_OPEN, &count); + + return count; +} + +uint32_t +libdm_task_get_event_num(libdm_task_t libdm_task) +{ + uint32_t event; + + (void)prop_dictionary_get_uint32(libdm_task->ldm_task, + DM_IOCTL_EVENT, &event); + + return event; +} + +/* Set cmd_data dictionary entry to task struct. */ +int +libdm_task_set_cmd(libdm_cmd_t libdm_cmd, libdm_task_t libdm_task) +{ + + if ((prop_dictionary_set(libdm_task->ldm_task, + DM_IOCTL_CMD_DATA, libdm_cmd->ldm_cmd)) == false) + return ENOENT; + + return 0; +} + +/* Get cmd_data dictionary entry from task struct */ +libdm_cmd_t +libdm_task_get_cmd(libdm_task_t libdm_task) +{ + libdm_cmd_t cmd; + + cmd = malloc(sizeof(*cmd)); + + cmd->ldm_cmd = prop_dictionary_get(libdm_task->ldm_task, + DM_IOCTL_CMD_DATA); + + if (cmd->ldm_cmd == NULL) { + free(cmd); + return NULL; + } + + /* Get a reference prop_dictionary_get will not get it */ + prop_object_retain(cmd->ldm_cmd); + + return cmd; +} + +/* Command functions + * + * Functions for creation, destroing, set, get of command area of + * ioctl dictionary. + */ +libdm_cmd_t +libdm_cmd_create(void) +{ + libdm_cmd_t cmd; + + cmd = malloc(sizeof(*cmd)); + if (cmd == NULL) + return NULL; + + cmd->ldm_cmd = prop_array_create(); + + return cmd; +} + +void +libdm_cmd_destroy(libdm_cmd_t libdm_cmd) +{ + + prop_object_release(libdm_cmd->ldm_cmd); + free(libdm_cmd); +} + +/* Create iterator object for caller this can be used to + iterate through all members of cmd array. */ +libdm_iter_t +libdm_cmd_iter_create(libdm_cmd_t libdm_cmd) +{ + + libdm_iter_t iter; + + iter = malloc(sizeof(*iter)); + if (iter == NULL) + return NULL; + + iter->ldm_obji = prop_array_iterator(libdm_cmd->ldm_cmd); + + return iter; +} + +int +libdm_cmd_set_table(libdm_table_t libdm_table, libdm_cmd_t libdm_cmd) +{ + + return prop_array_add(libdm_cmd->ldm_cmd, + libdm_table->ldm_tbl); +} + + +libdm_target_t +libdm_cmd_get_target(libdm_iter_t iter) +{ + libdm_target_t trgt; + + trgt = malloc(sizeof(*trgt)); + if (trgt == NULL) + return NULL; + + trgt->ldm_trgt = prop_object_iterator_next(iter->ldm_obji); + if (trgt->ldm_trgt == NULL) { + free(trgt); + return NULL; + } + + return trgt; +} + +libdm_table_t +libdm_cmd_get_table(libdm_iter_t iter) +{ + libdm_table_t tbl; + + tbl = malloc(sizeof(*tbl)); + if (tbl == NULL) + return NULL; + + tbl->ldm_tbl = prop_object_iterator_next(iter->ldm_obji); + if (tbl->ldm_tbl == NULL) { + free(tbl); + return NULL; + } + + return tbl; +} + +libdm_dev_t +libdm_cmd_get_dev(libdm_iter_t iter) +{ + libdm_dev_t dev; + + dev = malloc(sizeof(*dev)); + if (dev == NULL) + return NULL; + + dev->ldm_dev = prop_object_iterator_next(iter->ldm_obji); + if (dev->ldm_dev == NULL) { + free(dev); + return NULL; + } + + return dev; +} + +/* + * Deps manipulation routines + */ +uint64_t +libdm_cmd_get_deps(libdm_iter_t libdm_iter) +{ + prop_object_t obj; + uint64_t deps; + + obj = prop_object_iterator_next(libdm_iter->ldm_obji); + deps = prop_number_unsigned_integer_value(obj); + + if (obj != NULL) + prop_object_release(obj); + + return deps; +} + +/* + * Table manipulation routines + */ +libdm_table_t +libdm_table_create(void) +{ + libdm_table_t table; + + table = malloc(sizeof(*table)); + if (table == NULL) + return NULL; + + table->ldm_tbl = prop_dictionary_create(); + + return table; +} + +void +libdm_table_destroy(libdm_table_t libdm_table) +{ + + prop_object_release(libdm_table->ldm_tbl); + free(libdm_table); +} + +int +libdm_table_set_start(uint64_t start, libdm_table_t libdm_table) +{ + + if (libdm_table == NULL) + return ENOENT; + + return prop_dictionary_set_uint64(libdm_table->ldm_tbl, + DM_TABLE_START, start); +} + +uint64_t +libdm_table_get_start(libdm_table_t libdm_table) +{ + uint64_t start; + + if (libdm_table == NULL) + return ENOENT; + + (void)prop_dictionary_get_uint64(libdm_table->ldm_tbl, DM_TABLE_START, + &start); + + return start; +} + +int +libdm_table_set_length(uint64_t length, libdm_table_t libdm_table) +{ + + if (libdm_table == NULL) + return ENOENT; + + return prop_dictionary_set_uint64(libdm_table->ldm_tbl, + DM_TABLE_LENGTH, length); +} + +uint64_t +libdm_table_get_length(libdm_table_t libdm_table) +{ + uint64_t length; + + if (libdm_table == NULL) + return ENOENT; + + prop_dictionary_get_uint64(libdm_table->ldm_tbl, DM_TABLE_LENGTH, + &length); + + return length; +} + +int +libdm_table_set_target(const char *name, libdm_table_t libdm_table) +{ + + if (libdm_table == NULL) + return ENOENT; + + return prop_dictionary_set_cstring(libdm_table->ldm_tbl, DM_TABLE_TYPE, name); +} + +char * +libdm_table_get_target(libdm_table_t libdm_table) +{ + char *target; + + if (!prop_dictionary_get_cstring_nocopy(libdm_table->ldm_tbl, DM_TABLE_TYPE, + (const char **)&target)) + return NULL; + + return target; +} + +int +libdm_table_set_params(const char *params, libdm_table_t libdm_table) +{ + + if (libdm_table == NULL) + return ENOENT; + + return prop_dictionary_set_cstring(libdm_table->ldm_tbl, + DM_TABLE_PARAMS, params); +} + +/* + * Get table params string from libdm_table_t + * returned char * is dynamically allocated caller should free it. + */ +char * +libdm_table_get_params(libdm_table_t libdm_table) +{ + char *params; + + if (!prop_dictionary_get_cstring_nocopy(libdm_table->ldm_tbl, DM_TABLE_PARAMS, + (const char **)¶ms)) + return NULL; + + return params; +} + +int32_t +libdm_table_get_status(libdm_table_t libdm_table) +{ + int32_t status; + + (void)prop_dictionary_get_int32(libdm_table->ldm_tbl, DM_TABLE_STAT, + &status); + + return status; +} + +/* + * Target manipulation routines + */ +void +libdm_target_destroy(libdm_target_t libdm_target) +{ + + prop_object_release(libdm_target->ldm_trgt); + free(libdm_target); +} + +char * +libdm_target_get_name(libdm_target_t libdm_target) +{ + char *name; + + if (!prop_dictionary_get_cstring_nocopy(libdm_target->ldm_trgt, + DM_TARGETS_NAME, (const char **)&name)) + return NULL; + + return name; +} + +int32_t +libdm_target_get_version(libdm_target_t libdm_target, uint32_t *ver, size_t size) +{ + prop_array_t prop_ver; + size_t i; + + prop_ver = prop_dictionary_get(libdm_target->ldm_trgt, + DM_TARGETS_VERSION); + + i = prop_array_count(prop_ver); + + if (i > size) + return -i; + + for (i = 0; i < size; i++) + prop_array_get_uint32(prop_ver, i, &ver[i]); + + return i; +} + + +/* + * Dev manipulation routines + */ +void +libdm_dev_destroy(libdm_dev_t libdm_dev) +{ + + prop_object_release(libdm_dev->ldm_dev); + free(libdm_dev); +} + +char * +libdm_dev_get_name(libdm_dev_t libdm_dev) +{ + char *name; + + if (!prop_dictionary_get_cstring_nocopy(libdm_dev->ldm_dev, + DM_DEV_NAME, (const char **)&name)) + return NULL; + + return name; +} + +uint32_t +libdm_dev_get_minor(libdm_dev_t libdm_dev) +{ + uint32_t dev; + + (void)prop_dictionary_get_uint32(libdm_dev->ldm_dev, DM_DEV_DEV, + &dev); + + return dev; +} + +int +libdm_dev_set_newname(const char *newname, libdm_cmd_t libdm_cmd) +{ + + if (newname == NULL) + return ENOENT; + + return prop_array_set_cstring(libdm_cmd->ldm_cmd, 0, newname); +} |
