From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1758818AbYHASdp (ORCPT ); Fri, 1 Aug 2008 14:33:45 -0400 Received: (majordomo@vger.kernel.org) by vger.kernel.org id S1756726AbYHAScS (ORCPT ); Fri, 1 Aug 2008 14:32:18 -0400 Received: from nlpi053.sbcis.sbc.com ([207.115.36.82]:3716 "EHLO nlpi053.prodigy.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753860AbYHAScO (ORCPT ); Fri, 1 Aug 2008 14:32:14 -0400 Message-Id: <20080801182346.247698575@lameter.com> References: <20080801182324.572058187@lameter.com> User-Agent: quilt/0.46-1 Date: Fri, 09 May 2008 19:21:11 -0700 From: Christoph Lameter To: Pekka Enberg CC: akpm@linux-foundation.org, Christoph Lameter , Christoph Lameter Cc: linux-kernel@vger.kernel.org CC: linux-fsdevel@vger.kernel.org Cc: Mel Gorman Cc: andi@firstfloor.org Cc: Rik van Riel Cc: mpm@selenic.com Cc: Dave Chinner Subject: [patch 10/19] buffer heads: Support slab defrag Content-Disposition: inline; filename=0024-Buffer-heads-Support-slab-defrag.patch Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Defragmentation support for buffer heads. We convert the references to buffers to struct page references and try to remove the buffers from those pages. If the pages are dirty then trigger writeout so that the buffer heads can be removed later. Reviewed-by: Rik van Riel Signed-off-by: Christoph Lameter Signed-off-by: Christoph Lameter --- fs/buffer.c | 99 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 99 insertions(+) Index: linux-2.6/fs/buffer.c =================================================================== --- linux-2.6.orig/fs/buffer.c 2008-07-31 12:18:56.000000000 -0500 +++ linux-2.6/fs/buffer.c 2008-07-31 12:18:59.000000000 -0500 @@ -3316,6 +3316,104 @@ } EXPORT_SYMBOL(bh_submit_read); +/* + * Writeback a page to clean the dirty state + */ +static void trigger_write(struct page *page) +{ + struct address_space *mapping = page_mapping(page); + int rc; + struct writeback_control wbc = { + .sync_mode = WB_SYNC_NONE, + .nr_to_write = 1, + .range_start = 0, + .range_end = LLONG_MAX, + .nonblocking = 1, + .for_reclaim = 0 + }; + + if (!mapping->a_ops->writepage) + /* No write method for the address space */ + return; + + if (!clear_page_dirty_for_io(page)) + /* Someone else already triggered a write */ + return; + + rc = mapping->a_ops->writepage(page, &wbc); + if (rc < 0) + /* I/O Error writing */ + return; + + if (rc == AOP_WRITEPAGE_ACTIVATE) + unlock_page(page); +} + +/* + * Get references on buffers. + * + * We obtain references on the page that uses the buffer. v[i] will point to + * the corresponding page after get_buffers() is through. + * + * We are safe from the underlying page being removed simply by doing + * a get_page_unless_zero. The buffer head removal may race at will. + * try_to_free_buffes will later take appropriate locks to remove the + * buffers if they are still there. + */ +static void *get_buffers(struct kmem_cache *s, int nr, void **v) +{ + struct page *page; + struct buffer_head *bh; + int i, j; + int n = 0; + + for (i = 0; i < nr; i++) { + bh = v[i]; + v[i] = NULL; + + page = bh->b_page; + + if (page && PagePrivate(page)) { + for (j = 0; j < n; j++) + if (page == v[j]) + continue; + } + + if (get_page_unless_zero(page)) + v[n++] = page; + } + return NULL; +} + +/* + * Despite its name: kick_buffers operates on a list of pointers to + * page structs that was set up by get_buffer(). + */ +static void kick_buffers(struct kmem_cache *s, int nr, void **v, + void *private) +{ + struct page *page; + int i; + + for (i = 0; i < nr; i++) { + page = v[i]; + + if (!page || PageWriteback(page)) + continue; + + if (!TestSetPageLocked(page)) { + if (PageDirty(page)) + trigger_write(page); + else { + if (PagePrivate(page)) + try_to_free_buffers(page); + unlock_page(page); + } + } + put_page(page); + } +} + static void init_buffer_head(void *data) { @@ -3334,6 +3432,7 @@ (SLAB_RECLAIM_ACCOUNT|SLAB_PANIC| SLAB_MEM_SPREAD), init_buffer_head); + kmem_cache_setup_defrag(bh_cachep, get_buffers, kick_buffers); /* * Limit the bh occupancy to 10% of ZONE_NORMAL --