summaryrefslogtreecommitdiff
path: root/lib/libdm/libdm_ioctl.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/libdm/libdm_ioctl.c')
-rw-r--r--lib/libdm/libdm_ioctl.c895
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 **)&params))
+ 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);
+}