内存管理 初始化（八） 至kswapd_init

至此，内存初始化部分已看完，遗留问题：

1、对于unicore或者mips的页表建立都很清楚，但是对于ARM我不清楚：

      初始化部分涉及的页表映射建立，我都以unicore架构为准，ARM的页表映射从原理上讲easy，问题在于ARM的页表中没有引入Dirty、Accessed位，因此，对于如何在基于ARM架构的Linux系统上实现页回收就有些疑问，上次和同学看下代码，ARM使用了软件的方法解决了该问题，但是具体方法自己并不清楚.  当然对于新的ARM架构可能在页表项上已支持Dirty、Accessed位。

2、kswap的原理、实现？

3、对于zone->free_area的free_list的链表中的页的添加顺序（tail or head）,以及在其它的缓存机制中加入链表时——加入链表尾和链表头的区别？冷页、热页？

4、ZONE_MOVABLE区，希望关于这个区是我自己看错了，或者是对于嵌入式系统该区就没有利用，因为在我跟踪内存管理初始化的过程中，该区基本没用，但确实存在该区：为什么要引入ZONE_MOVABLE、有什么用？

5、zone:lowmem_reserve有什么用？

6、我回避了文件系统初始化部分，以及init_post的实现过程，我暂时不想把它们混入内存初始化部分。

7、.etc

kmem_cache_init_late之后的代码至kswapd_init

start_kernel()
  |-->page_address_init()

  | 

  |-->setup_arch(&command_line);

  |

  |-->setup_per_cpu_areas();

  |

  |-->build_all_zonelist()

  |

  |-->page_alloc_init()

  |

  |-->pidhash_init()

  |

  |-->vfs_caches_init_early()

  |

  |-->mm_init()

  |

  |-->.......

  |

  |-->init_IRQ()

  |

  |-->......

  |

  |-->gfp_allowed_mask = __GFP_BITS_MASK;

  |

  |-->kmem_cache_init_late();

  |

  |-->......

  |

  |-->setup_per_cpu_pageset();

  |   各个CPU申请内存时，如果需要获取页，则从各个zone中自己

  |   per_cpu_pageset获取(zone->pageset[]), 此处完成初始化. 

  |

  |-->......

  |

  |-->anon_vma_init();

      |-->anon_vma_cachep = kmem_cache_create("anon_vma",
      |                                    sizeof(struct anon_vma),

      |          0, SLAB_DESTROY_BY_RCU|SLAB_PANIC, anon_vma_ctor);

      |

      |-->anon_vma_chain_cachep = KMEM_CACHE(anon_vma_chain, SLAB_PANIC);

      | 即anon_vma_chain_cachep = kmem_cache_create("anon_vma_chain",

      |                           sizeof(struct anon_vma_chain),

      |                           __alignof__(struct anon_vma_chain),

      |                           SLAB_PANIC, NULL);

      |

  |-->fork_init(totalram_pages);

  |

  |-->proc_caches_init();

  |

  |-->......

  |

  |-->buffer_init();

  |   没看

  |-->......

  |

  |-->vfs_caches_init(totalram_pages);

  |   虚拟文件系统初始化

  |

  |-->......

  |

  |-->rest_init();

 

 

void setup_per_cpu_pageset(void)

  |-->struct zone *zone = NULL;

  |   int cpu = 0;

  |

  |--for_each_populated_zone(zone)

  |--{

  |    遍历所有的zone（zone->present_pages需不为0,注意ZONE_MOVABLE）

  |

  |    zone->pageset = alloc_percpu(struct per_cpu_pageset);

  |    原来的pageset职责是由全局的boot_pageset变量担当的，现在进行重新申请.

  |    关于alloc_percpu的percpu资源初始化是在setup_per_cpu_areas中完成的，

  |    这是通过bootmem完成的资源分配.

  |

  |    for_each_possible_cpu(cpu)

  |    {

  |      struct per_cpu_pageset *pcp = per_cpu_ptr(zone->pageset, cpu);

  |      setup_pageset(pcp, zone_batchsize(zone));

  |

  |      此处我们可以关注下对于boot_pageset的初始化：

  |      setup_pageset(&per_cpu(boot_pageset, cpu), 0);最后的参数是0

  |

  |      if(percpu_pagelist_fraction) setup_pagelist_highmark(pcp,

  |                 (zone->present_pages / percpu_pagelist_fraction));
  |      关于percpu_pagelist_fraction是通过proc来配置的，此处我们可以认为

  |      percpu_pagelist_fraction是0

  |

  |    }

  |--}

 

 

void fork_init(unsigned long mempages)
  |-->task_struct_cachep = kmem_cache_create("task_struct", 
  |                                      sizeof(struct task_struct),

  |               ARCH_MIN_TASKALIGN, SLAB_PANIC|SLAB_NOTRACK, NULL);

  |

  |-->max_threads = mempages / (8 * THREAD_SIZE / PAGE_SIZE);

  |   if(max_threads < 20) max_threads = 20;

  |

  |-->init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2;

  |   init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2;

  |   init_task.signal->rlim[RLIMIT_SIGPENDING] = 

  |                     init_task.signal->rlim[RLIMIT_NRPOC];

 

 

void proc_caches_init(void)

  |-->sighand_cachep = kmem_cache_create("sighand_cache",

  |                    sizeof(struct sighand_struct), 0,

  |    SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_DESTROY_BY_RCU|

  |    SLAB_NOTRACK, sighand_ctor);

  |

  |-->signal_cachep = kmem_cache_create("signal_cache",

  |                     sizeof(struct signal_struct), 0,

  |    SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL);

  |

  |-->files_cachep = kmem_cache_create("files_cache",

  |                     sizeof(struct files_struct), 0,

  |    SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL);

  |

  |-->fs_cachep = kmem_cache_create("fs_cache",

  |                     sizeof(struct fs_struct), 0,

  |    SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL);

  |

  |-->mm_cachep = kmem_cache_create("mm_struct",

  |     sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN,

  |      SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_NOTRACK, NULL);

  |

  |-->vm_area_cachep = KMEM_CACHE(vm_area_struct, SLAB_PANIC);

  | 即kmem_cache_create("vm_area_struct", 

  |                      sizeof(struct vm_area_struct), 
  |  __alignof__(struct vm_area_struct), SLAB_PANIC, NULL);

  |-->mmap_init();

void mmap_init(void)

  |-->int ret;

  |   ret = percpu_counter_init(&vm_committed_as, 0);

  |         |-->__percpu_counter_init(&vm_committed_as, 0);

            

int __percpu_counter_init(struct percpu_counter *fbc, s64 amount,

        struct lock_class_key *key)

  |-->spin_lock_init(&fbc->lock);

  |-->fbc->count = amount;

  |-->fbc->counters = alloc_percpu(s32);

  |-->return 0;

 

 

 

void rest_init(void)
  |-->kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);

  |

  |-->kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);

  |

  |-->kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);

  |

  |-->cpu_idle();

 

 

int kernel_init(void *unused)

  |-->smp_prepare_cpus(setup_max_cpus);

  |   |-->wakeup_secondary();

  |

  |-->smp_init()

  |   |-->cpu_up(cpu)

  |   |   |-->_cpu_up(cpu, 0)

  |   |   |   |-->__cpu_up(cpu);

  |   |   |      |-->boot_secondary(cpu, idle)

  |

  |-->do_basic_setup();

      |-->......

      |   并不意味这不重要，此处先回避相应的函数

      |

      |-->do_initcalls();

      |   对于这个函数,我们主要关注下：

      |   rootfs_initcall(populate_rootfs);

      |   module_init(init_per_zone_wmark_min);

      |   module_init(kswapd_init);

      |

  |

  |-->......

  |

  |-->init_post();

int init_post(void)

  |-->free_initmem()

      |-->totalram_pages += free_area(__phys_to_pfn(__pa(__init_begin)),

      |                               __phys_to_ptn(__pa(__init_end)),

      |                               "init");

      |   释放内核初始化相关部分的空间.

  |

  |-->system_state = SYSTEM_RUNNING;

  |

  |-->run_init_process(...)

 

 

 

我们此处重点关注: 

rootfs_initcall(populate_rootfs);

module_init(init_per_zone_wmark_min);

module_init(kswapd_init).

为什么？

1、populate_rootfs因为不知对于__initramfs_start ~ __initramfs_end的处理，

所以看下，当然不会太深入，这可是文件系统啊; 

2、init_per_zone_wmark_min涉及zone->watermark[]初始化;

3、kswapd_init页回收机制初始化（这个没有深入，我想看会资料后，在详细做下记录).



直接编译进内核：

#define __define_initcall(level, fn, id) \

    static initcall_t __initcall_##fn##id __used \

    __attribute__((__section__(".initcall" level ".init"))) = fn



#define rootfs_initcall(fn) __define_initcall("rootfs", fn, rootfs) 



#define device_initcall(fn) __define_initcall("6", fn, 6)

#define __initcall(fn)      device_initcall(fn)

#define module_init(x)      __initcall(x)

链接脚本中的__early_initcall_end和__initcall_end

                                                                                                                   

void do_initcalls(void)

  |-->initcall_t *fn;

  |-->for(fn = __early_initcall_end; fn < __initcall_end; fn++)

  |      do_one_initcall(*fn);

  |

  |-->flush_scheduled_work();

int populate_rootfs(void)

  |-->char *err = unpack_to_rootfs(__initramfs_start,

  |      __initramfs_end - __initramfs_start);

  |   关注下usr目录下的Makefile就明白了.

  |

  |-->if(initrd_start)

  |--{

  |    err = unpack_to_rootfs((char*)initrd_start, initrd_start,

  |          initrd_end - initrd_start);

  |    此处没有深入下去，文件系统以后解决.

  |

  |    if(!err){free_initrd(); return 0;}

  |    else .....

  |    ......

  |--}

  |  return 0;





这个没有深入，我想看会资料后，在详细做下记录

int kswapd_init(void)

  |-->swap_setup();

  |-->kswapd_run(0);

      |-->contig_page_data.kswapd = kthread_run(
      |       &contig_page_data, "kswapd0");

 

 

 

int init_per_zone_wmark_min(void)

  |-->unsigned long lowmem_kbytes;

  |  lowmen_kbytes = nr_free_buffer_pages() * (PGAE_SIZE >> 10);

  |  nr_free_buffer_pages()获取ZONE_DMA和ZONE_NORMAL区的页数.

  |  当然，如果没有ZONE_DMA,则只获取ZONE_NORMAL区的页数

  |

  |-->min_free_kbytes = int_sqrt(lowmem_kbytes * 16);

  |

  |-->if(min_free_kbytes < 128) min_free_kbytes = 128;

  |-->if(min_free_kbytes > 65536) min_free_kbytes = 65536;

  |

  |-->setup_per_zone_wmarks();

  |-->setup_per_zone_lowmem_reserve();

  |-->setup_per_zone_inactive_ratio();

  |-->return 0;

 

 

关于该函数的理解，可能有误：

每个zone都可能被耗尽，为了解决这种情况，

就在比自己低阶的zone中，把自身的一部分内存保存在低阶的

zone->lowmem_reserve[]中，以备自身被耗尽.

void setup_per_zone_lowmem_reserve(void)

  |-->struct pglist_data *pgdat;

  |   enum zone_type j, idx;

  |

  |-->考虑UMA

  |-->pgdat = contig_page_data;

  |-->for(j = 0; j < MAX_NR_ZONES; j++)

  |--{

  |     struct zone *zone = pgdat->node_zones + j;

  |     unsigned long present_pages = zone->present_pages;

  |     zone->lowmem_reserve[j] = 0;

  |     idx = j;

  |     while(idx)

  |     {

  |        struct zone *lower_zone;

  |        idx--;

  |        if(sysctl_lowmem_reserve_ratio[idx] < 1)

  |            sysctl_lowmem_reserve_ratio = 1;

  |      

  |        lower_zone = pgdat->node_zones + idx;

  |        lower_zone->lowmem_reserve[j] = present_pages /

  |              sysctl_lowmem_reserve_ratio[idx];

  |        present_pages += lower_zone->present_pages;

  |     }

  |--}

  |

  |-->calculate_totalreserve_pages();

 

 

void setup_per_zone_inactive_ratio(void)

  |-->for_each_zone(zone)

      |-->calculate_zone_inactive_ratio(zone);

void calculate_zone_inactive_ratio(struct zone *zone)

  |-->unsigned int gb, ratio;

  |

  |-->gb = zone->present_pages >> (30 - PAGE_SHIFT);

  |

  |-->if(gb) = int_sqrt(10 * gb);

  |   else ratio = 1;

  |

  |-->zone->inactive_ratio = ratio;

 

 

 

void setup_per_zone_wmarks(void)

  |-->unsigned long pages_min = min_free_kbytes >> (PAGE_SHITF - 10);

  |   获取min_free_kbytes所对应的页数. 

  |

  |-->unsigned long lowmem_pages = 0;

  |   struct zone *zone = NULL; 

  |   unsigned long flags = 0;

  |

  |-->for_each_zone(zone)

  |--{

  |     if(!is_highmem(zone)) lowmem_pages += zone->present_pages;

  |     如注释所言，获取非ZONE_HIGHMEM的zone中的present_pages总和.

  |--}

  |

  |--for_each_zone(zone)

  |--{

  |     u64 tmp;

  |     tmp = (u64)pages_min * zone->present_pages;

  |     do_div(tmp, lowmem_pages); //tmp = tmp / lowmem_pages

  |     对于以上两句,以通常的数学意义容易理解：

  |     pages_min * (zone->present_pages / lowmem_pages);

  |     if(is_highmem(zone))

  |    {  

  |      对于ZONE_HIGMEM做特殊处理. 

  |      int min_pages = zone->present_pages / 1024; 

  |      if(min_pages < SWAP_CLUSTER_MAX)

  |         min_pages = SWAP_CLUSTER_MAX;

  |      if(min_pages > 128)

  |         min_pages = 128;  

  |      zone->watermark[WMARK_MIN] = min_pages;

  |    }  

  |    else    

  |       zone->watermark[WMARK_MIN] = tmp;

  |

  |    zone->watermark[WMARK_LOW] = min_wmark_pages(zone) + (tmp >> 2);

  |    zone->watermark[WMARK_HIGH] = min_wmark_pages(zone) + (tmp >> 1);

  |    setup_zone_migrate_reserve(zone);

  |--}

  |

  |--calculate_totalreserve_pages();

  |

 

 

void setup_zone_migrate_reserve(struct zone *zone)

  |-->unsigned long start_pfn, pfn, end_pfn;

  |   struct page *page;

  |   unsigned long block_migratetype;

  |   int reserve;

  |

  |-->start_pfn = zone->zone_start_pfn;

  |   zone->zone_start_pfn是该zone中起始的那个页在物理内存中位置.

  |   end_pfn = start_pfn + zone->spanned_pages;

  |

  |-->reserve = roundup(min_wmark_pages(zone), pageblock_nr_pages)

  |             >> pageblock_order;

  |   reserve = min(2, reserve);

  |   以pageblock_order的整数被内存作为MIGRATE_RESERVE大小.

  |

  |-->for(pfn = start_pfn; pfn < end_pfn; pfn += pageblock_nr_pages)

  |--{

  |      page = pfn_to_page(pfn);

  |      if(PageRserved(page)) continue;

  |      block_migratetype = get_pageblock_migratetype(page);

  |

  |      if(reserve > 0 && block_migratetype == MIGRATE_RESERVE)

  |      {

  |         初始化过程中，到现在为止，我们只用到了MIGRATE_UNMOVABLE,

  |         MIGRATE_MOVABLE,只所以要检查，因为该函数可能通过proc

  |         被调用.

  |         reserve--; continue;

  |      }

  |

  |      if(reserve > 0 && block_migratetype == MIGRATE_MOVABLE)

  |      {

  |         set_pageblock_migratetype(page, MIGRATE_RESERVE);

  |         move_freepages_block(zone, page, MIGRATE_RESERVE);

  |         从MIGRATE_MOVABLE上迁移页块到MIGRATE_RESERVE链表上.

  |         reserve--;

  |         continue;

  |      }
  |
  |      if(block_migratetype = MIGRATE_RESERVE)
  |      {
  |          set_pageblock_migratetype(page, MIGRATE_MOVABLE);

  |          move_freepages_block(zone, page, MIGRATE_MOVABLE);

  |      }

  |--}

 

 

int zone_batchsize(struct zone *zone)

  |-->int batch;

  |

  |-->batch = zone->present_pages / 1024;

  |   if(batch * PAGE_SIZE > 512 * 1024)

  |      batch = (512 * 1024) / PAGE_SIZE;

  |   batch /= 4;

  |   if(batch < 1) batch = 1;

  |   batch = rounddown_pow_of_two(batch + batch/2) - 1;

  |   return batch;

 

 

void calculate_totalreserve_pages(void)
  |-->struct pglist_data *pgdat = NULL; 

  |   unsigned long reserve_pages = 0;

  |   enum zone_type i, j;

  |

  |-->考虑UMA

  |--pgdat = contig_page_data;

  |--for(i = 0; i < MAX_NR_ZONES; i++)

  |--{

  |     struct zone *zone = pgdat->node_zones + i;

  |     unsigned long max = 0;

  |     for(j = i; j < MAX_NR_ZONES; j++)

  |     { 

  |        if(zone->lowmem_reserve[j] > max)

  |             max = zone->lowmem_reserve[j]; 

  |        在初始化过程中,setup_per_lowmem_reserve是后于setup_per_zone_wmarks

  |        执行的，因此，首次执行calculate_totoalreseve_pages时，
  |        zone->lowmem_reserve[]为0，执行setup_per_lowmem_reserve
  |        后zone->lowmem_reserve[]被修正.
  |        注意，在setup_per_lowmem_reserve中也会执行该函数. 

  |     } 

  |

  |     max += high_wmark_pages(zone);

  | 

  |     if(max > zone->present_pages)

  |        max = zone->present_pages;

  |       

  |     reserve_pages += max; 

  |--}

  |

  |-->totoalreserve_pages = reserve_pages;

 

已是十月份，毕设+论文……后阶段，内容会更新地较慢，更多地从机制上阐述内核，关于具体的策略实现不会再如此详细。