 @@ -1,14 +1,14 @@
-/*        $NetBSD: dm.h,v 1.33 2019/12/05 15:52:39 tkusumi Exp $      */
+/*        $NetBSD: dm.h,v 1.34 2019/12/07 15:28:39 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.
 @@ -266,56 +266,56 @@ 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 *);
+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 *);
+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);
+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);

 @@ -1,14 +1,14 @@
-/*        $NetBSD: dm_dev.c,v 1.13 2019/12/04 15:31:12 tkusumi Exp $      */
+/*        $NetBSD: dm_dev.c,v 1.14 2019/12/07 15:28:39 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.
 @@ -19,52 +19,52 @@
  * 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_dev.c,v 1.13 2019/12/04 15:31:12 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_dev.c,v 1.14 2019/12/07 15:28:39 tkusumi Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/disk.h>
 #include <sys/disklabel.h>
 #include <sys/ioctl.h>
 #include <sys/ioccom.h>
 #include <sys/kmem.h>
 #include "netbsd-dm.h"
 #include "dm.h"
 static dm_dev_t *dm_dev_lookup_name(const char *);
 static dm_dev_t *dm_dev_lookup_uuid(const char *);
 static dm_dev_t *dm_dev_lookup_minor(int);
 static struct dm_dev_head dm_dev_list =
 TAILQ_HEAD_INITIALIZER(dm_dev_list);
 static kmutex_t dm_dev_mutex;
 /* dm_dev_mutex must be holdby caller before using disable_dev. */
 __inline static void
-disable_dev(dm_dev_t * dmv)
+disable_dev(dm_dev_t *dmv)
+{
 	TAILQ_REMOVE(&dm_dev_list, dmv, next_devlist);
 	mutex_enter(&dmv->dev_mtx);
 	mutex_exit(&dm_dev_mutex);
 	while (dmv->ref_cnt != 0)
 		cv_wait(&dmv->dev_cv, &dmv->dev_mtx);
 	mutex_exit(&dmv->dev_mtx);
+}
 /*
  * Generic function used to lookup dm_dev_t. Calling with dm_dev_name
  * and dm_dev_uuid NULL is allowed.
  */
 @@ -165,27 +165,27 @@ dm_dev_lookup_uuid(const char *dm_dev_uu
 			continue;
 		if (strncmp(dm_dev_uuid, dmv->uuid, strlen(dmv->uuid)) == 0)
 			return dmv;
+	}
 	return NULL;
+}
 /*
  * Insert new device to the global list of devices.
  */
 int
-dm_dev_insert(dm_dev_t * dev)
+dm_dev_insert(dm_dev_t *dev)
+{
 	dm_dev_t *dmv;
 	int r;
 	dmv = NULL;
 	r = 0;
 	KASSERT(dev != NULL);
 	mutex_enter(&dm_dev_mutex);
 	if (((dmv = dm_dev_lookup_uuid(dev->uuid)) == NULL) &&
 	    ((dmv = dm_dev_lookup_name(dev->name)) == NULL) &&
 	    ((dmv = dm_dev_lookup_minor(dev->minor)) == NULL)) {
 		TAILQ_INSERT_TAIL(&dm_dev_list, dev, next_devlist);
 @@ -321,52 +321,52 @@ dm_dev_t *
 dm_dev_alloc(void)
+{
 	dm_dev_t *dmv;
 	dmv = kmem_zalloc(sizeof(dm_dev_t), KM_SLEEP);
 	dmv->diskp = kmem_zalloc(sizeof(struct disk), KM_SLEEP);
 	return dmv;
+}
 /*
  * Freed device entry.
  */
 int
-dm_dev_free(dm_dev_t * dmv)
+dm_dev_free(dm_dev_t *dmv)
+{
 	KASSERT(dmv != NULL);
 	mutex_destroy(&dmv->dev_mtx);
 	mutex_destroy(&dmv->diskp_mtx);
 	cv_destroy(&dmv->dev_cv);
 	if (dmv->diskp != NULL)
 		(void)kmem_free(dmv->diskp, sizeof(struct disk));
 	(void)kmem_free(dmv, sizeof(dm_dev_t));
 	return 0;
+}
 void
-dm_dev_busy(dm_dev_t * dmv)
+dm_dev_busy(dm_dev_t *dmv)
+{
 	mutex_enter(&dmv->dev_mtx);
 	dmv->ref_cnt++;
 	mutex_exit(&dmv->dev_mtx);
+}
 void
-dm_dev_unbusy(dm_dev_t * dmv)
+dm_dev_unbusy(dm_dev_t *dmv)
+{
 	KASSERT(dmv->ref_cnt != 0);
 	mutex_enter(&dmv->dev_mtx);
 	if (--dmv->ref_cnt == 0)
 		cv_broadcast(&dmv->dev_cv);
 	mutex_exit(&dmv->dev_mtx);
+}
 /*
  * Return prop_array of dm_targer_list dictionaries.
  */
 prop_array_t

 @@ -1,14 +1,14 @@
-/*$NetBSD: dm_target_mirror.c,v 1.13 2019/12/06 16:11:59 tkusumi Exp $*/
+/*$NetBSD: dm_target_mirror.c,v 1.14 2019/12/07 15:28:39 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.
 @@ -19,41 +19,41 @@
  * 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.13 2019/12/06 16:11:59 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_target_mirror.c,v 1.14 2019/12/07 15:28:39 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_dev_t *, void**, char *);
-char * dm_target_mirror_status(void *);
+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 *);
 #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.
 @@ -104,76 +104,76 @@ dm_target_mirror_modcmd(modcmd_t cmd, vo
 		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_dev_t * dmv, void **target_config, char *argv)
+dm_target_mirror_init(dm_dev_t *dmv, void **target_config, char *argv)
+{
 	printf("Mirror target init function called!!\n");
 	*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)
+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)
+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)
+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)
+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)
+dm_target_mirror_upcall(dm_table_entry_t *table_en, struct buf *bp)
+{
 	return 0;
+}

 @@ -1,14 +1,14 @@
-/*        $NetBSD: dm_pdev.c,v 1.17 2019/12/07 06:26:31 tkusumi Exp $      */
+/*        $NetBSD: dm_pdev.c,v 1.18 2019/12/07 15:28:39 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.
 @@ -19,27 +19,27 @@
  * 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_pdev.c,v 1.17 2019/12/07 06:26:31 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_pdev.c,v 1.18 2019/12/07 15:28:39 tkusumi Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/disk.h>
 #include <sys/fcntl.h>
 #include <sys/kmem.h>
 #include <sys/namei.h>
 #include <dev/dkvar.h>
 #include "dm.h"
 @@ -157,27 +157,27 @@ dm_pdev_alloc(const char *name)
 	dmp = kmem_zalloc(sizeof(*dmp), KM_SLEEP);
 	strlcpy(dmp->name, name, sizeof(dmp->name));
 	dmp->ref_cnt = 0;
 	dmp->pdev_vnode = NULL;
 	return dmp;
+}
 /*
  * Destroy allocated dm_pdev.
  */
 static int
-dm_pdev_rem(dm_pdev_t * dmp)
+dm_pdev_rem(dm_pdev_t *dmp)
+{
 	KASSERT(dmp != NULL);
 	if (dmp->pdev_vnode != NULL) {
 		int error = vn_close(dmp->pdev_vnode, FREAD | FWRITE, FSCRED);
 		if (error != 0)
 			return error;
+	}
 	kmem_free(dmp, sizeof(*dmp));
 	return 0;
+}
 @@ -206,27 +206,27 @@ dm_pdev_destroy(void)
 /*
  * This funcion is called from dm_dev_remove_ioctl.
  * When I'm removing device from list, I have to decrement
  * reference counter. If reference counter is 0 I will remove
  * dmp from global list and from device list to. And I will CLOSE
  * dmp vnode too.
  */
 /*
  * Decrement pdev reference counter if 0 remove it.
  */
 int
-dm_pdev_decr(dm_pdev_t * dmp)
+dm_pdev_decr(dm_pdev_t *dmp)
+{
 	KASSERT(dmp != NULL);
 	/*
 	 * If this was last reference remove dmp from
 	 * global list also.
 	 */
 	mutex_enter(&dm_pdev_mutex);
 	if (--dmp->ref_cnt == 0) {
 		SLIST_REMOVE(&dm_pdev_list, dmp, dm_pdev, next_pdev);
 		mutex_exit(&dm_pdev_mutex);
 		dm_pdev_rem(dmp);
 		return 0;

 @@ -1,14 +1,14 @@
-/*        $NetBSD: dm_target_zero.c,v 1.17 2019/12/06 16:46:14 tkusumi Exp $      */
+/*        $NetBSD: dm_target_zero.c,v 1.18 2019/12/07 15:28:39 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.
 @@ -19,41 +19,41 @@
  * 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_zero.c,v 1.17 2019/12/06 16:46:14 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_target_zero.c,v 1.18 2019/12/07 15:28:39 tkusumi Exp $");
 /*
  * This file implements initial version of device-mapper zero target.
  */
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/buf.h>
 #include "dm.h"
 /* dm_target_zero.c */
 int dm_target_zero_init(dm_dev_t *, void**,  char *);
-char * dm_target_zero_status(void *);
+char *dm_target_zero_status(void *);
 int dm_target_zero_strategy(dm_table_entry_t *, struct buf *);
 int dm_target_zero_sync(dm_table_entry_t *);
 int dm_target_zero_destroy(dm_table_entry_t *);
 int dm_target_zero_deps(dm_table_entry_t *, prop_array_t);
 int dm_target_zero_upcall(dm_table_entry_t *, struct buf *);
 #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.
 @@ -103,80 +103,80 @@ dm_target_zero_modcmd(modcmd_t cmd, void
 	default:
 		return ENOTTY;
+	}
 	return r;
+}
 #endif
 /*
  * Zero target init function. This target doesn't need
  * target specific config area.
  */
 int
-dm_target_zero_init(dm_dev_t * dmv, void **target_config, char *argv)
+dm_target_zero_init(dm_dev_t *dmv, void **target_config, char *argv)
+{
 	printf("Zero target init function called!!\n");
 	*target_config = NULL;
 	return 0;
+}
 /* Status routine called to get params string. */
 char *
 dm_target_zero_status(void *target_config)
+{
 	return NULL;
+}
 /*
  * This routine does IO operations.
  */
 int
-dm_target_zero_strategy(dm_table_entry_t * table_en, struct buf * bp)
+dm_target_zero_strategy(dm_table_entry_t *table_en, struct buf *bp)
+{
 	/* printf("Zero target read function called %d!!\n", bp->b_bcount); */
 	memset(bp->b_data, 0, bp->b_bcount);
 	bp->b_resid = 0;	/* nestiobuf_done wants b_resid = 0 to be sure
 				 * that there is no other io to done  */
 	biodone(bp);
 	return 0;
+}
 /* Sync underlying disk caches. */
 int
-dm_target_zero_sync(dm_table_entry_t * table_en)
+dm_target_zero_sync(dm_table_entry_t *table_en)
+{
 	return 0;
+}
 /* Does not need to do anything here. */
 int
-dm_target_zero_destroy(dm_table_entry_t * table_en)
+dm_target_zero_destroy(dm_table_entry_t *table_en)
+{
 	/* Unbusy target so we can unload it */
 	dm_target_unbusy(table_en->target);
 	return 0;
+}
 /* Does not need to do anything here. */
 int
-dm_target_zero_deps(dm_table_entry_t * table_en, prop_array_t prop_array)
+dm_target_zero_deps(dm_table_entry_t *table_en, prop_array_t prop_array)
+{
 	return 0;
+}
 /* Unsuported for this target. */
 int
-dm_target_zero_upcall(dm_table_entry_t * table_en, struct buf * bp)
+dm_target_zero_upcall(dm_table_entry_t *table_en, struct buf *bp)
+{
 	return 0;
+}

 @@ -1,14 +1,14 @@
-/*        $NetBSD: dm_table.c,v 1.11 2019/12/07 06:26:31 tkusumi Exp $      */
+/*        $NetBSD: dm_table.c,v 1.12 2019/12/07 15:28:39 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.
 @@ -19,27 +19,27 @@
  * 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_table.c,v 1.11 2019/12/07 06:26:31 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_table.c,v 1.12 2019/12/07 15:28:39 tkusumi Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/kmem.h>
 #include "dm.h"
 /*
  * There are two types of users of this interface:
+ *
  * a) Readers such as
  *    dmstrategy, dmgetdisklabel, dmsize, dm_dev_status_ioctl,
 @@ -53,104 +53,104 @@ __KERNEL_RCSID(0, "$NetBSD: dm_table.c,v
+ *
  */
 static int dm_table_busy(dm_table_head_t *, uint8_t);
 static void dm_table_unbusy(dm_table_head_t *);
 /*
  * Function to increment table user reference counter. Return id
  * of table_id table.
  * DM_TABLE_ACTIVE will return active table id.
  * DM_TABLE_INACTIVE will return inactive table id.
  */
 static int
-dm_table_busy(dm_table_head_t * head, uint8_t table_id)
+dm_table_busy(dm_table_head_t *head, uint8_t table_id)
+{
 	uint8_t id;
 	mutex_enter(&head->table_mtx);
 	if (table_id == DM_TABLE_ACTIVE)
 		id = head->cur_active_table;
 	else
 		id = 1 - head->cur_active_table;
 	head->io_cnt++;
 	mutex_exit(&head->table_mtx);
 	return id;
+}
 /*
  * Function release table lock and eventually wakeup all waiters.
  */
 static void
-dm_table_unbusy(dm_table_head_t * head)
+dm_table_unbusy(dm_table_head_t *head)
+{
 	KASSERT(head->io_cnt != 0);
 	mutex_enter(&head->table_mtx);
 	if (--head->io_cnt == 0)
 		cv_broadcast(&head->table_cv);
 	mutex_exit(&head->table_mtx);
+}
 /*
  * Return current active table to caller, increment io_cnt reference counter.
  */
 dm_table_t *
-dm_table_get_entry(dm_table_head_t * head, uint8_t table_id)
+dm_table_get_entry(dm_table_head_t *head, uint8_t table_id)
+{
 	uint8_t id;
 	id = dm_table_busy(head, table_id);
 	return &head->tables[id];
+}
 /*
  * Decrement io reference counter and wake up all callers, with table_head cv.
  */
 void
-dm_table_release(dm_table_head_t * head, uint8_t table_id)
+dm_table_release(dm_table_head_t *head, uint8_t table_id)
+{
 	dm_table_unbusy(head);
+}
 /*
  * Switch table from inactive to active mode. Have to wait until io_cnt is 0.
  */
 void
-dm_table_switch_tables(dm_table_head_t * head)
+dm_table_switch_tables(dm_table_head_t *head)
+{
 	mutex_enter(&head->table_mtx);
 	while (head->io_cnt != 0)
 		cv_wait(&head->table_cv, &head->table_mtx);
 	head->cur_active_table = 1 - head->cur_active_table;
 	mutex_exit(&head->table_mtx);
+}
 /*
  * Destroy all table data. This function can run when there are no
  * readers on table lists.
+ *
  * XXX Is it ok to call kmem_free and potentialy VOP_CLOSE with held mutex ?xs
  */
 int
-dm_table_destroy(dm_table_head_t * head, uint8_t table_id)
+dm_table_destroy(dm_table_head_t *head, uint8_t table_id)
+{
 	dm_table_t *tbl;
 	dm_table_entry_t *table_en;
 	uint8_t id;
 	mutex_enter(&head->table_mtx);
 	aprint_debug("dm_Table_destroy called with %d--%d\n", table_id, head->io_cnt);
 	while (head->io_cnt != 0)
 		cv_wait(&head->table_cv, &head->table_mtx);
 	if (table_id == DM_TABLE_ACTIVE)
 @@ -168,27 +168,27 @@ dm_table_destroy(dm_table_head_t * head,
 		kmem_free(table_en, sizeof(*table_en));
+	}
 	KASSERT(SLIST_EMPTY(tbl));
 	mutex_exit(&head->table_mtx);
 	return 0;
+}
 /*
  * Return length of active table in device.
  */
 static inline uint64_t
-dm_table_size_impl(dm_table_head_t * head, int table)
+dm_table_size_impl(dm_table_head_t *head, int table)
+{
 	dm_table_t *tbl;
 	dm_table_entry_t *table_en;
 	uint64_t length;
 	uint8_t id;
 	length = 0;
 	id = dm_table_busy(head, table);
 	/* Select active table */
 	tbl = &head->tables[id];
 @@ -198,45 +198,45 @@ dm_table_size_impl(dm_table_head_t * hea
 	 */
 	SLIST_FOREACH(table_en, tbl, next)
 		length += table_en->length;
 	dm_table_unbusy(head);
 	return length;
+}
 /*
  * Return length of active table in device.
  */
 uint64_t
-dm_table_size(dm_table_head_t * head)
+dm_table_size(dm_table_head_t *head)
+{
 	return dm_table_size_impl(head, DM_TABLE_ACTIVE);
+}
 /*
  * Return length of active table in device.
  */
 uint64_t
-dm_inactive_table_size(dm_table_head_t * head)
+dm_inactive_table_size(dm_table_head_t *head)
+{
 	return dm_table_size_impl(head, DM_TABLE_INACTIVE);
+}
 /*
  * Return combined disk geometry
  */
 void
-dm_table_disksize(dm_table_head_t * head, uint64_t *numsecp, unsigned *secsizep)
+dm_table_disksize(dm_table_head_t *head, uint64_t *numsecp, unsigned *secsizep)
+{
 	dm_table_t *tbl;
 	dm_table_entry_t *table_en;
 	uint64_t length;
 	unsigned secsize, tsecsize;
 	uint8_t id;
 	length = 0;
 	id = dm_table_busy(head, DM_TABLE_ACTIVE);
 	/* Select active table */
 	tbl = &head->tables[id];
 @@ -255,68 +255,68 @@ dm_table_disksize(dm_table_head_t * head
 	*numsecp = secsize > 0 ? dbtob(length) / secsize : 0;
 	*secsizep = secsize;
 	dm_table_unbusy(head);
+}
 /*
  * Return > 0 if table is at least one table entry (returns number of entries)
  * and return 0 if there is not. Target count returned from this function
  * doesn't need to be true when userspace user receive it (after return
  * there can be dm_dev_resume_ioctl), therfore this isonly informative.
  */
 int
-dm_table_get_target_count(dm_table_head_t * head, uint8_t table_id)
+dm_table_get_target_count(dm_table_head_t *head, uint8_t table_id)
+{
 	dm_table_entry_t *table_en;
 	dm_table_t *tbl;
 	uint32_t target_count;
 	uint8_t id;
 	target_count = 0;
 	id = dm_table_busy(head, table_id);
 	tbl = &head->tables[id];
 	SLIST_FOREACH(table_en, tbl, next)
 		target_count++;
 	dm_table_unbusy(head);
 	return target_count;
+}
 /*
  * Initialize table_head structures, I'm trying to keep this structure as
  * opaque as possible.
  */
 void
-dm_table_head_init(dm_table_head_t * head)
+dm_table_head_init(dm_table_head_t *head)
+{
 	head->cur_active_table = 0;
 	head->io_cnt = 0;
 	/* Initialize tables. */
 	SLIST_INIT(&head->tables[0]);
 	SLIST_INIT(&head->tables[1]);
 	mutex_init(&head->table_mtx, MUTEX_DEFAULT, IPL_NONE);
 	cv_init(&head->table_cv, "dm_io");
+}
 /*
  * Destroy all variables in table_head
  */
 void
-dm_table_head_destroy(dm_table_head_t * head)
+dm_table_head_destroy(dm_table_head_t *head)
+{
 	KASSERT(!mutex_owned(&head->table_mtx));
 	KASSERT(!cv_has_waiters(&head->table_cv));
 	/* tables doens't exists when I call this routine, therefore it
 	 * doesn't make sense to have io_cnt != 0 */
 	KASSERT(head->io_cnt == 0);
 	cv_destroy(&head->table_cv);
 	mutex_destroy(&head->table_mtx);
+}

 @@ -1,14 +1,14 @@
-/*        $NetBSD: dm_target.c,v 1.24 2019/12/07 06:26:31 tkusumi Exp $      */
+/*        $NetBSD: dm_target.c,v 1.25 2019/12/07 15:28:39 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.
 @@ -19,61 +19,61 @@
  * 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.c,v 1.24 2019/12/07 06:26:31 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_target.c,v 1.25 2019/12/07 15:28:39 tkusumi Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/kmem.h>
 #include <sys/module.h>
 #include "netbsd-dm.h"
 #include "dm.h"
 static dm_target_t *dm_target_lookup_name(const char *);
 TAILQ_HEAD(dm_target_head, dm_target);
 static struct dm_target_head dm_target_list =
 TAILQ_HEAD_INITIALIZER(dm_target_list);
 static kmutex_t dm_target_mutex;
 /*
  * Called indirectly from dm_table_load_ioctl to mark target as used.
  */
 void
-dm_target_busy(dm_target_t * target)
+dm_target_busy(dm_target_t *target)
+{
 	atomic_inc_32(&target->ref_cnt);
+}
 /*
  * Release reference counter on target.
  */
 void
-dm_target_unbusy(dm_target_t * target)
+dm_target_unbusy(dm_target_t *target)
+{
 	KASSERT(target->ref_cnt > 0);
 	atomic_dec_32(&target->ref_cnt);
+}
 /*
  * Try to autoload target module if it was not found in current
  * target list.
  */
 dm_target_t *
 dm_target_autoload(const char *dm_target_name)
+{
 	char name[30];
 @@ -141,27 +141,27 @@ dm_target_lookup_name(const char *dm_tar
 		if (strncmp(dm_target_name, dm_target->name, slen) == 0)
 			return dm_target;
+	}
 	return NULL;
+}
 /*
  * Insert new target struct into the TAIL.
  * dm_target
  *   contains name, version, function pointer to specifif target functions.
  */
 int
-dm_target_insert(dm_target_t * dm_target)
+dm_target_insert(dm_target_t *dm_target)
+{
 	dm_target_t *dmt;
 	/* Sanity check for any missing function */
 	KASSERT(dm_target->init != NULL);
 	KASSERT(dm_target->status != NULL);
 	KASSERT(dm_target->strategy != NULL);
 	KASSERT(dm_target->deps != NULL);
 	KASSERT(dm_target->destroy != NULL);
 	KASSERT(dm_target->upcall != NULL);
 	KASSERT(dm_target->sync != NULL);
 	KASSERT(dm_target->secsize != NULL);

 @@ -1,14 +1,14 @@
-/*        $NetBSD: dm_target_snapshot.c,v 1.24 2019/12/06 16:11:59 tkusumi Exp $      */
+/*        $NetBSD: dm_target_snapshot.c,v 1.25 2019/12/07 15:28:39 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.
 @@ -19,27 +19,27 @@
  * 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.24 2019/12/06 16:11:59 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_target_snapshot.c,v 1.25 2019/12/07 15:28:39 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.
 @@ -78,35 +78,35 @@ __KERNEL_RCSID(0, "$NetBSD: dm_target_sn
 /*
  * 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_dev_t *, void**, char *);
-char * dm_target_snapshot_status(void *);
+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_dev_t *, void**, char *);
-char * dm_target_snapshot_orig_status(void *);
+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 *);
 #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.
 @@ -182,27 +182,27 @@ dm_target_snapshot_modcmd(modcmd_t cmd,
 		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_dev_t * dmv, void **target_config, char *params)
+dm_target_snapshot_init(dm_dev_t *dmv, void **target_config, 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
 	 */
 @@ -285,42 +285,42 @@ dm_target_snapshot_status(void *target_c
 	    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)
+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)
+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;
 @@ -329,76 +329,75 @@ dm_target_snapshot_destroy(dm_table_entr
 	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,
+dm_target_snapshot_deps(dm_table_entry_t *table_en, prop_array_t prop_array)
     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)
+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_dev_t * dmv, void **target_config, char *params)
+dm_target_snapshot_orig_init(dm_dev_t *dmv, void **target_config, 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;
 @@ -436,59 +435,59 @@ dm_target_snapshot_orig_status(void *tar
 	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)
+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)
+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)
+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 */
 @@ -496,44 +495,44 @@ dm_target_snapshot_orig_destroy(dm_table
 	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,
+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)
+dm_target_snapshot_orig_upcall(dm_table_entry_t *table_en, struct buf *bp)
+{
 	return 0;
+}

 @@ -1,14 +1,14 @@
-/*        $NetBSD: dm_target_error.c,v 1.15 2019/12/06 16:11:59 tkusumi Exp $      */
+/*        $NetBSD: dm_target_error.c,v 1.16 2019/12/07 15:28:39 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.
 @@ -19,41 +19,41 @@
  * 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_error.c,v 1.15 2019/12/06 16:11:59 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_target_error.c,v 1.16 2019/12/07 15:28:39 tkusumi Exp $");
 /*
  * This file implements initial version of device-mapper error target.
  */
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/buf.h>
 #include "dm.h"
 /* dm_target_error.c */
 int dm_target_error_init(dm_dev_t *, void**, char *);
-char * dm_target_error_status(void *);
+char *dm_target_error_status(void *);
 int dm_target_error_strategy(dm_table_entry_t *, struct buf *);
 int dm_target_error_sync(dm_table_entry_t *);
 int dm_target_error_deps(dm_table_entry_t *, prop_array_t);
 int dm_target_error_destroy(dm_table_entry_t *);
 int dm_target_error_upcall(dm_table_entry_t *, struct buf *);
 #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.
 @@ -100,76 +100,76 @@ dm_target_error_modcmd(modcmd_t cmd, voi
 	case MODULE_CMD_STAT:
 		return ENOTTY;
 	default:
 		return ENOTTY;
+	}
 	return r;
+}
 #endif
 /* Init function called from dm_table_load_ioctl. */
 int
-dm_target_error_init(dm_dev_t * dmv, void **target_config, char *argv)
+dm_target_error_init(dm_dev_t *dmv, void **target_config, char *argv)
+{
 	printf("Error target init function called!!\n");
 	*target_config = NULL;
 	return 0;
+}
 /* Status routine called to get params string. */
 char *
 dm_target_error_status(void *target_config)
+{
 	return NULL;
+}
 /* Strategy routine called from dm_strategy. */
 int
-dm_target_error_strategy(dm_table_entry_t * table_en, struct buf * bp)
+dm_target_error_strategy(dm_table_entry_t *table_en, struct buf *bp)
+{
 	printf("Error target read function called!!\n");
 	bp->b_error = EIO;
 	bp->b_resid = 0;
 	biodone(bp);
 	return 0;
+}
 /* Sync underlying disk caches. */
 int
-dm_target_error_sync(dm_table_entry_t * table_en)
+dm_target_error_sync(dm_table_entry_t *table_en)
+{
 	return 0;
+}
 /* Doesn't do anything here. */
 int
-dm_target_error_destroy(dm_table_entry_t * table_en)
+dm_target_error_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_error_deps(dm_table_entry_t * table_en, prop_array_t prop_array)
+dm_target_error_deps(dm_table_entry_t *table_en, prop_array_t prop_array)
+{
 	return 0;
+}
 /* Unsupported for this target. */
 int
-dm_target_error_upcall(dm_table_entry_t * table_en, struct buf * bp)
+dm_target_error_upcall(dm_table_entry_t *table_en, struct buf *bp)
+{
 	return 0;
+}

 @@ -1,14 +1,14 @@
-/*        $NetBSD: dm_target_linear.c,v 1.23 2019/12/06 16:46:14 tkusumi Exp $      */
+/*        $NetBSD: dm_target_linear.c,v 1.24 2019/12/07 15:28:39 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.
 @@ -19,53 +19,53 @@
  * 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_linear.c,v 1.23 2019/12/06 16:46:14 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_target_linear.c,v 1.24 2019/12/07 15:28:39 tkusumi Exp $");
 /*
  * This file implements initial version of device-mapper dklinear target.
  */
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/buf.h>
 #include <sys/kmem.h>
 #include <sys/lwp.h>
 #include <machine/int_fmtio.h>
 #include "dm.h"
 /*
  * Allocate target specific config data, and link them to table.
  * This function is called only when, flags is not READONLY and
  * therefore we can add things to pdev list. This should not a
  * problem because this routine is called only from dm_table_load_ioctl.
  * @argv[0] is name,
  * @argv[1] is physical data offset.
  */
 int
-dm_target_linear_init(dm_dev_t * dmv, void **target_config, char *params)
+dm_target_linear_init(dm_dev_t *dmv, void **target_config, char *params)
+{
 	dm_target_linear_config_t *tlc;
 	dm_pdev_t *dmp;
 	char **ap, *argv[3];
 	if (params == NULL)
 		return EINVAL;
 	/*
 	 * Parse a string, containing tokens delimited by white space,
 	 * into an argument vector
 	 */
 @@ -107,121 +107,121 @@ dm_target_linear_status(void *target_con
 	params = kmem_alloc(DM_MAX_PARAMS_SIZE, KM_SLEEP);
 	aprint_normal("%s %" PRIu64, tlc->pdev->name, tlc->offset);
 	snprintf(params, DM_MAX_PARAMS_SIZE, "%s %" PRIu64,
 	    tlc->pdev->name, tlc->offset);
 	return params;
+}
 /*
  * Do IO operation, called from dmstrategy routine.
  */
 int
-dm_target_linear_strategy(dm_table_entry_t * table_en, struct buf * bp)
+dm_target_linear_strategy(dm_table_entry_t *table_en, struct buf *bp)
+{
 	dm_target_linear_config_t *tlc;
 	tlc = table_en->target_config;
 /*	printf("Linear target read function called %" PRIu64 "!!\n",
 	tlc->offset);*/
 	bp->b_blkno += tlc->offset;
 	VOP_STRATEGY(tlc->pdev->pdev_vnode, bp);
 	return 0;
+}
 /*
  * Sync underlying disk caches.
  */
 int
-dm_target_linear_sync(dm_table_entry_t * table_en)
+dm_target_linear_sync(dm_table_entry_t *table_en)
+{
 	int cmd;
 	dm_target_linear_config_t *tlc;
 	tlc = table_en->target_config;
 	cmd = 1;
 	return VOP_IOCTL(tlc->pdev->pdev_vnode,  DIOCCACHESYNC, &cmd,
 	    FREAD|FWRITE, kauth_cred_get());
+}
 /*
  * Destroy target specific data. Decrement table pdevs.
  */
 int
-dm_target_linear_destroy(dm_table_entry_t * table_en)
+dm_target_linear_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_linear_config_t *tlc = table_en->target_config;
 	/* Decrement pdev ref counter if 0 remove it */
 	dm_pdev_decr(tlc->pdev);
 	kmem_free(tlc, sizeof(*tlc));
 out:
 	/* Unbusy target so we can unload it */
 	dm_target_unbusy(table_en->target);
 	return 0;
+}
 /* Add this target pdev dependencies to prop_array_t */
 int
-dm_target_linear_deps(dm_table_entry_t * table_en, prop_array_t prop_array)
+dm_target_linear_deps(dm_table_entry_t *table_en, prop_array_t prop_array)
+{
 	dm_target_linear_config_t *tlc;
 	if (table_en->target_config == NULL)
 		return ENOENT;
 	tlc = table_en->target_config;
 	prop_array_add_uint64(prop_array,
 	    (uint64_t) tlc->pdev->pdev_vnode->v_rdev);
 	return 0;
+}
 /*
  * Register upcall device.
  * Linear target doesn't need any upcall devices but other targets like
  * mirror, snapshot, multipath, stripe will use this functionality.
  */
 int
-dm_target_linear_upcall(dm_table_entry_t * table_en, struct buf * bp)
+dm_target_linear_upcall(dm_table_entry_t *table_en, struct buf *bp)
+{
 	return 0;
+}
 /*
  * Query physical block size of this target
  * For a linear target this is just the sector size of the underlying device
  */
 int
-dm_target_linear_secsize(dm_table_entry_t * table_en, unsigned *secsizep)
+dm_target_linear_secsize(dm_table_entry_t *table_en, unsigned *secsizep)
+{
 	dm_target_linear_config_t *tlc;
 	unsigned secsize;
 	secsize = 0;
 	tlc = table_en->target_config;
 	if (tlc != NULL)
 		secsize = tlc->pdev->pdev_secsize;
 	*secsizep = secsize;
 	return 0;

 @@ -1,14 +1,14 @@
-/*$NetBSD: dm_target_stripe.c,v 1.29 2019/12/06 16:33:47 tkusumi Exp $*/
+/*$NetBSD: dm_target_stripe.c,v 1.30 2019/12/07 15:28:39 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.
 @@ -19,27 +19,27 @@
  * 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.29 2019/12/06 16:33:47 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_target_stripe.c,v 1.30 2019/12/07 15:28:39 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"
 @@ -118,27 +118,27 @@ dm_target_stripe_fini(dm_target_stripe_c
 	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_dev_t * dmv, void **target_config, char *params)
+dm_target_stripe_init(dm_dev_t *dmv, void **target_config, 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;
 	/*
 @@ -207,27 +207,27 @@ dm_target_stripe_status(void *target_con
 	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_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;
 @@ -273,94 +273,94 @@ dm_target_stripe_strategy(dm_table_entry
 		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)
+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_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_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)
+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_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;
+		}