/* * Copyright (c) 2000-2004 Silicon Graphics, Inc.  All Rights Reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it would be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * * Further, this software is distributed without any warranty that it is * free of the rightful claim of any third person regarding infringement * or the like.  Any license provided herein, whether implied or * otherwise, applies only to this software file.  Patent licenses, if * any, provided herein do not apply to combinations of this program with * other software, or any other product whatsoever. * * You should have received a copy of the GNU General Public License along * with this program; if not, write the Free Software Foundation, Inc., 59 * Temple Place - Suite 330, Boston MA 02111-1307, USA. * * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy, * Mountain View, CA  94043, or: * * http://www.sgi.com * * For further information regarding this notice, see: * * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/ *//* * Written by Steve Lord, Jim Mostek, Russell Cattelan at SGI */#ifndef __XFS_BUF_H__#define __XFS_BUF_H__#include <linux/config.h>#include <linux/list.h>#include <linux/types.h>#include <linux/spinlock.h>#include <asm/system.h>#include <linux/mm.h>#include <linux/fs.h>#include <linux/buffer_head.h>#include <linux/uio.h>/* *	Base types */#define XFS_BUF_DADDR_NULL ((xfs_daddr_t) (-1LL))#define page_buf_ctob(pp)	((pp) * PAGE_CACHE_SIZE)#define page_buf_btoc(dd)	(((dd) + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT)#define page_buf_btoct(dd)	((dd) >> PAGE_CACHE_SHIFT)#define page_buf_poff(aa)	((aa) & ~PAGE_CACHE_MASK)typedef enum page_buf_rw_e {	PBRW_READ = 1,			/* transfer into target memory */	PBRW_WRITE = 2,			/* transfer from target memory */	PBRW_ZERO = 3			/* Zero target memory */} page_buf_rw_t;typedef enum page_buf_flags_e {		/* pb_flags values */	PBF_READ = (1 << 0),	/* buffer intended for reading from device */	PBF_WRITE = (1 << 1),	/* buffer intended for writing to device   */	PBF_MAPPED = (1 << 2),  /* buffer mapped (pb_addr valid)           */	PBF_PARTIAL = (1 << 3), /* buffer partially read                   */	PBF_ASYNC = (1 << 4),   /* initiator will not wait for completion  */	PBF_NONE = (1 << 5),    /* buffer not read at all                  */	PBF_DELWRI = (1 << 6),  /* buffer has dirty pages                  */	PBF_STALE = (1 << 7),	/* buffer has been staled, do not find it  */	PBF_FS_MANAGED = (1 << 8),  /* filesystem controls freeing memory  */	PBF_FS_DATAIOD = (1 << 9),  /* schedule IO completion on fs datad  */	PBF_FORCEIO = (1 << 10),    /* ignore any cache state		   */	PBF_FLUSH = (1 << 11),	    /* flush disk write cache		   */	PBF_READ_AHEAD = (1 << 12), /* asynchronous read-ahead		   */	/* flags used only as arguments to access routines */	PBF_LOCK = (1 << 14),       /* lock requested			   */	PBF_TRYLOCK = (1 << 15),    /* lock requested, but do not wait	   */	PBF_DONT_BLOCK = (1 << 16), /* do not block in current thread	   */	/* flags used only internally */	_PBF_PAGE_CACHE = (1 << 17),/* backed by pagecache		   */	_PBF_KMEM_ALLOC = (1 << 18),/* backed by kmem_alloc()		   */	_PBF_RUN_QUEUES = (1 << 19),/* run block device task queue	   */} page_buf_flags_t;#define PBF_UPDATE (PBF_READ | PBF_WRITE)#define PBF_NOT_DONE(pb) (((pb)->pb_flags & (PBF_PARTIAL|PBF_NONE)) != 0)#define PBF_DONE(pb) (((pb)->pb_flags & (PBF_PARTIAL|PBF_NONE)) == 0)typedef struct xfs_buftarg {	dev_t			pbr_dev;	struct block_device	*pbr_bdev;	struct address_space	*pbr_mapping;	unsigned int		pbr_bsize;	unsigned int		pbr_sshift;	size_t			pbr_smask;} xfs_buftarg_t;/* *	xfs_buf_t:  Buffer structure for page cache-based buffers * * This buffer structure is used by the page cache buffer management routines * to refer to an assembly of pages forming a logical buffer.  The actual * I/O is performed with buffer_head or bio structures, as required by drivers, * for drivers which do not understand this structure.  The buffer structure is * used on temporary basis only, and discarded when released. * * The real data storage is recorded in the page cache.  Metadata is * hashed to the inode for the block device on which the file system resides. * File data is hashed to the inode for the file.  Pages which are only * partially filled with data have bits set in their block_map entry * to indicate which disk blocks in the page are not valid. */struct xfs_buf;typedef void (*page_buf_iodone_t)(struct xfs_buf *);			/* call-back function on I/O completion */typedef void (*page_buf_relse_t)(struct xfs_buf *);			/* call-back function on I/O completion */typedef int (*page_buf_bdstrat_t)(struct xfs_buf *);#define PB_PAGES	4typedef struct xfs_buf {	struct semaphore	pb_sema;	/* semaphore for lockables  */	unsigned long		pb_queuetime;	/* time buffer was queued   */	atomic_t		pb_pin_count;	/* pin count		    */	wait_queue_head_t	pb_waiters;	/* unpin waiters	    */	struct list_head	pb_list;	page_buf_flags_t	pb_flags;	/* status flags */	struct list_head	pb_hash_list;	xfs_buftarg_t		*pb_target;	/* logical object */	atomic_t		pb_hold;	/* reference count */	xfs_daddr_t		pb_bn;		/* block number for I/O */	loff_t			pb_file_offset;	/* offset in file */	size_t			pb_buffer_length; /* size of buffer in bytes */	size_t			pb_count_desired; /* desired transfer size */	void			*pb_addr;	/* virtual address of buffer */	struct work_struct	pb_iodone_work;	atomic_t		pb_io_remaining;/* #outstanding I/O requests */	page_buf_iodone_t	pb_iodone;	/* I/O completion function */	page_buf_relse_t	pb_relse;	/* releasing function */	page_buf_bdstrat_t	pb_strat;	/* pre-write function */	struct semaphore	pb_iodonesema;	/* Semaphore for I/O waiters */	void			*pb_fspriv;	void			*pb_fspriv2;	void			*pb_fspriv3;	unsigned short		pb_error;	/* error code on I/O */	unsigned short		pb_page_count;	/* size of page array */	unsigned short		pb_offset;	/* page offset in first page */	unsigned char		pb_locked;	/* page array is locked */	unsigned char		pb_hash_index;	/* hash table index	*/	struct page		**pb_pages;	/* array of page pointers */	struct page		*pb_page_array[PB_PAGES]; /* inline pages */#ifdef PAGEBUF_LOCK_TRACKING	int			pb_last_holder;#endif} xfs_buf_t;/* Finding and Reading Buffers */extern xfs_buf_t *pagebuf_find(	/* find buffer for block if	*/					/* the block is in memory	*/		xfs_buftarg_t *,	/* inode for block		*/		loff_t,			/* starting offset of range	*/		size_t,			/* length of range		*/		page_buf_flags_t);	/* PBF_LOCK			*/extern xfs_buf_t *pagebuf_get(		/* allocate a buffer		*/		xfs_buftarg_t *,	/* inode for buffer		*/		loff_t,			/* starting offset of range     */		size_t,			/* length of range              */		page_buf_flags_t);	/* PBF_LOCK, PBF_READ,		*/					/* PBF_ASYNC			*/extern xfs_buf_t *pagebuf_lookup(		xfs_buftarg_t *,		loff_t,			/* starting offset of range	*/		size_t,			/* length of range		*/		page_buf_flags_t);	/* PBF_READ, PBF_WRITE,		*/					/* PBF_FORCEIO, 		*/extern xfs_buf_t *pagebuf_get_empty(	/* allocate pagebuf struct with	*/					/*  no memory or disk address	*/		size_t len,		xfs_buftarg_t *);	/* mount point "fake" inode	*/extern xfs_buf_t *pagebuf_get_no_daddr(/* allocate pagebuf struct	*/					/* without disk address		*/		size_t len,		xfs_buftarg_t *);	/* mount point "fake" inode	*/extern int pagebuf_associate_memory(		xfs_buf_t *,		void *,		size_t);extern void pagebuf_hold(		/* increment reference count	*/		xfs_buf_t *);		/* buffer to hold		*/extern void pagebuf_readahead(		/* read ahead into cache	*/		xfs_buftarg_t  *,	/* target for buffer (or NULL)	*/		loff_t,			/* starting offset of range     */		size_t,			/* length of range              */		page_buf_flags_t);	/* additional read flags	*//* Releasing Buffers */extern void pagebuf_free(		/* deallocate a buffer		*/		xfs_buf_t *);		/* buffer to deallocate		*/extern void pagebuf_rele(		/* release hold on a buffer	*/		xfs_buf_t *);		/* buffer to release		*//* Locking and Unlocking Buffers */extern int pagebuf_cond_lock(		/* lock buffer, if not locked	*/					/* (returns -EBUSY if locked)	*/		xfs_buf_t *);		/* buffer to lock		*/extern int pagebuf_lock_value(		/* return count on lock		*/		xfs_buf_t *);          /* buffer to check              */extern int pagebuf_lock(		/* lock buffer                  */		xfs_buf_t *);          /* buffer to lock               */extern void pagebuf_unlock(		/* unlock buffer		*/		xfs_buf_t *);		/* buffer to unlock		*//* Buffer Read and Write Routines */extern void pagebuf_iodone(		/* mark buffer I/O complete	*/		xfs_buf_t *,		/* buffer to mark		*/		int,			/* use data/log helper thread.	*/		int);			/* run completion locally, or in					 * a helper thread.		*/extern void pagebuf_ioerror(		/* mark buffer in error	(or not) */		xfs_buf_t *,		/* buffer to mark		*/		int);			/* error to store (0 if none)	*/extern int pagebuf_iostart(		/* start I/O on a buffer	*/		xfs_buf_t *,		/* buffer to start		*/		page_buf_flags_t);	/* PBF_LOCK, PBF_ASYNC,		*/					/* PBF_READ, PBF_WRITE,		*/					/* PBF_DELWRI			*/extern int pagebuf_iorequest(		/* start real I/O		*/		xfs_buf_t *);		/* buffer to convey to device	*/extern int pagebuf_iowait(		/* wait for buffer I/O done	*/		xfs_buf_t *);		/* buffer to wait on		*/extern void pagebuf_iomove(		/* move data in/out of pagebuf	*/		xfs_buf_t *,		/* buffer to manipulate		*/		size_t,			/* starting buffer offset	*/		size_t,			/* length in buffer		*/		caddr_t,		/* data pointer			*/		page_buf_rw_t);		/* direction			*/static inline int pagebuf_iostrategy(xfs_buf_t *pb){	return pb->pb_strat ? pb->pb_strat(pb) : pagebuf_iorequest(pb);}static inline int pagebuf_geterror(xfs_buf_t *pb){	return pb ? pb->pb_error : ENOMEM;}/* Buffer Utility Routines */extern caddr_t pagebuf_offset(		/* pointer at offset in buffer	*/		xfs_buf_t *,		/* buffer to offset into	*/		size_t);		/* offset			*//* Pinning Buffer Storage in Memory */extern void pagebuf_pin(		/* pin buffer in memory		*/		xfs_buf_t *);		/* buffer to pin		*/extern void pagebuf_unpin(		/* unpin buffered data		*/		xfs_buf_t *);		/* buffer to unpin		*/