__alloc_pages_nodemask

/*
 * This is the'heart' of the zoned buddy allocator.
 */
struct page *
__alloc_pages_nodemask(gfp_t gfp_mask, unsigned intorder,
                     structzonelist *zonelist, nodemask_t *nodemask)
{
       structpage *page;
       unsignedint cpuset_mems_cookie;
       unsignedint alloc_flags = ALLOC_WMARK_LOW|ALLOC_FAIR;
       gfp_talloc_mask = gfp_mask; /* The gfp_t that was actually used for allocation */
       structalloc_context ac = {
              .high_zoneidx= gfp_zone(gfp_mask),
              .zonelist= zonelist,
              .nodemask= nodemask,
              .migratetype =gfpflags_to_migratetype(gfp_mask),
       };

       if(cpusets_enabled()) {
              alloc_mask|= __GFP_HARDWALL;
              alloc_flags|= ALLOC_CPUSET;
              if(!ac.nodemask)
                     ac.nodemask= &cpuset_current_mems_allowed;
       }

       gfp_mask&= gfp_allowed_mask;

       lockdep_trace_alloc(gfp_mask);

       might_sleep_if(gfp_mask& __GFP_DIRECT_RECLAIM);

       if(should_fail_alloc_page(gfp_mask, order))
              returnNULL;

       /*
        * Check the zones suitable for the gfp_maskcontain at least one
        * valid zone. It's possible to have an emptyzonelist as a result
        * of __GFP_THISNODE and a memoryless node
        */
       if(unlikely(!zonelist->_zonerefs->zone))
              returnNULL;

       if(IS_ENABLED(CONFIG_CMA) && ac.migratetype == MIGRATE_MOVABLE)
              alloc_flags|= ALLOC_CMA;

retry_cpuset:
       cpuset_mems_cookie= read_mems_allowed_begin();

       /* Dirtyzone balancing only done in the fast path */
       ac.spread_dirty_pages= (gfp_mask & __GFP_WRITE);

       /*
        * The preferred zone is used for statisticsbut crucially it is
        * also used as the starting point for thezonelist iterator. It
        * may get reset for allocations that ignorememory policies.
        */
       ac.preferred_zoneref= first_zones_zonelist(ac.zonelist,
                                   ac.high_zoneidx,ac.nodemask);
       if(!ac.preferred_zoneref) {
              page= NULL;
              gotono_zone;
       }

       /* Firstallocation attempt */
       page =get_page_from_freelist(alloc_mask, order, alloc_flags, &ac);
       if(likely(page))
              gotoout;

       /*
        * Runtime PM, block IO and its error handlingpath can deadlock
        * because I/O on the device might notcomplete.
        */
       alloc_mask= memalloc_noio_flags(gfp_mask);
       ac.spread_dirty_pages= false;

       /*
        * Restore the original nodemask if it waspotentially replaced with
        * &cpuset_current_mems_allowed to optimizethe fast-path attempt.
        */
       if(cpusets_enabled())
              ac.nodemask= nodemask;
       page =__alloc_pages_slowpath(alloc_mask, order, &ac);

no_zone:
       /*
        * When updating a task's mems_allowed, it ispossible to race with
        * parallel threads in such a way that an allocationcan fail while
        * the mask is being updated. If a pageallocation is about to fail,
        * check if the cpuset changed duringallocation and if so, retry.
        */
       if(unlikely(!page && read_mems_allowed_retry(cpuset_mems_cookie))) {
              alloc_mask= gfp_mask;
              gotoretry_cpuset;
       }

out:
       if(kmemcheck_enabled && page)
              kmemcheck_pagealloc_alloc(page,order, gfp_mask);

       trace_mm_page_alloc(page,order, alloc_mask, ac.migratetype);

       returnpage;
}