内存管理[5]

•     一个新的高速缓存是通过kmem_chache_create()函数进行创建的：

 

1. 在<Slab.c(mm)>中
2. /**
3.  * kmem_cache_create - Create a cache.
4.  * @name: A string which is used in /proc/slabinfo to identify this cache.
5.  * @size: The size of objects to be created in this cache.
6.  * @align: The required alignment for the objects.
7.  * @flags: SLAB flags
8.  * @ctor: A constructor for the objects.
9.  * @dtor: A destructor for the objects.
10.  *
11.  * Returns a ptr to the cache on success, NULL on failure.
12.  * Cannot be called within a int, but can be interrupted.
13.  * The @ctor is run when new pages are allocated by the cache
14.  * and the @dtor is run before the pages are handed back.
15.  *
16.  * @name must be valid until the cache is destroyed. This implies that
17.  * the module calling this has to destroy the cache before getting unloaded.
18.  *
19.  * The flags are
20.  *
21.  * %SLAB_POISON - Poison the slab with a known test pattern (a5a5a5a5)
22.  * to catch references to uninitialised memory.
23.  *
24.  * %SLAB_RED_ZONE - Insert `Red' zones around the allocated memory to check
25.  * for buffer overruns.
26.  *
27.  * %SLAB_HWCACHE_ALIGN - Align the objects in this cache to a hardware
28.  * cacheline.  This can be beneficial if you're counting cycles as closely
29.  * as davem.
30.  */
31. struct kmem_cache *
32. kmem_cache_create (const char *name, size_t size, size_t align,
33.     unsigned long flags,
34.     void (*ctor)(void*, struct kmem_cache *, unsigned long),
35.     void (*dtor)(void*, struct kmem_cache *, unsigned long))
36. {
37.     size_t left_over, slab_size, ralign;
38.     struct kmem_cache *cachep = NULL, *pc;
40.     /*
41.      * Sanity checks... these are all serious usage bugs.
42.      */
43.     if (!name || in_interrupt() || (size < BYTES_PER_WORD) ||
44.         (size > (1 << MAX_OBJ_ORDER) * PAGE_SIZE) || (dtor && !ctor)) {
45.         printk(KERN_ERR "%s: Early error in slab %s/n", __FUNCTION__,
46.                 name);
47.         BUG();
48.     }
50.     /*
51.      * We use cache_chain_mutex to ensure a consistent view of
52.      * cpu_online_map as well.  Please see cpuup_callback
53.      */
54.     mutex_lock(&cache_chain_mutex);
56.     list_for_each_entry(pc, &cache_chain, next) {
57.         char tmp;
58.         int res;
60.         /*
61.          * This happens when the module gets unloaded and doesn't
62.          * destroy its slab cache and no-one else reuses the vmalloc
63.          * area of the module.  Print a warning.
64.          */
65.         res = probe_kernel_address(pc->name, tmp);
66.         if (res) {
67.             printk("SLAB: cache with size %d has lost its name/n",
68.                    pc->buffer_size);
69.             continue;
70.         }
72.         if (!strcmp(pc->name, name)) {
73.             printk("kmem_cache_create: duplicate cache %s/n", name);
74.             dump_stack();
75.             goto oops;
76.         }
77.     }
79. #if DEBUG
80.     WARN_ON(strchr(name, ' ')); /* It confuses parsers */
81.     if ((flags & SLAB_DEBUG_INITIAL) && !ctor) {
82.         /* No constructor, but inital state check requested */
83.         printk(KERN_ERR "%s: No con, but init state check "
84.                "requested - %s/n", __FUNCTION__, name);
85.         flags &= ~SLAB_DEBUG_INITIAL;
86.     }
87. #if FORCED_DEBUG
88.     /*
89.      * Enable redzoning and last user accounting, except for caches with
90.      * large objects, if the increased size would increase the object size
91.      * above the next power of two: caches with object sizes just above a
92.      * power of two have a significant amount of internal fragmentation.
93.      */
94.     if (size < 4096 || fls(size - 1) == fls(size-1 + 3 * BYTES_PER_WORD))
95.         flags |= SLAB_RED_ZONE | SLAB_STORE_USER;
96.     if (!(flags & SLAB_DESTROY_BY_RCU))
97.         flags |= SLAB_POISON;
98. #endif
99.     if (flags & SLAB_DESTROY_BY_RCU)
100.         BUG_ON(flags & SLAB_POISON);
101. #endif
102.     if (flags & SLAB_DESTROY_BY_RCU)
103.         BUG_ON(dtor);
105.     /*
106.      * Always checks flags, a caller might be expecting debug support which
107.      * isn't available.
108.      */
109.     BUG_ON(flags & ~CREATE_MASK);
111.     /*
112.      * Check that size is in terms of words.  This is needed to avoid
113.      * unaligned accesses for some archs when redzoning is used, and makes
114.      * sure any on-slab bufctl's are also correctly aligned.
115.      */
116.     if (size & (BYTES_PER_WORD - 1)) {
117.         size += (BYTES_PER_WORD - 1);
118.         size &= ~(BYTES_PER_WORD - 1);
119.     }
121.     /* calculate the final buffer alignment: */
123.     /* 1) arch recommendation: can be overridden for debug */
124.     if (flags & SLAB_HWCACHE_ALIGN) {
125.         /*
126.          * Default alignment: as specified by the arch code.  Except if
127.          * an object is really small, then squeeze multiple objects into
128.          * one cacheline.
129.          */
130.         ralign = cache_line_size();
131.         while (size <= ralign / 2)
132.             ralign /= 2;
133.     } else {
134.         ralign = BYTES_PER_WORD;
135.     }
137.     /*
138.      * Redzoning and user store require word alignment. Note this will be
139.      * overridden by architecture or caller mandated alignment if either
140.      * is greater than BYTES_PER_WORD.
141.      */
142.     if (flags & SLAB_RED_ZONE || flags & SLAB_STORE_USER)
143.         ralign = BYTES_PER_WORD;
145.     /* 2) arch mandated alignment */
146.     if (ralign < ARCH_SLAB_MINALIGN) {
147.         ralign = ARCH_SLAB_MINALIGN;
148.     }
149.     /* 3) caller mandated alignment */
150.     if (ralign < align) {
151.         ralign = align;
152.     }
153.     /* disable debug if necessary */
154.     if (ralign > BYTES_PER_WORD)
155.         flags &= ~(SLAB_RED_ZONE | SLAB_STORE_USER);
156.     /*
157.      * 4) Store it.
158.      */
159.     align = ralign;
161.     /* Get cache's description obj. */
162.     cachep = kmem_cache_zalloc(&cache_cache, GFP_KERNEL);
163.     if (!cachep)
164.         goto oops;
166. #if DEBUG
167.     cachep->obj_size = size;
169.     /*
170.      * Both debugging options require word-alignment which is calculated
171.      * into align above.
172.      */
173.     if (flags & SLAB_RED_ZONE) {
174.         /* add space for red zone words */
175.         cachep->obj_offset += BYTES_PER_WORD;
176.         size += 2 * BYTES_PER_WORD;
177.     }
178.     if (flags & SLAB_STORE_USER) {
179.         /* user store requires one word storage behind the end of
180.          * the real object.
181.          */
182.         size += BYTES_PER_WORD;
183.     }
184. #if FORCED_DEBUG && defined(CONFIG_DEBUG_PAGEALLOC)
185.     if (size >= malloc_sizes[INDEX_L3 + 1].cs_size
186.         && cachep->obj_size > cache_line_size() && size < PAGE_SIZE) {
187.         cachep->obj_offset += PAGE_SIZE - size;
188.         size = PAGE_SIZE;
189.     }
190. #endif
191. #endif
193.     /*
194.      * Determine if the slab management is 'on' or 'off' slab.
195.      * (bootstrapping cannot cope with offslab caches so don't do
196.      * it too early on.)
197.      */
198.     if ((size >= (PAGE_SIZE >> 3)) && !slab_early_init)
199.         /*
200.          * Size is large, assume best to place the slab management obj
201.          * off-slab (should allow better packing of objs).
202.          */
203.         flags |= CFLGS_OFF_SLAB;
205.     size = ALIGN(size, align);
207.     left_over = calculate_slab_order(cachep, size, align, flags);
209.     if (!cachep->num) {
210.         printk("kmem_cache_create: couldn't create cache %s./n", name);
211.         kmem_cache_free(&cache_cache, cachep);
212.         cachep = NULL;
213.         goto oops;
214.     }
215.     slab_size = ALIGN(cachep->num * sizeof(kmem_bufctl_t)
216.               + sizeof(struct slab), align);
218.     /*
219.      * If the slab has been placed off-slab, and we have enough space then
220.      * move it on-slab. This is at the expense of any extra colouring.
221.      */
222.     if (flags & CFLGS_OFF_SLAB && left_over >= slab_size) {
223.         flags &= ~CFLGS_OFF_SLAB;
224.         left_over -= slab_size;
225.     }
227.     if (flags & CFLGS_OFF_SLAB) {
228.         /* really off slab. No need for manual alignment */
229.         slab_size =
230.             cachep->num * sizeof(kmem_bufctl_t) + sizeof(struct slab);
231.     }
233.     cachep->colour_off = cache_line_size();
234.     /* Offset must be a multiple of the alignment. */
235.     if (cachep->colour_off < align)
236.         cachep->colour_off = align;
237.     cachep->colour = left_over / cachep->colour_off;
238.     cachep->slab_size = slab_size;
239.     cachep->flags = flags;
240.     cachep->gfpflags = 0;
241.     if (CONFIG_ZONE_DMA_FLAG && (flags & SLAB_CACHE_DMA))
242.         cachep->gfpflags |= GFP_DMA;
243.     cachep->buffer_size = size;
244.     cachep->reciprocal_buffer_size = reciprocal_value(size);
246.     if (flags & CFLGS_OFF_SLAB) {
247.         cachep->slabp_cache = kmem_find_general_cachep(slab_size, 0u);
248.         /*
249.          * This is a possibility for one of the malloc_sizes caches.
250.          * But since we go off slab only for object size greater than
251.          * PAGE_SIZE/8, and malloc_sizes gets created in ascending order,
252.          * this should not happen at all.
253.          * But leave a BUG_ON for some lucky dude.
254.          */
255.         BUG_ON(!cachep->slabp_cache);
256.     }
257.     cachep->ctor = ctor;
258.     cachep->dtor = dtor;
259.     cachep->name = name;
261.     if (setup_cpu_cache(cachep)) {
262.         __kmem_cache_destroy(cachep);
263.         cachep = NULL;
264.         goto oops;
265.     }
267.     /* cache setup completed, link it into the list */
268.     list_add(&cachep->next, &cache_chain);
269. oops:
270.     if (!cachep && (flags & SLAB_PANIC))
271.         panic("kmem_cache_create(): failed to create slab `%s'/n",
272.               name);
273.     mutex_unlock(&cache_chain_mutex);
274.     return cachep;
275. }

   这个函数不能在中断上下文中调用，因为它可能会睡眠。

•    要销毁一个高速缓存可以使用kmem_cache_destroy()函数：

 

2. /**
3.  * kmem_cache_destroy - delete a cache
4.  * @cachep: the cache to destroy
5.  *
6.  * Remove a &struct kmem_cache object from the slab cache.
7.  *
8.  * It is expected this function will be called by a module when it is
9.  * unloaded.  This will remove the cache completely, and avoid a duplicate
10.  * cache being allocated each time a module is loaded and unloaded, if the
11.  * module doesn't have persistent in-kernel storage across loads and unloads.
12.  *
13.  * The cache must be empty before calling this function.
14.  *
15.  * The caller must guarantee that noone will allocate memory from the cache
16.  * during the kmem_cache_destroy().
17.  */
18. void kmem_cache_destroy(struct kmem_cache *cachep)
19. {
20.     BUG_ON(!cachep || in_interrupt());
22.     /* Find the cache in the chain of caches. */
23.     mutex_lock(&cache_chain_mutex);
24.     /*
25.      * the chain is never empty, cache_cache is never destroyed
26.      */
27.     list_del(&cachep->next);
28.     if (__cache_shrink(cachep)) {
29.         slab_error(cachep, "Can't free all objects");
30.         list_add(&cachep->next, &cache_chain);
31.         mutex_unlock(&cache_chain_mutex);
32.         return;
33.     }
35.     if (unlikely(cachep->flags & SLAB_DESTROY_BY_RCU))
36.         synchronize_rcu();
38.     __kmem_cache_destroy(cachep);
39.     mutex_unlock(&cache_chain_mutex);
40. }

  这个函数也不能在中断上下文中调用，因为它可能会睡眠。

  调用kmem_cache_destroy()之前必须确保以下两个条件：

1. 告诉缓存中的所有slab都必须为空。其实，不管哪个slab中只要还有一个对象被分配出去，并正在使用的话，不可能销毁这个高速缓存。

2. 在调用该函数期间，不再访问这个高速缓存。调用者必须确保这种同步。

• 创建高速缓存后，通过kmem_cache_alloc()函数从中获取对象：

 

2. /**
3.  * kmem_cache_alloc - Allocate an object
4.  * @cachep: The cache to allocate from.
5.  * @flags: See kmalloc().
6.  *
7.  * Allocate an object from this cache.  The flags are only relevant
8.  * if the cache has no available objects.
9.  */
10. void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags)
11. {
12.     return __cache_alloc(cachep, flags, __builtin_return_address(0));
13. }

2. static __always_inline void *
3. __cache_alloc(struct kmem_cache *cachep, gfp_t flags, void *caller)
4. {
5.     unsigned long save_flags;
6.     void *objp;
8.     cache_alloc_debugcheck_before(cachep, flags);
9.     local_irq_save(save_flags);
10.     objp = __do_cache_alloc(cachep, flags);
11.     local_irq_restore(save_flags);
12.     objp = cache_alloc_debugcheck_after(cachep, flags, objp, caller);
13.     prefetchw(objp);
15.     return objp;
16. }

如果高速缓存的所有slab中都没有空闲的对象，那么slab层必须通过kmem_getpages()获取新的页。

• 最后，使用kmem_cache_free()函数释放一个对象，并把它返回给原先的slab：

 

2. /**
3.  * kmem_cache_free - Deallocate an object
4.  * @cachep: The cache the allocation was from.
5.  * @objp: The previously allocated object.
6.  *
7.  * Free an object which was previously allocated from this
8.  * cache.
9.  */
10. void kmem_cache_free(struct kmem_cache *cachep, void *objp)
11. {
12.     unsigned long flags;
14.     BUG_ON(virt_to_cache(objp) != cachep);
16.     local_irq_save(flags);
17.     debug_check_no_locks_freed(objp, obj_size(cachep));
18.     __cache_free(cachep, objp);
19.     local_irq_restore(flags);
20. }

2. /*
3.  * Release an obj back to its cache. If the obj has a constructed state, it must
4.  * be in this state _before_ it is released.  Called with disabled ints.
5.  */
6. static inline void __cache_free(struct kmem_cache *cachep, void *objp)
7. {
8.     struct array_cache *ac = cpu_cache_get(cachep);
10.     check_irq_off();
11.     objp = cache_free_debugcheck(cachep, objp, __builtin_return_address(0));
13.     if (cache_free_alien(cachep, objp))
14.         return;
16.     if (likely(ac->avail < ac->limit)) {
17.         STATS_INC_FREEHIT(cachep);
18.         ac->entry[ac->avail++] = objp;
19.         return;
20.     } else {
21.         STATS_INC_FREEMISS(cachep);
22.         cache_flusharray(cachep, ac);
23.         ac->entry[ac->avail++] = objp;
24.     }
25. }