kmalloc详解与分配大小的限制

最新推荐文章于 2025-10-11 20:16:46 发布

转载最新推荐文章于 2025-10-11 20:16:46 发布 · 4.5k 阅读

linux kernel 同时被 2 个专栏收录

11 篇文章

订阅专栏

2 篇文章

订阅专栏

本文深入探讨了Linux内核中的kmalloc函数，详细解析了其通过cache分配内存的机制，包括kmalloc_sizes.h文件中定义的内存大小范围，以及__find_general_cachep函数如何确定合适的cache。

kmalloc是通过cache来实现的, 只不过每次kmalloc的大小不同, 因此是从不同的cache中分配:

/* include/linux/slab.h */
// 注意kmalloc是在头文件中定义的
static inline void *kmalloc(size_t size, gfp_t flags)
{
 if (__builtin_constant_p(size)) {
/*__builtin_constant_p 用于判断一个值是否为编译时常数，如果参数size的值是常数，函数返
* 回 1，否则返回 0。__builtin_constant_p是GCC的内建函数*/
// 以下是找一个对象大小刚好大于等于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。