kmalloc是通过cache来实现的, 只不过每次kmalloc的大小不同, 因此是从不同的cache中分配:
/* include/linux/slab.h */
// 注意kmalloc是在头文件中定义的
static inline void *kmalloc(size_t size, gfp_t flags)
{
if (__builtin_constant_p(size)) {
// 以下是找一个对象大小刚好大于等于size的cache
int i = 0;
#define CACHE(x) \
if (size <= x) \
goto found; \
else \
i++;
#include "kmalloc_sizes.h"
#undef CACHE
{
extern void __you_cannot_kmalloc_that_much(void);
__you_cannot_kmalloc_that_much();
}
found:
// 实际还是通过kmem_cache_alloc来分配内存空间, 因此也是cache
return kmem_cache_alloc((flags & GFP_DMA) ?
malloc_sizes[i].cs_dmacachep :
malloc_sizes[i].cs_cachep, flags);
}
// 通过该函数最后也是由__cache_alloc()函数来分配空间
return __kmalloc(size, flags);
}
// 这是kmalloc_sizes.h文件内容, 实际就是定义CACHE中可用的对象大小
// 普通情况下最大是128K, 也就是kmalloc能分配的最大内存量
#if (PAGE_SIZE == 4096)
CACHE(32)
#endif
CACHE(64)
#if L1_CACHE_BYTES < 64
CACHE(96)
#endif
CACHE(128)
#if L1_CACHE_BYTES < 128
CACHE(192)
#endif
CACHE(256)
CACHE(512)
CACHE(1024)
CACHE(2048)
CACHE(4096)
CACHE(8192)
CACHE(16384)
CACHE(32768)
CACHE(65536)
CACHE(131072)
#if (NR_CPUS > 512) || (MAX_NUMNODES > 256) || !defined(CONFIG_MMU)
CACHE(262144)
#endif
#ifndef CONFIG_MMU
CACHE(524288)
CACHE(1048576)
#ifdef CONFIG_LARGE_ALLOCS
CACHE(2097152)
CACHE(4194304)
CACHE(8388608)
CACHE(16777216)
CACHE(33554432)
#endif /* CONFIG_LARGE_ALLOCS */
#endif /* CONFIG_MMU
继续调用
void *__kmalloc(size_t size, gfp_t flags)
{
return __do_kmalloc(size, flags, NULL);
}
static __always_inline void *__do_kmalloc(size_t size, gfp_t flags,
void *caller)
{
struct kmem_cache *cachep;
/* If you want to save a few bytes .text space: replace
* __ with kmem_.
* Then kmalloc uses the uninlined functions instead of the inline
* functions.
*/
cachep = __find_general_cachep(size, flags);
if (unlikely(cachep == NULL))
return NULL;
return __cache_alloc(cachep, flags, caller);
}
static inline struct kmem_cache *__find_general_cachep(size_t size, gfp_t gfpflags)
{
struct cache_sizes *csizep = malloc_sizes;
#if DEBUG
/* This happens if someone tries to call
* kmem_cache_create(), or __kmalloc(), before
* the generic caches are initialized.
*/
BUG_ON(malloc_sizes[INDEX_AC].cs_cachep == NULL);
#endif
while (size > csizep->cs_size)
csizep++;
/*
* Really subtle: The last entry with cs->cs_size==ULONG_MAX
* has cs_{dma,}cachep==NULL. Thus no special case
* for large kmalloc calls required.
*/
if (unlikely(gfpflags & GFP_DMA))
return csizep->cs_dmacachep;
return csizep->cs_cachep;
}
__find_general_cachep确定可以分配的空间大小由malloc_sizes结构体数组指定，在阅读mm/slab.c中它的定义如下
struct cache_sizes malloc_sizes[] = {
#define CACHE(x) { .cs_size = (x) },
#include
CACHE(ULONG_MAX)
#undef CACHE
};
在对一个结构体进行赋值的时候，第一次看到了这个用法，赶紧来仔细看看代码。
首先在slab_def.h中找到cache_sizes的定义如下：
struct cache_sizes {
size_t cs_size;
struct kmem_cache *cs_cachep;
#ifdef CONFIG_ZONE_DMA
struct kmem_cache *cs_dmacachep;
#endif
};
可以看出，无论cache_sizes的如何变，至少都要给cs_size分配一个值。函数一就是对malloc_sizes这个数组进行初始化。在初始化的时候却多了3行代码：
代码一:#define CACHE(x) { .cs_size = (x) },
作用：定义一个CACHE(x)的宏，作用在include里面。
代码二：#include
作用，引用kmalloc_size.h文件。使malloc_sizes[]得到初始化的值。换个角度看，把函数初始化和依据附加条件分开，使得程序的逻辑更加清晰。在函数中，CACHE仅仅作为一个宏，与具体的实现无关。
代码三：#undef CACHE
作用：撤销代码一中的定义。
综合来讲，实现的功能就是：
#include 把kmalloc_sizes.h文件里面的内容原封不动地复制到数组中， 定义了一个宏CACHE(x)，用完之后取消。
数组展开之后便成：
struct cache_sizes malloc_sizes[] = {
{ .cs_size = (32) },
{ .cs_size = (64) },
{ .cs_size = (96) },
...
{ .cs_size = (ULONG_MAX) }
};
在linux/kmalloc_sizes.h中可以看到，所有的代码做的事，仅仅是针对不同的硬件环境作出不同的反应。除了默认的分配CHACH(x)运算外，针对内存页面、一级缓存大小，和是否支持内存管理模块，是否允许kmalloc分配大于1MB的内存等，分别作出了不同的动作。
在面向对象的编程中，最基本的三个概念为：继承、封装、抽象。继承可以理解为在在当前已经存在的基础上进行革新；封装也就是说将一些内部的东西不给你看，你只需要知道如何操作；抽象的意思就是程序有能力忽略正在处理中信息的某些方面，即对信息主要方面关注的能力。oop对于类的编程一般是这个流程：首先是对当前对象进行初始化，接着针对对象进行一系列的操作，最后对当前对象进行销毁
再回到文首的三个代码运行流程，代码一首先定义一个宏；代码二接收到这个值，并且进行一系列的操作，是内部的，在slab.c中没有描述；代码三，销毁代码一定义的宏。同时，在mm/slab.c和include/linux/slab_def.h中可以多次看到上述三个代码，只是在每个代码的实现中，CACHE(x)定义为不同的宏。
用于kmalloc可分配的内存大小范围在32~131027(128k)字节，并且由于它用slab分配器来分配内存的，所以，得到的内存大小可能比你申请的要大一些（它向上取2的N次幂整数）。而且如果开启了CONFIG_LARGE_ALLOCS选项，这个值可以更大，可以达到了32M。
阅读(2641) | 评论(0) | 转发(0) |
