[dragonfly.git] / sys / dev / disk / dm / dm_pdev.c

/*        $NetBSD: dm_pdev.c,v 1.6 2010/01/04 00:19:08 haad 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/types.h>
#include <sys/param.h>

#include <sys/disk.h>
#include <sys/fcntl.h>
#include <sys/malloc.h>
#include <sys/namei.h>
#include <sys/vnode.h>
#include <sys/nlookup.h>

#include <dev/disk/dm/dm.h>

SLIST_HEAD(dm_pdevs, dm_pdev) dm_pdev_list;

struct lock dm_pdev_mutex;

static dm_pdev_t *dm_pdev_alloc(const char *);
static int dm_pdev_rem(dm_pdev_t *);
static dm_pdev_t *dm_pdev_lookup_name(const char *);

/*
 * Find used pdev with name == dm_pdev_name.
 * needs to be called with the dm_pdev_mutex held.
 */
static dm_pdev_t *
dm_pdev_lookup_name(const char *dm_pdev_name)
{
	dm_pdev_t *dm_pdev;

	KKASSERT(dm_pdev_name != NULL);

	SLIST_FOREACH(dm_pdev, &dm_pdev_list, next_pdev) {
		if (strcmp(dm_pdev_name, dm_pdev->name) == 0)
			return dm_pdev;
	}

	return NULL;
}

static int
dm_dk_lookup(const char *dev_name, struct vnode **vpp)
{
	struct nlookupdata nd;
	int error;

	error = nlookup_init(&nd, dev_name, UIO_SYSSPACE, NLC_FOLLOW);
	if (error)
	    return error;

	error = vn_open(&nd, NULL, FREAD|FWRITE, 0);
	*vpp = nd.nl_open_vp;
	nd.nl_open_vp = NULL;
	nlookup_done(&nd);

	return 0;
}

/*
 * Since dm can have arbitrary stacking on any number of disks and any dm
 * volume is at least stacked onto another disk, we need to adjust the
 * dumping offset (which is a raw offset from the beginning of the lowest
 * physical disk) taking into account the offset of the underlying device
 * which in turn takes into account the offset below it, etc.
 *
 * This function adjusts the dumping offset that is passed to the next
 * dev_ddump() so it is correct for that underlying device.
 */
off_t
dm_pdev_correct_dump_offset(dm_pdev_t *pdev, off_t offset)
{
	off_t noffset;

	noffset = pdev->pdev_pinfo.reserved_blocks +
	    pdev->pdev_pinfo.media_offset / pdev->pdev_pinfo.media_blksize;
	noffset *= DEV_BSIZE;
	noffset += offset;

	return noffset;
}

/*
 * Create entry for device with name dev_name and open vnode for it.
 * If entry already exists in global SLIST I will only increment
 * reference counter.
 */
dm_pdev_t *
dm_pdev_insert(const char *dev_name)
{
	dm_pdev_t *dmp;
	int error;

	KKASSERT(dev_name != NULL);

	lockmgr(&dm_pdev_mutex, LK_EXCLUSIVE);
	dmp = dm_pdev_lookup_name(dev_name);

	if (dmp != NULL) {
		dmp->ref_cnt++;
		aprint_debug("dmp_pdev_insert pdev %s already in tree\n", dev_name);
		lockmgr(&dm_pdev_mutex, LK_RELEASE);
		return dmp;
	}
	lockmgr(&dm_pdev_mutex, LK_RELEASE);

	if ((dmp = dm_pdev_alloc(dev_name)) == NULL)
		return NULL;

	error = dm_dk_lookup(dev_name, &dmp->pdev_vnode);
	if (error) {
		aprint_debug("dk_lookup on device: %s failed with error %d!\n",
		    dev_name, error);
		kfree(dmp, M_DM);
		return NULL;
	}
	dmp->ref_cnt = 1;

	/*
	 * Get us the partinfo from the underlying device, it's needed for
	 * dumps.
	 */
	bzero(&dmp->pdev_pinfo, sizeof(dmp->pdev_pinfo));
	error = dev_dioctl(dmp->pdev_vnode->v_rdev, DIOCGPART,
	    (void *)&dmp->pdev_pinfo, 0, proc0.p_ucred, NULL);

	lockmgr(&dm_pdev_mutex, LK_EXCLUSIVE);
	SLIST_INSERT_HEAD(&dm_pdev_list, dmp, next_pdev);
	lockmgr(&dm_pdev_mutex, LK_RELEASE);

	return dmp;
}
/*
 * Initialize pdev subsystem.
 */
int
dm_pdev_init(void)
{
	SLIST_INIT(&dm_pdev_list);	/* initialize global pdev list */
	lockinit(&dm_pdev_mutex, "dmpdev", 0, LK_CANRECURSE);

	return 0;
}
/*
 * Allocat new pdev structure if is not already present and
 * set name.
 */
static dm_pdev_t *
dm_pdev_alloc(const char *name)
{
	dm_pdev_t *dmp;

	if ((dmp = kmalloc(sizeof(dm_pdev_t), M_DM, M_WAITOK | M_ZERO)) == NULL)
		return NULL;

	strlcpy(dmp->name, name, MAX_DEV_NAME);

	dmp->ref_cnt = 0;
	dmp->pdev_vnode = NULL;

	return dmp;
}
/*
 * Destroy allocated dm_pdev.
 */
static int
dm_pdev_rem(dm_pdev_t * dmp)
{
	int err;

	KKASSERT(dmp != NULL);

	if (dmp->pdev_vnode != NULL) {
		err = vn_close(dmp->pdev_vnode, FREAD | FWRITE);
		if (err != 0)
			return err;
	}
	kfree(dmp, M_DM);
	dmp = NULL;

	return 0;
}
/*
 * Destroy all existing pdev's in device-mapper.
 */
int
dm_pdev_destroy(void)
{
	dm_pdev_t *dm_pdev;

	lockmgr(&dm_pdev_mutex, LK_EXCLUSIVE);
	while (!SLIST_EMPTY(&dm_pdev_list)) {	/* List Deletion. */

		dm_pdev = SLIST_FIRST(&dm_pdev_list);

		SLIST_REMOVE_HEAD(&dm_pdev_list, next_pdev);

		dm_pdev_rem(dm_pdev);
	}
	lockmgr(&dm_pdev_mutex, LK_RELEASE);

	lockuninit(&dm_pdev_mutex);
	return 0;
}
/*
 * 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)
{
	KKASSERT(dmp != NULL);
	/*
	 * If this was last reference remove dmp from
	 * global list also.
	 */
	lockmgr(&dm_pdev_mutex, LK_EXCLUSIVE);

	if (--dmp->ref_cnt == 0) {
		SLIST_REMOVE(&dm_pdev_list, dmp, dm_pdev, next_pdev);
		lockmgr(&dm_pdev_mutex, LK_RELEASE);
		dm_pdev_rem(dmp);
		return 0;
	}
	lockmgr(&dm_pdev_mutex, LK_RELEASE);
	return 0;
}
Commit	Line	Data
ff56536e AH	1	/* $NetBSD: dm_pdev.c,v 1.6 2010/01/04 00:19:08 haad Exp $ */
	2
	3	/*
	4	* Copyright (c) 2008 The NetBSD Foundation, Inc.
	5	* All rights reserved.
	6	*
	7	* This code is derived from software contributed to The NetBSD Foundation
	8	* by Adam Hamsik.
	9	*
	10	* Redistribution and use in source and binary forms, with or without
	11	* modification, are permitted provided that the following conditions
	12	* are met:
	13	* 1. Redistributions of source code must retain the above copyright
	14	* notice, this list of conditions and the following disclaimer.
	15	* 2. Redistributions in binary form must reproduce the above copyright
	16	* notice, this list of conditions and the following disclaimer in the
	17	* documentation and/or other materials provided with the distribution.
	18	*
	19	* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
	20	* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
	21	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	22	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
	23	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	24	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	25	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	26	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	27	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	28	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	29	* POSSIBILITY OF SUCH DAMAGE.
	30	*/
	31
	32	#include <sys/types.h>
	33	#include <sys/param.h>
	34
	35	#include <sys/disk.h>
	36	#include <sys/fcntl.h>
5b279a20	37	#include <sys/malloc.h>
ff56536e AH	38	#include <sys/namei.h>
ff56536e AH	39	#include <sys/vnode.h>
5b279a20	40	#include <sys/nlookup.h>
ff56536e	41
a84e173e	42	#include <dev/disk/dm/dm.h>
ff56536e AH	43
	44	SLIST_HEAD(dm_pdevs, dm_pdev) dm_pdev_list;
	45
add6c27f	46	struct lock dm_pdev_mutex;
ff56536e	47
add6c27f AH	48	static dm_pdev_t dm_pdev_alloc(const char );
	49	static int dm_pdev_rem(dm_pdev_t *);
	50	static dm_pdev_t dm_pdev_lookup_name(const char );
ff56536e AH	51
	52	/*
	53	* Find used pdev with name == dm_pdev_name.
add6c27f	54	* needs to be called with the dm_pdev_mutex held.
ff56536e	55	*/
add6c27f AH	56	static dm_pdev_t *
add6c27f AH	57	dm_pdev_lookup_name(const char *dm_pdev_name)
ff56536e AH	58	{
ff56536e AH	59	dm_pdev_t *dm_pdev;
ff56536e	60
5b279a20	61	KKASSERT(dm_pdev_name != NULL);
ff56536e	62
ff56536e	63	SLIST_FOREACH(dm_pdev, &dm_pdev_list, next_pdev) {
add6c27f	64	if (strcmp(dm_pdev_name, dm_pdev->name) == 0)
ff56536e AH	65	return dm_pdev;
	66	}
	67
	68	return NULL;
	69	}
5b279a20 AH	70
	71	static int
	72	dm_dk_lookup(const char dev_name, struct vnode *vpp)
	73	{
	74	struct nlookupdata nd;
	75	int error;
	76
5b279a20 AH	77	error = nlookup_init(&nd, dev_name, UIO_SYSSPACE, NLC_FOLLOW);
	78	if (error)
	79	return error;
	80
	81	error = vn_open(&nd, NULL, FREAD\|FWRITE, 0);
	82	*vpp = nd.nl_open_vp;
	83	nd.nl_open_vp = NULL;
	84	nlookup_done(&nd);
	85
	86	return 0;
	87	}
	88
add6c27f AH	89	/*
	90	* Since dm can have arbitrary stacking on any number of disks and any dm
	91	* volume is at least stacked onto another disk, we need to adjust the
	92	* dumping offset (which is a raw offset from the beginning of the lowest
	93	* physical disk) taking into account the offset of the underlying device
	94	* which in turn takes into account the offset below it, etc.
	95	*
	96	* This function adjusts the dumping offset that is passed to the next
	97	* dev_ddump() so it is correct for that underlying device.
	98	*/
79b7159f AH	99	off_t
	100	dm_pdev_correct_dump_offset(dm_pdev_t *pdev, off_t offset)
	101	{
	102	off_t noffset;
	103
	104	noffset = pdev->pdev_pinfo.reserved_blocks +
	105	pdev->pdev_pinfo.media_offset / pdev->pdev_pinfo.media_blksize;
	106	noffset *= DEV_BSIZE;
	107	noffset += offset;
	108
	109	return noffset;
	110	}
	111
ff56536e AH	112	/*
	113	* Create entry for device with name dev_name and open vnode for it.
	114	* If entry already exists in global SLIST I will only increment
	115	* reference counter.
	116	*/
	117	dm_pdev_t *
	118	dm_pdev_insert(const char *dev_name)
	119	{
	120	dm_pdev_t *dmp;
	121	int error;
	122
5b279a20	123	KKASSERT(dev_name != NULL);
ff56536e	124
5b279a20	125	lockmgr(&dm_pdev_mutex, LK_EXCLUSIVE);
ff56536e AH	126	dmp = dm_pdev_lookup_name(dev_name);
	127
	128	if (dmp != NULL) {
	129	dmp->ref_cnt++;
	130	aprint_debug("dmp_pdev_insert pdev %s already in tree\n", dev_name);
5b279a20	131	lockmgr(&dm_pdev_mutex, LK_RELEASE);
ff56536e AH	132	return dmp;
ff56536e AH	133	}
5b279a20	134	lockmgr(&dm_pdev_mutex, LK_RELEASE);
ff56536e AH	135
	136	if ((dmp = dm_pdev_alloc(dev_name)) == NULL)
	137	return NULL;
	138
5b279a20	139	error = dm_dk_lookup(dev_name, &dmp->pdev_vnode);
ff56536e AH	140	if (error) {
	141	aprint_debug("dk_lookup on device: %s failed with error %d!\n",
	142	dev_name, error);
5b279a20	143	kfree(dmp, M_DM);
ff56536e AH	144	return NULL;
	145	}
	146	dmp->ref_cnt = 1;
	147
79b7159f AH	148	/*
	149	* Get us the partinfo from the underlying device, it's needed for
	150	* dumps.
	151	*/
	152	bzero(&dmp->pdev_pinfo, sizeof(dmp->pdev_pinfo));
	153	error = dev_dioctl(dmp->pdev_vnode->v_rdev, DIOCGPART,
	154	(void *)&dmp->pdev_pinfo, 0, proc0.p_ucred, NULL);
	155
5b279a20	156	lockmgr(&dm_pdev_mutex, LK_EXCLUSIVE);
ff56536e	157	SLIST_INSERT_HEAD(&dm_pdev_list, dmp, next_pdev);
5b279a20	158	lockmgr(&dm_pdev_mutex, LK_RELEASE);
ff56536e AH	159
	160	return dmp;
	161	}
	162	/*
	163	* Initialize pdev subsystem.
	164	*/
	165	int
	166	dm_pdev_init(void)
	167	{
	168	SLIST_INIT(&dm_pdev_list); /* initialize global pdev list */
5b279a20	169	lockinit(&dm_pdev_mutex, "dmpdev", 0, LK_CANRECURSE);
ff56536e AH	170
	171	return 0;
	172	}
	173	/*
	174	* Allocat new pdev structure if is not already present and
	175	* set name.
	176	*/
	177	static dm_pdev_t *
	178	dm_pdev_alloc(const char *name)
	179	{
	180	dm_pdev_t *dmp;
	181
5b279a20	182	if ((dmp = kmalloc(sizeof(dm_pdev_t), M_DM, M_WAITOK \| M_ZERO)) == NULL)
ff56536e AH	183	return NULL;
	184
	185	strlcpy(dmp->name, name, MAX_DEV_NAME);
	186
	187	dmp->ref_cnt = 0;
	188	dmp->pdev_vnode = NULL;
	189
	190	return dmp;
	191	}
	192	/*
	193	* Destroy allocated dm_pdev.
	194	*/
	195	static int
	196	dm_pdev_rem(dm_pdev_t * dmp)
	197	{
	198	int err;
	199
5b279a20	200	KKASSERT(dmp != NULL);
ff56536e AH	201
ff56536e AH	202	if (dmp->pdev_vnode != NULL) {
5b279a20	203	err = vn_close(dmp->pdev_vnode, FREAD \| FWRITE);
ff56536e AH	204	if (err != 0)
	205	return err;
	206	}
5b279a20	207	kfree(dmp, M_DM);
ff56536e AH	208	dmp = NULL;
	209
	210	return 0;
	211	}
	212	/*
	213	* Destroy all existing pdev's in device-mapper.
	214	*/
	215	int
	216	dm_pdev_destroy(void)
	217	{
	218	dm_pdev_t *dm_pdev;
	219
5b279a20	220	lockmgr(&dm_pdev_mutex, LK_EXCLUSIVE);
ff56536e AH	221	while (!SLIST_EMPTY(&dm_pdev_list)) { /* List Deletion. */
	222
	223	dm_pdev = SLIST_FIRST(&dm_pdev_list);
	224
	225	SLIST_REMOVE_HEAD(&dm_pdev_list, next_pdev);
	226
	227	dm_pdev_rem(dm_pdev);
	228	}
5b279a20	229	lockmgr(&dm_pdev_mutex, LK_RELEASE);
ff56536e	230
5b279a20	231	lockuninit(&dm_pdev_mutex);
ff56536e AH	232	return 0;
	233	}
	234	/*
	235	* This funcion is called from dm_dev_remove_ioctl.
	236	* When I'm removing device from list, I have to decrement
	237	* reference counter. If reference counter is 0 I will remove
	238	* dmp from global list and from device list to. And I will CLOSE
	239	* dmp vnode too.
	240	*/
	241
	242	/*
	243	* Decrement pdev reference counter if 0 remove it.
	244	*/
	245	int
	246	dm_pdev_decr(dm_pdev_t * dmp)
	247	{
5b279a20	248	KKASSERT(dmp != NULL);
ff56536e AH	249	/*
	250	* If this was last reference remove dmp from
	251	* global list also.
	252	*/
5b279a20	253	lockmgr(&dm_pdev_mutex, LK_EXCLUSIVE);
ff56536e AH	254
	255	if (--dmp->ref_cnt == 0) {
	256	SLIST_REMOVE(&dm_pdev_list, dmp, dm_pdev, next_pdev);
5b279a20	257	lockmgr(&dm_pdev_mutex, LK_RELEASE);
ff56536e AH	258	dm_pdev_rem(dmp);
	259	return 0;
	260	}
5b279a20	261	lockmgr(&dm_pdev_mutex, LK_RELEASE);
ff56536e AH	262	return 0;
ff56536e AH	263	}