| 1 | |
| 2 | |
| 3 | * mm/percpu.c - percpu memory allocator
|
| 4 | *
|
| 5 | * Copyright (C) 2009 SUSE Linux Products GmbH
|
| 6 | * Copyright (C) 2009 Tejun Heo <[email protected]>
|
| 7 | *
|
| 8 | * Copyright (C) 2017 Facebook Inc.
|
| 9 | * Copyright (C) 2017 Dennis Zhou <[email protected]>
|
| 10 | *
|
| 11 | * The percpu allocator handles both static and dynamic areas. Percpu
|
| 12 | * areas are allocated in chunks which are divided into units. There is
|
| 13 | * a 1-to-1 mapping for units to possible cpus. These units are grouped
|
| 14 | * based on NUMA properties of the machine.
|
| 15 | *
|
| 16 | * c0 c1 c2
|
| 17 | * ------------------- ------------------- ------------
|
| 18 | * | u0 | u1 | u2 | u3 | | u0 | u1 | u2 | u3 | | u0 | u1 | u
|
| 19 | * ------------------- ...... ------------------- .... ------------
|
| 20 | *
|
| 21 | * Allocation is done by offsets into a unit's address space. Ie., an
|
| 22 | * area of 512 bytes at 6k in c1 occupies 512 bytes at 6k in c1:u0,
|
| 23 | * c1:u1, c1:u2, etc. On NUMA machines, the mapping may be non-linear
|
| 24 | * and even sparse. Access is handled by configuring percpu base
|
| 25 | * registers according to the cpu to unit mappings and offsetting the
|
| 26 | * base address using pcpu_unit_size.
|
| 27 | *
|
| 28 | * There is special consideration for the first chunk which must handle
|
| 29 | * the static percpu variables in the kernel image as allocation services
|
| 30 | * are not online yet. In short, the first chunk is structured like so:
|
| 31 | *
|
| 32 | * <Static | [Reserved] | Dynamic>
|
| 33 | *
|
| 34 | * The static data is copied from the original section managed by the
|
| 35 | * linker. The reserved section, if non-zero, primarily manages static
|
| 36 | * percpu variables from kernel modules. Finally, the dynamic section
|
| 37 | * takes care of normal allocations.
|
| 38 | *
|
| 39 | * The allocator organizes chunks into lists according to free size and
|
| 40 | * memcg-awareness. To make a percpu allocation memcg-aware the __GFP_ACCOUNT
|
| 41 | * flag should be passed. All memcg-aware allocations are sharing one set
|
| 42 | * of chunks and all unaccounted allocations and allocations performed
|
| 43 | * by processes belonging to the root memory cgroup are using the second set.
|
| 44 | *
|
| 45 | * The allocator tries to allocate from the fullest chunk first. Each chunk
|
| 46 | * is managed by a bitmap with metadata blocks. The allocation map is updated
|
| 47 | * on every allocation and free to reflect the current state while the boundary
|
| 48 | * map is only updated on allocation. Each metadata block contains
|
| 49 | * information to help mitigate the need to iterate over large portions
|
| 50 | * of the bitmap. The reverse mapping from page to chunk is stored in
|
| 51 | * the page's index. Lastly, units are lazily backed and grow in unison.
|
| 52 | *
|
| 53 | * There is a unique conversion that goes on here between bytes and bits.
|
| 54 | * Each bit represents a fragment of size PCPU_MIN_ALLOC_SIZE. The chunk
|
| 55 | * tracks the number of pages it is responsible for in nr_pages. Helper
|
| 56 | * functions are used to convert from between the bytes, bits, and blocks.
|
| 57 | * All hints are managed in bits unless explicitly stated.
|
| 58 | *
|
| 59 | * To use this allocator, arch code should do the following:
|
| 60 | *
|
| 61 | * - define __addr_to_pcpu_ptr() and __pcpu_ptr_to_addr() to translate
|
| 62 | * regular address to percpu pointer and back if they need to be
|
| 63 | * different from the default
|
| 64 | *
|
| 65 | * - use pcpu_setup_first_chunk() during percpu area initialization to
|
| 66 | * setup the first chunk containing the kernel static percpu area
|
| 67 |
|
| 68 |
|
| 69 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
| 70 |
|
| 71 | #include <linux/bitmap.h>
|
| 72 | #include <linux/cpumask.h>
|
| 73 | #include <linux/memblock.h>
|
| 74 | #include <linux/err.h>
|
| 75 | #include <linux/list.h>
|
| 76 | #include <linux/log2.h>
|
| 77 | #include <linux/mm.h>
|
| 78 | #include <linux/module.h>
|
| 79 | #include <linux/mutex.h>
|
| 80 | #include <linux/percpu.h>
|
| 81 | #include <linux/pfn.h>
|
| 82 | #include <linux/slab.h>
|
| 83 | #include <linux/spinlock.h>
|
| 84 | #include <linux/vmalloc.h>
|
| 85 | #include <linux/workqueue.h>
|
| 86 | #include <linux/kmemleak.h>
|
| 87 | #include <linux/sched.h>
|
| 88 | #include <linux/sched/mm.h>
|
| 89 | #include <linux/memcontrol.h>
|
| 90 |
|
| 91 | #include <asm/cacheflush.h>
|
| 92 | #include <asm/sections.h>
|
| 93 | #include <asm/tlbflush.h>
|
| 94 | #include <asm/io.h>
|
| 95 |
|
| 96 | #define CREATE_TRACE_POINTS
|
| 97 | #include <trace/events/percpu.h>
|
| 98 |
|
| 99 | #include "percpu-internal.h"
|
| 100 |
|
| 101 | |
| 102 | * The slots are sorted by the size of the biggest continuous free area.
|
| 103 | * 1-31 bytes share the same slot.
|
| 104 |
|
| 105 | #define PCPU_SLOT_BASE_SHIFT 5
|
| 106 |
|
| 107 | #define PCPU_SLOT_FAIL_THRESHOLD 3
|
| 108 |
|
| 109 | #define PCPU_EMPTY_POP_PAGES_LOW 2
|
| 110 | #define PCPU_EMPTY_POP_PAGES_HIGH 4
|
| 111 |
|
| 112 | #ifdef CONFIG_SMP
|
| 113 |
|
| 114 | #ifndef __addr_to_pcpu_ptr
|
| 115 | #define __addr_to_pcpu_ptr(addr) \
|
| 116 | (void __percpu *)((unsigned long)(addr) - \
|
| 117 | (unsigned long)pcpu_base_addr + \
|
| 118 | (unsigned long)__per_cpu_start)
|
| 119 | #endif
|
| 120 | #ifndef __pcpu_ptr_to_addr
|
| 121 | #define __pcpu_ptr_to_addr(ptr) \
|
| 122 | (void __force *)((unsigned long)(ptr) + \
|
| 123 | (unsigned long)pcpu_base_addr - \
|
| 124 | (unsigned long)__per_cpu_start)
|
| 125 | #endif
|
| 126 | #else
|
| 127 |
|
| 128 | #define __addr_to_pcpu_ptr(addr) (void __percpu *)(addr)
|
| 129 | #define __pcpu_ptr_to_addr(ptr) (void __force *)(ptr)
|
| 130 | #endif
|
| 131 |
|
| 132 | static int pcpu_unit_pages __ro_after_init;
|
| 133 | static int pcpu_unit_size __ro_after_init;
|
| 134 | static int pcpu_nr_units __ro_after_init;
|
| 135 | static int pcpu_atom_size __ro_after_init;
|
| 136 | int pcpu_nr_slots __ro_after_init;
|
| 137 | static int pcpu_free_slot __ro_after_init;
|
| 138 | int pcpu_sidelined_slot __ro_after_init;
|
| 139 | int pcpu_to_depopulate_slot __ro_after_init;
|
| 140 | static size_t pcpu_chunk_struct_size __ro_after_init;
|
| 141 |
|
| 142 |
|
| 143 | static unsigned int pcpu_low_unit_cpu __ro_after_init;
|
| 144 | static unsigned int pcpu_high_unit_cpu __ro_after_init;
|
| 145 |
|
| 146 |
|
| 147 | void *pcpu_base_addr __ro_after_init;
|
| 148 |
|
| 149 | static const int *pcpu_unit_map __ro_after_init;
|
| 150 | const unsigned long *pcpu_unit_offsets __ro_after_init;
|
| 151 |
|
| 152 |
|
| 153 | static int pcpu_nr_groups __ro_after_init;
|
| 154 | static const unsigned long *pcpu_group_offsets __ro_after_init;
|
| 155 | static const size_t *pcpu_group_sizes __ro_after_init;
|
| 156 |
|
| 157 | |
| 158 | * The first chunk which always exists. Note that unlike other
|
| 159 | * chunks, this one can be allocated and mapped in several different
|
| 160 | * ways and thus often doesn't live in the vmalloc area.
|
| 161 |
|
| 162 | struct pcpu_chunk *pcpu_first_chunk __ro_after_init;
|
| 163 |
|
| 164 | |
| 165 | * Optional reserved chunk. This chunk reserves part of the first
|
| 166 | * chunk and serves it for reserved allocations. When the reserved
|
| 167 | * region doesn't exist, the following variable is NULL.
|
| 168 |
|
| 169 | struct pcpu_chunk *pcpu_reserved_chunk __ro_after_init;
|
| 170 |
|
| 171 | DEFINE_SPINLOCK(pcpu_lock);
|
| 172 | static DEFINE_MUTEX(pcpu_alloc_mutex);
|
| 173 |
|
| 174 | struct list_head *pcpu_chunk_lists __ro_after_init;
|
| 175 |
|
| 176 | |
| 177 | * The number of empty populated pages, protected by pcpu_lock.
|
| 178 | * The reserved chunk doesn't contribute to the count.
|
| 179 |
|
| 180 | int pcpu_nr_empty_pop_pages;
|
| 181 |
|
| 182 | |
| 183 | * The number of populated pages in use by the allocator, protected by
|
| 184 | * pcpu_lock. This number is kept per a unit per chunk (i.e. when a page gets
|
| 185 | * allocated/deallocated, it is allocated/deallocated in all units of a chunk
|
| 186 | * and increments/decrements this count by 1).
|
| 187 |
|
| 188 | static unsigned long pcpu_nr_populated;
|
| 189 |
|
| 190 | |
| 191 | * Balance work is used to populate or destroy chunks asynchronously. We
|
| 192 | * try to keep the number of populated free pages between
|
| 193 | * PCPU_EMPTY_POP_PAGES_LOW and HIGH for atomic allocations and at most one
|
| 194 | * empty chunk.
|
| 195 |
|
| 196 | static void pcpu_balance_workfn(struct work_struct *work);
|
| 197 | static DECLARE_WORK(pcpu_balance_work, pcpu_balance_workfn);
|
| 198 | static bool pcpu_async_enabled __read_mostly;
|
| 199 | static bool pcpu_atomic_alloc_failed;
|
| 200 |
|
| 201 | static void pcpu_schedule_balance_work(void)
|
| 202 | {
|
| 203 | if (pcpu_async_enabled)
|
| 204 | schedule_work(&pcpu_balance_work);
|
| 205 | }
|
| 206 |
|
| 207 | |
| 208 | * pcpu_addr_in_chunk - check if the address is served from this chunk
|
| 209 | * @chunk: chunk of interest
|
| 210 | * @addr: percpu address
|
| 211 | *
|
| 212 | * RETURNS:
|
| 213 | * True if the address is served from this chunk.
|
| 214 |
|
| 215 | static bool pcpu_addr_in_chunk(struct pcpu_chunk *chunk, void *addr)
|
| 216 | {
|
| 217 | void *start_addr, *end_addr;
|
| 218 |
|
| 219 | if (!chunk)
|
| 220 | return false;
|
| 221 |
|
| 222 | start_addr = chunk->base_addr + chunk->start_offset;
|
| 223 | end_addr = chunk->base_addr + chunk->nr_pages * PAGE_SIZE -
|
| 224 | chunk->end_offset;
|
| 225 |
|
| 226 | return addr >= start_addr && addr < end_addr;
|
| 227 | }
|
| 228 |
|
| 229 | static int __pcpu_size_to_slot(int size)
|
| 230 | {
|
| 231 | int highbit = fls(size);
|
| 232 | return max(highbit - PCPU_SLOT_BASE_SHIFT + 2, 1);
|
| 233 | }
|
| 234 |
|
| 235 | static int pcpu_size_to_slot(int size)
|
| 236 | {
|
| 237 | if (size == pcpu_unit_size)
|
| 238 | return pcpu_free_slot;
|
| 239 | return __pcpu_size_to_slot(size);
|
| 240 | }
|
| 241 |
|
| 242 | static int pcpu_chunk_slot(const struct pcpu_chunk *chunk)
|
| 243 | {
|
| 244 | const struct pcpu_block_md *chunk_md = &chunk->chunk_md;
|
| 245 |
|
| 246 | if (chunk->free_bytes < PCPU_MIN_ALLOC_SIZE ||
|
| 247 | chunk_md->contig_hint == 0)
|
| 248 | return 0;
|
| 249 |
|
| 250 | return pcpu_size_to_slot(chunk_md->contig_hint * PCPU_MIN_ALLOC_SIZE);
|
| 251 | }
|
| 252 |
|
| 253 |
|
| 254 | static void pcpu_set_page_chunk(struct page *page, struct pcpu_chunk *pcpu)
|
| 255 | {
|
| 256 | page->private = (unsigned long)pcpu;
|
| 257 | }
|
| 258 |
|
| 259 |
|
| 260 | static struct pcpu_chunk *pcpu_get_page_chunk(struct page *page)
|
| 261 | {
|
| 262 | return (struct pcpu_chunk *)page->private;
|
| 263 | }
|
| 264 |
|
| 265 | static int __maybe_unused pcpu_page_idx(unsigned int cpu, int page_idx)
|
| 266 | {
|
| 267 | return pcpu_unit_map[cpu] * pcpu_unit_pages + page_idx;
|
| 268 | }
|
| 269 |
|
| 270 | static unsigned long pcpu_unit_page_offset(unsigned int cpu, int page_idx)
|
| 271 | {
|
| 272 | return pcpu_unit_offsets[cpu] + (page_idx << PAGE_SHIFT);
|
| 273 | }
|
| 274 |
|
| 275 | static unsigned long pcpu_chunk_addr(struct pcpu_chunk *chunk,
|
| 276 | unsigned int cpu, int page_idx)
|
| 277 | {
|
| 278 | return (unsigned long)chunk->base_addr +
|
| 279 | pcpu_unit_page_offset(cpu, page_idx);
|
| 280 | }
|
| 281 |
|
| 282 | |
| 283 | * The following are helper functions to help access bitmaps and convert
|
| 284 | * between bitmap offsets to address offsets.
|
| 285 |
|
| 286 | static unsigned long *pcpu_index_alloc_map(struct pcpu_chunk *chunk, int index)
|
| 287 | {
|
| 288 | return chunk->alloc_map +
|
| 289 | (index * PCPU_BITMAP_BLOCK_BITS / BITS_PER_LONG);
|
| 290 | }
|
| 291 |
|
| 292 | static unsigned long pcpu_off_to_block_index(int off)
|
| 293 | {
|
| 294 | return off / PCPU_BITMAP_BLOCK_BITS;
|
| 295 | }
|
| 296 |
|
| 297 | static unsigned long pcpu_off_to_block_off(int off)
|
| 298 | {
|
| 299 | return off & (PCPU_BITMAP_BLOCK_BITS - 1);
|
| 300 | }
|
| 301 |
|
| 302 | static unsigned long pcpu_block_off_to_off(int index, int off)
|
| 303 | {
|
| 304 | return index * PCPU_BITMAP_BLOCK_BITS + off;
|
| 305 | }
|
| 306 |
|
| 307 | |
| 308 | * pcpu_check_block_hint - check against the contig hint
|
| 309 | * @block: block of interest
|
| 310 | * @bits: size of allocation
|
| 311 | * @align: alignment of area (max PAGE_SIZE)
|
| 312 | *
|
| 313 | * Check to see if the allocation can fit in the block's contig hint.
|
| 314 | * Note, a chunk uses the same hints as a block so this can also check against
|
| 315 | * the chunk's contig hint.
|
| 316 |
|
| 317 | static bool pcpu_check_block_hint(struct pcpu_block_md *block, int bits,
|
| 318 | size_t align)
|
| 319 | {
|
| 320 | int bit_off = ALIGN(block->contig_hint_start, align) -
|
| 321 | block->contig_hint_start;
|
| 322 |
|
| 323 | return bit_off + bits <= block->contig_hint;
|
| 324 | }
|
| 325 |
|
| 326 | |
| 327 | * pcpu_next_hint - determine which hint to use
|
| 328 | * @block: block of interest
|
| 329 | * @alloc_bits: size of allocation
|
| 330 | *
|
| 331 | * This determines if we should scan based on the scan_hint or first_free.
|
| 332 | * In general, we want to scan from first_free to fulfill allocations by
|
| 333 | * first fit. However, if we know a scan_hint at position scan_hint_start
|
| 334 | * cannot fulfill an allocation, we can begin scanning from there knowing
|
| 335 | * the contig_hint will be our fallback.
|
| 336 |
|
| 337 | static int pcpu_next_hint(struct pcpu_block_md *block, int alloc_bits)
|
| 338 | {
|
| 339 | |
| 340 | * The three conditions below determine if we can skip past the
|
| 341 | * scan_hint. First, does the scan hint exist. Second, is the
|
| 342 | * contig_hint after the scan_hint (possibly not true iff
|
| 343 | * contig_hint == scan_hint). Third, is the allocation request
|
| 344 | * larger than the scan_hint.
|
| 345 |
|
| 346 | if (block->scan_hint &&
|
| 347 | block->contig_hint_start > block->scan_hint_start &&
|
| 348 | alloc_bits > block->scan_hint)
|
| 349 | return block->scan_hint_start + block->scan_hint;
|
| 350 |
|
| 351 | return block->first_free;
|
| 352 | }
|
| 353 |
|
| 354 | |
| 355 | * pcpu_next_md_free_region - finds the next hint free area
|
| 356 | * @chunk: chunk of interest
|
| 357 | * @bit_off: chunk offset
|
| 358 | * @bits: size of free area
|
| 359 | *
|
| 360 | * Helper function for pcpu_for_each_md_free_region. It checks
|
| 361 | * block->contig_hint and performs aggregation across blocks to find the
|
| 362 | * next hint. It modifies bit_off and bits in-place to be consumed in the
|
| 363 | * loop.
|
| 364 |
|
| 365 | static void pcpu_next_md_free_region(struct pcpu_chunk *chunk, int *bit_off,
|
| 366 | int *bits)
|
| 367 | {
|
| 368 | int i = pcpu_off_to_block_index(*bit_off);
|
| 369 | int block_off = pcpu_off_to_block_off(*bit_off);
|
| 370 | struct pcpu_block_md *block;
|
| 371 |
|
| 372 | *bits = 0;
|
| 373 | for (block = chunk->md_blocks + i; i < pcpu_chunk_nr_blocks(chunk);
|
| 374 | block++, i++) {
|
| 375 |
|
| 376 | if (*bits) {
|
| 377 | *bits += block->left_free;
|
| 378 | if (block->left_free == PCPU_BITMAP_BLOCK_BITS)
|
| 379 | continue;
|
| 380 | return;
|
| 381 | }
|
| 382 |
|
| 383 | |
| 384 | * This checks three things. First is there a contig_hint to
|
| 385 | * check. Second, have we checked this hint before by
|
| 386 | * comparing the block_off. Third, is this the same as the
|
| 387 | * right contig hint. In the last case, it spills over into
|
| 388 | * the next block and should be handled by the contig area
|
| 389 | * across blocks code.
|
| 390 |
|
| 391 | *bits = block->contig_hint;
|
| 392 | if (*bits && block->contig_hint_start >= block_off &&
|
| 393 | *bits + block->contig_hint_start < PCPU_BITMAP_BLOCK_BITS) {
|
| 394 | *bit_off = pcpu_block_off_to_off(i,
|
| 395 | block->contig_hint_start);
|
| 396 | return;
|
| 397 | }
|
| 398 |
|
| 399 | block_off = 0;
|
| 400 |
|
| 401 | *bits = block->right_free;
|
| 402 | *bit_off = (i + 1) * PCPU_BITMAP_BLOCK_BITS - block->right_free;
|
| 403 | }
|
| 404 | }
|
| 405 |
|
| 406 | |
| 407 | * pcpu_next_fit_region - finds fit areas for a given allocation request
|
| 408 | * @chunk: chunk of interest
|
| 409 | * @alloc_bits: size of allocation
|
| 410 | * @align: alignment of area (max PAGE_SIZE)
|
| 411 | * @bit_off: chunk offset
|
| 412 | * @bits: size of free area
|
| 413 | *
|
| 414 | * Finds the next free region that is viable for use with a given size and
|
| 415 | * alignment. This only returns if there is a valid area to be used for this
|
| 416 | * allocation. block->first_free is returned if the allocation request fits
|
| 417 | * within the block to see if the request can be fulfilled prior to the contig
|
| 418 | * hint.
|
| 419 |
|
| 420 | static void pcpu_next_fit_region(struct pcpu_chunk *chunk, int alloc_bits,
|
| 421 | int align, int *bit_off, int *bits)
|
| 422 | {
|
| 423 | int i = pcpu_off_to_block_index(*bit_off);
|
| 424 | int block_off = pcpu_off_to_block_off(*bit_off);
|
| 425 | struct pcpu_block_md *block;
|
| 426 |
|
| 427 | *bits = 0;
|
| 428 | for (block = chunk->md_blocks + i; i < pcpu_chunk_nr_blocks(chunk);
|
| 429 | block++, i++) {
|
| 430 |
|
| 431 | if (*bits) {
|
| 432 | *bits += block->left_free;
|
| 433 | if (*bits >= alloc_bits)
|
| 434 | return;
|
| 435 | if (block->left_free == PCPU_BITMAP_BLOCK_BITS)
|
| 436 | continue;
|
| 437 | }
|
| 438 |
|
| 439 |
|
| 440 | *bits = ALIGN(block->contig_hint_start, align) -
|
| 441 | block->contig_hint_start;
|
| 442 | |
| 443 | * This uses the block offset to determine if this has been
|
| 444 | * checked in the prior iteration.
|
| 445 |
|
| 446 | if (block->contig_hint &&
|
| 447 | block->contig_hint_start >= block_off &&
|
| 448 | block->contig_hint >= *bits + alloc_bits) {
|
| 449 | int start = pcpu_next_hint(block, alloc_bits);
|
| 450 |
|
| 451 | *bits += alloc_bits + block->contig_hint_start -
|
| 452 | start;
|
| 453 | *bit_off = pcpu_block_off_to_off(i, start);
|
| 454 | return;
|
| 455 | }
|
| 456 |
|
| 457 | block_off = 0;
|
| 458 |
|
| 459 | *bit_off = ALIGN(PCPU_BITMAP_BLOCK_BITS - block->right_free,
|
| 460 | align);
|
| 461 | *bits = PCPU_BITMAP_BLOCK_BITS - *bit_off;
|
| 462 | *bit_off = pcpu_block_off_to_off(i, *bit_off);
|
| 463 | if (*bits >= alloc_bits)
|
| 464 | return;
|
| 465 | }
|
| 466 |
|
| 467 |
|
| 468 | *bit_off = pcpu_chunk_map_bits(chunk);
|
| 469 | }
|
| 470 |
|
| 471 | |
| 472 | * Metadata free area iterators. These perform aggregation of free areas
|
| 473 | * based on the metadata blocks and return the offset @bit_off and size in
|
| 474 | * bits of the free area @bits. pcpu_for_each_fit_region only returns when
|
| 475 | * a fit is found for the allocation request.
|
| 476 |
|
| 477 | #define pcpu_for_each_md_free_region(chunk, bit_off, bits) \
|
| 478 | for (pcpu_next_md_free_region((chunk), &(bit_off), &(bits)); \
|
| 479 | (bit_off) < pcpu_chunk_map_bits((chunk)); \
|
| 480 | (bit_off) += (bits) + 1, \
|
| 481 | pcpu_next_md_free_region((chunk), &(bit_off), &(bits)))
|
| 482 |
|
| 483 | #define pcpu_for_each_fit_region(chunk, alloc_bits, align, bit_off, bits) \
|
| 484 | for (pcpu_next_fit_region((chunk), (alloc_bits), (align), &(bit_off), \
|
| 485 | &(bits)); \
|
| 486 | (bit_off) < pcpu_chunk_map_bits((chunk)); \
|
| 487 | (bit_off) += (bits), \
|
| 488 | pcpu_next_fit_region((chunk), (alloc_bits), (align), &(bit_off), \
|
| 489 | &(bits)))
|
| 490 |
|
| 491 | |
| 492 | * pcpu_mem_zalloc - allocate memory
|
| 493 | * @size: bytes to allocate
|
| 494 | * @gfp: allocation flags
|
| 495 | *
|
| 496 | * Allocate @size bytes. If @size is smaller than PAGE_SIZE,
|
| 497 | * kzalloc() is used; otherwise, the equivalent of vzalloc() is used.
|
| 498 | * This is to facilitate passing through whitelisted flags. The
|
| 499 | * returned memory is always zeroed.
|
| 500 | *
|
| 501 | * RETURNS:
|
| 502 | * Pointer to the allocated area on success, NULL on failure.
|
| 503 |
|
| 504 | static void *pcpu_mem_zalloc(size_t size, gfp_t gfp)
|
| 505 | {
|
| 506 | if (WARN_ON_ONCE(!slab_is_available()))
|
| 507 | return NULL;
|
| 508 |
|
| 509 | if (size <= PAGE_SIZE)
|
| 510 | return kzalloc(size, gfp);
|
| 511 | else
|
| 512 | return __vmalloc(size, gfp | __GFP_ZERO);
|
| 513 | }
|
| 514 |
|
| 515 | |
| 516 | * pcpu_mem_free - free memory
|
| 517 | * @ptr: memory to free
|
| 518 | *
|
| 519 | * Free @ptr. @ptr should have been allocated using pcpu_mem_zalloc().
|
| 520 |
|
| 521 | static void pcpu_mem_free(void *ptr)
|
| 522 | {
|
| 523 | kvfree(ptr);
|
| 524 | }
|
| 525 |
|
| 526 | static void __pcpu_chunk_move(struct pcpu_chunk *chunk, int slot,
|
| 527 | bool move_front)
|
| 528 | {
|
| 529 | if (chunk != pcpu_reserved_chunk) {
|
| 530 | if (move_front)
|
| 531 | list_move(&chunk->list, &pcpu_chunk_lists[slot]);
|
| 532 | else
|
| 533 | list_move_tail(&chunk->list, &pcpu_chunk_lists[slot]);
|
| 534 | }
|
| 535 | }
|
| 536 |
|
| 537 | static void pcpu_chunk_move(struct pcpu_chunk *chunk, int slot)
|
| 538 | {
|
| 539 | __pcpu_chunk_move(chunk, slot, true);
|
| 540 | }
|
| 541 |
|
| 542 | |
| 543 | * pcpu_chunk_relocate - put chunk in the appropriate chunk slot
|
| 544 | * @chunk: chunk of interest
|
| 545 | * @oslot: the previous slot it was on
|
| 546 | *
|
| 547 | * This function is called after an allocation or free changed @chunk.
|
| 548 | * New slot according to the changed state is determined and @chunk is
|
| 549 | * moved to the slot. Note that the reserved chunk is never put on
|
| 550 | * chunk slots.
|
| 551 | *
|
| 552 | * CONTEXT:
|
| 553 | * pcpu_lock.
|
| 554 |
|
| 555 | static void pcpu_chunk_relocate(struct pcpu_chunk *chunk, int oslot)
|
| 556 | {
|
| 557 | int nslot = pcpu_chunk_slot(chunk);
|
| 558 |
|
| 559 |
|
| 560 | if (chunk->isolated)
|
| 561 | return;
|
| 562 |
|
| 563 | if (oslot != nslot)
|
| 564 | __pcpu_chunk_move(chunk, nslot, oslot < nslot);
|
| 565 | }
|
| 566 |
|
| 567 | static void pcpu_isolate_chunk(struct pcpu_chunk *chunk)
|
| 568 | {
|
| 569 | lockdep_assert_held(&pcpu_lock);
|
| 570 |
|
| 571 | if (!chunk->isolated) {
|
| 572 | chunk->isolated = true;
|
| 573 | pcpu_nr_empty_pop_pages -= chunk->nr_empty_pop_pages;
|
| 574 | }
|
| 575 | list_move(&chunk->list, &pcpu_chunk_lists[pcpu_to_depopulate_slot]);
|
| 576 | }
|
| 577 |
|
| 578 | static void pcpu_reintegrate_chunk(struct pcpu_chunk *chunk)
|
| 579 | {
|
| 580 | lockdep_assert_held(&pcpu_lock);
|
| 581 |
|
| 582 | if (chunk->isolated) {
|
| 583 | chunk->isolated = false;
|
| 584 | pcpu_nr_empty_pop_pages += chunk->nr_empty_pop_pages;
|
| 585 | pcpu_chunk_relocate(chunk, -1);
|
| 586 | }
|
| 587 | }
|
| 588 |
|
| 589 | |
| 590 | * pcpu_update_empty_pages - update empty page counters
|
| 591 | * @chunk: chunk of interest
|
| 592 | * @nr: nr of empty pages
|
| 593 | *
|
| 594 | * This is used to keep track of the empty pages now based on the premise
|
| 595 | * a md_block covers a page. The hint update functions recognize if a block
|
| 596 | * is made full or broken to calculate deltas for keeping track of free pages.
|
| 597 |
|
| 598 | static inline void pcpu_update_empty_pages(struct pcpu_chunk *chunk, int nr)
|
| 599 | {
|
| 600 | chunk->nr_empty_pop_pages += nr;
|
| 601 | if (chunk != pcpu_reserved_chunk && !chunk->isolated)
|
| 602 | pcpu_nr_empty_pop_pages += nr;
|
| 603 | }
|
| 604 |
|
| 605 | |
| 606 | * pcpu_region_overlap - determines if two regions overlap
|
| 607 | * @a: start of first region, inclusive
|
| 608 | * @b: end of first region, exclusive
|
| 609 | * @x: start of second region, inclusive
|
| 610 | * @y: end of second region, exclusive
|
| 611 | *
|
| 612 | * This is used to determine if the hint region [a, b) overlaps with the
|
| 613 | * allocated region [x, y).
|
| 614 |
|
| 615 | static inline bool pcpu_region_overlap(int a, int b, int x, int y)
|
| 616 | {
|
| 617 | return (a < y) && (x < b);
|
| 618 | }
|
| 619 |
|
| 620 | |
| 621 | * pcpu_block_update - updates a block given a free area
|
| 622 | * @block: block of interest
|
| 623 | * @start: start offset in block
|
| 624 | * @end: end offset in block
|
| 625 | *
|
| 626 | * Updates a block given a known free area. The region [start, end) is
|
| 627 | * expected to be the entirety of the free area within a block. Chooses
|
| 628 | * the best starting offset if the contig hints are equal.
|
| 629 |
|
| 630 | static void pcpu_block_update(struct pcpu_block_md *block, int start, int end)
|
| 631 | {
|
| 632 | int contig = end - start;
|
| 633 |
|
| 634 | block->first_free = min(block->first_free, start);
|
| 635 | if (start == 0)
|
| 636 | block->left_free = contig;
|
| 637 |
|
| 638 | if (end == block->nr_bits)
|
| 639 | block->right_free = contig;
|
| 640 |
|
| 641 | if (contig > block->contig_hint) {
|
| 642 |
|
| 643 | if (start > block->contig_hint_start) {
|
| 644 | if (block->contig_hint > block->scan_hint) {
|
| 645 | block->scan_hint_start =
|
| 646 | block->contig_hint_start;
|
| 647 | block->scan_hint = block->contig_hint;
|
| 648 | } else if (start < block->scan_hint_start) {
|
| 649 | |
| 650 | * The old contig_hint == scan_hint. But, the
|
| 651 | * new contig is larger so hold the invariant
|
| 652 | * scan_hint_start < contig_hint_start.
|
| 653 |
|
| 654 | block->scan_hint = 0;
|
| 655 | }
|
| 656 | } else {
|
| 657 | block->scan_hint = 0;
|
| 658 | }
|
| 659 | block->contig_hint_start = start;
|
| 660 | block->contig_hint = contig;
|
| 661 | } else if (contig == block->contig_hint) {
|
| 662 | if (block->contig_hint_start &&
|
| 663 | (!start ||
|
| 664 | __ffs(start) > __ffs(block->contig_hint_start))) {
|
| 665 |
|
| 666 | block->contig_hint_start = start;
|
| 667 | if (start < block->scan_hint_start &&
|
| 668 | block->contig_hint > block->scan_hint)
|
| 669 | block->scan_hint = 0;
|
| 670 | } else if (start > block->scan_hint_start ||
|
| 671 | block->contig_hint > block->scan_hint) {
|
| 672 | |
| 673 | * Knowing contig == contig_hint, update the scan_hint
|
| 674 | * if it is farther than or larger than the current
|
| 675 | * scan_hint.
|
| 676 |
|
| 677 | block->scan_hint_start = start;
|
| 678 | block->scan_hint = contig;
|
| 679 | }
|
| 680 | } else {
|
| 681 | |
| 682 | * The region is smaller than the contig_hint. So only update
|
| 683 | * the scan_hint if it is larger than or equal and farther than
|
| 684 | * the current scan_hint.
|
| 685 |
|
| 686 | if ((start < block->contig_hint_start &&
|
| 687 | (contig > block->scan_hint ||
|
| 688 | (contig == block->scan_hint &&
|
| 689 | start > block->scan_hint_start)))) {
|
| 690 | block->scan_hint_start = start;
|
| 691 | block->scan_hint = contig;
|
| 692 | }
|
| 693 | }
|
| 694 | }
|
| 695 |
|
| 696 | |
| 697 | * pcpu_block_update_scan - update a block given a free area from a scan
|
| 698 | * @chunk: chunk of interest
|
| 699 | * @bit_off: chunk offset
|
| 700 | * @bits: size of free area
|
| 701 | *
|
| 702 | * Finding the final allocation spot first goes through pcpu_find_block_fit()
|
| 703 | * to find a block that can hold the allocation and then pcpu_alloc_area()
|
| 704 | * where a scan is used. When allocations require specific alignments,
|
| 705 | * we can inadvertently create holes which will not be seen in the alloc
|
| 706 | * or free paths.
|
| 707 | *
|
| 708 | * This takes a given free area hole and updates a block as it may change the
|
| 709 | * scan_hint. We need to scan backwards to ensure we don't miss free bits
|
| 710 | * from alignment.
|
| 711 |
|
| 712 | static void pcpu_block_update_scan(struct pcpu_chunk *chunk, int bit_off,
|
| 713 | int bits)
|
| 714 | {
|
| 715 | int s_off = pcpu_off_to_block_off(bit_off);
|
| 716 | int e_off = s_off + bits;
|
| 717 | int s_index, l_bit;
|
| 718 | struct pcpu_block_md *block;
|
| 719 |
|
| 720 | if (e_off > PCPU_BITMAP_BLOCK_BITS)
|
| 721 | return;
|
| 722 |
|
| 723 | s_index = pcpu_off_to_block_index(bit_off);
|
| 724 | block = chunk->md_blocks + s_index;
|
| 725 |
|
| 726 |
|
| 727 | l_bit = find_last_bit(pcpu_index_alloc_map(chunk, s_index), s_off);
|
| 728 | s_off = (s_off == l_bit) ? 0 : l_bit + 1;
|
| 729 |
|
| 730 | pcpu_block_update(block, s_off, e_off);
|
| 731 | }
|
| 732 |
|
| 733 | |
| 734 | * pcpu_chunk_refresh_hint - updates metadata about a chunk
|
| 735 | * @chunk: chunk of interest
|
| 736 | * @full_scan: if we should scan from the beginning
|
| 737 | *
|
| 738 | * Iterates over the metadata blocks to find the largest contig area.
|
| 739 | * A full scan can be avoided on the allocation path as this is triggered
|
| 740 | * if we broke the contig_hint. In doing so, the scan_hint will be before
|
| 741 | * the contig_hint or after if the scan_hint == contig_hint. This cannot
|
| 742 | * be prevented on freeing as we want to find the largest area possibly
|
| 743 | * spanning blocks.
|
| 744 |
|
| 745 | static void pcpu_chunk_refresh_hint(struct pcpu_chunk *chunk, bool full_scan)
|
| 746 | {
|
| 747 | struct pcpu_block_md *chunk_md = &chunk->chunk_md;
|
| 748 | int bit_off, bits;
|
| 749 |
|
| 750 |
|
| 751 | if (!full_scan && chunk_md->scan_hint) {
|
| 752 | bit_off = chunk_md->scan_hint_start + chunk_md->scan_hint;
|
| 753 | chunk_md->contig_hint_start = chunk_md->scan_hint_start;
|
| 754 | chunk_md->contig_hint = chunk_md->scan_hint;
|
| 755 | chunk_md->scan_hint = 0;
|
| 756 | } else {
|
| 757 | bit_off = chunk_md->first_free;
|
| 758 | chunk_md->contig_hint = 0;
|
| 759 | }
|
| 760 |
|
| 761 | bits = 0;
|
| 762 | pcpu_for_each_md_free_region(chunk, bit_off, bits)
|
| 763 | pcpu_block_update(chunk_md, bit_off, bit_off + bits);
|
| 764 | }
|
| 765 |
|
| 766 | |
| 767 | * pcpu_block_refresh_hint
|
| 768 | * @chunk: chunk of interest
|
| 769 | * @index: index of the metadata block
|
| 770 | *
|
| 771 | * Scans over the block beginning at first_free and updates the block
|
| 772 | * metadata accordingly.
|
| 773 |
|
| 774 | static void pcpu_block_refresh_hint(struct pcpu_chunk *chunk, int index)
|
| 775 | {
|
| 776 | struct pcpu_block_md *block = chunk->md_blocks + index;
|
| 777 | unsigned long *alloc_map = pcpu_index_alloc_map(chunk, index);
|
| 778 | unsigned int start, end;
|
| 779 |
|
| 780 |
|
| 781 | if (block->scan_hint) {
|
| 782 | start = block->scan_hint_start + block->scan_hint;
|
| 783 | block->contig_hint_start = block->scan_hint_start;
|
| 784 | block->contig_hint = block->scan_hint;
|
| 785 | block->scan_hint = 0;
|
| 786 | } else {
|
| 787 | start = block->first_free;
|
| 788 | block->contig_hint = 0;
|
| 789 | }
|
| 790 |
|
| 791 | block->right_free = 0;
|
| 792 |
|
| 793 |
|
| 794 | for_each_clear_bitrange_from(start, end, alloc_map, PCPU_BITMAP_BLOCK_BITS)
|
| 795 | pcpu_block_update(block, start, end);
|
| 796 | }
|
| 797 |
|
| 798 | |
| 799 | * pcpu_block_update_hint_alloc - update hint on allocation path
|
| 800 | * @chunk: chunk of interest
|
| 801 | * @bit_off: chunk offset
|
| 802 | * @bits: size of request
|
| 803 | *
|
| 804 | * Updates metadata for the allocation path. The metadata only has to be
|
| 805 | * refreshed by a full scan iff the chunk's contig hint is broken. Block level
|
| 806 | * scans are required if the block's contig hint is broken.
|
| 807 |
|
| 808 | static void pcpu_block_update_hint_alloc(struct pcpu_chunk *chunk, int bit_off,
|
| 809 | int bits)
|
| 810 | {
|
| 811 | struct pcpu_block_md *chunk_md = &chunk->chunk_md;
|
| 812 | int nr_empty_pages = 0;
|
| 813 | struct pcpu_block_md *s_block, *e_block, *block;
|
| 814 | int s_index, e_index;
|
| 815 | int s_off, e_off;
|
| 816 |
|
| 817 | |
| 818 | * Calculate per block offsets.
|
| 819 | * The calculation uses an inclusive range, but the resulting offsets
|
| 820 | * are [start, end). e_index always points to the last block in the
|
| 821 | * range.
|
| 822 |
|
| 823 | s_index = pcpu_off_to_block_index(bit_off);
|
| 824 | e_index = pcpu_off_to_block_index(bit_off + bits - 1);
|
| 825 | s_off = pcpu_off_to_block_off(bit_off);
|
| 826 | e_off = pcpu_off_to_block_off(bit_off + bits - 1) + 1;
|
| 827 |
|
| 828 | s_block = chunk->md_blocks + s_index;
|
| 829 | e_block = chunk->md_blocks + e_index;
|
| 830 |
|
| 831 | |
| 832 | * Update s_block.
|
| 833 |
|
| 834 | if (s_block->contig_hint == PCPU_BITMAP_BLOCK_BITS)
|
| 835 | nr_empty_pages++;
|
| 836 |
|
| 837 | |
| 838 | * block->first_free must be updated if the allocation takes its place.
|
| 839 | * If the allocation breaks the contig_hint, a scan is required to
|
| 840 | * restore this hint.
|
| 841 |
|
| 842 | if (s_off == s_block->first_free)
|
| 843 | s_block->first_free = find_next_zero_bit(
|
| 844 | pcpu_index_alloc_map(chunk, s_index),
|
| 845 | PCPU_BITMAP_BLOCK_BITS,
|
| 846 | s_off + bits);
|
| 847 |
|
| 848 | if (pcpu_region_overlap(s_block->scan_hint_start,
|
| 849 | s_block->scan_hint_start + s_block->scan_hint,
|
| 850 | s_off,
|
| 851 | s_off + bits))
|
| 852 | s_block->scan_hint = 0;
|
| 853 |
|
| 854 | if (pcpu_region_overlap(s_block->contig_hint_start,
|
| 855 | s_block->contig_hint_start +
|
| 856 | s_block->contig_hint,
|
| 857 | s_off,
|
| 858 | s_off + bits)) {
|
| 859 |
|
| 860 | if (!s_off)
|
| 861 | s_block->left_free = 0;
|
| 862 | pcpu_block_refresh_hint(chunk, s_index);
|
| 863 | } else {
|
| 864 |
|
| 865 | s_block->left_free = min(s_block->left_free, s_off);
|
| 866 | if (s_index == e_index)
|
| 867 | s_block->right_free = min_t(int, s_block->right_free,
|
| 868 | PCPU_BITMAP_BLOCK_BITS - e_off);
|
| 869 | else
|
| 870 | s_block->right_free = 0;
|
| 871 | }
|
| 872 |
|
| 873 | |
| 874 | * Update e_block.
|
| 875 |
|
| 876 | if (s_index != e_index) {
|
| 877 | if (e_block->contig_hint == PCPU_BITMAP_BLOCK_BITS)
|
| 878 | nr_empty_pages++;
|
| 879 |
|
| 880 | |
| 881 | * When the allocation is across blocks, the end is along
|
| 882 | * the left part of the e_block.
|
| 883 |
|
| 884 | e_block->first_free = find_next_zero_bit(
|
| 885 | pcpu_index_alloc_map(chunk, e_index),
|
| 886 | PCPU_BITMAP_BLOCK_BITS, e_off);
|
| 887 |
|
| 888 | if (e_off == PCPU_BITMAP_BLOCK_BITS) {
|
| 889 |
|
| 890 | e_block++;
|
| 891 | } else {
|
| 892 | if (e_off > e_block->scan_hint_start)
|
| 893 | e_block->scan_hint = 0;
|
| 894 |
|
| 895 | e_block->left_free = 0;
|
| 896 | if (e_off > e_block->contig_hint_start) {
|
| 897 |
|
| 898 | pcpu_block_refresh_hint(chunk, e_index);
|
| 899 | } else {
|
| 900 | e_block->right_free =
|
| 901 | min_t(int, e_block->right_free,
|
| 902 | PCPU_BITMAP_BLOCK_BITS - e_off);
|
| 903 | }
|
| 904 | }
|
| 905 |
|
| 906 |
|
| 907 | nr_empty_pages += (e_index - s_index - 1);
|
| 908 | for (block = s_block + 1; block < e_block; block++) {
|
| 909 | block->scan_hint = 0;
|
| 910 | block->contig_hint = 0;
|
| 911 | block->left_free = 0;
|
| 912 | block->right_free = 0;
|
| 913 | }
|
| 914 | }
|
| 915 |
|
| 916 | |
| 917 | * If the allocation is not atomic, some blocks may not be
|
| 918 | * populated with pages, while we account it here. The number
|
| 919 | * of pages will be added back with pcpu_chunk_populated()
|
| 920 | * when populating pages.
|
| 921 |
|
| 922 | if (nr_empty_pages)
|
| 923 | pcpu_update_empty_pages(chunk, -nr_empty_pages);
|
| 924 |
|
| 925 | if (pcpu_region_overlap(chunk_md->scan_hint_start,
|
| 926 | chunk_md->scan_hint_start +
|
| 927 | chunk_md->scan_hint,
|
| 928 | bit_off,
|
| 929 | bit_off + bits))
|
| 930 | chunk_md->scan_hint = 0;
|
| 931 |
|
| 932 | |
| 933 | * The only time a full chunk scan is required is if the chunk
|
| 934 | * contig hint is broken. Otherwise, it means a smaller space
|
| 935 | * was used and therefore the chunk contig hint is still correct.
|
| 936 |
|
| 937 | if (pcpu_region_overlap(chunk_md->contig_hint_start,
|
| 938 | chunk_md->contig_hint_start +
|
| 939 | chunk_md->contig_hint,
|
| 940 | bit_off,
|
| 941 | bit_off + bits))
|
| 942 | pcpu_chunk_refresh_hint(chunk, false);
|
| 943 | }
|
| 944 |
|
| 945 | |
| 946 | * pcpu_block_update_hint_free - updates the block hints on the free path
|
| 947 | * @chunk: chunk of interest
|
| 948 | * @bit_off: chunk offset
|
| 949 | * @bits: size of request
|
| 950 | *
|
| 951 | * Updates metadata for the allocation path. This avoids a blind block
|
| 952 | * refresh by making use of the block contig hints. If this fails, it scans
|
| 953 | * forward and backward to determine the extent of the free area. This is
|
| 954 | * capped at the boundary of blocks.
|
| 955 | *
|
| 956 | * A chunk update is triggered if a page becomes free, a block becomes free,
|
| 957 | * or the free spans across blocks. This tradeoff is to minimize iterating
|
| 958 | * over the block metadata to update chunk_md->contig_hint.
|
| 959 | * chunk_md->contig_hint may be off by up to a page, but it will never be more
|
| 960 | * than the available space. If the contig hint is contained in one block, it
|
| 961 | * will be accurate.
|
| 962 |
|
| 963 | static void pcpu_block_update_hint_free(struct pcpu_chunk *chunk, int bit_off,
|
| 964 | int bits)
|
| 965 | {
|
| 966 | int nr_empty_pages = 0;
|
| 967 | struct pcpu_block_md *s_block, *e_block, *block;
|
| 968 | int s_index, e_index;
|
| 969 | int s_off, e_off;
|
| 970 | int start, end;
|
| 971 |
|
| 972 | |
| 973 | * Calculate per block offsets.
|
| 974 | * The calculation uses an inclusive range, but the resulting offsets
|
| 975 | * are [start, end). e_index always points to the last block in the
|
| 976 | * range.
|
| 977 |
|
| 978 | s_index = pcpu_off_to_block_index(bit_off);
|
| 979 | e_index = pcpu_off_to_block_index(bit_off + bits - 1);
|
| 980 | s_off = pcpu_off_to_block_off(bit_off);
|
| 981 | e_off = pcpu_off_to_block_off(bit_off + bits - 1) + 1;
|
| 982 |
|
| 983 | s_block = chunk->md_blocks + s_index;
|
| 984 | e_block = chunk->md_blocks + e_index;
|
| 985 |
|
| 986 | |
| 987 | * Check if the freed area aligns with the block->contig_hint.
|
| 988 | * If it does, then the scan to find the beginning/end of the
|
| 989 | * larger free area can be avoided.
|
| 990 | *
|
| 991 | * start and end refer to beginning and end of the free area
|
| 992 | * within each their respective blocks. This is not necessarily
|
| 993 | * the entire free area as it may span blocks past the beginning
|
| 994 | * or end of the block.
|
| 995 |
|
| 996 | start = s_off;
|
| 997 | if (s_off == s_block->contig_hint + s_block->contig_hint_start) {
|
| 998 | start = s_block->contig_hint_start;
|
| 999 | } else {
|
| 1000 | |
| 1001 | * Scan backwards to find the extent of the free area.
|
| 1002 | * find_last_bit returns the starting bit, so if the start bit
|
| 1003 | * is returned, that means there was no last bit and the
|
| 1004 | * remainder of the chunk is free.
|
| 1005 |
|
| 1006 | int l_bit = find_last_bit(pcpu_index_alloc_map(chunk, s_index),
|
| 1007 | start);
|
| 1008 | start = (start == l_bit) ? 0 : l_bit + 1;
|
| 1009 | }
|
| 1010 |
|
| 1011 | end = e_off;
|
| 1012 | if (e_off == e_block->contig_hint_start)
|
| 1013 | end = e_block->contig_hint_start + e_block->contig_hint;
|
| 1014 | else
|
| 1015 | end = find_next_bit(pcpu_index_alloc_map(chunk, e_index),
|
| 1016 | PCPU_BITMAP_BLOCK_BITS, end);
|
| 1017 |
|
| 1018 |
|
| 1019 | e_off = (s_index == e_index) ? end : PCPU_BITMAP_BLOCK_BITS;
|
| 1020 | if (!start && e_off == PCPU_BITMAP_BLOCK_BITS)
|
| 1021 | nr_empty_pages++;
|
| 1022 | pcpu_block_update(s_block, start, e_off);
|
| 1023 |
|
| 1024 |
|
| 1025 | if (s_index != e_index) {
|
| 1026 |
|
| 1027 | if (end == PCPU_BITMAP_BLOCK_BITS)
|
| 1028 | nr_empty_pages++;
|
| 1029 | pcpu_block_update(e_block, 0, end);
|
| 1030 |
|
| 1031 |
|
| 1032 | nr_empty_pages += (e_index - s_index - 1);
|
| 1033 | for (block = s_block + 1; block < e_block; block++) {
|
| 1034 | block->first_free = 0;
|
| 1035 | block->scan_hint = 0;
|
| 1036 | block->contig_hint_start = 0;
|
| 1037 | block->contig_hint = PCPU_BITMAP_BLOCK_BITS;
|
| 1038 | block->left_free = PCPU_BITMAP_BLOCK_BITS;
|
| 1039 | block->right_free = PCPU_BITMAP_BLOCK_BITS;
|
| 1040 | }
|
| 1041 | }
|
| 1042 |
|
| 1043 | if (nr_empty_pages)
|
| 1044 | pcpu_update_empty_pages(chunk, nr_empty_pages);
|
| 1045 |
|
| 1046 | |
| 1047 | * Refresh chunk metadata when the free makes a block free or spans
|
| 1048 | * across blocks. The contig_hint may be off by up to a page, but if
|
| 1049 | * the contig_hint is contained in a block, it will be accurate with
|
| 1050 | * the else condition below.
|
| 1051 |
|
| 1052 | if (((end - start) >= PCPU_BITMAP_BLOCK_BITS) || s_index != e_index)
|
| 1053 | pcpu_chunk_refresh_hint(chunk, true);
|
| 1054 | else
|
| 1055 | pcpu_block_update(&chunk->chunk_md,
|
| 1056 | pcpu_block_off_to_off(s_index, start),
|
| 1057 | end);
|
| 1058 | }
|
| 1059 |
|
| 1060 | |
| 1061 | * pcpu_is_populated - determines if the region is populated
|
| 1062 | * @chunk: chunk of interest
|
| 1063 | * @bit_off: chunk offset
|
| 1064 | * @bits: size of area
|
| 1065 | * @next_off: return value for the next offset to start searching
|
| 1066 | *
|
| 1067 | * For atomic allocations, check if the backing pages are populated.
|
| 1068 | *
|
| 1069 | * RETURNS:
|
| 1070 | * Bool if the backing pages are populated.
|
| 1071 | * next_index is to skip over unpopulated blocks in pcpu_find_block_fit.
|
| 1072 |
|
| 1073 | static bool pcpu_is_populated(struct pcpu_chunk *chunk, int bit_off, int bits,
|
| 1074 | int *next_off)
|
| 1075 | {
|
| 1076 | unsigned int start, end;
|
| 1077 |
|
| 1078 | start = PFN_DOWN(bit_off * PCPU_MIN_ALLOC_SIZE);
|
| 1079 | end = PFN_UP((bit_off + bits) * PCPU_MIN_ALLOC_SIZE);
|
| 1080 |
|
| 1081 | start = find_next_zero_bit(chunk->populated, end, start);
|
| 1082 | if (start >= end)
|
| 1083 | return true;
|
| 1084 |
|
| 1085 | end = find_next_bit(chunk->populated, end, start + 1);
|
| 1086 |
|
| 1087 | *next_off = end * PAGE_SIZE / PCPU_MIN_ALLOC_SIZE;
|
| 1088 | return false;
|
| 1089 | }
|
| 1090 |
|
| 1091 | |
| 1092 | * pcpu_find_block_fit - finds the block index to start searching
|
| 1093 | * @chunk: chunk of interest
|
| 1094 | * @alloc_bits: size of request in allocation units
|
| 1095 | * @align: alignment of area (max PAGE_SIZE bytes)
|
| 1096 | * @pop_only: use populated regions only
|
| 1097 | *
|
| 1098 | * Given a chunk and an allocation spec, find the offset to begin searching
|
| 1099 | * for a free region. This iterates over the bitmap metadata blocks to
|
| 1100 | * find an offset that will be guaranteed to fit the requirements. It is
|
| 1101 | * not quite first fit as if the allocation does not fit in the contig hint
|
| 1102 | * of a block or chunk, it is skipped. This errs on the side of caution
|
| 1103 | * to prevent excess iteration. Poor alignment can cause the allocator to
|
| 1104 | * skip over blocks and chunks that have valid free areas.
|
| 1105 | *
|
| 1106 | * RETURNS:
|
| 1107 | * The offset in the bitmap to begin searching.
|
| 1108 | * -1 if no offset is found.
|
| 1109 |
|
| 1110 | static int pcpu_find_block_fit(struct pcpu_chunk *chunk, int alloc_bits,
|
| 1111 | size_t align, bool pop_only)
|
| 1112 | {
|
| 1113 | struct pcpu_block_md *chunk_md = &chunk->chunk_md;
|
| 1114 | int bit_off, bits, next_off;
|
| 1115 |
|
| 1116 | |
| 1117 | * This is an optimization to prevent scanning by assuming if the
|
| 1118 | * allocation cannot fit in the global hint, there is memory pressure
|
| 1119 | * and creating a new chunk would happen soon.
|
| 1120 |
|
| 1121 | if (!pcpu_check_block_hint(chunk_md, alloc_bits, align))
|
| 1122 | return -1;
|
| 1123 |
|
| 1124 | bit_off = pcpu_next_hint(chunk_md, alloc_bits);
|
| 1125 | bits = 0;
|
| 1126 | pcpu_for_each_fit_region(chunk, alloc_bits, align, bit_off, bits) {
|
| 1127 | if (!pop_only || pcpu_is_populated(chunk, bit_off, bits,
|
| 1128 | &next_off))
|
| 1129 | break;
|
| 1130 |
|
| 1131 | bit_off = next_off;
|
| 1132 | bits = 0;
|
| 1133 | }
|
| 1134 |
|
| 1135 | if (bit_off == pcpu_chunk_map_bits(chunk))
|
| 1136 | return -1;
|
| 1137 |
|
| 1138 | return bit_off;
|
| 1139 | }
|
| 1140 |
|
| 1141 | |
| 1142 | * pcpu_find_zero_area - modified from bitmap_find_next_zero_area_off()
|
| 1143 | * @map: the address to base the search on
|
| 1144 | * @size: the bitmap size in bits
|
| 1145 | * @start: the bitnumber to start searching at
|
| 1146 | * @nr: the number of zeroed bits we're looking for
|
| 1147 | * @align_mask: alignment mask for zero area
|
| 1148 | * @largest_off: offset of the largest area skipped
|
| 1149 | * @largest_bits: size of the largest area skipped
|
| 1150 | *
|
| 1151 | * The @align_mask should be one less than a power of 2.
|
| 1152 | *
|
| 1153 | * This is a modified version of bitmap_find_next_zero_area_off() to remember
|
| 1154 | * the largest area that was skipped. This is imperfect, but in general is
|
| 1155 | * good enough. The largest remembered region is the largest failed region
|
| 1156 | * seen. This does not include anything we possibly skipped due to alignment.
|
| 1157 | * pcpu_block_update_scan() does scan backwards to try and recover what was
|
| 1158 | * lost to alignment. While this can cause scanning to miss earlier possible
|
| 1159 | * free areas, smaller allocations will eventually fill those holes.
|
| 1160 |
|
| 1161 | static unsigned long pcpu_find_zero_area(unsigned long *map,
|
| 1162 | unsigned long size,
|
| 1163 | unsigned long start,
|
| 1164 | unsigned long nr,
|
| 1165 | unsigned long align_mask,
|
| 1166 | unsigned long *largest_off,
|
| 1167 | unsigned long *largest_bits)
|
| 1168 | {
|
| 1169 | unsigned long index, end, i, area_off, area_bits;
|
| 1170 | again:
|
| 1171 | index = find_next_zero_bit(map, size, start);
|
| 1172 |
|
| 1173 |
|
| 1174 | index = __ALIGN_MASK(index, align_mask);
|
| 1175 | area_off = index;
|
| 1176 |
|
| 1177 | end = index + nr;
|
| 1178 | if (end > size)
|
| 1179 | return end;
|
| 1180 | i = find_next_bit(map, end, index);
|
| 1181 | if (i < end) {
|
| 1182 | area_bits = i - area_off;
|
| 1183 |
|
| 1184 | if (area_bits > *largest_bits ||
|
| 1185 | (area_bits == *largest_bits && *largest_off &&
|
| 1186 | (!area_off || __ffs(area_off) > __ffs(*largest_off)))) {
|
| 1187 | *largest_off = area_off;
|
| 1188 | *largest_bits = area_bits;
|
| 1189 | }
|
| 1190 |
|
| 1191 | start = i + 1;
|
| 1192 | goto again;
|
| 1193 | }
|
| 1194 | return index;
|
| 1195 | }
|
| 1196 |
|
| 1197 | |
| 1198 | * pcpu_alloc_area - allocates an area from a pcpu_chunk
|
| 1199 | * @chunk: chunk of interest
|
| 1200 | * @alloc_bits: size of request in allocation units
|
| 1201 | * @align: alignment of area (max PAGE_SIZE)
|
| 1202 | * @start: bit_off to start searching
|
| 1203 | *
|
| 1204 | * This function takes in a @start offset to begin searching to fit an
|
| 1205 | * allocation of @alloc_bits with alignment @align. It needs to scan
|
| 1206 | * the allocation map because if it fits within the block's contig hint,
|
| 1207 | * @start will be block->first_free. This is an attempt to fill the
|
| 1208 | * allocation prior to breaking the contig hint. The allocation and
|
| 1209 | * boundary maps are updated accordingly if it confirms a valid
|
| 1210 | * free area.
|
| 1211 | *
|
| 1212 | * RETURNS:
|
| 1213 | * Allocated addr offset in @chunk on success.
|
| 1214 | * -1 if no matching area is found.
|
| 1215 |
|
| 1216 | static int pcpu_alloc_area(struct pcpu_chunk *chunk, int alloc_bits,
|
| 1217 | size_t align, int start)
|
| 1218 | {
|
| 1219 | struct pcpu_block_md *chunk_md = &chunk->chunk_md;
|
| 1220 | size_t align_mask = (align) ? (align - 1) : 0;
|
| 1221 | unsigned long area_off = 0, area_bits = 0;
|
| 1222 | int bit_off, end, oslot;
|
| 1223 |
|
| 1224 | lockdep_assert_held(&pcpu_lock);
|
| 1225 |
|
| 1226 | oslot = pcpu_chunk_slot(chunk);
|
| 1227 |
|
| 1228 | |
| 1229 | * Search to find a fit.
|
| 1230 |
|
| 1231 | end = min_t(int, start + alloc_bits + PCPU_BITMAP_BLOCK_BITS,
|
| 1232 | pcpu_chunk_map_bits(chunk));
|
| 1233 | bit_off = pcpu_find_zero_area(chunk->alloc_map, end, start, alloc_bits,
|
| 1234 | align_mask, &area_off, &area_bits);
|
| 1235 | if (bit_off >= end)
|
| 1236 | return -1;
|
| 1237 |
|
| 1238 | if (area_bits)
|
| 1239 | pcpu_block_update_scan(chunk, area_off, area_bits);
|
| 1240 |
|
| 1241 |
|
| 1242 | bitmap_set(chunk->alloc_map, bit_off, alloc_bits);
|
| 1243 |
|
| 1244 |
|
| 1245 | set_bit(bit_off, chunk->bound_map);
|
| 1246 | bitmap_clear(chunk->bound_map, bit_off + 1, alloc_bits - 1);
|
| 1247 | set_bit(bit_off + alloc_bits, chunk->bound_map);
|
| 1248 |
|
| 1249 | chunk->free_bytes -= alloc_bits * PCPU_MIN_ALLOC_SIZE;
|
| 1250 |
|
| 1251 |
|
| 1252 | if (bit_off == chunk_md->first_free)
|
| 1253 | chunk_md->first_free = find_next_zero_bit(
|
| 1254 | chunk->alloc_map,
|
| 1255 | pcpu_chunk_map_bits(chunk),
|
| 1256 | bit_off + alloc_bits);
|
| 1257 |
|
| 1258 | pcpu_block_update_hint_alloc(chunk, bit_off, alloc_bits);
|
| 1259 |
|
| 1260 | pcpu_chunk_relocate(chunk, oslot);
|
| 1261 |
|
| 1262 | return bit_off * PCPU_MIN_ALLOC_SIZE;
|
| 1263 | }
|
| 1264 |
|
| 1265 | |
| 1266 | * pcpu_free_area - frees the corresponding offset
|
| 1267 | * @chunk: chunk of interest
|
| 1268 | * @off: addr offset into chunk
|
| 1269 | *
|
| 1270 | * This function determines the size of an allocation to free using
|
| 1271 | * the boundary bitmap and clears the allocation map.
|
| 1272 | *
|
| 1273 | * RETURNS:
|
| 1274 | * Number of freed bytes.
|
| 1275 |
|
| 1276 | static int pcpu_free_area(struct pcpu_chunk *chunk, int off)
|
| 1277 | {
|
| 1278 | struct pcpu_block_md *chunk_md = &chunk->chunk_md;
|
| 1279 | int bit_off, bits, end, oslot, freed;
|
| 1280 |
|
| 1281 | lockdep_assert_held(&pcpu_lock);
|
| 1282 |
|
| 1283 | oslot = pcpu_chunk_slot(chunk);
|
| 1284 |
|
| 1285 | bit_off = off / PCPU_MIN_ALLOC_SIZE;
|
| 1286 |
|
| 1287 |
|
| 1288 | if (!test_bit(bit_off, chunk->alloc_map) ||
|
| 1289 | !test_bit(bit_off, chunk->bound_map))
|
| 1290 | return 0;
|
| 1291 |
|
| 1292 |
|
| 1293 | end = find_next_bit(chunk->bound_map, pcpu_chunk_map_bits(chunk),
|
| 1294 | bit_off + 1);
|
| 1295 | bits = end - bit_off;
|
| 1296 | bitmap_clear(chunk->alloc_map, bit_off, bits);
|
| 1297 |
|
| 1298 | freed = bits * PCPU_MIN_ALLOC_SIZE;
|
| 1299 |
|
| 1300 |
|
| 1301 | chunk->free_bytes += freed;
|
| 1302 |
|
| 1303 |
|
| 1304 | chunk_md->first_free = min(chunk_md->first_free, bit_off);
|
| 1305 |
|
| 1306 | pcpu_block_update_hint_free(chunk, bit_off, bits);
|
| 1307 |
|
| 1308 | pcpu_chunk_relocate(chunk, oslot);
|
| 1309 |
|
| 1310 | pcpu_stats_area_dealloc(chunk);
|
| 1311 |
|
| 1312 | return freed;
|
| 1313 | }
|
| 1314 |
|
| 1315 | static void pcpu_init_md_block(struct pcpu_block_md *block, int nr_bits)
|
| 1316 | {
|
| 1317 | block->scan_hint = 0;
|
| 1318 | block->contig_hint = nr_bits;
|
| 1319 | block->left_free = nr_bits;
|
| 1320 | block->right_free = nr_bits;
|
| 1321 | block->first_free = 0;
|
| 1322 | block->nr_bits = nr_bits;
|
| 1323 | }
|
| 1324 |
|
| 1325 | static void pcpu_init_md_blocks(struct pcpu_chunk *chunk)
|
| 1326 | {
|
| 1327 | struct pcpu_block_md *md_block;
|
| 1328 |
|
| 1329 |
|
| 1330 | pcpu_init_md_block(&chunk->chunk_md, pcpu_chunk_map_bits(chunk));
|
| 1331 |
|
| 1332 | for (md_block = chunk->md_blocks;
|
| 1333 | md_block != chunk->md_blocks + pcpu_chunk_nr_blocks(chunk);
|
| 1334 | md_block++)
|
| 1335 | pcpu_init_md_block(md_block, PCPU_BITMAP_BLOCK_BITS);
|
| 1336 | }
|
| 1337 |
|
| 1338 | |
| 1339 | * pcpu_alloc_first_chunk - creates chunks that serve the first chunk
|
| 1340 | * @tmp_addr: the start of the region served
|
| 1341 | * @map_size: size of the region served
|
| 1342 | *
|
| 1343 | * This is responsible for creating the chunks that serve the first chunk. The
|
| 1344 | * base_addr is page aligned down of @tmp_addr while the region end is page
|
| 1345 | * aligned up. Offsets are kept track of to determine the region served. All
|
| 1346 | * this is done to appease the bitmap allocator in avoiding partial blocks.
|
| 1347 | *
|
| 1348 | * RETURNS:
|
| 1349 | * Chunk serving the region at @tmp_addr of @map_size.
|
| 1350 |
|
| 1351 | static struct pcpu_chunk * __init pcpu_alloc_first_chunk(unsigned long tmp_addr,
|
| 1352 | int map_size)
|
| 1353 | {
|
| 1354 | struct pcpu_chunk *chunk;
|
| 1355 | unsigned long aligned_addr;
|
| 1356 | int start_offset, offset_bits, region_size, region_bits;
|
| 1357 | size_t alloc_size;
|
| 1358 |
|
| 1359 |
|
| 1360 | aligned_addr = tmp_addr & PAGE_MASK;
|
| 1361 |
|
| 1362 | start_offset = tmp_addr - aligned_addr;
|
| 1363 | region_size = ALIGN(start_offset + map_size, PAGE_SIZE);
|
| 1364 |
|
| 1365 |
|
| 1366 | alloc_size = struct_size(chunk, populated,
|
| 1367 | BITS_TO_LONGS(region_size >> PAGE_SHIFT));
|
| 1368 | chunk = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES);
|
| 1369 |
|
| 1370 | INIT_LIST_HEAD(&chunk->list);
|
| 1371 |
|
| 1372 | chunk->base_addr = (void *)aligned_addr;
|
| 1373 | chunk->start_offset = start_offset;
|
| 1374 | chunk->end_offset = region_size - chunk->start_offset - map_size;
|
| 1375 |
|
| 1376 | chunk->nr_pages = region_size >> PAGE_SHIFT;
|
| 1377 | region_bits = pcpu_chunk_map_bits(chunk);
|
| 1378 |
|
| 1379 | alloc_size = BITS_TO_LONGS(region_bits) * sizeof(chunk->alloc_map[0]);
|
| 1380 | chunk->alloc_map = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES);
|
| 1381 |
|
| 1382 | alloc_size =
|
| 1383 | BITS_TO_LONGS(region_bits + 1) * sizeof(chunk->bound_map[0]);
|
| 1384 | chunk->bound_map = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES);
|
| 1385 |
|
| 1386 | alloc_size = pcpu_chunk_nr_blocks(chunk) * sizeof(chunk->md_blocks[0]);
|
| 1387 | chunk->md_blocks = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES);
|
| 1388 | #ifdef NEED_PCPUOBJ_EXT
|
| 1389 |
|
| 1390 | chunk->obj_exts = NULL;
|
| 1391 | #endif
|
| 1392 | pcpu_init_md_blocks(chunk);
|
| 1393 |
|
| 1394 |
|
| 1395 | chunk->immutable = true;
|
| 1396 | bitmap_fill(chunk->populated, chunk->nr_pages);
|
| 1397 | chunk->nr_populated = chunk->nr_pages;
|
| 1398 | chunk->nr_empty_pop_pages = chunk->nr_pages;
|
| 1399 |
|
| 1400 | chunk->free_bytes = map_size;
|
| 1401 |
|
| 1402 | if (chunk->start_offset) {
|
| 1403 |
|
| 1404 | offset_bits = chunk->start_offset / PCPU_MIN_ALLOC_SIZE;
|
| 1405 | bitmap_set(chunk->alloc_map, 0, offset_bits);
|
| 1406 | set_bit(0, chunk->bound_map);
|
| 1407 | set_bit(offset_bits, chunk->bound_map);
|
| 1408 |
|
| 1409 | chunk->chunk_md.first_free = offset_bits;
|
| 1410 |
|
| 1411 | pcpu_block_update_hint_alloc(chunk, 0, offset_bits);
|
| 1412 | }
|
| 1413 |
|
| 1414 | if (chunk->end_offset) {
|
| 1415 |
|
| 1416 | offset_bits = chunk->end_offset / PCPU_MIN_ALLOC_SIZE;
|
| 1417 | bitmap_set(chunk->alloc_map,
|
| 1418 | pcpu_chunk_map_bits(chunk) - offset_bits,
|
| 1419 | offset_bits);
|
| 1420 | set_bit((start_offset + map_size) / PCPU_MIN_ALLOC_SIZE,
|
| 1421 | chunk->bound_map);
|
| 1422 | set_bit(region_bits, chunk->bound_map);
|
| 1423 |
|
| 1424 | pcpu_block_update_hint_alloc(chunk, pcpu_chunk_map_bits(chunk)
|
| 1425 | - offset_bits, offset_bits);
|
| 1426 | }
|
| 1427 |
|
| 1428 | return chunk;
|
| 1429 | }
|
| 1430 |
|
| 1431 | static struct pcpu_chunk *pcpu_alloc_chunk(gfp_t gfp)
|
| 1432 | {
|
| 1433 | struct pcpu_chunk *chunk;
|
| 1434 | int region_bits;
|
| 1435 |
|
| 1436 | chunk = pcpu_mem_zalloc(pcpu_chunk_struct_size, gfp);
|
| 1437 | if (!chunk)
|
| 1438 | return NULL;
|
| 1439 |
|
| 1440 | INIT_LIST_HEAD(&chunk->list);
|
| 1441 | chunk->nr_pages = pcpu_unit_pages;
|
| 1442 | region_bits = pcpu_chunk_map_bits(chunk);
|
| 1443 |
|
| 1444 | chunk->alloc_map = pcpu_mem_zalloc(BITS_TO_LONGS(region_bits) *
|
| 1445 | sizeof(chunk->alloc_map[0]), gfp);
|
| 1446 | if (!chunk->alloc_map)
|
| 1447 | goto alloc_map_fail;
|
| 1448 |
|
| 1449 | chunk->bound_map = pcpu_mem_zalloc(BITS_TO_LONGS(region_bits + 1) *
|
| 1450 | sizeof(chunk->bound_map[0]), gfp);
|
| 1451 | if (!chunk->bound_map)
|
| 1452 | goto bound_map_fail;
|
| 1453 |
|
| 1454 | chunk->md_blocks = pcpu_mem_zalloc(pcpu_chunk_nr_blocks(chunk) *
|
| 1455 | sizeof(chunk->md_blocks[0]), gfp);
|
| 1456 | if (!chunk->md_blocks)
|
| 1457 | goto md_blocks_fail;
|
| 1458 |
|
| 1459 | #ifdef NEED_PCPUOBJ_EXT
|
| 1460 | if (need_pcpuobj_ext()) {
|
| 1461 | chunk->obj_exts =
|
| 1462 | pcpu_mem_zalloc(pcpu_chunk_map_bits(chunk) *
|
| 1463 | sizeof(struct pcpuobj_ext), gfp);
|
| 1464 | if (!chunk->obj_exts)
|
| 1465 | goto objcg_fail;
|
| 1466 | }
|
| 1467 | #endif
|
| 1468 |
|
| 1469 | pcpu_init_md_blocks(chunk);
|
| 1470 |
|
| 1471 |
|
| 1472 | chunk->free_bytes = chunk->nr_pages * PAGE_SIZE;
|
| 1473 |
|
| 1474 | return chunk;
|
| 1475 |
|
| 1476 | #ifdef NEED_PCPUOBJ_EXT
|
| 1477 | objcg_fail:
|
| 1478 | pcpu_mem_free(chunk->md_blocks);
|
| 1479 | #endif
|
| 1480 | md_blocks_fail:
|
| 1481 | pcpu_mem_free(chunk->bound_map);
|
| 1482 | bound_map_fail:
|
| 1483 | pcpu_mem_free(chunk->alloc_map);
|
| 1484 | alloc_map_fail:
|
| 1485 | pcpu_mem_free(chunk);
|
| 1486 |
|
| 1487 | return NULL;
|
| 1488 | }
|
| 1489 |
|
| 1490 | static void pcpu_free_chunk(struct pcpu_chunk *chunk)
|
| 1491 | {
|
| 1492 | if (!chunk)
|
| 1493 | return;
|
| 1494 | #ifdef NEED_PCPUOBJ_EXT
|
| 1495 | pcpu_mem_free(chunk->obj_exts);
|
| 1496 | #endif
|
| 1497 | pcpu_mem_free(chunk->md_blocks);
|
| 1498 | pcpu_mem_free(chunk->bound_map);
|
| 1499 | pcpu_mem_free(chunk->alloc_map);
|
| 1500 | pcpu_mem_free(chunk);
|
| 1501 | }
|
| 1502 |
|
| 1503 | |
| 1504 | * pcpu_chunk_populated - post-population bookkeeping
|
| 1505 | * @chunk: pcpu_chunk which got populated
|
| 1506 | * @page_start: the start page
|
| 1507 | * @page_end: the end page
|
| 1508 | *
|
| 1509 | * Pages in [@page_start,@page_end) have been populated to @chunk. Update
|
| 1510 | * the bookkeeping information accordingly. Must be called after each
|
| 1511 | * successful population.
|
| 1512 |
|
| 1513 | static void pcpu_chunk_populated(struct pcpu_chunk *chunk, int page_start,
|
| 1514 | int page_end)
|
| 1515 | {
|
| 1516 | int nr = page_end - page_start;
|
| 1517 |
|
| 1518 | lockdep_assert_held(&pcpu_lock);
|
| 1519 |
|
| 1520 | bitmap_set(chunk->populated, page_start, nr);
|
| 1521 | chunk->nr_populated += nr;
|
| 1522 | pcpu_nr_populated += nr;
|
| 1523 |
|
| 1524 | pcpu_update_empty_pages(chunk, nr);
|
| 1525 | }
|
| 1526 |
|
| 1527 | |
| 1528 | * pcpu_chunk_depopulated - post-depopulation bookkeeping
|
| 1529 | * @chunk: pcpu_chunk which got depopulated
|
| 1530 | * @page_start: the start page
|
| 1531 | * @page_end: the end page
|
| 1532 | *
|
| 1533 | * Pages in [@page_start,@page_end) have been depopulated from @chunk.
|
| 1534 | * Update the bookkeeping information accordingly. Must be called after
|
| 1535 | * each successful depopulation.
|
| 1536 |
|
| 1537 | static void pcpu_chunk_depopulated(struct pcpu_chunk *chunk,
|
| 1538 | int page_start, int page_end)
|
| 1539 | {
|
| 1540 | int nr = page_end - page_start;
|
| 1541 |
|
| 1542 | lockdep_assert_held(&pcpu_lock);
|
| 1543 |
|
| 1544 | bitmap_clear(chunk->populated, page_start, nr);
|
| 1545 | chunk->nr_populated -= nr;
|
| 1546 | pcpu_nr_populated -= nr;
|
| 1547 |
|
| 1548 | pcpu_update_empty_pages(chunk, -nr);
|
| 1549 | }
|
| 1550 |
|
| 1551 | |
| 1552 | * Chunk management implementation.
|
| 1553 | *
|
| 1554 | * To allow different implementations, chunk alloc/free and
|
| 1555 | * [de]population are implemented in a separate file which is pulled
|
| 1556 | * into this file and compiled together. The following functions
|
| 1557 | * should be implemented.
|
| 1558 | *
|
| 1559 | * pcpu_populate_chunk - populate the specified range of a chunk
|
| 1560 | * pcpu_depopulate_chunk - depopulate the specified range of a chunk
|
| 1561 | * pcpu_post_unmap_tlb_flush - flush tlb for the specified range of a chunk
|
| 1562 | * pcpu_create_chunk - create a new chunk
|
| 1563 | * pcpu_destroy_chunk - destroy a chunk, always preceded by full depop
|
| 1564 | * pcpu_addr_to_page - translate address to physical address
|
| 1565 | * pcpu_verify_alloc_info - check alloc_info is acceptable during init
|
| 1566 |
|
| 1567 | static int pcpu_populate_chunk(struct pcpu_chunk *chunk,
|
| 1568 | int page_start, int page_end, gfp_t gfp);
|
| 1569 | static void pcpu_depopulate_chunk(struct pcpu_chunk *chunk,
|
| 1570 | int page_start, int page_end);
|
| 1571 | static void pcpu_post_unmap_tlb_flush(struct pcpu_chunk *chunk,
|
| 1572 | int page_start, int page_end);
|
| 1573 | static struct pcpu_chunk *pcpu_create_chunk(gfp_t gfp);
|
| 1574 | static void pcpu_destroy_chunk(struct pcpu_chunk *chunk);
|
| 1575 | static struct page *pcpu_addr_to_page(void *addr);
|
| 1576 | static int __init pcpu_verify_alloc_info(const struct pcpu_alloc_info *ai);
|
| 1577 |
|
| 1578 | #ifdef CONFIG_NEED_PER_CPU_KM
|
| 1579 | #include "percpu-km.c"
|
| 1580 | #else
|
| 1581 | #include "percpu-vm.c"
|
| 1582 | #endif
|
| 1583 |
|
| 1584 | |
| 1585 | * pcpu_chunk_addr_search - determine chunk containing specified address
|
| 1586 | * @addr: address for which the chunk needs to be determined.
|
| 1587 | *
|
| 1588 | * This is an internal function that handles all but static allocations.
|
| 1589 | * Static percpu address values should never be passed into the allocator.
|
| 1590 | *
|
| 1591 | * RETURNS:
|
| 1592 | * The address of the found chunk.
|
| 1593 |
|
| 1594 | static struct pcpu_chunk *pcpu_chunk_addr_search(void *addr)
|
| 1595 | {
|
| 1596 |
|
| 1597 | if (pcpu_addr_in_chunk(pcpu_first_chunk, addr))
|
| 1598 | return pcpu_first_chunk;
|
| 1599 |
|
| 1600 |
|
| 1601 | if (pcpu_addr_in_chunk(pcpu_reserved_chunk, addr))
|
| 1602 | return pcpu_reserved_chunk;
|
| 1603 |
|
| 1604 | |
| 1605 | * The address is relative to unit0 which might be unused and
|
| 1606 | * thus unmapped. Offset the address to the unit space of the
|
| 1607 | * current processor before looking it up in the vmalloc
|
| 1608 | * space. Note that any possible cpu id can be used here, so
|
| 1609 | * there's no need to worry about preemption or cpu hotplug.
|
| 1610 |
|
| 1611 | addr += pcpu_unit_offsets[raw_smp_processor_id()];
|
| 1612 | return pcpu_get_page_chunk(pcpu_addr_to_page(addr));
|
| 1613 | }
|
| 1614 |
|
| 1615 | #ifdef CONFIG_MEMCG
|
| 1616 | static bool pcpu_memcg_pre_alloc_hook(size_t size, gfp_t gfp,
|
| 1617 | struct obj_cgroup **objcgp)
|
| 1618 | {
|
| 1619 | struct obj_cgroup *objcg;
|
| 1620 |
|
| 1621 | if (!memcg_kmem_online() || !(gfp & __GFP_ACCOUNT))
|
| 1622 | return true;
|
| 1623 |
|
| 1624 | objcg = current_obj_cgroup();
|
| 1625 | if (!objcg || obj_cgroup_is_root(objcg))
|
| 1626 | return true;
|
| 1627 |
|
| 1628 | if (obj_cgroup_charge(objcg, gfp, pcpu_obj_full_size(size)))
|
| 1629 | return false;
|
| 1630 |
|
| 1631 | *objcgp = objcg;
|
| 1632 | return true;
|
| 1633 | }
|
| 1634 |
|
| 1635 | static void pcpu_memcg_post_alloc_hook(struct obj_cgroup *objcg,
|
| 1636 | struct pcpu_chunk *chunk, int off,
|
| 1637 | size_t size)
|
| 1638 | {
|
| 1639 | if (!objcg)
|
| 1640 | return;
|
| 1641 |
|
| 1642 | if (likely(chunk && chunk->obj_exts)) {
|
| 1643 | obj_cgroup_get(objcg);
|
| 1644 | chunk->obj_exts[off >> PCPU_MIN_ALLOC_SHIFT].cgroup = objcg;
|
| 1645 |
|
| 1646 | rcu_read_lock();
|
| 1647 | mod_memcg_state(obj_cgroup_memcg(objcg), MEMCG_PERCPU_B,
|
| 1648 | pcpu_obj_full_size(size));
|
| 1649 | rcu_read_unlock();
|
| 1650 | } else {
|
| 1651 | obj_cgroup_uncharge(objcg, pcpu_obj_full_size(size));
|
| 1652 | }
|
| 1653 | }
|
| 1654 |
|
| 1655 | static void pcpu_memcg_free_hook(struct pcpu_chunk *chunk, int off, size_t size)
|
| 1656 | {
|
| 1657 | struct obj_cgroup *objcg;
|
| 1658 |
|
| 1659 | if (unlikely(!chunk->obj_exts))
|
| 1660 | return;
|
| 1661 |
|
| 1662 | objcg = chunk->obj_exts[off >> PCPU_MIN_ALLOC_SHIFT].cgroup;
|
| 1663 | if (!objcg)
|
| 1664 | return;
|
| 1665 | chunk->obj_exts[off >> PCPU_MIN_ALLOC_SHIFT].cgroup = NULL;
|
| 1666 |
|
| 1667 | obj_cgroup_uncharge(objcg, pcpu_obj_full_size(size));
|
| 1668 |
|
| 1669 | rcu_read_lock();
|
| 1670 | mod_memcg_state(obj_cgroup_memcg(objcg), MEMCG_PERCPU_B,
|
| 1671 | -pcpu_obj_full_size(size));
|
| 1672 | rcu_read_unlock();
|
| 1673 |
|
| 1674 | obj_cgroup_put(objcg);
|
| 1675 | }
|
| 1676 |
|
| 1677 | #else
|
| 1678 | static bool
|
| 1679 | pcpu_memcg_pre_alloc_hook(size_t size, gfp_t gfp, struct obj_cgroup **objcgp)
|
| 1680 | {
|
| 1681 | return true;
|
| 1682 | }
|
| 1683 |
|
| 1684 | static void pcpu_memcg_post_alloc_hook(struct obj_cgroup *objcg,
|
| 1685 | struct pcpu_chunk *chunk, int off,
|
| 1686 | size_t size)
|
| 1687 | {
|
| 1688 | }
|
| 1689 |
|
| 1690 | static void pcpu_memcg_free_hook(struct pcpu_chunk *chunk, int off, size_t size)
|
| 1691 | {
|
| 1692 | }
|
| 1693 | #endif
|
| 1694 |
|
| 1695 | #ifdef CONFIG_MEM_ALLOC_PROFILING
|
| 1696 | static void pcpu_alloc_tag_alloc_hook(struct pcpu_chunk *chunk, int off,
|
| 1697 | size_t size)
|
| 1698 | {
|
| 1699 | if (mem_alloc_profiling_enabled() && likely(chunk->obj_exts)) {
|
| 1700 | alloc_tag_add(&chunk->obj_exts[off >> PCPU_MIN_ALLOC_SHIFT].tag,
|
| 1701 | current->alloc_tag, size);
|
| 1702 | }
|
| 1703 | }
|
| 1704 |
|
| 1705 | static void pcpu_alloc_tag_free_hook(struct pcpu_chunk *chunk, int off, size_t size)
|
| 1706 | {
|
| 1707 | if (mem_alloc_profiling_enabled() && likely(chunk->obj_exts))
|
| 1708 | alloc_tag_sub(&chunk->obj_exts[off >> PCPU_MIN_ALLOC_SHIFT].tag, size);
|
| 1709 | }
|
| 1710 | #else
|
| 1711 | static void pcpu_alloc_tag_alloc_hook(struct pcpu_chunk *chunk, int off,
|
| 1712 | size_t size)
|
| 1713 | {
|
| 1714 | }
|
| 1715 |
|
| 1716 | static void pcpu_alloc_tag_free_hook(struct pcpu_chunk *chunk, int off, size_t size)
|
| 1717 | {
|
| 1718 | }
|
| 1719 | #endif
|
| 1720 |
|
| 1721 | |
| 1722 | * pcpu_alloc - the percpu allocator
|
| 1723 | * @size: size of area to allocate in bytes
|
| 1724 | * @align: alignment of area (max PAGE_SIZE)
|
| 1725 | * @reserved: allocate from the reserved chunk if available
|
| 1726 | * @gfp: allocation flags
|
| 1727 | *
|
| 1728 | * Allocate percpu area of @size bytes aligned at @align. If @gfp doesn't
|
| 1729 | * allow blocking, the allocation is atomic. If @gfp has __GFP_NOWARN then no
|
| 1730 | * warning will be triggered on invalid or failed allocation requests.
|
| 1731 | *
|
| 1732 | * RETURNS:
|
| 1733 | * Percpu pointer to the allocated area on success, NULL on failure.
|
| 1734 |
|
| 1735 | void __percpu *pcpu_alloc_noprof(size_t size, size_t align, bool reserved,
|
| 1736 | gfp_t gfp)
|
| 1737 | {
|
| 1738 | gfp_t pcpu_gfp;
|
| 1739 | bool is_atomic;
|
| 1740 | bool do_warn;
|
| 1741 | struct obj_cgroup *objcg = NULL;
|
| 1742 | static atomic_t warn_limit = ATOMIC_INIT(10);
|
| 1743 | struct pcpu_chunk *chunk, *next;
|
| 1744 | const char *err;
|
| 1745 | int slot, off, cpu, ret;
|
| 1746 | unsigned long flags;
|
| 1747 | void __percpu *ptr;
|
| 1748 | size_t bits, bit_align;
|
| 1749 |
|
| 1750 | gfp = current_gfp_context(gfp);
|
| 1751 | |
| 1752 | * Allowlisted flags that can be passed to the backing allocators.
|
| 1753 | * Backing allocations under pcpu_alloc_mutex must not recurse into
|
| 1754 | * IO/FS reclaim. Otherwise a GFP_KERNEL caller holding the mutex can
|
| 1755 | * block on reclaim while a GFP_NOIO/NOFS caller holding an IO/FS lock
|
| 1756 | * waits for the same mutex.
|
| 1757 | *
|
| 1758 | * Do not pass __GFP_NOFAIL. A small percpu allocation may need many
|
| 1759 | * backing pages, making nofail reclaim too costly under NOIO/NOFS.
|
| 1760 |
|
| 1761 | pcpu_gfp = gfp & (GFP_NOIO | __GFP_NORETRY | __GFP_NOWARN);
|
| 1762 | is_atomic = !gfpflags_allow_blocking(gfp);
|
| 1763 | do_warn = !(gfp & __GFP_NOWARN);
|
| 1764 |
|
| 1765 | |
| 1766 | * There is now a minimum allocation size of PCPU_MIN_ALLOC_SIZE,
|
| 1767 | * therefore alignment must be a minimum of that many bytes.
|
| 1768 | * An allocation may have internal fragmentation from rounding up
|
| 1769 | * of up to PCPU_MIN_ALLOC_SIZE - 1 bytes.
|
| 1770 |
|
| 1771 | if (unlikely(align < PCPU_MIN_ALLOC_SIZE))
|
| 1772 | align = PCPU_MIN_ALLOC_SIZE;
|
| 1773 |
|
| 1774 | size = ALIGN(size, PCPU_MIN_ALLOC_SIZE);
|
| 1775 | bits = size >> PCPU_MIN_ALLOC_SHIFT;
|
| 1776 | bit_align = align >> PCPU_MIN_ALLOC_SHIFT;
|
| 1777 |
|
| 1778 | if (unlikely(!size || size > PCPU_MIN_UNIT_SIZE || align > PAGE_SIZE ||
|
| 1779 | !is_power_of_2(align))) {
|
| 1780 | WARN(do_warn, "illegal size (%zu) or align (%zu) for percpu allocation\n",
|
| 1781 | size, align);
|
| 1782 | return NULL;
|
| 1783 | }
|
| 1784 |
|
| 1785 | if (unlikely(!pcpu_memcg_pre_alloc_hook(size, gfp, &objcg)))
|
| 1786 | return NULL;
|
| 1787 |
|
| 1788 | if (!is_atomic) {
|
| 1789 | |
| 1790 | * pcpu_balance_workfn() allocates memory under this mutex,
|
| 1791 | * and it may wait for memory reclaim. Allow current task
|
| 1792 | * to become OOM victim, in case of memory pressure.
|
| 1793 |
|
| 1794 | if (gfp & __GFP_NOFAIL) {
|
| 1795 | mutex_lock(&pcpu_alloc_mutex);
|
| 1796 | } else if (mutex_lock_killable(&pcpu_alloc_mutex)) {
|
| 1797 | pcpu_memcg_post_alloc_hook(objcg, NULL, 0, size);
|
| 1798 | return NULL;
|
| 1799 | }
|
| 1800 | }
|
| 1801 |
|
| 1802 | spin_lock_irqsave(&pcpu_lock, flags);
|
| 1803 |
|
| 1804 |
|
| 1805 | if (reserved && pcpu_reserved_chunk) {
|
| 1806 | chunk = pcpu_reserved_chunk;
|
| 1807 |
|
| 1808 | off = pcpu_find_block_fit(chunk, bits, bit_align, is_atomic);
|
| 1809 | if (off < 0) {
|
| 1810 | err = "alloc from reserved chunk failed";
|
| 1811 | goto fail_unlock;
|
| 1812 | }
|
| 1813 |
|
| 1814 | off = pcpu_alloc_area(chunk, bits, bit_align, off);
|
| 1815 | if (off >= 0)
|
| 1816 | goto area_found;
|
| 1817 |
|
| 1818 | err = "alloc from reserved chunk failed";
|
| 1819 | goto fail_unlock;
|
| 1820 | }
|
| 1821 |
|
| 1822 | restart:
|
| 1823 |
|
| 1824 | for (slot = pcpu_size_to_slot(size); slot <= pcpu_free_slot; slot++) {
|
| 1825 | list_for_each_entry_safe(chunk, next, &pcpu_chunk_lists[slot],
|
| 1826 | list) {
|
| 1827 | off = pcpu_find_block_fit(chunk, bits, bit_align,
|
| 1828 | is_atomic);
|
| 1829 | if (off < 0) {
|
| 1830 | if (slot < PCPU_SLOT_FAIL_THRESHOLD)
|
| 1831 | pcpu_chunk_move(chunk, 0);
|
| 1832 | continue;
|
| 1833 | }
|
| 1834 |
|
| 1835 | off = pcpu_alloc_area(chunk, bits, bit_align, off);
|
| 1836 | if (off >= 0) {
|
| 1837 | pcpu_reintegrate_chunk(chunk);
|
| 1838 | goto area_found;
|
| 1839 | }
|
| 1840 | }
|
| 1841 | }
|
| 1842 |
|
| 1843 | spin_unlock_irqrestore(&pcpu_lock, flags);
|
| 1844 |
|
| 1845 | if (is_atomic) {
|
| 1846 | err = "atomic alloc failed, no space left";
|
| 1847 | goto fail;
|
| 1848 | }
|
| 1849 |
|
| 1850 |
|
| 1851 | if (list_empty(&pcpu_chunk_lists[pcpu_free_slot])) {
|
| 1852 | chunk = pcpu_create_chunk(pcpu_gfp);
|
| 1853 | if (!chunk) {
|
| 1854 | err = "failed to allocate new chunk";
|
| 1855 | goto fail;
|
| 1856 | }
|
| 1857 |
|
| 1858 | spin_lock_irqsave(&pcpu_lock, flags);
|
| 1859 | pcpu_chunk_relocate(chunk, -1);
|
| 1860 | } else {
|
| 1861 | spin_lock_irqsave(&pcpu_lock, flags);
|
| 1862 | }
|
| 1863 |
|
| 1864 | goto restart;
|
| 1865 |
|
| 1866 | area_found:
|
| 1867 | pcpu_stats_area_alloc(chunk, size);
|
| 1868 |
|
| 1869 | if (pcpu_nr_empty_pop_pages < PCPU_EMPTY_POP_PAGES_LOW)
|
| 1870 | pcpu_schedule_balance_work();
|
| 1871 |
|
| 1872 | spin_unlock_irqrestore(&pcpu_lock, flags);
|
| 1873 |
|
| 1874 |
|
| 1875 | if (!is_atomic) {
|
| 1876 | unsigned int page_end, rs, re;
|
| 1877 |
|
| 1878 | rs = PFN_DOWN(off);
|
| 1879 | page_end = PFN_UP(off + size);
|
| 1880 |
|
| 1881 | for_each_clear_bitrange_from(rs, re, chunk->populated, page_end) {
|
| 1882 | WARN_ON(chunk->immutable);
|
| 1883 |
|
| 1884 | ret = pcpu_populate_chunk(chunk, rs, re, pcpu_gfp);
|
| 1885 |
|
| 1886 | spin_lock_irqsave(&pcpu_lock, flags);
|
| 1887 | if (ret) {
|
| 1888 | pcpu_free_area(chunk, off);
|
| 1889 | err = "failed to populate";
|
| 1890 | goto fail_unlock;
|
| 1891 | }
|
| 1892 | pcpu_chunk_populated(chunk, rs, re);
|
| 1893 | spin_unlock_irqrestore(&pcpu_lock, flags);
|
| 1894 | }
|
| 1895 |
|
| 1896 | mutex_unlock(&pcpu_alloc_mutex);
|
| 1897 | }
|
| 1898 |
|
| 1899 |
|
| 1900 | for_each_possible_cpu(cpu)
|
| 1901 | memset((void *)pcpu_chunk_addr(chunk, cpu, 0) + off, 0, size);
|
| 1902 |
|
| 1903 | ptr = __addr_to_pcpu_ptr(chunk->base_addr + off);
|
| 1904 | kmemleak_alloc_percpu(ptr, size, gfp);
|
| 1905 |
|
| 1906 | trace_percpu_alloc_percpu(_RET_IP_, reserved, is_atomic, size, align,
|
| 1907 | chunk->base_addr, off, ptr,
|
| 1908 | pcpu_obj_full_size(size), gfp);
|
| 1909 |
|
| 1910 | pcpu_memcg_post_alloc_hook(objcg, chunk, off, size);
|
| 1911 |
|
| 1912 | pcpu_alloc_tag_alloc_hook(chunk, off, size);
|
| 1913 |
|
| 1914 | return ptr;
|
| 1915 |
|
| 1916 | fail_unlock:
|
| 1917 | spin_unlock_irqrestore(&pcpu_lock, flags);
|
| 1918 | fail:
|
| 1919 | trace_percpu_alloc_percpu_fail(reserved, is_atomic, size, align);
|
| 1920 |
|
| 1921 | if (do_warn) {
|
| 1922 | int remaining = atomic_dec_if_positive(&warn_limit);
|
| 1923 |
|
| 1924 | if (remaining >= 0) {
|
| 1925 | pr_warn("allocation failed, size=%zu align=%zu atomic=%d, %s\n",
|
| 1926 | size, align, is_atomic, err);
|
| 1927 | if (!is_atomic)
|
| 1928 | dump_stack();
|
| 1929 | if (remaining == 0)
|
| 1930 | pr_info("limit reached, disable warning\n");
|
| 1931 | }
|
| 1932 | }
|
| 1933 |
|
| 1934 | if (is_atomic) {
|
| 1935 |
|
| 1936 | pcpu_atomic_alloc_failed = true;
|
| 1937 | pcpu_schedule_balance_work();
|
| 1938 | } else {
|
| 1939 | mutex_unlock(&pcpu_alloc_mutex);
|
| 1940 | }
|
| 1941 |
|
| 1942 | pcpu_memcg_post_alloc_hook(objcg, NULL, 0, size);
|
| 1943 |
|
| 1944 | return NULL;
|
| 1945 | }
|
| 1946 | EXPORT_SYMBOL_GPL(pcpu_alloc_noprof);
|
| 1947 |
|
| 1948 | |
| 1949 | * pcpu_balance_free - manage the amount of free chunks
|
| 1950 | * @empty_only: free chunks only if there are no populated pages
|
| 1951 | *
|
| 1952 | * If empty_only is %false, reclaim all fully free chunks regardless of the
|
| 1953 | * number of populated pages. Otherwise, only reclaim chunks that have no
|
| 1954 | * populated pages.
|
| 1955 | *
|
| 1956 | * CONTEXT:
|
| 1957 | * pcpu_lock (can be dropped temporarily)
|
| 1958 |
|
| 1959 | static void pcpu_balance_free(bool empty_only)
|
| 1960 | {
|
| 1961 | LIST_HEAD(to_free);
|
| 1962 | struct list_head *free_head = &pcpu_chunk_lists[pcpu_free_slot];
|
| 1963 | struct pcpu_chunk *chunk, *next;
|
| 1964 |
|
| 1965 | lockdep_assert_held(&pcpu_lock);
|
| 1966 |
|
| 1967 | |
| 1968 | * There's no reason to keep around multiple unused chunks and VM
|
| 1969 | * areas can be scarce. Destroy all free chunks except for one.
|
| 1970 |
|
| 1971 | list_for_each_entry_safe(chunk, next, free_head, list) {
|
| 1972 | WARN_ON(chunk->immutable);
|
| 1973 |
|
| 1974 |
|
| 1975 | if (chunk == list_first_entry(free_head, struct pcpu_chunk, list))
|
| 1976 | continue;
|
| 1977 |
|
| 1978 | if (!empty_only || chunk->nr_empty_pop_pages == 0)
|
| 1979 | list_move(&chunk->list, &to_free);
|
| 1980 | }
|
| 1981 |
|
| 1982 | if (list_empty(&to_free))
|
| 1983 | return;
|
| 1984 |
|
| 1985 | spin_unlock_irq(&pcpu_lock);
|
| 1986 | list_for_each_entry_safe(chunk, next, &to_free, list) {
|
| 1987 | unsigned int rs, re;
|
| 1988 |
|
| 1989 | for_each_set_bitrange(rs, re, chunk->populated, chunk->nr_pages) {
|
| 1990 | pcpu_depopulate_chunk(chunk, rs, re);
|
| 1991 | spin_lock_irq(&pcpu_lock);
|
| 1992 | pcpu_chunk_depopulated(chunk, rs, re);
|
| 1993 | spin_unlock_irq(&pcpu_lock);
|
| 1994 | }
|
| 1995 | pcpu_destroy_chunk(chunk);
|
| 1996 | cond_resched();
|
| 1997 | }
|
| 1998 | spin_lock_irq(&pcpu_lock);
|
| 1999 | }
|
| 2000 |
|
| 2001 | |
| 2002 | * pcpu_balance_populated - manage the amount of populated pages
|
| 2003 | *
|
| 2004 | * Maintain a certain amount of populated pages to satisfy atomic allocations.
|
| 2005 | * It is possible that this is called when physical memory is scarce causing
|
| 2006 | * OOM killer to be triggered. We should avoid doing so until an actual
|
| 2007 | * allocation causes the failure as it is possible that requests can be
|
| 2008 | * serviced from already backed regions.
|
| 2009 | *
|
| 2010 | * CONTEXT:
|
| 2011 | * pcpu_lock (can be dropped temporarily)
|
| 2012 |
|
| 2013 | static void pcpu_balance_populated(void)
|
| 2014 | {
|
| 2015 |
|
| 2016 | const gfp_t gfp = GFP_KERNEL | __GFP_NORETRY | __GFP_NOWARN;
|
| 2017 | struct pcpu_chunk *chunk;
|
| 2018 | int slot, nr_to_pop, ret;
|
| 2019 |
|
| 2020 | lockdep_assert_held(&pcpu_lock);
|
| 2021 |
|
| 2022 | |
| 2023 | * Ensure there are certain number of free populated pages for
|
| 2024 | * atomic allocs. Fill up from the most packed so that atomic
|
| 2025 | * allocs don't increase fragmentation. If atomic allocation
|
| 2026 | * failed previously, always populate the maximum amount. This
|
| 2027 | * should prevent atomic allocs larger than PAGE_SIZE from keeping
|
| 2028 | * failing indefinitely; however, large atomic allocs are not
|
| 2029 | * something we support properly and can be highly unreliable and
|
| 2030 | * inefficient.
|
| 2031 |
|
| 2032 | retry_pop:
|
| 2033 | if (pcpu_atomic_alloc_failed) {
|
| 2034 | nr_to_pop = PCPU_EMPTY_POP_PAGES_HIGH;
|
| 2035 |
|
| 2036 | pcpu_atomic_alloc_failed = false;
|
| 2037 | } else {
|
| 2038 | nr_to_pop = clamp(PCPU_EMPTY_POP_PAGES_HIGH -
|
| 2039 | pcpu_nr_empty_pop_pages,
|
| 2040 | 0, PCPU_EMPTY_POP_PAGES_HIGH);
|
| 2041 | }
|
| 2042 |
|
| 2043 | for (slot = pcpu_size_to_slot(PAGE_SIZE); slot <= pcpu_free_slot; slot++) {
|
| 2044 | unsigned int nr_unpop = 0, rs, re;
|
| 2045 |
|
| 2046 | if (!nr_to_pop)
|
| 2047 | break;
|
| 2048 |
|
| 2049 | list_for_each_entry(chunk, &pcpu_chunk_lists[slot], list) {
|
| 2050 | nr_unpop = chunk->nr_pages - chunk->nr_populated;
|
| 2051 | if (nr_unpop)
|
| 2052 | break;
|
| 2053 | }
|
| 2054 |
|
| 2055 | if (!nr_unpop)
|
| 2056 | continue;
|
| 2057 |
|
| 2058 |
|
| 2059 | for_each_clear_bitrange(rs, re, chunk->populated, chunk->nr_pages) {
|
| 2060 | int nr = min_t(int, re - rs, nr_to_pop);
|
| 2061 |
|
| 2062 | spin_unlock_irq(&pcpu_lock);
|
| 2063 | ret = pcpu_populate_chunk(chunk, rs, rs + nr, gfp);
|
| 2064 | cond_resched();
|
| 2065 | spin_lock_irq(&pcpu_lock);
|
| 2066 | if (!ret) {
|
| 2067 | nr_to_pop -= nr;
|
| 2068 | pcpu_chunk_populated(chunk, rs, rs + nr);
|
| 2069 | } else {
|
| 2070 | nr_to_pop = 0;
|
| 2071 | }
|
| 2072 |
|
| 2073 | if (!nr_to_pop)
|
| 2074 | break;
|
| 2075 | }
|
| 2076 | }
|
| 2077 |
|
| 2078 | if (nr_to_pop) {
|
| 2079 |
|
| 2080 | spin_unlock_irq(&pcpu_lock);
|
| 2081 | chunk = pcpu_create_chunk(gfp);
|
| 2082 | cond_resched();
|
| 2083 | spin_lock_irq(&pcpu_lock);
|
| 2084 | if (chunk) {
|
| 2085 | pcpu_chunk_relocate(chunk, -1);
|
| 2086 | goto retry_pop;
|
| 2087 | }
|
| 2088 | }
|
| 2089 | }
|
| 2090 |
|
| 2091 | |
| 2092 | * pcpu_reclaim_populated - scan over to_depopulate chunks and free empty pages
|
| 2093 | *
|
| 2094 | * Scan over chunks in the depopulate list and try to release unused populated
|
| 2095 | * pages back to the system. Depopulated chunks are sidelined to prevent
|
| 2096 | * repopulating these pages unless required. Fully free chunks are reintegrated
|
| 2097 | * and freed accordingly (1 is kept around). If we drop below the empty
|
| 2098 | * populated pages threshold, reintegrate the chunk if it has empty free pages.
|
| 2099 | * Each chunk is scanned in the reverse order to keep populated pages close to
|
| 2100 | * the beginning of the chunk.
|
| 2101 | *
|
| 2102 | * CONTEXT:
|
| 2103 | * pcpu_lock (can be dropped temporarily)
|
| 2104 | *
|
| 2105 |
|
| 2106 | static void pcpu_reclaim_populated(void)
|
| 2107 | {
|
| 2108 | struct pcpu_chunk *chunk;
|
| 2109 | struct pcpu_block_md *block;
|
| 2110 | int freed_page_start, freed_page_end;
|
| 2111 | int i, end;
|
| 2112 | bool reintegrate;
|
| 2113 |
|
| 2114 | lockdep_assert_held(&pcpu_lock);
|
| 2115 |
|
| 2116 | |
| 2117 | * Once a chunk is isolated to the to_depopulate list, the chunk is no
|
| 2118 | * longer discoverable to allocations whom may populate pages. The only
|
| 2119 | * other accessor is the free path which only returns area back to the
|
| 2120 | * allocator not touching the populated bitmap.
|
| 2121 |
|
| 2122 | while ((chunk = list_first_entry_or_null(
|
| 2123 | &pcpu_chunk_lists[pcpu_to_depopulate_slot],
|
| 2124 | struct pcpu_chunk, list))) {
|
| 2125 | WARN_ON(chunk->immutable);
|
| 2126 |
|
| 2127 | |
| 2128 | * Scan chunk's pages in the reverse order to keep populated
|
| 2129 | * pages close to the beginning of the chunk.
|
| 2130 |
|
| 2131 | freed_page_start = chunk->nr_pages;
|
| 2132 | freed_page_end = 0;
|
| 2133 | reintegrate = false;
|
| 2134 | for (i = chunk->nr_pages - 1, end = -1; i >= 0; i--) {
|
| 2135 |
|
| 2136 | if (chunk->nr_empty_pop_pages == 0)
|
| 2137 | break;
|
| 2138 |
|
| 2139 |
|
| 2140 | if (pcpu_nr_empty_pop_pages < PCPU_EMPTY_POP_PAGES_HIGH) {
|
| 2141 | reintegrate = true;
|
| 2142 | break;
|
| 2143 | }
|
| 2144 |
|
| 2145 | |
| 2146 | * If the page is empty and populated, start or
|
| 2147 | * extend the (i, end) range. If i == 0, decrease
|
| 2148 | * i and perform the depopulation to cover the last
|
| 2149 | * (first) page in the chunk.
|
| 2150 |
|
| 2151 | block = chunk->md_blocks + i;
|
| 2152 | if (block->contig_hint == PCPU_BITMAP_BLOCK_BITS &&
|
| 2153 | test_bit(i, chunk->populated)) {
|
| 2154 | if (end == -1)
|
| 2155 | end = i;
|
| 2156 | if (i > 0)
|
| 2157 | continue;
|
| 2158 | i--;
|
| 2159 | }
|
| 2160 |
|
| 2161 |
|
| 2162 | if (end == -1)
|
| 2163 | continue;
|
| 2164 |
|
| 2165 | spin_unlock_irq(&pcpu_lock);
|
| 2166 | pcpu_depopulate_chunk(chunk, i + 1, end + 1);
|
| 2167 | cond_resched();
|
| 2168 | spin_lock_irq(&pcpu_lock);
|
| 2169 |
|
| 2170 | pcpu_chunk_depopulated(chunk, i + 1, end + 1);
|
| 2171 | freed_page_start = min(freed_page_start, i + 1);
|
| 2172 | freed_page_end = max(freed_page_end, end + 1);
|
| 2173 |
|
| 2174 |
|
| 2175 | end = -1;
|
| 2176 | }
|
| 2177 |
|
| 2178 |
|
| 2179 | if (freed_page_start < freed_page_end) {
|
| 2180 | spin_unlock_irq(&pcpu_lock);
|
| 2181 | pcpu_post_unmap_tlb_flush(chunk,
|
| 2182 | freed_page_start,
|
| 2183 | freed_page_end);
|
| 2184 | cond_resched();
|
| 2185 | spin_lock_irq(&pcpu_lock);
|
| 2186 | }
|
| 2187 |
|
| 2188 | if (reintegrate || chunk->free_bytes == pcpu_unit_size)
|
| 2189 | pcpu_reintegrate_chunk(chunk);
|
| 2190 | else
|
| 2191 | list_move_tail(&chunk->list,
|
| 2192 | &pcpu_chunk_lists[pcpu_sidelined_slot]);
|
| 2193 | }
|
| 2194 | }
|
| 2195 |
|
| 2196 | |
| 2197 | * pcpu_balance_workfn - manage the amount of free chunks and populated pages
|
| 2198 | * @work: unused
|
| 2199 | *
|
| 2200 | * For each chunk type, manage the number of fully free chunks and the number of
|
| 2201 | * populated pages. An important thing to consider is when pages are freed and
|
| 2202 | * how they contribute to the global counts.
|
| 2203 |
|
| 2204 | static void pcpu_balance_workfn(struct work_struct *work)
|
| 2205 | {
|
| 2206 | |
| 2207 | * pcpu_balance_free() is called twice because the first time we may
|
| 2208 | * trim pages in the active pcpu_nr_empty_pop_pages which may cause us
|
| 2209 | * to grow other chunks. This then gives pcpu_reclaim_populated() time
|
| 2210 | * to move fully free chunks to the active list to be freed if
|
| 2211 | * appropriate.
|
| 2212 | *
|
| 2213 | * Enforce GFP_NOIO allocations because we have pcpu_alloc users
|
| 2214 | * constrained to GFP_NOIO/NOFS contexts and they could form lock
|
| 2215 | * dependency through pcpu_alloc_mutex
|
| 2216 |
|
| 2217 | unsigned int flags = memalloc_noio_save();
|
| 2218 | mutex_lock(&pcpu_alloc_mutex);
|
| 2219 | spin_lock_irq(&pcpu_lock);
|
| 2220 |
|
| 2221 | pcpu_balance_free(false);
|
| 2222 | pcpu_reclaim_populated();
|
| 2223 | pcpu_balance_populated();
|
| 2224 | pcpu_balance_free(true);
|
| 2225 |
|
| 2226 | spin_unlock_irq(&pcpu_lock);
|
| 2227 | mutex_unlock(&pcpu_alloc_mutex);
|
| 2228 | memalloc_noio_restore(flags);
|
| 2229 | }
|
| 2230 |
|
| 2231 | |
| 2232 | * free_percpu - free percpu area
|
| 2233 | * @ptr: pointer to area to free
|
| 2234 | *
|
| 2235 | * Free percpu area @ptr.
|
| 2236 | *
|
| 2237 | * CONTEXT:
|
| 2238 | * Can be called from atomic context.
|
| 2239 |
|
| 2240 | void free_percpu(void __percpu *ptr)
|
| 2241 | {
|
| 2242 | void *addr;
|
| 2243 | struct pcpu_chunk *chunk;
|
| 2244 | unsigned long flags;
|
| 2245 | int size, off;
|
| 2246 | bool need_balance = false;
|
| 2247 |
|
| 2248 | if (!ptr)
|
| 2249 | return;
|
| 2250 |
|
| 2251 | kmemleak_free_percpu(ptr);
|
| 2252 |
|
| 2253 | addr = __pcpu_ptr_to_addr(ptr);
|
| 2254 | chunk = pcpu_chunk_addr_search(addr);
|
| 2255 | off = addr - chunk->base_addr;
|
| 2256 |
|
| 2257 | spin_lock_irqsave(&pcpu_lock, flags);
|
| 2258 | size = pcpu_free_area(chunk, off);
|
| 2259 | if (size == 0) {
|
| 2260 | spin_unlock_irqrestore(&pcpu_lock, flags);
|
| 2261 |
|
| 2262 |
|
| 2263 | WARN_ON_ONCE(1);
|
| 2264 | return;
|
| 2265 | }
|
| 2266 |
|
| 2267 | pcpu_alloc_tag_free_hook(chunk, off, size);
|
| 2268 |
|
| 2269 | pcpu_memcg_free_hook(chunk, off, size);
|
| 2270 |
|
| 2271 | |
| 2272 | * If there are more than one fully free chunks, wake up grim reaper.
|
| 2273 | * If the chunk is isolated, it may be in the process of being
|
| 2274 | * reclaimed. Let reclaim manage cleaning up of that chunk.
|
| 2275 |
|
| 2276 | if (!chunk->isolated && chunk->free_bytes == pcpu_unit_size) {
|
| 2277 | struct pcpu_chunk *pos;
|
| 2278 |
|
| 2279 | list_for_each_entry(pos, &pcpu_chunk_lists[pcpu_free_slot], list)
|
| 2280 | if (pos != chunk) {
|
| 2281 | need_balance = true;
|
| 2282 | break;
|
| 2283 | }
|
| 2284 | } else if (pcpu_should_reclaim_chunk(chunk)) {
|
| 2285 | pcpu_isolate_chunk(chunk);
|
| 2286 | need_balance = true;
|
| 2287 | }
|
| 2288 |
|
| 2289 | trace_percpu_free_percpu(chunk->base_addr, off, ptr);
|
| 2290 |
|
| 2291 | spin_unlock_irqrestore(&pcpu_lock, flags);
|
| 2292 |
|
| 2293 | if (need_balance)
|
| 2294 | pcpu_schedule_balance_work();
|
| 2295 | }
|
| 2296 | EXPORT_SYMBOL_GPL(free_percpu);
|
| 2297 |
|
| 2298 | bool __is_kernel_percpu_address(unsigned long addr, unsigned long *can_addr)
|
| 2299 | {
|
| 2300 | #ifdef CONFIG_SMP
|
| 2301 | const size_t static_size = __per_cpu_end - __per_cpu_start;
|
| 2302 | void __percpu *base = __addr_to_pcpu_ptr(pcpu_base_addr);
|
| 2303 | unsigned int cpu;
|
| 2304 |
|
| 2305 | for_each_possible_cpu(cpu) {
|
| 2306 | void *start = per_cpu_ptr(base, cpu);
|
| 2307 | void *va = (void *)addr;
|
| 2308 |
|
| 2309 | if (va >= start && va < start + static_size) {
|
| 2310 | if (can_addr) {
|
| 2311 | *can_addr = (unsigned long) (va - start);
|
| 2312 | *can_addr += (unsigned long)
|
| 2313 | per_cpu_ptr(base, get_boot_cpu_id());
|
| 2314 | }
|
| 2315 | return true;
|
| 2316 | }
|
| 2317 | }
|
| 2318 | #endif
|
| 2319 |
|
| 2320 | return false;
|
| 2321 | }
|
| 2322 |
|
| 2323 | |
| 2324 | * is_kernel_percpu_address - test whether address is from static percpu area
|
| 2325 | * @addr: address to test
|
| 2326 | *
|
| 2327 | * Test whether @addr belongs to in-kernel static percpu area. Module
|
| 2328 | * static percpu areas are not considered. For those, use
|
| 2329 | * is_module_percpu_address().
|
| 2330 | *
|
| 2331 | * RETURNS:
|
| 2332 | * %true if @addr is from in-kernel static percpu area, %false otherwise.
|
| 2333 |
|
| 2334 | bool is_kernel_percpu_address(unsigned long addr)
|
| 2335 | {
|
| 2336 | return __is_kernel_percpu_address(addr, NULL);
|
| 2337 | }
|
| 2338 |
|
| 2339 | |
| 2340 | * per_cpu_ptr_to_phys - convert translated percpu address to physical address
|
| 2341 | * @addr: the address to be converted to physical address
|
| 2342 | *
|
| 2343 | * Given @addr which is dereferenceable address obtained via one of
|
| 2344 | * percpu access macros, this function translates it into its physical
|
| 2345 | * address. The caller is responsible for ensuring @addr stays valid
|
| 2346 | * until this function finishes.
|
| 2347 | *
|
| 2348 | * percpu allocator has special setup for the first chunk, which currently
|
| 2349 | * supports either embedding in linear address space or vmalloc mapping,
|
| 2350 | * and, from the second one, the backing allocator (currently either vm or
|
| 2351 | * km) provides translation.
|
| 2352 | *
|
| 2353 | * The addr can be translated simply without checking if it falls into the
|
| 2354 | * first chunk. But the current code reflects better how percpu allocator
|
| 2355 | * actually works, and the verification can discover both bugs in percpu
|
| 2356 | * allocator itself and per_cpu_ptr_to_phys() callers. So we keep current
|
| 2357 | * code.
|
| 2358 | *
|
| 2359 | * RETURNS:
|
| 2360 | * The physical address for @addr.
|
| 2361 |
|
| 2362 | phys_addr_t per_cpu_ptr_to_phys(void *addr)
|
| 2363 | {
|
| 2364 | void __percpu *base = __addr_to_pcpu_ptr(pcpu_base_addr);
|
| 2365 | bool in_first_chunk = false;
|
| 2366 | unsigned long first_low, first_high;
|
| 2367 | unsigned int cpu;
|
| 2368 |
|
| 2369 | |
| 2370 | * The following test on unit_low/high isn't strictly
|
| 2371 | * necessary but will speed up lookups of addresses which
|
| 2372 | * aren't in the first chunk.
|
| 2373 | *
|
| 2374 | * The address check is against full chunk sizes. pcpu_base_addr
|
| 2375 | * points to the beginning of the first chunk including the
|
| 2376 | * static region. Assumes good intent as the first chunk may
|
| 2377 | * not be full (ie. < pcpu_unit_pages in size).
|
| 2378 |
|
| 2379 | first_low = (unsigned long)pcpu_base_addr +
|
| 2380 | pcpu_unit_page_offset(pcpu_low_unit_cpu, 0);
|
| 2381 | first_high = (unsigned long)pcpu_base_addr +
|
| 2382 | pcpu_unit_page_offset(pcpu_high_unit_cpu, pcpu_unit_pages);
|
| 2383 | if ((unsigned long)addr >= first_low &&
|
| 2384 | (unsigned long)addr < first_high) {
|
| 2385 | for_each_possible_cpu(cpu) {
|
| 2386 | void *start = per_cpu_ptr(base, cpu);
|
| 2387 |
|
| 2388 | if (addr >= start && addr < start + pcpu_unit_size) {
|
| 2389 | in_first_chunk = true;
|
| 2390 | break;
|
| 2391 | }
|
| 2392 | }
|
| 2393 | }
|
| 2394 |
|
| 2395 | if (in_first_chunk) {
|
| 2396 | if (!is_vmalloc_addr(addr))
|
| 2397 | return __pa(addr);
|
| 2398 | else
|
| 2399 | return page_to_phys(vmalloc_to_page(addr)) +
|
| 2400 | offset_in_page(addr);
|
| 2401 | } else
|
| 2402 | return page_to_phys(pcpu_addr_to_page(addr)) +
|
| 2403 | offset_in_page(addr);
|
| 2404 | }
|
| 2405 |
|
| 2406 | |
| 2407 | * pcpu_alloc_alloc_info - allocate percpu allocation info
|
| 2408 | * @nr_groups: the number of groups
|
| 2409 | * @nr_units: the number of units
|
| 2410 | *
|
| 2411 | * Allocate ai which is large enough for @nr_groups groups containing
|
| 2412 | * @nr_units units. The returned ai's groups[0].cpu_map points to the
|
| 2413 | * cpu_map array which is long enough for @nr_units and filled with
|
| 2414 | * NR_CPUS. It's the caller's responsibility to initialize cpu_map
|
| 2415 | * pointer of other groups.
|
| 2416 | *
|
| 2417 | * RETURNS:
|
| 2418 | * Pointer to the allocated pcpu_alloc_info on success, NULL on
|
| 2419 | * failure.
|
| 2420 |
|
| 2421 | struct pcpu_alloc_info * __init pcpu_alloc_alloc_info(int nr_groups,
|
| 2422 | int nr_units)
|
| 2423 | {
|
| 2424 | struct pcpu_alloc_info *ai;
|
| 2425 | size_t base_size, ai_size;
|
| 2426 | void *ptr;
|
| 2427 | int unit;
|
| 2428 |
|
| 2429 | base_size = ALIGN(struct_size(ai, groups, nr_groups),
|
| 2430 | __alignof__(ai->groups[0].cpu_map[0]));
|
| 2431 | ai_size = base_size + nr_units * sizeof(ai->groups[0].cpu_map[0]);
|
| 2432 |
|
| 2433 | ptr = memblock_alloc(PFN_ALIGN(ai_size), PAGE_SIZE);
|
| 2434 | if (!ptr)
|
| 2435 | return NULL;
|
| 2436 | ai = ptr;
|
| 2437 | ptr += base_size;
|
| 2438 |
|
| 2439 | ai->groups[0].cpu_map = ptr;
|
| 2440 |
|
| 2441 | for (unit = 0; unit < nr_units; unit++)
|
| 2442 | ai->groups[0].cpu_map[unit] = NR_CPUS;
|
| 2443 |
|
| 2444 | ai->nr_groups = nr_groups;
|
| 2445 | ai->__ai_size = PFN_ALIGN(ai_size);
|
| 2446 |
|
| 2447 | return ai;
|
| 2448 | }
|
| 2449 |
|
| 2450 | |
| 2451 | * pcpu_free_alloc_info - free percpu allocation info
|
| 2452 | * @ai: pcpu_alloc_info to free
|
| 2453 | *
|
| 2454 | * Free @ai which was allocated by pcpu_alloc_alloc_info().
|
| 2455 |
|
| 2456 | void __init pcpu_free_alloc_info(struct pcpu_alloc_info *ai)
|
| 2457 | {
|
| 2458 | memblock_free(ai, ai->__ai_size);
|
| 2459 | }
|
| 2460 |
|
| 2461 | |
| 2462 | * pcpu_dump_alloc_info - print out information about pcpu_alloc_info
|
| 2463 | * @lvl: loglevel
|
| 2464 | * @ai: allocation info to dump
|
| 2465 | *
|
| 2466 | * Print out information about @ai using loglevel @lvl.
|
| 2467 |
|
| 2468 | static void pcpu_dump_alloc_info(const char *lvl,
|
| 2469 | const struct pcpu_alloc_info *ai)
|
| 2470 | {
|
| 2471 | int group_width = 1, cpu_width = 1, width;
|
| 2472 | char empty_str[] = "--------";
|
| 2473 | int alloc = 0, alloc_end = 0;
|
| 2474 | int group, v;
|
| 2475 | int upa, apl;
|
| 2476 |
|
| 2477 | v = ai->nr_groups;
|
| 2478 | while (v /= 10)
|
| 2479 | group_width++;
|
| 2480 |
|
| 2481 | v = num_possible_cpus();
|
| 2482 | while (v /= 10)
|
| 2483 | cpu_width++;
|
| 2484 | empty_str[min_t(int, cpu_width, sizeof(empty_str) - 1)] = '\0';
|
| 2485 |
|
| 2486 | upa = ai->alloc_size / ai->unit_size;
|
| 2487 | width = upa * (cpu_width + 1) + group_width + 3;
|
| 2488 | apl = rounddown_pow_of_two(max(60 / width, 1));
|
| 2489 |
|
| 2490 | printk("%spcpu-alloc: s%zu r%zu d%zu u%zu alloc=%zu*%zu",
|
| 2491 | lvl, ai->static_size, ai->reserved_size, ai->dyn_size,
|
| 2492 | ai->unit_size, ai->alloc_size / ai->atom_size, ai->atom_size);
|
| 2493 |
|
| 2494 | for (group = 0; group < ai->nr_groups; group++) {
|
| 2495 | const struct pcpu_group_info *gi = &ai->groups[group];
|
| 2496 | int unit = 0, unit_end = 0;
|
| 2497 |
|
| 2498 | BUG_ON(gi->nr_units % upa);
|
| 2499 | for (alloc_end += gi->nr_units / upa;
|
| 2500 | alloc < alloc_end; alloc++) {
|
| 2501 | if (!(alloc % apl)) {
|
| 2502 | pr_cont("\n");
|
| 2503 | printk("%spcpu-alloc: ", lvl);
|
| 2504 | }
|
| 2505 | pr_cont("[%0*d] ", group_width, group);
|
| 2506 |
|
| 2507 | for (unit_end += upa; unit < unit_end; unit++)
|
| 2508 | if (gi->cpu_map[unit] != NR_CPUS)
|
| 2509 | pr_cont("%0*d ",
|
| 2510 | cpu_width, gi->cpu_map[unit]);
|
| 2511 | else
|
| 2512 | pr_cont("%s ", empty_str);
|
| 2513 | }
|
| 2514 | }
|
| 2515 | pr_cont("\n");
|
| 2516 | }
|
| 2517 |
|
| 2518 | |
| 2519 | * pcpu_setup_first_chunk - initialize the first percpu chunk
|
| 2520 | * @ai: pcpu_alloc_info describing how to percpu area is shaped
|
| 2521 | * @base_addr: mapped address
|
| 2522 | *
|
| 2523 | * Initialize the first percpu chunk which contains the kernel static
|
| 2524 | * percpu area. This function is to be called from arch percpu area
|
| 2525 | * setup path.
|
| 2526 | *
|
| 2527 | * @ai contains all information necessary to initialize the first
|
| 2528 | * chunk and prime the dynamic percpu allocator.
|
| 2529 | *
|
| 2530 | * @ai->static_size is the size of static percpu area.
|
| 2531 | *
|
| 2532 | * @ai->reserved_size, if non-zero, specifies the amount of bytes to
|
| 2533 | * reserve after the static area in the first chunk. This reserves
|
| 2534 | * the first chunk such that it's available only through reserved
|
| 2535 | * percpu allocation. This is primarily used to serve module percpu
|
| 2536 | * static areas on architectures where the addressing model has
|
| 2537 | * limited offset range for symbol relocations to guarantee module
|
| 2538 | * percpu symbols fall inside the relocatable range.
|
| 2539 | *
|
| 2540 | * @ai->dyn_size determines the number of bytes available for dynamic
|
| 2541 | * allocation in the first chunk. The area between @ai->static_size +
|
| 2542 | * @ai->reserved_size + @ai->dyn_size and @ai->unit_size is unused.
|
| 2543 | *
|
| 2544 | * @ai->unit_size specifies unit size and must be aligned to PAGE_SIZE
|
| 2545 | * and equal to or larger than @ai->static_size + @ai->reserved_size +
|
| 2546 | * @ai->dyn_size.
|
| 2547 | *
|
| 2548 | * @ai->atom_size is the allocation atom size and used as alignment
|
| 2549 | * for vm areas.
|
| 2550 | *
|
| 2551 | * @ai->alloc_size is the allocation size and always multiple of
|
| 2552 | * @ai->atom_size. This is larger than @ai->atom_size if
|
| 2553 | * @ai->unit_size is larger than @ai->atom_size.
|
| 2554 | *
|
| 2555 | * @ai->nr_groups and @ai->groups describe virtual memory layout of
|
| 2556 | * percpu areas. Units which should be colocated are put into the
|
| 2557 | * same group. Dynamic VM areas will be allocated according to these
|
| 2558 | * groupings. If @ai->nr_groups is zero, a single group containing
|
| 2559 | * all units is assumed.
|
| 2560 | *
|
| 2561 | * The caller should have mapped the first chunk at @base_addr and
|
| 2562 | * copied static data to each unit.
|
| 2563 | *
|
| 2564 | * The first chunk will always contain a static and a dynamic region.
|
| 2565 | * However, the static region is not managed by any chunk. If the first
|
| 2566 | * chunk also contains a reserved region, it is served by two chunks -
|
| 2567 | * one for the reserved region and one for the dynamic region. They
|
| 2568 | * share the same vm, but use offset regions in the area allocation map.
|
| 2569 | * The chunk serving the dynamic region is circulated in the chunk slots
|
| 2570 | * and available for dynamic allocation like any other chunk.
|
| 2571 |
|
| 2572 | void __init pcpu_setup_first_chunk(const struct pcpu_alloc_info *ai,
|
| 2573 | void *base_addr)
|
| 2574 | {
|
| 2575 | size_t size_sum = ai->static_size + ai->reserved_size + ai->dyn_size;
|
| 2576 | size_t static_size, dyn_size;
|
| 2577 | unsigned long *group_offsets;
|
| 2578 | size_t *group_sizes;
|
| 2579 | unsigned long *unit_off;
|
| 2580 | unsigned int cpu;
|
| 2581 | int *unit_map;
|
| 2582 | int group, unit, i;
|
| 2583 | unsigned long tmp_addr;
|
| 2584 | size_t alloc_size;
|
| 2585 |
|
| 2586 | #define PCPU_SETUP_BUG_ON(cond) do { \
|
| 2587 | if (unlikely(cond)) { \
|
| 2588 | pr_emerg("failed to initialize, %s\n", #cond); \
|
| 2589 | pr_emerg("cpu_possible_mask=%*pb\n", \
|
| 2590 | cpumask_pr_args(cpu_possible_mask)); \
|
| 2591 | pcpu_dump_alloc_info(KERN_EMERG, ai); \
|
| 2592 | BUG(); \
|
| 2593 | } \
|
| 2594 | } while (0)
|
| 2595 |
|
| 2596 |
|
| 2597 | PCPU_SETUP_BUG_ON(ai->nr_groups <= 0);
|
| 2598 | #ifdef CONFIG_SMP
|
| 2599 | PCPU_SETUP_BUG_ON(!ai->static_size);
|
| 2600 | PCPU_SETUP_BUG_ON(offset_in_page(__per_cpu_start));
|
| 2601 | #endif
|
| 2602 | PCPU_SETUP_BUG_ON(!base_addr);
|
| 2603 | PCPU_SETUP_BUG_ON(offset_in_page(base_addr));
|
| 2604 | PCPU_SETUP_BUG_ON(ai->unit_size < size_sum);
|
| 2605 | PCPU_SETUP_BUG_ON(offset_in_page(ai->unit_size));
|
| 2606 | PCPU_SETUP_BUG_ON(ai->unit_size < PCPU_MIN_UNIT_SIZE);
|
| 2607 | PCPU_SETUP_BUG_ON(!IS_ALIGNED(ai->unit_size, PCPU_BITMAP_BLOCK_SIZE));
|
| 2608 | PCPU_SETUP_BUG_ON(ai->dyn_size < PERCPU_DYNAMIC_EARLY_SIZE);
|
| 2609 | PCPU_SETUP_BUG_ON(!IS_ALIGNED(ai->reserved_size, PCPU_MIN_ALLOC_SIZE));
|
| 2610 | PCPU_SETUP_BUG_ON(!(IS_ALIGNED(PCPU_BITMAP_BLOCK_SIZE, PAGE_SIZE) ||
|
| 2611 | IS_ALIGNED(PAGE_SIZE, PCPU_BITMAP_BLOCK_SIZE)));
|
| 2612 | PCPU_SETUP_BUG_ON(pcpu_verify_alloc_info(ai) < 0);
|
| 2613 |
|
| 2614 |
|
| 2615 | alloc_size = ai->nr_groups * sizeof(group_offsets[0]);
|
| 2616 | group_offsets = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES);
|
| 2617 |
|
| 2618 | alloc_size = ai->nr_groups * sizeof(group_sizes[0]);
|
| 2619 | group_sizes = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES);
|
| 2620 |
|
| 2621 | alloc_size = nr_cpu_ids * sizeof(unit_map[0]);
|
| 2622 | unit_map = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES);
|
| 2623 |
|
| 2624 | alloc_size = nr_cpu_ids * sizeof(unit_off[0]);
|
| 2625 | unit_off = memblock_alloc_or_panic(alloc_size, SMP_CACHE_BYTES);
|
| 2626 |
|
| 2627 | for (cpu = 0; cpu < nr_cpu_ids; cpu++)
|
| 2628 | unit_map[cpu] = UINT_MAX;
|
| 2629 |
|
| 2630 | pcpu_low_unit_cpu = NR_CPUS;
|
| 2631 | pcpu_high_unit_cpu = NR_CPUS;
|
| 2632 |
|
| 2633 | for (group = 0, unit = 0; group < ai->nr_groups; group++, unit += i) {
|
| 2634 | const struct pcpu_group_info *gi = &ai->groups[group];
|
| 2635 |
|
| 2636 | group_offsets[group] = gi->base_offset;
|
| 2637 | group_sizes[group] = gi->nr_units * ai->unit_size;
|
| 2638 |
|
| 2639 | for (i = 0; i < gi->nr_units; i++) {
|
| 2640 | cpu = gi->cpu_map[i];
|
| 2641 | if (cpu == NR_CPUS)
|
| 2642 | continue;
|
| 2643 |
|
| 2644 | PCPU_SETUP_BUG_ON(cpu >= nr_cpu_ids);
|
| 2645 | PCPU_SETUP_BUG_ON(!cpu_possible(cpu));
|
| 2646 | PCPU_SETUP_BUG_ON(unit_map[cpu] != UINT_MAX);
|
| 2647 |
|
| 2648 | unit_map[cpu] = unit + i;
|
| 2649 | unit_off[cpu] = gi->base_offset + i * ai->unit_size;
|
| 2650 |
|
| 2651 |
|
| 2652 | if (pcpu_low_unit_cpu == NR_CPUS ||
|
| 2653 | unit_off[cpu] < unit_off[pcpu_low_unit_cpu])
|
| 2654 | pcpu_low_unit_cpu = cpu;
|
| 2655 | if (pcpu_high_unit_cpu == NR_CPUS ||
|
| 2656 | unit_off[cpu] > unit_off[pcpu_high_unit_cpu])
|
| 2657 | pcpu_high_unit_cpu = cpu;
|
| 2658 | }
|
| 2659 | }
|
| 2660 | pcpu_nr_units = unit;
|
| 2661 |
|
| 2662 | for_each_possible_cpu(cpu)
|
| 2663 | PCPU_SETUP_BUG_ON(unit_map[cpu] == UINT_MAX);
|
| 2664 |
|
| 2665 |
|
| 2666 | #undef PCPU_SETUP_BUG_ON
|
| 2667 | pcpu_dump_alloc_info(KERN_DEBUG, ai);
|
| 2668 |
|
| 2669 | pcpu_nr_groups = ai->nr_groups;
|
| 2670 | pcpu_group_offsets = group_offsets;
|
| 2671 | pcpu_group_sizes = group_sizes;
|
| 2672 | pcpu_unit_map = unit_map;
|
| 2673 | pcpu_unit_offsets = unit_off;
|
| 2674 |
|
| 2675 |
|
| 2676 | pcpu_unit_pages = ai->unit_size >> PAGE_SHIFT;
|
| 2677 | pcpu_unit_size = pcpu_unit_pages << PAGE_SHIFT;
|
| 2678 | pcpu_atom_size = ai->atom_size;
|
| 2679 | pcpu_chunk_struct_size = struct_size((struct pcpu_chunk *)0, populated,
|
| 2680 | BITS_TO_LONGS(pcpu_unit_pages));
|
| 2681 |
|
| 2682 | pcpu_stats_save_ai(ai);
|
| 2683 |
|
| 2684 | |
| 2685 | * Allocate chunk slots. The slots after the active slots are:
|
| 2686 | * sidelined_slot - isolated, depopulated chunks
|
| 2687 | * free_slot - fully free chunks
|
| 2688 | * to_depopulate_slot - isolated, chunks to depopulate
|
| 2689 |
|
| 2690 | pcpu_sidelined_slot = __pcpu_size_to_slot(pcpu_unit_size) + 1;
|
| 2691 | pcpu_free_slot = pcpu_sidelined_slot + 1;
|
| 2692 | pcpu_to_depopulate_slot = pcpu_free_slot + 1;
|
| 2693 | pcpu_nr_slots = pcpu_to_depopulate_slot + 1;
|
| 2694 | pcpu_chunk_lists = memblock_alloc_or_panic(pcpu_nr_slots *
|
| 2695 | sizeof(pcpu_chunk_lists[0]),
|
| 2696 | SMP_CACHE_BYTES);
|
| 2697 |
|
| 2698 | for (i = 0; i < pcpu_nr_slots; i++)
|
| 2699 | INIT_LIST_HEAD(&pcpu_chunk_lists[i]);
|
| 2700 |
|
| 2701 | |
| 2702 | * The end of the static region needs to be aligned with the
|
| 2703 | * minimum allocation size as this offsets the reserved and
|
| 2704 | * dynamic region. The first chunk ends page aligned by
|
| 2705 | * expanding the dynamic region, therefore the dynamic region
|
| 2706 | * can be shrunk to compensate while still staying above the
|
| 2707 | * configured sizes.
|
| 2708 |
|
| 2709 | static_size = ALIGN(ai->static_size, PCPU_MIN_ALLOC_SIZE);
|
| 2710 | dyn_size = ai->dyn_size - (static_size - ai->static_size);
|
| 2711 |
|
| 2712 | |
| 2713 | * Initialize first chunk:
|
| 2714 | * This chunk is broken up into 3 parts:
|
| 2715 | * < static | [reserved] | dynamic >
|
| 2716 | * - static - there is no backing chunk because these allocations can
|
| 2717 | * never be freed.
|
| 2718 | * - reserved (pcpu_reserved_chunk) - exists primarily to serve
|
| 2719 | * allocations from module load.
|
| 2720 | * - dynamic (pcpu_first_chunk) - serves the dynamic part of the first
|
| 2721 | * chunk.
|
| 2722 |
|
| 2723 | tmp_addr = (unsigned long)base_addr + static_size;
|
| 2724 | if (ai->reserved_size)
|
| 2725 | pcpu_reserved_chunk = pcpu_alloc_first_chunk(tmp_addr,
|
| 2726 | ai->reserved_size);
|
| 2727 | tmp_addr = (unsigned long)base_addr + static_size + ai->reserved_size;
|
| 2728 | pcpu_first_chunk = pcpu_alloc_first_chunk(tmp_addr, dyn_size);
|
| 2729 |
|
| 2730 | pcpu_nr_empty_pop_pages = pcpu_first_chunk->nr_empty_pop_pages;
|
| 2731 | pcpu_chunk_relocate(pcpu_first_chunk, -1);
|
| 2732 |
|
| 2733 |
|
| 2734 | pcpu_nr_populated += PFN_DOWN(size_sum);
|
| 2735 |
|
| 2736 | pcpu_stats_chunk_alloc();
|
| 2737 | trace_percpu_create_chunk(base_addr);
|
| 2738 |
|
| 2739 |
|
| 2740 | pcpu_base_addr = base_addr;
|
| 2741 | }
|
| 2742 |
|
| 2743 | #ifdef CONFIG_SMP
|
| 2744 |
|
| 2745 | const char * const pcpu_fc_names[PCPU_FC_NR] __initconst = {
|
| 2746 | [PCPU_FC_AUTO] = "auto",
|
| 2747 | [PCPU_FC_EMBED] = "embed",
|
| 2748 | [PCPU_FC_PAGE] = "page",
|
| 2749 | };
|
| 2750 |
|
| 2751 | enum pcpu_fc pcpu_chosen_fc __initdata = PCPU_FC_AUTO;
|
| 2752 |
|
| 2753 | static int __init percpu_alloc_setup(char *str)
|
| 2754 | {
|
| 2755 | if (!str)
|
| 2756 | return -EINVAL;
|
| 2757 |
|
| 2758 | if (0)
|
| 2759 | ;
|
| 2760 | #ifdef CONFIG_NEED_PER_CPU_EMBED_FIRST_CHUNK
|
| 2761 | else if (!strcmp(str, "embed"))
|
| 2762 | pcpu_chosen_fc = PCPU_FC_EMBED;
|
| 2763 | #endif
|
| 2764 | #ifdef CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK
|
| 2765 | else if (!strcmp(str, "page"))
|
| 2766 | pcpu_chosen_fc = PCPU_FC_PAGE;
|
| 2767 | #endif
|
| 2768 | else
|
| 2769 | pr_warn("unknown allocator %s specified\n", str);
|
| 2770 |
|
| 2771 | return 0;
|
| 2772 | }
|
| 2773 | early_param("percpu_alloc", percpu_alloc_setup);
|
| 2774 |
|
| 2775 | |
| 2776 | * pcpu_embed_first_chunk() is used by the generic percpu setup.
|
| 2777 | * Build it if needed by the arch config or the generic setup is going
|
| 2778 | * to be used.
|
| 2779 |
|
| 2780 | #if defined(CONFIG_NEED_PER_CPU_EMBED_FIRST_CHUNK) || \
|
| 2781 | !defined(CONFIG_HAVE_SETUP_PER_CPU_AREA)
|
| 2782 | #define BUILD_EMBED_FIRST_CHUNK
|
| 2783 | #endif
|
| 2784 |
|
| 2785 |
|
| 2786 | #if defined(CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK)
|
| 2787 | #define BUILD_PAGE_FIRST_CHUNK
|
| 2788 | #endif
|
| 2789 |
|
| 2790 |
|
| 2791 | #if defined(BUILD_EMBED_FIRST_CHUNK) || defined(BUILD_PAGE_FIRST_CHUNK)
|
| 2792 | |
| 2793 | * pcpu_build_alloc_info - build alloc_info considering distances between CPUs
|
| 2794 | * @reserved_size: the size of reserved percpu area in bytes
|
| 2795 | * @dyn_size: minimum free size for dynamic allocation in bytes
|
| 2796 | * @atom_size: allocation atom size
|
| 2797 | * @cpu_distance_fn: callback to determine distance between cpus, optional
|
| 2798 | *
|
| 2799 | * This function determines grouping of units, their mappings to cpus
|
| 2800 | * and other parameters considering needed percpu size, allocation
|
| 2801 | * atom size and distances between CPUs.
|
| 2802 | *
|
| 2803 | * Groups are always multiples of atom size and CPUs which are of
|
| 2804 | * LOCAL_DISTANCE both ways are grouped together and share space for
|
| 2805 | * units in the same group. The returned configuration is guaranteed
|
| 2806 | * to have CPUs on different nodes on different groups and >=75% usage
|
| 2807 | * of allocated virtual address space.
|
| 2808 | *
|
| 2809 | * RETURNS:
|
| 2810 | * On success, pointer to the new allocation_info is returned. On
|
| 2811 | * failure, ERR_PTR value is returned.
|
| 2812 |
|
| 2813 | static struct pcpu_alloc_info * __init __flatten pcpu_build_alloc_info(
|
| 2814 | size_t reserved_size, size_t dyn_size,
|
| 2815 | size_t atom_size,
|
| 2816 | pcpu_fc_cpu_distance_fn_t cpu_distance_fn)
|
| 2817 | {
|
| 2818 | static int group_map[NR_CPUS] __initdata;
|
| 2819 | static int group_cnt[NR_CPUS] __initdata;
|
| 2820 | static struct cpumask mask __initdata;
|
| 2821 | const size_t static_size = __per_cpu_end - __per_cpu_start;
|
| 2822 | int nr_groups = 1, nr_units = 0;
|
| 2823 | size_t size_sum, min_unit_size, alloc_size;
|
| 2824 | int upa, max_upa, best_upa;
|
| 2825 | int last_allocs, group, unit;
|
| 2826 | unsigned int cpu, tcpu;
|
| 2827 | struct pcpu_alloc_info *ai;
|
| 2828 | unsigned int *cpu_map;
|
| 2829 |
|
| 2830 |
|
| 2831 | memset(group_map, 0, sizeof(group_map));
|
| 2832 | memset(group_cnt, 0, sizeof(group_cnt));
|
| 2833 | cpumask_clear(&mask);
|
| 2834 |
|
| 2835 |
|
| 2836 | size_sum = PFN_ALIGN(static_size + reserved_size +
|
| 2837 | max_t(size_t, dyn_size, PERCPU_DYNAMIC_EARLY_SIZE));
|
| 2838 | dyn_size = size_sum - static_size - reserved_size;
|
| 2839 |
|
| 2840 | |
| 2841 | * Determine min_unit_size, alloc_size and max_upa such that
|
| 2842 | * alloc_size is multiple of atom_size and is the smallest
|
| 2843 | * which can accommodate 4k aligned segments which are equal to
|
| 2844 | * or larger than min_unit_size.
|
| 2845 |
|
| 2846 | min_unit_size = max_t(size_t, size_sum, PCPU_MIN_UNIT_SIZE);
|
| 2847 |
|
| 2848 |
|
| 2849 | alloc_size = roundup(min_unit_size, atom_size);
|
| 2850 | upa = alloc_size / min_unit_size;
|
| 2851 | while (alloc_size % upa || (offset_in_page(alloc_size / upa)))
|
| 2852 | upa--;
|
| 2853 | max_upa = upa;
|
| 2854 |
|
| 2855 | cpumask_copy(&mask, cpu_possible_mask);
|
| 2856 |
|
| 2857 |
|
| 2858 | for (group = 0; !cpumask_empty(&mask); group++) {
|
| 2859 |
|
| 2860 | cpu = cpumask_first(&mask);
|
| 2861 | group_map[cpu] = group;
|
| 2862 | group_cnt[group]++;
|
| 2863 | cpumask_clear_cpu(cpu, &mask);
|
| 2864 |
|
| 2865 | for_each_cpu(tcpu, &mask) {
|
| 2866 | if (!cpu_distance_fn ||
|
| 2867 | (cpu_distance_fn(cpu, tcpu) == LOCAL_DISTANCE &&
|
| 2868 | cpu_distance_fn(tcpu, cpu) == LOCAL_DISTANCE)) {
|
| 2869 | group_map[tcpu] = group;
|
| 2870 | group_cnt[group]++;
|
| 2871 | cpumask_clear_cpu(tcpu, &mask);
|
| 2872 | }
|
| 2873 | }
|
| 2874 | }
|
| 2875 | nr_groups = group;
|
| 2876 |
|
| 2877 | |
| 2878 | * Wasted space is caused by a ratio imbalance of upa to group_cnt.
|
| 2879 | * Expand the unit_size until we use >= 75% of the units allocated.
|
| 2880 | * Related to atom_size, which could be much larger than the unit_size.
|
| 2881 |
|
| 2882 | last_allocs = INT_MAX;
|
| 2883 | best_upa = 0;
|
| 2884 | for (upa = max_upa; upa; upa--) {
|
| 2885 | int allocs = 0, wasted = 0;
|
| 2886 |
|
| 2887 | if (alloc_size % upa || (offset_in_page(alloc_size / upa)))
|
| 2888 | continue;
|
| 2889 |
|
| 2890 | for (group = 0; group < nr_groups; group++) {
|
| 2891 | int this_allocs = DIV_ROUND_UP(group_cnt[group], upa);
|
| 2892 | allocs += this_allocs;
|
| 2893 | wasted += this_allocs * upa - group_cnt[group];
|
| 2894 | }
|
| 2895 |
|
| 2896 | |
| 2897 | * Don't accept if wastage is over 1/3. The
|
| 2898 | * greater-than comparison ensures upa==1 always
|
| 2899 | * passes the following check.
|
| 2900 |
|
| 2901 | if (wasted > num_possible_cpus() / 3)
|
| 2902 | continue;
|
| 2903 |
|
| 2904 |
|
| 2905 | if (allocs > last_allocs)
|
| 2906 | break;
|
| 2907 | last_allocs = allocs;
|
| 2908 | best_upa = upa;
|
| 2909 | }
|
| 2910 | BUG_ON(!best_upa);
|
| 2911 | upa = best_upa;
|
| 2912 |
|
| 2913 |
|
| 2914 | for (group = 0; group < nr_groups; group++)
|
| 2915 | nr_units += roundup(group_cnt[group], upa);
|
| 2916 |
|
| 2917 | ai = pcpu_alloc_alloc_info(nr_groups, nr_units);
|
| 2918 | if (!ai)
|
| 2919 | return ERR_PTR(-ENOMEM);
|
| 2920 | cpu_map = ai->groups[0].cpu_map;
|
| 2921 |
|
| 2922 | for (group = 0; group < nr_groups; group++) {
|
| 2923 | ai->groups[group].cpu_map = cpu_map;
|
| 2924 | cpu_map += roundup(group_cnt[group], upa);
|
| 2925 | }
|
| 2926 |
|
| 2927 | ai->static_size = static_size;
|
| 2928 | ai->reserved_size = reserved_size;
|
| 2929 | ai->dyn_size = dyn_size;
|
| 2930 | ai->unit_size = alloc_size / upa;
|
| 2931 | ai->atom_size = atom_size;
|
| 2932 | ai->alloc_size = alloc_size;
|
| 2933 |
|
| 2934 | for (group = 0, unit = 0; group < nr_groups; group++) {
|
| 2935 | struct pcpu_group_info *gi = &ai->groups[group];
|
| 2936 |
|
| 2937 | |
| 2938 | * Initialize base_offset as if all groups are located
|
| 2939 | * back-to-back. The caller should update this to
|
| 2940 | * reflect actual allocation.
|
| 2941 |
|
| 2942 | gi->base_offset = unit * ai->unit_size;
|
| 2943 |
|
| 2944 | for_each_possible_cpu(cpu)
|
| 2945 | if (group_map[cpu] == group)
|
| 2946 | gi->cpu_map[gi->nr_units++] = cpu;
|
| 2947 | gi->nr_units = roundup(gi->nr_units, upa);
|
| 2948 | unit += gi->nr_units;
|
| 2949 | }
|
| 2950 | BUG_ON(unit != nr_units);
|
| 2951 |
|
| 2952 | return ai;
|
| 2953 | }
|
| 2954 |
|
| 2955 | static void * __init pcpu_fc_alloc(unsigned int cpu, size_t size, size_t align,
|
| 2956 | pcpu_fc_cpu_to_node_fn_t cpu_to_nd_fn)
|
| 2957 | {
|
| 2958 | const unsigned long goal = __pa(MAX_DMA_ADDRESS);
|
| 2959 | #ifdef CONFIG_NUMA
|
| 2960 | int node = NUMA_NO_NODE;
|
| 2961 | void *ptr;
|
| 2962 |
|
| 2963 | if (cpu_to_nd_fn)
|
| 2964 | node = cpu_to_nd_fn(cpu);
|
| 2965 |
|
| 2966 | if (node == NUMA_NO_NODE || !node_online(node) || !NODE_DATA(node)) {
|
| 2967 | ptr = memblock_alloc_from(size, align, goal);
|
| 2968 | pr_info("cpu %d has no node %d or node-local memory\n",
|
| 2969 | cpu, node);
|
| 2970 | pr_debug("per cpu data for cpu%d %zu bytes at 0x%llx\n",
|
| 2971 | cpu, size, (u64)__pa(ptr));
|
| 2972 | } else {
|
| 2973 | ptr = memblock_alloc_try_nid(size, align, goal,
|
| 2974 | MEMBLOCK_ALLOC_ACCESSIBLE,
|
| 2975 | node);
|
| 2976 |
|
| 2977 | pr_debug("per cpu data for cpu%d %zu bytes on node%d at 0x%llx\n",
|
| 2978 | cpu, size, node, (u64)__pa(ptr));
|
| 2979 | }
|
| 2980 | return ptr;
|
| 2981 | #else
|
| 2982 | return memblock_alloc_from(size, align, goal);
|
| 2983 | #endif
|
| 2984 | }
|
| 2985 |
|
| 2986 | static void __init pcpu_fc_free(void *ptr, size_t size)
|
| 2987 | {
|
| 2988 | memblock_free(ptr, size);
|
| 2989 | }
|
| 2990 | #endif
|
| 2991 |
|
| 2992 | #if defined(BUILD_EMBED_FIRST_CHUNK)
|
| 2993 | |
| 2994 | * pcpu_embed_first_chunk - embed the first percpu chunk into bootmem
|
| 2995 | * @reserved_size: the size of reserved percpu area in bytes
|
| 2996 | * @dyn_size: minimum free size for dynamic allocation in bytes
|
| 2997 | * @atom_size: allocation atom size
|
| 2998 | * @cpu_distance_fn: callback to determine distance between cpus, optional
|
| 2999 | * @cpu_to_nd_fn: callback to convert cpu to it's node, optional
|
| 3000 | *
|
| 3001 | * This is a helper to ease setting up embedded first percpu chunk and
|
| 3002 | * can be called where pcpu_setup_first_chunk() is expected.
|
| 3003 | *
|
| 3004 | * If this function is used to setup the first chunk, it is allocated
|
| 3005 | * by calling pcpu_fc_alloc and used as-is without being mapped into
|
| 3006 | * vmalloc area. Allocations are always whole multiples of @atom_size
|
| 3007 | * aligned to @atom_size.
|
| 3008 | *
|
| 3009 | * This enables the first chunk to piggy back on the linear physical
|
| 3010 | * mapping which often uses larger page size. Please note that this
|
| 3011 | * can result in very sparse cpu->unit mapping on NUMA machines thus
|
| 3012 | * requiring large vmalloc address space. Don't use this allocator if
|
| 3013 | * vmalloc space is not orders of magnitude larger than distances
|
| 3014 | * between node memory addresses (ie. 32bit NUMA machines).
|
| 3015 | *
|
| 3016 | * @dyn_size specifies the minimum dynamic area size.
|
| 3017 | *
|
| 3018 | * If the needed size is smaller than the minimum or specified unit
|
| 3019 | * size, the leftover is returned using pcpu_fc_free.
|
| 3020 | *
|
| 3021 | * RETURNS:
|
| 3022 | * 0 on success, -errno on failure.
|
| 3023 |
|
| 3024 | int __init pcpu_embed_first_chunk(size_t reserved_size, size_t dyn_size,
|
| 3025 | size_t atom_size,
|
| 3026 | pcpu_fc_cpu_distance_fn_t cpu_distance_fn,
|
| 3027 | pcpu_fc_cpu_to_node_fn_t cpu_to_nd_fn)
|
| 3028 | {
|
| 3029 | void *base = (void *)ULONG_MAX;
|
| 3030 | void **areas = NULL;
|
| 3031 | struct pcpu_alloc_info *ai;
|
| 3032 | size_t size_sum, areas_size;
|
| 3033 | unsigned long max_distance;
|
| 3034 | int group, i, highest_group, rc = 0;
|
| 3035 |
|
| 3036 | ai = pcpu_build_alloc_info(reserved_size, dyn_size, atom_size,
|
| 3037 | cpu_distance_fn);
|
| 3038 | if (IS_ERR(ai))
|
| 3039 | return PTR_ERR(ai);
|
| 3040 |
|
| 3041 | size_sum = ai->static_size + ai->reserved_size + ai->dyn_size;
|
| 3042 | areas_size = PFN_ALIGN(ai->nr_groups * sizeof(void *));
|
| 3043 |
|
| 3044 | areas = memblock_alloc(areas_size, SMP_CACHE_BYTES);
|
| 3045 | if (!areas) {
|
| 3046 | rc = -ENOMEM;
|
| 3047 | goto out_free;
|
| 3048 | }
|
| 3049 |
|
| 3050 |
|
| 3051 | highest_group = 0;
|
| 3052 | for (group = 0; group < ai->nr_groups; group++) {
|
| 3053 | struct pcpu_group_info *gi = &ai->groups[group];
|
| 3054 | unsigned int cpu = NR_CPUS;
|
| 3055 | void *ptr;
|
| 3056 |
|
| 3057 | for (i = 0; i < gi->nr_units && cpu == NR_CPUS; i++)
|
| 3058 | cpu = gi->cpu_map[i];
|
| 3059 | BUG_ON(cpu == NR_CPUS);
|
| 3060 |
|
| 3061 |
|
| 3062 | ptr = pcpu_fc_alloc(cpu, gi->nr_units * ai->unit_size, atom_size, cpu_to_nd_fn);
|
| 3063 | if (!ptr) {
|
| 3064 | rc = -ENOMEM;
|
| 3065 | goto out_free_areas;
|
| 3066 | }
|
| 3067 |
|
| 3068 | kmemleak_ignore_phys(__pa(ptr));
|
| 3069 | areas[group] = ptr;
|
| 3070 |
|
| 3071 | base = min(ptr, base);
|
| 3072 | if (ptr > areas[highest_group])
|
| 3073 | highest_group = group;
|
| 3074 | }
|
| 3075 | max_distance = areas[highest_group] - base;
|
| 3076 | max_distance += ai->unit_size * ai->groups[highest_group].nr_units;
|
| 3077 |
|
| 3078 |
|
| 3079 | if (max_distance > VMALLOC_TOTAL * 3 / 4) {
|
| 3080 | pr_warn("max_distance=0x%lx too large for vmalloc space 0x%lx\n",
|
| 3081 | max_distance, VMALLOC_TOTAL);
|
| 3082 | #ifdef CONFIG_NEED_PER_CPU_PAGE_FIRST_CHUNK
|
| 3083 |
|
| 3084 | rc = -EINVAL;
|
| 3085 | goto out_free_areas;
|
| 3086 | #endif
|
| 3087 | }
|
| 3088 |
|
| 3089 | |
| 3090 | * Copy data and free unused parts. This should happen after all
|
| 3091 | * allocations are complete; otherwise, we may end up with
|
| 3092 | * overlapping groups.
|
| 3093 |
|
| 3094 | for (group = 0; group < ai->nr_groups; group++) {
|
| 3095 | struct pcpu_group_info *gi = &ai->groups[group];
|
| 3096 | void *ptr = areas[group];
|
| 3097 |
|
| 3098 | for (i = 0; i < gi->nr_units; i++, ptr += ai->unit_size) {
|
| 3099 | if (gi->cpu_map[i] == NR_CPUS) {
|
| 3100 |
|
| 3101 | pcpu_fc_free(ptr, ai->unit_size);
|
| 3102 | continue;
|
| 3103 | }
|
| 3104 |
|
| 3105 | memcpy(ptr, __per_cpu_start, ai->static_size);
|
| 3106 | pcpu_fc_free(ptr + size_sum, ai->unit_size - size_sum);
|
| 3107 | }
|
| 3108 | }
|
| 3109 |
|
| 3110 |
|
| 3111 | for (group = 0; group < ai->nr_groups; group++) {
|
| 3112 | ai->groups[group].base_offset = areas[group] - base;
|
| 3113 | }
|
| 3114 |
|
| 3115 | pr_info("Embedded %zu pages/cpu s%zu r%zu d%zu u%zu\n",
|
| 3116 | PFN_DOWN(size_sum), ai->static_size, ai->reserved_size,
|
| 3117 | ai->dyn_size, ai->unit_size);
|
| 3118 |
|
| 3119 | pcpu_setup_first_chunk(ai, base);
|
| 3120 | goto out_free;
|
| 3121 |
|
| 3122 | out_free_areas:
|
| 3123 | for (group = 0; group < ai->nr_groups; group++)
|
| 3124 | if (areas[group])
|
| 3125 | pcpu_fc_free(areas[group],
|
| 3126 | ai->groups[group].nr_units * ai->unit_size);
|
| 3127 | out_free:
|
| 3128 | pcpu_free_alloc_info(ai);
|
| 3129 | if (areas)
|
| 3130 | memblock_free(areas, areas_size);
|
| 3131 | return rc;
|
| 3132 | }
|
| 3133 | #endif
|
| 3134 |
|
| 3135 | #ifdef BUILD_PAGE_FIRST_CHUNK
|
| 3136 | #include <linux/pgalloc.h>
|
| 3137 |
|
| 3138 | #ifndef P4D_TABLE_SIZE
|
| 3139 | #define P4D_TABLE_SIZE PAGE_SIZE
|
| 3140 | #endif
|
| 3141 |
|
| 3142 | #ifndef PUD_TABLE_SIZE
|
| 3143 | #define PUD_TABLE_SIZE PAGE_SIZE
|
| 3144 | #endif
|
| 3145 |
|
| 3146 | #ifndef PMD_TABLE_SIZE
|
| 3147 | #define PMD_TABLE_SIZE PAGE_SIZE
|
| 3148 | #endif
|
| 3149 |
|
| 3150 | #ifndef PTE_TABLE_SIZE
|
| 3151 | #define PTE_TABLE_SIZE PAGE_SIZE
|
| 3152 | #endif
|
| 3153 | void __init __weak pcpu_populate_pte(unsigned long addr)
|
| 3154 | {
|
| 3155 | pgd_t *pgd = pgd_offset_k(addr);
|
| 3156 | p4d_t *p4d;
|
| 3157 | pud_t *pud;
|
| 3158 | pmd_t *pmd;
|
| 3159 |
|
| 3160 | if (pgd_none(*pgd)) {
|
| 3161 | p4d = memblock_alloc_or_panic(P4D_TABLE_SIZE, P4D_TABLE_SIZE);
|
| 3162 | pgd_populate_kernel(addr, pgd, p4d);
|
| 3163 | }
|
| 3164 |
|
| 3165 | p4d = p4d_offset(pgd, addr);
|
| 3166 | if (p4d_none(*p4d)) {
|
| 3167 | pud = memblock_alloc_or_panic(PUD_TABLE_SIZE, PUD_TABLE_SIZE);
|
| 3168 | p4d_populate_kernel(addr, p4d, pud);
|
| 3169 | }
|
| 3170 |
|
| 3171 | pud = pud_offset(p4d, addr);
|
| 3172 | if (pud_none(*pud)) {
|
| 3173 | pmd = memblock_alloc_or_panic(PMD_TABLE_SIZE, PMD_TABLE_SIZE);
|
| 3174 | pud_populate(&init_mm, pud, pmd);
|
| 3175 | }
|
| 3176 |
|
| 3177 | pmd = pmd_offset(pud, addr);
|
| 3178 | if (!pmd_present(*pmd)) {
|
| 3179 | pte_t *new;
|
| 3180 |
|
| 3181 | new = memblock_alloc_or_panic(PTE_TABLE_SIZE, PTE_TABLE_SIZE);
|
| 3182 | pmd_populate_kernel(&init_mm, pmd, new);
|
| 3183 | }
|
| 3184 |
|
| 3185 | return;
|
| 3186 | }
|
| 3187 |
|
| 3188 | |
| 3189 | * pcpu_page_first_chunk - map the first chunk using PAGE_SIZE pages
|
| 3190 | * @reserved_size: the size of reserved percpu area in bytes
|
| 3191 | * @cpu_to_nd_fn: callback to convert cpu to it's node, optional
|
| 3192 | *
|
| 3193 | * This is a helper to ease setting up page-remapped first percpu
|
| 3194 | * chunk and can be called where pcpu_setup_first_chunk() is expected.
|
| 3195 | *
|
| 3196 | * This is the basic allocator. Static percpu area is allocated
|
| 3197 | * page-by-page into vmalloc area.
|
| 3198 | *
|
| 3199 | * RETURNS:
|
| 3200 | * 0 on success, -errno on failure.
|
| 3201 |
|
| 3202 | int __init pcpu_page_first_chunk(size_t reserved_size, pcpu_fc_cpu_to_node_fn_t cpu_to_nd_fn)
|
| 3203 | {
|
| 3204 | static struct vm_struct vm;
|
| 3205 | struct pcpu_alloc_info *ai;
|
| 3206 | char psize_str[16];
|
| 3207 | int unit_pages;
|
| 3208 | size_t pages_size;
|
| 3209 | struct page **pages;
|
| 3210 | int unit, i, j, rc = 0;
|
| 3211 | int upa;
|
| 3212 | int nr_g0_units;
|
| 3213 |
|
| 3214 | snprintf(psize_str, sizeof(psize_str), "%luK", PAGE_SIZE >> 10);
|
| 3215 |
|
| 3216 | ai = pcpu_build_alloc_info(reserved_size, 0, PAGE_SIZE, NULL);
|
| 3217 | if (IS_ERR(ai))
|
| 3218 | return PTR_ERR(ai);
|
| 3219 | BUG_ON(ai->nr_groups != 1);
|
| 3220 | upa = ai->alloc_size/ai->unit_size;
|
| 3221 | nr_g0_units = roundup(num_possible_cpus(), upa);
|
| 3222 | if (WARN_ON(ai->groups[0].nr_units != nr_g0_units)) {
|
| 3223 | pcpu_free_alloc_info(ai);
|
| 3224 | return -EINVAL;
|
| 3225 | }
|
| 3226 |
|
| 3227 | unit_pages = ai->unit_size >> PAGE_SHIFT;
|
| 3228 |
|
| 3229 |
|
| 3230 | pages_size = PFN_ALIGN(unit_pages * num_possible_cpus() *
|
| 3231 | sizeof(pages[0]));
|
| 3232 | pages = memblock_alloc_or_panic(pages_size, SMP_CACHE_BYTES);
|
| 3233 |
|
| 3234 |
|
| 3235 | j = 0;
|
| 3236 | for (unit = 0; unit < num_possible_cpus(); unit++) {
|
| 3237 | unsigned int cpu = ai->groups[0].cpu_map[unit];
|
| 3238 | for (i = 0; i < unit_pages; i++) {
|
| 3239 | void *ptr;
|
| 3240 |
|
| 3241 | ptr = pcpu_fc_alloc(cpu, PAGE_SIZE, PAGE_SIZE, cpu_to_nd_fn);
|
| 3242 | if (!ptr) {
|
| 3243 | pr_warn("failed to allocate %s page for cpu%u\n",
|
| 3244 | psize_str, cpu);
|
| 3245 | goto enomem;
|
| 3246 | }
|
| 3247 |
|
| 3248 | kmemleak_ignore_phys(__pa(ptr));
|
| 3249 | pages[j++] = virt_to_page(ptr);
|
| 3250 | }
|
| 3251 | }
|
| 3252 |
|
| 3253 |
|
| 3254 | vm.flags = VM_ALLOC;
|
| 3255 | vm.size = num_possible_cpus() * ai->unit_size;
|
| 3256 | vm_area_register_early(&vm, PAGE_SIZE);
|
| 3257 |
|
| 3258 | for (unit = 0; unit < num_possible_cpus(); unit++) {
|
| 3259 | unsigned long unit_addr =
|
| 3260 | (unsigned long)vm.addr + unit * ai->unit_size;
|
| 3261 |
|
| 3262 | for (i = 0; i < unit_pages; i++)
|
| 3263 | pcpu_populate_pte(unit_addr + (i << PAGE_SHIFT));
|
| 3264 |
|
| 3265 |
|
| 3266 | rc = __pcpu_map_pages(unit_addr, &pages[unit * unit_pages],
|
| 3267 | unit_pages, GFP_KERNEL);
|
| 3268 | if (rc < 0)
|
| 3269 | panic("failed to map percpu area, err=%d\n", rc);
|
| 3270 |
|
| 3271 | flush_cache_vmap_early(unit_addr, unit_addr + ai->unit_size);
|
| 3272 |
|
| 3273 |
|
| 3274 | memcpy((void *)unit_addr, __per_cpu_start, ai->static_size);
|
| 3275 | }
|
| 3276 |
|
| 3277 |
|
| 3278 | pr_info("%d %s pages/cpu s%zu r%zu d%zu\n",
|
| 3279 | unit_pages, psize_str, ai->static_size,
|
| 3280 | ai->reserved_size, ai->dyn_size);
|
| 3281 |
|
| 3282 | pcpu_setup_first_chunk(ai, vm.addr);
|
| 3283 | goto out_free_ar;
|
| 3284 |
|
| 3285 | enomem:
|
| 3286 | while (--j >= 0)
|
| 3287 | pcpu_fc_free(page_address(pages[j]), PAGE_SIZE);
|
| 3288 | rc = -ENOMEM;
|
| 3289 | out_free_ar:
|
| 3290 | memblock_free(pages, pages_size);
|
| 3291 | pcpu_free_alloc_info(ai);
|
| 3292 | return rc;
|
| 3293 | }
|
| 3294 | #endif
|
| 3295 |
|
| 3296 | #ifndef CONFIG_HAVE_SETUP_PER_CPU_AREA
|
| 3297 | |
| 3298 | * Generic SMP percpu area setup.
|
| 3299 | *
|
| 3300 | * The embedding helper is used because its behavior closely resembles
|
| 3301 | * the original non-dynamic generic percpu area setup. This is
|
| 3302 | * important because many archs have addressing restrictions and might
|
| 3303 | * fail if the percpu area is located far away from the previous
|
| 3304 | * location. As an added bonus, in non-NUMA cases, embedding is
|
| 3305 | * generally a good idea TLB-wise because percpu area can piggy back
|
| 3306 | * on the physical linear memory mapping which uses large page
|
| 3307 | * mappings on applicable archs.
|
| 3308 |
|
| 3309 | unsigned long __per_cpu_offset[NR_CPUS] __read_mostly;
|
| 3310 | EXPORT_SYMBOL(__per_cpu_offset);
|
| 3311 |
|
| 3312 | void __init setup_per_cpu_areas(void)
|
| 3313 | {
|
| 3314 | unsigned long delta;
|
| 3315 | unsigned int cpu;
|
| 3316 | int rc;
|
| 3317 |
|
| 3318 | |
| 3319 | * Always reserve area for module percpu variables. That's
|
| 3320 | * what the legacy allocator did.
|
| 3321 |
|
| 3322 | rc = pcpu_embed_first_chunk(PERCPU_MODULE_RESERVE, PERCPU_DYNAMIC_RESERVE,
|
| 3323 | PAGE_SIZE, NULL, NULL);
|
| 3324 | if (rc < 0)
|
| 3325 | panic("Failed to initialize percpu areas.");
|
| 3326 |
|
| 3327 | delta = (unsigned long)pcpu_base_addr - (unsigned long)__per_cpu_start;
|
| 3328 | for_each_possible_cpu(cpu)
|
| 3329 | __per_cpu_offset[cpu] = delta + pcpu_unit_offsets[cpu];
|
| 3330 | }
|
| 3331 | #endif
|
| 3332 |
|
| 3333 | #else
|
| 3334 |
|
| 3335 | |
| 3336 | * UP percpu area setup.
|
| 3337 | *
|
| 3338 | * UP always uses km-based percpu allocator with identity mapping.
|
| 3339 | * Static percpu variables are indistinguishable from the usual static
|
| 3340 | * variables and don't require any special preparation.
|
| 3341 |
|
| 3342 | void __init setup_per_cpu_areas(void)
|
| 3343 | {
|
| 3344 | const size_t unit_size =
|
| 3345 | roundup_pow_of_two(max_t(size_t, PCPU_MIN_UNIT_SIZE,
|
| 3346 | PERCPU_DYNAMIC_RESERVE));
|
| 3347 | struct pcpu_alloc_info *ai;
|
| 3348 | void *fc;
|
| 3349 |
|
| 3350 | ai = pcpu_alloc_alloc_info(1, 1);
|
| 3351 | fc = memblock_alloc_from(unit_size, PAGE_SIZE, __pa(MAX_DMA_ADDRESS));
|
| 3352 | if (!ai || !fc)
|
| 3353 | panic("Failed to allocate memory for percpu areas.");
|
| 3354 |
|
| 3355 | kmemleak_ignore_phys(__pa(fc));
|
| 3356 |
|
| 3357 | ai->dyn_size = unit_size;
|
| 3358 | ai->unit_size = unit_size;
|
| 3359 | ai->atom_size = unit_size;
|
| 3360 | ai->alloc_size = unit_size;
|
| 3361 | ai->groups[0].nr_units = 1;
|
| 3362 | ai->groups[0].cpu_map[0] = 0;
|
| 3363 |
|
| 3364 | pcpu_setup_first_chunk(ai, fc);
|
| 3365 | pcpu_free_alloc_info(ai);
|
| 3366 | }
|
| 3367 |
|
| 3368 | #endif
|
| 3369 |
|
| 3370 | |
| 3371 | * pcpu_nr_pages - calculate total number of populated backing pages
|
| 3372 | *
|
| 3373 | * This reflects the number of pages populated to back chunks. Metadata is
|
| 3374 | * excluded in the number exposed in meminfo as the number of backing pages
|
| 3375 | * scales with the number of cpus and can quickly outweigh the memory used for
|
| 3376 | * metadata. It also keeps this calculation nice and simple.
|
| 3377 | *
|
| 3378 | * RETURNS:
|
| 3379 | * Total number of populated backing pages in use by the allocator.
|
| 3380 |
|
| 3381 | unsigned long pcpu_nr_pages(void)
|
| 3382 | {
|
| 3383 | return data_race(READ_ONCE(pcpu_nr_populated)) * pcpu_nr_units;
|
| 3384 | }
|
| 3385 |
|
| 3386 | |
| 3387 | * Percpu allocator is initialized early during boot when neither slab or
|
| 3388 | * workqueue is available. Plug async management until everything is up
|
| 3389 | * and running.
|
| 3390 |
|
| 3391 | static int __init percpu_enable_async(void)
|
| 3392 | {
|
| 3393 | pcpu_async_enabled = true;
|
| 3394 | return 0;
|
| 3395 | }
|
| 3396 | subsys_initcall(percpu_enable_async);
|