2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2005-11-01 20:58:39 -07:00
|
|
|
* Copyright (c) 2000-2005 Silicon Graphics, Inc.
|
|
|
|
* All Rights Reserved.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License as
|
2005-04-16 16:20:36 -06:00
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* 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.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-11-01 20:58:39 -07:00
|
|
|
* 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
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#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
|
|
|
|
*/
|
|
|
|
|
2006-01-10 21:39:08 -07:00
|
|
|
#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;
|
|
|
|
|
2010-06-23 19:49:12 -06:00
|
|
|
#define XBF_READ (1 << 0) /* buffer intended for reading from device */
|
|
|
|
#define XBF_WRITE (1 << 1) /* buffer intended for writing to device */
|
2011-07-08 06:36:32 -06:00
|
|
|
#define XBF_READ_AHEAD (1 << 2) /* asynchronous read-ahead */
|
|
|
|
#define XBF_MAPPED (1 << 3) /* buffer mapped (b_addr valid) */
|
2010-06-23 19:49:12 -06:00
|
|
|
#define XBF_ASYNC (1 << 4) /* initiator will not wait for completion */
|
|
|
|
#define XBF_DONE (1 << 5) /* all pages in the buffer uptodate */
|
|
|
|
#define XBF_DELWRI (1 << 6) /* buffer has dirty pages */
|
|
|
|
#define XBF_STALE (1 << 7) /* buffer has been staled, do not find it */
|
2011-07-08 06:36:32 -06:00
|
|
|
|
|
|
|
/* I/O hints for the BIO layer */
|
|
|
|
#define XBF_SYNCIO (1 << 10)/* treat this buffer as synchronous I/O */
|
|
|
|
#define XBF_FUA (1 << 11)/* force cache write through mode */
|
|
|
|
#define XBF_FLUSH (1 << 12)/* flush the disk cache before a write */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-06-23 19:49:12 -06:00
|
|
|
/* flags used only as arguments to access routines */
|
2011-07-08 06:36:32 -06:00
|
|
|
#define XBF_LOCK (1 << 15)/* lock requested */
|
|
|
|
#define XBF_TRYLOCK (1 << 16)/* lock requested, but do not wait */
|
|
|
|
#define XBF_DONT_BLOCK (1 << 17)/* do not block in current thread */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-06-23 19:49:12 -06:00
|
|
|
/* flags used only internally */
|
2011-07-08 06:36:32 -06:00
|
|
|
#define _XBF_PAGES (1 << 20)/* backed by refcounted pages */
|
|
|
|
#define _XBF_KMEM (1 << 21)/* backed by heap memory */
|
|
|
|
#define _XBF_DELWRI_Q (1 << 22)/* buffer on delwri queue */
|
2008-05-19 00:34:42 -06:00
|
|
|
|
2010-06-23 19:49:12 -06:00
|
|
|
typedef unsigned int xfs_buf_flags_t;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-12-14 16:14:59 -07:00
|
|
|
#define XFS_BUF_FLAGS \
|
|
|
|
{ XBF_READ, "READ" }, \
|
|
|
|
{ XBF_WRITE, "WRITE" }, \
|
2011-07-08 06:36:32 -06:00
|
|
|
{ XBF_READ_AHEAD, "READ_AHEAD" }, \
|
2009-12-14 16:14:59 -07:00
|
|
|
{ XBF_MAPPED, "MAPPED" }, \
|
|
|
|
{ XBF_ASYNC, "ASYNC" }, \
|
|
|
|
{ XBF_DONE, "DONE" }, \
|
|
|
|
{ XBF_DELWRI, "DELWRI" }, \
|
|
|
|
{ XBF_STALE, "STALE" }, \
|
2011-07-08 06:36:32 -06:00
|
|
|
{ XBF_SYNCIO, "SYNCIO" }, \
|
|
|
|
{ XBF_FUA, "FUA" }, \
|
|
|
|
{ XBF_FLUSH, "FLUSH" }, \
|
2009-12-14 16:14:59 -07:00
|
|
|
{ XBF_LOCK, "LOCK" }, /* should never be set */\
|
|
|
|
{ XBF_TRYLOCK, "TRYLOCK" }, /* ditto */\
|
|
|
|
{ XBF_DONT_BLOCK, "DONT_BLOCK" }, /* ditto */\
|
|
|
|
{ _XBF_PAGES, "PAGES" }, \
|
2011-03-25 16:16:45 -06:00
|
|
|
{ _XBF_KMEM, "KMEM" }, \
|
|
|
|
{ _XBF_DELWRI_Q, "DELWRI_Q" }
|
2009-12-14 16:14:59 -07:00
|
|
|
|
2006-01-10 21:39:08 -07:00
|
|
|
typedef enum {
|
2007-02-10 00:34:49 -07:00
|
|
|
XBT_FORCE_SLEEP = 0,
|
|
|
|
XBT_FORCE_FLUSH = 1,
|
2006-01-10 21:39:08 -07:00
|
|
|
} xfs_buftarg_flags_t;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
typedef struct xfs_buftarg {
|
2006-01-10 21:39:08 -07:00
|
|
|
dev_t bt_dev;
|
|
|
|
struct block_device *bt_bdev;
|
2011-03-25 16:16:45 -06:00
|
|
|
struct backing_dev_info *bt_bdi;
|
2010-09-21 18:47:20 -06:00
|
|
|
struct xfs_mount *bt_mount;
|
2006-01-10 21:39:08 -07:00
|
|
|
unsigned int bt_bsize;
|
|
|
|
unsigned int bt_sshift;
|
|
|
|
size_t bt_smask;
|
|
|
|
|
2006-01-10 21:37:58 -07:00
|
|
|
/* per device delwri queue */
|
|
|
|
struct task_struct *bt_task;
|
|
|
|
struct list_head bt_delwrite_queue;
|
|
|
|
spinlock_t bt_delwrite_lock;
|
2006-01-10 21:39:08 -07:00
|
|
|
unsigned long bt_flags;
|
2010-11-29 23:27:57 -07:00
|
|
|
|
|
|
|
/* LRU control structures */
|
|
|
|
struct shrinker bt_shrinker;
|
2010-12-01 22:30:55 -07:00
|
|
|
struct list_head bt_lru;
|
|
|
|
spinlock_t bt_lru_lock;
|
|
|
|
unsigned int bt_lru_nr;
|
2005-04-16 16:20:36 -06:00
|
|
|
} xfs_buftarg_t;
|
|
|
|
|
|
|
|
struct xfs_buf;
|
2006-01-10 21:39:08 -07:00
|
|
|
typedef void (*xfs_buf_iodone_t)(struct xfs_buf *);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-01-10 21:39:08 -07:00
|
|
|
#define XB_PAGES 2
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
typedef struct xfs_buf {
|
2010-09-24 03:59:15 -06:00
|
|
|
/*
|
|
|
|
* first cacheline holds all the fields needed for an uncontended cache
|
|
|
|
* hit to be fully processed. The semaphore straddles the cacheline
|
|
|
|
* boundary, but the counter and lock sits on the first cacheline,
|
|
|
|
* which is the only bit that is touched if we hit the semaphore
|
|
|
|
* fast-path on locking.
|
|
|
|
*/
|
|
|
|
struct rb_node b_rbnode; /* rbtree node */
|
|
|
|
xfs_off_t b_file_offset; /* offset in file */
|
|
|
|
size_t b_buffer_length;/* size of buffer in bytes */
|
|
|
|
atomic_t b_hold; /* reference count */
|
2010-12-01 22:30:55 -07:00
|
|
|
atomic_t b_lru_ref; /* lru reclaim ref count */
|
2010-09-24 03:59:15 -06:00
|
|
|
xfs_buf_flags_t b_flags; /* status flags */
|
2006-01-10 21:39:08 -07:00
|
|
|
struct semaphore b_sema; /* semaphore for lockables */
|
2010-09-24 03:59:15 -06:00
|
|
|
|
2010-12-01 22:30:55 -07:00
|
|
|
struct list_head b_lru; /* lru list */
|
2006-01-10 21:39:08 -07:00
|
|
|
wait_queue_head_t b_waiters; /* unpin waiters */
|
|
|
|
struct list_head b_list;
|
2010-09-24 03:59:04 -06:00
|
|
|
struct xfs_perag *b_pag; /* contains rbtree root */
|
2006-01-10 21:39:08 -07:00
|
|
|
xfs_buftarg_t *b_target; /* buffer target (device) */
|
|
|
|
xfs_daddr_t b_bn; /* block number for I/O */
|
|
|
|
size_t b_count_desired;/* desired transfer size */
|
|
|
|
void *b_addr; /* virtual address of buffer */
|
|
|
|
struct work_struct b_iodone_work;
|
|
|
|
xfs_buf_iodone_t b_iodone; /* I/O completion function */
|
2008-08-13 00:36:11 -06:00
|
|
|
struct completion b_iowait; /* queue for I/O waiters */
|
2006-01-10 21:39:08 -07:00
|
|
|
void *b_fspriv;
|
2011-07-13 05:43:49 -06:00
|
|
|
struct xfs_trans *b_transp;
|
2006-01-10 21:39:08 -07:00
|
|
|
struct page **b_pages; /* array of page pointers */
|
|
|
|
struct page *b_page_array[XB_PAGES]; /* inline pages */
|
2010-09-24 03:59:15 -06:00
|
|
|
unsigned long b_queuetime; /* time buffer was queued */
|
|
|
|
atomic_t b_pin_count; /* pin count */
|
|
|
|
atomic_t b_io_remaining; /* #outstanding I/O requests */
|
|
|
|
unsigned int b_page_count; /* size of page array */
|
|
|
|
unsigned int b_offset; /* page offset in first page */
|
|
|
|
unsigned short b_error; /* error code on I/O */
|
2006-01-10 21:39:08 -07:00
|
|
|
#ifdef XFS_BUF_LOCK_TRACKING
|
|
|
|
int b_last_holder;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
} xfs_buf_t;
|
|
|
|
|
|
|
|
|
|
|
|
/* Finding and Reading Buffers */
|
2006-01-10 21:39:08 -07:00
|
|
|
extern xfs_buf_t *_xfs_buf_find(xfs_buftarg_t *, xfs_off_t, size_t,
|
|
|
|
xfs_buf_flags_t, xfs_buf_t *);
|
2005-04-16 16:20:36 -06:00
|
|
|
#define xfs_incore(buftarg,blkno,len,lockit) \
|
2006-01-10 21:39:08 -07:00
|
|
|
_xfs_buf_find(buftarg, blkno ,len, lockit, NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-24 11:02:23 -07:00
|
|
|
extern xfs_buf_t *xfs_buf_get(xfs_buftarg_t *, xfs_off_t, size_t,
|
2006-01-10 21:39:08 -07:00
|
|
|
xfs_buf_flags_t);
|
2009-11-24 11:02:23 -07:00
|
|
|
extern xfs_buf_t *xfs_buf_read(xfs_buftarg_t *, xfs_off_t, size_t,
|
2006-01-10 21:39:08 -07:00
|
|
|
xfs_buf_flags_t);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-01-10 21:39:08 -07:00
|
|
|
extern xfs_buf_t *xfs_buf_get_empty(size_t, xfs_buftarg_t *);
|
2011-04-21 03:34:27 -06:00
|
|
|
extern void xfs_buf_set_empty(struct xfs_buf *bp, size_t len);
|
2010-09-24 04:07:47 -06:00
|
|
|
extern xfs_buf_t *xfs_buf_get_uncached(struct xfs_buftarg *, size_t, int);
|
2006-01-10 21:39:08 -07:00
|
|
|
extern int xfs_buf_associate_memory(xfs_buf_t *, void *, size_t);
|
|
|
|
extern void xfs_buf_hold(xfs_buf_t *);
|
2010-10-06 12:41:18 -06:00
|
|
|
extern void xfs_buf_readahead(xfs_buftarg_t *, xfs_off_t, size_t);
|
2010-09-24 05:58:31 -06:00
|
|
|
struct xfs_buf *xfs_buf_read_uncached(struct xfs_mount *mp,
|
|
|
|
struct xfs_buftarg *target,
|
|
|
|
xfs_daddr_t daddr, size_t length, int flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Releasing Buffers */
|
2006-01-10 21:39:08 -07:00
|
|
|
extern void xfs_buf_free(xfs_buf_t *);
|
|
|
|
extern void xfs_buf_rele(xfs_buf_t *);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Locking and Unlocking Buffers */
|
2011-07-08 06:36:19 -06:00
|
|
|
extern int xfs_buf_trylock(xfs_buf_t *);
|
2006-01-10 21:39:08 -07:00
|
|
|
extern void xfs_buf_lock(xfs_buf_t *);
|
|
|
|
extern void xfs_buf_unlock(xfs_buf_t *);
|
2011-07-08 06:36:19 -06:00
|
|
|
#define xfs_buf_islocked(bp) \
|
|
|
|
((bp)->b_sema.count <= 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Buffer Read and Write Routines */
|
2011-08-23 02:28:07 -06:00
|
|
|
extern int xfs_bwrite(struct xfs_buf *bp);
|
2010-01-13 15:17:56 -07:00
|
|
|
|
|
|
|
extern void xfsbdstrat(struct xfs_mount *, struct xfs_buf *);
|
|
|
|
extern int xfs_bdstrat_cb(struct xfs_buf *);
|
|
|
|
|
2006-01-10 21:39:08 -07:00
|
|
|
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 *);
|
2010-01-19 16:47:39 -07:00
|
|
|
extern void xfs_buf_iomove(xfs_buf_t *, size_t, size_t, void *,
|
2006-01-10 21:39:08 -07:00
|
|
|
xfs_buf_rw_t);
|
2010-10-06 12:41:18 -06:00
|
|
|
#define xfs_buf_zero(bp, off, len) \
|
|
|
|
xfs_buf_iomove((bp), (off), (len), NULL, XBRW_ZERO)
|
2006-01-10 21:39:08 -07:00
|
|
|
|
|
|
|
static inline int xfs_buf_geterror(xfs_buf_t *bp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-01-10 21:39:08 -07:00
|
|
|
return bp ? bp->b_error : ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Buffer Utility Routines */
|
2006-01-10 21:39:08 -07:00
|
|
|
extern xfs_caddr_t xfs_buf_offset(xfs_buf_t *, size_t);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Delayed Write Buffer Routines */
|
2011-08-23 02:28:06 -06:00
|
|
|
extern void xfs_buf_delwri_queue(struct xfs_buf *);
|
|
|
|
extern void xfs_buf_delwri_dequeue(struct xfs_buf *);
|
|
|
|
extern void xfs_buf_delwri_promote(struct xfs_buf *);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Buffer Daemon Setup Routines */
|
2006-01-10 21:39:08 -07:00
|
|
|
extern int xfs_buf_init(void);
|
|
|
|
extern void xfs_buf_terminate(void);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-07-22 17:40:46 -06:00
|
|
|
static inline const char *
|
|
|
|
xfs_buf_target_name(struct xfs_buftarg *target)
|
|
|
|
{
|
|
|
|
static char __b[BDEVNAME_SIZE];
|
|
|
|
|
|
|
|
return bdevname(target->bt_bdev, __b);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
2011-07-08 06:36:32 -06:00
|
|
|
#define XFS_BUF_ZEROFLAGS(bp) \
|
|
|
|
((bp)->b_flags &= ~(XBF_READ|XBF_WRITE|XBF_ASYNC|XBF_DELWRI| \
|
|
|
|
XBF_SYNCIO|XBF_FUA|XBF_FLUSH))
|
2006-01-10 21:39:08 -07:00
|
|
|
|
2010-12-01 22:30:55 -07:00
|
|
|
void xfs_buf_stale(struct xfs_buf *bp);
|
|
|
|
#define XFS_BUF_STALE(bp) xfs_buf_stale(bp);
|
2010-01-19 02:56:44 -07:00
|
|
|
#define XFS_BUF_UNSTALE(bp) ((bp)->b_flags &= ~XBF_STALE)
|
|
|
|
#define XFS_BUF_ISSTALE(bp) ((bp)->b_flags & XBF_STALE)
|
2006-01-10 21:39:08 -07:00
|
|
|
#define XFS_BUF_SUPER_STALE(bp) do { \
|
|
|
|
XFS_BUF_STALE(bp); \
|
|
|
|
xfs_buf_delwri_dequeue(bp); \
|
|
|
|
XFS_BUF_DONE(bp); \
|
|
|
|
} while (0)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-01-10 21:39:08 -07:00
|
|
|
#define XFS_BUF_ISDELAYWRITE(bp) ((bp)->b_flags & XBF_DELWRI)
|
|
|
|
|
|
|
|
#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_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_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_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))
|
|
|
|
|
2010-12-01 22:31:13 -07:00
|
|
|
static inline void
|
|
|
|
xfs_buf_set_ref(
|
|
|
|
struct xfs_buf *bp,
|
|
|
|
int lru_ref)
|
|
|
|
{
|
|
|
|
atomic_set(&bp->b_lru_ref, lru_ref);
|
|
|
|
}
|
|
|
|
#define XFS_BUF_SET_VTYPE_REF(bp, type, ref) xfs_buf_set_ref(bp, ref)
|
2006-01-10 21:39:08 -07:00
|
|
|
#define XFS_BUF_SET_VTYPE(bp, type) do { } while (0)
|
|
|
|
|
2011-07-22 17:40:27 -06:00
|
|
|
static inline int xfs_buf_ispinned(struct xfs_buf *bp)
|
|
|
|
{
|
|
|
|
return atomic_read(&bp->b_pin_count);
|
|
|
|
}
|
2006-01-10 21:39:08 -07:00
|
|
|
|
2008-08-13 00:36:11 -06:00
|
|
|
#define XFS_BUF_FINISH_IOWAIT(bp) complete(&bp->b_iowait);
|
2006-01-10 21:39:08 -07:00
|
|
|
|
|
|
|
static inline void xfs_buf_relse(xfs_buf_t *bp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
xfs: fix error handling for synchronous writes
If we get an IO error on a synchronous superblock write, we attach an
error release function to it so that when the last reference goes away
the release function is called and the buffer is invalidated and
unlocked. The buffer is left locked until the release function is
called so that other concurrent users of the buffer will be locked out
until the buffer error is fully processed.
Unfortunately, for the superblock buffer the filesyetm itself holds a
reference to the buffer which prevents the reference count from
dropping to zero and the release function being called. As a result,
once an IO error occurs on a sync write, the buffer will never be
unlocked and all future attempts to lock the buffer will hang.
To make matters worse, this problems is not unique to such buffers;
if there is a concurrent _xfs_buf_find() running, the lookup will grab
a reference to the buffer and then wait on the buffer lock, preventing
the reference count from ever falling to zero and hence unlocking the
buffer.
As such, the whole b_relse function implementation is broken because it
cannot rely on the buffer reference count falling to zero to unlock the
errored buffer. The synchronous write error path is the only path that
uses this callback - it is used to ensure that the synchronous waiter
gets the buffer error before the error state is cleared from the buffer
by the release function.
Given that the only sychronous buffer writes now go through xfs_bwrite
and the error path in question can only occur for a write of a dirty,
logged buffer, we can move most of the b_relse processing to happen
inline in xfs_buf_iodone_callbacks, just like a normal I/O completion.
In addition to that we make sure the error is not cleared in
xfs_buf_iodone_callbacks, so that xfs_bwrite can reliably check it.
Given that xfs_bwrite keeps the buffer locked until it has waited for
it and checked the error this allows to reliably propagate the error
to the caller, and make sure that the buffer is reliably unlocked.
Given that xfs_buf_iodone_callbacks was the only instance of the
b_relse callback we can remove it entirely.
Based on earlier patches by Dave Chinner and Ajeet Yadav.
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reported-by: Ajeet Yadav <ajeet.yadav.77@gmail.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Alex Elder <aelder@sgi.com>
2011-01-07 06:02:23 -07:00
|
|
|
xfs_buf_unlock(bp);
|
2006-01-10 21:39:08 -07:00
|
|
|
xfs_buf_rele(bp);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handling of buftargs.
|
|
|
|
*/
|
2010-09-21 18:47:20 -06:00
|
|
|
extern xfs_buftarg_t *xfs_alloc_buftarg(struct xfs_mount *,
|
|
|
|
struct block_device *, int, const char *);
|
2009-03-03 12:48:37 -07:00
|
|
|
extern void xfs_free_buftarg(struct xfs_mount *, struct xfs_buftarg *);
|
2005-04-16 16:20:36 -06:00
|
|
|
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);
|
2010-02-01 16:13:42 -07:00
|
|
|
|
2007-05-07 21:49:59 -06:00
|
|
|
#ifdef CONFIG_KDB_MODULES
|
|
|
|
extern struct list_head *xfs_get_buftarg_list(void);
|
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-01-10 21:39:08 -07:00
|
|
|
#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)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#endif /* __XFS_BUF_H__ */
|