1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Copyright (C) 2015 Synopsys, Inc. (www.synopsys.com) 4 */ 5 6#include <linux/memblock.h> 7#include <linux/export.h> 8#include <linux/highmem.h> 9#include <linux/pgtable.h> 10#include <asm/processor.h> 11#include <asm/pgalloc.h> 12#include <asm/tlbflush.h> 13 14/* 15 * HIGHMEM API: 16 * 17 * kmap() API provides sleep semantics hence referred to as "permanent maps" 18 * It allows mapping LAST_PKMAP pages, using @last_pkmap_nr as the cursor 19 * for book-keeping 20 * 21 * kmap_atomic() can't sleep (calls pagefault_disable()), thus it provides 22 * shortlived ala "temporary mappings" which historically were implemented as 23 * fixmaps (compile time addr etc). Their book-keeping is done per cpu. 24 * 25 * Both these facts combined (preemption disabled and per-cpu allocation) 26 * means the total number of concurrent fixmaps will be limited to max 27 * such allocations in a single control path. Thus KM_TYPE_NR (another 28 * historic relic) is a small'ish number which caps max percpu fixmaps 29 * 30 * ARC HIGHMEM Details 31 * 32 * - the kernel vaddr space from 0x7z to 0x8z (currently used by vmalloc/module) 33 * is now shared between vmalloc and kmap (non overlapping though) 34 * 35 * - Both fixmap/pkmap use a dedicated page table each, hooked up to swapper PGD 36 * This means each only has 1 PGDIR_SIZE worth of kvaddr mappings, which means 37 * 2M of kvaddr space for typical config (8K page and 11:8:13 traversal split) 38 * 39 * - fixmap anyhow needs a limited number of mappings. So 2M kvaddr == 256 PTE 40 * slots across NR_CPUS would be more than sufficient (generic code defines 41 * KM_TYPE_NR as 20). 42 * 43 * - pkmap being preemptible, in theory could do with more than 256 concurrent 44 * mappings. However, generic pkmap code: map_new_virtual(), doesn't traverse 45 * the PGD and only works with a single page table @pkmap_page_table, hence 46 * sets the limit 47 */ 48 49extern pte_t * pkmap_page_table; 50static pte_t * fixmap_page_table; 51 52void *kmap_atomic_high_prot(struct page *page, pgprot_t prot) 53{ 54 int idx, cpu_idx; 55 unsigned long vaddr; 56 57 cpu_idx = kmap_atomic_idx_push(); 58 idx = cpu_idx + KM_TYPE_NR * smp_processor_id(); 59 vaddr = FIXMAP_ADDR(idx); 60 61 set_pte_at(&init_mm, vaddr, fixmap_page_table + idx, 62 mk_pte(page, prot)); 63 64 return (void *)vaddr; 65} 66EXPORT_SYMBOL(kmap_atomic_high_prot); 67 68void kunmap_atomic_high(void *kv) 69{ 70 unsigned long kvaddr = (unsigned long)kv; 71 72 if (kvaddr >= FIXMAP_BASE && kvaddr < (FIXMAP_BASE + FIXMAP_SIZE)) { 73 74 /* 75 * Because preemption is disabled, this vaddr can be associated 76 * with the current allocated index. 77 * But in case of multiple live kmap_atomic(), it still relies on 78 * callers to unmap in right order. 79 */ 80 int cpu_idx = kmap_atomic_idx(); 81 int idx = cpu_idx + KM_TYPE_NR * smp_processor_id(); 82 83 WARN_ON(kvaddr != FIXMAP_ADDR(idx)); 84 85 pte_clear(&init_mm, kvaddr, fixmap_page_table + idx); 86 local_flush_tlb_kernel_range(kvaddr, kvaddr + PAGE_SIZE); 87 88 kmap_atomic_idx_pop(); 89 } 90} 91EXPORT_SYMBOL(kunmap_atomic_high); 92 93static noinline pte_t * __init alloc_kmap_pgtable(unsigned long kvaddr) 94{ 95 pmd_t *pmd_k = pmd_off_k(kvaddr); 96 pte_t *pte_k; 97 98 pte_k = (pte_t *)memblock_alloc_low(PAGE_SIZE, PAGE_SIZE); 99 if (!pte_k) 100 panic("%s: Failed to allocate %lu bytes align=0x%lx\n", 101 __func__, PAGE_SIZE, PAGE_SIZE); 102 103 pmd_populate_kernel(&init_mm, pmd_k, pte_k); 104 return pte_k; 105} 106 107void __init kmap_init(void) 108{ 109 /* Due to recursive include hell, we can't do this in processor.h */ 110 BUILD_BUG_ON(PAGE_OFFSET < (VMALLOC_END + FIXMAP_SIZE + PKMAP_SIZE)); 111 112 BUILD_BUG_ON(KM_TYPE_NR > PTRS_PER_PTE); 113 pkmap_page_table = alloc_kmap_pgtable(PKMAP_BASE); 114 115 BUILD_BUG_ON(LAST_PKMAP > PTRS_PER_PTE); 116 fixmap_page_table = alloc_kmap_pgtable(FIXMAP_BASE); 117} 118