lkml.org 
[lkml]   [2020]   [Jun]   [3]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    SubjectRe: [PATCH 0/9] x86/entry fixes
    On Wed, Jun 03, 2020 at 06:07:22PM +0200, Peter Zijlstra wrote:
    > On Wed, Jun 03, 2020 at 04:47:54PM +0200, Marco Elver wrote:

    > > With that in mind, you could whitelist "__ubsan_handle"-prefixed
    > > functions in objtool. Given the __always_inline+noinstr+__ubsan_handle
    > > case is quite rare, it might be reasonable.
    >
    > Yes, I think so. Let me go have dinner and then I'll try and do a patch
    > to that effect.

    Here's a slightly more radical patch, it unconditionally allows UBSAN.

    I've not actually boot tested this.. yet.

    ---
    Subject: x86/entry, ubsan, objtool: Whitelist __ubsan_handle_*()
    From: Peter Zijlstra <peterz@infradead.org>
    Date: Wed Jun 3 20:09:06 CEST 2020

    The UBSAN instrumentation only inserts external CALLs when things go
    'BAD', much like WARN(). So treat them similar to WARN()s for noinstr,
    that is: allow them, at the risk of taking the machine down, to get
    their message out.

    Suggested-by: Marco Elver <elver@google.com>
    Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
    ---
    include/linux/compiler_types.h | 2 +-
    tools/objtool/check.c | 28 +++++++++++++++++++++++++++-
    2 files changed, 28 insertions(+), 2 deletions(-)

    --- a/include/linux/compiler_types.h
    +++ b/include/linux/compiler_types.h
    @@ -199,7 +199,7 @@ struct ftrace_likely_data {
    /* Section for code which can't be instrumented at all */
    #define noinstr \
    noinline notrace __attribute((__section__(".noinstr.text"))) \
    - __no_kcsan __no_sanitize_address __no_sanitize_undefined
    + __no_kcsan __no_sanitize_address

    #endif /* __KERNEL__ */

    --- a/tools/objtool/check.c
    +++ b/tools/objtool/check.c
    @@ -2190,10 +2190,36 @@ static inline const char *call_dest_name
    return "{dynamic}";
    }

    +static inline bool noinstr_call_dest(struct symbol *func)
    +{
    + /*
    + * We can't deal with indirect function calls at present;
    + * assume they're instrumented.
    + */
    + if (!func)
    + return false;
    +
    + /*
    + * If the symbol is from a noinstr section; we good.
    + */
    + if (func->sec->noinstr)
    + return true;
    +
    + /*
    + * The __ubsan_handle_*() calls are like WARN(), they only happen when
    + * something 'BAD' happened. At the risk of taking the machine down,
    + * let them proceed to get the message out.
    + */
    + if (!strncmp(func->name, "__ubsan_handle_", 15))
    + return true;
    +
    + return false;
    +}
    +
    static int validate_call(struct instruction *insn, struct insn_state *state)
    {
    if (state->noinstr && state->instr <= 0 &&
    - (!insn->call_dest || !insn->call_dest->sec->noinstr)) {
    + !noinstr_call_dest(insn->call_dest)) {
    WARN_FUNC("call to %s() leaves .noinstr.text section",
    insn->sec, insn->offset, call_dest_name(insn));
    return 1;
    \
     
     \ /
      Last update: 2020-06-03 20:19    [W:2.351 / U:0.156 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site