xfs_buf.h 15 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2 3
 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
 * All Rights Reserved.
Linus Torvalds's avatar
Linus Torvalds committed
4
 *
5 6
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
Linus Torvalds's avatar
Linus Torvalds committed
7 8
 * published by the Free Software Foundation.
 *
9 10 11 12
 * 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.  See the
 * GNU General Public License for more details.
Linus Torvalds's avatar
Linus Torvalds committed
13
 *
14 15 16
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
Linus Torvalds's avatar
Linus Torvalds committed
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
 */
#ifndef __XFS_BUF_H__
#define __XFS_BUF_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
 */

34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
#define XFS_BUF_DADDR_NULL	((xfs_daddr_t) (-1LL))

#define xfs_buf_ctob(pp)	((pp) * PAGE_CACHE_SIZE)
#define xfs_buf_btoc(dd)	(((dd) + PAGE_CACHE_SIZE-1) >> PAGE_CACHE_SHIFT)
#define xfs_buf_btoct(dd)	((dd) >> PAGE_CACHE_SHIFT)
#define xfs_buf_poff(aa)	((aa) & ~PAGE_CACHE_MASK)

typedef enum {
	XBRW_READ = 1,			/* transfer into target memory */
	XBRW_WRITE = 2,			/* transfer from target memory */
	XBRW_ZERO = 3,			/* Zero target memory */
} xfs_buf_rw_t;

typedef enum {
	XBF_READ = (1 << 0),	/* buffer intended for reading from device */
	XBF_WRITE = (1 << 1),	/* buffer intended for writing to device   */
	XBF_MAPPED = (1 << 2),  /* buffer mapped (b_addr valid)            */
	XBF_ASYNC = (1 << 4),   /* initiator will not wait for completion  */
	XBF_DONE = (1 << 5),    /* all pages in the buffer uptodate	   */
	XBF_DELWRI = (1 << 6),  /* buffer has dirty pages                  */
	XBF_STALE = (1 << 7),	/* buffer has been staled, do not find it  */
	XBF_FS_MANAGED = (1 << 8),  /* filesystem controls freeing memory  */
 	XBF_ORDERED = (1 << 11),    /* use ordered writes		   */
	XBF_READ_AHEAD = (1 << 12), /* asynchronous read-ahead		   */
58
	XBF_LOG_BUFFER = (1 << 13), /* this is a buffer used for the log   */
Linus Torvalds's avatar
Linus Torvalds committed
59 60

	/* flags used only as arguments to access routines */
61 62 63
	XBF_LOCK = (1 << 14),       /* lock requested			   */
	XBF_TRYLOCK = (1 << 15),    /* lock requested, but do not wait	   */
	XBF_DONT_BLOCK = (1 << 16), /* do not block in current thread	   */
Linus Torvalds's avatar
Linus Torvalds committed
64 65

	/* flags used only internally */
66
	_XBF_PAGE_CACHE = (1 << 17),/* backed by pagecache		   */
67
	_XBF_PAGES = (1 << 18),	    /* backed by refcounted pages	   */
68 69
	_XBF_RUN_QUEUES = (1 << 19),/* run block device task queue	   */
	_XBF_DELWRI_Q = (1 << 21),   /* buffer on delwri queue		   */
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88

	/*
	 * Special flag for supporting metadata blocks smaller than a FSB.
	 *
	 * In this case we can have multiple xfs_buf_t on a single page and
	 * need to lock out concurrent xfs_buf_t readers as they only
	 * serialise access to the buffer.
	 *
	 * If the FSB size >= PAGE_CACHE_SIZE case, we have no serialisation
	 * between reads of the page. Hence we can have one thread read the
	 * page and modify it, but then race with another thread that thinks
	 * the page is not up-to-date and hence reads it again.
	 *
	 * The result is that the first modifcation to the page is lost.
	 * This sort of AGF/AGI reading race can happen when unlinking inodes
	 * that require truncation and results in the AGI unlinked list
	 * modifications being lost.
	 */
	_XBF_PAGE_LOCKED = (1 << 22),
89 90 91 92 93 94 95 96

	/*
	 * If we try a barrier write, but it fails we have to communicate
	 * this to the upper layers.  Unfortunately b_error gets overwritten
	 * when the buffer is re-issued so we have to add another flag to
	 * keep this information.
	 */
	_XFS_BARRIER_FAILED = (1 << 23),
97
} xfs_buf_flags_t;
Linus Torvalds's avatar
Linus Torvalds committed
98

99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
#define XFS_BUF_FLAGS \
	{ XBF_READ,		"READ" }, \
	{ XBF_WRITE,		"WRITE" }, \
	{ XBF_MAPPED,		"MAPPED" }, \
	{ XBF_ASYNC,		"ASYNC" }, \
	{ XBF_DONE,		"DONE" }, \
	{ XBF_DELWRI,		"DELWRI" }, \
	{ XBF_STALE,		"STALE" }, \
	{ XBF_FS_MANAGED,	"FS_MANAGED" }, \
	{ XBF_ORDERED,		"ORDERED" }, \
	{ XBF_READ_AHEAD,	"READ_AHEAD" }, \
	{ XBF_LOCK,		"LOCK" },  	/* should never be set */\
	{ XBF_TRYLOCK,		"TRYLOCK" }, 	/* ditto */\
	{ XBF_DONT_BLOCK,	"DONT_BLOCK" },	/* ditto */\
	{ _XBF_PAGE_CACHE,	"PAGE_CACHE" }, \
	{ _XBF_PAGES,		"PAGES" }, \
	{ _XBF_RUN_QUEUES,	"RUN_QUEUES" }, \
	{ _XBF_DELWRI_Q,	"DELWRI_Q" }, \
	{ _XBF_PAGE_LOCKED,	"PAGE_LOCKED" }, \
	{ _XFS_BARRIER_FAILED,	"BARRIER_FAILED" }


121
typedef enum {
122 123
	XBT_FORCE_SLEEP = 0,
	XBT_FORCE_FLUSH = 1,
124
} xfs_buftarg_flags_t;
Linus Torvalds's avatar
Linus Torvalds committed
125 126 127 128 129 130 131

typedef struct xfs_bufhash {
	struct list_head	bh_list;
	spinlock_t		bh_lock;
} xfs_bufhash_t;

typedef struct xfs_buftarg {
132 133 134 135 136 137 138 139
	dev_t			bt_dev;
	struct block_device	*bt_bdev;
	struct address_space	*bt_mapping;
	unsigned int		bt_bsize;
	unsigned int		bt_sshift;
	size_t			bt_smask;

	/* per device buffer hash table */
Linus Torvalds's avatar
Linus Torvalds committed
140 141 142
	uint			bt_hashmask;
	uint			bt_hashshift;
	xfs_bufhash_t		*bt_hash;
143 144 145 146 147 148

	/* per device delwri queue */
	struct task_struct	*bt_task;
	struct list_head	bt_list;
	struct list_head	bt_delwrite_queue;
	spinlock_t		bt_delwrite_lock;
149
	unsigned long		bt_flags;
Linus Torvalds's avatar
Linus Torvalds committed
150 151 152
} xfs_buftarg_t;

/*
153
 *	xfs_buf_t:  Buffer structure for pagecache-based buffers
Linus Torvalds's avatar
Linus Torvalds committed
154
 *
155 156 157 158 159
 * This buffer structure is used by the pagecache buffer management routines
 * to refer to an assembly of pages forming a logical buffer.
 *
 * The buffer structure is used on a temporary basis only, and discarded when
 * released.  The real data storage is recorded in the pagecache. Buffers are
Linus Torvalds's avatar
Linus Torvalds committed
160 161 162 163
 * hashed to the block device on which the file system resides.
 */

struct xfs_buf;
164 165 166
typedef void (*xfs_buf_iodone_t)(struct xfs_buf *);
typedef void (*xfs_buf_relse_t)(struct xfs_buf *);
typedef int (*xfs_buf_bdstrat_t)(struct xfs_buf *);
Linus Torvalds's avatar
Linus Torvalds committed
167

168
#define XB_PAGES	2
Linus Torvalds's avatar
Linus Torvalds committed
169 170

typedef struct xfs_buf {
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
	struct semaphore	b_sema;		/* semaphore for lockables */
	unsigned long		b_queuetime;	/* time buffer was queued */
	atomic_t		b_pin_count;	/* pin count */
	wait_queue_head_t	b_waiters;	/* unpin waiters */
	struct list_head	b_list;
	xfs_buf_flags_t		b_flags;	/* status flags */
	struct list_head	b_hash_list;	/* hash table list */
	xfs_bufhash_t		*b_hash;	/* hash table list start */
	xfs_buftarg_t		*b_target;	/* buffer target (device) */
	atomic_t		b_hold;		/* reference count */
	xfs_daddr_t		b_bn;		/* block number for I/O */
	xfs_off_t		b_file_offset;	/* offset in file */
	size_t			b_buffer_length;/* size of buffer in bytes */
	size_t			b_count_desired;/* desired transfer size */
	void			*b_addr;	/* virtual address of buffer */
	struct work_struct	b_iodone_work;
	atomic_t		b_io_remaining;	/* #outstanding I/O requests */
	xfs_buf_iodone_t	b_iodone;	/* I/O completion function */
	xfs_buf_relse_t		b_relse;	/* releasing function */
	xfs_buf_bdstrat_t	b_strat;	/* pre-write function */
191
	struct completion	b_iowait;	/* queue for I/O waiters */
192 193
	void			*b_fspriv;
	void			*b_fspriv2;
194
	struct xfs_mount	*b_mount;
195 196 197 198 199 200 201
	unsigned short		b_error;	/* error code on I/O */
	unsigned int		b_page_count;	/* size of page array */
	unsigned int		b_offset;	/* page offset in first page */
	struct page		**b_pages;	/* array of page pointers */
	struct page		*b_page_array[XB_PAGES]; /* inline pages */
#ifdef XFS_BUF_LOCK_TRACKING
	int			b_last_holder;
Linus Torvalds's avatar
Linus Torvalds committed
202 203 204 205 206
#endif
} xfs_buf_t;


/* Finding and Reading Buffers */
207 208
extern xfs_buf_t *_xfs_buf_find(xfs_buftarg_t *, xfs_off_t, size_t,
				xfs_buf_flags_t, xfs_buf_t *);
Linus Torvalds's avatar
Linus Torvalds committed
209
#define xfs_incore(buftarg,blkno,len,lockit) \
210
	_xfs_buf_find(buftarg, blkno ,len, lockit, NULL)
Linus Torvalds's avatar
Linus Torvalds committed
211

212
extern xfs_buf_t *xfs_buf_get(xfs_buftarg_t *, xfs_off_t, size_t,
213
				xfs_buf_flags_t);
214
extern xfs_buf_t *xfs_buf_read(xfs_buftarg_t *, xfs_off_t, size_t,
215
				xfs_buf_flags_t);
Linus Torvalds's avatar
Linus Torvalds committed
216

217 218 219 220 221 222
extern xfs_buf_t *xfs_buf_get_empty(size_t, xfs_buftarg_t *);
extern xfs_buf_t *xfs_buf_get_noaddr(size_t, xfs_buftarg_t *);
extern int xfs_buf_associate_memory(xfs_buf_t *, void *, size_t);
extern void xfs_buf_hold(xfs_buf_t *);
extern void xfs_buf_readahead(xfs_buftarg_t *, xfs_off_t, size_t,
				xfs_buf_flags_t);
Linus Torvalds's avatar
Linus Torvalds committed
223 224

/* Releasing Buffers */
225 226
extern void xfs_buf_free(xfs_buf_t *);
extern void xfs_buf_rele(xfs_buf_t *);
Linus Torvalds's avatar
Linus Torvalds committed
227 228

/* Locking and Unlocking Buffers */
229 230 231 232
extern int xfs_buf_cond_lock(xfs_buf_t *);
extern int xfs_buf_lock_value(xfs_buf_t *);
extern void xfs_buf_lock(xfs_buf_t *);
extern void xfs_buf_unlock(xfs_buf_t *);
Linus Torvalds's avatar
Linus Torvalds committed
233 234

/* Buffer Read and Write Routines */
Christoph Hellwig's avatar
Christoph Hellwig committed
235 236
extern int xfs_bawrite(void *mp, xfs_buf_t *bp);
extern void xfs_bdwrite(void *mp, xfs_buf_t *bp);
237 238 239 240 241 242 243 244
extern void xfs_buf_ioend(xfs_buf_t *,	int);
extern void xfs_buf_ioerror(xfs_buf_t *, int);
extern int xfs_buf_iorequest(xfs_buf_t *);
extern int xfs_buf_iowait(xfs_buf_t *);
extern void xfs_buf_iomove(xfs_buf_t *, size_t, size_t, xfs_caddr_t,
				xfs_buf_rw_t);

static inline int xfs_buf_iostrategy(xfs_buf_t *bp)
Linus Torvalds's avatar
Linus Torvalds committed
245
{
246
	return bp->b_strat ? bp->b_strat(bp) : xfs_buf_iorequest(bp);
Linus Torvalds's avatar
Linus Torvalds committed
247 248
}

249
static inline int xfs_buf_geterror(xfs_buf_t *bp)
Linus Torvalds's avatar
Linus Torvalds committed
250
{
251
	return bp ? bp->b_error : ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
252 253 254
}

/* Buffer Utility Routines */
255
extern xfs_caddr_t xfs_buf_offset(xfs_buf_t *, size_t);
Linus Torvalds's avatar
Linus Torvalds committed
256 257

/* Pinning Buffer Storage in Memory */
258 259 260
extern void xfs_buf_pin(xfs_buf_t *);
extern void xfs_buf_unpin(xfs_buf_t *);
extern int xfs_buf_ispin(xfs_buf_t *);
Linus Torvalds's avatar
Linus Torvalds committed
261 262

/* Delayed Write Buffer Routines */
263
extern void xfs_buf_delwri_dequeue(xfs_buf_t *);
Linus Torvalds's avatar
Linus Torvalds committed
264 265

/* Buffer Daemon Setup Routines */
266 267
extern int xfs_buf_init(void);
extern void xfs_buf_terminate(void);
Linus Torvalds's avatar
Linus Torvalds committed
268

269 270
#define xfs_buf_target_name(target)	\
	({ char __b[BDEVNAME_SIZE]; bdevname((target)->bt_bdev, __b); __b; })
Linus Torvalds's avatar
Linus Torvalds committed
271 272


273 274 275 276 277
#define XFS_B_ASYNC		XBF_ASYNC
#define XFS_B_DELWRI		XBF_DELWRI
#define XFS_B_READ		XBF_READ
#define XFS_B_WRITE		XBF_WRITE
#define XFS_B_STALE		XBF_STALE
Linus Torvalds's avatar
Linus Torvalds committed
278

279 280 281 282
#define XFS_BUF_TRYLOCK		XBF_TRYLOCK
#define XFS_INCORE_TRYLOCK	XBF_TRYLOCK
#define XFS_BUF_LOCK		XBF_LOCK
#define XFS_BUF_MAPPED		XBF_MAPPED
Linus Torvalds's avatar
Linus Torvalds committed
283

284 285 286
#define BUF_BUSY		XBF_DONT_BLOCK

#define XFS_BUF_BFLAGS(bp)	((bp)->b_flags)
287 288
#define XFS_BUF_ZEROFLAGS(bp)	((bp)->b_flags &= \
		~(XBF_READ|XBF_WRITE|XBF_ASYNC|XBF_DELWRI|XBF_ORDERED))
289 290 291 292 293 294 295 296 297

#define XFS_BUF_STALE(bp)	((bp)->b_flags |= XFS_B_STALE)
#define XFS_BUF_UNSTALE(bp)	((bp)->b_flags &= ~XFS_B_STALE)
#define XFS_BUF_ISSTALE(bp)	((bp)->b_flags & XFS_B_STALE)
#define XFS_BUF_SUPER_STALE(bp)	do {				\
					XFS_BUF_STALE(bp);	\
					xfs_buf_delwri_dequeue(bp);	\
					XFS_BUF_DONE(bp);	\
				} while (0)
Linus Torvalds's avatar
Linus Torvalds committed
298

299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
#define XFS_BUF_MANAGE		XBF_FS_MANAGED
#define XFS_BUF_UNMANAGE(bp)	((bp)->b_flags &= ~XBF_FS_MANAGED)

#define XFS_BUF_DELAYWRITE(bp)		((bp)->b_flags |= XBF_DELWRI)
#define XFS_BUF_UNDELAYWRITE(bp)	xfs_buf_delwri_dequeue(bp)
#define XFS_BUF_ISDELAYWRITE(bp)	((bp)->b_flags & XBF_DELWRI)

#define XFS_BUF_ERROR(bp,no)	xfs_buf_ioerror(bp,no)
#define XFS_BUF_GETERROR(bp)	xfs_buf_geterror(bp)
#define XFS_BUF_ISERROR(bp)	(xfs_buf_geterror(bp) ? 1 : 0)

#define XFS_BUF_DONE(bp)	((bp)->b_flags |= XBF_DONE)
#define XFS_BUF_UNDONE(bp)	((bp)->b_flags &= ~XBF_DONE)
#define XFS_BUF_ISDONE(bp)	((bp)->b_flags & XBF_DONE)

#define XFS_BUF_BUSY(bp)	do { } while (0)
#define XFS_BUF_UNBUSY(bp)	do { } while (0)
#define XFS_BUF_ISBUSY(bp)	(1)

#define XFS_BUF_ASYNC(bp)	((bp)->b_flags |= XBF_ASYNC)
#define XFS_BUF_UNASYNC(bp)	((bp)->b_flags &= ~XBF_ASYNC)
#define XFS_BUF_ISASYNC(bp)	((bp)->b_flags & XBF_ASYNC)

#define XFS_BUF_ORDERED(bp)	((bp)->b_flags |= XBF_ORDERED)
#define XFS_BUF_UNORDERED(bp)	((bp)->b_flags &= ~XBF_ORDERED)
#define XFS_BUF_ISORDERED(bp)	((bp)->b_flags & XBF_ORDERED)

#define XFS_BUF_HOLD(bp)	xfs_buf_hold(bp)
#define XFS_BUF_READ(bp)	((bp)->b_flags |= XBF_READ)
#define XFS_BUF_UNREAD(bp)	((bp)->b_flags &= ~XBF_READ)
#define XFS_BUF_ISREAD(bp)	((bp)->b_flags & XBF_READ)

#define XFS_BUF_WRITE(bp)	((bp)->b_flags |= XBF_WRITE)
#define XFS_BUF_UNWRITE(bp)	((bp)->b_flags &= ~XBF_WRITE)
#define XFS_BUF_ISWRITE(bp)	((bp)->b_flags & XBF_WRITE)

#define XFS_BUF_IODONE_FUNC(bp)			((bp)->b_iodone)
#define XFS_BUF_SET_IODONE_FUNC(bp, func)	((bp)->b_iodone = (func))
#define XFS_BUF_CLR_IODONE_FUNC(bp)		((bp)->b_iodone = NULL)
#define XFS_BUF_SET_BDSTRAT_FUNC(bp, func)	((bp)->b_strat = (func))
#define XFS_BUF_CLR_BDSTRAT_FUNC(bp)		((bp)->b_strat = NULL)

#define XFS_BUF_FSPRIVATE(bp, type)		((type)(bp)->b_fspriv)
#define XFS_BUF_SET_FSPRIVATE(bp, val)		((bp)->b_fspriv = (void*)(val))
#define XFS_BUF_FSPRIVATE2(bp, type)		((type)(bp)->b_fspriv2)
#define XFS_BUF_SET_FSPRIVATE2(bp, val)		((bp)->b_fspriv2 = (void*)(val))
#define XFS_BUF_SET_START(bp)			do { } while (0)
#define XFS_BUF_SET_BRELSE_FUNC(bp, func)	((bp)->b_relse = (func))

#define XFS_BUF_PTR(bp)			(xfs_caddr_t)((bp)->b_addr)
#define XFS_BUF_SET_PTR(bp, val, cnt)	xfs_buf_associate_memory(bp, val, cnt)
#define XFS_BUF_ADDR(bp)		((bp)->b_bn)
#define XFS_BUF_SET_ADDR(bp, bno)	((bp)->b_bn = (xfs_daddr_t)(bno))
#define XFS_BUF_OFFSET(bp)		((bp)->b_file_offset)
#define XFS_BUF_SET_OFFSET(bp, off)	((bp)->b_file_offset = (off))
#define XFS_BUF_COUNT(bp)		((bp)->b_count_desired)
#define XFS_BUF_SET_COUNT(bp, cnt)	((bp)->b_count_desired = (cnt))
#define XFS_BUF_SIZE(bp)		((bp)->b_buffer_length)
#define XFS_BUF_SET_SIZE(bp, cnt)	((bp)->b_buffer_length = (cnt))

#define XFS_BUF_SET_VTYPE_REF(bp, type, ref)	do { } while (0)
#define XFS_BUF_SET_VTYPE(bp, type)		do { } while (0)
#define XFS_BUF_SET_REF(bp, ref)		do { } while (0)

#define XFS_BUF_ISPINNED(bp)	xfs_buf_ispin(bp)

#define XFS_BUF_VALUSEMA(bp)	xfs_buf_lock_value(bp)
#define XFS_BUF_CPSEMA(bp)	(xfs_buf_cond_lock(bp) == 0)
#define XFS_BUF_VSEMA(bp)	xfs_buf_unlock(bp)
#define XFS_BUF_PSEMA(bp,x)	xfs_buf_lock(bp)
369
#define XFS_BUF_FINISH_IOWAIT(bp)	complete(&bp->b_iowait);
370 371 372 373 374 375

#define XFS_BUF_SET_TARGET(bp, target)	((bp)->b_target = (target))
#define XFS_BUF_TARGET(bp)		((bp)->b_target)
#define XFS_BUFTARG_NAME(target)	xfs_buf_target_name(target)

static inline void xfs_buf_relse(xfs_buf_t *bp)
Linus Torvalds's avatar
Linus Torvalds committed
376
{
377 378 379
	if (!bp->b_relse)
		xfs_buf_unlock(bp);
	xfs_buf_rele(bp);
Linus Torvalds's avatar
Linus Torvalds committed
380 381
}

382 383 384
#define xfs_bpin(bp)		xfs_buf_pin(bp)
#define xfs_bunpin(bp)		xfs_buf_unpin(bp)
#define xfs_biodone(bp)		xfs_buf_ioend(bp, 0)
Linus Torvalds's avatar
Linus Torvalds committed
385

386 387 388
#define xfs_biomove(bp, off, len, data, rw) \
	    xfs_buf_iomove((bp), (off), (len), (data), \
		((rw) == XFS_B_WRITE) ? XBRW_WRITE : XBRW_READ)
Linus Torvalds's avatar
Linus Torvalds committed
389

390 391
#define xfs_biozero(bp, off, len) \
	    xfs_buf_iomove((bp), (off), (len), NULL, XBRW_ZERO)
Linus Torvalds's avatar
Linus Torvalds committed
392 393


394
static inline int XFS_bwrite(xfs_buf_t *bp)
Linus Torvalds's avatar
Linus Torvalds committed
395
{
396
	int	iowait = (bp->b_flags & XBF_ASYNC) == 0;
Linus Torvalds's avatar
Linus Torvalds committed
397 398 399
	int	error = 0;

	if (!iowait)
400
		bp->b_flags |= _XBF_RUN_QUEUES;
Linus Torvalds's avatar
Linus Torvalds committed
401

402 403
	xfs_buf_delwri_dequeue(bp);
	xfs_buf_iostrategy(bp);
Linus Torvalds's avatar
Linus Torvalds committed
404
	if (iowait) {
405 406
		error = xfs_buf_iowait(bp);
		xfs_buf_relse(bp);
Linus Torvalds's avatar
Linus Torvalds committed
407 408 409 410
	}
	return error;
}

411
#define xfs_iowait(bp)	xfs_buf_iowait(bp)
Linus Torvalds's avatar
Linus Torvalds committed
412 413

#define xfs_baread(target, rablkno, ralen)  \
414
	xfs_buf_readahead((target), (rablkno), (ralen), XBF_DONT_BLOCK)
Linus Torvalds's avatar
Linus Torvalds committed
415 416 417 418 419 420


/*
 *	Handling of buftargs.
 */
extern xfs_buftarg_t *xfs_alloc_buftarg(struct block_device *, int);
421
extern void xfs_free_buftarg(struct xfs_mount *, struct xfs_buftarg *);
Linus Torvalds's avatar
Linus Torvalds committed
422 423 424
extern void xfs_wait_buftarg(xfs_buftarg_t *);
extern int xfs_setsize_buftarg(xfs_buftarg_t *, unsigned int, unsigned int);
extern int xfs_flush_buftarg(xfs_buftarg_t *, int);
425 426 427
#ifdef CONFIG_KDB_MODULES
extern struct list_head *xfs_get_buftarg_list(void);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
428

429 430 431 432 433
#define xfs_getsize_buftarg(buftarg)	block_size((buftarg)->bt_bdev)
#define xfs_readonly_buftarg(buftarg)	bdev_read_only((buftarg)->bt_bdev)

#define xfs_binval(buftarg)		xfs_flush_buftarg(buftarg, 1)
#define XFS_bflush(buftarg)		xfs_flush_buftarg(buftarg, 1)
Linus Torvalds's avatar
Linus Torvalds committed
434 435

#endif	/* __XFS_BUF_H__ */