[deliverable/linux.git] / fs / nfs / blocklayout / blocklayout.h

/*
 *  linux/fs/nfs/blocklayout/blocklayout.h
 *
 *  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.
 */
#ifndef FS_NFS_NFS4BLOCKLAYOUT_H
#define FS_NFS_NFS4BLOCKLAYOUT_H

#include <linux/device-mapper.h>
#include <linux/nfs_fs.h>
#include <linux/sunrpc/rpc_pipe_fs.h>

#include "../nfs4_fs.h"
#include "../pnfs.h"
#include "../netns.h"

#define PAGE_CACHE_SECTORS (PAGE_SIZE >> SECTOR_SHIFT)
#define PAGE_CACHE_SECTOR_SHIFT (PAGE_SHIFT - SECTOR_SHIFT)
#define SECTOR_SIZE (1 << SECTOR_SHIFT)

struct pnfs_block_dev;

#define PNFS_BLOCK_MAX_UUIDS	4
#define PNFS_BLOCK_MAX_DEVICES	64

/*
 * Random upper cap for the uuid length to avoid unbounded allocation.
 * Not actually limited by the protocol.
 */
#define PNFS_BLOCK_UUID_LEN	128

struct pnfs_block_volume {
	enum pnfs_block_volume_type	type;
	union {
		struct {
			int		len;
			int		nr_sigs;
			struct {
				u64		offset;
				u32		sig_len;
				u8		sig[PNFS_BLOCK_UUID_LEN];
			} sigs[PNFS_BLOCK_MAX_UUIDS];
		} simple;
		struct {
			u64		start;
			u64		len;
			u32		volume;
		} slice;
		struct {
			u32		volumes_count;
			u32		volumes[PNFS_BLOCK_MAX_DEVICES];
		} concat;
		struct {
			u64		chunk_size;
			u32		volumes_count;
			u32		volumes[PNFS_BLOCK_MAX_DEVICES];
		} stripe;
		struct {
			enum scsi_code_set		code_set;
			enum scsi_designator_type	designator_type;
			int				designator_len;
			u8				designator[256];
			u64				pr_key;
		} scsi;
	};
};

struct pnfs_block_dev_map {
	sector_t			start;
	sector_t			len;

	sector_t			disk_offset;
	struct block_device		*bdev;
};

struct pnfs_block_dev {
	struct nfs4_deviceid_node	node;

	u64				start;
	u64				len;

	u32				nr_children;
	struct pnfs_block_dev		*children;
	u64				chunk_size;

	struct block_device		*bdev;
	u64				disk_offset;

	u64				pr_key;
	bool				pr_registered;

	bool (*map)(struct pnfs_block_dev *dev, u64 offset,
			struct pnfs_block_dev_map *map);
};

/* sector_t fields are all in 512-byte sectors */
struct pnfs_block_extent {
	union {
		struct rb_node	be_node;
		struct list_head be_list;
	};
	struct nfs4_deviceid_node *be_device;
	sector_t	be_f_offset;	/* the starting offset in the file */
	sector_t	be_length;	/* the size of the extent */
	sector_t	be_v_offset;	/* the starting offset in the volume */
	enum pnfs_block_extent_state be_state;	/* the state of this extent */
#define EXTENT_WRITTEN		1
#define EXTENT_COMMITTING	2
	unsigned int	be_tag;
};

struct pnfs_block_layout {
	struct pnfs_layout_hdr	bl_layout;
	struct rb_root		bl_ext_rw;
	struct rb_root		bl_ext_ro;
	spinlock_t		bl_ext_lock;   /* Protects list manipulation */
	bool			bl_scsi_layout;
	u64			bl_lwb;
};

static inline struct pnfs_block_layout *
BLK_LO2EXT(struct pnfs_layout_hdr *lo)
{
	return container_of(lo, struct pnfs_block_layout, bl_layout);
}

static inline struct pnfs_block_layout *
BLK_LSEG2EXT(struct pnfs_layout_segment *lseg)
{
	return BLK_LO2EXT(lseg->pls_layout);
}

struct bl_pipe_msg {
	struct rpc_pipe_msg msg;
	wait_queue_head_t *bl_wq;
};

struct bl_msg_hdr {
	u8  type;
	u16 totallen; /* length of entire message, including hdr itself */
};

#define BL_DEVICE_UMOUNT               0x0 /* Umount--delete devices */
#define BL_DEVICE_MOUNT                0x1 /* Mount--create devices*/
#define BL_DEVICE_REQUEST_INIT         0x0 /* Start request */
#define BL_DEVICE_REQUEST_PROC         0x1 /* User level process succeeds */
#define BL_DEVICE_REQUEST_ERR          0x2 /* User level process fails */

/* dev.c */
struct nfs4_deviceid_node *bl_alloc_deviceid_node(struct nfs_server *server,
		struct pnfs_device *pdev, gfp_t gfp_mask);
void bl_free_deviceid_node(struct nfs4_deviceid_node *d);

/* extent_tree.c */
int ext_tree_insert(struct pnfs_block_layout *bl,
		struct pnfs_block_extent *new);
int ext_tree_remove(struct pnfs_block_layout *bl, bool rw, sector_t start,
		sector_t end);
int ext_tree_mark_written(struct pnfs_block_layout *bl, sector_t start,
		sector_t len, u64 lwb);
bool ext_tree_lookup(struct pnfs_block_layout *bl, sector_t isect,
		struct pnfs_block_extent *ret, bool rw);
int ext_tree_prepare_commit(struct nfs4_layoutcommit_args *arg);
void ext_tree_mark_committed(struct nfs4_layoutcommit_args *arg, int status);

/* rpc_pipefs.c */
dev_t bl_resolve_deviceid(struct nfs_server *server,
		struct pnfs_block_volume *b, gfp_t gfp_mask);
int __init bl_init_pipefs(void);
void bl_cleanup_pipefs(void);

#endif /* FS_NFS_NFS4BLOCKLAYOUT_H */
Commit	Line	Data
155e7524 FI	1	/*
	2	* linux/fs/nfs/blocklayout/blocklayout.h
	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	#ifndef FS_NFS_NFS4BLOCKLAYOUT_H
	33	#define FS_NFS_NFS4BLOCKLAYOUT_H
	34
	35	#include <linux/device-mapper.h>
	36	#include <linux/nfs_fs.h>
fe0a9b74 JR	37	#include <linux/sunrpc/rpc_pipe_fs.h>
fe0a9b74 JR	38
694e096f	39	#include "../nfs4_fs.h"
155e7524	40	#include "../pnfs.h"
9e2e74db	41	#include "../netns.h"
155e7524	42
09cbfeaf KS	43	#define PAGE_CACHE_SECTORS (PAGE_SIZE >> SECTOR_SHIFT)
09cbfeaf KS	44	#define PAGE_CACHE_SECTOR_SHIFT (PAGE_SHIFT - SECTOR_SHIFT)
fe6e1e8d	45	#define SECTOR_SIZE (1 << SECTOR_SHIFT)
c1c2a4cd	46
5c83746a CH	47	struct pnfs_block_dev;
5c83746a CH	48
5c83746a CH	49	#define PNFS_BLOCK_MAX_UUIDS 4
	50	#define PNFS_BLOCK_MAX_DEVICES 64
	51
	52	/*
	53	* Random upper cap for the uuid length to avoid unbounded allocation.
	54	* Not actually limited by the protocol.
	55	*/
	56	#define PNFS_BLOCK_UUID_LEN 128
	57
5c83746a CH	58	struct pnfs_block_volume {
	59	enum pnfs_block_volume_type type;
	60	union {
	61	struct {
	62	int len;
	63	int nr_sigs;
	64	struct {
	65	u64 offset;
	66	u32 sig_len;
	67	u8 sig[PNFS_BLOCK_UUID_LEN];
	68	} sigs[PNFS_BLOCK_MAX_UUIDS];
	69	} simple;
	70	struct {
	71	u64 start;
	72	u64 len;
	73	u32 volume;
	74	} slice;
	75	struct {
	76	u32 volumes_count;
	77	u32 volumes[PNFS_BLOCK_MAX_DEVICES];
	78	} concat;
	79	struct {
	80	u64 chunk_size;
	81	u32 volumes_count;
	82	u32 volumes[PNFS_BLOCK_MAX_DEVICES];
	83	} stripe;
d9186c03 CH	84	struct {
	85	enum scsi_code_set code_set;
	86	enum scsi_designator_type designator_type;
	87	int designator_len;
	88	u8 designator[256];
	89	u64 pr_key;
	90	} scsi;
5c83746a CH	91	};
	92	};
	93
	94	struct pnfs_block_dev_map {
	95	sector_t start;
	96	sector_t len;
	97
	98	sector_t disk_offset;
	99	struct block_device *bdev;
	100	};
	101
fe0a9b74	102	struct pnfs_block_dev {
5c83746a CH	103	struct nfs4_deviceid_node node;
	104
	105	u64 start;
	106	u64 len;
	107
	108	u32 nr_children;
	109	struct pnfs_block_dev *children;
	110	u64 chunk_size;
	111
	112	struct block_device *bdev;
	113	u64 disk_offset;
	114
d9186c03 CH	115	u64 pr_key;
	116	bool pr_registered;
	117
5c83746a CH	118	bool (map)(struct pnfs_block_dev dev, u64 offset,
5c83746a CH	119	struct pnfs_block_dev_map *map);
fe0a9b74 JR	120	};
fe0a9b74 JR	121
155e7524 FI	122	/* sector_t fields are all in 512-byte sectors */
155e7524 FI	123	struct pnfs_block_extent {
8067253c CH	124	union {
	125	struct rb_node be_node;
	126	struct list_head be_list;
	127	};
20d655d6	128	struct nfs4_deviceid_node *be_device;
155e7524 FI	129	sector_t be_f_offset; /* the starting offset in the file */
	130	sector_t be_length; /* the size of the extent */
	131	sector_t be_v_offset; /* the starting offset in the volume */
8bb28975	132	enum pnfs_block_extent_state be_state; /* the state of this extent */
8067253c CH	133	#define EXTENT_WRITTEN 1
	134	#define EXTENT_COMMITTING 2
	135	unsigned int be_tag;
90ace12a FI	136	};
90ace12a FI	137
155e7524	138	struct pnfs_block_layout {
8067253c CH	139	struct pnfs_layout_hdr bl_layout;
	140	struct rb_root bl_ext_rw;
	141	struct rb_root bl_ext_ro;
155e7524	142	spinlock_t bl_ext_lock; /* Protects list manipulation */
d9186c03	143	bool bl_scsi_layout;
41963c10	144	u64 bl_lwb;
155e7524 FI	145	};
155e7524 FI	146
2f9fd182 FI	147	static inline struct pnfs_block_layout *
2f9fd182 FI	148	BLK_LO2EXT(struct pnfs_layout_hdr *lo)
155e7524 FI	149	{
	150	return container_of(lo, struct pnfs_block_layout, bl_layout);
	151	}
	152
a60d2ebd FI	153	static inline struct pnfs_block_layout *
	154	BLK_LSEG2EXT(struct pnfs_layout_segment *lseg)
	155	{
	156	return BLK_LO2EXT(lseg->pls_layout);
	157	}
	158
5ffaf855 SK	159	struct bl_pipe_msg {
	160	struct rpc_pipe_msg msg;
	161	wait_queue_head_t *bl_wq;
	162	};
	163
fe0a9b74 JR	164	struct bl_msg_hdr {
	165	u8 type;
	166	u16 totallen; /* length of entire message, including hdr itself */
	167	};
	168
fe0a9b74 JR	169	#define BL_DEVICE_UMOUNT 0x0 /* Umount--delete devices */
	170	#define BL_DEVICE_MOUNT 0x1 /* Mount--create devices*/
	171	#define BL_DEVICE_REQUEST_INIT 0x0 /* Start request */
	172	#define BL_DEVICE_REQUEST_PROC 0x1 /* User level process succeeds */
	173	#define BL_DEVICE_REQUEST_ERR 0x2 /* User level process fails */
	174
5c83746a CH	175	/* dev.c */
	176	struct nfs4_deviceid_node bl_alloc_deviceid_node(struct nfs_server server,
	177	struct pnfs_device *pdev, gfp_t gfp_mask);
	178	void bl_free_deviceid_node(struct nfs4_deviceid_node *d);
	179
8067253c CH	180	/* extent_tree.c */
	181	int ext_tree_insert(struct pnfs_block_layout *bl,
	182	struct pnfs_block_extent *new);
	183	int ext_tree_remove(struct pnfs_block_layout *bl, bool rw, sector_t start,
	184	sector_t end);
	185	int ext_tree_mark_written(struct pnfs_block_layout *bl, sector_t start,
41963c10	186	sector_t len, u64 lwb);
8067253c CH	187	bool ext_tree_lookup(struct pnfs_block_layout *bl, sector_t isect,
8067253c CH	188	struct pnfs_block_extent *ret, bool rw);
34dc93c2 CH	189	int ext_tree_prepare_commit(struct nfs4_layoutcommit_args *arg);
34dc93c2 CH	190	void ext_tree_mark_committed(struct nfs4_layoutcommit_args *arg, int status);
03341d2c	191
871760ce	192	/* rpc_pipefs.c */
5c83746a CH	193	dev_t bl_resolve_deviceid(struct nfs_server *server,
5c83746a CH	194	struct pnfs_block_volume *b, gfp_t gfp_mask);
871760ce	195	int __init bl_init_pipefs(void);
d9186c03	196	void bl_cleanup_pipefs(void);
871760ce	197
155e7524	198	#endif /* FS_NFS_NFS4BLOCKLAYOUT_H */