bootmem 释放页到伙伴系统

 

在前面介绍的mm_init中，其调用函数mem_init()，在这个函数中会把bootmem中空闲内存释放到伙伴系统。我们下面看bootmem中一个释放内存的

函数free_all_bootmem

unsigned long __init free_all_bootmem(void){ unsigned long total_pages = 0; bootmem_data_t *bdata;
 reset_all_zones_managed_pages();
 list_for_each_entry(bdata, &bdata_list, list)  total_pages += free_all_bootmem_core(bdata);
 totalram_pages += total_pages;
 return total_pages;}

可以看到，函数针对系统内的所有node节点下内存进行释放，这里对链表bdata_list遍历处理，然后调用函数free_all_bootmem_core()，并且把释放的总页数记录到totalram_pages中。内核中很多函数会使用totalram_pages变量来了解系统有多少空闲内存。

函数free_all_bootmem_core(bootmem_data_t *bdata)是bootmem内存管理释放内存的核心函数，函数实现如下：

static unsigned long __init free_all_bootmem_core(bootmem_data_t *bdata){ struct page *page; unsigned long *map, start, end, pages, cur, count = 0;
 if (!bdata->node_bootmem_map)  return 0;节点node下必须关联了内存，否则释放无从谈起
 map = bdata->node_bootmem_map;获取node下内存以位图描述的指针，对于2^32即4GB内存来说，共有2^20个页，一个字节有8比特，所以这些页需要2^17字节
2^17 字节需要多少页呢，可想而知需要2^5个连续页，即32个页才能跟踪这4GB物理内存。 start = bdata->node_min_pfn;起始页帧号 end = bdata->node_low_pfn;结束页帧号。
 bdebug("nid=%td start=%lx end=%lx\n",  bdata - bootmem_node_data, start, end);
 while (start < end) {  unsigned long idx, vec;  unsigned shift;
  idx = start - bdata->node_min_pfn;获取位图描述的index  shift = idx & (BITS_PER_LONG - 1);看看偏移值  /*   * vec holds at most BITS_PER_LONG map bits,   * bit 0 corresponds to start.   */  vec = ~map[idx / BITS_PER_LONG];了解位于哪个位置
  if (shift) {   vec >>= shift;   if (end - start >= BITS_PER_LONG)    vec |= ~map[idx / BITS_PER_LONG + 1] <<     (BITS_PER_LONG - shift);  }  /*   * If we have a properly aligned and fully unreserved   * BITS_PER_LONG block of pages in front of us, free   * it in one go.   */  if (IS_ALIGNED(start, BITS_PER_LONG) && vec == ~0UL) {   int order = ilog2(BITS_PER_LONG);
   __free_pages_bootmem(pfn_to_page(start), start, order);释放到伙伴系统   count += BITS_PER_LONG;   start += BITS_PER_LONG;  } else {   cur = start;
   start = ALIGN(start + 1, BITS_PER_LONG);   while (vec && cur != start) {    if (vec & 1) {     page = pfn_to_page(cur);     __free_pages_bootmem(page, cur, 0);     count++;    }    vec >>= 1;    ++cur;   }  } }
 cur = bdata->node_min_pfn; page = virt_to_page(bdata->node_bootmem_map); pages = bdata->node_low_pfn - bdata->node_min_pfn; pages = bootmem_bootmap_pages(pages); count += pages; while (pages--)  __free_pages_bootmem(page++, cur++, 0); bdata->node_bootmem_map = NULL;
 bdebug("nid=%td released=%lx\n", bdata - bootmem_node_data, count);
 return count;}可以看到，最后把map数组占用的内存也释放了。
 

void __init __free_pages_bootmem(struct page *page, unsigned long pfn,unsigned int order){ if (early_page_uninitialised(pfn))  return; return __free_pages_boot_core(page, order);}

static void __init __free_pages_boot_core(struct page *page, unsigned int order){ unsigned int nr_pages = 1 << order; struct page *p = page; unsigned int loop;
 prefetchw(p); for (loop = 0; loop < (nr_pages - 1); loop++, p++) {  prefetchw(p + 1);  __ClearPageReserved(p);  set_page_count(p, 0); } __ClearPageReserved(p); set_page_count(p, 0);
 page_zone(page)->managed_pages += nr_pages; set_page_refcounted(page); __free_pages(page, order);}在所有的页的相关属性设置后，最后通过__free_pages(page, order)把页释放到伙伴系统。

void __free_pages(struct page *page, unsigned int order){ if (put_page_testzero(page)) {  if (order == 0)   free_hot_cold_page(page, false); 进per-cpu高速缓存队列  else   __free_pages_ok(page, order);释放到伙伴系统 }}

static void __free_pages_ok(struct page *page, unsigned int order){ unsigned long flags; int migratetype; unsigned long pfn = page_to_pfn(page);
 if (!free_pages_prepare(page, order, true))  return;
 migratetype = get_pfnblock_migratetype(page, pfn); local_irq_save(flags); __count_vm_events(PGFREE, 1 << order); free_one_page(page_zone(page), page, pfn, order, migratetype); local_irq_restore(flags);}
 
函数free_hot_cold_page()把空闲内存释放到per-cpu链表。这个也是位于zone下面的pageset对象/* * Free a 0-order page * cold == true ? free a cold page : free a hot page */void free_hot_cold_page(struct page *page, bool cold){ struct zone *zone = page_zone(page); struct per_cpu_pages *pcp; unsigned long flags; unsigned long pfn = page_to_pfn(page); int migratetype;
 if (!free_pcp_prepare(page))  return;
 migratetype = get_pfnblock_migratetype(page, pfn); set_pcppage_migratetype(page, migratetype); local_irq_save(flags); __count_vm_event(PGFREE);
 /*  * We only track unmovable, reclaimable and movable on pcp lists.  * Free ISOLATE pages back to the allocator because they are being  * offlined but treat RESERVE as movable pages so we can get those  * areas back if necessary. Otherwise, we may have to free  * excessively into the page allocator  */ if (migratetype >= MIGRATE_PCPTYPES) {  if (unlikely(is_migrate_isolate(migratetype))) {   free_one_page(zone, page, pfn, 0, migratetype);   goto out;  }  migratetype = MIGRATE_MOVABLE; }
 pcp = &this_cpu_ptr(zone->pageset)->pcp; if (!cold)  list_add(&page->lru, &pcp->lists[migratetype]); else  list_add_tail(&page->lru, &pcp->lists[migratetype]); pcp->count++; if (pcp->count >= pcp->high) {批处理这些页，如果较多，则我们把per-cpu上面的页释放到伙伴系统。  unsigned long batch = READ_ONCE(pcp->batch);  free_pcppages_bulk(zone, batch, pcp);  pcp->count -= batch; }
out: local_irq_restore(flags);}
/* * Frees a number of pages from the PCP lists * Assumes all pages on list are in same zone, and of same order. * count is the number of pages to free. * * If the zone was previously in an "all pages pinned" state then look to * see if this freeing clears that state. * * And clear the zone's pages_scanned counter, to hold off the "all pages are * pinned" detection logic. */
从per-cpu链表上把内存释放到伙伴系统static void free_pcppages_bulk(struct zone *zone, int count,     struct per_cpu_pages *pcp){ int migratetype = 0; int batch_free = 0; unsigned long nr_scanned; bool isolated_pageblocks;
 spin_lock(&zone->lock); isolated_pageblocks = has_isolate_pageblock(zone); nr_scanned = node_page_state(zone->zone_pgdat, NR_PAGES_SCANNED); if (nr_scanned)  __mod_node_page_state(zone->zone_pgdat, NR_PAGES_SCANNED, -nr_scanned);
 while (count) {  struct page *page;  struct list_head *list;
  /*   * Remove pages from lists in a round-robin fashion. A   * batch_free count is maintained that is incremented when an   * empty list is encountered.  This is so more pages are freed   * off fuller lists instead of spinning excessively around empty   * lists   */  do {   batch_free++;   if (++migratetype == MIGRATE_PCPTYPES)    migratetype = 0;   list = &pcp->lists[migratetype];  } while (list_empty(list));
  /* This is the only non-empty list. Free them all. */  if (batch_free == MIGRATE_PCPTYPES)   batch_free = count;
  do {   int mt; /* migratetype of the to-be-freed page */
   page = list_last_entry(list, struct page, lru);   /* must delete as __free_one_page list manipulates */   list_del(&page->lru);
   mt = get_pcppage_migratetype(page);   /* MIGRATE_ISOLATE page should not go to pcplists */   VM_BUG_ON_PAGE(is_migrate_isolate(mt), page);   /* Pageblock could have been isolated meanwhile */   if (unlikely(isolated_pageblocks))    mt = get_pageblock_migratetype(page);
   if (bulkfree_pcp_prepare(page))    continue;
   __free_one_page(page, page_to_pfn(page), zone, 0, mt);   trace_mm_page_pcpu_drain(page, 0, mt);  } while (--count && --batch_free && !list_empty(list)); } spin_unlock(&zone->lock);}