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 <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 */
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
#define XBF_STALE (1 << 6) /* 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 */
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
#define _XBF_DELWRI_Q (1 << 22)/* buffer on a 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_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
|
|
|
|
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;
|
|
|
|
|
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 */
|
2012-04-22 23:58:50 -06:00
|
|
|
xfs_daddr_t b_bn; /* block number for I/O */
|
2012-04-22 23:58:51 -06:00
|
|
|
int b_length; /* size of buffer in BBs */
|
2010-09-24 03:59:15 -06:00
|
|
|
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) */
|
|
|
|
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 */
|
2012-04-22 23:58:52 -06:00
|
|
|
int b_io_length; /* IO size in BBs */
|
2010-09-24 03:59:15 -06:00
|
|
|
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 */
|
2012-04-22 23:58:49 -06:00
|
|
|
struct xfs_buf *_xfs_buf_find(struct xfs_buftarg *target, xfs_daddr_t blkno,
|
|
|
|
size_t numblks, xfs_buf_flags_t flags,
|
|
|
|
struct xfs_buf *new_bp);
|
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
|
|
|
|
2012-04-22 23:58:49 -06:00
|
|
|
struct xfs_buf *xfs_buf_get(struct xfs_buftarg *target, xfs_daddr_t blkno,
|
|
|
|
size_t numblks, xfs_buf_flags_t flags);
|
|
|
|
struct xfs_buf *xfs_buf_read(struct xfs_buftarg *target, xfs_daddr_t blkno,
|
|
|
|
size_t numblks, xfs_buf_flags_t flags);
|
|
|
|
void xfs_buf_readahead(struct xfs_buftarg *target, xfs_daddr_t blkno,
|
|
|
|
size_t numblks);
|
|
|
|
|
|
|
|
struct xfs_buf *xfs_buf_get_empty(struct xfs_buftarg *target, size_t numblks);
|
|
|
|
struct xfs_buf *xfs_buf_alloc(struct xfs_buftarg *target, xfs_daddr_t blkno,
|
|
|
|
size_t numblks, xfs_buf_flags_t flags);
|
|
|
|
void xfs_buf_set_empty(struct xfs_buf *bp, size_t numblks);
|
|
|
|
int xfs_buf_associate_memory(struct xfs_buf *bp, void *mem, size_t length);
|
|
|
|
|
|
|
|
struct xfs_buf *xfs_buf_get_uncached(struct xfs_buftarg *target, size_t numblks,
|
|
|
|
int flags);
|
|
|
|
struct xfs_buf *xfs_buf_read_uncached(struct xfs_buftarg *target,
|
|
|
|
xfs_daddr_t daddr, size_t numblks, int flags);
|
|
|
|
void xfs_buf_hold(struct xfs_buf *bp);
|
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);
|
2011-10-10 10:52:49 -06:00
|
|
|
extern void xfs_buf_ioerror_alert(struct xfs_buf *, const char *func);
|
2012-04-22 23:58:46 -06:00
|
|
|
extern void xfs_buf_iorequest(xfs_buf_t *);
|
2006-01-10 21:39:08 -07:00
|
|
|
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 */
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
extern bool xfs_buf_delwri_queue(struct xfs_buf *, struct list_head *);
|
|
|
|
extern int xfs_buf_delwri_submit(struct list_head *);
|
|
|
|
extern int xfs_buf_delwri_submit_nowait(struct list_head *);
|
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-08 06:36:32 -06:00
|
|
|
#define XFS_BUF_ZEROFLAGS(bp) \
|
xfs: on-stack delayed write buffer lists
Queue delwri buffers on a local on-stack list instead of a per-buftarg one,
and write back the buffers per-process instead of by waking up xfsbufd.
This is now easily doable given that we have very few places left that write
delwri buffers:
- log recovery:
Only done at mount time, and already forcing out the buffers
synchronously using xfs_flush_buftarg
- quotacheck:
Same story.
- dquot reclaim:
Writes out dirty dquots on the LRU under memory pressure. We might
want to look into doing more of this via xfsaild, but it's already
more optimal than the synchronous inode reclaim that writes each
buffer synchronously.
- xfsaild:
This is the main beneficiary of the change. By keeping a local list
of buffers to write we reduce latency of writing out buffers, and
more importably we can remove all the delwri list promotions which
were hitting the buffer cache hard under sustained metadata loads.
The implementation is very straight forward - xfs_buf_delwri_queue now gets
a new list_head pointer that it adds the delwri buffers to, and all callers
need to eventually submit the list using xfs_buf_delwi_submit or
xfs_buf_delwi_submit_nowait. Buffers that already are on a delwri list are
skipped in xfs_buf_delwri_queue, assuming they already are on another delwri
list. The biggest change to pass down the buffer list was done to the AIL
pushing. Now that we operate on buffers the trylock, push and pushbuf log
item methods are merged into a single push routine, which tries to lock the
item, and if possible add the buffer that needs writeback to the buffer list.
This leads to much simpler code than the previous split but requires the
individual IOP_PUSH instances to unlock and reacquire the AIL around calls
to blocking routines.
Given that xfsailds now also handle writing out buffers, the conditions for
log forcing and the sleep times needed some small changes. The most
important one is that we consider an AIL busy as long we still have buffers
to push, and the other one is that we do increment the pushed LSN for
buffers that are under flushing at this moment, but still count them towards
the stuck items for restart purposes. Without this we could hammer on stuck
items without ever forcing the log and not make progress under heavy random
delete workloads on fast flash storage devices.
[ Dave Chinner:
- rebase on previous patches.
- improved comments for XBF_DELWRI_Q handling
- fix XBF_ASYNC handling in queue submission (test 106 failure)
- rename delwri submit function buffer list parameters for clarity
- xfs_efd_item_push() should return XFS_ITEM_PINNED ]
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>
2012-04-22 23:58:39 -06:00
|
|
|
((bp)->b_flags &= ~(XBF_READ|XBF_WRITE|XBF_ASYNC| \
|
2011-07-08 06:36:32 -06:00
|
|
|
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);
|
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)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-01-10 21:39:08 -07:00
|
|
|
#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))
|
|
|
|
|
2011-10-10 10:52:45 -06:00
|
|
|
static inline void xfs_buf_set_ref(struct xfs_buf *bp, int lru_ref)
|
2010-12-01 22:31:13 -07:00
|
|
|
{
|
|
|
|
atomic_set(&bp->b_lru_ref, lru_ref);
|
|
|
|
}
|
2006-01-10 21:39:08 -07:00
|
|
|
|
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
|
|
|
|
|
|
|
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);
|
2010-02-01 16:13:42 -07: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)
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif /* __XFS_BUF_H__ */
|