内存Zone中的pageset成员分析

   1: struct per_cpu_pageset __percpu *pageset;

首先，分析一个函数，__free_pages，这个函数是Buddy System提供的API接口函数，用于翻译曾经分配的一组页（多少个页视order大小而定）

   1: void __free_pages(struct page *page, unsigned int order)

   2: {

   3:     if (put_page_testzero(page)) {

   4:         if (order == 0)

   5:             free_hot_cold_page(page, 0);

   6:         else

   7:             __free_pages_ok(page, order);

   8:     }

   9: }

首先，调用put_page_testzero来查看该页是否还有其他引用（struct page结构中的_count）。

即先减去当前的这次引用（减1），然后查看是否引用值已经为0。

   1: /*

   2:  * Drop a ref, return true if the refcount fell to zero (the page has no users)

   3:  */

   4: static inline int put_page_testzero(struct page *page)

   5: {

   6:     VM_BUG_ON(atomic_read(&page->_count) == 0);

   7:     return atomic_dec_and_test(&page->_count);

   8: }

其中，atomic_xxx是内核提供的原子操作实现，有兴趣的话可以进一步深入研究。

然后，如果order为1，代表只有一个内存页需要释放，就调用free_hot_cold_page函数。

   1: /*

   2:  * Free a 0-order page

   3:  * cold == 1 ? free a cold page : free a hot page

   4:  */

   5: void free_hot_cold_page(struct page *page, int cold)

   6: {

   7:     struct zone *zone = page_zone(page);

   8:     struct per_cpu_pages *pcp;

   9:     unsigned long flags;

  10:     int migratetype;

  11:     int wasMlocked = __TestClearPageMlocked(page);

  12:  

  13:     if (!free_pages_prepare(page, 0))

  14:         return;

  15:  

  16:     migratetype = get_pageblock_migratetype(page);

  17:     set_page_private(page, migratetype);

  18:     local_irq_save(flags);

  19:     if (unlikely(wasMlocked))

  20:         free_page_mlock(page);

  21:     __count_vm_event(PGFREE);

  22:  

  23:     /*

  24:      * We only track unmovable, reclaimable and movable on pcp lists.

  25:      * Free ISOLATE pages back to the allocator because they are being

  26:      * offlined but treat RESERVE as movable pages so we can get those

  27:      * areas back if necessary. Otherwise, we may have to free

  28:      * excessively into the page allocator

  29:      */

  30:     if (migratetype >= MIGRATE_PCPTYPES) {

  31:         if (unlikely(migratetype == MIGRATE_ISOLATE)) {

  32:             free_one_page(zone, page, 0, migratetype);

  33:             goto out;

  34:         }

  35:         migratetype = MIGRATE_MOVABLE;

  36:     }

  37:  

  38:     pcp = &this_cpu_ptr(zone->pageset)->pcp;

  39:     if (cold)

  40:         list_add_tail(&page->lru, &pcp->lists[migratetype]);

  41:     else

  42:         list_add(&page->lru, &pcp->lists[migratetype]);

  43:     pcp->count++;

  44:     if (pcp->count >= pcp->high) {

  45:         free_pcppages_bulk(zone, pcp->batch, pcp);

  46:         pcp->count -= pcp->batch;

  47:     }

  48:  

  49: out:

  50:     local_irq_restore(flags);

  51: }

page_zone是根据page找到其所在的zone的函数，具体实现是在page->flags里面有相应的比特位，保存它是从哪个zone上分配的。

那么page->flags是从什么时候开始携带这些信息的呢？

首先，所有的page结构体都保存在pglist_data的成员node_mem_map指向的一片内存里。

   1: /*

   2:  * Initially all pages are reserved - free ones are freed

   3:  * up by free_all_bootmem() once the early boot process is

   4:  * done. Non-atomic initialization, single-pass.

   5:  */

   6: void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,

   7:         unsigned long start_pfn, enum memmap_context context)

   8: {

   9:     struct page *page;

  10:     unsigned long end_pfn = start_pfn + size;

  11:     unsigned long pfn;

  12:     struct zone *z;

  13:  

  14:     if (highest_memmap_pfn < end_pfn - 1)

  15:         highest_memmap_pfn = end_pfn - 1;

  16:  

  17:     z = &NODE_DATA(nid)->node_zones[zone];

  18:     for (pfn = start_pfn; pfn < end_pfn; pfn++) {

  19:         /*

  20:          * There can be holes in boot-time mem_map[]s

  21:          * handed to this function.  They do not

  22:          * exist on hotplugged memory.

  23:          */

  24:         if (context == MEMMAP_EARLY) {

  25:             if (!early_pfn_valid(pfn))

  26:                 continue;

  27:             if (!early_pfn_in_nid(pfn, nid))

  28:                 continue;

  29:         }

  30:         page = pfn_to_page(pfn);

  31:         set_page_links(page, zone, nid, pfn);

  32:         mminit_verify_page_links(page, zone, nid, pfn);

  33:         init_page_count(page);

  34:         reset_page_mapcount(page);

  35:         SetPageReserved(page);

  36:         /*

  37:          * Mark the block movable so that blocks are reserved for

  38:          * movable at startup. This will force kernel allocations

  39:          * to reserve their blocks rather than leaking throughout

  40:          * the address space during boot when many long-lived

  41:          * kernel allocations are made. Later some blocks near

  42:          * the start are marked MIGRATE_RESERVE by

  43:          * setup_zone_migrate_reserve()

  44:          *

  45:          * bitmap is created for zone's valid pfn range. but memmap

  46:          * can be created for invalid pages (for alignment)

  47:          * check here not to call set_pageblock_migratetype() against

  48:          * pfn out of zone.

  49:          */

  50:         if ((z->zone_start_pfn <= pfn)

  51:             && (pfn < z->zone_start_pfn + z->spanned_pages)

  52:             && !(pfn & (pageblock_nr_pages - 1)))

  53:             set_pageblock_migratetype(page, MIGRATE_MOVABLE);

  54:  

  55:         INIT_LIST_HEAD(&page->lru);

  56: #ifdef WANT_PAGE_VIRTUAL

  57:         /* The shift won't overflow because ZONE_NORMAL is below 4G. */

  58:         if (!is_highmem_idx(zone))

  59:             set_page_address(page, __va(pfn << PAGE_SHIFT));

  60: #endif

  61:     }

  62: }

在Buddy System初始化的过程中，会调用memmap_init_zone函数，在该函数中，会将属于该Zone的所有page结构体都遍历处理一遍，都调用一次set_page_links来建立page与zone之间的对应关系。

   1: static inline void set_page_zone(struct page *page, enum zone_type zone)

   2: {

   3:     page->flags &= ~(ZONES_MASK << ZONES_PGSHIFT);

   4:     page->flags |= (zone & ZONES_MASK) << ZONES_PGSHIFT;

   5: }

   6:  

   7: static inline void set_page_node(struct page *page, unsigned long node)

   8: {

   9:     page->flags &= ~(NODES_MASK << NODES_PGSHIFT);

  10:     page->flags |= (node & NODES_MASK) << NODES_PGSHIFT;

  11: }

  12:  

  13: static inline void set_page_links(struct page *page, enum zone_type zone,

  14:     unsigned long node, unsigned long pfn)

  15: {

  16:     set_page_zone(page, zone);

  17:     set_page_node(page, node);

  18: #if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)

  19:     set_page_section(page, pfn_to_section_nr(pfn));

  20: #endif

  21: }

内存启动过程的初始化

   1: void __init setup_arch(char **cmdline_p)

   2: {

   3: ......

   4: /* max_pfn_mapped is updated here */

   5: max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn<<PAGE_SHIFT);

   6: max_pfn_mapped = max_low_pfn_mapped;

   7: ......

   8: paging_init();

   9: ......

  10: }

调用init_memory_mapping

   1: /*

   2:  * Setup the direct mapping of the physical memory at PAGE_OFFSET.

   3:  * This runs before bootmem is initialized and gets pages directly from

   4:  * the physical memory. To access them they are temporarily mapped.

   5:  */

   6: unsigned long __init_refok init_memory_mapping(unsigned long start,

   7:                            unsigned long end)

   8: {

   9: ......

  10:  

  11: for (i = 0; i < nr_range; i++)

  12:     ret = kernel_physical_mapping_init(mr[i].start, mr[i].end,

  13:                        mr[i].page_size_mask);

  14:  

  15: ......

  16: }

调用kernel_physical_mapping_init

   1: /*

   2:  * This maps the physical memory to kernel virtual address space, a total

   3:  * of max_low_pfn pages, by creating page tables starting from address

   4:  * PAGE_OFFSET:

   5:  */

   6: unsigned long __init

   7: kernel_physical_mapping_init(unsigned long start,

   8:                  unsigned long end,

   9:                  unsigned long page_size_mask)

  10: {

  11:     int use_pse = page_size_mask == (1<<PG_LEVEL_2M);

  12:     unsigned long last_map_addr = end;

  13:     unsigned long start_pfn, end_pfn;

  14:     pgd_t *pgd_base = swapper_pg_dir;

  15:     int pgd_idx, pmd_idx, pte_ofs;

  16:     unsigned long pfn;

  17:     pgd_t *pgd;

  18:     pmd_t *pmd;

  19:     pte_t *pte;

  20:     unsigned pages_2m, pages_4k;

  21:     int mapping_iter;

  22:  

  23:     start_pfn = start >> PAGE_SHIFT;

  24:     end_pfn = end >> PAGE_SHIFT;

  25:  

  26:     /*

  27:      * First iteration will setup identity mapping using large/small pages

  28:      * based on use_pse, with other attributes same as set by

  29:      * the early code in head_32.S

  30:      *

  31:      * Second iteration will setup the appropriate attributes (NX, GLOBAL..)

  32:      * as desired for the kernel identity mapping.

  33:      *

  34:      * This two pass mechanism conforms to the TLB app note which says:

  35:      *

  36:      *     "Software should not write to a paging-structure entry in a way

  37:      *      that would change, for any linear address, both the page size

  38:      *      and either the page frame or attributes."

  39:      */

  40:     mapping_iter = 1;

  41:  

  42:     if (!cpu_has_pse)

  43:         use_pse = 0;

  44:  

  45: repeat:

  46:     pages_2m = pages_4k = 0;

  47:     pfn = start_pfn;

  48:     pgd_idx = pgd_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET);

  49:     pgd = pgd_base + pgd_idx;

  50:     for (; pgd_idx < PTRS_PER_PGD; pgd++, pgd_idx++) {

  51:         pmd = one_md_table_init(pgd);

  52:  

  53:         if (pfn >= end_pfn)

  54:             continue;

  55: #ifdef CONFIG_X86_PAE

  56:         pmd_idx = pmd_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET);

  57:         pmd += pmd_idx;

  58: #else

  59:         pmd_idx = 0;

  60: #endif

  61:         for (; pmd_idx < PTRS_PER_PMD && pfn < end_pfn;

  62:              pmd++, pmd_idx++) {

  63:             unsigned int addr = pfn * PAGE_SIZE + PAGE_OFFSET;

  64:  

  65:             /*

  66:              * Map with big pages if possible, otherwise

  67:              * create normal page tables:

  68:              */

  69:             if (use_pse) {

  70:                 unsigned int addr2;

  71:                 pgprot_t prot = PAGE_KERNEL_LARGE;

  72:                 /*

  73:                  * first pass will use the same initial

  74:                  * identity mapping attribute + _PAGE_PSE.

  75:                  */

  76:                 pgprot_t init_prot =

  77:                     __pgprot(PTE_IDENT_ATTR |

  78:                          _PAGE_PSE);

  79:  

  80:                 addr2 = (pfn + PTRS_PER_PTE-1) * PAGE_SIZE +

  81:                     PAGE_OFFSET + PAGE_SIZE-1;

  82:  

  83:                 if (is_kernel_text(addr) ||

  84:                     is_kernel_text(addr2))

  85:                     prot = PAGE_KERNEL_LARGE_EXEC;

  86:  

  87:                 pages_2m++;

  88:                 if (mapping_iter == 1)

  89:                     set_pmd(pmd, pfn_pmd(pfn, init_prot));

  90:                 else

  91:                     set_pmd(pmd, pfn_pmd(pfn, prot));

  92:  

  93:                 pfn += PTRS_PER_PTE;

  94:                 continue;

  95:             }

  96:             pte = one_page_table_init(pmd);

  97:  

  98:             pte_ofs = pte_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET);

  99:             pte += pte_ofs;

 100:             for (; pte_ofs < PTRS_PER_PTE && pfn < end_pfn;

 101:                  pte++, pfn++, pte_ofs++, addr += PAGE_SIZE) {

 102:                 pgprot_t prot = PAGE_KERNEL;

 103:                 /*

 104:                  * first pass will use the same initial

 105:                  * identity mapping attribute.

 106:                  */

 107:                 pgprot_t init_prot = __pgprot(PTE_IDENT_ATTR);

 108:  

 109:                 if (is_kernel_text(addr))

 110:                     prot = PAGE_KERNEL_EXEC;

 111:  

 112:                 pages_4k++;

 113:                 if (mapping_iter == 1) {

 114:                     set_pte(pte, pfn_pte(pfn, init_prot));

 115:                     last_map_addr = (pfn << PAGE_SHIFT) + PAGE_SIZE;

 116:                 } else

 117:                     set_pte(pte, pfn_pte(pfn, prot));

 118:             }

 119:         }

 120:     }

 121:     if (mapping_iter == 1) {

 122:         /*

 123:          * update direct mapping page count only in the first

 124:          * iteration.

 125:          */

 126:         update_page_count(PG_LEVEL_2M, pages_2m);

 127:         update_page_count(PG_LEVEL_4K, pages_4k);

 128:  

 129:         /*

 130:          * local global flush tlb, which will flush the previous

 131:          * mappings present in both small and large page TLB's.

 132:          */

 133:         __flush_tlb_all();

 134:  

 135:         /*

 136:          * Second iteration will set the actual desired PTE attributes.

 137:          */

 138:         mapping_iter = 2;

 139:         goto repeat;

 140:     }

 141:     return last_map_addr;

 142: }

在这里面，将swapper_pg_dir作为pgd_t（Page Directory）的指针，对swapper_pg_dir指向的内存区域作处理，将Normal区域的映射关系建立到该页目录中。

然后在paging_init中

   1: static void __init pagetable_init(void)

   2: {

   3:     pgd_t *pgd_base = swapper_pg_dir;

   4:  

   5:     permanent_kmaps_init(pgd_base);

   6: }