-#ifdef CONFIG_NEED_PER_CPU_LPAGE_FIRST_CHUNK
-struct pcpul_ent {
- void *ptr;
- void *map_addr;
-};
-
-static size_t pcpul_size;
-static size_t pcpul_lpage_size;
-static int pcpul_nr_lpages;
-static struct pcpul_ent *pcpul_map;
-
-static bool __init pcpul_unit_to_cpu(int unit, const int *unit_map,
- unsigned int *cpup)
-{
- unsigned int cpu;
-
- for_each_possible_cpu(cpu)
- if (unit_map[cpu] == unit) {
- if (cpup)
- *cpup = cpu;
- return true;
- }
-
- return false;
-}
-
-/**
- * pcpu_lpage_first_chunk - remap the first percpu chunk using large page
- * @reserved_size: the size of reserved percpu area in bytes
- * @dyn_size: free size for dynamic allocation in bytes
- * @unit_size: unit size in bytes
- * @lpage_size: the size of a large page
- * @unit_map: cpu -> unit mapping
- * @nr_units: the number of units
- * @alloc_fn: function to allocate percpu lpage, always called with lpage_size
- * @free_fn: function to free percpu memory, @size <= lpage_size
- * @map_fn: function to map percpu lpage, always called with lpage_size
- *
- * This allocator uses large page to build and map the first chunk.
- * Unlike other helpers, the caller should always specify @dyn_size
- * and @unit_size. These parameters along with @unit_map and
- * @nr_units can be determined using pcpu_lpage_build_unit_map().
- * This two stage initialization is to allow arch code to evaluate the
- * parameters before committing to it.
- *
- * Large pages are allocated as directed by @unit_map and other
- * parameters and mapped to vmalloc space. Unused holes are returned
- * to the page allocator. Note that these holes end up being actively
- * mapped twice - once to the physical mapping and to the vmalloc area
- * for the first percpu chunk. Depending on architecture, this might
- * cause problem when changing page attributes of the returned area.
- * These double mapped areas can be detected using
- * pcpu_lpage_remapped().
- *
- * RETURNS:
- * The determined pcpu_unit_size which can be used to initialize
- * percpu access on success, -errno on failure.
- */
-ssize_t __init pcpu_lpage_first_chunk(size_t reserved_size, size_t dyn_size,
- size_t unit_size, size_t lpage_size,
- const int *unit_map, int nr_units,
- pcpu_fc_alloc_fn_t alloc_fn,
- pcpu_fc_free_fn_t free_fn,
- pcpu_fc_map_fn_t map_fn)
-{
- static struct vm_struct vm;
- const size_t static_size = __per_cpu_end - __per_cpu_start;
- size_t chunk_size = unit_size * nr_units;
- size_t map_size;
- unsigned int cpu;
- ssize_t ret;
- int i, j, unit;
-
- pcpul_lpage_dump_cfg(KERN_DEBUG, static_size, reserved_size, dyn_size,
- unit_size, lpage_size, unit_map, nr_units);
-
- BUG_ON(chunk_size % lpage_size);
-
- pcpul_size = static_size + reserved_size + dyn_size;
- pcpul_lpage_size = lpage_size;
- pcpul_nr_lpages = chunk_size / lpage_size;
-
- /* allocate pointer array and alloc large pages */
- map_size = pcpul_nr_lpages * sizeof(pcpul_map[0]);
- pcpul_map = alloc_bootmem(map_size);
-
- /* allocate all pages */
- for (i = 0; i < pcpul_nr_lpages; i++) {
- size_t offset = i * lpage_size;
- int first_unit = offset / unit_size;
- int last_unit = (offset + lpage_size - 1) / unit_size;
- void *ptr;
-
- /* find out which cpu is mapped to this unit */
- for (unit = first_unit; unit <= last_unit; unit++)
- if (pcpul_unit_to_cpu(unit, unit_map, &cpu))
- goto found;
- continue;
- found:
- ptr = alloc_fn(cpu, lpage_size, lpage_size);
- if (!ptr) {
- pr_warning("PERCPU: failed to allocate large page "
- "for cpu%u\n", cpu);
- goto enomem;
- }
-
- pcpul_map[i].ptr = ptr;
- }
-
- /* return unused holes */
- for (unit = 0; unit < nr_units; unit++) {
- size_t start = unit * unit_size;
- size_t end = start + unit_size;
- size_t off, next;
-
- /* don't free used part of occupied unit */
- if (pcpul_unit_to_cpu(unit, unit_map, NULL))
- start += pcpul_size;
-
- /* unit can span more than one page, punch the holes */
- for (off = start; off < end; off = next) {
- void *ptr = pcpul_map[off / lpage_size].ptr;
- next = min(roundup(off + 1, lpage_size), end);
- if (ptr)
- free_fn(ptr + off % lpage_size, next - off);
- }
- }
-
- /* allocate address, map and copy */
- vm.flags = VM_ALLOC;
- vm.size = chunk_size;
- vm_area_register_early(&vm, unit_size);
-
- for (i = 0; i < pcpul_nr_lpages; i++) {
- if (!pcpul_map[i].ptr)
- continue;
- pcpul_map[i].map_addr = vm.addr + i * lpage_size;
- map_fn(pcpul_map[i].ptr, lpage_size, pcpul_map[i].map_addr);
- }
-
- for_each_possible_cpu(cpu)
- memcpy(vm.addr + unit_map[cpu] * unit_size, __per_cpu_load,
- static_size);
-
- /* we're ready, commit */
- pr_info("PERCPU: large pages @%p s%zu r%zu d%zu u%zu\n",
- vm.addr, static_size, reserved_size, dyn_size, unit_size);
-
- ret = pcpu_setup_first_chunk(static_size, reserved_size, dyn_size,
- unit_size, vm.addr, unit_map);
-
- /*
- * Sort pcpul_map array for pcpu_lpage_remapped(). Unmapped
- * lpages are pushed to the end and trimmed.
- */
- for (i = 0; i < pcpul_nr_lpages - 1; i++)
- for (j = i + 1; j < pcpul_nr_lpages; j++) {
- struct pcpul_ent tmp;
-
- if (!pcpul_map[j].ptr)
- continue;
- if (pcpul_map[i].ptr &&
- pcpul_map[i].ptr < pcpul_map[j].ptr)
- continue;
-
- tmp = pcpul_map[i];
- pcpul_map[i] = pcpul_map[j];
- pcpul_map[j] = tmp;
- }
-
- while (pcpul_nr_lpages && !pcpul_map[pcpul_nr_lpages - 1].ptr)
- pcpul_nr_lpages--;
-
- return ret;
-
-enomem:
- for (i = 0; i < pcpul_nr_lpages; i++)
- if (pcpul_map[i].ptr)
- free_fn(pcpul_map[i].ptr, lpage_size);
- free_bootmem(__pa(pcpul_map), map_size);
- return -ENOMEM;
-}
-
-/**
- * pcpu_lpage_remapped - determine whether a kaddr is in pcpul recycled area
- * @kaddr: the kernel address in question
- *
- * Determine whether @kaddr falls in the pcpul recycled area. This is
- * used by pageattr to detect VM aliases and break up the pcpu large
- * page mapping such that the same physical page is not mapped under
- * different attributes.
- *
- * The recycled area is always at the tail of a partially used large
- * page.
- *
- * RETURNS:
- * Address of corresponding remapped pcpu address if match is found;
- * otherwise, NULL.
- */
-void *pcpu_lpage_remapped(void *kaddr)
-{
- unsigned long lpage_mask = pcpul_lpage_size - 1;
- void *lpage_addr = (void *)((unsigned long)kaddr & ~lpage_mask);
- unsigned long offset = (unsigned long)kaddr & lpage_mask;
- int left = 0, right = pcpul_nr_lpages - 1;
- int pos;
-
- /* pcpul in use at all? */
- if (!pcpul_map)
- return NULL;
-
- /* okay, perform binary search */
- while (left <= right) {
- pos = (left + right) / 2;
-
- if (pcpul_map[pos].ptr < lpage_addr)
- left = pos + 1;
- else if (pcpul_map[pos].ptr > lpage_addr)
- right = pos - 1;
- else
- return pcpul_map[pos].map_addr + offset;
- }
-
- return NULL;
-}
-#endif /* CONFIG_NEED_PER_CPU_LPAGE_FIRST_CHUNK */
-