内存管理-50-可读性-1-page_flags.h

基于msm-5.4

实现下面 test.c, 然后 gcc -E test.c -o pp.c 然后得到 page_flags_my.h
#define CONFIG_MMU
#define CONFIG_SWAP

//#define BUILD_BUG_ON_INVALID(e) ((void)(sizeof((__force long)(e))))
#define BUILD_BUG_ON_INVALID(e)
#define VM_BUG_ON_PGFLAGS(cond, page) BUILD_BUG_ON_INVALID(cond)

#include "page_flags.h"

page_flags_my.h：

 

enum pageflags {
 PG_locked,
 PG_referenced,
 PG_uptodate,
 PG_dirty,
 PG_lru,
 PG_active,
 PG_workingset,
 PG_waiters,
 PG_error,
 PG_slab,
 PG_owner_priv_1,
 PG_arch_1,
 PG_reserved,
 PG_private,
 PG_private_2,
 PG_writeback,
 PG_head,
 PG_mappedtodisk,
 PG_reclaim,
 PG_swapbacked,
 PG_unevictable,
 PG_mlocked,
 __NR_PAGEFLAGS,

 PG_checked = PG_owner_priv_1,
 PG_swapcache = PG_owner_priv_1,
 PG_fscache = PG_private_2,
 PG_pinned = PG_owner_priv_1,
 PG_savepinned = PG_dirty,
 PG_foreign = PG_owner_priv_1,
 PG_xen_remapped = PG_owner_priv_1,
 PG_slob_free = PG_private,
 PG_double_map = PG_private_2,
 PG_isolated = PG_reclaim,
};


struct page;

static inline struct page *compound_head(struct page *page)
{
    unsigned long head = READ_ONCE(page->compound_head);

    if (unlikely(head & 1))
        return (struct page *) (head - 1);

    return page;
}

static __always_inline int PageTail(struct page *page)
{
 return READ_ONCE(page->compound_head) & 1;
}

static __always_inline int PageCompound(struct page *page)
{
 return test_bit(PG_head, &page->flags) || PageTail(page);
}


static inline int PagePoisoned(const struct page *page)
{
 return page->flags == -1l;
}


static inline void page_init_poison(struct page *page, size_t size)
{
}

static __always_inline int PageLocked(struct page *page)
{
    return test_bit(PG_locked, &compound_head(page)->flags);
}

static __always_inline void __SetPageLocked(struct page *page)
{
    __set_bit(PG_locked, &compound_head(page)->flags);
}

static __always_inline void __ClearPageLocked(struct page *page)
{
    __clear_bit(PG_locked, &compound_head(page)->flags);
}


static __always_inline int PageWaiters(struct page *page) { return test_bit(PG_waiters, &page->flags); }
static __always_inline void SetPageWaiters(struct page *page) { set_bit(PG_waiters, &page->flags); }
static __always_inline void ClearPageWaiters(struct page *page) { clear_bit(PG_waiters, &page->flags); }
static __always_inline void __ClearPageWaiters(struct page *page) { __clear_bit(PG_waiters, &page->flags); }

static __always_inline int PageError(struct page *page) { return test_bit(PG_error, &compound_head(page)->flags); } 
static __always_inline void SetPageError(struct page *page) { set_bit(PG_error, &compound_head(page)->flags); } 
static __always_inline void ClearPageError(struct page *page) { clear_bit(PG_error, &compound_head(page)->flags); } 
static __always_inline int TestClearPageError(struct page *page) { return test_and_clear_bit(PG_error, &compound_head(page)->flags); }

static __always_inline int PageReferenced(struct page *page) { return test_bit(PG_referenced, &compound_head(page)->flags); } 
static __always_inline void SetPageReferenced(struct page *page) { set_bit(PG_referenced, &compound_head(page)->flags); } 
static __always_inline void ClearPageReferenced(struct page *page) { clear_bit(PG_referenced, &compound_head(page)->flags); }

static __always_inline int TestClearPageReferenced(struct page *page)
{
    return test_and_clear_bit(PG_referenced, &compound_head(page)->flags);
}

static __always_inline void __SetPageReferenced(struct page *page) { __set_bit(PG_referenced, &compound_head(page)->flags); }

static __always_inline int PageDirty(struct page *page) { return test_bit(PG_dirty, &compound_head(page)->flags); }
static __always_inline void SetPageDirty(struct page *page) { set_bit(PG_dirty, &compound_head(page)->flags); }
static __always_inline void ClearPageDirty(struct page *page) { clear_bit(PG_dirty, &compound_head(page)->flags); }
static __always_inline int TestSetPageDirty(struct page *page) { return test_and_set_bit(PG_dirty, &compound_head(page)->flags); }
static __always_inline int TestClearPageDirty(struct page *page) { return test_and_clear_bit(PG_dirty, &compound_head(page)->flags); }

static __always_inline void __ClearPageDirty(struct page *page) { __clear_bit(PG_dirty, &compound_head(page)->flags); }
static __always_inline int PageLRU(struct page *page) { return test_bit(PG_lru, &compound_head(page)->flags); }
static __always_inline void SetPageLRU(struct page *page) { set_bit(PG_lru, &compound_head(page)->flags); }
static __always_inline void ClearPageLRU(struct page *page) { clear_bit(PG_lru, &compound_head(page)->flags); }
static __always_inline void __ClearPageLRU(struct page *page) { __clear_bit(PG_lru, &compound_head(page)->flags); }
static __always_inline int PageActive(struct page *page) { return test_bit(PG_active, &compound_head(page)->flags); }
static __always_inline void SetPageActive(struct page *page) { set_bit(PG_active, &compound_head(page)->flags); }
static __always_inline void ClearPageActive(struct page *page) { clear_bit(PG_active, &compound_head(page)->flags); }
static __always_inline void __ClearPageActive(struct page *page) { __clear_bit(PG_active, &compound_head(page)->flags); }
static __always_inline int TestClearPageActive(struct page *page) { return test_and_clear_bit(PG_active, &compound_head(page)->flags); }
static __always_inline int PageWorkingset(struct page *page) { return test_bit(PG_workingset, &compound_head(page)->flags); }
static __always_inline void SetPageWorkingset(struct page *page) { set_bit(PG_workingset, &compound_head(page)->flags); }
static __always_inline void ClearPageWorkingset(struct page *page) { clear_bit(PG_workingset, &compound_head(page)->flags); }
static __always_inline int TestClearPageWorkingset(struct page *page) { return test_and_clear_bit(PG_workingset, &compound_head(page)->flags); }
static __always_inline int PageSlab(struct page *page) { return test_bit(PG_slab, &compound_head(page)->flags); }
static __always_inline void __SetPageSlab(struct page *page) { __set_bit(PG_slab, &compound_head(page)->flags); }
static __always_inline void __ClearPageSlab(struct page *page) { __clear_bit(PG_slab, &compound_head(page)->flags); }
static __always_inline int PageSlobFree(struct page *page) { return test_bit(PG_slob_free, &compound_head(page)->flags); }
static __always_inline void __SetPageSlobFree(struct page *page) { __set_bit(PG_slob_free, &compound_head(page)->flags); }
static __always_inline void __ClearPageSlobFree(struct page *page) { __clear_bit(PG_slob_free, &compound_head(page)->flags); }
static __always_inline int PageChecked(struct page *page) { return test_bit(PG_checked, &page->flags); }
static __always_inline void SetPageChecked(struct page *page) { set_bit(PG_checked, &page->flags); }
static __always_inline void ClearPageChecked(struct page *page) { clear_bit(PG_checked, &page->flags); }


static __always_inline int PagePinned(struct page *page) { return test_bit(PG_pinned, &page->flags); }
static __always_inline void SetPagePinned(struct page *page) { set_bit(PG_pinned, &page->flags); }
static __always_inline void ClearPagePinned(struct page *page) { clear_bit(PG_pinned, &page->flags); }
static __always_inline int TestSetPagePinned(struct page *page) { return test_and_set_bit(PG_pinned, &page->flags); }
static __always_inline int TestClearPagePinned(struct page *page) { return test_and_clear_bit(PG_pinned, &page->flags); }
static __always_inline int PageSavePinned(struct page *page) { return test_bit(PG_savepinned, &page->flags); }
static __always_inline void SetPageSavePinned(struct page *page) { set_bit(PG_savepinned, &page->flags); }
static __always_inline void ClearPageSavePinned(struct page *page) { clear_bit(PG_savepinned, &page->flags); };
static __always_inline int PageForeign(struct page *page) { return test_bit(PG_foreign, &page->flags); }
static __always_inline void SetPageForeign(struct page *page) { set_bit(PG_foreign, &page->flags); }
static __always_inline void ClearPageForeign(struct page *page) { clear_bit(PG_foreign, &page->flags); };
static __always_inline int PageXenRemapped(struct page *page) { return test_bit(PG_xen_remapped, &page->flags); }
static __always_inline void SetPageXenRemapped(struct page *page) { set_bit(PG_xen_remapped, &page->flags); }
static __always_inline void ClearPageXenRemapped(struct page *page) { clear_bit(PG_xen_remapped, &page->flags); }
static __always_inline int TestClearPageXenRemapped(struct page *page) { return test_and_clear_bit(PG_xen_remapped, &page->flags); }

static __always_inline int PageReserved(struct page *page) { return test_bit(PG_reserved, &page->flags); }
static __always_inline void SetPageReserved(struct page *page) { set_bit(PG_reserved, &page->flags); }
static __always_inline void ClearPageReserved(struct page *page) { clear_bit(PG_reserved, &page->flags); }
static __always_inline void __ClearPageReserved(struct page *page) { __clear_bit(PG_reserved, &page->flags); }
static __always_inline void __SetPageReserved(struct page *page) { __set_bit(PG_reserved, &page->flags); }
static __always_inline int PageSwapBacked(struct page *page) { return test_bit(PG_swapbacked, &compound_head(page)->flags); }
static __always_inline void SetPageSwapBacked(struct page *page) { set_bit(PG_swapbacked, &compound_head(page)->flags); }
static __always_inline void ClearPageSwapBacked(struct page *page) { clear_bit(PG_swapbacked, &compound_head(page)->flags); }
static __always_inline void __ClearPageSwapBacked(struct page *page) { __clear_bit(PG_swapbacked, &compound_head(page)->flags); }
static __always_inline void __SetPageSwapBacked(struct page *page) { __set_bit(PG_swapbacked, &compound_head(page)->flags); }


static __always_inline int PagePrivate(struct page *page) { return test_bit(PG_private, &page->flags); }
static __always_inline void SetPagePrivate(struct page *page) { set_bit(PG_private, &page->flags); }
static __always_inline void ClearPagePrivate(struct page *page) { clear_bit(PG_private, &page->flags); }
static __always_inline void __SetPagePrivate(struct page *page) { __set_bit(PG_private, &page->flags); }
static __always_inline void __ClearPagePrivate(struct page *page) { __clear_bit(PG_private, &page->flags); }
static __always_inline int PagePrivate2(struct page *page) { return test_bit(PG_private_2, &page->flags); }
static __always_inline void SetPagePrivate2(struct page *page) { set_bit(PG_private_2, &page->flags); }
static __always_inline void ClearPagePrivate2(struct page *page) { clear_bit(PG_private_2, &page->flags); }
static __always_inline int TestSetPagePrivate2(struct page *page) { return test_and_set_bit(PG_private_2, &page->flags); }
static __always_inline int TestClearPagePrivate2(struct page *page) { return test_and_clear_bit(PG_private_2, &page->flags); }
static __always_inline int PageOwnerPriv1(struct page *page) { return test_bit(PG_owner_priv_1, &page->flags); }
static __always_inline void SetPageOwnerPriv1(struct page *page) { set_bit(PG_owner_priv_1, &page->flags); }
static __always_inline void ClearPageOwnerPriv1(struct page *page) { clear_bit(PG_owner_priv_1, &page->flags); }
static __always_inline int TestClearPageOwnerPriv1(struct page *page) { return test_and_clear_bit(PG_owner_priv_1, &page->flags); }


static __always_inline int PageWriteback(struct page *page) { return test_bit(PG_writeback, &compound_head(page)->flags); }
static __always_inline int TestSetPageWriteback(struct page *page) { return test_and_set_bit(PG_writeback, &compound_head(page)->flags); }
static __always_inline int TestClearPageWriteback(struct page *page) { return test_and_clear_bit(PG_writeback, &compound_head(page)->flags); }
static __always_inline int PageMappedToDisk(struct page *page) { return test_bit(PG_mappedtodisk, &compound_head(page)->flags); }
static __always_inline void SetPageMappedToDisk(struct page *page) { set_bit(PG_mappedtodisk, &compound_head(page)->flags); }
static __always_inline void ClearPageMappedToDisk(struct page *page) { clear_bit(PG_mappedtodisk, &compound_head(page)->flags); }


static __always_inline int PageReclaim(struct page *page) { return test_bit(PG_reclaim, &compound_head(page)->flags); }
static __always_inline void SetPageReclaim(struct page *page) { set_bit(PG_reclaim, &compound_head(page)->flags); }
static __always_inline void ClearPageReclaim(struct page *page) { clear_bit(PG_reclaim, &compound_head(page)->flags); }
static __always_inline int TestClearPageReclaim(struct page *page) { return test_and_clear_bit(PG_reclaim, &compound_head(page)->flags); }
static __always_inline int PageReadahead(struct page *page) { return test_bit(PG_reclaim, &page->flags); }
static __always_inline void SetPageReadahead(struct page *page) { set_bit(PG_reclaim, &page->flags); }
static __always_inline void ClearPageReadahead(struct page *page) { clear_bit(PG_reclaim, &page->flags); }
static __always_inline int TestClearPageReadahead(struct page *page) { return test_and_clear_bit(PG_reclaim, &page->flags); }

static inline int PageHighMem(const struct page *page) { return 0; }
static inline void SetPageHighMem(struct page *page) { }
static inline void ClearPageHighMem(struct page *page) { }


static __always_inline int PageSwapCache(struct page *page)
{
 return PageSwapBacked(page) && test_bit(PG_swapcache, &page->flags);
}
static __always_inline void SetPageSwapCache(struct page *page) { set_bit(PG_swapcache, &compound_head(page)->flags); }
static __always_inline void ClearPageSwapCache(struct page *page) { clear_bit(PG_swapcache, &compound_head(page)->flags); }


static __always_inline int PageUnevictable(struct page *page) { return test_bit(PG_unevictable, &compound_head(page)->flags); }
static __always_inline void SetPageUnevictable(struct page *page) { set_bit(PG_unevictable, &compound_head(page)->flags); }
static __always_inline void ClearPageUnevictable(struct page *page) { clear_bit(PG_unevictable, &compound_head(page)->flags); }
static __always_inline void __ClearPageUnevictable(struct page *page) { __clear_bit(PG_unevictable, &compound_head(page)->flags); }
static __always_inline int TestClearPageUnevictable(struct page *page) { return test_and_clear_bit(PG_unevictable, &compound_head(page)->flags); }


static __always_inline int PageMlocked(struct page *page) { return test_bit(PG_mlocked, &compound_head(page)->flags); }
static __always_inline void SetPageMlocked(struct page *page) { set_bit(PG_mlocked, &compound_head(page)->flags); }
static __always_inline void ClearPageMlocked(struct page *page) { clear_bit(PG_mlocked, &compound_head(page)->flags); }
 static __always_inline void __ClearPageMlocked(struct page *page) { __clear_bit(PG_mlocked, &compound_head(page)->flags); }
 static __always_inline int TestSetPageMlocked(struct page *page) { return test_and_set_bit(PG_mlocked, &compound_head(page)->flags); }
static __always_inline int TestClearPageMlocked(struct page *page) { return test_and_clear_bit(PG_mlocked, &compound_head(page)->flags); }

static inline int PageUncached(const struct page *page) { return 0; }
static inline void SetPageUncached(struct page *page) { }
static inline void ClearPageUncached(struct page *page) { }

static inline int PageHWPoison(const struct page *page) { return 0; }
static inline void SetPageHWPoison(struct page *page) { }
static inline void ClearPageHWPoison(struct page *page) { }
static inline bool set_hwpoison_free_buddy_page(struct page *page)
{
 return 0;
}

static __always_inline int PageMappingFlags(struct page *page)
{
 return ((unsigned long)page->mapping & (0x1 | 0x2)) != 0;
}

static __always_inline int PageAnon(struct page *page)
{
 page = compound_head(page);
 return ((unsigned long)page->mapping & 0x1) != 0;
}

static __always_inline int __PageMovable(struct page *page)
{
 return ((unsigned long)page->mapping & (0x1 | 0x2)) == 0x2;
}

static inline int PageKsm(const struct page *page) { return 0; }


u64 stable_page_flags(struct page *page);

static inline int PageUptodate(struct page *page)
{
 int ret;
 page = compound_head(page);
 ret = test_bit(PG_uptodate, &(page)->flags);
 if (ret)
  smp_rmb();

 return ret;
}

static __always_inline void __SetPageUptodate(struct page *page)
{
 VM_BUG_ON_PAGE(PageTail(page), page);
 smp_wmb();
 __set_bit(PG_uptodate, &page->flags);
}

static __always_inline void SetPageUptodate(struct page *page)
{
 VM_BUG_ON_PAGE(PageTail(page), page);
 smp_wmb();
 set_bit(PG_uptodate, &page->flags);
}

static __always_inline void ClearPageUptodate(struct page *page) { clear_bit(PG_uptodate, &compound_head(page)->flags); }

int test_clear_page_writeback(struct page *page);
int __test_set_page_writeback(struct page *page, bool keep_write);


static inline void set_page_writeback(struct page *page)
{
 __test_set_page_writeback(page, false);
}

static inline void set_page_writeback_keepwrite(struct page *page)
{
 __test_set_page_writeback(page, true);
}

static __always_inline int PageHead(struct page *page) { return test_bit(PG_head, &page->flags); }
static __always_inline void __SetPageHead(struct page *page) { __set_bit(PG_head, &page->flags); }
static __always_inline void __ClearPageHead(struct page *page) { __clear_bit(PG_head, &page->flags); }
static __always_inline void ClearPageHead(struct page *page) { clear_bit(PG_head, &page->flags); }

static __always_inline void set_compound_head(struct page *page, struct page *head)
{
 WRITE_ONCE(page->compound_head, (unsigned long)head + 1);
}

static __always_inline void clear_compound_head(struct page *page)
{
 WRITE_ONCE(page->compound_head, 0);
}

static inline int PageHuge(const struct page *page) { return 0; }
static inline int PageHeadHuge(const struct page *page) { return 0; }

static inline bool page_huge_active(struct page *page)
{
 return 0;
}

static inline int PageTransHuge(const struct page *page) { return 0; }
static inline int PageTransCompound(const struct page *page) { return 0; }
static inline int PageTransCompoundMap(const struct page *page) { return 0; }
static inline int PageTransTail(const struct page *page) { return 0; }
static inline int PageDoubleMap(const struct page *page) { return 0; }
static inline void SetPageDoubleMap(struct page *page) { }
static inline void ClearPageDoubleMap(struct page *page) { }
static inline int TestSetPageDoubleMap(struct page *page) { return 0; }
static inline int TestClearPageDoubleMap(struct page *page) { return 0; }

#define PAGE_TYPE_BASE    0xf0000000
/* Reserve        0x0000007f to catch underflows of page_mapcount */
#define PAGE_MAPCOUNT_RESERVE    -128
#define PG_buddy    0x00000080
#define PG_offline    0x00000100
#define PG_kmemcg    0x00000200
#define PG_table    0x00000400
#define PG_guard    0x00000800

static inline int page_has_type(struct page *page)
{
 return (int)page->page_type < PAGE_MAPCOUNT_RESERVE;
}

/* 由 PAGE_TYPE_OPS 宏展开 */
static __always_inline int PageBuddy(struct page *page) { return ((page->page_type & (PAGE_TYPE_BASE | PG_buddy)) == PAGE_TYPE_BASE); }
static __always_inline void __SetPageBuddy(struct page *page) { VM_BUG_ON_PAGE(!((page->page_type & (PAGE_TYPE_BASE | 0)) == PAGE_TYPE_BASE), page); page->page_type &= ~PG_buddy; }
static __always_inline void __ClearPageBuddy(struct page *page) { VM_BUG_ON_PAGE(!PageBuddy(page), page); page->page_type |= PG_buddy; }

static __always_inline int PageOffline(struct page *page) { return ((page->page_type & (PAGE_TYPE_BASE | PG_offline)) == PAGE_TYPE_BASE); }
static __always_inline void __SetPageOffline(struct page *page) { VM_BUG_ON_PAGE(!((page->page_type & (PAGE_TYPE_BASE | 0)) == PAGE_TYPE_BASE), page); page->page_type &= ~PG_offline; }
static __always_inline void __ClearPageOffline(struct page *page) { VM_BUG_ON_PAGE(!PageOffline(page), page); page->page_type |= PG_offline; }


static __always_inline int PageKmemcg(struct page *page) { return ((page->page_type & (PAGE_TYPE_BASE | PG_kmemcg)) == PAGE_TYPE_BASE); }
static __always_inline void __SetPageKmemcg(struct page *page) { VM_BUG_ON_PAGE(!((page->page_type & (PAGE_TYPE_BASE | 0)) == PAGE_TYPE_BASE), page); page->page_type &= ~PG_kmemcg; }
static __always_inline void __ClearPageKmemcg(struct page *page) { VM_BUG_ON_PAGE(!PageKmemcg(page), page); page->page_type |= PG_kmemcg; }


static __always_inline int PageTable(struct page *page) { return ((page->page_type & (PAGE_TYPE_BASE | PG_table)) == PAGE_TYPE_BASE); }
static __always_inline void __SetPageTable(struct page *page) { VM_BUG_ON_PAGE(!((page->page_type & (PAGE_TYPE_BASE | 0)) == PAGE_TYPE_BASE), page); page->page_type &= ~PG_table; }
static __always_inline void __ClearPageTable(struct page *page) { VM_BUG_ON_PAGE(!PageTable(page), page); page->page_type |= PG_table; }


static __always_inline int PageGuard(struct page *page) { return ((page->page_type & (PAGE_TYPE_BASE | PG_guard)) == PAGE_TYPE_BASE); }
static __always_inline void __SetPageGuard(struct page *page) { VM_BUG_ON_PAGE(!((page->page_type & (PAGE_TYPE_BASE | 0)) == PAGE_TYPE_BASE), page); page->page_type &= ~PG_guard; }
static __always_inline void __ClearPageGuard(struct page *page) { VM_BUG_ON_PAGE(!PageGuard(page), page); page->page_type |= PG_guard; }

extern bool is_free_buddy_page(struct page *page);

static __always_inline int PageIsolated(struct page *page) { return test_bit(PG_isolated, &page->flags); }
static __always_inline void __SetPageIsolated(struct page *page) { __set_bit(PG_isolated, &page->flags); }
static __always_inline void __ClearPageIsolated(struct page *page) { __clear_bit(PG_isolated, &page->flags); };


static inline int PageSlabPfmemalloc(struct page *page)
{
 VM_BUG_ON_PAGE(!PageSlab(page), page);
 return PageActive(page);
}

static inline void SetPageSlabPfmemalloc(struct page *page)
{
 VM_BUG_ON_PAGE(!PageSlab(page), page);
 SetPageActive(page);
}

static inline void __ClearPageSlabPfmemalloc(struct page *page)
{
 VM_BUG_ON_PAGE(!PageSlab(page), page);
 __ClearPageActive(page);
}

static inline void ClearPageSlabPfmemalloc(struct page *page)
{
 VM_BUG_ON_PAGE(!PageSlab(page), page);
 ClearPageActive(page);
}

#define PAGE_FLAGS_PRIVATE                \
    (1UL << PG_private | 1UL << PG_private_2)

static inline int page_has_private(struct page *page)
{
 return !!(page->flags & PAGE_FLAGS_PRIVATE);
}