Lines Matching +full:memory +full:- +full:mapping
2 High Memory Handling
9 What Is High Memory?
12 High memory (highmem) is used when the size of physical memory approaches or
13 exceeds the maximum size of virtual memory. At that point it becomes
14 impossible for the kernel to keep all of the available physical memory mapped
16 the pieces of physical memory that it wants to access.
18 The part of (physical) memory not covered by a permanent mapping is what we
24 kernel entry/exit. This means the available virtual memory space (4GiB on
30 +--------+ 0xffffffff
32 +--------+ 0xc0000000
36 +--------+ 0x00000000
38 This means that the kernel can at most map 1GiB of physical memory at any one
39 time, but because we need virtual address space for other things - including
40 temporary maps to access the rest of the physical memory - the actual direct
54 * kmap_local_page(), kmap_local_folio() - These functions are used to create
64 These mappings are thread-local and CPU-local, meaning that the mapping
66 CPU while the mapping is active. Although preemption is never disabled by
68 CPU-hotplug until the mapping is disposed.
71 in which the local mapping is acquired does not allow it for other reasons.
81 On CONFIG_HIGHMEM=n kernels and for low memory pages they return the
82 virtual address of the direct mapping. Only real highmem pages are
95 therefore try to design their code to avoid the use of kmap() by mapping
107 NOTE: Conversions to kmap_local_page() must take care to follow the mapping
116 This permits a very short duration mapping of a single page. Since the
117 mapping is restricted to the CPU that issued it, it performs well, but
125 Each call of kmap_atomic() in the kernel creates a non-preemptible section
133 NOTE: Conversions to kmap_local_page() must take care to follow the mapping
135 make sure that the kernel virtual memory pointer is only valid in the thread
140 This should be used to make short duration mapping of a single page with no
141 restrictions on preemption or migration. It comes with an overhead as mapping
143 mapping is no longer needed, the address that the page was mapped to must be
146 Mapping changes must be propagated across all the CPUs. kmap() also
148 block when the mapping space is fully utilized until a slot becomes
151 All the above work is necessary if a mapping must last for a relatively
152 long time but the bulk of high-memory mappings in the kernel are
153 short-lived and only used in one place. This means that the cost of
159 On 64-bit systems, calls to kmap_local_page(), kmap_atomic() and kmap() have
160 no real work to do because a 64-bit address space is more than sufficient to
161 address all the physical memory whose pages are permanently mapped.
163 * vmap(). This can be used to make a long duration mapping of multiple
174 If CONFIG_HIGHMEM is not set, then the kernel will try and create a mapping
187 of RAM into your 32-bit machine. This has a number of consequences:
189 * Linux needs a page-frame structure for each page in the system and the
190 pageframes need to live in the permanent mapping, which means:
192 * you can have 896M/sizeof(struct page) page-frames at most; with struct
193 page being 32-bytes that would end up being something in the order of 112G
195 page-frames in that memory...
197 * PAE makes your page tables larger - which slows the system down as more
202 The general recommendation is that you don't use more than 8GiB on a 32-bit
203 machine - although more might work for you and your workload, you're pretty
204 much on your own - don't expect kernel developers to really care much if things
211 .. kernel-doc:: include/linux/highmem.h
212 .. kernel-doc:: mm/highmem.c
213 .. kernel-doc:: include/linux/highmem-internal.h