一文掌握 Linux 内存管理

void detect_memory(void)
{
 detect_memory_e820();

 detect_memory_e801();

 detect_memory_88();
}

static void detect_memory_e820(void)
{
 int count = 0;
 struct biosregs ireg, oreg;
 struct boot_e820_entry *desc = boot_params.e820_table;
 static struct boot_e820_entry buf; /* static so it is zeroed */

 initregs(&ireg);
 ireg.ax  = 0xe820;
 ireg.cx  = sizeof(buf);
 ireg.edx = SMAP;
 ireg.di  = (size_t)&buf;

 do {
  intcall(0x15, &ireg, &oreg);
  ireg.ebx = oreg.ebx; /* for next iteration... */

  if (oreg.eflags & X86_EFLAGS_CF)
   break;

  if (oreg.eax != SMAP) {
   count = 0;
   break;
  }

  *desc++ = buf;
  count++;
 } while (ireg.ebx && count < ARRAY_SIZE(boot_params.e820_table));

 boot_params.e820_entries = count;
}

start_kernel() -> setup_arch() -> setup_memory_map()
void __init e820__memory_setup(void)
{
 char *who;

 BUILD_BUG_ON(sizeof(struct boot_e820_entry) != 20);

 who = x86_init.resources.memory_setup();

 memcpy(e820_table_kexec, e820_table, sizeof(*e820_table_kexec));
 memcpy(e820_table_firmware, e820_table, sizeof(*e820_table_firmware));

 pr_info("BIOS-provided physical RAM map:\n");
 e820__print_table(who);
}

struct x86_init_ops x86_init __initdata = {

 .resources = {
  .probe_roms  = probe_roms,
  .reserve_resources = reserve_standard_io_resources,
  .memory_setup  = e820__memory_setup_default,
 },
 ......
}

char *__init e820__memory_setup_default(void)
{
 char *who = "BIOS-e820";

 /*
  * Try to copy the BIOS-supplied E820-map.
  *
  * Otherwise fake a memory map; one section from 0k->640k,
  * the next section from 1mb->appropriate_mem_k
  */
 if (append_e820_table(boot_params.e820_table, boot_params.e820_entries) < 0) {
  u64 mem_size;

  /* Compare results from other methods and take the one that gives more RAM: */
  if (boot_params.alt_mem_k < boot_params.screen_info.ext_mem_k) {
   mem_size = boot_params.screen_info.ext_mem_k;
   who = "BIOS-88";
  } else {
   mem_size = boot_params.alt_mem_k;
   who = "BIOS-e801";
  }

  e820_table->nr_entries = 0;
  e820__range_add(0, LOWMEMSIZE(), E820_TYPE_RAM);
  e820__range_add(HIGH_MEMORY, mem_size << 10, E820_TYPE_RAM);
 }

 /* We just appended a lot of ranges, sanitize the table: */
 e820__update_table(e820_table);

 return who;
}

enum e820_type {
 E820_TYPE_RAM  = 1,
 E820_TYPE_RESERVED = 2,
 E820_TYPE_ACPI  = 3,
 E820_TYPE_NVS  = 4,
 E820_TYPE_UNUSABLE = 5,
 E820_TYPE_PMEM  = 7,
 E820_TYPE_PRAM  = 12,
 E820_TYPE_SOFT_RESERVED = 0xefffffff,
 E820_TYPE_RESERVED_KERN = 128,
};

struct e820_entry {
 u64   addr;
 u64   size;
 enum e820_type  type;
} __attribute__((packed));

struct e820_table {
 __u32 nr_entries;
 struct e820_entry entries[E820_MAX_ENTRIES];
};

typedef struct Descriptor{
    unsigned int base;  // 段基址
    unsigned int limit; // 段大小
    unsigned short attribute;   // 段属性、权限
}

struct memblock_region {
 phys_addr_t base;
 phys_addr_t size;
 enum memblock_flags flags;
#ifdef CONFIG_NEED_MULTIPLE_NODES
 int nid;
#endif
};

struct memblock_type {
 unsigned long cnt;
 unsigned long max;
 phys_addr_t total_size;
 struct memblock_region *regions;
 char *name;
};

struct memblock {
 bool bottom_up;  /* is bottom up direction? */
 phys_addr_t current_limit;
 struct memblock_type memory;
 struct memblock_type reserved;
};

#define MEMBLOCK_ALLOC_ANYWHERE (~(phys_addr_t)0) //即0xFFFFFFFF
#define INIT_MEMBLOCK_REGIONS   128

#ifndef INIT_MEMBLOCK_RESERVED_REGIONS
# define INIT_MEMBLOCK_RESERVED_REGIONS  INIT_MEMBLOCK_REGIONS
#endif

static struct memblock_region memblock_memory_init_regions[INIT_MEMBLOCK_REGIONS] __initdata_memblock;
static struct memblock_region memblock_reserved_init_regions[INIT_MEMBLOCK_RESERVED_REGIONS] __initdata_memblock;

struct memblock memblock __initdata_memblock = {
 .memory.regions  = memblock_memory_init_regions,
 .memory.cnt  = 1, /* empty dummy entry */
 .memory.max  = INIT_MEMBLOCK_REGIONS,
 .memory.name  = "memory",

 .reserved.regions = memblock_reserved_init_regions,
 .reserved.cnt  = 1, /* empty dummy entry */
 .reserved.max  = INIT_MEMBLOCK_RESERVED_REGIONS,
 .reserved.name  = "reserved",

 .bottom_up  = false,
 .current_limit  = MEMBLOCK_ALLOC_ANYWHERE,
};

void __init e820__memblock_setup(void)
{
 int i;
 u64 end;

 memblock_allow_resize();

 for (i = 0; i < e820_table->nr_entries; i++) {
  struct e820_entry *entry = &e820_table->entries[i];

  end = entry->addr + entry->size;
  if (end != (resource_size_t)end)
   continue;

  if (entry->type == E820_TYPE_SOFT_RESERVED)
   memblock_reserve(entry->addr, entry->size);

  if (entry->type != E820_TYPE_RAM && entry->type != E820_TYPE_RESERVED_KERN)
   continue;

  memblock_add(entry->addr, entry->size);
 }

 /* Throw away partial pages: */
 memblock_trim_memory(PAGE_SIZE);

 memblock_dump_all();
}

int __init_memblock memblock_add(phys_addr_t base, phys_addr_t size)
{
 phys_addr_t end = base + size - 1;

 memblock_dbg("%s: [%pa-%pa] %pS\n", __func__,
       &base, &end, (void *)_RET_IP_);

 return memblock_add_range(&memblock.memory, base, size, MAX_NUMNODES, 0);
}

static int __init_memblock memblock_add_range(struct memblock_type *type,
    phys_addr_t base, phys_addr_t size,
    int nid, enum memblock_flags flags)
{
 bool insert = false;
 phys_addr_t obase = base;
    //调整size大小，确保不会越过边界
 phys_addr_t end = base + memblock_cap_size(base, &size);
 int idx, nr_new;
 struct memblock_region *rgn;

 if (!size)
  return 0;

 /* special case for empty array */
 if (type->regions[0].size == 0) {
  WARN_ON(type->cnt != 1 || type->total_size);
  type->regions[0].base = base;
  type->regions[0].size = size;
  type->regions[0].flags = flags;
  memblock_set_region_node(&type->regions[0], nid);
  type->total_size = size;
  return 0;
 }
repeat:
 /*
  * The following is executed twice.  Once with %false @insert and
  * then with %true.  The first counts the number of regions needed
  * to accommodate the new area.  The second actually inserts them.
  */
 base = obase;
 nr_new = 0;

 for_each_memblock_type(idx, type, rgn) {
  phys_addr_t rbase = rgn->base;
  phys_addr_t rend = rbase + rgn->size;

  if (rbase >= end)
   break;
  if (rend <= base)
   continue;
  /*
   * @rgn overlaps.  If it separates the lower part of new
   * area, insert that portion.
   */
  if (rbase > base) {
#ifdef CONFIG_NEED_MULTIPLE_NODES
   WARN_ON(nid != memblock_get_region_node(rgn));
#endif
   WARN_ON(flags != rgn->flags);
   nr_new++;
   if (insert)
    memblock_insert_region(type, idx++, base,
             rbase - base, nid,
             flags);
  }
  /* area below @rend is dealt with, forget about it */
  base = min(rend, end);
 }

 /* insert the remaining portion */
 if (base < end) {
  nr_new++;
  if (insert)
   memblock_insert_region(type, idx, base, end - base,
            nid, flags);
 }

 if (!nr_new)
  return 0;

 /*
  * If this was the first round, resize array and repeat for actual
  * insertions; otherwise, merge and return.
  */
 if (!insert) {
  while (type->cnt + nr_new > type->max)
   if (memblock_double_array(type, obase, size) < 0)
    return -ENOMEM;
  insert = true;
  goto repeat;
 } else {
  memblock_merge_regions(type);
  return 0;
 }
}

//size即分配区块的大小，align用于字节对齐,表示分配区块的对齐大小
//这里NUMA_NO_NODE指任何节点（没有节点），关于节点后面会介绍，这里节点还没初始化
//MEMBLOCK_ALLOC_ACCESSIBLE指分配内存块时仅受memblock.current_limit的限制
#define NUMA_NO_NODE (-1)
#define MEMBLOCK_LOW_LIMIT 0
#define MEMBLOCK_ALLOC_ACCESSIBLE 0

static inline void * __init memblock_alloc(phys_addr_t size,  phys_addr_t align)
{
 return memblock_alloc_try_nid(size, align, MEMBLOCK_LOW_LIMIT,
          MEMBLOCK_ALLOC_ACCESSIBLE, NUMA_NO_NODE);
}

void * __init memblock_alloc_try_nid(
   phys_addr_t size, phys_addr_t align,
   phys_addr_t min_addr, phys_addr_t max_addr,
   int nid)
{
 void *ptr;

 memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=%pa max_addr=%pa %pS\n",
       __func__, (u64)size, (u64)align, nid, &min_addr,
       &max_addr, (void *)_RET_IP_);
 ptr = memblock_alloc_internal(size, align,
        min_addr, max_addr, nid, false);
 if (ptr)
  memset(ptr, 0, size);

 return ptr;
}

static void * __init memblock_alloc_internal(
    phys_addr_t size, phys_addr_t align,
    phys_addr_t min_addr, phys_addr_t max_addr,
    int nid, bool exact_nid)
{
 phys_addr_t alloc;

 /*
  * Detect any accidental use of these APIs after slab is ready, as at
  * this moment memblock may be deinitialized already and its
  * internal data may be destroyed (after execution of memblock_free_all)
  */
 if (WARN_ON_ONCE(slab_is_available()))
  return kzalloc_node(size, GFP_NOWAIT, nid);

 if (max_addr > memblock.current_limit)
  max_addr = memblock.current_limit;

 alloc = memblock_alloc_range_nid(size, align, min_addr, max_addr, nid,
     exact_nid);

 /* retry allocation without lower limit */
 if (!alloc && min_addr)
  alloc = memblock_alloc_range_nid(size, align, 0, max_addr, nid,
      exact_nid);

 if (!alloc)
  return NULL;

 return phys_to_virt(alloc);
}

phys_addr_t __init memblock_alloc_range_nid(phys_addr_t size,
     phys_addr_t align, phys_addr_t start,
     phys_addr_t end, int nid,
     bool exact_nid)
{
 enum memblock_flags flags = choose_memblock_flags();
 phys_addr_t found;

 if (WARN_ONCE(nid == MAX_NUMNODES, "Usage of MAX_NUMNODES is deprecated. Use NUMA_NO_NODE instead\n"))
  nid = NUMA_NO_NODE;

 if (!align) {
  /* Can't use WARNs this early in boot on powerpc */
  dump_stack();
  align = SMP_CACHE_BYTES;
 }

again:
 found = memblock_find_in_range_node(size, align, start, end, nid,
         flags);
 if (found && !memblock_reserve(found, size))
  goto done;

 if (nid != NUMA_NO_NODE && !exact_nid) {
  found = memblock_find_in_range_node(size, align, start,
          end, NUMA_NO_NODE,
          flags);
  if (found && !memblock_reserve(found, size))
   goto done;
 }

 if (flags & MEMBLOCK_MIRROR) {
  flags &= ~MEMBLOCK_MIRROR;
  pr_warn("Could not allocate %pap bytes of mirrored memory\n",
   &size);
  goto again;
 }

 return 0;

done:
 if (end != MEMBLOCK_ALLOC_KASAN)
  kmemleak_alloc_phys(found, size, 0, 0);

 return found;
}

static phys_addr_t __init_memblock memblock_find_in_range_node(phys_addr_t size,
     phys_addr_t align, phys_addr_t start,
     phys_addr_t end, int nid,
     enum memblock_flags flags)
{
 phys_addr_t kernel_end, ret;

 /* pump up @end */
 if (end == MEMBLOCK_ALLOC_ACCESSIBLE ||
     end == MEMBLOCK_ALLOC_KASAN)
  end = memblock.current_limit;

 /* avoid allocating the first page */
 start = max_t(phys_addr_t, start, PAGE_SIZE);
 end = max(start, end);
 kernel_end = __pa_symbol(_end);

 if (memblock_bottom_up() && end > kernel_end) {
  phys_addr_t bottom_up_start;

  /* make sure we will allocate above the kernel */
  bottom_up_start = max(start, kernel_end);

  /* ok, try bottom-up allocation first */
  ret = __memblock_find_range_bottom_up(bottom_up_start, end,
            size, align, nid, flags);
  if (ret)
   return ret;

  WARN_ONCE(IS_ENABLED(CONFIG_MEMORY_HOTREMOVE),
     "memblock: bottom-up allocation failed, memory hotremove may be affected\n");
 }

 return __memblock_find_range_top_down(start, end, size, align, nid,
           flags);
}

static phys_addr_t __init_memblock
__memblock_find_range_top_down(phys_addr_t start, phys_addr_t end,
          phys_addr_t size, phys_addr_t align, int nid,
          enum memblock_flags flags)
{
 phys_addr_t this_start, this_end, cand;
 u64 i;

 for_each_free_mem_range_reverse(i, nid, flags, &this_start, &this_end,
     NULL) {
  this_start = clamp(this_start, start, end);
  this_end = clamp(this_end, start, end);

  if (this_end < size)
   continue;

  cand = round_down(this_end - size, align);
  if (cand >= this_start)
   return cand;
 }

 return 0;
}

int __init_memblock memblock_free(phys_addr_t base, phys_addr_t size)
{
 phys_addr_t end = base + size - 1;

 memblock_dbg("%s: [%pa-%pa] %pS\n", __func__,
       &base, &end, (void *)_RET_IP_);

 kmemleak_free_part_phys(base, size);
 return memblock_remove_range(&memblock.reserved, base, size);
}

static int __init_memblock memblock_remove_range(struct memblock_type *type,
       phys_addr_t base, phys_addr_t size)
{
 int start_rgn, end_rgn;
 int i, ret;

 ret = memblock_isolate_range(type, base, size, &start_rgn, &end_rgn);
 if (ret)
  return ret;

 for (i = end_rgn - 1; i >= start_rgn; i--)
  memblock_remove_region(type, i);
 return 0;
}
static void __init_memblock memblock_remove_region(struct memblock_type *type, unsigned long r)
{
 type->total_size -= type->regions[r].size;
 memmove(&type->regions[r], &type->regions[r + 1],
  (type->cnt - (r + 1)) * sizeof(type->regions[r]));
 type->cnt--;

 /* Special case for empty arrays */
 if (type->cnt == 0) {
  WARN_ON(type->total_size != 0);
  type->cnt = 1;
  type->regions[0].base = 0;
  type->regions[0].size = 0;
  type->regions[0].flags = 0;
  memblock_set_region_node(&type->regions[0], MAX_NUMNODES);
 }
}

void __init setup_arch(char **cmdline_p)
{
    ......
 max_pfn = e820__end_of_ram_pfn();
 .....
#ifdef CONFIG_X86_32
 /* max_low_pfn get updated here */
 find_low_pfn_range();
#else
 check_x2apic();

 /* How many end-of-memory variables you have, grandma! */
 /* need this before calling reserve_initrd */
 if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
  max_low_pfn = e820__end_of_low_ram_pfn();
 else
  max_low_pfn = max_pfn;

 high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
#endif
 ......
    e820__memblock_setup();
    ......
}

#define PAGE_SHIFT  12

#ifdef CONFIG_X86_32
# ifdef CONFIG_X86_PAE
#  define MAX_ARCH_PFN  (1ULL<<(36-PAGE_SHIFT))
# else
//32位系统，1<<20，即0x100000，代表4G物理内存的最大页面帧号
#  define MAX_ARCH_PFN  (1ULL<<(32-PAGE_SHIFT))
# endif
#else /* CONFIG_X86_32 */
# define MAX_ARCH_PFN MAXMEM>>PAGE_SHIFT
#endif

unsigned long __init e820__end_of_ram_pfn(void)
{
 return e820_end_pfn(MAX_ARCH_PFN, E820_TYPE_RAM);
}

/*
 * Find the highest page frame number we have available
 */
static unsigned long __init e820_end_pfn(unsigned long limit_pfn, enum e820_type type)
{
 int i;
 unsigned long last_pfn = 0;
 unsigned long max_arch_pfn = MAX_ARCH_PFN;

 for (i = 0; i < e820_table->nr_entries; i++) {
  struct e820_entry *entry = &e820_table->entries[i];
  unsigned long start_pfn;
  unsigned long end_pfn;

  if (entry->type != type)
   continue;

  start_pfn = entry->addr >> PAGE_SHIFT;
  end_pfn = (entry->addr + entry->size) >> PAGE_SHIFT;

  if (start_pfn >= limit_pfn)
   continue;
  if (end_pfn > limit_pfn) {
   last_pfn = limit_pfn;
   break;
  }
  if (end_pfn > last_pfn)
   last_pfn = end_pfn;
 }

 if (last_pfn > max_arch_pfn)
  last_pfn = max_arch_pfn;

 pr_info("last_pfn = %#lx max_arch_pfn = %#lx\n",
  last_pfn, max_arch_pfn);
 return last_pfn;
}

#define PFN_UP(x) (((x) + PAGE_SIZE-1) >> PAGE_SHIFT)
#define PFN_DOWN(x) ((x) >> PAGE_SHIFT)
#define PFN_PHYS(x) ((phys_addr_t)(x) << PAGE_SHIFT)

#ifndef __pa
#define __pa(x)  __phys_addr((unsigned long)(x))
#endif

#define VMALLOC_RESERVE  SZ_128M
#define VMALLOC_END  (CONSISTENT_BASE - PAGE_SIZE)
#define VMALLOC_START  ((VMALLOC_END) - VMALLOC_RESERVE)
#define VMALLOC_VMADDR(x) ((unsigned long)(x))
#define MAXMEM   __pa(VMALLOC_START)
#define MAXMEM_PFN  PFN_DOWN(MAXMEM)

void __init find_low_pfn_range(void)
{
 /* it could update max_pfn */

 if (max_pfn <= MAXMEM_PFN)
  lowmem_pfn_init();
 else
  highmem_pfn_init();
}

#ifdef CONFIG_HIGHMEM
#define CONSISTENT_BASE  ((PKMAP_BASE) - (SZ_2M))
#define CONSISTENT_END  (PKMAP_BASE)
#else
#define CONSISTENT_BASE  (FIXADDR_START - SZ_2M)
#define CONSISTENT_END  (FIXADDR_START)
#endif

#define SZ_2M    0x00200000
#define SZ_128M    0x08000000

#define MAXMEM              __pa(VMALLOC_END – PAGE_OFFSET – __VMALLOC_RESERVE)
//进一步展开
#define MAXMEM              __pa(CONSISTENT_BASE - PAGE_SIZE – PAGE_OFFSET – SZ_128M)
//再进一步展开
#define MAXMEM              __pa((PKMAP_BASE) - (SZ_2M) - PAGE_SIZE – PAGE_OFFSET – SZ_128M)

//临时映射
//-4096(4KB) -> 0xfffff000
#define __FIXADDR_TOP (-PAGE_SIZE)

#define FIXADDR_TOP ((unsigned long)__FIXADDR_TOP)
#define FIXADDR_SIZE  (__end_of_permanent_fixed_addresses << PAGE_SHIFT)
#define FIXADDR_START  (FIXADDR_TOP - FIXADDR_SIZE)
#define FIXADDR_TOT_SIZE (__end_of_fixed_addresses << PAGE_SHIFT)
#define FIXADDR_TOT_START (FIXADDR_TOP - FIXADDR_TOT_SIZE)

//持久内核映射
#ifdef CONFIG_X86_PAE
#define LAST_PKMAP 512
#else
#define LAST_PKMAP 1024
#endif

#define CPU_ENTRY_AREA_BASE \
 ((FIXADDR_TOT_START - PAGE_SIZE*(CPU_ENTRY_AREA_PAGES+1)) & PMD_MASK)

#define LDT_BASE_ADDR  \
 ((CPU_ENTRY_AREA_BASE - PAGE_SIZE) & PMD_MASK)

#define LDT_END_ADDR  (LDT_BASE_ADDR + PMD_SIZE)

#define PKMAP_BASE  \
 ((LDT_BASE_ADDR - PAGE_SIZE) & PMD_MASK)

//动态映射
//0xffffff80<<20 -> 0xf8000000 -> 4,160,749,568 -> 3948MB -> 3GB+896MB 与上述一致
#define high_memory (-128UL << 20)
//8MB
#define VMALLOC_OFFSET (8 * 1024 * 1024)
#define VMALLOC_START ((unsigned long)high_memory + VMALLOC_OFFSET)

#ifdef CONFIG_HIGHMEM
# define VMALLOC_END (PKMAP_BASE - 2 * PAGE_SIZE)
#else
# define VMALLOC_END (LDT_BASE_ADDR - 2 * PAGE_SIZE)
#endif

static void __init highmem_pfn_init(void)
{
 max_low_pfn = MAXMEM_PFN;

 if (highmem_pages == -1)
  highmem_pages = max_pfn - MAXMEM_PFN;

 if (highmem_pages + MAXMEM_PFN < max_pfn)
  max_pfn = MAXMEM_PFN + highmem_pages;

 if (highmem_pages + MAXMEM_PFN > max_pfn) {
  printk(KERN_WARNING MSG_HIGHMEM_TOO_SMALL,
   pages_to_mb(max_pfn - MAXMEM_PFN),
   pages_to_mb(highmem_pages));
  highmem_pages = 0;
 }
#ifndef CONFIG_HIGHMEM
 /* Maximum memory usable is what is directly addressable */
 printk(KERN_WARNING "Warning only %ldMB will be used.\n", MAXMEM>>20);
 if (max_pfn > MAX_NONPAE_PFN)
  printk(KERN_WARNING "Use a HIGHMEM64G enabled kernel.\n");
 else
  printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
 max_pfn = MAXMEM_PFN;
#else /* !CONFIG_HIGHMEM */
#ifndef CONFIG_HIGHMEM64G
 if (max_pfn > MAX_NONPAE_PFN) {
  max_pfn = MAX_NONPAE_PFN;
  printk(KERN_WARNING MSG_HIGHMEM_TRIMMED);
 }
#endif /* !CONFIG_HIGHMEM64G */
#endif /* !CONFIG_HIGHMEM */
}

void __init setup_arch(char **cmdline_p)
{
    ......
 max_pfn = e820__end_of_ram_pfn();
 .....
#ifdef CONFIG_X86_32
 /* max_low_pfn get updated here */
 find_low_pfn_range();
#else
 check_x2apic();

 /* How many end-of-memory variables you have, grandma! */
 /* need this before calling reserve_initrd */
 if (max_pfn > (1UL<<(32 - PAGE_SHIFT)))
  max_low_pfn = e820__end_of_low_ram_pfn();
 else
  max_low_pfn = max_pfn;

 high_memory = (void *)__va(max_pfn * PAGE_SIZE - 1) + 1;
#endif
 ......
 early_alloc_pgt_buf(); //<-------------------------------------
    /*
  * Need to conclude brk, before e820__memblock_setup()
  *  it could use memblock_find_in_range, could overlap with
  *  brk area.
  */
 reserve_brk(); //<-------------------------------------------
    ......
    e820__memblock_setup();
 ......
}

#define INIT_PGD_PAGE_COUNT      6
#define INIT_PGT_BUF_SIZE (INIT_PGD_PAGE_COUNT * PAGE_SIZE)
RESERVE_BRK(early_pgt_alloc, INIT_PGT_BUF_SIZE);
void  __init early_alloc_pgt_buf(void)
{
 unsigned long tables = INIT_PGT_BUF_SIZE;
 phys_addr_t base;

 base = __pa(extend_brk(tables, PAGE_SIZE));

 pgt_buf_start = base >> PAGE_SHIFT;
 pgt_buf_end = pgt_buf_start;
 pgt_buf_top = pgt_buf_start + (tables >> PAGE_SHIFT);
}

unsigned long _brk_start = (unsigned long)__brk_base;
unsigned long _brk_end   = (unsigned long)__brk_base;

void * __init extend_brk(size_t size, size_t align)
{
 size_t mask = align - 1;
 void *ret;

 BUG_ON(_brk_start == 0);
 BUG_ON(align & mask);

 _brk_end = (_brk_end + mask) & ~mask;
 BUG_ON((char *)(_brk_end + size) > __brk_limit);

 ret = (void *)_brk_end;
 _brk_end += size;

 memset(ret, 0, size);

 return ret;
}

static void __init reserve_brk(void)
{
 if (_brk_end > _brk_start)
  memblock_reserve(__pa_symbol(_brk_start),
     _brk_end - _brk_start);

 /* Mark brk area as locked down and no longer taking any
    new allocations */
 _brk_start = 0;
}

void __init setup_arch(char **cmdline_p)
{
    ......
 max_pfn = e820__end_of_ram_pfn(); //max_pfn初始化
 ......
 find_low_pfn_range(); //max_low_pfn、高端内存初始化
 ......

 ......
 early_alloc_pgt_buf(); //页表缓冲区分配
 reserve_brk(); //缓冲区加入memblock.reserve

    ......
    e820__memblock_setup(); //memblock.memory空间初始化 启动
 ......

    init_mem_mapping(); //<-----------------------------
    ......
}

#define ISA_END_ADDRESS  0x00100000 //1MB

void __init init_mem_mapping(void)
{
 unsigned long end;

 pti_check_boottime_disable();
 probe_page_size_mask();
 setup_pcid();

#ifdef CONFIG_X86_64
 end = max_pfn << PAGE_SHIFT;
#else
 end = max_low_pfn << PAGE_SHIFT;
#endif

 /* the ISA range is always mapped regardless of memory holes */
 init_memory_mapping(0, ISA_END_ADDRESS, PAGE_KERNEL);

 /* Init the trampoline, possibly with KASLR memory offset */
 init_trampoline();

 /*
  * If the allocation is in bottom-up direction, we setup direct mapping
  * in bottom-up, otherwise we setup direct mapping in top-down.
  */
 if (memblock_bottom_up()) {
  unsigned long kernel_end = __pa_symbol(_end);

  memory_map_bottom_up(kernel_end, end);
  memory_map_bottom_up(ISA_END_ADDRESS, kernel_end);
 } else {
  memory_map_top_down(ISA_END_ADDRESS, end);
 }

#ifdef CONFIG_X86_64
 if (max_pfn > max_low_pfn) {
  /* can we preseve max_low_pfn ?*/
  max_low_pfn = max_pfn;
 }
#else
 early_ioremap_page_table_range_init();
#endif

 load_cr3(swapper_pg_dir);
 __flush_tlb_all();

 x86_init.hyper.init_mem_mapping();

 early_memtest(0, max_pfn_mapped << PAGE_SHIFT);
}

#ifdef CONFIG_X86_32
#define NR_RANGE_MR 3
#else /* CONFIG_X86_64 */
#define NR_RANGE_MR 5
#endif

struct map_range {
 unsigned long start;
 unsigned long end;
 unsigned page_size_mask;
};

unsigned long __ref init_memory_mapping(unsigned long start,
     unsigned long end, pgprot_t prot)
{
 struct map_range mr[NR_RANGE_MR];
 unsigned long ret = 0;
 int nr_range, i;

 pr_debug("init_memory_mapping: [mem %#010lx-%#010lx]\n",
        start, end - 1);

 memset(mr, 0, sizeof(mr));
 nr_range = split_mem_range(mr, 0, start, end);

 for (i = 0; i < nr_range; i++)
  ret = kernel_physical_mapping_init(mr[i].start, mr[i].end,
         mr[i].page_size_mask,
         prot);

 add_pfn_range_mapped(start >> PAGE_SHIFT, ret >> PAGE_SHIFT);

 return ret >> PAGE_SHIFT;
}

static int __meminit split_mem_range(struct map_range *mr, int nr_range,
         unsigned long start,
         unsigned long end)
{
 unsigned long start_pfn, end_pfn, limit_pfn;
 unsigned long pfn;
 int i;
 //返回小于...的最后一个物理页号
 limit_pfn = PFN_DOWN(end);

 pfn = start_pfn = PFN_DOWN(start);

 if (pfn == 0)
  end_pfn = PFN_DOWN(PMD_SIZE);
 else
  end_pfn = round_up(pfn, PFN_DOWN(PMD_SIZE));

 if (end_pfn > limit_pfn)
  end_pfn = limit_pfn;
 if (start_pfn < end_pfn) {
  nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, 0);
  pfn = end_pfn;
 }

 /* big page (2M) range */
 start_pfn = round_up(pfn, PFN_DOWN(PMD_SIZE));

 end_pfn = round_down(limit_pfn, PFN_DOWN(PMD_SIZE));

 if (start_pfn < end_pfn) {
  nr_range = save_mr(mr, nr_range, start_pfn, end_pfn,
    page_size_mask & (1<<PG_LEVEL_2M));
  pfn = end_pfn;
 }

 /* tail is not big page (2M) alignment */
 start_pfn = pfn;
 end_pfn = limit_pfn;
 nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, 0);

 if (!after_bootmem)
  adjust_range_page_size_mask(mr, nr_range);

 /* try to merge same page size and continuous */
 for (i = 0; nr_range > 1 && i < nr_range - 1; i++) {
  unsigned long old_start;
  if (mr[i].end != mr[i+1].start ||
      mr[i].page_size_mask != mr[i+1].page_size_mask)
   continue;
  /* move it */
  old_start = mr[i].start;
  memmove(&mr[i], &mr[i+1],
   (nr_range - 1 - i) * sizeof(struct map_range));
  mr[i--].start = old_start;
  nr_range--;
 }

 for (i = 0; i < nr_range; i++)
  pr_debug(" [mem %#010lx-%#010lx] page %s\n",
    mr[i].start, mr[i].end - 1,
    page_size_string(&mr[i]));

 return nr_range;
}

#define __round_mask(x, y) ((__typeof__(x))((y)-1))
#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
//可以理解为：#define round_up(x, y) (((x)+(y) - 1)/(y))*(y))
#define round_down(x, y) ((x) & ~__round_mask(x, y))
//可以理解为：#define round_down(x, y) ((x/y) * y)

unsigned long __init
kernel_physical_mapping_init(unsigned long start,
        unsigned long end,
        unsigned long page_size_mask,
        pgprot_t prot)
{
 int use_pse = page_size_mask == (1<<PG_LEVEL_2M);
 unsigned long last_map_addr = end;
 unsigned long start_pfn, end_pfn;
 pgd_t *pgd_base = swapper_pg_dir;
 int pgd_idx, pmd_idx, pte_ofs;
 unsigned long pfn;
 pgd_t *pgd;
 pmd_t *pmd;
 pte_t *pte;
 unsigned pages_2m, pages_4k;
 int mapping_iter;

 start_pfn = start >> PAGE_SHIFT;
 end_pfn = end >> PAGE_SHIFT;

 mapping_iter = 1;

 if (!boot_cpu_has(X86_FEATURE_PSE))
  use_pse = 0;

repeat:
 pages_2m = pages_4k = 0;
 pfn = start_pfn; //pfn保存起始页框号
 pgd_idx = pgd_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET); //低端内存的起始地址对应的pgd的偏移
 pgd = pgd_base + pgd_idx; //得到起始页框对应的pgd
 //由pgd开始遍历
    for (; pgd_idx < PTRS_PER_PGD; pgd++, pgd_idx++) {
  pmd = one_md_table_init(pgd);//申请得到一个pmd表

  if (pfn >= end_pfn)
   continue;
#ifdef CONFIG_X86_PAE
  pmd_idx = pmd_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET);
  pmd += pmd_idx;
#else
  pmd_idx = 0;
#endif
        //遍历pmd表,对于未激活PAE的32位系统，PTRS_PER_PMD为1，激活PAE则为512
  for (; pmd_idx < PTRS_PER_PMD && pfn < end_pfn;
       pmd++, pmd_idx++) {
   unsigned int addr = pfn * PAGE_SIZE + PAGE_OFFSET;

   /*
    * Map with big pages if possible, otherwise
    * create normal page tables:
    */
   if (use_pse) {
    unsigned int addr2;
    pgprot_t prot = PAGE_KERNEL_LARGE;
    /*
     * first pass will use the same initial
     * identity mapping attribute + _PAGE_PSE.
     */
    pgprot_t init_prot =
     __pgprot(PTE_IDENT_ATTR |
       _PAGE_PSE);

    pfn &= PMD_MASK >> PAGE_SHIFT;
    addr2 = (pfn + PTRS_PER_PTE-1) * PAGE_SIZE +
     PAGE_OFFSET + PAGE_SIZE-1;

    if (__is_kernel_text(addr) ||
        __is_kernel_text(addr2))
     prot = PAGE_KERNEL_LARGE_EXEC;

    pages_2m++;
    if (mapping_iter == 1)
     set_pmd(pmd, pfn_pmd(pfn, init_prot));
    else
     set_pmd(pmd, pfn_pmd(pfn, prot));

    pfn += PTRS_PER_PTE;
    continue;
   }
   pte = one_page_table_init(pmd); //创建一个页表
   //得到pfn在page table中的偏移并定位到具体的pte
   pte_ofs = pte_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET);
   pte += pte_ofs;
            //由pte开始遍历page table
   for (; pte_ofs < PTRS_PER_PTE && pfn < end_pfn;
        pte++, pfn++, pte_ofs++, addr += PAGE_SIZE) {
    pgprot_t prot = PAGE_KERNEL;
    /*
     * first pass will use the same initial
     * identity mapping attribute.
     */
    pgprot_t init_prot = __pgprot(PTE_IDENT_ATTR);

    if (__is_kernel_text(addr)) //如果处于内核代码段，权限设为可执行
     prot = PAGE_KERNEL_EXEC;

    pages_4k++;
                //设置pte与pfn关联
    if (mapping_iter == 1) {
     set_pte(pte, pfn_pte(pfn, init_prot)); //第一次执行将权限位设为init_prot
     last_map_addr = (pfn << PAGE_SHIFT) + PAGE_SIZE;
    } else
     set_pte(pte, pfn_pte(pfn, prot)); //之后的执行将权限位置为prot
   }
  }
 }
 if (mapping_iter == 1) {
  /*
   * update direct mapping page count only in the first
   * iteration.
   */
  update_page_count(PG_LEVEL_2M, pages_2m);
  update_page_count(PG_LEVEL_4K, pages_4k);

  /*
   * local global flush tlb, which will flush the previous
   * mappings present in both small and large page TLB's.
   */
  __flush_tlb_all(); //TLB全部刷新

  /*
   * Second iteration will set the actual desired PTE attributes.
   */
  mapping_iter = 2;
  goto repeat;
 }
 return last_map_addr;
}

typedef unsigned long   pgdval_t;

typedef struct { pgdval_t pgd; } pgd_t;

#define pgd_val(x)      native_pgd_val(x)

static inline pgdval_t native_pgd_val(pgd_t pgd)
{
      return pgd.pgd;
}

struct range pfn_mapped[E820_MAX_ENTRIES];
int nr_pfn_mapped;

static void add_pfn_range_mapped(unsigned long start_pfn, unsigned long end_pfn)
{
 nr_pfn_mapped = add_range_with_merge(pfn_mapped, E820_MAX_ENTRIES,
          nr_pfn_mapped, start_pfn, end_pfn);
 nr_pfn_mapped = clean_sort_range(pfn_mapped, E820_MAX_ENTRIES);

 max_pfn_mapped = max(max_pfn_mapped, end_pfn);

 if (start_pfn < (1UL<<(32-PAGE_SHIFT)))
  max_low_pfn_mapped = max(max_low_pfn_mapped,
      min(end_pfn, 1UL<<(32-PAGE_SHIFT)));
}

# define PMD_MASK (~(PMD_SIZE - 1))
void __init early_ioremap_page_table_range_init(void)
{
 pgd_t *pgd_base = swapper_pg_dir;
 unsigned long vaddr, end;

 /*
  * Fixed mappings, only the page table structure has to be
  * created - mappings will be set by set_fixmap():
  */
 vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
 end = (FIXADDR_TOP + PMD_SIZE - 1) & PMD_MASK;
 page_table_range_init(vaddr, end, pgd_base);
 early_ioremap_reset();
}

enum fixed_addresses {
#ifdef CONFIG_X86_32
 FIX_HOLE,
#else
#ifdef CONFIG_X86_VSYSCALL_EMULATION
 VSYSCALL_PAGE = (FIXADDR_TOP - VSYSCALL_ADDR) >> PAGE_SHIFT,
#endif
#endif
 FIX_DBGP_BASE,
 FIX_EARLYCON_MEM_BASE,
#ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT
 FIX_OHCI1394_BASE,
#endif
#ifdef CONFIG_X86_LOCAL_APIC
 FIX_APIC_BASE, /* local (CPU) APIC) -- required for SMP or not */
#endif
#ifdef CONFIG_X86_IO_APIC
 FIX_IO_APIC_BASE_0,
 FIX_IO_APIC_BASE_END = FIX_IO_APIC_BASE_0 + MAX_IO_APICS - 1,
#endif
#ifdef CONFIG_X86_32
    //这里即为固定映射区
 FIX_KMAP_BEGIN, /* reserved pte's for temporary kernel mappings */
 FIX_KMAP_END = FIX_KMAP_BEGIN+(KM_TYPE_NR*NR_CPUS)-1,
#ifdef CONFIG_PCI_MMCONFIG
 FIX_PCIE_MCFG,
#endif
#endif
#ifdef CONFIG_PARAVIRT_XXL
 FIX_PARAVIRT_BOOTMAP,
#endif
#ifdef CONFIG_X86_INTEL_MID
 FIX_LNW_VRTC,
#endif

#ifdef CONFIG_ACPI_APEI_GHES
 /* Used for GHES mapping from assorted contexts */
 FIX_APEI_GHES_IRQ,
 FIX_APEI_GHES_NMI,
#endif

 __end_of_permanent_fixed_addresses,

 /*
  * 512 temporary boot-time mappings, used by early_ioremap(),
  * before ioremap() is functional.
  *
  * If necessary we round it up to the next 512 pages boundary so
  * that we can have a single pmd entry and a single pte table:
  */
#define NR_FIX_BTMAPS  64
#define FIX_BTMAPS_SLOTS 8
#define TOTAL_FIX_BTMAPS (NR_FIX_BTMAPS * FIX_BTMAPS_SLOTS)
 FIX_BTMAP_END =
  (__end_of_permanent_fixed_addresses ^
   (__end_of_permanent_fixed_addresses + TOTAL_FIX_BTMAPS - 1)) &
  -PTRS_PER_PTE
  ? __end_of_permanent_fixed_addresses + TOTAL_FIX_BTMAPS -
    (__end_of_permanent_fixed_addresses & (TOTAL_FIX_BTMAPS - 1))
  : __end_of_permanent_fixed_addresses,
 FIX_BTMAP_BEGIN = FIX_BTMAP_END + TOTAL_FIX_BTMAPS - 1,
#ifdef CONFIG_X86_32
 FIX_WP_TEST,
#endif
#ifdef CONFIG_INTEL_TXT
 FIX_TBOOT_BASE,
#endif
 __end_of_fixed_addresses
};

#define __fix_to_virt(x) (FIXADDR_TOP - ((x) << PAGE_SHIFT))

//初始化pgd_base指向的页全局目录中start到end这个范围的线性地址，整个函数结束后只是初始化好了页中间目录项对应的页表，但是页表中的页表项并没有初始化
static void __init
page_table_range_init(unsigned long start, unsigned long end, pgd_t *pgd_base)
{
 int pgd_idx, pmd_idx;
 unsigned long vaddr;
 pgd_t *pgd;
 pmd_t *pmd;
 pte_t *pte = NULL;
 unsigned long count = page_table_range_init_count(start, end);
 void *adr = NULL;

 if (count)
  adr = alloc_low_pages(count);

 vaddr = start;
 pgd_idx = pgd_index(vaddr); //得到vaddr对应的pgd索引
 pmd_idx = pmd_index(vaddr); //得到vaddr对应的pmd索引
 pgd = pgd_base + pgd_idx;   //得到pgd项

 for ( ; (pgd_idx < PTRS_PER_PGD) && (vaddr != end); pgd++, pgd_idx++) {
  pmd = one_md_table_init(pgd); //得到pmd起始项
  pmd = pmd + pmd_index(vaddr); //得到偏移后的pmd
  for (; (pmd_idx < PTRS_PER_PMD) && (vaddr != end);
       pmd++, pmd_idx++) {
            //建立pte表并检查vaddr是否对应内核临时映射区,若是则重新申请一个页表来保存pte表
   pte = page_table_kmap_check(one_page_table_init(pmd),
          pmd, vaddr, pte, &adr);

   vaddr += PMD_SIZE;
  }
  pmd_idx = 0;
 }
}

static unsigned long __init
page_table_range_init_count(unsigned long start, unsigned long end)
{
 unsigned long count = 0;
#ifdef CONFIG_HIGHMEM
 int pmd_idx_kmap_begin = fix_to_virt(FIX_KMAP_END) >> PMD_SHIFT;
 int pmd_idx_kmap_end = fix_to_virt(FIX_KMAP_BEGIN) >> PMD_SHIFT;
 int pgd_idx, pmd_idx;
 unsigned long vaddr;

 if (pmd_idx_kmap_begin == pmd_idx_kmap_end)
  return 0;

 vaddr = start;
 pgd_idx = pgd_index(vaddr);
 pmd_idx = pmd_index(vaddr);

 for ( ; (pgd_idx < PTRS_PER_PGD) && (vaddr != end); pgd_idx++) {
  for (; (pmd_idx < PTRS_PER_PMD) && (vaddr != end);
       pmd_idx++) {
   if ((vaddr >> PMD_SHIFT) >= pmd_idx_kmap_begin &&
       (vaddr >> PMD_SHIFT) <= pmd_idx_kmap_end)
    count++;
   vaddr += PMD_SIZE;
  }
  pmd_idx = 0;
 }
#endif
 return count;
}

FIX_KMAP_BEGIN, /* reserved pte's for temporary kernel mappings */
FIX_KMAP_END = FIX_KMAP_BEGIN+(KM_TYPE_NR*NR_CPUS)-1,

__ref void *alloc_low_pages(unsigned int num)
{
 unsigned long pfn;
 int i;

 if (after_bootmem) {
  unsigned int order;

  order = get_order((unsigned long)num << PAGE_SHIFT);
  return (void *)__get_free_pages(GFP_ATOMIC | __GFP_ZERO, order);
 }

 if ((pgt_buf_end + num) > pgt_buf_top || !can_use_brk_pgt) {
  unsigned long ret = 0;

  if (min_pfn_mapped < max_pfn_mapped) {
   ret = memblock_find_in_range(
     min_pfn_mapped << PAGE_SHIFT,
     max_pfn_mapped << PAGE_SHIFT,
     PAGE_SIZE * num , PAGE_SIZE);
  }
  if (ret)
   memblock_reserve(ret, PAGE_SIZE * num);
  else if (can_use_brk_pgt)
   ret = __pa(extend_brk(PAGE_SIZE * num, PAGE_SIZE));

  if (!ret)
   panic("alloc_low_pages: can not alloc memory");

  pfn = ret >> PAGE_SHIFT;
 } else {
  pfn = pgt_buf_end;
  pgt_buf_end += num;
 }

 for (i = 0; i < num; i++) {
  void *adr;

  adr = __va((pfn + i) << PAGE_SHIFT);
  clear_page(adr);
 }

 return __va(pfn << PAGE_SHIFT);
}

static pmd_t * __init one_md_table_init(pgd_t *pgd)
{
 p4d_t *p4d;
 pud_t *pud;
 pmd_t *pmd_table;

#ifdef CONFIG_X86_PAE
 if (!(pgd_val(*pgd) & _PAGE_PRESENT)) {
  pmd_table = (pmd_t *)alloc_low_page();
  paravirt_alloc_pmd(&init_mm, __pa(pmd_table) >> PAGE_SHIFT);
  set_pgd(pgd, __pgd(__pa(pmd_table) | _PAGE_PRESENT));
  p4d = p4d_offset(pgd, 0);
  pud = pud_offset(p4d, 0);
  BUG_ON(pmd_table != pmd_offset(pud, 0));

  return pmd_table;
 }
#endif
 p4d = p4d_offset(pgd, 0);
 pud = pud_offset(p4d, 0);
 pmd_table = pmd_offset(pud, 0);

 return pmd_table;
}

static pte_t * __init one_page_table_init(pmd_t *pmd)
{
 if (!(pmd_val(*pmd) & _PAGE_PRESENT)) {
  pte_t *page_table = (pte_t *)alloc_low_page();

  paravirt_alloc_pte(&init_mm, __pa(page_table) >> PAGE_SHIFT);
  set_pmd(pmd, __pmd(__pa(page_table) | _PAGE_TABLE));
  BUG_ON(page_table != pte_offset_kernel(pmd, 0));
 }

 return pte_offset_kernel(pmd, 0);
}

#define PTRS_PER_PTE 512
static pte_t *__init page_table_kmap_check(pte_t *pte, pmd_t *pmd,
        unsigned long vaddr, pte_t *lastpte,
        void **adr)
{
#ifdef CONFIG_HIGHMEM
 /*
  * Something (early fixmap) may already have put a pte
  * page here, which causes the page table allocation
  * to become nonlinear. Attempt to fix it, and if it
  * is still nonlinear then we have to bug.
  */
    //得到内核固定映射区的临时映射区的起始和结束虚拟页框号
 int pmd_idx_kmap_begin = fix_to_virt(FIX_KMAP_END) >> PMD_SHIFT;
 int pmd_idx_kmap_end = fix_to_virt(FIX_KMAP_BEGIN) >> PMD_SHIFT;

 if (pmd_idx_kmap_begin != pmd_idx_kmap_end
     && (vaddr >> PMD_SHIFT) >= pmd_idx_kmap_begin
     && (vaddr >> PMD_SHIFT) <= pmd_idx_kmap_end) {
  pte_t *newpte;
  int i;

  BUG_ON(after_bootmem);
  newpte = *adr;
        //拷贝操作
  for (i = 0; i < PTRS_PER_PTE; i++)
   set_pte(newpte + i, pte[i]);
  *adr = (void *)(((unsigned long)(*adr)) + PAGE_SIZE);

  paravirt_alloc_pte(&init_mm, __pa(newpte) >> PAGE_SHIFT);
  set_pmd(pmd, __pmd(__pa(newpte)|_PAGE_TABLE)); //pmd与newpte表进行关联
  BUG_ON(newpte != pte_offset_kernel(pmd, 0));
  __flush_tlb_all();

  paravirt_release_pte(__pa(pte) >> PAGE_SHIFT);
  pte = newpte;
 }
 BUG_ON(vaddr < fix_to_virt(FIX_KMAP_BEGIN - 1)
        && vaddr > fix_to_virt(FIX_KMAP_END)
        && lastpte && lastpte + PTRS_PER_PTE != pte);
#endif
 return pte;
}

include/linux/mmzone.h

enum zone_type {
#ifdef CONFIG_ZONE_DMA
 ZONE_DMA, //通常为内存首部16MB,某些工业标准体系结构设备需要用到ZONE_DMA(较旧的外设，只能寻址24位内存)
#endif

#ifdef CONFIG_ZONE_DMA32
 ZONE_DMA32, //在64位Linux操作系统上,DMA32为16M~4G（可访问32位），高于4G的内存为Normal ZONE
#endif

 ZONE_NORMAL, //通常为16MB~896MB，该部分的内存由内核直接映射到物理地址空间的较高部分
#ifdef CONFIG_HIGHMEM
 ZONE_HIGHMEM, //通常为896MB~末尾，将保留给系统使用，是系统中预留的可用内存空间，动态映射
#endif

 ZONE_MOVABLE, //用于减少内存的碎片化，这个区域的页都是可迁移的

#ifdef CONFIG_ZONE_DEVICE
 ZONE_DEVICE, //为支持热插拔设备而分配的非易失性内存
#endif

 __MAX_NR_ZONES
};

void __init setup_arch(char **cmdline_p)
{
    ......
 max_pfn = e820__end_of_ram_pfn(); //max_pfn初始化
 ......
 find_low_pfn_range(); //max_low_pfn、高端内存初始化
 ......

 ......
 early_alloc_pgt_buf(); //页表缓冲区分配
 reserve_brk(); //缓冲区加入memblock.reserve

    ......
    e820__memblock_setup(); //memblock.memory空间初始化 启动
 ......

    init_mem_mapping(); //低端内存内核页表初始化 高端内存固定映射区中临时映射区页表初始化

  ......
    initmem_init(); // <----------------------------------------
    ......
}

#define PHYS_ADDR_MAX (~(phys_addr_t)0)

#ifndef CONFIG_NEED_MULTIPLE_NODES
void __init initmem_init(void)
{
#ifdef CONFIG_HIGHMEM
 highstart_pfn = highend_pfn = max_pfn;
 if (max_pfn > max_low_pfn)
  highstart_pfn = max_low_pfn;
 printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
  pages_to_mb(highend_pfn - highstart_pfn));
 high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;
#else
 high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;
#endif

 memblock_set_node(0, PHYS_ADDR_MAX, &memblock.memory, 0);

#ifdef CONFIG_FLATMEM
 max_mapnr = IS_ENABLED(CONFIG_HIGHMEM) ? highend_pfn : max_low_pfn;
#endif
 __vmalloc_start_set = true;

 printk(KERN_NOTICE "%ldMB LOWMEM available.\n",
   pages_to_mb(max_low_pfn));

 setup_bootmem_allocator();
}
#endif /* !CONFIG_NEED_MULTIPLE_NODES */

int __init_memblock memblock_set_node(phys_addr_t base, phys_addr_t size,
          struct memblock_type *type, int nid)
{
#ifdef CONFIG_NEED_MULTIPLE_NODES
 int start_rgn, end_rgn;
 int i, ret;

 ret = memblock_isolate_range(type, base, size, &start_rgn, &end_rgn);
 if (ret)
  return ret;

 for (i = start_rgn; i < end_rgn; i++)
  memblock_set_region_node(&type->regions[i], nid);

 memblock_merge_regions(type);
#endif
 return 0;
}

/* adjust *@size so that (@base + *@size) doesn't overflow, return new size */
static inline phys_addr_t memblock_cap_size(phys_addr_t base, phys_addr_t *size)
{
 return *size = min(*size, PHYS_ADDR_MAX - base);
}

static int __init_memblock memblock_isolate_range(struct memblock_type *type,
     phys_addr_t base, phys_addr_t size,
     int *start_rgn, int *end_rgn)
{
 phys_addr_t end = base + memblock_cap_size(base, &size);
 int idx;
 struct memblock_region *rgn;

 *start_rgn = *end_rgn = 0;

 if (!size)
  return 0;

 /* we'll create at most two more regions */
 while (type->cnt + 2 > type->max)
  if (memblock_double_array(type, base, size) < 0)
   return -ENOMEM;

 for_each_memblock_type(idx, type, rgn) {
  phys_addr_t rbase = rgn->base;
  phys_addr_t rend = rbase + rgn->size;

  if (rbase >= end)
   break;
  if (rend <= base)
   continue;

  if (rbase < base) {
   /*
    * @rgn intersects from below.  Split and continue
    * to process the next region - the new top half.
    */
   rgn->base = base;
   rgn->size -= base - rbase;
   type->total_size -= base - rbase;
   memblock_insert_region(type, idx, rbase, base - rbase,
            memblock_get_region_node(rgn),
            rgn->flags);
  } else if (rend > end) {
   /*
    * @rgn intersects from above.  Split and redo the
    * current region - the new bottom half.
    */
   rgn->base = end;
   rgn->size -= end - rbase;
   type->total_size -= end - rbase;
   memblock_insert_region(type, idx--, rbase, end - rbase,
            memblock_get_region_node(rgn),
            rgn->flags);
  } else {
   /* @rgn is fully contained, record it */
   if (!*end_rgn)
    *start_rgn = idx;
   *end_rgn = idx + 1;
  }
 }

 return 0;
}

static inline void memblock_set_region_node(struct memblock_region *r, int nid)
{
 r->nid = nid;
}
static inline int memblock_get_region_node(const struct memblock_region *r)
{
 return r->nid;
}

static void __init_memblock memblock_insert_region(struct memblock_type *type,
         int idx, phys_addr_t base,
         phys_addr_t size,
         int nid, unsigned long flags)
{
 struct memblock_region *rgn = &type->regions[idx];

 BUG_ON(type->cnt >= type->max);
 memmove(rgn + 1, rgn, (type->cnt - idx) * sizeof(*rgn));
 rgn->base = base;
 rgn->size = size;
 rgn->flags = flags;
 memblock_set_region_node(rgn, nid);
 type->cnt++;
 type->total_size += size;
}

void __init setup_bootmem_allocator(void)
{
 printk(KERN_INFO "  mapped low ram: 0 - %08lx\n",
   max_pfn_mapped<<PAGE_SHIFT);
 printk(KERN_INFO "  low ram: 0 - %08lx\n", max_low_pfn<<PAGE_SHIFT);
}

void __init setup_arch(char **cmdline_p)
{
    ......
 max_pfn = e820__end_of_raCm_pfn(); //max_pfn初始化
 ......
 find_low_pfn_range(); //max_low_pfn、高端内存初始化
 ......

 ......
 early_alloc_pgt_buf(); //页表缓冲区分配
 reserve_brk(); //缓冲区加入memblock.reserve

    ......
    e820__memblock_setup(); //memblock.memory空间初始化 启动
 ......

    init_mem_mapping(); //低端内存内核页表初始化 高端内存固定映射区中临时映射区页表初始化

  ......
    initmem_init(); //high_memory（高端内存起始pfn）初始化 通过memblock内存管理器设置node节点信息
    ......

    x86_init.paging.pagetable_init(); // <-----------------------------
    ......
}

struct x86_init_ops x86_init __initdata = {
 ......

 .paging = {
  .pagetable_init  = native_pagetable_init,
 },

 ......
}

void __init native_pagetable_init(void)
{
 unsigned long pfn, va;
 pgd_t *pgd, *base = swapper_pg_dir;
 p4d_t *p4d;
 pud_t *pud;
 pmd_t *pmd;
 pte_t *pte;

    //循环 低端内存最大物理页号~最大物理页号
 for (pfn = max_low_pfn; pfn < 1<<(32-PAGE_SHIFT); pfn++) {
  va = PAGE_OFFSET + (pfn<<PAGE_SHIFT);
  pgd = base + pgd_index(va);
  if (!pgd_present(*pgd))
   break;

  p4d = p4d_offset(pgd, va);
  pud = pud_offset(p4d, va);
  pmd = pmd_offset(pud, va);
  if (!pmd_present(*pmd))
   break;

  /* should not be large page here */
  if (pmd_large(*pmd)) {
   pr_warn("try to clear pte for ram above max_low_pfn: pfn: %lx pmd: %p pmd phys: %lx, but pmd is big page and is not using pte !\n",
    pfn, pmd, __pa(pmd));
   BUG_ON(1);
  }

  pte = pte_offset_kernel(pmd, va);
  if (!pte_present(*pte))
   break;

  printk(KERN_DEBUG "clearing pte for ram above max_low_pfn: pfn: %lx pmd: %p pmd phys: %lx pte: %p pte phys: %lx\n",
    pfn, pmd, __pa(pmd), pte, __pa(pte));
  pte_clear(NULL, va, pte);
 }
 paravirt_alloc_pmd(&init_mm, __pa(base) >> PAGE_SHIFT);
 paging_init();
}

void __init paging_init(void)
{
 pagetable_init();

 __flush_tlb_all();

 kmap_init();

 /*
  * NOTE: at this point the bootmem allocator is fully available.
  */
 olpc_dt_build_devicetree();
 sparse_init();
 zone_sizes_init();
}

static void __init pagetable_init(void)
{
 pgd_t *pgd_base = swapper_pg_dir;

 permanent_kmaps_init(pgd_base);
}

static void __init permanent_kmaps_init(pgd_t *pgd_base)
{
 unsigned long vaddr = PKMAP_BASE;

 page_table_range_init(vaddr, vaddr + PAGE_SIZE*LAST_PKMAP, pgd_base);

 pkmap_page_table = virt_to_kpte(vaddr);
}

static void __init kmap_init(void)
{
 unsigned long kmap_vstart;

 /*
  * Cache the first kmap pte:
  */
 kmap_vstart = __fix_to_virt(FIX_KMAP_BEGIN);
 kmap_pte = virt_to_kpte(kmap_vstart);
}

#if defined(CONFIG_FLATMEM)

#define __pfn_to_page(pfn) (mem_map + ((pfn) - ARCH_PFN_OFFSET))
#define __page_to_pfn(page) ((unsigned long)((page) - mem_map) + \
     ARCH_PFN_OFFSET)

#elif defined(CONFIG_DISCONTIGMEM)

#define __pfn_to_page(pfn)   \
({ unsigned long __pfn = (pfn);  \
 unsigned long __nid = arch_pfn_to_nid(__pfn);  \
 NODE_DATA(__nid)->node_mem_map + arch_local_page_offset(__pfn, __nid);\
})

#define __page_to_pfn(pg)      \
({ const struct page *__pg = (pg);     \
 struct pglist_data *__pgdat = NODE_DATA(page_to_nid(__pg)); \
 (unsigned long)(__pg - __pgdat->node_mem_map) +   \
  __pgdat->node_start_pfn;     \
})

#elif defined(CONFIG_SPARSEMEM)
/*
 * Note: section's mem_map is encoded to reflect its start_pfn.
 * section[i].section_mem_map == mem_map's address - start_pfn;
 */
#define __page_to_pfn(pg)     \
({ const struct page *__pg = (pg);    \
 int __sec = page_to_section(__pg);   \
 (unsigned long)(__pg - __section_mem_map_addr(__nr_to_section(__sec))); \
})

#define __pfn_to_page(pfn)    \
({ unsigned long __pfn = (pfn);   \
 struct mem_section *__sec = __pfn_to_section(__pfn); \
 __section_mem_map_addr(__sec) + __pfn;  \
})
#endif /* CONFIG_FLATMEM/DISCONTIGMEM/SPARSEMEM */

#elif defined(CONFIG_SPARSEMEM_VMEMMAP)

/* memmap is virtually contiguous.  */
#define __pfn_to_page(pfn) (vmemmap + (pfn))
#define __page_to_pfn(page) (unsigned long)((page) - vmemmap)

void __init zone_sizes_init(void)
{
 unsigned long max_zone_pfns[MAX_NR_ZONES];

 memset(max_zone_pfns, 0, sizeof(max_zone_pfns));

#ifdef CONFIG_ZONE_DMA
 max_zone_pfns[ZONE_DMA]  = min(MAX_DMA_PFN, max_low_pfn);
#endif
#ifdef CONFIG_ZONE_DMA32
 max_zone_pfns[ZONE_DMA32] = min(MAX_DMA32_PFN, max_low_pfn);
#endif
 max_zone_pfns[ZONE_NORMAL] = max_low_pfn;
#ifdef CONFIG_HIGHMEM
 max_zone_pfns[ZONE_HIGHMEM] = max_pfn;
#endif

 free_area_init(max_zone_pfns);
}

void __init free_area_init(unsigned long *max_zone_pfn)
{
 unsigned long start_pfn, end_pfn;
 int i, nid, zone;
 bool descending;

 /* Record where the zone boundaries are */
    //全局数组arch_zone_lowest_possible_pfn用来存储各个内存域可使用的最低内存页帧编号
    //全局数组arch_zone_highest_possible_pfn用来存储各个内存域可使用的最高内存页帧编号
 memset(arch_zone_lowest_possible_pfn, 0,
    sizeof(arch_zone_lowest_possible_pfn));
 memset(arch_zone_highest_possible_pfn, 0,
    sizeof(arch_zone_highest_possible_pfn));

    //用于最低内存区域中可用的编号最小的页帧，即memblock.memory.regions[0].base
 start_pfn = find_min_pfn_with_active_regions();
    //return false
 descending = arch_has_descending_max_zone_pfns();

    //根据max_zone_pfn和start_pfn初始化arch_zone_lowest_possible_pfn和arch_zone_highest_possible_pfn
 for (i = 0; i < MAX_NR_ZONES; i++) {
  if (descending)
   zone = MAX_NR_ZONES - i - 1;
  else
   zone = i;
  //由于ZONE_MOVABLE是一个虚拟内存域，不与真正的硬件内存域关联，该内存域的边界总是设置为0
  if (zone == ZONE_MOVABLE)
   continue;

  end_pfn = max(max_zone_pfn[zone], start_pfn);
  arch_zone_lowest_possible_pfn[zone] = start_pfn;
  arch_zone_highest_possible_pfn[zone] = end_pfn;

  start_pfn = end_pfn;
 }

 /* Find the PFNs that ZONE_MOVABLE begins at in each node */
 memset(zone_movable_pfn, 0, sizeof(zone_movable_pfn));
    //用于计算ZONE_MOVABLE的内存数量
    //在内存较多的32位系统上, 这通常会是ZONE_HIGHMEM, 但是对于64位系统，将使用ZONE_NORMAL或ZONE_DMA32，这里计算也比较复杂，感兴趣的话可以去看一下源码，这里便不做介绍了
 find_zone_movable_pfns_for_nodes();

 ......
    //各种打印
    ......

 /* Initialise every node */
    //为系统中的每个节点调用free_area_init_node()
 mminit_verify_pageflags_layout();
 setup_nr_node_ids();
 init_unavailable_mem();
 for_each_online_node(nid) {
  pg_data_t *pgdat = NODE_DATA(nid);
  free_area_init_node(nid);

  /* Any memory on that node */
  if (pgdat->node_present_pages)
   node_set_state(nid, N_MEMORY);
  check_for_memory(pgdat, nid);
 }
}

pg_data_t node_data[MAX_NUMNODES];
EXPORT_SYMBOL(node_data);

#ifdef CONFIG_NUMA
extern struct pglist_data *node_data[];
#define NODE_DATA(nid) (node_data[nid])
#endif /* CONFIG_NUMA */

static void __init free_area_init_node(int nid)
{
    //从全局节点数组中获取一个节点
 pg_data_t *pgdat = NODE_DATA(nid);
 unsigned long start_pfn = 0;
 unsigned long end_pfn = 0;

 /* pg_data_t should be reset to zero when it's allocated */
 WARN_ON(pgdat->nr_zones || pgdat->kswapd_highest_zoneidx);
 //根据节点id获取起始pfn和结束pfn，前面node初始化时，memblock处已经设置好节点ID了
 get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);
 //设置节点ID以及起始pfn
 pgdat->node_id = nid;
 pgdat->node_start_pfn = start_pfn;
 pgdat->per_cpu_nodestats = NULL;

 pr_info("Initmem setup node %d [mem %#018Lx-%#018Lx]\n", nid,
  (u64)start_pfn << PAGE_SHIFT,
  end_pfn ? ((u64)end_pfn << PAGE_SHIFT) - 1 : 0);
 //初始化节点中每个zone的大小和空洞，同时计算节点的spanned_pages和present_pages
    calculate_node_totalpages(pgdat, start_pfn, end_pfn);

 alloc_node_mem_map(pgdat);
 pgdat_set_deferred_range(pgdat);

 free_area_init_core(pgdat);
}

struct zoneref {
 struct zone *zone; /* Pointer to actual zone */
 int zone_idx;  /* zone_idx(zoneref->zone) */
};
struct zonelist {
 struct zoneref _zonerefs[MAX_ZONES_PER_ZONELIST + 1];
};
typedef struct pglist_data {
 //本节点的所有zone内存管理区
 struct zone node_zones[MAX_NR_ZONES];
    //包含了对所有node的zone的引用，通常第一个node_zonelists为本节点自己的zones
 struct zonelist node_zonelists[MAX_ZONELISTS];
 //本节点zone管理区数目
 int nr_zones; /* number of populated zones in this node */
#ifdef CONFIG_FLAT_NODE_MEM_MAP /* means !SPARSEMEM */
    //Discontiguous Memory内存模型，可以找到节点下的所有page
 struct page *node_mem_map;
#ifdef CONFIG_PAGE_EXTENSION
 struct page_ext *node_page_ext;
#endif
#endif

    ......

    //节点第一个页的页号
 unsigned long node_start_pfn;
    //节点总共的物理页数，不含空洞
 unsigned long node_present_pages; /* total number of physical pages */
    //节点物理页的范围大小，含空洞
 unsigned long node_spanned_pages; /* total size of physical page
          range, including holes */
 int node_id;

    ......
    //内存回收相关的数据结构
 ......

 ZONE_PADDING(_pad1_)
    ......
 unsigned long  flags;

 ZONE_PADDING(_pad2_)
    ......
} pg_data_t;

static void __init calculate_node_totalpages(struct pglist_data *pgdat,
      unsigned long node_start_pfn,
      unsigned long node_end_pfn)
{
 unsigned long realtotalpages = 0, totalpages = 0;
 enum zone_type i;

 for (i = 0; i < MAX_NR_ZONES; i++) {
  struct zone *zone = pgdat->node_zones + i;
  unsigned long zone_start_pfn, zone_end_pfn;
  unsigned long spanned, absent;
  unsigned long size, real_size;

  spanned = zone_spanned_pages_in_node(pgdat->node_id, i,
           node_start_pfn,
           node_end_pfn,
           &zone_start_pfn,
           &zone_end_pfn);
  absent = zone_absent_pages_in_node(pgdat->node_id, i,
         node_start_pfn,
         node_end_pfn);

  size = spanned;
  real_size = size - absent;

  if (size)
   zone->zone_start_pfn = zone_start_pfn;
  else
   zone->zone_start_pfn = 0;
  zone->spanned_pages = size;
  zone->present_pages = real_size;

  totalpages += size;
  realtotalpages += real_size;
 }

 pgdat->node_spanned_pages = totalpages;
 pgdat->node_present_pages = realtotalpages;
 printk(KERN_DEBUG "On node %d totalpages: %lu\n", pgdat->node_id,
       realtotalpages);
}

static unsigned long __init zone_spanned_pages_in_node(int nid,
     unsigned long zone_type,
     unsigned long node_start_pfn,
     unsigned long node_end_pfn,
     unsigned long *zone_start_pfn,
     unsigned long *zone_end_pfn)
{
 unsigned long zone_low = arch_zone_lowest_possible_pfn[zone_type];
 unsigned long zone_high = arch_zone_highest_possible_pfn[zone_type];
 /* When hotadd a new node from cpu_up(), the node should be empty */
 if (!node_start_pfn && !node_end_pfn)
  return 0;

 /* Get the start and end of the zone */
    //限制zone_start_pfn和zone_end_pfn所在区间
 *zone_start_pfn = clamp(node_start_pfn, zone_low, zone_high);
 *zone_end_pfn = clamp(node_end_pfn, zone_low, zone_high);
 adjust_zone_range_for_zone_movable(nid, zone_type,
    node_start_pfn, node_end_pfn,
    zone_start_pfn, zone_end_pfn);

 /* Check that this node has pages within the zone's required range */
 if (*zone_end_pfn < node_start_pfn || *zone_start_pfn > node_end_pfn)
  return 0;

 /* Move the zone boundaries inside the node if necessary */
 *zone_end_pfn = min(*zone_end_pfn, node_end_pfn);
 *zone_start_pfn = max(*zone_start_pfn, node_start_pfn);

 /* Return the spanned pages */
 return *zone_end_pfn - *zone_start_pfn;
}

unsigned long __init __absent_pages_in_range(int nid,
    unsigned long range_start_pfn,
    unsigned long range_end_pfn)
{
 unsigned long nr_absent = range_end_pfn - range_start_pfn;
 unsigned long start_pfn, end_pfn;
 int i;

 for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, NULL) {
  start_pfn = clamp(start_pfn, range_start_pfn, range_end_pfn);
  end_pfn = clamp(end_pfn, range_start_pfn, range_end_pfn);
  nr_absent -= end_pfn - start_pfn;
 }
 return nr_absent;
}

static unsigned long __init zone_absent_pages_in_node(int nid,
     unsigned long zone_type,
     unsigned long node_start_pfn,
     unsigned long node_end_pfn)
{
 unsigned long zone_low = arch_zone_lowest_possible_pfn[zone_type];
 unsigned long zone_high = arch_zone_highest_possible_pfn[zone_type];
 unsigned long zone_start_pfn, zone_end_pfn;
 unsigned long nr_absent;

 /* When hotadd a new node from cpu_up(), the node should be empty */
 if (!node_start_pfn && !node_end_pfn)
  return 0;

 zone_start_pfn = clamp(node_start_pfn, zone_low, zone_high);
 zone_end_pfn = clamp(node_end_pfn, zone_low, zone_high);

 adjust_zone_range_for_zone_movable(nid, zone_type,
   node_start_pfn, node_end_pfn,
   &zone_start_pfn, &zone_end_pfn);
 nr_absent = __absent_pages_in_range(nid, zone_start_pfn, zone_end_pfn);

 /*
  * ZONE_MOVABLE handling.
  * Treat pages to be ZONE_MOVABLE in ZONE_NORMAL as absent pages
  * and vice versa.
  */
 if (mirrored_kernelcore && zone_movable_pfn[nid]) {
  unsigned long start_pfn, end_pfn;
  struct memblock_region *r;

  for_each_mem_region(r) {
   start_pfn = clamp(memblock_region_memory_base_pfn(r),
       zone_start_pfn, zone_end_pfn);
   end_pfn = clamp(memblock_region_memory_end_pfn(r),
     zone_start_pfn, zone_end_pfn);

   if (zone_type == ZONE_MOVABLE &&
       memblock_is_mirror(r))
    nr_absent += end_pfn - start_pfn;

   if (zone_type == ZONE_NORMAL &&
       !memblock_is_mirror(r))
    nr_absent += end_pfn - start_pfn;
  }
 }

 return nr_absent;
}

struct zone {
 ......
    //保留页框池，记录每个管理区中必须保留的物理页面数，以用于紧急状况下的内存分配
 long lowmem_reserve[MAX_NR_ZONES];
    //保持对UMA的兼容(当做一个节点)，NUMA模式下的节点数
#ifdef CONFIG_NUMA
 int node;
#endif
 //该zone的父节点
    struct pglist_data *zone_pgdat;

 ......
 //该zone的第一个页的页号
 unsigned long  zone_start_pfn;
    //伙伴系统管理的page数，这是除去了在初始化阶段被申请的页面（比如memblock）
 atomic_long_t  managed_pages;
    //zone大小，含空洞，即zone_end_pfn - zone_start_pfn
 unsigned long  spanned_pages;
    //zone实际大小，不含空洞
 unsigned long  present_pages;
 //zone的名称，如“DMA”“Normal”“Highmem”，这些名称定义于page_alloc.c的zone_names[MAX_NR_ZONES]
 const char  *name;

 ZONE_PADDING(_pad1_)

 //包含所有空闲页面，伙伴系统使用，里面有数量为MIGRATE_TYPES个的free_list链表，分别用于管理不同迁移类型的内存页面
 struct free_area free_area[MAX_ORDER];
    //描述zone的当前状态
 unsigned long  flags;
    /* Primarily protects free_area */
    //与伙伴算法的碎片迁移算法有关
 spinlock_t  lock;

 ZONE_PADDING(_pad2_)

 ......

 ZONE_PADDING(_pad3_)
 ......
} ____cacheline_internodealigned_in_smp;

static void __init free_area_init_core(struct pglist_data *pgdat)
{
 enum zone_type j;
 int nid = pgdat->node_id;
 //对节点的一些锁和队列进行初始化
 pgdat_init_internals(pgdat);
 pgdat->per_cpu_nodestats = &boot_nodestats;

 for (j = 0; j < MAX_NR_ZONES; j++) {
  struct zone *zone = pgdat->node_zones + j;
  unsigned long size, freesize, memmap_pages;
  unsigned long zone_start_pfn = zone->zone_start_pfn;

  size = zone->spanned_pages;
  freesize = zone->present_pages;

  //memmap_pages,每一个4k物理页都对应一个mem_map_t来管理
  memmap_pages = calc_memmap_size(size, freesize);
  if (!is_highmem_idx(j)) {
   if (freesize >= memmap_pages) {
    freesize -= memmap_pages;
    if (memmap_pages)
     printk(KERN_DEBUG
            "  %s zone: %lu pages used for memmap\n",
            zone_names[j], memmap_pages);
   } else
    pr_warn("  %s zone: %lu pages exceeds freesize %lu\n",
     zone_names[j], memmap_pages, freesize);
  }

  //dma保留页
  if (j == 0 && freesize > dma_reserve) {
   freesize -= dma_reserve;
   printk(KERN_DEBUG "  %s zone: %lu pages reserved\n",
     zone_names[0], dma_reserve);
  }
  //计算nr_kernel_pages（低端内存的页数）和nr_all_pages的数量
  if (!is_highmem_idx(j))
   nr_kernel_pages += freesize;
  /* Charge for highmem memmap if there are enough kernel pages */
        //如果有足够的页，则也为高端内存提供memmap_pages
  else if (nr_kernel_pages > memmap_pages * 2)
   nr_kernel_pages -= memmap_pages;
  nr_all_pages += freesize;

  /*
   * Set an approximate value for lowmem here, it will be adjusted
   * when the bootmem allocator frees pages into the buddy system.
   * And all highmem pages will be managed by the buddy system.
   */
        //初始化zone使用的各类锁
  zone_init_internals(zone, j, nid, freesize);

  if (!size)
   continue;

  set_pageblock_order();
  setup_usemap(pgdat, zone, zone_start_pfn, size);
  init_currently_empty_zone(zone, zone_start_pfn, size);
  memmap_init(size, nid, j, zone_start_pfn);
 }
}

//遍历memblock，找到节点的内存地址范围，zone的范围不能大于这个，使用memmap_init_zone对该zone进行处理
void __meminit __weak memmap_init(unsigned long size, int nid,
      unsigned long zone,
      unsigned long range_start_pfn)
{
 unsigned long start_pfn, end_pfn;
 unsigned long range_end_pfn = range_start_pfn + size;
 int i;

 for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, NULL) {
  start_pfn = clamp(start_pfn, range_start_pfn, range_end_pfn);
  end_pfn = clamp(end_pfn, range_start_pfn, range_end_pfn);

  if (end_pfn > start_pfn) {
   size = end_pfn - start_pfn;
   memmap_init_zone(size, nid, zone, start_pfn,
      MEMINIT_EARLY, NULL, MIGRATE_MOVABLE);
  }
 }
}

void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,
  unsigned long start_pfn,
  enum meminit_context context,
  struct vmem_altmap *altmap, int migratetype)
{
 unsigned long pfn, end_pfn = start_pfn + size;
 struct page *page;

 if (highest_memmap_pfn < end_pfn - 1)
  highest_memmap_pfn = end_pfn - 1;

#ifdef CONFIG_ZONE_DEVICE
 /*
  * Honor reservation requested by the driver for this ZONE_DEVICE
  * memory. We limit the total number of pages to initialize to just
  * those that might contain the memory mapping. We will defer the
  * ZONE_DEVICE page initialization until after we have released
  * the hotplug lock.
  */
 if (zone == ZONE_DEVICE) {
  if (!altmap)
   return;

  if (start_pfn == altmap->base_pfn)
   start_pfn += altmap->reserve;
  end_pfn = altmap->base_pfn + vmem_altmap_offset(altmap);
 }
#endif

 for (pfn = start_pfn; pfn < end_pfn; ) {
  /*
   * There can be holes in boot-time mem_map[]s handed to this
   * function.  They do not exist on hotplugged memory.
   */
  if (context == MEMINIT_EARLY) {
   if (overlap_memmap_init(zone, &pfn))
    continue;
   if (defer_init(nid, pfn, end_pfn))
    break;
  }

  page = pfn_to_page(pfn);
  __init_single_page(page, pfn, zone, nid);
  if (context == MEMINIT_HOTPLUG)
   __SetPageReserved(page);

  /*
   * Usually, we want to mark the pageblock MIGRATE_MOVABLE,
   * such that unmovable allocations won't be scattered all
   * over the place during system boot.
   */
  if (IS_ALIGNED(pfn, pageblock_nr_pages)) {
   set_pageblock_migratetype(page, migratetype);
   cond_resched();
  }
  pfn++;
 }
}

    struct page (include/linux/mm_types.h)

                         page
               +--------------------------------------------------------------+
               |flags                                                         |
               |   (unsigned long)                                            |
   --+--       +==============================================================+
     |         |..............................................................|
     |         |page cache and anonymous pages                                |
     |         |    +---------------------------------------------------------+
     |         |    |lru                                                      |
     |         |    |    (struct list_head)                                   |
               |    |mapping                                                  |
               |    |    (struct address_space*)                              |
               |    |index                                                    |
               |    |    (pgoff_t)                                            |
  5 words      |    |private                                                  |
   union       |    |    (unsigned long)                                      |
               |    +---------------------------------------------------------+
               |..............................................................|
    has        |slab, slob, slub                                              |
               |    +---------------------------------------------------------+
  7 usage      |    |.........................................................|
               |    |                            .+---------------------------|
               |    |slab_list                   .|next                       |
               |    |    (struct list_head)      .|   (struct page*)          |
               |    |                            .|pages                      |
               |    |                            .|pobjects                   |
               |    |                            .|   (int)                   |
               |    |                            .+---------------------------|
               |    |.........................................................|
               |    +---------------------------------------------------------+
               |    |slab_cache                                               |
               |    |    (struct kmem_cache*)                                 |
               |    |freelist                                                 |
               |    |    (void*)                                              |
               |    +---------------------------------------------------------+
               |    |.........................................................|
               |    |s_mem    .counters          .+---------------------------|
               |    | (void*) . (unsigned long)  .|inuse                      |
               |    |         .                  .|objects                    |
               |    |         .                  .|frozen                     |
               |    |         .                  .|    (unsigned)             |
               |    |         .                  .+---------------------------|
               |    |.........................................................|
               |    +---------------------------------------------------------+
               |..............................................................|
               |Tail pages of compound page                                   |
               |    +---------------------------------------------------------+
               |    |compound_head                                            |
               |    |    (unsigned long)                                      |
               |    |compound_dtor                                            |
               |    |compound_order                                           |
               |    |    (unsigned char)                                      |
               |    |compound_mapcount                                        |
               |    |    (atomic_t)                                           |
               |    +---------------------------------------------------------+
               |..............................................................|
               |Second tail page of compound page                             |
               |    +---------------------------------------------------------+
               |    |_compound_pad_1                                          |
               |    |_compound_pad_2                                          |
               |    |    (unsigned long)                                      |
               |    |deferred_list                                            |
               |    |    (struct list_head)                                   |
               |    +---------------------------------------------------------+
               |..............................................................|
               |Page table pages                                              |
               |    +---------------------------------------------------------+
               |    |_pt_pad_1                                                |
               |    |    (unsigned long)                                      |
               |    |pmd_huge_pte                                             |
               |    |    (pgtable_t)                                          |
               |    |_pt_pad_2                                                |
               |    |    (unsigned long)                                      |
               |    |.........................................................|
               |    |pt_mm                         .pt_frag_refcount          |
               |    |    (struct mm_struct*)       .    (atomic_t)            |
               |    |.........................................................|
               |    |ptl                                                      |
               |    |    (spinlock_t/spinlock_t *)                            |
               |    +---------------------------------------------------------+
               |..............................................................|
               |ZONE_DEVICE pages                                             |
               |    +---------------------------------------------------------+
               |    |pgmap                                                    |
               |    |    (struct dev_pagemap*)                                |
               |    |hmm_data                                                 |
               |    |_zd_pad_1                                                |
     |         |    |    (unsigned long)                                      |
     |         |    +---------------------------------------------------------+
     |         |..............................................................|
     |         |rcu_head                                                      |
     |         |    (struct rcu_head)                                         |
     |         |..............................................................|
   --+--       +==============================================================+
     |         |..............................................................|
               |            .                 .                .              |
   4 bytes     |_mapcount   .page_type        .active          .units         |
    union      |  (atomic_t).   (unsigned int).  (unsigned int).   (int)      |
               |            .                 .                .              |
     |         |..............................................................|
   --+--       +==============================================================+
               |_refcount                                                     |
               |     (atomic_t)                                               |
               |mem_cgroup                                                    |
               |     (struct mem_cgroup)                                      |
               |virtual                                                       |
               |     (void *)                                                 |
               |_last_cpupid                                                  |
               |     (int)                                                    |
               +--------------------------------------------------------------+

page-flags.h
enum pageflags {
 PG_locked,  /* 表示页面已上锁，不要访问 */
 PG_error,     /* 表示页面发生IO错误 */
 PG_referenced, /* 用于RCU算法 */
 PG_uptodate,   /* 表示页面内容有效，当该页面上读操作完成后，设置该标志位 */
 PG_dirty,      /* 表示页面是脏页，内容被修改过 */
 PG_lru,        /* 表示该页面在lru链表中 */
 PG_active,     /* 表示该页面在活跃lru链表中 */
 PG_slab,       /* 表示该页面是属于slab分配器创建的slab */
 PG_owner_priv_1, /* 页面的所有者使用，如果是pagecache页面，文件系统可能使用*/
 PG_arch_1,       /* 与体系架构相关的页面状态位 */
 PG_reserved,     /* 表示该页面不可被换出，防止该page被交换到swap */
 PG_private,  /* 如果page中的private成员非空，则需要设置该标志，如果是pagecache, 包含fs-private data */
 PG_writeback,  /* 页面正在回写 */
 PG_head,  /* A head page */
 PG_swapcache,  /* 表示该page处于swap cache中 */
 PG_reclaim,  /* 表示该page要被回收，决定要回收某个page后，需要设置该标志 */
 PG_swapbacked,  /* 该page的后备存储器是swap/ram，一般匿名页才可以回写swap分区 */
 PG_unevictable,  /* 该page被锁住，不能回收，并会出现在LRU_UNEVICTABLE链表中 */
 ......
}

PageXXX()（检查是否设置）
SetPageXXX()
ClearPageXXX()

static void __meminit __init_single_page(struct page *page, unsigned long pfn,
    unsigned long zone, int nid)
{
 mm_zero_struct_page(page); //page初始化，根据page大小还有一些特殊操作
 set_page_links(page, zone, nid, pfn); //flags初始化，将页面映射到zone和node
 init_page_count(page); //page的_refcount设置为1
 page_mapcount_reset(page); //page的_mapcount设置为-1


 INIT_LIST_HEAD(&page->lru); //初始化lru，指向自身
 ......
}

void __init setup_arch(char **cmdline_p)
{
    ......
 max_pfn = e820__end_of_raCm_pfn(); //max_pfn初始化
 ......
 find_low_pfn_range(); //max_low_pfn、高端内存初始化
 ......

 ......
 early_alloc_pgt_buf(); //页表缓冲区分配
 reserve_brk(); //缓冲区加入memblock.reserve

    ......
    e820__memblock_setup(); //memblock.memory空间初始化 启动
 ......

    init_mem_mapping(); //低端内存内核页表初始化 高端内存固定映射区中临时映射区页表初始化

  ......
    initmem_init(); //high_memory初始化 通过memblock内存管理器设置node节点信息
    ......

    x86_init.paging.pagetable_init(); // 节点node、内存管理区zone、page初始化
    ......
}

//物理地址->物理页
#define PAGE_SHIFT _PAGE_SHIFT
#define _PAGE_SHIFT 12
#define phys_to_pfn(phys) ((phys) >> PAGE_SHIFT)
#define pfn_to_phys(pfn) ((pfn) << PAGE_SHIFT)

#define phys_to_page(phys) pfn_to_page(phys_to_pfn(phys))
#define page_to_phys(page) pfn_to_phys(page_to_pfn(page))

#define pfn_to_virt(pfn) __va(pfn_to_phys(pfn))
#define virt_to_pfn(kaddr) (phys_to_pfn(__pa(kaddr)))
#define virt_to_page(kaddr) pfn_to_page(virt_to_pfn(kaddr))
#define page_to_virt(page) pfn_to_virt(page_to_pfn(page))

#define __pa(x)         ((unsigned long) (x) - PAGE_OFFSET)
#define __va(x)         ((void *)((unsigned long) (x) + PAGE_OFFSET))