mprotect.c 7.5 KB

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