| Message ID | 20210205151631.43511-11-kirill.shutemov@linux.intel.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | Linear Address Masking enabling | expand |
On Fri, Feb 5, 2021 at 7:16 AM Kirill A. Shutemov <kirill.shutemov@linux.intel.com> wrote: > > Provide prctl() interface to enabled LAM for user addresses. Depending > how many tag bits requested it may result in enabling LAM_U57 or > LAM_U48. I prefer the alternate kernel interface based on CET arch_prctl interface which is implemented in glibc on users/intel/lam/master branch: https://gitlab.com/x86-glibc/glibc/-/tree/users/intel/lam/master and in GCC on users/intel/lam/master branch: https://gitlab.com/x86-gcc/gcc/-/tree/users/intel/lam/master
On Fri, Feb 5, 2021 at 4:43 PM H.J. Lu <hjl.tools@gmail.com> wrote: > > On Fri, Feb 5, 2021 at 7:16 AM Kirill A. Shutemov > <kirill.shutemov@linux.intel.com> wrote: > > > > Provide prctl() interface to enabled LAM for user addresses. Depending > > how many tag bits requested it may result in enabling LAM_U57 or > > LAM_U48. > > I prefer the alternate kernel interface based on CET arch_prctl interface which > is implemented in glibc on users/intel/lam/master branch: > > https://gitlab.com/x86-glibc/glibc/-/tree/users/intel/lam/master > > and in GCC on users/intel/lam/master branch: > > https://gitlab.com/x86-gcc/gcc/-/tree/users/intel/lam/master Hi Kirill, H.J., I don't have strong preference for PR_SET/GET_TAGGED_ADDR_CTRL vs ARCH_X86_FEATURE_1_ENABLE itself, but tying LAM to ELF and GNU_PROPERTY in the second option looks strange. LAM can be used outside of ELF/GNU, right?
On Sun, Feb 07, 2021 at 09:07:02AM +0100, Dmitry Vyukov wrote: > On Fri, Feb 5, 2021 at 4:43 PM H.J. Lu <hjl.tools@gmail.com> wrote: > > > > On Fri, Feb 5, 2021 at 7:16 AM Kirill A. Shutemov > > <kirill.shutemov@linux.intel.com> wrote: > > > > > > Provide prctl() interface to enabled LAM for user addresses. Depending > > > how many tag bits requested it may result in enabling LAM_U57 or > > > LAM_U48. > > > > I prefer the alternate kernel interface based on CET arch_prctl interface which > > is implemented in glibc on users/intel/lam/master branch: > > > > https://gitlab.com/x86-glibc/glibc/-/tree/users/intel/lam/master > > > > and in GCC on users/intel/lam/master branch: > > > > https://gitlab.com/x86-gcc/gcc/-/tree/users/intel/lam/master > > Hi Kirill, H.J., > > I don't have strong preference for PR_SET/GET_TAGGED_ADDR_CTRL vs > ARCH_X86_FEATURE_1_ENABLE itself, but tying LAM to ELF and > GNU_PROPERTY in the second option looks strange. LAM can be used > outside of ELF/GNU, right? Sure. In both cases it's still a syscall.
On Sun, Feb 7, 2021 at 3:09 PM Kirill A. Shutemov <kirill@shutemov.name> wrote: > > On Sun, Feb 07, 2021 at 09:07:02AM +0100, Dmitry Vyukov wrote: > > On Fri, Feb 5, 2021 at 4:43 PM H.J. Lu <hjl.tools@gmail.com> wrote: > > > > > > On Fri, Feb 5, 2021 at 7:16 AM Kirill A. Shutemov > > > <kirill.shutemov@linux.intel.com> wrote: > > > > > > > > Provide prctl() interface to enabled LAM for user addresses. Depending > > > > how many tag bits requested it may result in enabling LAM_U57 or > > > > LAM_U48. > > > > > > I prefer the alternate kernel interface based on CET arch_prctl interface which > > > is implemented in glibc on users/intel/lam/master branch: > > > > > > https://gitlab.com/x86-glibc/glibc/-/tree/users/intel/lam/master > > > > > > and in GCC on users/intel/lam/master branch: > > > > > > https://gitlab.com/x86-gcc/gcc/-/tree/users/intel/lam/master > > > > Hi Kirill, H.J., > > > > I don't have strong preference for PR_SET/GET_TAGGED_ADDR_CTRL vs > > ARCH_X86_FEATURE_1_ENABLE itself, but tying LAM to ELF and > > GNU_PROPERTY in the second option looks strange. LAM can be used > > outside of ELF/GNU, right? > > Sure. In both cases it's still a syscall. Oh, I meant just the naming scheme. The consts are declared in elf.h and are prefixed with GNU_PROPERTY.
diff --git a/arch/x86/include/asm/processor.h b/arch/x86/include/asm/processor.h index 82a08b585818..49fac2cc4329 100644 --- a/arch/x86/include/asm/processor.h +++ b/arch/x86/include/asm/processor.h @@ -810,6 +810,16 @@ extern void start_thread(struct pt_regs *regs, unsigned long new_ip, extern int get_tsc_mode(unsigned long adr); extern int set_tsc_mode(unsigned int val); +#ifdef CONFIG_X86_64 +long set_tagged_addr_ctrl(unsigned long flags, + int __user *nr_bits, int __user *offset); +long get_tagged_addr_ctrl(int __user *nr_bits, int __user *offset); +#define SET_TAGGED_ADDR_CTRL(flags, nr_bits, offset) \ + set_tagged_addr_ctrl(flags, nr_bits, offset) +#define GET_TAGGED_ADDR_CTRL(nr_bits, offset) \ + get_tagged_addr_ctrl(nr_bits, offset) +#endif + DECLARE_PER_CPU(u64, msr_misc_features_shadow); #ifdef CONFIG_CPU_SUP_AMD diff --git a/arch/x86/kernel/process_64.c b/arch/x86/kernel/process_64.c index df342bedea88..99b87f0e1bc7 100644 --- a/arch/x86/kernel/process_64.c +++ b/arch/x86/kernel/process_64.c @@ -837,3 +837,148 @@ unsigned long KSTK_ESP(struct task_struct *task) { return task_pt_regs(task)->sp; } + +/* + * Control the relaxed ABI allowing tagged user addresses into the kernel. + */ +static unsigned int tagged_addr_disabled; + +static bool lam_u48_allowed(void) +{ + struct mm_struct *mm = current->mm; + + if (!full_va_allowed(mm)) + return true; + + return find_vma(mm, DEFAULT_MAP_WINDOW) == NULL; +} + +#define LAM_U48_BITS 15 +#define LAM_U57_BITS 6 + +long set_tagged_addr_ctrl(unsigned long flags, + int __user *nr_bits, int __user *offset) +{ + int val; + + if (in_32bit_syscall()) + return -EINVAL; + if (flags & ~PR_TAGGED_ADDR_ENABLE) + return -EINVAL; + if (!boot_cpu_has(X86_FEATURE_LAM)) + return -ENOTSUPP; + + /* Disable LAM */ + if (!(flags & PR_TAGGED_ADDR_ENABLE)) { + clear_thread_flag(TIF_LAM_U48); + clear_thread_flag(TIF_LAM_U57); + + /* Update CR3 */ + switch_mm(current->mm, current->mm, current); + + return 0; + } + + /* + * nr_bits == NULL || offset == NULL assumes ARM TBI (nr_bits == 8, + * offset == 56). LAM cannot provide this. + */ + if (!nr_bits || !offset) + return -EINVAL; + + /* + * Do not allow the enabling of the tagged address ABI if globally + * disabled via sysctl abi.tagged_addr_disabled. + */ + if (tagged_addr_disabled) + return -EINVAL; + + if (get_user(val, nr_bits)) + return -EFAULT; + if (val > LAM_U48_BITS || val < 1) + return -EINVAL; + if (val > LAM_U57_BITS && !lam_u48_allowed()) + return -EINVAL; + + val = val > LAM_U57_BITS ? LAM_U48_BITS : LAM_U57_BITS; + if (put_user(val, nr_bits) || put_user(63 - val, offset)) + return -EFAULT; + + if (val == LAM_U57_BITS) { + clear_thread_flag(TIF_LAM_U48); + set_thread_flag(TIF_LAM_U57); + if (current->mm->context.lam == LAM_NONE) + current->mm->context.lam = LAM_U57; + } else { + clear_thread_flag(TIF_LAM_U57); + set_thread_flag(TIF_LAM_U48); + + /* + * Do not allow to create a mapping above 47 bit. + * + * It's one way road: once a thread of the process enabled + * LAM_U48, no thread can ever create mapping above 47 bit. + * Even the LAM got disabled later. + */ + current->mm->context.lam = LAM_U48; + } + + /* Update CR3 */ + switch_mm(current->mm, current->mm, current); + + return 0; +} + +long get_tagged_addr_ctrl(int __user *nr_bits, int __user *offset) +{ + if (in_32bit_syscall()) + return -EINVAL; + + if (test_thread_flag(TIF_LAM_U57)) { + if (nr_bits && put_user(LAM_U57_BITS, nr_bits)) + return -EFAULT; + if (offset && put_user(63 - LAM_U57_BITS, offset)) + return -EFAULT; + } else if (test_thread_flag(TIF_LAM_U48)) { + if (nr_bits && put_user(LAM_U48_BITS, nr_bits)) + return -EFAULT; + if (offset && put_user(63 - LAM_U48_BITS, offset)) + return -EFAULT; + } else { + int max_bits = lam_u48_allowed() ? LAM_U48_BITS : LAM_U57_BITS; + + /* Report maximum tag size */ + if (nr_bits && put_user(max_bits, nr_bits)) + return -EFAULT; + return 0; + } + + return PR_TAGGED_ADDR_ENABLE; +} + +/* + * Global sysctl to disable the tagged user addresses support. This control + * only prevents the tagged address ABI enabling via prctl() and does not + * disable it for tasks that already opted in to the relaxed ABI. + */ + +static struct ctl_table tagged_addr_sysctl_table[] = { + { + .procname = "tagged_addr_disabled", + .mode = 0644, + .data = &tagged_addr_disabled, + .maxlen = sizeof(int), + .proc_handler = proc_dointvec_minmax, + .extra1 = SYSCTL_ZERO, + .extra2 = SYSCTL_ONE, + }, + { } +}; + +static int __init tagged_addr_init(void) +{ + if (!register_sysctl("abi", tagged_addr_sysctl_table)) + return -EINVAL; + return 0; +} +core_initcall(tagged_addr_init);
Provide prctl() interface to enabled LAM for user addresses. Depending how many tag bits requested it may result in enabling LAM_U57 or LAM_U48. If LAM_U48 is enabled, the process is no longer able to use full address space on 5-level paging machine and gets limited to 47-bit VA. Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com> --- arch/x86/include/asm/processor.h | 10 +++ arch/x86/kernel/process_64.c | 145 +++++++++++++++++++++++++++++++ 2 files changed, 155 insertions(+)