enum zone_type

{

#ifdef CONFIG_ZONE_DMA

    ZONE_DMA,

#endif

#ifdef CONFIG_ZONE_DMA32

    ZONE_DMA32,

#endif

    ZONE_NORMAL,

#ifdef CONFIG_HIGHMEM

    ZONE_HIGHMEM,

#endif

    ZONE_MOVABLE,

#ifdef CONFIG_ZONE_DEVICE

    ZONE_DEVICE,

#endif

    __MAX_NR_ZONES

};

struct zone

{

    /* Read-mostly fields */

    /* zone watermarks, access with *_wmark_pages(zone) macros */

    unsigned long watermark[NR_WMARK];

    unsigned long nr_reserved_highatomic;

    /*

     * We don't know if the memory that we're going to allocate will be

     * freeable or/and it will be released eventually, so to avoid totally

     * wasting several GB of ram we must reserve some of the lower zone

     * memory (otherwise we risk to run OOM on the lower zones despite

     * there being tons of freeable ram on the higher zones).  This array is

     * recalculated at runtime if the sysctl_lowmem_reserve_ratio sysctl

     * changes.

     * 分别为各种内存域指定了若干页

     * 用于一些无论如何都不能失败的关键性内存分配。

     */

    long lowmem_reserve[MAX_NR_ZONES];

#ifdef CONFIG_NUMA

    int node;

#endif

    /*

     * The target ratio of ACTIVE_ANON to INACTIVE_ANON pages on

     * this zone's LRU.  Maintained by the pageout code.

     * 不活动页的比例,

     * 接着是一些很少使用或者大部分情况下是只读的字段：

     * wait_table wait_table_hash_nr_entries wait_table_bits

     * 形成等待列队，可以等待某一页可供进程使用  */

    unsigned int inactive_ratio;

    /*  指向这个zone所在的pglist_data对象  */

    struct pglist_data      *zone_pgdat;

    /*/这个数组用于实现每个CPU的热/冷页帧列表。内核使用这些列表来保存可用于满足实现的“新鲜”页。但冷热页帧对应的高速缓存状态不同：有些页帧很可能在高速缓存中，因此可以快速访问，故称之为热的；未缓存的页帧与此相对，称之为冷的。*/

    struct per_cpu_pageset __percpu *pageset;

    /*

     * This is a per-zone reserve of pages that are not available

     * to userspace allocations.

     * 每个区域保留的不能被用户空间分配的页面数目

     */

    unsigned long       totalreserve_pages;

#ifndef CONFIG_SPARSEMEM

    /*

     * Flags for a pageblock_nr_pages block. See pageblock-flags.h.

     * In SPARSEMEM, this map is stored in struct mem_section

     */

    unsigned long       *pageblock_flags;

#endif /* CONFIG_SPARSEMEM */

#ifdef CONFIG_NUMA

    /*

     * zone reclaim becomes active if more unmapped pages exist.

     */

    unsigned long       min_unmapped_pages;

    unsigned long       min_slab_pages;

#endif /* CONFIG_NUMA */

    /* zone_start_pfn == zone_start_paddr >> PAGE_SHIFT

     * 只内存域的第一个页帧 */

    unsigned long       zone_start_pfn;

    /*

     * spanned_pages is the total pages spanned by the zone, including

     * holes, which is calculated as:

     *      spanned_pages = zone_end_pfn - zone_start_pfn;

     *

     * present_pages is physical pages existing within the zone, which

     * is calculated as:

     *      present_pages = spanned_pages - absent_pages(pages in holes);

     *

     * managed_pages is present pages managed by the buddy system, which

     * is calculated as (reserved_pages includes pages allocated by the

     * bootmem allocator):

     *      managed_pages = present_pages - reserved_pages;

     *

     * So present_pages may be used by memory hotplug or memory power

     * management logic to figure out unmanaged pages by checking

     * (present_pages - managed_pages). And managed_pages should be used

     * by page allocator and vm scanner to calculate all kinds of watermarks

     * and thresholds.

     *

     * Locking rules:

     *

     * zone_start_pfn and spanned_pages are protected by span_seqlock.

     * It is a seqlock because it has to be read outside of zone->lock,

     * and it is done in the main allocator path.  But, it is written

     * quite infrequently.

     *

     * The span_seq lock is declared along with zone->lock because it is

     * frequently read in proximity to zone->lock.  It's good to

     * give them a chance of being in the same cacheline.

     *

     * Write access to present_pages at runtime should be protected by

     * mem_hotplug_begin/end(). Any reader who can't tolerant drift of

     * present_pages should get_online_mems() to get a stable value.

     *

     * Read access to managed_pages should be safe because it's unsigned

     * long. Write access to zone->managed_pages and totalram_pages are

     * protected by managed_page_count_lock at runtime. Idealy only

     * adjust_managed_page_count() should be used instead of directly

     * touching zone->managed_pages and totalram_pages.

     */

    unsigned long       managed_pages;

    unsigned long       spanned_pages;             /*  总页数，包含空洞  */

    unsigned long       present_pages;              /*  可用页数，不包哈空洞  */

    /*  指向管理区的传统名字, "DMA", "NROMAL"或"HIGHMEM" */

    const char          *name;

#ifdef CONFIG_MEMORY_ISOLATION

    /*

     * Number of isolated pageblock. It is used to solve incorrect

     * freepage counting problem due to racy retrieving migratetype

     * of pageblock. Protected by zone->lock.

     */

    unsigned long       nr_isolate_pageblock;

#endif

#ifdef CONFIG_MEMORY_HOTPLUG

    /* see spanned/present_pages for more description */

    seqlock_t           span_seqlock;

#endif

    /*

     * wait_table       -- the array holding the hash table

     * wait_table_hash_nr_entries   -- the size of the hash table array

     * wait_table_bits      -- wait_table_size == (1 << wait_table_bits)

     *

     * The purpose of all these is to keep track of the people

     * waiting for a page to become available and make them

     * runnable again when possible. The trouble is that this

     * consumes a lot of space, especially when so few things

     * wait on pages at a given time. So instead of using

     * per-page waitqueues, we use a waitqueue hash table.

     *

     * The bucket discipline is to sleep on the same queue when

     * colliding and wake all in that wait queue when removing.

     * When something wakes, it must check to be sure its page is

     * truly available, a la thundering herd. The cost of a

     * collision is great, but given the expected load of the

     * table, they should be so rare as to be outweighed by the

     * benefits from the saved space.

     *

     * __wait_on_page_locked() and unlock_page() in mm/filemap.c, are the

     * primary users of these fields, and in mm/page_alloc.c

     * free_area_init_core() performs the initialization of them.

     */

    /*  进程等待队列的散列表, 这些进程正在等待管理区中的某页  */

    wait_queue_head_t       *wait_table;

    /*  等待队列散列表中的调度实体数目  */

    unsigned long       wait_table_hash_nr_entries;

    /*  等待队列散列表数组大小, 值为2^order  */

    unsigned long       wait_table_bits;

    ZONE_PADDING(_pad1_)

    /* free areas of different sizes

       页面使用状态的信息，以每个bit标识对应的page是否可以分配

       是用于伙伴系统的，每个数组元素指向对应阶也表的数组开头

       以下是供页帧回收扫描器(page reclaim scanner)访问的字段

       scanner会跟据页帧的活动情况对内存域中使用的页进行编目

       如果页帧被频繁访问，则是活动的，相反则是不活动的，

       在需要换出页帧时，这样的信息是很重要的：   */

    struct free_area    free_area[MAX_ORDER];

    /* zone flags, see below 描述当前内存的状态, 参见下面的enum zone_flags结构 */

    unsigned long       flags;

    /* Write-intensive fields used from the page allocator, 保存该描述符的自旋锁  */

    spinlock_t          lock;

    ZONE_PADDING(_pad2_)

    /* Write-intensive fields used by page reclaim */

    /* Fields commonly accessed by the page reclaim scanner */

    spinlock_t          lru_lock;   /* LRU(最近最少使用算法)活动以及非活动链表使用的自旋锁  */

    struct lruvec       lruvec;

    /*

     * When free pages are below this point, additional steps are taken

     * when reading the number of free pages to avoid per-cpu counter

     * drift allowing watermarks to be breached

     * 在空闲页的数目少于这个点percpu_drift_mark的时候

     * 当读取和空闲页数一样的内存页时，系统会采取额外的工作，

     * 防止单CPU页数漂移，从而导致水印被破坏。

     */

    unsigned long percpu_drift_mark;

#if defined CONFIG_COMPACTION || defined CONFIG_CMA

    /* pfn where compaction free scanner should start */

    unsigned long       compact_cached_free_pfn;

    /* pfn where async and sync compaction migration scanner should start */

    unsigned long       compact_cached_migrate_pfn[];

#endif

#ifdef CONFIG_COMPACTION

    /*

     * On compaction failure, 1<<compact_defer_shift compactions

     * are skipped before trying again. The number attempted since

     * last failure is tracked with compact_considered.

     */

    unsigned int        compact_considered;

    unsigned int        compact_defer_shift;

    int                       compact_order_failed;

#endif

#if defined CONFIG_COMPACTION || defined CONFIG_CMA

    /* Set to true when the PG_migrate_skip bits should be cleared */

    bool            compact_blockskip_flush;

#endif

    bool            contiguous;

    ZONE_PADDING(_pad3_)

    /* Zone statistics 内存域的统计信息, 参见后面的enum zone_stat_item结构 */

    atomic_long_t       vm_stat[NR_VM_ZONE_STAT_ITEMS];

} ____cacheline_internodealigned_in_smp;

/*

 * zone->lock and zone->lru_lock are two of the hottest locks in the kernel.

 * So add a wild amount of padding here to ensure that they fall into separate

 * cachelines.  There are very few zone structures in the machine, so space

 * consumption is not a concern here.

     */

#if defined(CONFIG_SMP)

    struct zone_padding

    {

            char x[];

    } ____cacheline_internodealigned_in_smp;

    #define ZONE_PADDING(name)      struct zone_padding name;

#else

    #define ZONE_PADDING(name)

 #endif

#if !defined(____cacheline_internodealigned_in_smp)

    #if defined(CONFIG_SMP)

        #define ____cacheline_internodealigned_in_smp \

        __attribute__((__aligned__( << (INTERNODE_CACHE_SHIFT))))

    #else

        #define ____cacheline_internodealigned_in_smp

    #endif

#endif

enum zone_watermarks

{

        WMARK_MIN,

        WMARK_LOW,

        WMARK_HIGH,

        NR_WMARK

};

#define min_wmark_pages(z) (z->watermark[WMARK_MIN])

#define low_wmark_pages(z) (z->watermark[WMARK_LOW])

#define high_wmark_pages(z) (z->watermark[WMARK_HIGH])

typedef struct zone_watermarks_s

{

    unsigned long min, low, high;

} zone_watermarks_t;

typedef struct zone_struct {

    zone_watermarks_t       watermarks[MAX_NR_ZONES];

//  http://lxr.free-electrons.com/source/include/linux/mmzone.h#L475

struct zone

{

    /* zone flags, see below */

    unsigned long           flags;

}

enum zone_flags

{

    ZONE_RECLAIM_LOCKED,         /* prevents concurrent reclaim */

    ZONE_OOM_LOCKED,               /* zone is in OOM killer zonelist 内存域可被回收*/

    ZONE_CONGESTED,                 /* zone has many dirty pages backed by

                                                    * a congested BDI

                                                    */

    ZONE_DIRTY,                           /* reclaim scanning has recently found

                                                   * many dirty file pages at the tail

                                                   * of the LRU.

                                                   */

    ZONE_WRITEBACK,                 /* reclaim scanning has recently found

                                                   * many pages under writeback

                                                   */

    ZONE_FAIR_DEPLETED,           /* fair zone policy batch depleted */

};

//  http://lxr.free-electrons.com/source/include/linux/mmzone.h#L522

struct zone

{

      atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];

}

enum zone_stat_item

{

    /* First 128 byte cacheline (assuming 64 bit words) */

    NR_FREE_PAGES,

    NR_ALLOC_BATCH,

    NR_LRU_BASE,

    NR_INACTIVE_ANON = NR_LRU_BASE, /* must match order of LRU_[IN]ACTIVE */

    NR_ACTIVE_ANON,         /*  "     "     "   "       "         */

    NR_INACTIVE_FILE,       /*  "     "     "   "       "         */

    NR_ACTIVE_FILE,         /*  "     "     "   "       "         */

    NR_UNEVICTABLE,         /*  "     "     "   "       "         */

    NR_MLOCK,               /* mlock()ed pages found and moved off LRU */

    NR_ANON_PAGES,  /* Mapped anonymous pages */

    NR_FILE_MAPPED, /* pagecache pages mapped into pagetables.

                       only modified from process context */

    NR_FILE_PAGES,

    NR_FILE_DIRTY,

    NR_WRITEBACK,

    NR_SLAB_RECLAIMABLE,

    NR_SLAB_UNRECLAIMABLE,

    NR_PAGETABLE,           /* used for pagetables */

    NR_KERNEL_STACK,

    /* Second 128 byte cacheline */

    NR_UNSTABLE_NFS,        /* NFS unstable pages */

    NR_BOUNCE,

    NR_VMSCAN_WRITE,

    NR_VMSCAN_IMMEDIATE,    /* Prioritise for reclaim when writeback ends */

    NR_WRITEBACK_TEMP,      /* Writeback using temporary buffers */

    NR_ISOLATED_ANON,       /* Temporary isolated pages from anon lru */

    NR_ISOLATED_FILE,       /* Temporary isolated pages from file lru */

    NR_SHMEM,               /* shmem pages (included tmpfs/GEM pages) */

    NR_DIRTIED,             /* page dirtyings since bootup */

    NR_WRITTEN,             /* page writings since bootup */

    NR_PAGES_SCANNED,       /* pages scanned since last reclaim */

#ifdef CONFIG_NUMA

    NUMA_HIT,               /* allocated in intended node */

    NUMA_MISS,              /* allocated in non intended node */

    NUMA_FOREIGN,           /* was intended here, hit elsewhere */

    NUMA_INTERLEAVE_HIT,    /* interleaver preferred this zone */

    NUMA_LOCAL,             /* allocation from local node */

    NUMA_OTHER,             /* allocation from other node */

#endif

    WORKINGSET_REFAULT,

    WORKINGSET_ACTIVATE,

    WORKINGSET_NODERECLAIM,

    NR_ANON_TRANSPARENT_HUGEPAGES,

    NR_FREE_CMA_PAGES,

    NR_VM_ZONE_STAT_ITEMS

};

struct zone

{

    wait_queue_head_t       *wait_table;

    unsigned long               wait_table_hash_nr_entries;

    unsigned long               wait_table_bits;

}

struct zone

{

    struct per_cpu_pageset __percpu *pageset;

};

struct per_cpu_pageset {

       struct per_cpu_pages pcp;

#ifdef CONFIG_NUMA

       s8 expire;

#endif

#ifdef CONFIG_SMP

       s8 stat_threshold;

       s8 vm_stat_diff[NR_VM_ZONE_STAT_ITEMS];

#endif

};

struct per_cpu_pages {

    int count;              /* number of pages in the list 列表中的页数  */

    int high;               /* high watermark, emptying needed 页数上限水印, 在需要的情况清空列表  */

    int batch;              /* chunk size for buddy add/remove,  添加/删除多页块的时候, 块的大小  */

    /* Lists of pages, one per migrate type stored on the pcp-lists 页的链表*/

       struct list_head lists[MIGRATE_PCPTYPES];

};

unsigned long max_low_pfn;

unsigned long min_low_pfn;

unsigned long max_pfn;

unsigned long long max_possible_pfn;

/*

 *

 * The zone_table array is used to look up the address of the

 * struct zone corresponding to a given zone number (ZONE_DMA,

 * ZONE_NORMAL, or ZONE_HIGHMEM).

 */

zone_t *zone_table[MAX_NR_ZONES*MAX_NR_NODES];

EXPORT_SYMBOL(zone_table);

enum

{

    ZONELIST_FALLBACK,      /* zonelist with fallback */

#ifdef CONFIG_NUMA

    /*

     * The NUMA zonelists are doubled because we need zonelists that

     * restrict the allocations to a single node for __GFP_THISNODE.

     */

    ZONELIST_NOFALLBACK,    /* zonelist without fallback (__GFP_THISNODE) */

#endif

    MAX_ZONELISTS

};

/*

 * One allocation request operates on a zonelist. A zonelist

 * is a list of zones, the first one is the 'goal' of the

 * allocation, the other zones are fallback zones, in decreasing

 * priority.

 *

 * To speed the reading of the zonelist, the zonerefs contain the zone index

 * of the entry being read. Helper functions to access information given

 * a struct zoneref are

 *

 * zonelist_zone()      - Return the struct zone * for an entry in _zonerefs

 * zonelist_zone_idx()  - Return the index of the zone for an entry

 * zonelist_node_idx()  - Return the index of the node for an entry

 */

struct zonelist {

    struct zoneref _zonerefs[MAX_ZONES_PER_ZONELIST + ];

};

而struct zoneref结构的定义如下include/linux/mmzone.h?v=4.7, line 

/*

 * This struct contains information about a zone in a zonelist. It is stored

 * here to avoid dereferences into large structures and lookups of tables

 */

struct zoneref {

    struct zone *zone;      /* Pointer to actual zone */

    int zone_idx;       /* zone_idx(zoneref->zone) */

};

// http://lxr.free-electrons.com/source/mm/page_alloc.c?v=4.7#L4551

#define ZONELIST_ORDER_DEFAULT  0 /* 智能选择Node或Zone方式 */

#define ZONELIST_ORDER_NODE     1 /* 对应Node方式 */

#define ZONELIST_ORDER_ZONE     2 /* 对应Zone方式 */

//  http://lxr.free-electrons.com/source/mm/page_alloc.c?v=4.7#L4564

/* zonelist order in the kernel.

 * set_zonelist_order() will set this to NODE or ZONE.

 */

static int current_zonelist_order = ZONELIST_ORDER_DEFAULT;

static char zonelist_order_name[][] = {"Default", "Node", "Zone"};