arch/i386/mm/init.c

   1 /*
   2  *  linux/arch/i386/mm/init.c
   3  *
   4  *  Copyright (C) 1995  Linus Torvalds
   5  */
   6
   7 #include <linux/config.h>
   8 #include <linux/signal.h>
   9 #include <linux/sched.h>
  10 #include <linux/kernel.h>
  11 #include <linux/errno.h>
  12 #include <linux/string.h>
  13 #include <linux/types.h>
  14 #include <linux/ptrace.h>
  15 #include <linux/mman.h>
  16 #include <linux/mm.h>
  17 #include <linux/swap.h>
  18 #include <linux/smp.h>
  19 #include <linux/init.h>
  20 #ifdef CONFIG_BLK_DEV_INITRD
  21 #include <linux/blk.h>
  22 #endif
  23
  24 #include <asm/processor.h>
  25 #include <asm/system.h>
  26 #include <asm/uaccess.h>
  27 #include <asm/pgtable.h>
  28 #include <asm/dma.h>
  29 #include <asm/fixmap.h>
  30
  31 extern void show_net_buffers(void);
  32 extern unsigned long init_smp_mappings(unsigned long);
  33
  34 void __bad_pte_kernel(pmd_t *pmd)
  35 {
  36         printk("Bad pmd in pte_alloc: %08lx\n", pmd_val(*pmd));
  37         pmd_val(*pmd) = _KERNPG_TABLE + __pa(BAD_PAGETABLE);
  38 }
  39
  40 void __bad_pte(pmd_t *pmd)
  41 {
  42         printk("Bad pmd in pte_alloc: %08lx\n", pmd_val(*pmd));
  43         pmd_val(*pmd) = _PAGE_TABLE + __pa(BAD_PAGETABLE);
  44 }
  45
  46 pte_t *get_pte_kernel_slow(pmd_t *pmd, unsigned long offset)
  47 {
  48         pte_t *pte;
  49
  50         pte = (pte_t *) __get_free_page(GFP_KERNEL);
  51         if (pmd_none(*pmd)) {
  52                 if (pte) {
  53                         clear_page((unsigned long)pte);
  54                         pmd_val(*pmd) = _KERNPG_TABLE + __pa(pte);
  55                         return pte + offset;
  56                 }
  57                 pmd_val(*pmd) = _KERNPG_TABLE + __pa(BAD_PAGETABLE);
  58                 return NULL;
  59         }
  60         free_page((unsigned long)pte);
  61         if (pmd_bad(*pmd)) {
  62                 __bad_pte_kernel(pmd);
  63                 return NULL;
  64         }
  65         return (pte_t *) pmd_page(*pmd) + offset;
  66 }
  67
  68 pte_t *get_pte_slow(pmd_t *pmd, unsigned long offset)
  69 {
  70         unsigned long pte;
  71
  72         pte = (unsigned long) __get_free_page(GFP_KERNEL);
  73         if (pmd_none(*pmd)) {
  74                 if (pte) {
  75                         clear_page(pte);
  76                         pmd_val(*pmd) = _PAGE_TABLE + __pa(pte);
  77                         return (pte_t *)(pte + offset);
  78                 }
  79                 pmd_val(*pmd) = _PAGE_TABLE + __pa(BAD_PAGETABLE);
  80                 return NULL;
  81         }
  82         free_page(pte);
  83         if (pmd_bad(*pmd)) {
  84                 __bad_pte(pmd);
  85                 return NULL;
  86         }
  87         return (pte_t *) (pmd_page(*pmd) + offset);
  88 }
  89
  90 int do_check_pgt_cache(int low, int high)
  91 {
  92         int freed = 0;
  93         if(pgtable_cache_size > high) {
  94                 do {
  95                         if(pgd_quicklist)
  96                                 free_pgd_slow(get_pgd_fast()), freed++;
  97                         if(pmd_quicklist)
  98                                 free_pmd_slow(get_pmd_fast()), freed++;
  99                         if(pte_quicklist)
 100                                 free_pte_slow(get_pte_fast()), freed++;
 101                 } while(pgtable_cache_size > low);
 102         }
 103         return freed;
 104 }
 105
 106 /*
 107  * BAD_PAGE is the page that is used for page faults when linux
 108  * is out-of-memory. Older versions of linux just did a
 109  * do_exit(), but using this instead means there is less risk
 110  * for a process dying in kernel mode, possibly leaving an inode
 111  * unused etc..
 112  *
 113  * BAD_PAGETABLE is the accompanying page-table: it is initialized
 114  * to point to BAD_PAGE entries.
 115  *
 116  * ZERO_PAGE is a special page that is used for zero-initialized
 117  * data and COW.
 118  */
 119 pte_t * __bad_pagetable(void)
 120 {
 121         extern char empty_bad_page_table[PAGE_SIZE];
 122         int d0, d1;
 123
 124         __asm__ __volatile__("cld ; rep ; stosl"
 125                              : "=&D" (d0), "=&c" (d1)
 126                              : "a" (pte_val(BAD_PAGE)),
 127                              "0" ((long) empty_bad_page_table),
 128                              "1" (PAGE_SIZE/4)
 129                              : "memory");
 130         return (pte_t *) empty_bad_page_table;
 131 }
 132
 133 pte_t __bad_page(void)
 134 {
 135         extern char empty_bad_page[PAGE_SIZE];
 136         int d0, d1;
 137
 138         __asm__ __volatile__("cld ; rep ; stosl"
 139                              : "=&D" (d0), "=&c" (d1)
 140                              : "a" (0),
 141                              "0" ((long) empty_bad_page),
 142                              "1" (PAGE_SIZE/4)
 143                              : "memory");
 144         return pte_mkdirty(mk_pte((unsigned long) empty_bad_page, PAGE_SHARED));
 145 }
 146
 147 void show_mem(void)
 148 {
 149         int i,free = 0,total = 0,reserved = 0;
 150         int shared = 0, cached = 0;
 151
 152         printk("Mem-info:\n");
 153         show_free_areas();
 154         printk("Free swap:       %6dkB\n",nr_swap_pages<<(PAGE_SHIFT-10));
 155         i = max_mapnr;
 156         while (i-- > 0) {
 157                 total++;
 158                 if (PageReserved(mem_map+i))
 159                         reserved++;
 160                 else if (PageSwapCache(mem_map+i))
 161                         cached++;
 162                 else if (!page_count(mem_map+i))
 163                         free++;
 164                 else
 165                         shared += page_count(mem_map+i) - 1;
 166         }
 167         printk("%d pages of RAM\n",total);
 168         printk("%d reserved pages\n",reserved);
 169         printk("%d pages shared\n",shared);
 170         printk("%d pages swap cached\n",cached);
 171         printk("%ld pages in page table cache\n",pgtable_cache_size);
 172 #ifdef CONFIG_NET
 173         show_net_buffers();
 174 #endif
 175 }
 176
 177 extern unsigned long free_area_init(unsigned long, unsigned long);
 178
 179 /* References to section boundaries */
 180
 181 extern char _text, _etext, _edata, __bss_start, _end;
 182 extern char __init_begin, __init_end;
 183
 184 /*
 185  * allocate page table(s) for compile-time fixed mappings
 186  */
 187 static unsigned long __init fixmap_init(unsigned long start_mem)
 188 {
 189         pgd_t * pg_dir;
 190         unsigned int idx;
 191         unsigned long address;
 192
 193         start_mem = PAGE_ALIGN(start_mem);
 194
 195         for (idx=1; idx <= __end_of_fixed_addresses; idx += PTRS_PER_PTE)
 196         {
 197                 address = __fix_to_virt(__end_of_fixed_addresses-idx);
 198                 pg_dir = swapper_pg_dir + (address >> PGDIR_SHIFT);
 199                 memset((void *)start_mem, 0, PAGE_SIZE);
 200                 pgd_val(*pg_dir) = _PAGE_TABLE | __pa(start_mem);
 201                 start_mem += PAGE_SIZE;
 202         }
 203
 204         return start_mem;
 205 }
 206
 207 static void set_pte_phys (unsigned long vaddr, unsigned long phys)
 208 {
 209         pgprot_t prot;
 210         pte_t * pte;
 211
 212         pte = pte_offset(pmd_offset(pgd_offset_k(vaddr), vaddr), vaddr);
 213         prot = PAGE_KERNEL;
 214         if (boot_cpu_data.x86_capability & X86_FEATURE_PGE)
 215                 pgprot_val(prot) |= _PAGE_GLOBAL;
 216         set_pte(pte, mk_pte_phys(phys, prot));
 217
 218         local_flush_tlb();
 219 }
 220
 221 void set_fixmap (enum fixed_addresses idx, unsigned long phys)
 222 {
 223         unsigned long address = __fix_to_virt(idx);
 224
 225         if (idx >= __end_of_fixed_addresses) {
 226                 printk("Invalid set_fixmap\n");
 227                 return;
 228         }
 229         set_pte_phys (address,phys);
 230 }
 231
 232 /*
 233  * paging_init() sets up the page tables - note that the first 4MB are
 234  * already mapped by head.S.
 235  *
 236  * This routines also unmaps the page at virtual kernel address 0, so
 237  * that we can trap those pesky NULL-reference errors in the kernel.
 238  */
 239 __initfunc(unsigned long paging_init(unsigned long start_mem, unsigned long end_mem))
 240 {
 241         pgd_t * pg_dir;
 242         pte_t * pg_table;
 243         unsigned long tmp;
 244         unsigned long address;
 245
 246 /*
 247  * Physical page 0 is special; it's not touched by Linux since BIOS
 248  * and SMM (for laptops with [34]86/SL chips) may need it.  It is read
 249  * and write protected to detect null pointer references in the
 250  * kernel.
 251  * It may also hold the MP configuration table when we are booting SMP.
 252  */
 253         start_mem = PAGE_ALIGN(start_mem);
 254         address = PAGE_OFFSET;
 255         pg_dir = swapper_pg_dir;
 256         /* unmap the original low memory mappings */
 257         pgd_val(pg_dir[0]) = 0;
 258
 259         /* Map whole memory from PAGE_OFFSET */
 260         pg_dir += USER_PGD_PTRS;
 261         while (address < end_mem) {
 262                 /*
 263                  * If we're running on a Pentium CPU, we can use the 4MB
 264                  * page tables.
 265                  *
 266                  * The page tables we create span up to the next 4MB
 267                  * virtual memory boundary, but that's OK as we won't
 268                  * use that memory anyway.
 269                  */
 270                 if (boot_cpu_data.x86_capability & X86_FEATURE_PSE) {
 271                         unsigned long __pe;
 272
 273                         set_in_cr4(X86_CR4_PSE);
 274                         boot_cpu_data.wp_works_ok = 1;
 275                         __pe = _KERNPG_TABLE + _PAGE_4M + __pa(address);
 276                         /* Make it "global" too if supported */
 277                         if (boot_cpu_data.x86_capability & X86_FEATURE_PGE) {
 278                                 set_in_cr4(X86_CR4_PGE);
 279                                 __pe += _PAGE_GLOBAL;
 280                         }
 281                         pgd_val(*pg_dir) = __pe;
 282                         pg_dir++;
 283                         address += 4*1024*1024;
 284                         continue;
 285                 }
 286
 287                 /*
 288                  * We're on a [34]86, use normal page tables.
 289                  * pg_table is physical at this point
 290                  */
 291                 pg_table = (pte_t *) (PAGE_MASK & pgd_val(*pg_dir));
 292                 if (!pg_table) {
 293                         pg_table = (pte_t *) __pa(start_mem);
 294                         start_mem += PAGE_SIZE;
 295                 }
 296
 297                 pgd_val(*pg_dir) = _PAGE_TABLE | (unsigned long) pg_table;
 298                 pg_dir++;
 299
 300                 /* now change pg_table to kernel virtual addresses */
 301                 pg_table = (pte_t *) __va(pg_table);
 302                 for (tmp = 0 ; tmp < PTRS_PER_PTE ; tmp++,pg_table++) {
 303                         pte_t pte = mk_pte(address, PAGE_KERNEL);
 304                         if (address >= end_mem)
 305                                 pte_val(pte) = 0;
 306                         set_pte(pg_table, pte);
 307                         address += PAGE_SIZE;
 308                 }
 309         }
 310         start_mem = fixmap_init(start_mem);
 311 #ifdef __SMP__
 312         start_mem = init_smp_mappings(start_mem);
 313 #endif
 314         local_flush_tlb();
 315
 316         return free_area_init(start_mem, end_mem);
 317 }
 318
 319 /*
 320  * Test if the WP bit works in supervisor mode. It isn't supported on 386's
 321  * and also on some strange 486's (NexGen etc.). All 586+'s are OK. The jumps
 322  * before and after the test are here to work-around some nasty CPU bugs.
 323  */
 324
 325 __initfunc(void test_wp_bit(void))
 326 {
 327         unsigned char tmp_reg;
 328         unsigned long old = pg0[0];
 329
 330         printk("Checking if this processor honours the WP bit even in supervisor mode... ");
 331         pg0[0] = pte_val(mk_pte(PAGE_OFFSET, PAGE_READONLY));
 332         local_flush_tlb();
 333         current->mm->mmap->vm_start += PAGE_SIZE;
 334         __asm__ __volatile__(
 335                 "jmp 1f; 1:\n"
 336                 "movb %0,%1\n"
 337                 "movb %1,%0\n"
 338                 "jmp 1f; 1:\n"
 339                 :"=m" (*(char *) __va(0)),
 340                  "=q" (tmp_reg)
 341                 :/* no inputs */
 342                 :"memory");
 343         pg0[0] = old;
 344         local_flush_tlb();
 345         current->mm->mmap->vm_start -= PAGE_SIZE;
 346         if (boot_cpu_data.wp_works_ok < 0) {
 347                 boot_cpu_data.wp_works_ok = 0;
 348                 printk("No.\n");
 349 #ifdef CONFIG_X86_WP_WORKS_OK
 350                 panic("This kernel doesn't support CPU's with broken WP. Recompile it for a 386!");
 351 #endif
 352         } else
 353                 printk(".\n");
 354 }
 355
 356 __initfunc(void mem_init(unsigned long start_mem, unsigned long end_mem))
 357 {
 358         unsigned long start_low_mem = PAGE_SIZE;
 359         int codepages = 0;
 360         int reservedpages = 0;
 361         int datapages = 0;
 362         int initpages = 0;
 363         unsigned long tmp;
 364         unsigned long endbase;
 365
 366         end_mem &= PAGE_MASK;
 367         high_memory = (void *) end_mem;
 368         max_mapnr = num_physpages = MAP_NR(end_mem);
 369
 370         /* clear the zero-page */
 371         memset(empty_zero_page, 0, PAGE_SIZE);
 372
 373         /* mark usable pages in the mem_map[] */
 374         start_low_mem = PAGE_ALIGN(start_low_mem)+PAGE_OFFSET;
 375
 376 #ifdef __SMP__
 377         /*
 378          * But first pinch a few for the stack/trampoline stuff
 379          *      FIXME: Don't need the extra page at 4K, but need to fix
 380          *      trampoline before removing it. (see the GDT stuff)
 381          *
 382          */
 383         start_low_mem += PAGE_SIZE;                             /* 32bit startup code */
 384         start_low_mem = smp_alloc_memory(start_low_mem);        /* AP processor stacks */
 385 #endif
 386         start_mem = PAGE_ALIGN(start_mem);
 387
 388         /*
 389          * IBM messed up *AGAIN* in their thinkpad: 0xA0000 -> 0x9F000.
 390          * They seem to have done something stupid with the floppy
 391          * controller as well..
 392          * The amount of available base memory is in WORD 40:13.
 393          */
 394         endbase = PAGE_OFFSET + ((*(unsigned short *)__va(0x413) * 1024) & PAGE_MASK);
 395         while (start_low_mem < endbase) {
 396                 clear_bit(PG_reserved, &mem_map[MAP_NR(start_low_mem)].flags);
 397                 start_low_mem += PAGE_SIZE;
 398         }
 399
 400         while (start_mem < end_mem) {
 401                 clear_bit(PG_reserved, &mem_map[MAP_NR(start_mem)].flags);
 402                 start_mem += PAGE_SIZE;
 403         }
 404         for (tmp = PAGE_OFFSET ; tmp < end_mem ; tmp += PAGE_SIZE) {
 405                 if (tmp >= MAX_DMA_ADDRESS)
 406                         clear_bit(PG_DMA, &mem_map[MAP_NR(tmp)].flags);
 407                 if (PageReserved(mem_map+MAP_NR(tmp))) {
 408                         if (tmp >= (unsigned long) &_text && tmp < (unsigned long) &_edata) {
 409                                 if (tmp < (unsigned long) &_etext)
 410                                         codepages++;
 411                                 else
 412                                         datapages++;
 413                         } else if (tmp >= (unsigned long) &__init_begin
 414                                    && tmp < (unsigned long) &__init_end)
 415                                 initpages++;
 416                         else if (tmp >= (unsigned long) &__bss_start
 417                                  && tmp < (unsigned long) start_mem)
 418                                 datapages++;
 419                         else
 420                                 reservedpages++;
 421                         continue;
 422                 }
 423                 set_page_count(mem_map+MAP_NR(tmp), 1);
 424 #ifdef CONFIG_BLK_DEV_INITRD
 425                 if (!initrd_start || (tmp < initrd_start || tmp >=
 426                     initrd_end))
 427 #endif
 428                         free_page(tmp);
 429         }
 430         printk("Memory: %luk/%luk available (%dk kernel code, %dk reserved, %dk data, %dk init)\n",
 431                 (unsigned long) nr_free_pages << (PAGE_SHIFT-10),
 432                 max_mapnr << (PAGE_SHIFT-10),
 433                 codepages << (PAGE_SHIFT-10),
 434                 reservedpages << (PAGE_SHIFT-10),
 435                 datapages << (PAGE_SHIFT-10),
 436                 initpages << (PAGE_SHIFT-10));
 437
 438         if (boot_cpu_data.wp_works_ok < 0)
 439                 test_wp_bit();
 440 }
 441
 442 void free_initmem(void)
 443 {
 444         unsigned long addr;
 445
 446         addr = (unsigned long)(&__init_begin);
 447         for (; addr < (unsigned long)(&__init_end); addr += PAGE_SIZE) {
 448                 mem_map[MAP_NR(addr)].flags &= ~(1 << PG_reserved);
 449                 set_page_count(mem_map+MAP_NR(addr), 1);
 450                 free_page(addr);
 451         }
 452         printk ("Freeing unused kernel memory: %dk freed\n", (&__init_end - &__init_begin) >> 10);
 453 }
 454
 455 void si_meminfo(struct sysinfo *val)
 456 {
 457         int i;
 458
 459         i = max_mapnr;
 460         val->totalram = 0;
 461         val->sharedram = 0;
 462         val->freeram = nr_free_pages << PAGE_SHIFT;
 463         val->bufferram = atomic_read(&buffermem);
 464         while (i-- > 0)  {
 465                 if (PageReserved(mem_map+i))
 466                         continue;
 467                 val->totalram++;
 468                 if (!page_count(mem_map+i))
 469                         continue;
 470                 val->sharedram += page_count(mem_map+i) - 1;
 471         }
 472         val->totalram <<= PAGE_SHIFT;
 473         val->sharedram <<= PAGE_SHIFT;
 474         return;
 475 }