__alloc_pages_slowpath

 

static inline struct page *

__alloc_pages_slowpath(gfp_t gfp_mask, unsigned intorder,

                                          structalloc_context *ac)

{

       boolcan_direct_reclaim = gfp_mask & __GFP_DIRECT_RECLAIM;

       structpage *page = NULL;

       unsignedint alloc_flags;

       unsignedlong did_some_progress;

       enummigrate_mode migration_mode = MIGRATE_ASYNC;

       enumcompact_result compact_result;

       intcompaction_retries = 0;

       intno_progress_loops = 0;

 

       /*

        * In the slowpath, we sanity check order toavoid ever trying to

        * reclaim >= MAX_ORDER areas which willnever succeed. Callers may

        * be using allocators in order of preferencefor an area that is

        * too large.

        */

       if (order>= MAX_ORDER) {

              WARN_ON_ONCE(!(gfp_mask& __GFP_NOWARN));

              returnNULL;

       }

 

       /*

        * We also sanity check to catch abuse ofatomic reserves being used by

        * callers that are not in atomic context.

        */

       if(WARN_ON_ONCE((gfp_mask & (__GFP_ATOMIC|__GFP_DIRECT_RECLAIM)) ==

                            (__GFP_ATOMIC|__GFP_DIRECT_RECLAIM)))

              gfp_mask&= ~__GFP_ATOMIC;

 

retry:

       if(gfp_mask & __GFP_KSWAPD_RECLAIM)

              wake_all_kswapds(order,ac);

 

       /*

        * OK, we're below the kswapd watermark andhave kicked background

        * reclaim. Now things get more complex, so setup alloc_flags according

        * to how we want to proceed.

        */

       alloc_flags= gfp_to_alloc_flags(gfp_mask);

 

       /*

        * Reset the zonelist iterators if memorypolicies can be ignored.

        * These allocations are high priority andsystem rather than user

        * orientated.

        */

       if((alloc_flags & ALLOC_NO_WATERMARKS) || !(alloc_flags & ALLOC_CPUSET)){

              ac->zonelist= node_zonelist(numa_node_id(), gfp_mask);

              ac->preferred_zoneref= first_zones_zonelist(ac->zonelist,

                                   ac->high_zoneidx,ac->nodemask);

       }

 

       /* This isthe last chance, in general, before the goto nopage. */

       page =get_page_from_freelist(gfp_mask, order,

                            alloc_flags& ~ALLOC_NO_WATERMARKS, ac);

       if (page)

              gotogot_pg;

 

       /*Allocate without watermarks if the context allows */

       if(alloc_flags & ALLOC_NO_WATERMARKS) {

              page= get_page_from_freelist(gfp_mask, order,

                                          ALLOC_NO_WATERMARKS,ac);

              if(page)

                     gotogot_pg;

       }

 

       /* Calleris not willing to reclaim, we can't balance anything */

       if(!can_direct_reclaim) {

              /*

               * All existing users of the __GFP_NOFAIL areblockable, so warn

               * of any new users that actually allow thistype of allocation

               * to fail.

               */

              WARN_ON_ONCE(gfp_mask& __GFP_NOFAIL);

              gotonopage;

       }

 

       /* Avoidrecursion of direct reclaim */

       if(current->flags & PF_MEMALLOC) {

              /*

               * __GFP_NOFAIL request from this context israther bizarre

               * because we cannot reclaim anything and onlycan loop waiting

               * for somebody to do a work for us.

               */

              if(WARN_ON_ONCE(gfp_mask & __GFP_NOFAIL)) {

                     cond_resched();

                     gotoretry;

              }

              gotonopage;

       }

 

       /* Avoidallocations with no watermarks from looping endlessly */

       if(test_thread_flag(TIF_MEMDIE) && !(gfp_mask & __GFP_NOFAIL))

              gotonopage;

 

       /*

        * Try direct compaction. The first pass isasynchronous. Subsequent

        * attempts after direct reclaim aresynchronous

        */

       page =__alloc_pages_direct_compact(gfp_mask, order, alloc_flags, ac,

                                   migration_mode,

                                   &compact_result);

       if (page)

              gotogot_pg;

 

       /* Checksfor THP-specific high-order allocations */

       if (is_thp_gfp_mask(gfp_mask)){

              /*

               * If compaction is deferred for high-orderallocations, it is

               * because sync compaction recently failed. Ifthis is the case

               * and the caller requested a THP allocation,we do not want

               * to heavily disrupt the system, so we failthe allocation

               * instead of entering direct reclaim.

               */

              if(compact_result == COMPACT_DEFERRED)

                     gotonopage;

 

              /*

               * Compaction is contended so rather back offthan cause

               * excessive stalls.

               */

              if(compact_result== COMPACT_CONTENDED)

                     gotonopage;

       }

 

       if (order&& compaction_made_progress(compact_result))

              compaction_retries++;

 

       /* Trydirect reclaim and then allocating */

       page =__alloc_pages_direct_reclaim(gfp_mask, order, alloc_flags, ac,

                                                 &did_some_progress);

       if (page)

              gotogot_pg;

 

       /* Do notloop if specifically requested */

       if(gfp_mask & __GFP_NORETRY)

              gotonoretry;

 

       /*

        * Do not retry costly high order allocationsunless they are

        * __GFP_REPEAT

        */

       if (order> PAGE_ALLOC_COSTLY_ORDER && !(gfp_mask & __GFP_REPEAT))

              gotonoretry;

 

       /*

        * Costly allocations might have made aprogress but this doesn't mean

        * their order will become available due tohigh fragmentation so

        * always increment the no progress counter forthem

        */

       if(did_some_progress && order <= PAGE_ALLOC_COSTLY_ORDER)

              no_progress_loops= 0;

       else

              no_progress_loops++;

 

       if(should_reclaim_retry(gfp_mask, order, ac, alloc_flags,

                             did_some_progress > 0, no_progress_loops))

              gotoretry;

 

       /*

        * It doesn't make any sense to retry for thecompaction if the order-0

        * reclaim is not able to make any progressbecause the current

        * implementation of the compaction depends onthe sufficient amount

        * of free memory (see __compaction_suitable)

        */

       if(did_some_progress > 0 &&

                     should_compact_retry(ac,order, alloc_flags,

                            compact_result,&migration_mode,

                            compaction_retries))

              gotoretry;

 

       /* Reclaimhas failed us, start killing things */

       page =__alloc_pages_may_oom(gfp_mask, order, ac, &did_some_progress);

       if (page)

              gotogot_pg;

 

       /* Retryas long as the OOM killer is making progress */

       if(did_some_progress) {

              no_progress_loops= 0;

              gotoretry;

       }

 

noretry:

       /*

        * High-order allocations do not necessarilyloop after direct reclaim

        * and reclaim/compaction depends on compactionbeing called after

        * reclaim so call directly if necessary.

        * It can become very expensive to allocatetransparent hugepages at

        * fault, so use asynchronous memory compactionfor THP unless it is

        * khugepaged trying to collapse. All otherrequests should tolerate

        * at least light sync migration.

        */

       if(is_thp_gfp_mask(gfp_mask) && !(current->flags & PF_KTHREAD))

              migration_mode= MIGRATE_ASYNC;

       else

              migration_mode= MIGRATE_SYNC_LIGHT;

       page =__alloc_pages_direct_compact(gfp_mask, order, alloc_flags,

                                       ac, migration_mode,

                                       &compact_result);

       if (page)

              gotogot_pg;

nopage:

       warn_alloc_failed(gfp_mask,order, NULL);

got_pg:

       returnpage;

}