xfs: buffer cache shrinker overhaul V2
cover xfs: buffer cache shrinker overhaul V2
This series adds a per-filesystem LRU to the buffer cache. When combined with a shrinker per filesystem, this enables us to prioritise reclaim of buffers under memory pressure. This solves the current problem of page cache reclaim having no concept of what the pages actually contain in deciding which pages to reclaim.
The LRU is lazily updated, meaning that we only access the LRU lists and locks when the last reference to a buffer goes away. As a result, there is no impact to the hot buffer lookup path and we are not constantly moving buffers around in the LRU.
This series effectively means that the buffer cache can now be made independent of the page cache as we now have our own optimised buffer cache reclaim mechanisms.
Version 2:
- removed buffer lru addition during xfs_buf_find() as it is done lazily on the last reference going away.
- removed buffer type additions and used the existing macro to just set the reference value.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 1/3 xfs: convert xfsbud shrinker to a per-buftarg shrinker.
From: Dave Chinner <[email protected]>
Before we introduce per-buftarg LRU lists, split the shrinker implementation into per-buftarg shrinker callbacks. At the moment we wake all the xfsbufds to run the delayed write queues to free the dirty buffers and make their pages available for reclaim. However, with an LRU, we want to be able to free clean, unused buffers as well, so we need to separate the xfsbufd from the shrinker callbacks.
--- fs/xfs/linux-2.6/xfs_buf.c | 89 ++++++++++++-------------------------------- fs/xfs/linux-2.6/xfs_buf.h | 4 +- 2 files changed, 27 insertions(+), 66 deletions(-)
fs/xfs/linux-2.6/xfs_buf.c +24 -65
@@ -44,12 +44,7 @@static kmem_zone_t *xfs_buf_zone; STATIC int xfsbufd(void *); -STATIC int xfsbufd_wakeup(struct shrinker *, int, gfp_t); STATIC void xfs_buf_delwri_queue(xfs_buf_t *, int); -static struct shrinker xfs_buf_shake = { - .shrink = xfsbufd_wakeup, - .seeks =DEFAULT_SEEKS , -};static struct workqueue_struct *xfslogd_workqueue;struct workqueue_struct *xfsdatad_workqueue;
@@ -337,7 +332,6 @@ _xfs_buf_lookup_pages( __func__, gfp_mask);XFS_STATS_INC (xb_page_retries); -xfsbufd_wakeup (NULL ,0 , gfp_mask);congestion_wait (BLK_RW_ASYNC ,HZ /50 ); goto retry; }
@@ -1461,28 +1455,23 @@ xfs_wait_buftarg( } } -/* -* buftarg list for delwrite queue processing -*/ -static LIST_HEAD (xfs_buftarg_list); -static DEFINE_SPINLOCK (xfs_buftarg_lock); - -STATIC void -xfs_register_buftarg ( -xfs_buftarg_t *btp) -{ -spin_lock (&xfs_buftarg_lock); -list_add (&btp->bt_list, &xfs_buftarg_list); -spin_unlock (&xfs_buftarg_lock); -} - -STATIC void -xfs_unregister_buftarg ( -xfs_buftarg_t *btp) +int +xfs_buftarg_shrink ( +struct shrinker *shrink, +int nr_to_scan, +gfp_t mask) { -spin_lock (&xfs_buftarg_lock); -list_del (&btp->bt_list); -spin_unlock (&xfs_buftarg_lock); +struct xfs_buftarg *btp =container_of (shrink, + struct xfs_buftarg, bt_shrinker); +if (nr_to_scan) { +if (test_bit (XBT_FORCE_SLEEP , &btp->bt_flags)) +return -1 ; +if (list_empty (&btp->bt_delwrite_queue)) +return -1 ; +set_bit (XBT_FORCE_FLUSH , &btp->bt_flags); +wake_up_process (btp->bt_task); + } +return list_empty (&btp->bt_delwrite_queue) ?-1 :1 ; }void
@@ -1490,17 +1479,14 @@ xfs_free_buftarg(struct xfs_mount *mp, struct xfs_buftarg *btp) { + unregister_shrinker(&btp->bt_shrinker); +xfs_flush_buftarg (btp,1 );if (mp->m_flags &XFS_MOUNT_BARRIER )xfs_blkdev_issue_flush (btp);iput (btp->bt_mapping->host); -/* Unregister the buftarg first so that we don't get a -* wakeup finding a non-existent task -*/ -xfs_unregister_buftarg (btp);kthread_stop (btp->bt_task); -kmem_free (btp); }
@@ -1597,20 +1583,13 @@ xfs_alloc_delwrite_queue(xfs_buftarg_t *btp, const char *fsname) { - int error = 0; - -INIT_LIST_HEAD (&btp->bt_list); INIT_LIST_HEAD(&btp->bt_delwrite_queue);spin_lock_init (&btp->bt_delwrite_lock); btp->bt_flags =0 ; btp->bt_task =kthread_run (xfsbufd, btp,"xfsbufd/%s" , fsname); -if (IS_ERR (btp->bt_task)) { - error =PTR_ERR (btp->bt_task); - goto out_error; - } -xfs_register_buftarg (btp); -out_error: -return error; +if (IS_ERR (btp->bt_task)) +return PTR_ERR (btp->bt_task); +return 0 ; } xfs_buftarg_t *
@@ -1633,6 +1612,9 @@ xfs_alloc_buftarg( goto error;if (xfs_alloc_delwrite_queue (btp, fsname)) goto error; + btp->bt_shrinker.shrink = xfs_buftarg_shrink; + btp->bt_shrinker.seeks =DEFAULT_SEEKS ; +register_shrinker (&btp->bt_shrinker);return btp; error:
@@ -1737,27 +1719,6 @@ xfs_buf_runall_queues(flush_workqueue (queue); } -STATIC int -xfsbufd_wakeup ( -struct shrinker *shrink, -int priority, -gfp_t mask) -{ -xfs_buftarg_t *btp; - -spin_lock (&xfs_buftarg_lock); -list_for_each_entry (btp, &xfs_buftarg_list, bt_list) { -if (test_bit (XBT_FORCE_SLEEP , &btp->bt_flags)) -continue ; -if (list_empty (&btp->bt_delwrite_queue)) -continue ; -set_bit (XBT_FORCE_FLUSH , &btp->bt_flags); -wake_up_process (btp->bt_task); - } -spin_unlock (&xfs_buftarg_lock); -return 0 ; -} -/* * Move as many buffers as specified to the supplied list * idicating if we skipped any buffers to prevent deadlocks.
@@ -1952,7 +1913,6 @@ xfs_buf_init(void)if (!xfsconvertd_workqueue) goto out_destroy_xfsdatad_workqueue; -register_shrinker (&xfs_buf_shake);return 0 ; out_destroy_xfsdatad_workqueue:
@@ -1968,7 +1928,6 @@ xfs_buf_init(void)void xfs_buf_terminate (void ) { -unregister_shrinker (&xfs_buf_shake);destroy_workqueue (xfsconvertd_workqueue);destroy_workqueue (xfsdatad_workqueue);destroy_workqueue (xfslogd_workqueue);
fs/xfs/linux-2.6/xfs_buf.h +3 -1
@@ -128,10 +128,12 @@ typedef struct xfs_buftarg {/* 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;unsigned long bt_flags; + +/* LRU control structures */ +struct shrinker bt_shrinker; } xfs_buftarg_t;/*
Signature · 6 lines
1.7.2.3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
PATCH 2/3 xfs: add a lru to the XFS buffer cache
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Introduce a per-buftarg LRU for memory reclaim to operate on. This is the last piece we need to put in place so that we can fully control the buffer lifecycle. This allows XFS to be responsibile for maintaining the working set of buffers under memory pressure instead of relying on the VM reclaim not to take pages we need out from underneath us.
The implementation introduces a b_lru_ref counter into the buffer. This is currently set to 1 whenever the buffer is referenced and so is used to determine if the buffer should be added to the LRU or not when freed. Effectively it allows lazy LRU initialisation of the buffer so we do not need to touch the LRU list and locks in xfs_buf_find().
Instead, when the buffer is being released and we drop the last reference to it, we check the b_lru_ref count and if it is none zero we re-add the buffer reference and add the inode to the LRU. The b_lru_ref counter is decremented by the shrinker, and whenever the shrinker comes across a buffer with a zero b_lru_ref counter, if released the LRU reference on the buffer. In the absence of a lookup race, this will result in the buffer being freed.
This counting mechanism is used instead of a reference flag so that it is simple to re-introduce buffer-type specific reclaim reference counts to prioritise reclaim more effectively. We still have all those hooks in the XFS code, so this will provide the infrastructure to re-implement that functionality.
--- fs/xfs/linux-2.6/xfs_buf.c | 166 ++++++++++++++++++++++++++++++++++++++------ fs/xfs/linux-2.6/xfs_buf.h | 8 ++- 2 files changed, 151 insertions(+), 23 deletions(-)
fs/xfs/linux-2.6/xfs_buf.c +143 -21
@@ -163,8 +163,79 @@ test_page_region( }/* -* Internal xfs_buf_t object manipulation +* xfs_buf_lru_add - add a buffer to the LRU. +* +* The LRU takes a new reference to the buffer so that it will only be freed +* once the shrinker takes the buffer off the LRU. */ +STATIC void +xfs_buf_lru_add ( +struct xfs_buf *bp) +{ +struct xfs_buftarg *btp = bp->b_target; + +spin_lock (&btp->bt_lru_lock); +if (list_empty (&bp->b_lru)) { +atomic_inc (&bp->b_hold); +list_add_tail (&bp->b_lru, &btp->bt_lru); + btp->bt_lru_nr++; + } +spin_unlock (&btp->bt_lru_lock); +} + +/* +* xfs_buf_lru_del - remove a buffer from the LRU +* +* The unlocked check is safe here because it only occurs when there are not +* b_lru_ref counts left on the inode under the pag->pag_buf_lock. it is there +* to optimise the shrinker removing the buffer from the LRU and calling +* xfs_buf_free(). i.e. it removes an unneccessary round trip on the +* bt_lru_lock. +*/ +STATIC void +xfs_buf_lru_del ( +struct xfs_buf *bp) +{ +struct xfs_buftarg *btp = bp->b_target; + +if (list_empty (&bp->b_lru)) +return ; + +spin_lock (&btp->bt_lru_lock); +if (!list_empty (&bp->b_lru)) { +list_del_init (&bp->b_lru); + btp->bt_lru_nr--; + } +spin_unlock (&btp->bt_lru_lock); +} + +/* +* When we mark a buffer stale, we remove the buffer from the LRU and clear the +* b_lru_ref count so that the buffer is freed immediately when the buffer +* reference count falls to zero. If the buffer is already on the LRU, we need +* to remove the reference that LRU holds on the buffer. +* +* This prevents build-up of stale buffers on the LRU. +*/ +void +xfs_buf_stale ( +struct xfs_buf *bp) +{ + bp->b_flags |=XBF_STALE ; +atomic_set (&(bp)->b_lru_ref,0 ); +if (!list_empty (&bp->b_lru)) { +struct xfs_buftarg *btp = bp->b_target; + +spin_lock (&btp->bt_lru_lock); +if (!list_empty (&bp->b_lru)) { +list_del_init (&bp->b_lru); + btp->bt_lru_nr--; +atomic_dec (&bp->b_hold); + } +spin_unlock (&btp->bt_lru_lock); + } +ASSERT (atomic_read (&bp->b_hold) >=1 ); +} STATIC void _xfs_buf_initialize(
@@ -181,7 +252,9 @@ _xfs_buf_initialize(memset (bp,0 ,sizeof (xfs_buf_t));atomic_set (&bp->b_hold,1 ); +atomic_set (&bp->b_lru_ref,1 );init_completion (&bp->b_iowait); +INIT_LIST_HEAD (&bp->b_lru);INIT_LIST_HEAD (&bp->b_list);RB_CLEAR_NODE (&bp->b_rbnode);sema_init (&bp->b_sema,0 );/* held, no waiters */
@@ -257,6 +330,8 @@ xfs_buf_free( {trace_xfs_buf_free (bp, _RET_IP_); +ASSERT (list_empty (&bp->b_lru)); +if (bp->b_flags & (_XBF_PAGE_CACHE|_XBF_PAGES)) {uint i;
@@ -822,6 +897,7 @@ xfs_buf_rele(if (!pag) {ASSERT (!bp->b_relse); +ASSERT (list_empty (&bp->b_lru));ASSERT (RB_EMPTY_NODE (&bp->b_rbnode));if (atomic_dec_and_test (&bp->b_hold))xfs_buf_free (bp);
@@ -829,13 +905,19 @@ xfs_buf_rele( }ASSERT (!RB_EMPTY_NODE (&bp->b_rbnode)); +ASSERT (atomic_read (&bp->b_hold) >0 );if (atomic_dec_and_lock (&bp->b_hold, &pag->pag_buf_lock)) {if (bp->b_relse) {atomic_inc (&bp->b_hold);spin_unlock (&pag->pag_buf_lock); bp->b_relse (bp); + }else if (!(bp->b_flags &XBF_STALE ) && +atomic_read (&bp->b_lru_ref)) { +xfs_buf_lru_add (bp); +spin_unlock (&pag->pag_buf_lock); }else { +xfs_buf_lru_del (bp);ASSERT (!(bp->b_flags & (XBF_DELWRI |_XBF_DELWRI_Q)));rb_erase (&bp->b_rbnode, &pag->pag_buf_tree);spin_unlock (&pag->pag_buf_lock);
@@ -1432,27 +1514,35 @@ xfs_buf_iomove(*/ /* -* Wait for any bufs with callbacks that have been submitted but -* have not yet returned... walk the hash list for the target. +* Wait for any bufs with callbacks that have been submitted but have not yet +* returned. These buffers will have an elevated hold count, so wait on those +* while freeing all the buffers only held by the LRU. */ void xfs_wait_buftarg (struct xfs_buftarg *btp) { -struct xfs_perag *pag; -uint i; +struct xfs_buf *bp; -for (i =0 ; i < btp->bt_mount->m_sb.sb_agcount; i++) { - pag =xfs_perag_get (btp->bt_mount, i); -spin_lock (&pag->pag_buf_lock); -while (rb_first (&pag->pag_buf_tree)) { -spin_unlock (&pag->pag_buf_lock); +restart: +spin_lock (&btp->bt_lru_lock); +while (!list_empty (&btp->bt_lru)) { + bp = list_first_entry(&btp->bt_lru, struct xfs_buf, b_lru); +if (atomic_read (&bp->b_hold) >1 ) { +spin_unlock (&btp->bt_lru_lock);delay (100 ); -spin_lock (&pag->pag_buf_lock); + goto restart; } -spin_unlock (&pag->pag_buf_lock); -xfs_perag_put (pag); +/* +* clear the LRU reference count so the bufer doesn't get +* ignored in xfs_buf_rele(). +*/ +atomic_set (&bp->b_lru_ref,0 ); +spin_unlock (&btp->bt_lru_lock); +xfs_buf_rele (bp); +spin_lock (&btp->bt_lru_lock); } +spin_unlock (&btp->bt_lru_lock); }int
@@ -1463,15 +1553,45 @@ xfs_buftarg_shrink( {struct xfs_buftarg *btp =container_of (shrink, struct xfs_buftarg, bt_shrinker); -if (nr_to_scan) { -if (test_bit (XBT_FORCE_SLEEP , &btp->bt_flags)) -return -1 ; -if (list_empty (&btp->bt_delwrite_queue)) -return -1 ; -set_bit (XBT_FORCE_FLUSH , &btp->bt_flags); -wake_up_process (btp->bt_task); +struct xfs_buf *bp; +LIST_HEAD (dispose); + +if (!nr_to_scan) +return btp->bt_lru_nr; + +spin_lock (&btp->bt_lru_lock); +while (!list_empty (&btp->bt_lru)) { +if (nr_to_scan-- <=0 ) +break ; + + bp = list_first_entry(&btp->bt_lru, struct xfs_buf, b_lru); + +/* +* Decrement the b_lru_ref count unless the value is already +* zero. If the value is already zero, we need to reclaim the +* buffer, otherwise it gets another trip through the LRU. +*/ +if (!atomic_add_unless (&bp->b_lru_ref,-1 ,0 )) { +list_move_tail (&bp->b_lru, &btp->bt_lru); +continue ; + } + +/* +* remove the buffer from the LRU now to avoid needing another +* lock round trip inside xfs_buf_rele(). +*/ +list_move (&bp->b_lru, &dispose); + btp->bt_lru_nr--; } -return list_empty (&btp->bt_delwrite_queue) ?-1 :1 ; +spin_unlock (&btp->bt_lru_lock); + +while (!list_empty (&dispose)) { + bp = list_first_entry(&dispose, struct xfs_buf, b_lru); +list_del_init (&bp->b_lru); +xfs_buf_rele (bp); + } + +return btp->bt_lru_nr; }void
@@ -1606,6 +1726,8 @@ xfs_alloc_buftarg( btp->bt_mount = mp; btp->bt_dev = bdev->bd_dev; btp->bt_bdev = bdev; +INIT_LIST_HEAD (&btp->bt_lru); +spin_lock_init (&btp->bt_lru_lock);if (xfs_setsize_buftarg_early (btp, bdev)) goto error;if (xfs_mapping_buftarg (btp, bdev))
fs/xfs/linux-2.6/xfs_buf.h +7 -1
@@ -134,6 +134,9 @@ typedef struct xfs_buftarg {/* LRU control structures */ struct shrinker bt_shrinker; +struct list_head bt_lru; +spinlock_t bt_lru_lock; +unsigned int bt_lru_nr; } xfs_buftarg_t;/*
@@ -166,9 +169,11 @@ typedef struct xfs_buf {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 */ +atomic_t b_lru_ref;/* lru reclaim ref count */ xfs_buf_flags_t b_flags;/* status flags */ struct semaphore b_sema;/* semaphore for lockables */ +struct list_head b_lru;/* lru list */ wait_queue_head_t b_waiters;/* unpin waiters */ struct list_head b_list;struct xfs_perag *b_pag;/* contains rbtree root */
@@ -266,7 +271,8 @@ extern void xfs_buf_terminate(void);#define XFS_BUF_ZEROFLAGS (bp) ((bp)->b_flags &= \ ~(XBF_READ|XBF_WRITE|XBF_ASYNC|XBF_DELWRI|XBF_ORDERED)) -#define XFS_BUF_STALE (bp) ((bp)->b_flags |= XBF_STALE) +void xfs_buf_stale (struct xfs_buf *bp); +#define XFS_BUF_STALE (bp) xfs_buf_stale(bp);#define XFS_BUF_UNSTALE (bp) ((bp)->b_flags &= ~XBF_STALE)#define XFS_BUF_ISSTALE (bp) ((bp)->b_flags & XBF_STALE)#define XFS_BUF_SUPER_STALE (bp) do { \
Signature · 6 lines
1.7.2.3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 2/3] xfs: add a lru to the XFS buffer cache
Looks good,
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
PATCH 3/3 xfs: connect up buffer reclaim priority hooks
In reply to Dave ChinnerFrom: Dave Chinner <[email protected]>
Now that the buffer reclaim infrastructure can handle different reclaim priorities for different types of buffers, reconnect the hooks in the XFS code that has been sitting dormant since it was ported to Linux. This should finally give use reclaim prioritisation that is on a par with the functionality that Irix provided XFS 15 years ago.
--- fs/xfs/linux-2.6/xfs_buf.h | 10 ++++++++-- fs/xfs/xfs_btree.c | 9 ++++----- fs/xfs/xfs_inode.c | 2 +- fs/xfs/xfs_trans.h | 2 +- 4 files changed, 14 insertions(+), 9 deletions(-)
fs/xfs/linux-2.6/xfs_buf.h +8 -2
@@ -336,9 +336,15 @@ void xfs_buf_stale(struct xfs_buf *bp);#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) +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)#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) atomic_read(&((bp)->b_pin_count))
fs/xfs/xfs_btree.c +4 -5
@@ -634,9 +634,8 @@ xfs_btree_read_bufl(return error; }ASSERT (!bp || !XFS_BUF_GETERROR (bp)); -if (bp !=NULL ) { +if (bp)XFS_BUF_SET_VTYPE_REF (bp,B_FS_MAP , refval); - } *bpp = bp;return 0 ; }
@@ -944,13 +943,13 @@ xfs_btree_set_refs(switch (cur->bc_btnum) {case XFS_BTNUM_BNO :case XFS_BTNUM_CNT : -XFS_BUF_SET_VTYPE_REF (*bpp,B_FS_MAP ,XFS_ALLOC_BTREE_REF ); +XFS_BUF_SET_VTYPE_REF (bp,B_FS_MAP ,XFS_ALLOC_BTREE_REF );break ;case XFS_BTNUM_INO : -XFS_BUF_SET_VTYPE_REF (*bpp,B_FS_INOMAP ,XFS_INO_BTREE_REF ); +XFS_BUF_SET_VTYPE_REF (bp,B_FS_INOMAP ,XFS_INO_BTREE_REF );break ;case XFS_BTNUM_BMAP : -XFS_BUF_SET_VTYPE_REF (*bpp,B_FS_MAP ,XFS_BMAP_BTREE_REF ); +XFS_BUF_SET_VTYPE_REF (bp,B_FS_MAP ,XFS_BMAP_BTREE_REF );break ;default :ASSERT (0 );
fs/xfs/xfs_inode.c +1 -1
@@ -887,7 +887,7 @@ xfs_iread(* around for a while. This helps to keep recently accessed * meta-data in-core longer. */ -XFS_BUF_SET_REF (bp,XFS_INO_REF ); +xfs_buf_set_ref (bp,XFS_INO_REF );/* * Use xfs_trans_brelse() to release the buffer containing the
fs/xfs/xfs_trans.h +1 -1
@@ -294,8 +294,8 @@ struct xfs_log_item_desc {#define XFS_ALLOC_BTREE_REF 2#define XFS_BMAP_BTREE_REF 2#define XFS_DIR_BTREE_REF 2 +#define XFS_INO_REF 2#define XFS_ATTR_BTREE_REF 1 -#define XFS_INO_REF 1#define XFS_DQUOT_REF 1#ifdef __KERNEL__
Signature · 6 lines
1.7.2.3 _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs
Re: [PATCH 3/3] xfs: connect up buffer reclaim priority hooks
Quoted 7 lines · Dave Chinner
From: Dave Chinner <[email protected]>
Now that the buffer reclaim infrastructure can handle different reclaim priorities for different types of buffers, reconnect the hooks in the XFS code that has been sitting dormant since it was ported to Linux. This should finally give use reclaim prioritisation that is on a par with the functionality that Irix provided XFS 15 years ago.
I think we really should call the buffer type macro fragments, but that can be left for another patch.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Quoted 3 lines · Dave Chinner
This series effectively means that the buffer cache can now be made independent of the page cache as we now have our own optimised buffer cache reclaim mechanisms.
What happened to that part of the first series? Implementing the sub-page blocksize support using kmalloc should be fairly straight forward.
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs
Quoted 8 lines · Christoph Hellwig
Quoted 3 lines · Dave Chinner
This series effectively means that the buffer cache can now be made independent of the page cache as we now have our own optimised buffer cache reclaim mechanisms.
What happened to that part of the first series? Implementing the sub-page blocksize support using kmalloc should be fairly straight forward.
I haven't had time to implement a new version of it yet. I've still got the get_free_page version of it around, I just need to update and test it. Hopefully I'll get that done in the next couple of days...
Cheers,
Dave.
Signature · 7 lines
Dave Chinner [email protected] _______________________________________________ xfs mailing list [email protected] http://oss.sgi.com/mailman/listinfo/xfs