xref: /openbmc/linux/mm/percpu.c (revision 6774def6)
1 /*
2  * mm/percpu.c - percpu memory allocator
3  *
4  * Copyright (C) 2009		SUSE Linux Products GmbH
5  * Copyright (C) 2009		Tejun Heo <tj@kernel.org>
6  *
7  * This file is released under the GPLv2.
8  *
9  * This is percpu allocator which can handle both static and dynamic
10  * areas.  Percpu areas are allocated in chunks.  Each chunk is
11  * consisted of boot-time determined number of units and the first
12  * chunk is used for static percpu variables in the kernel image
13  * (special boot time alloc/init handling necessary as these areas
14  * need to be brought up before allocation services are running).
15  * Unit grows as necessary and all units grow or shrink in unison.
16  * When a chunk is filled up, another chunk is allocated.
17  *
18  *  c0                           c1                         c2
19  *  -------------------          -------------------        ------------
20  * | u0 | u1 | u2 | u3 |        | u0 | u1 | u2 | u3 |      | u0 | u1 | u
21  *  -------------------  ......  -------------------  ....  ------------
22  *
23  * Allocation is done in offset-size areas of single unit space.  Ie,
24  * an area of 512 bytes at 6k in c1 occupies 512 bytes at 6k of c1:u0,
25  * c1:u1, c1:u2 and c1:u3.  On UMA, units corresponds directly to
26  * cpus.  On NUMA, the mapping can be non-linear and even sparse.
27  * Percpu access can be done by configuring percpu base registers
28  * according to cpu to unit mapping and pcpu_unit_size.
29  *
30  * There are usually many small percpu allocations many of them being
31  * as small as 4 bytes.  The allocator organizes chunks into lists
32  * according to free size and tries to allocate from the fullest one.
33  * Each chunk keeps the maximum contiguous area size hint which is
34  * guaranteed to be equal to or larger than the maximum contiguous
35  * area in the chunk.  This helps the allocator not to iterate the
36  * chunk maps unnecessarily.
37  *
38  * Allocation state in each chunk is kept using an array of integers
39  * on chunk->map.  A positive value in the map represents a free
40  * region and negative allocated.  Allocation inside a chunk is done
41  * by scanning this map sequentially and serving the first matching
42  * entry.  This is mostly copied from the percpu_modalloc() allocator.
43  * Chunks can be determined from the address using the index field
44  * in the page struct. The index field contains a pointer to the chunk.
45  *
46  * To use this allocator, arch code should do the followings.
47  *
48  * - define __addr_to_pcpu_ptr() and __pcpu_ptr_to_addr() to translate
49  *   regular address to percpu pointer and back if they need to be
50  *   different from the default
51  *
52  * - use pcpu_setup_first_chunk() during percpu area initialization to
53  *   setup the first chunk containing the kernel static percpu area
54  */
55 
56 #include <linux/bitmap.h>
57 #include <linux/bootmem.h>
58 #include <linux/err.h>
59 #include <linux/list.h>
60 #include <linux/log2.h>
61 #include <linux/mm.h>
62 #include <linux/module.h>
63 #include <linux/mutex.h>
64 #include <linux/percpu.h>
65 #include <linux/pfn.h>
66 #include <linux/slab.h>
67 #include <linux/spinlock.h>
68 #include <linux/vmalloc.h>
69 #include <linux/workqueue.h>
70 #include <linux/kmemleak.h>
71 
72 #include <asm/cacheflush.h>
73 #include <asm/sections.h>
74 #include <asm/tlbflush.h>
75 #include <asm/io.h>
76 
77 #define PCPU_SLOT_BASE_SHIFT		5	/* 1-31 shares the same slot */
78 #define PCPU_DFL_MAP_ALLOC		16	/* start a map with 16 ents */
79 #define PCPU_ATOMIC_MAP_MARGIN_LOW	32
80 #define PCPU_ATOMIC_MAP_MARGIN_HIGH	64
81 #define PCPU_EMPTY_POP_PAGES_LOW	2
82 #define PCPU_EMPTY_POP_PAGES_HIGH	4
83 
84 #ifdef CONFIG_SMP
85 /* default addr <-> pcpu_ptr mapping, override in asm/percpu.h if necessary */
86 #ifndef __addr_to_pcpu_ptr
87 #define __addr_to_pcpu_ptr(addr)					\
88 	(void __percpu *)((unsigned long)(addr) -			\
89 			  (unsigned long)pcpu_base_addr	+		\
90 			  (unsigned long)__per_cpu_start)
91 #endif
92 #ifndef __pcpu_ptr_to_addr
93 #define __pcpu_ptr_to_addr(ptr)						\
94 	(void __force *)((unsigned long)(ptr) +				\
95 			 (unsigned long)pcpu_base_addr -		\
96 			 (unsigned long)__per_cpu_start)
97 #endif
98 #else	/* CONFIG_SMP */
99 /* on UP, it's always identity mapped */
100 #define __addr_to_pcpu_ptr(addr)	(void __percpu *)(addr)
101 #define __pcpu_ptr_to_addr(ptr)		(void __force *)(ptr)
102 #endif	/* CONFIG_SMP */
103 
104 struct pcpu_chunk {
105 	struct list_head	list;		/* linked to pcpu_slot lists */
106 	int			free_size;	/* free bytes in the chunk */
107 	int			contig_hint;	/* max contiguous size hint */
108 	void			*base_addr;	/* base address of this chunk */
109 
110 	int			map_used;	/* # of map entries used before the sentry */
111 	int			map_alloc;	/* # of map entries allocated */
112 	int			*map;		/* allocation map */
113 	struct work_struct	map_extend_work;/* async ->map[] extension */
114 
115 	void			*data;		/* chunk data */
116 	int			first_free;	/* no free below this */
117 	bool			immutable;	/* no [de]population allowed */
118 	int			nr_populated;	/* # of populated pages */
119 	unsigned long		populated[];	/* populated bitmap */
120 };
121 
122 static int pcpu_unit_pages __read_mostly;
123 static int pcpu_unit_size __read_mostly;
124 static int pcpu_nr_units __read_mostly;
125 static int pcpu_atom_size __read_mostly;
126 static int pcpu_nr_slots __read_mostly;
127 static size_t pcpu_chunk_struct_size __read_mostly;
128 
129 /* cpus with the lowest and highest unit addresses */
130 static unsigned int pcpu_low_unit_cpu __read_mostly;
131 static unsigned int pcpu_high_unit_cpu __read_mostly;
132 
133 /* the address of the first chunk which starts with the kernel static area */
134 void *pcpu_base_addr __read_mostly;
135 EXPORT_SYMBOL_GPL(pcpu_base_addr);
136 
137 static const int *pcpu_unit_map __read_mostly;		/* cpu -> unit */
138 const unsigned long *pcpu_unit_offsets __read_mostly;	/* cpu -> unit offset */
139 
140 /* group information, used for vm allocation */
141 static int pcpu_nr_groups __read_mostly;
142 static const unsigned long *pcpu_group_offsets __read_mostly;
143 static const size_t *pcpu_group_sizes __read_mostly;
144 
145 /*
146  * The first chunk which always exists.  Note that unlike other
147  * chunks, this one can be allocated and mapped in several different
148  * ways and thus often doesn't live in the vmalloc area.
149  */
150 static struct pcpu_chunk *pcpu_first_chunk;
151 
152 /*
153  * Optional reserved chunk.  This chunk reserves part of the first
154  * chunk and serves it for reserved allocations.  The amount of
155  * reserved offset is in pcpu_reserved_chunk_limit.  When reserved
156  * area doesn't exist, the following variables contain NULL and 0
157  * respectively.
158  */
159 static struct pcpu_chunk *pcpu_reserved_chunk;
160 static int pcpu_reserved_chunk_limit;
161 
162 static DEFINE_SPINLOCK(pcpu_lock);	/* all internal data structures */
163 static DEFINE_MUTEX(pcpu_alloc_mutex);	/* chunk create/destroy, [de]pop */
164 
165 static struct list_head *pcpu_slot __read_mostly; /* chunk list slots */
166 
167 /*
168  * The number of empty populated pages, protected by pcpu_lock.  The
169  * reserved chunk doesn't contribute to the count.
170  */
171 static int pcpu_nr_empty_pop_pages;
172 
173 /*
174  * Balance work is used to populate or destroy chunks asynchronously.  We
175  * try to keep the number of populated free pages between
176  * PCPU_EMPTY_POP_PAGES_LOW and HIGH for atomic allocations and at most one
177  * empty chunk.
178  */
179 static void pcpu_balance_workfn(struct work_struct *work);
180 static DECLARE_WORK(pcpu_balance_work, pcpu_balance_workfn);
181 static bool pcpu_async_enabled __read_mostly;
182 static bool pcpu_atomic_alloc_failed;
183 
184 static void pcpu_schedule_balance_work(void)
185 {
186 	if (pcpu_async_enabled)
187 		schedule_work(&pcpu_balance_work);
188 }
189 
190 static bool pcpu_addr_in_first_chunk(void *addr)
191 {
192 	void *first_start = pcpu_first_chunk->base_addr;
193 
194 	return addr >= first_start && addr < first_start + pcpu_unit_size;
195 }
196 
197 static bool pcpu_addr_in_reserved_chunk(void *addr)
198 {
199 	void *first_start = pcpu_first_chunk->base_addr;
200 
201 	return addr >= first_start &&
202 		addr < first_start + pcpu_reserved_chunk_limit;
203 }
204 
205 static int __pcpu_size_to_slot(int size)
206 {
207 	int highbit = fls(size);	/* size is in bytes */
208 	return max(highbit - PCPU_SLOT_BASE_SHIFT + 2, 1);
209 }
210 
211 static int pcpu_size_to_slot(int size)
212 {
213 	if (size == pcpu_unit_size)
214 		return pcpu_nr_slots - 1;
215 	return __pcpu_size_to_slot(size);
216 }
217 
218 static int pcpu_chunk_slot(const struct pcpu_chunk *chunk)
219 {
220 	if (chunk->free_size < sizeof(int) || chunk->contig_hint < sizeof(int))
221 		return 0;
222 
223 	return pcpu_size_to_slot(chunk->free_size);
224 }
225 
226 /* set the pointer to a chunk in a page struct */
227 static void pcpu_set_page_chunk(struct page *page, struct pcpu_chunk *pcpu)
228 {
229 	page->index = (unsigned long)pcpu;
230 }
231 
232 /* obtain pointer to a chunk from a page struct */
233 static struct pcpu_chunk *pcpu_get_page_chunk(struct page *page)
234 {
235 	return (struct pcpu_chunk *)page->index;
236 }
237 
238 static int __maybe_unused pcpu_page_idx(unsigned int cpu, int page_idx)
239 {
240 	return pcpu_unit_map[cpu] * pcpu_unit_pages + page_idx;
241 }
242 
243 static unsigned long pcpu_chunk_addr(struct pcpu_chunk *chunk,
244 				     unsigned int cpu, int page_idx)
245 {
246 	return (unsigned long)chunk->base_addr + pcpu_unit_offsets[cpu] +
247 		(page_idx << PAGE_SHIFT);
248 }
249 
250 static void __maybe_unused pcpu_next_unpop(struct pcpu_chunk *chunk,
251 					   int *rs, int *re, int end)
252 {
253 	*rs = find_next_zero_bit(chunk->populated, end, *rs);
254 	*re = find_next_bit(chunk->populated, end, *rs + 1);
255 }
256 
257 static void __maybe_unused pcpu_next_pop(struct pcpu_chunk *chunk,
258 					 int *rs, int *re, int end)
259 {
260 	*rs = find_next_bit(chunk->populated, end, *rs);
261 	*re = find_next_zero_bit(chunk->populated, end, *rs + 1);
262 }
263 
264 /*
265  * (Un)populated page region iterators.  Iterate over (un)populated
266  * page regions between @start and @end in @chunk.  @rs and @re should
267  * be integer variables and will be set to start and end page index of
268  * the current region.
269  */
270 #define pcpu_for_each_unpop_region(chunk, rs, re, start, end)		    \
271 	for ((rs) = (start), pcpu_next_unpop((chunk), &(rs), &(re), (end)); \
272 	     (rs) < (re);						    \
273 	     (rs) = (re) + 1, pcpu_next_unpop((chunk), &(rs), &(re), (end)))
274 
275 #define pcpu_for_each_pop_region(chunk, rs, re, start, end)		    \
276 	for ((rs) = (start), pcpu_next_pop((chunk), &(rs), &(re), (end));   \
277 	     (rs) < (re);						    \
278 	     (rs) = (re) + 1, pcpu_next_pop((chunk), &(rs), &(re), (end)))
279 
280 /**
281  * pcpu_mem_zalloc - allocate memory
282  * @size: bytes to allocate
283  *
284  * Allocate @size bytes.  If @size is smaller than PAGE_SIZE,
285  * kzalloc() is used; otherwise, vzalloc() is used.  The returned
286  * memory is always zeroed.
287  *
288  * CONTEXT:
289  * Does GFP_KERNEL allocation.
290  *
291  * RETURNS:
292  * Pointer to the allocated area on success, NULL on failure.
293  */
294 static void *pcpu_mem_zalloc(size_t size)
295 {
296 	if (WARN_ON_ONCE(!slab_is_available()))
297 		return NULL;
298 
299 	if (size <= PAGE_SIZE)
300 		return kzalloc(size, GFP_KERNEL);
301 	else
302 		return vzalloc(size);
303 }
304 
305 /**
306  * pcpu_mem_free - free memory
307  * @ptr: memory to free
308  * @size: size of the area
309  *
310  * Free @ptr.  @ptr should have been allocated using pcpu_mem_zalloc().
311  */
312 static void pcpu_mem_free(void *ptr, size_t size)
313 {
314 	if (size <= PAGE_SIZE)
315 		kfree(ptr);
316 	else
317 		vfree(ptr);
318 }
319 
320 /**
321  * pcpu_count_occupied_pages - count the number of pages an area occupies
322  * @chunk: chunk of interest
323  * @i: index of the area in question
324  *
325  * Count the number of pages chunk's @i'th area occupies.  When the area's
326  * start and/or end address isn't aligned to page boundary, the straddled
327  * page is included in the count iff the rest of the page is free.
328  */
329 static int pcpu_count_occupied_pages(struct pcpu_chunk *chunk, int i)
330 {
331 	int off = chunk->map[i] & ~1;
332 	int end = chunk->map[i + 1] & ~1;
333 
334 	if (!PAGE_ALIGNED(off) && i > 0) {
335 		int prev = chunk->map[i - 1];
336 
337 		if (!(prev & 1) && prev <= round_down(off, PAGE_SIZE))
338 			off = round_down(off, PAGE_SIZE);
339 	}
340 
341 	if (!PAGE_ALIGNED(end) && i + 1 < chunk->map_used) {
342 		int next = chunk->map[i + 1];
343 		int nend = chunk->map[i + 2] & ~1;
344 
345 		if (!(next & 1) && nend >= round_up(end, PAGE_SIZE))
346 			end = round_up(end, PAGE_SIZE);
347 	}
348 
349 	return max_t(int, PFN_DOWN(end) - PFN_UP(off), 0);
350 }
351 
352 /**
353  * pcpu_chunk_relocate - put chunk in the appropriate chunk slot
354  * @chunk: chunk of interest
355  * @oslot: the previous slot it was on
356  *
357  * This function is called after an allocation or free changed @chunk.
358  * New slot according to the changed state is determined and @chunk is
359  * moved to the slot.  Note that the reserved chunk is never put on
360  * chunk slots.
361  *
362  * CONTEXT:
363  * pcpu_lock.
364  */
365 static void pcpu_chunk_relocate(struct pcpu_chunk *chunk, int oslot)
366 {
367 	int nslot = pcpu_chunk_slot(chunk);
368 
369 	if (chunk != pcpu_reserved_chunk && oslot != nslot) {
370 		if (oslot < nslot)
371 			list_move(&chunk->list, &pcpu_slot[nslot]);
372 		else
373 			list_move_tail(&chunk->list, &pcpu_slot[nslot]);
374 	}
375 }
376 
377 /**
378  * pcpu_need_to_extend - determine whether chunk area map needs to be extended
379  * @chunk: chunk of interest
380  * @is_atomic: the allocation context
381  *
382  * Determine whether area map of @chunk needs to be extended.  If
383  * @is_atomic, only the amount necessary for a new allocation is
384  * considered; however, async extension is scheduled if the left amount is
385  * low.  If !@is_atomic, it aims for more empty space.  Combined, this
386  * ensures that the map is likely to have enough available space to
387  * accomodate atomic allocations which can't extend maps directly.
388  *
389  * CONTEXT:
390  * pcpu_lock.
391  *
392  * RETURNS:
393  * New target map allocation length if extension is necessary, 0
394  * otherwise.
395  */
396 static int pcpu_need_to_extend(struct pcpu_chunk *chunk, bool is_atomic)
397 {
398 	int margin, new_alloc;
399 
400 	if (is_atomic) {
401 		margin = 3;
402 
403 		if (chunk->map_alloc <
404 		    chunk->map_used + PCPU_ATOMIC_MAP_MARGIN_LOW &&
405 		    pcpu_async_enabled)
406 			schedule_work(&chunk->map_extend_work);
407 	} else {
408 		margin = PCPU_ATOMIC_MAP_MARGIN_HIGH;
409 	}
410 
411 	if (chunk->map_alloc >= chunk->map_used + margin)
412 		return 0;
413 
414 	new_alloc = PCPU_DFL_MAP_ALLOC;
415 	while (new_alloc < chunk->map_used + margin)
416 		new_alloc *= 2;
417 
418 	return new_alloc;
419 }
420 
421 /**
422  * pcpu_extend_area_map - extend area map of a chunk
423  * @chunk: chunk of interest
424  * @new_alloc: new target allocation length of the area map
425  *
426  * Extend area map of @chunk to have @new_alloc entries.
427  *
428  * CONTEXT:
429  * Does GFP_KERNEL allocation.  Grabs and releases pcpu_lock.
430  *
431  * RETURNS:
432  * 0 on success, -errno on failure.
433  */
434 static int pcpu_extend_area_map(struct pcpu_chunk *chunk, int new_alloc)
435 {
436 	int *old = NULL, *new = NULL;
437 	size_t old_size = 0, new_size = new_alloc * sizeof(new[0]);
438 	unsigned long flags;
439 
440 	new = pcpu_mem_zalloc(new_size);
441 	if (!new)
442 		return -ENOMEM;
443 
444 	/* acquire pcpu_lock and switch to new area map */
445 	spin_lock_irqsave(&pcpu_lock, flags);
446 
447 	if (new_alloc <= chunk->map_alloc)
448 		goto out_unlock;
449 
450 	old_size = chunk->map_alloc * sizeof(chunk->map[0]);
451 	old = chunk->map;
452 
453 	memcpy(new, old, old_size);
454 
455 	chunk->map_alloc = new_alloc;
456 	chunk->map = new;
457 	new = NULL;
458 
459 out_unlock:
460 	spin_unlock_irqrestore(&pcpu_lock, flags);
461 
462 	/*
463 	 * pcpu_mem_free() might end up calling vfree() which uses
464 	 * IRQ-unsafe lock and thus can't be called under pcpu_lock.
465 	 */
466 	pcpu_mem_free(old, old_size);
467 	pcpu_mem_free(new, new_size);
468 
469 	return 0;
470 }
471 
472 static void pcpu_map_extend_workfn(struct work_struct *work)
473 {
474 	struct pcpu_chunk *chunk = container_of(work, struct pcpu_chunk,
475 						map_extend_work);
476 	int new_alloc;
477 
478 	spin_lock_irq(&pcpu_lock);
479 	new_alloc = pcpu_need_to_extend(chunk, false);
480 	spin_unlock_irq(&pcpu_lock);
481 
482 	if (new_alloc)
483 		pcpu_extend_area_map(chunk, new_alloc);
484 }
485 
486 /**
487  * pcpu_fit_in_area - try to fit the requested allocation in a candidate area
488  * @chunk: chunk the candidate area belongs to
489  * @off: the offset to the start of the candidate area
490  * @this_size: the size of the candidate area
491  * @size: the size of the target allocation
492  * @align: the alignment of the target allocation
493  * @pop_only: only allocate from already populated region
494  *
495  * We're trying to allocate @size bytes aligned at @align.  @chunk's area
496  * at @off sized @this_size is a candidate.  This function determines
497  * whether the target allocation fits in the candidate area and returns the
498  * number of bytes to pad after @off.  If the target area doesn't fit, -1
499  * is returned.
500  *
501  * If @pop_only is %true, this function only considers the already
502  * populated part of the candidate area.
503  */
504 static int pcpu_fit_in_area(struct pcpu_chunk *chunk, int off, int this_size,
505 			    int size, int align, bool pop_only)
506 {
507 	int cand_off = off;
508 
509 	while (true) {
510 		int head = ALIGN(cand_off, align) - off;
511 		int page_start, page_end, rs, re;
512 
513 		if (this_size < head + size)
514 			return -1;
515 
516 		if (!pop_only)
517 			return head;
518 
519 		/*
520 		 * If the first unpopulated page is beyond the end of the
521 		 * allocation, the whole allocation is populated;
522 		 * otherwise, retry from the end of the unpopulated area.
523 		 */
524 		page_start = PFN_DOWN(head + off);
525 		page_end = PFN_UP(head + off + size);
526 
527 		rs = page_start;
528 		pcpu_next_unpop(chunk, &rs, &re, PFN_UP(off + this_size));
529 		if (rs >= page_end)
530 			return head;
531 		cand_off = re * PAGE_SIZE;
532 	}
533 }
534 
535 /**
536  * pcpu_alloc_area - allocate area from a pcpu_chunk
537  * @chunk: chunk of interest
538  * @size: wanted size in bytes
539  * @align: wanted align
540  * @pop_only: allocate only from the populated area
541  * @occ_pages_p: out param for the number of pages the area occupies
542  *
543  * Try to allocate @size bytes area aligned at @align from @chunk.
544  * Note that this function only allocates the offset.  It doesn't
545  * populate or map the area.
546  *
547  * @chunk->map must have at least two free slots.
548  *
549  * CONTEXT:
550  * pcpu_lock.
551  *
552  * RETURNS:
553  * Allocated offset in @chunk on success, -1 if no matching area is
554  * found.
555  */
556 static int pcpu_alloc_area(struct pcpu_chunk *chunk, int size, int align,
557 			   bool pop_only, int *occ_pages_p)
558 {
559 	int oslot = pcpu_chunk_slot(chunk);
560 	int max_contig = 0;
561 	int i, off;
562 	bool seen_free = false;
563 	int *p;
564 
565 	for (i = chunk->first_free, p = chunk->map + i; i < chunk->map_used; i++, p++) {
566 		int head, tail;
567 		int this_size;
568 
569 		off = *p;
570 		if (off & 1)
571 			continue;
572 
573 		this_size = (p[1] & ~1) - off;
574 
575 		head = pcpu_fit_in_area(chunk, off, this_size, size, align,
576 					pop_only);
577 		if (head < 0) {
578 			if (!seen_free) {
579 				chunk->first_free = i;
580 				seen_free = true;
581 			}
582 			max_contig = max(this_size, max_contig);
583 			continue;
584 		}
585 
586 		/*
587 		 * If head is small or the previous block is free,
588 		 * merge'em.  Note that 'small' is defined as smaller
589 		 * than sizeof(int), which is very small but isn't too
590 		 * uncommon for percpu allocations.
591 		 */
592 		if (head && (head < sizeof(int) || !(p[-1] & 1))) {
593 			*p = off += head;
594 			if (p[-1] & 1)
595 				chunk->free_size -= head;
596 			else
597 				max_contig = max(*p - p[-1], max_contig);
598 			this_size -= head;
599 			head = 0;
600 		}
601 
602 		/* if tail is small, just keep it around */
603 		tail = this_size - head - size;
604 		if (tail < sizeof(int)) {
605 			tail = 0;
606 			size = this_size - head;
607 		}
608 
609 		/* split if warranted */
610 		if (head || tail) {
611 			int nr_extra = !!head + !!tail;
612 
613 			/* insert new subblocks */
614 			memmove(p + nr_extra + 1, p + 1,
615 				sizeof(chunk->map[0]) * (chunk->map_used - i));
616 			chunk->map_used += nr_extra;
617 
618 			if (head) {
619 				if (!seen_free) {
620 					chunk->first_free = i;
621 					seen_free = true;
622 				}
623 				*++p = off += head;
624 				++i;
625 				max_contig = max(head, max_contig);
626 			}
627 			if (tail) {
628 				p[1] = off + size;
629 				max_contig = max(tail, max_contig);
630 			}
631 		}
632 
633 		if (!seen_free)
634 			chunk->first_free = i + 1;
635 
636 		/* update hint and mark allocated */
637 		if (i + 1 == chunk->map_used)
638 			chunk->contig_hint = max_contig; /* fully scanned */
639 		else
640 			chunk->contig_hint = max(chunk->contig_hint,
641 						 max_contig);
642 
643 		chunk->free_size -= size;
644 		*p |= 1;
645 
646 		*occ_pages_p = pcpu_count_occupied_pages(chunk, i);
647 		pcpu_chunk_relocate(chunk, oslot);
648 		return off;
649 	}
650 
651 	chunk->contig_hint = max_contig;	/* fully scanned */
652 	pcpu_chunk_relocate(chunk, oslot);
653 
654 	/* tell the upper layer that this chunk has no matching area */
655 	return -1;
656 }
657 
658 /**
659  * pcpu_free_area - free area to a pcpu_chunk
660  * @chunk: chunk of interest
661  * @freeme: offset of area to free
662  * @occ_pages_p: out param for the number of pages the area occupies
663  *
664  * Free area starting from @freeme to @chunk.  Note that this function
665  * only modifies the allocation map.  It doesn't depopulate or unmap
666  * the area.
667  *
668  * CONTEXT:
669  * pcpu_lock.
670  */
671 static void pcpu_free_area(struct pcpu_chunk *chunk, int freeme,
672 			   int *occ_pages_p)
673 {
674 	int oslot = pcpu_chunk_slot(chunk);
675 	int off = 0;
676 	unsigned i, j;
677 	int to_free = 0;
678 	int *p;
679 
680 	freeme |= 1;	/* we are searching for <given offset, in use> pair */
681 
682 	i = 0;
683 	j = chunk->map_used;
684 	while (i != j) {
685 		unsigned k = (i + j) / 2;
686 		off = chunk->map[k];
687 		if (off < freeme)
688 			i = k + 1;
689 		else if (off > freeme)
690 			j = k;
691 		else
692 			i = j = k;
693 	}
694 	BUG_ON(off != freeme);
695 
696 	if (i < chunk->first_free)
697 		chunk->first_free = i;
698 
699 	p = chunk->map + i;
700 	*p = off &= ~1;
701 	chunk->free_size += (p[1] & ~1) - off;
702 
703 	*occ_pages_p = pcpu_count_occupied_pages(chunk, i);
704 
705 	/* merge with next? */
706 	if (!(p[1] & 1))
707 		to_free++;
708 	/* merge with previous? */
709 	if (i > 0 && !(p[-1] & 1)) {
710 		to_free++;
711 		i--;
712 		p--;
713 	}
714 	if (to_free) {
715 		chunk->map_used -= to_free;
716 		memmove(p + 1, p + 1 + to_free,
717 			(chunk->map_used - i) * sizeof(chunk->map[0]));
718 	}
719 
720 	chunk->contig_hint = max(chunk->map[i + 1] - chunk->map[i] - 1, chunk->contig_hint);
721 	pcpu_chunk_relocate(chunk, oslot);
722 }
723 
724 static struct pcpu_chunk *pcpu_alloc_chunk(void)
725 {
726 	struct pcpu_chunk *chunk;
727 
728 	chunk = pcpu_mem_zalloc(pcpu_chunk_struct_size);
729 	if (!chunk)
730 		return NULL;
731 
732 	chunk->map = pcpu_mem_zalloc(PCPU_DFL_MAP_ALLOC *
733 						sizeof(chunk->map[0]));
734 	if (!chunk->map) {
735 		pcpu_mem_free(chunk, pcpu_chunk_struct_size);
736 		return NULL;
737 	}
738 
739 	chunk->map_alloc = PCPU_DFL_MAP_ALLOC;
740 	chunk->map[0] = 0;
741 	chunk->map[1] = pcpu_unit_size | 1;
742 	chunk->map_used = 1;
743 
744 	INIT_LIST_HEAD(&chunk->list);
745 	INIT_WORK(&chunk->map_extend_work, pcpu_map_extend_workfn);
746 	chunk->free_size = pcpu_unit_size;
747 	chunk->contig_hint = pcpu_unit_size;
748 
749 	return chunk;
750 }
751 
752 static void pcpu_free_chunk(struct pcpu_chunk *chunk)
753 {
754 	if (!chunk)
755 		return;
756 	pcpu_mem_free(chunk->map, chunk->map_alloc * sizeof(chunk->map[0]));
757 	pcpu_mem_free(chunk, pcpu_chunk_struct_size);
758 }
759 
760 /**
761  * pcpu_chunk_populated - post-population bookkeeping
762  * @chunk: pcpu_chunk which got populated
763  * @page_start: the start page
764  * @page_end: the end page
765  *
766  * Pages in [@page_start,@page_end) have been populated to @chunk.  Update
767  * the bookkeeping information accordingly.  Must be called after each
768  * successful population.
769  */
770 static void pcpu_chunk_populated(struct pcpu_chunk *chunk,
771 				 int page_start, int page_end)
772 {
773 	int nr = page_end - page_start;
774 
775 	lockdep_assert_held(&pcpu_lock);
776 
777 	bitmap_set(chunk->populated, page_start, nr);
778 	chunk->nr_populated += nr;
779 	pcpu_nr_empty_pop_pages += nr;
780 }
781 
782 /**
783  * pcpu_chunk_depopulated - post-depopulation bookkeeping
784  * @chunk: pcpu_chunk which got depopulated
785  * @page_start: the start page
786  * @page_end: the end page
787  *
788  * Pages in [@page_start,@page_end) have been depopulated from @chunk.
789  * Update the bookkeeping information accordingly.  Must be called after
790  * each successful depopulation.
791  */
792 static void pcpu_chunk_depopulated(struct pcpu_chunk *chunk,
793 				   int page_start, int page_end)
794 {
795 	int nr = page_end - page_start;
796 
797 	lockdep_assert_held(&pcpu_lock);
798 
799 	bitmap_clear(chunk->populated, page_start, nr);
800 	chunk->nr_populated -= nr;
801 	pcpu_nr_empty_pop_pages -= nr;
802 }
803 
804 /*
805  * Chunk management implementation.
806  *
807  * To allow different implementations, chunk alloc/free and
808  * [de]population are implemented in a separate file which is pulled
809  * into this file and compiled together.  The following functions
810  * should be implemented.
811  *
812  * pcpu_populate_chunk		- populate the specified range of a chunk
813  * pcpu_depopulate_chunk	- depopulate the specified range of a chunk
814  * pcpu_create_chunk		- create a new chunk
815  * pcpu_destroy_chunk		- destroy a chunk, always preceded by full depop
816  * pcpu_addr_to_page		- translate address to physical address
817  * pcpu_verify_alloc_info	- check alloc_info is acceptable during init
818  */
819 static int pcpu_populate_chunk(struct pcpu_chunk *chunk, int off, int size);
820 static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk, int off, int size);
821 static struct pcpu_chunk *pcpu_create_chunk(void);
822 static void pcpu_destroy_chunk(struct pcpu_chunk *chunk);
823 static struct page *pcpu_addr_to_page(void *addr);
824 static int __init pcpu_verify_alloc_info(const struct pcpu_alloc_info *ai);
825 
826 #ifdef CONFIG_NEED_PER_CPU_KM
827 #include "percpu-km.c"
828 #else
829 #include "percpu-vm.c"
830 #endif
831 
832 /**
833  * pcpu_chunk_addr_search - determine chunk containing specified address
834  * @addr: address for which the chunk needs to be determined.
835  *
836  * RETURNS:
837  * The address of the found chunk.
838  */
839 static struct pcpu_chunk *pcpu_chunk_addr_search(void *addr)
840 {
841 	/* is it in the first chunk? */
842 	if (pcpu_addr_in_first_chunk(addr)) {
843 		/* is it in the reserved area? */
844 		if (pcpu_addr_in_reserved_chunk(addr))
845 			return pcpu_reserved_chunk;
846 		return pcpu_first_chunk;
847 	}
848 
849 	/*
850 	 * The address is relative to unit0 which might be unused and
851 	 * thus unmapped.  Offset the address to the unit space of the
852 	 * current processor before looking it up in the vmalloc
853 	 * space.  Note that any possible cpu id can be used here, so
854 	 * there's no need to worry about preemption or cpu hotplug.
855 	 */
856 	addr += pcpu_unit_offsets[raw_smp_processor_id()];
857 	return pcpu_get_page_chunk(pcpu_addr_to_page(addr));
858 }
859 
860 /**
861  * pcpu_alloc - the percpu allocator
862  * @size: size of area to allocate in bytes
863  * @align: alignment of area (max PAGE_SIZE)
864  * @reserved: allocate from the reserved chunk if available
865  * @gfp: allocation flags
866  *
867  * Allocate percpu area of @size bytes aligned at @align.  If @gfp doesn't
868  * contain %GFP_KERNEL, the allocation is atomic.
869  *
870  * RETURNS:
871  * Percpu pointer to the allocated area on success, NULL on failure.
872  */
873 static void __percpu *pcpu_alloc(size_t size, size_t align, bool reserved,
874 				 gfp_t gfp)
875 {
876 	static int warn_limit = 10;
877 	struct pcpu_chunk *chunk;
878 	const char *err;
879 	bool is_atomic = (gfp & GFP_KERNEL) != GFP_KERNEL;
880 	int occ_pages = 0;
881 	int slot, off, new_alloc, cpu, ret;
882 	unsigned long flags;
883 	void __percpu *ptr;
884 
885 	/*
886 	 * We want the lowest bit of offset available for in-use/free
887 	 * indicator, so force >= 16bit alignment and make size even.
888 	 */
889 	if (unlikely(align < 2))
890 		align = 2;
891 
892 	size = ALIGN(size, 2);
893 
894 	if (unlikely(!size || size > PCPU_MIN_UNIT_SIZE || align > PAGE_SIZE)) {
895 		WARN(true, "illegal size (%zu) or align (%zu) for "
896 		     "percpu allocation\n", size, align);
897 		return NULL;
898 	}
899 
900 	spin_lock_irqsave(&pcpu_lock, flags);
901 
902 	/* serve reserved allocations from the reserved chunk if available */
903 	if (reserved && pcpu_reserved_chunk) {
904 		chunk = pcpu_reserved_chunk;
905 
906 		if (size > chunk->contig_hint) {
907 			err = "alloc from reserved chunk failed";
908 			goto fail_unlock;
909 		}
910 
911 		while ((new_alloc = pcpu_need_to_extend(chunk, is_atomic))) {
912 			spin_unlock_irqrestore(&pcpu_lock, flags);
913 			if (is_atomic ||
914 			    pcpu_extend_area_map(chunk, new_alloc) < 0) {
915 				err = "failed to extend area map of reserved chunk";
916 				goto fail;
917 			}
918 			spin_lock_irqsave(&pcpu_lock, flags);
919 		}
920 
921 		off = pcpu_alloc_area(chunk, size, align, is_atomic,
922 				      &occ_pages);
923 		if (off >= 0)
924 			goto area_found;
925 
926 		err = "alloc from reserved chunk failed";
927 		goto fail_unlock;
928 	}
929 
930 restart:
931 	/* search through normal chunks */
932 	for (slot = pcpu_size_to_slot(size); slot < pcpu_nr_slots; slot++) {
933 		list_for_each_entry(chunk, &pcpu_slot[slot], list) {
934 			if (size > chunk->contig_hint)
935 				continue;
936 
937 			new_alloc = pcpu_need_to_extend(chunk, is_atomic);
938 			if (new_alloc) {
939 				if (is_atomic)
940 					continue;
941 				spin_unlock_irqrestore(&pcpu_lock, flags);
942 				if (pcpu_extend_area_map(chunk,
943 							 new_alloc) < 0) {
944 					err = "failed to extend area map";
945 					goto fail;
946 				}
947 				spin_lock_irqsave(&pcpu_lock, flags);
948 				/*
949 				 * pcpu_lock has been dropped, need to
950 				 * restart cpu_slot list walking.
951 				 */
952 				goto restart;
953 			}
954 
955 			off = pcpu_alloc_area(chunk, size, align, is_atomic,
956 					      &occ_pages);
957 			if (off >= 0)
958 				goto area_found;
959 		}
960 	}
961 
962 	spin_unlock_irqrestore(&pcpu_lock, flags);
963 
964 	/*
965 	 * No space left.  Create a new chunk.  We don't want multiple
966 	 * tasks to create chunks simultaneously.  Serialize and create iff
967 	 * there's still no empty chunk after grabbing the mutex.
968 	 */
969 	if (is_atomic)
970 		goto fail;
971 
972 	mutex_lock(&pcpu_alloc_mutex);
973 
974 	if (list_empty(&pcpu_slot[pcpu_nr_slots - 1])) {
975 		chunk = pcpu_create_chunk();
976 		if (!chunk) {
977 			mutex_unlock(&pcpu_alloc_mutex);
978 			err = "failed to allocate new chunk";
979 			goto fail;
980 		}
981 
982 		spin_lock_irqsave(&pcpu_lock, flags);
983 		pcpu_chunk_relocate(chunk, -1);
984 	} else {
985 		spin_lock_irqsave(&pcpu_lock, flags);
986 	}
987 
988 	mutex_unlock(&pcpu_alloc_mutex);
989 	goto restart;
990 
991 area_found:
992 	spin_unlock_irqrestore(&pcpu_lock, flags);
993 
994 	/* populate if not all pages are already there */
995 	if (!is_atomic) {
996 		int page_start, page_end, rs, re;
997 
998 		mutex_lock(&pcpu_alloc_mutex);
999 
1000 		page_start = PFN_DOWN(off);
1001 		page_end = PFN_UP(off + size);
1002 
1003 		pcpu_for_each_unpop_region(chunk, rs, re, page_start, page_end) {
1004 			WARN_ON(chunk->immutable);
1005 
1006 			ret = pcpu_populate_chunk(chunk, rs, re);
1007 
1008 			spin_lock_irqsave(&pcpu_lock, flags);
1009 			if (ret) {
1010 				mutex_unlock(&pcpu_alloc_mutex);
1011 				pcpu_free_area(chunk, off, &occ_pages);
1012 				err = "failed to populate";
1013 				goto fail_unlock;
1014 			}
1015 			pcpu_chunk_populated(chunk, rs, re);
1016 			spin_unlock_irqrestore(&pcpu_lock, flags);
1017 		}
1018 
1019 		mutex_unlock(&pcpu_alloc_mutex);
1020 	}
1021 
1022 	if (chunk != pcpu_reserved_chunk)
1023 		pcpu_nr_empty_pop_pages -= occ_pages;
1024 
1025 	if (pcpu_nr_empty_pop_pages < PCPU_EMPTY_POP_PAGES_LOW)
1026 		pcpu_schedule_balance_work();
1027 
1028 	/* clear the areas and return address relative to base address */
1029 	for_each_possible_cpu(cpu)
1030 		memset((void *)pcpu_chunk_addr(chunk, cpu, 0) + off, 0, size);
1031 
1032 	ptr = __addr_to_pcpu_ptr(chunk->base_addr + off);
1033 	kmemleak_alloc_percpu(ptr, size);
1034 	return ptr;
1035 
1036 fail_unlock:
1037 	spin_unlock_irqrestore(&pcpu_lock, flags);
1038 fail:
1039 	if (!is_atomic && warn_limit) {
1040 		pr_warning("PERCPU: allocation failed, size=%zu align=%zu atomic=%d, %s\n",
1041 			   size, align, is_atomic, err);
1042 		dump_stack();
1043 		if (!--warn_limit)
1044 			pr_info("PERCPU: limit reached, disable warning\n");
1045 	}
1046 	if (is_atomic) {
1047 		/* see the flag handling in pcpu_blance_workfn() */
1048 		pcpu_atomic_alloc_failed = true;
1049 		pcpu_schedule_balance_work();
1050 	}
1051 	return NULL;
1052 }
1053 
1054 /**
1055  * __alloc_percpu_gfp - allocate dynamic percpu area
1056  * @size: size of area to allocate in bytes
1057  * @align: alignment of area (max PAGE_SIZE)
1058  * @gfp: allocation flags
1059  *
1060  * Allocate zero-filled percpu area of @size bytes aligned at @align.  If
1061  * @gfp doesn't contain %GFP_KERNEL, the allocation doesn't block and can
1062  * be called from any context but is a lot more likely to fail.
1063  *
1064  * RETURNS:
1065  * Percpu pointer to the allocated area on success, NULL on failure.
1066  */
1067 void __percpu *__alloc_percpu_gfp(size_t size, size_t align, gfp_t gfp)
1068 {
1069 	return pcpu_alloc(size, align, false, gfp);
1070 }
1071 EXPORT_SYMBOL_GPL(__alloc_percpu_gfp);
1072 
1073 /**
1074  * __alloc_percpu - allocate dynamic percpu area
1075  * @size: size of area to allocate in bytes
1076  * @align: alignment of area (max PAGE_SIZE)
1077  *
1078  * Equivalent to __alloc_percpu_gfp(size, align, %GFP_KERNEL).
1079  */
1080 void __percpu *__alloc_percpu(size_t size, size_t align)
1081 {
1082 	return pcpu_alloc(size, align, false, GFP_KERNEL);
1083 }
1084 EXPORT_SYMBOL_GPL(__alloc_percpu);
1085 
1086 /**
1087  * __alloc_reserved_percpu - allocate reserved percpu area
1088  * @size: size of area to allocate in bytes
1089  * @align: alignment of area (max PAGE_SIZE)
1090  *
1091  * Allocate zero-filled percpu area of @size bytes aligned at @align
1092  * from reserved percpu area if arch has set it up; otherwise,
1093  * allocation is served from the same dynamic area.  Might sleep.
1094  * Might trigger writeouts.
1095  *
1096  * CONTEXT:
1097  * Does GFP_KERNEL allocation.
1098  *
1099  * RETURNS:
1100  * Percpu pointer to the allocated area on success, NULL on failure.
1101  */
1102 void __percpu *__alloc_reserved_percpu(size_t size, size_t align)
1103 {
1104 	return pcpu_alloc(size, align, true, GFP_KERNEL);
1105 }
1106 
1107 /**
1108  * pcpu_balance_workfn - manage the amount of free chunks and populated pages
1109  * @work: unused
1110  *
1111  * Reclaim all fully free chunks except for the first one.
1112  */
1113 static void pcpu_balance_workfn(struct work_struct *work)
1114 {
1115 	LIST_HEAD(to_free);
1116 	struct list_head *free_head = &pcpu_slot[pcpu_nr_slots - 1];
1117 	struct pcpu_chunk *chunk, *next;
1118 	int slot, nr_to_pop, ret;
1119 
1120 	/*
1121 	 * There's no reason to keep around multiple unused chunks and VM
1122 	 * areas can be scarce.  Destroy all free chunks except for one.
1123 	 */
1124 	mutex_lock(&pcpu_alloc_mutex);
1125 	spin_lock_irq(&pcpu_lock);
1126 
1127 	list_for_each_entry_safe(chunk, next, free_head, list) {
1128 		WARN_ON(chunk->immutable);
1129 
1130 		/* spare the first one */
1131 		if (chunk == list_first_entry(free_head, struct pcpu_chunk, list))
1132 			continue;
1133 
1134 		list_move(&chunk->list, &to_free);
1135 	}
1136 
1137 	spin_unlock_irq(&pcpu_lock);
1138 
1139 	list_for_each_entry_safe(chunk, next, &to_free, list) {
1140 		int rs, re;
1141 
1142 		pcpu_for_each_pop_region(chunk, rs, re, 0, pcpu_unit_pages) {
1143 			pcpu_depopulate_chunk(chunk, rs, re);
1144 			spin_lock_irq(&pcpu_lock);
1145 			pcpu_chunk_depopulated(chunk, rs, re);
1146 			spin_unlock_irq(&pcpu_lock);
1147 		}
1148 		pcpu_destroy_chunk(chunk);
1149 	}
1150 
1151 	/*
1152 	 * Ensure there are certain number of free populated pages for
1153 	 * atomic allocs.  Fill up from the most packed so that atomic
1154 	 * allocs don't increase fragmentation.  If atomic allocation
1155 	 * failed previously, always populate the maximum amount.  This
1156 	 * should prevent atomic allocs larger than PAGE_SIZE from keeping
1157 	 * failing indefinitely; however, large atomic allocs are not
1158 	 * something we support properly and can be highly unreliable and
1159 	 * inefficient.
1160 	 */
1161 retry_pop:
1162 	if (pcpu_atomic_alloc_failed) {
1163 		nr_to_pop = PCPU_EMPTY_POP_PAGES_HIGH;
1164 		/* best effort anyway, don't worry about synchronization */
1165 		pcpu_atomic_alloc_failed = false;
1166 	} else {
1167 		nr_to_pop = clamp(PCPU_EMPTY_POP_PAGES_HIGH -
1168 				  pcpu_nr_empty_pop_pages,
1169 				  0, PCPU_EMPTY_POP_PAGES_HIGH);
1170 	}
1171 
1172 	for (slot = pcpu_size_to_slot(PAGE_SIZE); slot < pcpu_nr_slots; slot++) {
1173 		int nr_unpop = 0, rs, re;
1174 
1175 		if (!nr_to_pop)
1176 			break;
1177 
1178 		spin_lock_irq(&pcpu_lock);
1179 		list_for_each_entry(chunk, &pcpu_slot[slot], list) {
1180 			nr_unpop = pcpu_unit_pages - chunk->nr_populated;
1181 			if (nr_unpop)
1182 				break;
1183 		}
1184 		spin_unlock_irq(&pcpu_lock);
1185 
1186 		if (!nr_unpop)
1187 			continue;
1188 
1189 		/* @chunk can't go away while pcpu_alloc_mutex is held */
1190 		pcpu_for_each_unpop_region(chunk, rs, re, 0, pcpu_unit_pages) {
1191 			int nr = min(re - rs, nr_to_pop);
1192 
1193 			ret = pcpu_populate_chunk(chunk, rs, rs + nr);
1194 			if (!ret) {
1195 				nr_to_pop -= nr;
1196 				spin_lock_irq(&pcpu_lock);
1197 				pcpu_chunk_populated(chunk, rs, rs + nr);
1198 				spin_unlock_irq(&pcpu_lock);
1199 			} else {
1200 				nr_to_pop = 0;
1201 			}
1202 
1203 			if (!nr_to_pop)
1204 				break;
1205 		}
1206 	}
1207 
1208 	if (nr_to_pop) {
1209 		/* ran out of chunks to populate, create a new one and retry */
1210 		chunk = pcpu_create_chunk();
1211 		if (chunk) {
1212 			spin_lock_irq(&pcpu_lock);
1213 			pcpu_chunk_relocate(chunk, -1);
1214 			spin_unlock_irq(&pcpu_lock);
1215 			goto retry_pop;
1216 		}
1217 	}
1218 
1219 	mutex_unlock(&pcpu_alloc_mutex);
1220 }
1221 
1222 /**
1223  * free_percpu - free percpu area
1224  * @ptr: pointer to area to free
1225  *
1226  * Free percpu area @ptr.
1227  *
1228  * CONTEXT:
1229  * Can be called from atomic context.
1230  */
1231 void free_percpu(void __percpu *ptr)
1232 {
1233 	void *addr;
1234 	struct pcpu_chunk *chunk;
1235 	unsigned long flags;
1236 	int off, occ_pages;
1237 
1238 	if (!ptr)
1239 		return;
1240 
1241 	kmemleak_free_percpu(ptr);
1242 
1243 	addr = __pcpu_ptr_to_addr(ptr);
1244 
1245 	spin_lock_irqsave(&pcpu_lock, flags);
1246 
1247 	chunk = pcpu_chunk_addr_search(addr);
1248 	off = addr - chunk->base_addr;
1249 
1250 	pcpu_free_area(chunk, off, &occ_pages);
1251 
1252 	if (chunk != pcpu_reserved_chunk)
1253 		pcpu_nr_empty_pop_pages += occ_pages;
1254 
1255 	/* if there are more than one fully free chunks, wake up grim reaper */
1256 	if (chunk->free_size == pcpu_unit_size) {
1257 		struct pcpu_chunk *pos;
1258 
1259 		list_for_each_entry(pos, &pcpu_slot[pcpu_nr_slots - 1], list)
1260 			if (pos != chunk) {
1261 				pcpu_schedule_balance_work();
1262 				break;
1263 			}
1264 	}
1265 
1266 	spin_unlock_irqrestore(&pcpu_lock, flags);
1267 }
1268 EXPORT_SYMBOL_GPL(free_percpu);
1269 
1270 /**
1271  * is_kernel_percpu_address - test whether address is from static percpu area
1272  * @addr: address to test
1273  *
1274  * Test whether @addr belongs to in-kernel static percpu area.  Module
1275  * static percpu areas are not considered.  For those, use
1276  * is_module_percpu_address().
1277  *
1278  * RETURNS:
1279  * %true if @addr is from in-kernel static percpu area, %false otherwise.
1280  */
1281 bool is_kernel_percpu_address(unsigned long addr)
1282 {
1283 #ifdef CONFIG_SMP
1284 	const size_t static_size = __per_cpu_end - __per_cpu_start;
1285 	void __percpu *base = __addr_to_pcpu_ptr(pcpu_base_addr);
1286 	unsigned int cpu;
1287 
1288 	for_each_possible_cpu(cpu) {
1289 		void *start = per_cpu_ptr(base, cpu);
1290 
1291 		if ((void *)addr >= start && (void *)addr < start + static_size)
1292 			return true;
1293         }
1294 #endif
1295 	/* on UP, can't distinguish from other static vars, always false */
1296 	return false;
1297 }
1298 
1299 /**
1300  * per_cpu_ptr_to_phys - convert translated percpu address to physical address
1301  * @addr: the address to be converted to physical address
1302  *
1303  * Given @addr which is dereferenceable address obtained via one of
1304  * percpu access macros, this function translates it into its physical
1305  * address.  The caller is responsible for ensuring @addr stays valid
1306  * until this function finishes.
1307  *
1308  * percpu allocator has special setup for the first chunk, which currently
1309  * supports either embedding in linear address space or vmalloc mapping,
1310  * and, from the second one, the backing allocator (currently either vm or
1311  * km) provides translation.
1312  *
1313  * The addr can be tranlated simply without checking if it falls into the
1314  * first chunk. But the current code reflects better how percpu allocator
1315  * actually works, and the verification can discover both bugs in percpu
1316  * allocator itself and per_cpu_ptr_to_phys() callers. So we keep current
1317  * code.
1318  *
1319  * RETURNS:
1320  * The physical address for @addr.
1321  */
1322 phys_addr_t per_cpu_ptr_to_phys(void *addr)
1323 {
1324 	void __percpu *base = __addr_to_pcpu_ptr(pcpu_base_addr);
1325 	bool in_first_chunk = false;
1326 	unsigned long first_low, first_high;
1327 	unsigned int cpu;
1328 
1329 	/*
1330 	 * The following test on unit_low/high isn't strictly
1331 	 * necessary but will speed up lookups of addresses which
1332 	 * aren't in the first chunk.
1333 	 */
1334 	first_low = pcpu_chunk_addr(pcpu_first_chunk, pcpu_low_unit_cpu, 0);
1335 	first_high = pcpu_chunk_addr(pcpu_first_chunk, pcpu_high_unit_cpu,
1336 				     pcpu_unit_pages);
1337 	if ((unsigned long)addr >= first_low &&
1338 	    (unsigned long)addr < first_high) {
1339 		for_each_possible_cpu(cpu) {
1340 			void *start = per_cpu_ptr(base, cpu);
1341 
1342 			if (addr >= start && addr < start + pcpu_unit_size) {
1343 				in_first_chunk = true;
1344 				break;
1345 			}
1346 		}
1347 	}
1348 
1349 	if (in_first_chunk) {
1350 		if (!is_vmalloc_addr(addr))
1351 			return __pa(addr);
1352 		else
1353 			return page_to_phys(vmalloc_to_page(addr)) +
1354 			       offset_in_page(addr);
1355 	} else
1356 		return page_to_phys(pcpu_addr_to_page(addr)) +
1357 		       offset_in_page(addr);
1358 }
1359 
1360 /**
1361  * pcpu_alloc_alloc_info - allocate percpu allocation info
1362  * @nr_groups: the number of groups
1363  * @nr_units: the number of units
1364  *
1365  * Allocate ai which is large enough for @nr_groups groups containing
1366  * @nr_units units.  The returned ai's groups[0].cpu_map points to the
1367  * cpu_map array which is long enough for @nr_units and filled with
1368  * NR_CPUS.  It's the caller's responsibility to initialize cpu_map
1369  * pointer of other groups.
1370  *
1371  * RETURNS:
1372  * Pointer to the allocated pcpu_alloc_info on success, NULL on
1373  * failure.
1374  */
1375 struct pcpu_alloc_info * __init pcpu_alloc_alloc_info(int nr_groups,
1376 						      int nr_units)
1377 {
1378 	struct pcpu_alloc_info *ai;
1379 	size_t base_size, ai_size;
1380 	void *ptr;
1381 	int unit;
1382 
1383 	base_size = ALIGN(sizeof(*ai) + nr_groups * sizeof(ai->groups[0]),
1384 			  __alignof__(ai->groups[0].cpu_map[0]));
1385 	ai_size = base_size + nr_units * sizeof(ai->groups[0].cpu_map[0]);
1386 
1387 	ptr = memblock_virt_alloc_nopanic(PFN_ALIGN(ai_size), 0);
1388 	if (!ptr)
1389 		return NULL;
1390 	ai = ptr;
1391 	ptr += base_size;
1392 
1393 	ai->groups[0].cpu_map = ptr;
1394 
1395 	for (unit = 0; unit < nr_units; unit++)
1396 		ai->groups[0].cpu_map[unit] = NR_CPUS;
1397 
1398 	ai->nr_groups = nr_groups;
1399 	ai->__ai_size = PFN_ALIGN(ai_size);
1400 
1401 	return ai;
1402 }
1403 
1404 /**
1405  * pcpu_free_alloc_info - free percpu allocation info
1406  * @ai: pcpu_alloc_info to free
1407  *
1408  * Free @ai which was allocated by pcpu_alloc_alloc_info().
1409  */
1410 void __init pcpu_free_alloc_info(struct pcpu_alloc_info *ai)
1411 {
1412 	memblock_free_early(__pa(ai), ai->__ai_size);
1413 }
1414 
1415 /**
1416  * pcpu_dump_alloc_info - print out information about pcpu_alloc_info
1417  * @lvl: loglevel
1418  * @ai: allocation info to dump
1419  *
1420  * Print out information about @ai using loglevel @lvl.
1421  */
1422 static void pcpu_dump_alloc_info(const char *lvl,
1423 				 const struct pcpu_alloc_info *ai)
1424 {
1425 	int group_width = 1, cpu_width = 1, width;
1426 	char empty_str[] = "--------";
1427 	int alloc = 0, alloc_end = 0;
1428 	int group, v;
1429 	int upa, apl;	/* units per alloc, allocs per line */
1430 
1431 	v = ai->nr_groups;
1432 	while (v /= 10)
1433 		group_width++;
1434 
1435 	v = num_possible_cpus();
1436 	while (v /= 10)
1437 		cpu_width++;
1438 	empty_str[min_t(int, cpu_width, sizeof(empty_str) - 1)] = '\0';
1439 
1440 	upa = ai->alloc_size / ai->unit_size;
1441 	width = upa * (cpu_width + 1) + group_width + 3;
1442 	apl = rounddown_pow_of_two(max(60 / width, 1));
1443 
1444 	printk("%spcpu-alloc: s%zu r%zu d%zu u%zu alloc=%zu*%zu",
1445 	       lvl, ai->static_size, ai->reserved_size, ai->dyn_size,
1446 	       ai->unit_size, ai->alloc_size / ai->atom_size, ai->atom_size);
1447 
1448 	for (group = 0; group < ai->nr_groups; group++) {
1449 		const struct pcpu_group_info *gi = &ai->groups[group];
1450 		int unit = 0, unit_end = 0;
1451 
1452 		BUG_ON(gi->nr_units % upa);
1453 		for (alloc_end += gi->nr_units / upa;
1454 		     alloc < alloc_end; alloc++) {
1455 			if (!(alloc % apl)) {
1456 				printk(KERN_CONT "\n");
1457 				printk("%spcpu-alloc: ", lvl);
1458 			}
1459 			printk(KERN_CONT "[%0*d] ", group_width, group);
1460 
1461 			for (unit_end += upa; unit < unit_end; unit++)
1462 				if (gi->cpu_map[unit] != NR_CPUS)
1463 					printk(KERN_CONT "%0*d ", cpu_width,
1464 					       gi->cpu_map[unit]);
1465 				else
1466 					printk(KERN_CONT "%s ", empty_str);
1467 		}
1468 	}
1469 	printk(KERN_CONT "\n");
1470 }
1471 
1472 /**
1473  * pcpu_setup_first_chunk - initialize the first percpu chunk
1474  * @ai: pcpu_alloc_info describing how to percpu area is shaped
1475  * @base_addr: mapped address
1476  *
1477  * Initialize the first percpu chunk which contains the kernel static
1478  * perpcu area.  This function is to be called from arch percpu area
1479  * setup path.
1480  *
1481  * @ai contains all information necessary to initialize the first
1482  * chunk and prime the dynamic percpu allocator.
1483  *
1484  * @ai->static_size is the size of static percpu area.
1485  *
1486  * @ai->reserved_size, if non-zero, specifies the amount of bytes to
1487  * reserve after the static area in the first chunk.  This reserves
1488  * the first chunk such that it's available only through reserved
1489  * percpu allocation.  This is primarily used to serve module percpu
1490  * static areas on architectures where the addressing model has
1491  * limited offset range for symbol relocations to guarantee module
1492  * percpu symbols fall inside the relocatable range.
1493  *
1494  * @ai->dyn_size determines the number of bytes available for dynamic
1495  * allocation in the first chunk.  The area between @ai->static_size +
1496  * @ai->reserved_size + @ai->dyn_size and @ai->unit_size is unused.
1497  *
1498  * @ai->unit_size specifies unit size and must be aligned to PAGE_SIZE
1499  * and equal to or larger than @ai->static_size + @ai->reserved_size +
1500  * @ai->dyn_size.
1501  *
1502  * @ai->atom_size is the allocation atom size and used as alignment
1503  * for vm areas.
1504  *
1505  * @ai->alloc_size is the allocation size and always multiple of
1506  * @ai->atom_size.  This is larger than @ai->atom_size if
1507  * @ai->unit_size is larger than @ai->atom_size.
1508  *
1509  * @ai->nr_groups and @ai->groups describe virtual memory layout of
1510  * percpu areas.  Units which should be colocated are put into the
1511  * same group.  Dynamic VM areas will be allocated according to these
1512  * groupings.  If @ai->nr_groups is zero, a single group containing
1513  * all units is assumed.
1514  *
1515  * The caller should have mapped the first chunk at @base_addr and
1516  * copied static data to each unit.
1517  *
1518  * If the first chunk ends up with both reserved and dynamic areas, it
1519  * is served by two chunks - one to serve the core static and reserved
1520  * areas and the other for the dynamic area.  They share the same vm
1521  * and page map but uses different area allocation map to stay away
1522  * from each other.  The latter chunk is circulated in the chunk slots
1523  * and available for dynamic allocation like any other chunks.
1524  *
1525  * RETURNS:
1526  * 0 on success, -errno on failure.
1527  */
1528 int __init pcpu_setup_first_chunk(const struct pcpu_alloc_info *ai,
1529 				  void *base_addr)
1530 {
1531 	static char cpus_buf[4096] __initdata;
1532 	static int smap[PERCPU_DYNAMIC_EARLY_SLOTS] __initdata;
1533 	static int dmap[PERCPU_DYNAMIC_EARLY_SLOTS] __initdata;
1534 	size_t dyn_size = ai->dyn_size;
1535 	size_t size_sum = ai->static_size + ai->reserved_size + dyn_size;
1536 	struct pcpu_chunk *schunk, *dchunk = NULL;
1537 	unsigned long *group_offsets;
1538 	size_t *group_sizes;
1539 	unsigned long *unit_off;
1540 	unsigned int cpu;
1541 	int *unit_map;
1542 	int group, unit, i;
1543 
1544 	cpumask_scnprintf(cpus_buf, sizeof(cpus_buf), cpu_possible_mask);
1545 
1546 #define PCPU_SETUP_BUG_ON(cond)	do {					\
1547 	if (unlikely(cond)) {						\
1548 		pr_emerg("PERCPU: failed to initialize, %s", #cond);	\
1549 		pr_emerg("PERCPU: cpu_possible_mask=%s\n", cpus_buf);	\
1550 		pcpu_dump_alloc_info(KERN_EMERG, ai);			\
1551 		BUG();							\
1552 	}								\
1553 } while (0)
1554 
1555 	/* sanity checks */
1556 	PCPU_SETUP_BUG_ON(ai->nr_groups <= 0);
1557 #ifdef CONFIG_SMP
1558 	PCPU_SETUP_BUG_ON(!ai->static_size);
1559 	PCPU_SETUP_BUG_ON((unsigned long)__per_cpu_start & ~PAGE_MASK);
1560 #endif
1561 	PCPU_SETUP_BUG_ON(!base_addr);
1562 	PCPU_SETUP_BUG_ON((unsigned long)base_addr & ~PAGE_MASK);
1563 	PCPU_SETUP_BUG_ON(ai->unit_size < size_sum);
1564 	PCPU_SETUP_BUG_ON(ai->unit_size & ~PAGE_MASK);
1565 	PCPU_SETUP_BUG_ON(ai->unit_size < PCPU_MIN_UNIT_SIZE);
1566 	PCPU_SETUP_BUG_ON(ai->dyn_size < PERCPU_DYNAMIC_EARLY_SIZE);
1567 	PCPU_SETUP_BUG_ON(pcpu_verify_alloc_info(ai) < 0);
1568 
1569 	/* process group information and build config tables accordingly */
1570 	group_offsets = memblock_virt_alloc(ai->nr_groups *
1571 					     sizeof(group_offsets[0]), 0);
1572 	group_sizes = memblock_virt_alloc(ai->nr_groups *
1573 					   sizeof(group_sizes[0]), 0);
1574 	unit_map = memblock_virt_alloc(nr_cpu_ids * sizeof(unit_map[0]), 0);
1575 	unit_off = memblock_virt_alloc(nr_cpu_ids * sizeof(unit_off[0]), 0);
1576 
1577 	for (cpu = 0; cpu < nr_cpu_ids; cpu++)
1578 		unit_map[cpu] = UINT_MAX;
1579 
1580 	pcpu_low_unit_cpu = NR_CPUS;
1581 	pcpu_high_unit_cpu = NR_CPUS;
1582 
1583 	for (group = 0, unit = 0; group < ai->nr_groups; group++, unit += i) {
1584 		const struct pcpu_group_info *gi = &ai->groups[group];
1585 
1586 		group_offsets[group] = gi->base_offset;
1587 		group_sizes[group] = gi->nr_units * ai->unit_size;
1588 
1589 		for (i = 0; i < gi->nr_units; i++) {
1590 			cpu = gi->cpu_map[i];
1591 			if (cpu == NR_CPUS)
1592 				continue;
1593 
1594 			PCPU_SETUP_BUG_ON(cpu > nr_cpu_ids);
1595 			PCPU_SETUP_BUG_ON(!cpu_possible(cpu));
1596 			PCPU_SETUP_BUG_ON(unit_map[cpu] != UINT_MAX);
1597 
1598 			unit_map[cpu] = unit + i;
1599 			unit_off[cpu] = gi->base_offset + i * ai->unit_size;
1600 
1601 			/* determine low/high unit_cpu */
1602 			if (pcpu_low_unit_cpu == NR_CPUS ||
1603 			    unit_off[cpu] < unit_off[pcpu_low_unit_cpu])
1604 				pcpu_low_unit_cpu = cpu;
1605 			if (pcpu_high_unit_cpu == NR_CPUS ||
1606 			    unit_off[cpu] > unit_off[pcpu_high_unit_cpu])
1607 				pcpu_high_unit_cpu = cpu;
1608 		}
1609 	}
1610 	pcpu_nr_units = unit;
1611 
1612 	for_each_possible_cpu(cpu)
1613 		PCPU_SETUP_BUG_ON(unit_map[cpu] == UINT_MAX);
1614 
1615 	/* we're done parsing the input, undefine BUG macro and dump config */
1616 #undef PCPU_SETUP_BUG_ON
1617 	pcpu_dump_alloc_info(KERN_DEBUG, ai);
1618 
1619 	pcpu_nr_groups = ai->nr_groups;
1620 	pcpu_group_offsets = group_offsets;
1621 	pcpu_group_sizes = group_sizes;
1622 	pcpu_unit_map = unit_map;
1623 	pcpu_unit_offsets = unit_off;
1624 
1625 	/* determine basic parameters */
1626 	pcpu_unit_pages = ai->unit_size >> PAGE_SHIFT;
1627 	pcpu_unit_size = pcpu_unit_pages << PAGE_SHIFT;
1628 	pcpu_atom_size = ai->atom_size;
1629 	pcpu_chunk_struct_size = sizeof(struct pcpu_chunk) +
1630 		BITS_TO_LONGS(pcpu_unit_pages) * sizeof(unsigned long);
1631 
1632 	/*
1633 	 * Allocate chunk slots.  The additional last slot is for
1634 	 * empty chunks.
1635 	 */
1636 	pcpu_nr_slots = __pcpu_size_to_slot(pcpu_unit_size) + 2;
1637 	pcpu_slot = memblock_virt_alloc(
1638 			pcpu_nr_slots * sizeof(pcpu_slot[0]), 0);
1639 	for (i = 0; i < pcpu_nr_slots; i++)
1640 		INIT_LIST_HEAD(&pcpu_slot[i]);
1641 
1642 	/*
1643 	 * Initialize static chunk.  If reserved_size is zero, the
1644 	 * static chunk covers static area + dynamic allocation area
1645 	 * in the first chunk.  If reserved_size is not zero, it
1646 	 * covers static area + reserved area (mostly used for module
1647 	 * static percpu allocation).
1648 	 */
1649 	schunk = memblock_virt_alloc(pcpu_chunk_struct_size, 0);
1650 	INIT_LIST_HEAD(&schunk->list);
1651 	INIT_WORK(&schunk->map_extend_work, pcpu_map_extend_workfn);
1652 	schunk->base_addr = base_addr;
1653 	schunk->map = smap;
1654 	schunk->map_alloc = ARRAY_SIZE(smap);
1655 	schunk->immutable = true;
1656 	bitmap_fill(schunk->populated, pcpu_unit_pages);
1657 	schunk->nr_populated = pcpu_unit_pages;
1658 
1659 	if (ai->reserved_size) {
1660 		schunk->free_size = ai->reserved_size;
1661 		pcpu_reserved_chunk = schunk;
1662 		pcpu_reserved_chunk_limit = ai->static_size + ai->reserved_size;
1663 	} else {
1664 		schunk->free_size = dyn_size;
1665 		dyn_size = 0;			/* dynamic area covered */
1666 	}
1667 	schunk->contig_hint = schunk->free_size;
1668 
1669 	schunk->map[0] = 1;
1670 	schunk->map[1] = ai->static_size;
1671 	schunk->map_used = 1;
1672 	if (schunk->free_size)
1673 		schunk->map[++schunk->map_used] = 1 | (ai->static_size + schunk->free_size);
1674 	else
1675 		schunk->map[1] |= 1;
1676 
1677 	/* init dynamic chunk if necessary */
1678 	if (dyn_size) {
1679 		dchunk = memblock_virt_alloc(pcpu_chunk_struct_size, 0);
1680 		INIT_LIST_HEAD(&dchunk->list);
1681 		INIT_WORK(&dchunk->map_extend_work, pcpu_map_extend_workfn);
1682 		dchunk->base_addr = base_addr;
1683 		dchunk->map = dmap;
1684 		dchunk->map_alloc = ARRAY_SIZE(dmap);
1685 		dchunk->immutable = true;
1686 		bitmap_fill(dchunk->populated, pcpu_unit_pages);
1687 		dchunk->nr_populated = pcpu_unit_pages;
1688 
1689 		dchunk->contig_hint = dchunk->free_size = dyn_size;
1690 		dchunk->map[0] = 1;
1691 		dchunk->map[1] = pcpu_reserved_chunk_limit;
1692 		dchunk->map[2] = (pcpu_reserved_chunk_limit + dchunk->free_size) | 1;
1693 		dchunk->map_used = 2;
1694 	}
1695 
1696 	/* link the first chunk in */
1697 	pcpu_first_chunk = dchunk ?: schunk;
1698 	pcpu_nr_empty_pop_pages +=
1699 		pcpu_count_occupied_pages(pcpu_first_chunk, 1);
1700 	pcpu_chunk_relocate(pcpu_first_chunk, -1);
1701 
1702 	/* we're done */
1703 	pcpu_base_addr = base_addr;
1704 	return 0;
1705 }
1706 
1707 #ifdef CONFIG_SMP
1708 
1709 const char * const pcpu_fc_names[PCPU_FC_NR] __initconst = {
1710 	[PCPU_FC_AUTO]	= "auto",
1711 	[PCPU_FC_EMBED]	= "embed",
1712 	[PCPU_FC_PAGE]	= "page",
1713 };
1714 
1715 enum pcpu_fc pcpu_chosen_fc __initdata = PCPU_FC_AUTO;
1716 
1717 static int __init percpu_alloc_setup(char *str)
1718 {
1719 	if (!str)
1720 		return -EINVAL;
1721 
1722 	if (0)
1723 		/* nada */;
1724 #ifdef CONFIG_NEED_PER_CPU_EMBED_FIRST_CHUNK
1725 	else if (!strcmp(str, "embed"))
1726 		pcpu_chosen_fc = PCPU_FC_EMBED;
1727 #endif
1728 #ifdef CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK
1729 	else if (!strcmp(str, "page"))
1730 		pcpu_chosen_fc = PCPU_FC_PAGE;
1731 #endif
1732 	else
1733 		pr_warning("PERCPU: unknown allocator %s specified\n", str);
1734 
1735 	return 0;
1736 }
1737 early_param("percpu_alloc", percpu_alloc_setup);
1738 
1739 /*
1740  * pcpu_embed_first_chunk() is used by the generic percpu setup.
1741  * Build it if needed by the arch config or the generic setup is going
1742  * to be used.
1743  */
1744 #if defined(CONFIG_NEED_PER_CPU_EMBED_FIRST_CHUNK) || \
1745 	!defined(CONFIG_HAVE_SETUP_PER_CPU_AREA)
1746 #define BUILD_EMBED_FIRST_CHUNK
1747 #endif
1748 
1749 /* build pcpu_page_first_chunk() iff needed by the arch config */
1750 #if defined(CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK)
1751 #define BUILD_PAGE_FIRST_CHUNK
1752 #endif
1753 
1754 /* pcpu_build_alloc_info() is used by both embed and page first chunk */
1755 #if defined(BUILD_EMBED_FIRST_CHUNK) || defined(BUILD_PAGE_FIRST_CHUNK)
1756 /**
1757  * pcpu_build_alloc_info - build alloc_info considering distances between CPUs
1758  * @reserved_size: the size of reserved percpu area in bytes
1759  * @dyn_size: minimum free size for dynamic allocation in bytes
1760  * @atom_size: allocation atom size
1761  * @cpu_distance_fn: callback to determine distance between cpus, optional
1762  *
1763  * This function determines grouping of units, their mappings to cpus
1764  * and other parameters considering needed percpu size, allocation
1765  * atom size and distances between CPUs.
1766  *
1767  * Groups are always mutliples of atom size and CPUs which are of
1768  * LOCAL_DISTANCE both ways are grouped together and share space for
1769  * units in the same group.  The returned configuration is guaranteed
1770  * to have CPUs on different nodes on different groups and >=75% usage
1771  * of allocated virtual address space.
1772  *
1773  * RETURNS:
1774  * On success, pointer to the new allocation_info is returned.  On
1775  * failure, ERR_PTR value is returned.
1776  */
1777 static struct pcpu_alloc_info * __init pcpu_build_alloc_info(
1778 				size_t reserved_size, size_t dyn_size,
1779 				size_t atom_size,
1780 				pcpu_fc_cpu_distance_fn_t cpu_distance_fn)
1781 {
1782 	static int group_map[NR_CPUS] __initdata;
1783 	static int group_cnt[NR_CPUS] __initdata;
1784 	const size_t static_size = __per_cpu_end - __per_cpu_start;
1785 	int nr_groups = 1, nr_units = 0;
1786 	size_t size_sum, min_unit_size, alloc_size;
1787 	int upa, max_upa, uninitialized_var(best_upa);	/* units_per_alloc */
1788 	int last_allocs, group, unit;
1789 	unsigned int cpu, tcpu;
1790 	struct pcpu_alloc_info *ai;
1791 	unsigned int *cpu_map;
1792 
1793 	/* this function may be called multiple times */
1794 	memset(group_map, 0, sizeof(group_map));
1795 	memset(group_cnt, 0, sizeof(group_cnt));
1796 
1797 	/* calculate size_sum and ensure dyn_size is enough for early alloc */
1798 	size_sum = PFN_ALIGN(static_size + reserved_size +
1799 			    max_t(size_t, dyn_size, PERCPU_DYNAMIC_EARLY_SIZE));
1800 	dyn_size = size_sum - static_size - reserved_size;
1801 
1802 	/*
1803 	 * Determine min_unit_size, alloc_size and max_upa such that
1804 	 * alloc_size is multiple of atom_size and is the smallest
1805 	 * which can accommodate 4k aligned segments which are equal to
1806 	 * or larger than min_unit_size.
1807 	 */
1808 	min_unit_size = max_t(size_t, size_sum, PCPU_MIN_UNIT_SIZE);
1809 
1810 	alloc_size = roundup(min_unit_size, atom_size);
1811 	upa = alloc_size / min_unit_size;
1812 	while (alloc_size % upa || ((alloc_size / upa) & ~PAGE_MASK))
1813 		upa--;
1814 	max_upa = upa;
1815 
1816 	/* group cpus according to their proximity */
1817 	for_each_possible_cpu(cpu) {
1818 		group = 0;
1819 	next_group:
1820 		for_each_possible_cpu(tcpu) {
1821 			if (cpu == tcpu)
1822 				break;
1823 			if (group_map[tcpu] == group && cpu_distance_fn &&
1824 			    (cpu_distance_fn(cpu, tcpu) > LOCAL_DISTANCE ||
1825 			     cpu_distance_fn(tcpu, cpu) > LOCAL_DISTANCE)) {
1826 				group++;
1827 				nr_groups = max(nr_groups, group + 1);
1828 				goto next_group;
1829 			}
1830 		}
1831 		group_map[cpu] = group;
1832 		group_cnt[group]++;
1833 	}
1834 
1835 	/*
1836 	 * Expand unit size until address space usage goes over 75%
1837 	 * and then as much as possible without using more address
1838 	 * space.
1839 	 */
1840 	last_allocs = INT_MAX;
1841 	for (upa = max_upa; upa; upa--) {
1842 		int allocs = 0, wasted = 0;
1843 
1844 		if (alloc_size % upa || ((alloc_size / upa) & ~PAGE_MASK))
1845 			continue;
1846 
1847 		for (group = 0; group < nr_groups; group++) {
1848 			int this_allocs = DIV_ROUND_UP(group_cnt[group], upa);
1849 			allocs += this_allocs;
1850 			wasted += this_allocs * upa - group_cnt[group];
1851 		}
1852 
1853 		/*
1854 		 * Don't accept if wastage is over 1/3.  The
1855 		 * greater-than comparison ensures upa==1 always
1856 		 * passes the following check.
1857 		 */
1858 		if (wasted > num_possible_cpus() / 3)
1859 			continue;
1860 
1861 		/* and then don't consume more memory */
1862 		if (allocs > last_allocs)
1863 			break;
1864 		last_allocs = allocs;
1865 		best_upa = upa;
1866 	}
1867 	upa = best_upa;
1868 
1869 	/* allocate and fill alloc_info */
1870 	for (group = 0; group < nr_groups; group++)
1871 		nr_units += roundup(group_cnt[group], upa);
1872 
1873 	ai = pcpu_alloc_alloc_info(nr_groups, nr_units);
1874 	if (!ai)
1875 		return ERR_PTR(-ENOMEM);
1876 	cpu_map = ai->groups[0].cpu_map;
1877 
1878 	for (group = 0; group < nr_groups; group++) {
1879 		ai->groups[group].cpu_map = cpu_map;
1880 		cpu_map += roundup(group_cnt[group], upa);
1881 	}
1882 
1883 	ai->static_size = static_size;
1884 	ai->reserved_size = reserved_size;
1885 	ai->dyn_size = dyn_size;
1886 	ai->unit_size = alloc_size / upa;
1887 	ai->atom_size = atom_size;
1888 	ai->alloc_size = alloc_size;
1889 
1890 	for (group = 0, unit = 0; group_cnt[group]; group++) {
1891 		struct pcpu_group_info *gi = &ai->groups[group];
1892 
1893 		/*
1894 		 * Initialize base_offset as if all groups are located
1895 		 * back-to-back.  The caller should update this to
1896 		 * reflect actual allocation.
1897 		 */
1898 		gi->base_offset = unit * ai->unit_size;
1899 
1900 		for_each_possible_cpu(cpu)
1901 			if (group_map[cpu] == group)
1902 				gi->cpu_map[gi->nr_units++] = cpu;
1903 		gi->nr_units = roundup(gi->nr_units, upa);
1904 		unit += gi->nr_units;
1905 	}
1906 	BUG_ON(unit != nr_units);
1907 
1908 	return ai;
1909 }
1910 #endif /* BUILD_EMBED_FIRST_CHUNK || BUILD_PAGE_FIRST_CHUNK */
1911 
1912 #if defined(BUILD_EMBED_FIRST_CHUNK)
1913 /**
1914  * pcpu_embed_first_chunk - embed the first percpu chunk into bootmem
1915  * @reserved_size: the size of reserved percpu area in bytes
1916  * @dyn_size: minimum free size for dynamic allocation in bytes
1917  * @atom_size: allocation atom size
1918  * @cpu_distance_fn: callback to determine distance between cpus, optional
1919  * @alloc_fn: function to allocate percpu page
1920  * @free_fn: function to free percpu page
1921  *
1922  * This is a helper to ease setting up embedded first percpu chunk and
1923  * can be called where pcpu_setup_first_chunk() is expected.
1924  *
1925  * If this function is used to setup the first chunk, it is allocated
1926  * by calling @alloc_fn and used as-is without being mapped into
1927  * vmalloc area.  Allocations are always whole multiples of @atom_size
1928  * aligned to @atom_size.
1929  *
1930  * This enables the first chunk to piggy back on the linear physical
1931  * mapping which often uses larger page size.  Please note that this
1932  * can result in very sparse cpu->unit mapping on NUMA machines thus
1933  * requiring large vmalloc address space.  Don't use this allocator if
1934  * vmalloc space is not orders of magnitude larger than distances
1935  * between node memory addresses (ie. 32bit NUMA machines).
1936  *
1937  * @dyn_size specifies the minimum dynamic area size.
1938  *
1939  * If the needed size is smaller than the minimum or specified unit
1940  * size, the leftover is returned using @free_fn.
1941  *
1942  * RETURNS:
1943  * 0 on success, -errno on failure.
1944  */
1945 int __init pcpu_embed_first_chunk(size_t reserved_size, size_t dyn_size,
1946 				  size_t atom_size,
1947 				  pcpu_fc_cpu_distance_fn_t cpu_distance_fn,
1948 				  pcpu_fc_alloc_fn_t alloc_fn,
1949 				  pcpu_fc_free_fn_t free_fn)
1950 {
1951 	void *base = (void *)ULONG_MAX;
1952 	void **areas = NULL;
1953 	struct pcpu_alloc_info *ai;
1954 	size_t size_sum, areas_size, max_distance;
1955 	int group, i, rc;
1956 
1957 	ai = pcpu_build_alloc_info(reserved_size, dyn_size, atom_size,
1958 				   cpu_distance_fn);
1959 	if (IS_ERR(ai))
1960 		return PTR_ERR(ai);
1961 
1962 	size_sum = ai->static_size + ai->reserved_size + ai->dyn_size;
1963 	areas_size = PFN_ALIGN(ai->nr_groups * sizeof(void *));
1964 
1965 	areas = memblock_virt_alloc_nopanic(areas_size, 0);
1966 	if (!areas) {
1967 		rc = -ENOMEM;
1968 		goto out_free;
1969 	}
1970 
1971 	/* allocate, copy and determine base address */
1972 	for (group = 0; group < ai->nr_groups; group++) {
1973 		struct pcpu_group_info *gi = &ai->groups[group];
1974 		unsigned int cpu = NR_CPUS;
1975 		void *ptr;
1976 
1977 		for (i = 0; i < gi->nr_units && cpu == NR_CPUS; i++)
1978 			cpu = gi->cpu_map[i];
1979 		BUG_ON(cpu == NR_CPUS);
1980 
1981 		/* allocate space for the whole group */
1982 		ptr = alloc_fn(cpu, gi->nr_units * ai->unit_size, atom_size);
1983 		if (!ptr) {
1984 			rc = -ENOMEM;
1985 			goto out_free_areas;
1986 		}
1987 		/* kmemleak tracks the percpu allocations separately */
1988 		kmemleak_free(ptr);
1989 		areas[group] = ptr;
1990 
1991 		base = min(ptr, base);
1992 	}
1993 
1994 	/*
1995 	 * Copy data and free unused parts.  This should happen after all
1996 	 * allocations are complete; otherwise, we may end up with
1997 	 * overlapping groups.
1998 	 */
1999 	for (group = 0; group < ai->nr_groups; group++) {
2000 		struct pcpu_group_info *gi = &ai->groups[group];
2001 		void *ptr = areas[group];
2002 
2003 		for (i = 0; i < gi->nr_units; i++, ptr += ai->unit_size) {
2004 			if (gi->cpu_map[i] == NR_CPUS) {
2005 				/* unused unit, free whole */
2006 				free_fn(ptr, ai->unit_size);
2007 				continue;
2008 			}
2009 			/* copy and return the unused part */
2010 			memcpy(ptr, __per_cpu_load, ai->static_size);
2011 			free_fn(ptr + size_sum, ai->unit_size - size_sum);
2012 		}
2013 	}
2014 
2015 	/* base address is now known, determine group base offsets */
2016 	max_distance = 0;
2017 	for (group = 0; group < ai->nr_groups; group++) {
2018 		ai->groups[group].base_offset = areas[group] - base;
2019 		max_distance = max_t(size_t, max_distance,
2020 				     ai->groups[group].base_offset);
2021 	}
2022 	max_distance += ai->unit_size;
2023 
2024 	/* warn if maximum distance is further than 75% of vmalloc space */
2025 	if (max_distance > VMALLOC_TOTAL * 3 / 4) {
2026 		pr_warning("PERCPU: max_distance=0x%zx too large for vmalloc "
2027 			   "space 0x%lx\n", max_distance,
2028 			   VMALLOC_TOTAL);
2029 #ifdef CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK
2030 		/* and fail if we have fallback */
2031 		rc = -EINVAL;
2032 		goto out_free;
2033 #endif
2034 	}
2035 
2036 	pr_info("PERCPU: Embedded %zu pages/cpu @%p s%zu r%zu d%zu u%zu\n",
2037 		PFN_DOWN(size_sum), base, ai->static_size, ai->reserved_size,
2038 		ai->dyn_size, ai->unit_size);
2039 
2040 	rc = pcpu_setup_first_chunk(ai, base);
2041 	goto out_free;
2042 
2043 out_free_areas:
2044 	for (group = 0; group < ai->nr_groups; group++)
2045 		if (areas[group])
2046 			free_fn(areas[group],
2047 				ai->groups[group].nr_units * ai->unit_size);
2048 out_free:
2049 	pcpu_free_alloc_info(ai);
2050 	if (areas)
2051 		memblock_free_early(__pa(areas), areas_size);
2052 	return rc;
2053 }
2054 #endif /* BUILD_EMBED_FIRST_CHUNK */
2055 
2056 #ifdef BUILD_PAGE_FIRST_CHUNK
2057 /**
2058  * pcpu_page_first_chunk - map the first chunk using PAGE_SIZE pages
2059  * @reserved_size: the size of reserved percpu area in bytes
2060  * @alloc_fn: function to allocate percpu page, always called with PAGE_SIZE
2061  * @free_fn: function to free percpu page, always called with PAGE_SIZE
2062  * @populate_pte_fn: function to populate pte
2063  *
2064  * This is a helper to ease setting up page-remapped first percpu
2065  * chunk and can be called where pcpu_setup_first_chunk() is expected.
2066  *
2067  * This is the basic allocator.  Static percpu area is allocated
2068  * page-by-page into vmalloc area.
2069  *
2070  * RETURNS:
2071  * 0 on success, -errno on failure.
2072  */
2073 int __init pcpu_page_first_chunk(size_t reserved_size,
2074 				 pcpu_fc_alloc_fn_t alloc_fn,
2075 				 pcpu_fc_free_fn_t free_fn,
2076 				 pcpu_fc_populate_pte_fn_t populate_pte_fn)
2077 {
2078 	static struct vm_struct vm;
2079 	struct pcpu_alloc_info *ai;
2080 	char psize_str[16];
2081 	int unit_pages;
2082 	size_t pages_size;
2083 	struct page **pages;
2084 	int unit, i, j, rc;
2085 
2086 	snprintf(psize_str, sizeof(psize_str), "%luK", PAGE_SIZE >> 10);
2087 
2088 	ai = pcpu_build_alloc_info(reserved_size, 0, PAGE_SIZE, NULL);
2089 	if (IS_ERR(ai))
2090 		return PTR_ERR(ai);
2091 	BUG_ON(ai->nr_groups != 1);
2092 	BUG_ON(ai->groups[0].nr_units != num_possible_cpus());
2093 
2094 	unit_pages = ai->unit_size >> PAGE_SHIFT;
2095 
2096 	/* unaligned allocations can't be freed, round up to page size */
2097 	pages_size = PFN_ALIGN(unit_pages * num_possible_cpus() *
2098 			       sizeof(pages[0]));
2099 	pages = memblock_virt_alloc(pages_size, 0);
2100 
2101 	/* allocate pages */
2102 	j = 0;
2103 	for (unit = 0; unit < num_possible_cpus(); unit++)
2104 		for (i = 0; i < unit_pages; i++) {
2105 			unsigned int cpu = ai->groups[0].cpu_map[unit];
2106 			void *ptr;
2107 
2108 			ptr = alloc_fn(cpu, PAGE_SIZE, PAGE_SIZE);
2109 			if (!ptr) {
2110 				pr_warning("PERCPU: failed to allocate %s page "
2111 					   "for cpu%u\n", psize_str, cpu);
2112 				goto enomem;
2113 			}
2114 			/* kmemleak tracks the percpu allocations separately */
2115 			kmemleak_free(ptr);
2116 			pages[j++] = virt_to_page(ptr);
2117 		}
2118 
2119 	/* allocate vm area, map the pages and copy static data */
2120 	vm.flags = VM_ALLOC;
2121 	vm.size = num_possible_cpus() * ai->unit_size;
2122 	vm_area_register_early(&vm, PAGE_SIZE);
2123 
2124 	for (unit = 0; unit < num_possible_cpus(); unit++) {
2125 		unsigned long unit_addr =
2126 			(unsigned long)vm.addr + unit * ai->unit_size;
2127 
2128 		for (i = 0; i < unit_pages; i++)
2129 			populate_pte_fn(unit_addr + (i << PAGE_SHIFT));
2130 
2131 		/* pte already populated, the following shouldn't fail */
2132 		rc = __pcpu_map_pages(unit_addr, &pages[unit * unit_pages],
2133 				      unit_pages);
2134 		if (rc < 0)
2135 			panic("failed to map percpu area, err=%d\n", rc);
2136 
2137 		/*
2138 		 * FIXME: Archs with virtual cache should flush local
2139 		 * cache for the linear mapping here - something
2140 		 * equivalent to flush_cache_vmap() on the local cpu.
2141 		 * flush_cache_vmap() can't be used as most supporting
2142 		 * data structures are not set up yet.
2143 		 */
2144 
2145 		/* copy static data */
2146 		memcpy((void *)unit_addr, __per_cpu_load, ai->static_size);
2147 	}
2148 
2149 	/* we're ready, commit */
2150 	pr_info("PERCPU: %d %s pages/cpu @%p s%zu r%zu d%zu\n",
2151 		unit_pages, psize_str, vm.addr, ai->static_size,
2152 		ai->reserved_size, ai->dyn_size);
2153 
2154 	rc = pcpu_setup_first_chunk(ai, vm.addr);
2155 	goto out_free_ar;
2156 
2157 enomem:
2158 	while (--j >= 0)
2159 		free_fn(page_address(pages[j]), PAGE_SIZE);
2160 	rc = -ENOMEM;
2161 out_free_ar:
2162 	memblock_free_early(__pa(pages), pages_size);
2163 	pcpu_free_alloc_info(ai);
2164 	return rc;
2165 }
2166 #endif /* BUILD_PAGE_FIRST_CHUNK */
2167 
2168 #ifndef	CONFIG_HAVE_SETUP_PER_CPU_AREA
2169 /*
2170  * Generic SMP percpu area setup.
2171  *
2172  * The embedding helper is used because its behavior closely resembles
2173  * the original non-dynamic generic percpu area setup.  This is
2174  * important because many archs have addressing restrictions and might
2175  * fail if the percpu area is located far away from the previous
2176  * location.  As an added bonus, in non-NUMA cases, embedding is
2177  * generally a good idea TLB-wise because percpu area can piggy back
2178  * on the physical linear memory mapping which uses large page
2179  * mappings on applicable archs.
2180  */
2181 unsigned long __per_cpu_offset[NR_CPUS] __read_mostly;
2182 EXPORT_SYMBOL(__per_cpu_offset);
2183 
2184 static void * __init pcpu_dfl_fc_alloc(unsigned int cpu, size_t size,
2185 				       size_t align)
2186 {
2187 	return  memblock_virt_alloc_from_nopanic(
2188 			size, align, __pa(MAX_DMA_ADDRESS));
2189 }
2190 
2191 static void __init pcpu_dfl_fc_free(void *ptr, size_t size)
2192 {
2193 	memblock_free_early(__pa(ptr), size);
2194 }
2195 
2196 void __init setup_per_cpu_areas(void)
2197 {
2198 	unsigned long delta;
2199 	unsigned int cpu;
2200 	int rc;
2201 
2202 	/*
2203 	 * Always reserve area for module percpu variables.  That's
2204 	 * what the legacy allocator did.
2205 	 */
2206 	rc = pcpu_embed_first_chunk(PERCPU_MODULE_RESERVE,
2207 				    PERCPU_DYNAMIC_RESERVE, PAGE_SIZE, NULL,
2208 				    pcpu_dfl_fc_alloc, pcpu_dfl_fc_free);
2209 	if (rc < 0)
2210 		panic("Failed to initialize percpu areas.");
2211 
2212 	delta = (unsigned long)pcpu_base_addr - (unsigned long)__per_cpu_start;
2213 	for_each_possible_cpu(cpu)
2214 		__per_cpu_offset[cpu] = delta + pcpu_unit_offsets[cpu];
2215 }
2216 #endif	/* CONFIG_HAVE_SETUP_PER_CPU_AREA */
2217 
2218 #else	/* CONFIG_SMP */
2219 
2220 /*
2221  * UP percpu area setup.
2222  *
2223  * UP always uses km-based percpu allocator with identity mapping.
2224  * Static percpu variables are indistinguishable from the usual static
2225  * variables and don't require any special preparation.
2226  */
2227 void __init setup_per_cpu_areas(void)
2228 {
2229 	const size_t unit_size =
2230 		roundup_pow_of_two(max_t(size_t, PCPU_MIN_UNIT_SIZE,
2231 					 PERCPU_DYNAMIC_RESERVE));
2232 	struct pcpu_alloc_info *ai;
2233 	void *fc;
2234 
2235 	ai = pcpu_alloc_alloc_info(1, 1);
2236 	fc = memblock_virt_alloc_from_nopanic(unit_size,
2237 					      PAGE_SIZE,
2238 					      __pa(MAX_DMA_ADDRESS));
2239 	if (!ai || !fc)
2240 		panic("Failed to allocate memory for percpu areas.");
2241 	/* kmemleak tracks the percpu allocations separately */
2242 	kmemleak_free(fc);
2243 
2244 	ai->dyn_size = unit_size;
2245 	ai->unit_size = unit_size;
2246 	ai->atom_size = unit_size;
2247 	ai->alloc_size = unit_size;
2248 	ai->groups[0].nr_units = 1;
2249 	ai->groups[0].cpu_map[0] = 0;
2250 
2251 	if (pcpu_setup_first_chunk(ai, fc) < 0)
2252 		panic("Failed to initialize percpu areas.");
2253 }
2254 
2255 #endif	/* CONFIG_SMP */
2256 
2257 /*
2258  * First and reserved chunks are initialized with temporary allocation
2259  * map in initdata so that they can be used before slab is online.
2260  * This function is called after slab is brought up and replaces those
2261  * with properly allocated maps.
2262  */
2263 void __init percpu_init_late(void)
2264 {
2265 	struct pcpu_chunk *target_chunks[] =
2266 		{ pcpu_first_chunk, pcpu_reserved_chunk, NULL };
2267 	struct pcpu_chunk *chunk;
2268 	unsigned long flags;
2269 	int i;
2270 
2271 	for (i = 0; (chunk = target_chunks[i]); i++) {
2272 		int *map;
2273 		const size_t size = PERCPU_DYNAMIC_EARLY_SLOTS * sizeof(map[0]);
2274 
2275 		BUILD_BUG_ON(size > PAGE_SIZE);
2276 
2277 		map = pcpu_mem_zalloc(size);
2278 		BUG_ON(!map);
2279 
2280 		spin_lock_irqsave(&pcpu_lock, flags);
2281 		memcpy(map, chunk->map, size);
2282 		chunk->map = map;
2283 		spin_unlock_irqrestore(&pcpu_lock, flags);
2284 	}
2285 }
2286 
2287 /*
2288  * Percpu allocator is initialized early during boot when neither slab or
2289  * workqueue is available.  Plug async management until everything is up
2290  * and running.
2291  */
2292 static int __init percpu_enable_async(void)
2293 {
2294 	pcpu_async_enabled = true;
2295 	return 0;
2296 }
2297 subsys_initcall(percpu_enable_async);
2298