]>
Commit | Line | Data |
---|---|---|
60863c0d MF |
1 | /* |
2 | * Common EFI memory map functions. | |
3 | */ | |
4 | ||
5 | #define pr_fmt(fmt) "efi: " fmt | |
6 | ||
7 | #include <linux/init.h> | |
8 | #include <linux/kernel.h> | |
9 | #include <linux/efi.h> | |
10 | #include <linux/io.h> | |
11 | #include <asm/early_ioremap.h> | |
20b1e22d NS |
12 | #include <linux/memblock.h> |
13 | #include <linux/slab.h> | |
14 | ||
15 | static phys_addr_t __init __efi_memmap_alloc_early(unsigned long size) | |
16 | { | |
17 | return memblock_alloc(size, 0); | |
18 | } | |
19 | ||
20 | static phys_addr_t __init __efi_memmap_alloc_late(unsigned long size) | |
21 | { | |
22 | unsigned int order = get_order(size); | |
23 | struct page *p = alloc_pages(GFP_KERNEL, order); | |
24 | ||
25 | if (!p) | |
26 | return 0; | |
27 | ||
28 | return PFN_PHYS(page_to_pfn(p)); | |
29 | } | |
30 | ||
31 | /** | |
32 | * efi_memmap_alloc - Allocate memory for the EFI memory map | |
33 | * @num_entries: Number of entries in the allocated map. | |
34 | * | |
35 | * Depending on whether mm_init() has already been invoked or not, | |
36 | * either memblock or "normal" page allocation is used. | |
37 | * | |
38 | * Returns the physical address of the allocated memory map on | |
39 | * success, zero on failure. | |
40 | */ | |
41 | phys_addr_t __init efi_memmap_alloc(unsigned int num_entries) | |
42 | { | |
43 | unsigned long size = num_entries * efi.memmap.desc_size; | |
44 | ||
45 | if (slab_is_available()) | |
46 | return __efi_memmap_alloc_late(size); | |
47 | ||
48 | return __efi_memmap_alloc_early(size); | |
49 | } | |
60863c0d MF |
50 | |
51 | /** | |
52 | * __efi_memmap_init - Common code for mapping the EFI memory map | |
53 | * @data: EFI memory map data | |
54 | * @late: Use early or late mapping function? | |
55 | * | |
56 | * This function takes care of figuring out which function to use to | |
57 | * map the EFI memory map in efi.memmap based on how far into the boot | |
58 | * we are. | |
59 | * | |
60 | * During bootup @late should be %false since we only have access to | |
61 | * the early_memremap*() functions as the vmalloc space isn't setup. | |
62 | * Once the kernel is fully booted we can fallback to the more robust | |
63 | * memremap*() API. | |
64 | * | |
65 | * Returns zero on success, a negative error code on failure. | |
66 | */ | |
67 | static int __init | |
68 | __efi_memmap_init(struct efi_memory_map_data *data, bool late) | |
69 | { | |
70 | struct efi_memory_map map; | |
71 | phys_addr_t phys_map; | |
72 | ||
73 | if (efi_enabled(EFI_PARAVIRT)) | |
74 | return 0; | |
75 | ||
76 | phys_map = data->phys_map; | |
77 | ||
78 | if (late) | |
79 | map.map = memremap(phys_map, data->size, MEMREMAP_WB); | |
80 | else | |
81 | map.map = early_memremap(phys_map, data->size); | |
82 | ||
83 | if (!map.map) { | |
84 | pr_err("Could not map the memory map!\n"); | |
85 | return -ENOMEM; | |
86 | } | |
87 | ||
88 | map.phys_map = data->phys_map; | |
89 | map.nr_map = data->size / data->desc_size; | |
90 | map.map_end = map.map + data->size; | |
91 | ||
92 | map.desc_version = data->desc_version; | |
93 | map.desc_size = data->desc_size; | |
94 | map.late = late; | |
95 | ||
96 | set_bit(EFI_MEMMAP, &efi.flags); | |
97 | ||
98 | efi.memmap = map; | |
99 | ||
100 | return 0; | |
101 | } | |
102 | ||
103 | /** | |
104 | * efi_memmap_init_early - Map the EFI memory map data structure | |
105 | * @data: EFI memory map data | |
106 | * | |
107 | * Use early_memremap() to map the passed in EFI memory map and assign | |
108 | * it to efi.memmap. | |
109 | */ | |
110 | int __init efi_memmap_init_early(struct efi_memory_map_data *data) | |
111 | { | |
112 | /* Cannot go backwards */ | |
113 | WARN_ON(efi.memmap.late); | |
114 | ||
115 | return __efi_memmap_init(data, false); | |
116 | } | |
117 | ||
118 | void __init efi_memmap_unmap(void) | |
119 | { | |
120 | if (!efi.memmap.late) { | |
121 | unsigned long size; | |
122 | ||
123 | size = efi.memmap.desc_size * efi.memmap.nr_map; | |
124 | early_memunmap(efi.memmap.map, size); | |
125 | } else { | |
126 | memunmap(efi.memmap.map); | |
127 | } | |
128 | ||
129 | efi.memmap.map = NULL; | |
130 | clear_bit(EFI_MEMMAP, &efi.flags); | |
131 | } | |
132 | ||
133 | /** | |
134 | * efi_memmap_init_late - Map efi.memmap with memremap() | |
135 | * @phys_addr: Physical address of the new EFI memory map | |
136 | * @size: Size in bytes of the new EFI memory map | |
137 | * | |
138 | * Setup a mapping of the EFI memory map using ioremap_cache(). This | |
139 | * function should only be called once the vmalloc space has been | |
140 | * setup and is therefore not suitable for calling during early EFI | |
141 | * initialise, e.g. in efi_init(). Additionally, it expects | |
142 | * efi_memmap_init_early() to have already been called. | |
143 | * | |
144 | * The reason there are two EFI memmap initialisation | |
145 | * (efi_memmap_init_early() and this late version) is because the | |
146 | * early EFI memmap should be explicitly unmapped once EFI | |
147 | * initialisation is complete as the fixmap space used to map the EFI | |
148 | * memmap (via early_memremap()) is a scarce resource. | |
149 | * | |
150 | * This late mapping is intended to persist for the duration of | |
151 | * runtime so that things like efi_mem_desc_lookup() and | |
152 | * efi_mem_attributes() always work. | |
153 | * | |
154 | * Returns zero on success, a negative error code on failure. | |
155 | */ | |
156 | int __init efi_memmap_init_late(phys_addr_t addr, unsigned long size) | |
157 | { | |
158 | struct efi_memory_map_data data = { | |
159 | .phys_map = addr, | |
160 | .size = size, | |
161 | }; | |
162 | ||
163 | /* Did we forget to unmap the early EFI memmap? */ | |
164 | WARN_ON(efi.memmap.map); | |
165 | ||
166 | /* Were we already called? */ | |
167 | WARN_ON(efi.memmap.late); | |
168 | ||
169 | /* | |
170 | * It makes no sense to allow callers to register different | |
171 | * values for the following fields. Copy them out of the | |
172 | * existing early EFI memmap. | |
173 | */ | |
174 | data.desc_version = efi.memmap.desc_version; | |
175 | data.desc_size = efi.memmap.desc_size; | |
176 | ||
177 | return __efi_memmap_init(&data, true); | |
178 | } | |
179 | ||
c45f4da3 MF |
180 | /** |
181 | * efi_memmap_install - Install a new EFI memory map in efi.memmap | |
182 | * @addr: Physical address of the memory map | |
183 | * @nr_map: Number of entries in the memory map | |
184 | * | |
185 | * Unlike efi_memmap_init_*(), this function does not allow the caller | |
186 | * to switch from early to late mappings. It simply uses the existing | |
187 | * mapping function and installs the new memmap. | |
188 | * | |
189 | * Returns zero on success, a negative error code on failure. | |
190 | */ | |
191 | int __init efi_memmap_install(phys_addr_t addr, unsigned int nr_map) | |
192 | { | |
193 | struct efi_memory_map_data data; | |
194 | ||
195 | efi_memmap_unmap(); | |
196 | ||
197 | data.phys_map = addr; | |
198 | data.size = efi.memmap.desc_size * nr_map; | |
199 | data.desc_version = efi.memmap.desc_version; | |
200 | data.desc_size = efi.memmap.desc_size; | |
201 | ||
202 | return __efi_memmap_init(&data, efi.memmap.late); | |
203 | } | |
204 | ||
60863c0d MF |
205 | /** |
206 | * efi_memmap_split_count - Count number of additional EFI memmap entries | |
207 | * @md: EFI memory descriptor to split | |
208 | * @range: Address range (start, end) to split around | |
209 | * | |
210 | * Returns the number of additional EFI memmap entries required to | |
211 | * accomodate @range. | |
212 | */ | |
213 | int __init efi_memmap_split_count(efi_memory_desc_t *md, struct range *range) | |
214 | { | |
215 | u64 m_start, m_end; | |
216 | u64 start, end; | |
217 | int count = 0; | |
218 | ||
219 | start = md->phys_addr; | |
220 | end = start + (md->num_pages << EFI_PAGE_SHIFT) - 1; | |
221 | ||
222 | /* modifying range */ | |
223 | m_start = range->start; | |
224 | m_end = range->end; | |
225 | ||
226 | if (m_start <= start) { | |
227 | /* split into 2 parts */ | |
228 | if (start < m_end && m_end < end) | |
229 | count++; | |
230 | } | |
231 | ||
232 | if (start < m_start && m_start < end) { | |
233 | /* split into 3 parts */ | |
234 | if (m_end < end) | |
235 | count += 2; | |
236 | /* split into 2 parts */ | |
237 | if (end <= m_end) | |
238 | count++; | |
239 | } | |
240 | ||
241 | return count; | |
242 | } | |
243 | ||
244 | /** | |
245 | * efi_memmap_insert - Insert a memory region in an EFI memmap | |
246 | * @old_memmap: The existing EFI memory map structure | |
247 | * @buf: Address of buffer to store new map | |
248 | * @mem: Memory map entry to insert | |
249 | * | |
250 | * It is suggested that you call efi_memmap_split_count() first | |
251 | * to see how large @buf needs to be. | |
252 | */ | |
253 | void __init efi_memmap_insert(struct efi_memory_map *old_memmap, void *buf, | |
254 | struct efi_mem_range *mem) | |
255 | { | |
256 | u64 m_start, m_end, m_attr; | |
257 | efi_memory_desc_t *md; | |
258 | u64 start, end; | |
259 | void *old, *new; | |
260 | ||
261 | /* modifying range */ | |
262 | m_start = mem->range.start; | |
263 | m_end = mem->range.end; | |
264 | m_attr = mem->attribute; | |
265 | ||
92dc3350 MF |
266 | /* |
267 | * The EFI memory map deals with regions in EFI_PAGE_SIZE | |
268 | * units. Ensure that the region described by 'mem' is aligned | |
269 | * correctly. | |
270 | */ | |
271 | if (!IS_ALIGNED(m_start, EFI_PAGE_SIZE) || | |
272 | !IS_ALIGNED(m_end + 1, EFI_PAGE_SIZE)) { | |
273 | WARN_ON(1); | |
274 | return; | |
275 | } | |
276 | ||
60863c0d MF |
277 | for (old = old_memmap->map, new = buf; |
278 | old < old_memmap->map_end; | |
279 | old += old_memmap->desc_size, new += old_memmap->desc_size) { | |
280 | ||
281 | /* copy original EFI memory descriptor */ | |
282 | memcpy(new, old, old_memmap->desc_size); | |
283 | md = new; | |
284 | start = md->phys_addr; | |
285 | end = md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1; | |
286 | ||
287 | if (m_start <= start && end <= m_end) | |
288 | md->attribute |= m_attr; | |
289 | ||
290 | if (m_start <= start && | |
291 | (start < m_end && m_end < end)) { | |
292 | /* first part */ | |
293 | md->attribute |= m_attr; | |
294 | md->num_pages = (m_end - md->phys_addr + 1) >> | |
295 | EFI_PAGE_SHIFT; | |
296 | /* latter part */ | |
297 | new += old_memmap->desc_size; | |
298 | memcpy(new, old, old_memmap->desc_size); | |
299 | md = new; | |
300 | md->phys_addr = m_end + 1; | |
301 | md->num_pages = (end - md->phys_addr + 1) >> | |
302 | EFI_PAGE_SHIFT; | |
303 | } | |
304 | ||
305 | if ((start < m_start && m_start < end) && m_end < end) { | |
306 | /* first part */ | |
307 | md->num_pages = (m_start - md->phys_addr) >> | |
308 | EFI_PAGE_SHIFT; | |
309 | /* middle part */ | |
310 | new += old_memmap->desc_size; | |
311 | memcpy(new, old, old_memmap->desc_size); | |
312 | md = new; | |
313 | md->attribute |= m_attr; | |
314 | md->phys_addr = m_start; | |
315 | md->num_pages = (m_end - m_start + 1) >> | |
316 | EFI_PAGE_SHIFT; | |
317 | /* last part */ | |
318 | new += old_memmap->desc_size; | |
319 | memcpy(new, old, old_memmap->desc_size); | |
320 | md = new; | |
321 | md->phys_addr = m_end + 1; | |
322 | md->num_pages = (end - m_end) >> | |
323 | EFI_PAGE_SHIFT; | |
324 | } | |
325 | ||
326 | if ((start < m_start && m_start < end) && | |
327 | (end <= m_end)) { | |
328 | /* first part */ | |
329 | md->num_pages = (m_start - md->phys_addr) >> | |
330 | EFI_PAGE_SHIFT; | |
331 | /* latter part */ | |
332 | new += old_memmap->desc_size; | |
333 | memcpy(new, old, old_memmap->desc_size); | |
334 | md = new; | |
335 | md->phys_addr = m_start; | |
336 | md->num_pages = (end - md->phys_addr + 1) >> | |
337 | EFI_PAGE_SHIFT; | |
338 | md->attribute |= m_attr; | |
339 | } | |
340 | } | |
341 | } |