linux如何管理物理内存？

Linux kernel version: 5.0.1

arm64

　　1.将物理内存划分为若干页，每页的大小为4KiB(可以为8KiB或16KiB)，那么如何知道每个页当前是什么情况呢？

　　那就需要一个结构体来描述每一页的情况，那么就出现了结构体struct page.

　　2.有若干页，意味着需要若干个struct page这样的结构体来描述若干页的状态;

　　3.这些struct page存放在哪里呢？肯定是存放在物理内存里;

　　4.存放在物理内存里，那么假设物理内存有4MiB,指定页面大小为4KiB,那么这些物理内存能被划分为多少个页面呢？又需要多少物理内存来存放struct page结构体呢？

　　页面个数=4MiB/4KiB=4*1024 KiB/4KiB=1024个;

　　那么就需要1024个struct page来描述这1024个页面的情况,这么多结构体需要多少内存呢?

　　1024 * sizeof(struct page)

　　5.如何获取sizeof(struct page)的大小呢?

　　struct page结构体（结构体定义在include/linux/mm_types.h）如下:

   struct page {
       unsigned long flags;        /* Atomic flags, some possibly
                        * updated asynchronously */
       /*
        * 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 */
               /**
                * @lru: Pageout list, eg. active_list protected by
                * zone_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 {    /* slab, slob and slub */
               union {
                   struct list_head slab_list; /* uses lru */
                   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:;
                       unsigned objects:;
                       unsigned frozen:;
                   };
               };
           };
           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;
               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;
               unsigned long hmm_data;
               unsigned long _zd_pad_1;    /* uses mapping */
           };

           /** @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;

　　使用此内核模块获取，编译方法为：make CROSS_COMPILE=1 KDIR=<linux kernel source code path>

　　所以:

　　1024 * sizeof(struct page) = 1024 * 64 = 64 KiB = 16 个页面

　　6.既然有部分物理内存用来存储每个页面的情况，那么可用的物理内存必然少于4MiB,那么具体是多少呢？

　　1024 - 16 = 1008 个页面 = 1008 * 4 KiB = 4032 KiB