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 the bindings directly, 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 * Sorted alphabetically. 21 */ 22 23 #include <kunit/test-bug.h> 24 #include <linux/bug.h> 25 #include <linux/build_bug.h> 26 #include <linux/device.h> 27 #include <linux/err.h> 28 #include <linux/errname.h> 29 #include <linux/gfp.h> 30 #include <linux/highmem.h> 31 #include <linux/mutex.h> 32 #include <linux/refcount.h> 33 #include <linux/sched/signal.h> 34 #include <linux/slab.h> 35 #include <linux/spinlock.h> 36 #include <linux/wait.h> 37 #include <linux/workqueue.h> 38 39 __noreturn void rust_helper_BUG(void) 40 { 41 BUG(); 42 } 43 EXPORT_SYMBOL_GPL(rust_helper_BUG); 44 45 unsigned long rust_helper_copy_from_user(void *to, const void __user *from, 46 unsigned long n) 47 { 48 return copy_from_user(to, from, n); 49 } 50 EXPORT_SYMBOL_GPL(rust_helper_copy_from_user); 51 52 unsigned long rust_helper_copy_to_user(void __user *to, const void *from, 53 unsigned long n) 54 { 55 return copy_to_user(to, from, n); 56 } 57 EXPORT_SYMBOL_GPL(rust_helper_copy_to_user); 58 59 void rust_helper_mutex_lock(struct mutex *lock) 60 { 61 mutex_lock(lock); 62 } 63 EXPORT_SYMBOL_GPL(rust_helper_mutex_lock); 64 65 void rust_helper___spin_lock_init(spinlock_t *lock, const char *name, 66 struct lock_class_key *key) 67 { 68 #ifdef CONFIG_DEBUG_SPINLOCK 69 __raw_spin_lock_init(spinlock_check(lock), name, key, LD_WAIT_CONFIG); 70 #else 71 spin_lock_init(lock); 72 #endif 73 } 74 EXPORT_SYMBOL_GPL(rust_helper___spin_lock_init); 75 76 void rust_helper_spin_lock(spinlock_t *lock) 77 { 78 spin_lock(lock); 79 } 80 EXPORT_SYMBOL_GPL(rust_helper_spin_lock); 81 82 void rust_helper_spin_unlock(spinlock_t *lock) 83 { 84 spin_unlock(lock); 85 } 86 EXPORT_SYMBOL_GPL(rust_helper_spin_unlock); 87 88 void rust_helper_init_wait(struct wait_queue_entry *wq_entry) 89 { 90 init_wait(wq_entry); 91 } 92 EXPORT_SYMBOL_GPL(rust_helper_init_wait); 93 94 int rust_helper_signal_pending(struct task_struct *t) 95 { 96 return signal_pending(t); 97 } 98 EXPORT_SYMBOL_GPL(rust_helper_signal_pending); 99 100 struct page *rust_helper_alloc_pages(gfp_t gfp_mask, unsigned int order) 101 { 102 return alloc_pages(gfp_mask, order); 103 } 104 EXPORT_SYMBOL_GPL(rust_helper_alloc_pages); 105 106 void *rust_helper_kmap_local_page(struct page *page) 107 { 108 return kmap_local_page(page); 109 } 110 EXPORT_SYMBOL_GPL(rust_helper_kmap_local_page); 111 112 void rust_helper_kunmap_local(const void *addr) 113 { 114 kunmap_local(addr); 115 } 116 EXPORT_SYMBOL_GPL(rust_helper_kunmap_local); 117 118 refcount_t rust_helper_REFCOUNT_INIT(int n) 119 { 120 return (refcount_t)REFCOUNT_INIT(n); 121 } 122 EXPORT_SYMBOL_GPL(rust_helper_REFCOUNT_INIT); 123 124 void rust_helper_refcount_inc(refcount_t *r) 125 { 126 refcount_inc(r); 127 } 128 EXPORT_SYMBOL_GPL(rust_helper_refcount_inc); 129 130 bool rust_helper_refcount_dec_and_test(refcount_t *r) 131 { 132 return refcount_dec_and_test(r); 133 } 134 EXPORT_SYMBOL_GPL(rust_helper_refcount_dec_and_test); 135 136 __force void *rust_helper_ERR_PTR(long err) 137 { 138 return ERR_PTR(err); 139 } 140 EXPORT_SYMBOL_GPL(rust_helper_ERR_PTR); 141 142 bool rust_helper_IS_ERR(__force const void *ptr) 143 { 144 return IS_ERR(ptr); 145 } 146 EXPORT_SYMBOL_GPL(rust_helper_IS_ERR); 147 148 long rust_helper_PTR_ERR(__force const void *ptr) 149 { 150 return PTR_ERR(ptr); 151 } 152 EXPORT_SYMBOL_GPL(rust_helper_PTR_ERR); 153 154 const char *rust_helper_errname(int err) 155 { 156 return errname(err); 157 } 158 EXPORT_SYMBOL_GPL(rust_helper_errname); 159 160 struct task_struct *rust_helper_get_current(void) 161 { 162 return current; 163 } 164 EXPORT_SYMBOL_GPL(rust_helper_get_current); 165 166 void rust_helper_get_task_struct(struct task_struct *t) 167 { 168 get_task_struct(t); 169 } 170 EXPORT_SYMBOL_GPL(rust_helper_get_task_struct); 171 172 void rust_helper_put_task_struct(struct task_struct *t) 173 { 174 put_task_struct(t); 175 } 176 EXPORT_SYMBOL_GPL(rust_helper_put_task_struct); 177 178 struct kunit *rust_helper_kunit_get_current_test(void) 179 { 180 return kunit_get_current_test(); 181 } 182 EXPORT_SYMBOL_GPL(rust_helper_kunit_get_current_test); 183 184 void rust_helper_init_work_with_key(struct work_struct *work, work_func_t func, 185 bool onstack, const char *name, 186 struct lock_class_key *key) 187 { 188 __init_work(work, onstack); 189 work->data = (atomic_long_t)WORK_DATA_INIT(); 190 lockdep_init_map(&work->lockdep_map, name, key, 0); 191 INIT_LIST_HEAD(&work->entry); 192 work->func = func; 193 } 194 EXPORT_SYMBOL_GPL(rust_helper_init_work_with_key); 195 196 void * __must_check __realloc_size(2) 197 rust_helper_krealloc(const void *objp, size_t new_size, gfp_t flags) 198 { 199 return krealloc(objp, new_size, flags); 200 } 201 EXPORT_SYMBOL_GPL(rust_helper_krealloc); 202 203 /* 204 * `bindgen` binds the C `size_t` type as the Rust `usize` type, so we can 205 * use it in contexts where Rust expects a `usize` like slice (array) indices. 206 * `usize` is defined to be the same as C's `uintptr_t` type (can hold any 207 * pointer) but not necessarily the same as `size_t` (can hold the size of any 208 * single object). Most modern platforms use the same concrete integer type for 209 * both of them, but in case we find ourselves on a platform where 210 * that's not true, fail early instead of risking ABI or 211 * integer-overflow issues. 212 * 213 * If your platform fails this assertion, it means that you are in 214 * danger of integer-overflow bugs (even if you attempt to add 215 * `--no-size_t-is-usize`). It may be easiest to change the kernel ABI on 216 * your platform such that `size_t` matches `uintptr_t` (i.e., to increase 217 * `size_t`, because `uintptr_t` has to be at least as big as `size_t`). 218 */ 219 static_assert( 220 sizeof(size_t) == sizeof(uintptr_t) && 221 __alignof__(size_t) == __alignof__(uintptr_t), 222 "Rust code expects C `size_t` to match Rust `usize`" 223 ); 224 225 // This will soon be moved to a separate file, so no need to merge with above. 226 #include <linux/blk-mq.h> 227 #include <linux/blkdev.h> 228 229 void *rust_helper_blk_mq_rq_to_pdu(struct request *rq) 230 { 231 return blk_mq_rq_to_pdu(rq); 232 } 233 EXPORT_SYMBOL_GPL(rust_helper_blk_mq_rq_to_pdu); 234 235 struct request *rust_helper_blk_mq_rq_from_pdu(void *pdu) 236 { 237 return blk_mq_rq_from_pdu(pdu); 238 } 239 EXPORT_SYMBOL_GPL(rust_helper_blk_mq_rq_from_pdu); 240
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.