2009-02-20 08:29:08 +01:00
|
|
|
/*
|
|
|
|
* linux/mm/percpu.c - percpu memory allocator
|
|
|
|
*
|
|
|
|
* Copyright (C) 2009 SUSE Linux Products GmbH
|
|
|
|
* Copyright (C) 2009 Tejun Heo <tj@kernel.org>
|
|
|
|
*
|
|
|
|
* This file is released under the GPLv2.
|
|
|
|
*
|
|
|
|
* This is percpu allocator which can handle both static and dynamic
|
|
|
|
* areas. Percpu areas are allocated in chunks in vmalloc area. Each
|
2009-07-04 01:11:00 +02:00
|
|
|
* chunk is consisted of boot-time determined number of units and the
|
|
|
|
* first chunk is used for static percpu variables in the kernel image
|
|
|
|
* (special boot time alloc/init handling necessary as these areas
|
|
|
|
* need to be brought up before allocation services are running).
|
|
|
|
* Unit grows as necessary and all units grow or shrink in unison.
|
|
|
|
* When a chunk is filled up, another chunk is allocated. ie. in
|
|
|
|
* vmalloc area
|
2009-02-20 08:29:08 +01:00
|
|
|
*
|
|
|
|
* c0 c1 c2
|
|
|
|
* ------------------- ------------------- ------------
|
|
|
|
* | u0 | u1 | u2 | u3 | | u0 | u1 | u2 | u3 | | u0 | u1 | u
|
|
|
|
* ------------------- ...... ------------------- .... ------------
|
|
|
|
*
|
|
|
|
* Allocation is done in offset-size areas of single unit space. Ie,
|
|
|
|
* an area of 512 bytes at 6k in c1 occupies 512 bytes at 6k of c1:u0,
|
2009-07-04 01:11:00 +02:00
|
|
|
* c1:u1, c1:u2 and c1:u3. On UMA, units corresponds directly to
|
|
|
|
* cpus. On NUMA, the mapping can be non-linear and even sparse.
|
|
|
|
* Percpu access can be done by configuring percpu base registers
|
|
|
|
* according to cpu to unit mapping and pcpu_unit_size.
|
2009-02-20 08:29:08 +01:00
|
|
|
*
|
2009-07-04 01:11:00 +02:00
|
|
|
* There are usually many small percpu allocations many of them being
|
|
|
|
* as small as 4 bytes. The allocator organizes chunks into lists
|
2009-02-20 08:29:08 +01:00
|
|
|
* according to free size and tries to allocate from the fullest one.
|
|
|
|
* Each chunk keeps the maximum contiguous area size hint which is
|
|
|
|
* guaranteed to be eqaul to or larger than the maximum contiguous
|
|
|
|
* area in the chunk. This helps the allocator not to iterate the
|
|
|
|
* chunk maps unnecessarily.
|
|
|
|
*
|
|
|
|
* Allocation state in each chunk is kept using an array of integers
|
|
|
|
* on chunk->map. A positive value in the map represents a free
|
|
|
|
* region and negative allocated. Allocation inside a chunk is done
|
|
|
|
* by scanning this map sequentially and serving the first matching
|
|
|
|
* entry. This is mostly copied from the percpu_modalloc() allocator.
|
2009-04-02 06:21:44 +02:00
|
|
|
* Chunks can be determined from the address using the index field
|
|
|
|
* in the page struct. The index field contains a pointer to the chunk.
|
2009-02-20 08:29:08 +01:00
|
|
|
*
|
|
|
|
* To use this allocator, arch code should do the followings.
|
|
|
|
*
|
2009-03-30 12:07:44 +02:00
|
|
|
* - drop CONFIG_HAVE_LEGACY_PER_CPU_AREA
|
2009-02-20 08:29:08 +01:00
|
|
|
*
|
|
|
|
* - define __addr_to_pcpu_ptr() and __pcpu_ptr_to_addr() to translate
|
2009-03-10 08:27:48 +01:00
|
|
|
* regular address to percpu pointer and back if they need to be
|
|
|
|
* different from the default
|
2009-02-20 08:29:08 +01:00
|
|
|
*
|
2009-02-24 03:57:21 +01:00
|
|
|
* - use pcpu_setup_first_chunk() during percpu area initialization to
|
|
|
|
* setup the first chunk containing the kernel static percpu area
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/bitmap.h>
|
|
|
|
#include <linux/bootmem.h>
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
#include <linux/err.h>
|
2009-02-20 08:29:08 +01:00
|
|
|
#include <linux/list.h>
|
2009-07-04 01:11:00 +02:00
|
|
|
#include <linux/log2.h>
|
2009-02-20 08:29:08 +01:00
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/percpu.h>
|
|
|
|
#include <linux/pfn.h>
|
|
|
|
#include <linux/slab.h>
|
2009-03-06 16:44:13 +01:00
|
|
|
#include <linux/spinlock.h>
|
2009-02-20 08:29:08 +01:00
|
|
|
#include <linux/vmalloc.h>
|
2009-03-06 16:44:11 +01:00
|
|
|
#include <linux/workqueue.h>
|
2009-02-20 08:29:08 +01:00
|
|
|
|
|
|
|
#include <asm/cacheflush.h>
|
2009-03-10 08:27:48 +01:00
|
|
|
#include <asm/sections.h>
|
2009-02-20 08:29:08 +01:00
|
|
|
#include <asm/tlbflush.h>
|
|
|
|
|
|
|
|
#define PCPU_SLOT_BASE_SHIFT 5 /* 1-31 shares the same slot */
|
|
|
|
#define PCPU_DFL_MAP_ALLOC 16 /* start a map with 16 ents */
|
|
|
|
|
2009-03-10 08:27:48 +01:00
|
|
|
/* default addr <-> pcpu_ptr mapping, override in asm/percpu.h if necessary */
|
|
|
|
#ifndef __addr_to_pcpu_ptr
|
|
|
|
#define __addr_to_pcpu_ptr(addr) \
|
|
|
|
(void *)((unsigned long)(addr) - (unsigned long)pcpu_base_addr \
|
|
|
|
+ (unsigned long)__per_cpu_start)
|
|
|
|
#endif
|
|
|
|
#ifndef __pcpu_ptr_to_addr
|
|
|
|
#define __pcpu_ptr_to_addr(ptr) \
|
|
|
|
(void *)((unsigned long)(ptr) + (unsigned long)pcpu_base_addr \
|
|
|
|
- (unsigned long)__per_cpu_start)
|
|
|
|
#endif
|
|
|
|
|
2009-02-20 08:29:08 +01:00
|
|
|
struct pcpu_chunk {
|
|
|
|
struct list_head list; /* linked to pcpu_slot lists */
|
|
|
|
int free_size; /* free bytes in the chunk */
|
|
|
|
int contig_hint; /* max contiguous size hint */
|
2009-08-14 08:00:51 +02:00
|
|
|
void *base_addr; /* base address of this chunk */
|
2009-02-20 08:29:08 +01:00
|
|
|
int map_used; /* # of map entries used */
|
|
|
|
int map_alloc; /* # of map entries allocated */
|
|
|
|
int *map; /* allocation map */
|
2009-08-14 08:00:52 +02:00
|
|
|
struct vm_struct **vms; /* mapped vmalloc regions */
|
2009-02-24 03:57:21 +01:00
|
|
|
bool immutable; /* no [de]population allowed */
|
2009-07-04 01:11:00 +02:00
|
|
|
unsigned long populated[]; /* populated bitmap */
|
2009-02-20 08:29:08 +01:00
|
|
|
};
|
|
|
|
|
2009-02-24 04:32:28 +01:00
|
|
|
static int pcpu_unit_pages __read_mostly;
|
|
|
|
static int pcpu_unit_size __read_mostly;
|
2009-07-04 01:11:00 +02:00
|
|
|
static int pcpu_nr_units __read_mostly;
|
2009-08-14 08:00:52 +02:00
|
|
|
static int pcpu_atom_size __read_mostly;
|
2009-02-24 04:32:28 +01:00
|
|
|
static int pcpu_nr_slots __read_mostly;
|
|
|
|
static size_t pcpu_chunk_struct_size __read_mostly;
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/* cpus with the lowest and highest unit numbers */
|
|
|
|
static unsigned int pcpu_first_unit_cpu __read_mostly;
|
|
|
|
static unsigned int pcpu_last_unit_cpu __read_mostly;
|
|
|
|
|
2009-02-20 08:29:08 +01:00
|
|
|
/* the address of the first chunk which starts with the kernel static area */
|
2009-02-24 04:32:28 +01:00
|
|
|
void *pcpu_base_addr __read_mostly;
|
2009-02-20 08:29:08 +01:00
|
|
|
EXPORT_SYMBOL_GPL(pcpu_base_addr);
|
|
|
|
|
2009-08-14 08:00:51 +02:00
|
|
|
static const int *pcpu_unit_map __read_mostly; /* cpu -> unit */
|
|
|
|
const unsigned long *pcpu_unit_offsets __read_mostly; /* cpu -> unit offset */
|
2009-07-04 01:11:00 +02:00
|
|
|
|
2009-08-14 08:00:52 +02:00
|
|
|
/* group information, used for vm allocation */
|
|
|
|
static int pcpu_nr_groups __read_mostly;
|
|
|
|
static const unsigned long *pcpu_group_offsets __read_mostly;
|
|
|
|
static const size_t *pcpu_group_sizes __read_mostly;
|
|
|
|
|
2009-04-02 06:19:54 +02:00
|
|
|
/*
|
|
|
|
* The first chunk which always exists. Note that unlike other
|
|
|
|
* chunks, this one can be allocated and mapped in several different
|
|
|
|
* ways and thus often doesn't live in the vmalloc area.
|
|
|
|
*/
|
|
|
|
static struct pcpu_chunk *pcpu_first_chunk;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Optional reserved chunk. This chunk reserves part of the first
|
|
|
|
* chunk and serves it for reserved allocations. The amount of
|
|
|
|
* reserved offset is in pcpu_reserved_chunk_limit. When reserved
|
|
|
|
* area doesn't exist, the following variables contain NULL and 0
|
|
|
|
* respectively.
|
|
|
|
*/
|
2009-03-06 06:33:59 +01:00
|
|
|
static struct pcpu_chunk *pcpu_reserved_chunk;
|
|
|
|
static int pcpu_reserved_chunk_limit;
|
|
|
|
|
2009-02-20 08:29:08 +01:00
|
|
|
/*
|
2009-03-06 16:44:13 +01:00
|
|
|
* Synchronization rules.
|
|
|
|
*
|
|
|
|
* There are two locks - pcpu_alloc_mutex and pcpu_lock. The former
|
2009-07-04 01:11:00 +02:00
|
|
|
* protects allocation/reclaim paths, chunks, populated bitmap and
|
|
|
|
* vmalloc mapping. The latter is a spinlock and protects the index
|
|
|
|
* data structures - chunk slots, chunks and area maps in chunks.
|
2009-03-06 16:44:13 +01:00
|
|
|
*
|
|
|
|
* During allocation, pcpu_alloc_mutex is kept locked all the time and
|
|
|
|
* pcpu_lock is grabbed and released as necessary. All actual memory
|
|
|
|
* allocations are done using GFP_KERNEL with pcpu_lock released.
|
|
|
|
*
|
|
|
|
* Free path accesses and alters only the index data structures, so it
|
|
|
|
* can be safely called from atomic context. When memory needs to be
|
|
|
|
* returned to the system, free path schedules reclaim_work which
|
|
|
|
* grabs both pcpu_alloc_mutex and pcpu_lock, unlinks chunks to be
|
|
|
|
* reclaimed, release both locks and frees the chunks. Note that it's
|
|
|
|
* necessary to grab both locks to remove a chunk from circulation as
|
|
|
|
* allocation path might be referencing the chunk with only
|
|
|
|
* pcpu_alloc_mutex locked.
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
2009-03-06 16:44:13 +01:00
|
|
|
static DEFINE_MUTEX(pcpu_alloc_mutex); /* protects whole alloc and reclaim */
|
|
|
|
static DEFINE_SPINLOCK(pcpu_lock); /* protects index data structures */
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-02-24 04:32:28 +01:00
|
|
|
static struct list_head *pcpu_slot __read_mostly; /* chunk list slots */
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-03-06 16:44:11 +01:00
|
|
|
/* reclaim work to release fully free chunks, scheduled from free path */
|
|
|
|
static void pcpu_reclaim(struct work_struct *work);
|
|
|
|
static DECLARE_WORK(pcpu_reclaim_work, pcpu_reclaim);
|
|
|
|
|
2009-02-24 03:57:21 +01:00
|
|
|
static int __pcpu_size_to_slot(int size)
|
2009-02-20 08:29:08 +01:00
|
|
|
{
|
2009-02-21 08:56:23 +01:00
|
|
|
int highbit = fls(size); /* size is in bytes */
|
2009-02-20 08:29:08 +01:00
|
|
|
return max(highbit - PCPU_SLOT_BASE_SHIFT + 2, 1);
|
|
|
|
}
|
|
|
|
|
2009-02-24 03:57:21 +01:00
|
|
|
static int pcpu_size_to_slot(int size)
|
|
|
|
{
|
|
|
|
if (size == pcpu_unit_size)
|
|
|
|
return pcpu_nr_slots - 1;
|
|
|
|
return __pcpu_size_to_slot(size);
|
|
|
|
}
|
|
|
|
|
2009-02-20 08:29:08 +01:00
|
|
|
static int pcpu_chunk_slot(const struct pcpu_chunk *chunk)
|
|
|
|
{
|
|
|
|
if (chunk->free_size < sizeof(int) || chunk->contig_hint < sizeof(int))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return pcpu_size_to_slot(chunk->free_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pcpu_page_idx(unsigned int cpu, int page_idx)
|
|
|
|
{
|
2009-07-04 01:11:00 +02:00
|
|
|
return pcpu_unit_map[cpu] * pcpu_unit_pages + page_idx;
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long pcpu_chunk_addr(struct pcpu_chunk *chunk,
|
|
|
|
unsigned int cpu, int page_idx)
|
|
|
|
{
|
2009-08-14 08:00:51 +02:00
|
|
|
return (unsigned long)chunk->base_addr + pcpu_unit_offsets[cpu] +
|
2009-08-14 08:00:51 +02:00
|
|
|
(page_idx << PAGE_SHIFT);
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
static struct page *pcpu_chunk_page(struct pcpu_chunk *chunk,
|
|
|
|
unsigned int cpu, int page_idx)
|
2009-02-20 08:29:08 +01:00
|
|
|
{
|
2009-07-04 01:11:00 +02:00
|
|
|
/* must not be used on pre-mapped chunk */
|
|
|
|
WARN_ON(chunk->immutable);
|
2009-07-04 01:10:59 +02:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
return vmalloc_to_page((void *)pcpu_chunk_addr(chunk, cpu, page_idx));
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
2009-04-02 06:21:44 +02:00
|
|
|
/* set the pointer to a chunk in a page struct */
|
|
|
|
static void pcpu_set_page_chunk(struct page *page, struct pcpu_chunk *pcpu)
|
|
|
|
{
|
|
|
|
page->index = (unsigned long)pcpu;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* obtain pointer to a chunk from a page struct */
|
|
|
|
static struct pcpu_chunk *pcpu_get_page_chunk(struct page *page)
|
|
|
|
{
|
|
|
|
return (struct pcpu_chunk *)page->index;
|
|
|
|
}
|
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
static void pcpu_next_unpop(struct pcpu_chunk *chunk, int *rs, int *re, int end)
|
|
|
|
{
|
|
|
|
*rs = find_next_zero_bit(chunk->populated, end, *rs);
|
|
|
|
*re = find_next_bit(chunk->populated, end, *rs + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pcpu_next_pop(struct pcpu_chunk *chunk, int *rs, int *re, int end)
|
|
|
|
{
|
|
|
|
*rs = find_next_bit(chunk->populated, end, *rs);
|
|
|
|
*re = find_next_zero_bit(chunk->populated, end, *rs + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* (Un)populated page region iterators. Iterate over (un)populated
|
|
|
|
* page regions betwen @start and @end in @chunk. @rs and @re should
|
|
|
|
* be integer variables and will be set to start and end page index of
|
|
|
|
* the current region.
|
|
|
|
*/
|
|
|
|
#define pcpu_for_each_unpop_region(chunk, rs, re, start, end) \
|
|
|
|
for ((rs) = (start), pcpu_next_unpop((chunk), &(rs), &(re), (end)); \
|
|
|
|
(rs) < (re); \
|
|
|
|
(rs) = (re) + 1, pcpu_next_unpop((chunk), &(rs), &(re), (end)))
|
|
|
|
|
|
|
|
#define pcpu_for_each_pop_region(chunk, rs, re, start, end) \
|
|
|
|
for ((rs) = (start), pcpu_next_pop((chunk), &(rs), &(re), (end)); \
|
|
|
|
(rs) < (re); \
|
|
|
|
(rs) = (re) + 1, pcpu_next_pop((chunk), &(rs), &(re), (end)))
|
|
|
|
|
2009-02-20 08:29:08 +01:00
|
|
|
/**
|
2009-03-06 16:44:09 +01:00
|
|
|
* pcpu_mem_alloc - allocate memory
|
|
|
|
* @size: bytes to allocate
|
2009-02-20 08:29:08 +01:00
|
|
|
*
|
2009-03-06 16:44:09 +01:00
|
|
|
* Allocate @size bytes. If @size is smaller than PAGE_SIZE,
|
|
|
|
* kzalloc() is used; otherwise, vmalloc() is used. The returned
|
|
|
|
* memory is always zeroed.
|
2009-02-20 08:29:08 +01:00
|
|
|
*
|
2009-03-06 16:44:13 +01:00
|
|
|
* CONTEXT:
|
|
|
|
* Does GFP_KERNEL allocation.
|
|
|
|
*
|
2009-02-20 08:29:08 +01:00
|
|
|
* RETURNS:
|
2009-03-06 16:44:09 +01:00
|
|
|
* Pointer to the allocated area on success, NULL on failure.
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
2009-03-06 16:44:09 +01:00
|
|
|
static void *pcpu_mem_alloc(size_t size)
|
2009-02-20 08:29:08 +01:00
|
|
|
{
|
2009-03-06 16:44:09 +01:00
|
|
|
if (size <= PAGE_SIZE)
|
|
|
|
return kzalloc(size, GFP_KERNEL);
|
|
|
|
else {
|
|
|
|
void *ptr = vmalloc(size);
|
|
|
|
if (ptr)
|
|
|
|
memset(ptr, 0, size);
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
}
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-03-06 16:44:09 +01:00
|
|
|
/**
|
|
|
|
* pcpu_mem_free - free memory
|
|
|
|
* @ptr: memory to free
|
|
|
|
* @size: size of the area
|
|
|
|
*
|
|
|
|
* Free @ptr. @ptr should have been allocated using pcpu_mem_alloc().
|
|
|
|
*/
|
|
|
|
static void pcpu_mem_free(void *ptr, size_t size)
|
|
|
|
{
|
2009-02-20 08:29:08 +01:00
|
|
|
if (size <= PAGE_SIZE)
|
2009-03-06 16:44:09 +01:00
|
|
|
kfree(ptr);
|
2009-02-20 08:29:08 +01:00
|
|
|
else
|
2009-03-06 16:44:09 +01:00
|
|
|
vfree(ptr);
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pcpu_chunk_relocate - put chunk in the appropriate chunk slot
|
|
|
|
* @chunk: chunk of interest
|
|
|
|
* @oslot: the previous slot it was on
|
|
|
|
*
|
|
|
|
* This function is called after an allocation or free changed @chunk.
|
|
|
|
* New slot according to the changed state is determined and @chunk is
|
2009-03-06 06:33:59 +01:00
|
|
|
* moved to the slot. Note that the reserved chunk is never put on
|
|
|
|
* chunk slots.
|
2009-03-06 16:44:13 +01:00
|
|
|
*
|
|
|
|
* CONTEXT:
|
|
|
|
* pcpu_lock.
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
|
|
|
static void pcpu_chunk_relocate(struct pcpu_chunk *chunk, int oslot)
|
|
|
|
{
|
|
|
|
int nslot = pcpu_chunk_slot(chunk);
|
|
|
|
|
2009-03-06 06:33:59 +01:00
|
|
|
if (chunk != pcpu_reserved_chunk && oslot != nslot) {
|
2009-02-20 08:29:08 +01:00
|
|
|
if (oslot < nslot)
|
|
|
|
list_move(&chunk->list, &pcpu_slot[nslot]);
|
|
|
|
else
|
|
|
|
list_move_tail(&chunk->list, &pcpu_slot[nslot]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-04-02 06:21:44 +02:00
|
|
|
* pcpu_chunk_addr_search - determine chunk containing specified address
|
|
|
|
* @addr: address for which the chunk needs to be determined.
|
2009-03-06 16:44:13 +01:00
|
|
|
*
|
2009-02-20 08:29:08 +01:00
|
|
|
* RETURNS:
|
|
|
|
* The address of the found chunk.
|
|
|
|
*/
|
|
|
|
static struct pcpu_chunk *pcpu_chunk_addr_search(void *addr)
|
|
|
|
{
|
2009-08-14 08:00:51 +02:00
|
|
|
void *first_start = pcpu_first_chunk->base_addr;
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-04-02 06:19:54 +02:00
|
|
|
/* is it in the first chunk? */
|
2009-07-04 01:10:58 +02:00
|
|
|
if (addr >= first_start && addr < first_start + pcpu_unit_size) {
|
2009-04-02 06:19:54 +02:00
|
|
|
/* is it in the reserved area? */
|
|
|
|
if (addr < first_start + pcpu_reserved_chunk_limit)
|
2009-03-06 06:33:59 +01:00
|
|
|
return pcpu_reserved_chunk;
|
2009-04-02 06:19:54 +02:00
|
|
|
return pcpu_first_chunk;
|
2009-03-06 06:33:59 +01:00
|
|
|
}
|
|
|
|
|
2009-09-01 14:12:28 +02:00
|
|
|
/*
|
|
|
|
* The address is relative to unit0 which might be unused and
|
|
|
|
* thus unmapped. Offset the address to the unit space of the
|
|
|
|
* current processor before looking it up in the vmalloc
|
|
|
|
* space. Note that any possible cpu id can be used here, so
|
|
|
|
* there's no need to worry about preemption or cpu hotplug.
|
|
|
|
*/
|
2009-09-15 02:57:19 +02:00
|
|
|
addr += pcpu_unit_offsets[raw_smp_processor_id()];
|
2009-04-02 06:21:44 +02:00
|
|
|
return pcpu_get_page_chunk(vmalloc_to_page(addr));
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
2009-03-06 16:44:09 +01:00
|
|
|
/**
|
|
|
|
* pcpu_extend_area_map - extend area map for allocation
|
|
|
|
* @chunk: target chunk
|
|
|
|
*
|
|
|
|
* Extend area map of @chunk so that it can accomodate an allocation.
|
|
|
|
* A single allocation can split an area into three areas, so this
|
|
|
|
* function makes sure that @chunk->map has at least two extra slots.
|
|
|
|
*
|
2009-03-06 16:44:13 +01:00
|
|
|
* CONTEXT:
|
|
|
|
* pcpu_alloc_mutex, pcpu_lock. pcpu_lock is released and reacquired
|
|
|
|
* if area map is extended.
|
|
|
|
*
|
2009-03-06 16:44:09 +01:00
|
|
|
* RETURNS:
|
|
|
|
* 0 if noop, 1 if successfully extended, -errno on failure.
|
|
|
|
*/
|
|
|
|
static int pcpu_extend_area_map(struct pcpu_chunk *chunk)
|
|
|
|
{
|
|
|
|
int new_alloc;
|
|
|
|
int *new;
|
|
|
|
size_t size;
|
|
|
|
|
|
|
|
/* has enough? */
|
|
|
|
if (chunk->map_alloc >= chunk->map_used + 2)
|
|
|
|
return 0;
|
|
|
|
|
2009-03-06 16:44:13 +01:00
|
|
|
spin_unlock_irq(&pcpu_lock);
|
|
|
|
|
2009-03-06 16:44:09 +01:00
|
|
|
new_alloc = PCPU_DFL_MAP_ALLOC;
|
|
|
|
while (new_alloc < chunk->map_used + 2)
|
|
|
|
new_alloc *= 2;
|
|
|
|
|
|
|
|
new = pcpu_mem_alloc(new_alloc * sizeof(new[0]));
|
2009-03-06 16:44:13 +01:00
|
|
|
if (!new) {
|
|
|
|
spin_lock_irq(&pcpu_lock);
|
2009-03-06 16:44:09 +01:00
|
|
|
return -ENOMEM;
|
2009-03-06 16:44:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Acquire pcpu_lock and switch to new area map. Only free
|
|
|
|
* could have happened inbetween, so map_used couldn't have
|
|
|
|
* grown.
|
|
|
|
*/
|
|
|
|
spin_lock_irq(&pcpu_lock);
|
|
|
|
BUG_ON(new_alloc < chunk->map_used + 2);
|
2009-03-06 16:44:09 +01:00
|
|
|
|
|
|
|
size = chunk->map_alloc * sizeof(chunk->map[0]);
|
|
|
|
memcpy(new, chunk->map, size);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* map_alloc < PCPU_DFL_MAP_ALLOC indicates that the chunk is
|
|
|
|
* one of the first chunks and still using static map.
|
|
|
|
*/
|
|
|
|
if (chunk->map_alloc >= PCPU_DFL_MAP_ALLOC)
|
|
|
|
pcpu_mem_free(chunk->map, size);
|
|
|
|
|
|
|
|
chunk->map_alloc = new_alloc;
|
|
|
|
chunk->map = new;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-02-20 08:29:08 +01:00
|
|
|
/**
|
|
|
|
* pcpu_split_block - split a map block
|
|
|
|
* @chunk: chunk of interest
|
|
|
|
* @i: index of map block to split
|
2009-02-21 08:56:23 +01:00
|
|
|
* @head: head size in bytes (can be 0)
|
|
|
|
* @tail: tail size in bytes (can be 0)
|
2009-02-20 08:29:08 +01:00
|
|
|
*
|
|
|
|
* Split the @i'th map block into two or three blocks. If @head is
|
|
|
|
* non-zero, @head bytes block is inserted before block @i moving it
|
|
|
|
* to @i+1 and reducing its size by @head bytes.
|
|
|
|
*
|
|
|
|
* If @tail is non-zero, the target block, which can be @i or @i+1
|
|
|
|
* depending on @head, is reduced by @tail bytes and @tail byte block
|
|
|
|
* is inserted after the target block.
|
|
|
|
*
|
2009-03-06 16:44:09 +01:00
|
|
|
* @chunk->map must have enough free slots to accomodate the split.
|
2009-03-06 16:44:13 +01:00
|
|
|
*
|
|
|
|
* CONTEXT:
|
|
|
|
* pcpu_lock.
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
2009-03-06 16:44:09 +01:00
|
|
|
static void pcpu_split_block(struct pcpu_chunk *chunk, int i,
|
|
|
|
int head, int tail)
|
2009-02-20 08:29:08 +01:00
|
|
|
{
|
|
|
|
int nr_extra = !!head + !!tail;
|
2009-03-06 16:44:09 +01:00
|
|
|
|
2009-03-06 16:44:09 +01:00
|
|
|
BUG_ON(chunk->map_alloc < chunk->map_used + nr_extra);
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-03-06 16:44:09 +01:00
|
|
|
/* insert new subblocks */
|
2009-02-20 08:29:08 +01:00
|
|
|
memmove(&chunk->map[i + nr_extra], &chunk->map[i],
|
|
|
|
sizeof(chunk->map[0]) * (chunk->map_used - i));
|
|
|
|
chunk->map_used += nr_extra;
|
|
|
|
|
|
|
|
if (head) {
|
|
|
|
chunk->map[i + 1] = chunk->map[i] - head;
|
|
|
|
chunk->map[i++] = head;
|
|
|
|
}
|
|
|
|
if (tail) {
|
|
|
|
chunk->map[i++] -= tail;
|
|
|
|
chunk->map[i] = tail;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pcpu_alloc_area - allocate area from a pcpu_chunk
|
|
|
|
* @chunk: chunk of interest
|
2009-02-21 08:56:23 +01:00
|
|
|
* @size: wanted size in bytes
|
2009-02-20 08:29:08 +01:00
|
|
|
* @align: wanted align
|
|
|
|
*
|
|
|
|
* Try to allocate @size bytes area aligned at @align from @chunk.
|
|
|
|
* Note that this function only allocates the offset. It doesn't
|
|
|
|
* populate or map the area.
|
|
|
|
*
|
2009-03-06 16:44:09 +01:00
|
|
|
* @chunk->map must have at least two free slots.
|
|
|
|
*
|
2009-03-06 16:44:13 +01:00
|
|
|
* CONTEXT:
|
|
|
|
* pcpu_lock.
|
|
|
|
*
|
2009-02-20 08:29:08 +01:00
|
|
|
* RETURNS:
|
2009-03-06 16:44:09 +01:00
|
|
|
* Allocated offset in @chunk on success, -1 if no matching area is
|
|
|
|
* found.
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
|
|
|
static int pcpu_alloc_area(struct pcpu_chunk *chunk, int size, int align)
|
|
|
|
{
|
|
|
|
int oslot = pcpu_chunk_slot(chunk);
|
|
|
|
int max_contig = 0;
|
|
|
|
int i, off;
|
|
|
|
|
|
|
|
for (i = 0, off = 0; i < chunk->map_used; off += abs(chunk->map[i++])) {
|
|
|
|
bool is_last = i + 1 == chunk->map_used;
|
|
|
|
int head, tail;
|
|
|
|
|
|
|
|
/* extra for alignment requirement */
|
|
|
|
head = ALIGN(off, align) - off;
|
|
|
|
BUG_ON(i == 0 && head != 0);
|
|
|
|
|
|
|
|
if (chunk->map[i] < 0)
|
|
|
|
continue;
|
|
|
|
if (chunk->map[i] < head + size) {
|
|
|
|
max_contig = max(chunk->map[i], max_contig);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If head is small or the previous block is free,
|
|
|
|
* merge'em. Note that 'small' is defined as smaller
|
|
|
|
* than sizeof(int), which is very small but isn't too
|
|
|
|
* uncommon for percpu allocations.
|
|
|
|
*/
|
|
|
|
if (head && (head < sizeof(int) || chunk->map[i - 1] > 0)) {
|
|
|
|
if (chunk->map[i - 1] > 0)
|
|
|
|
chunk->map[i - 1] += head;
|
|
|
|
else {
|
|
|
|
chunk->map[i - 1] -= head;
|
|
|
|
chunk->free_size -= head;
|
|
|
|
}
|
|
|
|
chunk->map[i] -= head;
|
|
|
|
off += head;
|
|
|
|
head = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if tail is small, just keep it around */
|
|
|
|
tail = chunk->map[i] - head - size;
|
|
|
|
if (tail < sizeof(int))
|
|
|
|
tail = 0;
|
|
|
|
|
|
|
|
/* split if warranted */
|
|
|
|
if (head || tail) {
|
2009-03-06 16:44:09 +01:00
|
|
|
pcpu_split_block(chunk, i, head, tail);
|
2009-02-20 08:29:08 +01:00
|
|
|
if (head) {
|
|
|
|
i++;
|
|
|
|
off += head;
|
|
|
|
max_contig = max(chunk->map[i - 1], max_contig);
|
|
|
|
}
|
|
|
|
if (tail)
|
|
|
|
max_contig = max(chunk->map[i + 1], max_contig);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* update hint and mark allocated */
|
|
|
|
if (is_last)
|
|
|
|
chunk->contig_hint = max_contig; /* fully scanned */
|
|
|
|
else
|
|
|
|
chunk->contig_hint = max(chunk->contig_hint,
|
|
|
|
max_contig);
|
|
|
|
|
|
|
|
chunk->free_size -= chunk->map[i];
|
|
|
|
chunk->map[i] = -chunk->map[i];
|
|
|
|
|
|
|
|
pcpu_chunk_relocate(chunk, oslot);
|
|
|
|
return off;
|
|
|
|
}
|
|
|
|
|
|
|
|
chunk->contig_hint = max_contig; /* fully scanned */
|
|
|
|
pcpu_chunk_relocate(chunk, oslot);
|
|
|
|
|
2009-03-06 16:44:09 +01:00
|
|
|
/* tell the upper layer that this chunk has no matching area */
|
|
|
|
return -1;
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pcpu_free_area - free area to a pcpu_chunk
|
|
|
|
* @chunk: chunk of interest
|
|
|
|
* @freeme: offset of area to free
|
|
|
|
*
|
|
|
|
* Free area starting from @freeme to @chunk. Note that this function
|
|
|
|
* only modifies the allocation map. It doesn't depopulate or unmap
|
|
|
|
* the area.
|
2009-03-06 16:44:13 +01:00
|
|
|
*
|
|
|
|
* CONTEXT:
|
|
|
|
* pcpu_lock.
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
|
|
|
static void pcpu_free_area(struct pcpu_chunk *chunk, int freeme)
|
|
|
|
{
|
|
|
|
int oslot = pcpu_chunk_slot(chunk);
|
|
|
|
int i, off;
|
|
|
|
|
|
|
|
for (i = 0, off = 0; i < chunk->map_used; off += abs(chunk->map[i++]))
|
|
|
|
if (off == freeme)
|
|
|
|
break;
|
|
|
|
BUG_ON(off != freeme);
|
|
|
|
BUG_ON(chunk->map[i] > 0);
|
|
|
|
|
|
|
|
chunk->map[i] = -chunk->map[i];
|
|
|
|
chunk->free_size += chunk->map[i];
|
|
|
|
|
|
|
|
/* merge with previous? */
|
|
|
|
if (i > 0 && chunk->map[i - 1] >= 0) {
|
|
|
|
chunk->map[i - 1] += chunk->map[i];
|
|
|
|
chunk->map_used--;
|
|
|
|
memmove(&chunk->map[i], &chunk->map[i + 1],
|
|
|
|
(chunk->map_used - i) * sizeof(chunk->map[0]));
|
|
|
|
i--;
|
|
|
|
}
|
|
|
|
/* merge with next? */
|
|
|
|
if (i + 1 < chunk->map_used && chunk->map[i + 1] >= 0) {
|
|
|
|
chunk->map[i] += chunk->map[i + 1];
|
|
|
|
chunk->map_used--;
|
|
|
|
memmove(&chunk->map[i + 1], &chunk->map[i + 2],
|
|
|
|
(chunk->map_used - (i + 1)) * sizeof(chunk->map[0]));
|
|
|
|
}
|
|
|
|
|
|
|
|
chunk->contig_hint = max(chunk->map[i], chunk->contig_hint);
|
|
|
|
pcpu_chunk_relocate(chunk, oslot);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-07-04 01:11:00 +02:00
|
|
|
* pcpu_get_pages_and_bitmap - get temp pages array and bitmap
|
2009-02-20 08:29:08 +01:00
|
|
|
* @chunk: chunk of interest
|
2009-07-04 01:11:00 +02:00
|
|
|
* @bitmapp: output parameter for bitmap
|
|
|
|
* @may_alloc: may allocate the array
|
2009-02-20 08:29:08 +01:00
|
|
|
*
|
2009-07-04 01:11:00 +02:00
|
|
|
* Returns pointer to array of pointers to struct page and bitmap,
|
|
|
|
* both of which can be indexed with pcpu_page_idx(). The returned
|
|
|
|
* array is cleared to zero and *@bitmapp is copied from
|
|
|
|
* @chunk->populated. Note that there is only one array and bitmap
|
|
|
|
* and access exclusion is the caller's responsibility.
|
|
|
|
*
|
|
|
|
* CONTEXT:
|
|
|
|
* pcpu_alloc_mutex and does GFP_KERNEL allocation if @may_alloc.
|
|
|
|
* Otherwise, don't care.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
* Pointer to temp pages array on success, NULL on failure.
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
2009-07-04 01:11:00 +02:00
|
|
|
static struct page **pcpu_get_pages_and_bitmap(struct pcpu_chunk *chunk,
|
|
|
|
unsigned long **bitmapp,
|
|
|
|
bool may_alloc)
|
2009-02-20 08:29:08 +01:00
|
|
|
{
|
2009-07-04 01:11:00 +02:00
|
|
|
static struct page **pages;
|
|
|
|
static unsigned long *bitmap;
|
2009-07-04 01:11:00 +02:00
|
|
|
size_t pages_size = pcpu_nr_units * pcpu_unit_pages * sizeof(pages[0]);
|
2009-07-04 01:11:00 +02:00
|
|
|
size_t bitmap_size = BITS_TO_LONGS(pcpu_unit_pages) *
|
|
|
|
sizeof(unsigned long);
|
|
|
|
|
|
|
|
if (!pages || !bitmap) {
|
|
|
|
if (may_alloc && !pages)
|
|
|
|
pages = pcpu_mem_alloc(pages_size);
|
|
|
|
if (may_alloc && !bitmap)
|
|
|
|
bitmap = pcpu_mem_alloc(bitmap_size);
|
|
|
|
if (!pages || !bitmap)
|
|
|
|
return NULL;
|
|
|
|
}
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
memset(pages, 0, pages_size);
|
|
|
|
bitmap_copy(bitmap, chunk->populated, pcpu_unit_pages);
|
2009-02-24 03:57:21 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
*bitmapp = bitmap;
|
|
|
|
return pages;
|
|
|
|
}
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/**
|
|
|
|
* pcpu_free_pages - free pages which were allocated for @chunk
|
|
|
|
* @chunk: chunk pages were allocated for
|
|
|
|
* @pages: array of pages to be freed, indexed by pcpu_page_idx()
|
|
|
|
* @populated: populated bitmap
|
|
|
|
* @page_start: page index of the first page to be freed
|
|
|
|
* @page_end: page index of the last page to be freed + 1
|
|
|
|
*
|
|
|
|
* Free pages [@page_start and @page_end) in @pages for all units.
|
|
|
|
* The pages were allocated for @chunk.
|
|
|
|
*/
|
|
|
|
static void pcpu_free_pages(struct pcpu_chunk *chunk,
|
|
|
|
struct page **pages, unsigned long *populated,
|
|
|
|
int page_start, int page_end)
|
|
|
|
{
|
|
|
|
unsigned int cpu;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
for (i = page_start; i < page_end; i++) {
|
|
|
|
struct page *page = pages[pcpu_page_idx(cpu, i)];
|
|
|
|
|
|
|
|
if (page)
|
|
|
|
__free_page(page);
|
|
|
|
}
|
|
|
|
}
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-07-04 01:11:00 +02:00
|
|
|
* pcpu_alloc_pages - allocates pages for @chunk
|
|
|
|
* @chunk: target chunk
|
|
|
|
* @pages: array to put the allocated pages into, indexed by pcpu_page_idx()
|
|
|
|
* @populated: populated bitmap
|
|
|
|
* @page_start: page index of the first page to be allocated
|
|
|
|
* @page_end: page index of the last page to be allocated + 1
|
|
|
|
*
|
|
|
|
* Allocate pages [@page_start,@page_end) into @pages for all units.
|
|
|
|
* The allocation is for @chunk. Percpu core doesn't care about the
|
|
|
|
* content of @pages and will pass it verbatim to pcpu_map_pages().
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
2009-07-04 01:11:00 +02:00
|
|
|
static int pcpu_alloc_pages(struct pcpu_chunk *chunk,
|
|
|
|
struct page **pages, unsigned long *populated,
|
|
|
|
int page_start, int page_end)
|
2009-02-20 08:29:08 +01:00
|
|
|
{
|
2009-07-04 01:11:00 +02:00
|
|
|
const gfp_t gfp = GFP_KERNEL | __GFP_HIGHMEM | __GFP_COLD;
|
2009-02-20 08:29:08 +01:00
|
|
|
unsigned int cpu;
|
|
|
|
int i;
|
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
for (i = page_start; i < page_end; i++) {
|
|
|
|
struct page **pagep = &pages[pcpu_page_idx(cpu, i)];
|
|
|
|
|
|
|
|
*pagep = alloc_pages_node(cpu_to_node(cpu), gfp, 0);
|
|
|
|
if (!*pagep) {
|
|
|
|
pcpu_free_pages(chunk, pages, populated,
|
|
|
|
page_start, page_end);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/**
|
|
|
|
* pcpu_pre_unmap_flush - flush cache prior to unmapping
|
|
|
|
* @chunk: chunk the regions to be flushed belongs to
|
|
|
|
* @page_start: page index of the first page to be flushed
|
|
|
|
* @page_end: page index of the last page to be flushed + 1
|
|
|
|
*
|
|
|
|
* Pages in [@page_start,@page_end) of @chunk are about to be
|
|
|
|
* unmapped. Flush cache. As each flushing trial can be very
|
|
|
|
* expensive, issue flush on the whole region at once rather than
|
|
|
|
* doing it for each cpu. This could be an overkill but is more
|
|
|
|
* scalable.
|
|
|
|
*/
|
|
|
|
static void pcpu_pre_unmap_flush(struct pcpu_chunk *chunk,
|
|
|
|
int page_start, int page_end)
|
|
|
|
{
|
2009-07-04 01:11:00 +02:00
|
|
|
flush_cache_vunmap(
|
|
|
|
pcpu_chunk_addr(chunk, pcpu_first_unit_cpu, page_start),
|
|
|
|
pcpu_chunk_addr(chunk, pcpu_last_unit_cpu, page_end));
|
2009-07-04 01:11:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __pcpu_unmap_pages(unsigned long addr, int nr_pages)
|
|
|
|
{
|
|
|
|
unmap_kernel_range_noflush(addr, nr_pages << PAGE_SHIFT);
|
|
|
|
}
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/**
|
|
|
|
* pcpu_unmap_pages - unmap pages out of a pcpu_chunk
|
2009-02-20 08:29:08 +01:00
|
|
|
* @chunk: chunk of interest
|
2009-07-04 01:11:00 +02:00
|
|
|
* @pages: pages array which can be used to pass information to free
|
|
|
|
* @populated: populated bitmap
|
2009-02-20 08:29:08 +01:00
|
|
|
* @page_start: page index of the first page to unmap
|
|
|
|
* @page_end: page index of the last page to unmap + 1
|
|
|
|
*
|
|
|
|
* For each cpu, unmap pages [@page_start,@page_end) out of @chunk.
|
2009-07-04 01:11:00 +02:00
|
|
|
* Corresponding elements in @pages were cleared by the caller and can
|
|
|
|
* be used to carry information to pcpu_free_pages() which will be
|
|
|
|
* called after all unmaps are finished. The caller should call
|
|
|
|
* proper pre/post flush functions.
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
2009-07-04 01:11:00 +02:00
|
|
|
static void pcpu_unmap_pages(struct pcpu_chunk *chunk,
|
|
|
|
struct page **pages, unsigned long *populated,
|
|
|
|
int page_start, int page_end)
|
2009-02-20 08:29:08 +01:00
|
|
|
{
|
|
|
|
unsigned int cpu;
|
2009-07-04 01:11:00 +02:00
|
|
|
int i;
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
for (i = page_start; i < page_end; i++) {
|
|
|
|
struct page *page;
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
page = pcpu_chunk_page(chunk, cpu, i);
|
|
|
|
WARN_ON(!page);
|
|
|
|
pages[pcpu_page_idx(cpu, i)] = page;
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
2009-07-04 01:11:00 +02:00
|
|
|
__pcpu_unmap_pages(pcpu_chunk_addr(chunk, cpu, page_start),
|
|
|
|
page_end - page_start);
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
for (i = page_start; i < page_end; i++)
|
|
|
|
__clear_bit(i, populated);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pcpu_post_unmap_tlb_flush - flush TLB after unmapping
|
|
|
|
* @chunk: pcpu_chunk the regions to be flushed belong to
|
|
|
|
* @page_start: page index of the first page to be flushed
|
|
|
|
* @page_end: page index of the last page to be flushed + 1
|
|
|
|
*
|
|
|
|
* Pages [@page_start,@page_end) of @chunk have been unmapped. Flush
|
|
|
|
* TLB for the regions. This can be skipped if the area is to be
|
|
|
|
* returned to vmalloc as vmalloc will handle TLB flushing lazily.
|
|
|
|
*
|
|
|
|
* As with pcpu_pre_unmap_flush(), TLB flushing also is done at once
|
|
|
|
* for the whole region.
|
|
|
|
*/
|
|
|
|
static void pcpu_post_unmap_tlb_flush(struct pcpu_chunk *chunk,
|
|
|
|
int page_start, int page_end)
|
|
|
|
{
|
2009-07-04 01:11:00 +02:00
|
|
|
flush_tlb_kernel_range(
|
|
|
|
pcpu_chunk_addr(chunk, pcpu_first_unit_cpu, page_start),
|
|
|
|
pcpu_chunk_addr(chunk, pcpu_last_unit_cpu, page_end));
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
2009-07-04 01:10:59 +02:00
|
|
|
static int __pcpu_map_pages(unsigned long addr, struct page **pages,
|
|
|
|
int nr_pages)
|
|
|
|
{
|
|
|
|
return map_kernel_range_noflush(addr, nr_pages << PAGE_SHIFT,
|
|
|
|
PAGE_KERNEL, pages);
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-07-04 01:11:00 +02:00
|
|
|
* pcpu_map_pages - map pages into a pcpu_chunk
|
2009-02-20 08:29:08 +01:00
|
|
|
* @chunk: chunk of interest
|
2009-07-04 01:11:00 +02:00
|
|
|
* @pages: pages array containing pages to be mapped
|
|
|
|
* @populated: populated bitmap
|
2009-02-20 08:29:08 +01:00
|
|
|
* @page_start: page index of the first page to map
|
|
|
|
* @page_end: page index of the last page to map + 1
|
|
|
|
*
|
2009-07-04 01:11:00 +02:00
|
|
|
* For each cpu, map pages [@page_start,@page_end) into @chunk. The
|
|
|
|
* caller is responsible for calling pcpu_post_map_flush() after all
|
|
|
|
* mappings are complete.
|
|
|
|
*
|
|
|
|
* This function is responsible for setting corresponding bits in
|
|
|
|
* @chunk->populated bitmap and whatever is necessary for reverse
|
|
|
|
* lookup (addr -> chunk).
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
2009-07-04 01:11:00 +02:00
|
|
|
static int pcpu_map_pages(struct pcpu_chunk *chunk,
|
|
|
|
struct page **pages, unsigned long *populated,
|
|
|
|
int page_start, int page_end)
|
2009-02-20 08:29:08 +01:00
|
|
|
{
|
2009-07-04 01:11:00 +02:00
|
|
|
unsigned int cpu, tcpu;
|
|
|
|
int i, err;
|
2009-02-24 03:57:21 +01:00
|
|
|
|
2009-02-20 08:29:08 +01:00
|
|
|
for_each_possible_cpu(cpu) {
|
2009-07-04 01:10:59 +02:00
|
|
|
err = __pcpu_map_pages(pcpu_chunk_addr(chunk, cpu, page_start),
|
2009-07-04 01:11:00 +02:00
|
|
|
&pages[pcpu_page_idx(cpu, page_start)],
|
2009-07-04 01:10:59 +02:00
|
|
|
page_end - page_start);
|
2009-02-20 08:29:08 +01:00
|
|
|
if (err < 0)
|
2009-07-04 01:11:00 +02:00
|
|
|
goto err;
|
2009-07-04 01:10:59 +02:00
|
|
|
}
|
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/* mapping successful, link chunk and mark populated */
|
|
|
|
for (i = page_start; i < page_end; i++) {
|
|
|
|
for_each_possible_cpu(cpu)
|
|
|
|
pcpu_set_page_chunk(pages[pcpu_page_idx(cpu, i)],
|
|
|
|
chunk);
|
|
|
|
__set_bit(i, populated);
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2009-07-04 01:11:00 +02:00
|
|
|
|
|
|
|
err:
|
|
|
|
for_each_possible_cpu(tcpu) {
|
|
|
|
if (tcpu == cpu)
|
|
|
|
break;
|
|
|
|
__pcpu_unmap_pages(pcpu_chunk_addr(chunk, tcpu, page_start),
|
|
|
|
page_end - page_start);
|
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pcpu_post_map_flush - flush cache after mapping
|
|
|
|
* @chunk: pcpu_chunk the regions to be flushed belong to
|
|
|
|
* @page_start: page index of the first page to be flushed
|
|
|
|
* @page_end: page index of the last page to be flushed + 1
|
|
|
|
*
|
|
|
|
* Pages [@page_start,@page_end) of @chunk have been mapped. Flush
|
|
|
|
* cache.
|
|
|
|
*
|
|
|
|
* As with pcpu_pre_unmap_flush(), TLB flushing also is done at once
|
|
|
|
* for the whole region.
|
|
|
|
*/
|
|
|
|
static void pcpu_post_map_flush(struct pcpu_chunk *chunk,
|
|
|
|
int page_start, int page_end)
|
|
|
|
{
|
2009-07-04 01:11:00 +02:00
|
|
|
flush_cache_vmap(
|
|
|
|
pcpu_chunk_addr(chunk, pcpu_first_unit_cpu, page_start),
|
|
|
|
pcpu_chunk_addr(chunk, pcpu_last_unit_cpu, page_end));
|
2009-07-04 01:10:59 +02:00
|
|
|
}
|
|
|
|
|
2009-02-20 08:29:08 +01:00
|
|
|
/**
|
|
|
|
* pcpu_depopulate_chunk - depopulate and unmap an area of a pcpu_chunk
|
|
|
|
* @chunk: chunk to depopulate
|
|
|
|
* @off: offset to the area to depopulate
|
2009-02-21 08:56:23 +01:00
|
|
|
* @size: size of the area to depopulate in bytes
|
2009-02-20 08:29:08 +01:00
|
|
|
* @flush: whether to flush cache and tlb or not
|
|
|
|
*
|
|
|
|
* For each cpu, depopulate and unmap pages [@page_start,@page_end)
|
|
|
|
* from @chunk. If @flush is true, vcache is flushed before unmapping
|
|
|
|
* and tlb after.
|
2009-03-06 16:44:13 +01:00
|
|
|
*
|
|
|
|
* CONTEXT:
|
|
|
|
* pcpu_alloc_mutex.
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
2009-07-04 01:11:00 +02:00
|
|
|
static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk, int off, int size)
|
2009-02-20 08:29:08 +01:00
|
|
|
{
|
|
|
|
int page_start = PFN_DOWN(off);
|
|
|
|
int page_end = PFN_UP(off + size);
|
2009-07-04 01:11:00 +02:00
|
|
|
struct page **pages;
|
|
|
|
unsigned long *populated;
|
|
|
|
int rs, re;
|
|
|
|
|
|
|
|
/* quick path, check whether it's empty already */
|
|
|
|
pcpu_for_each_unpop_region(chunk, rs, re, page_start, page_end) {
|
|
|
|
if (rs == page_start && re == page_end)
|
|
|
|
return;
|
|
|
|
break;
|
|
|
|
}
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/* immutable chunks can't be depopulated */
|
|
|
|
WARN_ON(chunk->immutable);
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/*
|
|
|
|
* If control reaches here, there must have been at least one
|
|
|
|
* successful population attempt so the temp pages array must
|
|
|
|
* be available now.
|
|
|
|
*/
|
|
|
|
pages = pcpu_get_pages_and_bitmap(chunk, &populated, false);
|
|
|
|
BUG_ON(!pages);
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/* unmap and free */
|
|
|
|
pcpu_pre_unmap_flush(chunk, page_start, page_end);
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
pcpu_for_each_pop_region(chunk, rs, re, page_start, page_end)
|
|
|
|
pcpu_unmap_pages(chunk, pages, populated, rs, re);
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/* no need to flush tlb, vmalloc will handle it lazily */
|
|
|
|
|
|
|
|
pcpu_for_each_pop_region(chunk, rs, re, page_start, page_end)
|
|
|
|
pcpu_free_pages(chunk, pages, populated, rs, re);
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/* commit new bitmap */
|
|
|
|
bitmap_copy(chunk->populated, populated, pcpu_unit_pages);
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pcpu_populate_chunk - populate and map an area of a pcpu_chunk
|
|
|
|
* @chunk: chunk of interest
|
|
|
|
* @off: offset to the area to populate
|
2009-02-21 08:56:23 +01:00
|
|
|
* @size: size of the area to populate in bytes
|
2009-02-20 08:29:08 +01:00
|
|
|
*
|
|
|
|
* For each cpu, populate and map pages [@page_start,@page_end) into
|
|
|
|
* @chunk. The area is cleared on return.
|
2009-03-06 16:44:13 +01:00
|
|
|
*
|
|
|
|
* CONTEXT:
|
|
|
|
* pcpu_alloc_mutex, does GFP_KERNEL allocation.
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
|
|
|
static int pcpu_populate_chunk(struct pcpu_chunk *chunk, int off, int size)
|
|
|
|
{
|
|
|
|
int page_start = PFN_DOWN(off);
|
|
|
|
int page_end = PFN_UP(off + size);
|
2009-07-04 01:11:00 +02:00
|
|
|
int free_end = page_start, unmap_end = page_start;
|
|
|
|
struct page **pages;
|
|
|
|
unsigned long *populated;
|
2009-02-20 08:29:08 +01:00
|
|
|
unsigned int cpu;
|
2009-07-04 01:11:00 +02:00
|
|
|
int rs, re, rc;
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/* quick path, check whether all pages are already there */
|
|
|
|
pcpu_for_each_pop_region(chunk, rs, re, page_start, page_end) {
|
|
|
|
if (rs == page_start && re == page_end)
|
|
|
|
goto clear;
|
|
|
|
break;
|
|
|
|
}
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/* need to allocate and map pages, this chunk can't be immutable */
|
|
|
|
WARN_ON(chunk->immutable);
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
pages = pcpu_get_pages_and_bitmap(chunk, &populated, true);
|
|
|
|
if (!pages)
|
|
|
|
return -ENOMEM;
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/* alloc and map */
|
|
|
|
pcpu_for_each_unpop_region(chunk, rs, re, page_start, page_end) {
|
|
|
|
rc = pcpu_alloc_pages(chunk, pages, populated, rs, re);
|
|
|
|
if (rc)
|
|
|
|
goto err_free;
|
|
|
|
free_end = re;
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
pcpu_for_each_unpop_region(chunk, rs, re, page_start, page_end) {
|
|
|
|
rc = pcpu_map_pages(chunk, pages, populated, rs, re);
|
|
|
|
if (rc)
|
|
|
|
goto err_unmap;
|
|
|
|
unmap_end = re;
|
|
|
|
}
|
|
|
|
pcpu_post_map_flush(chunk, page_start, page_end);
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/* commit new bitmap */
|
|
|
|
bitmap_copy(chunk->populated, populated, pcpu_unit_pages);
|
|
|
|
clear:
|
2009-02-20 08:29:08 +01:00
|
|
|
for_each_possible_cpu(cpu)
|
2009-07-04 01:11:00 +02:00
|
|
|
memset((void *)pcpu_chunk_addr(chunk, cpu, 0) + off, 0, size);
|
2009-02-20 08:29:08 +01:00
|
|
|
return 0;
|
2009-07-04 01:11:00 +02:00
|
|
|
|
|
|
|
err_unmap:
|
|
|
|
pcpu_pre_unmap_flush(chunk, page_start, unmap_end);
|
|
|
|
pcpu_for_each_unpop_region(chunk, rs, re, page_start, unmap_end)
|
|
|
|
pcpu_unmap_pages(chunk, pages, populated, rs, re);
|
|
|
|
pcpu_post_unmap_tlb_flush(chunk, page_start, unmap_end);
|
|
|
|
err_free:
|
|
|
|
pcpu_for_each_unpop_region(chunk, rs, re, page_start, free_end)
|
|
|
|
pcpu_free_pages(chunk, pages, populated, rs, re);
|
|
|
|
return rc;
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void free_pcpu_chunk(struct pcpu_chunk *chunk)
|
|
|
|
{
|
|
|
|
if (!chunk)
|
|
|
|
return;
|
2009-08-14 08:00:52 +02:00
|
|
|
if (chunk->vms)
|
|
|
|
pcpu_free_vm_areas(chunk->vms, pcpu_nr_groups);
|
2009-03-06 16:44:09 +01:00
|
|
|
pcpu_mem_free(chunk->map, chunk->map_alloc * sizeof(chunk->map[0]));
|
2009-02-20 08:29:08 +01:00
|
|
|
kfree(chunk);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct pcpu_chunk *alloc_pcpu_chunk(void)
|
|
|
|
{
|
|
|
|
struct pcpu_chunk *chunk;
|
|
|
|
|
|
|
|
chunk = kzalloc(pcpu_chunk_struct_size, GFP_KERNEL);
|
|
|
|
if (!chunk)
|
|
|
|
return NULL;
|
|
|
|
|
2009-03-06 16:44:09 +01:00
|
|
|
chunk->map = pcpu_mem_alloc(PCPU_DFL_MAP_ALLOC * sizeof(chunk->map[0]));
|
2009-02-20 08:29:08 +01:00
|
|
|
chunk->map_alloc = PCPU_DFL_MAP_ALLOC;
|
|
|
|
chunk->map[chunk->map_used++] = pcpu_unit_size;
|
|
|
|
|
2009-08-14 08:00:52 +02:00
|
|
|
chunk->vms = pcpu_get_vm_areas(pcpu_group_offsets, pcpu_group_sizes,
|
|
|
|
pcpu_nr_groups, pcpu_atom_size,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!chunk->vms) {
|
2009-02-20 08:29:08 +01:00
|
|
|
free_pcpu_chunk(chunk);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&chunk->list);
|
|
|
|
chunk->free_size = pcpu_unit_size;
|
|
|
|
chunk->contig_hint = pcpu_unit_size;
|
2009-08-14 08:00:52 +02:00
|
|
|
chunk->base_addr = chunk->vms[0]->addr - pcpu_group_offsets[0];
|
2009-02-20 08:29:08 +01:00
|
|
|
|
|
|
|
return chunk;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2009-03-06 06:33:59 +01:00
|
|
|
* pcpu_alloc - the percpu allocator
|
2009-02-21 08:56:23 +01:00
|
|
|
* @size: size of area to allocate in bytes
|
2009-02-20 08:29:08 +01:00
|
|
|
* @align: alignment of area (max PAGE_SIZE)
|
2009-03-06 06:33:59 +01:00
|
|
|
* @reserved: allocate from the reserved chunk if available
|
2009-02-20 08:29:08 +01:00
|
|
|
*
|
2009-03-06 16:44:13 +01:00
|
|
|
* Allocate percpu area of @size bytes aligned at @align.
|
|
|
|
*
|
|
|
|
* CONTEXT:
|
|
|
|
* Does GFP_KERNEL allocation.
|
2009-02-20 08:29:08 +01:00
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
* Percpu pointer to the allocated area on success, NULL on failure.
|
|
|
|
*/
|
2009-03-06 06:33:59 +01:00
|
|
|
static void *pcpu_alloc(size_t size, size_t align, bool reserved)
|
2009-02-20 08:29:08 +01:00
|
|
|
{
|
|
|
|
struct pcpu_chunk *chunk;
|
|
|
|
int slot, off;
|
|
|
|
|
2009-02-24 03:57:21 +01:00
|
|
|
if (unlikely(!size || size > PCPU_MIN_UNIT_SIZE || align > PAGE_SIZE)) {
|
2009-02-20 08:29:08 +01:00
|
|
|
WARN(true, "illegal size (%zu) or align (%zu) for "
|
|
|
|
"percpu allocation\n", size, align);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-03-06 16:44:13 +01:00
|
|
|
mutex_lock(&pcpu_alloc_mutex);
|
|
|
|
spin_lock_irq(&pcpu_lock);
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-03-06 06:33:59 +01:00
|
|
|
/* serve reserved allocations from the reserved chunk if available */
|
|
|
|
if (reserved && pcpu_reserved_chunk) {
|
|
|
|
chunk = pcpu_reserved_chunk;
|
2009-03-06 16:44:09 +01:00
|
|
|
if (size > chunk->contig_hint ||
|
|
|
|
pcpu_extend_area_map(chunk) < 0)
|
2009-03-06 16:44:13 +01:00
|
|
|
goto fail_unlock;
|
2009-03-06 06:33:59 +01:00
|
|
|
off = pcpu_alloc_area(chunk, size, align);
|
|
|
|
if (off >= 0)
|
|
|
|
goto area_found;
|
2009-03-06 16:44:13 +01:00
|
|
|
goto fail_unlock;
|
2009-03-06 06:33:59 +01:00
|
|
|
}
|
|
|
|
|
2009-03-06 16:44:13 +01:00
|
|
|
restart:
|
2009-03-06 06:33:59 +01:00
|
|
|
/* search through normal chunks */
|
2009-02-20 08:29:08 +01:00
|
|
|
for (slot = pcpu_size_to_slot(size); slot < pcpu_nr_slots; slot++) {
|
|
|
|
list_for_each_entry(chunk, &pcpu_slot[slot], list) {
|
|
|
|
if (size > chunk->contig_hint)
|
|
|
|
continue;
|
2009-03-06 16:44:13 +01:00
|
|
|
|
|
|
|
switch (pcpu_extend_area_map(chunk)) {
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
goto restart; /* pcpu_lock dropped, restart */
|
|
|
|
default:
|
|
|
|
goto fail_unlock;
|
|
|
|
}
|
|
|
|
|
2009-02-20 08:29:08 +01:00
|
|
|
off = pcpu_alloc_area(chunk, size, align);
|
|
|
|
if (off >= 0)
|
|
|
|
goto area_found;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* hmmm... no space left, create a new chunk */
|
2009-03-06 16:44:13 +01:00
|
|
|
spin_unlock_irq(&pcpu_lock);
|
|
|
|
|
2009-02-20 08:29:08 +01:00
|
|
|
chunk = alloc_pcpu_chunk();
|
|
|
|
if (!chunk)
|
2009-03-06 16:44:13 +01:00
|
|
|
goto fail_unlock_mutex;
|
|
|
|
|
|
|
|
spin_lock_irq(&pcpu_lock);
|
2009-02-20 08:29:08 +01:00
|
|
|
pcpu_chunk_relocate(chunk, -1);
|
2009-03-06 16:44:13 +01:00
|
|
|
goto restart;
|
2009-02-20 08:29:08 +01:00
|
|
|
|
|
|
|
area_found:
|
2009-03-06 16:44:13 +01:00
|
|
|
spin_unlock_irq(&pcpu_lock);
|
|
|
|
|
2009-02-20 08:29:08 +01:00
|
|
|
/* populate, map and clear the area */
|
|
|
|
if (pcpu_populate_chunk(chunk, off, size)) {
|
2009-03-06 16:44:13 +01:00
|
|
|
spin_lock_irq(&pcpu_lock);
|
2009-02-20 08:29:08 +01:00
|
|
|
pcpu_free_area(chunk, off);
|
2009-03-06 16:44:13 +01:00
|
|
|
goto fail_unlock;
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
2009-03-06 16:44:13 +01:00
|
|
|
mutex_unlock(&pcpu_alloc_mutex);
|
|
|
|
|
2009-08-14 08:00:51 +02:00
|
|
|
/* return address relative to base address */
|
|
|
|
return __addr_to_pcpu_ptr(chunk->base_addr + off);
|
2009-03-06 16:44:13 +01:00
|
|
|
|
|
|
|
fail_unlock:
|
|
|
|
spin_unlock_irq(&pcpu_lock);
|
|
|
|
fail_unlock_mutex:
|
|
|
|
mutex_unlock(&pcpu_alloc_mutex);
|
|
|
|
return NULL;
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
2009-03-06 06:33:59 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* __alloc_percpu - allocate dynamic percpu area
|
|
|
|
* @size: size of area to allocate in bytes
|
|
|
|
* @align: alignment of area (max PAGE_SIZE)
|
|
|
|
*
|
|
|
|
* Allocate percpu area of @size bytes aligned at @align. Might
|
|
|
|
* sleep. Might trigger writeouts.
|
|
|
|
*
|
2009-03-06 16:44:13 +01:00
|
|
|
* CONTEXT:
|
|
|
|
* Does GFP_KERNEL allocation.
|
|
|
|
*
|
2009-03-06 06:33:59 +01:00
|
|
|
* RETURNS:
|
|
|
|
* Percpu pointer to the allocated area on success, NULL on failure.
|
|
|
|
*/
|
|
|
|
void *__alloc_percpu(size_t size, size_t align)
|
|
|
|
{
|
|
|
|
return pcpu_alloc(size, align, false);
|
|
|
|
}
|
2009-02-20 08:29:08 +01:00
|
|
|
EXPORT_SYMBOL_GPL(__alloc_percpu);
|
|
|
|
|
2009-03-06 06:33:59 +01:00
|
|
|
/**
|
|
|
|
* __alloc_reserved_percpu - allocate reserved percpu area
|
|
|
|
* @size: size of area to allocate in bytes
|
|
|
|
* @align: alignment of area (max PAGE_SIZE)
|
|
|
|
*
|
|
|
|
* Allocate percpu area of @size bytes aligned at @align from reserved
|
|
|
|
* percpu area if arch has set it up; otherwise, allocation is served
|
|
|
|
* from the same dynamic area. Might sleep. Might trigger writeouts.
|
|
|
|
*
|
2009-03-06 16:44:13 +01:00
|
|
|
* CONTEXT:
|
|
|
|
* Does GFP_KERNEL allocation.
|
|
|
|
*
|
2009-03-06 06:33:59 +01:00
|
|
|
* RETURNS:
|
|
|
|
* Percpu pointer to the allocated area on success, NULL on failure.
|
|
|
|
*/
|
|
|
|
void *__alloc_reserved_percpu(size_t size, size_t align)
|
|
|
|
{
|
|
|
|
return pcpu_alloc(size, align, true);
|
|
|
|
}
|
|
|
|
|
2009-03-06 16:44:11 +01:00
|
|
|
/**
|
|
|
|
* pcpu_reclaim - reclaim fully free chunks, workqueue function
|
|
|
|
* @work: unused
|
|
|
|
*
|
|
|
|
* Reclaim all fully free chunks except for the first one.
|
2009-03-06 16:44:13 +01:00
|
|
|
*
|
|
|
|
* CONTEXT:
|
|
|
|
* workqueue context.
|
2009-03-06 16:44:11 +01:00
|
|
|
*/
|
|
|
|
static void pcpu_reclaim(struct work_struct *work)
|
2009-02-20 08:29:08 +01:00
|
|
|
{
|
2009-03-06 16:44:11 +01:00
|
|
|
LIST_HEAD(todo);
|
|
|
|
struct list_head *head = &pcpu_slot[pcpu_nr_slots - 1];
|
|
|
|
struct pcpu_chunk *chunk, *next;
|
|
|
|
|
2009-03-06 16:44:13 +01:00
|
|
|
mutex_lock(&pcpu_alloc_mutex);
|
|
|
|
spin_lock_irq(&pcpu_lock);
|
2009-03-06 16:44:11 +01:00
|
|
|
|
|
|
|
list_for_each_entry_safe(chunk, next, head, list) {
|
|
|
|
WARN_ON(chunk->immutable);
|
|
|
|
|
|
|
|
/* spare the first one */
|
|
|
|
if (chunk == list_first_entry(head, struct pcpu_chunk, list))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
list_move(&chunk->list, &todo);
|
|
|
|
}
|
|
|
|
|
2009-03-06 16:44:13 +01:00
|
|
|
spin_unlock_irq(&pcpu_lock);
|
2009-03-06 16:44:11 +01:00
|
|
|
|
|
|
|
list_for_each_entry_safe(chunk, next, &todo, list) {
|
2009-07-04 01:11:00 +02:00
|
|
|
pcpu_depopulate_chunk(chunk, 0, pcpu_unit_size);
|
2009-03-06 16:44:11 +01:00
|
|
|
free_pcpu_chunk(chunk);
|
|
|
|
}
|
2009-08-14 08:00:49 +02:00
|
|
|
|
|
|
|
mutex_unlock(&pcpu_alloc_mutex);
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* free_percpu - free percpu area
|
|
|
|
* @ptr: pointer to area to free
|
|
|
|
*
|
2009-03-06 16:44:13 +01:00
|
|
|
* Free percpu area @ptr.
|
|
|
|
*
|
|
|
|
* CONTEXT:
|
|
|
|
* Can be called from atomic context.
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
|
|
|
void free_percpu(void *ptr)
|
|
|
|
{
|
|
|
|
void *addr = __pcpu_ptr_to_addr(ptr);
|
|
|
|
struct pcpu_chunk *chunk;
|
2009-03-06 16:44:13 +01:00
|
|
|
unsigned long flags;
|
2009-02-20 08:29:08 +01:00
|
|
|
int off;
|
|
|
|
|
|
|
|
if (!ptr)
|
|
|
|
return;
|
|
|
|
|
2009-03-06 16:44:13 +01:00
|
|
|
spin_lock_irqsave(&pcpu_lock, flags);
|
2009-02-20 08:29:08 +01:00
|
|
|
|
|
|
|
chunk = pcpu_chunk_addr_search(addr);
|
2009-08-14 08:00:51 +02:00
|
|
|
off = addr - chunk->base_addr;
|
2009-02-20 08:29:08 +01:00
|
|
|
|
|
|
|
pcpu_free_area(chunk, off);
|
|
|
|
|
2009-03-06 16:44:11 +01:00
|
|
|
/* if there are more than one fully free chunks, wake up grim reaper */
|
2009-02-20 08:29:08 +01:00
|
|
|
if (chunk->free_size == pcpu_unit_size) {
|
|
|
|
struct pcpu_chunk *pos;
|
|
|
|
|
2009-03-06 16:44:11 +01:00
|
|
|
list_for_each_entry(pos, &pcpu_slot[pcpu_nr_slots - 1], list)
|
2009-02-20 08:29:08 +01:00
|
|
|
if (pos != chunk) {
|
2009-03-06 16:44:11 +01:00
|
|
|
schedule_work(&pcpu_reclaim_work);
|
2009-02-20 08:29:08 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-03-06 16:44:13 +01:00
|
|
|
spin_unlock_irqrestore(&pcpu_lock, flags);
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(free_percpu);
|
|
|
|
|
2009-08-14 08:00:51 +02:00
|
|
|
static inline size_t pcpu_calc_fc_sizes(size_t static_size,
|
|
|
|
size_t reserved_size,
|
|
|
|
ssize_t *dyn_sizep)
|
|
|
|
{
|
|
|
|
size_t size_sum;
|
|
|
|
|
|
|
|
size_sum = PFN_ALIGN(static_size + reserved_size +
|
|
|
|
(*dyn_sizep >= 0 ? *dyn_sizep : 0));
|
|
|
|
if (*dyn_sizep != 0)
|
|
|
|
*dyn_sizep = size_sum - static_size - reserved_size;
|
|
|
|
|
|
|
|
return size_sum;
|
|
|
|
}
|
|
|
|
|
2009-02-20 08:29:08 +01:00
|
|
|
/**
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
* pcpu_alloc_alloc_info - allocate percpu allocation info
|
|
|
|
* @nr_groups: the number of groups
|
|
|
|
* @nr_units: the number of units
|
|
|
|
*
|
|
|
|
* Allocate ai which is large enough for @nr_groups groups containing
|
|
|
|
* @nr_units units. The returned ai's groups[0].cpu_map points to the
|
|
|
|
* cpu_map array which is long enough for @nr_units and filled with
|
|
|
|
* NR_CPUS. It's the caller's responsibility to initialize cpu_map
|
|
|
|
* pointer of other groups.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
|
|
|
* Pointer to the allocated pcpu_alloc_info on success, NULL on
|
|
|
|
* failure.
|
|
|
|
*/
|
|
|
|
struct pcpu_alloc_info * __init pcpu_alloc_alloc_info(int nr_groups,
|
|
|
|
int nr_units)
|
|
|
|
{
|
|
|
|
struct pcpu_alloc_info *ai;
|
|
|
|
size_t base_size, ai_size;
|
|
|
|
void *ptr;
|
|
|
|
int unit;
|
|
|
|
|
|
|
|
base_size = ALIGN(sizeof(*ai) + nr_groups * sizeof(ai->groups[0]),
|
|
|
|
__alignof__(ai->groups[0].cpu_map[0]));
|
|
|
|
ai_size = base_size + nr_units * sizeof(ai->groups[0].cpu_map[0]);
|
|
|
|
|
|
|
|
ptr = alloc_bootmem_nopanic(PFN_ALIGN(ai_size));
|
|
|
|
if (!ptr)
|
|
|
|
return NULL;
|
|
|
|
ai = ptr;
|
|
|
|
ptr += base_size;
|
|
|
|
|
|
|
|
ai->groups[0].cpu_map = ptr;
|
|
|
|
|
|
|
|
for (unit = 0; unit < nr_units; unit++)
|
|
|
|
ai->groups[0].cpu_map[unit] = NR_CPUS;
|
|
|
|
|
|
|
|
ai->nr_groups = nr_groups;
|
|
|
|
ai->__ai_size = PFN_ALIGN(ai_size);
|
|
|
|
|
|
|
|
return ai;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pcpu_free_alloc_info - free percpu allocation info
|
|
|
|
* @ai: pcpu_alloc_info to free
|
|
|
|
*
|
|
|
|
* Free @ai which was allocated by pcpu_alloc_alloc_info().
|
|
|
|
*/
|
|
|
|
void __init pcpu_free_alloc_info(struct pcpu_alloc_info *ai)
|
|
|
|
{
|
|
|
|
free_bootmem(__pa(ai), ai->__ai_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pcpu_build_alloc_info - build alloc_info considering distances between CPUs
|
2009-03-06 06:33:59 +01:00
|
|
|
* @reserved_size: the size of reserved percpu area in bytes
|
2009-03-06 06:33:59 +01:00
|
|
|
* @dyn_size: free size for dynamic allocation in bytes, -1 for auto
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
* @atom_size: allocation atom size
|
|
|
|
* @cpu_distance_fn: callback to determine distance between cpus, optional
|
2009-08-14 08:00:51 +02:00
|
|
|
*
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
* This function determines grouping of units, their mappings to cpus
|
|
|
|
* and other parameters considering needed percpu size, allocation
|
|
|
|
* atom size and distances between CPUs.
|
2009-08-14 08:00:51 +02:00
|
|
|
*
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
* Groups are always mutliples of atom size and CPUs which are of
|
|
|
|
* LOCAL_DISTANCE both ways are grouped together and share space for
|
|
|
|
* units in the same group. The returned configuration is guaranteed
|
|
|
|
* to have CPUs on different nodes on different groups and >=75% usage
|
|
|
|
* of allocated virtual address space.
|
2009-08-14 08:00:51 +02:00
|
|
|
*
|
|
|
|
* RETURNS:
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
* On success, pointer to the new allocation_info is returned. On
|
|
|
|
* failure, ERR_PTR value is returned.
|
2009-08-14 08:00:51 +02:00
|
|
|
*/
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
struct pcpu_alloc_info * __init pcpu_build_alloc_info(
|
|
|
|
size_t reserved_size, ssize_t dyn_size,
|
|
|
|
size_t atom_size,
|
|
|
|
pcpu_fc_cpu_distance_fn_t cpu_distance_fn)
|
2009-08-14 08:00:51 +02:00
|
|
|
{
|
|
|
|
static int group_map[NR_CPUS] __initdata;
|
|
|
|
static int group_cnt[NR_CPUS] __initdata;
|
|
|
|
const size_t static_size = __per_cpu_end - __per_cpu_start;
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
int group_cnt_max = 0, nr_groups = 1, nr_units = 0;
|
2009-08-14 08:00:51 +02:00
|
|
|
size_t size_sum, min_unit_size, alloc_size;
|
|
|
|
int upa, max_upa, uninitialized_var(best_upa); /* units_per_alloc */
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
int last_allocs, group, unit;
|
2009-08-14 08:00:51 +02:00
|
|
|
unsigned int cpu, tcpu;
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
struct pcpu_alloc_info *ai;
|
|
|
|
unsigned int *cpu_map;
|
2009-08-14 08:00:51 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine min_unit_size, alloc_size and max_upa such that
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
* alloc_size is multiple of atom_size and is the smallest
|
2009-08-14 08:00:51 +02:00
|
|
|
* which can accomodate 4k aligned segments which are equal to
|
|
|
|
* or larger than min_unit_size.
|
|
|
|
*/
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
size_sum = pcpu_calc_fc_sizes(static_size, reserved_size, &dyn_size);
|
2009-08-14 08:00:51 +02:00
|
|
|
min_unit_size = max_t(size_t, size_sum, PCPU_MIN_UNIT_SIZE);
|
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
alloc_size = roundup(min_unit_size, atom_size);
|
2009-08-14 08:00:51 +02:00
|
|
|
upa = alloc_size / min_unit_size;
|
|
|
|
while (alloc_size % upa || ((alloc_size / upa) & ~PAGE_MASK))
|
|
|
|
upa--;
|
|
|
|
max_upa = upa;
|
|
|
|
|
|
|
|
/* group cpus according to their proximity */
|
|
|
|
for_each_possible_cpu(cpu) {
|
|
|
|
group = 0;
|
|
|
|
next_group:
|
|
|
|
for_each_possible_cpu(tcpu) {
|
|
|
|
if (cpu == tcpu)
|
|
|
|
break;
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
if (group_map[tcpu] == group && cpu_distance_fn &&
|
2009-08-14 08:00:51 +02:00
|
|
|
(cpu_distance_fn(cpu, tcpu) > LOCAL_DISTANCE ||
|
|
|
|
cpu_distance_fn(tcpu, cpu) > LOCAL_DISTANCE)) {
|
|
|
|
group++;
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
nr_groups = max(nr_groups, group + 1);
|
2009-08-14 08:00:51 +02:00
|
|
|
goto next_group;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
group_map[cpu] = group;
|
|
|
|
group_cnt[group]++;
|
|
|
|
group_cnt_max = max(group_cnt_max, group_cnt[group]);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Expand unit size until address space usage goes over 75%
|
|
|
|
* and then as much as possible without using more address
|
|
|
|
* space.
|
|
|
|
*/
|
|
|
|
last_allocs = INT_MAX;
|
|
|
|
for (upa = max_upa; upa; upa--) {
|
|
|
|
int allocs = 0, wasted = 0;
|
|
|
|
|
|
|
|
if (alloc_size % upa || ((alloc_size / upa) & ~PAGE_MASK))
|
|
|
|
continue;
|
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
for (group = 0; group < nr_groups; group++) {
|
2009-08-14 08:00:51 +02:00
|
|
|
int this_allocs = DIV_ROUND_UP(group_cnt[group], upa);
|
|
|
|
allocs += this_allocs;
|
|
|
|
wasted += this_allocs * upa - group_cnt[group];
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't accept if wastage is over 25%. The
|
|
|
|
* greater-than comparison ensures upa==1 always
|
|
|
|
* passes the following check.
|
|
|
|
*/
|
|
|
|
if (wasted > num_possible_cpus() / 3)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* and then don't consume more memory */
|
|
|
|
if (allocs > last_allocs)
|
|
|
|
break;
|
|
|
|
last_allocs = allocs;
|
|
|
|
best_upa = upa;
|
|
|
|
}
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
upa = best_upa;
|
|
|
|
|
|
|
|
/* allocate and fill alloc_info */
|
|
|
|
for (group = 0; group < nr_groups; group++)
|
|
|
|
nr_units += roundup(group_cnt[group], upa);
|
|
|
|
|
|
|
|
ai = pcpu_alloc_alloc_info(nr_groups, nr_units);
|
|
|
|
if (!ai)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
cpu_map = ai->groups[0].cpu_map;
|
|
|
|
|
|
|
|
for (group = 0; group < nr_groups; group++) {
|
|
|
|
ai->groups[group].cpu_map = cpu_map;
|
|
|
|
cpu_map += roundup(group_cnt[group], upa);
|
|
|
|
}
|
|
|
|
|
|
|
|
ai->static_size = static_size;
|
|
|
|
ai->reserved_size = reserved_size;
|
|
|
|
ai->dyn_size = dyn_size;
|
|
|
|
ai->unit_size = alloc_size / upa;
|
|
|
|
ai->atom_size = atom_size;
|
|
|
|
ai->alloc_size = alloc_size;
|
|
|
|
|
|
|
|
for (group = 0, unit = 0; group_cnt[group]; group++) {
|
|
|
|
struct pcpu_group_info *gi = &ai->groups[group];
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize base_offset as if all groups are located
|
|
|
|
* back-to-back. The caller should update this to
|
|
|
|
* reflect actual allocation.
|
|
|
|
*/
|
|
|
|
gi->base_offset = unit * ai->unit_size;
|
2009-08-14 08:00:51 +02:00
|
|
|
|
|
|
|
for_each_possible_cpu(cpu)
|
|
|
|
if (group_map[cpu] == group)
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
gi->cpu_map[gi->nr_units++] = cpu;
|
|
|
|
gi->nr_units = roundup(gi->nr_units, upa);
|
|
|
|
unit += gi->nr_units;
|
2009-08-14 08:00:51 +02:00
|
|
|
}
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
BUG_ON(unit != nr_units);
|
2009-08-14 08:00:51 +02:00
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
return ai;
|
2009-08-14 08:00:51 +02:00
|
|
|
}
|
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
/**
|
|
|
|
* pcpu_dump_alloc_info - print out information about pcpu_alloc_info
|
|
|
|
* @lvl: loglevel
|
|
|
|
* @ai: allocation info to dump
|
|
|
|
*
|
|
|
|
* Print out information about @ai using loglevel @lvl.
|
|
|
|
*/
|
|
|
|
static void pcpu_dump_alloc_info(const char *lvl,
|
|
|
|
const struct pcpu_alloc_info *ai)
|
2009-08-14 08:00:51 +02:00
|
|
|
{
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
int group_width = 1, cpu_width = 1, width;
|
2009-08-14 08:00:51 +02:00
|
|
|
char empty_str[] = "--------";
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
int alloc = 0, alloc_end = 0;
|
|
|
|
int group, v;
|
|
|
|
int upa, apl; /* units per alloc, allocs per line */
|
|
|
|
|
|
|
|
v = ai->nr_groups;
|
|
|
|
while (v /= 10)
|
|
|
|
group_width++;
|
2009-08-14 08:00:51 +02:00
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
v = num_possible_cpus();
|
2009-08-14 08:00:51 +02:00
|
|
|
while (v /= 10)
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
cpu_width++;
|
|
|
|
empty_str[min_t(int, cpu_width, sizeof(empty_str) - 1)] = '\0';
|
2009-08-14 08:00:51 +02:00
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
upa = ai->alloc_size / ai->unit_size;
|
|
|
|
width = upa * (cpu_width + 1) + group_width + 3;
|
|
|
|
apl = rounddown_pow_of_two(max(60 / width, 1));
|
2009-08-14 08:00:51 +02:00
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
printk("%spcpu-alloc: s%zu r%zu d%zu u%zu alloc=%zu*%zu",
|
|
|
|
lvl, ai->static_size, ai->reserved_size, ai->dyn_size,
|
|
|
|
ai->unit_size, ai->alloc_size / ai->atom_size, ai->atom_size);
|
2009-08-14 08:00:51 +02:00
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
for (group = 0; group < ai->nr_groups; group++) {
|
|
|
|
const struct pcpu_group_info *gi = &ai->groups[group];
|
|
|
|
int unit = 0, unit_end = 0;
|
|
|
|
|
|
|
|
BUG_ON(gi->nr_units % upa);
|
|
|
|
for (alloc_end += gi->nr_units / upa;
|
|
|
|
alloc < alloc_end; alloc++) {
|
|
|
|
if (!(alloc % apl)) {
|
2009-08-14 08:00:51 +02:00
|
|
|
printk("\n");
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
printk("%spcpu-alloc: ", lvl);
|
|
|
|
}
|
|
|
|
printk("[%0*d] ", group_width, group);
|
|
|
|
|
|
|
|
for (unit_end += upa; unit < unit_end; unit++)
|
|
|
|
if (gi->cpu_map[unit] != NR_CPUS)
|
|
|
|
printk("%0*d ", cpu_width,
|
|
|
|
gi->cpu_map[unit]);
|
|
|
|
else
|
|
|
|
printk("%s ", empty_str);
|
2009-08-14 08:00:51 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
printk("\n");
|
|
|
|
}
|
|
|
|
|
2009-02-20 08:29:08 +01:00
|
|
|
/**
|
2009-02-24 03:57:21 +01:00
|
|
|
* pcpu_setup_first_chunk - initialize the first percpu chunk
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
* @ai: pcpu_alloc_info describing how to percpu area is shaped
|
2009-07-04 01:10:59 +02:00
|
|
|
* @base_addr: mapped address
|
2009-02-24 03:57:21 +01:00
|
|
|
*
|
|
|
|
* Initialize the first percpu chunk which contains the kernel static
|
|
|
|
* perpcu area. This function is to be called from arch percpu area
|
2009-07-04 01:10:59 +02:00
|
|
|
* setup path.
|
2009-02-24 03:57:21 +01:00
|
|
|
*
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
* @ai contains all information necessary to initialize the first
|
|
|
|
* chunk and prime the dynamic percpu allocator.
|
|
|
|
*
|
|
|
|
* @ai->static_size is the size of static percpu area.
|
|
|
|
*
|
|
|
|
* @ai->reserved_size, if non-zero, specifies the amount of bytes to
|
2009-03-06 06:33:59 +01:00
|
|
|
* reserve after the static area in the first chunk. This reserves
|
|
|
|
* the first chunk such that it's available only through reserved
|
|
|
|
* percpu allocation. This is primarily used to serve module percpu
|
|
|
|
* static areas on architectures where the addressing model has
|
|
|
|
* limited offset range for symbol relocations to guarantee module
|
|
|
|
* percpu symbols fall inside the relocatable range.
|
|
|
|
*
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
* @ai->dyn_size determines the number of bytes available for dynamic
|
|
|
|
* allocation in the first chunk. The area between @ai->static_size +
|
|
|
|
* @ai->reserved_size + @ai->dyn_size and @ai->unit_size is unused.
|
2009-03-10 08:27:48 +01:00
|
|
|
*
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
* @ai->unit_size specifies unit size and must be aligned to PAGE_SIZE
|
|
|
|
* and equal to or larger than @ai->static_size + @ai->reserved_size +
|
|
|
|
* @ai->dyn_size.
|
2009-02-24 03:57:21 +01:00
|
|
|
*
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
* @ai->atom_size is the allocation atom size and used as alignment
|
|
|
|
* for vm areas.
|
2009-02-24 03:57:21 +01:00
|
|
|
*
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
* @ai->alloc_size is the allocation size and always multiple of
|
|
|
|
* @ai->atom_size. This is larger than @ai->atom_size if
|
|
|
|
* @ai->unit_size is larger than @ai->atom_size.
|
|
|
|
*
|
|
|
|
* @ai->nr_groups and @ai->groups describe virtual memory layout of
|
|
|
|
* percpu areas. Units which should be colocated are put into the
|
|
|
|
* same group. Dynamic VM areas will be allocated according to these
|
|
|
|
* groupings. If @ai->nr_groups is zero, a single group containing
|
|
|
|
* all units is assumed.
|
2009-02-24 03:57:21 +01:00
|
|
|
*
|
2009-07-04 01:10:59 +02:00
|
|
|
* The caller should have mapped the first chunk at @base_addr and
|
|
|
|
* copied static data to each unit.
|
2009-02-20 08:29:08 +01:00
|
|
|
*
|
2009-03-06 06:33:59 +01:00
|
|
|
* If the first chunk ends up with both reserved and dynamic areas, it
|
|
|
|
* is served by two chunks - one to serve the core static and reserved
|
|
|
|
* areas and the other for the dynamic area. They share the same vm
|
|
|
|
* and page map but uses different area allocation map to stay away
|
|
|
|
* from each other. The latter chunk is circulated in the chunk slots
|
|
|
|
* and available for dynamic allocation like any other chunks.
|
|
|
|
*
|
2009-02-20 08:29:08 +01:00
|
|
|
* RETURNS:
|
2009-08-14 08:00:51 +02:00
|
|
|
* 0 on success, -errno on failure.
|
2009-02-20 08:29:08 +01:00
|
|
|
*/
|
2009-08-14 08:00:51 +02:00
|
|
|
int __init pcpu_setup_first_chunk(const struct pcpu_alloc_info *ai,
|
|
|
|
void *base_addr)
|
2009-02-20 08:29:08 +01:00
|
|
|
{
|
2009-03-06 06:33:59 +01:00
|
|
|
static int smap[2], dmap[2];
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
size_t dyn_size = ai->dyn_size;
|
|
|
|
size_t size_sum = ai->static_size + ai->reserved_size + dyn_size;
|
2009-03-06 06:33:59 +01:00
|
|
|
struct pcpu_chunk *schunk, *dchunk = NULL;
|
2009-08-14 08:00:52 +02:00
|
|
|
unsigned long *group_offsets;
|
|
|
|
size_t *group_sizes;
|
2009-08-14 08:00:51 +02:00
|
|
|
unsigned long *unit_off;
|
2009-02-20 08:29:08 +01:00
|
|
|
unsigned int cpu;
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
int *unit_map;
|
|
|
|
int group, unit, i;
|
2009-02-20 08:29:08 +01:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
/* sanity checks */
|
2009-03-06 06:33:59 +01:00
|
|
|
BUILD_BUG_ON(ARRAY_SIZE(smap) >= PCPU_DFL_MAP_ALLOC ||
|
|
|
|
ARRAY_SIZE(dmap) >= PCPU_DFL_MAP_ALLOC);
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
BUG_ON(ai->nr_groups <= 0);
|
|
|
|
BUG_ON(!ai->static_size);
|
2009-07-04 01:10:59 +02:00
|
|
|
BUG_ON(!base_addr);
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
BUG_ON(ai->unit_size < size_sum);
|
|
|
|
BUG_ON(ai->unit_size & ~PAGE_MASK);
|
|
|
|
BUG_ON(ai->unit_size < PCPU_MIN_UNIT_SIZE);
|
|
|
|
|
|
|
|
pcpu_dump_alloc_info(KERN_DEBUG, ai);
|
2009-02-24 03:57:21 +01:00
|
|
|
|
2009-08-14 08:00:52 +02:00
|
|
|
/* process group information and build config tables accordingly */
|
|
|
|
group_offsets = alloc_bootmem(ai->nr_groups * sizeof(group_offsets[0]));
|
|
|
|
group_sizes = alloc_bootmem(ai->nr_groups * sizeof(group_sizes[0]));
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
unit_map = alloc_bootmem(nr_cpu_ids * sizeof(unit_map[0]));
|
2009-08-14 08:00:51 +02:00
|
|
|
unit_off = alloc_bootmem(nr_cpu_ids * sizeof(unit_off[0]));
|
2009-07-04 01:11:00 +02:00
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
for (cpu = 0; cpu < nr_cpu_ids; cpu++)
|
2009-09-29 02:17:56 +02:00
|
|
|
unit_map[cpu] = UINT_MAX;
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
pcpu_first_unit_cpu = NR_CPUS;
|
2009-07-04 01:11:00 +02:00
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
for (group = 0, unit = 0; group < ai->nr_groups; group++, unit += i) {
|
|
|
|
const struct pcpu_group_info *gi = &ai->groups[group];
|
2009-07-04 01:11:00 +02:00
|
|
|
|
2009-08-14 08:00:52 +02:00
|
|
|
group_offsets[group] = gi->base_offset;
|
|
|
|
group_sizes[group] = gi->nr_units * ai->unit_size;
|
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
for (i = 0; i < gi->nr_units; i++) {
|
|
|
|
cpu = gi->cpu_map[i];
|
|
|
|
if (cpu == NR_CPUS)
|
|
|
|
continue;
|
2009-02-24 03:57:21 +01:00
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
BUG_ON(cpu > nr_cpu_ids || !cpu_possible(cpu));
|
2009-09-29 02:17:56 +02:00
|
|
|
BUG_ON(unit_map[cpu] != UINT_MAX);
|
2009-02-20 08:29:08 +01:00
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
unit_map[cpu] = unit + i;
|
2009-08-14 08:00:51 +02:00
|
|
|
unit_off[cpu] = gi->base_offset + i * ai->unit_size;
|
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
if (pcpu_first_unit_cpu == NR_CPUS)
|
|
|
|
pcpu_first_unit_cpu = cpu;
|
|
|
|
}
|
2009-07-04 01:11:00 +02:00
|
|
|
}
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
pcpu_last_unit_cpu = cpu;
|
|
|
|
pcpu_nr_units = unit;
|
|
|
|
|
|
|
|
for_each_possible_cpu(cpu)
|
2009-09-29 02:17:56 +02:00
|
|
|
BUG_ON(unit_map[cpu] == UINT_MAX);
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
|
2009-08-14 08:00:52 +02:00
|
|
|
pcpu_nr_groups = ai->nr_groups;
|
|
|
|
pcpu_group_offsets = group_offsets;
|
|
|
|
pcpu_group_sizes = group_sizes;
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
pcpu_unit_map = unit_map;
|
2009-08-14 08:00:51 +02:00
|
|
|
pcpu_unit_offsets = unit_off;
|
2009-07-04 01:11:00 +02:00
|
|
|
|
|
|
|
/* determine basic parameters */
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
pcpu_unit_pages = ai->unit_size >> PAGE_SHIFT;
|
2009-02-24 03:57:21 +01:00
|
|
|
pcpu_unit_size = pcpu_unit_pages << PAGE_SHIFT;
|
2009-08-14 08:00:52 +02:00
|
|
|
pcpu_atom_size = ai->atom_size;
|
2009-07-04 01:11:00 +02:00
|
|
|
pcpu_chunk_struct_size = sizeof(struct pcpu_chunk) +
|
|
|
|
BITS_TO_LONGS(pcpu_unit_pages) * sizeof(unsigned long);
|
2009-03-06 06:33:59 +01:00
|
|
|
|
2009-02-24 03:57:21 +01:00
|
|
|
/*
|
|
|
|
* Allocate chunk slots. The additional last slot is for
|
|
|
|
* empty chunks.
|
|
|
|
*/
|
|
|
|
pcpu_nr_slots = __pcpu_size_to_slot(pcpu_unit_size) + 2;
|
2009-02-20 08:29:08 +01:00
|
|
|
pcpu_slot = alloc_bootmem(pcpu_nr_slots * sizeof(pcpu_slot[0]));
|
|
|
|
for (i = 0; i < pcpu_nr_slots; i++)
|
|
|
|
INIT_LIST_HEAD(&pcpu_slot[i]);
|
|
|
|
|
2009-03-06 06:33:59 +01:00
|
|
|
/*
|
|
|
|
* Initialize static chunk. If reserved_size is zero, the
|
|
|
|
* static chunk covers static area + dynamic allocation area
|
|
|
|
* in the first chunk. If reserved_size is not zero, it
|
|
|
|
* covers static area + reserved area (mostly used for module
|
|
|
|
* static percpu allocation).
|
|
|
|
*/
|
2009-03-06 06:33:59 +01:00
|
|
|
schunk = alloc_bootmem(pcpu_chunk_struct_size);
|
|
|
|
INIT_LIST_HEAD(&schunk->list);
|
2009-08-14 08:00:51 +02:00
|
|
|
schunk->base_addr = base_addr;
|
2009-03-06 06:33:59 +01:00
|
|
|
schunk->map = smap;
|
|
|
|
schunk->map_alloc = ARRAY_SIZE(smap);
|
2009-07-04 01:10:59 +02:00
|
|
|
schunk->immutable = true;
|
2009-07-04 01:11:00 +02:00
|
|
|
bitmap_fill(schunk->populated, pcpu_unit_pages);
|
2009-03-06 06:33:59 +01:00
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
if (ai->reserved_size) {
|
|
|
|
schunk->free_size = ai->reserved_size;
|
2009-04-02 06:19:54 +02:00
|
|
|
pcpu_reserved_chunk = schunk;
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
pcpu_reserved_chunk_limit = ai->static_size + ai->reserved_size;
|
2009-03-06 06:33:59 +01:00
|
|
|
} else {
|
|
|
|
schunk->free_size = dyn_size;
|
|
|
|
dyn_size = 0; /* dynamic area covered */
|
|
|
|
}
|
2009-03-06 06:33:59 +01:00
|
|
|
schunk->contig_hint = schunk->free_size;
|
2009-02-20 08:29:08 +01:00
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
schunk->map[schunk->map_used++] = -ai->static_size;
|
2009-03-06 06:33:59 +01:00
|
|
|
if (schunk->free_size)
|
|
|
|
schunk->map[schunk->map_used++] = schunk->free_size;
|
|
|
|
|
2009-03-06 06:33:59 +01:00
|
|
|
/* init dynamic chunk if necessary */
|
|
|
|
if (dyn_size) {
|
2009-07-04 01:11:00 +02:00
|
|
|
dchunk = alloc_bootmem(pcpu_chunk_struct_size);
|
2009-03-06 06:33:59 +01:00
|
|
|
INIT_LIST_HEAD(&dchunk->list);
|
2009-08-14 08:00:51 +02:00
|
|
|
dchunk->base_addr = base_addr;
|
2009-03-06 06:33:59 +01:00
|
|
|
dchunk->map = dmap;
|
|
|
|
dchunk->map_alloc = ARRAY_SIZE(dmap);
|
2009-07-04 01:10:59 +02:00
|
|
|
dchunk->immutable = true;
|
2009-07-04 01:11:00 +02:00
|
|
|
bitmap_fill(dchunk->populated, pcpu_unit_pages);
|
2009-03-06 06:33:59 +01:00
|
|
|
|
|
|
|
dchunk->contig_hint = dchunk->free_size = dyn_size;
|
|
|
|
dchunk->map[dchunk->map_used++] = -pcpu_reserved_chunk_limit;
|
|
|
|
dchunk->map[dchunk->map_used++] = dchunk->free_size;
|
|
|
|
}
|
|
|
|
|
2009-03-06 06:33:59 +01:00
|
|
|
/* link the first chunk in */
|
2009-04-02 06:19:54 +02:00
|
|
|
pcpu_first_chunk = dchunk ?: schunk;
|
|
|
|
pcpu_chunk_relocate(pcpu_first_chunk, -1);
|
2009-02-20 08:29:08 +01:00
|
|
|
|
|
|
|
/* we're done */
|
2009-08-14 08:00:51 +02:00
|
|
|
pcpu_base_addr = base_addr;
|
2009-08-14 08:00:51 +02:00
|
|
|
return 0;
|
2009-02-20 08:29:08 +01:00
|
|
|
}
|
2009-03-10 08:27:48 +01:00
|
|
|
|
2009-08-14 08:00:50 +02:00
|
|
|
const char *pcpu_fc_names[PCPU_FC_NR] __initdata = {
|
|
|
|
[PCPU_FC_AUTO] = "auto",
|
|
|
|
[PCPU_FC_EMBED] = "embed",
|
|
|
|
[PCPU_FC_PAGE] = "page",
|
|
|
|
};
|
2009-03-10 08:27:48 +01:00
|
|
|
|
2009-08-14 08:00:50 +02:00
|
|
|
enum pcpu_fc pcpu_chosen_fc __initdata = PCPU_FC_AUTO;
|
2009-03-10 08:27:48 +01:00
|
|
|
|
2009-08-14 08:00:50 +02:00
|
|
|
static int __init percpu_alloc_setup(char *str)
|
|
|
|
{
|
|
|
|
if (0)
|
|
|
|
/* nada */;
|
|
|
|
#ifdef CONFIG_NEED_PER_CPU_EMBED_FIRST_CHUNK
|
|
|
|
else if (!strcmp(str, "embed"))
|
|
|
|
pcpu_chosen_fc = PCPU_FC_EMBED;
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK
|
|
|
|
else if (!strcmp(str, "page"))
|
|
|
|
pcpu_chosen_fc = PCPU_FC_PAGE;
|
|
|
|
#endif
|
|
|
|
else
|
|
|
|
pr_warning("PERCPU: unknown allocator %s specified\n", str);
|
2009-03-10 08:27:48 +01:00
|
|
|
|
2009-08-14 08:00:50 +02:00
|
|
|
return 0;
|
2009-03-10 08:27:48 +01:00
|
|
|
}
|
2009-08-14 08:00:50 +02:00
|
|
|
early_param("percpu_alloc", percpu_alloc_setup);
|
2009-03-10 08:27:48 +01:00
|
|
|
|
2009-08-14 08:00:49 +02:00
|
|
|
#if defined(CONFIG_NEED_PER_CPU_EMBED_FIRST_CHUNK) || \
|
|
|
|
!defined(CONFIG_HAVE_SETUP_PER_CPU_AREA)
|
2009-03-10 08:27:48 +01:00
|
|
|
/**
|
|
|
|
* pcpu_embed_first_chunk - embed the first percpu chunk into bootmem
|
|
|
|
* @reserved_size: the size of reserved percpu area in bytes
|
|
|
|
* @dyn_size: free size for dynamic allocation in bytes, -1 for auto
|
2009-08-14 08:00:52 +02:00
|
|
|
* @atom_size: allocation atom size
|
|
|
|
* @cpu_distance_fn: callback to determine distance between cpus, optional
|
|
|
|
* @alloc_fn: function to allocate percpu page
|
|
|
|
* @free_fn: funtion to free percpu page
|
2009-03-10 08:27:48 +01:00
|
|
|
*
|
|
|
|
* This is a helper to ease setting up embedded first percpu chunk and
|
|
|
|
* can be called where pcpu_setup_first_chunk() is expected.
|
|
|
|
*
|
|
|
|
* If this function is used to setup the first chunk, it is allocated
|
2009-08-14 08:00:52 +02:00
|
|
|
* by calling @alloc_fn and used as-is without being mapped into
|
|
|
|
* vmalloc area. Allocations are always whole multiples of @atom_size
|
|
|
|
* aligned to @atom_size.
|
|
|
|
*
|
|
|
|
* This enables the first chunk to piggy back on the linear physical
|
|
|
|
* mapping which often uses larger page size. Please note that this
|
|
|
|
* can result in very sparse cpu->unit mapping on NUMA machines thus
|
|
|
|
* requiring large vmalloc address space. Don't use this allocator if
|
|
|
|
* vmalloc space is not orders of magnitude larger than distances
|
|
|
|
* between node memory addresses (ie. 32bit NUMA machines).
|
2009-03-10 08:27:48 +01:00
|
|
|
*
|
|
|
|
* When @dyn_size is positive, dynamic area might be larger than
|
2009-07-04 01:10:58 +02:00
|
|
|
* specified to fill page alignment. When @dyn_size is auto,
|
|
|
|
* @dyn_size is just big enough to fill page alignment after static
|
|
|
|
* and reserved areas.
|
2009-03-10 08:27:48 +01:00
|
|
|
*
|
|
|
|
* If the needed size is smaller than the minimum or specified unit
|
2009-08-14 08:00:52 +02:00
|
|
|
* size, the leftover is returned using @free_fn.
|
2009-03-10 08:27:48 +01:00
|
|
|
*
|
|
|
|
* RETURNS:
|
2009-08-14 08:00:51 +02:00
|
|
|
* 0 on success, -errno on failure.
|
2009-03-10 08:27:48 +01:00
|
|
|
*/
|
2009-08-14 08:00:52 +02:00
|
|
|
int __init pcpu_embed_first_chunk(size_t reserved_size, ssize_t dyn_size,
|
|
|
|
size_t atom_size,
|
|
|
|
pcpu_fc_cpu_distance_fn_t cpu_distance_fn,
|
|
|
|
pcpu_fc_alloc_fn_t alloc_fn,
|
|
|
|
pcpu_fc_free_fn_t free_fn)
|
2009-03-10 08:27:48 +01:00
|
|
|
{
|
2009-08-14 08:00:52 +02:00
|
|
|
void *base = (void *)ULONG_MAX;
|
|
|
|
void **areas = NULL;
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
struct pcpu_alloc_info *ai;
|
2009-08-14 08:00:52 +02:00
|
|
|
size_t size_sum, areas_size;
|
|
|
|
int group, i, rc;
|
2009-03-10 08:27:48 +01:00
|
|
|
|
2009-08-14 08:00:52 +02:00
|
|
|
ai = pcpu_build_alloc_info(reserved_size, dyn_size, atom_size,
|
|
|
|
cpu_distance_fn);
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
if (IS_ERR(ai))
|
|
|
|
return PTR_ERR(ai);
|
2009-03-10 08:27:48 +01:00
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
size_sum = ai->static_size + ai->reserved_size + ai->dyn_size;
|
2009-08-14 08:00:52 +02:00
|
|
|
areas_size = PFN_ALIGN(ai->nr_groups * sizeof(void *));
|
2009-06-22 04:56:24 +02:00
|
|
|
|
2009-08-14 08:00:52 +02:00
|
|
|
areas = alloc_bootmem_nopanic(areas_size);
|
|
|
|
if (!areas) {
|
2009-08-14 08:00:51 +02:00
|
|
|
rc = -ENOMEM;
|
2009-08-14 08:00:52 +02:00
|
|
|
goto out_free;
|
2009-06-22 04:56:24 +02:00
|
|
|
}
|
2009-03-10 08:27:48 +01:00
|
|
|
|
2009-08-14 08:00:52 +02:00
|
|
|
/* allocate, copy and determine base address */
|
|
|
|
for (group = 0; group < ai->nr_groups; group++) {
|
|
|
|
struct pcpu_group_info *gi = &ai->groups[group];
|
|
|
|
unsigned int cpu = NR_CPUS;
|
|
|
|
void *ptr;
|
|
|
|
|
|
|
|
for (i = 0; i < gi->nr_units && cpu == NR_CPUS; i++)
|
|
|
|
cpu = gi->cpu_map[i];
|
|
|
|
BUG_ON(cpu == NR_CPUS);
|
|
|
|
|
|
|
|
/* allocate space for the whole group */
|
|
|
|
ptr = alloc_fn(cpu, gi->nr_units * ai->unit_size, atom_size);
|
|
|
|
if (!ptr) {
|
|
|
|
rc = -ENOMEM;
|
|
|
|
goto out_free_areas;
|
|
|
|
}
|
|
|
|
areas[group] = ptr;
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
|
2009-08-14 08:00:52 +02:00
|
|
|
base = min(ptr, base);
|
|
|
|
|
|
|
|
for (i = 0; i < gi->nr_units; i++, ptr += ai->unit_size) {
|
|
|
|
if (gi->cpu_map[i] == NR_CPUS) {
|
|
|
|
/* unused unit, free whole */
|
|
|
|
free_fn(ptr, ai->unit_size);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
/* copy and return the unused part */
|
|
|
|
memcpy(ptr, __per_cpu_load, ai->static_size);
|
|
|
|
free_fn(ptr + size_sum, ai->unit_size - size_sum);
|
|
|
|
}
|
2009-06-22 04:56:24 +02:00
|
|
|
}
|
2009-03-10 08:27:48 +01:00
|
|
|
|
2009-08-14 08:00:52 +02:00
|
|
|
/* base address is now known, determine group base offsets */
|
|
|
|
for (group = 0; group < ai->nr_groups; group++)
|
|
|
|
ai->groups[group].base_offset = areas[group] - base;
|
|
|
|
|
2009-08-14 08:00:49 +02:00
|
|
|
pr_info("PERCPU: Embedded %zu pages/cpu @%p s%zu r%zu d%zu u%zu\n",
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
PFN_DOWN(size_sum), base, ai->static_size, ai->reserved_size,
|
|
|
|
ai->dyn_size, ai->unit_size);
|
2009-07-04 01:10:59 +02:00
|
|
|
|
2009-08-14 08:00:51 +02:00
|
|
|
rc = pcpu_setup_first_chunk(ai, base);
|
2009-08-14 08:00:52 +02:00
|
|
|
goto out_free;
|
|
|
|
|
|
|
|
out_free_areas:
|
|
|
|
for (group = 0; group < ai->nr_groups; group++)
|
|
|
|
free_fn(areas[group],
|
|
|
|
ai->groups[group].nr_units * ai->unit_size);
|
|
|
|
out_free:
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
pcpu_free_alloc_info(ai);
|
2009-08-14 08:00:52 +02:00
|
|
|
if (areas)
|
|
|
|
free_bootmem(__pa(areas), areas_size);
|
2009-08-14 08:00:51 +02:00
|
|
|
return rc;
|
2009-07-04 01:10:59 +02:00
|
|
|
}
|
2009-08-14 08:00:49 +02:00
|
|
|
#endif /* CONFIG_NEED_PER_CPU_EMBED_FIRST_CHUNK ||
|
|
|
|
!CONFIG_HAVE_SETUP_PER_CPU_AREA */
|
2009-07-04 01:10:59 +02:00
|
|
|
|
2009-08-14 08:00:49 +02:00
|
|
|
#ifdef CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK
|
2009-07-04 01:10:59 +02:00
|
|
|
/**
|
2009-08-14 08:00:49 +02:00
|
|
|
* pcpu_page_first_chunk - map the first chunk using PAGE_SIZE pages
|
2009-07-04 01:10:59 +02:00
|
|
|
* @reserved_size: the size of reserved percpu area in bytes
|
|
|
|
* @alloc_fn: function to allocate percpu page, always called with PAGE_SIZE
|
|
|
|
* @free_fn: funtion to free percpu page, always called with PAGE_SIZE
|
|
|
|
* @populate_pte_fn: function to populate pte
|
|
|
|
*
|
2009-08-14 08:00:49 +02:00
|
|
|
* This is a helper to ease setting up page-remapped first percpu
|
|
|
|
* chunk and can be called where pcpu_setup_first_chunk() is expected.
|
2009-07-04 01:10:59 +02:00
|
|
|
*
|
|
|
|
* This is the basic allocator. Static percpu area is allocated
|
|
|
|
* page-by-page into vmalloc area.
|
|
|
|
*
|
|
|
|
* RETURNS:
|
2009-08-14 08:00:51 +02:00
|
|
|
* 0 on success, -errno on failure.
|
2009-07-04 01:10:59 +02:00
|
|
|
*/
|
2009-08-14 08:00:51 +02:00
|
|
|
int __init pcpu_page_first_chunk(size_t reserved_size,
|
|
|
|
pcpu_fc_alloc_fn_t alloc_fn,
|
|
|
|
pcpu_fc_free_fn_t free_fn,
|
|
|
|
pcpu_fc_populate_pte_fn_t populate_pte_fn)
|
2009-07-04 01:10:59 +02:00
|
|
|
{
|
2009-07-04 01:10:59 +02:00
|
|
|
static struct vm_struct vm;
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
struct pcpu_alloc_info *ai;
|
2009-08-14 08:00:49 +02:00
|
|
|
char psize_str[16];
|
2009-07-04 01:11:00 +02:00
|
|
|
int unit_pages;
|
2009-07-04 01:10:59 +02:00
|
|
|
size_t pages_size;
|
2009-07-04 01:11:00 +02:00
|
|
|
struct page **pages;
|
2009-08-14 08:00:51 +02:00
|
|
|
int unit, i, j, rc;
|
2009-07-04 01:10:59 +02:00
|
|
|
|
2009-08-14 08:00:49 +02:00
|
|
|
snprintf(psize_str, sizeof(psize_str), "%luK", PAGE_SIZE >> 10);
|
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
ai = pcpu_build_alloc_info(reserved_size, -1, PAGE_SIZE, NULL);
|
|
|
|
if (IS_ERR(ai))
|
|
|
|
return PTR_ERR(ai);
|
|
|
|
BUG_ON(ai->nr_groups != 1);
|
|
|
|
BUG_ON(ai->groups[0].nr_units != num_possible_cpus());
|
|
|
|
|
|
|
|
unit_pages = ai->unit_size >> PAGE_SHIFT;
|
2009-07-04 01:10:59 +02:00
|
|
|
|
|
|
|
/* unaligned allocations can't be freed, round up to page size */
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
pages_size = PFN_ALIGN(unit_pages * num_possible_cpus() *
|
|
|
|
sizeof(pages[0]));
|
2009-07-04 01:11:00 +02:00
|
|
|
pages = alloc_bootmem(pages_size);
|
2009-07-04 01:10:59 +02:00
|
|
|
|
2009-07-04 01:10:59 +02:00
|
|
|
/* allocate pages */
|
2009-07-04 01:10:59 +02:00
|
|
|
j = 0;
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
for (unit = 0; unit < num_possible_cpus(); unit++)
|
2009-07-04 01:11:00 +02:00
|
|
|
for (i = 0; i < unit_pages; i++) {
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
unsigned int cpu = ai->groups[0].cpu_map[unit];
|
2009-07-04 01:10:59 +02:00
|
|
|
void *ptr;
|
|
|
|
|
2009-08-14 08:00:50 +02:00
|
|
|
ptr = alloc_fn(cpu, PAGE_SIZE, PAGE_SIZE);
|
2009-07-04 01:10:59 +02:00
|
|
|
if (!ptr) {
|
2009-08-14 08:00:49 +02:00
|
|
|
pr_warning("PERCPU: failed to allocate %s page "
|
|
|
|
"for cpu%u\n", psize_str, cpu);
|
2009-07-04 01:10:59 +02:00
|
|
|
goto enomem;
|
|
|
|
}
|
2009-07-04 01:11:00 +02:00
|
|
|
pages[j++] = virt_to_page(ptr);
|
2009-07-04 01:10:59 +02:00
|
|
|
}
|
|
|
|
|
2009-07-04 01:10:59 +02:00
|
|
|
/* allocate vm area, map the pages and copy static data */
|
|
|
|
vm.flags = VM_ALLOC;
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
vm.size = num_possible_cpus() * ai->unit_size;
|
2009-07-04 01:10:59 +02:00
|
|
|
vm_area_register_early(&vm, PAGE_SIZE);
|
|
|
|
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
for (unit = 0; unit < num_possible_cpus(); unit++) {
|
2009-08-14 08:00:50 +02:00
|
|
|
unsigned long unit_addr =
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
(unsigned long)vm.addr + unit * ai->unit_size;
|
2009-07-04 01:10:59 +02:00
|
|
|
|
2009-07-04 01:11:00 +02:00
|
|
|
for (i = 0; i < unit_pages; i++)
|
2009-07-04 01:10:59 +02:00
|
|
|
populate_pte_fn(unit_addr + (i << PAGE_SHIFT));
|
|
|
|
|
|
|
|
/* pte already populated, the following shouldn't fail */
|
2009-08-14 08:00:51 +02:00
|
|
|
rc = __pcpu_map_pages(unit_addr, &pages[unit * unit_pages],
|
|
|
|
unit_pages);
|
|
|
|
if (rc < 0)
|
|
|
|
panic("failed to map percpu area, err=%d\n", rc);
|
2009-03-10 08:27:48 +01:00
|
|
|
|
2009-07-04 01:10:59 +02:00
|
|
|
/*
|
|
|
|
* FIXME: Archs with virtual cache should flush local
|
|
|
|
* cache for the linear mapping here - something
|
|
|
|
* equivalent to flush_cache_vmap() on the local cpu.
|
|
|
|
* flush_cache_vmap() can't be used as most supporting
|
|
|
|
* data structures are not set up yet.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* copy static data */
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
memcpy((void *)unit_addr, __per_cpu_load, ai->static_size);
|
2009-03-10 08:27:48 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* we're ready, commit */
|
2009-08-14 08:00:50 +02:00
|
|
|
pr_info("PERCPU: %d %s pages/cpu @%p s%zu r%zu d%zu\n",
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
unit_pages, psize_str, vm.addr, ai->static_size,
|
|
|
|
ai->reserved_size, ai->dyn_size);
|
2009-07-04 01:10:59 +02:00
|
|
|
|
2009-08-14 08:00:51 +02:00
|
|
|
rc = pcpu_setup_first_chunk(ai, vm.addr);
|
2009-07-04 01:10:59 +02:00
|
|
|
goto out_free_ar;
|
|
|
|
|
|
|
|
enomem:
|
|
|
|
while (--j >= 0)
|
2009-07-04 01:11:00 +02:00
|
|
|
free_fn(page_address(pages[j]), PAGE_SIZE);
|
2009-08-14 08:00:51 +02:00
|
|
|
rc = -ENOMEM;
|
2009-07-04 01:10:59 +02:00
|
|
|
out_free_ar:
|
2009-07-04 01:11:00 +02:00
|
|
|
free_bootmem(__pa(pages), pages_size);
|
percpu: introduce pcpu_alloc_info and pcpu_group_info
Till now, non-linear cpu->unit map was expressed using an integer
array which maps each cpu to a unit and used only by lpage allocator.
Although how many units have been placed in a single contiguos area
(group) is known while building unit_map, the information is lost when
the result is recorded into the unit_map array. For lpage allocator,
as all allocations are done by lpages and whether two adjacent lpages
are in the same group or not is irrelevant, this didn't cause any
problem. Non-linear cpu->unit mapping will be used for sparse
embedding and this grouping information is necessary for that.
This patch introduces pcpu_alloc_info which contains all the
information necessary for initializing percpu allocator.
pcpu_alloc_info contains array of pcpu_group_info which describes how
units are grouped and mapped to cpus. pcpu_group_info also has
base_offset field to specify its offset from the chunk's base address.
pcpu_build_alloc_info() initializes this field as if all groups are
allocated back-to-back as is currently done but this will be used to
sparsely place groups.
pcpu_alloc_info is a rather complex data structure which contains a
flexible array which in turn points to nested cpu_map arrays.
* pcpu_alloc_alloc_info() and pcpu_free_alloc_info() are provided to
help dealing with pcpu_alloc_info.
* pcpu_lpage_build_unit_map() is updated to build pcpu_alloc_info,
generalized and renamed to pcpu_build_alloc_info().
@cpu_distance_fn may be NULL indicating that all cpus are of
LOCAL_DISTANCE.
* pcpul_lpage_dump_cfg() is updated to process pcpu_alloc_info,
generalized and renamed to pcpu_dump_alloc_info(). It now also
prints which group each alloc unit belongs to.
* pcpu_setup_first_chunk() now takes pcpu_alloc_info instead of the
separate parameters. All first chunk allocators are updated to use
pcpu_build_alloc_info() to build alloc_info and call
pcpu_setup_first_chunk() with it. This has the side effect of
packing units for sparse possible cpus. ie. if cpus 0, 2 and 4 are
possible, they'll be assigned unit 0, 1 and 2 instead of 0, 2 and 4.
* x86 setup_pcpu_lpage() is updated to deal with alloc_info.
* sparc64 setup_per_cpu_areas() is updated to build alloc_info.
Although the changes made by this patch are pretty pervasive, it
doesn't cause any behavior difference other than packing of sparse
cpus. It mostly changes how information is passed among
initialization functions and makes room for more flexibility.
Signed-off-by: Tejun Heo <tj@kernel.org>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: David Miller <davem@davemloft.net>
2009-08-14 08:00:51 +02:00
|
|
|
pcpu_free_alloc_info(ai);
|
2009-08-14 08:00:51 +02:00
|
|
|
return rc;
|
2009-07-04 01:10:59 +02:00
|
|
|
}
|
2009-08-14 08:00:49 +02:00
|
|
|
#endif /* CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK */
|
2009-07-04 01:10:59 +02:00
|
|
|
|
2009-03-30 12:07:44 +02:00
|
|
|
/*
|
|
|
|
* Generic percpu area setup.
|
|
|
|
*
|
|
|
|
* The embedding helper is used because its behavior closely resembles
|
|
|
|
* the original non-dynamic generic percpu area setup. This is
|
|
|
|
* important because many archs have addressing restrictions and might
|
|
|
|
* fail if the percpu area is located far away from the previous
|
|
|
|
* location. As an added bonus, in non-NUMA cases, embedding is
|
|
|
|
* generally a good idea TLB-wise because percpu area can piggy back
|
|
|
|
* on the physical linear memory mapping which uses large page
|
|
|
|
* mappings on applicable archs.
|
|
|
|
*/
|
|
|
|
#ifndef CONFIG_HAVE_SETUP_PER_CPU_AREA
|
|
|
|
unsigned long __per_cpu_offset[NR_CPUS] __read_mostly;
|
|
|
|
EXPORT_SYMBOL(__per_cpu_offset);
|
|
|
|
|
2009-08-14 08:00:52 +02:00
|
|
|
static void * __init pcpu_dfl_fc_alloc(unsigned int cpu, size_t size,
|
|
|
|
size_t align)
|
|
|
|
{
|
|
|
|
return __alloc_bootmem_nopanic(size, align, __pa(MAX_DMA_ADDRESS));
|
|
|
|
}
|
2009-03-10 08:27:48 +01:00
|
|
|
|
2009-08-14 08:00:52 +02:00
|
|
|
static void __init pcpu_dfl_fc_free(void *ptr, size_t size)
|
|
|
|
{
|
|
|
|
free_bootmem(__pa(ptr), size);
|
|
|
|
}
|
|
|
|
|
2009-03-30 12:07:44 +02:00
|
|
|
void __init setup_per_cpu_areas(void)
|
|
|
|
{
|
|
|
|
unsigned long delta;
|
|
|
|
unsigned int cpu;
|
2009-08-14 08:00:51 +02:00
|
|
|
int rc;
|
2009-03-30 12:07:44 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Always reserve area for module percpu variables. That's
|
|
|
|
* what the legacy allocator did.
|
|
|
|
*/
|
2009-08-14 08:00:51 +02:00
|
|
|
rc = pcpu_embed_first_chunk(PERCPU_MODULE_RESERVE,
|
2009-08-14 08:00:52 +02:00
|
|
|
PERCPU_DYNAMIC_RESERVE, PAGE_SIZE, NULL,
|
|
|
|
pcpu_dfl_fc_alloc, pcpu_dfl_fc_free);
|
2009-08-14 08:00:51 +02:00
|
|
|
if (rc < 0)
|
2009-03-30 12:07:44 +02:00
|
|
|
panic("Failed to initialized percpu areas.");
|
|
|
|
|
|
|
|
delta = (unsigned long)pcpu_base_addr - (unsigned long)__per_cpu_start;
|
|
|
|
for_each_possible_cpu(cpu)
|
2009-08-14 08:00:51 +02:00
|
|
|
__per_cpu_offset[cpu] = delta + pcpu_unit_offsets[cpu];
|
2009-03-10 08:27:48 +01:00
|
|
|
}
|
2009-03-30 12:07:44 +02:00
|
|
|
#endif /* CONFIG_HAVE_SETUP_PER_CPU_AREA */
|