 @@ -1,366 +1,367 @@
-/*        $NetBSD: dm.h,v 1.22 2010/12/23 20:07:13 christos Exp $      */
+/*        $NetBSD: dm.h,v 1.23 2011/08/27 17:07:49 ahoka Exp $      */
 /*
  * Copyright (c) 2008 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.
  */
 #ifndef _DM_DEV_H_
 #define _DM_DEV_H_
 #ifdef _KERNEL
 #include <sys/errno.h>
 #include <sys/atomic.h>
 #include <sys/fcntl.h>
 #include <sys/condvar.h>
 #include <sys/kauth.h>
 #include <sys/mutex.h>
 #include <sys/rwlock.h>
 #include <sys/queue.h>
 #include <sys/device.h>
 #include <sys/disk.h>
 #include <sys/disklabel.h>
 #include <prop/proplib.h>
 #define DM_MAX_TYPE_NAME 16
 #define DM_NAME_LEN 128
 #define DM_UUID_LEN 129
 #define DM_VERSION_MAJOR	4
 #define DM_VERSION_MINOR	16
 #define DM_VERSION_PATCHLEVEL	0
 /*** Internal device-mapper structures ***/
 /*
  * A table entry describes a physical range of the logical volume.
  */
 #define MAX_TARGET_STRING_LEN 32
 /*
  * A device mapper table is a list of physical ranges plus the mapping target
  * applied to them.
  */
 typedef struct dm_table_entry {
 	struct dm_dev *dm_dev;		/* backlink */
 	uint64_t start;
 	uint64_t length;
 	struct dm_target *target;      /* Link to table target. */
 	void *target_config;           /* Target specific data. */
 	SLIST_ENTRY(dm_table_entry) next;
 } dm_table_entry_t;
 SLIST_HEAD(dm_table, dm_table_entry);
 typedef struct dm_table dm_table_t;
 typedef struct dm_table_head {
 	/* Current active table is selected with this. */
 	int cur_active_table;
 	struct dm_table tables[2];
 	kmutex_t   table_mtx;
 	kcondvar_t table_cv; /*IO waiting cv */
 	uint32_t io_cnt;
 } dm_table_head_t;
 #define MAX_DEV_NAME 32
 /*
  * This structure is used to store opened vnodes for disk with name.
  * I need this because devices can be opened only once, but I can
  * have more then one device on one partition.
  */
 typedef struct dm_pdev {
 	char name[MAX_DEV_NAME];
 	struct vnode *pdev_vnode;
 	uint64_t pdev_numsec;
 	unsigned pdev_secsize;
 	int ref_cnt; /* reference counter for users ofthis pdev */
 	SLIST_ENTRY(dm_pdev) next_pdev;
 } dm_pdev_t;
 /*
  * This structure is called for every device-mapper device.
  * It points to SLIST of device tables and mirrored, snapshoted etc. devices.
  */
 TAILQ_HEAD(dm_dev_head, dm_dev) dm_devs;
 typedef struct dm_dev {
 	char name[DM_NAME_LEN];
 	char uuid[DM_UUID_LEN];
 	device_t devt; /* pointer to autoconf device_t structure */
 	uint64_t minor; /* Device minor number */
 	uint32_t flags; /* store communication protocol flags */
 	kmutex_t dev_mtx; /* mutex for generall device lock */
 	kcondvar_t dev_cv; /* cv for between ioctl synchronisation */
 	uint32_t event_nr;
 	uint32_t ref_cnt;
 	uint32_t dev_type;
 	dm_table_head_t table_head;
 	struct dm_dev_head upcalls;
 	struct disk *diskp;
 	kmutex_t diskp_mtx;
 	TAILQ_ENTRY(dm_dev) next_upcall; /* LIST of mirrored, snapshoted devices. */
 	TAILQ_ENTRY(dm_dev) next_devlist; /* Major device list. */
 } dm_dev_t;
 /* Device types used for upcalls */
 #define DM_ZERO_DEV            (1 << 0)
 #define DM_ERROR_DEV           (1 << 1)
 #define DM_LINEAR_DEV          (1 << 2)
 #define DM_MIRROR_DEV          (1 << 3)
 #define DM_STRIPE_DEV          (1 << 4)
 #define DM_SNAPSHOT_DEV        (1 << 5)
 #define DM_SNAPSHOT_ORIG_DEV   (1 << 6)
 #define DM_SPARE_DEV           (1 << 7)
 /* Set this device type only during dev remove ioctl. */
 #define DM_DELETING_DEV        (1 << 8)
 /* for zero, error : dm_target->target_config == NULL */
 /*
  * Target config is initiated with target_init function.
  */
 /* for linear : */
 typedef struct target_linear_config {
 	dm_pdev_t *pdev;
 	uint64_t offset;
 	TAILQ_ENTRY(target_linear_config) entries;
 } dm_target_linear_config_t;
 /*
  * Striping devices are stored in a linked list, this might be inefficient
  * for more than 8 striping devices and can be changed to something more
  * scalable.
  * TODO: look for other options than linked list.
  */
 TAILQ_HEAD(target_linear_devs, target_linear_config);
 typedef struct target_linear_devs dm_target_linear_devs_t;
 /* for stripe : */
 typedef struct target_stripe_config {
 #define DM_STRIPE_DEV_OFFSET 2
 	struct target_linear_devs stripe_devs;
 	uint8_t stripe_num;
 	uint64_t stripe_chunksize;
 	size_t params_len;
 } dm_target_stripe_config_t;
 /* for mirror : */
 typedef struct target_mirror_config {
 #define MAX_MIRROR_COPIES 4
 	dm_pdev_t *orig;
 	dm_pdev_t *copies[MAX_MIRROR_COPIES];
 	/* copied blocks bitmaps administration etc*/
 	dm_pdev_t *log_pdev;	/* for administration */
 	uint64_t log_regionsize;	/* blocksize of mirror */
 	/* list of parts that still need copied etc.; run length encoded? */
 } dm_target_mirror_config_t;
 /* for snapshot : */
 typedef struct target_snapshot_config {
 	dm_pdev_t *tsc_snap_dev;
 	/* cow dev is set only for persistent snapshot devices */
 	dm_pdev_t *tsc_cow_dev;
 	uint64_t tsc_chunk_size;
 	uint32_t tsc_persistent_dev;
 } dm_target_snapshot_config_t;
 /* for snapshot-origin devices */
 typedef struct target_snapshot_origin_config {
 	dm_pdev_t *tsoc_real_dev;
 	/* list of snapshots ? */
 } dm_target_snapshot_origin_config_t;
 /* constant dm_target structures for error, zero, linear, stripes etc. */
 typedef struct dm_target {
 	char name[DM_MAX_TYPE_NAME];
 	/* Initialize target_config area */
 	int (*init)(dm_dev_t *, void **, char *);
 	/* Destroy target_config area */
 	int (*destroy)(dm_table_entry_t *);
 	int (*deps) (dm_table_entry_t *, prop_array_t);
 	/*
 	 * Status routine is called to get params string, which is target
 	 * specific. When dm_table_status_ioctl is called with flag
 	 * DM_STATUS_TABLE_FLAG I have to sent params string back.
 	 */
 	char * (*status)(void *);
 	int (*strategy)(dm_table_entry_t *, struct buf *);
 	int (*sync)(dm_table_entry_t *);
 	int (*upcall)(dm_table_entry_t *, struct buf *);
 	int (*secsize)(dm_table_entry_t *, unsigned *);
 	uint32_t version[3];
 	int ref_cnt;
 	TAILQ_ENTRY(dm_target) dm_target_next;
 } dm_target_t;
 /* Interface structures */
 /*
  * This structure is used to translate command sent to kernel driver in
  * <key>command</key>
  * <value></value>
  * to function which I can call, and if the command is allowed for
  * non-superusers.
  */
 struct cmd_function {
 	const char *cmd;
 	int  (*fn)(prop_dictionary_t);
 	int  allowed;
 };
 /* device-mapper */
 void dmgetproperties(struct disk *, dm_table_head_t *);
 /* dm_ioctl.c */
 int dm_dev_create_ioctl(prop_dictionary_t);
 int dm_dev_list_ioctl(prop_dictionary_t);
 int dm_dev_remove_ioctl(prop_dictionary_t);
 int dm_dev_rename_ioctl(prop_dictionary_t);
 int dm_dev_resume_ioctl(prop_dictionary_t);
 int dm_dev_status_ioctl(prop_dictionary_t);
 int dm_dev_suspend_ioctl(prop_dictionary_t);
 int dm_check_version(prop_dictionary_t);
 int dm_get_version_ioctl(prop_dictionary_t);
 int dm_list_versions_ioctl(prop_dictionary_t);
 int dm_table_clear_ioctl(prop_dictionary_t);
 int dm_table_deps_ioctl(prop_dictionary_t);
 int dm_table_load_ioctl(prop_dictionary_t);
 int dm_table_status_ioctl(prop_dictionary_t);
 /* dm_target.c */
 dm_target_t* dm_target_alloc(const char *);
 dm_target_t* dm_target_autoload(const char *);
 int dm_target_destroy(void);
 int dm_target_insert(dm_target_t *);
 prop_array_t dm_target_prop_list(void);
 dm_target_t* dm_target_lookup(const char *);
 int dm_target_rem(char *);
 void dm_target_unbusy(dm_target_t *);
 void dm_target_busy(dm_target_t *);
 /* XXX temporally add */
 int dm_target_init(void);
 #define DM_MAX_PARAMS_SIZE 1024
 /* dm_target_linear.c */
 int dm_target_linear_init(dm_dev_t *, void**, char *);
 char * dm_target_linear_status(void *);
 int dm_target_linear_strategy(dm_table_entry_t *, struct buf *);
 int dm_target_linear_sync(dm_table_entry_t *);
 int dm_target_linear_deps(dm_table_entry_t *, prop_array_t);
 int dm_target_linear_destroy(dm_table_entry_t *);
 int dm_target_linear_upcall(dm_table_entry_t *, struct buf *);
 int dm_target_linear_secsize(dm_table_entry_t *, unsigned *);
 /* Generic function used to convert char to string */
 uint64_t atoi(const char *);
 /* dm_target_stripe.c */
 int dm_target_stripe_init(dm_dev_t *, void**, char *);
 char * dm_target_stripe_status(void *);
 int dm_target_stripe_strategy(dm_table_entry_t *, struct buf *);
 int dm_target_stripe_sync(dm_table_entry_t *);
 int dm_target_stripe_deps(dm_table_entry_t *, prop_array_t);
 int dm_target_stripe_destroy(dm_table_entry_t *);
 int dm_target_stripe_upcall(dm_table_entry_t *, struct buf *);
 int dm_target_stripe_secsize(dm_table_entry_t *, unsigned *);
 /* dm_table.c  */
 #define DM_TABLE_ACTIVE 0
 #define DM_TABLE_INACTIVE 1
 int dm_table_destroy(dm_table_head_t *, uint8_t);
 uint64_t dm_table_size(dm_table_head_t *);
 uint64_t dm_inactive_table_size(dm_table_head_t *);
 void dm_table_disksize(dm_table_head_t *, uint64_t *, unsigned *);
 dm_table_t * dm_table_get_entry(dm_table_head_t *, uint8_t);
 int dm_table_get_target_count(dm_table_head_t *, uint8_t);
 void dm_table_release(dm_table_head_t *, uint8_t s);
 void dm_table_switch_tables(dm_table_head_t *);
 void dm_table_head_init(dm_table_head_t *);
 void dm_table_head_destroy(dm_table_head_t *);
 /* dm_dev.c */
 dm_dev_t* dm_dev_alloc(void);
 void dm_dev_busy(dm_dev_t *);
 int dm_dev_destroy(void);
 dm_dev_t* dm_dev_detach(device_t);
 int dm_dev_free(dm_dev_t *);
 int dm_dev_init(void);
 int dm_dev_insert(dm_dev_t *);
 dm_dev_t* dm_dev_lookup(const char *, const char *, int);
 prop_array_t dm_dev_prop_list(void);
 dm_dev_t* dm_dev_rem(const char *, const char *, int);
 /*int dm_dev_test_minor(int);*/
 void dm_dev_unbusy(dm_dev_t *);
 /* dm_pdev.c */
 int dm_pdev_decr(dm_pdev_t *);
 int dm_pdev_destroy(void);
 int dm_pdev_init(void);
 dm_pdev_t* dm_pdev_insert(const char *);
 #endif /*_KERNEL*/
 #endif /*_DM_DEV_H_*/

 @@ -1,977 +1,978 @@
-/* $NetBSD: dm_ioctl.c,v 1.25 2011/05/24 15:23:41 joerg Exp $      */
+/* $NetBSD: dm_ioctl.c,v 1.26 2011/08/27 17:07:49 ahoka Exp $      */
 /*
  * Copyright (c) 2008 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.
  */
 /*
  * Locking is used to synchronise between ioctl calls and between dm_table's
  * users.
+ *
  * ioctl locking:
  * Simple reference counting, to count users of device will be used routines
  * dm_dev_busy/dm_dev_unbusy are used for that.
  * dm_dev_lookup/dm_dev_rem call dm_dev_busy before return(caller is therefore
  * holder of reference_counter last).
+ *
  * ioctl routines which change/remove dm_dev parameters must wait on
  * dm_dev::dev_cv and when last user will call dm_dev_unbusy they will wake
  * up them.
+ *
  * table_head locking:
  * To access table entries dm_table_* routines must be used.
+ *
  * dm_table_get_entry will increment table users reference
  * counter. It will return active or inactive table depends
  * on uint8_t argument.
+ *
  * dm_table_release must be called for every table_entry from
  * dm_table_get_entry. Between these to calls tables can'tbe switched
  * or destroyed.
+ *
  * dm_table_head_init initialize talbe_entries SLISTS and io_cv.
+ *
  * dm_table_head_destroy destroy cv.
+ *
  * There are two types of users for dm_table_head first type will
  * only read list and try to do anything with it e.g. dmstrategy,
  * dm_table_size etc. There is another user for table_head which wants
  * to change table lists e.g. dm_dev_resume_ioctl, dm_dev_remove_ioctl,
  * dm_table_clear_ioctl.
+ *
  * NOTE: It is not allowed to call dm_table_destroy, dm_table_switch_tables
  *       with hold table reference counter. Table reference counter is hold
  *       after calling dm_table_get_entry routine. After calling this
  *       function user must call dm_table_release before any writer table
  *       operation.
+ *
  * Example: dm_table_get_entry
  *          dm_table_destroy/dm_table_switch_tables
  * This exaple will lead to deadlock situation because after dm_table_get_entry
  * table reference counter is != 0 and dm_table_destroy have to wait on cv until
  * reference counter is 0.
+ *
  */
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/device.h>
 #include <sys/disk.h>
 #include <sys/disklabel.h>
 #include <sys/kmem.h>
 #include <sys/malloc.h>
 #include <sys/vnode.h>
 #include <machine/int_fmtio.h>
 #include "netbsd-dm.h"
 #include "dm.h"
 static uint32_t sc_minor_num;
 extern const struct dkdriver dmdkdriver;
 uint32_t dm_dev_counter;
 /* Generic cf_data for device-mapper driver */
 static struct cfdata dm_cfdata = {
 	.cf_name = "dm",
 	.cf_atname = "dm",
 	.cf_fstate = FSTATE_STAR,
 	.cf_unit = 0
 };
 #define DM_REMOVE_FLAG(flag, name) do {					\
 		prop_dictionary_get_uint32(dm_dict,DM_IOCTL_FLAGS,&flag); \
 		flag &= ~name;						\
 		prop_dictionary_set_uint32(dm_dict,DM_IOCTL_FLAGS,flag); \
 } while (/*CONSTCOND*/0)
 #define DM_ADD_FLAG(flag, name) do {					\
 		prop_dictionary_get_uint32(dm_dict,DM_IOCTL_FLAGS,&flag); \
 		flag |= name;						\
 		prop_dictionary_set_uint32(dm_dict,DM_IOCTL_FLAGS,flag); \
 } while (/*CONSTCOND*/0)
 static int dm_dbg_print_flags(int);
 /*
  * Print flags sent to the kernel from libevmapper.
  */
 static int
 dm_dbg_print_flags(int flags)
+{
 	aprint_debug("dbg_print --- %d\n", flags);
 	if (flags & DM_READONLY_FLAG)
 		aprint_debug("dbg_flags: DM_READONLY_FLAG set In/Out\n");
 	if (flags & DM_SUSPEND_FLAG)
 		aprint_debug("dbg_flags: DM_SUSPEND_FLAG set In/Out \n");
 	if (flags & DM_PERSISTENT_DEV_FLAG)
 		aprint_debug("db_flags: DM_PERSISTENT_DEV_FLAG set In\n");
 	if (flags & DM_STATUS_TABLE_FLAG)
 		aprint_debug("dbg_flags: DM_STATUS_TABLE_FLAG set In\n");
 	if (flags & DM_ACTIVE_PRESENT_FLAG)
 		aprint_debug("dbg_flags: DM_ACTIVE_PRESENT_FLAG set Out\n");
 	if (flags & DM_INACTIVE_PRESENT_FLAG)
 		aprint_debug("dbg_flags: DM_INACTIVE_PRESENT_FLAG set Out\n");
 	if (flags & DM_BUFFER_FULL_FLAG)
 		aprint_debug("dbg_flags: DM_BUFFER_FULL_FLAG set Out\n");
 	if (flags & DM_SKIP_BDGET_FLAG)
 		aprint_debug("dbg_flags: DM_SKIP_BDGET_FLAG set In\n");
 	if (flags & DM_SKIP_LOCKFS_FLAG)
 		aprint_debug("dbg_flags: DM_SKIP_LOCKFS_FLAG set In\n");
 	if (flags & DM_NOFLUSH_FLAG)
 		aprint_debug("dbg_flags: DM_NOFLUSH_FLAG set In\n");
 	return 0;
+}
 /*
  * Get version ioctl call I do it as default therefore this
  * function is unused now.
  */
 int
 dm_get_version_ioctl(prop_dictionary_t dm_dict)
+{
 	return 0;
+}
 /*
  * Get list of all available targets from global
  * target list and sent them back to libdevmapper.
  */
 int
 dm_list_versions_ioctl(prop_dictionary_t dm_dict)
+{
 	prop_array_t target_list;
 	uint32_t flags;
 	flags = 0;
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
 	dm_dbg_print_flags(flags);
 	target_list = dm_target_prop_list();
 	prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, target_list);
 	prop_object_release(target_list);
 	return 0;
+}
 /*
  * Create in-kernel entry for device. Device attributes such as name, uuid are
  * taken from proplib dictionary.
+ *
  */
 int
 dm_dev_create_ioctl(prop_dictionary_t dm_dict)
+{
 	dm_dev_t *dmv;
 	const char *name, *uuid;
 	int r, flags;
 	device_t devt;
 	r = 0;
 	flags = 0;
 	name = NULL;
 	uuid = NULL;
 	/* Get needed values from dictionary. */
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
 	dm_dbg_print_flags(flags);
 	/* Lookup name and uuid if device already exist quit. */
 	if ((dmv = dm_dev_lookup(name, uuid, -1)) != NULL) {
 		DM_ADD_FLAG(flags, DM_EXISTS_FLAG);	/* Device already exists */
 		dm_dev_unbusy(dmv);
 		return EEXIST;
+	}
 	if ((devt = config_attach_pseudo(&dm_cfdata)) == NULL) {
 		aprint_error("Unable to attach pseudo device dm/%s\n", name);
 		return (ENOMEM);
+	}
 	if ((dmv = dm_dev_alloc()) == NULL)
 		return ENOMEM;
 	if (uuid)
 		strncpy(dmv->uuid, uuid, DM_UUID_LEN);
 	else
 		dmv->uuid[0] = '\0';
 	if (name)
 		strlcpy(dmv->name, name, DM_NAME_LEN);
 	dmv->minor = (uint64_t)atomic_inc_32_nv(&sc_minor_num);
 	dmv->flags = 0;		/* device flags are set when needed */
 	dmv->ref_cnt = 0;
 	dmv->event_nr = 0;
 	dmv->dev_type = 0;
 	dmv->devt = devt;
 	dm_table_head_init(&dmv->table_head);
 	mutex_init(&dmv->dev_mtx, MUTEX_DEFAULT, IPL_NONE);
 	mutex_init(&dmv->diskp_mtx, MUTEX_DEFAULT, IPL_NONE);
 	cv_init(&dmv->dev_cv, "dm_dev");
 	if (flags & DM_READONLY_FLAG)
 		dmv->flags |= DM_READONLY_FLAG;
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
 	disk_init(dmv->diskp, dmv->name, &dmdkdriver);
 	disk_attach(dmv->diskp);
 	dmv->diskp->dk_info = NULL;
 	if ((r = dm_dev_insert(dmv)) != 0)
 		dm_dev_free(dmv);
 	DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
 	DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
 	/* Increment device counter After creating device */
 	atomic_inc_32(&dm_dev_counter);
 	return r;
+}
 /*
  * Get list of created device-mapper devices fromglobal list and
  * send it to kernel.
+ *
  * Output dictionary:
+ *
  * <key>cmd_data</key>
  *  <array>
  *   <dict>
  *    <key>name<key>
  *    <string>...</string>
+ *
  *    <key>dev</key>
  *    <integer>...</integer>
  *   </dict>
  *  </array>
+ *
  */
 int
 dm_dev_list_ioctl(prop_dictionary_t dm_dict)
+{
 	prop_array_t dev_list;
 	uint32_t flags;
 	flags = 0;
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
 	dm_dbg_print_flags(flags);
 	dev_list = dm_dev_prop_list();
 	prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, dev_list);
 	prop_object_release(dev_list);
 	return 0;
+}
 /*
  * Rename selected devices old name is in struct dm_ioctl.
  * newname is taken from dictionary
+ *
  * <key>cmd_data</key>
  *  <array>
  *   <string>...</string>
  *  </array>
  */
 int
 dm_dev_rename_ioctl(prop_dictionary_t dm_dict)
+{
 	prop_array_t cmd_array;
 	dm_dev_t *dmv;
 	const char *name, *uuid, *n_name;
 	uint32_t flags, minor;
 	name = NULL;
 	uuid = NULL;
 	minor = 0;
 	/* Get needed values from dictionary. */
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
 	dm_dbg_print_flags(flags);
 	cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA);
 	prop_array_get_cstring_nocopy(cmd_array, 0, &n_name);
 	if (strlen(n_name) + 1 > DM_NAME_LEN)
 		return EINVAL;
 	if ((dmv = dm_dev_rem(name, uuid, minor)) == NULL) {
 		DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
 		return ENOENT;
+	}
 	/* change device name */
 	/*
 	 * XXX How to deal with this change, name only used in
 	 * dm_dev_routines, should I add dm_dev_change_name which will run
 	 * under the dm_dev_list mutex ?
 	 */
 	strlcpy(dmv->name, n_name, DM_NAME_LEN);
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
 	prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
 	dm_dev_insert(dmv);
 	return 0;
+}
 /*
  * Remove device from global list I have to remove active
  * and inactive tables first.
  */
 int
 dm_dev_remove_ioctl(prop_dictionary_t dm_dict)
+{
 	dm_dev_t *dmv;
 	const char *name, *uuid;
 	uint32_t flags, minor;
 	device_t devt;
 	flags = 0;
 	name = NULL;
 	uuid = NULL;
 	/* Get needed values from dictionary. */
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
 	dm_dbg_print_flags(flags);
 	/*
 	 * This seems as hack to me, probably use routine dm_dev_get_devt to
 	 * atomicaly get devt from device.
 	 */
 	if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
 		DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
 		return ENOENT;
+	}
 	devt = dmv->devt;
 	dm_dev_unbusy(dmv);
 	/*
 	 * This will call dm_detach routine which will actually removes
 	 * device.
 	 */
 	return config_detach(devt, DETACH_QUIET);
+}
 /*
  * Return actual state of device to libdevmapper.
  */
 int
 dm_dev_status_ioctl(prop_dictionary_t dm_dict)
+{
 	dm_dev_t *dmv;
 	const char *name, *uuid;
 	uint32_t flags, j, minor;
 	name = NULL;
 	uuid = NULL;
 	flags = 0;
 	j = 0;
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
 	if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
 		DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
 		return ENOENT;
+	}
 	dm_dbg_print_flags(dmv->flags);
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
 	prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
 	if (dmv->flags & DM_SUSPEND_FLAG)
 		DM_ADD_FLAG(flags, DM_SUSPEND_FLAG);
 	/*
 	 * Add status flags for tables I have to check both active and
 	 * inactive tables.
 	 */
 	if ((j = dm_table_get_target_count(&dmv->table_head, DM_TABLE_ACTIVE))) {
 		DM_ADD_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
 	} else
 		DM_REMOVE_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_TARGET_COUNT, j);
 	if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_INACTIVE))
 		DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
 	else
 		DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
 	dm_dev_unbusy(dmv);
 	return 0;
+}
 /*
  * Set only flag to suggest that device is suspended. This call is
  * not supported in NetBSD.
+ *
  */
 int
 dm_dev_suspend_ioctl(prop_dictionary_t dm_dict)
+{
 	dm_dev_t *dmv;
 	const char *name, *uuid;
 	uint32_t flags, minor;
 	name = NULL;
 	uuid = NULL;
 	flags = 0;
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
 	if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
 		DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
 		return ENOENT;
+	}
 	atomic_or_32(&dmv->flags, DM_SUSPEND_FLAG);
 	dm_dbg_print_flags(dmv->flags);
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, dmv->flags);
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
 	dm_dev_unbusy(dmv);
 	/* Add flags to dictionary flag after dmv -> dict copy */
 	DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
 	return 0;
+}
 /*
  * Simulate Linux behaviour better and switch tables here and not in
  * dm_table_load_ioctl.
  */
 int
 dm_dev_resume_ioctl(prop_dictionary_t dm_dict)
+{
 	dm_dev_t *dmv;
 	const char *name, *uuid;
 	uint32_t flags, minor;
 	name = NULL;
 	uuid = NULL;
 	flags = 0;
 	/*
 	 * char *xml; xml = prop_dictionary_externalize(dm_dict);
 	 * printf("%s\n",xml);
 	 */
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
 	/* Remove device from global device list */
 	if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
 		DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
 		return ENOENT;
+	}
 	atomic_and_32(&dmv->flags, ~(DM_SUSPEND_FLAG | DM_INACTIVE_PRESENT_FLAG));
 	atomic_or_32(&dmv->flags, DM_ACTIVE_PRESENT_FLAG);
 	dm_table_switch_tables(&dmv->table_head);
 	DM_ADD_FLAG(flags, DM_EXISTS_FLAG);
 	dmgetproperties(dmv->diskp, &dmv->table_head);
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt);
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, flags);
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
 	dm_dev_unbusy(dmv);
 	/* Destroy inactive table after resume. */
 	dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
 	return 0;
+}
 /*
  * Table management routines
  * lvm2tools doens't send name/uuid to kernel with table
  * for lookup I have to use minor number.
  */
 /*
  * Remove inactive table from device. Routines which work's with inactive tables
  * doesn't need to synchronise with dmstrategy. They can synchronise themselves with mutex?.
+ *
  */
 int
 dm_table_clear_ioctl(prop_dictionary_t dm_dict)
+{
 	dm_dev_t *dmv;
 	const char *name, *uuid;
 	uint32_t flags, minor;
 	dmv = NULL;
 	name = NULL;
 	uuid = NULL;
 	flags = 0;
 	minor = 0;
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
 	aprint_debug("Clearing inactive table from device: %s--%s\n",
 	    name, uuid);
 	if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
 		DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
 		return ENOENT;
+	}
 	/* Select unused table */
 	dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
 	atomic_and_32(&dmv->flags, ~DM_INACTIVE_PRESENT_FLAG);
 	dm_dev_unbusy(dmv);
 	return 0;
+}
 /*
  * Get list of physical devices for active table.
  * Get dev_t from pdev vnode and insert it into cmd_array.
+ *
  * XXX. This function is called from lvm2tools to get information
  *      about physical devices, too e.g. during vgcreate.
  */
 int
 dm_table_deps_ioctl(prop_dictionary_t dm_dict)
+{
 	dm_dev_t *dmv;
 	dm_table_t *tbl;
 	dm_table_entry_t *table_en;
 	prop_array_t cmd_array;
 	const char *name, *uuid;
 	uint32_t flags, minor;
 	int table_type;
 	size_t i;
 	name = NULL;
 	uuid = NULL;
 	dmv = NULL;
 	flags = 0;
 	i = 0;
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
 	/* create array for dev_t's */
 	cmd_array = prop_array_create();
 	if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
 		DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
 		return ENOENT;
+	}
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
 	prop_dictionary_set_cstring(dm_dict, DM_IOCTL_NAME, dmv->name);
 	prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid);
 	aprint_debug("Getting table deps for device: %s\n", dmv->name);
 	/*
 	 * if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query
 	 * INACTIVE TABLE
 	 */
 	if (flags & DM_QUERY_INACTIVE_TABLE_FLAG)
 		table_type = DM_TABLE_INACTIVE;
 	else
 		table_type = DM_TABLE_ACTIVE;
 	tbl = dm_table_get_entry(&dmv->table_head, table_type);
 	SLIST_FOREACH(table_en, tbl, next)
 	    table_en->target->deps(table_en, cmd_array);
 	dm_table_release(&dmv->table_head, table_type);
 	dm_dev_unbusy(dmv);
 	prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, cmd_array);
 	prop_object_release(cmd_array);
 	return 0;
+}
 /*
  * Load new table/tables to device.
  * Call apropriate target init routine open all physical pdev's and
  * link them to device. For other targets mirror, strip, snapshot
  * etc. also add dependency devices to upcalls list.
+ *
  * Load table to inactive slot table are switched in dm_device_resume_ioctl.
  * This simulates Linux behaviour better there should not be any difference.
+ *
  */
 int
 dm_table_load_ioctl(prop_dictionary_t dm_dict)
+{
 	dm_dev_t *dmv;
 	dm_table_entry_t *table_en, *last_table;
 	dm_table_t *tbl;
 	dm_target_t *target;
 	prop_object_iterator_t iter;
 	prop_array_t cmd_array;
 	prop_dictionary_t target_dict;
 	const char *name, *uuid, *type;
 	uint32_t flags, ret, minor;
 	char *str;
 	ret = 0;
 	flags = 0;
 	name = NULL;
 	uuid = NULL;
 	dmv = NULL;
 	last_table = NULL;
 	str = NULL;
 	/*
 	 * char *xml; xml = prop_dictionary_externalize(dm_dict);
 	 * printf("%s\n",xml);
 	 */
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
 	cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA);
 	iter = prop_array_iterator(cmd_array);
 	dm_dbg_print_flags(flags);
 	if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
 		DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
 		return ENOENT;
+	}
 	aprint_debug("Loading table to device: %s--%d\n", name,
 	    dmv->table_head.cur_active_table);
 	/*
 	 * I have to check if this table slot is not used by another table list.
 	 * if it is used I should free them.
 	 */
 	if (dmv->flags & DM_INACTIVE_PRESENT_FLAG)
 		dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
 	dm_dbg_print_flags(dmv->flags);
 	tbl = dm_table_get_entry(&dmv->table_head, DM_TABLE_INACTIVE);
 	aprint_debug("dmv->name = %s\n", dmv->name);
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
 	while ((target_dict = prop_object_iterator_next(iter)) != NULL) {
 		prop_dictionary_get_cstring_nocopy(target_dict,
 		    DM_TABLE_TYPE, &type);
 		/*
 		 * If we want to deny table with 2 or more different
 		 * target we should do it here
 		 */
 		if (((target = dm_target_lookup(type)) == NULL) &&
 		    ((target = dm_target_autoload(type)) == NULL)) {
 			dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
 			dm_dev_unbusy(dmv);
 			return ENOENT;
+		}
 		if ((table_en = kmem_alloc(sizeof(dm_table_entry_t),
 			    KM_SLEEP)) == NULL) {
 			dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
 			dm_dev_unbusy(dmv);
 			return ENOMEM;
+		}
 		prop_dictionary_get_uint64(target_dict, DM_TABLE_START,
 		    &table_en->start);
 		prop_dictionary_get_uint64(target_dict, DM_TABLE_LENGTH,
 		    &table_en->length);
 		table_en->target = target;
 		table_en->dm_dev = dmv;
 		table_en->target_config = NULL;
 		/*
 		 * There is a parameter string after dm_target_spec
 		 * structure which  points to /dev/wd0a 284 part of
 		 * table. String str points to this text. This can be
 		 * null and therefore it should be checked before we try to
 		 * use it.
 		 */
 		prop_dictionary_get_cstring(target_dict,
 		    DM_TABLE_PARAMS, (char **) &str);
 		if (SLIST_EMPTY(tbl))
 			/* insert this table to head */
 			SLIST_INSERT_HEAD(tbl, table_en, next);
 		else
 			SLIST_INSERT_AFTER(last_table, table_en, next);
 		/*
 		 * Params string is different for every target,
 		 * therfore I have to pass it to target init
 		 * routine and parse parameters there.
 		 */
 		if ((ret = target->init(dmv, &table_en->target_config,
 			    str)) != 0) {
 			dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
 			dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE);
 			free(str, M_TEMP);
 			dm_dev_unbusy(dmv);
 			dm_target_unbusy(target);
 			return ret;
+		}
 		last_table = table_en;
 		free(str, M_TEMP);
+	}
 	prop_object_iterator_release(iter);
 	DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
 	atomic_or_32(&dmv->flags, DM_INACTIVE_PRESENT_FLAG);
 	dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE);
 	dm_dev_unbusy(dmv);
 	return 0;
+}
 /*
  * Get description of all tables loaded to device from kernel
  * and send it to libdevmapper.
+ *
  * Output dictionary for every table:
+ *
  * <key>cmd_data</key>
  * <array>
  *   <dict>
  *    <key>type<key>
  *    <string>...</string>
+ *
  *    <key>start</key>
  *    <integer>...</integer>
+ *
  *    <key>length</key>
  *    <integer>...</integer>
+ *
  *    <key>params</key>
  *    <string>...</string>
  *   </dict>
  * </array>
+ *
  */
 int
 dm_table_status_ioctl(prop_dictionary_t dm_dict)
+{
 	dm_dev_t *dmv;
 	dm_table_t *tbl;
 	dm_table_entry_t *table_en;
 	prop_array_t cmd_array;
 	prop_dictionary_t target_dict;
 	uint32_t rec_size, minor;
 	const char *name, *uuid;
 	char *params;
 	int flags;
 	int table_type;
 	dmv = NULL;
 	uuid = NULL;
 	name = NULL;
 	params = NULL;
 	flags = 0;
 	rec_size = 0;
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name);
 	prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags);
 	prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor);
 	cmd_array = prop_array_create();
 	if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) {
 		DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG);
 		return ENOENT;
+	}
 	/*
 	 * if DM_QUERY_INACTIVE_TABLE_FLAG is passed we need to query
 	 * INACTIVE TABLE
 	 */
 	if (flags & DM_QUERY_INACTIVE_TABLE_FLAG)
 		table_type = DM_TABLE_INACTIVE;
 	else
 		table_type = DM_TABLE_ACTIVE;
 	if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_ACTIVE))
 		DM_ADD_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
 	else {
 		DM_REMOVE_FLAG(flags, DM_ACTIVE_PRESENT_FLAG);
 		if (dm_table_get_target_count(&dmv->table_head, DM_TABLE_INACTIVE))
 			DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
 		else {
 			DM_REMOVE_FLAG(flags, DM_INACTIVE_PRESENT_FLAG);
+		}
+	}
 	if (dmv->flags & DM_SUSPEND_FLAG)
 		DM_ADD_FLAG(flags, DM_SUSPEND_FLAG);
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor);
 	aprint_debug("Status of device tables: %s--%d\n",
 	    name, dmv->table_head.cur_active_table);
 	tbl = dm_table_get_entry(&dmv->table_head, table_type);
 	SLIST_FOREACH(table_en, tbl, next) {
 		target_dict = prop_dictionary_create();
 		aprint_debug("%016" PRIu64 ", length %016" PRIu64
 		    ", target %s\n", table_en->start, table_en->length,
 		    table_en->target->name);
 		prop_dictionary_set_uint64(target_dict, DM_TABLE_START,
 		    table_en->start);
 		prop_dictionary_set_uint64(target_dict, DM_TABLE_LENGTH,
 		    table_en->length);
 		prop_dictionary_set_cstring(target_dict, DM_TABLE_TYPE,
 		    table_en->target->name);
 		/* dm_table_get_cur_actv.table ?? */
 		prop_dictionary_set_int32(target_dict, DM_TABLE_STAT,
 		    dmv->table_head.cur_active_table);
 		if (flags & DM_STATUS_TABLE_FLAG) {
 			params = table_en->target->status
 			    (table_en->target_config);
 			if (params != NULL) {
 				prop_dictionary_set_cstring(target_dict,
 				    DM_TABLE_PARAMS, params);
 				kmem_free(params, DM_MAX_PARAMS_SIZE);
+			}
+		}
 		prop_array_add(cmd_array, target_dict);
 		prop_object_release(target_dict);
+	}
 	dm_table_release(&dmv->table_head, table_type);
 	dm_dev_unbusy(dmv);
 	prop_dictionary_set_uint32(dm_dict, DM_IOCTL_FLAGS, flags);
 	prop_dictionary_set(dm_dict, DM_IOCTL_CMD_DATA, cmd_array);
 	prop_object_release(cmd_array);
 	return 0;
+}
 /*
  * For every call I have to set kernel driver version.
  * Because I can have commands supported only in other
  * newer/later version. This routine is called for every
  * ioctl command.
  */
 int
 dm_check_version(prop_dictionary_t dm_dict)
+{
 	size_t i;
 	int dm_version[3];
 	prop_array_t ver;
 	ver = prop_dictionary_get(dm_dict, DM_IOCTL_VERSION);
 	for (i = 0; i < 3; i++)
 		prop_array_get_uint32(ver, i, &dm_version[i]);
 	if (DM_VERSION_MAJOR != dm_version[0] || DM_VERSION_MINOR < dm_version[1]) {
 		aprint_debug("libdevmapper/kernel version mismatch "
 		    "kernel: %d.%d.%d libdevmapper: %d.%d.%d\n",
 		    DM_VERSION_MAJOR, DM_VERSION_MINOR, DM_VERSION_PATCHLEVEL,
 		    dm_version[0], dm_version[1], dm_version[2]);
 		return EIO;
+	}
 	prop_array_set_uint32(ver, 0, DM_VERSION_MAJOR);
 	prop_array_set_uint32(ver, 1, DM_VERSION_MINOR);
 	prop_array_set_uint32(ver, 2, DM_VERSION_PATCHLEVEL);
 	prop_dictionary_set(dm_dict, DM_IOCTL_VERSION, ver);
 	return 0;
+}