#include "/build/bcachefs-tools/src/bcachefs-tools/bcachefs-shim/src/wrapper.h"

// Static wrappers

void __read_once_size__extern(const void *p, void *res, int size) { __read_once_size(p, res, size); }
void __write_once_size__extern(void *p, void *res, int size) { __write_once_size(p, res, size); }
bool __must_check_overflow__extern(bool overflow) { return __must_check_overflow(overflow); }
size_t size_mul__extern(size_t factor1, size_t factor2) { return size_mul(factor1, factor2); }
size_t size_add__extern(size_t addend1, size_t addend2) { return size_add(addend1, addend2); }
size_t size_sub__extern(size_t minuend, size_t subtrahend) { return size_sub(minuend, subtrahend); }
const void * __must_check_fn__extern(const void *val) { return __must_check_fn(val); }
void shrink_dcache_sb__extern(struct super_block *sb) { shrink_dcache_sb(sb); }
void kmsan_poison_memory__extern(const void *address, size_t size, unsigned int flags) { kmsan_poison_memory(address, size, flags); }
void kmsan_unpoison_memory__extern(const void *address, size_t size) { kmsan_unpoison_memory(address, size); }
void kmsan_check_memory__extern(const void *address, size_t size) { kmsan_check_memory(address, size); }
void kmsan_copy_to_user__extern(void *to, const void *from, size_t to_copy, size_t left) { kmsan_copy_to_user(to, from, to_copy, left); }
void kmsan_memmove__extern(void *to, const void *from, size_t to_copy) { kmsan_memmove(to, from, to_copy); }
void static_key_enable__extern(struct static_key *key) { static_key_enable(key); }
void static_key_disable__extern(struct static_key *key) { static_key_disable(key); }
bool static_key_enabled__extern(struct static_key *key) { return static_key_enabled(key); }
int kstrtoul__extern(const char *s, unsigned int base, unsigned long *res) { return kstrtoul(s, base, res); }
int kstrtol__extern(const char *s, unsigned int base, long *res) { return kstrtol(s, base, res); }
int kstrtou64__extern(const char *s, unsigned int base, u64 *res) { return kstrtou64(s, base, res); }
int kstrtos64__extern(const char *s, unsigned int base, s64 *res) { return kstrtos64(s, base, res); }
int kstrtou32__extern(const char *s, unsigned int base, u32 *res) { return kstrtou32(s, base, res); }
int kstrtos32__extern(const char *s, unsigned int base, s32 *res) { return kstrtos32(s, base, res); }
u32 reciprocal_scale__extern(u32 val, u32 ep_ro) { return reciprocal_scale(val, ep_ro); }
u32 int_sqrt64__extern(u64 x) { return int_sqrt64(x); }
bool in_range64__extern(u64 val, u64 start, u64 len) { return in_range64(val, start, len); }
bool in_range32__extern(u32 val, u32 start, u32 len) { return in_range32(val, start, len); }
void le16_add_cpu__extern(__le16 *var, u16 val) { le16_add_cpu(var, val); }
void le32_add_cpu__extern(__le32 *var, u32 val) { le32_add_cpu(var, val); }
void le64_add_cpu__extern(__le64 *var, u64 val) { le64_add_cpu(var, val); }
void le32_to_cpu_array__extern(u32 *buf, unsigned int words) { le32_to_cpu_array(buf, words); }
size_t copy_to_user__extern(void *dst, void *src, size_t len) { return copy_to_user(dst, src, len); }
void __set_bit__extern(int nr, unsigned long *addr) { __set_bit(nr, addr); }
void set_bit__extern(long nr, unsigned long *addr) { set_bit(nr, addr); }
void __clear_bit__extern(int nr, unsigned long *addr) { __clear_bit(nr, addr); }
void clear_bit__extern(long nr, unsigned long *addr) { clear_bit(nr, addr); }
int test_bit__extern(long nr, const unsigned long *addr) { return test_bit(nr, addr); }
int test_bit_acquire__extern(long nr, const unsigned long *addr) { return test_bit_acquire(nr, addr); }
int __test_and_set_bit__extern(int nr, unsigned long *addr) { return __test_and_set_bit(nr, addr); }
bool test_and_set_bit__extern(long nr, unsigned long *addr) { return test_and_set_bit(nr, addr); }
bool test_and_clear_bit__extern(long nr, unsigned long *addr) { return test_and_clear_bit(nr, addr); }
void clear_bit_unlock__extern(long nr, unsigned long *addr) { clear_bit_unlock(nr, addr); }
bool test_and_set_bit_lock__extern(long nr, unsigned long *addr) { return test_and_set_bit_lock(nr, addr); }
unsigned long hweight_long__extern(unsigned long w) { return hweight_long(w); }
unsigned long hweight64__extern(u64 w) { return hweight64(w); }
unsigned long hweight32__extern(u32 w) { return hweight32(w); }
unsigned long hweight8__extern(unsigned long w) { return hweight8(w); }
__u64 rol64__extern(__u64 word, unsigned int shift) { return rol64(word, shift); }
__u64 ror64__extern(__u64 word, unsigned int shift) { return ror64(word, shift); }
__u32 rol32__extern(__u32 word, unsigned int shift) { return rol32(word, shift); }
__u32 ror32__extern(__u32 word, unsigned int shift) { return ror32(word, shift); }
__u16 rol16__extern(__u16 word, unsigned int shift) { return rol16(word, shift); }
__u16 ror16__extern(__u16 word, unsigned int shift) { return ror16(word, shift); }
__u8 rol8__extern(__u8 word, unsigned int shift) { return rol8(word, shift); }
__u8 ror8__extern(__u8 word, unsigned int shift) { return ror8(word, shift); }
unsigned long __fls__extern(unsigned long word) { return __fls(word); }
int fls__extern(int x) { return fls(x); }
int fls64__extern(__u64 x) { return fls64(x); }
unsigned int fls_long__extern(unsigned long l) { return fls_long(l); }
unsigned long __ffs__extern(unsigned long word) { return __ffs(word); }
unsigned long __ffs64__extern(u64 word) { return __ffs64(word); }
unsigned long rounddown_pow_of_two__extern(unsigned long n) { return rounddown_pow_of_two(n); }
int __bitmap_weight__extern(const unsigned long *bitmap, int bits) { return __bitmap_weight(bitmap, bits); }
int __bitmap_and__extern(unsigned long *dst, const unsigned long *bitmap1, const unsigned long *bitmap2, unsigned int bits) { return __bitmap_and(dst, bitmap1, bitmap2, bits); }
void bitmap_copy__extern(unsigned long *dst, const unsigned long *src, unsigned int bits) { bitmap_copy(dst, src, bits); }
void bitmap_complement__extern(unsigned long *dst, const unsigned long *src, unsigned int bits) { bitmap_complement(dst, src, bits); }
bool __bitmap_andnot__extern(unsigned long *dst, const unsigned long *bitmap1, const unsigned long *bitmap2, unsigned int bits) { return __bitmap_andnot(dst, bitmap1, bitmap2, bits); }
bool bitmap_andnot__extern(unsigned long *dst, const unsigned long *src1, const unsigned long *src2, unsigned int nbits) { return bitmap_andnot(dst, src1, src2, nbits); }
void bitmap_zero__extern(unsigned long *dst, int nbits) { bitmap_zero(dst, nbits); }
bool bitmap_subset__extern(const unsigned long *src1, const unsigned long *src2, unsigned int nbits) { return bitmap_subset(src1, src2, nbits); }
int bitmap_weight__extern(const unsigned long *src, int nbits) { return bitmap_weight(src, nbits); }
unsigned long * bitmap_alloc__extern(int nbits) { return bitmap_alloc(nbits); }
int bitmap_and__extern(unsigned long *dst, const unsigned long *src1, const unsigned long *src2, unsigned int nbits) { return bitmap_and(dst, src1, src2, nbits); }
void bitmap_or__extern(unsigned long *dst, const unsigned long *src1, const unsigned long *src2, unsigned int nbits) { bitmap_or(dst, src1, src2, nbits); }
unsigned long _find_next_bit__extern(const unsigned long *addr, unsigned long nbits, unsigned long start, unsigned long invert) { return _find_next_bit(addr, nbits, start, invert); }
unsigned long find_next_bit__extern(const unsigned long *addr, unsigned long size, unsigned long offset) { return find_next_bit(addr, size, offset); }
unsigned long find_next_zero_bit__extern(const unsigned long *addr, unsigned long size, unsigned long offset) { return find_next_zero_bit(addr, size, offset); }
unsigned long _find_next_andnot_bit__extern(const unsigned long *addr1, const unsigned long *addr2, unsigned long nbits, unsigned long start) { return _find_next_andnot_bit(addr1, addr2, nbits, start); }
unsigned long find_next_andnot_bit__extern(const unsigned long *addr1, const unsigned long *addr2, unsigned long size, unsigned long offset) { return find_next_andnot_bit(addr1, addr2, size, offset); }
bool bitmap_empty__extern(const unsigned long *src, unsigned int nbits) { return bitmap_empty(src, nbits); }
bool __bitmap_equal__extern(const unsigned long *bitmap1, const unsigned long *bitmap2, unsigned int bits) { return __bitmap_equal(bitmap1, bitmap2, bits); }
bool bitmap_equal__extern(const unsigned long *src1, const unsigned long *src2, unsigned int nbits) { return bitmap_equal(src1, src2, nbits); }
int list_empty_careful__extern(const struct cds_list_head *head) { return list_empty_careful(head); }
void list_replace__extern(struct cds_list_head *old, struct cds_list_head *_new) { list_replace(old, _new); }
void list_replace_init__extern(struct cds_list_head *old, struct cds_list_head *_new) { list_replace_init(old, _new); }
void list_move_tail__extern(struct cds_list_head *list, struct cds_list_head *head) { list_move_tail(list, head); }
void list_splice_init__extern(struct cds_list_head *list, struct cds_list_head *head) { list_splice_init(list, head); }
void list_splice_tail__extern(struct cds_list_head *list, struct cds_list_head *head) { list_splice_tail(list, head); }
void list_splice_tail_init__extern(struct cds_list_head *list, struct cds_list_head *head) { list_splice_tail_init(list, head); }
int hlist_unhashed__extern(const struct cds_hlist_node *h) { return hlist_unhashed(h); }
void cds_hlist_del_init__extern(struct cds_hlist_node *n) { cds_hlist_del_init(n); }
size_t list_count_nodes__extern(struct cds_list_head *head) { return list_count_nodes(head); }
int list_is_last__extern(const struct cds_list_head *list, const struct cds_list_head *head) { return list_is_last(list, head); }
int atomic_read__extern(const atomic_t *v) { return atomic_read(v); }
int atomic_read_acquire__extern(const atomic_t *v) { return atomic_read_acquire(v); }
void atomic_set__extern(atomic_t *v, int i) { atomic_set(v, i); }
void atomic_set_release__extern(atomic_t *v, int i) { atomic_set_release(v, i); }
int atomic_add_return__extern(int i, atomic_t *v) { return atomic_add_return(i, v); }
int atomic_add_return_release__extern(int i, atomic_t *v) { return atomic_add_return_release(i, v); }
int atomic_sub_return_release__extern(int i, atomic_t *v) { return atomic_sub_return_release(i, v); }
int atomic_fetch_sub_release__extern(int i, atomic_t *v) { return atomic_fetch_sub_release(i, v); }
int atomic_sub_return__extern(int i, atomic_t *v) { return atomic_sub_return(i, v); }
void atomic_add__extern(int i, atomic_t *v) { atomic_add(i, v); }
void atomic_sub__extern(int i, atomic_t *v) { atomic_sub(i, v); }
int atomic_inc_return__extern(atomic_t *v) { return atomic_inc_return(v); }
int atomic_dec_return__extern(atomic_t *v) { return atomic_dec_return(v); }
int atomic_dec_return_release__extern(atomic_t *v) { return atomic_dec_return_release(v); }
void atomic_inc__extern(atomic_t *v) { atomic_inc(v); }
void atomic_dec__extern(atomic_t *v) { atomic_dec(v); }
bool atomic_add_negative__extern(int i, atomic_t *v) { return atomic_add_negative(i, v); }
bool atomic_sub_and_test__extern(int i, atomic_t *v) { return atomic_sub_and_test(i, v); }
bool atomic_inc_and_test__extern(atomic_t *v) { return atomic_inc_and_test(v); }
bool atomic_dec_and_test__extern(atomic_t *v) { return atomic_dec_and_test(v); }
int atomic_add_unless__extern(atomic_t *v, int a, int u) { return atomic_add_unless(v, a, u); }
bool atomic_inc_not_zero__extern(atomic_t *v) { return atomic_inc_not_zero(v); }
void atomic_and__extern(int a, atomic_t *v) { atomic_and(a, v); }
void atomic_or__extern(int a, atomic_t *v) { atomic_or(a, v); }
int atomic_xchg__extern(atomic_t *v, int i) { return atomic_xchg(v, i); }
int atomic_cmpxchg__extern(atomic_t *v, int old, int new) { return atomic_cmpxchg(v, old, new); }
bool atomic_try_cmpxchg__extern(atomic_t *v, int *old, int new) { return atomic_try_cmpxchg(v, old, new); }
int atomic_cmpxchg_acquire__extern(atomic_t *v, int old, int new) { return atomic_cmpxchg_acquire(v, old, new); }
bool atomic_try_cmpxchg_acquire__extern(atomic_t *v, int *old, int new) { return atomic_try_cmpxchg_acquire(v, old, new); }
bool atomic_try_cmpxchg_release__extern(atomic_t *v, int *old, int new) { return atomic_try_cmpxchg_release(v, old, new); }
long atomic_long_read__extern(const atomic_long_t *v) { return atomic_long_read(v); }
long atomic_long_read_acquire__extern(const atomic_long_t *v) { return atomic_long_read_acquire(v); }
void atomic_long_set__extern(atomic_long_t *v, long i) { atomic_long_set(v, i); }
void atomic_long_set_release__extern(atomic_long_t *v, long i) { atomic_long_set_release(v, i); }
long atomic_long_add_return__extern(long i, atomic_long_t *v) { return atomic_long_add_return(i, v); }
long atomic_long_add_return_release__extern(long i, atomic_long_t *v) { return atomic_long_add_return_release(i, v); }
long atomic_long_sub_return_release__extern(long i, atomic_long_t *v) { return atomic_long_sub_return_release(i, v); }
long atomic_long_fetch_sub_release__extern(long i, atomic_long_t *v) { return atomic_long_fetch_sub_release(i, v); }
long atomic_long_sub_return__extern(long i, atomic_long_t *v) { return atomic_long_sub_return(i, v); }
void atomic_long_add__extern(long i, atomic_long_t *v) { atomic_long_add(i, v); }
void atomic_long_sub__extern(long i, atomic_long_t *v) { atomic_long_sub(i, v); }
long atomic_long_inc_return__extern(atomic_long_t *v) { return atomic_long_inc_return(v); }
long atomic_long_dec_return__extern(atomic_long_t *v) { return atomic_long_dec_return(v); }
long atomic_long_dec_return_release__extern(atomic_long_t *v) { return atomic_long_dec_return_release(v); }
void atomic_long_inc__extern(atomic_long_t *v) { atomic_long_inc(v); }
void atomic_long_dec__extern(atomic_long_t *v) { atomic_long_dec(v); }
bool atomic_long_add_negative__extern(long i, atomic_long_t *v) { return atomic_long_add_negative(i, v); }
bool atomic_long_sub_and_test__extern(long i, atomic_long_t *v) { return atomic_long_sub_and_test(i, v); }
bool atomic_long_inc_and_test__extern(atomic_long_t *v) { return atomic_long_inc_and_test(v); }
bool atomic_long_dec_and_test__extern(atomic_long_t *v) { return atomic_long_dec_and_test(v); }
long atomic_long_add_unless__extern(atomic_long_t *v, long a, long u) { return atomic_long_add_unless(v, a, u); }
bool atomic_long_inc_not_zero__extern(atomic_long_t *v) { return atomic_long_inc_not_zero(v); }
void atomic_long_and__extern(long a, atomic_long_t *v) { atomic_long_and(a, v); }
void atomic_long_or__extern(long a, atomic_long_t *v) { atomic_long_or(a, v); }
long atomic_long_xchg__extern(atomic_long_t *v, long i) { return atomic_long_xchg(v, i); }
long atomic_long_cmpxchg__extern(atomic_long_t *v, long old, long new) { return atomic_long_cmpxchg(v, old, new); }
bool atomic_long_try_cmpxchg__extern(atomic_long_t *v, long *old, long new) { return atomic_long_try_cmpxchg(v, old, new); }
long atomic_long_cmpxchg_acquire__extern(atomic_long_t *v, long old, long new) { return atomic_long_cmpxchg_acquire(v, old, new); }
bool atomic_long_try_cmpxchg_acquire__extern(atomic_long_t *v, long *old, long new) { return atomic_long_try_cmpxchg_acquire(v, old, new); }
bool atomic_long_try_cmpxchg_release__extern(atomic_long_t *v, long *old, long new) { return atomic_long_try_cmpxchg_release(v, old, new); }
s64 atomic64_read__extern(const atomic64_t *v) { return atomic64_read(v); }
s64 atomic64_read_acquire__extern(const atomic64_t *v) { return atomic64_read_acquire(v); }
void atomic64_set__extern(atomic64_t *v, s64 i) { atomic64_set(v, i); }
void atomic64_set_release__extern(atomic64_t *v, s64 i) { atomic64_set_release(v, i); }
s64 atomic64_add_return__extern(s64 i, atomic64_t *v) { return atomic64_add_return(i, v); }
s64 atomic64_add_return_release__extern(s64 i, atomic64_t *v) { return atomic64_add_return_release(i, v); }
s64 atomic64_sub_return_release__extern(s64 i, atomic64_t *v) { return atomic64_sub_return_release(i, v); }
s64 atomic64_fetch_sub_release__extern(s64 i, atomic64_t *v) { return atomic64_fetch_sub_release(i, v); }
s64 atomic64_sub_return__extern(s64 i, atomic64_t *v) { return atomic64_sub_return(i, v); }
void atomic64_add__extern(s64 i, atomic64_t *v) { atomic64_add(i, v); }
void atomic64_sub__extern(s64 i, atomic64_t *v) { atomic64_sub(i, v); }
s64 atomic64_inc_return__extern(atomic64_t *v) { return atomic64_inc_return(v); }
s64 atomic64_dec_return__extern(atomic64_t *v) { return atomic64_dec_return(v); }
s64 atomic64_dec_return_release__extern(atomic64_t *v) { return atomic64_dec_return_release(v); }
void atomic64_inc__extern(atomic64_t *v) { atomic64_inc(v); }
void atomic64_dec__extern(atomic64_t *v) { atomic64_dec(v); }
bool atomic64_add_negative__extern(s64 i, atomic64_t *v) { return atomic64_add_negative(i, v); }
bool atomic64_sub_and_test__extern(s64 i, atomic64_t *v) { return atomic64_sub_and_test(i, v); }
bool atomic64_inc_and_test__extern(atomic64_t *v) { return atomic64_inc_and_test(v); }
bool atomic64_dec_and_test__extern(atomic64_t *v) { return atomic64_dec_and_test(v); }
s64 atomic64_add_unless__extern(atomic64_t *v, s64 a, s64 u) { return atomic64_add_unless(v, a, u); }
bool atomic64_inc_not_zero__extern(atomic64_t *v) { return atomic64_inc_not_zero(v); }
void atomic64_and__extern(s64 a, atomic64_t *v) { atomic64_and(a, v); }
void atomic64_or__extern(s64 a, atomic64_t *v) { atomic64_or(a, v); }
s64 atomic64_xchg__extern(atomic64_t *v, s64 i) { return atomic64_xchg(v, i); }
s64 atomic64_cmpxchg__extern(atomic64_t *v, s64 old, s64 new) { return atomic64_cmpxchg(v, old, new); }
bool atomic64_try_cmpxchg__extern(atomic64_t *v, s64 *old, s64 new) { return atomic64_try_cmpxchg(v, old, new); }
s64 atomic64_cmpxchg_acquire__extern(atomic64_t *v, s64 old, s64 new) { return atomic64_cmpxchg_acquire(v, old, new); }
bool atomic64_try_cmpxchg_acquire__extern(atomic64_t *v, s64 *old, s64 new) { return atomic64_try_cmpxchg_acquire(v, old, new); }
bool atomic64_try_cmpxchg_release__extern(atomic64_t *v, s64 *old, s64 new) { return atomic64_try_cmpxchg_release(v, old, new); }
void raw_spin_lock_init__extern(raw_spinlock_t *lock) { raw_spin_lock_init(lock); }
bool raw_spin_trylock__extern(raw_spinlock_t *lock) { return raw_spin_trylock(lock); }
void raw_spin_lock__extern(raw_spinlock_t *lock) { raw_spin_lock(lock); }
void raw_spin_unlock__extern(raw_spinlock_t *lock) { raw_spin_unlock(lock); }
void init_waitqueue_head__extern(wait_queue_head_t *q) { init_waitqueue_head(q); }
int wait_on_bit__extern(unsigned long *word, int bit, unsigned int mode) { return wait_on_bit(word, bit, mode); }
int wait_on_bit_lock__extern(unsigned long *word, int bit, unsigned int mode) { return wait_on_bit_lock(word, bit, mode); }
void * ERR_PTR__extern(long error_) { return ERR_PTR(error_); }
long PTR_ERR__extern(const void *ptr) { return PTR_ERR(ptr); }
bool IS_ERR__extern(const void *ptr) { return IS_ERR(ptr); }
bool IS_ERR_OR_NULL__extern(const void *ptr) { return IS_ERR_OR_NULL(ptr); }
void * ERR_CAST__extern(const void *ptr) { return ERR_CAST(ptr); }
int PTR_ERR_OR_ZERO__extern(const void *ptr) { return PTR_ERR_OR_ZERO(ptr); }
int __ilog2_u32__extern(u32 n) { return __ilog2_u32(n); }
int __ilog2_u64__extern(u64 n) { return __ilog2_u64(n); }
bool is_power_of_2__extern(unsigned long n) { return is_power_of_2(n); }
unsigned long __roundup_pow_of_two__extern(unsigned long n) { return __roundup_pow_of_two(n); }
unsigned long __rounddown_pow_of_two__extern(unsigned long n) { return __rounddown_pow_of_two(n); }
int __order_base_2__extern(unsigned long n) { return __order_base_2(n); }
int __bits_per__extern(unsigned long n) { return __bits_per(n); }
int get_order__extern(unsigned long size) { return get_order(size); }
size_t kmalloc_size_roundup__extern(size_t s) { return kmalloc_size_roundup(s); }
void * kmalloc_noprof__extern(size_t size, gfp_t flags) { return kmalloc_noprof(size, flags); }
void * krealloc__extern(void *old, size_t size, gfp_t flags) { return krealloc(old, size, flags); }
void * kvrealloc__extern(void *old, size_t size, gfp_t flags) { return kvrealloc(old, size, flags); }
void * krealloc_array__extern(void *p, size_t new_n, size_t new_size, gfp_t flags) { return krealloc_array(p, new_n, new_size, flags); }
void * kmalloc_array__extern(size_t n, size_t size, gfp_t flags) { return kmalloc_array(n, size, flags); }
void __free_kfree__extern(void *p) { __free_kfree(p); }
void __free_kvfree__extern(void *p) { __free_kvfree(p); }
struct page * alloc_pages_noprof__extern(gfp_t flags, unsigned int order) { return alloc_pages_noprof(flags, order); }
void vunmap__extern(const void *addr) { vunmap(addr); }
void * vmap__extern(struct page **pages, unsigned int count, unsigned long flags, unsigned int prot) { return vmap(pages, count, flags, prot); }
void * kmemdup__extern(const void *src, size_t len, gfp_t gfp) { return kmemdup(src, len, gfp); }
void * kmem_cache_alloc__extern(struct kmem_cache *c, gfp_t gfp) { return kmem_cache_alloc(c, gfp); }
void * kmem_cache_zalloc__extern(struct kmem_cache *c, gfp_t gfp) { return kmem_cache_zalloc(c, gfp); }
void kmem_cache_free__extern(struct kmem_cache *c, void *p) { kmem_cache_free(c, p); }
void kmem_cache_destroy__extern(struct kmem_cache *p) { kmem_cache_destroy(p); }
struct kmem_cache * kmem_cache_create__extern(size_t obj_size) { return kmem_cache_create(obj_size); }
void * __vmalloc_noprof__extern(unsigned long size, gfp_t flags) { return __vmalloc_noprof(size, flags); }
void * vmalloc_exec__extern(unsigned long size, gfp_t gfp_mask) { return vmalloc_exec(size, gfp_mask); }
void * vmalloc__extern(unsigned long size) { return vmalloc(size); }
void * vzalloc__extern(unsigned long size) { return vzalloc(size); }
bool mempool_initialized__extern(mempool_t *pool) { return mempool_initialized(pool); }
int mempool_init_slab_pool__extern(mempool_t *pool, int min_nr, struct kmem_cache *kc) { return mempool_init_slab_pool(pool, min_nr, kc); }
mempool_t * mempool_create_slab_pool__extern(int min_nr, struct kmem_cache *kc) { return mempool_create_slab_pool(min_nr, kc); }
int mempool_init_kmalloc_pool__extern(mempool_t *pool, int min_nr, size_t size) { return mempool_init_kmalloc_pool(pool, min_nr, size); }
mempool_t * mempool_create_kmalloc_pool__extern(int min_nr, size_t size) { return mempool_create_kmalloc_pool(min_nr, size); }
int mempool_init_page_pool__extern(mempool_t *pool, int min_nr, int order) { return mempool_init_page_pool(pool, min_nr, order); }
mempool_t * mempool_create_page_pool__extern(int min_nr, int order) { return mempool_create_page_pool(min_nr, order); }
int bdi_congested__extern(struct backing_dev_info *bdi, int cong_bits) { return bdi_congested(bdi, cong_bits); }
int bdi_setup_and_register__extern(struct backing_dev_info *bdi, char *name) { return bdi_setup_and_register(bdi, name); }
void bdi_destroy__extern(struct backing_dev_info *bdi) { bdi_destroy(bdi); }
void * bvec_virt__extern(struct bio_vec *bv) { return bvec_virt(bv); }
void bvec_iter_advance__extern(const struct bio_vec *bv, struct bvec_iter *iter, unsigned int bytes) { bvec_iter_advance(bv, iter, bytes); }
void timer_setup__extern(struct timer_list *timer, void (*func) (struct timer_list *), unsigned int flags) { timer_setup(timer, func, flags); }
int timer_pending__extern(const struct timer_list *timer) { return timer_pending(timer); }
void add_timer__extern(struct timer_list *timer) { add_timer(timer); }
struct delayed_work * to_delayed_work__extern(struct work_struct *work) { return to_delayed_work(work); }
bool work_pending__extern(struct work_struct *work) { return work_pending(work); }
bool delayed_work_pending__extern(struct delayed_work *dwork) { return delayed_work_pending(dwork); }
int work_busy__extern(struct work_struct *work) { return work_busy(work); }
bool schedule_work_on__extern(int cpu, struct work_struct *work) { return schedule_work_on(cpu, work); }
bool schedule_work__extern(struct work_struct *work) { return schedule_work(work); }
bool schedule_delayed_work_on__extern(int cpu, struct delayed_work *dwork, unsigned long delay) { return schedule_delayed_work_on(cpu, dwork, delay); }
bool schedule_delayed_work__extern(struct delayed_work *dwork, unsigned long delay) { return schedule_delayed_work(dwork, delay); }
void kobject_uevent_env__extern(struct kobject *kobj, int flags, char **envp) { kobject_uevent_env(kobj, flags, envp); }
void mutex_init__extern(struct mutex *l) { mutex_init(l); }
void mutex_lock__extern(struct mutex *l) { mutex_lock(l); }
bool mutex_trylock__extern(struct mutex *l) { return mutex_trylock(l); }
void mutex_unlock__extern(struct mutex *l) { mutex_unlock(l); }
void init_rwsem__extern(struct rw_semaphore *lock) { init_rwsem(lock); }
void down_read__extern(struct rw_semaphore *sem) { down_read(sem); }
int down_read_trylock__extern(struct rw_semaphore *sem) { return down_read_trylock(sem); }
int down_read_interruptible__extern(struct rw_semaphore *sem) { return down_read_interruptible(sem); }
int down_read_killable__extern(struct rw_semaphore *sem) { return down_read_killable(sem); }
void up_read__extern(struct rw_semaphore *sem) { up_read(sem); }
void down_write__extern(struct rw_semaphore *sem) { down_write(sem); }
int down_write_trylock__extern(struct rw_semaphore *sem) { return down_write_trylock(sem); }
void up_write__extern(struct rw_semaphore *sem) { up_write(sem); }
struct bio_vec * bio_inline_vecs__extern(struct bio *bio) { return bio_inline_vecs(bio); }
void bio_set_op_attrs__extern(struct bio *bio, unsigned int op, unsigned int op_flags) { bio_set_op_attrs(bio, op, op_flags); }
struct inode * file_inode__extern(const struct file *f) { return file_inode(f); }
void submit_bio__extern(struct bio *bio) { submit_bio(bio); }
void blk_start_plug__extern(struct blk_plug *plug) { blk_start_plug(plug); }
void blk_finish_plug__extern(struct blk_plug *plug) { blk_finish_plug(plug); }
struct block_device * file_bdev__extern(struct file *file) { return file_bdev(file); }
void evict_inodes__extern(struct super_block *sb) { evict_inodes(sb); }
int sync_filesystem__extern(struct super_block *sb) { return sync_filesystem(sb); }
int register_chrdev__extern(unsigned int major, const char *name, const struct file_operations *fops) { return register_chrdev(major, name, fops); }
void unregister_chrdev__extern(unsigned int major, const char *name) { unregister_chrdev(major, name); }
const char * bdevname__extern(struct block_device *bdev, char *buf) { return bdevname(bdev, buf); }
bool op_is_write__extern(unsigned int op) { return op_is_write(op); }
int bio_data_dir__extern(struct bio *bio) { return bio_data_dir(bio); }
bool dir_emit__extern(struct dir_context *ctx, const char *name, int namelen, u64 ino, unsigned int type) { return dir_emit(ctx, name, namelen, ino, type); }
bool dir_emit_dots__extern(struct file *file, struct dir_context *ctx) { return dir_emit_dots(file, ctx); }
void invalidate_bdev__extern(struct block_device *bdev) { invalidate_bdev(bdev); }
bool bio_has_data__extern(struct bio *bio) { return bio_has_data(bio); }
bool bio_no_advance_iter__extern(struct bio *bio) { return bio_no_advance_iter(bio); }
bool bio_is_rw__extern(struct bio *bio) { return bio_is_rw(bio); }
bool bio_mergeable__extern(struct bio *bio) { return bio_mergeable(bio); }
unsigned int bio_cur_bytes__extern(struct bio *bio) { return bio_cur_bytes(bio); }
struct bio_vec * bio_next_segment__extern(const struct bio *bio, struct bvec_iter_all *iter) { return bio_next_segment(bio, iter); }
void bio_advance_iter__extern(struct bio *bio, struct bvec_iter *iter, unsigned int bytes) { bio_advance_iter(bio, iter, bytes); }
unsigned int bio_segments__extern(struct bio *bio) { return bio_segments(bio); }
void bio_get__extern(struct bio *bio) { bio_get(bio); }
bool bio_flagged__extern(struct bio *bio, unsigned int bit) { return bio_flagged(bio, bit); }
void bio_set_flag__extern(struct bio *bio, unsigned int bit) { bio_set_flag(bio, bit); }
void bio_clear_flag__extern(struct bio *bio, unsigned int bit) { bio_clear_flag(bio, bit); }
struct bio * bio_next_split__extern(struct bio *bio, int sectors, gfp_t gfp, struct bio_set *bs) { return bio_next_split(bio, sectors, gfp, bs); }
void bioset_free__extern(struct bio_set *bs) { bioset_free(bs); }
void bio_add_vmalloc__extern(struct bio *bio, void *vaddr, unsigned int len) { bio_add_vmalloc(bio, vaddr, len); }
void zero_fill_bio__extern(struct bio *bio) { zero_fill_bio(bio); }
void * bvec_kmap_local__extern(struct bio_vec *bvec) { return bvec_kmap_local(bvec); }
void bvec_kunmap_local__extern(char *buffer) { bvec_kunmap_local(buffer); }
int bio_list_empty__extern(const struct bio_list *bl) { return bio_list_empty(bl); }
void bio_list_init__extern(struct bio_list *bl) { bio_list_init(bl); }
unsigned int bio_list_size__extern(const struct bio_list *bl) { return bio_list_size(bl); }
void bio_list_add__extern(struct bio_list *bl, struct bio *bio) { bio_list_add(bl, bio); }
void bio_list_add_head__extern(struct bio_list *bl, struct bio *bio) { bio_list_add_head(bl, bio); }
void bio_list_merge__extern(struct bio_list *bl, struct bio_list *bl2) { bio_list_merge(bl, bl2); }
void bio_list_merge_head__extern(struct bio_list *bl, struct bio_list *bl2) { bio_list_merge_head(bl, bl2); }
struct bio * bio_list_peek__extern(struct bio_list *bl) { return bio_list_peek(bl); }
struct bio * bio_list_pop__extern(struct bio_list *bl) { return bio_list_pop(bl); }
struct bio * bio_list_get__extern(struct bio_list *bl) { return bio_list_get(bl); }
void bio_inc_remaining__extern(struct bio *bio) { bio_inc_remaining(bio); }
void bio_init__extern(struct bio *bio, struct block_device *bdev, struct bio_vec *table, unsigned short max_vecs, unsigned int opf) { bio_init(bio, bdev, table, max_vecs, opf); }
int genradix_depth_shift__extern(unsigned int depth) { return genradix_depth_shift(depth); }
size_t genradix_depth_size__extern(unsigned int depth) { return genradix_depth_size(depth); }
unsigned int genradix_root_to_depth__extern(struct genradix_root *r) { return genradix_root_to_depth(r); }
struct genradix_node * genradix_root_to_node__extern(struct genradix_root *r) { return genradix_root_to_node(r); }
struct genradix_node * genradix_alloc_node__extern(gfp_t gfp_mask) { return genradix_alloc_node(gfp_mask); }
void genradix_free_node__extern(struct genradix_node *node) { genradix_free_node(node); }
bool __idx_to_offset__extern(size_t idx, size_t obj_size, size_t *offset) { return __idx_to_offset(idx, obj_size, offset); }
void * __genradix_ptr_inlined__extern(struct __genradix *radix, size_t offset) { return __genradix_ptr_inlined(radix, offset); }
void __genradix_iter_advance__extern(struct genradix_iter *iter, size_t obj_size) { __genradix_iter_advance(iter, obj_size); }
void __genradix_iter_rewind__extern(struct genradix_iter *iter, size_t obj_size) { __genradix_iter_rewind(iter, obj_size); }
int idr_alloc__extern(struct idr *idp, void *ptr, int start, int end, gfp_t gfp_mask) { return idr_alloc(idp, ptr, start, end, gfp_mask); }
void idr_remove__extern(struct idr *idp, int id) { idr_remove(idp, id); }
int ida_alloc__extern(struct ida *ida, gfp_t gfp) { return ida_alloc(ida, gfp); }
int ida_alloc_min__extern(struct ida *ida, unsigned int min, gfp_t gfp) { return ida_alloc_min(ida, min, gfp); }
int ida_alloc_max__extern(struct ida *ida, unsigned int max, gfp_t gfp) { return ida_alloc_max(ida, max, gfp); }
void init_llist_head__extern(struct llist_head *list) { init_llist_head(list); }
bool llist_empty__extern(const struct llist_head *head) { return llist_empty(head); }
struct llist_node * llist_next__extern(struct llist_node *node) { return llist_next(node); }
bool llist_add__extern(struct llist_node *new, struct llist_head *head) { return llist_add(new, head); }
struct llist_node * llist_del_all__extern(struct llist_head *head) { return llist_del_all(head); }
void * __bch_percpu_resolve__extern(void *p, void *chunk) { return __bch_percpu_resolve(p, chunk); }
void percpu_ref_exit__extern(struct percpu_ref *ref) { percpu_ref_exit(ref); }
int percpu_ref_init__extern(struct percpu_ref *ref, percpu_ref_func_t *release, unsigned int flags, gfp_t gfp) { return percpu_ref_init(ref, release, flags, gfp); }
void percpu_ref_get_many__extern(struct percpu_ref *ref, unsigned long nr) { percpu_ref_get_many(ref, nr); }
void percpu_ref_get__extern(struct percpu_ref *ref) { percpu_ref_get(ref); }
bool percpu_ref_tryget__extern(struct percpu_ref *ref) { return percpu_ref_tryget(ref); }
bool percpu_ref_tryget_live__extern(struct percpu_ref *ref) { return percpu_ref_tryget_live(ref); }
void percpu_ref_put_many__extern(struct percpu_ref *ref, unsigned long nr) { percpu_ref_put_many(ref, nr); }
void percpu_ref_put__extern(struct percpu_ref *ref) { percpu_ref_put(ref); }
void percpu_ref_reinit__extern(struct percpu_ref *ref) { percpu_ref_reinit(ref); }
void percpu_ref_kill__extern(struct percpu_ref *ref) { percpu_ref_kill(ref); }
bool percpu_ref_is_zero__extern(struct percpu_ref *ref) { return percpu_ref_is_zero(ref); }
bool percpu_ref_is_dying__extern(struct percpu_ref *ref) { return percpu_ref_is_dying(ref); }
void percpu_down_read_preempt_disable__extern(struct percpu_rw_semaphore *sem) { percpu_down_read_preempt_disable(sem); }
void percpu_down_read__extern(struct percpu_rw_semaphore *sem) { percpu_down_read(sem); }
int percpu_down_read_trylock__extern(struct percpu_rw_semaphore *sem) { return percpu_down_read_trylock(sem); }
void percpu_up_read_preempt_enable__extern(struct percpu_rw_semaphore *sem) { percpu_up_read_preempt_enable(sem); }
void percpu_up_read__extern(struct percpu_rw_semaphore *sem) { percpu_up_read(sem); }
void percpu_down_write__extern(struct percpu_rw_semaphore *sem) { percpu_down_write(sem); }
void percpu_up_write__extern(struct percpu_rw_semaphore *sem) { percpu_up_write(sem); }
void percpu_free_rwsem__extern(struct percpu_rw_semaphore *sem) { percpu_free_rwsem(sem); }
int percpu_init_rwsem__extern(struct percpu_rw_semaphore *sem) { return percpu_init_rwsem(sem); }
int vscnprintf__extern(char *buf, size_t size, const char *fmt, va_list args) { return vscnprintf(buf, size, fmt, args); }
void init_completion__extern(struct completion *x) { init_completion(x); }
void reinit_completion__extern(struct completion *x) { reinit_completion(x); }
struct timespec ns_to_timespec__extern(const u64 nsec) { return ns_to_timespec(nsec); }
s64 timespec_to_ns__extern(const struct timespec *ts) { return timespec_to_ns(ts); }
struct timespec timespec_trunc__extern(struct timespec t, unsigned int gran) { return timespec_trunc(t, gran); }
void set_normalized_timespec64__extern(struct timespec *ts, time64_t sec, s64 nsec) { set_normalized_timespec64(ts, sec, nsec); }
u64 jiffies_to_nsecs__extern(const unsigned long j) { return jiffies_to_nsecs(j); }
unsigned int jiffies_to_msecs__extern(const unsigned long j) { return jiffies_to_msecs(j); }
unsigned long msecs_to_jiffies__extern(const unsigned int m) { return msecs_to_jiffies(m); }
unsigned long nsecs_to_jiffies__extern(u64 n) { return nsecs_to_jiffies(n); }
u64 sched_clock__extern(void) { return sched_clock(); }
u64 local_clock__extern(void) { return local_clock(); }
u64 ktime_get_ns__extern(void) { return ktime_get_ns(); }
struct task_struct * get_task_struct__extern(struct task_struct *task) { return get_task_struct(task); }
void put_task_struct__extern(struct task_struct *t) { put_task_struct(t); }
void cond_resched__extern(void) { cond_resched(); }
void io_schedule__extern(void) { io_schedule(); }
long io_schedule_timeout__extern(long timeout) { return io_schedule_timeout(timeout); }
u64 ktime_get_seconds__extern(void) { return ktime_get_seconds(); }
u64 ktime_get_real_ns__extern(void) { return ktime_get_real_ns(); }
u64 ktime_get_real_seconds__extern(void) { return ktime_get_real_seconds(); }
void ktime_get_coarse_real_ts64__extern(struct timespec *ts) { ktime_get_coarse_real_ts64(ts); }
void ratelimit_state_init__extern(struct ratelimit_state *rs, int interval, int burst) { ratelimit_state_init(rs, interval, burst); }
void ratelimit_default_init__extern(struct ratelimit_state *rs) { ratelimit_default_init(rs); }
void ratelimit_state_inc_miss__extern(struct ratelimit_state *rs) { ratelimit_state_inc_miss(rs); }
int ratelimit_state_get_miss__extern(struct ratelimit_state *rs) { return ratelimit_state_get_miss(rs); }
int ratelimit_state_reset_miss__extern(struct ratelimit_state *rs) { return ratelimit_state_reset_miss(rs); }
void ratelimit_state_reset_interval__extern(struct ratelimit_state *rs, int interval_init) { ratelimit_state_reset_interval(rs, interval_init); }
void ratelimit_state_exit__extern(struct ratelimit_state *rs) { ratelimit_state_exit(rs); }
void ratelimit_set_flags__extern(struct ratelimit_state *rs, unsigned long flags) { ratelimit_set_flags(rs, flags); }
void refcount_set__extern(refcount_t *r, int n) { refcount_set(r, n); }
unsigned int refcount_read__extern(const refcount_t *r) { return refcount_read(r); }
bool __refcount_add_not_zero__extern(int i, refcount_t *r, int *oldp) { return __refcount_add_not_zero(i, r, oldp); }
bool refcount_add_not_zero__extern(int i, refcount_t *r) { return refcount_add_not_zero(i, r); }
void __refcount_add__extern(int i, refcount_t *r, int *oldp) { __refcount_add(i, r, oldp); }
void refcount_add__extern(int i, refcount_t *r) { refcount_add(i, r); }
bool __refcount_inc_not_zero__extern(refcount_t *r, int *oldp) { return __refcount_inc_not_zero(r, oldp); }
bool refcount_inc_not_zero__extern(refcount_t *r) { return refcount_inc_not_zero(r); }
void __refcount_inc__extern(refcount_t *r, int *oldp) { __refcount_inc(r, oldp); }
void refcount_inc__extern(refcount_t *r) { refcount_inc(r); }
bool __refcount_sub_and_test__extern(int i, refcount_t *r, int *oldp) { return __refcount_sub_and_test(i, r, oldp); }
bool refcount_sub_and_test__extern(int i, refcount_t *r) { return refcount_sub_and_test(i, r); }
bool __refcount_dec_and_test__extern(refcount_t *r, int *oldp) { return __refcount_dec_and_test(r, oldp); }
bool refcount_dec_and_test__extern(refcount_t *r) { return refcount_dec_and_test(r); }
void __refcount_dec__extern(refcount_t *r, int *oldp) { __refcount_dec(r, oldp); }
void refcount_dec__extern(refcount_t *r) { refcount_dec(r); }
void rcu_free_wrapper_cb__extern(struct rcu_head *head) { rcu_free_wrapper_cb(head); }
void rcu_free_ptr__extern(void *p) { rcu_free_ptr(p); }
void rcu_head_init__extern(struct rcu_head *rhp) { rcu_head_init(rhp); }
bool rcu_head_after_call_rcu__extern(struct rcu_head *rhp, void (*f) (struct rcu_head *head)) { return rcu_head_after_call_rcu(rhp, f); }
u16 __get_unaligned_cpu16__extern(const void *p) { return __get_unaligned_cpu16(p); }
u32 __get_unaligned_cpu32__extern(const void *p) { return __get_unaligned_cpu32(p); }
u64 __get_unaligned_cpu64__extern(const void *p) { return __get_unaligned_cpu64(p); }
void __put_unaligned_cpu16__extern(u16 val, void *p) { __put_unaligned_cpu16(val, p); }
void __put_unaligned_cpu32__extern(u32 val, void *p) { __put_unaligned_cpu32(val, p); }
void __put_unaligned_cpu64__extern(u64 val, void *p) { __put_unaligned_cpu64(val, p); }
u32 jhash__extern(const void *key, u32 length, u32 initval) { return jhash(key, length, initval); }
u32 jhash2__extern(const u32 *k, u32 length, u32 initval) { return jhash2(k, length, initval); }
u32 __jhash_nwords__extern(u32 a, u32 b, u32 c, u32 initval) { return __jhash_nwords(a, b, c, initval); }
u32 jhash_3words__extern(u32 a, u32 b, u32 c, u32 initval) { return jhash_3words(a, b, c, initval); }
u32 jhash_2words__extern(u32 a, u32 b, u32 initval) { return jhash_2words(a, b, initval); }
u32 jhash_1word__extern(u32 a, u32 initval) { return jhash_1word(a, initval); }
int is_a_nulls__extern(const struct hlist_nulls_node *ptr) { return is_a_nulls(ptr); }
unsigned long get_nulls_value__extern(const struct hlist_nulls_node *ptr) { return get_nulls_value(ptr); }
int hlist_nulls_unhashed__extern(const struct hlist_nulls_node *h) { return hlist_nulls_unhashed(h); }
int hlist_nulls_unhashed_lockless__extern(const struct hlist_nulls_node *h) { return hlist_nulls_unhashed_lockless(h); }
int hlist_nulls_empty__extern(const struct hlist_nulls_head *h) { return hlist_nulls_empty(h); }
void hlist_nulls_add_head__extern(struct hlist_nulls_node *n, struct hlist_nulls_head *h) { hlist_nulls_add_head(n, h); }
void __hlist_nulls_del__extern(struct hlist_nulls_node *n) { __hlist_nulls_del(n); }
void hlist_nulls_del__extern(struct hlist_nulls_node *n) { hlist_nulls_del(n); }
void do_futex__extern(int nr, unsigned long *addr, unsigned long v, int futex_flags) { do_futex(nr, addr, v, futex_flags); }
void bit_spin_lock__extern(int nr, unsigned long *_addr) { bit_spin_lock(nr, _addr); }
void bit_spin_wake__extern(int nr, unsigned long *_addr) { bit_spin_wake(nr, _addr); }
void bit_spin_unlock__extern(int nr, unsigned long *_addr) { bit_spin_unlock(nr, _addr); }
bool rht_is_a_nulls__extern(const struct rhash_head *ptr) { return rht_is_a_nulls(ptr); }
void * rht_obj__extern(const struct rhashtable *ht, const struct rhash_head *he) { return rht_obj(ht, he); }
unsigned int rht_bucket_index__extern(const struct bucket_table *tbl, unsigned int hash) { return rht_bucket_index(tbl, hash); }
unsigned int rht_key_get_hash__extern(struct rhashtable *ht, const void *key, const struct rhashtable_params params, unsigned int hash_rnd) { return rht_key_get_hash(ht, key, params, hash_rnd); }
unsigned int rht_key_hashfn__extern(struct rhashtable *ht, const struct bucket_table *tbl, const void *key, const struct rhashtable_params params) { return rht_key_hashfn(ht, tbl, key, params); }
unsigned int rht_head_hashfn__extern(struct rhashtable *ht, const struct bucket_table *tbl, const struct rhash_head *he, const struct rhashtable_params params) { return rht_head_hashfn(ht, tbl, he, params); }
bool rht_grow_above_75__extern(const struct rhashtable *ht, const struct bucket_table *tbl) { return rht_grow_above_75(ht, tbl); }
bool rht_shrink_below_30__extern(const struct rhashtable *ht, const struct bucket_table *tbl) { return rht_shrink_below_30(ht, tbl); }
bool rht_grow_above_100__extern(const struct rhashtable *ht, const struct bucket_table *tbl) { return rht_grow_above_100(ht, tbl); }
bool rht_grow_above_max__extern(const struct rhashtable *ht, const struct bucket_table *tbl) { return rht_grow_above_max(ht, tbl); }
int lockdep_rht_mutex_is_held__extern(struct rhashtable *ht) { return lockdep_rht_mutex_is_held(ht); }
int lockdep_rht_bucket_is_held__extern(const struct bucket_table *tbl, u32 hash) { return lockdep_rht_bucket_is_held(tbl, hash); }
void rhashtable_walk_start__extern(struct rhashtable_iter *iter) { rhashtable_walk_start(iter); }
struct rhash_lock_head *const * rht_bucket__extern(const struct bucket_table *tbl, unsigned int hash) { return rht_bucket(tbl, hash); }
struct rhash_lock_head ** rht_bucket_var__extern(struct bucket_table *tbl, unsigned int hash) { return rht_bucket_var(tbl, hash); }
struct rhash_lock_head ** rht_bucket_insert__extern(struct rhashtable *ht, struct bucket_table *tbl, unsigned int hash) { return rht_bucket_insert(ht, tbl, hash); }
void rht_lock__extern(struct bucket_table *tbl, struct rhash_lock_head **bkt) { rht_lock(tbl, bkt); }
void rht_lock_nested__extern(struct bucket_table *tbl, struct rhash_lock_head **bucket, unsigned int subclass) { rht_lock_nested(tbl, bucket, subclass); }
void rht_unlock__extern(struct bucket_table *tbl, struct rhash_lock_head **bkt) { rht_unlock(tbl, bkt); }
struct rhash_head * __rht_ptr__extern(struct rhash_lock_head *p, struct rhash_lock_head *const *bkt) { return __rht_ptr(p, bkt); }
struct rhash_head * rht_ptr_rcu__extern(struct rhash_lock_head *const *bkt) { return rht_ptr_rcu(bkt); }
struct rhash_head * rht_ptr__extern(struct rhash_lock_head *const *bkt, struct bucket_table *tbl, unsigned int hash) { return rht_ptr(bkt, tbl, hash); }
struct rhash_head * rht_ptr_exclusive__extern(struct rhash_lock_head *const *bkt) { return rht_ptr_exclusive(bkt); }
void rht_assign_locked__extern(struct rhash_lock_head **bkt, struct rhash_head *obj) { rht_assign_locked(bkt, obj); }
void rht_assign_unlock__extern(struct bucket_table *tbl, struct rhash_lock_head **bkt, struct rhash_head *obj) { rht_assign_unlock(tbl, bkt, obj); }
int rhashtable_compare__extern(struct rhashtable_compare_arg *arg, const void *obj) { return rhashtable_compare(arg, obj); }
struct rhash_head * __rhashtable_lookup__extern(struct rhashtable *ht, const void *key, const struct rhashtable_params params) { return __rhashtable_lookup(ht, key, params); }
void * rhashtable_lookup__extern(struct rhashtable *ht, const void *key, const struct rhashtable_params params) { return rhashtable_lookup(ht, key, params); }
void * rhashtable_lookup_fast__extern(struct rhashtable *ht, const void *key, const struct rhashtable_params params) { return rhashtable_lookup_fast(ht, key, params); }
struct rhlist_head * rhltable_lookup__extern(struct rhltable *hlt, const void *key, const struct rhashtable_params params) { return rhltable_lookup(hlt, key, params); }
void * __rhashtable_insert_fast__extern(struct rhashtable *ht, const void *key, struct rhash_head *obj, const struct rhashtable_params params, bool rhlist) { return __rhashtable_insert_fast(ht, key, obj, params, rhlist); }
int rhashtable_insert_fast__extern(struct rhashtable *ht, struct rhash_head *obj, const struct rhashtable_params params) { return rhashtable_insert_fast(ht, obj, params); }
int rhltable_insert_key__extern(struct rhltable *hlt, const void *key, struct rhlist_head *list, const struct rhashtable_params params) { return rhltable_insert_key(hlt, key, list, params); }
int rhltable_insert__extern(struct rhltable *hlt, struct rhlist_head *list, const struct rhashtable_params params) { return rhltable_insert(hlt, list, params); }
int rhashtable_lookup_insert_fast__extern(struct rhashtable *ht, struct rhash_head *obj, const struct rhashtable_params params) { return rhashtable_lookup_insert_fast(ht, obj, params); }
void * rhashtable_lookup_get_insert_fast__extern(struct rhashtable *ht, struct rhash_head *obj, const struct rhashtable_params params) { return rhashtable_lookup_get_insert_fast(ht, obj, params); }
int rhashtable_lookup_insert_key__extern(struct rhashtable *ht, const void *key, struct rhash_head *obj, const struct rhashtable_params params) { return rhashtable_lookup_insert_key(ht, key, obj, params); }
void * rhashtable_lookup_get_insert_key__extern(struct rhashtable *ht, const void *key, struct rhash_head *obj, const struct rhashtable_params params) { return rhashtable_lookup_get_insert_key(ht, key, obj, params); }
int __rhashtable_remove_fast_one__extern(struct rhashtable *ht, struct bucket_table *tbl, struct rhash_head *obj, const struct rhashtable_params params, bool rhlist) { return __rhashtable_remove_fast_one(ht, tbl, obj, params, rhlist); }
int __rhashtable_remove_fast__extern(struct rhashtable *ht, struct rhash_head *obj, const struct rhashtable_params params, bool rhlist) { return __rhashtable_remove_fast(ht, obj, params, rhlist); }
int rhashtable_remove_fast__extern(struct rhashtable *ht, struct rhash_head *obj, const struct rhashtable_params params) { return rhashtable_remove_fast(ht, obj, params); }
int rhltable_remove__extern(struct rhltable *hlt, struct rhlist_head *list, const struct rhashtable_params params) { return rhltable_remove(hlt, list, params); }
int __rhashtable_replace_fast__extern(struct rhashtable *ht, struct bucket_table *tbl, struct rhash_head *obj_old, struct rhash_head *obj_new, const struct rhashtable_params params) { return __rhashtable_replace_fast(ht, tbl, obj_old, obj_new, params); }
int rhashtable_replace_fast__extern(struct rhashtable *ht, struct rhash_head *obj_old, struct rhash_head *obj_new, const struct rhashtable_params params) { return rhashtable_replace_fast(ht, obj_old, obj_new, params); }
void rhltable_walk_enter__extern(struct rhltable *hlt, struct rhashtable_iter *iter) { rhltable_walk_enter(hlt, iter); }
void rhltable_free_and_destroy__extern(struct rhltable *hlt, void (*free_fn) (void *ptr, void *arg), void *arg) { rhltable_free_and_destroy(hlt, free_fn, arg); }
void rhltable_destroy__extern(struct rhltable *hlt) { rhltable_destroy(hlt); }
void sema_init__extern(struct semaphore *sem, int val) { sema_init(sem, val); }
void seqcount_init__extern(seqcount_t *s) { seqcount_init(s); }
unsigned int read_seqcount_begin__extern(const seqcount_t *s) { return read_seqcount_begin(s); }
int read_seqcount_retry__extern(const seqcount_t *s, unsigned int start) { return read_seqcount_retry(s, start); }
void write_seqcount_begin__extern(seqcount_t *s) { write_seqcount_begin(s); }
void write_seqcount_end__extern(seqcount_t *s) { write_seqcount_end(s); }
void memcpy_and_pad__extern(void *dest, size_t dest_len, const void *src, size_t count, int pad) { memcpy_and_pad(dest, dest_len, src, count, pad); }
bool uuid_equal__extern(const __uuid_t *u1, const __uuid_t *u2) { return uuid_equal(u1, u2); }
u8 unicode_major__extern(unsigned int age) { return unicode_major(age); }
u8 unicode_minor__extern(unsigned int age) { return unicode_minor(age); }
u8 unicode_rev__extern(unsigned int age) { return unicode_rev(age); }
