arch/um/kernel/mem.c

   1 /*
   2  * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
   3  * Licensed under the GPL
   4  */
   5
   6 #include <linux/stddef.h>
   7 #include <linux/module.h>
   8 #include <linux/memblock.h>
   9 #include <linux/highmem.h>
  10 #include <linux/mm.h>
  11 #include <linux/swap.h>
  12 #include <linux/slab.h>
  13 #include <asm/fixmap.h>
  14 #include <asm/page.h>
  15 #include <as-layout.h>
  16 #include <init.h>
  17 #include <kern.h>
  18 #include <kern_util.h>
  19 #include <mem_user.h>
  20 #include <os.h>
  21
  22 /* allocated in paging_init, zeroed in mem_init, and unchanged thereafter */
  23 unsigned long *empty_zero_page = NULL;
  24 EXPORT_SYMBOL(empty_zero_page);
  25
  26 /*
  27  * Initialized during boot, and readonly for initializing page tables
  28  * afterwards
  29  */
  30 pgd_t swapper_pg_dir[PTRS_PER_PGD];
  31
  32 /* Initialized at boot time, and readonly after that */
  33 unsigned long long highmem;
  34 int kmalloc_ok = 0;
  35
  36 /* Used during early boot */
  37 static unsigned long brk_end;
  38
  39 void __init mem_init(void)
  40 {
  41         /* clear the zero-page */
  42         memset(empty_zero_page, 0, PAGE_SIZE);
  43
  44         /* Map in the area just after the brk now that kmalloc is about
  45          * to be turned on.
  46          */
  47         brk_end = (unsigned long) UML_ROUND_UP(sbrk(0));
  48         map_memory(brk_end, __pa(brk_end), uml_reserved - brk_end, 1, 1, 0);
  49         memblock_free(__pa(brk_end), uml_reserved - brk_end);
  50         uml_reserved = brk_end;
  51
  52         /* this will put all low memory onto the freelists */
  53         memblock_free_all();
  54         max_low_pfn = totalram_pages;
  55         max_pfn = totalram_pages;
  56         mem_init_print_info(NULL);
  57         kmalloc_ok = 1;
  58 }
  59
  60 /*
  61  * Create a page table and place a pointer to it in a middle page
  62  * directory entry.
  63  */
  64 static void __init one_page_table_init(pmd_t *pmd)
  65 {
  66         if (pmd_none(*pmd)) {
  67                 pte_t *pte = (pte_t *) memblock_alloc_low(PAGE_SIZE,
  68                                                           PAGE_SIZE);
  69                 set_pmd(pmd, __pmd(_KERNPG_TABLE +
  70                                            (unsigned long) __pa(pte)));
  71                 if (pte != pte_offset_kernel(pmd, 0))
  72                         BUG();
  73         }
  74 }
  75
  76 static void __init one_md_table_init(pud_t *pud)
  77 {
  78 #ifdef CONFIG_3_LEVEL_PGTABLES
  79         pmd_t *pmd_table = (pmd_t *) memblock_alloc_low(PAGE_SIZE, PAGE_SIZE);
  80         set_pud(pud, __pud(_KERNPG_TABLE + (unsigned long) __pa(pmd_table)));
  81         if (pmd_table != pmd_offset(pud, 0))
  82                 BUG();
  83 #endif
  84 }
  85
  86 static void __init fixrange_init(unsigned long start, unsigned long end,
  87                                  pgd_t *pgd_base)
  88 {
  89         pgd_t *pgd;
  90         pud_t *pud;
  91         pmd_t *pmd;
  92         int i, j;
  93         unsigned long vaddr;
  94
  95         vaddr = start;
  96         i = pgd_index(vaddr);
  97         j = pmd_index(vaddr);
  98         pgd = pgd_base + i;
  99
 100         for ( ; (i < PTRS_PER_PGD) && (vaddr < end); pgd++, i++) {
 101                 pud = pud_offset(pgd, vaddr);
 102                 if (pud_none(*pud))
 103                         one_md_table_init(pud);
 104                 pmd = pmd_offset(pud, vaddr);
 105                 for (; (j < PTRS_PER_PMD) && (vaddr < end); pmd++, j++) {
 106                         one_page_table_init(pmd);
 107                         vaddr += PMD_SIZE;
 108                 }
 109                 j = 0;
 110         }
 111 }
 112
 113 static void __init fixaddr_user_init( void)
 114 {
 115 #ifdef CONFIG_ARCH_REUSE_HOST_VSYSCALL_AREA
 116         long size = FIXADDR_USER_END - FIXADDR_USER_START;
 117         pgd_t *pgd;
 118         pud_t *pud;
 119         pmd_t *pmd;
 120         pte_t *pte;
 121         phys_t p;
 122         unsigned long v, vaddr = FIXADDR_USER_START;
 123
 124         if (!size)
 125                 return;
 126
 127         fixrange_init( FIXADDR_USER_START, FIXADDR_USER_END, swapper_pg_dir);
 128         v = (unsigned long) memblock_alloc_low(size, PAGE_SIZE);
 129         memcpy((void *) v , (void *) FIXADDR_USER_START, size);
 130         p = __pa(v);
 131         for ( ; size > 0; size -= PAGE_SIZE, vaddr += PAGE_SIZE,
 132                       p += PAGE_SIZE) {
 133                 pgd = swapper_pg_dir + pgd_index(vaddr);
 134                 pud = pud_offset(pgd, vaddr);
 135                 pmd = pmd_offset(pud, vaddr);
 136                 pte = pte_offset_kernel(pmd, vaddr);
 137                 pte_set_val(*pte, p, PAGE_READONLY);
 138         }
 139 #endif
 140 }
 141
 142 void __init paging_init(void)
 143 {
 144         unsigned long zones_size[MAX_NR_ZONES], vaddr;
 145         int i;
 146
 147         empty_zero_page = (unsigned long *) memblock_alloc_low(PAGE_SIZE,
 148                                                                PAGE_SIZE);
 149         for (i = 0; i < ARRAY_SIZE(zones_size); i++)
 150                 zones_size[i] = 0;
 151
 152         zones_size[ZONE_NORMAL] = (end_iomem >> PAGE_SHIFT) -
 153                 (uml_physmem >> PAGE_SHIFT);
 154         free_area_init(zones_size);
 155
 156         /*
 157          * Fixed mappings, only the page table structure has to be
 158          * created - mappings will be set by set_fixmap():
 159          */
 160         vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
 161         fixrange_init(vaddr, FIXADDR_TOP, swapper_pg_dir);
 162
 163         fixaddr_user_init();
 164 }
 165
 166 /*
 167  * This can't do anything because nothing in the kernel image can be freed
 168  * since it's not in kernel physical memory.
 169  */
 170
 171 void free_initmem(void)
 172 {
 173 }
 174
 175 #ifdef CONFIG_BLK_DEV_INITRD
 176 void free_initrd_mem(unsigned long start, unsigned long end)
 177 {
 178         free_reserved_area((void *)start, (void *)end, -1, "initrd");
 179 }
 180 #endif
 181
 182 /* Allocate and free page tables. */
 183
 184 pgd_t *pgd_alloc(struct mm_struct *mm)
 185 {
 186         pgd_t *pgd = (pgd_t *)__get_free_page(GFP_KERNEL);
 187
 188         if (pgd) {
 189                 memset(pgd, 0, USER_PTRS_PER_PGD * sizeof(pgd_t));
 190                 memcpy(pgd + USER_PTRS_PER_PGD,
 191                        swapper_pg_dir + USER_PTRS_PER_PGD,
 192                        (PTRS_PER_PGD - USER_PTRS_PER_PGD) * sizeof(pgd_t));
 193         }
 194         return pgd;
 195 }
 196
 197 void pgd_free(struct mm_struct *mm, pgd_t *pgd)
 198 {
 199         free_page((unsigned long) pgd);
 200 }
 201
 202 pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
 203 {
 204         pte_t *pte;
 205
 206         pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
 207         return pte;
 208 }
 209
 210 pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)
 211 {
 212         struct page *pte;
 213
 214         pte = alloc_page(GFP_KERNEL|__GFP_ZERO);
 215         if (!pte)
 216                 return NULL;
 217         if (!pgtable_page_ctor(pte)) {
 218                 __free_page(pte);
 219                 return NULL;
 220         }
 221         return pte;
 222 }
 223
 224 #ifdef CONFIG_3_LEVEL_PGTABLES
 225 pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address)
 226 {
 227         pmd_t *pmd = (pmd_t *) __get_free_page(GFP_KERNEL);
 228
 229         if (pmd)
 230                 memset(pmd, 0, PAGE_SIZE);
 231
 232         return pmd;
 233 }
 234 #endif
 235
 236 void *uml_kmalloc(int size, int flags)
 237 {
 238         return kmalloc(size, flags);
 239 }