​

​

 //kernel/msm-5.4/include/linux/mm_types.h 

//kernel/msm-5.4/include/linux/mmzone.h  struct zone, struct pglist_data
  /*
   * Each physical page in the system has a struct page associated with
   * it to keep track of whatever it is we are using the page for at the
   * moment. Note that we have no way to track which tasks are using
   * a page, though if it is a pagecache page, rmap structures can tell us
   * who is mapping it.
   *
   * If you allocate the page using alloc_pages(), you can use some of the
   * space in struct page for your own purposes.  The five words in the main
   * union are available, except for bit 0 of the first word which must be
   * kept clear.  Many users use this word to store a pointer to an object
   * which is guaranteed to be aligned.  If you use the same storage as
   * page->mapping, you must restore it to NULL before freeing the page.
   *
   * If your page will not be mapped to userspace, you can also use the four
   * bytes in the mapcount union, but you must call page_mapcount_reset()
   * before freeing it.
   *
   * If you want to use the refcount field, it must be used in such a way
   * that other CPUs temporarily incrementing and then decrementing the
   * refcount does not cause problems.  On receiving the page from
   * alloc_pages(), the refcount will be positive.
   *
   * If you allocate pages of order > 0, you can use some of the fields
   * in each subpage, but you may need to restore some of their values
   * afterwards.
   *
   * SLUB uses cmpxchg_double() to atomically update its freelist and
   * counters.  That requires that freelist & counters be adjacent and
   * double-word aligned.  We align all struct pages to double-word
   * boundaries, and ensure that 'freelist' is aligned within the
   * struct.
   */
  #ifdef CONFIG_HAVE_ALIGNED_STRUCT_PAGE
  #define _struct_page_alignment	__aligned(2 * sizeof(unsigned long))//按照2*8B=16B字节对齐
  #else
  #define _struct_page_alignment
  #endif
  
  struct page {
  	unsigned long flags;		/* Atomic flags, some possibly 
  					 * updated asynchronously  描述page的状态和其他信息,
                     关于page的状态标识的具体定义在linux/page-flags.h中*/
    /*对于flags这64比特位的使用大致包括（从比特高位到低位顺序）：
    section，node，zone，last_cpuid和flags这五部分
    其中zone和flags区域是一定有的，其他部分，根据内核的配置不用会有不同的组合。
    至于详细的组合情况，后面会讲  
    */
  	/*
  	 * Five words (20/40 bytes) are available in this union.
  	 * WARNING: bit 0 of the first word is used for PageTail(). That
  	 * means the other users of this union MUST NOT use the bit to
  	 * avoid collision and false-positive PageTail().
  	 */
  	union {
  		struct {	/* Page cache and anonymous pages  跟page cache 和anon page相关的一下参数，这里就包括所有page类型*/
  			/**
  			 * @lru: Pageout list, eg. active_list protected by
  			 * pgdat->lru_lock.  Sometimes used as a generic list
  			 * by the page owner.
  			 */
  			struct list_head lru;
  			/* See page-flags.h for PAGE_MAPPING_FLAGS */
  			struct address_space *mapping;
  			pgoff_t index;		/* Our offset within mapping. */
  			/**
  			 * @private: Mapping-private opaque data.
  			 * Usually used for buffer_heads if PagePrivate.
  			 * Used for swp_entry_t if PageSwapCache.
  			 * Indicates order in the buddy system if PageBuddy.
  			 */
  			unsigned long private;
  		};
  		struct {	/* page_pool used by netstack */
  			/**
  			 * @dma_addr: might require a 64-bit value even on
  			 * 32-bit architectures.
  			 */
  			dma_addr_t dma_addr;
  		};
  		struct {	/* slab, slob and slub */
  			union {
  				struct list_head slab_list;
  				struct {	/* Partial pages */
  					struct page *next;
  #ifdef CONFIG_64BIT
  					int pages;	/* Nr of pages left */
  					int pobjects;	/* Approximate count */
  #else
  					short int pages;
  					short int pobjects;
  #endif
  				};
  			};
  			struct kmem_cache *slab_cache; /* not slob */
  			/* Double-word boundary */
  			void *freelist;		/* first free object */
  			union {
  				void *s_mem;	/* slab: first object */
  				unsigned long counters;		/* SLUB */
  				struct {			/* SLUB */
  					unsigned inuse:16;
  					unsigned objects:15;
  					unsigned frozen:1;
  				};
  			};
  		};
  		struct {	/* Tail pages of compound page */
  			unsigned long compound_head;	/* Bit zero is set */
  
  			/* First tail page only */
  			unsigned char compound_dtor;
  			unsigned char compound_order;
  			atomic_t compound_mapcount;
  		};
  		struct {	/* Second tail page of compound page */
  			unsigned long _compound_pad_1;	/* compound_head */
  			unsigned long _compound_pad_2;
  			/* For both global and memcg */
  			struct list_head deferred_list;
  		};
  		struct {	/* Page table pages */
  			unsigned long _pt_pad_1;	/* compound_head */
  			pgtable_t pmd_huge_pte; /* protected by page->ptl */
  			unsigned long _pt_pad_2;	/* mapping */
  			union {
  				struct mm_struct *pt_mm; /* x86 pgds only */
  				atomic_t pt_frag_refcount; /* powerpc */
  			};
  #if ALLOC_SPLIT_PTLOCKS
  			spinlock_t *ptl;
  #else
  			spinlock_t ptl;
  #endif
  		};
  		struct {	/* ZONE_DEVICE pages */
  			/** @pgmap: Points to the hosting device page map. */
  			struct dev_pagemap *pgmap;
  			void *zone_device_data;
  			/*
  			 * ZONE_DEVICE private pages are counted as being
  			 * mapped so the next 3 words hold the mapping, index,
  			 * and private fields from the source anonymous or
  			 * page cache page while the page is migrated to device
  			 * private memory.
  			 * ZONE_DEVICE MEMORY_DEVICE_FS_DAX pages also
  			 * use the mapping, index, and private fields when
  			 * pmem backed DAX files are mapped.
  			 */
  		};
  
  		/** @rcu_head: You can use this to free a page by RCU. */
  		struct rcu_head rcu_head;
  	};
  
  	union {		/* This union is 4 bytes in size. */
  		/*
  		 * If the page can be mapped to userspace, encodes the number
  		 * of times this page is referenced by a page table.
  		 */
  		atomic_t _mapcount;
  
  		/*
  		 * If the page is neither PageSlab nor mappable to userspace,
  		 * the value stored here may help determine what this page
  		 * is used for.  See page-flags.h for a list of page types
  		 * which are currently stored here.
  		 */
  		unsigned int page_type;
  
  		unsigned int active;		/* SLAB */
  		int units;			/* SLOB */
  	};
  
  	/* Usage count. *DO NOT USE DIRECTLY*. See page_ref.h */
  	atomic_t _refcount;
  
  #ifdef CONFIG_MEMCG
  	struct mem_cgroup *mem_cgroup;
  #endif
  
  	/*
  	 * On machines where all RAM is mapped into kernel address space,
  	 * we can simply calculate the virtual address. On machines with
  	 * highmem some memory is mapped into kernel virtual memory
  	 * dynamically, so we need a place to store that address.
  	 * Note that this field could be 16 bits on x86 ... ;)
  	 *
  	 * Architectures with slow multiplication can define
  	 * WANT_PAGE_VIRTUAL in asm/page.h
  	 */
  #if defined(WANT_PAGE_VIRTUAL)
  	void *virtual;			/* Kernel virtual address (NULL if
  					   not kmapped, ie. highmem) */
  #endif /* WANT_PAGE_VIRTUAL */
  
  #ifdef LAST_CPUPID_NOT_IN_PAGE_FLAGS
  	int _last_cpupid;
  #endif
  } _struct_page_alignment; //意味这个struct page结构体是以16B基本单位进行字节对齐的，根据前面图片所示，该结构体占用64B

//include/linux/page-flags-layout.h
/*
 * page->flags layout:
 *
 * There are five possibilities for how page->flags get laid out.  The first
 * pair is for the normal case without sparsemem. The second pair is for
 * sparsemem when there is plenty of space for node and section information.
 * The last is when there is insufficient space in page->flags and a separate
 * lookup is necessary.
 *
 * No sparsemem or sparsemem vmemmap: |       NODE     | ZONE |             ... | FLAGS |
 *      " plus space for last_cpupid: |       NODE     | ZONE | LAST_CPUPID ... | FLAGS |
 * classic sparse with space for node:| SECTION | NODE | ZONE |             ... | FLAGS |
 *      " plus space for last_cpupid: | SECTION | NODE | ZONE | LAST_CPUPID ... | FLAGS |
 * classic sparse no space for node:  | SECTION |     ZONE    | ... | FLAGS |
 */

//实际上在include/linux/page-flags.h 也有大概介绍，只不过没有那么详细
/*
* 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).
*/

//kernel/msm-5.4/mm/sparse.c
#ifdef NODE_NOT_IN_PAGE_FLAGS
/*
 * If we did not store the node number in the page then we have to
 * do a lookup in the section_to_node_table in order to find which
 * node the page belongs to.
 */
#if MAX_NUMNODES <= 256
static u8 section_to_node_table[NR_MEM_SECTIONS] __cacheline_aligned;
#else
static u16 section_to_node_table[NR_MEM_SECTIONS] __cacheline_aligned;
#endif

int page_to_nid(const struct page *page)
{
//对于这个page_to_section函数在2.1.1 section区域这节有介绍，得到这个页的section_nr
//然后从section_to_node_table数组中得到section_nr对应的nid
	return section_to_node_table[page_to_section(page)];
}
EXPORT_SYMBOL(page_to_nid);

static void set_section_nid(unsigned long section_nr, int nid)
{
	section_to_node_table[section_nr] = nid;
}
#else /* !NODE_NOT_IN_PAGE_FLAGS */
static inline void set_section_nid(unsigned long section_nr, int nid)
{
}
#endif

#if SECTIONS_WIDTH+NODES_WIDTH+ZONES_WIDTH+LAST_CPUPID_WIDTH+KASAN_TAG_WIDTH \
	> BITS_PER_LONG - NR_PAGEFLAGS
#error "Not enough bits in page flags"
#endif

//msm-5.4/include/linux/mm.h 
/*
 * The zone field is never updated after free_area_init_core()
 * sets it, so none of the operations on it need to be atomic.
 */

/* Page flags: | [SECTION] | [NODE] | ZONE | [LAST_CPUPID] | ... | FLAGS | */
#define SECTIONS_PGOFF		((sizeof(unsigned long)*8) - SECTIONS_WIDTH) // 8*8 - SECTIONS_WIDTH, SECTIONS_WIDTH定义在msm-5.4/include/linux/page-flags-layout.h里面
#define NODES_PGOFF		(SECTIONS_PGOFF - NODES_WIDTH)
#define ZONES_PGOFF		(NODES_PGOFF - ZONES_WIDTH)
#define LAST_CPUPID_PGOFF	(ZONES_PGOFF - LAST_CPUPID_WIDTH)
#define KASAN_TAG_PGOFF		(LAST_CPUPID_PGOFF - KASAN_TAG_WIDTH)

/*
 * Define the bit shifts to access each section.  For non-existent
 * sections we define the shift as 0; that plus a 0 mask ensures
 * the compiler will optimise away reference to them. 如果一个字段位0则PGSHIFT则为0
 */
#define SECTIONS_PGSHIFT	(SECTIONS_PGOFF * (SECTIONS_WIDTH != 0))
#define NODES_PGSHIFT		(NODES_PGOFF * (NODES_WIDTH != 0))
#define ZONES_PGSHIFT		(ZONES_PGOFF * (ZONES_WIDTH != 0))
#define LAST_CPUPID_PGSHIFT	(LAST_CPUPID_PGOFF * (LAST_CPUPID_WIDTH != 0))
#define KASAN_TAG_PGSHIFT	(KASAN_TAG_PGOFF * (KASAN_TAG_WIDTH != 0))

/* NODE:ZONE or SECTION:ZONE is used to ID a zone for the buddy allocator */
#ifdef NODE_NOT_IN_PAGE_FLAGS
#define ZONEID_SHIFT		(SECTIONS_SHIFT + ZONES_SHIFT)
#define ZONEID_PGOFF		((SECTIONS_PGOFF < ZONES_PGOFF)? \
						SECTIONS_PGOFF : ZONES_PGOFF)
#else
#define ZONEID_SHIFT		(NODES_SHIFT + ZONES_SHIFT)
#define ZONEID_PGOFF		((NODES_PGOFF < ZONES_PGOFF)? \
						NODES_PGOFF : ZONES_PGOFF)
#endif

#define ZONEID_PGSHIFT		(ZONEID_PGOFF * (ZONEID_SHIFT != 0))

//msm-5.4/include/linux/page-flags-layout.h
/*
 *MAX_PHYSMEM_BITS和SECTION_SIZE_BITS这两个值跟操作系统使用的架构有关
 *对于arm结构，定义值在msm-5.4/arch/arm/include/asm/sparsemem.h里面，分别为36和28。
 *对于arm64结构，定义值在msm-5.4/arch/arm64/include/asm/sparsemem.h里面，MAX_PHYSMEM_BITS可以 
 *设置为48或者52，SECTION_SIZE_BITS可以设置为27或者29。
 *在msm-5.4/arch/arm64/Kconfig里面分别搜索ARM64_PA_BITS和HOTPLUG_SIZE_BITS可以找到对应的设置
*/
/* SECTION_SHIFT	#bits space required to store a section # */
#define SECTIONS_SHIFT	(MAX_PHYSMEM_BITS - SECTION_SIZE_BITS)

//内存模型为非VMEMMAP的稀疏型内存模型，此时是有section区域的，而且SECTIONS_WIDTH就为SECTIONS_SHIFT，否则为0
#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
#define SECTIONS_WIDTH		SECTIONS_SHIFT
#else
#define SECTIONS_WIDTH		0
#endif

//msm-5.4/include/linux/mm.h
#ifdef SECTION_IN_PAGE_FLAGS
//设置page section函数
static inline void set_page_section(struct page *page, unsigned long section)
{
//首先确认是否有section区域，然后再进行设置
	page->flags &= ~(SECTIONS_MASK << SECTIONS_PGSHIFT);
	page->flags |= (section & SECTIONS_MASK) << SECTIONS_PGSHIFT;
}
//获取page section函数
static inline unsigned long page_to_section(const struct page *page)
{
	return (page->flags >> SECTIONS_PGSHIFT) & SECTIONS_MASK;
}
#endif

//msm-5.4/arch/arm64/Kconfig
config NODES_SHIFT
	int "Maximum NUMA Nodes (as a power of 2)"
	range 1 10
	default "2"
	depends on NEED_MULTIPLE_NODES
	help
	  Specify the maximum number of NUMA Nodes available on the target
	  system.  Increases memory reserved to accommodate various tables.

//msm-5.4/include/linux/numa.h
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef _LINUX_NUMA_H
#define _LINUX_NUMA_H


#ifdef CONFIG_NODES_SHIFT
#define NODES_SHIFT     CONFIG_NODES_SHIFT
#else
#define NODES_SHIFT     0
#endif

#define MAX_NUMNODES    (1 << NODES_SHIFT)

#define	NUMA_NO_NODE	(-1)

#endif /* _LINUX_NUMA_H */

//msm-5.4/include/linux/page-flags-layout.h
#if SECTIONS_WIDTH+ZONES_WIDTH+NODES_SHIFT <= BITS_PER_LONG - NR_PAGEFLAGS
#define NODES_WIDTH		NODES_SHIFT
#else
#ifdef CONFIG_SPARSEMEM_VMEMMAP //这个对应前面所说的第五种情况，没有足够空间分配给node区域
#error "Vmemmap: No space for nodes field in page flags"
#endif
#define NODES_WIDTH		0
#endif

//设置page node区域信息
static inline void set_page_node(struct page *page, unsigned long node)
{
//同样也是先确认是否有node区域，再进行设置
	page->flags &= ~(NODES_MASK << NODES_PGSHIFT);
	page->flags |= (node & NODES_MASK) << NODES_PGSHIFT;
}

//获取page node id，如果page->flags里面没有node区域，page_to_nid直接是个空函数
#ifdef NODE_NOT_IN_PAGE_FLAGS
extern int page_to_nid(const struct page *page);
#else
static inline int page_to_nid(const struct page *page)
{
	struct page *p = (struct page *)page;

	return (PF_POISONED_CHECK(p)->flags >> NODES_PGSHIFT) & NODES_MASK;
}
#endif

//根据page_to_nid函数获取的id,在NODE_DATA数组中得到对应的node结构体pg_data_t
static inline pg_data_t *page_pgdat(const struct page *page)
{
	return NODE_DATA(page_to_nid(page));
}

#if MAX_NR_ZONES < 2
#define ZONES_SHIFT 0
#elif MAX_NR_ZONES <= 2
#define ZONES_SHIFT 1
#elif MAX_NR_ZONES <= 4
#define ZONES_SHIFT 2
#elif MAX_NR_ZONES <= 8
#define ZONES_SHIFT 3
#else
#error ZONES_SHIFT -- too many zones configured adjust calculation
#endif

#define ZONES_WIDTH		ZONES_SHIFT

//设置page zone区域
static inline void set_page_zone(struct page *page, enum zone_type zone)
{
//首先判断是否存下zone区域，再进行设置
	page->flags &= ~(ZONES_MASK << ZONES_PGSHIFT);
	page->flags |= (zone & ZONES_MASK) << ZONES_PGSHIFT;
}

/*
 * The identification function is mainly used by the buddy allocator for
 * determining if two pages could be buddies. We are not really identifying
 * the zone since we could be using the section number id if we do not have
 * node id available in page flags.
 * We only guarantee that it will return the same value for two combinable
 * pages in a zone.
 */
//获取page zone id
static inline int page_zone_id(struct page *page)
{
	return (page->flags >> ZONEID_PGSHIFT) & ZONEID_MASK;
}

//获取该page zone对应的struct zone结构体信息，因为zone是挂在node下面的，所以可以通过page对应的node找到对应zone结构体信息
static inline struct zone *page_zone(const struct page *page)
{
	return &NODE_DATA(page_to_nid(page))->node_zones[page_zonenum(page)];
}

//msm-5.4/arch/arm64/Kconfig
config NR_CPUS
	int "Maximum number of CPUs (2-4096)"
	range 2 4096
	default "256"

//msm-5.4/kernel/bounds.c
#ifdef CONFIG_SMP //正常CPU一般是8核的，即NR_CPUS_BITS为8
	DEFINE(NR_CPUS_BITS, ilog2(CONFIG_NR_CPUS));
#endif


#ifdef CONFIG_NUMA_BALANCING
#define LAST__PID_SHIFT 8
#define LAST__PID_MASK  ((1 << LAST__PID_SHIFT)-1)

#define LAST__CPU_SHIFT NR_CPUS_BITS
#define LAST__CPU_MASK  ((1 << LAST__CPU_SHIFT)-1)

#define LAST_CPUPID_SHIFT (LAST__PID_SHIFT+LAST__CPU_SHIFT)
#else
#define LAST_CPUPID_SHIFT 0
#endif

#ifdef CONFIG_KASAN_SW_TAGS
#define KASAN_TAG_WIDTH 8
#else
#define KASAN_TAG_WIDTH 0
#endif

//会进行bit位长度判断，避免超限
#if SECTIONS_WIDTH+ZONES_WIDTH+NODES_SHIFT+LAST_CPUPID_SHIFT+KASAN_TAG_WIDTH \
	<= BITS_PER_LONG - NR_PAGEFLAGS
#define LAST_CPUPID_WIDTH LAST_CPUPID_SHIFT
#else
#define LAST_CPUPID_WIDTH 0
#endif

#ifdef LAST_CPUPID_NOT_IN_PAGE_FLAGS
static inline int page_cpupid_xchg_last(struct page *page, int cpupid)
{
	return xchg(&page->_last_cpupid, cpupid & LAST_CPUPID_MASK);
}
//如果page->flags里面没有LAST_CPUPID区域，则直接从page->_last_cpupid获取last_cpupid
static inline int page_cpupid_last(struct page *page)
{
	return page->_last_cpupid;
}
//设置last_cpupid
static inline void page_cpupid_reset_last(struct page *page)
{
	page->_last_cpupid = -1 & LAST_CPUPID_MASK;
}
#else
//page->flags里面有LAST_CPUPID区域，获取last_cpupid
static inline int page_cpupid_last(struct page *page)
{
	return (page->flags >> LAST_CPUPID_PGSHIFT) & LAST_CPUPID_MASK;
}

extern int page_cpupid_xchg_last(struct page *page, int cpupid);
//设置last_cpupid
static inline void page_cpupid_reset_last(struct page *page)
{
	page->flags |= LAST_CPUPID_MASK << LAST_CPUPID_PGSHIFT;
}
#endif /* LAST_CPUPID_NOT_IN_PAGE_FLAGS */

/*
 * Macros to create function definitions for page flags
 */
#define TESTPAGEFLAG(uname, lname, policy)				\
static __always_inline int Page##uname(struct page *page)		\
	{ return test_bit(PG_##lname, &policy(page, 0)->flags); }

#define SETPAGEFLAG(uname, lname, policy)				\
static __always_inline void SetPage##uname(struct page *page)		\
	{ set_bit(PG_##lname, &policy(page, 1)->flags); }

#define CLEARPAGEFLAG(uname, lname, policy)				\
static __always_inline void ClearPage##uname(struct page *page)		\
	{ clear_bit(PG_##lname, &policy(page, 1)->flags); }

#define __SETPAGEFLAG(uname, lname, policy)				\
static __always_inline void __SetPage##uname(struct page *page)		\
	{ __set_bit(PG_##lname, &policy(page, 1)->flags); }

#define __CLEARPAGEFLAG(uname, lname, policy)				\
static __always_inline void __ClearPage##uname(struct page *page)	\
	{ __clear_bit(PG_##lname, &policy(page, 1)->flags); }

#define TESTSETFLAG(uname, lname, policy)				\
static __always_inline int TestSetPage##uname(struct page *page)	\
	{ return test_and_set_bit(PG_##lname, &policy(page, 1)->flags); }

#define TESTCLEARFLAG(uname, lname, policy)				\
static __always_inline int TestClearPage##uname(struct page *page)	\
	{ return test_and_clear_bit(PG_##lname, &policy(page, 1)->flags); }
......

struct {	/* Page cache and anonymous pages  跟page cache 和anon page相关的一下参数*/
	/**
	 * @lru: Pageout list, eg. active_list protected by
	 * pgdat->lru_lock.  Sometimes used as a generic list
	 * by the page owner.
	 */
	struct list_head lru;
	/* See page-flags.h for PAGE_MAPPING_FLAGS */
	struct address_space *mapping;
	pgoff_t index;		/* Our offset within mapping. */
	/**
	 * @private: Mapping-private opaque data.
	 * Usually used for buffer_heads if PagePrivate.
	 * Used for swp_entry_t if PageSwapCache.
	 * Indicates order in the buddy system if PageBuddy.
	 */
	unsigned long private;
};

/*
 * On an anonymous page mapped into a user virtual memory area,
 * page->mapping points to its anon_vma, not to a struct address_space;
 * with the PAGE_MAPPING_ANON bit set to distinguish it.  See rmap.h.
 *
 * On an anonymous page in a VM_MERGEABLE area, if CONFIG_KSM is enabled,
 * the PAGE_MAPPING_MOVABLE bit may be set along with the PAGE_MAPPING_ANON
 * bit; and then page->mapping points, not to an anon_vma, but to a private
 * structure which KSM associates with that merged page.  See ksm.h.
 *
 * PAGE_MAPPING_KSM without PAGE_MAPPING_ANON is used for non-lru movable
 * page and then page->mapping points a struct address_space.
 *
 * Please note that, confusingly, "page_mapping" refers to the inode
 * address_space which maps the page from disk; whereas "page_mapped"
 * refers to user virtual address space into which the page is mapped.
 */
#define PAGE_MAPPING_ANON	0x1
#define PAGE_MAPPING_MOVABLE	0x2
#define PAGE_MAPPING_KSM	(PAGE_MAPPING_ANON | PAGE_MAPPING_MOVABLE)
#define PAGE_MAPPING_FLAGS	(PAGE_MAPPING_ANON | PAGE_MAPPING_MOVABLE)

//判断是否是anon page
static __always_inline int PageAnon(struct page *page)
{
//如果这个页是复合页的话，首先找到这个page的复合页的head page，对于复合页，这个信息是保存在head page的
	page = compound_head(page);
	return ((unsigned long)page->mapping & PAGE_MAPPING_ANON) != 0;
}

//判断是否是可movable的page
static __always_inline int __PageMovable(struct page *page)
{
	return ((unsigned long)page->mapping & PAGE_MAPPING_FLAGS) ==
				PAGE_MAPPING_MOVABLE;
}

//从这里可以看到，此时mapping指向的是struct anon_vma *，得到anon page被映射时对应的映射地址空间
struct anon_vma *page_anon_vma(struct page *page)
{
    unsigned long mapping;

    page = compound_head(page);
    mapping = (unsigned long)page->mapping;
//如果不是anon映射，直接返回null
    if ((mapping & PAGE_MAPPING_FLAGS) != PAGE_MAPPING_ANON)
        return NULL;
    return __page_rmapping(page);
}

//从这里可以看到，此时mapping指向的是struct address_space *，得到page cache被映射是对应的映射地址空间
struct address_space *page_mapping(struct page *page)
{
    struct address_space *mapping;

    page = compound_head(page);

    /* This happens if someone calls flush_dcache_page on slab page */
    if (unlikely(PageSlab(page)))
        return NULL;

    if (unlikely(PageSwapCache(page))) {
        swp_entry_t entry;

        entry.val = page_private(page);
        return swap_address_space(entry);
    }

    mapping = page->mapping;
//如果不是文件映射，是anon映射，直接返回null
    if ((unsigned long)mapping & PAGE_MAPPING_ANON)
        return NULL;

    return (void *)((unsigned long)mapping & ~PAGE_MAPPING_FLAGS);
}
EXPORT_SYMBOL(page_mapping);

//msm-5.4/include/linux/page-flags.h
/*
 * For pages that are never mapped to userspace (and aren't PageSlab),
 * page_type may be used.  Because it is initialised to -1, we invert the
 * sense of the bit, so __SetPageFoo *clears* the bit used for PageFoo, and
 * __ClearPageFoo *sets* the bit used for PageFoo.  We reserve a few high and
 * low bits so that an underflow or overflow of page_mapcount() won't be
 * mistaken for a page type value.
 */

#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

//对于page->page_type这个参数，后面会介绍
#define PageType(page, flag)						\
	((page->page_type & (PAGE_TYPE_BASE | flag)) == PAGE_TYPE_BASE)

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

#define PAGE_TYPE_OPS(uname, lname)					\
static __always_inline int Page##uname(struct page *page)		\
{									\
	return PageType(page, PG_##lname);				\
}									\
static __always_inline void __SetPage##uname(struct page *page)		\
{									\
	VM_BUG_ON_PAGE(!PageType(page, 0), page);			\
	page->page_type &= ~PG_##lname;					\
}									\
static __always_inline void __ClearPage##uname(struct page *page)	\
{									\
	VM_BUG_ON_PAGE(!Page##uname(page), page);			\
	page->page_type |= PG_##lname;					\
}

//在这里使用的PageBuddy,然后调用上面的Page##uname函数
/*
 * PageBuddy() indicates that the page is free and in the buddy system
 * (see mm/page_alloc.c).
 */
PAGE_TYPE_OPS(Buddy, buddy)

struct {	/* page_pool used by netstack */
 			/**
  			 * @dma_addr: might require a 64-bit value even on
  			 * 32-bit architectures.
  			 */
  			dma_addr_t dma_addr;
};

//跟slab内存管理机制强相关的参数结构体，当前系统中，我们一般都是slub分配算法
        struct {    /* slab, slob and slub */
            union {
                struct list_head slab_list; 
                struct {    /* Partial pages */ //这个结构体主要用于CPU partial里面的page的
                    struct page *next; 
  #ifdef CONFIG_64BIT
                    
                    int pages;  /* Nr of pages left */ 
                    int pobjects;   /* Approximate count */ 
  #else
                    short int pages;
                    short int pobjects;
  #endif
                };
            };
            struct kmem_cache *slab_cache; /* not slob */
            /* Double-word boundary */
            void *freelist;     /* first free object */
            union {
                void *s_mem;    /* slab: first object */
                unsigned long counters;     /* SLUB */
                struct {            /* SLUB */
                    unsigned inuse:16; 
                    unsigned objects:15;
                    unsigned frozen:1;
                };
            };
        };

struct {    /* Tail pages of compound page */
    unsigned long compound_head;    /* Bit zero is set */

    /* First tail page only */
    unsigned char compound_dtor;
    unsigned char compound_order;
    atomic_t compound_mapcount;
};

//得到复合页的head page
static inline struct page *compound_head(struct page *page)
{
	unsigned long head = READ_ONCE(page->compound_head);
//如果page->compound_head为不为0，则这个页是tail page，直接返回它的上一页（head-1）
	if (unlikely(head & 1))
		return (struct page *) (head - 1);
//否则，该页就是head page
	return page;
}

//判断该page是否是tail page，page->compound_head不为0，则这个页是tail page
static __always_inline int PageTail(struct page *page)
{
	return READ_ONCE(page->compound_head) & 1;
}
//判断该page是否是复合页，要么该page是head page（通过page->flags是不是PG_head），要么该page是tail page
static __always_inline int PageCompound(struct page *page)
{
	return test_bit(PG_head, &page->flags) || PageTail(page);
}

//msm-5.19/mm/page_alloc.c
//在这里会进行compound_page_dtors定义和初始化
compound_page_dtor * const compound_page_dtors[NR_COMPOUND_DTORS] = {
    [NULL_COMPOUND_DTOR] = NULL,
    [COMPOUND_PAGE_DTOR] = free_compound_page,//这个free_compound_page就是释放函数，下面的两个free_xx也是
#ifdef CONFIG_HUGETLB_PAGE
    [HUGETLB_PAGE_DTOR] = free_huge_page,
#endif
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
    [TRANSHUGE_PAGE_DTOR] = free_transhuge_page,
#endif
};

//msm-5.19/include/linux/mm.h 比较奇怪的是，在msm-5.4中，没有定义这个destroy_compound_page函数，不知道5.4版本是怎么析构复合页
/*
 * Compound pages have a destructor function.  Provide a
 * prototype for that function and accessor functions.
 * These are _only_ valid on the head of a compound page.
 */
typedef void compound_page_dtor(struct page *);

/* Keep the enum in sync with compound_page_dtors array in mm/page_alloc.c */
enum compound_dtor_id {
    NULL_COMPOUND_DTOR,
    COMPOUND_PAGE_DTOR,
#ifdef CONFIG_HUGETLB_PAGE
    HUGETLB_PAGE_DTOR,
#endif
#if defined(CONFIG_TRANSPARENT_HUGEPAGE) || defined(CONFIG_GKI_OPT_FEATURES)
    TRANSHUGE_PAGE_DTOR,
#endif
    NR_COMPOUND_DTORS,
};

//这里通过extern关键词，告诉编译器，这个compound_page_dtors数组在其他地方（mm/page_alloc.c）有定义
extern compound_page_dtor * const compound_page_dtors[NR_COMPOUND_DTORS];

//析构函数的实现
static inline void destroy_compound_page(struct page *page)
{
//如果compound_dtor类型超过前面的枚举类型范围，会报kernel bug
    VM_BUG_ON_PAGE(page[1].compound_dtor >= NR_COMPOUND_DTORS, page);
//在compound_page_dtors数组里面找到对应的析构函数，然后进行复合页的free
    compound_page_dtors[page[1].compound_dtor](page);
}

//include/linux/mm.h
//下面就是获取page order的方式
static inline unsigned int compound_order(struct page *page)
{
//从这里就可看出，如果这个页不是head page，直接返回0。这里需要head page,才好后面直接用page[1]表示为第一个tail page
	if (!PageHead(page))
		return 0;
//否则，返回compound_order参数，得到复合页的阶数，
//这在slab内存管理机制中也有使用，用于获取阶数
//SLUB内存管理的4个主要接口函数介绍(2)(3)均使用了这个函数
	return page[1].compound_order;
}

//include/linux/mm_types.h
static inline atomic_t *compound_mapcount_ptr(struct page *page)
{
	return &page[1].compound_mapcount;
}

//include/linux/mm.h
/*
 * Mapcount of compound page as a whole, does not include mapped sub-pages.
 *
 * Must be called only for compound pages or any their tail sub-pages.
 */
static inline int compound_mapcount(struct page *page)
{
//首先判读是否是复合页，不是则直接bug on，退出，是则继续
	VM_BUG_ON_PAGE(!PageCompound(page), page);
//得到这个page所在复合页里面的head page
	page = compound_head(page);
//调用compound_mapcount_ptr函数，得到compound_mapcount值，因为是从0开始计数的，实际的复合页的mapcount需要+1,下面_mapcount有介绍
	return atomic_read(compound_mapcount_ptr(page)) + 1;
}