percpu.c 36.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
/*
 * 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
11 12 13 14 15 16
 * chunk is consisted of nr_cpu_ids 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
17 18 19 20 21 22 23 24 25
 *
 *  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,
 * c1:u1, c1:u2 and c1:u3.  Percpu access can be done by configuring
26
 * percpu base registers pcpu_unit_size apart.
27 28 29 30 31 32 33 34 35 36 37 38 39 40
 *
 * There are usually many small percpu allocations many of them as
 * small as 4 bytes.  The allocator organizes chunks into lists
 * 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.
41 42
 * Chunks can be determined from the address using the index field
 * in the page struct. The index field contains a pointer to the chunk.
43 44 45 46 47 48
 *
 * To use this allocator, arch code should do the followings.
 *
 * - define CONFIG_HAVE_DYNAMIC_PER_CPU_AREA
 *
 * - define __addr_to_pcpu_ptr() and __pcpu_ptr_to_addr() to translate
49 50
 *   regular address to percpu pointer and back if they need to be
 *   different from the default
51
 *
52 53
 * - use pcpu_setup_first_chunk() during percpu area initialization to
 *   setup the first chunk containing the kernel static percpu area
54 55 56 57 58 59 60 61 62 63 64
 */

#include <linux/bitmap.h>
#include <linux/bootmem.h>
#include <linux/list.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/percpu.h>
#include <linux/pfn.h>
#include <linux/slab.h>
65
#include <linux/spinlock.h>
66
#include <linux/vmalloc.h>
67
#include <linux/workqueue.h>
68 69

#include <asm/cacheflush.h>
70
#include <asm/sections.h>
71 72 73 74 75
#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 */

76 77 78 79 80 81 82 83 84 85 86 87
/* 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

88 89 90 91 92 93 94 95
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 */
	struct vm_struct	*vm;		/* mapped vmalloc region */
	int			map_used;	/* # of map entries used */
	int			map_alloc;	/* # of map entries allocated */
	int			*map;		/* allocation map */
96
	bool			immutable;	/* no [de]population allowed */
97 98
	struct page		**page;		/* points to page array */
	struct page		*page_ar[];	/* #cpus * UNIT_PAGES */
99 100
};

101 102 103 104 105
static int pcpu_unit_pages __read_mostly;
static int pcpu_unit_size __read_mostly;
static int pcpu_chunk_size __read_mostly;
static int pcpu_nr_slots __read_mostly;
static size_t pcpu_chunk_struct_size __read_mostly;
106 107

/* the address of the first chunk which starts with the kernel static area */
108
void *pcpu_base_addr __read_mostly;
109 110
EXPORT_SYMBOL_GPL(pcpu_base_addr);

111 112 113 114 115 116 117 118 119 120 121 122 123 124
/*
 * 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.
 */
125 126 127
static struct pcpu_chunk *pcpu_reserved_chunk;
static int pcpu_reserved_chunk_limit;

128
/*
129 130 131 132 133
 * Synchronization rules.
 *
 * There are two locks - pcpu_alloc_mutex and pcpu_lock.  The former
 * protects allocation/reclaim paths, chunks and chunk->page arrays.
 * The latter is a spinlock and protects the index data structures -
134
 * chunk slots, chunks and area maps in chunks.
135 136 137 138 139 140 141 142 143 144 145 146 147
 *
 * 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.
148
 */
149 150
static DEFINE_MUTEX(pcpu_alloc_mutex);	/* protects whole alloc and reclaim */
static DEFINE_SPINLOCK(pcpu_lock);	/* protects index data structures */
151

152
static struct list_head *pcpu_slot __read_mostly; /* chunk list slots */
153

154 155 156 157
/* 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);

158
static int __pcpu_size_to_slot(int size)
159
{
T
Tejun Heo 已提交
160
	int highbit = fls(size);	/* size is in bytes */
161 162 163
	return max(highbit - PCPU_SLOT_BASE_SHIFT + 2, 1);
}

164 165 166 167 168 169 170
static int pcpu_size_to_slot(int size)
{
	if (size == pcpu_unit_size)
		return pcpu_nr_slots - 1;
	return __pcpu_size_to_slot(size);
}

171 172 173 174 175 176 177 178 179 180
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)
{
181
	return cpu * pcpu_unit_pages + page_idx;
182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
}

static struct page **pcpu_chunk_pagep(struct pcpu_chunk *chunk,
				      unsigned int cpu, int page_idx)
{
	return &chunk->page[pcpu_page_idx(cpu, page_idx)];
}

static unsigned long pcpu_chunk_addr(struct pcpu_chunk *chunk,
				     unsigned int cpu, int page_idx)
{
	return (unsigned long)chunk->vm->addr +
		(pcpu_page_idx(cpu, page_idx) << PAGE_SHIFT);
}

static bool pcpu_chunk_page_occupied(struct pcpu_chunk *chunk,
				     int page_idx)
{
	return *pcpu_chunk_pagep(chunk, 0, page_idx) != NULL;
}

203 204 205 206 207 208 209 210 211 212 213 214
/* 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;
}

215
/**
216 217
 * pcpu_mem_alloc - allocate memory
 * @size: bytes to allocate
218
 *
219 220 221
 * Allocate @size bytes.  If @size is smaller than PAGE_SIZE,
 * kzalloc() is used; otherwise, vmalloc() is used.  The returned
 * memory is always zeroed.
222
 *
223 224 225
 * CONTEXT:
 * Does GFP_KERNEL allocation.
 *
226
 * RETURNS:
227
 * Pointer to the allocated area on success, NULL on failure.
228
 */
229
static void *pcpu_mem_alloc(size_t size)
230
{
231 232 233 234 235 236 237 238 239
	if (size <= PAGE_SIZE)
		return kzalloc(size, GFP_KERNEL);
	else {
		void *ptr = vmalloc(size);
		if (ptr)
			memset(ptr, 0, size);
		return ptr;
	}
}
240

241 242 243 244 245 246 247 248 249
/**
 * 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)
{
250
	if (size <= PAGE_SIZE)
251
		kfree(ptr);
252
	else
253
		vfree(ptr);
254 255 256 257 258 259 260 261 262
}

/**
 * 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
263 264
 * moved to the slot.  Note that the reserved chunk is never put on
 * chunk slots.
265 266 267
 *
 * CONTEXT:
 * pcpu_lock.
268 269 270 271 272
 */
static void pcpu_chunk_relocate(struct pcpu_chunk *chunk, int oslot)
{
	int nslot = pcpu_chunk_slot(chunk);

273
	if (chunk != pcpu_reserved_chunk && oslot != nslot) {
274 275 276 277 278 279 280 281
		if (oslot < nslot)
			list_move(&chunk->list, &pcpu_slot[nslot]);
		else
			list_move_tail(&chunk->list, &pcpu_slot[nslot]);
	}
}

/**
282 283
 * pcpu_chunk_addr_search - determine chunk containing specified address
 * @addr: address for which the chunk needs to be determined.
284
 *
285 286 287 288 289
 * RETURNS:
 * The address of the found chunk.
 */
static struct pcpu_chunk *pcpu_chunk_addr_search(void *addr)
{
290
	void *first_start = pcpu_first_chunk->vm->addr;
291

292 293 294 295
	/* is it in the first chunk? */
	if (addr >= first_start && addr < first_start + pcpu_chunk_size) {
		/* is it in the reserved area? */
		if (addr < first_start + pcpu_reserved_chunk_limit)
296
			return pcpu_reserved_chunk;
297
		return pcpu_first_chunk;
298 299
	}

300
	return pcpu_get_page_chunk(vmalloc_to_page(addr));
301 302
}

303 304 305 306 307 308 309 310
/**
 * 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.
 *
311 312 313 314
 * CONTEXT:
 * pcpu_alloc_mutex, pcpu_lock.  pcpu_lock is released and reacquired
 * if area map is extended.
 *
315 316 317 318 319 320 321 322 323 324 325 326 327
 * 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;

328 329
	spin_unlock_irq(&pcpu_lock);

330 331 332 333 334
	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]));
335 336
	if (!new) {
		spin_lock_irq(&pcpu_lock);
337
		return -ENOMEM;
338 339 340 341 342 343 344 345 346
	}

	/*
	 * 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);
347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362

	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;
}

363 364 365 366
/**
 * pcpu_split_block - split a map block
 * @chunk: chunk of interest
 * @i: index of map block to split
T
Tejun Heo 已提交
367 368
 * @head: head size in bytes (can be 0)
 * @tail: tail size in bytes (can be 0)
369 370 371 372 373 374 375 376 377
 *
 * 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.
 *
378
 * @chunk->map must have enough free slots to accomodate the split.
379 380 381
 *
 * CONTEXT:
 * pcpu_lock.
382
 */
383 384
static void pcpu_split_block(struct pcpu_chunk *chunk, int i,
			     int head, int tail)
385 386
{
	int nr_extra = !!head + !!tail;
387

388
	BUG_ON(chunk->map_alloc < chunk->map_used + nr_extra);
389

390
	/* insert new subblocks */
391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
	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
T
Tejun Heo 已提交
408
 * @size: wanted size in bytes
409 410 411 412 413 414
 * @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.
 *
415 416
 * @chunk->map must have at least two free slots.
 *
417 418 419
 * CONTEXT:
 * pcpu_lock.
 *
420
 * RETURNS:
421 422
 * Allocated offset in @chunk on success, -1 if no matching area is
 * found.
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469
 */
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) {
470
			pcpu_split_block(chunk, i, head, tail);
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496
			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);

497 498
	/* tell the upper layer that this chunk has no matching area */
	return -1;
499 500 501 502 503 504 505 506 507 508
}

/**
 * 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.
509 510 511
 *
 * CONTEXT:
 * pcpu_lock.
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
 */
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);
}

/**
 * pcpu_unmap - unmap pages out of a pcpu_chunk
 * @chunk: chunk of interest
 * @page_start: page index of the first page to unmap
 * @page_end: page index of the last page to unmap + 1
552
 * @flush_tlb: whether to flush tlb or not
553 554 555 556 557 558
 *
 * For each cpu, unmap pages [@page_start,@page_end) out of @chunk.
 * If @flush is true, vcache is flushed before unmapping and tlb
 * after.
 */
static void pcpu_unmap(struct pcpu_chunk *chunk, int page_start, int page_end,
559
		       bool flush_tlb)
560
{
561
	unsigned int last = nr_cpu_ids - 1;
562 563
	unsigned int cpu;

564 565 566
	/* unmap must not be done on immutable chunk */
	WARN_ON(chunk->immutable);

567 568 569 570 571
	/*
	 * 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.
	 */
572 573
	flush_cache_vunmap(pcpu_chunk_addr(chunk, 0, page_start),
			   pcpu_chunk_addr(chunk, last, page_end));
574 575 576 577 578 579 580

	for_each_possible_cpu(cpu)
		unmap_kernel_range_noflush(
				pcpu_chunk_addr(chunk, cpu, page_start),
				(page_end - page_start) << PAGE_SHIFT);

	/* ditto as flush_cache_vunmap() */
581
	if (flush_tlb)
582 583 584 585 586 587 588 589
		flush_tlb_kernel_range(pcpu_chunk_addr(chunk, 0, page_start),
				       pcpu_chunk_addr(chunk, last, page_end));
}

/**
 * pcpu_depopulate_chunk - depopulate and unmap an area of a pcpu_chunk
 * @chunk: chunk to depopulate
 * @off: offset to the area to depopulate
T
Tejun Heo 已提交
590
 * @size: size of the area to depopulate in bytes
591 592 593 594 595
 * @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.
596 597 598
 *
 * CONTEXT:
 * pcpu_alloc_mutex.
599
 */
T
Tejun Heo 已提交
600 601
static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk, int off, int size,
				  bool flush)
602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645
{
	int page_start = PFN_DOWN(off);
	int page_end = PFN_UP(off + size);
	int unmap_start = -1;
	int uninitialized_var(unmap_end);
	unsigned int cpu;
	int i;

	for (i = page_start; i < page_end; i++) {
		for_each_possible_cpu(cpu) {
			struct page **pagep = pcpu_chunk_pagep(chunk, cpu, i);

			if (!*pagep)
				continue;

			__free_page(*pagep);

			/*
			 * If it's partial depopulation, it might get
			 * populated or depopulated again.  Mark the
			 * page gone.
			 */
			*pagep = NULL;

			unmap_start = unmap_start < 0 ? i : unmap_start;
			unmap_end = i + 1;
		}
	}

	if (unmap_start >= 0)
		pcpu_unmap(chunk, unmap_start, unmap_end, flush);
}

/**
 * pcpu_map - map pages into a pcpu_chunk
 * @chunk: chunk of interest
 * @page_start: page index of the first page to map
 * @page_end: page index of the last page to map + 1
 *
 * For each cpu, map pages [@page_start,@page_end) into @chunk.
 * vcache is flushed afterwards.
 */
static int pcpu_map(struct pcpu_chunk *chunk, int page_start, int page_end)
{
646
	unsigned int last = nr_cpu_ids - 1;
647 648 649
	unsigned int cpu;
	int err;

650 651 652
	/* map must not be done on immutable chunk */
	WARN_ON(chunk->immutable);

653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672
	for_each_possible_cpu(cpu) {
		err = map_kernel_range_noflush(
				pcpu_chunk_addr(chunk, cpu, page_start),
				(page_end - page_start) << PAGE_SHIFT,
				PAGE_KERNEL,
				pcpu_chunk_pagep(chunk, cpu, page_start));
		if (err < 0)
			return err;
	}

	/* flush at once, please read comments in pcpu_unmap() */
	flush_cache_vmap(pcpu_chunk_addr(chunk, 0, page_start),
			 pcpu_chunk_addr(chunk, last, page_end));
	return 0;
}

/**
 * pcpu_populate_chunk - populate and map an area of a pcpu_chunk
 * @chunk: chunk of interest
 * @off: offset to the area to populate
T
Tejun Heo 已提交
673
 * @size: size of the area to populate in bytes
674 675 676
 *
 * For each cpu, populate and map pages [@page_start,@page_end) into
 * @chunk.  The area is cleared on return.
677 678 679
 *
 * CONTEXT:
 * pcpu_alloc_mutex, does GFP_KERNEL allocation.
680 681 682 683 684 685 686
 */
static int pcpu_populate_chunk(struct pcpu_chunk *chunk, int off, int size)
{
	const gfp_t alloc_mask = GFP_KERNEL | __GFP_HIGHMEM | __GFP_COLD;
	int page_start = PFN_DOWN(off);
	int page_end = PFN_UP(off + size);
	int map_start = -1;
687
	int uninitialized_var(map_end);
688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710
	unsigned int cpu;
	int i;

	for (i = page_start; i < page_end; i++) {
		if (pcpu_chunk_page_occupied(chunk, i)) {
			if (map_start >= 0) {
				if (pcpu_map(chunk, map_start, map_end))
					goto err;
				map_start = -1;
			}
			continue;
		}

		map_start = map_start < 0 ? i : map_start;
		map_end = i + 1;

		for_each_possible_cpu(cpu) {
			struct page **pagep = pcpu_chunk_pagep(chunk, cpu, i);

			*pagep = alloc_pages_node(cpu_to_node(cpu),
						  alloc_mask, 0);
			if (!*pagep)
				goto err;
711
			pcpu_set_page_chunk(*pagep, chunk);
712 713 714 715 716 717 718
		}
	}

	if (map_start >= 0 && pcpu_map(chunk, map_start, map_end))
		goto err;

	for_each_possible_cpu(cpu)
719
		memset(chunk->vm->addr + cpu * pcpu_unit_size + off, 0,
720 721 722 723 724 725 726 727 728 729 730 731 732 733 734
		       size);

	return 0;
err:
	/* likely under heavy memory pressure, give memory back */
	pcpu_depopulate_chunk(chunk, off, size, true);
	return -ENOMEM;
}

static void free_pcpu_chunk(struct pcpu_chunk *chunk)
{
	if (!chunk)
		return;
	if (chunk->vm)
		free_vm_area(chunk->vm);
735
	pcpu_mem_free(chunk->map, chunk->map_alloc * sizeof(chunk->map[0]));
736 737 738 739 740 741 742 743 744 745 746
	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;

747
	chunk->map = pcpu_mem_alloc(PCPU_DFL_MAP_ALLOC * sizeof(chunk->map[0]));
748 749
	chunk->map_alloc = PCPU_DFL_MAP_ALLOC;
	chunk->map[chunk->map_used++] = pcpu_unit_size;
750
	chunk->page = chunk->page_ar;
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765

	chunk->vm = get_vm_area(pcpu_chunk_size, GFP_KERNEL);
	if (!chunk->vm) {
		free_pcpu_chunk(chunk);
		return NULL;
	}

	INIT_LIST_HEAD(&chunk->list);
	chunk->free_size = pcpu_unit_size;
	chunk->contig_hint = pcpu_unit_size;

	return chunk;
}

/**
766
 * pcpu_alloc - the percpu allocator
T
Tejun Heo 已提交
767
 * @size: size of area to allocate in bytes
768
 * @align: alignment of area (max PAGE_SIZE)
769
 * @reserved: allocate from the reserved chunk if available
770
 *
771 772 773 774
 * Allocate percpu area of @size bytes aligned at @align.
 *
 * CONTEXT:
 * Does GFP_KERNEL allocation.
775 776 777 778
 *
 * RETURNS:
 * Percpu pointer to the allocated area on success, NULL on failure.
 */
779
static void *pcpu_alloc(size_t size, size_t align, bool reserved)
780 781 782 783
{
	struct pcpu_chunk *chunk;
	int slot, off;

784
	if (unlikely(!size || size > PCPU_MIN_UNIT_SIZE || align > PAGE_SIZE)) {
785 786 787 788 789
		WARN(true, "illegal size (%zu) or align (%zu) for "
		     "percpu allocation\n", size, align);
		return NULL;
	}

790 791
	mutex_lock(&pcpu_alloc_mutex);
	spin_lock_irq(&pcpu_lock);
792

793 794 795
	/* serve reserved allocations from the reserved chunk if available */
	if (reserved && pcpu_reserved_chunk) {
		chunk = pcpu_reserved_chunk;
796 797
		if (size > chunk->contig_hint ||
		    pcpu_extend_area_map(chunk) < 0)
798
			goto fail_unlock;
799 800 801
		off = pcpu_alloc_area(chunk, size, align);
		if (off >= 0)
			goto area_found;
802
		goto fail_unlock;
803 804
	}

805
restart:
806
	/* search through normal chunks */
807 808 809 810
	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;
811 812 813 814 815 816 817 818 819 820

			switch (pcpu_extend_area_map(chunk)) {
			case 0:
				break;
			case 1:
				goto restart;	/* pcpu_lock dropped, restart */
			default:
				goto fail_unlock;
			}

821 822 823 824 825 826 827
			off = pcpu_alloc_area(chunk, size, align);
			if (off >= 0)
				goto area_found;
		}
	}

	/* hmmm... no space left, create a new chunk */
828 829
	spin_unlock_irq(&pcpu_lock);

830 831
	chunk = alloc_pcpu_chunk();
	if (!chunk)
832 833 834
		goto fail_unlock_mutex;

	spin_lock_irq(&pcpu_lock);
835
	pcpu_chunk_relocate(chunk, -1);
836
	goto restart;
837 838

area_found:
839 840
	spin_unlock_irq(&pcpu_lock);

841 842
	/* populate, map and clear the area */
	if (pcpu_populate_chunk(chunk, off, size)) {
843
		spin_lock_irq(&pcpu_lock);
844
		pcpu_free_area(chunk, off);
845
		goto fail_unlock;
846 847
	}

848 849 850 851 852 853 854 855 856
	mutex_unlock(&pcpu_alloc_mutex);

	return __addr_to_pcpu_ptr(chunk->vm->addr + off);

fail_unlock:
	spin_unlock_irq(&pcpu_lock);
fail_unlock_mutex:
	mutex_unlock(&pcpu_alloc_mutex);
	return NULL;
857
}
858 859 860 861 862 863 864 865 866

/**
 * __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.
 *
867 868 869
 * CONTEXT:
 * Does GFP_KERNEL allocation.
 *
870 871 872 873 874 875 876
 * 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);
}
877 878
EXPORT_SYMBOL_GPL(__alloc_percpu);

879 880 881 882 883 884 885 886 887
/**
 * __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.
 *
888 889 890
 * CONTEXT:
 * Does GFP_KERNEL allocation.
 *
891 892 893 894 895 896 897 898
 * 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);
}

899 900 901 902 903
/**
 * pcpu_reclaim - reclaim fully free chunks, workqueue function
 * @work: unused
 *
 * Reclaim all fully free chunks except for the first one.
904 905 906
 *
 * CONTEXT:
 * workqueue context.
907 908
 */
static void pcpu_reclaim(struct work_struct *work)
909
{
910 911 912 913
	LIST_HEAD(todo);
	struct list_head *head = &pcpu_slot[pcpu_nr_slots - 1];
	struct pcpu_chunk *chunk, *next;

914 915
	mutex_lock(&pcpu_alloc_mutex);
	spin_lock_irq(&pcpu_lock);
916 917 918 919 920 921 922 923 924 925 926

	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);
	}

927 928
	spin_unlock_irq(&pcpu_lock);
	mutex_unlock(&pcpu_alloc_mutex);
929 930 931 932 933

	list_for_each_entry_safe(chunk, next, &todo, list) {
		pcpu_depopulate_chunk(chunk, 0, pcpu_unit_size, false);
		free_pcpu_chunk(chunk);
	}
934 935 936 937 938 939
}

/**
 * free_percpu - free percpu area
 * @ptr: pointer to area to free
 *
940 941 942 943
 * Free percpu area @ptr.
 *
 * CONTEXT:
 * Can be called from atomic context.
944 945 946 947 948
 */
void free_percpu(void *ptr)
{
	void *addr = __pcpu_ptr_to_addr(ptr);
	struct pcpu_chunk *chunk;
949
	unsigned long flags;
950 951 952 953 954
	int off;

	if (!ptr)
		return;

955
	spin_lock_irqsave(&pcpu_lock, flags);
956 957 958 959 960 961

	chunk = pcpu_chunk_addr_search(addr);
	off = addr - chunk->vm->addr;

	pcpu_free_area(chunk, off);

962
	/* if there are more than one fully free chunks, wake up grim reaper */
963 964 965
	if (chunk->free_size == pcpu_unit_size) {
		struct pcpu_chunk *pos;

966
		list_for_each_entry(pos, &pcpu_slot[pcpu_nr_slots - 1], list)
967
			if (pos != chunk) {
968
				schedule_work(&pcpu_reclaim_work);
969 970 971 972
				break;
			}
	}

973
	spin_unlock_irqrestore(&pcpu_lock, flags);
974 975 976 977
}
EXPORT_SYMBOL_GPL(free_percpu);

/**
978 979 980
 * pcpu_setup_first_chunk - initialize the first percpu chunk
 * @get_page_fn: callback to fetch page pointer
 * @static_size: the size of static percpu area in bytes
981
 * @reserved_size: the size of reserved percpu area in bytes
982
 * @dyn_size: free size for dynamic allocation in bytes, -1 for auto
983
 * @unit_size: unit size in bytes, must be multiple of PAGE_SIZE, -1 for auto
984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999
 * @base_addr: mapped address, NULL for auto
 * @populate_pte_fn: callback to allocate pagetable, NULL if unnecessary
 *
 * Initialize the first percpu chunk which contains the kernel static
 * perpcu area.  This function is to be called from arch percpu area
 * setup path.  The first two parameters are mandatory.  The rest are
 * optional.
 *
 * @get_page_fn() should return pointer to percpu page given cpu
 * number and page number.  It should at least return enough pages to
 * cover the static area.  The returned pages for static area should
 * have been initialized with valid data.  If @unit_size is specified,
 * it can also return pages after the static area.  NULL return
 * indicates end of pages for the cpu.  Note that @get_page_fn() must
 * return the same number of pages for all cpus.
 *
1000 1001 1002 1003 1004 1005 1006 1007
 * @reserved_size, if non-zero, specifies the amount of bytes to
 * 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.
 *
1008 1009 1010 1011 1012
 * @dyn_size, if non-negative, determines the number of bytes
 * available for dynamic allocation in the first chunk.  Specifying
 * non-negative value makes percpu leave alone the area beyond
 * @static_size + @reserved_size + @dyn_size.
 *
1013 1014
 * @unit_size, if non-negative, specifies unit size and must be
 * aligned to PAGE_SIZE and equal to or larger than @static_size +
1015
 * @reserved_size + if non-negative, @dyn_size.
1016 1017 1018 1019 1020 1021 1022 1023
 *
 * Non-null @base_addr means that the caller already allocated virtual
 * region for the first chunk and mapped it.  percpu must not mess
 * with the chunk.  Note that @base_addr with 0 @unit_size or non-NULL
 * @populate_pte_fn doesn't make any sense.
 *
 * @populate_pte_fn is used to populate the pagetable.  NULL means the
 * caller already populated the pagetable.
1024
 *
1025 1026 1027 1028 1029 1030 1031
 * 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.
 *
1032 1033 1034 1035
 * RETURNS:
 * The determined pcpu_unit_size which can be used to initialize
 * percpu access.
 */
1036
size_t __init pcpu_setup_first_chunk(pcpu_get_page_fn_t get_page_fn,
1037
				     size_t static_size, size_t reserved_size,
1038
				     ssize_t dyn_size, ssize_t unit_size,
1039
				     void *base_addr,
1040
				     pcpu_populate_pte_fn_t populate_pte_fn)
1041
{
1042
	static struct vm_struct first_vm;
1043
	static int smap[2], dmap[2];
1044 1045
	size_t size_sum = static_size + reserved_size +
			  (dyn_size >= 0 ? dyn_size : 0);
1046
	struct pcpu_chunk *schunk, *dchunk = NULL;
1047
	unsigned int cpu;
1048
	int nr_pages;
1049 1050
	int err, i;

1051
	/* santiy checks */
1052 1053
	BUILD_BUG_ON(ARRAY_SIZE(smap) >= PCPU_DFL_MAP_ALLOC ||
		     ARRAY_SIZE(dmap) >= PCPU_DFL_MAP_ALLOC);
1054
	BUG_ON(!static_size);
1055
	if (unit_size >= 0) {
1056
		BUG_ON(unit_size < size_sum);
1057
		BUG_ON(unit_size & ~PAGE_MASK);
1058 1059
		BUG_ON(unit_size < PCPU_MIN_UNIT_SIZE);
	} else
1060
		BUG_ON(base_addr);
1061
	BUG_ON(base_addr && populate_pte_fn);
1062

1063
	if (unit_size >= 0)
1064 1065 1066
		pcpu_unit_pages = unit_size >> PAGE_SHIFT;
	else
		pcpu_unit_pages = max_t(int, PCPU_MIN_UNIT_SIZE >> PAGE_SHIFT,
1067
					PFN_UP(size_sum));
1068

1069
	pcpu_unit_size = pcpu_unit_pages << PAGE_SHIFT;
1070
	pcpu_chunk_size = nr_cpu_ids * pcpu_unit_size;
1071
	pcpu_chunk_struct_size = sizeof(struct pcpu_chunk)
1072
		+ nr_cpu_ids * pcpu_unit_pages * sizeof(struct page *);
1073

1074
	if (dyn_size < 0)
1075
		dyn_size = pcpu_unit_size - static_size - reserved_size;
1076

1077 1078 1079 1080 1081
	/*
	 * Allocate chunk slots.  The additional last slot is for
	 * empty chunks.
	 */
	pcpu_nr_slots = __pcpu_size_to_slot(pcpu_unit_size) + 2;
1082 1083 1084 1085
	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]);

1086 1087 1088 1089 1090 1091 1092
	/*
	 * 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).
	 */
1093 1094 1095
	schunk = alloc_bootmem(pcpu_chunk_struct_size);
	INIT_LIST_HEAD(&schunk->list);
	schunk->vm = &first_vm;
1096 1097
	schunk->map = smap;
	schunk->map_alloc = ARRAY_SIZE(smap);
1098
	schunk->page = schunk->page_ar;
1099 1100 1101

	if (reserved_size) {
		schunk->free_size = reserved_size;
1102 1103
		pcpu_reserved_chunk = schunk;
		pcpu_reserved_chunk_limit = static_size + reserved_size;
1104 1105 1106 1107
	} else {
		schunk->free_size = dyn_size;
		dyn_size = 0;			/* dynamic area covered */
	}
1108
	schunk->contig_hint = schunk->free_size;
1109

1110 1111 1112 1113
	schunk->map[schunk->map_used++] = -static_size;
	if (schunk->free_size)
		schunk->map[schunk->map_used++] = schunk->free_size;

1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127
	/* init dynamic chunk if necessary */
	if (dyn_size) {
		dchunk = alloc_bootmem(sizeof(struct pcpu_chunk));
		INIT_LIST_HEAD(&dchunk->list);
		dchunk->vm = &first_vm;
		dchunk->map = dmap;
		dchunk->map_alloc = ARRAY_SIZE(dmap);
		dchunk->page = schunk->page_ar;	/* share page map with schunk */

		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;
	}

1128
	/* allocate vm address */
1129 1130
	first_vm.flags = VM_ALLOC;
	first_vm.size = pcpu_chunk_size;
1131 1132

	if (!base_addr)
1133
		vm_area_register_early(&first_vm, PAGE_SIZE);
1134 1135 1136
	else {
		/*
		 * Pages already mapped.  No need to remap into
1137 1138
		 * vmalloc area.  In this case the first chunks can't
		 * be mapped or unmapped by percpu and are marked
1139 1140
		 * immutable.
		 */
1141 1142
		first_vm.addr = base_addr;
		schunk->immutable = true;
1143 1144
		if (dchunk)
			dchunk->immutable = true;
1145 1146 1147 1148
	}

	/* assign pages */
	nr_pages = -1;
1149
	for_each_possible_cpu(cpu) {
1150 1151 1152 1153 1154
		for (i = 0; i < pcpu_unit_pages; i++) {
			struct page *page = get_page_fn(cpu, i);

			if (!page)
				break;
1155
			*pcpu_chunk_pagep(schunk, cpu, i) = page;
1156
		}
1157

1158
		BUG_ON(i < PFN_UP(static_size));
1159 1160 1161 1162 1163

		if (nr_pages < 0)
			nr_pages = i;
		else
			BUG_ON(nr_pages != i);
1164 1165
	}

1166 1167 1168 1169
	/* map them */
	if (populate_pte_fn) {
		for_each_possible_cpu(cpu)
			for (i = 0; i < nr_pages; i++)
1170
				populate_pte_fn(pcpu_chunk_addr(schunk,
1171 1172
								cpu, i));

1173
		err = pcpu_map(schunk, 0, nr_pages);
1174 1175 1176 1177
		if (err)
			panic("failed to setup static percpu area, err=%d\n",
			      err);
	}
1178

1179
	/* link the first chunk in */
1180 1181
	pcpu_first_chunk = dchunk ?: schunk;
	pcpu_chunk_relocate(pcpu_first_chunk, -1);
1182 1183

	/* we're done */
1184
	pcpu_base_addr = (void *)pcpu_chunk_addr(schunk, 0, 0);
1185 1186
	return pcpu_unit_size;
}
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235

/*
 * Embedding first chunk setup helper.
 */
static void *pcpue_ptr __initdata;
static size_t pcpue_size __initdata;
static size_t pcpue_unit_size __initdata;

static struct page * __init pcpue_get_page(unsigned int cpu, int pageno)
{
	size_t off = (size_t)pageno << PAGE_SHIFT;

	if (off >= pcpue_size)
		return NULL;

	return virt_to_page(pcpue_ptr + cpu * pcpue_unit_size + off);
}

/**
 * pcpu_embed_first_chunk - embed the first percpu chunk into bootmem
 * @static_size: the size of static percpu area in bytes
 * @reserved_size: the size of reserved percpu area in bytes
 * @dyn_size: free size for dynamic allocation in bytes, -1 for auto
 * @unit_size: unit size in bytes, must be multiple of PAGE_SIZE, -1 for auto
 *
 * 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
 * as a contiguous area using bootmem allocator and used as-is without
 * being mapped into vmalloc area.  This enables the first chunk to
 * piggy back on the linear physical mapping which often uses larger
 * page size.
 *
 * When @dyn_size is positive, dynamic area might be larger than
 * specified to fill page alignment.  Also, when @dyn_size is auto,
 * @dyn_size does not fill the whole first chunk but only what's
 * necessary for page alignment after static and reserved areas.
 *
 * If the needed size is smaller than the minimum or specified unit
 * size, the leftover is returned to the bootmem allocator.
 *
 * RETURNS:
 * The determined pcpu_unit_size which can be used to initialize
 * percpu access on success, -errno on failure.
 */
ssize_t __init pcpu_embed_first_chunk(size_t static_size, size_t reserved_size,
				      ssize_t dyn_size, ssize_t unit_size)
{
1236
	size_t chunk_size;
1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250
	unsigned int cpu;

	/* determine parameters and allocate */
	pcpue_size = PFN_ALIGN(static_size + reserved_size +
			       (dyn_size >= 0 ? dyn_size : 0));
	if (dyn_size != 0)
		dyn_size = pcpue_size - static_size - reserved_size;

	if (unit_size >= 0) {
		BUG_ON(unit_size < pcpue_size);
		pcpue_unit_size = unit_size;
	} else
		pcpue_unit_size = max_t(size_t, pcpue_size, PCPU_MIN_UNIT_SIZE);

1251
	chunk_size = pcpue_unit_size * nr_cpu_ids;
1252 1253 1254 1255 1256 1257

	pcpue_ptr = __alloc_bootmem_nopanic(chunk_size, PAGE_SIZE,
					    __pa(MAX_DMA_ADDRESS));
	if (!pcpue_ptr) {
		pr_warning("PERCPU: failed to allocate %zu bytes for "
			   "embedding\n", chunk_size);
1258
		return -ENOMEM;
1259
	}
1260 1261

	/* return the leftover and copy */
1262
	for (cpu = 0; cpu < nr_cpu_ids; cpu++) {
1263 1264
		void *ptr = pcpue_ptr + cpu * pcpue_unit_size;

1265 1266 1267 1268 1269 1270
		if (cpu_possible(cpu)) {
			free_bootmem(__pa(ptr + pcpue_size),
				     pcpue_unit_size - pcpue_size);
			memcpy(ptr, __per_cpu_load, static_size);
		} else
			free_bootmem(__pa(ptr), pcpue_unit_size);
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280
	}

	/* we're ready, commit */
	pr_info("PERCPU: Embedded %zu pages at %p, static data %zu bytes\n",
		pcpue_size >> PAGE_SHIFT, pcpue_ptr, static_size);

	return pcpu_setup_first_chunk(pcpue_get_page, static_size,
				      reserved_size, dyn_size,
				      pcpue_unit_size, pcpue_ptr, NULL);
}