367b7f6c063736958e7f266e3a21fd32c3613245
[linux-2.6.git] / mm / mprotect.c
1 /*
2  *  mm/mprotect.c
3  *
4  *  (C) Copyright 1994 Linus Torvalds
5  *  (C) Copyright 2002 Christoph Hellwig
6  *
7  *  Address space accounting code       <alan@redhat.com>
8  *  (C) Copyright 2002 Red Hat Inc, All Rights Reserved
9  */
10
11 #include <linux/mm.h>
12 #include <linux/hugetlb.h>
13 #include <linux/slab.h>
14 #include <linux/shm.h>
15 #include <linux/mman.h>
16 #include <linux/fs.h>
17 #include <linux/highmem.h>
18 #include <linux/security.h>
19 #include <linux/mempolicy.h>
20 #include <linux/personality.h>
21 #include <linux/syscalls.h>
22 #include <linux/swap.h>
23 #include <linux/swapops.h>
24 #include <asm/uaccess.h>
25 #include <asm/pgtable.h>
26 #include <asm/cacheflush.h>
27 #include <asm/tlbflush.h>
28
29 static void change_pte_range(struct mm_struct *mm, pmd_t *pmd,
30                 unsigned long addr, unsigned long end, pgprot_t newprot)
31 {
32         pte_t *pte, oldpte;
33         spinlock_t *ptl;
34
35         pte = pte_offset_map_lock(mm, pmd, addr, &ptl);
36         do {
37                 oldpte = *pte;
38                 if (pte_present(oldpte)) {
39                         pte_t ptent;
40
41                         /* Avoid an SMP race with hardware updated dirty/clean
42                          * bits by wiping the pte and then setting the new pte
43                          * into place.
44                          */
45                         ptent = pte_modify(ptep_get_and_clear(mm, addr, pte), newprot);
46                         set_pte_at(mm, addr, pte, ptent);
47                         lazy_mmu_prot_update(ptent);
48 #ifdef CONFIG_MIGRATION
49                 } else if (!pte_file(oldpte)) {
50                         swp_entry_t entry = pte_to_swp_entry(oldpte);
51
52                         if (is_write_migration_entry(entry)) {
53                                 /*
54                                  * A protection check is difficult so
55                                  * just be safe and disable write
56                                  */
57                                 make_migration_entry_read(&entry);
58                                 set_pte_at(mm, addr, pte,
59                                         swp_entry_to_pte(entry));
60                         }
61 #endif
62                 }
63
64         } while (pte++, addr += PAGE_SIZE, addr != end);
65         pte_unmap_unlock(pte - 1, ptl);
66 }
67
68 static inline void change_pmd_range(struct mm_struct *mm, pud_t *pud,
69                 unsigned long addr, unsigned long end, pgprot_t newprot)
70 {
71         pmd_t *pmd;
72         unsigned long next;
73
74         pmd = pmd_offset(pud, addr);
75         do {
76                 next = pmd_addr_end(addr, end);
77                 if (pmd_none_or_clear_bad(pmd))
78                         continue;
79                 change_pte_range(mm, pmd, addr, next, newprot);
80         } while (pmd++, addr = next, addr != end);
81 }
82
83 static inline void change_pud_range(struct mm_struct *mm, pgd_t *pgd,
84                 unsigned long addr, unsigned long end, pgprot_t newprot)
85 {
86         pud_t *pud;
87         unsigned long next;
88
89         pud = pud_offset(pgd, addr);
90         do {
91                 next = pud_addr_end(addr, end);
92                 if (pud_none_or_clear_bad(pud))
93                         continue;
94                 change_pmd_range(mm, pud, addr, next, newprot);
95         } while (pud++, addr = next, addr != end);
96 }
97
98 static void change_protection(struct vm_area_struct *vma,
99                 unsigned long addr, unsigned long end, pgprot_t newprot)
100 {
101         struct mm_struct *mm = vma->vm_mm;
102         pgd_t *pgd;
103         unsigned long next;
104         unsigned long start = addr;
105
106         BUG_ON(addr >= end);
107         pgd = pgd_offset(mm, addr);
108         flush_cache_range(vma, addr, end);
109         do {
110                 next = pgd_addr_end(addr, end);
111                 if (pgd_none_or_clear_bad(pgd))
112                         continue;
113                 change_pud_range(mm, pgd, addr, next, newprot);
114         } while (pgd++, addr = next, addr != end);
115         flush_tlb_range(vma, start, end);
116 }
117
118 static int
119 mprotect_fixup(struct vm_area_struct *vma, struct vm_area_struct **pprev,
120         unsigned long start, unsigned long end, unsigned long newflags)
121 {
122         struct mm_struct *mm = vma->vm_mm;
123         unsigned long oldflags = vma->vm_flags;
124         long nrpages = (end - start) >> PAGE_SHIFT;
125         unsigned long charged = 0;
126         pgoff_t pgoff;
127         int error;
128
129         if (newflags == oldflags) {
130                 *pprev = vma;
131                 return 0;
132         }
133
134         /*
135          * If we make a private mapping writable we increase our commit;
136          * but (without finer accounting) cannot reduce our commit if we
137          * make it unwritable again.
138          *
139          * FIXME? We haven't defined a VM_NORESERVE flag, so mprotecting
140          * a MAP_NORESERVE private mapping to writable will now reserve.
141          */
142         if (newflags & VM_WRITE) {
143                 if (!(oldflags & (VM_ACCOUNT|VM_WRITE|VM_SHARED))) {
144                         charged = nrpages;
145                         if (security_vm_enough_memory(charged))
146                                 return -ENOMEM;
147                         newflags |= VM_ACCOUNT;
148                 }
149         }
150
151         /*
152          * First try to merge with previous and/or next vma.
153          */
154         pgoff = vma->vm_pgoff + ((start - vma->vm_start) >> PAGE_SHIFT);
155         *pprev = vma_merge(mm, *pprev, start, end, newflags,
156                         vma->anon_vma, vma->vm_file, pgoff, vma_policy(vma));
157         if (*pprev) {
158                 vma = *pprev;
159                 goto success;
160         }
161
162         *pprev = vma;
163
164         if (start != vma->vm_start) {
165                 error = split_vma(mm, vma, start, 1);
166                 if (error)
167                         goto fail;
168         }
169
170         if (end != vma->vm_end) {
171                 error = split_vma(mm, vma, end, 0);
172                 if (error)
173                         goto fail;
174         }
175
176 success:
177         /*
178          * vm_flags and vm_page_prot are protected by the mmap_sem
179          * held in write mode.
180          */
181         vma->vm_flags = newflags;
182         vma->vm_page_prot = protection_map[newflags &
183                 (VM_READ|VM_WRITE|VM_EXEC|VM_SHARED)];
184         if (vma_wants_writenotify(vma))
185                 vma->vm_page_prot = protection_map[newflags &
186                         (VM_READ|VM_WRITE|VM_EXEC)];
187
188         if (is_vm_hugetlb_page(vma))
189                 hugetlb_change_protection(vma, start, end, vma->vm_page_prot);
190         else
191                 change_protection(vma, start, end, vma->vm_page_prot);
192         vm_stat_account(mm, oldflags, vma->vm_file, -nrpages);
193         vm_stat_account(mm, newflags, vma->vm_file, nrpages);
194         return 0;
195
196 fail:
197         vm_unacct_memory(charged);
198         return error;
199 }
200
201 asmlinkage long
202 sys_mprotect(unsigned long start, size_t len, unsigned long prot)
203 {
204         unsigned long vm_flags, nstart, end, tmp, reqprot;
205         struct vm_area_struct *vma, *prev;
206         int error = -EINVAL;
207         const int grows = prot & (PROT_GROWSDOWN|PROT_GROWSUP);
208         prot &= ~(PROT_GROWSDOWN|PROT_GROWSUP);
209         if (grows == (PROT_GROWSDOWN|PROT_GROWSUP)) /* can't be both */
210                 return -EINVAL;
211
212         if (start & ~PAGE_MASK)
213                 return -EINVAL;
214         if (!len)
215                 return 0;
216         len = PAGE_ALIGN(len);
217         end = start + len;
218         if (end <= start)
219                 return -ENOMEM;
220         if (prot & ~(PROT_READ | PROT_WRITE | PROT_EXEC | PROT_SEM))
221                 return -EINVAL;
222
223         reqprot = prot;
224         /*
225          * Does the application expect PROT_READ to imply PROT_EXEC:
226          */
227         if ((prot & PROT_READ) && (current->personality & READ_IMPLIES_EXEC))
228                 prot |= PROT_EXEC;
229
230         vm_flags = calc_vm_prot_bits(prot);
231
232         down_write(&current->mm->mmap_sem);
233
234         vma = find_vma_prev(current->mm, start, &prev);
235         error = -ENOMEM;
236         if (!vma)
237                 goto out;
238         if (unlikely(grows & PROT_GROWSDOWN)) {
239                 if (vma->vm_start >= end)
240                         goto out;
241                 start = vma->vm_start;
242                 error = -EINVAL;
243                 if (!(vma->vm_flags & VM_GROWSDOWN))
244                         goto out;
245         }
246         else {
247                 if (vma->vm_start > start)
248                         goto out;
249                 if (unlikely(grows & PROT_GROWSUP)) {
250                         end = vma->vm_end;
251                         error = -EINVAL;
252                         if (!(vma->vm_flags & VM_GROWSUP))
253                                 goto out;
254                 }
255         }
256         if (start > vma->vm_start)
257                 prev = vma;
258
259         for (nstart = start ; ; ) {
260                 unsigned long newflags;
261
262                 /* Here we know that  vma->vm_start <= nstart < vma->vm_end. */
263
264                 newflags = vm_flags | (vma->vm_flags & ~(VM_READ | VM_WRITE | VM_EXEC));
265
266                 /* newflags >> 4 shift VM_MAY% in place of VM_% */
267                 if ((newflags & ~(newflags >> 4)) & (VM_READ | VM_WRITE | VM_EXEC)) {
268                         error = -EACCES;
269                         goto out;
270                 }
271
272                 error = security_file_mprotect(vma, reqprot, prot);
273                 if (error)
274                         goto out;
275
276                 tmp = vma->vm_end;
277                 if (tmp > end)
278                         tmp = end;
279                 error = mprotect_fixup(vma, &prev, nstart, tmp, newflags);
280                 if (error)
281                         goto out;
282                 nstart = tmp;
283
284                 if (nstart < prev->vm_end)
285                         nstart = prev->vm_end;
286                 if (nstart >= end)
287                         goto out;
288
289                 vma = prev->vm_next;
290                 if (!vma || vma->vm_start != nstart) {
291                         error = -ENOMEM;
292                         goto out;
293                 }
294         }
295 out:
296         up_write(&current->mm->mmap_sem);
297         return error;
298 }