 @@ -1,337 +1,298 @@
-/*        $NetBSD: dm.h,v 1.36 2019/12/08 10:35:53 tkusumi Exp $      */
+/*        $NetBSD: dm.h,v 1.37 2019/12/08 10:50:21 tkusumi 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/vnode.h>
 #include <sys/device.h>
 #include <sys/disk.h>
 #include <sys/disklabel.h>
 #include <miscfs/specfs/specdev.h> /* for v_rdev */
 #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 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 than 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);
 //extern struct dm_dev_head 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;
 	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;
 /* 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_table_entry_t *, 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];
 	uint32_t ref_cnt;
 	TAILQ_ENTRY(dm_target) dm_target_next;
 } dm_target_t;
 /* Interface structures */
 /* 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_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(const 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_table_entry_t *, 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_table_entry_t *, 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,179 +1,191 @@
-/*$NetBSD: dm_target_mirror.c,v 1.15 2019/12/08 04:41:02 tkusumi Exp $*/
+/*$NetBSD: dm_target_mirror.c,v 1.16 2019/12/08 10:50:21 tkusumi Exp $*/
 /*
  * Copyright (c) 2009 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/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: dm_target_mirror.c,v 1.15 2019/12/08 04:41:02 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_target_mirror.c,v 1.16 2019/12/08 10:50:21 tkusumi Exp $");
 /*
  * This file implements initial version of device-mapper mirror target.
  */
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/buf.h>
 #include "dm.h"
 /* dm_target_mirror.c */
 int dm_target_mirror_init(dm_table_entry_t *, char *);
 char *dm_target_mirror_status(void *);
 int dm_target_mirror_strategy(dm_table_entry_t *, struct buf *);
 int dm_target_mirror_sync(dm_table_entry_t *);
 int dm_target_mirror_deps(dm_table_entry_t *, prop_array_t);
 int dm_target_mirror_destroy(dm_table_entry_t *);
 int dm_target_mirror_upcall(dm_table_entry_t *, struct buf *);
 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;
 #ifdef DM_TARGET_MODULE
 /*
  * Every target can be compiled directly to dm driver or as a
  * separate module this part of target is used for loading targets
  * to dm driver.
  * Target can be unloaded from kernel only if there are no users of
  * it e.g. there are no devices which uses that target.
  */
 #include <sys/kernel.h>
 #include <sys/module.h>
 MODULE(MODULE_CLASS_MISC, dm_target_mirror, "dm");
 static int
 dm_target_mirror_modcmd(modcmd_t cmd, void *arg)
+{
 	dm_target_t *dmt;
 	int r;
 	dmt = NULL;
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 		if ((dmt = dm_target_lookup("mirror")) != NULL) {
 			dm_target_unbusy(dmt);
 			return EEXIST;
+		}
 		dmt = dm_target_alloc("mirror");
 		dmt->version[0] = 1;
 		dmt->version[1] = 0;
 		dmt->version[2] = 0;
 		dmt->init = &dm_target_mirror_init;
 		dmt->status = &dm_target_mirror_status;
 		dmt->strategy = &dm_target_mirror_strategy;
 		dmt->sync = &dm_target_mirror_sync;
 		dmt->deps = &dm_target_mirror_deps;
 		dmt->destroy = &dm_target_mirror_destroy;
 		dmt->upcall = &dm_target_mirror_upcall;
 		r = dm_target_insert(dmt);
 		break;
 	case MODULE_CMD_FINI:
 		r = dm_target_rem("mirror");
 		break;
 	case MODULE_CMD_STAT:
 		return ENOTTY;
 	default:
 		return ENOTTY;
+	}
 	return r;
+}
 #endif
 /*
  * Init function called from dm_table_load_ioctl.
  * start length mirror log_type #logargs logarg1 ... logargN #devs device1 offset1 ... deviceN offsetN
  * 0 52428800 mirror clustered_disk 4 253:2 1024 UUID block_on_error 3 253:3 0 253:4 0 253:5 0
  */
 int
 dm_target_mirror_init(dm_table_entry_t *table_en, char *params)
+{
 	printf("Mirror target init function called!!\n");
 	table_en->target_config = NULL;
 	return ENOSYS;
+}
 /* Status routine called to get params string. */
 char *
 dm_target_mirror_status(void *target_config)
+{
 	return NULL;
+}
 /* Strategy routine called from dm_strategy. */
 int
 dm_target_mirror_strategy(dm_table_entry_t *table_en, struct buf *bp)
+{
 	printf("Mirror target read function called!!\n");
 	bp->b_error = EIO;
 	bp->b_resid = 0;
 	biodone(bp);
 	return 0;
+}
 /* Sync underlying disk caches. */
 int
 dm_target_mirror_sync(dm_table_entry_t *table_en)
+{
 	return 0;
+}
 /* Doesn't do anything here. */
 int
 dm_target_mirror_destroy(dm_table_entry_t *table_en)
+{
 	/* Unbusy target so we can unload it */
 	dm_target_unbusy(table_en->target);
 	return 0;
+}
 /* Doesn't not need to do anything here. */
 int
 dm_target_mirror_deps(dm_table_entry_t *table_en, prop_array_t prop_array)
+{
 	return 0;
+}
 /* Unsupported for this target. */
 int
 dm_target_mirror_upcall(dm_table_entry_t *table_en, struct buf *bp)
+{
 	return 0;
+}

 @@ -1,535 +1,549 @@
-/*        $NetBSD: dm_target_snapshot.c,v 1.27 2019/12/08 10:35:53 tkusumi Exp $      */
+/*        $NetBSD: dm_target_snapshot.c,v 1.28 2019/12/08 10:50:21 tkusumi 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: dm_target_snapshot.c,v 1.27 2019/12/08 10:35:53 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_target_snapshot.c,v 1.28 2019/12/08 10:50:21 tkusumi Exp $");
 /*
  * 1. Suspend my_data to temporarily stop any I/O while the snapshot is being
  * activated.
  * dmsetup suspend my_data
+ *
  * 2. Create the snapshot-origin device with no table.
  * dmsetup create my_data_org
+ *
  * 3. Read the table from my_data and load it into my_data_org.
  * dmsetup table my_data | dmsetup load my_data_org
+ *
  * 4. Resume this new table.
  * dmsetup resume my_data_org
+ *
  * 5. Create the snapshot device with no table.
  * dmsetup create my_data_snap
+ *
  * 6. Load the table into my_data_snap. This uses /dev/hdd1 as the COW device and
  * uses a 32kB chunk-size.
  * echo "0 `blockdev --getsize /dev/mapper/my_data` snapshot \
  *  /dev/mapper/my_data_org /dev/hdd1 p 64" | dmsetup load my_data_snap
+ *
  * 7. Reload my_data as a snapshot-origin device that points to my_data_org.
  * echo "0 `blockdev --getsize /dev/mapper/my_data` snapshot-origin \
  *  /dev/mapper/my_data_org" | dmsetup load my_data
+ *
  * 8. Resume the snapshot and origin devices.
  * dmsetup resume my_data_snap
  * dmsetup resume my_data
+ *
  * Before snapshot creation
  *  dev_name; dev table
  * | my_data; 0 1024 linear /dev/sd1a 384|
+ *
  * After snapshot creation
  *                               |my_data_org;0 1024 linear /dev/sd1a 384|
  *                              /
  * |my_data; 0 1024 snapshot-origin /dev/vg00/my_data_org|
  *                           /
  * |my_data_snap; 0 1024 snapshot /dev/vg00/my_data /dev/mapper/my_data_cow P 8
  *                           \
  *                            |my_data_cow; 0 256 linear /dev/sd1a 1408|
  */
 /*
  * This file implements initial version of device-mapper snapshot target.
  */
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/kmem.h>
 #include "dm.h"
 /* dm_target_snapshot.c */
 int dm_target_snapshot_init(dm_table_entry_t *, char *);
 char *dm_target_snapshot_status(void *);
 int dm_target_snapshot_strategy(dm_table_entry_t *, struct buf *);
 int dm_target_snapshot_deps(dm_table_entry_t *, prop_array_t);
 int dm_target_snapshot_destroy(dm_table_entry_t *);
 int dm_target_snapshot_upcall(dm_table_entry_t *, struct buf *);
 /* dm snapshot origin driver */
 int dm_target_snapshot_orig_init(dm_table_entry_t *, char *);
 char *dm_target_snapshot_orig_status(void *);
 int dm_target_snapshot_orig_strategy(dm_table_entry_t *, struct buf *);
 int dm_target_snapshot_orig_sync(dm_table_entry_t *);
 int dm_target_snapshot_orig_deps(dm_table_entry_t *, prop_array_t);
 int dm_target_snapshot_orig_destroy(dm_table_entry_t *);
 int dm_target_snapshot_orig_upcall(dm_table_entry_t *, struct buf *);
 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;
 typedef struct target_snapshot_origin_config {
 	dm_pdev_t *tsoc_real_dev;
 	/* list of snapshots ? */
 } dm_target_snapshot_origin_config_t;
 #ifdef DM_TARGET_MODULE
 /*
  * Every target can be compiled directly to dm driver or as a
  * separate module this part of target is used for loading targets
  * to dm driver.
  * Target can be unloaded from kernel only if there are no users of
  * it e.g. there are no devices which uses that target.
  */
 #include <sys/kernel.h>
 #include <sys/module.h>
 MODULE(MODULE_CLASS_MISC, dm_target_snapshot, "dm");
 static int
 dm_target_snapshot_modcmd(modcmd_t cmd, void *arg)
+{
 	dm_target_t *dmt, *dmt1;
 	int r;
 	dmt = NULL;
 	dmt1 = NULL;
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 		if (((dmt = dm_target_lookup("snapshot")) != NULL)) {
 			dm_target_unbusy(dmt);
 			return EEXIST;
+		}
 		if (((dmt = dm_target_lookup("snapshot-origin")) != NULL)) {
 			dm_target_unbusy(dmt);
 			return EEXIST;
+		}
 		dmt = dm_target_alloc("snapshot");
 		dmt1 = dm_target_alloc("snapshot-origin");
 		dmt->version[0] = 1;
 		dmt->version[1] = 0;
 		dmt->version[2] = 5;
 		dmt->init = &dm_target_snapshot_init;
 		dmt->status = &dm_target_snapshot_status;
 		dmt->strategy = &dm_target_snapshot_strategy;
 		dmt->deps = &dm_target_snapshot_deps;
 		dmt->destroy = &dm_target_snapshot_destroy;
 		dmt->upcall = &dm_target_snapshot_upcall;
 		r = dm_target_insert(dmt);
 		dmt1->version[0] = 1;
 		dmt1->version[1] = 0;
 		dmt1->version[2] = 5;
 		dmt1->init = &dm_target_snapshot_orig_init;
 		dmt1->status = &dm_target_snapshot_orig_status;
 		dmt1->strategy = &dm_target_snapshot_orig_strategy;
 		dmt1->sync = &dm_target_snapshot_orig_sync;
 		dmt1->deps = &dm_target_snapshot_orig_deps;
 		dmt1->destroy = &dm_target_snapshot_orig_destroy;
 		dmt1->upcall = &dm_target_snapshot_orig_upcall;
 		r = dm_target_insert(dmt1);
 		break;
 	case MODULE_CMD_FINI:
 		/*
 		 * Try to remove snapshot target if it works remove snap-origin
 		 * it is not possible to remove snapshot and do not remove
 		 * snap-origin because they are used together.
 		 */
 		if ((r = dm_target_rem("snapshot")) == 0)
 			r = dm_target_rem("snapshot-origin");
 		break;
 	case MODULE_CMD_STAT:
 		return ENOTTY;
 	default:
 		return ENOTTY;
+	}
 	return r;
+}
 #endif
 /*
  * Init function called from dm_table_load_ioctl.
  * argv:  /dev/mapper/my_data_org /dev/mapper/tsc_cow_dev p 64
  *        snapshot_origin device, cow device, persistent flag, chunk size
  */
 int
 dm_target_snapshot_init(dm_table_entry_t *table_en, char *params)
+{
 	dm_target_snapshot_config_t *tsc;
 	dm_pdev_t *dmp_snap, *dmp_cow;
 	char **ap, *argv[5];
 	dmp_cow = NULL;
 	if (params == NULL)
 		return EINVAL;
 	/*
 	 * Parse a string, containing tokens delimited by white space,
 	 * into an argument vector
 	 */
 	for (ap = argv; ap < &argv[4] &&
 	    (*ap = strsep(&params, " \t")) != NULL;) {
 		if (**ap != '\0')
 			ap++;
+	}
 	printf("Snapshot target init function called!!\n");
 	printf("Snapshotted device: %s, cow device %s,\n\t persistent flag: %s, "
 	    "chunk size: %s\n", argv[0], argv[1], argv[2], argv[3]);
 	/* Insert snap device to global pdev list */
 	if ((dmp_snap = dm_pdev_insert(argv[0])) == NULL)
 		return ENOENT;
 	tsc = kmem_alloc(sizeof(*tsc), KM_SLEEP);
 	tsc->tsc_persistent_dev = 0;
 	/* There is now cow device for nonpersistent snapshot devices */
 	if (strcmp(argv[2], "p") == 0) {
 		tsc->tsc_persistent_dev = 1;
 		/* Insert cow device to global pdev list */
 		if ((dmp_cow = dm_pdev_insert(argv[1])) == NULL) {
 			kmem_free(tsc, sizeof(*tsc));
 			return ENOENT;
+		}
+	}
 	tsc->tsc_chunk_size = atoi(argv[3]);
 	tsc->tsc_snap_dev = dmp_snap;
 	tsc->tsc_cow_dev = dmp_cow;
 	table_en->target_config = tsc;
 	return 0;
+}
 /*
  * 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 *
 dm_target_snapshot_status(void *target_config)
+{
 	dm_target_snapshot_config_t *tsc;
 	uint32_t i;
 	uint32_t count;
 	size_t prm_len, cow_len;
 	char *params;
 	tsc = target_config;
 	prm_len = 0;
 	cow_len = 0;
 	count = 0;
 	printf("Snapshot target status function called\n");
 	/* count number of chars in offset */
 	for (i = tsc->tsc_chunk_size; i != 0; i /= 10)
 		count++;
 	if (tsc->tsc_persistent_dev)
 		cow_len = strlen(tsc->tsc_cow_dev->name);
 	/* length of names + count of chars + spaces and null char */
 	prm_len = strlen(tsc->tsc_snap_dev->name) + cow_len + count + 5;
 	params = kmem_alloc(prm_len, KM_SLEEP);
 	printf("%s %s %s %" PRIu64 "\n", tsc->tsc_snap_dev->name,
 	    tsc->tsc_cow_dev->name, tsc->tsc_persistent_dev ? "p" : "n",
 	    tsc->tsc_chunk_size);
 	snprintf(params, prm_len, "%s %s %s %" PRIu64, tsc->tsc_snap_dev->name,
 	    tsc->tsc_persistent_dev ? tsc->tsc_cow_dev->name : "",
 	    tsc->tsc_persistent_dev ? "p" : "n",
 	    tsc->tsc_chunk_size);
 	return params;
+}
 /* Strategy routine called from dm_strategy. */
 int
 dm_target_snapshot_strategy(dm_table_entry_t *table_en, struct buf *bp)
+{
 	printf("Snapshot target read function called!!\n");
 	bp->b_error = EIO;
 	bp->b_resid = 0;
 	biodone(bp);
 	return 0;
+}
 /* Doesn't do anything here. */
 int
 dm_target_snapshot_destroy(dm_table_entry_t *table_en)
+{
 	/*
 	 * Destroy function is called for every target even if it
 	 * doesn't have target_config.
 	 */
 	if (table_en->target_config == NULL)
 		goto out;
 	printf("Snapshot target destroy function called\n");
 	dm_target_snapshot_config_t *tsc = table_en->target_config;
 	/* Decrement pdev ref counter if 0 remove it */
 	dm_pdev_decr(tsc->tsc_snap_dev);
 	if (tsc->tsc_persistent_dev)
 		dm_pdev_decr(tsc->tsc_cow_dev);
 	kmem_free(tsc, sizeof(*tsc));
 out:
 	/* Unbusy target so we can unload it */
 	dm_target_unbusy(table_en->target);
 	return 0;
+}
 /* Add this target dependencies to prop_array_t */
 int
 dm_target_snapshot_deps(dm_table_entry_t *table_en, prop_array_t prop_array)
+{
 	dm_target_snapshot_config_t *tsc;
 	if (table_en->target_config == NULL)
 		return 0;
 	tsc = table_en->target_config;
 	prop_array_add_uint64(prop_array,
 	    (uint64_t) tsc->tsc_snap_dev->pdev_vnode->v_rdev);
 	if (tsc->tsc_persistent_dev) {
 		prop_array_add_uint64(prop_array,
 		    (uint64_t) tsc->tsc_cow_dev->pdev_vnode->v_rdev);
+	}
 	return 0;
+}
 /* Upcall is used to inform other depended devices about IO. */
 int
 dm_target_snapshot_upcall(dm_table_entry_t *table_en, struct buf *bp)
+{
 	printf("dm_target_snapshot_upcall called\n");
 	printf("upcall buf flags %s %s\n",
 	    (bp->b_flags & B_WRITE) ? "B_WRITE" : "",
 	    (bp->b_flags & B_READ) ? "B_READ" : "");
 	return 0;
+}
 /*
  * dm target snapshot origin routines.
+ *
  * Keep for compatibility with linux lvm2tools. They use two targets
  * to implement snapshots. Snapshot target will implement exception
  * store and snapshot origin will implement device which calls every
  * snapshot device when write is done on master device.
  */
 /*
  * Init function called from dm_table_load_ioctl.
+ *
  * argv: /dev/mapper/my_data_real
  */
 int
 dm_target_snapshot_orig_init(dm_table_entry_t *table_en, char *params)
+{
 	dm_target_snapshot_origin_config_t *tsoc;
 	dm_pdev_t *dmp_real;
 	if (params == NULL)
 		return EINVAL;
 	printf("Snapshot origin target init function called!!\n");
 	printf("Parent device: %s\n", params);
 	/* Insert snap device to global pdev list */
 	if ((dmp_real = dm_pdev_insert(params)) == NULL)
 		return ENOENT;
 	tsoc = kmem_alloc(sizeof(dm_target_snapshot_origin_config_t), KM_SLEEP);
 	tsoc->tsoc_real_dev = dmp_real;
 	table_en->target_config = tsoc;
 	return 0;
+}
 /*
  * 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 *
 dm_target_snapshot_orig_status(void *target_config)
+{
 	dm_target_snapshot_origin_config_t *tsoc;
 	size_t prm_len;
 	char *params;
 	tsoc = target_config;
 	prm_len = 0;
 	printf("Snapshot origin target status function called\n");
 	/* length of names + count of chars + spaces and null char */
 	prm_len = strlen(tsoc->tsoc_real_dev->name) + 1;
 	printf("real_dev name %s\n", tsoc->tsoc_real_dev->name);
 	params = kmem_alloc(prm_len, KM_SLEEP);
 	printf("%s\n", tsoc->tsoc_real_dev->name);
 	snprintf(params, prm_len, "%s", tsoc->tsoc_real_dev->name);
 	return params;
+}
 /* Strategy routine called from dm_strategy. */
 int
 dm_target_snapshot_orig_strategy(dm_table_entry_t *table_en, struct buf *bp)
+{
 	printf("Snapshot_Orig target read function called!!\n");
 	bp->b_error = EIO;
 	bp->b_resid = 0;
 	biodone(bp);
 	return 0;
+}
 /*
  * Sync underlying disk caches.
  */
 int
 dm_target_snapshot_orig_sync(dm_table_entry_t *table_en)
+{
 	int cmd;
 	dm_target_snapshot_origin_config_t *tsoc;
 	tsoc = table_en->target_config;
 	cmd = 1;
 	return VOP_IOCTL(tsoc->tsoc_real_dev->pdev_vnode,  DIOCCACHESYNC,
 	    &cmd, FREAD|FWRITE, kauth_cred_get());
+}
 /* Decrement pdev and free allocated space. */
 int
 dm_target_snapshot_orig_destroy(dm_table_entry_t *table_en)
+{
 	/*
 	 * Destroy function is called for every target even if it
 	 * doesn't have target_config.
 	 */
 	if (table_en->target_config == NULL)
 		goto out;
 	dm_target_snapshot_origin_config_t *tsoc = table_en->target_config;
 	/* Decrement pdev ref counter if 0 remove it */
 	dm_pdev_decr(tsoc->tsoc_real_dev);
 	kmem_free(tsoc, sizeof(*tsoc));
 out:
 	/* Unbusy target so we can unload it */
 	dm_target_unbusy(table_en->target);
 	return 0;
+}
 /*
  * Get target deps and add them to prop_array_t.
  */
 int
 dm_target_snapshot_orig_deps(dm_table_entry_t *table_en,
     prop_array_t prop_array)
+{
 	dm_target_snapshot_origin_config_t *tsoc;
 	struct vattr va;
 	int error;
 	if (table_en->target_config == NULL)
 		return 0;
 	tsoc = table_en->target_config;
 	vn_lock(tsoc->tsoc_real_dev->pdev_vnode, LK_SHARED | LK_RETRY);
 	error = VOP_GETATTR(tsoc->tsoc_real_dev->pdev_vnode, &va,
 	    curlwp->l_cred);
 	VOP_UNLOCK(tsoc->tsoc_real_dev->pdev_vnode);
 	if (error != 0)
 		return error;
 	prop_array_add_uint64(prop_array, (uint64_t) va.va_rdev);
 	return 0;
+}
 /* Unsupported for this target. */
 int
 dm_target_snapshot_orig_upcall(dm_table_entry_t *table_en, struct buf *bp)
+{
 	return 0;
+}

 @@ -1,372 +1,380 @@
-/*$NetBSD: dm_target_stripe.c,v 1.31 2019/12/08 04:41:02 tkusumi Exp $*/
+/*$NetBSD: dm_target_stripe.c,v 1.32 2019/12/08 10:50:21 tkusumi Exp $*/
 /*
  * Copyright (c) 2009 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/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: dm_target_stripe.c,v 1.31 2019/12/08 04:41:02 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_target_stripe.c,v 1.32 2019/12/08 10:50:21 tkusumi Exp $");
 /*
  * This file implements initial version of device-mapper stripe target.
  */
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/kmem.h>
 #include <sys/lwp.h>
 #include "dm.h"
 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;
 #ifdef DM_TARGET_MODULE
 /*
  * Every target can be compiled directly to dm driver or as a
  * separate module this part of target is used for loading targets
  * to dm driver.
  * Target can be unloaded from kernel only if there are no users of
  * it e.g. there are no devices which uses that target.
  */
 #include <sys/kernel.h>
 #include <sys/module.h>
 MODULE(MODULE_CLASS_MISC, dm_target_stripe, NULL);
 static int
 dm_target_stripe_modcmd(modcmd_t cmd, void *arg)
+{
 	dm_target_t *dmt;
 	int r;
 	dmt = NULL;
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 		if ((dmt = dm_target_lookup("stripe")) != NULL) {
 			dm_target_unbusy(dmt);
 			return EEXIST;
+		}
 		dmt = dm_target_alloc("stripe");
 		dmt->version[0] = 1;
 		dmt->version[1] = 0;
 		dmt->version[2] = 0;
 		dmt->init = &dm_target_stripe_init;
 		dmt->status = &dm_target_stripe_status;
 		dmt->strategy = &dm_target_stripe_strategy;
 		dmt->sync = &dm_target_stripe_sync;
 		dmt->deps = &dm_target_stripe_deps;
 		dmt->destroy = &dm_target_stripe_destroy;
 		dmt->upcall = &dm_target_stripe_upcall;
 		dmt->secsize = &dm_target_stripe_secsize;
 		r = dm_target_insert(dmt);
 		break;
 	case MODULE_CMD_FINI:
 		r = dm_target_rem("stripe");
 		break;
 	case MODULE_CMD_STAT:
 		return ENOTTY;
 	default:
 		return ENOTTY;
+	}
 	return r;
+}
 #endif
 static void
 dm_target_stripe_fini(dm_target_stripe_config_t *tsc)
+{
 	dm_target_linear_config_t *tlc;
 	if (tsc == NULL)
 		return;
 	while ((tlc = TAILQ_FIRST(&tsc->stripe_devs)) != NULL) {
 		TAILQ_REMOVE(&tsc->stripe_devs, tlc, entries);
 		dm_pdev_decr(tlc->pdev);
 		kmem_free(tlc, sizeof(*tlc));
+	}
 	kmem_free(tsc, sizeof(*tsc));
+}
 /*
  * Init function called from dm_table_load_ioctl.
  * DM_STRIPE_DEV_OFFSET should always hold the index of the first device-offset
  * pair in the parameters.
  * Example line sent to dm from lvm tools when using striped target.
  * start length striped #stripes chunk_size device1 offset1 ... deviceN offsetN
  * 0 65536 striped 2 512 /dev/hda 0 /dev/hdb 0
  */
 int
 dm_target_stripe_init(dm_table_entry_t *table_en, char *params)
+{
 	dm_target_linear_config_t *tlc;
 	dm_target_stripe_config_t *tsc;
 	size_t len;
 	char **ap, *argv[10];
 	int strpc, strpi;
 	if (params == NULL)
 		return EINVAL;
 	len = strlen(params) + 1;
 	/*
 	 * Parse a string, containing tokens delimited by white space,
 	 * into an argument vector
 	 */
 	for (ap = argv; ap <= &argv[9] &&
 	    (*ap = strsep(&params, " \t")) != NULL;) {
 		if (**ap != '\0')
 			ap++;
+	}
 	printf("Stripe target init function called!!\n");
 	printf("Stripe target chunk size %s number of stripes %s\n",
 	    argv[1], argv[0]);
 	tsc = kmem_alloc(sizeof(*tsc), KM_SLEEP);
 	/* Initialize linked list for striping devices */
 	TAILQ_INIT(&tsc->stripe_devs);
 	/* Save length of param string */
 	tsc->params_len = len;
 	tsc->stripe_chunksize = atoi(argv[1]);
 	tsc->stripe_num = (uint8_t) atoi(argv[0]);
 	strpc = DM_STRIPE_DEV_OFFSET + (tsc->stripe_num * 2);
 	for (strpi = DM_STRIPE_DEV_OFFSET; strpi < strpc; strpi += 2) {
 		printf("Stripe target device name %s -- offset %s\n",
 		       argv[strpi], argv[strpi+1]);
 		tlc = kmem_alloc(sizeof(*tlc), KM_SLEEP);
 		if ((tlc->pdev = dm_pdev_insert(argv[strpi])) == NULL) {
 			kmem_free(tlc, sizeof(*tlc));
 			dm_target_stripe_fini(tsc);
 			return ENOENT;
+		}
 		tlc->offset = atoi(argv[strpi+1]);
 		/* Insert striping device to linked list. */
 		TAILQ_INSERT_TAIL(&tsc->stripe_devs, tlc, entries);
+	}
 	table_en->target_config = tsc;
 	return 0;
+}
 /* Status routine called to get params string. */
 char *
 dm_target_stripe_status(void *target_config)
+{
 	dm_target_linear_config_t *tlc;
 	dm_target_stripe_config_t *tsc;
 	char *params, *tmp;
 	tsc = target_config;
 	params = kmem_alloc(DM_MAX_PARAMS_SIZE, KM_SLEEP);
 	tmp = kmem_alloc(DM_MAX_PARAMS_SIZE, KM_SLEEP);
 	snprintf(params, DM_MAX_PARAMS_SIZE, "%d %" PRIu64,
 	    tsc->stripe_num, tsc->stripe_chunksize);
 	TAILQ_FOREACH(tlc, &tsc->stripe_devs, entries) {
 		snprintf(tmp, DM_MAX_PARAMS_SIZE, " %s %" PRIu64,
 		    tlc->pdev->name, tlc->offset);
 		strcat(params, tmp);
+	}
 	kmem_free(tmp, DM_MAX_PARAMS_SIZE);
 	return params;
+}
 /* Strategy routine called from dm_strategy. */
 int
 dm_target_stripe_strategy(dm_table_entry_t *table_en, struct buf *bp)
+{
 	dm_target_linear_config_t *tlc;
 	dm_target_stripe_config_t *tsc;
 	struct buf *nestbuf;
 	uint64_t blkno, blkoff;
 	uint64_t stripe, stripe_blknr;
 	uint32_t stripe_off, stripe_rest, num_blks, issue_blks;
 	int i, stripe_devnr;
 	tsc = table_en->target_config;
 	if (tsc == NULL)
 		return 0;
 /*	printf("Stripe target read function called %" PRIu64 "!!\n",
 	tlc->offset);*/
 	/* calculate extent of request */
 	KASSERT(bp->b_resid % DEV_BSIZE == 0);
 	blkno = bp->b_blkno;
 	blkoff = 0;
 	num_blks = bp->b_resid / DEV_BSIZE;
 	for (;;) {
 		/* blockno to stripe piece nr */
 		stripe = blkno / tsc->stripe_chunksize;
 		stripe_off = blkno % tsc->stripe_chunksize;
 		/* where we are inside the stripe */
 		stripe_devnr = stripe % tsc->stripe_num;
 		stripe_blknr = stripe / tsc->stripe_num;
 		/* how much is left before we hit a boundary */
 		stripe_rest = tsc->stripe_chunksize - stripe_off;
 		/* issue this piece on stripe `stripe' */
 		issue_blks = MIN(stripe_rest, num_blks);
 		nestbuf = getiobuf(NULL, true);
 		nestiobuf_setup(bp, nestbuf, blkoff, issue_blks * DEV_BSIZE);
 		nestbuf->b_blkno = stripe_blknr * tsc->stripe_chunksize + stripe_off;
 		tlc = TAILQ_FIRST(&tsc->stripe_devs);
 		for (i = 0; i < stripe_devnr && tlc != NULL; i++)
 			tlc = TAILQ_NEXT(tlc, entries);
 		/* by this point we should have an tlc */
 		KASSERT(tlc != NULL);
 		nestbuf->b_blkno += tlc->offset;
 		VOP_STRATEGY(tlc->pdev->pdev_vnode, nestbuf);
 		blkno += issue_blks;
 		blkoff += issue_blks * DEV_BSIZE;
 		num_blks -= issue_blks;
 		if (num_blks <= 0)
 			break;
+	}
 	return 0;
+}
 /* Sync underlying disk caches. */
 int
 dm_target_stripe_sync(dm_table_entry_t *table_en)
+{
 	int cmd, err;
 	dm_target_stripe_config_t *tsc;
 	dm_target_linear_config_t *tlc;
 	tsc = table_en->target_config;
 	err = 0;
 	cmd = 1;
 	TAILQ_FOREACH(tlc, &tsc->stripe_devs, entries) {
 		if ((err = VOP_IOCTL(tlc->pdev->pdev_vnode, DIOCCACHESYNC,
 			    &cmd, FREAD|FWRITE, kauth_cred_get())) != 0)
 			return err;
+	}
 	return err;
+}
 /* Destroy target specific data. */
 int
 dm_target_stripe_destroy(dm_table_entry_t *table_en)
+{
 	dm_target_stripe_fini(table_en->target_config);
 	/* Unbusy target so we can unload it */
 	dm_target_unbusy(table_en->target);
 	return 0;
+}
 /* Doesn't not need to do anything here. */
 int
 dm_target_stripe_deps(dm_table_entry_t *table_en, prop_array_t prop_array)
+{
 	dm_target_stripe_config_t *tsc;
 	dm_target_linear_config_t *tlc;
 	if (table_en->target_config == NULL)
 		return ENOENT;
 	tsc = table_en->target_config;
 	TAILQ_FOREACH(tlc, &tsc->stripe_devs, entries) {
 		prop_array_add_uint64(prop_array,
 		    (uint64_t) tlc->pdev->pdev_vnode->v_rdev);
+	}
 	return 0;
+}
 /* Unsupported for this target. */
 int
 dm_target_stripe_upcall(dm_table_entry_t *table_en, struct buf *bp)
+{
 	return 0;
+}
 /*
  * Compute physical block size
  * For a stripe target we chose the maximum sector size of all
  * stripe devices. For the supported power-of-2 sizes this is equivalent
  * to the least common multiple.
  */
 int
 dm_target_stripe_secsize(dm_table_entry_t *table_en, unsigned *secsizep)
+{
 	dm_target_linear_config_t *tlc;
 	dm_target_stripe_config_t *tsc;
 	unsigned secsize;
 	secsize = 0;
 	tsc = table_en->target_config;
 	if (tsc != NULL) {
 		TAILQ_FOREACH(tlc, &tsc->stripe_devs, entries) {
 			if (secsize < tlc->pdev->pdev_secsize)
 				secsize = tlc->pdev->pdev_secsize;
+		}
+	}
 	*secsizep = secsize;
 	return 0;
+}