关于宏PageReserved

 

宏PageReserved用来检测是否是该页是否为内核代码所用或者该页根本就没有使用。

定义在include/linux/page-flags.h中

#define TESTPAGEFLAG(uname, lname)                                \

static inline int Page##uname(struct page *page)                      \

                     { return test_bit(PG_##lname, &page->flags); }

#define SETPAGEFLAG(uname, lname)                                  \

static inline void SetPage##uname(struct page *page)                \

                     { set_bit(PG_##lname, &page->flags); }

#define CLEARPAGEFLAG(uname, lname)                              \

static inline void ClearPage##uname(struct page *page)                    \

                     { clear_bit(PG_##lname, &page->flags); }

#define PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname)             \

       SETPAGEFLAG(uname, lname) CLEARPAGEFLAG(uname, lname)

#define __CLEARPAGEFLAG(uname, lname)                                 \

static inline void __ClearPage##uname(struct page *page)          \

                     { __clear_bit(PG_##lname, &page->flags); }

PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)

 

其中

__clear_bit() is non-atomic，

clear_bit - Clears a bit in memory. clear_bit() is atomic and may not be reordered.

set_bit - Atomically set a bit in memory. set_bit() is atomic and may not be reordered.

   

至于flag PG_reserved，在ULK第八章里有描述：

PG_reserved：The page frame is reserved for kernel code or is unusable.页框留给内核代码或者没有使用。

 

/*

 * Various page->flags bits:

 *

 * PG_reserved is set for special pages, which can never be swapped out. Some

 * of them might not even exist (eg empty_bad_page)...

 *

 * The PG_private bitflag is set on pagecache pages if they contain filesystem

 * specific data (which is normally at page->private). It can be used by

 * private allocations for its own usage.

 *

 * During initiation of disk I/O, PG_locked is set. This bit is set before I/O

 * and cleared when writeback _starts_ or when read _completes_. PG_writeback

 * is set before writeback starts and cleared when it finishes.

 *

 * PG_locked also pins a page in pagecache, and blocks truncation of the file

 * while it is held.

 *

 * page_waitqueue(page) is a wait queue of all tasks waiting for the page

 * to become unlocked.

 *

 * PG_uptodate tells whether the page's contents is valid.  When a read

 * completes, the page becomes uptodate, unless a disk I/O error happened.

 *

 * PG_referenced, PG_reclaim are used for page reclaim for anonymous and

 * file-backed pagecache (see mm/vmscan.c).

 *

 * PG_error is set to indicate that an I/O error occurred on this page.

 *

 * PG_arch_1 is an architecture specific page state bit.  The generic code

 * guarantees that this bit is cleared for a page when it first is entered into

 * the page cache.

 *

 * PG_highmem pages are not permanently mapped into the kernel virtual address

 * space, they need to be kmapped separately for doing IO on the pages.  The

 * struct page (these bits with information) are always mapped into kernel

 * address space...

 *

 * PG_buddy is set to indicate that the page is free and in the buddy system

 * (see mm/page_alloc.c).

 *

 */

 

/*

 * Don't use the *_dontuse flags.  Use the macros.  Otherwise you'll break

 * locked- and dirty-page accounting.

 *

 * The page flags field is split into two parts, the main flags area

 * which extends from the low bits upwards, and the fields area which

 * extends from the high bits downwards.

 *

 *  | FIELD | ... | FLAGS |

 *  N-1           ^       0

 *               (NR_PAGEFLAGS)

 *

 * The fields area is reserved for fields mapping zone, node (for NUMA) and

 * SPARSEMEM section (for variants of SPARSEMEM that require section ids like

 * SPARSEMEM_EXTREME with !SPARSEMEM_VMEMMAP).

 */

enum pageflags {

       PG_locked,            /* Page is locked. Don't touch. */

       PG_error,

       PG_referenced,

       PG_uptodate,

       PG_dirty,

       PG_lru,

       PG_active,

#ifdef CONFIG_FASTFREE

       PG_fastfree,

#endif

       PG_slab,

       PG_owner_priv_1, /* Owner use. If pagecache, fs may use*/

       PG_arch_1,

       PG_reserved,

       PG_private,           /* If pagecache, has fs-private data */

       PG_writeback,              /* Page is under writeback */

#ifdef CONFIG_PAGEFLAGS_EXTENDED

       PG_head,              /* A head page */

       PG_tail,          /* A tail page */

#else

       PG_compound,             /* A compound page */

#endif

       PG_swapcache,            /* Swap page: swp_entry_t in private */

       PG_mappedtodisk, /* Has blocks allocated on-disk */

       PG_reclaim,           /* To be reclaimed asap */

       PG_buddy,            /* Page is free, on buddy lists */

#ifdef CONFIG_IA64_UNCACHED_ALLOCATOR

       PG_uncached,              /* Page has been mapped as uncached */

#endif

       __NR_PAGEFLAGS,

 

       /* Filesystems */

       PG_checked = PG_owner_priv_1,

 

       /* XEN */

       PG_pinned = PG_owner_priv_1,

       PG_savepinned = PG_dirty,

 

       /* SLOB */

       PG_slob_page = PG_active,

       PG_slob_free = PG_private,

 

       /* SLUB */

       PG_slub_frozen = PG_active,

       PG_slub_debug = PG_error,

};