x86: Remove arbitrary instruction size limit in instruction decoder

The current x86 instruction decoder steps along through the
instruction stream but always ensures that it never steps farther
than the largest possible instruction size (MAX_INSN_SIZE).

The MPX code is now going to be doing some decoding of userspace
instructions.  We copy those from userspace in to the kernel and
they're obviously completely untrusted coming from userspace.  In
addition to the constraint that instructions can only be so long,
we also have to be aware of how long the buffer is that came in
from userspace.  This _looks_ to be similar to what the perf and
kprobes is doing, but it's unclear to me whether they are
affected.

The whole reason we need this is that it is perfectly valid to be
executing an instruction within MAX_INSN_SIZE bytes of an
unreadable page. We should be able to gracefully handle short
reads in those cases.

This adds support to the decoder to record how long the buffer
being decoded is and to refuse to "validate" the instruction if
we would have gone over the end of the buffer to decode it.

The kprobes code probably needs to be looked at here a bit more
carefully.  This patch still respects the MAX_INSN_SIZE limit
there but the kprobes code does look like it might be able to
be a bit more strict than it currently is.

Signed-off-by: Dave Hansen <dave.hansen@linux.intel.com>
Acked-by: Jim Keniston <jkenisto@us.ibm.com>
Acked-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Cc: x86@kernel.org
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Arnaldo Carvalho de Melo <acme@kernel.org>
Cc: Srikar Dronamraju <srikar@linux.vnet.ibm.com>
Cc: Ananth N Mavinakayanahalli <ananth@in.ibm.com>
Cc: Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
Cc: "David S. Miller" <davem@davemloft.net>
Link: http://lkml.kernel.org/r/20141114153957.E6B01535@viggo.jf.intel.com
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

2 files changed, 33 insertions, 9 deletions

diff --git a/arch/x86/kernel/cpu/perf_event_intel_ds.c b/arch/x86/kernel/cpu/perf_event_intel_ds.c
index 46211bcc813e..6a94277525c9 100644
--- a/arch/x86/kernel/cpu/perf_event_intel_ds.c
+++ b/arch/x86/kernel/cpu/perf_event_intel_ds.c
@@ -724,6 +724,7 @@ static int intel_pmu_pebs_fixup_ip(struct pt_regs *regs)
         unsigned long ip = regs->ip;
         int is_64bit = 0;
         void *kaddr;
+        int size;
 
         /*
          * We don't need to fixup if the PEBS assist is fault like
@@ -758,11 +759,12 @@ static int intel_pmu_pebs_fixup_ip(struct pt_regs *regs)
                 return 1;
         }
 
+        size = ip - to;
         if (!kernel_ip(ip)) {
-                int size, bytes;
+                int bytes;
                 u8 *buf = this_cpu_read(insn_buffer);
 
-                size = ip - to; /* Must fit our buffer, see above */
+                /* 'size' must fit our buffer, see above */
                 bytes = copy_from_user_nmi(buf, (void __user *)to, size);
                 if (bytes != 0)
                         return 0;
@@ -780,11 +782,20 @@ static int intel_pmu_pebs_fixup_ip(struct pt_regs *regs)
 #ifdef CONFIG_X86_64
                 is_64bit = kernel_ip(to) || !test_thread_flag(TIF_IA32);
 #endif
-                insn_init(&insn, kaddr, is_64bit);
+                insn_init(&insn, kaddr, size, is_64bit);
                 insn_get_length(&insn);
+                /*
+                 * Make sure there was not a problem decoding the
+                 * instruction and getting the length.  This is
+                 * doubly important because we have an infinite
+                 * loop if insn.length=0.
+                 */
+                if (!insn.length)
+                        break;
 
                 to += insn.length;
                 kaddr += insn.length;
+                size -= insn.length;
         } while (to < ip);
 
         if (to == ip) {
diff --git a/arch/x86/kernel/cpu/perf_event_intel_lbr.c b/arch/x86/kernel/cpu/perf_event_intel_lbr.c
index 45fa730a5283..58f1a94beaf0 100644
--- a/arch/x86/kernel/cpu/perf_event_intel_lbr.c
+++ b/arch/x86/kernel/cpu/perf_event_intel_lbr.c
@@ -465,7 +465,7 @@ static int branch_type(unsigned long from, unsigned long to, int abort)
 {
         struct insn insn;
         void *addr;
-        int bytes, size = MAX_INSN_SIZE;
+        int bytes_read, bytes_left;
         int ret = X86_BR_NONE;
         int ext, to_plm, from_plm;
         u8 buf[MAX_INSN_SIZE];
@@ -493,8 +493,10 @@ static int branch_type(unsigned long from, unsigned long to, int abort)
                         return X86_BR_NONE;
 
                 /* may fail if text not present */
-                bytes = copy_from_user_nmi(buf, (void __user *)from, size);
-                if (bytes != 0)
+                bytes_left = copy_from_user_nmi(buf, (void __user *)from,
+                                                MAX_INSN_SIZE);
+                bytes_read = MAX_INSN_SIZE - bytes_left;
+                if (!bytes_read)
                         return X86_BR_NONE;
 
                 addr = buf;
@@ -505,10 +507,19 @@ static int branch_type(unsigned long from, unsigned long to, int abort)
                  * Ensure we don't blindy read any address by validating it is
                  * a known text address.
                  */
-                if (kernel_text_address(from))
+                if (kernel_text_address(from)) {
                         addr = (void *)from;
-                else
+                        /*
+                         * Assume we can get the maximum possible size
+                         * when grabbing kernel data.  This is not
+                         * _strictly_ true since we could possibly be
+                         * executing up next to a memory hole, but
+                         * it is very unlikely to be a problem.
+                         */
+                        bytes_read = MAX_INSN_SIZE;
+                } else {
                         return X86_BR_NONE;
+                }
         }
 
         /*
@@ -518,8 +529,10 @@ static int branch_type(unsigned long from, unsigned long to, int abort)
 #ifdef CONFIG_X86_64
         is64 = kernel_ip((unsigned long)addr) || !test_thread_flag(TIF_IA32);
 #endif
-        insn_init(&insn, addr, is64);
+        insn_init(&insn, addr, bytes_read, is64);
         insn_get_opcode(&insn);
+        if (!insn.opcode.got)
+                return X86_BR_ABORT;
 
         switch (insn.opcode.bytes[0]) {
         case 0xf: