objtool: Assume unannotated UD2 instructions are dead ends

Arnd reported some false positive warnings with GCC 7:

  drivers/hid/wacom_wac.o: warning: objtool: wacom_bpt3_touch()+0x2a5: stack state mismatch: cfa1=7+8 cfa2=6+16
  drivers/iio/adc/vf610_adc.o: warning: objtool: vf610_adc_calculate_rates() falls through to next function vf610_adc_sample_set()
  drivers/pwm/pwm-hibvt.o: warning: objtool: hibvt_pwm_get_state() falls through to next function hibvt_pwm_remove()
  drivers/pwm/pwm-mediatek.o: warning: objtool: mtk_pwm_config() falls through to next function mtk_pwm_enable()
  drivers/spi/spi-bcm2835.o: warning: objtool: .text: unexpected end of section
  drivers/spi/spi-bcm2835aux.o: warning: objtool: .text: unexpected end of section
  drivers/watchdog/digicolor_wdt.o: warning: objtool: dc_wdt_get_timeleft() falls through to next function dc_wdt_restart()

When GCC 7 detects a potential divide-by-zero condition, it sometimes
inserts a UD2 instruction for the case where the divisor is zero,
instead of letting the hardware trap on the divide instruction.

Objtool doesn't consider UD2 to be fatal unless it's annotated with
unreachable().  So it considers the GCC-generated UD2 to be non-fatal,
and it tries to follow the control flow past the UD2 and gets
confused.

Previously, objtool *did* assume UD2 was always a dead end.  That
changed with the following commit:

  d1091c7fa3d5 ("objtool: Improve detection of BUG() and other dead ends")

The motivation behind that change was that Peter was planning on using
UD2 for __WARN(), which is *not* a dead end.  However, it turns out
that some emulators rely on UD2 being fatal, so he ended up using
'ud0' instead:

  9a93848fe787 ("x86/debug: Implement __WARN() using UD0")

For GCC 4.5+, it should be safe to go back to the previous assumption
that UD2 is fatal, even when it's not annotated with unreachable().

But for pre-4.5 versions of GCC, the unreachable() macro isn't
supported, so such cases of UD2 need to be explicitly annotated as
reachable.

Reported-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Josh Poimboeuf <jpoimboe@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Fixes: d1091c7fa3d5 ("objtool: Improve detection of BUG() and other dead ends")
Link: http://lkml.kernel.org/r/e57fa9dfede25f79487da8126ee9cdf7b856db65.1501188854.git.jpoimboe@redhat.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>

diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index 17cbe3cffc0e17bfb6623ed7f8927105798951bf..dd4b4c59c2f0cb32a98a59b7e6df6098471c3f85 100644 (file)
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -128,22 +128,6 @@
 #define __always_unused                __attribute__((unused))
 #define __mode(x)               __attribute__((mode(x)))
 
-#ifdef CONFIG_STACK_VALIDATION
-#define annotate_unreachable() ({                                      \
-       asm("%c0:\n\t"                                                  \
-           ".pushsection .discard.unreachable\n\t"                     \
-           ".long %c0b - .\n\t"                                        \
-           ".popsection\n\t" : : "i" (__LINE__));                      \
-})
-#define ASM_UNREACHABLE                                                        \
-       "999:\n\t"                                                      \
-       ".pushsection .discard.unreachable\n\t"                         \
-       ".long 999b - .\n\t"                                            \
-       ".popsection\n\t"
-#else
-#define annotate_unreachable()
-#endif
-
 /* gcc version specific checks */
 
 #if GCC_VERSION < 30200

diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 641f5912d75f96b8bf6c94fbde72e9b0bce92433..70f070ddd7c7bf2a05235dd5ffe163aee7882697 100644 (file)
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -185,11 +185,34 @@ void ftrace_likely_update(struct ftrace_likely_data *f, int val,
 #endif
 
 /* Unreachable code */
+#ifdef CONFIG_STACK_VALIDATION
+#define annotate_reachable() ({                                                \
+       asm("%c0:\n\t"                                                  \
+           ".pushsection .discard.reachable\n\t"                       \
+           ".long %c0b - .\n\t"                                        \
+           ".popsection\n\t" : : "i" (__LINE__));                      \
+})
+#define annotate_unreachable() ({                                      \
+       asm("%c0:\n\t"                                                  \
+           ".pushsection .discard.unreachable\n\t"                     \
+           ".long %c0b - .\n\t"                                        \
+           ".popsection\n\t" : : "i" (__LINE__));                      \
+})
+#define ASM_UNREACHABLE                                                        \
+       "999:\n\t"                                                      \
+       ".pushsection .discard.unreachable\n\t"                         \
+       ".long 999b - .\n\t"                                            \
+       ".popsection\n\t"
+#else
+#define annotate_reachable()
+#define annotate_unreachable()
+#endif
+
 #ifndef ASM_UNREACHABLE
 # define ASM_UNREACHABLE
 #endif
 #ifndef unreachable
-# define unreachable() do { } while (1)
+# define unreachable() do { annotate_reachable(); do { } while (1); } while (0)
 #endif
 
 /*

diff --git a/tools/objtool/arch.h b/tools/objtool/arch.h
index 21aeca874edb33043f9f0cc2f4b344759bc32ad9..b0d7dc3d71b5ac21e8acb36b1c1f38bcf06879c4 100644 (file)
--- a/tools/objtool/arch.h
+++ b/tools/objtool/arch.h
@@ -31,8 +31,9 @@
 #define INSN_RETURN            6
 #define INSN_CONTEXT_SWITCH    7
 #define INSN_STACK             8
-#define INSN_NOP               9
-#define INSN_OTHER             10
+#define INSN_BUG               9
+#define INSN_NOP               10
+#define INSN_OTHER             11
 #define INSN_LAST              INSN_OTHER
 
 enum op_dest_type {

diff --git a/tools/objtool/arch/x86/decode.c b/tools/objtool/arch/x86/decode.c
index a36c2eba64e7729347e46175a11f89ff5fe8ebbe..e4b400b67e412980ea135ae5a392b74876b8ee59 100644 (file)
--- a/tools/objtool/arch/x86/decode.c
+++ b/tools/objtool/arch/x86/decode.c
@@ -382,20 +382,27 @@ int arch_decode_instruction(struct elf *elf, struct section *sec,
 
        case 0x0f:
 
-               if (op2 >= 0x80 && op2 <= 0x8f)
+               if (op2 >= 0x80 && op2 <= 0x8f) {
+
                        *type = INSN_JUMP_CONDITIONAL;
-               else if (op2 == 0x05 || op2 == 0x07 || op2 == 0x34 ||
-                        op2 == 0x35)
+
+               } else if (op2 == 0x05 || op2 == 0x07 || op2 == 0x34 ||
+                          op2 == 0x35) {
 
                        /* sysenter, sysret */
                        *type = INSN_CONTEXT_SWITCH;
 
-               else if (op2 == 0x0d || op2 == 0x1f)
+               } else if (op2 == 0x0b || op2 == 0xb9) {
+
+                       /* ud2 */
+                       *type = INSN_BUG;
+
+               } else if (op2 == 0x0d || op2 == 0x1f) {
 
                        /* nopl/nopw */
                        *type = INSN_NOP;
 
-               else if (op2 == 0xa0 || op2 == 0xa8) {
+               } else if (op2 == 0xa0 || op2 == 0xa8) {
 
                        /* push fs/gs */
                        *type = INSN_STACK;

diff --git a/tools/objtool/check.c b/tools/objtool/check.c
index 3436a942b6067ae1c0105e0607eeb9da39791af6..d07bf4a62b4599094a7fe016e3817c4575cc1376 100644 (file)
--- a/tools/objtool/check.c
+++ b/tools/objtool/check.c
@@ -296,7 +296,7 @@ static int decode_instructions(struct objtool_file *file)
 }
 
 /*
- * Find all uses of the unreachable() macro, which are code path dead ends.
+ * Mark "ud2" instructions and manually annotated dead ends.
  */
 static int add_dead_ends(struct objtool_file *file)
 {
@@ -305,9 +305,20 @@ static int add_dead_ends(struct objtool_file *file)
        struct instruction *insn;
        bool found;
 
+       /*
+        * By default, "ud2" is a dead end unless otherwise annotated, because
+        * GCC 7 inserts it for certain divide-by-zero cases.
+        */
+       for_each_insn(file, insn)
+               if (insn->type == INSN_BUG)
+                       insn->dead_end = true;
+
+       /*
+        * Check for manually annotated dead ends.
+        */
        sec = find_section_by_name(file->elf, ".rela.discard.unreachable");
        if (!sec)
-               return 0;
+               goto reachable;
 
        list_for_each_entry(rela, &sec->rela_list, list) {
                if (rela->sym->type != STT_SECTION) {
@@ -340,6 +351,48 @@ static int add_dead_ends(struct objtool_file *file)
                insn->dead_end = true;
        }
 
+reachable:
+       /*
+        * These manually annotated reachable checks are needed for GCC 4.4,
+        * where the Linux unreachable() macro isn't supported.  In that case
+        * GCC doesn't know the "ud2" is fatal, so it generates code as if it's
+        * not a dead end.
+        */
+       sec = find_section_by_name(file->elf, ".rela.discard.reachable");
+       if (!sec)
+               return 0;
+
+       list_for_each_entry(rela, &sec->rela_list, list) {
+               if (rela->sym->type != STT_SECTION) {
+                       WARN("unexpected relocation symbol type in %s", sec->name);
+                       return -1;
+               }
+               insn = find_insn(file, rela->sym->sec, rela->addend);
+               if (insn)
+                       insn = list_prev_entry(insn, list);
+               else if (rela->addend == rela->sym->sec->len) {
+                       found = false;
+                       list_for_each_entry_reverse(insn, &file->insn_list, list) {
+                               if (insn->sec == rela->sym->sec) {
+                                       found = true;
+                                       break;
+                               }
+                       }
+
+                       if (!found) {
+                               WARN("can't find reachable insn at %s+0x%x",
+                                    rela->sym->sec->name, rela->addend);
+                               return -1;
+                       }
+               } else {
+                       WARN("can't find reachable insn at %s+0x%x",
+                            rela->sym->sec->name, rela->addend);
+                       return -1;
+               }
+
+               insn->dead_end = false;
+       }
+
        return 0;
 }