 @@ -1,298 +1,305 @@
-/*        $NetBSD: dm.h,v 1.37 2019/12/08 10:50:21 tkusumi Exp $      */
+/*        $NetBSD: dm.h,v 1.38 2019/12/08 14:59:42 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;
 /* 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 *);
 /* XXX dummy */
 static __inline int
 dm_target_dummy_secsize(dm_table_entry_t *table_en, unsigned *secsizep)
+{
 	return 0;
+}
 #endif /*_KERNEL*/
 #endif /*_DM_DEV_H_*/

 @@ -1,175 +1,176 @@
-/*        $NetBSD: dm_target_error.c,v 1.17 2019/12/08 04:41:02 tkusumi Exp $      */
+/*        $NetBSD: dm_target_error.c,v 1.18 2019/12/08 14:59:42 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_error.c,v 1.17 2019/12/08 04:41:02 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_target_error.c,v 1.18 2019/12/08 14:59:42 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_table_entry_t*, char *);
 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.
  */
 #include <sys/kernel.h>
 #include <sys/module.h>
 MODULE(MODULE_CLASS_MISC, dm_target_error, "dm");
 static int
 dm_target_error_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("error")) != NULL) {
 			dm_target_unbusy(dmt);
 			return EEXIST;
+		}
 		dmt = dm_target_alloc("error");
 		dmt->version[0] = 1;
 		dmt->version[1] = 0;
 		dmt->version[2] = 0;
 		dmt->init = &dm_target_error_init;
 		dmt->status = &dm_target_error_status;
 		dmt->strategy = &dm_target_error_strategy;
 		dmt->sync = &dm_target_error_sync;
 		dmt->deps = &dm_target_error_deps;
 		dmt->destroy = &dm_target_error_destroy;
 		dmt->upcall = &dm_target_error_upcall;
 		dmt->secsize = dm_target_dummy_secsize;
 		r = dm_target_insert(dmt);
 		break;
 	case MODULE_CMD_FINI:
 		r = dm_target_rem("error");
 		break;
 	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_table_entry_t *table_en, char *params)
+{
 	printf("Error target init function called!!\n");
 	table_en->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)
+{
 	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)
+{
 	return 0;
+}
 /* Doesn't do anything here. */
 int
 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)
+{
 	return 0;
+}
 /* Unsupported for this target. */
 int
 dm_target_error_upcall(dm_table_entry_t *table_en, struct buf *bp)
+{
 	return 0;
+}

 @@ -1,191 +1,192 @@
-/*$NetBSD: dm_target_mirror.c,v 1.16 2019/12/08 10:50:21 tkusumi Exp $*/
+/*$NetBSD: dm_target_mirror.c,v 1.17 2019/12/08 14:59:42 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.16 2019/12/08 10:50:21 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_target_mirror.c,v 1.17 2019/12/08 14:59:42 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;
 		dmt->secsize = dm_target_dummy_secsize;
 		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,549 +1,560 @@
-/*        $NetBSD: dm_target_snapshot.c,v 1.28 2019/12/08 10:50:21 tkusumi Exp $      */
+/*        $NetBSD: dm_target_snapshot.c,v 1.29 2019/12/08 14:59:42 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.28 2019/12/08 10:50:21 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_target_snapshot.c,v 1.29 2019/12/08 14:59:42 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_sync(dm_table_entry_t *);
 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->sync = &dm_target_snapshot_sync;
 		dmt->deps = &dm_target_snapshot_deps;
 		dmt->destroy = &dm_target_snapshot_destroy;
 		dmt->upcall = &dm_target_snapshot_upcall;
 		dmt->secsize = dm_target_dummy_secsize;
 		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;
 		dmt1->secsize = dm_target_dummy_secsize;
 		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;
+}
 /* XXX dummy */
 int
 dm_target_snapshot_sync(dm_table_entry_t *table_en)
+{
 	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,182 +1,183 @@
-/*        $NetBSD: dm_target_zero.c,v 1.19 2019/12/08 04:41:02 tkusumi Exp $      */
+/*        $NetBSD: dm_target_zero.c,v 1.20 2019/12/08 14:59:42 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_zero.c,v 1.19 2019/12/08 04:41:02 tkusumi Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dm_target_zero.c,v 1.20 2019/12/08 14:59:42 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_table_entry_t *, char *);
 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.
  */
 #include <sys/kernel.h>
 #include <sys/module.h>
 MODULE(MODULE_CLASS_MISC, dm_target_zero, "dm");
 static int
 dm_target_zero_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("zero")) != NULL) {
 			dm_target_unbusy(dmt);
 			return EEXIST;
+		}
 		dmt = dm_target_alloc("zero");
 		dmt->version[0] = 1;
 		dmt->version[1] = 0;
 		dmt->version[2] = 0;
 		dmt->init = &dm_target_zero_init;
 		dmt->status = &dm_target_zero_status;
 		dmt->strategy = &dm_target_zero_strategy;
 		dmt->sync = &dm_target_zero_sync;
 		dmt->deps = &dm_target_zero_deps;
 		dmt->destroy = &dm_target_zero_destroy;
 		dmt->upcall = &dm_target_zero_upcall;
 		dmt->secsize = dm_target_dummy_secsize;
 		r = dm_target_insert(dmt);
 		break;
 	case MODULE_CMD_FINI:
 		r = dm_target_rem("zero");
 		break;
 	case MODULE_CMD_STAT:
 		return ENOTTY;
 	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_table_entry_t *table_en, char *params)
+{
 	printf("Zero target init function called!!\n");
 	table_en->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)
+{
 	/* 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)
+{
 	return 0;
+}
 /* Does not need to do anything here. */
 int
 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)
+{
 	return 0;
+}
 /* Unsuported for this target. */
 int
 dm_target_zero_upcall(dm_table_entry_t *table_en, struct buf *bp)
+{
 	return 0;
+}