1 // SPDX-License-Identifier: GPL-2.0
5 * (C) Copyright 1994 Linus Torvalds
6 * (C) Copyright 2002 Christoph Hellwig
8 * Address space accounting code <alan@lxorguk.ukuu.org.uk>
9 * (C) Copyright 2002 Red Hat Inc, All Rights Reserved
12 #include <linux/pagewalk.h>
13 #include <linux/hugetlb.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>
22 #include <linux/swap.h>
23 #include <linux/swapops.h>
24 #include <linux/mmu_notifier.h>
25 #include <linux/migrate.h>
26 #include <linux/perf_event.h>
27 #include <linux/pkeys.h>
28 #include <linux/ksm.h>
29 #include <linux/uaccess.h>
30 #include <linux/mm_inline.h>
31 #include <linux/pgtable.h>
32 #include <linux/sched/sysctl.h>
33 #include <linux/userfaultfd_k.h>
34 #include <linux/memory-tiers.h>
35 #include <asm/cacheflush.h>
36 #include <asm/mmu_context.h>
37 #include <asm/tlbflush.h>
42 bool can_change_pte_writable(struct vm_area_struct
*vma
, unsigned long addr
,
47 if (WARN_ON_ONCE(!(vma
->vm_flags
& VM_WRITE
)))
50 /* Don't touch entries that are not even readable. */
51 if (pte_protnone(pte
))
54 /* Do we need write faults for softdirty tracking? */
55 if (vma_soft_dirty_enabled(vma
) && !pte_soft_dirty(pte
))
58 /* Do we need write faults for uffd-wp tracking? */
59 if (userfaultfd_pte_wp(vma
, pte
))
62 if (!(vma
->vm_flags
& VM_SHARED
)) {
64 * Writable MAP_PRIVATE mapping: We can only special-case on
65 * exclusive anonymous pages, because we know that our
66 * write-fault handler similarly would map them writable without
67 * any additional checks while holding the PT lock.
69 page
= vm_normal_page(vma
, addr
, pte
);
70 return page
&& PageAnon(page
) && PageAnonExclusive(page
);
74 * Writable MAP_SHARED mapping: "clean" might indicate that the FS still
75 * needs a real write-fault for writenotify
76 * (see vma_wants_writenotify()). If "dirty", the assumption is that the
77 * FS was already notified and we can simply mark the PTE writable
78 * just like the write-fault handler would do.
80 return pte_dirty(pte
);
83 static long change_pte_range(struct mmu_gather
*tlb
,
84 struct vm_area_struct
*vma
, pmd_t
*pmd
, unsigned long addr
,
85 unsigned long end
, pgprot_t newprot
, unsigned long cp_flags
)
90 int target_node
= NUMA_NO_NODE
;
91 bool prot_numa
= cp_flags
& MM_CP_PROT_NUMA
;
92 bool uffd_wp
= cp_flags
& MM_CP_UFFD_WP
;
93 bool uffd_wp_resolve
= cp_flags
& MM_CP_UFFD_WP_RESOLVE
;
95 tlb_change_page_size(tlb
, PAGE_SIZE
);
96 pte
= pte_offset_map_lock(vma
->vm_mm
, pmd
, addr
, &ptl
);
100 /* Get target node for single threaded private VMAs */
101 if (prot_numa
&& !(vma
->vm_flags
& VM_SHARED
) &&
102 atomic_read(&vma
->vm_mm
->mm_users
) == 1)
103 target_node
= numa_node_id();
105 flush_tlb_batched_pending(vma
->vm_mm
);
106 arch_enter_lazy_mmu_mode();
108 oldpte
= ptep_get(pte
);
109 if (pte_present(oldpte
)) {
113 * Avoid trapping faults against the zero or KSM
114 * pages. See similar comment in change_huge_pmd.
121 /* Avoid TLB flush if possible */
122 if (pte_protnone(oldpte
))
125 page
= vm_normal_page(vma
, addr
, oldpte
);
126 if (!page
|| is_zone_device_page(page
) || PageKsm(page
))
129 /* Also skip shared copy-on-write pages */
130 if (is_cow_mapping(vma
->vm_flags
) &&
131 page_count(page
) != 1)
135 * While migration can move some dirty pages,
136 * it cannot move them all from MIGRATE_ASYNC
139 if (page_is_file_lru(page
) && PageDirty(page
))
143 * Don't mess with PTEs if page is already on the node
144 * a single-threaded process is running on.
146 nid
= page_to_nid(page
);
147 if (target_node
== nid
)
149 toptier
= node_is_toptier(nid
);
152 * Skip scanning top tier node if normal numa
153 * balancing is disabled
155 if (!(sysctl_numa_balancing_mode
& NUMA_BALANCING_NORMAL
) &&
158 if (sysctl_numa_balancing_mode
& NUMA_BALANCING_MEMORY_TIERING
&&
160 xchg_page_access_time(page
,
161 jiffies_to_msecs(jiffies
));
164 oldpte
= ptep_modify_prot_start(vma
, addr
, pte
);
165 ptent
= pte_modify(oldpte
, newprot
);
168 ptent
= pte_mkuffd_wp(ptent
);
169 else if (uffd_wp_resolve
)
170 ptent
= pte_clear_uffd_wp(ptent
);
173 * In some writable, shared mappings, we might want
174 * to catch actual write access -- see
175 * vma_wants_writenotify().
177 * In all writable, private mappings, we have to
178 * properly handle COW.
180 * In both cases, we can sometimes still change PTEs
181 * writable and avoid the write-fault handler, for
182 * example, if a PTE is already dirty and no other
183 * COW or special handling is required.
185 if ((cp_flags
& MM_CP_TRY_CHANGE_WRITABLE
) &&
187 can_change_pte_writable(vma
, addr
, ptent
))
188 ptent
= pte_mkwrite(ptent
, vma
);
190 ptep_modify_prot_commit(vma
, addr
, pte
, oldpte
, ptent
);
191 if (pte_needs_flush(oldpte
, ptent
))
192 tlb_flush_pte_range(tlb
, addr
, PAGE_SIZE
);
194 } else if (is_swap_pte(oldpte
)) {
195 swp_entry_t entry
= pte_to_swp_entry(oldpte
);
198 if (is_writable_migration_entry(entry
)) {
199 struct page
*page
= pfn_swap_entry_to_page(entry
);
202 * A protection check is difficult so
203 * just be safe and disable write
206 entry
= make_readable_exclusive_migration_entry(
209 entry
= make_readable_migration_entry(swp_offset(entry
));
210 newpte
= swp_entry_to_pte(entry
);
211 if (pte_swp_soft_dirty(oldpte
))
212 newpte
= pte_swp_mksoft_dirty(newpte
);
213 } else if (is_writable_device_private_entry(entry
)) {
215 * We do not preserve soft-dirtiness. See
216 * copy_nonpresent_pte() for explanation.
218 entry
= make_readable_device_private_entry(
220 newpte
= swp_entry_to_pte(entry
);
221 if (pte_swp_uffd_wp(oldpte
))
222 newpte
= pte_swp_mkuffd_wp(newpte
);
223 } else if (is_writable_device_exclusive_entry(entry
)) {
224 entry
= make_readable_device_exclusive_entry(
226 newpte
= swp_entry_to_pte(entry
);
227 if (pte_swp_soft_dirty(oldpte
))
228 newpte
= pte_swp_mksoft_dirty(newpte
);
229 if (pte_swp_uffd_wp(oldpte
))
230 newpte
= pte_swp_mkuffd_wp(newpte
);
231 } else if (is_pte_marker_entry(entry
)) {
233 * Ignore error swap entries unconditionally,
234 * because any access should sigbus anyway.
236 if (is_poisoned_swp_entry(entry
))
239 * If this is uffd-wp pte marker and we'd like
240 * to unprotect it, drop it; the next page
241 * fault will trigger without uffd trapping.
243 if (uffd_wp_resolve
) {
244 pte_clear(vma
->vm_mm
, addr
, pte
);
253 newpte
= pte_swp_mkuffd_wp(newpte
);
254 else if (uffd_wp_resolve
)
255 newpte
= pte_swp_clear_uffd_wp(newpte
);
257 if (!pte_same(oldpte
, newpte
)) {
258 set_pte_at(vma
->vm_mm
, addr
, pte
, newpte
);
262 /* It must be an none page, or what else?.. */
263 WARN_ON_ONCE(!pte_none(oldpte
));
266 * Nobody plays with any none ptes besides
267 * userfaultfd when applying the protections.
269 if (likely(!uffd_wp
))
272 if (userfaultfd_wp_use_markers(vma
)) {
274 * For file-backed mem, we need to be able to
275 * wr-protect a none pte, because even if the
276 * pte is none, the page/swap cache could
277 * exist. Doing that by install a marker.
279 set_pte_at(vma
->vm_mm
, addr
, pte
,
280 make_pte_marker(PTE_MARKER_UFFD_WP
));
284 } while (pte
++, addr
+= PAGE_SIZE
, addr
!= end
);
285 arch_leave_lazy_mmu_mode();
286 pte_unmap_unlock(pte
- 1, ptl
);
292 * Return true if we want to split THPs into PTE mappings in change
293 * protection procedure, false otherwise.
296 pgtable_split_needed(struct vm_area_struct
*vma
, unsigned long cp_flags
)
299 * pte markers only resides in pte level, if we need pte markers,
300 * we need to split. We cannot wr-protect shmem thp because file
301 * thp is handled differently when split by erasing the pmd so far.
303 return (cp_flags
& MM_CP_UFFD_WP
) && !vma_is_anonymous(vma
);
307 * Return true if we want to populate pgtables in change protection
308 * procedure, false otherwise
311 pgtable_populate_needed(struct vm_area_struct
*vma
, unsigned long cp_flags
)
313 /* If not within ioctl(UFFDIO_WRITEPROTECT), then don't bother */
314 if (!(cp_flags
& MM_CP_UFFD_WP
))
317 /* Populate if the userfaultfd mode requires pte markers */
318 return userfaultfd_wp_use_markers(vma
);
322 * Populate the pgtable underneath for whatever reason if requested.
323 * When {pte|pmd|...}_alloc() failed we treat it the same way as pgtable
324 * allocation failures during page faults by kicking OOM and returning
327 #define change_pmd_prepare(vma, pmd, cp_flags) \
330 if (unlikely(pgtable_populate_needed(vma, cp_flags))) { \
331 if (pte_alloc(vma->vm_mm, pmd)) \
338 * This is the general pud/p4d/pgd version of change_pmd_prepare(). We need to
339 * have separate change_pmd_prepare() because pte_alloc() returns 0 on success,
340 * while {pmd|pud|p4d}_alloc() returns the valid pointer on success.
342 #define change_prepare(vma, high, low, addr, cp_flags) \
345 if (unlikely(pgtable_populate_needed(vma, cp_flags))) { \
346 low##_t *p = low##_alloc(vma->vm_mm, high, addr); \
353 static inline long change_pmd_range(struct mmu_gather
*tlb
,
354 struct vm_area_struct
*vma
, pud_t
*pud
, unsigned long addr
,
355 unsigned long end
, pgprot_t newprot
, unsigned long cp_flags
)
360 unsigned long nr_huge_updates
= 0;
361 struct mmu_notifier_range range
;
365 pmd
= pmd_offset(pud
, addr
);
370 next
= pmd_addr_end(addr
, end
);
372 ret
= change_pmd_prepare(vma
, pmd
, cp_flags
);
381 /* invoke the mmu notifier if the pmd is populated */
383 mmu_notifier_range_init(&range
,
384 MMU_NOTIFY_PROTECTION_VMA
, 0,
385 vma
->vm_mm
, addr
, end
);
386 mmu_notifier_invalidate_range_start(&range
);
389 _pmd
= pmdp_get_lockless(pmd
);
390 if (is_swap_pmd(_pmd
) || pmd_trans_huge(_pmd
) || pmd_devmap(_pmd
)) {
391 if ((next
- addr
!= HPAGE_PMD_SIZE
) ||
392 pgtable_split_needed(vma
, cp_flags
)) {
393 __split_huge_pmd(vma
, pmd
, addr
, false, NULL
);
395 * For file-backed, the pmd could have been
396 * cleared; make sure pmd populated if
397 * necessary, then fall-through to pte level.
399 ret
= change_pmd_prepare(vma
, pmd
, cp_flags
);
405 ret
= change_huge_pmd(tlb
, vma
, pmd
,
406 addr
, newprot
, cp_flags
);
408 if (ret
== HPAGE_PMD_NR
) {
409 pages
+= HPAGE_PMD_NR
;
413 /* huge pmd was handled */
417 /* fall through, the trans huge pmd just split */
420 ret
= change_pte_range(tlb
, vma
, pmd
, addr
, next
, newprot
,
427 } while (pmd
++, addr
= next
, addr
!= end
);
430 mmu_notifier_invalidate_range_end(&range
);
433 count_vm_numa_events(NUMA_HUGE_PTE_UPDATES
, nr_huge_updates
);
437 static inline long change_pud_range(struct mmu_gather
*tlb
,
438 struct vm_area_struct
*vma
, p4d_t
*p4d
, unsigned long addr
,
439 unsigned long end
, pgprot_t newprot
, unsigned long cp_flags
)
445 pud
= pud_offset(p4d
, addr
);
447 next
= pud_addr_end(addr
, end
);
448 ret
= change_prepare(vma
, pud
, pmd
, addr
, cp_flags
);
451 if (pud_none_or_clear_bad(pud
))
453 pages
+= change_pmd_range(tlb
, vma
, pud
, addr
, next
, newprot
,
455 } while (pud
++, addr
= next
, addr
!= end
);
460 static inline long change_p4d_range(struct mmu_gather
*tlb
,
461 struct vm_area_struct
*vma
, pgd_t
*pgd
, unsigned long addr
,
462 unsigned long end
, pgprot_t newprot
, unsigned long cp_flags
)
468 p4d
= p4d_offset(pgd
, addr
);
470 next
= p4d_addr_end(addr
, end
);
471 ret
= change_prepare(vma
, p4d
, pud
, addr
, cp_flags
);
474 if (p4d_none_or_clear_bad(p4d
))
476 pages
+= change_pud_range(tlb
, vma
, p4d
, addr
, next
, newprot
,
478 } while (p4d
++, addr
= next
, addr
!= end
);
483 static long change_protection_range(struct mmu_gather
*tlb
,
484 struct vm_area_struct
*vma
, unsigned long addr
,
485 unsigned long end
, pgprot_t newprot
, unsigned long cp_flags
)
487 struct mm_struct
*mm
= vma
->vm_mm
;
493 pgd
= pgd_offset(mm
, addr
);
494 tlb_start_vma(tlb
, vma
);
496 next
= pgd_addr_end(addr
, end
);
497 ret
= change_prepare(vma
, pgd
, p4d
, addr
, cp_flags
);
502 if (pgd_none_or_clear_bad(pgd
))
504 pages
+= change_p4d_range(tlb
, vma
, pgd
, addr
, next
, newprot
,
506 } while (pgd
++, addr
= next
, addr
!= end
);
508 tlb_end_vma(tlb
, vma
);
513 long change_protection(struct mmu_gather
*tlb
,
514 struct vm_area_struct
*vma
, unsigned long start
,
515 unsigned long end
, unsigned long cp_flags
)
517 pgprot_t newprot
= vma
->vm_page_prot
;
520 BUG_ON((cp_flags
& MM_CP_UFFD_WP_ALL
) == MM_CP_UFFD_WP_ALL
);
522 #ifdef CONFIG_NUMA_BALANCING
524 * Ordinary protection updates (mprotect, uffd-wp, softdirty tracking)
525 * are expected to reflect their requirements via VMA flags such that
526 * vma_set_page_prot() will adjust vma->vm_page_prot accordingly.
528 if (cp_flags
& MM_CP_PROT_NUMA
)
531 WARN_ON_ONCE(cp_flags
& MM_CP_PROT_NUMA
);
534 if (is_vm_hugetlb_page(vma
))
535 pages
= hugetlb_change_protection(vma
, start
, end
, newprot
,
538 pages
= change_protection_range(tlb
, vma
, start
, end
, newprot
,
544 static int prot_none_pte_entry(pte_t
*pte
, unsigned long addr
,
545 unsigned long next
, struct mm_walk
*walk
)
547 return pfn_modify_allowed(pte_pfn(ptep_get(pte
)),
548 *(pgprot_t
*)(walk
->private)) ?
552 static int prot_none_hugetlb_entry(pte_t
*pte
, unsigned long hmask
,
553 unsigned long addr
, unsigned long next
,
554 struct mm_walk
*walk
)
556 return pfn_modify_allowed(pte_pfn(ptep_get(pte
)),
557 *(pgprot_t
*)(walk
->private)) ?
561 static int prot_none_test(unsigned long addr
, unsigned long next
,
562 struct mm_walk
*walk
)
567 static const struct mm_walk_ops prot_none_walk_ops
= {
568 .pte_entry
= prot_none_pte_entry
,
569 .hugetlb_entry
= prot_none_hugetlb_entry
,
570 .test_walk
= prot_none_test
,
571 .walk_lock
= PGWALK_WRLOCK
,
575 mprotect_fixup(struct vma_iterator
*vmi
, struct mmu_gather
*tlb
,
576 struct vm_area_struct
*vma
, struct vm_area_struct
**pprev
,
577 unsigned long start
, unsigned long end
, unsigned long newflags
)
579 struct mm_struct
*mm
= vma
->vm_mm
;
580 unsigned long oldflags
= vma
->vm_flags
;
581 long nrpages
= (end
- start
) >> PAGE_SHIFT
;
582 unsigned int mm_cp_flags
= 0;
583 unsigned long charged
= 0;
587 if (newflags
== oldflags
) {
593 * Do PROT_NONE PFN permission checks here when we can still
594 * bail out without undoing a lot of state. This is a rather
595 * uncommon case, so doesn't need to be very optimized.
597 if (arch_has_pfn_modify_check() &&
598 (vma
->vm_flags
& (VM_PFNMAP
|VM_MIXEDMAP
)) &&
599 (newflags
& VM_ACCESS_FLAGS
) == 0) {
600 pgprot_t new_pgprot
= vm_get_page_prot(newflags
);
602 error
= walk_page_range(current
->mm
, start
, end
,
603 &prot_none_walk_ops
, &new_pgprot
);
609 * If we make a private mapping writable we increase our commit;
610 * but (without finer accounting) cannot reduce our commit if we
611 * make it unwritable again. hugetlb mapping were accounted for
612 * even if read-only so there is no need to account for them here
614 if (newflags
& VM_WRITE
) {
615 /* Check space limits when area turns into data. */
616 if (!may_expand_vm(mm
, newflags
, nrpages
) &&
617 may_expand_vm(mm
, oldflags
, nrpages
))
619 if (!(oldflags
& (VM_ACCOUNT
|VM_WRITE
|VM_HUGETLB
|
620 VM_SHARED
|VM_NORESERVE
))) {
622 if (security_vm_enough_memory_mm(mm
, charged
))
624 newflags
|= VM_ACCOUNT
;
629 * First try to merge with previous and/or next vma.
631 pgoff
= vma
->vm_pgoff
+ ((start
- vma
->vm_start
) >> PAGE_SHIFT
);
632 *pprev
= vma_merge(vmi
, mm
, *pprev
, start
, end
, newflags
,
633 vma
->anon_vma
, vma
->vm_file
, pgoff
, vma_policy(vma
),
634 vma
->vm_userfaultfd_ctx
, anon_vma_name(vma
));
637 VM_WARN_ON((vma
->vm_flags
^ newflags
) & ~VM_SOFTDIRTY
);
643 if (start
!= vma
->vm_start
) {
644 error
= split_vma(vmi
, vma
, start
, 1);
649 if (end
!= vma
->vm_end
) {
650 error
= split_vma(vmi
, vma
, end
, 0);
657 * vm_flags and vm_page_prot are protected by the mmap_lock
658 * held in write mode.
660 vma_start_write(vma
);
661 vm_flags_reset(vma
, newflags
);
662 if (vma_wants_manual_pte_write_upgrade(vma
))
663 mm_cp_flags
|= MM_CP_TRY_CHANGE_WRITABLE
;
664 vma_set_page_prot(vma
);
666 change_protection(tlb
, vma
, start
, end
, mm_cp_flags
);
669 * Private VM_LOCKED VMA becoming writable: trigger COW to avoid major
672 if ((oldflags
& (VM_WRITE
| VM_SHARED
| VM_LOCKED
)) == VM_LOCKED
&&
673 (newflags
& VM_WRITE
)) {
674 populate_vma_page_range(vma
, start
, end
, NULL
);
677 vm_stat_account(mm
, oldflags
, -nrpages
);
678 vm_stat_account(mm
, newflags
, nrpages
);
679 perf_event_mmap(vma
);
683 vm_unacct_memory(charged
);
688 * pkey==-1 when doing a legacy mprotect()
690 static int do_mprotect_pkey(unsigned long start
, size_t len
,
691 unsigned long prot
, int pkey
)
693 unsigned long nstart
, end
, tmp
, reqprot
;
694 struct vm_area_struct
*vma
, *prev
;
696 const int grows
= prot
& (PROT_GROWSDOWN
|PROT_GROWSUP
);
697 const bool rier
= (current
->personality
& READ_IMPLIES_EXEC
) &&
699 struct mmu_gather tlb
;
700 struct vma_iterator vmi
;
702 start
= untagged_addr(start
);
704 prot
&= ~(PROT_GROWSDOWN
|PROT_GROWSUP
);
705 if (grows
== (PROT_GROWSDOWN
|PROT_GROWSUP
)) /* can't be both */
708 if (start
& ~PAGE_MASK
)
712 len
= PAGE_ALIGN(len
);
716 if (!arch_validate_prot(prot
, start
))
721 if (mmap_write_lock_killable(current
->mm
))
725 * If userspace did not allocate the pkey, do not let
729 if ((pkey
!= -1) && !mm_pkey_is_allocated(current
->mm
, pkey
))
732 vma_iter_init(&vmi
, current
->mm
, start
);
733 vma
= vma_find(&vmi
, end
);
738 if (unlikely(grows
& PROT_GROWSDOWN
)) {
739 if (vma
->vm_start
>= end
)
741 start
= vma
->vm_start
;
743 if (!(vma
->vm_flags
& VM_GROWSDOWN
))
746 if (vma
->vm_start
> start
)
748 if (unlikely(grows
& PROT_GROWSUP
)) {
751 if (!(vma
->vm_flags
& VM_GROWSUP
))
756 prev
= vma_prev(&vmi
);
757 if (start
> vma
->vm_start
)
760 tlb_gather_mmu(&tlb
, current
->mm
);
763 for_each_vma_range(vmi
, vma
, end
) {
764 unsigned long mask_off_old_flags
;
765 unsigned long newflags
;
768 if (vma
->vm_start
!= tmp
) {
773 /* Does the application expect PROT_READ to imply PROT_EXEC */
774 if (rier
&& (vma
->vm_flags
& VM_MAYEXEC
))
778 * Each mprotect() call explicitly passes r/w/x permissions.
779 * If a permission is not passed to mprotect(), it must be
780 * cleared from the VMA.
782 mask_off_old_flags
= VM_ACCESS_FLAGS
| VM_FLAGS_CLEAR
;
784 new_vma_pkey
= arch_override_mprotect_pkey(vma
, prot
, pkey
);
785 newflags
= calc_vm_prot_bits(prot
, new_vma_pkey
);
786 newflags
|= (vma
->vm_flags
& ~mask_off_old_flags
);
788 /* newflags >> 4 shift VM_MAY% in place of VM_% */
789 if ((newflags
& ~(newflags
>> 4)) & VM_ACCESS_FLAGS
) {
794 if (map_deny_write_exec(vma
, newflags
)) {
799 /* Allow architectures to sanity-check the new flags */
800 if (!arch_validate_flags(newflags
)) {
805 error
= security_file_mprotect(vma
, reqprot
, prot
);
813 if (vma
->vm_ops
&& vma
->vm_ops
->mprotect
) {
814 error
= vma
->vm_ops
->mprotect(vma
, nstart
, tmp
, newflags
);
819 error
= mprotect_fixup(&vmi
, &tlb
, vma
, &prev
, nstart
, tmp
, newflags
);
823 tmp
= vma_iter_end(&vmi
);
827 tlb_finish_mmu(&tlb
);
829 if (!error
&& tmp
< end
)
833 mmap_write_unlock(current
->mm
);
837 SYSCALL_DEFINE3(mprotect
, unsigned long, start
, size_t, len
,
840 return do_mprotect_pkey(start
, len
, prot
, -1);
843 #ifdef CONFIG_ARCH_HAS_PKEYS
845 SYSCALL_DEFINE4(pkey_mprotect
, unsigned long, start
, size_t, len
,
846 unsigned long, prot
, int, pkey
)
848 return do_mprotect_pkey(start
, len
, prot
, pkey
);
851 SYSCALL_DEFINE2(pkey_alloc
, unsigned long, flags
, unsigned long, init_val
)
856 /* No flags supported yet. */
859 /* check for unsupported init values */
860 if (init_val
& ~PKEY_ACCESS_MASK
)
863 mmap_write_lock(current
->mm
);
864 pkey
= mm_pkey_alloc(current
->mm
);
870 ret
= arch_set_user_pkey_access(current
, pkey
, init_val
);
872 mm_pkey_free(current
->mm
, pkey
);
877 mmap_write_unlock(current
->mm
);
881 SYSCALL_DEFINE1(pkey_free
, int, pkey
)
885 mmap_write_lock(current
->mm
);
886 ret
= mm_pkey_free(current
->mm
, pkey
);
887 mmap_write_unlock(current
->mm
);
890 * We could provide warnings or errors if any VMA still
891 * has the pkey set here.
896 #endif /* CONFIG_ARCH_HAS_PKEYS */