projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'efi-urgent' of git://git.kernel.org/pub/scm/linux/kernel/git/mfleming...
[deliverable/linux.git] / arch / arm / mm / init.c
1 /*
2 * linux/arch/arm/mm/init.c
3 *
4 * Copyright (C) 1995-2005 Russell King
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
10 #include <linux/kernel.h>
11 #include <linux/errno.h>
12 #include <linux/swap.h>
13 #include <linux/init.h>
14 #include <linux/bootmem.h>
15 #include <linux/mman.h>
16 #include <linux/export.h>
17 #include <linux/nodemask.h>
18 #include <linux/initrd.h>
19 #include <linux/of_fdt.h>
20 #include <linux/highmem.h>
21 #include <linux/gfp.h>
22 #include <linux/memblock.h>
23 #include <linux/dma-contiguous.h>
24 #include <linux/sizes.h>
25
26 #include <asm/cp15.h>
27 #include <asm/mach-types.h>
28 #include <asm/memblock.h>
29 #include <asm/prom.h>
30 #include <asm/sections.h>
31 #include <asm/setup.h>
32 #include <asm/system_info.h>
33 #include <asm/tlb.h>
34 #include <asm/fixmap.h>
35
36 #include <asm/mach/arch.h>
37 #include <asm/mach/map.h>
38
39 #include "mm.h"
40
41 #ifdef CONFIG_CPU_CP15_MMU
42 unsigned long __init __clear_cr(unsigned long mask)
43 {
44 cr_alignment = cr_alignment & ~mask;
45 return cr_alignment;
46 }
47 #endif
48
49 static phys_addr_t phys_initrd_start __initdata = 0;
50 static unsigned long phys_initrd_size __initdata = 0;
51
52 static int __init early_initrd(char *p)
53 {
54 phys_addr_t start;
55 unsigned long size;
56 char *endp;
57
58 start = memparse(p, &endp);
59 if (*endp == ',') {
60 size = memparse(endp + 1, NULL);
61
62 phys_initrd_start = start;
63 phys_initrd_size = size;
64 }
65 return 0;
66 }
67 early_param("initrd", early_initrd);
68
69 static int __init parse_tag_initrd(const struct tag *tag)
70 {
71 pr_warn("ATAG_INITRD is deprecated; "
72 "please update your bootloader.\n");
73 phys_initrd_start = __virt_to_phys(tag->u.initrd.start);
74 phys_initrd_size = tag->u.initrd.size;
75 return 0;
76 }
77
78 __tagtable(ATAG_INITRD, parse_tag_initrd);
79
80 static int __init parse_tag_initrd2(const struct tag *tag)
81 {
82 phys_initrd_start = tag->u.initrd.start;
83 phys_initrd_size = tag->u.initrd.size;
84 return 0;
85 }
86
87 __tagtable(ATAG_INITRD2, parse_tag_initrd2);
88
89 /*
90 * This keeps memory configuration data used by a couple memory
91 * initialization functions, as well as show_mem() for the skipping
92 * of holes in the memory map. It is populated by arm_add_memory().
93 */
94 void show_mem(unsigned int filter)
95 {
96 int free = 0, total = 0, reserved = 0;
97 int shared = 0, cached = 0, slab = 0;
98 struct memblock_region *reg;
99
100 printk("Mem-info:\n");
101 show_free_areas(filter);
102
103 for_each_memblock (memory, reg) {
104 unsigned int pfn1, pfn2;
105 struct page *page, *end;
106
107 pfn1 = memblock_region_memory_base_pfn(reg);
108 pfn2 = memblock_region_memory_end_pfn(reg);
109
110 page = pfn_to_page(pfn1);
111 end = pfn_to_page(pfn2 - 1) + 1;
112
113 do {
114 total++;
115 if (PageReserved(page))
116 reserved++;
117 else if (PageSwapCache(page))
118 cached++;
119 else if (PageSlab(page))
120 slab++;
121 else if (!page_count(page))
122 free++;
123 else
124 shared += page_count(page) - 1;
125 pfn1++;
126 page = pfn_to_page(pfn1);
127 } while (pfn1 < pfn2);
128 }
129
130 printk("%d pages of RAM\n", total);
131 printk("%d free pages\n", free);
132 printk("%d reserved pages\n", reserved);
133 printk("%d slab pages\n", slab);
134 printk("%d pages shared\n", shared);
135 printk("%d pages swap cached\n", cached);
136 }
137
138 static void __init find_limits(unsigned long *min, unsigned long *max_low,
139 unsigned long *max_high)
140 {
141 *max_low = PFN_DOWN(memblock_get_current_limit());
142 *min = PFN_UP(memblock_start_of_DRAM());
143 *max_high = PFN_DOWN(memblock_end_of_DRAM());
144 }
145
146 #ifdef CONFIG_ZONE_DMA
147
148 phys_addr_t arm_dma_zone_size __read_mostly;
149 EXPORT_SYMBOL(arm_dma_zone_size);
150
151 /*
152 * The DMA mask corresponding to the maximum bus address allocatable
153 * using GFP_DMA. The default here places no restriction on DMA
154 * allocations. This must be the smallest DMA mask in the system,
155 * so a successful GFP_DMA allocation will always satisfy this.
156 */
157 phys_addr_t arm_dma_limit;
158 unsigned long arm_dma_pfn_limit;
159
160 static void __init arm_adjust_dma_zone(unsigned long *size, unsigned long *hole,
161 unsigned long dma_size)
162 {
163 if (size[0] <= dma_size)
164 return;
165
166 size[ZONE_NORMAL] = size[0] - dma_size;
167 size[ZONE_DMA] = dma_size;
168 hole[ZONE_NORMAL] = hole[0];
169 hole[ZONE_DMA] = 0;
170 }
171 #endif
172
173 void __init setup_dma_zone(const struct machine_desc *mdesc)
174 {
175 #ifdef CONFIG_ZONE_DMA
176 if (mdesc->dma_zone_size) {
177 arm_dma_zone_size = mdesc->dma_zone_size;
178 arm_dma_limit = PHYS_OFFSET + arm_dma_zone_size - 1;
179 } else
180 arm_dma_limit = 0xffffffff;
181 arm_dma_pfn_limit = arm_dma_limit >> PAGE_SHIFT;
182 #endif
183 }
184
185 static void __init zone_sizes_init(unsigned long min, unsigned long max_low,
186 unsigned long max_high)
187 {
188 unsigned long zone_size[MAX_NR_ZONES], zhole_size[MAX_NR_ZONES];
189 struct memblock_region *reg;
190
191 /*
192 * initialise the zones.
193 */
194 memset(zone_size, 0, sizeof(zone_size));
195
196 /*
197 * The memory size has already been determined. If we need
198 * to do anything fancy with the allocation of this memory
199 * to the zones, now is the time to do it.
200 */
201 zone_size[0] = max_low - min;
202 #ifdef CONFIG_HIGHMEM
203 zone_size[ZONE_HIGHMEM] = max_high - max_low;
204 #endif
205
206 /*
207 * Calculate the size of the holes.
208 * holes = node_size - sum(bank_sizes)
209 */
210 memcpy(zhole_size, zone_size, sizeof(zhole_size));
211 for_each_memblock(memory, reg) {
212 unsigned long start = memblock_region_memory_base_pfn(reg);
213 unsigned long end = memblock_region_memory_end_pfn(reg);
214
215 if (start < max_low) {
216 unsigned long low_end = min(end, max_low);
217 zhole_size[0] -= low_end - start;
218 }
219 #ifdef CONFIG_HIGHMEM
220 if (end > max_low) {
221 unsigned long high_start = max(start, max_low);
222 zhole_size[ZONE_HIGHMEM] -= end - high_start;
223 }
224 #endif
225 }
226
227 #ifdef CONFIG_ZONE_DMA
228 /*
229 * Adjust the sizes according to any special requirements for
230 * this machine type.
231 */
232 if (arm_dma_zone_size)
233 arm_adjust_dma_zone(zone_size, zhole_size,
234 arm_dma_zone_size >> PAGE_SHIFT);
235 #endif
236
237 free_area_init_node(0, zone_size, min, zhole_size);
238 }
239
240 #ifdef CONFIG_HAVE_ARCH_PFN_VALID
241 int pfn_valid(unsigned long pfn)
242 {
243 return memblock_is_memory(__pfn_to_phys(pfn));
244 }
245 EXPORT_SYMBOL(pfn_valid);
246 #endif
247
248 #ifndef CONFIG_SPARSEMEM
249 static void __init arm_memory_present(void)
250 {
251 }
252 #else
253 static void __init arm_memory_present(void)
254 {
255 struct memblock_region *reg;
256
257 for_each_memblock(memory, reg)
258 memory_present(0, memblock_region_memory_base_pfn(reg),
259 memblock_region_memory_end_pfn(reg));
260 }
261 #endif
262
263 static bool arm_memblock_steal_permitted = true;
264
265 phys_addr_t __init arm_memblock_steal(phys_addr_t size, phys_addr_t align)
266 {
267 phys_addr_t phys;
268
269 BUG_ON(!arm_memblock_steal_permitted);
270
271 phys = memblock_alloc_base(size, align, MEMBLOCK_ALLOC_ANYWHERE);
272 memblock_free(phys, size);
273 memblock_remove(phys, size);
274
275 return phys;
276 }
277
278 void __init arm_memblock_init(const struct machine_desc *mdesc)
279 {
280 /* Register the kernel text, kernel data and initrd with memblock. */
281 #ifdef CONFIG_XIP_KERNEL
282 memblock_reserve(__pa(_sdata), _end - _sdata);
283 #else
284 memblock_reserve(__pa(_stext), _end - _stext);
285 #endif
286 #ifdef CONFIG_BLK_DEV_INITRD
287 /* FDT scan will populate initrd_start */
288 if (initrd_start && !phys_initrd_size) {
289 phys_initrd_start = __virt_to_phys(initrd_start);
290 phys_initrd_size = initrd_end - initrd_start;
291 }
292 initrd_start = initrd_end = 0;
293 if (phys_initrd_size &&
294 !memblock_is_region_memory(phys_initrd_start, phys_initrd_size)) {
295 pr_err("INITRD: 0x%08llx+0x%08lx is not a memory region - disabling initrd\n",
296 (u64)phys_initrd_start, phys_initrd_size);
297 phys_initrd_start = phys_initrd_size = 0;
298 }
299 if (phys_initrd_size &&
300 memblock_is_region_reserved(phys_initrd_start, phys_initrd_size)) {
301 pr_err("INITRD: 0x%08llx+0x%08lx overlaps in-use memory region - disabling initrd\n",
302 (u64)phys_initrd_start, phys_initrd_size);
303 phys_initrd_start = phys_initrd_size = 0;
304 }
305 if (phys_initrd_size) {
306 memblock_reserve(phys_initrd_start, phys_initrd_size);
307
308 /* Now convert initrd to virtual addresses */
309 initrd_start = __phys_to_virt(phys_initrd_start);
310 initrd_end = initrd_start + phys_initrd_size;
311 }
312 #endif
313
314 arm_mm_memblock_reserve();
315
316 /* reserve any platform specific memblock areas */
317 if (mdesc->reserve)
318 mdesc->reserve();
319
320 early_init_fdt_scan_reserved_mem();
321
322 /* reserve memory for DMA contiguous allocations */
323 dma_contiguous_reserve(arm_dma_limit);
324
325 arm_memblock_steal_permitted = false;
326 memblock_dump_all();
327 }
328
329 void __init bootmem_init(void)
330 {
331 unsigned long min, max_low, max_high;
332
333 memblock_allow_resize();
334 max_low = max_high = 0;
335
336 find_limits(&min, &max_low, &max_high);
337
338 /*
339 * Sparsemem tries to allocate bootmem in memory_present(),
340 * so must be done after the fixed reservations
341 */
342 arm_memory_present();
343
344 /*
345 * sparse_init() needs the bootmem allocator up and running.
346 */
347 sparse_init();
348
349 /*
350 * Now free the memory - free_area_init_node needs
351 * the sparse mem_map arrays initialized by sparse_init()
352 * for memmap_init_zone(), otherwise all PFNs are invalid.
353 */
354 zone_sizes_init(min, max_low, max_high);
355
356 /*
357 * This doesn't seem to be used by the Linux memory manager any
358 * more, but is used by ll_rw_block. If we can get rid of it, we
359 * also get rid of some of the stuff above as well.
360 */
361 min_low_pfn = min;
362 max_low_pfn = max_low;
363 max_pfn = max_high;
364 }
365
366 /*
367 * Poison init memory with an undefined instruction (ARM) or a branch to an
368 * undefined instruction (Thumb).
369 */
370 static inline void poison_init_mem(void *s, size_t count)
371 {
372 u32 *p = (u32 *)s;
373 for (; count != 0; count -= 4)
374 *p++ = 0xe7fddef0;
375 }
376
377 static inline void
378 free_memmap(unsigned long start_pfn, unsigned long end_pfn)
379 {
380 struct page *start_pg, *end_pg;
381 phys_addr_t pg, pgend;
382
383 /*
384 * Convert start_pfn/end_pfn to a struct page pointer.
385 */
386 start_pg = pfn_to_page(start_pfn - 1) + 1;
387 end_pg = pfn_to_page(end_pfn - 1) + 1;
388
389 /*
390 * Convert to physical addresses, and
391 * round start upwards and end downwards.
392 */
393 pg = PAGE_ALIGN(__pa(start_pg));
394 pgend = __pa(end_pg) & PAGE_MASK;
395
396 /*
397 * If there are free pages between these,
398 * free the section of the memmap array.
399 */
400 if (pg < pgend)
401 memblock_free_early(pg, pgend - pg);
402 }
403
404 /*
405 * The mem_map array can get very big. Free the unused area of the memory map.
406 */
407 static void __init free_unused_memmap(void)
408 {
409 unsigned long start, prev_end = 0;
410 struct memblock_region *reg;
411
412 /*
413 * This relies on each bank being in address order.
414 * The banks are sorted previously in bootmem_init().
415 */
416 for_each_memblock(memory, reg) {
417 start = memblock_region_memory_base_pfn(reg);
418
419 #ifdef CONFIG_SPARSEMEM
420 /*
421 * Take care not to free memmap entries that don't exist
422 * due to SPARSEMEM sections which aren't present.
423 */
424 start = min(start,
425 ALIGN(prev_end, PAGES_PER_SECTION));
426 #else
427 /*
428 * Align down here since the VM subsystem insists that the
429 * memmap entries are valid from the bank start aligned to
430 * MAX_ORDER_NR_PAGES.
431 */
432 start = round_down(start, MAX_ORDER_NR_PAGES);
433 #endif
434 /*
435 * If we had a previous bank, and there is a space
436 * between the current bank and the previous, free it.
437 */
438 if (prev_end && prev_end < start)
439 free_memmap(prev_end, start);
440
441 /*
442 * Align up here since the VM subsystem insists that the
443 * memmap entries are valid from the bank end aligned to
444 * MAX_ORDER_NR_PAGES.
445 */
446 prev_end = ALIGN(memblock_region_memory_end_pfn(reg),
447 MAX_ORDER_NR_PAGES);
448 }
449
450 #ifdef CONFIG_SPARSEMEM
451 if (!IS_ALIGNED(prev_end, PAGES_PER_SECTION))
452 free_memmap(prev_end,
453 ALIGN(prev_end, PAGES_PER_SECTION));
454 #endif
455 }
456
457 #ifdef CONFIG_HIGHMEM
458 static inline void free_area_high(unsigned long pfn, unsigned long end)
459 {
460 for (; pfn < end; pfn++)
461 free_highmem_page(pfn_to_page(pfn));
462 }
463 #endif
464
465 static void __init free_highpages(void)
466 {
467 #ifdef CONFIG_HIGHMEM
468 unsigned long max_low = max_low_pfn;
469 struct memblock_region *mem, *res;
470
471 /* set highmem page free */
472 for_each_memblock(memory, mem) {
473 unsigned long start = memblock_region_memory_base_pfn(mem);
474 unsigned long end = memblock_region_memory_end_pfn(mem);
475
476 /* Ignore complete lowmem entries */
477 if (end <= max_low)
478 continue;
479
480 /* Truncate partial highmem entries */
481 if (start < max_low)
482 start = max_low;
483
484 /* Find and exclude any reserved regions */
485 for_each_memblock(reserved, res) {
486 unsigned long res_start, res_end;
487
488 res_start = memblock_region_reserved_base_pfn(res);
489 res_end = memblock_region_reserved_end_pfn(res);
490
491 if (res_end < start)
492 continue;
493 if (res_start < start)
494 res_start = start;
495 if (res_start > end)
496 res_start = end;
497 if (res_end > end)
498 res_end = end;
499 if (res_start != start)
500 free_area_high(start, res_start);
501 start = res_end;
502 if (start == end)
503 break;
504 }
505
506 /* And now free anything which remains */
507 if (start < end)
508 free_area_high(start, end);
509 }
510 #endif
511 }
512
513 /*
514 * mem_init() marks the free areas in the mem_map and tells us how much
515 * memory is free. This is done after various parts of the system have
516 * claimed their memory after the kernel image.
517 */
518 void __init mem_init(void)
519 {
520 #ifdef CONFIG_HAVE_TCM
521 /* These pointers are filled in on TCM detection */
522 extern u32 dtcm_end;
523 extern u32 itcm_end;
524 #endif
525
526 set_max_mapnr(pfn_to_page(max_pfn) - mem_map);
527
528 /* this will put all unused low memory onto the freelists */
529 free_unused_memmap();
530 free_all_bootmem();
531
532 #ifdef CONFIG_SA1111
533 /* now that our DMA memory is actually so designated, we can free it */
534 free_reserved_area(__va(PHYS_OFFSET), swapper_pg_dir, -1, NULL);
535 #endif
536
537 free_highpages();
538
539 mem_init_print_info(NULL);
540
541 #define MLK(b, t) b, t, ((t) - (b)) >> 10
542 #define MLM(b, t) b, t, ((t) - (b)) >> 20
543 #define MLK_ROUNDUP(b, t) b, t, DIV_ROUND_UP(((t) - (b)), SZ_1K)
544
545 pr_notice("Virtual kernel memory layout:\n"
546 " vector : 0x%08lx - 0x%08lx (%4ld kB)\n"
547 #ifdef CONFIG_HAVE_TCM
548 " DTCM : 0x%08lx - 0x%08lx (%4ld kB)\n"
549 " ITCM : 0x%08lx - 0x%08lx (%4ld kB)\n"
550 #endif
551 " fixmap : 0x%08lx - 0x%08lx (%4ld kB)\n"
552 " vmalloc : 0x%08lx - 0x%08lx (%4ld MB)\n"
553 " lowmem : 0x%08lx - 0x%08lx (%4ld MB)\n"
554 #ifdef CONFIG_HIGHMEM
555 " pkmap : 0x%08lx - 0x%08lx (%4ld MB)\n"
556 #endif
557 #ifdef CONFIG_MODULES
558 " modules : 0x%08lx - 0x%08lx (%4ld MB)\n"
559 #endif
560 " .text : 0x%p" " - 0x%p" " (%4td kB)\n"
561 " .init : 0x%p" " - 0x%p" " (%4td kB)\n"
562 " .data : 0x%p" " - 0x%p" " (%4td kB)\n"
563 " .bss : 0x%p" " - 0x%p" " (%4td kB)\n",
564
565 MLK(UL(CONFIG_VECTORS_BASE), UL(CONFIG_VECTORS_BASE) +
566 (PAGE_SIZE)),
567 #ifdef CONFIG_HAVE_TCM
568 MLK(DTCM_OFFSET, (unsigned long) dtcm_end),
569 MLK(ITCM_OFFSET, (unsigned long) itcm_end),
570 #endif
571 MLK(FIXADDR_START, FIXADDR_END),
572 MLM(VMALLOC_START, VMALLOC_END),
573 MLM(PAGE_OFFSET, (unsigned long)high_memory),
574 #ifdef CONFIG_HIGHMEM
575 MLM(PKMAP_BASE, (PKMAP_BASE) + (LAST_PKMAP) *
576 (PAGE_SIZE)),
577 #endif
578 #ifdef CONFIG_MODULES
579 MLM(MODULES_VADDR, MODULES_END),
580 #endif
581
582 MLK_ROUNDUP(_text, _etext),
583 MLK_ROUNDUP(__init_begin, __init_end),
584 MLK_ROUNDUP(_sdata, _edata),
585 MLK_ROUNDUP(__bss_start, __bss_stop));
586
587 #undef MLK
588 #undef MLM
589 #undef MLK_ROUNDUP
590
591 /*
592 * Check boundaries twice: Some fundamental inconsistencies can
593 * be detected at build time already.
594 */
595 #ifdef CONFIG_MMU
596 BUILD_BUG_ON(TASK_SIZE > MODULES_VADDR);
597 BUG_ON(TASK_SIZE > MODULES_VADDR);
598 #endif
599
600 #ifdef CONFIG_HIGHMEM
601 BUILD_BUG_ON(PKMAP_BASE + LAST_PKMAP * PAGE_SIZE > PAGE_OFFSET);
602 BUG_ON(PKMAP_BASE + LAST_PKMAP * PAGE_SIZE > PAGE_OFFSET);
603 #endif
604
605 if (PAGE_SIZE >= 16384 && get_num_physpages() <= 128) {
606 extern int sysctl_overcommit_memory;
607 /*
608 * On a machine this small we won't get
609 * anywhere without overcommit, so turn
610 * it on by default.
611 */
612 sysctl_overcommit_memory = OVERCOMMIT_ALWAYS;
613 }
614 }
615
616 #ifdef CONFIG_ARM_KERNMEM_PERMS
617 struct section_perm {
618 unsigned long start;
619 unsigned long end;
620 pmdval_t mask;
621 pmdval_t prot;
622 pmdval_t clear;
623 };
624
625 static struct section_perm nx_perms[] = {
626 /* Make pages tables, etc before _stext RW (set NX). */
627 {
628 .start = PAGE_OFFSET,
629 .end = (unsigned long)_stext,
630 .mask = ~PMD_SECT_XN,
631 .prot = PMD_SECT_XN,
632 },
633 /* Make init RW (set NX). */
634 {
635 .start = (unsigned long)__init_begin,
636 .end = (unsigned long)_sdata,
637 .mask = ~PMD_SECT_XN,
638 .prot = PMD_SECT_XN,
639 },
640 #ifdef CONFIG_DEBUG_RODATA
641 /* Make rodata NX (set RO in ro_perms below). */
642 {
643 .start = (unsigned long)__start_rodata,
644 .end = (unsigned long)__init_begin,
645 .mask = ~PMD_SECT_XN,
646 .prot = PMD_SECT_XN,
647 },
648 #endif
649 };
650
651 #ifdef CONFIG_DEBUG_RODATA
652 static struct section_perm ro_perms[] = {
653 /* Make kernel code and rodata RX (set RO). */
654 {
655 .start = (unsigned long)_stext,
656 .end = (unsigned long)__init_begin,
657 #ifdef CONFIG_ARM_LPAE
658 .mask = ~L_PMD_SECT_RDONLY,
659 .prot = L_PMD_SECT_RDONLY,
660 #else
661 .mask = ~(PMD_SECT_APX | PMD_SECT_AP_WRITE),
662 .prot = PMD_SECT_APX | PMD_SECT_AP_WRITE,
663 .clear = PMD_SECT_AP_WRITE,
664 #endif
665 },
666 };
667 #endif
668
669 /*
670 * Updates section permissions only for the current mm (sections are
671 * copied into each mm). During startup, this is the init_mm. Is only
672 * safe to be called with preemption disabled, as under stop_machine().
673 */
674 static inline void section_update(unsigned long addr, pmdval_t mask,
675 pmdval_t prot)
676 {
677 struct mm_struct *mm;
678 pmd_t *pmd;
679
680 mm = current->active_mm;
681 pmd = pmd_offset(pud_offset(pgd_offset(mm, addr), addr), addr);
682
683 #ifdef CONFIG_ARM_LPAE
684 pmd[0] = __pmd((pmd_val(pmd[0]) & mask) | prot);
685 #else
686 if (addr & SECTION_SIZE)
687 pmd[1] = __pmd((pmd_val(pmd[1]) & mask) | prot);
688 else
689 pmd[0] = __pmd((pmd_val(pmd[0]) & mask) | prot);
690 #endif
691 flush_pmd_entry(pmd);
692 local_flush_tlb_kernel_range(addr, addr + SECTION_SIZE);
693 }
694
695 /* Make sure extended page tables are in use. */
696 static inline bool arch_has_strict_perms(void)
697 {
698 if (cpu_architecture() < CPU_ARCH_ARMv6)
699 return false;
700
701 return !!(get_cr() & CR_XP);
702 }
703
704 #define set_section_perms(perms, field) { \
705 size_t i; \
706 unsigned long addr; \
707 \
708 if (!arch_has_strict_perms()) \
709 return; \
710 \
711 for (i = 0; i < ARRAY_SIZE(perms); i++) { \
712 if (!IS_ALIGNED(perms[i].start, SECTION_SIZE) || \
713 !IS_ALIGNED(perms[i].end, SECTION_SIZE)) { \
714 pr_err("BUG: section %lx-%lx not aligned to %lx\n", \
715 perms[i].start, perms[i].end, \
716 SECTION_SIZE); \
717 continue; \
718 } \
719 \
720 for (addr = perms[i].start; \
721 addr < perms[i].end; \
722 addr += SECTION_SIZE) \
723 section_update(addr, perms[i].mask, \
724 perms[i].field); \
725 } \
726 }
727
728 static inline void fix_kernmem_perms(void)
729 {
730 set_section_perms(nx_perms, prot);
731 }
732
733 #ifdef CONFIG_DEBUG_RODATA
734 void mark_rodata_ro(void)
735 {
736 set_section_perms(ro_perms, prot);
737 }
738
739 void set_kernel_text_rw(void)
740 {
741 set_section_perms(ro_perms, clear);
742 }
743
744 void set_kernel_text_ro(void)
745 {
746 set_section_perms(ro_perms, prot);
747 }
748 #endif /* CONFIG_DEBUG_RODATA */
749
750 #else
751 static inline void fix_kernmem_perms(void) { }
752 #endif /* CONFIG_ARM_KERNMEM_PERMS */
753
754 void free_tcmmem(void)
755 {
756 #ifdef CONFIG_HAVE_TCM
757 extern char __tcm_start, __tcm_end;
758
759 poison_init_mem(&__tcm_start, &__tcm_end - &__tcm_start);
760 free_reserved_area(&__tcm_start, &__tcm_end, -1, "TCM link");
761 #endif
762 }
763
764 void free_initmem(void)
765 {
766 fix_kernmem_perms();
767 free_tcmmem();
768
769 poison_init_mem(__init_begin, __init_end - __init_begin);
770 if (!machine_is_integrator() && !machine_is_cintegrator())
771 free_initmem_default(-1);
772 }
773
774 #ifdef CONFIG_BLK_DEV_INITRD
775
776 static int keep_initrd;
777
778 void free_initrd_mem(unsigned long start, unsigned long end)
779 {
780 if (!keep_initrd) {
781 if (start == initrd_start)
782 start = round_down(start, PAGE_SIZE);
783 if (end == initrd_end)
784 end = round_up(end, PAGE_SIZE);
785
786 poison_init_mem((void *)start, PAGE_ALIGN(end) - start);
787 free_reserved_area((void *)start, (void *)end, -1, "initrd");
788 }
789 }
790
791 static int __init keepinitrd_setup(char *__unused)
792 {
793 keep_initrd = 1;
794 return 1;
795 }
796
797 __setup("keepinitrd", keepinitrd_setup);
798 #endif
Linux kernel - Deliverables
This page took 0.04716 seconds and 6 git commands to generate.