* [PATCH bpf 0/4] bpf_prog_pack and vmalloc-on-huge-page fixes
@ 2022-04-22 5:18 Song Liu
2022-04-22 5:18 ` [PATCH bpf 1/4] bpf: invalidate unused part of bpf_prog_pack Song Liu
` (4 more replies)
0 siblings, 5 replies; 8+ messages in thread
From: Song Liu @ 2022-04-22 5:18 UTC (permalink / raw)
To: bpf, linux-mm, linux-kernel
Cc: ast, daniel, kernel-team, akpm, rick.p.edgecombe, hch, imbrenda,
mcgrof, Song Liu
NOTE: This set is based on Linus' master branch (d569e86915b7), not
bpf/master.
There are various discussion about these changes, check out [1] [2].
I guess we can use this thread to discuss which patches should go in 5.18.
AFAICT, 1/4 need to with 5.18; 2/4 seems safe to go as well; 3/4 and 4/4
may still need more work/discussion.
Thanks!
[1] https://lore.kernel.org/linux-mm/20220415164413.2727220-1-song@kernel.org/
[2] https://lore.kernel.org/linux-mm/20220421072212.608884-1-song@kernel.org/
Song Liu (4):
bpf: invalidate unused part of bpf_prog_pack
page_alloc: use vmalloc_huge for large system hash
module: introduce module_alloc_huge
bpf: use module_alloc_huge for bpf_prog_pack
arch/x86/kernel/module.c | 21 +++++++++++++++++++++
arch/x86/net/bpf_jit_comp.c | 22 ++++++++++++++++++++++
include/linux/bpf.h | 2 ++
include/linux/moduleloader.h | 5 +++++
kernel/bpf/core.c | 28 +++++++++++++++++++++-------
kernel/module.c | 8 ++++++++
mm/page_alloc.c | 2 +-
7 files changed, 80 insertions(+), 8 deletions(-)
--
2.30.2
^ permalink raw reply [flat|nested] 8+ messages in thread
* [PATCH bpf 1/4] bpf: invalidate unused part of bpf_prog_pack
2022-04-22 5:18 [PATCH bpf 0/4] bpf_prog_pack and vmalloc-on-huge-page fixes Song Liu
@ 2022-04-22 5:18 ` Song Liu
2022-04-22 5:18 ` [PATCH bpf 2/4] page_alloc: use vmalloc_huge for large system hash Song Liu
` (3 subsequent siblings)
4 siblings, 0 replies; 8+ messages in thread
From: Song Liu @ 2022-04-22 5:18 UTC (permalink / raw)
To: bpf, linux-mm, linux-kernel
Cc: ast, daniel, kernel-team, akpm, rick.p.edgecombe, hch, imbrenda,
mcgrof, Song Liu
bpf_prog_pack enables sharing huge pages among multiple BPF programs.
These pages are marked as executable, but some part of these huge page
may not contain proper BPF programs. To make these pages safe, fill such
unused part of these pages with invalid instructions. This is done when a
pack is first allocated, and when a bpf program is freed..
Fixes: 57631054fae6 ("bpf: Introduce bpf_prog_pack allocator")
Fixes: 33c9805860e5 ("bpf: Introduce bpf_jit_binary_pack_[alloc|finalize|free]")
Signed-off-by: Song Liu <song@kernel.org>
---
arch/x86/net/bpf_jit_comp.c | 22 ++++++++++++++++++++++
include/linux/bpf.h | 2 ++
kernel/bpf/core.c | 21 +++++++++++++++++----
3 files changed, 41 insertions(+), 4 deletions(-)
diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c
index 16b6efacf7c6..ff3f0811c9a1 100644
--- a/arch/x86/net/bpf_jit_comp.c
+++ b/arch/x86/net/bpf_jit_comp.c
@@ -228,6 +228,28 @@ static void jit_fill_hole(void *area, unsigned int size)
memset(area, 0xcc, size);
}
+#define INVALID_BUF_SIZE PAGE_SIZE
+static char invalid_insn_buf[INVALID_BUF_SIZE];
+
+static int __init bpf_init_invalid_insn_buf(void)
+{
+ jit_fill_hole(invalid_insn_buf, INVALID_BUF_SIZE);
+ return 0;
+}
+pure_initcall(bpf_init_invalid_insn_buf);
+
+void bpf_arch_invalidate_text(void *dst, size_t len)
+{
+ size_t i = 0;
+
+ while (i < len) {
+ size_t s = min_t(size_t, len - i, INVALID_BUF_SIZE);
+
+ bpf_arch_text_copy(dst + i, invalid_insn_buf, s);
+ i += s;
+ }
+}
+
struct jit_context {
int cleanup_addr; /* Epilogue code offset */
diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index bdb5298735ce..2157392a94d1 100644
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -2382,6 +2382,8 @@ int bpf_arch_text_poke(void *ip, enum bpf_text_poke_type t,
void *bpf_arch_text_copy(void *dst, void *src, size_t len);
+void bpf_arch_invalidate_text(void *dst, size_t len);
+
struct btf_id_set;
bool btf_id_set_contains(const struct btf_id_set *set, u32 id);
diff --git a/kernel/bpf/core.c b/kernel/bpf/core.c
index 13e9dbeeedf3..2be2d73fb6a8 100644
--- a/kernel/bpf/core.c
+++ b/kernel/bpf/core.c
@@ -873,7 +873,7 @@ static size_t select_bpf_prog_pack_size(void)
return size;
}
-static struct bpf_prog_pack *alloc_new_pack(void)
+static struct bpf_prog_pack *alloc_new_pack(bpf_jit_fill_hole_t bpf_fill_ill_insns)
{
struct bpf_prog_pack *pack;
@@ -886,6 +886,7 @@ static struct bpf_prog_pack *alloc_new_pack(void)
kfree(pack);
return NULL;
}
+ bpf_fill_ill_insns(pack->ptr, bpf_prog_pack_size);
bitmap_zero(pack->bitmap, bpf_prog_pack_size / BPF_PROG_CHUNK_SIZE);
list_add_tail(&pack->list, &pack_list);
@@ -895,7 +896,7 @@ static struct bpf_prog_pack *alloc_new_pack(void)
return pack;
}
-static void *bpf_prog_pack_alloc(u32 size)
+static void *bpf_prog_pack_alloc(u32 size, bpf_jit_fill_hole_t bpf_fill_ill_insns)
{
unsigned int nbits = BPF_PROG_SIZE_TO_NBITS(size);
struct bpf_prog_pack *pack;
@@ -910,6 +911,7 @@ static void *bpf_prog_pack_alloc(u32 size)
size = round_up(size, PAGE_SIZE);
ptr = module_alloc(size);
if (ptr) {
+ bpf_fill_ill_insns(ptr, size);
set_vm_flush_reset_perms(ptr);
set_memory_ro((unsigned long)ptr, size / PAGE_SIZE);
set_memory_x((unsigned long)ptr, size / PAGE_SIZE);
@@ -923,7 +925,7 @@ static void *bpf_prog_pack_alloc(u32 size)
goto found_free_area;
}
- pack = alloc_new_pack();
+ pack = alloc_new_pack(bpf_fill_ill_insns);
if (!pack)
goto out;
@@ -966,6 +968,7 @@ static void bpf_prog_pack_free(struct bpf_binary_header *hdr)
nbits = BPF_PROG_SIZE_TO_NBITS(hdr->size);
pos = ((unsigned long)hdr - (unsigned long)pack_ptr) >> BPF_PROG_CHUNK_SHIFT;
+ bpf_arch_invalidate_text(hdr, hdr->size);
bitmap_clear(pack->bitmap, pos, nbits);
if (bitmap_find_next_zero_area(pack->bitmap, bpf_prog_chunk_count(), 0,
bpf_prog_chunk_count(), 0) == 0) {
@@ -1102,7 +1105,7 @@ bpf_jit_binary_pack_alloc(unsigned int proglen, u8 **image_ptr,
if (bpf_jit_charge_modmem(size))
return NULL;
- ro_header = bpf_prog_pack_alloc(size);
+ ro_header = bpf_prog_pack_alloc(size, bpf_fill_ill_insns);
if (!ro_header) {
bpf_jit_uncharge_modmem(size);
return NULL;
@@ -1203,6 +1206,16 @@ void __weak bpf_jit_free(struct bpf_prog *fp)
bpf_prog_unlock_free(fp);
}
+void __weak bpf_arch_invalidate_text(void *dst, size_t len)
+{
+ char buf[1] = {};
+ int i;
+
+ WARN_ONCE(1, "Please override %s for bpf_prog_pack\n", __func__);
+ for (i = 0; i < len; i++)
+ bpf_arch_text_copy(dst + i, buf, 1);
+}
+
int bpf_jit_get_func_addr(const struct bpf_prog *prog,
const struct bpf_insn *insn, bool extra_pass,
u64 *func_addr, bool *func_addr_fixed)
--
2.30.2
^ permalink raw reply related [flat|nested] 8+ messages in thread
* [PATCH bpf 2/4] page_alloc: use vmalloc_huge for large system hash
2022-04-22 5:18 [PATCH bpf 0/4] bpf_prog_pack and vmalloc-on-huge-page fixes Song Liu
2022-04-22 5:18 ` [PATCH bpf 1/4] bpf: invalidate unused part of bpf_prog_pack Song Liu
@ 2022-04-22 5:18 ` Song Liu
2022-04-22 9:06 ` kernel test robot
2022-04-22 5:18 ` [PATCH bpf 3/4] module: introduce module_alloc_huge Song Liu
` (2 subsequent siblings)
4 siblings, 1 reply; 8+ messages in thread
From: Song Liu @ 2022-04-22 5:18 UTC (permalink / raw)
To: bpf, linux-mm, linux-kernel
Cc: ast, daniel, kernel-team, akpm, rick.p.edgecombe, hch, imbrenda,
mcgrof, Song Liu, Christoph Hellwig
Use vmalloc_huge() in alloc_large_system_hash() so that large system hash
(>= PMD_SIZE) could benefit from huge pages. Note that vmalloc_huge only
allocates huge pages for systems with HAVE_ARCH_HUGE_VMALLOC.
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Song Liu <song@kernel.org>
---
mm/page_alloc.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 33ca8cab21e6..0e42038382c1 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -8919,7 +8919,7 @@ void *__init alloc_large_system_hash(const char *tablename,
table = memblock_alloc_raw(size,
SMP_CACHE_BYTES);
} else if (get_order(size) >= MAX_ORDER || hashdist) {
- table = __vmalloc(size, gfp_flags);
+ table = vmalloc_huge(size, gfp_flags);
virt = true;
if (table)
huge = is_vm_area_hugepages(table);
--
2.30.2
^ permalink raw reply related [flat|nested] 8+ messages in thread
* [PATCH bpf 3/4] module: introduce module_alloc_huge
2022-04-22 5:18 [PATCH bpf 0/4] bpf_prog_pack and vmalloc-on-huge-page fixes Song Liu
2022-04-22 5:18 ` [PATCH bpf 1/4] bpf: invalidate unused part of bpf_prog_pack Song Liu
2022-04-22 5:18 ` [PATCH bpf 2/4] page_alloc: use vmalloc_huge for large system hash Song Liu
@ 2022-04-22 5:18 ` Song Liu
2022-04-22 9:48 ` kernel test robot
2022-04-22 5:18 ` [PATCH bpf 4/4] bpf: use module_alloc_huge for bpf_prog_pack Song Liu
2022-04-22 14:42 ` [PATCH bpf 0/4] bpf_prog_pack and vmalloc-on-huge-page fixes Luis Chamberlain
4 siblings, 1 reply; 8+ messages in thread
From: Song Liu @ 2022-04-22 5:18 UTC (permalink / raw)
To: bpf, linux-mm, linux-kernel
Cc: ast, daniel, kernel-team, akpm, rick.p.edgecombe, hch, imbrenda,
mcgrof, Song Liu
Introduce module_alloc_huge, which allocates huge page backed memory in
module memory space. The primary user of this memory is bpf_prog_pack
(multiple BPF programs sharing a huge page).
Signed-off-by: Song Liu <song@kernel.org>
---
arch/x86/kernel/module.c | 21 +++++++++++++++++++++
include/linux/moduleloader.h | 5 +++++
kernel/module.c | 8 ++++++++
3 files changed, 34 insertions(+)
diff --git a/arch/x86/kernel/module.c b/arch/x86/kernel/module.c
index b98ffcf4d250..63f6a16c70dc 100644
--- a/arch/x86/kernel/module.c
+++ b/arch/x86/kernel/module.c
@@ -86,6 +86,27 @@ void *module_alloc(unsigned long size)
return p;
}
+void *module_alloc_huge(unsigned long size)
+{
+ gfp_t gfp_mask = GFP_KERNEL;
+ void *p;
+
+ if (PAGE_ALIGN(size) > MODULES_LEN)
+ return NULL;
+
+ p = __vmalloc_node_range(size, MODULE_ALIGN,
+ MODULES_VADDR + get_module_load_offset(),
+ MODULES_END, gfp_mask, PAGE_KERNEL,
+ VM_DEFER_KMEMLEAK | VM_ALLOW_HUGE_VMAP,
+ NUMA_NO_NODE, __builtin_return_address(0));
+ if (p && (kasan_alloc_module_shadow(p, size, gfp_mask) < 0)) {
+ vfree(p);
+ return NULL;
+ }
+
+ return p;
+}
+
#ifdef CONFIG_X86_32
int apply_relocate(Elf32_Shdr *sechdrs,
const char *strtab,
diff --git a/include/linux/moduleloader.h b/include/linux/moduleloader.h
index 9e09d11ffe5b..d34743a88938 100644
--- a/include/linux/moduleloader.h
+++ b/include/linux/moduleloader.h
@@ -26,6 +26,11 @@ unsigned int arch_mod_section_prepend(struct module *mod, unsigned int section);
sections. Returns NULL on failure. */
void *module_alloc(unsigned long size);
+/* Allocator used for allocating memory in module memory space. If size is
+ * greater than PMD_SIZE, allow using huge pages. Returns NULL on failure.
+ */
+void *module_alloc_huge(unsigned long size);
+
/* Free memory returned from module_alloc. */
void module_memfree(void *module_region);
diff --git a/kernel/module.c b/kernel/module.c
index 6cea788fd965..2af20ac3209c 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -2839,6 +2839,14 @@ void * __weak module_alloc(unsigned long size)
NUMA_NO_NODE, __builtin_return_address(0));
}
+void * __weak module_alloc_huge(unsigned long size)
+{
+ return __vmalloc_node_range(size, 1, VMALLOC_START, VMALLOC_END,
+ GFP_KERNEL, PAGE_KERNEL_EXEC,
+ VM_FLUSH_RESET_PERMS | VM_ALLOW_HUGE_VMAP,
+ NUMA_NO_NODE, __builtin_return_address(0));
+}
+
bool __weak module_init_section(const char *name)
{
return strstarts(name, ".init");
--
2.30.2
^ permalink raw reply related [flat|nested] 8+ messages in thread
* [PATCH bpf 4/4] bpf: use module_alloc_huge for bpf_prog_pack
2022-04-22 5:18 [PATCH bpf 0/4] bpf_prog_pack and vmalloc-on-huge-page fixes Song Liu
` (2 preceding siblings ...)
2022-04-22 5:18 ` [PATCH bpf 3/4] module: introduce module_alloc_huge Song Liu
@ 2022-04-22 5:18 ` Song Liu
2022-04-22 14:42 ` [PATCH bpf 0/4] bpf_prog_pack and vmalloc-on-huge-page fixes Luis Chamberlain
4 siblings, 0 replies; 8+ messages in thread
From: Song Liu @ 2022-04-22 5:18 UTC (permalink / raw)
To: bpf, linux-mm, linux-kernel
Cc: ast, daniel, kernel-team, akpm, rick.p.edgecombe, hch, imbrenda,
mcgrof, Song Liu
Use module_alloc_huge for bpf_prog_pack so that BPF programs sit on
PMD_SIZE pages. This benefits system performance by reducing iTLB miss
rate.
Also, remove set_vm_flush_reset_perms() from alloc_new_pack() and use
set_memory_[nx|rw] in bpf_prog_pack_free(). This is because
VM_FLUSH_RESET_PERMS does not work with huge pages yet.
Signed-off-by: Song Liu <song@kernel.org>
---
kernel/bpf/core.c | 7 ++++---
1 file changed, 4 insertions(+), 3 deletions(-)
diff --git a/kernel/bpf/core.c b/kernel/bpf/core.c
index 2be2d73fb6a8..9acfa8e21fda 100644
--- a/kernel/bpf/core.c
+++ b/kernel/bpf/core.c
@@ -857,7 +857,7 @@ static size_t select_bpf_prog_pack_size(void)
void *ptr;
size = BPF_HPAGE_SIZE * num_online_nodes();
- ptr = module_alloc(size);
+ ptr = module_alloc_huge(size);
/* Test whether we can get huge pages. If not just use PAGE_SIZE
* packs.
@@ -881,7 +881,7 @@ static struct bpf_prog_pack *alloc_new_pack(bpf_jit_fill_hole_t bpf_fill_ill_ins
GFP_KERNEL);
if (!pack)
return NULL;
- pack->ptr = module_alloc(bpf_prog_pack_size);
+ pack->ptr = module_alloc_huge(bpf_prog_pack_size);
if (!pack->ptr) {
kfree(pack);
return NULL;
@@ -890,7 +890,6 @@ static struct bpf_prog_pack *alloc_new_pack(bpf_jit_fill_hole_t bpf_fill_ill_ins
bitmap_zero(pack->bitmap, bpf_prog_pack_size / BPF_PROG_CHUNK_SIZE);
list_add_tail(&pack->list, &pack_list);
- set_vm_flush_reset_perms(pack->ptr);
set_memory_ro((unsigned long)pack->ptr, bpf_prog_pack_size / PAGE_SIZE);
set_memory_x((unsigned long)pack->ptr, bpf_prog_pack_size / PAGE_SIZE);
return pack;
@@ -973,6 +972,8 @@ static void bpf_prog_pack_free(struct bpf_binary_header *hdr)
if (bitmap_find_next_zero_area(pack->bitmap, bpf_prog_chunk_count(), 0,
bpf_prog_chunk_count(), 0) == 0) {
list_del(&pack->list);
+ set_memory_nx((unsigned long)pack->ptr, bpf_prog_pack_size / PAGE_SIZE);
+ set_memory_rw((unsigned long)pack->ptr, bpf_prog_pack_size / PAGE_SIZE);
module_memfree(pack->ptr);
kfree(pack);
}
--
2.30.2
^ permalink raw reply related [flat|nested] 8+ messages in thread
* Re: [PATCH bpf 2/4] page_alloc: use vmalloc_huge for large system hash
2022-04-22 5:18 ` [PATCH bpf 2/4] page_alloc: use vmalloc_huge for large system hash Song Liu
@ 2022-04-22 9:06 ` kernel test robot
0 siblings, 0 replies; 8+ messages in thread
From: kernel test robot @ 2022-04-22 9:06 UTC (permalink / raw)
To: Song Liu, bpf, linux-mm, linux-kernel
Cc: kbuild-all, ast, daniel, kernel-team, akpm, rick.p.edgecombe,
hch, imbrenda, mcgrof, Song Liu, Christoph Hellwig
Hi Song,
I love your patch! Yet something to improve:
[auto build test ERROR on bpf/master]
url: https://github.com/intel-lab-lkp/linux/commits/Song-Liu/bpf_prog_pack-and-vmalloc-on-huge-page-fixes/20220422-133605
base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf.git master
config: i386-randconfig-a001 (https://download.01.org/0day-ci/archive/20220422/202204221628.82Qczjsq-lkp@intel.com/config)
compiler: gcc-11 (Debian 11.2.0-20) 11.2.0
reproduce (this is a W=1 build):
# https://github.com/intel-lab-lkp/linux/commit/239fb9ca743cf33db8d56df7957726e19aea87d5
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Song-Liu/bpf_prog_pack-and-vmalloc-on-huge-page-fixes/20220422-133605
git checkout 239fb9ca743cf33db8d56df7957726e19aea87d5
# save the config file
mkdir build_dir && cp config build_dir/.config
make W=1 O=build_dir ARCH=i386 SHELL=/bin/bash
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
All error/warnings (new ones prefixed by >>):
mm/page_alloc.c: In function 'alloc_large_system_hash':
>> mm/page_alloc.c:8921:33: error: implicit declaration of function 'vmalloc_huge'; did you mean 'vmalloc_no_huge'? [-Werror=implicit-function-declaration]
8921 | table = vmalloc_huge(size, gfp_flags);
| ^~~~~~~~~~~~
| vmalloc_no_huge
>> mm/page_alloc.c:8921:31: warning: assignment to 'void *' from 'int' makes pointer from integer without a cast [-Wint-conversion]
8921 | table = vmalloc_huge(size, gfp_flags);
| ^
cc1: some warnings being treated as errors
vim +8921 mm/page_alloc.c
8876
8877 /* limit to 1 bucket per 2^scale bytes of low memory */
8878 if (scale > PAGE_SHIFT)
8879 numentries >>= (scale - PAGE_SHIFT);
8880 else
8881 numentries <<= (PAGE_SHIFT - scale);
8882
8883 /* Make sure we've got at least a 0-order allocation.. */
8884 if (unlikely(flags & HASH_SMALL)) {
8885 /* Makes no sense without HASH_EARLY */
8886 WARN_ON(!(flags & HASH_EARLY));
8887 if (!(numentries >> *_hash_shift)) {
8888 numentries = 1UL << *_hash_shift;
8889 BUG_ON(!numentries);
8890 }
8891 } else if (unlikely((numentries * bucketsize) < PAGE_SIZE))
8892 numentries = PAGE_SIZE / bucketsize;
8893 }
8894 numentries = roundup_pow_of_two(numentries);
8895
8896 /* limit allocation size to 1/16 total memory by default */
8897 if (max == 0) {
8898 max = ((unsigned long long)nr_all_pages << PAGE_SHIFT) >> 4;
8899 do_div(max, bucketsize);
8900 }
8901 max = min(max, 0x80000000ULL);
8902
8903 if (numentries < low_limit)
8904 numentries = low_limit;
8905 if (numentries > max)
8906 numentries = max;
8907
8908 log2qty = ilog2(numentries);
8909
8910 gfp_flags = (flags & HASH_ZERO) ? GFP_ATOMIC | __GFP_ZERO : GFP_ATOMIC;
8911 do {
8912 virt = false;
8913 size = bucketsize << log2qty;
8914 if (flags & HASH_EARLY) {
8915 if (flags & HASH_ZERO)
8916 table = memblock_alloc(size, SMP_CACHE_BYTES);
8917 else
8918 table = memblock_alloc_raw(size,
8919 SMP_CACHE_BYTES);
8920 } else if (get_order(size) >= MAX_ORDER || hashdist) {
> 8921 table = vmalloc_huge(size, gfp_flags);
8922 virt = true;
8923 if (table)
8924 huge = is_vm_area_hugepages(table);
8925 } else {
8926 /*
8927 * If bucketsize is not a power-of-two, we may free
8928 * some pages at the end of hash table which
8929 * alloc_pages_exact() automatically does
8930 */
8931 table = alloc_pages_exact(size, gfp_flags);
8932 kmemleak_alloc(table, size, 1, gfp_flags);
8933 }
8934 } while (!table && size > PAGE_SIZE && --log2qty);
8935
8936 if (!table)
8937 panic("Failed to allocate %s hash table\n", tablename);
8938
8939 pr_info("%s hash table entries: %ld (order: %d, %lu bytes, %s)\n",
8940 tablename, 1UL << log2qty, ilog2(size) - PAGE_SHIFT, size,
8941 virt ? (huge ? "vmalloc hugepage" : "vmalloc") : "linear");
8942
8943 if (_hash_shift)
8944 *_hash_shift = log2qty;
8945 if (_hash_mask)
8946 *_hash_mask = (1 << log2qty) - 1;
8947
8948 return table;
8949 }
8950
--
0-DAY CI Kernel Test Service
https://01.org/lkp
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH bpf 3/4] module: introduce module_alloc_huge
2022-04-22 5:18 ` [PATCH bpf 3/4] module: introduce module_alloc_huge Song Liu
@ 2022-04-22 9:48 ` kernel test robot
0 siblings, 0 replies; 8+ messages in thread
From: kernel test robot @ 2022-04-22 9:48 UTC (permalink / raw)
To: Song Liu, bpf, linux-mm, linux-kernel
Cc: kbuild-all, ast, daniel, kernel-team, akpm, rick.p.edgecombe,
hch, imbrenda, mcgrof, Song Liu
Hi Song,
I love your patch! Yet something to improve:
[auto build test ERROR on bpf/master]
url: https://github.com/intel-lab-lkp/linux/commits/Song-Liu/bpf_prog_pack-and-vmalloc-on-huge-page-fixes/20220422-133605
base: https://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf.git master
config: x86_64-randconfig-a004 (https://download.01.org/0day-ci/archive/20220422/202204221700.93ehQrzU-lkp@intel.com/config)
compiler: gcc-11 (Debian 11.2.0-20) 11.2.0
reproduce (this is a W=1 build):
# https://github.com/intel-lab-lkp/linux/commit/8a0dfde5aef7e95487be2f6e3ff9487d79a30714
git remote add linux-review https://github.com/intel-lab-lkp/linux
git fetch --no-tags linux-review Song-Liu/bpf_prog_pack-and-vmalloc-on-huge-page-fixes/20220422-133605
git checkout 8a0dfde5aef7e95487be2f6e3ff9487d79a30714
# save the config file
mkdir build_dir && cp config build_dir/.config
make W=1 O=build_dir ARCH=x86_64 SHELL=/bin/bash
If you fix the issue, kindly add following tag as appropriate
Reported-by: kernel test robot <lkp@intel.com>
All errors (new ones prefixed by >>):
arch/x86/kernel/module.c: In function 'module_alloc_huge':
>> arch/x86/kernel/module.c:100:54: error: 'VM_ALLOW_HUGE_VMAP' undeclared (first use in this function); did you mean 'VM_NO_HUGE_VMAP'?
100 | VM_DEFER_KMEMLEAK | VM_ALLOW_HUGE_VMAP,
| ^~~~~~~~~~~~~~~~~~
| VM_NO_HUGE_VMAP
arch/x86/kernel/module.c:100:54: note: each undeclared identifier is reported only once for each function it appears in
vim +100 arch/x86/kernel/module.c
88
89 void *module_alloc_huge(unsigned long size)
90 {
91 gfp_t gfp_mask = GFP_KERNEL;
92 void *p;
93
94 if (PAGE_ALIGN(size) > MODULES_LEN)
95 return NULL;
96
97 p = __vmalloc_node_range(size, MODULE_ALIGN,
98 MODULES_VADDR + get_module_load_offset(),
99 MODULES_END, gfp_mask, PAGE_KERNEL,
> 100 VM_DEFER_KMEMLEAK | VM_ALLOW_HUGE_VMAP,
101 NUMA_NO_NODE, __builtin_return_address(0));
102 if (p && (kasan_alloc_module_shadow(p, size, gfp_mask) < 0)) {
103 vfree(p);
104 return NULL;
105 }
106
107 return p;
108 }
109
--
0-DAY CI Kernel Test Service
https://01.org/lkp
^ permalink raw reply [flat|nested] 8+ messages in thread
* Re: [PATCH bpf 0/4] bpf_prog_pack and vmalloc-on-huge-page fixes
2022-04-22 5:18 [PATCH bpf 0/4] bpf_prog_pack and vmalloc-on-huge-page fixes Song Liu
` (3 preceding siblings ...)
2022-04-22 5:18 ` [PATCH bpf 4/4] bpf: use module_alloc_huge for bpf_prog_pack Song Liu
@ 2022-04-22 14:42 ` Luis Chamberlain
4 siblings, 0 replies; 8+ messages in thread
From: Luis Chamberlain @ 2022-04-22 14:42 UTC (permalink / raw)
To: Song Liu, Linus Torvalds
Cc: bpf, linux-mm, linux-kernel, ast, daniel, kernel-team, akpm,
rick.p.edgecombe, hch, imbrenda
On Thu, Apr 21, 2022 at 10:18:09PM -0700, Song Liu wrote:
> NOTE: This set is based on Linus' master branch (d569e86915b7), not
> bpf/master.
>
> There are various discussion about these changes, check out [1] [2].
> I guess we can use this thread to discuss which patches should go in 5.18.
> AFAICT, 1/4 need to with 5.18;
Since huge pages are effectively disabled on v5.18 I can't see why.
> 2/4 seems safe to go as well;
My impression on the discussion was that huge pages design was broken
and evidence for this came up after x86 finally enabled *a small*
portion use case of it. This revealed how broken huge pages were not
just for x86 but for other architectures. And so I can't see why we'd
enable for v5.18 huge pages for the large system hash.
> 3/4 and 4/4
> may still need more work/discussion.
Happy to review these but if huge pages are disabled I don't see the
point in a module_alloc_huge() yet.
Luis
>
> Thanks!
>
> [1] https://lore.kernel.org/linux-mm/20220415164413.2727220-1-song@kernel.org/
> [2] https://lore.kernel.org/linux-mm/20220421072212.608884-1-song@kernel.org/
>
> Song Liu (4):
> bpf: invalidate unused part of bpf_prog_pack
> page_alloc: use vmalloc_huge for large system hash
> module: introduce module_alloc_huge
> bpf: use module_alloc_huge for bpf_prog_pack
>
> arch/x86/kernel/module.c | 21 +++++++++++++++++++++
> arch/x86/net/bpf_jit_comp.c | 22 ++++++++++++++++++++++
> include/linux/bpf.h | 2 ++
> include/linux/moduleloader.h | 5 +++++
> kernel/bpf/core.c | 28 +++++++++++++++++++++-------
> kernel/module.c | 8 ++++++++
> mm/page_alloc.c | 2 +-
> 7 files changed, 80 insertions(+), 8 deletions(-)
>
> --
> 2.30.2
^ permalink raw reply [flat|nested] 8+ messages in thread
end of thread, other threads:[~2022-04-22 14:42 UTC | newest]
Thread overview: 8+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-04-22 5:18 [PATCH bpf 0/4] bpf_prog_pack and vmalloc-on-huge-page fixes Song Liu
2022-04-22 5:18 ` [PATCH bpf 1/4] bpf: invalidate unused part of bpf_prog_pack Song Liu
2022-04-22 5:18 ` [PATCH bpf 2/4] page_alloc: use vmalloc_huge for large system hash Song Liu
2022-04-22 9:06 ` kernel test robot
2022-04-22 5:18 ` [PATCH bpf 3/4] module: introduce module_alloc_huge Song Liu
2022-04-22 9:48 ` kernel test robot
2022-04-22 5:18 ` [PATCH bpf 4/4] bpf: use module_alloc_huge for bpf_prog_pack Song Liu
2022-04-22 14:42 ` [PATCH bpf 0/4] bpf_prog_pack and vmalloc-on-huge-page fixes Luis Chamberlain
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.