Commit d85f3385 authored by Christoph Lameter's avatar Christoph Lameter Committed by Linus Torvalds
Browse files

Make page->private usable in compound pages 

If we add a new flag so that we can distinguish between the first page and the
tail pages then we can avoid to use page->private in the first page.
page->private == page for the first page, so there is no real information in
there.

Freeing up page->private makes the use of compound pages more transparent.
They become more usable like real pages.  Right now we have to be careful f.e.
 if we are going beyond PAGE_SIZE allocations in the slab on i386 because we
can then no longer use the private field.  This is one of the issues that
cause us not to support debugging for page size slabs in SLAB.

Having page->private available for SLUB would allow more meta information in
the page struct.  I can probably avoid the 16 bit ints that I have in there
right now.

Also if page->private is available then a compound page may be equipped with
buffer heads.  This may free up the way for filesystems to support larger
blocks than page size.

We add PageTail as an alias of PageReclaim.  Compound pages cannot currently
be reclaimed.  Because of the alias one needs to check PageCompound first.

The RFC for the this approach was discussed at
http://marc.info/?t=117574302800001&r=1&w=2



[nacc@us.ibm.com: fix hugetlbfs]
Signed-off-by: default avatarChristoph Lameter <clameter@sgi.com>
Signed-off-by: default avatarNishanth Aravamudan <nacc@us.ibm.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 30520864

arch/ia64/mm/init.c

+1 −1
Original line number Diff line number Diff line
@@ -121,7 +121,7 @@ lazy_mmu_prot_update (pte_t pte) 
		return;				/* i-cache is already coherent with d-cache */



	if (PageCompound(page)) {

		order = (unsigned long) (page[1].lru.prev);

		order = compound_order(page);

		flush_icache_range(addr, addr + (1UL << order << PAGE_SHIFT));

	}

	else

fs/hugetlbfs/inode.c

+1 −1
Original line number Diff line number Diff line
@@ -450,7 +450,7 @@ static int hugetlbfs_symlink(struct inode *dir, 
 */

static int hugetlbfs_set_page_dirty(struct page *page)

{

	struct page *head = (struct page *)page_private(page);

	struct page *head = compound_head(page);



	SetPageDirty(head);

	return 0;

include/linux/mm.h

+28 −5
Original line number Diff line number Diff line
@@ -267,17 +267,28 @@ static inline int get_page_unless_zero(struct page *page) 
	return atomic_inc_not_zero(&page->_count);

}



static inline struct page *compound_head(struct page *page)

{

	/*

	 * We could avoid the PageCompound(page) check if

	 * we would not overload PageTail().

	 *

	 * This check has to be done in several performance critical

	 * paths of the slab etc. IMHO PageTail deserves its own flag.

	 */

	if (unlikely(PageCompound(page) && PageTail(page)))

		return page->first_page;

	return page;

}



static inline int page_count(struct page *page)

{

	if (unlikely(PageCompound(page)))

		page = (struct page *)page_private(page);

	return atomic_read(&page->_count);

	return atomic_read(&compound_head(page)->_count);

}



static inline void get_page(struct page *page)

{

	if (unlikely(PageCompound(page)))

		page = (struct page *)page_private(page);

	page = compound_head(page);

	VM_BUG_ON(atomic_read(&page->_count) == 0);

	atomic_inc(&page->_count);

}
@@ -314,6 +325,18 @@ static inline compound_page_dtor *get_compound_page_dtor(struct page *page) 
	return (compound_page_dtor *)page[1].lru.next;

}



static inline int compound_order(struct page *page)

{

	if (!PageCompound(page) || PageTail(page))

		return 0;

	return (unsigned long)page[1].lru.prev;

}



static inline void set_compound_order(struct page *page, unsigned long order)

{

	page[1].lru.prev = (void *)order;

}



/*

 * Multiple processes may "see" the same page. E.g. for untouched

 * mappings of /dev/null, all processes see the same page full of

include/linux/page-flags.h

+14 −0
Original line number Diff line number Diff line
@@ -94,6 +94,12 @@ 
/* PG_owner_priv_1 users should have descriptive aliases */

#define PG_checked		PG_owner_priv_1 /* Used by some filesystems */



/*

 * Marks tail portion of a compound page. We currently do not reclaim

 * compound pages so we can reuse a flag only used for reclaim here.

 */

#define PG_tail			PG_reclaim



#if (BITS_PER_LONG > 32)

/*

 * 64-bit-only flags build down from bit 31
@@ -241,6 +247,14 @@ static inline void SetPageUptodate(struct page *page) 
#define __SetPageCompound(page)	__set_bit(PG_compound, &(page)->flags)

#define __ClearPageCompound(page) __clear_bit(PG_compound, &(page)->flags)



/*

 * Note: PG_tail is an alias of another page flag. The result of PageTail()

 * is only valid if PageCompound(page) is true.

 */

#define PageTail(page)	test_bit(PG_tail, &(page)->flags)

#define __SetPageTail(page)	__set_bit(PG_tail, &(page)->flags)

#define __ClearPageTail(page)	__clear_bit(PG_tail, &(page)->flags)



#ifdef CONFIG_SWAP

#define PageSwapCache(page)	test_bit(PG_swapcache, &(page)->flags)

#define SetPageSwapCache(page)	set_bit(PG_swapcache, &(page)->flags)

mm/internal.h

+1 −1
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ static inline void set_page_count(struct page *page, int v) 
 */

static inline void set_page_refcounted(struct page *page)

{

	VM_BUG_ON(PageCompound(page) && page_private(page) != (unsigned long)page);

	VM_BUG_ON(PageCompound(page) && PageTail(page));

	VM_BUG_ON(atomic_read(&page->_count));

	set_page_count(page, 1);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE