arch/sh/mm/init.c

   1 /*
   2  *  linux/arch/sh/mm/init.c
   3  *
   4  *  Copyright (C) 1999  Niibe Yutaka
   5  *
   6  *  Based on linux/arch/i386/mm/init.c:
   7  *   Copyright (C) 1995  Linus Torvalds
   8  */
   9
  10 #include <linux/config.h>
  11 #include <linux/signal.h>
  12 #include <linux/sched.h>
  13 #include <linux/kernel.h>
  14 #include <linux/errno.h>
  15 #include <linux/string.h>
  16 #include <linux/types.h>
  17 #include <linux/ptrace.h>
  18 #include <linux/mman.h>
  19 #include <linux/mm.h>
  20 #include <linux/swap.h>
  21 #include <linux/smp.h>
  22 #include <linux/init.h>
  23 #ifdef CONFIG_BLK_DEV_INITRD
  24 #include <linux/blk.h>
  25 #endif
  26
  27 #include <asm/processor.h>
  28 #include <asm/system.h>
  29 #include <asm/uaccess.h>
  30 #include <asm/pgtable.h>
  31 #include <asm/mmu_context.h>
  32
  33 /*
  34  * Cache of MMU context last used.
  35  */
  36 unsigned long mmu_context_cache;
  37
  38 static unsigned long totalram = 0;
  39
  40 extern void show_net_buffers(void);
  41 extern unsigned long init_smp_mappings(unsigned long);
  42
  43 void __bad_pte_kernel(pmd_t *pmd)
  44 {
  45         printk("Bad pmd in pte_alloc: %08lx\n", pmd_val(*pmd));
  46         pmd_val(*pmd) = _KERNPG_TABLE + __pa(BAD_PAGETABLE);
  47 }
  48
  49 void __bad_pte(pmd_t *pmd)
  50 {
  51         printk("Bad pmd in pte_alloc: %08lx\n", pmd_val(*pmd));
  52         pmd_val(*pmd) = _PAGE_TABLE + __pa(BAD_PAGETABLE);
  53 }
  54
  55 pte_t *get_pte_kernel_slow(pmd_t *pmd, unsigned long offset)
  56 {
  57         pte_t *pte;
  58
  59         pte = (pte_t *) __get_free_page(GFP_KERNEL);
  60         if (pmd_none(*pmd)) {
  61                 if (pte) {
  62                         clear_page((unsigned long)pte);
  63                         pmd_val(*pmd) = _KERNPG_TABLE + __pa(pte);
  64                         return pte + offset;
  65                 }
  66                 pmd_val(*pmd) = _KERNPG_TABLE + __pa(BAD_PAGETABLE);
  67                 return NULL;
  68         }
  69         free_page((unsigned long)pte);
  70         if (pmd_bad(*pmd)) {
  71                 __bad_pte_kernel(pmd);
  72                 return NULL;
  73         }
  74         return (pte_t *) pmd_page(*pmd) + offset;
  75 }
  76
  77 pte_t *get_pte_slow(pmd_t *pmd, unsigned long offset)
  78 {
  79         unsigned long pte;
  80
  81         pte = (unsigned long) __get_free_page(GFP_KERNEL);
  82         if (pmd_none(*pmd)) {
  83                 if (pte) {
  84                         clear_page(pte);
  85                         pmd_val(*pmd) = _PAGE_TABLE + __pa(pte);
  86                         return (pte_t *)(pte + offset);
  87                 }
  88                 pmd_val(*pmd) = _PAGE_TABLE + __pa(BAD_PAGETABLE);
  89                 return NULL;
  90         }
  91         free_page(pte);
  92         if (pmd_bad(*pmd)) {
  93                 __bad_pte(pmd);
  94                 return NULL;
  95         }
  96         return (pte_t *) (pmd_page(*pmd) + offset);
  97 }
  98
  99 int do_check_pgt_cache(int low, int high)
 100 {
 101         int freed = 0;
 102         if(pgtable_cache_size > high) {
 103                 do {
 104                         if(pgd_quicklist)
 105                                 free_pgd_slow(get_pgd_fast()), freed++;
 106                         if(pmd_quicklist)
 107                                 free_pmd_slow(get_pmd_fast()), freed++;
 108                         if(pte_quicklist)
 109                                 free_pte_slow(get_pte_fast()), freed++;
 110                 } while(pgtable_cache_size > low);
 111         }
 112         return freed;
 113 }
 114
 115 /*
 116  * BAD_PAGE is the page that is used for page faults when linux
 117  * is out-of-memory. Older versions of linux just did a
 118  * do_exit(), but using this instead means there is less risk
 119  * for a process dying in kernel mode, possibly leaving an inode
 120  * unused etc..
 121  *
 122  * BAD_PAGETABLE is the accompanying page-table: it is initialized
 123  * to point to BAD_PAGE entries.
 124  *
 125  * ZERO_PAGE is a special page that is used for zero-initialized
 126  * data and COW.
 127  */
 128 pte_t * __bad_pagetable(void)
 129 {
 130         extern char empty_bad_page_table[PAGE_SIZE];
 131         unsigned long page = (unsigned long)empty_bad_page_table;
 132
 133         clear_page(page);
 134         return (pte_t *)empty_bad_page_table;
 135 }
 136
 137 pte_t __bad_page(void)
 138 {
 139         extern char empty_bad_page[PAGE_SIZE];
 140         unsigned long page = (unsigned long)empty_bad_page;
 141
 142         clear_page(page);
 143         return pte_mkdirty(mk_pte(page, PAGE_SHARED));
 144 }
 145
 146 void show_mem(void)
 147 {
 148         int i,free = 0,total = 0,reserved = 0;
 149         int shared = 0, cached = 0;
 150
 151         printk("Mem-info:\n");
 152         show_free_areas();
 153         printk("Free swap:       %6dkB\n",nr_swap_pages<<(PAGE_SHIFT-10));
 154         i = max_mapnr;
 155         while (i-- > 0) {
 156                 total++;
 157                 if (PageReserved(mem_map+i))
 158                         reserved++;
 159                 else if (PageSwapCache(mem_map+i))
 160                         cached++;
 161                 else if (!page_count(mem_map+i))
 162                         free++;
 163                 else
 164                         shared += page_count(mem_map+i) - 1;
 165         }
 166         printk("%d pages of RAM\n",total);
 167         printk("%d reserved pages\n",reserved);
 168         printk("%d pages shared\n",shared);
 169         printk("%d pages swap cached\n",cached);
 170         printk("%ld pages in page table cache\n",pgtable_cache_size);
 171 #ifdef CONFIG_NET
 172         show_net_buffers();
 173 #endif
 174 }
 175
 176 extern unsigned long free_area_init(unsigned long, unsigned long);
 177
 178 /* References to section boundaries */
 179
 180 extern char _text, _etext, _edata, __bss_start, _end;
 181 extern char __init_begin, __init_end;
 182
 183 pgd_t swapper_pg_dir[1024];
 184
 185 /*
 186  * paging_init() sets up the page tables
 187  *
 188  * This routines also unmaps the page at virtual kernel address 0, so
 189  * that we can trap those pesky NULL-reference errors in the kernel.
 190  */
 191 unsigned long __init
 192 paging_init(unsigned long start_mem, unsigned long end_mem)
 193 {
 194         pgd_t * pg_dir;
 195
 196         start_mem = PAGE_ALIGN(start_mem);
 197
 198         /* We don't need kernel mapping as hardware support that. */
 199         pg_dir = swapper_pg_dir;
 200
 201         /* Unmap the original low memory mappings to detect NULL reference */
 202         pgd_val(pg_dir[0]) = 0;
 203
 204         /* Enable MMU */
 205         __asm__ __volatile__ ("mov.l    %0,%1"
 206                               : /* no output */
 207                               : "r" (MMU_CONTROL_INIT), "m" (__m(MMUCR)));
 208
 209         return free_area_init(start_mem, end_mem);
 210 }
 211
 212 unsigned long empty_bad_page[1024];
 213 unsigned long empty_bad_page_table[1024];
 214 unsigned long empty_zero_page[1024];
 215
 216 void __init mem_init(unsigned long start_mem, unsigned long end_mem)
 217 {
 218         int codepages = 0;
 219         int reservedpages = 0;
 220         int datapages = 0;
 221         int initpages = 0;
 222         unsigned long tmp;
 223
 224         end_mem &= PAGE_MASK;
 225         high_memory = (void *) end_mem;
 226         max_mapnr = num_physpages = MAP_NR(end_mem);
 227
 228         /* clear the zero-page */
 229         memset(empty_zero_page, 0, PAGE_SIZE);
 230
 231         /* Mark (clear "reserved" bit) usable pages in the mem_map[] */
 232         /*    Note that all are marked reserved already. */
 233         tmp = start_mem = PAGE_ALIGN(start_mem);
 234         while (tmp < end_mem) {
 235                 clear_bit(PG_reserved, &mem_map[MAP_NR(tmp)].flags);
 236                 clear_bit(PG_DMA, &mem_map[MAP_NR(tmp)].flags);
 237                 tmp += PAGE_SIZE;
 238         }
 239
 240         for (tmp = PAGE_OFFSET; tmp < end_mem; tmp += PAGE_SIZE) {
 241                 if (PageReserved(mem_map+MAP_NR(tmp))) {
 242                         if (tmp >= (unsigned long) &_text && tmp < (unsigned long) &_edata) {
 243                                 if (tmp < (unsigned long) &_etext)
 244                                         codepages++;
 245                                 else
 246                                         datapages++;
 247                         } else if (tmp >= (unsigned long) &__init_begin
 248                                    && tmp < (unsigned long) &__init_end)
 249                                 initpages++;
 250                         else if (tmp >= (unsigned long) &__bss_start
 251                                  && tmp < (unsigned long) start_mem)
 252                                 datapages++;
 253                         else
 254                                 reservedpages++;
 255                         continue;
 256                 }
 257                 set_page_count(mem_map+MAP_NR(tmp), 1);
 258                 totalram += PAGE_SIZE;
 259 #ifdef CONFIG_BLK_DEV_INITRD
 260                 if (!initrd_start || (tmp < initrd_start || tmp >= initrd_end))
 261 #endif
 262                         free_page(tmp);
 263         }
 264         printk("Memory: %luk/%luk available (%dk kernel code, %dk reserved, %dk data, %dk init)\n",
 265                 (unsigned long) nr_free_pages << (PAGE_SHIFT-10),
 266                 max_mapnr << (PAGE_SHIFT-10),
 267                 codepages << (PAGE_SHIFT-10),
 268                 reservedpages << (PAGE_SHIFT-10),
 269                 datapages << (PAGE_SHIFT-10),
 270                 initpages << (PAGE_SHIFT-10));
 271 }
 272
 273 void free_initmem(void)
 274 {
 275         unsigned long addr;
 276
 277         addr = (unsigned long)(&__init_begin);
 278         for (; addr < (unsigned long)(&__init_end); addr += PAGE_SIZE) {
 279                 mem_map[MAP_NR(addr)].flags &= ~(1 << PG_reserved);
 280                 set_page_count(mem_map+MAP_NR(addr), 1);
 281                 free_page(addr);
 282                 totalram += PAGE_SIZE;
 283         }
 284         printk ("Freeing unused kernel memory: %dk freed\n", (&__init_end - &__init_begin) >> 10);
 285 }
 286
 287 void si_meminfo(struct sysinfo *val)
 288 {
 289         val->totalram = totalram;
 290         val->sharedram = 0;
 291         val->freeram = nr_free_pages << PAGE_SHIFT;
 292         val->bufferram = atomic_read(&buffermem);
 293         return;
 294 }