Commit | Line | Data |
---|---|---|
12f57721 MO |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * Non-trivial C macros cannot be used in Rust. Similarly, inlined C functions | |
4 | * cannot be called either. This file explicitly creates functions ("helpers") | |
5 | * that wrap those so that they can be called from Rust. | |
6 | * | |
7 | * Even though Rust kernel modules should never use directly the bindings, some | |
8 | * of these helpers need to be exported because Rust generics and inlined | |
9 | * functions may not get their code generated in the crate where they are | |
10 | * defined. Other helpers, called from non-inline functions, may not be | |
11 | * exported, in principle. However, in general, the Rust compiler does not | |
12 | * guarantee codegen will be performed for a non-inline function either. | |
13 | * Therefore, this file exports all the helpers. In the future, this may be | |
14 | * revisited to reduce the number of exports after the compiler is informed | |
15 | * about the places codegen is required. | |
16 | * | |
17 | * All symbols are exported as GPL-only to guarantee no GPL-only feature is | |
18 | * accidentally exposed. | |
19 | */ | |
20 | ||
21 | #include <linux/bug.h> | |
22 | #include <linux/build_bug.h> | |
9dc04365 | 23 | #include <linux/refcount.h> |
12f57721 MO |
24 | |
25 | __noreturn void rust_helper_BUG(void) | |
26 | { | |
27 | BUG(); | |
28 | } | |
29 | EXPORT_SYMBOL_GPL(rust_helper_BUG); | |
30 | ||
9dc04365 WAF |
31 | refcount_t rust_helper_REFCOUNT_INIT(int n) |
32 | { | |
33 | return (refcount_t)REFCOUNT_INIT(n); | |
34 | } | |
35 | EXPORT_SYMBOL_GPL(rust_helper_REFCOUNT_INIT); | |
36 | ||
37 | void rust_helper_refcount_inc(refcount_t *r) | |
38 | { | |
39 | refcount_inc(r); | |
40 | } | |
41 | EXPORT_SYMBOL_GPL(rust_helper_refcount_inc); | |
42 | ||
43 | bool rust_helper_refcount_dec_and_test(refcount_t *r) | |
44 | { | |
45 | return refcount_dec_and_test(r); | |
46 | } | |
47 | EXPORT_SYMBOL_GPL(rust_helper_refcount_dec_and_test); | |
48 | ||
12f57721 MO |
49 | /* |
50 | * We use `bindgen`'s `--size_t-is-usize` option to bind the C `size_t` type | |
51 | * as the Rust `usize` type, so we can use it in contexts where Rust | |
52 | * expects a `usize` like slice (array) indices. `usize` is defined to be | |
53 | * the same as C's `uintptr_t` type (can hold any pointer) but not | |
54 | * necessarily the same as `size_t` (can hold the size of any single | |
55 | * object). Most modern platforms use the same concrete integer type for | |
56 | * both of them, but in case we find ourselves on a platform where | |
57 | * that's not true, fail early instead of risking ABI or | |
58 | * integer-overflow issues. | |
59 | * | |
60 | * If your platform fails this assertion, it means that you are in | |
61 | * danger of integer-overflow bugs (even if you attempt to remove | |
62 | * `--size_t-is-usize`). It may be easiest to change the kernel ABI on | |
63 | * your platform such that `size_t` matches `uintptr_t` (i.e., to increase | |
64 | * `size_t`, because `uintptr_t` has to be at least as big as `size_t`). | |
65 | */ | |
66 | static_assert( | |
67 | sizeof(size_t) == sizeof(uintptr_t) && | |
68 | __alignof__(size_t) == __alignof__(uintptr_t), | |
69 | "Rust code expects C `size_t` to match Rust `usize`" | |
70 | ); |