include/asm-mips/pgalloc.h

   1 /* $Id: pgalloc.h,v 1.3 2000/02/23 00:41:38 ralf Exp $
   2  *
   3  * This file is subject to the terms and conditions of the GNU General Public
   4  * License.  See the file "COPYING" in the main directory of this archive
   5  * for more details.
   6  *
   7  * Copyright (C) 1994 - 2000 by Ralf Baechle at alii
   8  * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
   9  */
  10 #ifndef _ASM_PGALLOC_H
  11 #define _ASM_PGALLOC_H
  12
  13 #include <linux/config.h>
  14
  15 /* TLB flushing:
  16  *
  17  *  - flush_tlb_all() flushes all processes TLB entries
  18  *  - flush_tlb_mm(mm) flushes the specified mm context TLB entries
  19  *  - flush_tlb_page(mm, vmaddr) flushes a single page
  20  *  - flush_tlb_range(mm, start, end) flushes a range of pages
  21  */
  22 extern void flush_tlb_all(void);
  23 extern void flush_tlb_mm(struct mm_struct *mm);
  24 extern void flush_tlb_range(struct mm_struct *mm, unsigned long start,
  25                                unsigned long end);
  26 extern void flush_tlb_page(struct vm_area_struct *vma, unsigned long page);
  27
  28 extern inline void flush_tlb_pgtables(struct mm_struct *mm,
  29                                       unsigned long start, unsigned long end)
  30 {
  31         /* Nothing to do on MIPS.  */
  32 }
  33
  34
  35 /*
  36  * Allocate and free page tables. The xxx_kernel() versions are
  37  * used to allocate a kernel page table - this turns on ASN bits
  38  * if any.
  39  */
  40
  41 #define pgd_quicklist (current_cpu_data.pgd_quick)
  42 #define pmd_quicklist ((unsigned long *)0)
  43 #define pte_quicklist (current_cpu_data.pte_quick)
  44 #define pgtable_cache_size (current_cpu_data.pgtable_cache_sz)
  45
  46 extern __inline__ pgd_t *get_pgd_slow(void)
  47 {
  48         pgd_t *ret = (pgd_t *)__get_free_page(GFP_KERNEL), *init;
  49
  50         if (ret) {
  51                 init = pgd_offset(&init_mm, 0);
  52                 pgd_init((unsigned long)ret);
  53                 memcpy (ret + USER_PTRS_PER_PGD, init + USER_PTRS_PER_PGD,
  54                         (PTRS_PER_PGD - USER_PTRS_PER_PGD) * sizeof(pgd_t));
  55         }
  56         return ret;
  57 }
  58
  59 extern __inline__ pgd_t *get_pgd_fast(void)
  60 {
  61         unsigned long *ret;
  62
  63         if((ret = pgd_quicklist) != NULL) {
  64                 pgd_quicklist = (unsigned long *)(*ret);
  65                 ret[0] = ret[1];
  66                 pgtable_cache_size--;
  67         } else
  68                 ret = (unsigned long *)get_pgd_slow();
  69         return (pgd_t *)ret;
  70 }
  71
  72 extern __inline__ void free_pgd_fast(pgd_t *pgd)
  73 {
  74         *(unsigned long *)pgd = (unsigned long) pgd_quicklist;
  75         pgd_quicklist = (unsigned long *) pgd;
  76         pgtable_cache_size++;
  77 }
  78
  79 extern __inline__ void free_pgd_slow(pgd_t *pgd)
  80 {
  81         free_page((unsigned long)pgd);
  82 }
  83
  84 extern pte_t *get_pte_slow(pmd_t *pmd, unsigned long address_preadjusted);
  85 extern pte_t *get_pte_kernel_slow(pmd_t *pmd, unsigned long address_preadjusted);
  86
  87 extern __inline__ pte_t *get_pte_fast(void)
  88 {
  89         unsigned long *ret;
  90
  91         if((ret = (unsigned long *)pte_quicklist) != NULL) {
  92                 pte_quicklist = (unsigned long *)(*ret);
  93                 ret[0] = ret[1];
  94                 pgtable_cache_size--;
  95         }
  96         return (pte_t *)ret;
  97 }
  98
  99 extern __inline__ void free_pte_fast(pte_t *pte)
 100 {
 101         *(unsigned long *)pte = (unsigned long) pte_quicklist;
 102         pte_quicklist = (unsigned long *) pte;
 103         pgtable_cache_size++;
 104 }
 105
 106 extern __inline__ void free_pte_slow(pte_t *pte)
 107 {
 108         free_page((unsigned long)pte);
 109 }
 110
 111 /* We don't use pmd cache, so these are dummy routines */
 112 extern __inline__ pmd_t *get_pmd_fast(void)
 113 {
 114         return (pmd_t *)0;
 115 }
 116
 117 extern __inline__ void free_pmd_fast(pmd_t *pmd)
 118 {
 119 }
 120
 121 extern __inline__ void free_pmd_slow(pmd_t *pmd)
 122 {
 123 }
 124
 125 extern void __bad_pte(pmd_t *pmd);
 126 extern void __bad_pte_kernel(pmd_t *pmd);
 127
 128 #define pte_free_kernel(pte)    free_pte_fast(pte)
 129 #define pte_free(pte)           free_pte_fast(pte)
 130 #define pgd_free(pgd)           free_pgd_fast(pgd)
 131 #define pgd_alloc()             get_pgd_fast()
 132
 133 extern inline pte_t * pte_alloc_kernel(pmd_t * pmd, unsigned long address)
 134 {
 135         address = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
 136
 137         if (pmd_none(*pmd)) {
 138                 pte_t *page = get_pte_fast();
 139                 if (page) {
 140                         pmd_val(*pmd) = (unsigned long)page;
 141                         return page + address;
 142                 }
 143                 return get_pte_kernel_slow(pmd, address);
 144         }
 145         if (pmd_bad(*pmd)) {
 146                 __bad_pte_kernel(pmd);
 147                 return NULL;
 148         }
 149         return (pte_t *) pmd_page(*pmd) + address;
 150 }
 151
 152 extern inline pte_t * pte_alloc(pmd_t * pmd, unsigned long address)
 153 {
 154         address = (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);
 155
 156         if (pmd_none(*pmd)) {
 157                 pte_t *page = get_pte_fast();
 158                 if (page) {
 159                         pmd_val(*pmd) = (unsigned long)page;
 160                         return page + address;
 161                 }
 162                 return get_pte_slow(pmd, address);
 163         }
 164         if (pmd_bad(*pmd)) {
 165                 __bad_pte(pmd);
 166                 return NULL;
 167         }
 168         return (pte_t *) pmd_page(*pmd) + address;
 169 }
 170
 171 /*
 172  * allocating and freeing a pmd is trivial: the 1-entry pmd is
 173  * inside the pgd, so has no extra memory associated with it.
 174  */
 175 extern inline void pmd_free(pmd_t * pmd)
 176 {
 177 }
 178
 179 extern inline pmd_t * pmd_alloc(pgd_t * pgd, unsigned long address)
 180 {
 181         return (pmd_t *) pgd;
 182 }
 183
 184 #define pmd_free_kernel         pmd_free
 185 #define pmd_alloc_kernel        pmd_alloc
 186
 187 extern int do_check_pgt_cache(int, int);
 188
 189 extern inline void set_pgdir(unsigned long address, pgd_t entry)
 190 {
 191         struct task_struct * p;
 192         pgd_t *pgd;
 193 #ifdef CONFIG_SMP
 194         int i;
 195 #endif
 196
 197         read_lock(&tasklist_lock);
 198         for_each_task(p) {
 199                 if (!p->mm)
 200                         continue;
 201                 *pgd_offset(p->mm,address) = entry;
 202         }
 203         read_unlock(&tasklist_lock);
 204 #ifndef CONFIG_SMP
 205         for (pgd = (pgd_t *)pgd_quicklist; pgd; pgd = (pgd_t *)*(unsigned long *)pgd)
 206                 pgd[address >> PGDIR_SHIFT] = entry;
 207 #else
 208         /* To pgd_alloc/pgd_free, one holds master kernel lock and so does our
 209            callee, so we can modify pgd caches of other CPUs as well. -jj */
 210         for (i = 0; i < NR_CPUS; i++)
 211                 for (pgd = (pgd_t *)cpu_data[i].pgd_quick; pgd; pgd = (pgd_t *)*(unsigned long *)pgd)
 212                         pgd[address >> PGDIR_SHIFT] = entry;
 213 #endif
 214 }
 215
 216 #endif /* _ASM_PGALLOC_H */