1、__alloc_pages_nodemask（hear func）

zonelist可能为本地zonelist也可能为带有fallback的zonelist

  1. struct page *
  2. __alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order,
  3.             struct zonelist *zonelist, nodemask_t *nodemask)
  4. {
  5.     enum zone_type high_zoneidx = gfp_zone(gfp_mask);
  6.     struct zone *preferred_zone;
  7.     struct page *page;
  8.     int migratetype = allocflags_to_migratetype(gfp_mask);
  10.     gfp_mask &= gfp_allowed_mask;
  12.     lockdep_trace_alloc(gfp_mask);
  14.     might_sleep_if(gfp_mask & __GFP_WAIT);
  16.     if (should_fail_alloc_page(gfp_mask, order))
  17.         return NULL;
  19.     /*
  20.      * Check the zones suitable for the gfp_mask contain at least one
  21.      * valid zone. It's possible to have an empty zonelist as a result
  22.      * of GFP_THISNODE and a memoryless node
  23.      */
  24.     if (unlikely(!zonelist->_zonerefs->zone))
  25.         return NULL;
  27.     /* The preferred zone is used for statistics later */
  28.     first_zones_zonelist(zonelist, high_zoneidx, nodemask, &preferred_zone);
  29.     if (!preferred_zone)
  30.         return NULL;
  32.     /* First allocation attempt */
  33.     page = get_page_from_freelist(gfp_mask|__GFP_HARDWALL, nodemask, order,
  34.             zonelist, high_zoneidx, ALLOC_WMARK_LOW|ALLOC_CPUSET,
  35.             preferred_zone, migratetype);
  36.     if (unlikely(!page))
  37.         page = __alloc_pages_slowpath(gfp_mask, order,
  38.                 zonelist, high_zoneidx, nodemask,
  39.                 preferred_zone, migratetype);
  41.     trace_mm_page_alloc(page, order, gfp_mask, migratetype);
  42.     return page;
  43. }

1.1、get_page_from_freelist

  1. static struct page *get_page_from_freelist(gfp_t gfp_mask, nodemask_t *nodemask, 
  2.         unsigned int order,
  3.         struct zonelist *zonelist, int high_zoneidx, int alloc_flags,
  4.         struct zone *preferred_zone, int migratetype)
  5. {
  6.     struct zoneref *z;
  7.     struct page *page = NULL;
  8.     int classzone_idx;
  9.     struct zone *zone;
  10.     nodemask_t *allowednodes = NULL;/* zonelist_cache approximation */
  11.     int zlc_active = 0;        /* set if using zonelist_cache */
  12.     int did_zlc_setup = 0;        /* just call zlc_setup() one time */
  14.     // 获取zone的index ZONE_DMA OR ZONE_NORMAL
  15.     classzone_idx = zone_idx(preferred_zone);
  16. zonelist_scan:
  17.     for_each_zone_zonelist_nodemask(zone, z, zonelist, high_zoneidx, nodemask) {
  18.         if (NUMA_BUILD && zlc_active &&
  19.             !zlc_zone_worth_trying(zonelist, z, allowednodes))
  20.                 continue;
  21.         if ((alloc_flags & ALLOC_CPUSET) &&
  22.             !cpuset_zone_allowed_softwall(zone, gfp_mask))
  23.                 goto try_next_zone;
  25.         if (!(alloc_flags & ALLOC_NO_WATERMARKS)) {
  26.             unsigned long mark;
  27.             int ret;
  28.             mark = zone->watermark[alloc_flags & ALLOC_WMARK_MASK];
  29.             if (zone_watermark_ok(zone, order, mark,
  30.                     classzone_idx, alloc_flags))
  31.                 goto try_this_zone;
  33.             if (zone_reclaim_mode == 0)
  34.                 goto this_zone_full;
  36.             ret = zone_reclaim(zone, gfp_mask, order);
  37.             switch (ret) {
  38.             case ZONE_RECLAIM_NOSCAN:
  39.                 /* did not scan */
  40.                 goto try_next_zone;
  41.             case ZONE_RECLAIM_FULL:
  42.                 /* scanned but unreclaimable */
  43.                 goto this_zone_full;
  44.             default:
  45.                 /* did we reclaim enough */
  46.                 if (!zone_watermark_ok(zone, order, mark,
  47.                         classzone_idx, alloc_flags))
  48.                     goto this_zone_full;
  49.             }
  50.         }
  52. try_this_zone:
  53.         page = buffered_rmqueue(preferred_zone, zone, order,
  54.                         gfp_mask, migratetype);
  55.         if (page)
  56.             break;
  57. this_zone_full:
  58.         if (NUMA_BUILD)
  59.             zlc_mark_zone_full(zonelist, z);
  60. try_next_zone:
  61.         if (NUMA_BUILD && !did_zlc_setup && nr_online_nodes > 1) {
  62.             /*
  63.              * we do zlc_setup after the first zone is tried but only
  64.              * if there are multiple nodes make it worthwhile
  65.              */
  66.             allowednodes = zlc_setup(zonelist, alloc_flags);
  67.             zlc_active = 1;
  68.             did_zlc_setup = 1;
  69.         }
  70.     }
  72.     if (unlikely(NUMA_BUILD && page == NULL && zlc_active)) {
  73.         /* Disable zlc cache for second zonelist scan */
  74.         zlc_active = 0;
  75.         goto zonelist_scan;
  76.     }
  77.     return page;
  78. }

1.2、buffered_rmqueue

  1. /*
  2.  * Really, prep_compound_page() should be called from __rmqueue_bulk().  But
  3.  * we cheat by calling it from here, in the order > 0 path.  Saves a branch
  4.  * or two.
  5.  */
  6. static inline struct page *buffered_rmqueue(struct zone *preferred_zone,
  7.             struct zone *zone, int order, gfp_t gfp_flags,
  8.             int migratetype)
  9. {
  10.     unsigned long flags;
  11.     struct page *page;
  12.     int cold = !!(gfp_flags & __GFP_COLD);
  14. again:
  15.     if (likely(order == 0)) {
  16.         struct per_cpu_pages *pcp;
  17.         struct list_head *list;
  19.         local_irq_save(flags);
  20.         pcp = &this_cpu_ptr(zone->pageset)->pcp;
  21.         list = &pcp->lists[migratetype];
  22.         if (list_empty(list)) {
  23.             pcp->count += rmqueue_bulk(zone, 0,
  24.                     pcp->batch, list,
  25.                     migratetype, cold);
  26.             if (unlikely(list_empty(list)))
  27.                 goto failed;
  28.         }
  30.         if (cold)
  31.             page = list_entry(list->prev, struct page, lru);
  32.         else
  33.             page = list_entry(list->next, struct page, lru);
  35.         list_del(&page->lru);
  36.         pcp->count--;
  37.     } else {
  38.         if (unlikely(gfp_flags & __GFP_NOFAIL)) {
  39.             /*
  40.              * __GFP_NOFAIL is not to be used in new code.
  41.              *
  42.              * All __GFP_NOFAIL callers should be fixed so that they
  43.              * properly detect and handle allocation failures.
  44.              *
  45.              * We most definitely don't want callers attempting to
  46.              * allocate greater than order-1 page units with
  47.              * __GFP_NOFAIL.
  48.              */
  49.             WARN_ON_ONCE(order > 1);
  50.         }
  51.         spin_lock_irqsave(&zone->lock, flags);
  52.         page = __rmqueue(zone, order, migratetype);
  53.         spin_unlock(&zone->lock);
  54.         if (!page)
  55.             goto failed;
  56.         __mod_zone_page_state(zone, NR_FREE_PAGES, -(1 << order));
  57.     }
  59.     __count_zone_vm_events(PGALLOC, zone, 1 << order);
  60.     zone_statistics(preferred_zone, zone);
  61.     local_irq_restore(flags);
  63.     VM_BUG_ON(bad_range(zone, page));
  64.     if (prep_new_page(page, order, gfp_flags))
  65.         goto again;
  66.     return page;
  68. failed:
  69.     local_irq_restore(flags);
  70.     return NULL;
  71. }