[linux-2.6-block.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)
{
	dprintk("%s enter\n", __func__);
	encode_pnfs_block_layoutupdate(BLK_LO2EXT(lo), xdr, arg);
}

static void
bl_cleanup_layoutcommit(struct nfs4_layoutcommit_data *lcdata)
{
	struct pnfs_layout_hdr *lo = NFS_I(lcdata->args.inode)->layout;

	dprintk("%s enter\n", __func__);
	clean_pnfs_block_layoutupdate(BLK_LO2EXT(lo), &lcdata->args, lcdata->res.status);
}

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	{
90ace12a FI	158	dprintk("%s enter\n", __func__);
90ace12a FI	159	encode_pnfs_block_layoutupdate(BLK_LO2EXT(lo), xdr, arg);
155e7524 FI	160	}
	161
	162	static void
	163	bl_cleanup_layoutcommit(struct nfs4_layoutcommit_data *lcdata)
	164	{
b2be7811 FI	165	struct pnfs_layout_hdr *lo = NFS_I(lcdata->args.inode)->layout;
	166
	167	dprintk("%s enter\n", __func__);
	168	clean_pnfs_block_layoutupdate(BLK_LO2EXT(lo), &lcdata->args, lcdata->res.status);
155e7524 FI	169	}
155e7524 FI	170
2f9fd182 FI	171	static void free_blk_mountid(struct block_mount_id *mid)
	172	{
	173	if (mid) {
	174	struct pnfs_block_dev *dev;
	175	spin_lock(&mid->bm_lock);
	176	while (!list_empty(&mid->bm_devlist)) {
	177	dev = list_first_entry(&mid->bm_devlist,
	178	struct pnfs_block_dev,
	179	bm_node);
	180	list_del(&dev->bm_node);
	181	bl_free_block_dev(dev);
	182	}
	183	spin_unlock(&mid->bm_lock);
	184	kfree(mid);
	185	}
	186	}
	187
	188	/* This is mostly copied from the filelayout's get_device_info function.
	189	* It seems much of this should be at the generic pnfs level.
	190	*/
	191	static struct pnfs_block_dev *
	192	nfs4_blk_get_deviceinfo(struct nfs_server server, const struct nfs_fh fh,
	193	struct nfs4_deviceid *d_id)
	194	{
	195	struct pnfs_device *dev;
	196	struct pnfs_block_dev *rv = NULL;
	197	u32 max_resp_sz;
	198	int max_pages;
	199	struct page **pages = NULL;
	200	int i, rc;
	201
	202	/*
	203	* Use the session max response size as the basis for setting
	204	* GETDEVICEINFO's maxcount
	205	*/
	206	max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
	207	max_pages = max_resp_sz >> PAGE_SHIFT;
	208	dprintk("%s max_resp_sz %u max_pages %d\n",
	209	__func__, max_resp_sz, max_pages);
	210
	211	dev = kmalloc(sizeof(*dev), GFP_NOFS);
	212	if (!dev) {
	213	dprintk("%s kmalloc failed\n", __func__);
	214	return NULL;
	215	}
	216
	217	pages = kzalloc(max_pages * sizeof(struct page *), GFP_NOFS);
	218	if (pages == NULL) {
	219	kfree(dev);
	220	return NULL;
	221	}
	222	for (i = 0; i < max_pages; i++) {
	223	pages[i] = alloc_page(GFP_NOFS);
	224	if (!pages[i])
	225	goto out_free;
	226	}
	227
	228	memcpy(&dev->dev_id, d_id, sizeof(*d_id));
	229	dev->layout_type = LAYOUT_BLOCK_VOLUME;
	230	dev->pages = pages;
	231	dev->pgbase = 0;
	232	dev->pglen = PAGE_SIZE * max_pages;
	233	dev->mincount = 0;
	234
235	dprintk("%s: dev_id: %s\n", __func__, dev->dev_id.data);
236	rc = nfs4_proc_getdeviceinfo(server, dev);
237	dprintk("%s getdevice info returns %d\n", __func__, rc);
238	if (rc)
239	goto out_free;
240
241	rv = nfs4_blk_decode_device(server, dev);
242	out_free:
243	for (i = 0; i < max_pages; i++)
244	__free_page(pages[i]);
245	kfree(pages);
246	kfree(dev);
247	return rv;
248	}
249
155e7524 FI	250	static int
	251	bl_set_layoutdriver(struct nfs_server server, const struct nfs_fh fh)
	252	{
2f9fd182 FI	253	struct block_mount_id *b_mt_id = NULL;
	254	struct pnfs_devicelist *dlist = NULL;
	255	struct pnfs_block_dev *bdev;
	256	LIST_HEAD(block_disklist);
	257	int status = 0, i;
	258
155e7524	259	dprintk("%s enter\n", __func__);
2f9fd182 FI	260
	261	if (server->pnfs_blksize == 0) {
	262	dprintk("%s Server did not return blksize\n", __func__);
	263	return -EINVAL;
	264	}
	265	b_mt_id = kzalloc(sizeof(struct block_mount_id), GFP_NOFS);
	266	if (!b_mt_id) {
	267	status = -ENOMEM;
	268	goto out_error;
	269	}
	270	/* Initialize nfs4 block layout mount id */
	271	spin_lock_init(&b_mt_id->bm_lock);
	272	INIT_LIST_HEAD(&b_mt_id->bm_devlist);
	273
	274	dlist = kmalloc(sizeof(struct pnfs_devicelist), GFP_NOFS);
	275	if (!dlist) {
	276	status = -ENOMEM;
	277	goto out_error;
	278	}
	279	dlist->eof = 0;
	280	while (!dlist->eof) {
	281	status = nfs4_proc_getdevicelist(server, fh, dlist);
	282	if (status)
	283	goto out_error;
	284	dprintk("%s GETDEVICELIST numdevs=%i, eof=%i\n",
	285	__func__, dlist->num_devs, dlist->eof);
	286	for (i = 0; i < dlist->num_devs; i++) {
	287	bdev = nfs4_blk_get_deviceinfo(server, fh,
	288	&dlist->dev_id[i]);
	289	if (!bdev) {
	290	status = -ENODEV;
	291	goto out_error;
	292	}
	293	spin_lock(&b_mt_id->bm_lock);
	294	list_add(&bdev->bm_node, &b_mt_id->bm_devlist);
	295	spin_unlock(&b_mt_id->bm_lock);
	296	}
	297	}
	298	dprintk("%s SUCCESS\n", __func__);
	299	server->pnfs_ld_data = b_mt_id;
	300
	301	out_return:
	302	kfree(dlist);
	303	return status;
	304
	305	out_error:
	306	free_blk_mountid(b_mt_id);
	307	goto out_return;
155e7524 FI	308	}
	309
	310	static int
	311	bl_clear_layoutdriver(struct nfs_server *server)
	312	{
2f9fd182 FI	313	struct block_mount_id *b_mt_id = server->pnfs_ld_data;
2f9fd182 FI	314
155e7524	315	dprintk("%s enter\n", __func__);
2f9fd182 FI	316	free_blk_mountid(b_mt_id);
2f9fd182 FI	317	dprintk("%s RETURNS\n", __func__);
155e7524 FI	318	return 0;
	319	}
	320
e9643fe8 BH	321	static const struct nfs_pageio_ops bl_pg_read_ops = {
	322	.pg_init = pnfs_generic_pg_init_read,
	323	.pg_test = pnfs_generic_pg_test,
	324	.pg_doio = pnfs_generic_pg_readpages,
	325	};
	326
	327	static const struct nfs_pageio_ops bl_pg_write_ops = {
	328	.pg_init = pnfs_generic_pg_init_write,
	329	.pg_test = pnfs_generic_pg_test,
	330	.pg_doio = pnfs_generic_pg_writepages,
	331	};
	332
155e7524 FI	333	static struct pnfs_layoutdriver_type blocklayout_type = {
	334	.id = LAYOUT_BLOCK_VOLUME,
	335	.name = "LAYOUT_BLOCK_VOLUME",
	336	.read_pagelist = bl_read_pagelist,
	337	.write_pagelist = bl_write_pagelist,
	338	.alloc_layout_hdr = bl_alloc_layout_hdr,
	339	.free_layout_hdr = bl_free_layout_hdr,
	340	.alloc_lseg = bl_alloc_lseg,
	341	.free_lseg = bl_free_lseg,
	342	.encode_layoutcommit = bl_encode_layoutcommit,
	343	.cleanup_layoutcommit = bl_cleanup_layoutcommit,
	344	.set_layoutdriver = bl_set_layoutdriver,
	345	.clear_layoutdriver = bl_clear_layoutdriver,
e9643fe8 BH	346	.pg_read_ops = &bl_pg_read_ops,
e9643fe8 BH	347	.pg_write_ops = &bl_pg_write_ops,
155e7524 FI	348	};
155e7524 FI	349
fe0a9b74 JR	350	static const struct rpc_pipe_ops bl_upcall_ops = {
	351	.upcall = bl_pipe_upcall,
	352	.downcall = bl_pipe_downcall,
	353	.destroy_msg = bl_pipe_destroy_msg,
	354	};
	355
155e7524 FI	356	static int __init nfs4blocklayout_init(void)
155e7524 FI	357	{
fe0a9b74 JR	358	struct vfsmount *mnt;
fe0a9b74 JR	359	struct path path;
155e7524 FI	360	int ret;
	361
	362	dprintk("%s: NFSv4 Block Layout Driver Registering...\n", __func__);
	363
	364	ret = pnfs_register_layoutdriver(&blocklayout_type);
fe0a9b74 JR	365	if (ret)
	366	goto out;
	367
	368	init_waitqueue_head(&bl_wq);
	369
	370	mnt = rpc_get_mount();
	371	if (IS_ERR(mnt)) {
	372	ret = PTR_ERR(mnt);
	373	goto out_remove;
	374	}
	375
	376	ret = vfs_path_lookup(mnt->mnt_root,
	377	mnt,
	378	NFS_PIPE_DIRNAME, 0, &path);
	379	if (ret)
	380	goto out_remove;
	381
	382	bl_device_pipe = rpc_mkpipe(path.dentry, "blocklayout", NULL,
	383	&bl_upcall_ops, 0);
	384	if (IS_ERR(bl_device_pipe)) {
	385	ret = PTR_ERR(bl_device_pipe);
	386	goto out_remove;
	387	}
	388	out:
	389	return ret;
	390
	391	out_remove:
	392	pnfs_unregister_layoutdriver(&blocklayout_type);
155e7524 FI	393	return ret;
	394	}
	395
	396	static void __exit nfs4blocklayout_exit(void)
	397	{
	398	dprintk("%s: NFSv4 Block Layout Driver Unregistering...\n",
	399	__func__);
	400
	401	pnfs_unregister_layoutdriver(&blocklayout_type);
fe0a9b74	402	rpc_unlink(bl_device_pipe);
155e7524 FI	403	}
	404
	405	MODULE_ALIAS("nfs-layouttype4-3");
	406
	407	module_init(nfs4blocklayout_init);
	408	module_exit(nfs4blocklayout_exit);