Commit 47504ee0 authored by Dennis Zhou's avatar Dennis Zhou Committed by Tejun Heo

percpu: add __GFP_NORETRY semantics to the percpu balancing path

Percpu memory using the vmalloc area based chunk allocator lazily
populates chunks by first requesting the full virtual address space
required for the chunk and subsequently adding pages as allocations come
through. To ensure atomic allocations can succeed, a workqueue item is
used to maintain a minimum number of empty pages. In certain scenarios,
such as reported in [1], it is possible that physical memory becomes
quite scarce which can result in either a rather long time spent trying
to find free pages or worse, a kernel panic.

This patch adds support for __GFP_NORETRY and __GFP_NOWARN passing them
through to the underlying allocators. This should prevent any
unnecessary panics potentially caused by the workqueue item. The passing
of gfp around is as additional flags rather than a full set of flags.
The next patch will change these to caller passed semantics.

V2:
Added const modifier to gfp flags in the balance path.
Removed an extra whitespace.

[1] https://lkml.org/lkml/2018/2/12/551Signed-off-by: default avatarDennis Zhou <dennisszhou@gmail.com>
Suggested-by: default avatarDaniel Borkmann <daniel@iogearbox.net>
Reported-by: syzbot+adb03f3f0bb57ce3acda@syzkaller.appspotmail.com
Acked-by: default avatarChristoph Lameter <cl@linux.com>
Signed-off-by: default avatarTejun Heo <tj@kernel.org>
parent 15d9f3d1
...@@ -34,7 +34,7 @@ ...@@ -34,7 +34,7 @@
#include <linux/log2.h> #include <linux/log2.h>
static int pcpu_populate_chunk(struct pcpu_chunk *chunk, static int pcpu_populate_chunk(struct pcpu_chunk *chunk,
int page_start, int page_end) int page_start, int page_end, gfp_t gfp)
{ {
return 0; return 0;
} }
...@@ -45,18 +45,18 @@ static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk, ...@@ -45,18 +45,18 @@ static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk,
/* nada */ /* nada */
} }
static struct pcpu_chunk *pcpu_create_chunk(void) static struct pcpu_chunk *pcpu_create_chunk(gfp_t gfp)
{ {
const int nr_pages = pcpu_group_sizes[0] >> PAGE_SHIFT; const int nr_pages = pcpu_group_sizes[0] >> PAGE_SHIFT;
struct pcpu_chunk *chunk; struct pcpu_chunk *chunk;
struct page *pages; struct page *pages;
int i; int i;
chunk = pcpu_alloc_chunk(); chunk = pcpu_alloc_chunk(gfp);
if (!chunk) if (!chunk)
return NULL; return NULL;
pages = alloc_pages(GFP_KERNEL, order_base_2(nr_pages)); pages = alloc_pages(gfp | GFP_KERNEL, order_base_2(nr_pages));
if (!pages) { if (!pages) {
pcpu_free_chunk(chunk); pcpu_free_chunk(chunk);
return NULL; return NULL;
......
...@@ -37,7 +37,7 @@ static struct page **pcpu_get_pages(void) ...@@ -37,7 +37,7 @@ static struct page **pcpu_get_pages(void)
lockdep_assert_held(&pcpu_alloc_mutex); lockdep_assert_held(&pcpu_alloc_mutex);
if (!pages) if (!pages)
pages = pcpu_mem_zalloc(pages_size); pages = pcpu_mem_zalloc(pages_size, 0);
return pages; return pages;
} }
...@@ -73,18 +73,21 @@ static void pcpu_free_pages(struct pcpu_chunk *chunk, ...@@ -73,18 +73,21 @@ static void pcpu_free_pages(struct pcpu_chunk *chunk,
* @pages: array to put the allocated pages into, indexed by pcpu_page_idx() * @pages: array to put the allocated pages into, indexed by pcpu_page_idx()
* @page_start: page index of the first page to be allocated * @page_start: page index of the first page to be allocated
* @page_end: page index of the last page to be allocated + 1 * @page_end: page index of the last page to be allocated + 1
* @gfp: allocation flags passed to the underlying allocator
* *
* Allocate pages [@page_start,@page_end) into @pages for all units. * Allocate pages [@page_start,@page_end) into @pages for all units.
* The allocation is for @chunk. Percpu core doesn't care about the * The allocation is for @chunk. Percpu core doesn't care about the
* content of @pages and will pass it verbatim to pcpu_map_pages(). * content of @pages and will pass it verbatim to pcpu_map_pages().
*/ */
static int pcpu_alloc_pages(struct pcpu_chunk *chunk, static int pcpu_alloc_pages(struct pcpu_chunk *chunk,
struct page **pages, int page_start, int page_end) struct page **pages, int page_start, int page_end,
gfp_t gfp)
{ {
const gfp_t gfp = GFP_KERNEL | __GFP_HIGHMEM;
unsigned int cpu, tcpu; unsigned int cpu, tcpu;
int i; int i;
gfp |= GFP_KERNEL | __GFP_HIGHMEM;
for_each_possible_cpu(cpu) { for_each_possible_cpu(cpu) {
for (i = page_start; i < page_end; i++) { for (i = page_start; i < page_end; i++) {
struct page **pagep = &pages[pcpu_page_idx(cpu, i)]; struct page **pagep = &pages[pcpu_page_idx(cpu, i)];
...@@ -262,6 +265,7 @@ static void pcpu_post_map_flush(struct pcpu_chunk *chunk, ...@@ -262,6 +265,7 @@ static void pcpu_post_map_flush(struct pcpu_chunk *chunk,
* @chunk: chunk of interest * @chunk: chunk of interest
* @page_start: the start page * @page_start: the start page
* @page_end: the end page * @page_end: the end page
* @gfp: allocation flags passed to the underlying memory allocator
* *
* For each cpu, populate and map pages [@page_start,@page_end) into * For each cpu, populate and map pages [@page_start,@page_end) into
* @chunk. * @chunk.
...@@ -270,7 +274,7 @@ static void pcpu_post_map_flush(struct pcpu_chunk *chunk, ...@@ -270,7 +274,7 @@ static void pcpu_post_map_flush(struct pcpu_chunk *chunk,
* pcpu_alloc_mutex, does GFP_KERNEL allocation. * pcpu_alloc_mutex, does GFP_KERNEL allocation.
*/ */
static int pcpu_populate_chunk(struct pcpu_chunk *chunk, static int pcpu_populate_chunk(struct pcpu_chunk *chunk,
int page_start, int page_end) int page_start, int page_end, gfp_t gfp)
{ {
struct page **pages; struct page **pages;
...@@ -278,7 +282,7 @@ static int pcpu_populate_chunk(struct pcpu_chunk *chunk, ...@@ -278,7 +282,7 @@ static int pcpu_populate_chunk(struct pcpu_chunk *chunk,
if (!pages) if (!pages)
return -ENOMEM; return -ENOMEM;
if (pcpu_alloc_pages(chunk, pages, page_start, page_end)) if (pcpu_alloc_pages(chunk, pages, page_start, page_end, gfp))
return -ENOMEM; return -ENOMEM;
if (pcpu_map_pages(chunk, pages, page_start, page_end)) { if (pcpu_map_pages(chunk, pages, page_start, page_end)) {
...@@ -325,12 +329,12 @@ static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk, ...@@ -325,12 +329,12 @@ static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk,
pcpu_free_pages(chunk, pages, page_start, page_end); pcpu_free_pages(chunk, pages, page_start, page_end);
} }
static struct pcpu_chunk *pcpu_create_chunk(void) static struct pcpu_chunk *pcpu_create_chunk(gfp_t gfp)
{ {
struct pcpu_chunk *chunk; struct pcpu_chunk *chunk;
struct vm_struct **vms; struct vm_struct **vms;
chunk = pcpu_alloc_chunk(); chunk = pcpu_alloc_chunk(gfp);
if (!chunk) if (!chunk)
return NULL; return NULL;
......
...@@ -447,10 +447,12 @@ static void pcpu_next_fit_region(struct pcpu_chunk *chunk, int alloc_bits, ...@@ -447,10 +447,12 @@ static void pcpu_next_fit_region(struct pcpu_chunk *chunk, int alloc_bits,
/** /**
* pcpu_mem_zalloc - allocate memory * pcpu_mem_zalloc - allocate memory
* @size: bytes to allocate * @size: bytes to allocate
* @gfp: allocation flags
* *
* Allocate @size bytes. If @size is smaller than PAGE_SIZE, * Allocate @size bytes. If @size is smaller than PAGE_SIZE,
* kzalloc() is used; otherwise, vzalloc() is used. The returned * kzalloc() is used; otherwise, the equivalent of vzalloc() is used.
* memory is always zeroed. * This is to facilitate passing through whitelisted flags. The
* returned memory is always zeroed.
* *
* CONTEXT: * CONTEXT:
* Does GFP_KERNEL allocation. * Does GFP_KERNEL allocation.
...@@ -458,15 +460,16 @@ static void pcpu_next_fit_region(struct pcpu_chunk *chunk, int alloc_bits, ...@@ -458,15 +460,16 @@ static void pcpu_next_fit_region(struct pcpu_chunk *chunk, int alloc_bits,
* RETURNS: * RETURNS:
* Pointer to the allocated area on success, NULL on failure. * Pointer to the allocated area on success, NULL on failure.
*/ */
static void *pcpu_mem_zalloc(size_t size) static void *pcpu_mem_zalloc(size_t size, gfp_t gfp)
{ {
if (WARN_ON_ONCE(!slab_is_available())) if (WARN_ON_ONCE(!slab_is_available()))
return NULL; return NULL;
if (size <= PAGE_SIZE) if (size <= PAGE_SIZE)
return kzalloc(size, GFP_KERNEL); return kzalloc(size, gfp | GFP_KERNEL);
else else
return vzalloc(size); return __vmalloc(size, gfp | GFP_KERNEL | __GFP_ZERO,
PAGE_KERNEL);
} }
/** /**
...@@ -1154,12 +1157,12 @@ static struct pcpu_chunk * __init pcpu_alloc_first_chunk(unsigned long tmp_addr, ...@@ -1154,12 +1157,12 @@ static struct pcpu_chunk * __init pcpu_alloc_first_chunk(unsigned long tmp_addr,
return chunk; return chunk;
} }
static struct pcpu_chunk *pcpu_alloc_chunk(void) static struct pcpu_chunk *pcpu_alloc_chunk(gfp_t gfp)
{ {
struct pcpu_chunk *chunk; struct pcpu_chunk *chunk;
int region_bits; int region_bits;
chunk = pcpu_mem_zalloc(pcpu_chunk_struct_size); chunk = pcpu_mem_zalloc(pcpu_chunk_struct_size, gfp);
if (!chunk) if (!chunk)
return NULL; return NULL;
...@@ -1168,17 +1171,17 @@ static struct pcpu_chunk *pcpu_alloc_chunk(void) ...@@ -1168,17 +1171,17 @@ static struct pcpu_chunk *pcpu_alloc_chunk(void)
region_bits = pcpu_chunk_map_bits(chunk); region_bits = pcpu_chunk_map_bits(chunk);
chunk->alloc_map = pcpu_mem_zalloc(BITS_TO_LONGS(region_bits) * chunk->alloc_map = pcpu_mem_zalloc(BITS_TO_LONGS(region_bits) *
sizeof(chunk->alloc_map[0])); sizeof(chunk->alloc_map[0]), gfp);
if (!chunk->alloc_map) if (!chunk->alloc_map)
goto alloc_map_fail; goto alloc_map_fail;
chunk->bound_map = pcpu_mem_zalloc(BITS_TO_LONGS(region_bits + 1) * chunk->bound_map = pcpu_mem_zalloc(BITS_TO_LONGS(region_bits + 1) *
sizeof(chunk->bound_map[0])); sizeof(chunk->bound_map[0]), gfp);
if (!chunk->bound_map) if (!chunk->bound_map)
goto bound_map_fail; goto bound_map_fail;
chunk->md_blocks = pcpu_mem_zalloc(pcpu_chunk_nr_blocks(chunk) * chunk->md_blocks = pcpu_mem_zalloc(pcpu_chunk_nr_blocks(chunk) *
sizeof(chunk->md_blocks[0])); sizeof(chunk->md_blocks[0]), gfp);
if (!chunk->md_blocks) if (!chunk->md_blocks)
goto md_blocks_fail; goto md_blocks_fail;
...@@ -1278,10 +1281,10 @@ static void pcpu_chunk_depopulated(struct pcpu_chunk *chunk, ...@@ -1278,10 +1281,10 @@ static void pcpu_chunk_depopulated(struct pcpu_chunk *chunk,
* pcpu_verify_alloc_info - check alloc_info is acceptable during init * pcpu_verify_alloc_info - check alloc_info is acceptable during init
*/ */
static int pcpu_populate_chunk(struct pcpu_chunk *chunk, static int pcpu_populate_chunk(struct pcpu_chunk *chunk,
int page_start, int page_end); int page_start, int page_end, gfp_t gfp);
static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk, static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk,
int page_start, int page_end); int page_start, int page_end);
static struct pcpu_chunk *pcpu_create_chunk(void); static struct pcpu_chunk *pcpu_create_chunk(gfp_t gfp);
static void pcpu_destroy_chunk(struct pcpu_chunk *chunk); static void pcpu_destroy_chunk(struct pcpu_chunk *chunk);
static struct page *pcpu_addr_to_page(void *addr); static struct page *pcpu_addr_to_page(void *addr);
static int __init pcpu_verify_alloc_info(const struct pcpu_alloc_info *ai); static int __init pcpu_verify_alloc_info(const struct pcpu_alloc_info *ai);
...@@ -1423,7 +1426,7 @@ static void __percpu *pcpu_alloc(size_t size, size_t align, bool reserved, ...@@ -1423,7 +1426,7 @@ static void __percpu *pcpu_alloc(size_t size, size_t align, bool reserved,
} }
if (list_empty(&pcpu_slot[pcpu_nr_slots - 1])) { if (list_empty(&pcpu_slot[pcpu_nr_slots - 1])) {
chunk = pcpu_create_chunk(); chunk = pcpu_create_chunk(0);
if (!chunk) { if (!chunk) {
err = "failed to allocate new chunk"; err = "failed to allocate new chunk";
goto fail; goto fail;
...@@ -1452,7 +1455,7 @@ static void __percpu *pcpu_alloc(size_t size, size_t align, bool reserved, ...@@ -1452,7 +1455,7 @@ static void __percpu *pcpu_alloc(size_t size, size_t align, bool reserved,
page_start, page_end) { page_start, page_end) {
WARN_ON(chunk->immutable); WARN_ON(chunk->immutable);
ret = pcpu_populate_chunk(chunk, rs, re); ret = pcpu_populate_chunk(chunk, rs, re, 0);
spin_lock_irqsave(&pcpu_lock, flags); spin_lock_irqsave(&pcpu_lock, flags);
if (ret) { if (ret) {
...@@ -1563,10 +1566,17 @@ void __percpu *__alloc_reserved_percpu(size_t size, size_t align) ...@@ -1563,10 +1566,17 @@ void __percpu *__alloc_reserved_percpu(size_t size, size_t align)
* pcpu_balance_workfn - manage the amount of free chunks and populated pages * pcpu_balance_workfn - manage the amount of free chunks and populated pages
* @work: unused * @work: unused
* *
* Reclaim all fully free chunks except for the first one. * Reclaim all fully free chunks except for the first one. This is also
* responsible for maintaining the pool of empty populated pages. However,
* it is possible that this is called when physical memory is scarce causing
* OOM killer to be triggered. We should avoid doing so until an actual
* allocation causes the failure as it is possible that requests can be
* serviced from already backed regions.
*/ */
static void pcpu_balance_workfn(struct work_struct *work) static void pcpu_balance_workfn(struct work_struct *work)
{ {
/* gfp flags passed to underlying allocators */
const gfp_t gfp = __GFP_NORETRY | __GFP_NOWARN;
LIST_HEAD(to_free); LIST_HEAD(to_free);
struct list_head *free_head = &pcpu_slot[pcpu_nr_slots - 1]; struct list_head *free_head = &pcpu_slot[pcpu_nr_slots - 1];
struct pcpu_chunk *chunk, *next; struct pcpu_chunk *chunk, *next;
...@@ -1647,7 +1657,7 @@ static void pcpu_balance_workfn(struct work_struct *work) ...@@ -1647,7 +1657,7 @@ static void pcpu_balance_workfn(struct work_struct *work)
chunk->nr_pages) { chunk->nr_pages) {
int nr = min(re - rs, nr_to_pop); int nr = min(re - rs, nr_to_pop);
ret = pcpu_populate_chunk(chunk, rs, rs + nr); ret = pcpu_populate_chunk(chunk, rs, rs + nr, gfp);
if (!ret) { if (!ret) {
nr_to_pop -= nr; nr_to_pop -= nr;
spin_lock_irq(&pcpu_lock); spin_lock_irq(&pcpu_lock);
...@@ -1664,7 +1674,7 @@ static void pcpu_balance_workfn(struct work_struct *work) ...@@ -1664,7 +1674,7 @@ static void pcpu_balance_workfn(struct work_struct *work)
if (nr_to_pop) { if (nr_to_pop) {
/* ran out of chunks to populate, create a new one and retry */ /* ran out of chunks to populate, create a new one and retry */
chunk = pcpu_create_chunk(); chunk = pcpu_create_chunk(gfp);
if (chunk) { if (chunk) {
spin_lock_irq(&pcpu_lock); spin_lock_irq(&pcpu_lock);
pcpu_chunk_relocate(chunk, -1); pcpu_chunk_relocate(chunk, -1);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment