![Dave Hansen](/assets/img/avatar_default.png)
We had originally planned on submitting MPX support in one patch set. We eventually broke it up in to two pieces for easier review. One of the features that didn't make the first round was supporting 32-bit binaries on 64-bit kernels. Once we split the set up, we never added code to restrict 32-bit binaries from _using_ MPX on 64-bit kernels. The 32-bit bounds tables are a different format than the 64-bit ones. Without this patch, the kernel will try to read a 32-bit binary's tables as if they were the 64-bit version. They will likely be noticed as being invalid rather quickly and the app will get killed, but that's kinda mean. This patch adds an explicit check, and will make a 64-bit kernel essentially behave as if it has no MPX support when called from a 32-bit binary. Signed-off-by: Dave Hansen <dave.hansen@linux.intel.com> Cc: Andy Lutomirski <luto@amacapital.net> Cc: Dave Hansen <dave@sr71.net> Link: http://lkml.kernel.org/r/20150108223020.9E9AA511@viggo.jf.intel.com Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
935 lines
24 KiB
C
935 lines
24 KiB
C
/*
|
|
* mpx.c - Memory Protection eXtensions
|
|
*
|
|
* Copyright (c) 2014, Intel Corporation.
|
|
* Qiaowei Ren <qiaowei.ren@intel.com>
|
|
* Dave Hansen <dave.hansen@intel.com>
|
|
*/
|
|
#include <linux/kernel.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/syscalls.h>
|
|
#include <linux/sched/sysctl.h>
|
|
|
|
#include <asm/i387.h>
|
|
#include <asm/insn.h>
|
|
#include <asm/mman.h>
|
|
#include <asm/mmu_context.h>
|
|
#include <asm/mpx.h>
|
|
#include <asm/processor.h>
|
|
#include <asm/fpu-internal.h>
|
|
|
|
static const char *mpx_mapping_name(struct vm_area_struct *vma)
|
|
{
|
|
return "[mpx]";
|
|
}
|
|
|
|
static struct vm_operations_struct mpx_vma_ops = {
|
|
.name = mpx_mapping_name,
|
|
};
|
|
|
|
static int is_mpx_vma(struct vm_area_struct *vma)
|
|
{
|
|
return (vma->vm_ops == &mpx_vma_ops);
|
|
}
|
|
|
|
/*
|
|
* This is really a simplified "vm_mmap". it only handles MPX
|
|
* bounds tables (the bounds directory is user-allocated).
|
|
*
|
|
* Later on, we use the vma->vm_ops to uniquely identify these
|
|
* VMAs.
|
|
*/
|
|
static unsigned long mpx_mmap(unsigned long len)
|
|
{
|
|
unsigned long ret;
|
|
unsigned long addr, pgoff;
|
|
struct mm_struct *mm = current->mm;
|
|
vm_flags_t vm_flags;
|
|
struct vm_area_struct *vma;
|
|
|
|
/* Only bounds table and bounds directory can be allocated here */
|
|
if (len != MPX_BD_SIZE_BYTES && len != MPX_BT_SIZE_BYTES)
|
|
return -EINVAL;
|
|
|
|
down_write(&mm->mmap_sem);
|
|
|
|
/* Too many mappings? */
|
|
if (mm->map_count > sysctl_max_map_count) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
/* Obtain the address to map to. we verify (or select) it and ensure
|
|
* that it represents a valid section of the address space.
|
|
*/
|
|
addr = get_unmapped_area(NULL, 0, len, 0, MAP_ANONYMOUS | MAP_PRIVATE);
|
|
if (addr & ~PAGE_MASK) {
|
|
ret = addr;
|
|
goto out;
|
|
}
|
|
|
|
vm_flags = VM_READ | VM_WRITE | VM_MPX |
|
|
mm->def_flags | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC;
|
|
|
|
/* Set pgoff according to addr for anon_vma */
|
|
pgoff = addr >> PAGE_SHIFT;
|
|
|
|
ret = mmap_region(NULL, addr, len, vm_flags, pgoff);
|
|
if (IS_ERR_VALUE(ret))
|
|
goto out;
|
|
|
|
vma = find_vma(mm, ret);
|
|
if (!vma) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
vma->vm_ops = &mpx_vma_ops;
|
|
|
|
if (vm_flags & VM_LOCKED) {
|
|
up_write(&mm->mmap_sem);
|
|
mm_populate(ret, len);
|
|
return ret;
|
|
}
|
|
|
|
out:
|
|
up_write(&mm->mmap_sem);
|
|
return ret;
|
|
}
|
|
|
|
enum reg_type {
|
|
REG_TYPE_RM = 0,
|
|
REG_TYPE_INDEX,
|
|
REG_TYPE_BASE,
|
|
};
|
|
|
|
static int get_reg_offset(struct insn *insn, struct pt_regs *regs,
|
|
enum reg_type type)
|
|
{
|
|
int regno = 0;
|
|
|
|
static const int regoff[] = {
|
|
offsetof(struct pt_regs, ax),
|
|
offsetof(struct pt_regs, cx),
|
|
offsetof(struct pt_regs, dx),
|
|
offsetof(struct pt_regs, bx),
|
|
offsetof(struct pt_regs, sp),
|
|
offsetof(struct pt_regs, bp),
|
|
offsetof(struct pt_regs, si),
|
|
offsetof(struct pt_regs, di),
|
|
#ifdef CONFIG_X86_64
|
|
offsetof(struct pt_regs, r8),
|
|
offsetof(struct pt_regs, r9),
|
|
offsetof(struct pt_regs, r10),
|
|
offsetof(struct pt_regs, r11),
|
|
offsetof(struct pt_regs, r12),
|
|
offsetof(struct pt_regs, r13),
|
|
offsetof(struct pt_regs, r14),
|
|
offsetof(struct pt_regs, r15),
|
|
#endif
|
|
};
|
|
int nr_registers = ARRAY_SIZE(regoff);
|
|
/*
|
|
* Don't possibly decode a 32-bit instructions as
|
|
* reading a 64-bit-only register.
|
|
*/
|
|
if (IS_ENABLED(CONFIG_X86_64) && !insn->x86_64)
|
|
nr_registers -= 8;
|
|
|
|
switch (type) {
|
|
case REG_TYPE_RM:
|
|
regno = X86_MODRM_RM(insn->modrm.value);
|
|
if (X86_REX_B(insn->rex_prefix.value) == 1)
|
|
regno += 8;
|
|
break;
|
|
|
|
case REG_TYPE_INDEX:
|
|
regno = X86_SIB_INDEX(insn->sib.value);
|
|
if (X86_REX_X(insn->rex_prefix.value) == 1)
|
|
regno += 8;
|
|
break;
|
|
|
|
case REG_TYPE_BASE:
|
|
regno = X86_SIB_BASE(insn->sib.value);
|
|
if (X86_REX_B(insn->rex_prefix.value) == 1)
|
|
regno += 8;
|
|
break;
|
|
|
|
default:
|
|
pr_err("invalid register type");
|
|
BUG();
|
|
break;
|
|
}
|
|
|
|
if (regno > nr_registers) {
|
|
WARN_ONCE(1, "decoded an instruction with an invalid register");
|
|
return -EINVAL;
|
|
}
|
|
return regoff[regno];
|
|
}
|
|
|
|
/*
|
|
* return the address being referenced be instruction
|
|
* for rm=3 returning the content of the rm reg
|
|
* for rm!=3 calculates the address using SIB and Disp
|
|
*/
|
|
static void __user *mpx_get_addr_ref(struct insn *insn, struct pt_regs *regs)
|
|
{
|
|
unsigned long addr, base, indx;
|
|
int addr_offset, base_offset, indx_offset;
|
|
insn_byte_t sib;
|
|
|
|
insn_get_modrm(insn);
|
|
insn_get_sib(insn);
|
|
sib = insn->sib.value;
|
|
|
|
if (X86_MODRM_MOD(insn->modrm.value) == 3) {
|
|
addr_offset = get_reg_offset(insn, regs, REG_TYPE_RM);
|
|
if (addr_offset < 0)
|
|
goto out_err;
|
|
addr = regs_get_register(regs, addr_offset);
|
|
} else {
|
|
if (insn->sib.nbytes) {
|
|
base_offset = get_reg_offset(insn, regs, REG_TYPE_BASE);
|
|
if (base_offset < 0)
|
|
goto out_err;
|
|
|
|
indx_offset = get_reg_offset(insn, regs, REG_TYPE_INDEX);
|
|
if (indx_offset < 0)
|
|
goto out_err;
|
|
|
|
base = regs_get_register(regs, base_offset);
|
|
indx = regs_get_register(regs, indx_offset);
|
|
addr = base + indx * (1 << X86_SIB_SCALE(sib));
|
|
} else {
|
|
addr_offset = get_reg_offset(insn, regs, REG_TYPE_RM);
|
|
if (addr_offset < 0)
|
|
goto out_err;
|
|
addr = regs_get_register(regs, addr_offset);
|
|
}
|
|
addr += insn->displacement.value;
|
|
}
|
|
return (void __user *)addr;
|
|
out_err:
|
|
return (void __user *)-1;
|
|
}
|
|
|
|
static int mpx_insn_decode(struct insn *insn,
|
|
struct pt_regs *regs)
|
|
{
|
|
unsigned char buf[MAX_INSN_SIZE];
|
|
int x86_64 = !test_thread_flag(TIF_IA32);
|
|
int not_copied;
|
|
int nr_copied;
|
|
|
|
not_copied = copy_from_user(buf, (void __user *)regs->ip, sizeof(buf));
|
|
nr_copied = sizeof(buf) - not_copied;
|
|
/*
|
|
* The decoder _should_ fail nicely if we pass it a short buffer.
|
|
* But, let's not depend on that implementation detail. If we
|
|
* did not get anything, just error out now.
|
|
*/
|
|
if (!nr_copied)
|
|
return -EFAULT;
|
|
insn_init(insn, buf, nr_copied, x86_64);
|
|
insn_get_length(insn);
|
|
/*
|
|
* copy_from_user() tries to get as many bytes as we could see in
|
|
* the largest possible instruction. If the instruction we are
|
|
* after is shorter than that _and_ we attempt to copy from
|
|
* something unreadable, we might get a short read. This is OK
|
|
* as long as the read did not stop in the middle of the
|
|
* instruction. Check to see if we got a partial instruction.
|
|
*/
|
|
if (nr_copied < insn->length)
|
|
return -EFAULT;
|
|
|
|
insn_get_opcode(insn);
|
|
/*
|
|
* We only _really_ need to decode bndcl/bndcn/bndcu
|
|
* Error out on anything else.
|
|
*/
|
|
if (insn->opcode.bytes[0] != 0x0f)
|
|
goto bad_opcode;
|
|
if ((insn->opcode.bytes[1] != 0x1a) &&
|
|
(insn->opcode.bytes[1] != 0x1b))
|
|
goto bad_opcode;
|
|
|
|
return 0;
|
|
bad_opcode:
|
|
return -EINVAL;
|
|
}
|
|
|
|
/*
|
|
* If a bounds overflow occurs then a #BR is generated. This
|
|
* function decodes MPX instructions to get violation address
|
|
* and set this address into extended struct siginfo.
|
|
*
|
|
* Note that this is not a super precise way of doing this.
|
|
* Userspace could have, by the time we get here, written
|
|
* anything it wants in to the instructions. We can not
|
|
* trust anything about it. They might not be valid
|
|
* instructions or might encode invalid registers, etc...
|
|
*
|
|
* The caller is expected to kfree() the returned siginfo_t.
|
|
*/
|
|
siginfo_t *mpx_generate_siginfo(struct pt_regs *regs,
|
|
struct xsave_struct *xsave_buf)
|
|
{
|
|
struct bndreg *bndregs, *bndreg;
|
|
siginfo_t *info = NULL;
|
|
struct insn insn;
|
|
uint8_t bndregno;
|
|
int err;
|
|
|
|
err = mpx_insn_decode(&insn, regs);
|
|
if (err)
|
|
goto err_out;
|
|
|
|
/*
|
|
* We know at this point that we are only dealing with
|
|
* MPX instructions.
|
|
*/
|
|
insn_get_modrm(&insn);
|
|
bndregno = X86_MODRM_REG(insn.modrm.value);
|
|
if (bndregno > 3) {
|
|
err = -EINVAL;
|
|
goto err_out;
|
|
}
|
|
/* get the bndregs _area_ of the xsave structure */
|
|
bndregs = get_xsave_addr(xsave_buf, XSTATE_BNDREGS);
|
|
if (!bndregs) {
|
|
err = -EINVAL;
|
|
goto err_out;
|
|
}
|
|
/* now go select the individual register in the set of 4 */
|
|
bndreg = &bndregs[bndregno];
|
|
|
|
info = kzalloc(sizeof(*info), GFP_KERNEL);
|
|
if (!info) {
|
|
err = -ENOMEM;
|
|
goto err_out;
|
|
}
|
|
/*
|
|
* The registers are always 64-bit, but the upper 32
|
|
* bits are ignored in 32-bit mode. Also, note that the
|
|
* upper bounds are architecturally represented in 1's
|
|
* complement form.
|
|
*
|
|
* The 'unsigned long' cast is because the compiler
|
|
* complains when casting from integers to different-size
|
|
* pointers.
|
|
*/
|
|
info->si_lower = (void __user *)(unsigned long)bndreg->lower_bound;
|
|
info->si_upper = (void __user *)(unsigned long)~bndreg->upper_bound;
|
|
info->si_addr_lsb = 0;
|
|
info->si_signo = SIGSEGV;
|
|
info->si_errno = 0;
|
|
info->si_code = SEGV_BNDERR;
|
|
info->si_addr = mpx_get_addr_ref(&insn, regs);
|
|
/*
|
|
* We were not able to extract an address from the instruction,
|
|
* probably because there was something invalid in it.
|
|
*/
|
|
if (info->si_addr == (void *)-1) {
|
|
err = -EINVAL;
|
|
goto err_out;
|
|
}
|
|
return info;
|
|
err_out:
|
|
/* info might be NULL, but kfree() handles that */
|
|
kfree(info);
|
|
return ERR_PTR(err);
|
|
}
|
|
|
|
static __user void *task_get_bounds_dir(struct task_struct *tsk)
|
|
{
|
|
struct bndcsr *bndcsr;
|
|
|
|
if (!cpu_feature_enabled(X86_FEATURE_MPX))
|
|
return MPX_INVALID_BOUNDS_DIR;
|
|
|
|
/*
|
|
* 32-bit binaries on 64-bit kernels are currently
|
|
* unsupported.
|
|
*/
|
|
if (IS_ENABLED(CONFIG_X86_64) && test_thread_flag(TIF_IA32))
|
|
return MPX_INVALID_BOUNDS_DIR;
|
|
/*
|
|
* The bounds directory pointer is stored in a register
|
|
* only accessible if we first do an xsave.
|
|
*/
|
|
fpu_save_init(&tsk->thread.fpu);
|
|
bndcsr = get_xsave_addr(&tsk->thread.fpu.state->xsave, XSTATE_BNDCSR);
|
|
if (!bndcsr)
|
|
return MPX_INVALID_BOUNDS_DIR;
|
|
|
|
/*
|
|
* Make sure the register looks valid by checking the
|
|
* enable bit.
|
|
*/
|
|
if (!(bndcsr->bndcfgu & MPX_BNDCFG_ENABLE_FLAG))
|
|
return MPX_INVALID_BOUNDS_DIR;
|
|
|
|
/*
|
|
* Lastly, mask off the low bits used for configuration
|
|
* flags, and return the address of the bounds table.
|
|
*/
|
|
return (void __user *)(unsigned long)
|
|
(bndcsr->bndcfgu & MPX_BNDCFG_ADDR_MASK);
|
|
}
|
|
|
|
int mpx_enable_management(struct task_struct *tsk)
|
|
{
|
|
void __user *bd_base = MPX_INVALID_BOUNDS_DIR;
|
|
struct mm_struct *mm = tsk->mm;
|
|
int ret = 0;
|
|
|
|
/*
|
|
* runtime in the userspace will be responsible for allocation of
|
|
* the bounds directory. Then, it will save the base of the bounds
|
|
* directory into XSAVE/XRSTOR Save Area and enable MPX through
|
|
* XRSTOR instruction.
|
|
*
|
|
* fpu_xsave() is expected to be very expensive. Storing the bounds
|
|
* directory here means that we do not have to do xsave in the unmap
|
|
* path; we can just use mm->bd_addr instead.
|
|
*/
|
|
bd_base = task_get_bounds_dir(tsk);
|
|
down_write(&mm->mmap_sem);
|
|
mm->bd_addr = bd_base;
|
|
if (mm->bd_addr == MPX_INVALID_BOUNDS_DIR)
|
|
ret = -ENXIO;
|
|
|
|
up_write(&mm->mmap_sem);
|
|
return ret;
|
|
}
|
|
|
|
int mpx_disable_management(struct task_struct *tsk)
|
|
{
|
|
struct mm_struct *mm = current->mm;
|
|
|
|
if (!cpu_feature_enabled(X86_FEATURE_MPX))
|
|
return -ENXIO;
|
|
|
|
down_write(&mm->mmap_sem);
|
|
mm->bd_addr = MPX_INVALID_BOUNDS_DIR;
|
|
up_write(&mm->mmap_sem);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* With 32-bit mode, MPX_BT_SIZE_BYTES is 4MB, and the size of each
|
|
* bounds table is 16KB. With 64-bit mode, MPX_BT_SIZE_BYTES is 2GB,
|
|
* and the size of each bounds table is 4MB.
|
|
*/
|
|
static int allocate_bt(long __user *bd_entry)
|
|
{
|
|
unsigned long expected_old_val = 0;
|
|
unsigned long actual_old_val = 0;
|
|
unsigned long bt_addr;
|
|
int ret = 0;
|
|
|
|
/*
|
|
* Carve the virtual space out of userspace for the new
|
|
* bounds table:
|
|
*/
|
|
bt_addr = mpx_mmap(MPX_BT_SIZE_BYTES);
|
|
if (IS_ERR((void *)bt_addr))
|
|
return PTR_ERR((void *)bt_addr);
|
|
/*
|
|
* Set the valid flag (kinda like _PAGE_PRESENT in a pte)
|
|
*/
|
|
bt_addr = bt_addr | MPX_BD_ENTRY_VALID_FLAG;
|
|
|
|
/*
|
|
* Go poke the address of the new bounds table in to the
|
|
* bounds directory entry out in userspace memory. Note:
|
|
* we may race with another CPU instantiating the same table.
|
|
* In that case the cmpxchg will see an unexpected
|
|
* 'actual_old_val'.
|
|
*
|
|
* This can fault, but that's OK because we do not hold
|
|
* mmap_sem at this point, unlike some of the other part
|
|
* of the MPX code that have to pagefault_disable().
|
|
*/
|
|
ret = user_atomic_cmpxchg_inatomic(&actual_old_val, bd_entry,
|
|
expected_old_val, bt_addr);
|
|
if (ret)
|
|
goto out_unmap;
|
|
|
|
/*
|
|
* The user_atomic_cmpxchg_inatomic() will only return nonzero
|
|
* for faults, *not* if the cmpxchg itself fails. Now we must
|
|
* verify that the cmpxchg itself completed successfully.
|
|
*/
|
|
/*
|
|
* We expected an empty 'expected_old_val', but instead found
|
|
* an apparently valid entry. Assume we raced with another
|
|
* thread to instantiate this table and desclare succecss.
|
|
*/
|
|
if (actual_old_val & MPX_BD_ENTRY_VALID_FLAG) {
|
|
ret = 0;
|
|
goto out_unmap;
|
|
}
|
|
/*
|
|
* We found a non-empty bd_entry but it did not have the
|
|
* VALID_FLAG set. Return an error which will result in
|
|
* a SEGV since this probably means that somebody scribbled
|
|
* some invalid data in to a bounds table.
|
|
*/
|
|
if (expected_old_val != actual_old_val) {
|
|
ret = -EINVAL;
|
|
goto out_unmap;
|
|
}
|
|
return 0;
|
|
out_unmap:
|
|
vm_munmap(bt_addr & MPX_BT_ADDR_MASK, MPX_BT_SIZE_BYTES);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* When a BNDSTX instruction attempts to save bounds to a bounds
|
|
* table, it will first attempt to look up the table in the
|
|
* first-level bounds directory. If it does not find a table in
|
|
* the directory, a #BR is generated and we get here in order to
|
|
* allocate a new table.
|
|
*
|
|
* With 32-bit mode, the size of BD is 4MB, and the size of each
|
|
* bound table is 16KB. With 64-bit mode, the size of BD is 2GB,
|
|
* and the size of each bound table is 4MB.
|
|
*/
|
|
static int do_mpx_bt_fault(struct xsave_struct *xsave_buf)
|
|
{
|
|
unsigned long bd_entry, bd_base;
|
|
struct bndcsr *bndcsr;
|
|
|
|
bndcsr = get_xsave_addr(xsave_buf, XSTATE_BNDCSR);
|
|
if (!bndcsr)
|
|
return -EINVAL;
|
|
/*
|
|
* Mask off the preserve and enable bits
|
|
*/
|
|
bd_base = bndcsr->bndcfgu & MPX_BNDCFG_ADDR_MASK;
|
|
/*
|
|
* The hardware provides the address of the missing or invalid
|
|
* entry via BNDSTATUS, so we don't have to go look it up.
|
|
*/
|
|
bd_entry = bndcsr->bndstatus & MPX_BNDSTA_ADDR_MASK;
|
|
/*
|
|
* Make sure the directory entry is within where we think
|
|
* the directory is.
|
|
*/
|
|
if ((bd_entry < bd_base) ||
|
|
(bd_entry >= bd_base + MPX_BD_SIZE_BYTES))
|
|
return -EINVAL;
|
|
|
|
return allocate_bt((long __user *)bd_entry);
|
|
}
|
|
|
|
int mpx_handle_bd_fault(struct xsave_struct *xsave_buf)
|
|
{
|
|
/*
|
|
* Userspace never asked us to manage the bounds tables,
|
|
* so refuse to help.
|
|
*/
|
|
if (!kernel_managing_mpx_tables(current->mm))
|
|
return -EINVAL;
|
|
|
|
if (do_mpx_bt_fault(xsave_buf)) {
|
|
force_sig(SIGSEGV, current);
|
|
/*
|
|
* The force_sig() is essentially "handling" this
|
|
* exception, so we do not pass up the error
|
|
* from do_mpx_bt_fault().
|
|
*/
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* A thin wrapper around get_user_pages(). Returns 0 if the
|
|
* fault was resolved or -errno if not.
|
|
*/
|
|
static int mpx_resolve_fault(long __user *addr, int write)
|
|
{
|
|
long gup_ret;
|
|
int nr_pages = 1;
|
|
int force = 0;
|
|
|
|
gup_ret = get_user_pages(current, current->mm, (unsigned long)addr,
|
|
nr_pages, write, force, NULL, NULL);
|
|
/*
|
|
* get_user_pages() returns number of pages gotten.
|
|
* 0 means we failed to fault in and get anything,
|
|
* probably because 'addr' is bad.
|
|
*/
|
|
if (!gup_ret)
|
|
return -EFAULT;
|
|
/* Other error, return it */
|
|
if (gup_ret < 0)
|
|
return gup_ret;
|
|
/* must have gup'd a page and gup_ret>0, success */
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Get the base of bounds tables pointed by specific bounds
|
|
* directory entry.
|
|
*/
|
|
static int get_bt_addr(struct mm_struct *mm,
|
|
long __user *bd_entry, unsigned long *bt_addr)
|
|
{
|
|
int ret;
|
|
int valid_bit;
|
|
|
|
if (!access_ok(VERIFY_READ, (bd_entry), sizeof(*bd_entry)))
|
|
return -EFAULT;
|
|
|
|
while (1) {
|
|
int need_write = 0;
|
|
|
|
pagefault_disable();
|
|
ret = get_user(*bt_addr, bd_entry);
|
|
pagefault_enable();
|
|
if (!ret)
|
|
break;
|
|
if (ret == -EFAULT)
|
|
ret = mpx_resolve_fault(bd_entry, need_write);
|
|
/*
|
|
* If we could not resolve the fault, consider it
|
|
* userspace's fault and error out.
|
|
*/
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
valid_bit = *bt_addr & MPX_BD_ENTRY_VALID_FLAG;
|
|
*bt_addr &= MPX_BT_ADDR_MASK;
|
|
|
|
/*
|
|
* When the kernel is managing bounds tables, a bounds directory
|
|
* entry will either have a valid address (plus the valid bit)
|
|
* *OR* be completely empty. If we see a !valid entry *and* some
|
|
* data in the address field, we know something is wrong. This
|
|
* -EINVAL return will cause a SIGSEGV.
|
|
*/
|
|
if (!valid_bit && *bt_addr)
|
|
return -EINVAL;
|
|
/*
|
|
* Do we have an completely zeroed bt entry? That is OK. It
|
|
* just means there was no bounds table for this memory. Make
|
|
* sure to distinguish this from -EINVAL, which will cause
|
|
* a SEGV.
|
|
*/
|
|
if (!valid_bit)
|
|
return -ENOENT;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Free the backing physical pages of bounds table 'bt_addr'.
|
|
* Assume start...end is within that bounds table.
|
|
*/
|
|
static int zap_bt_entries(struct mm_struct *mm,
|
|
unsigned long bt_addr,
|
|
unsigned long start, unsigned long end)
|
|
{
|
|
struct vm_area_struct *vma;
|
|
unsigned long addr, len;
|
|
|
|
/*
|
|
* Find the first overlapping vma. If vma->vm_start > start, there
|
|
* will be a hole in the bounds table. This -EINVAL return will
|
|
* cause a SIGSEGV.
|
|
*/
|
|
vma = find_vma(mm, start);
|
|
if (!vma || vma->vm_start > start)
|
|
return -EINVAL;
|
|
|
|
/*
|
|
* A NUMA policy on a VM_MPX VMA could cause this bouds table to
|
|
* be split. So we need to look across the entire 'start -> end'
|
|
* range of this bounds table, find all of the VM_MPX VMAs, and
|
|
* zap only those.
|
|
*/
|
|
addr = start;
|
|
while (vma && vma->vm_start < end) {
|
|
/*
|
|
* We followed a bounds directory entry down
|
|
* here. If we find a non-MPX VMA, that's bad,
|
|
* so stop immediately and return an error. This
|
|
* probably results in a SIGSEGV.
|
|
*/
|
|
if (!is_mpx_vma(vma))
|
|
return -EINVAL;
|
|
|
|
len = min(vma->vm_end, end) - addr;
|
|
zap_page_range(vma, addr, len, NULL);
|
|
|
|
vma = vma->vm_next;
|
|
addr = vma->vm_start;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int unmap_single_bt(struct mm_struct *mm,
|
|
long __user *bd_entry, unsigned long bt_addr)
|
|
{
|
|
unsigned long expected_old_val = bt_addr | MPX_BD_ENTRY_VALID_FLAG;
|
|
unsigned long actual_old_val = 0;
|
|
int ret;
|
|
|
|
while (1) {
|
|
int need_write = 1;
|
|
|
|
pagefault_disable();
|
|
ret = user_atomic_cmpxchg_inatomic(&actual_old_val, bd_entry,
|
|
expected_old_val, 0);
|
|
pagefault_enable();
|
|
if (!ret)
|
|
break;
|
|
if (ret == -EFAULT)
|
|
ret = mpx_resolve_fault(bd_entry, need_write);
|
|
/*
|
|
* If we could not resolve the fault, consider it
|
|
* userspace's fault and error out.
|
|
*/
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
/*
|
|
* The cmpxchg was performed, check the results.
|
|
*/
|
|
if (actual_old_val != expected_old_val) {
|
|
/*
|
|
* Someone else raced with us to unmap the table.
|
|
* There was no bounds table pointed to by the
|
|
* directory, so declare success. Somebody freed
|
|
* it.
|
|
*/
|
|
if (!actual_old_val)
|
|
return 0;
|
|
/*
|
|
* Something messed with the bounds directory
|
|
* entry. We hold mmap_sem for read or write
|
|
* here, so it could not be a _new_ bounds table
|
|
* that someone just allocated. Something is
|
|
* wrong, so pass up the error and SIGSEGV.
|
|
*/
|
|
return -EINVAL;
|
|
}
|
|
|
|
/*
|
|
* Note, we are likely being called under do_munmap() already. To
|
|
* avoid recursion, do_munmap() will check whether it comes
|
|
* from one bounds table through VM_MPX flag.
|
|
*/
|
|
return do_munmap(mm, bt_addr, MPX_BT_SIZE_BYTES);
|
|
}
|
|
|
|
/*
|
|
* If the bounds table pointed by bounds directory 'bd_entry' is
|
|
* not shared, unmap this whole bounds table. Otherwise, only free
|
|
* those backing physical pages of bounds table entries covered
|
|
* in this virtual address region start...end.
|
|
*/
|
|
static int unmap_shared_bt(struct mm_struct *mm,
|
|
long __user *bd_entry, unsigned long start,
|
|
unsigned long end, bool prev_shared, bool next_shared)
|
|
{
|
|
unsigned long bt_addr;
|
|
int ret;
|
|
|
|
ret = get_bt_addr(mm, bd_entry, &bt_addr);
|
|
/*
|
|
* We could see an "error" ret for not-present bounds
|
|
* tables (not really an error), or actual errors, but
|
|
* stop unmapping either way.
|
|
*/
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (prev_shared && next_shared)
|
|
ret = zap_bt_entries(mm, bt_addr,
|
|
bt_addr+MPX_GET_BT_ENTRY_OFFSET(start),
|
|
bt_addr+MPX_GET_BT_ENTRY_OFFSET(end));
|
|
else if (prev_shared)
|
|
ret = zap_bt_entries(mm, bt_addr,
|
|
bt_addr+MPX_GET_BT_ENTRY_OFFSET(start),
|
|
bt_addr+MPX_BT_SIZE_BYTES);
|
|
else if (next_shared)
|
|
ret = zap_bt_entries(mm, bt_addr, bt_addr,
|
|
bt_addr+MPX_GET_BT_ENTRY_OFFSET(end));
|
|
else
|
|
ret = unmap_single_bt(mm, bd_entry, bt_addr);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* A virtual address region being munmap()ed might share bounds table
|
|
* with adjacent VMAs. We only need to free the backing physical
|
|
* memory of these shared bounds tables entries covered in this virtual
|
|
* address region.
|
|
*/
|
|
static int unmap_edge_bts(struct mm_struct *mm,
|
|
unsigned long start, unsigned long end)
|
|
{
|
|
int ret;
|
|
long __user *bde_start, *bde_end;
|
|
struct vm_area_struct *prev, *next;
|
|
bool prev_shared = false, next_shared = false;
|
|
|
|
bde_start = mm->bd_addr + MPX_GET_BD_ENTRY_OFFSET(start);
|
|
bde_end = mm->bd_addr + MPX_GET_BD_ENTRY_OFFSET(end-1);
|
|
|
|
/*
|
|
* Check whether bde_start and bde_end are shared with adjacent
|
|
* VMAs.
|
|
*
|
|
* We already unliked the VMAs from the mm's rbtree so 'start'
|
|
* is guaranteed to be in a hole. This gets us the first VMA
|
|
* before the hole in to 'prev' and the next VMA after the hole
|
|
* in to 'next'.
|
|
*/
|
|
next = find_vma_prev(mm, start, &prev);
|
|
if (prev && (mm->bd_addr + MPX_GET_BD_ENTRY_OFFSET(prev->vm_end-1))
|
|
== bde_start)
|
|
prev_shared = true;
|
|
if (next && (mm->bd_addr + MPX_GET_BD_ENTRY_OFFSET(next->vm_start))
|
|
== bde_end)
|
|
next_shared = true;
|
|
|
|
/*
|
|
* This virtual address region being munmap()ed is only
|
|
* covered by one bounds table.
|
|
*
|
|
* In this case, if this table is also shared with adjacent
|
|
* VMAs, only part of the backing physical memory of the bounds
|
|
* table need be freeed. Otherwise the whole bounds table need
|
|
* be unmapped.
|
|
*/
|
|
if (bde_start == bde_end) {
|
|
return unmap_shared_bt(mm, bde_start, start, end,
|
|
prev_shared, next_shared);
|
|
}
|
|
|
|
/*
|
|
* If more than one bounds tables are covered in this virtual
|
|
* address region being munmap()ed, we need to separately check
|
|
* whether bde_start and bde_end are shared with adjacent VMAs.
|
|
*/
|
|
ret = unmap_shared_bt(mm, bde_start, start, end, prev_shared, false);
|
|
if (ret)
|
|
return ret;
|
|
ret = unmap_shared_bt(mm, bde_end, start, end, false, next_shared);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int mpx_unmap_tables(struct mm_struct *mm,
|
|
unsigned long start, unsigned long end)
|
|
{
|
|
int ret;
|
|
long __user *bd_entry, *bde_start, *bde_end;
|
|
unsigned long bt_addr;
|
|
|
|
/*
|
|
* "Edge" bounds tables are those which are being used by the region
|
|
* (start -> end), but that may be shared with adjacent areas. If they
|
|
* turn out to be completely unshared, they will be freed. If they are
|
|
* shared, we will free the backing store (like an MADV_DONTNEED) for
|
|
* areas used by this region.
|
|
*/
|
|
ret = unmap_edge_bts(mm, start, end);
|
|
switch (ret) {
|
|
/* non-present tables are OK */
|
|
case 0:
|
|
case -ENOENT:
|
|
/* Success, or no tables to unmap */
|
|
break;
|
|
case -EINVAL:
|
|
case -EFAULT:
|
|
default:
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Only unmap the bounds table that are
|
|
* 1. fully covered
|
|
* 2. not at the edges of the mapping, even if full aligned
|
|
*/
|
|
bde_start = mm->bd_addr + MPX_GET_BD_ENTRY_OFFSET(start);
|
|
bde_end = mm->bd_addr + MPX_GET_BD_ENTRY_OFFSET(end-1);
|
|
for (bd_entry = bde_start + 1; bd_entry < bde_end; bd_entry++) {
|
|
ret = get_bt_addr(mm, bd_entry, &bt_addr);
|
|
switch (ret) {
|
|
case 0:
|
|
break;
|
|
case -ENOENT:
|
|
/* No table here, try the next one */
|
|
continue;
|
|
case -EINVAL:
|
|
case -EFAULT:
|
|
default:
|
|
/*
|
|
* Note: we are being strict here.
|
|
* Any time we run in to an issue
|
|
* unmapping tables, we stop and
|
|
* SIGSEGV.
|
|
*/
|
|
return ret;
|
|
}
|
|
|
|
ret = unmap_single_bt(mm, bd_entry, bt_addr);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Free unused bounds tables covered in a virtual address region being
|
|
* munmap()ed. Assume end > start.
|
|
*
|
|
* This function will be called by do_munmap(), and the VMAs covering
|
|
* the virtual address region start...end have already been split if
|
|
* necessary, and the 'vma' is the first vma in this range (start -> end).
|
|
*/
|
|
void mpx_notify_unmap(struct mm_struct *mm, struct vm_area_struct *vma,
|
|
unsigned long start, unsigned long end)
|
|
{
|
|
int ret;
|
|
|
|
/*
|
|
* Refuse to do anything unless userspace has asked
|
|
* the kernel to help manage the bounds tables,
|
|
*/
|
|
if (!kernel_managing_mpx_tables(current->mm))
|
|
return;
|
|
/*
|
|
* This will look across the entire 'start -> end' range,
|
|
* and find all of the non-VM_MPX VMAs.
|
|
*
|
|
* To avoid recursion, if a VM_MPX vma is found in the range
|
|
* (start->end), we will not continue follow-up work. This
|
|
* recursion represents having bounds tables for bounds tables,
|
|
* which should not occur normally. Being strict about it here
|
|
* helps ensure that we do not have an exploitable stack overflow.
|
|
*/
|
|
do {
|
|
if (vma->vm_flags & VM_MPX)
|
|
return;
|
|
vma = vma->vm_next;
|
|
} while (vma && vma->vm_start < end);
|
|
|
|
ret = mpx_unmap_tables(mm, start, end);
|
|
if (ret)
|
|
force_sig(SIGSEGV, current);
|
|
}
|