]>
git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - mm/mprotect.c
4 * (C) Copyright 1994 Linus Torvalds
5 * (C) Copyright 2002 Christoph Hellwig
7 * Address space accounting code <alan@redhat.com>
8 * (C) Copyright 2002 Red Hat Inc, All Rights Reserved
12 #include <linux/hugetlb.h>
13 #include <linux/slab.h>
14 #include <linux/shm.h>
15 #include <linux/mman.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>
23 #include <asm/uaccess.h>
24 #include <asm/pgtable.h>
25 #include <asm/cacheflush.h>
26 #include <asm/tlbflush.h>
28 static void change_pte_range(struct mm_struct
*mm
, pmd_t
*pmd
,
29 unsigned long addr
, unsigned long end
, pgprot_t newprot
)
33 pte
= pte_offset_map(pmd
, addr
);
35 if (pte_present(*pte
)) {
38 /* Avoid an SMP race with hardware updated dirty/clean
39 * bits by wiping the pte and then setting the new pte
42 ptent
= pte_modify(ptep_get_and_clear(mm
, addr
, pte
), newprot
);
43 set_pte_at(mm
, addr
, pte
, ptent
);
44 lazy_mmu_prot_update(ptent
);
46 } while (pte
++, addr
+= PAGE_SIZE
, addr
!= end
);
50 static inline void change_pmd_range(struct mm_struct
*mm
, pud_t
*pud
,
51 unsigned long addr
, unsigned long end
, pgprot_t newprot
)
56 pmd
= pmd_offset(pud
, addr
);
58 next
= pmd_addr_end(addr
, end
);
59 if (pmd_none_or_clear_bad(pmd
))
61 change_pte_range(mm
, pmd
, addr
, next
, newprot
);
62 } while (pmd
++, addr
= next
, addr
!= end
);
65 static inline void change_pud_range(struct mm_struct
*mm
, pgd_t
*pgd
,
66 unsigned long addr
, unsigned long end
, pgprot_t newprot
)
71 pud
= pud_offset(pgd
, addr
);
73 next
= pud_addr_end(addr
, end
);
74 if (pud_none_or_clear_bad(pud
))
76 change_pmd_range(mm
, pud
, addr
, next
, newprot
);
77 } while (pud
++, addr
= next
, addr
!= end
);
80 static void change_protection(struct vm_area_struct
*vma
,
81 unsigned long addr
, unsigned long end
, pgprot_t newprot
)
83 struct mm_struct
*mm
= vma
->vm_mm
;
86 unsigned long start
= addr
;
89 pgd
= pgd_offset(mm
, addr
);
90 flush_cache_range(vma
, addr
, end
);
91 spin_lock(&mm
->page_table_lock
);
93 next
= pgd_addr_end(addr
, end
);
94 if (pgd_none_or_clear_bad(pgd
))
96 change_pud_range(mm
, pgd
, addr
, next
, newprot
);
97 } while (pgd
++, addr
= next
, addr
!= end
);
98 flush_tlb_range(vma
, start
, end
);
99 spin_unlock(&mm
->page_table_lock
);
103 mprotect_fixup(struct vm_area_struct
*vma
, struct vm_area_struct
**pprev
,
104 unsigned long start
, unsigned long end
, unsigned long newflags
)
106 struct mm_struct
*mm
= vma
->vm_mm
;
107 unsigned long oldflags
= vma
->vm_flags
;
108 long nrpages
= (end
- start
) >> PAGE_SHIFT
;
109 unsigned long charged
= 0;
114 if (newflags
== oldflags
) {
120 * If we make a private mapping writable we increase our commit;
121 * but (without finer accounting) cannot reduce our commit if we
122 * make it unwritable again.
124 * FIXME? We haven't defined a VM_NORESERVE flag, so mprotecting
125 * a MAP_NORESERVE private mapping to writable will now reserve.
127 if (newflags
& VM_WRITE
) {
128 if (oldflags
& VM_RESERVED
) {
129 BUG_ON(oldflags
& VM_WRITE
);
130 printk(KERN_WARNING
"program %s is using MAP_PRIVATE, "
131 "PROT_WRITE mprotect of VM_RESERVED memory, "
132 "which is deprecated. Please report this to "
133 "linux-kernel@vger.kernel.org\n",current
->comm
);
136 if (!(oldflags
& (VM_ACCOUNT
|VM_WRITE
|VM_SHARED
|VM_HUGETLB
))) {
138 if (security_vm_enough_memory(charged
))
140 newflags
|= VM_ACCOUNT
;
144 newprot
= protection_map
[newflags
& 0xf];
147 * First try to merge with previous and/or next vma.
149 pgoff
= vma
->vm_pgoff
+ ((start
- vma
->vm_start
) >> PAGE_SHIFT
);
150 *pprev
= vma_merge(mm
, *pprev
, start
, end
, newflags
,
151 vma
->anon_vma
, vma
->vm_file
, pgoff
, vma_policy(vma
));
159 if (start
!= vma
->vm_start
) {
160 error
= split_vma(mm
, vma
, start
, 1);
165 if (end
!= vma
->vm_end
) {
166 error
= split_vma(mm
, vma
, end
, 0);
173 * vm_flags and vm_page_prot are protected by the mmap_sem
174 * held in write mode.
176 vma
->vm_flags
= newflags
;
177 vma
->vm_page_prot
= newprot
;
178 change_protection(vma
, start
, end
, newprot
);
179 vm_stat_account(mm
, oldflags
, vma
->vm_file
, -nrpages
);
180 vm_stat_account(mm
, newflags
, vma
->vm_file
, nrpages
);
184 vm_unacct_memory(charged
);
189 sys_mprotect(unsigned long start
, size_t len
, unsigned long prot
)
191 unsigned long vm_flags
, nstart
, end
, tmp
, reqprot
;
192 struct vm_area_struct
*vma
, *prev
;
194 const int grows
= prot
& (PROT_GROWSDOWN
|PROT_GROWSUP
);
195 prot
&= ~(PROT_GROWSDOWN
|PROT_GROWSUP
);
196 if (grows
== (PROT_GROWSDOWN
|PROT_GROWSUP
)) /* can't be both */
199 if (start
& ~PAGE_MASK
)
203 len
= PAGE_ALIGN(len
);
207 if (prot
& ~(PROT_READ
| PROT_WRITE
| PROT_EXEC
| PROT_SEM
))
212 * Does the application expect PROT_READ to imply PROT_EXEC:
214 if (unlikely((prot
& PROT_READ
) &&
215 (current
->personality
& READ_IMPLIES_EXEC
)))
218 vm_flags
= calc_vm_prot_bits(prot
);
220 down_write(¤t
->mm
->mmap_sem
);
222 vma
= find_vma_prev(current
->mm
, start
, &prev
);
226 if (unlikely(grows
& PROT_GROWSDOWN
)) {
227 if (vma
->vm_start
>= end
)
229 start
= vma
->vm_start
;
231 if (!(vma
->vm_flags
& VM_GROWSDOWN
))
235 if (vma
->vm_start
> start
)
237 if (unlikely(grows
& PROT_GROWSUP
)) {
240 if (!(vma
->vm_flags
& VM_GROWSUP
))
244 if (start
> vma
->vm_start
)
247 for (nstart
= start
; ; ) {
248 unsigned long newflags
;
250 /* Here we know that vma->vm_start <= nstart < vma->vm_end. */
252 if (is_vm_hugetlb_page(vma
)) {
257 newflags
= vm_flags
| (vma
->vm_flags
& ~(VM_READ
| VM_WRITE
| VM_EXEC
));
259 /* newflags >> 4 shift VM_MAY% in place of VM_% */
260 if ((newflags
& ~(newflags
>> 4)) & (VM_READ
| VM_WRITE
| VM_EXEC
)) {
265 error
= security_file_mprotect(vma
, reqprot
, prot
);
272 error
= mprotect_fixup(vma
, &prev
, nstart
, tmp
, newflags
);
277 if (nstart
< prev
->vm_end
)
278 nstart
= prev
->vm_end
;
283 if (!vma
|| vma
->vm_start
!= nstart
) {
289 up_write(¤t
->mm
->mmap_sem
);