mm/mprotect.c

   1 /*
   2  *      linux/mm/mprotect.c
   3  *
   4  *  (C) Copyright 1994 Linus Torvalds
   5  */
   6 #include <linux/slab.h>
   7 #include <linux/smp_lock.h>
   8 #include <linux/shm.h>
   9 #include <linux/mman.h>
  10
  11 #include <asm/uaccess.h>
  12 #include <asm/pgalloc.h>
  13
  14 static inline void change_pte_range(pmd_t * pmd, unsigned long address,
  15         unsigned long size, pgprot_t newprot)
  16 {
  17         pte_t * pte;
  18         unsigned long end;
  19
  20         if (pmd_none(*pmd))
  21                 return;
  22         if (pmd_bad(*pmd)) {
  23                 pmd_ERROR(*pmd);
  24                 pmd_clear(pmd);
  25                 return;
  26         }
  27         pte = pte_offset(pmd, address);
  28         address &= ~PMD_MASK;
  29         end = address + size;
  30         if (end > PMD_SIZE)
  31                 end = PMD_SIZE;
  32         do {
  33                 pte_t entry = *pte;
  34                 if (pte_present(entry))
  35                         set_pte(pte, pte_modify(entry, newprot));
  36                 address += PAGE_SIZE;
  37                 pte++;
  38         } while (address && (address < end));
  39 }
  40
  41 static inline void change_pmd_range(pgd_t * pgd, unsigned long address,
  42         unsigned long size, pgprot_t newprot)
  43 {
  44         pmd_t * pmd;
  45         unsigned long end;
  46
  47         if (pgd_none(*pgd))
  48                 return;
  49         if (pgd_bad(*pgd)) {
  50                 pgd_ERROR(*pgd);
  51                 pgd_clear(pgd);
  52                 return;
  53         }
  54         pmd = pmd_offset(pgd, address);
  55         address &= ~PGDIR_MASK;
  56         end = address + size;
  57         if (end > PGDIR_SIZE)
  58                 end = PGDIR_SIZE;
  59         do {
  60                 change_pte_range(pmd, address, end - address, newprot);
  61                 address = (address + PMD_SIZE) & PMD_MASK;
  62                 pmd++;
  63         } while (address && (address < end));
  64 }
  65
  66 static void change_protection(unsigned long start, unsigned long end, pgprot_t newprot)
  67 {
  68         pgd_t *dir;
  69         unsigned long beg = start;
  70
  71         dir = pgd_offset(current->mm, start);
  72         flush_cache_range(current->mm, beg, end);
  73         if (start >= end)
  74                 BUG();
  75         spin_lock(&current->mm->page_table_lock);
  76         do {
  77                 change_pmd_range(dir, start, end - start, newprot);
  78                 start = (start + PGDIR_SIZE) & PGDIR_MASK;
  79                 dir++;
  80         } while (start && (start < end));
  81         spin_unlock(&current->mm->page_table_lock);
  82         flush_tlb_range(current->mm, beg, end);
  83         return;
  84 }
  85
  86 static inline int mprotect_fixup_all(struct vm_area_struct * vma,
  87         int newflags, pgprot_t prot)
  88 {
  89         vmlist_modify_lock(vma->vm_mm);
  90         vma->vm_flags = newflags;
  91         vma->vm_page_prot = prot;
  92         vmlist_modify_unlock(vma->vm_mm);
  93         return 0;
  94 }
  95
  96 static inline int mprotect_fixup_start(struct vm_area_struct * vma,
  97         unsigned long end,
  98         int newflags, pgprot_t prot)
  99 {
 100         struct vm_area_struct * n;
 101
 102         n = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);
 103         if (!n)
 104                 return -ENOMEM;
 105         *n = *vma;
 106         n->vm_end = end;
 107         n->vm_flags = newflags;
 108         n->vm_raend = 0;
 109         n->vm_page_prot = prot;
 110         if (n->vm_file)
 111                 get_file(n->vm_file);
 112         if (n->vm_ops && n->vm_ops->open)
 113                 n->vm_ops->open(n);
 114         vmlist_modify_lock(vma->vm_mm);
 115         vma->vm_pgoff += (end - vma->vm_start) >> PAGE_SHIFT;
 116         vma->vm_start = end;
 117         insert_vm_struct(current->mm, n);
 118         vmlist_modify_unlock(vma->vm_mm);
 119         return 0;
 120 }
 121
 122 static inline int mprotect_fixup_end(struct vm_area_struct * vma,
 123         unsigned long start,
 124         int newflags, pgprot_t prot)
 125 {
 126         struct vm_area_struct * n;
 127
 128         n = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
 129         if (!n)
 130                 return -ENOMEM;
 131         *n = *vma;
 132         n->vm_start = start;
 133         n->vm_pgoff += (n->vm_start - vma->vm_start) >> PAGE_SHIFT;
 134         n->vm_flags = newflags;
 135         n->vm_raend = 0;
 136         n->vm_page_prot = prot;
 137         if (n->vm_file)
 138                 get_file(n->vm_file);
 139         if (n->vm_ops && n->vm_ops->open)
 140                 n->vm_ops->open(n);
 141         vmlist_modify_lock(vma->vm_mm);
 142         vma->vm_end = start;
 143         insert_vm_struct(current->mm, n);
 144         vmlist_modify_unlock(vma->vm_mm);
 145         return 0;
 146 }
 147
 148 static inline int mprotect_fixup_middle(struct vm_area_struct * vma,
 149         unsigned long start, unsigned long end,
 150         int newflags, pgprot_t prot)
 151 {
 152         struct vm_area_struct * left, * right;
 153
 154         left = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);
 155         if (!left)
 156                 return -ENOMEM;
 157         right = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);
 158         if (!right) {
 159                 kmem_cache_free(vm_area_cachep, left);
 160                 return -ENOMEM;
 161         }
 162         *left = *vma;
 163         *right = *vma;
 164         left->vm_end = start;
 165         right->vm_start = end;
 166         right->vm_pgoff += (right->vm_start - left->vm_start) >> PAGE_SHIFT;
 167         left->vm_raend = 0;
 168         right->vm_raend = 0;
 169         if (vma->vm_file)
 170                 atomic_add(2,&vma->vm_file->f_count);
 171         if (vma->vm_ops && vma->vm_ops->open) {
 172                 vma->vm_ops->open(left);
 173                 vma->vm_ops->open(right);
 174         }
 175         vmlist_modify_lock(vma->vm_mm);
 176         vma->vm_pgoff += (start - vma->vm_start) >> PAGE_SHIFT;
 177         vma->vm_start = start;
 178         vma->vm_end = end;
 179         vma->vm_flags = newflags;
 180         vma->vm_raend = 0;
 181         vma->vm_page_prot = prot;
 182         insert_vm_struct(current->mm, left);
 183         insert_vm_struct(current->mm, right);
 184         vmlist_modify_unlock(vma->vm_mm);
 185         return 0;
 186 }
 187
 188 static int mprotect_fixup(struct vm_area_struct * vma,
 189         unsigned long start, unsigned long end, unsigned int newflags)
 190 {
 191         pgprot_t newprot;
 192         int error;
 193
 194         if (newflags == vma->vm_flags)
 195                 return 0;
 196         newprot = protection_map[newflags & 0xf];
 197         if (start == vma->vm_start) {
 198                 if (end == vma->vm_end)
 199                         error = mprotect_fixup_all(vma, newflags, newprot);
 200                 else
 201                         error = mprotect_fixup_start(vma, end, newflags, newprot);
 202         } else if (end == vma->vm_end)
 203                 error = mprotect_fixup_end(vma, start, newflags, newprot);
 204         else
 205                 error = mprotect_fixup_middle(vma, start, end, newflags, newprot);
 206
 207         if (error)
 208                 return error;
 209
 210         change_protection(start, end, newprot);
 211         return 0;
 212 }
 213
 214 asmlinkage long sys_mprotect(unsigned long start, size_t len, unsigned long prot)
 215 {
 216         unsigned long nstart, end, tmp;
 217         struct vm_area_struct * vma, * next;
 218         int error = -EINVAL;
 219
 220         if (start & ~PAGE_MASK)
 221                 return -EINVAL;
 222         len = PAGE_ALIGN(len);
 223         end = start + len;
 224         if (end < start)
 225                 return -EINVAL;
 226         if (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC))
 227                 return -EINVAL;
 228         if (end == start)
 229                 return 0;
 230
 231         down(&current->mm->mmap_sem);
 232
 233         vma = find_vma(current->mm, start);
 234         error = -EFAULT;
 235         if (!vma || vma->vm_start > start)
 236                 goto out;
 237
 238         for (nstart = start ; ; ) {
 239                 unsigned int newflags;
 240
 241                 /* Here we know that  vma->vm_start <= nstart < vma->vm_end. */
 242
 243                 newflags = prot | (vma->vm_flags & ~(PROT_READ | PROT_WRITE | PROT_EXEC));
 244                 if ((newflags & ~(newflags >> 4)) & 0xf) {
 245                         error = -EACCES;
 246                         break;
 247                 }
 248
 249                 if (vma->vm_end >= end) {
 250                         error = mprotect_fixup(vma, nstart, end, newflags);
 251                         break;
 252                 }
 253
 254                 tmp = vma->vm_end;
 255                 next = vma->vm_next;
 256                 error = mprotect_fixup(vma, nstart, tmp, newflags);
 257                 if (error)
 258                         break;
 259                 nstart = tmp;
 260                 vma = next;
 261                 if (!vma || vma->vm_start != nstart) {
 262                         error = -EFAULT;
 263                         break;
 264                 }
 265         }
 266         vmlist_modify_lock(current->mm);
 267         merge_segments(current->mm, start, end);
 268         vmlist_modify_unlock(current->mm);
 269 out:
 270         up(&current->mm->mmap_sem);
 271         return error;
 272 }