~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/include/asm/pkeys.h

Version: ~ [ linux-5.12-rc7 ] ~ [ linux-5.11.13 ] ~ [ linux-5.10.29 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.111 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.186 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.230 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.266 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.266 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* SPDX-License-Identifier: GPL-2.0+ */
  2 /*
  3  * PowerPC Memory Protection Keys management
  4  *
  5  * Copyright 2017, Ram Pai, IBM Corporation.
  6  */
  7 
  8 #ifndef _ASM_POWERPC_KEYS_H
  9 #define _ASM_POWERPC_KEYS_H
 10 
 11 #include <linux/jump_label.h>
 12 #include <asm/firmware.h>
 13 
 14 DECLARE_STATIC_KEY_TRUE(pkey_disabled);
 15 extern int pkeys_total; /* total pkeys as per device tree */
 16 extern u32 initial_allocation_mask; /*  bits set for the initially allocated keys */
 17 extern u32 reserved_allocation_mask; /* bits set for reserved keys */
 18 
 19 #define ARCH_VM_PKEY_FLAGS (VM_PKEY_BIT0 | VM_PKEY_BIT1 | VM_PKEY_BIT2 | \
 20                             VM_PKEY_BIT3 | VM_PKEY_BIT4)
 21 
 22 /* Override any generic PKEY permission defines */
 23 #define PKEY_DISABLE_EXECUTE   0x4
 24 #define PKEY_ACCESS_MASK       (PKEY_DISABLE_ACCESS | \
 25                                 PKEY_DISABLE_WRITE  | \
 26                                 PKEY_DISABLE_EXECUTE)
 27 
 28 static inline u64 pkey_to_vmflag_bits(u16 pkey)
 29 {
 30         return (((u64)pkey << VM_PKEY_SHIFT) & ARCH_VM_PKEY_FLAGS);
 31 }
 32 
 33 static inline u64 vmflag_to_pte_pkey_bits(u64 vm_flags)
 34 {
 35         if (static_branch_likely(&pkey_disabled))
 36                 return 0x0UL;
 37 
 38         return (((vm_flags & VM_PKEY_BIT0) ? H_PTE_PKEY_BIT4 : 0x0UL) |
 39                 ((vm_flags & VM_PKEY_BIT1) ? H_PTE_PKEY_BIT3 : 0x0UL) |
 40                 ((vm_flags & VM_PKEY_BIT2) ? H_PTE_PKEY_BIT2 : 0x0UL) |
 41                 ((vm_flags & VM_PKEY_BIT3) ? H_PTE_PKEY_BIT1 : 0x0UL) |
 42                 ((vm_flags & VM_PKEY_BIT4) ? H_PTE_PKEY_BIT0 : 0x0UL));
 43 }
 44 
 45 static inline int vma_pkey(struct vm_area_struct *vma)
 46 {
 47         if (static_branch_likely(&pkey_disabled))
 48                 return 0;
 49         return (vma->vm_flags & ARCH_VM_PKEY_FLAGS) >> VM_PKEY_SHIFT;
 50 }
 51 
 52 #define arch_max_pkey() pkeys_total
 53 
 54 static inline u64 pte_to_hpte_pkey_bits(u64 pteflags)
 55 {
 56         return (((pteflags & H_PTE_PKEY_BIT0) ? HPTE_R_KEY_BIT0 : 0x0UL) |
 57                 ((pteflags & H_PTE_PKEY_BIT1) ? HPTE_R_KEY_BIT1 : 0x0UL) |
 58                 ((pteflags & H_PTE_PKEY_BIT2) ? HPTE_R_KEY_BIT2 : 0x0UL) |
 59                 ((pteflags & H_PTE_PKEY_BIT3) ? HPTE_R_KEY_BIT3 : 0x0UL) |
 60                 ((pteflags & H_PTE_PKEY_BIT4) ? HPTE_R_KEY_BIT4 : 0x0UL));
 61 }
 62 
 63 static inline u16 pte_to_pkey_bits(u64 pteflags)
 64 {
 65         return (((pteflags & H_PTE_PKEY_BIT0) ? 0x10 : 0x0UL) |
 66                 ((pteflags & H_PTE_PKEY_BIT1) ? 0x8 : 0x0UL) |
 67                 ((pteflags & H_PTE_PKEY_BIT2) ? 0x4 : 0x0UL) |
 68                 ((pteflags & H_PTE_PKEY_BIT3) ? 0x2 : 0x0UL) |
 69                 ((pteflags & H_PTE_PKEY_BIT4) ? 0x1 : 0x0UL));
 70 }
 71 
 72 #define pkey_alloc_mask(pkey) (0x1 << pkey)
 73 
 74 #define mm_pkey_allocation_map(mm) (mm->context.pkey_allocation_map)
 75 
 76 #define __mm_pkey_allocated(mm, pkey) { \
 77         mm_pkey_allocation_map(mm) |= pkey_alloc_mask(pkey); \
 78 }
 79 
 80 #define __mm_pkey_free(mm, pkey) {      \
 81         mm_pkey_allocation_map(mm) &= ~pkey_alloc_mask(pkey);   \
 82 }
 83 
 84 #define __mm_pkey_is_allocated(mm, pkey)        \
 85         (mm_pkey_allocation_map(mm) & pkey_alloc_mask(pkey))
 86 
 87 #define __mm_pkey_is_reserved(pkey) (reserved_allocation_mask & \
 88                                        pkey_alloc_mask(pkey))
 89 
 90 static inline bool mm_pkey_is_allocated(struct mm_struct *mm, int pkey)
 91 {
 92         if (pkey < 0 || pkey >= arch_max_pkey())
 93                 return false;
 94 
 95         /* Reserved keys are never allocated. */
 96         if (__mm_pkey_is_reserved(pkey))
 97                 return false;
 98 
 99         return __mm_pkey_is_allocated(mm, pkey);
100 }
101 
102 /*
103  * Returns a positive, 5-bit key on success, or -1 on failure.
104  * Relies on the mmap_sem to protect against concurrency in mm_pkey_alloc() and
105  * mm_pkey_free().
106  */
107 static inline int mm_pkey_alloc(struct mm_struct *mm)
108 {
109         /*
110          * Note: this is the one and only place we make sure that the pkey is
111          * valid as far as the hardware is concerned. The rest of the kernel
112          * trusts that only good, valid pkeys come out of here.
113          */
114         u32 all_pkeys_mask = (u32)(~(0x0));
115         int ret;
116 
117         if (static_branch_likely(&pkey_disabled))
118                 return -1;
119 
120         /*
121          * Are we out of pkeys? We must handle this specially because ffz()
122          * behavior is undefined if there are no zeros.
123          */
124         if (mm_pkey_allocation_map(mm) == all_pkeys_mask)
125                 return -1;
126 
127         ret = ffz((u32)mm_pkey_allocation_map(mm));
128         __mm_pkey_allocated(mm, ret);
129 
130         return ret;
131 }
132 
133 static inline int mm_pkey_free(struct mm_struct *mm, int pkey)
134 {
135         if (static_branch_likely(&pkey_disabled))
136                 return -1;
137 
138         if (!mm_pkey_is_allocated(mm, pkey))
139                 return -EINVAL;
140 
141         __mm_pkey_free(mm, pkey);
142 
143         return 0;
144 }
145 
146 /*
147  * Try to dedicate one of the protection keys to be used as an
148  * execute-only protection key.
149  */
150 extern int __execute_only_pkey(struct mm_struct *mm);
151 static inline int execute_only_pkey(struct mm_struct *mm)
152 {
153         if (static_branch_likely(&pkey_disabled))
154                 return -1;
155 
156         return __execute_only_pkey(mm);
157 }
158 
159 extern int __arch_override_mprotect_pkey(struct vm_area_struct *vma,
160                                          int prot, int pkey);
161 static inline int arch_override_mprotect_pkey(struct vm_area_struct *vma,
162                                               int prot, int pkey)
163 {
164         if (static_branch_likely(&pkey_disabled))
165                 return 0;
166 
167         /*
168          * Is this an mprotect_pkey() call? If so, never override the value that
169          * came from the user.
170          */
171         if (pkey != -1)
172                 return pkey;
173 
174         return __arch_override_mprotect_pkey(vma, prot, pkey);
175 }
176 
177 extern int __arch_set_user_pkey_access(struct task_struct *tsk, int pkey,
178                                        unsigned long init_val);
179 static inline int arch_set_user_pkey_access(struct task_struct *tsk, int pkey,
180                                             unsigned long init_val)
181 {
182         if (static_branch_likely(&pkey_disabled))
183                 return -EINVAL;
184 
185         /*
186          * userspace should not change pkey-0 permissions.
187          * pkey-0 is associated with every page in the kernel.
188          * If userspace denies any permission on pkey-0, the
189          * kernel cannot operate.
190          */
191         if (pkey == 0)
192                 return init_val ? -EINVAL : 0;
193 
194         return __arch_set_user_pkey_access(tsk, pkey, init_val);
195 }
196 
197 static inline bool arch_pkeys_enabled(void)
198 {
199         return !static_branch_likely(&pkey_disabled);
200 }
201 
202 extern void pkey_mm_init(struct mm_struct *mm);
203 extern bool arch_supports_pkeys(int cap);
204 extern unsigned int arch_usable_pkeys(void);
205 extern void thread_pkey_regs_save(struct thread_struct *thread);
206 extern void thread_pkey_regs_restore(struct thread_struct *new_thread,
207                                      struct thread_struct *old_thread);
208 extern void thread_pkey_regs_init(struct thread_struct *thread);
209 #endif /*_ASM_POWERPC_KEYS_H */
210 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp