| Message ID | 20210323203946.2159693-3-samitolvanen@google.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | Add support for Clang CFI | expand |
On 23/03/2021 21.39, Sami Tolvanen wrote: > With CONFIG_CFI_CLANG, the compiler replaces a function address taken > in C code with the address of a local jump table entry, which passes > runtime indirect call checks. However, the compiler won't replace > addresses taken in assembly code, which will result in a CFI failure > if we later jump to such an address in instrumented C code. The code > generated for the non-canonical jump table looks this: > > <noncanonical.cfi_jt>: /* In C, &noncanonical points here */ > jmp noncanonical > ... > <noncanonical>: /* function body */ > ... > > This change adds the __cficanonical attribute, which tells the > compiler to use a canonical jump table for the function instead. This > means the compiler will rename the actual function to <function>.cfi > and points the original symbol to the jump table entry instead: > > <canonical>: /* jump table entry */ > jmp canonical.cfi > ... > <canonical.cfi>: /* function body */ > ... > > As a result, the address taken in assembly, or other non-instrumented > code always points to the jump table and therefore, can be used for > indirect calls in instrumented code without tripping CFI checks. Random ramblings, I'm trying to understand how this CFI stuff works. First, patch 1 and 2 explain the pros and cons of canonical vs non-canonical jump tables, in either case, there's problems with stuff implemented in assembly. But I don't understand why those pros and cons then end up with using the non-canonical jump tables by default. IIUC, with canonical jump tables, function pointer equality would keep working for functions implemented in C, because &func would always refer to the same stub "function" that lives in the same object file as func.cfi, whereas with the non-canonical version, each TU (or maybe DSO) that takes the address of func ends up with its own func.cfi_jt. There are of course lots of direct calls of assembly functions, but I don't think we take the address of such functions very often. So why can't we instead equip the declarations of those with a __cfi_noncanonical attribute? And now, more directed at the clang folks on cc: As to how CFI works, I've tried to make sense of the clang docs. So at place where some int (*)(long, int) function pointer is called, the compiler computes (roughly) md5sum("int (*)(long, int)") and uses the first 8 bytes as a cookie representing that type. It then goes to some global table of jump table ranges indexed by that cookie and checks that the address it is about to call is within that range. All jump table entries for one type of function are consecutive in memory (with complications arising from cross-DSO calls). What I don't understand about all this is why that indirection through some hidden global table and magic jump table (whether canonical or not) is even needed in the simple common case of ordinary C functions. Why can't the compiler just emit the cookie corresponding to a given function's prototype immediately prior to the function? Then the inline check would just be "if (*(u64*)((void*)func - 8) == cookie)" and function pointer comparison would just work because there's no magic involved when doing &func. Cross-DSO calls of C function have no extra cost to look up a __cfi_check function in the target DSO. An indirect call doesn't touch at least two extra cache lines (the range table and the jump table entry). It seems to rely on LTO anyway, so it's not even that the compiler would have to emit that cookie for every single function, it knows at link time which functions have their address taken. Calling functions implemented in assembly through a function pointer will have the same problem as with the "canonical" jump table approach, but with a suitable attribute on those surely the compiler could emit a func.cfi_hoop .quad 0x1122334455667788 // cookie <func.cfi_hoop>: jmp func and perhaps no such attribute would even be needed (with LTO, the compiler should be able to see "hey, I don't know that function, it's probably implemented in assembly, so lemme emit that trampoline with a cookie in front and redirect address-of to that"). Rasmus
On Wed, Mar 24, 2021 at 8:31 AM Rasmus Villemoes <linux@rasmusvillemoes.dk> wrote: > > On 23/03/2021 21.39, Sami Tolvanen wrote: > > With CONFIG_CFI_CLANG, the compiler replaces a function address taken > > in C code with the address of a local jump table entry, which passes > > runtime indirect call checks. However, the compiler won't replace > > addresses taken in assembly code, which will result in a CFI failure > > if we later jump to such an address in instrumented C code. The code > > generated for the non-canonical jump table looks this: > > > > <noncanonical.cfi_jt>: /* In C, &noncanonical points here */ > > jmp noncanonical > > ... > > <noncanonical>: /* function body */ > > ... > > > > This change adds the __cficanonical attribute, which tells the > > compiler to use a canonical jump table for the function instead. This > > means the compiler will rename the actual function to <function>.cfi > > and points the original symbol to the jump table entry instead: > > > > <canonical>: /* jump table entry */ > > jmp canonical.cfi > > ... > > <canonical.cfi>: /* function body */ > > ... > > > > As a result, the address taken in assembly, or other non-instrumented > > code always points to the jump table and therefore, can be used for > > indirect calls in instrumented code without tripping CFI checks. > > Random ramblings, I'm trying to understand how this CFI stuff works. > > First, patch 1 and 2 explain the pros and cons of canonical vs > non-canonical jump tables, in either case, there's problems with stuff > implemented in assembly. But I don't understand why those pros and cons > then end up with using the non-canonical jump tables by default. IIUC, > with canonical jump tables, function pointer equality would keep working > for functions implemented in C, because &func would always refer to the > same stub "function" that lives in the same object file as func.cfi, > whereas with the non-canonical version, each TU (or maybe DSO) that > takes the address of func ends up with its own func.cfi_jt. Correct. > There are of course lots of direct calls of assembly functions, but > I don't think we take the address of such functions very often. So why > can't we instead equip the declarations of those with a > __cfi_noncanonical attribute? Clang doesn't support these attributes in function declarations, unfortunately. If it did, that would certainly help, until someone wants to compare addresses of assembly functions, in which case we would again have a problem. Another way to work around the issue with canonical CFI would be to add C wrappers for all address-taken assembly functions, but that's not quite ideal either. I think most indirect calls to assembly functions happen in the crypto code, which would have required so many changes that we decided to default to non-canonical CFI instead. This resulted in far fewer kernel changes despite the cross-module function address equality issue. Sami
diff --git a/include/linux/compiler-clang.h b/include/linux/compiler-clang.h index 6de9d0c9377e..adbe76b203e2 100644 --- a/include/linux/compiler-clang.h +++ b/include/linux/compiler-clang.h @@ -63,3 +63,4 @@ #endif #define __nocfi __attribute__((__no_sanitize__("cfi"))) +#define __cficanonical __attribute__((__cfi_canonical_jump_table__)) diff --git a/include/linux/compiler_types.h b/include/linux/compiler_types.h index 796935a37e37..d29bda7f6ebd 100644 --- a/include/linux/compiler_types.h +++ b/include/linux/compiler_types.h @@ -246,6 +246,10 @@ struct ftrace_likely_data { # define __nocfi #endif +#ifndef __cficanonical +# define __cficanonical +#endif + #ifndef asm_volatile_goto #define asm_volatile_goto(x...) asm goto(x) #endif diff --git a/include/linux/init.h b/include/linux/init.h index b3ea15348fbd..045ad1650ed1 100644 --- a/include/linux/init.h +++ b/include/linux/init.h @@ -220,8 +220,8 @@ extern bool initcall_debug; __initcall_name(initstub, __iid, id) #define __define_initcall_stub(__stub, fn) \ - int __init __stub(void); \ - int __init __stub(void) \ + int __init __cficanonical __stub(void); \ + int __init __cficanonical __stub(void) \ { \ return fn(); \ } \ diff --git a/include/linux/pci.h b/include/linux/pci.h index 86c799c97b77..39684b72db91 100644 --- a/include/linux/pci.h +++ b/include/linux/pci.h @@ -1944,8 +1944,8 @@ enum pci_fixup_pass { #ifdef CONFIG_LTO_CLANG #define __DECLARE_PCI_FIXUP_SECTION(sec, name, vendor, device, class, \ class_shift, hook, stub) \ - void stub(struct pci_dev *dev); \ - void stub(struct pci_dev *dev) \ + void __cficanonical stub(struct pci_dev *dev); \ + void __cficanonical stub(struct pci_dev *dev) \ { \ hook(dev); \ } \