arch/mips/mm/umap.c

   1 /*
   2  * arch/mips/mm/umap.c
   3  *
   4  * (C) Copyright 1994 Linus Torvalds
   5  *
   6  * Changes:
   7  *
   8  * Modified from Linus source to removing active mappings from any
   9  * task.  This is required for implementing the virtual graphics
  10  * interface for direct rendering on the SGI - miguel.
  11  *
  12  * Added a routine to map a vmalloc()ed area into user space, this one
  13  * is required by the /dev/shmiq driver - miguel.
  14  */
  15 #include <linux/stat.h>
  16 #include <linux/sched.h>
  17 #include <linux/kernel.h>
  18 #include <linux/mm.h>
  19 #include <linux/smp.h>
  20 #include <linux/smp_lock.h>
  21 #include <linux/shm.h>
  22 #include <linux/errno.h>
  23 #include <linux/mman.h>
  24 #include <linux/string.h>
  25 #include <linux/vmalloc.h>
  26 #include <linux/swap.h>
  27
  28 #include <asm/system.h>
  29 #include <asm/pgalloc.h>
  30 #include <asm/page.h>
  31
  32 static inline void
  33 remove_mapping_pte_range (pmd_t *pmd, unsigned long address, unsigned long size)
  34 {
  35         pte_t *pte;
  36         unsigned long end;
  37
  38         if (pmd_none (*pmd))
  39                 return;
  40         if (pmd_bad (*pmd)){
  41                 printk ("remove_graphics_pte_range: bad pmd (%08lx)\n", pmd_val (*pmd));
  42                 pmd_clear (pmd);
  43                 return;
  44         }
  45         pte = pte_offset (pmd, address);
  46         address &= ~PMD_MASK;
  47         end = address + size;
  48         if (end > PMD_SIZE)
  49                 end = PMD_SIZE;
  50         do {
  51                 pte_t entry = *pte;
  52                 if (pte_present (entry))
  53                         set_pte (pte, pte_modify (entry, PAGE_NONE));
  54                 address += PAGE_SIZE;
  55                 pte++;
  56         } while (address < end);
  57
  58 }
  59
  60 static inline void
  61 remove_mapping_pmd_range (pgd_t *pgd, unsigned long address, unsigned long size)
  62 {
  63         pmd_t *pmd;
  64         unsigned long end;
  65
  66         if (pgd_none (*pgd))
  67                 return;
  68
  69         if (pgd_bad (*pgd)){
  70                 printk ("remove_graphics_pmd_range: bad pgd (%08lx)\n", pgd_val (*pgd));
  71                 pgd_clear (pgd);
  72                 return;
  73         }
  74         pmd = pmd_offset (pgd, address);
  75         address &= ~PGDIR_MASK;
  76         end = address + size;
  77         if (end > PGDIR_SIZE)
  78                 end = PGDIR_SIZE;
  79         do {
  80                 remove_mapping_pte_range (pmd, address, end - address);
  81                 address = (address + PMD_SIZE) & PMD_MASK;
  82                 pmd++;
  83         } while (address < end);
  84
  85 }
  86
  87 /*
  88  * This routine is called from the page fault handler to remove a
  89  * range of active mappings at this point
  90  */
  91 void
  92 remove_mapping (struct task_struct *task, unsigned long start, unsigned long end)
  93 {
  94         unsigned long beg = start;
  95         pgd_t *dir;
  96
  97         down (&task->mm->mmap_sem);
  98         dir = pgd_offset (task->mm, start);
  99         flush_cache_range (task->mm, beg, end);
 100         while (start < end){
 101                 remove_mapping_pmd_range (dir, start, end - start);
 102                 start = (start + PGDIR_SIZE) & PGDIR_MASK;
 103                 dir++;
 104         }
 105         flush_tlb_range (task->mm, beg, end);
 106         up (&task->mm->mmap_sem);
 107 }
 108
 109 void *vmalloc_uncached (unsigned long size)
 110 {
 111         return __vmalloc (size, GFP_KERNEL | __GFP_HIGHMEM,
 112                           PAGE_KERNEL_UNCACHED);
 113 }
 114
 115 static inline void free_pte(pte_t page)
 116 {
 117         if (pte_present(page)) {
 118                 struct page *ptpage = pte_page(page);
 119                 if ((!VALID_PAGE(ptpage)) || PageReserved(ptpage))
 120                         return;
 121                 __free_page(ptpage);
 122                 if (current->mm->rss <= 0)
 123                         return;
 124                 current->mm->rss--;
 125                 return;
 126         }
 127         swap_free(pte_to_swp_entry(page));
 128 }
 129
 130 static inline void forget_pte(pte_t page)
 131 {
 132         if (!pte_none(page)) {
 133                 printk("forget_pte: old mapping existed!\n");
 134                 free_pte(page);
 135         }
 136 }
 137
 138 /*
 139  * maps a range of vmalloc()ed memory into the requested pages. the old
 140  * mappings are removed.
 141  */
 142 static inline void
 143 vmap_pte_range (pte_t *pte, unsigned long address, unsigned long size, unsigned long vaddr)
 144 {
 145         unsigned long end;
 146         pgd_t *vdir;
 147         pmd_t *vpmd;
 148         pte_t *vpte;
 149
 150         address &= ~PMD_MASK;
 151         end = address + size;
 152         if (end > PMD_SIZE)
 153                 end = PMD_SIZE;
 154         do {
 155                 pte_t oldpage = *pte;
 156                 struct page * page;
 157                 pte_clear(pte);
 158
 159                 vdir = pgd_offset_k (vaddr);
 160                 vpmd = pmd_offset (vdir, vaddr);
 161                 vpte = pte_offset (vpmd, vaddr);
 162                 page = pte_page (*vpte);
 163
 164                 set_pte(pte, mk_pte(page, PAGE_USERIO));
 165                 forget_pte(oldpage);
 166                 address += PAGE_SIZE;
 167                 vaddr += PAGE_SIZE;
 168                 pte++;
 169         } while (address < end);
 170 }
 171
 172 static inline int
 173 vmap_pmd_range (pmd_t *pmd, unsigned long address, unsigned long size, unsigned long vaddr)
 174 {
 175         unsigned long end;
 176
 177         address &= ~PGDIR_MASK;
 178         end = address + size;
 179         if (end > PGDIR_SIZE)
 180                 end = PGDIR_SIZE;
 181         vaddr -= address;
 182         do {
 183                 pte_t * pte = pte_alloc(pmd, address);
 184                 if (!pte)
 185                         return -ENOMEM;
 186                 vmap_pte_range(pte, address, end - address, address + vaddr);
 187                 address = (address + PMD_SIZE) & PMD_MASK;
 188                 pmd++;
 189         } while (address < end);
 190         return 0;
 191 }
 192
 193 int
 194 vmap_page_range (unsigned long from, unsigned long size, unsigned long vaddr)
 195 {
 196         int error = 0;
 197         pgd_t * dir;
 198         unsigned long beg = from;
 199         unsigned long end = from + size;
 200
 201         vaddr -= from;
 202         dir = pgd_offset(current->mm, from);
 203         flush_cache_range(current->mm, beg, end);
 204         while (from < end) {
 205                 pmd_t *pmd = pmd_alloc(dir, from);
 206                 error = -ENOMEM;
 207                 if (!pmd)
 208                         break;
 209                 error = vmap_pmd_range(pmd, from, end - from, vaddr + from);
 210                 if (error)
 211                         break;
 212                 from = (from + PGDIR_SIZE) & PGDIR_MASK;
 213                 dir++;
 214         }
 215         flush_tlb_range(current->mm, beg, end);
 216         return error;
 217 }