xref: /src/lib/libdm/libdm_ioctl.c

/*
 * 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);
}