1、cache_alloc_refill

  1. static void *cache_alloc_refill(struct kmem_cache *cachep, gfp_t flags)
  2. {
  3.     int batchcount;
  4.     struct kmem_list3 *l3;
  5.     struct array_cache *ac;
  6.     int node;
  8. retry:
  9.     check_irq_off();
  10.     node = numa_node_id();
  11.     ac = cpu_cache_get(cachep);
  12.     // 初始化阶段batchcount为1
  13.     batchcount = ac->batchcount;
  14.     if (!ac->touched && batchcount > BATCHREFILL_LIMIT) {
  15.         /*
  16.          * If there was little recent activity on this cache, then
  17.          * perform only a partial refill.  Otherwise we could generate
  18.          * refill bouncing.
  19.          */
  20.         batchcount = BATCHREFILL_LIMIT;
  21.     }
  22.     l3 = cachep->nodelists[node];
  24.     spin_lock(&l3->list_lock);
  26.     /* See if we can refill from the shared array */
  27.     // 初始化阶段l3均为空，此处也不会执行
  28.     if (l3->shared && transfer_objects(ac, l3->shared, batchcount)) {
  29.         l3->shared->touched = 1;
  30.         goto alloc_done;
  31.     }
  33.     while (batchcount > 0) {
  34.         struct list_head *entry;
  35.         struct slab *slabp;
  37.         entry = l3->slabs_partial.next;
  38.         if (entry == &l3->slabs_partial) {
  39.             l3->free_touched = 1;
  40.             entry = l3->slabs_free.next;
  41.             if (entry == &l3->slabs_free)
  42.                 goto must_grow;
  43.         }
  45.         // 初始化阶段，刚申请完page，slab均在free链表上面
  46.         slabp = list_entry(entry, struct slab, list);
  48.         // 检查
  49.         check_slabp(cachep, slabp);
  50.         check_spinlock_acquired(cachep);
  52.         // 必须保证有一个可用对象
  53.         BUG_ON(slabp->inuse >= cachep->num);
  55.         while (slabp->inuse < cachep->num && batchcount--) {
  56.             // 填充一个obj到ac
  57.             ac->entry[ac->avail++] = slab_get_obj(cachep, slabp,
  58.                                 node);
  59.         }
  60.         check_slabp(cachep, slabp);
  62.         // 移动链表
  63.         list_del(&slabp->list);
  64.         if (slabp->free == BUFCTL_END)
  65.             list_add(&slabp->list, &l3->slabs_full);
  66.         else
  67.             list_add(&slabp->list, &l3->slabs_partial);
  68.     }
  70. must_grow:
  71.     // obj转移到ac，则相应的free_objects要减少
  72.     l3->free_objects -= ac->avail;
  73. alloc_done:
  74.     spin_unlock(&l3->list_lock);
  75.     if (unlikely(!ac->avail)) {
  76.         int x;
  77.         x = cache_grow(cachep, flags | GFP_THISNODE, node, NULL);
  78.         ac = cpu_cache_get(cachep);
  79.         if (!x && ac->avail == 0)
  80.             return NULL;
  81.         if (!ac->avail)
  82.             goto retry;
  83.     }
  84.     ac->touched = 1;
  85.     return ac->entry[--ac->avail];
  86. }

2、cache_grow

  1. static int cache_grow(struct kmem_cache *cachep, gfp_t flags, int nodeid, void *objp)
  2. {
  3.     struct slab *slabp;
  4.     size_t offset;
  5.     gfp_t local_flags;
  6.     struct kmem_list3 *l3;
  8.     /*
  9.      * Be lazy and only check for valid flags here,  keeping it out of the
  10.      * critical path in kmem_cache_alloc().
  11.      */
  12.     BUG_ON(flags & GFP_SLAB_BUG_MASK);
  13.     local_flags = flags & (GFP_CONSTRAINT_MASK|GFP_RECLAIM_MASK);
  15.     /* Take the l3 list lock to change the colour_next on this node */
  16.     check_irq_off();
  17.     l3 = cachep->nodelists[nodeid];
  18.     spin_lock(&l3->list_lock);
  20.     /* Get colour for the slab, and cal the next value. */
  21.     offset = l3->colour_next;
  22.     l3->colour_next++;
  23.     if (l3->colour_next >= cachep->colour)
  24.         l3->colour_next = 0;
  25.     spin_unlock(&l3->list_lock);
  27.     offset *= cachep->colour_off;
  29.     if (local_flags & __GFP_WAIT)
  30.         local_irq_enable();
  32.     /*
  33.      * The test for missing atomic flag is performed here, rather than
  34.      * the more obvious place, simply to reduce the critical path length
  35.      * in kmem_cache_alloc(). If a caller is seriously mis-behaving they
  36.      * will eventually be caught here (where it matters).
  37.      */
  38.     kmem_flagcheck(cachep, flags);
  40.     if (!objp)
  41.         objp = kmem_getpages(cachep, local_flags, nodeid);
  42.     if (!objp)
  43.         goto failed;
  45.     slabp = alloc_slabmgmt(cachep, objp, offset,
  46.             local_flags & ~GFP_CONSTRAINT_MASK, nodeid);
  47.     if (!slabp)
  48.         goto opps1;
  50.     slab_map_pages(cachep, slabp, objp);
  52.     cache_init_objs(cachep, slabp);
  54.     if (local_flags & __GFP_WAIT)
  55.         local_irq_disable();
  56.     check_irq_off();
  57.     spin_lock(&l3->list_lock);
  59.     list_add_tail(&slabp->list, &(l3->slabs_free));
  60.     l3->free_objects += cachep->num;
  61.     spin_unlock(&l3->list_lock);
  62.     return 1;
  63. opps1:
  64.     kmem_freepages(cachep, objp);
  65. failed:
  66.     if (local_flags & __GFP_WAIT)
  67.         local_irq_disable();
  68.     return 0;
  69. }