Linux PERCPU:分配失败，大小=256对齐=256，分配新块失败

PERCPU:分配失败，大小=256对齐=256，分配新块失败

每个CPU分配的空间量是否有限

我可以在Linux内核模块编程中使用多少percpu空间

---

现在我正在尝试创建尽可能多的

workqueue\u struct

。我的内核是3.10

我的结果是：我可以创建大约100000个

workqueue_struct

s，然后在使用

dmesg

命令时找到错误信息（与标题中相同）

我的代码：

#包括
#包括
#包括
#include//kthread\u create是错误的
#包含//kfree
#包括//时间表
#包括
#包括
#包括
u64i=0；
静态列表头（myworkqueuehead）；
静态结构任务_struct*任务；
结构MyworkqueueType{
结构列表\头条目；
struct workqueue_struct*wq；
u64编号；
};
void myfree（void）
{
结构MyworkqueueType*tempwqtype，*n；
列出每个条目的条目（tempwqtype，n和myworkqueuehead，条目）
{
if（tempwqtype）
{
if（tempwqtype->wq）{
//printk（“myfree（）：number=%lld\n”，tempwqtype->number）；
//printk（“list_del（）\n”）；
列表删除（&（tempwqtype->entry））；
//printk（“销毁工作队列（）\n”）；
销毁工作队列（tempwqtype->wq）；
//printk（“自由tempwqtypetype:kfree（tempwqtype）\n”）；
kfree（tempwqtype）；
//printk（“在自由tempwqtypetype\n之后”）；
}否则{
printk（“tempwqtype->wq为空\n”）；
}
}否则{
printk（“tempwqtype为空\n”）；
}
}
printk（“已释放所有工作队列空间…\n”）；
}
静态整数测试（无效*数据）
{
printk（“kthread create_wq start to run test（）…\n”）；
而(1)
{
结构MyworkqueueType*myworkqueue；
if（kthread_should_stop（））
{
printk（“create_wq kthread begin to do myfree（）…\n”）；
myfree（）；
printk（“创建线程停止…\n”）；
返回0；
}
myworkqueue=kzalloc（sizeof（*myworkqueue），GFP_内核）；
if（myworkqueue）{
struct workqueue_struct*wq=alloc_workqueue（“myworkqueue”，0,0）；
//struct workqueue_struct*wq=create_workqueue（“myworkqueue”）；
如果（！wq）
{
结构MyworkqueueType*mytype；
kfree（myworkqueue）；
printk（“\n创建工作队列失败…\n”）；
mytype=列表\条目（myworkqueuehead.prev，结构MyworkqueueType，条目）；
printk（“当前工作队列号=%lld.start to sleep…\n”，mytype->number）；
msleep（5000）；
附表（）；
继续；
}
++一,；
myworkqueue->number=i；
myworkqueue->wq=wq；
初始化列表头（&myworkqueue->entry）；
列表\添加\尾部（&myworkqueue->entry，&myworkqueuehead）；
printk（“%lld”，i）；
}
其他的
{
printk（“\nalloc结构MyworkqueueType失败…\n”）；
printk（“当前工作队列数量=%lld”，i）；
kfree（myworkqueue）；
msleep（5000）；
附表（）；
继续；
}
}
}
静态int\uu init maxwqnum\u init（void）
{
printk（“------------maxwqnum-------------------\n”）；
task=kthread_create（test，NULL，“create_wq”）；
如果（是错误（任务））
{
printk（“创建任务\u结构创建\u wq失败…\n”）；
kfree（任务）；
返回0；
}
printk（“创建任务\u结构创建\u wq成功…\n”）；
唤醒过程（任务）；
返回0；
}
静态void\u退出maxwqnum\u清理（void）
{
kthread_stop（任务）；
printk（“------------离开maxwqnum-----------------\n”）；
}
模块_init（maxwqnum_init）；
模块退出（maxwqnum_清理）；
模块许可证（“GPL”）；
模块作者（“mjq”）；
模块描述（“只是一个测试！”）；
模块支持的设备（“工作队列”）；

每cpu池中模块可用的最大块取决于Linux内核中已加载的其他模块的当前使用情况

PERCPU: Embedded 13 pages/cpu @f77d1000 s31616 r0 d21632 u53248  

percpu池的大小取决于内核配置中是否定义了以下配置

• 配置每个CPU区域都有设置

• 配置\u SMP

启动时每个cpu池的典型初始大小为

如果定义了特定于体系结构的

setup\u per\u cpu\u area（）。在Linux内核引导期间，为percpu池保留的确切内存量将记录到控制台。例如，我的Intel Core 2 Duo P8700机器上的Linux内核3.2记录了以下内容：

PERCPU: Embedded 13 pages/cpu @f77d1000 s31616 r0 d21632 u53248

percpu池为13页，即每个cpu 52KB，总计104KB。其他数字分别是池的
基址
，
静态大小
，
保留大小
，
动态大小
和
单位大小


更新：

编译Linux内核模块（根据上述问题中的代码）并
insmod
ing它会导致以下错误：

[867955.300798] create workqueue fail...
[867955.300804] current workqueue number=198634.start to sleep...
[867960.315934] PERCPU: allocation failed, size=92 align=256, failed to allocate new chunk
[867960.315948] Pid: 26103, comm: create_wq Tainted: G           O 3.2.0-51-generic #77-Ubuntu
[867960.315955] Call Trace:
[867960.315973]  [<c1563ac4>] ? printk+0x2d/0x2f
[867960.315986]  [<c110335e>] pcpu_alloc+0x30e/0x340
[867960.315995]  [<c110339f>] __alloc_percpu+0xf/0x20
[867960.316032]  [<c10641b0>] __alloc_workqueue_key+0xd0/0x430
[867960.316047]  [<c1122f75>] ? kmem_cache_alloc_trace+0x105/0x140
[867960.316065]  [<f93e50e6>] test+0x56/0x194 [kmod]
[867960.316078]  [<f93e5090>] ? myfree+0x90/0x90 [kmod]
[867960.316091]  [<c1069ddd>] kthread+0x6d/0x80
[867960.316104]  [<c1069d70>] ? flush_kthread_worker+0x80/0x80
[867960.316118]  [<c158033e>] kernel_thread_helper+0x6/0x10

这就是日志所描述的

静态31616+动态21632=总计53248，即52KB（13页，每页4KB）

随着越来越多的每cpu分配使用
pcpu\u alloc（）
，动态池的大小不断增加。它可以是非连续的，甚至在内存中是稀疏的。但是，只要满足要求的对齐和尺寸要求，这将继续成功。这是因为分配是使用
kmalloc（）/vmalloc（）
进行的

最终，其中一个调用失败，因为满足请求的大小/对齐方式的内存孔不可用。差不多就是这样。正如人们无法预测一个电话是否会成功一样，也很难准确地确定