[mirror_ubuntu-bionic-kernel.git] / fs / nfs / blocklayout / blocklayout.c

/*
 *  linux/fs/nfs/blocklayout/blocklayout.c
 *
 *  Module for the NFSv4.1 pNFS block layout driver.
 *
 *  Copyright (c) 2006 The Regents of the University of Michigan.
 *  All rights reserved.
 *
 *  Andy Adamson <andros@citi.umich.edu>
 *  Fred Isaman <iisaman@umich.edu>
 *
 * permission is granted to use, copy, create derivative works and
 * redistribute this software and such derivative works for any purpose,
 * so long as the name of the university of michigan is not used in
 * any advertising or publicity pertaining to the use or distribution
 * of this software without specific, written prior authorization.  if
 * the above copyright notice or any other identification of the
 * university of michigan is included in any copy of any portion of
 * this software, then the disclaimer below must also be included.
 *
 * this software is provided as is, without representation from the
 * university of michigan as to its fitness for any purpose, and without
 * warranty by the university of michigan of any kind, either express
 * or implied, including without limitation the implied warranties of
 * merchantability and fitness for a particular purpose.  the regents
 * of the university of michigan shall not be liable for any damages,
 * including special, indirect, incidental, or consequential damages,
 * with respect to any claim arising out or in connection with the use
 * of the software, even if it has been or is hereafter advised of the
 * possibility of such damages.
 */
#include <linux/module.h>
#include <linux/init.h>
#include <linux/mount.h>
#include <linux/namei.h>

#include "blocklayout.h"

#define NFSDBG_FACILITY	NFSDBG_PNFS_LD

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Andy Adamson <andros@citi.umich.edu>");
MODULE_DESCRIPTION("The NFSv4.1 pNFS Block layout driver");

struct dentry *bl_device_pipe;
wait_queue_head_t bl_wq;

static enum pnfs_try_status
bl_read_pagelist(struct nfs_read_data *rdata)
{
	return PNFS_NOT_ATTEMPTED;
}

static enum pnfs_try_status
bl_write_pagelist(struct nfs_write_data *wdata,
		  int sync)
{
	return PNFS_NOT_ATTEMPTED;
}

/* FIXME - range ignored */
static void
release_extents(struct pnfs_block_layout *bl, struct pnfs_layout_range *range)
{
	int i;
	struct pnfs_block_extent *be;

	spin_lock(&bl->bl_ext_lock);
	for (i = 0; i < EXTENT_LISTS; i++) {
		while (!list_empty(&bl->bl_extents[i])) {
			be = list_first_entry(&bl->bl_extents[i],
					      struct pnfs_block_extent,
					      be_node);
			list_del(&be->be_node);
			bl_put_extent(be);
		}
	}
	spin_unlock(&bl->bl_ext_lock);
}

static void
release_inval_marks(struct pnfs_inval_markings *marks)
{
	struct pnfs_inval_tracking *pos, *temp;

	list_for_each_entry_safe(pos, temp, &marks->im_tree.mtt_stub, it_link) {
		list_del(&pos->it_link);
		kfree(pos);
	}
	return;
}

static void bl_free_layout_hdr(struct pnfs_layout_hdr *lo)
{
	struct pnfs_block_layout *bl = BLK_LO2EXT(lo);

	dprintk("%s enter\n", __func__);
	release_extents(bl, NULL);
	release_inval_marks(&bl->bl_inval);
	kfree(bl);
}

static struct pnfs_layout_hdr *bl_alloc_layout_hdr(struct inode *inode,
						   gfp_t gfp_flags)
{
	struct pnfs_block_layout *bl;

	dprintk("%s enter\n", __func__);
	bl = kzalloc(sizeof(*bl), gfp_flags);
	if (!bl)
		return NULL;
	spin_lock_init(&bl->bl_ext_lock);
	INIT_LIST_HEAD(&bl->bl_extents[0]);
	INIT_LIST_HEAD(&bl->bl_extents[1]);
	INIT_LIST_HEAD(&bl->bl_commit);
	INIT_LIST_HEAD(&bl->bl_committing);
	bl->bl_count = 0;
	bl->bl_blocksize = NFS_SERVER(inode)->pnfs_blksize >> SECTOR_SHIFT;
	BL_INIT_INVAL_MARKS(&bl->bl_inval, bl->bl_blocksize);
	return &bl->bl_layout;
}

static void bl_free_lseg(struct pnfs_layout_segment *lseg)
{
	dprintk("%s enter\n", __func__);
	kfree(lseg);
}

/* We pretty much ignore lseg, and store all data layout wide, so we
 * can correctly merge.
 */
static struct pnfs_layout_segment *bl_alloc_lseg(struct pnfs_layout_hdr *lo,
						 struct nfs4_layoutget_res *lgr,
						 gfp_t gfp_flags)
{
	struct pnfs_layout_segment *lseg;
	int status;

	dprintk("%s enter\n", __func__);
	lseg = kzalloc(sizeof(*lseg), gfp_flags);
	if (!lseg)
		return ERR_PTR(-ENOMEM);
	status = nfs4_blk_process_layoutget(lo, lgr, gfp_flags);
	if (status) {
		/* We don't want to call the full-blown bl_free_lseg,
		 * since on error extents were not touched.
		 */
		kfree(lseg);
		return ERR_PTR(status);
	}
	return lseg;
}

static void
bl_encode_layoutcommit(struct pnfs_layout_hdr *lo, struct xdr_stream *xdr,
		       const struct nfs4_layoutcommit_args *arg)
{
}

static void
bl_cleanup_layoutcommit(struct nfs4_layoutcommit_data *lcdata)
{
}

static void free_blk_mountid(struct block_mount_id *mid)
{
	if (mid) {
		struct pnfs_block_dev *dev;
		spin_lock(&mid->bm_lock);
		while (!list_empty(&mid->bm_devlist)) {
			dev = list_first_entry(&mid->bm_devlist,
					       struct pnfs_block_dev,
					       bm_node);
			list_del(&dev->bm_node);
			bl_free_block_dev(dev);
		}
		spin_unlock(&mid->bm_lock);
		kfree(mid);
	}
}

/* This is mostly copied from the filelayout's get_device_info function.
 * It seems much of this should be at the generic pnfs level.
 */
static struct pnfs_block_dev *
nfs4_blk_get_deviceinfo(struct nfs_server *server, const struct nfs_fh *fh,
			struct nfs4_deviceid *d_id)
{
	struct pnfs_device *dev;
	struct pnfs_block_dev *rv = NULL;
	u32 max_resp_sz;
	int max_pages;
	struct page **pages = NULL;
	int i, rc;

	/*
	 * Use the session max response size as the basis for setting
	 * GETDEVICEINFO's maxcount
	 */
	max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
	max_pages = max_resp_sz >> PAGE_SHIFT;
	dprintk("%s max_resp_sz %u max_pages %d\n",
		__func__, max_resp_sz, max_pages);

	dev = kmalloc(sizeof(*dev), GFP_NOFS);
	if (!dev) {
		dprintk("%s kmalloc failed\n", __func__);
		return NULL;
	}

	pages = kzalloc(max_pages * sizeof(struct page *), GFP_NOFS);
	if (pages == NULL) {
		kfree(dev);
		return NULL;
	}
	for (i = 0; i < max_pages; i++) {
		pages[i] = alloc_page(GFP_NOFS);
		if (!pages[i])
			goto out_free;
	}

	memcpy(&dev->dev_id, d_id, sizeof(*d_id));
	dev->layout_type = LAYOUT_BLOCK_VOLUME;
	dev->pages = pages;
	dev->pgbase = 0;
	dev->pglen = PAGE_SIZE * max_pages;
	dev->mincount = 0;

	dprintk("%s: dev_id: %s\n", __func__, dev->dev_id.data);
	rc = nfs4_proc_getdeviceinfo(server, dev);
	dprintk("%s getdevice info returns %d\n", __func__, rc);
	if (rc)
		goto out_free;

	rv = nfs4_blk_decode_device(server, dev);
 out_free:
	for (i = 0; i < max_pages; i++)
		__free_page(pages[i]);
	kfree(pages);
	kfree(dev);
	return rv;
}

static int
bl_set_layoutdriver(struct nfs_server *server, const struct nfs_fh *fh)
{
	struct block_mount_id *b_mt_id = NULL;
	struct pnfs_devicelist *dlist = NULL;
	struct pnfs_block_dev *bdev;
	LIST_HEAD(block_disklist);
	int status = 0, i;

	dprintk("%s enter\n", __func__);

	if (server->pnfs_blksize == 0) {
		dprintk("%s Server did not return blksize\n", __func__);
		return -EINVAL;
	}
	b_mt_id = kzalloc(sizeof(struct block_mount_id), GFP_NOFS);
	if (!b_mt_id) {
		status = -ENOMEM;
		goto out_error;
	}
	/* Initialize nfs4 block layout mount id */
	spin_lock_init(&b_mt_id->bm_lock);
	INIT_LIST_HEAD(&b_mt_id->bm_devlist);

	dlist = kmalloc(sizeof(struct pnfs_devicelist), GFP_NOFS);
	if (!dlist) {
		status = -ENOMEM;
		goto out_error;
	}
	dlist->eof = 0;
	while (!dlist->eof) {
		status = nfs4_proc_getdevicelist(server, fh, dlist);
		if (status)
			goto out_error;
		dprintk("%s GETDEVICELIST numdevs=%i, eof=%i\n",
			__func__, dlist->num_devs, dlist->eof);
		for (i = 0; i < dlist->num_devs; i++) {
			bdev = nfs4_blk_get_deviceinfo(server, fh,
						       &dlist->dev_id[i]);
			if (!bdev) {
				status = -ENODEV;
				goto out_error;
			}
			spin_lock(&b_mt_id->bm_lock);
			list_add(&bdev->bm_node, &b_mt_id->bm_devlist);
			spin_unlock(&b_mt_id->bm_lock);
		}
	}
	dprintk("%s SUCCESS\n", __func__);
	server->pnfs_ld_data = b_mt_id;

 out_return:
	kfree(dlist);
	return status;

 out_error:
	free_blk_mountid(b_mt_id);
	goto out_return;
}

static int
bl_clear_layoutdriver(struct nfs_server *server)
{
	struct block_mount_id *b_mt_id = server->pnfs_ld_data;

	dprintk("%s enter\n", __func__);
	free_blk_mountid(b_mt_id);
	dprintk("%s RETURNS\n", __func__);
	return 0;
}

static const struct nfs_pageio_ops bl_pg_read_ops = {
	.pg_init = pnfs_generic_pg_init_read,
	.pg_test = pnfs_generic_pg_test,
	.pg_doio = pnfs_generic_pg_readpages,
};

static const struct nfs_pageio_ops bl_pg_write_ops = {
	.pg_init = pnfs_generic_pg_init_write,
	.pg_test = pnfs_generic_pg_test,
	.pg_doio = pnfs_generic_pg_writepages,
};

static struct pnfs_layoutdriver_type blocklayout_type = {
	.id				= LAYOUT_BLOCK_VOLUME,
	.name				= "LAYOUT_BLOCK_VOLUME",
	.read_pagelist			= bl_read_pagelist,
	.write_pagelist			= bl_write_pagelist,
	.alloc_layout_hdr		= bl_alloc_layout_hdr,
	.free_layout_hdr		= bl_free_layout_hdr,
	.alloc_lseg			= bl_alloc_lseg,
	.free_lseg			= bl_free_lseg,
	.encode_layoutcommit		= bl_encode_layoutcommit,
	.cleanup_layoutcommit		= bl_cleanup_layoutcommit,
	.set_layoutdriver		= bl_set_layoutdriver,
	.clear_layoutdriver		= bl_clear_layoutdriver,
	.pg_read_ops			= &bl_pg_read_ops,
	.pg_write_ops			= &bl_pg_write_ops,
};

static const struct rpc_pipe_ops bl_upcall_ops = {
	.upcall		= bl_pipe_upcall,
	.downcall	= bl_pipe_downcall,
	.destroy_msg	= bl_pipe_destroy_msg,
};

static int __init nfs4blocklayout_init(void)
{
	struct vfsmount *mnt;
	struct path path;
	int ret;

	dprintk("%s: NFSv4 Block Layout Driver Registering...\n", __func__);

	ret = pnfs_register_layoutdriver(&blocklayout_type);
	if (ret)
		goto out;

	init_waitqueue_head(&bl_wq);

	mnt = rpc_get_mount();
	if (IS_ERR(mnt)) {
		ret = PTR_ERR(mnt);
		goto out_remove;
	}

	ret = vfs_path_lookup(mnt->mnt_root,
			      mnt,
			      NFS_PIPE_DIRNAME, 0, &path);
	if (ret)
		goto out_remove;

	bl_device_pipe = rpc_mkpipe(path.dentry, "blocklayout", NULL,
				    &bl_upcall_ops, 0);
	if (IS_ERR(bl_device_pipe)) {
		ret = PTR_ERR(bl_device_pipe);
		goto out_remove;
	}
out:
	return ret;

out_remove:
	pnfs_unregister_layoutdriver(&blocklayout_type);
	return ret;
}

static void __exit nfs4blocklayout_exit(void)
{
	dprintk("%s: NFSv4 Block Layout Driver Unregistering...\n",
	       __func__);

	pnfs_unregister_layoutdriver(&blocklayout_type);
	rpc_unlink(bl_device_pipe);
}

MODULE_ALIAS("nfs-layouttype4-3");

module_init(nfs4blocklayout_init);
module_exit(nfs4blocklayout_exit);
Commit	Line	Data
155e7524 FI	1	/*
	2	* linux/fs/nfs/blocklayout/blocklayout.c
	3	*
	4	* Module for the NFSv4.1 pNFS block layout driver.
	5	*
	6	* Copyright (c) 2006 The Regents of the University of Michigan.
	7	* All rights reserved.
	8	*
	9	* Andy Adamson <andros@citi.umich.edu>
	10	* Fred Isaman <iisaman@umich.edu>
	11	*
	12	* permission is granted to use, copy, create derivative works and
	13	* redistribute this software and such derivative works for any purpose,
	14	* so long as the name of the university of michigan is not used in
	15	* any advertising or publicity pertaining to the use or distribution
	16	* of this software without specific, written prior authorization. if
	17	* the above copyright notice or any other identification of the
	18	* university of michigan is included in any copy of any portion of
	19	* this software, then the disclaimer below must also be included.
	20	*
	21	* this software is provided as is, without representation from the
	22	* university of michigan as to its fitness for any purpose, and without
	23	* warranty by the university of michigan of any kind, either express
	24	* or implied, including without limitation the implied warranties of
	25	* merchantability and fitness for a particular purpose. the regents
	26	* of the university of michigan shall not be liable for any damages,
	27	* including special, indirect, incidental, or consequential damages,
	28	* with respect to any claim arising out or in connection with the use
	29	* of the software, even if it has been or is hereafter advised of the
	30	* possibility of such damages.
	31	*/
	32	#include <linux/module.h>
	33	#include <linux/init.h>
fe0a9b74 JR	34	#include <linux/mount.h>
fe0a9b74 JR	35	#include <linux/namei.h>
155e7524 FI	36
	37	#include "blocklayout.h"
	38
	39	#define NFSDBG_FACILITY NFSDBG_PNFS_LD
	40
	41	MODULE_LICENSE("GPL");
	42	MODULE_AUTHOR("Andy Adamson <andros@citi.umich.edu>");
	43	MODULE_DESCRIPTION("The NFSv4.1 pNFS Block layout driver");
	44
fe0a9b74 JR	45	struct dentry *bl_device_pipe;
	46	wait_queue_head_t bl_wq;
	47
155e7524 FI	48	static enum pnfs_try_status
	49	bl_read_pagelist(struct nfs_read_data *rdata)
	50	{
	51	return PNFS_NOT_ATTEMPTED;
	52	}
	53
	54	static enum pnfs_try_status
	55	bl_write_pagelist(struct nfs_write_data *wdata,
	56	int sync)
	57	{
	58	return PNFS_NOT_ATTEMPTED;
	59	}
	60
9e692969	61	/* FIXME - range ignored */
155e7524	62	static void
9e692969	63	release_extents(struct pnfs_block_layout bl, struct pnfs_layout_range range)
155e7524	64	{
9e692969 FI	65	int i;
	66	struct pnfs_block_extent *be;
	67
	68	spin_lock(&bl->bl_ext_lock);
	69	for (i = 0; i < EXTENT_LISTS; i++) {
	70	while (!list_empty(&bl->bl_extents[i])) {
	71	be = list_first_entry(&bl->bl_extents[i],
	72	struct pnfs_block_extent,
	73	be_node);
	74	list_del(&be->be_node);
	75	bl_put_extent(be);
	76	}
	77	}
	78	spin_unlock(&bl->bl_ext_lock);
155e7524 FI	79	}
155e7524 FI	80
155e7524 FI	81	static void
	82	release_inval_marks(struct pnfs_inval_markings *marks)
	83	{
c1c2a4cd FI	84	struct pnfs_inval_tracking pos, temp;
	85
	86	list_for_each_entry_safe(pos, temp, &marks->im_tree.mtt_stub, it_link) {
	87	list_del(&pos->it_link);
	88	kfree(pos);
	89	}
155e7524 FI	90	return;
	91	}
	92
	93	static void bl_free_layout_hdr(struct pnfs_layout_hdr *lo)
	94	{
	95	struct pnfs_block_layout *bl = BLK_LO2EXT(lo);
	96
	97	dprintk("%s enter\n", __func__);
	98	release_extents(bl, NULL);
	99	release_inval_marks(&bl->bl_inval);
	100	kfree(bl);
	101	}
	102
	103	static struct pnfs_layout_hdr bl_alloc_layout_hdr(struct inode inode,
	104	gfp_t gfp_flags)
	105	{
	106	struct pnfs_block_layout *bl;
	107
	108	dprintk("%s enter\n", __func__);
	109	bl = kzalloc(sizeof(*bl), gfp_flags);
	110	if (!bl)
	111	return NULL;
	112	spin_lock_init(&bl->bl_ext_lock);
	113	INIT_LIST_HEAD(&bl->bl_extents[0]);
	114	INIT_LIST_HEAD(&bl->bl_extents[1]);
	115	INIT_LIST_HEAD(&bl->bl_commit);
	116	INIT_LIST_HEAD(&bl->bl_committing);
	117	bl->bl_count = 0;
	118	bl->bl_blocksize = NFS_SERVER(inode)->pnfs_blksize >> SECTOR_SHIFT;
	119	BL_INIT_INVAL_MARKS(&bl->bl_inval, bl->bl_blocksize);
	120	return &bl->bl_layout;
	121	}
	122
a60d2ebd	123	static void bl_free_lseg(struct pnfs_layout_segment *lseg)
155e7524	124	{
a60d2ebd FI	125	dprintk("%s enter\n", __func__);
a60d2ebd FI	126	kfree(lseg);
155e7524 FI	127	}
155e7524 FI	128
a60d2ebd FI	129	/* We pretty much ignore lseg, and store all data layout wide, so we
	130	* can correctly merge.
	131	*/
	132	static struct pnfs_layout_segment bl_alloc_lseg(struct pnfs_layout_hdr lo,
	133	struct nfs4_layoutget_res *lgr,
	134	gfp_t gfp_flags)
155e7524	135	{
a60d2ebd FI	136	struct pnfs_layout_segment *lseg;
	137	int status;
	138
	139	dprintk("%s enter\n", __func__);
	140	lseg = kzalloc(sizeof(*lseg), gfp_flags);
	141	if (!lseg)
	142	return ERR_PTR(-ENOMEM);
	143	status = nfs4_blk_process_layoutget(lo, lgr, gfp_flags);
	144	if (status) {
	145	/* We don't want to call the full-blown bl_free_lseg,
	146	* since on error extents were not touched.
	147	*/
	148	kfree(lseg);
	149	return ERR_PTR(status);
	150	}
	151	return lseg;
155e7524 FI	152	}
	153
	154	static void
	155	bl_encode_layoutcommit(struct pnfs_layout_hdr lo, struct xdr_stream xdr,
	156	const struct nfs4_layoutcommit_args *arg)
	157	{
	158	}
	159
	160	static void
	161	bl_cleanup_layoutcommit(struct nfs4_layoutcommit_data *lcdata)
	162	{
	163	}
	164
2f9fd182 FI	165	static void free_blk_mountid(struct block_mount_id *mid)
	166	{
	167	if (mid) {
	168	struct pnfs_block_dev *dev;
	169	spin_lock(&mid->bm_lock);
	170	while (!list_empty(&mid->bm_devlist)) {
	171	dev = list_first_entry(&mid->bm_devlist,
	172	struct pnfs_block_dev,
	173	bm_node);
	174	list_del(&dev->bm_node);
	175	bl_free_block_dev(dev);
	176	}
	177	spin_unlock(&mid->bm_lock);
	178	kfree(mid);
	179	}
	180	}
	181
	182	/* This is mostly copied from the filelayout's get_device_info function.
	183	* It seems much of this should be at the generic pnfs level.
	184	*/
	185	static struct pnfs_block_dev *
	186	nfs4_blk_get_deviceinfo(struct nfs_server server, const struct nfs_fh fh,
	187	struct nfs4_deviceid *d_id)
	188	{
	189	struct pnfs_device *dev;
	190	struct pnfs_block_dev *rv = NULL;
	191	u32 max_resp_sz;
	192	int max_pages;
	193	struct page **pages = NULL;
	194	int i, rc;
	195
	196	/*
	197	* Use the session max response size as the basis for setting
	198	* GETDEVICEINFO's maxcount
	199	*/
	200	max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
	201	max_pages = max_resp_sz >> PAGE_SHIFT;
	202	dprintk("%s max_resp_sz %u max_pages %d\n",
	203	__func__, max_resp_sz, max_pages);
	204
	205	dev = kmalloc(sizeof(*dev), GFP_NOFS);
	206	if (!dev) {
	207	dprintk("%s kmalloc failed\n", __func__);
	208	return NULL;
	209	}
	210
	211	pages = kzalloc(max_pages * sizeof(struct page *), GFP_NOFS);
	212	if (pages == NULL) {
	213	kfree(dev);
	214	return NULL;
	215	}
	216	for (i = 0; i < max_pages; i++) {
	217	pages[i] = alloc_page(GFP_NOFS);
	218	if (!pages[i])
	219	goto out_free;
	220	}
	221
	222	memcpy(&dev->dev_id, d_id, sizeof(*d_id));
	223	dev->layout_type = LAYOUT_BLOCK_VOLUME;
	224	dev->pages = pages;
	225	dev->pgbase = 0;
	226	dev->pglen = PAGE_SIZE * max_pages;
	227	dev->mincount = 0;
	228
229	dprintk("%s: dev_id: %s\n", __func__, dev->dev_id.data);
230	rc = nfs4_proc_getdeviceinfo(server, dev);
231	dprintk("%s getdevice info returns %d\n", __func__, rc);
232	if (rc)
233	goto out_free;
234
235	rv = nfs4_blk_decode_device(server, dev);
236	out_free:
237	for (i = 0; i < max_pages; i++)
238	__free_page(pages[i]);
239	kfree(pages);
240	kfree(dev);
241	return rv;
242	}
243
155e7524 FI	244	static int
	245	bl_set_layoutdriver(struct nfs_server server, const struct nfs_fh fh)
	246	{
2f9fd182 FI	247	struct block_mount_id *b_mt_id = NULL;
	248	struct pnfs_devicelist *dlist = NULL;
	249	struct pnfs_block_dev *bdev;
	250	LIST_HEAD(block_disklist);
	251	int status = 0, i;
	252
155e7524	253	dprintk("%s enter\n", __func__);
2f9fd182 FI	254
	255	if (server->pnfs_blksize == 0) {
	256	dprintk("%s Server did not return blksize\n", __func__);
	257	return -EINVAL;
	258	}
	259	b_mt_id = kzalloc(sizeof(struct block_mount_id), GFP_NOFS);
	260	if (!b_mt_id) {
	261	status = -ENOMEM;
	262	goto out_error;
	263	}
	264	/* Initialize nfs4 block layout mount id */
	265	spin_lock_init(&b_mt_id->bm_lock);
	266	INIT_LIST_HEAD(&b_mt_id->bm_devlist);
	267
	268	dlist = kmalloc(sizeof(struct pnfs_devicelist), GFP_NOFS);
	269	if (!dlist) {
	270	status = -ENOMEM;
	271	goto out_error;
	272	}
	273	dlist->eof = 0;
	274	while (!dlist->eof) {
	275	status = nfs4_proc_getdevicelist(server, fh, dlist);
	276	if (status)
	277	goto out_error;
	278	dprintk("%s GETDEVICELIST numdevs=%i, eof=%i\n",
	279	__func__, dlist->num_devs, dlist->eof);
	280	for (i = 0; i < dlist->num_devs; i++) {
	281	bdev = nfs4_blk_get_deviceinfo(server, fh,
	282	&dlist->dev_id[i]);
	283	if (!bdev) {
	284	status = -ENODEV;
	285	goto out_error;
	286	}
	287	spin_lock(&b_mt_id->bm_lock);
	288	list_add(&bdev->bm_node, &b_mt_id->bm_devlist);
	289	spin_unlock(&b_mt_id->bm_lock);
	290	}
	291	}
	292	dprintk("%s SUCCESS\n", __func__);
	293	server->pnfs_ld_data = b_mt_id;
	294
	295	out_return:
	296	kfree(dlist);
	297	return status;
	298
	299	out_error:
	300	free_blk_mountid(b_mt_id);
	301	goto out_return;
155e7524 FI	302	}
	303
	304	static int
	305	bl_clear_layoutdriver(struct nfs_server *server)
	306	{
2f9fd182 FI	307	struct block_mount_id *b_mt_id = server->pnfs_ld_data;
2f9fd182 FI	308
155e7524	309	dprintk("%s enter\n", __func__);
2f9fd182 FI	310	free_blk_mountid(b_mt_id);
2f9fd182 FI	311	dprintk("%s RETURNS\n", __func__);
155e7524 FI	312	return 0;
	313	}
	314
e9643fe8 BH	315	static const struct nfs_pageio_ops bl_pg_read_ops = {
	316	.pg_init = pnfs_generic_pg_init_read,
	317	.pg_test = pnfs_generic_pg_test,
	318	.pg_doio = pnfs_generic_pg_readpages,
	319	};
	320
	321	static const struct nfs_pageio_ops bl_pg_write_ops = {
	322	.pg_init = pnfs_generic_pg_init_write,
	323	.pg_test = pnfs_generic_pg_test,
	324	.pg_doio = pnfs_generic_pg_writepages,
	325	};
	326
155e7524 FI	327	static struct pnfs_layoutdriver_type blocklayout_type = {
	328	.id = LAYOUT_BLOCK_VOLUME,
	329	.name = "LAYOUT_BLOCK_VOLUME",
	330	.read_pagelist = bl_read_pagelist,
	331	.write_pagelist = bl_write_pagelist,
	332	.alloc_layout_hdr = bl_alloc_layout_hdr,
	333	.free_layout_hdr = bl_free_layout_hdr,
	334	.alloc_lseg = bl_alloc_lseg,
	335	.free_lseg = bl_free_lseg,
	336	.encode_layoutcommit = bl_encode_layoutcommit,
	337	.cleanup_layoutcommit = bl_cleanup_layoutcommit,
	338	.set_layoutdriver = bl_set_layoutdriver,
	339	.clear_layoutdriver = bl_clear_layoutdriver,
e9643fe8 BH	340	.pg_read_ops = &bl_pg_read_ops,
e9643fe8 BH	341	.pg_write_ops = &bl_pg_write_ops,
155e7524 FI	342	};
155e7524 FI	343
fe0a9b74 JR	344	static const struct rpc_pipe_ops bl_upcall_ops = {
	345	.upcall = bl_pipe_upcall,
	346	.downcall = bl_pipe_downcall,
	347	.destroy_msg = bl_pipe_destroy_msg,
	348	};
	349
155e7524 FI	350	static int __init nfs4blocklayout_init(void)
155e7524 FI	351	{
fe0a9b74 JR	352	struct vfsmount *mnt;
fe0a9b74 JR	353	struct path path;
155e7524 FI	354	int ret;
	355
	356	dprintk("%s: NFSv4 Block Layout Driver Registering...\n", __func__);
	357
	358	ret = pnfs_register_layoutdriver(&blocklayout_type);
fe0a9b74 JR	359	if (ret)
	360	goto out;
	361
	362	init_waitqueue_head(&bl_wq);
	363
	364	mnt = rpc_get_mount();
	365	if (IS_ERR(mnt)) {
	366	ret = PTR_ERR(mnt);
	367	goto out_remove;
	368	}
	369
	370	ret = vfs_path_lookup(mnt->mnt_root,
	371	mnt,
	372	NFS_PIPE_DIRNAME, 0, &path);
	373	if (ret)
	374	goto out_remove;
	375
	376	bl_device_pipe = rpc_mkpipe(path.dentry, "blocklayout", NULL,
	377	&bl_upcall_ops, 0);
	378	if (IS_ERR(bl_device_pipe)) {
	379	ret = PTR_ERR(bl_device_pipe);
	380	goto out_remove;
	381	}
	382	out:
	383	return ret;
	384
	385	out_remove:
	386	pnfs_unregister_layoutdriver(&blocklayout_type);
155e7524 FI	387	return ret;
	388	}
	389
	390	static void __exit nfs4blocklayout_exit(void)
	391	{
	392	dprintk("%s: NFSv4 Block Layout Driver Unregistering...\n",
	393	__func__);
	394
	395	pnfs_unregister_layoutdriver(&blocklayout_type);
fe0a9b74	396	rpc_unlink(bl_device_pipe);
155e7524 FI	397	}
	398
	399	MODULE_ALIAS("nfs-layouttype4-3");
	400
	401	module_init(nfs4blocklayout_init);
	402	module_exit(nfs4blocklayout_exit);