Linux-3.14.12 Memory Management Note "Kmalloc and Kfree Implementation" "Go"

This article was reproduced from: http://blog.chinaunix.net/uid-26859697-id-5573776.html

Kmalloc () is implemented on the basis of the Slab/slob/slub allocation algorithm, and many places use it as the entrance to the Slab/slob/slub allocation algorithm, which is actually slightly different.

Now analyze the implementation:

2. "File:/include/linux/slab.h"
4. /**
6. * Kmalloc-allocate Memory
8. * @size: How many bytes of memory is required.
10. * @flags: The type of memory to allocate.
12. *
14. * Kmalloc is the normal method of allocating memory
16. * For objects smaller than page size in the kernel.
18. *
20. * The @flags argument May is one of:
22. *
24. *%gfp_user-allocate memory on behalf of USER. May sleep.
26. *
28. *%gfp_kernel-allocate normal KERNEL RAM. May sleep.
30. *
32. *%gfp_atomic-allocation won't sleep. may use emergency pools.
34. * For example, use this inside interrupt handlers.
36. *
38. *%gfp_highuser-allocate pages from high memory.
40. *
42. *%gfp_noio-do not does any I/O at all and trying to get memory.
44. *
46. *%gfp_nofs-do not make no FS calls while trying to get memory.
48. *
50. *%gfp_nowait-allocation won't sleep.
52. *
54. *%__gfp_thisnode-allocate node-local memory only.
56. *
58. *%gfp_dma-allocation suitable for DMA.
60. * Should only is used for kmalloc () caches. Otherwise, use a
62. * Slab created with SLAB_DMA.
64. *
66. * Also It is possible to set different the flags by OR ' ing
68. * In one or more of the following additional @flags:
70. *
72. *%__gfp_cold-request cache-cold pages instead of
74. * Trying to return cache-warm pages.
76. *
78. *%__gfp_high-this allocation have high priority and may use emergency pools.
80. *
82. *%__gfp_nofail-indicate that this allocation are in no-allowed to fail
84. * (think twice before using).
86. *
88. *%__gfp_noretry-if memory is not immediately available,
90. * Then give up at once.
92. *
94. *%__gfp_nowarn-if allocation fails, don ' t issue any warnings.
96. *
98. *%__gfp_repeat-if allocation fails Initially, try once more before failing.
100. *
102. * There is other flags available as well, but these is not intended
104. * For general use, and so is not the documented here. For a full list of
106. * Potential flags, always refer to linux/gfp.h.
108. */
110. static __always_inline void *kmalloc (size_t size, gfp_t flags)
112. {
114. if (__builtin_constant_p (size)) {
116. if (Size > Kmalloc_max_cache_size)
118. Return Kmalloc_large (size, flags);
120. #ifndef Config_slob
122. if (! ( Flags & GFP_DMA)) {
124. int index = kmalloc_index (size);
128. if (!index)
130. return zero_size_ptr;
134. Return Kmem_cache_alloc_trace (Kmalloc_caches[index],
136. flags, size);
138. }
140. #endif
142. }
144. Return __kmalloc (size, flags);
146. }

The parameter size of Kmalloc () indicates the amount of space requested, while flags represents the allocation flag. The Kamlloc has numerous distribution marks, each of which is assigned to identify specific bit bits, which can be combined in a variety of combinations.

Gfp_user: Used to indicate that memory is allocated for user space and may cause hibernation;

Gfp_kernel: The general allocation of kernel memory may cause hibernation;

Gfp_atomic: This assignment does not cause hibernation, but may use emergency memory resources, which are typically used in interrupt processing;

Gfp_highuser: Use high-end memory for allocation;

Gfp_noio: When allocating memory, prohibit any IO operation;

Gfp_nofs: When allocating memory, prohibit any file system operation;

Gfp_nowait: Disables hibernation when allocating memory;

__gfp_thisnode: Allocates memory only from local node memory;

GFP_DMA: Allocate the appropriate memory from DMA memory and should be used only for kmalloc cache allocation;

__gfp_cold: Used to request the allocation of cold pages in hot and cold pages;

__gfp_high: Used to indicate that the allocation has a higher priority and may use emergency memory resources;

__gfp_nofail: Used to indicate that the allocation is not allowed to fail, the flag needs to be used with caution;

__gfp_noretry: If the allocated memory can not be directly obtained, then no longer try to allocate, give up directly;

__gfp_nowarn: If the allocation process fails, do not report any alarms;

__gfp_repeat: If the allocation process fails, try to apply again;

The __builtin_constant_p in the function entry if judgment is the GCC built-in function that determines whether a value is a compile-time constant, or returns true, otherwise false. It also means that if you call Kmalloc () and the value is greater than kmalloc_max_cache_size (that is, the request space exceeds Kmalloc () to allocate the largest CACHE size), then the allocation will be made through Kmalloc_large () Otherwise, they will be allocated through __kmalloc (). If memory allocations are made through Kmalloc_large (), Kmalloc_large ()->kmalloc_order ()->__get_free_pages () will eventually request the required memory through the Buddy partner algorithm.

The partner algorithm has been analyzed before, no longer repeat, next look at the implementation of __kmalloc ():

2. "FILE:/MM/SLUB.C"
4. void *__kmalloc (size_t size, gfp_t flags)
6. {
8. struct Kmem_cache *s;
10. void *ret;
14. if (Unlikely (Size > Kmalloc_max_cache_size))
16. Return Kmalloc_large (size, flags);
20. s = kmalloc_slab (size, flags);
24. if (Unlikely (Zero_or_null_ptr (s)))
26. return s;
30. ret = Slab_alloc (s, flags, _RET_IP_);
34. Trace_kmalloc (_ret_ip_, RET, size, s->size, flags);
38. return ret;
40. }

The function also determines whether the request exceeds the maximum cache size, if it is allocated by Kmalloc_large (), and then calls Kmalloc_slab () through the application size and application flags to find the applicable kmem_cache; finally through Slab_alloc () For slab distribution.

Take a look at the implementation of Kmalloc_slab ():

2. "File:/mm/slab_commmon.c"
4. /*
6. * Find The Kmem_cache structure that serves a given size of
8. * Allocation
10. */
12. struct Kmem_cache *kmalloc_slab (size_t size, gfp_t flags)
14. {
16. int index;
20. if (Unlikely (Size > Kmalloc_max_size)) {
22. Warn_on_once (! ( Flags & __gfp_nowarn));
24. return NULL;
26. }
30. if (size <= 192) {
32. if (!size)
34. return zero_size_ptr;
38. index = Size_index[size_index_elem (size)];
40. } else
42. index = FLS (size-1);
46. #ifdef CONFIG_ZONE_DMA
48. if (Unlikely (Flags & GFP_DMA))
50. return Kmalloc_dma_caches[index];
54. #endif
56. return Kmalloc_caches[index];
58. }

If the size of the request exceeds the Kmalloc_max_size maximum, the return null represents a failure, and if the request size is less than 192 and is not 0, the index value is obtained by Size_index Global array after the Size_index_elem macro is converted to subscript. Otherwise, the index value will be obtained directly through FLS (); Finally, if the DMA memory configuration is turned on and the GFP_DMA flag is set, the Kmem_cache management structure information will be returned by Kmalloc_dma_caches with the index value, otherwise the KMALLOC_ Caches returns the structure.

It can be seen that the kmalloc () implementation is relatively simple, the allocated memory is not only the virtual address of the continuous storage space, but also the physical address of the continuous storage space. This is different from the memory of the Vmalloc () application that will be analyzed later.

In addition to the interface implementation of Kfree (), the function is implemented in many places, mainly in the SLAB.C/SLOB.C/SLUB.C, so also said Kmalloc () and Kfree () is based on slab/slob/slub implementation. Here the previous Slub algorithm, the main analysis of the SLUB.C in the Kfree () implementation:

2. "FILE:/MM/SLUB.C"
4. void Kfree (const void *x)
6. {
8. struct page *page;
10. void *object = (void *) x;
14. Trace_kfree (_ret_ip_, x);
18. if (Unlikely (Zero_or_null_ptr (x)))
20. Return
24. page = Virt_to_head_page (x);
26. if (Unlikely (! Pageslab (page))) {
28. BUG_ON (! Pagecompound (page));
30. Kfree_hook (x);
32. __free_memcg_kmem_pages (page, Compound_order (page));
34. Return
36. }
38. Slab_free (Page->slab_cache, page, object, _RET_IP_);
40. }

The function is simple, first of all through the Trace_kfree () record kfree trajectory, then if (Unlikely (Zero_or_null_ptr (x)) to the address does not 0 judgment, and then Virt_to_head_page (x) Convert the virtual address to a page, and then judge if (The unlikely (! Pageslab (page))) determines whether the page is managed as a slab assignment and, if it is, is released through Slab_free (), otherwise it will enter the if branch, and in the If branch, the Kfree_hook () Do the kmemleak before releasing (the function is to encapsulate the Kmemleak_free ()), and after that it will __free_memcg_kmem_pages () release the page, and the function will also cgroup release processing.

Kmalloc () and Kfree () are so simple.

Linux-3.14.12 Memory Management Note "Kmalloc and Kfree Implementation" "Go"