OpenEuler 24.03-LTS 版本KAPI规范列表

接口	函数原型	x86架构	aarch64架构
___ratelimit	int ___ratelimit(struct ratelimit_state *rs, const char *func);
__alloc_pages	struct page *__alloc_pages(gfp_t gfp, unsigned int order, int preferred_nid, nodemask_t *nodemask);
__alloc_percpu	void __percpu *__alloc_percpu(size_t size, size_t align);
__alloc_skb	struct sk_buff *__alloc_skb(unsigned int size, gfp_t priority, int flags, int node);
__auxiliary_device_add	int __auxiliary_device_add(struct auxiliary_device *auxdev, const char *modname);
__auxiliary_driver_register	int __auxiliary_driver_register(struct auxiliary_driver *auxdrv, struct module *owner, const char *modname);
__bitmap_and	bool __bitmap_and(unsigned long *dst, const unsigned long *bitmap1, const unsigned long *bitmap2, unsigned int nbits);
__bitmap_andnot	bool __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1, const unsigned long *bitmap2, unsigned int nbits);
__bitmap_clear	void __bitmap_clear(unsigned long *map, unsigned int start, int len);
__bitmap_complement	void __bitmap_complement(unsigned long *dst, const unsigned long *src, unsigned int nbits);
__bitmap_intersects	bool __bitmap_intersects(const unsigned long *bitmap1, const unsigned long *bitmap2, unsigned int nbits);
__bitmap_or	void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1, const unsigned long *bitmap2, unsigned int nbits);
__bitmap_set	void __bitmap_set(unsigned long *map, unsigned int start, int len);
__bitmap_shift_left	void __bitmap_shift_left(unsigned long *dst, const unsigned long *src, unsigned int shift, unsigned int nbits);
__bitmap_shift_right	void __bitmap_shift_right(unsigned long *dst, const unsigned long *src, unsigned int shift, unsigned int nbits);
__bitmap_subset	bool __bitmap_subset(const unsigned long *bitmap1, const unsigned long *bitmap2, unsigned int nbits);
__bitmap_weight	unsigned int __bitmap_weight(const unsigned long *bitmap, unsigned int nbits);
__bitmap_xor	void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1, const unsigned long *bitmap2, unsigned int nbits);
__check_object_size	void __check_object_size(const void *ptr, unsigned long n, bool to_user);
__const_udelay	void __const_udelay(unsigned long xloops);
__copy_overflow	void __copy_overflow(int size, unsigned long count);
__cpu_online_mask	struct cpumask __cpu_online_mask;
__cpu_possible_mask	struct cpumask __cpu_possible_mask;
__cpu_present_mask	struct cpumask __cpu_present_mask;
__default_kernel_pte_mask	pteval_t __default_kernel_pte_mask;		否
__dev_get_by_index	struct net_device *__dev_get_by_index(struct net *net, int ifindex);
__dev_get_by_name	struct net_device *__dev_get_by_name(struct net *net, const char *name);
__dev_queue_xmit	int __dev_queue_xmit(struct sk_buff *skb, struct net_device *sb_dev);
__devm_add_action	int __devm_add_action(struct device *dev, void (*action)(void *), void *data, const char *name);
__devm_mdiobus_register	int __devm_mdiobus_register(struct device *dev, struct mii_bus *bus, struct module *owner);
__drm_atomic_helper_crtc_destroy_state	void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc_state *state);
__drm_atomic_helper_crtc_duplicate_state	void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc, struct drm_crtc_state *state);
__drm_atomic_helper_plane_destroy_state	void __drm_atomic_helper_plane_destroy_state(struct drm_plane_state *state);
__drm_atomic_helper_plane_duplicate_state	void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane, struct drm_plane_state *state);
__drm_atomic_state_free	void __drm_atomic_state_free(struct kref *ref);
__drm_err	void __drm_err(const char *format, ...);
__dynamic_dev_dbg	void __dynamic_dev_dbg(struct _ddebug *descriptor, const struct device *dev, const char *fmt, ...);
__dynamic_ibdev_dbg	void __dynamic_ibdev_dbg(struct _ddebug *descriptor, const struct ib_device *ibdev, const char *fmt, ...);
__dynamic_netdev_dbg	void __dynamic_netdev_dbg(struct _ddebug *descriptor, const struct net_device *dev, const char *fmt, ...);
__dynamic_pr_debug	void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...);
__ethtool_get_link_ksettings	int __ethtool_get_link_ksettings(struct net_device *dev, struct ethtool_link_ksettings *link_ksettings);
__fdget	unsigned long __fdget(unsigned int fd);
__fib_lookup	int __fib_lookup(struct net *net, struct flowi4 *flp, struct fib_result *res, unsigned int flags);
__flush_workqueue	void __flush_workqueue(struct workqueue_struct *wq);
__folio_put	void __folio_put(struct folio *folio);
__free_pages	void __free_pages(struct page *page, unsigned int order);
__get_free_pages	unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order);
__get_random_u32_below	u32 __get_random_u32_below(u32 ceil);
__get_task_comm	char *__get_task_comm(char *to, size_t len, struct task_struct *tsk);
__hw_addr_sync_dev	int __hw_addr_sync_dev(struct netdev_hw_addr_list *list, struct net_device *dev, int (*sync)(struct net_device *, const unsigned char *), int (*unsync)(struct net_device *, const unsigned char *));
__hw_addr_unsync_dev	void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list, struct net_device *dev, int (*unsync)(struct net_device *, const unsigned char *));
__ib_alloc_cq	struct ib_cq *__ib_alloc_cq(struct ib_device *dev, void *private, int nr_cqe, int comp_vector, enum ib_poll_context poll_ctx, const char *caller);
__ib_alloc_pd	struct ib_pd *__ib_alloc_pd(struct ib_device *device, unsigned int flags, const char *caller);
__ib_create_cq	struct ib_cq *__ib_create_cq(struct ib_device *device, ib_comp_handler comp_handler, void (*event_handler)(struct ib_event *, void *), void *cq_context, const struct ib_cq_init_attr *cq_attr, const char *caller);
__icmp_send	void __icmp_send(struct sk_buff *skb_in, int type, int code, __be32 info, const struct ip_options *opt);
__inet_lookup_established	struct sock *__inet_lookup_established(struct net *net, struct inet_hashinfo *hashinfo, const __be32 saddr, const __be16 sport, const __be32 daddr, const u16 hnum, const int dif, const int sdif);
__inet6_lookup_established	struct sock *__inet6_lookup_established(struct net *net, struct inet_hashinfo *hashinfo, const struct in6_addr *saddr, const __be16 sport, const struct in6_addr *daddr, const u16 hnum, const int dif, const int sdif);
__init_rwsem	void __init_rwsem(struct rw_semaphore *sem, const char *name, struct lock_class_key *key);
__init_swait_queue_head	void __init_swait_queue_head(struct swait_queue_head *q, const char *name, struct lock_class_key *key);
__init_waitqueue_head	void __init_waitqueue_head(struct wait_queue_head *wq_head, const char *name, struct lock_class_key *);
__iowrite32_copy	void __iowrite32_copy(void __iomem *to, const void *from, size_t count);
__iowrite64_copy	void __iowrite64_copy(void __iomem *to, const void *from, size_t count);
__ip_dev_find	struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref);
__ip_mc_dec_group	void __ip_mc_dec_group(struct in_device *in_dev, __be32 addr, gfp_t gfp);
__ipv6_addr_type	int __ipv6_addr_type(const struct in6_addr *addr);
__irq_apply_affinity_hint	int __irq_apply_affinity_hint(unsigned int irq, const struct cpumask *m, bool setaffinity);
__kernel_write	ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_t *pos);
__kfifo_alloc	int __kfifo_alloc(struct __kfifo *fifo, unsigned int size, size_t esize, gfp_t gfp_mask);
__kfifo_free	void __kfifo_free(struct __kfifo *fifo);
__kfifo_in	unsigned int __kfifo_in(struct __kfifo *fifo, const void *buf, unsigned int len);
__kfifo_to_user	int __kfifo_to_user(struct __kfifo *fifo, void __user *to, unsigned long len, unsigned int *copied);
__kmalloc	void *__kmalloc(size_t size, gfp_t flags);
__kmalloc_node	void *__kmalloc_node(size_t size, gfp_t flags, int node);
__list_add_valid_or_report	bool __list_add_valid_or_report(struct list_head *new, struct list_head *prev, struct list_head *next);
__list_del_entry_valid_or_report	bool __list_del_entry_valid_or_report(struct list_head *entry);
__local_bh_enable_ip	void __local_bh_enable_ip(unsigned long ip, unsigned int cnt);
__mmap_lock_do_trace_acquire_returned	void __mmap_lock_do_trace_acquire_returned(struct mm_struct *mm, bool write, bool success);
__mmap_lock_do_trace_released	void __mmap_lock_do_trace_released(struct mm_struct *mm, bool write);
__mmap_lock_do_trace_start_locking	void __mmap_lock_do_trace_start_locking(struct mm_struct *mm, bool write);
__mmdrop	void __mmdrop(struct mm_struct *mm);
__module_get	void __module_get(struct module *module);
__msecs_to_jiffies	unsigned long __msecs_to_jiffies(const unsigned int m);
__mutex_init	void __mutex_init(struct mutex *lock, const char *name, struct lock_class_key *key);
__napi_alloc_frag_align	void *__napi_alloc_frag_align(unsigned int fragsz, unsigned int align_mask);
__napi_alloc_skb	struct sk_buff *__napi_alloc_skb(struct napi_struct *napi, unsigned int length, gfp_t gfp_mask);
__napi_schedule	void __napi_schedule(struct napi_struct *n);
__napi_schedule_irqoff	void __napi_schedule_irqoff(struct napi_struct *n);
__ndelay	void __ndelay(unsigned long nsecs);
__neigh_event_send	int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb, const bool immediate_ok);
__netdev_alloc_frag_align	void *__netdev_alloc_frag_align(unsigned int fragsz, unsigned int align_mask);
__netdev_alloc_skb	struct sk_buff *__netdev_alloc_skb(struct net_device *dev, unsigned int length, gfp_t gfp_mask);
__netif_napi_del	void __netif_napi_del(struct napi_struct *napi);
__netlink_dump_start	int __netlink_dump_start(struct sock *ssk, struct sk_buff *skb, const struct nlmsghdr *nlh, struct netlink_dump_control *control);
__netlink_kernel_create	struct sock *__netlink_kernel_create(struct net *net, int unit, struct module *module, struct netlink_kernel_cfg *cfg);
__nla_parse	int __nla_parse(struct nlattr **tb, int maxtype, const struct nlattr *head, int len, const struct nla_policy *policy, unsigned int validate, struct netlink_ext_ack *extack);
__nla_reserve	struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen);
__nla_validate	int __nla_validate(const struct nlattr *head, int len, int maxtype, const struct nla_policy *policy, unsigned int validate, struct netlink_ext_ack *extack);
__nlmsg_put	struct nlmsghdr *__nlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, int type, int len, int flags);
__num_online_cpus	atomic_t __num_online_cpus;
__page_frag_cache_drain	void __page_frag_cache_drain(struct page *page, unsigned int count);
__pci_register_driver	int __pci_register_driver(struct pci_driver *drv, struct module *owner, const char *mod_name);
__per_cpu_offset	unsigned long __per_cpu_offset[NR_CPUS];
__pm_runtime_idle	int __pm_runtime_idle(struct device *dev, int rpmflags);
__printk_ratelimit	int __printk_ratelimit(const char *func);
__pskb_pull_tail	void *__pskb_pull_tail(struct sk_buff *skb, int delta);
__put_devmap_managed_page_refs	bool __put_devmap_managed_page_refs(struct page *page, int refs);
__put_net	void __put_net(struct net *net);
__put_task_struct	void __put_task_struct(struct task_struct *t);
__rdma_block_iter_next	bool __rdma_block_iter_next(struct ib_block_iter *biter);
__rdma_block_iter_start	void __rdma_block_iter_start(struct ib_block_iter *biter, struct scatterlist *sglist, unsigned int nents, unsigned long pgsz);
__refrigerator	bool __refrigerator(bool check_kthr_stop);
__register_chrdev	int __register_chrdev(unsigned int major, unsigned int baseminor, unsigned int count, const char *name, const struct file_operations *fops);
__release_region	void __release_region(struct resource *parent, resource_size_t start, resource_size_t n);
__request_module	int __request_module(bool wait, const char *fmt, ...);
__request_region	struct resource * __request_region(struct resource *, resource_size_t start, resource_size_t n, const char *name, int flags);
__rht_bucket_nested	struct rhash_lock_head __rcu **__rht_bucket_nested(const struct bucket_table *tbl, unsigned int hash);
__scsi_iterate_devices	struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *shost, struct scsi_device *prev);
__skb_flow_dissect	bool __skb_flow_dissect(const struct net *net, const struct sk_buff *skb, struct flow_dissector *flow_dissector, void *target_container, const void *data, __be16 proto, int nhoff, int hlen, unsigned int flags);
__skb_pad	int __skb_pad(struct sk_buff *skb, int pad, bool free_on_error);
__srcu_read_lock	int __srcu_read_lock(struct srcu_struct *ssp);
__srcu_read_unlock	void __srcu_read_unlock(struct srcu_struct *ssp, int idx);
__stack_chk_fail	void __stack_chk_fail(void);
__sw_hweight32	unsigned int __sw_hweight32(unsigned int w);
__sw_hweight64	unsigned long __sw_hweight64(__u64 w);
__symbol_get	void *__symbol_get(const char *symbol);
__symbol_put	void __symbol_put(const char *symbol);
__sysfs_match_string	int __sysfs_match_string(const char * const *array, size_t n, const char *s);
__task_pid_nr_ns	pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type, struct pid_namespace *ns);
__tasklet_schedule	void __tasklet_schedule(struct tasklet_struct *t);
__trace_trigger_soft_disabled	bool __trace_trigger_soft_disabled(struct trace_event_file *file);
__tty_alloc_driver	struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner, unsigned long flags);
__tty_insert_flip_string_flags	size_t __tty_insert_flip_string_flags(struct tty_port *port, const u8 *chars, const u8 *flags, bool mutable_flags, size_t size);
__udelay	void __udelay(unsigned long usecs);
__unregister_chrdev	void __unregister_chrdev(unsigned int major, unsigned int baseminor, unsigned int count, const char *name);
__usecs_to_jiffies	unsigned long __usecs_to_jiffies(const unsigned int u);
__virt_addr_valid	bool __virt_addr_valid(unsigned long kaddr);		否
__vmalloc	void *__vmalloc(unsigned long size, gfp_t gfp_mask);
__wake_up	int __wake_up(struct wait_queue_head *wq_head, unsigned int mode, int nr, void *key);
__warn_printk	void __warn_printk(const char *fmt, ...);
__xa_alloc	int __xa_alloc(struct xarray *xa, u32 *id, void *entry, struct xa_limit limit, gfp_t gfp);
__xa_alloc_cyclic	int __xa_alloc_cyclic(struct xarray *xa, u32 *id, void *entry, struct xa_limit limit, u32 *next, gfp_t gfp);
__xa_cmpxchg	void *__xa_cmpxchg(struct xarray *xa, unsigned long index, void *old, void *entry, gfp_t gfp);
__xa_erase	void *__xa_erase(struct xarray *xa, unsigned long index);
__xa_insert	int __xa_insert(struct xarray *xa, unsigned long index, void *entry, gfp_t gfp);
__xa_store	void *__xa_store(struct xarray *xa, unsigned long index, void *entry, gfp_t gfp);
__xdp_rxq_info_reg	int __xdp_rxq_info_reg(struct xdp_rxq_info *xdp_rxq, struct net_device *dev, u32 queue_index, unsigned int napi_id, u32 frag_size);
_bin2bcd	unsigned char _bin2bcd(unsigned val);
_copy_from_user	unsigned long _copy_from_user(void *to, const void __user *from, unsigned long n);		否
_copy_to_user	unsigned long _copy_to_user(void __user *to, const void *from, unsigned long n);		否
_ctype	const unsigned char[] _ctype
_dev_err	void _dev_err(const struct device *dev, const char *fmt, ...);
_dev_info	void _dev_info(const struct device *dev, const char *fmt, ...);
_dev_notice	void _dev_notice(const struct device *dev, const char *fmt, ...);
_dev_printk	void _dev_printk(const char *level, const struct device *dev, const char *fmt, ...);
_dev_warn	void _dev_warn(const struct device *dev, const char *fmt, ...);
_find_first_bit	unsigned long _find_first_bit(const unsigned long *addr, unsigned long size);
_find_first_zero_bit	unsigned long _find_first_zero_bit(const unsigned long *addr, unsigned long size);
_find_last_bit	unsigned long _find_last_bit(const unsigned long *addr, unsigned long size);
_find_next_and_bit	unsigned long _find_next_and_bit(const unsigned long *addr1, const unsigned long *addr2, unsigned long nbits, unsigned long start);
_find_next_andnot_bit	unsigned long _find_next_andnot_bit(const unsigned long *addr1, const unsigned long *addr2, unsigned long nbits, unsigned long start);
_find_next_bit	unsigned long _find_next_bit(const unsigned long *addr1, unsigned long nbits, unsigned long start);
_find_next_zero_bit	unsigned long _find_next_zero_bit(const unsigned long *addr, unsigned long nbits, unsigned long start);
_ib_alloc_device	struct ib_device *_ib_alloc_device(size_t size);
_printk	int _printk(const char *fmt, ...);
_uverbs_alloc	void *_uverbs_alloc(struct uverbs_attr_bundle *bundle, size_t size, gfp_t flags);
_uverbs_get_const_signed	int _uverbs_get_const_signed(s64 *to, const struct uverbs_attr_bundle *attrs_bundle, size_t idx, s64 lower_bound, u64 upper_bound, s64 *def_val);
_uverbs_get_const_unsigned	int _uverbs_get_const_unsigned(u64 *to, const struct uverbs_attr_bundle *attrs_bundle, size_t idx, u64 upper_bound, u64 *def_val);
acpi_evaluate_integer	acpi_status acpi_evaluate_integer(acpi_handle handle, acpi_string pathname, struct acpi_object_list *arguments, unsigned long long *data);
acpi_evaluate_object	acpi_status acpi_evaluate_object(acpi_handle handle, acpi_string pathname, struct acpi_object_list *external_params, struct acpi_buffer *return_buffer);
acpi_gbl_FADT	ACPI_GLOBAL(struct acpi_table_fadt, acpi_gbl_FADT);
acpi_get_handle	acpi_status acpi_get_handle(acpi_handle parent, const char *pathname, acpi_handle * ret_handle);
acpi_get_next_object	acpi_status acpi_get_next_object(acpi_object_type type, acpi_handle parent, acpi_handle child, acpi_handle * ret_handle);
acpi_install_notify_handler	acpi_status acpi_install_notify_handler(acpi_handle device, u32 handler_type, acpi_notify_handler handler, void *context);
acpi_remove_notify_handler	acpi_status acpi_remove_notify_handler(acpi_handle device, u32 handler_type, acpi_notify_handler handler);
acpi_walk_namespace	acpi_status acpi_walk_namespace(acpi_object_type type, acpi_handle start_object, u32 max_depth, acpi_walk_callback descending_callback, acpi_walk_callback ascending_callback, void *context, void **return_value);
add_timer	void add_timer(struct timer_list *timer);
add_uevent_var	int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...);
address_space_init_once	void address_space_init_once(struct address_space *mapping);
alloc_chrdev_region	int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name);
alloc_cpu_rmap	struct cpu_rmap *alloc_cpu_rmap(unsigned int size, gfp_t flags);
alloc_cpumask_var_node	bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node);		否
alloc_etherdev_mqs	struct net_device *alloc_etherdev_mqs(int sizeof_priv, unsigned int txqs, unsigned int rxqs);
alloc_iova	struct iova *alloc_iova(struct iova_domain *iovad, unsigned long size, unsigned long limit_pfn, bool size_aligned);
alloc_iova_fast	unsigned long alloc_iova_fast(struct iova_domain *iovad, unsigned long size, unsigned long limit_pfn, bool flush_rcache);
alloc_netdev_mqs	struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name, unsigned char name_assign_type, void (*setup)(struct net_device *), unsigned int txqs, unsigned int rxqs);
alloc_pages	struct page *alloc_pages(gfp_t gfp_mask, unsigned int order);
alloc_workqueue	struct workqueue_struct *alloc_workqueue(const char *fmt, unsigned int flags, int max_active, ...);
anon_inode_getfile	struct file *anon_inode_getfile(const char *name, const struct file_operations *fops, void *priv, int flags);
argv_free	void argv_free(char **argv);
argv_split	char **argv_split(gfp_t gfp, const char *str, int *argcp);
arp_tbl	struct neigh_table arp_tbl;
atomic_notifier_call_chain	int atomic_notifier_call_chain(struct atomic_notifier_head *nh, unsigned long val, void *v);
atomic_notifier_chain_register	int atomic_notifier_chain_register(struct atomic_notifier_head *nh, struct notifier_block *nb);
atomic_notifier_chain_unregister	int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh, struct notifier_block *nb);
auxiliary_device_init	int auxiliary_device_init(struct auxiliary_device *auxdev);
auxiliary_driver_unregister	void auxiliary_driver_unregister(struct auxiliary_driver *auxdrv);
backlight_device_register	struct backlight_device *backlight_device_register(const char *name, struct device *dev, void *devdata, const struct backlight_ops *ops, const struct backlight_properties *props);
backlight_device_unregister	void backlight_device_unregister(struct backlight_device *bd);
bin2hex	char *bin2hex(char *dst, const void *src, size_t count);
bit_wait	int bit_wait(struct wait_bit_key *key, int mode);
bitmap_find_free_region	int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order);
bitmap_find_next_zero_area_off	unsigned long bitmap_find_next_zero_area_off(unsigned long *map, unsigned long size, unsigned long start, unsigned int nr, unsigned long align_mask, unsigned long align_offset);
bitmap_free	void bitmap_free(const unsigned long *bitmap);
bitmap_from_arr32	void bitmap_from_arr32(unsigned long *bitmap, const u32 *buf, unsigned int nbits);
bitmap_zalloc	unsigned long *bitmap_zalloc(unsigned int nbits, gfp_t flags);
bitmap_zalloc_node	unsigned long *bitmap_zalloc_node(unsigned int nbits, gfp_t flags, int node);
blk_mq_map_queues	void blk_mq_map_queues(struct blk_mq_queue_map *qmap);
blk_mq_pci_map_queues	void blk_mq_pci_map_queues(struct blk_mq_queue_map *qmap, struct pci_dev *pdev, int offset);
blk_mq_tagset_busy_iter	void blk_mq_tagset_busy_iter(struct blk_mq_tag_set *tagset, busy_tag_iter_fn *fn, void *priv);
blk_mq_unique_tag	u32 blk_mq_unique_tag(struct request *rq);
blk_queue_max_hw_sectors	void blk_queue_max_hw_sectors(struct request_queue *q, unsigned int max_hw_sectors);
blk_queue_max_segments	void blk_queue_max_segments(struct request_queue *q, unsigned short max_segments);
blk_queue_rq_timeout	void blk_queue_rq_timeout(struct request_queue *q, unsigned int timeout);
blk_queue_virt_boundary	void blk_queue_virt_boundary(struct request_queue *q, unsigned long mask);
blocking_notifier_call_chain	int blocking_notifier_call_chain(struct blocking_notifier_head *nh, unsigned long val, void *v);
blocking_notifier_chain_register	int blocking_notifier_chain_register(struct blocking_notifier_head *nh, struct notifier_block *nb);
blocking_notifier_chain_unregister	int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh, struct notifier_block *nb);
bpf_master_redirect_enabled_key	DEFINE_STATIC_KEY_FALSE(bpf_master_redirect_enabled_key);
bpf_prog_add	void bpf_prog_add(struct bpf_prog *prog, int i);
bpf_prog_inc	void bpf_prog_inc(struct bpf_prog *prog);
bpf_prog_put	void bpf_prog_put(struct bpf_prog *prog);
bpf_stats_enabled_key	DEFINE_STATIC_KEY_FALSE(bpf_stats_enabled_key);
bpf_trace_run1	void bpf_trace_run1(struct bpf_prog *prog, u64 arg1);
bpf_trace_run2	void bpf_trace_run2(struct bpf_prog *prog, u64 arg1, u64 arg2);
bpf_trace_run3	void bpf_trace_run3(struct bpf_prog *prog, u64 arg1, u64 arg2, u64 arg3);
bpf_trace_run4	void bpf_trace_run4(struct bpf_prog *prog, u64 arg1, u64 arg2, u64 arg3, u64 arg4);
bpf_trace_run5	void bpf_trace_run5(struct bpf_prog *prog, u64 arg1, u64 arg2, u64 arg3, u64 arg4, u64 arg5);
bpf_trace_run7	void bpf_trace_run7(struct bpf_prog *prog, u64 arg1, u64 arg2, u64 arg3, u64 arg4, u64 arg5, u64 arg6, u64 arg7);
bpf_warn_invalid_xdp_action	void bpf_warn_invalid_xdp_action(struct net_device *dev, struct bpf_prog *prog, u32 act);
bsg_job_done	void bsg_job_done(struct bsg_job *job, int result, unsigned int reply_payload_rcv_len);
bsg_remove_queue	void bsg_remove_queue(struct request_queue *q);
bsg_setup_queue	struct request_queue *bsg_setup_queue(struct device *dev, const char *name, bsg_job_fn *job_fn, bsg_timeout_fn *timeout, int dd_job_size);
build_skb	struct sk_buff *build_skb(void *data, unsigned int frag_size);
bus_find_device	struct device *bus_find_device(const struct bus_type *bus, struct device *start, const void *data, int (*match)(struct device *dev, const void *data));
cachemode2protval	unsigned long cachemode2protval(enum page_cache_mode pcm);		否
call_netdevice_notifiers	int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
call_rcu	void call_rcu(struct rcu_head *head, rcu_callback_t func);
call_srcu	void call_srcu(struct srcu_struct *ssp, struct rcu_head *head, void (*func)(struct rcu_head *head));
call_switchdev_notifiers	int call_switchdev_notifiers(unsigned long val, struct net_device *dev, struct switchdev_notifier_info *info, struct netlink_ext_ack *extack);
call_usermodehelper	int call_usermodehelper(const char *path, char **argv, char **envp, int wait);
can_do_mlock	bool can_do_mlock(void);
cancel_delayed_work	bool cancel_delayed_work(struct delayed_work *dwork);
cancel_delayed_work_sync	bool cancel_delayed_work_sync(struct delayed_work *dwork);
cancel_work	bool cancel_work(struct work_struct *work);
cancel_work_sync	bool cancel_work_sync(struct work_struct *work);
capable	bool capable(int cap);
cc_mkdec	u64 cc_mkdec(u64 val);		否
cdev_add	int cdev_add(struct cdev *p, dev_t dev, unsigned count);
cdev_alloc	struct cdev *cdev_alloc(void);
cdev_del	void cdev_del(struct cdev *p);
cdev_device_add	int cdev_device_add(struct cdev *cdev, struct device *dev);
cdev_device_del	void cdev_device_del(struct cdev *cdev, struct device *dev);
cdev_init	void cdev_init(struct cdev *cdev, const struct file_operations *fops);
cgroup_path_ns	int cgroup_path_ns(struct cgroup *cgrp, char *buf, size_t buflen, struct cgroup_namespace *ns);
class_create	struct class *class_create(const char *name);
class_create_file_ns	int class_create_file_ns(const struct class *cls, const struct class_attribute *attr, const void *ns);
class_destroy	void class_destroy(const struct class *cls);
class_register	int class_register(const struct class *cls);
class_unregister	void class_unregister(const struct class *class);
cleanup_srcu_struct	void cleanup_srcu_struct(struct srcu_struct *ssp);
clock_t_to_jiffies	unsigned long clock_t_to_jiffies(unsigned long x);
compat_ptr_ioctl	long compat_ptr_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
complete	void complete(struct completion *x);
complete_all	void complete_all(struct completion *x);
config_group_init	void config_group_init(struct config_group *group);
config_group_init_type_name	void config_group_init_type_name(struct config_group *group, const char *name, const struct config_item_type *type);
config_item_put	void config_item_put(struct config_item *item);
configfs_register_subsystem	int configfs_register_subsystem(struct configfs_subsystem *subsys);
configfs_remove_default_groups	void configfs_remove_default_groups(struct config_group *group);
configfs_unregister_subsystem	void configfs_unregister_subsystem(struct configfs_subsystem *subsys);
console_lock	void console_lock(void);
console_unlock	void console_unlock(void);
consume_skb	void consume_skb(struct sk_buff *skb);
convert_art_ns_to_tsc	struct system_counterval_t convert_art_ns_to_tsc(u64 art_ns);		否
cpu_bit_bitmap	const unsigned long cpu_bit_bitmap[BITS_PER_LONG+1][BITS_TO_LONGS(NR_CPUS)]
cpufreq_get	unsigned int cpufreq_get(unsigned int cpu);
cpumask_local_spread	unsigned int cpumask_local_spread(unsigned int i, int node);
crc32_le	u32 crc32_le(u32 crc, unsigned char const *p, size_t len);
csum_ipv6_magic	__sum16 csum_ipv6_magic(const struct in6_addr *saddr, const struct in6_addr *daddr, __u32 len, __u8 proto, __wsum sum);
csum_partial	__wsum csum_partial(const void *buff, int len, __wsum sum);
current_work	struct work_struct *current_work(void);
dcb_getapp	u8 dcb_getapp(struct net_device *dev, struct dcb_app *app);
dcb_ieee_delapp	int dcb_ieee_delapp(struct net_device *dev, struct dcb_app *del);
dcb_ieee_getapp_mask	u8 dcb_ieee_getapp_mask(struct net_device *dev, struct dcb_app *app);
dcb_ieee_getapp_prio_dscp_mask_map	void dcb_ieee_getapp_prio_dscp_mask_map(const struct net_device *dev, struct dcb_ieee_app_prio_map *p_map);
dcb_ieee_setapp	int dcb_ieee_setapp(struct net_device *dev, struct dcb_app *new);
debugfs_attr_read	ssize_t debugfs_attr_read(struct file *file, char __user *buf, size_t len, loff_t *ppos);
debugfs_attr_write	ssize_t debugfs_attr_write(struct file *file, const char __user *buf, size_t len, loff_t *ppos);
debugfs_create_atomic_t	void debugfs_create_atomic_t(const char *name, umode_t mode, struct dentry *parent, atomic_t *value);
debugfs_create_blob	struct dentry *debugfs_create_blob(const char *name, umode_t mode, struct dentry *parent, struct debugfs_blob_wrapper *blob);
debugfs_create_devm_seqfile	void debugfs_create_devm_seqfile(struct device *dev, const char *name, struct dentry *parent, int (*read_fn)(struct seq_file *s, void *data));
debugfs_create_dir	struct dentry *debugfs_create_dir(const char *name, struct dentry *parent);
debugfs_create_file	struct dentry *debugfs_create_file(const char *name, umode_t mode, struct dentry *parent, void *data, const struct file_operations *fops);
debugfs_create_file_unsafe	struct dentry *debugfs_create_file_unsafe(const char *name, umode_t mode, struct dentry *parent, void *data, const struct file_operations *fops);
debugfs_create_size_t	void debugfs_create_size_t(const char *name, umode_t mode, struct dentry *parent, size_t *value);
debugfs_create_u32	void debugfs_create_u32(const char *name, umode_t mode, struct dentry *parent, u32 *value);
debugfs_create_u64	void debugfs_create_u64(const char *name, umode_t mode, struct dentry *parent, u64 *value);
debugfs_create_u8	void debugfs_create_u8(const char *name, umode_t mode, struct dentry *parent, u8 *value);
debugfs_create_x32	void debugfs_create_x32(const char *name, umode_t mode, struct dentry *parent, u32 *value);
debugfs_lookup	struct dentry *debugfs_lookup(const char *name, struct dentry *parent);
debugfs_lookup_and_remove	void debugfs_lookup_and_remove(const char *name, struct dentry *parent);
debugfs_remove	void debugfs_remove(struct dentry *dentry);
default_llseek	loff_t default_llseek(struct file *file, loff_t offset, int whence);
delayed_work_timer_fn	void delayed_work_timer_fn(struct timer_list *t);
destroy_workqueue	void destroy_workqueue(struct workqueue_struct *wq);
dev_add_pack	void dev_add_pack(struct packet_type *pt);
dev_addr_mod	void dev_addr_mod(struct net_device *dev, unsigned int offset, const void *addr, size_t len);
dev_change_flags	int dev_change_flags(struct net_device *dev, unsigned int flags, struct netlink_ext_ack *extack);
dev_close	void dev_close(struct net_device *dev);
dev_driver_string	const char *dev_driver_string(const struct device *dev);
dev_get_by_index	struct net_device *dev_get_by_index(struct net *net, int ifindex);
dev_get_by_index_rcu	struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
dev_get_by_name	struct net_device *dev_get_by_name(struct net *net, const char *name);
dev_get_iflink	int dev_get_iflink(const struct net_device *dev);
dev_kfree_skb_any_reason	void dev_kfree_skb_any_reason(struct sk_buff *skb, enum skb_drop_reason reason);
dev_kfree_skb_irq_reason	void dev_kfree_skb_irq_reason(struct sk_buff *skb, enum skb_drop_reason reason);
dev_mc_add_excl	int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr);
dev_mc_del	int dev_mc_del(struct net_device *dev, const unsigned char *addr);
dev_open	int dev_open(struct net_device *dev, struct netlink_ext_ack *extack);
dev_printk_emit	int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
dev_remove_pack	void dev_remove_pack(struct packet_type *pt);
dev_set_mtu	int dev_set_mtu(struct net_device *dev, int new_mtu);
dev_set_name	int dev_set_name(struct device *dev, const char *name, ...);
dev_trans_start	unsigned long dev_trans_start(struct net_device *dev);
dev_uc_add	int dev_uc_add(struct net_device *dev, const unsigned char *addr);
dev_uc_add_excl	int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr);
dev_uc_del	int dev_uc_del(struct net_device *dev, const unsigned char *addr);
device_add	int device_add(struct device *dev);
device_attach	int device_attach(struct device *dev);
device_create	struct device *device_create(const struct class *class, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...);
device_create_file	int device_create_file(struct device *device, const struct device_attribute *entry);
device_del	void device_del(struct device *dev);
device_destroy	void device_destroy(const struct class *cls, dev_t devt);
device_for_each_child	int device_for_each_child(struct device *dev, void *data, int (*fn)(struct device *, void *));
device_initialize	void device_initialize(struct device *dev);
device_release_driver	void device_release_driver(struct device *dev);
device_remove_file	void device_remove_file(struct device *dev, const struct device_attribute *attr);
device_rename	int device_rename(struct device *dev, const char *new_name);
device_set_wakeup_capable	void device_set_wakeup_capable(struct device *dev, bool capable);
device_set_wakeup_enable	int device_set_wakeup_enable(struct device *dev, bool enable);
devl_assert_locked	void devl_assert_locked(struct devlink *devlink);
devl_health_reporter_create	struct devlink_health_reporter *devl_health_reporter_create(struct devlink *devlink, const struct devlink_health_reporter_ops *ops, u64 graceful_period, void *priv);
devl_health_reporter_destroy	void devl_health_reporter_destroy(struct devlink_health_reporter *reporter);
devl_lock	void devl_lock(struct devlink *devlink);
devl_param_driverinit_value_get	int devl_param_driverinit_value_get(struct devlink *devlink, u32 param_id, union devlink_param_value *val);
devl_param_driverinit_value_set	void devl_param_driverinit_value_set(struct devlink *devlink, u32 param_id, union devlink_param_value init_val);
devl_params_register	int devl_params_register(struct devlink *devlink, const struct devlink_param *params, size_t params_count);
devl_params_unregister	void devl_params_unregister(struct devlink *devlink, const struct devlink_param *params, size_t params_count);
devl_port_health_reporter_create	struct devlink_health_reporter *devl_port_health_reporter_create(struct devlink_port *port, const struct devlink_health_reporter_ops *ops, u64 graceful_period, void *priv);
devl_port_register_with_ops	int devl_port_register_with_ops(struct devlink *devlink, struct devlink_port *devlink_port, unsigned int port_index, const struct devlink_port_ops *ops);
devl_port_unregister	void devl_port_unregister(struct devlink_port *devlink_port);
devl_rate_leaf_create	int devl_rate_leaf_create(struct devlink_port *devlink_port, void *priv, struct devlink_rate *parent);
devl_rate_leaf_destroy	void devl_rate_leaf_destroy(struct devlink_port *devlink_port);
devl_rate_node_create	struct devlink_rate *devl_rate_node_create(struct devlink *devlink, void *priv, char *node_name, struct devlink_rate *parent);
devl_rate_nodes_destroy	void devl_rate_nodes_destroy(struct devlink *devlink);
devl_register	int devl_register(struct devlink *devlink);
devl_resource_register	int devl_resource_register(struct devlink *devlink, const char *resource_name, u64 resource_size, u64 resource_id, u64 parent_resource_id, const struct devlink_resource_size_params *size_params);
devl_resource_size_get	int devl_resource_size_get(struct devlink *devlink, u64 resource_id, u64 *p_resource_size);
devl_resources_unregister	void devl_resources_unregister(struct devlink *devlink);
devl_trap_groups_register	int devl_trap_groups_register(struct devlink *devlink, const struct devlink_trap_group *groups, size_t groups_count);
devl_trap_groups_unregister	void devl_trap_groups_unregister(struct devlink *devlink, const struct devlink_trap_group *groups, size_t groups_count);
devl_traps_register	int devl_traps_register(struct devlink *devlink, const struct devlink_trap *traps, size_t traps_count, void *priv);
devl_traps_unregister	void devl_traps_unregister(struct devlink *devlink, const struct devlink_trap *traps, size_t traps_count);
devl_unlock	void devl_unlock(struct devlink *devlink);
devl_unregister	void devl_unregister(struct devlink *devlink);
devlink_alloc_ns	struct devlink *devlink_alloc_ns(const struct devlink_ops *ops, size_t priv_size, struct net *net, struct device *dev);
devlink_flash_update_status_notify	void devlink_flash_update_status_notify(struct devlink *devlink, const char *status_msg, const char *component, unsigned long done, unsigned long total);
devlink_flash_update_timeout_notify	void devlink_flash_update_timeout_notify(struct devlink *devlink, const char *status_msg, const char *component, unsigned long timeout);
devlink_fmsg_arr_pair_nest_end	int devlink_fmsg_arr_pair_nest_end(struct devlink_fmsg *fmsg);
devlink_fmsg_arr_pair_nest_start	int devlink_fmsg_arr_pair_nest_start(struct devlink_fmsg *fmsg, const char *name);
devlink_fmsg_binary_pair_nest_end	int devlink_fmsg_binary_pair_nest_end(struct devlink_fmsg *fmsg);
devlink_fmsg_binary_pair_nest_start	int devlink_fmsg_binary_pair_nest_start(struct devlink_fmsg *fmsg, const char *name);
devlink_fmsg_binary_pair_put	int devlink_fmsg_binary_pair_put(struct devlink_fmsg *fmsg, const char *name, const void *value, u32 value_len);
devlink_fmsg_binary_put	int devlink_fmsg_binary_put(struct devlink_fmsg *fmsg, const void *value, u16 value_len);
devlink_fmsg_bool_pair_put	int devlink_fmsg_bool_pair_put(struct devlink_fmsg *fmsg, const char *name, bool value);
devlink_fmsg_obj_nest_end	int devlink_fmsg_obj_nest_end(struct devlink_fmsg *fmsg);
devlink_fmsg_obj_nest_start	int devlink_fmsg_obj_nest_start(struct devlink_fmsg *fmsg);
devlink_fmsg_pair_nest_end	int devlink_fmsg_pair_nest_end(struct devlink_fmsg *fmsg);
devlink_fmsg_pair_nest_start	int devlink_fmsg_pair_nest_start(struct devlink_fmsg *fmsg, const char *name);
devlink_fmsg_string_pair_put	int devlink_fmsg_string_pair_put(struct devlink_fmsg *fmsg, const char *name, const char *value);
devlink_fmsg_u32_pair_put	int devlink_fmsg_u32_pair_put(struct devlink_fmsg *fmsg, const char *name, u32 value);
devlink_fmsg_u32_put	int devlink_fmsg_u32_put(struct devlink_fmsg *fmsg, u32 value);
devlink_fmsg_u64_pair_put	int devlink_fmsg_u64_pair_put(struct devlink_fmsg *fmsg, const char *name, u64 value);
devlink_fmsg_u8_pair_put	int devlink_fmsg_u8_pair_put(struct devlink_fmsg *fmsg, const char *name, u8 value);
devlink_free	void devlink_free(struct devlink *devlink);
devlink_health_report	int devlink_health_report(struct devlink_health_reporter *reporter, const char *msg, void *priv_ctx);
devlink_health_reporter_create	struct devlink_health_reporter *devlink_health_reporter_create(struct devlink *devlink, const struct devlink_health_reporter_ops *ops, u64 graceful_period, void *priv);
devlink_health_reporter_destroy	void devlink_health_reporter_destroy(struct devlink_health_reporter *reporter);
devlink_health_reporter_priv	void *devlink_health_reporter_priv(struct devlink_health_reporter *reporter);
devlink_health_reporter_recovery_done	void devlink_health_reporter_recovery_done(struct devlink_health_reporter *reporter);
devlink_health_reporter_state_update	void devlink_health_reporter_state_update(struct devlink_health_reporter *reporter, enum devlink_health_reporter_state state);
devlink_info_board_serial_number_put	int devlink_info_board_serial_number_put(struct devlink_info_req *req, const char *bsn);
devlink_info_serial_number_put	int devlink_info_serial_number_put(struct devlink_info_req *req, const char *sn);
devlink_info_version_fixed_put	int devlink_info_version_fixed_put(struct devlink_info_req *req, const char *version_name, const char *version_value);
devlink_info_version_running_put	int devlink_info_version_running_put(struct devlink_info_req *req, const char *version_name, const char *version_value);
devlink_info_version_stored_put	int devlink_info_version_stored_put(struct devlink_info_req *req, const char *version_name, const char *version_value);
devlink_net	struct net *devlink_net(const struct devlink *devlink);
devlink_params_register	int devlink_params_register(struct devlink *devlink, const struct devlink_param *params, size_t params_count);
devlink_params_unregister	void devlink_params_unregister(struct devlink *devlink, const struct devlink_param *params, size_t params_count);
devlink_port_attrs_pci_pf_set	void devlink_port_attrs_pci_pf_set(struct devlink_port *devlink_port, u32 controller, u16 pf, bool external);
devlink_port_attrs_pci_sf_set	void devlink_port_attrs_pci_sf_set(struct devlink_port *devlink_port, u32 controller, u16 pf, u32 sf, bool external);
devlink_port_attrs_pci_vf_set	void devlink_port_attrs_pci_vf_set(struct devlink_port *devlink_port, u32 controller, u16 pf, u16 vf, bool external);
devlink_port_attrs_set	void devlink_port_attrs_set(struct devlink_port *devlink_port, struct devlink_port_attrs *devlink_port_attrs);
devlink_port_health_reporter_create	struct devlink_health_reporter *devlink_port_health_reporter_create(struct devlink_port *port, const struct devlink_health_reporter_ops *ops, u64 graceful_period, void *priv);
devlink_port_register_with_ops	int devlink_port_register_with_ops(struct devlink *devlink, struct devlink_port *devlink_port, unsigned int port_index, const struct devlink_port_ops *ops);
devlink_port_type_clear	void devlink_port_type_clear(struct devlink_port *devlink_port);
devlink_port_unregister	void devlink_port_unregister(struct devlink_port *devlink_port);
devlink_priv	void *devlink_priv(struct devlink *devlink);
devlink_region_create	struct devlink_region *devlink_region_create(struct devlink *devlink, const struct devlink_region_ops *ops, u32 region_max_snapshots, u64 region_size);
devlink_region_destroy	void devlink_region_destroy(struct devlink_region *region);
devlink_register	void devlink_register(struct devlink *devlink);
devlink_remote_reload_actions_performed	void devlink_remote_reload_actions_performed(struct devlink *devlink, enum devlink_reload_limit limit, u32 actions_performed);
devlink_resource_occ_get_register	void devlink_resource_occ_get_register(struct devlink *devlink, u64 resource_id, devlink_resource_occ_get_t *occ_get, void *occ_get_priv);
devlink_resource_occ_get_unregister	void devlink_resource_occ_get_unregister(struct devlink *devlink, u64 resource_id);
devlink_resource_register	int devlink_resource_register(struct devlink *devlink, const char *resource_name, u64 resource_size, u64 resource_id, u64 parent_resource_id, const struct devlink_resource_size_params *size_params);
devlink_resources_unregister	void devlink_resources_unregister(struct devlink *devlink);
devlink_to_dev	struct device *devlink_to_dev(const struct devlink *devlink);
devlink_trap_report	void devlink_trap_report(struct devlink *devlink, struct sk_buff *skb, void *trap_ctx, struct devlink_port *in_devlink_port, const struct flow_action_cookie *fa_cookie);
devlink_unregister	void devlink_unregister(struct devlink *devlink);
devm_alloc_etherdev_mqs	struct net_device *devm_alloc_etherdev_mqs(struct device *dev, int sizeof_priv, unsigned int txqs, unsigned int rxqs);
devm_free_irq	void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id);
devm_iounmap	void devm_iounmap(struct device *dev, void __iomem *addr);
devm_kasprintf	char *devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...);
devm_kfree	void devm_kfree(struct device *dev, const void *p);
devm_kmalloc	void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp);
devm_kmemdup	void *devm_kmemdup(struct device *dev, const void *src, size_t len, gfp_t gfp);
devm_request_threaded_irq	int devm_request_threaded_irq(struct device *dev, unsigned int irq, irq_handler_t handler, irq_handler_t thread_fn, unsigned long irqflags, const char *devname, void *dev_id);
devmap_managed_key	DEFINE_STATIC_KEY_FALSE(devmap_managed_key);
disable_irq	void disable_irq(unsigned int irq);
disable_irq_nosync	void disable_irq_nosync(unsigned int irq);
dma_alloc_attrs	void *dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle, gfp_t flag, unsigned long attrs);
dma_buf_detach	void dma_buf_detach(struct dma_buf *dmabuf, struct dma_buf_attachment *attach);
dma_buf_dynamic_attach	struct dma_buf_attachment *dma_buf_dynamic_attach(struct dma_buf *dmabuf, struct device *dev, const struct dma_buf_attach_ops *importer_ops, void *importer_priv);
dma_buf_get	struct dma_buf *dma_buf_get(int fd);
dma_buf_map_attachment	struct sg_table *dma_buf_map_attachment(struct dma_buf_attachment *attach, enum dma_data_direction direction);
dma_buf_pin	int dma_buf_pin(struct dma_buf_attachment *attach);
dma_buf_put	void dma_buf_put(struct dma_buf *dmabuf);
dma_buf_unmap_attachment	void dma_buf_unmap_attachment(struct dma_buf_attachment *attach, struct sg_table *sg_table, enum dma_data_direction direction);
dma_buf_unpin	void dma_buf_unpin(struct dma_buf_attachment *attach);
dma_fence_context_alloc	u64 dma_fence_context_alloc(unsigned num);
dma_fence_default_wait	signed long dma_fence_default_wait(struct dma_fence *fence, bool intr, signed long timeout);
dma_fence_init	void dma_fence_init(struct dma_fence *fence, const struct dma_fence_ops *ops, spinlock_t *lock, u64 context, u64 seqno);
dma_fence_release	void dma_fence_release(struct kref *kref);
dma_fence_signal	int dma_fence_signal(struct dma_fence *fence);
dma_free_attrs	void dma_free_attrs(struct device *dev, size_t size, void *cpu_addr, dma_addr_t dma_handle, unsigned long attrs);
dma_map_page_attrs	dma_addr_t dma_map_page_attrs(struct device *dev, struct page *page, size_t offset, size_t size, enum dma_data_direction dir, unsigned long attrs);
dma_map_resource	dma_addr_t dma_map_resource(struct device *dev, phys_addr_t phys_addr, size_t size, enum dma_data_direction dir, unsigned long attrs);
dma_map_sg_attrs	unsigned int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction dir, unsigned long attrs);
dma_map_sgtable	int dma_map_sgtable(struct device *dev, struct sg_table *sgt, enum dma_data_direction dir, unsigned long attrs);
dma_ops	const struct dma_map_ops *dma_ops		否
dma_pool_alloc	void *dma_pool_alloc(struct dma_pool *pool, gfp_t mem_flags, dma_addr_t *handle);
dma_pool_create	struct dma_pool *dma_pool_create(const char *name, struct device *dev, size_t size, size_t align, size_t allocation);
dma_pool_destroy	void dma_pool_destroy(struct dma_pool *pool);
dma_pool_free	void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t addr);
dma_resv_wait_timeout	long dma_resv_wait_timeout(struct dma_resv *obj, enum dma_resv_usage usage, bool intr, unsigned long timeout);
dma_set_coherent_mask	int dma_set_coherent_mask(struct device *dev, u64 mask);
dma_set_mask	int dma_set_mask(struct device *dev, u64 mask);
dma_sync_single_for_cpu	void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr, size_t size, enum dma_data_direction dir);
dma_sync_single_for_device	void dma_sync_single_for_device(struct device *dev, dma_addr_t addr, size_t size, enum dma_data_direction dir);
dma_unmap_page_attrs	void dma_unmap_page_attrs(struct device *dev, dma_addr_t addr, size_t size, enum dma_data_direction dir, unsigned long attrs);
dma_unmap_resource	void dma_unmap_resource(struct device *dev, dma_addr_t addr, size_t size, enum dma_data_direction dir, unsigned long attrs);
dma_unmap_sg_attrs	void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg, int nents, enum dma_data_direction dir, unsigned long attrs);
dmam_alloc_attrs	void *dmam_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs);
dmam_free_coherent	void dmam_free_coherent(struct device *dev, size_t size, void *vaddr, dma_addr_t dma_handle);
dmi_find_device	const struct dmi_device *dmi_find_device(int type, const char *name, const struct dmi_device *from);
dmi_get_system_info	const char *dmi_get_system_info(int field);
dmi_match	bool dmi_match(enum dmi_field f, const char *str);
do_trace_netlink_extack	void do_trace_netlink_extack(const char *msg);
do_trace_read_msr	void do_trace_read_msr(unsigned int msr, u64 val, int failed);		否
down	void down(struct semaphore *sem);
down_interruptible	int down_interruptible(struct semaphore *sem);
down_read	void down_read(struct rw_semaphore *sem);
down_read_trylock	int down_read_trylock(struct rw_semaphore *sem);
down_timeout	int down_timeout(struct semaphore *sem, long timeout);
down_trylock	int down_trylock(struct semaphore *sem);
down_write	void down_write(struct rw_semaphore *sem);
down_write_trylock	int down_write_trylock(struct rw_semaphore *sem);
downgrade_write	void downgrade_write(struct rw_semaphore *sem);
dql_completed	void dql_completed(struct dql *dql, unsigned int count);
dql_reset	void dql_reset(struct dql *dql);
driver_create_file	int driver_create_file(struct device_driver *drv, const struct driver_attribute *attr);
driver_remove_file	void driver_remove_file(struct device_driver *driver, const struct driver_attribute *attr);
drm_atomic_add_affected_connectors	int drm_atomic_add_affected_connectors(struct drm_atomic_state *state, struct drm_crtc *crtc);
drm_atomic_add_affected_planes	int drm_atomic_add_affected_planes(struct drm_atomic_state *state, struct drm_crtc *crtc);
drm_atomic_commit	int drm_atomic_commit(struct drm_atomic_state *state);
drm_atomic_get_crtc_state	struct drm_crtc_state *drm_atomic_get_crtc_state(struct drm_atomic_state *state, struct drm_crtc *crtc);
drm_atomic_get_plane_state	struct drm_plane_state *drm_atomic_get_plane_state(struct drm_atomic_state *state, struct drm_plane *plane);
drm_atomic_helper_check	int drm_atomic_helper_check(struct drm_device *dev, struct drm_atomic_state *state);
drm_atomic_helper_connector_destroy_state	void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector, struct drm_connector_state *state);
drm_atomic_helper_connector_duplicate_state	struct drm_connector_state *drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector);
drm_atomic_helper_connector_reset	void drm_atomic_helper_connector_reset(struct drm_connector *connector);
drm_atomic_helper_crtc_reset	void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc);
drm_atomic_helper_disable_plane	int drm_atomic_helper_disable_plane(struct drm_plane *plane, struct drm_modeset_acquire_ctx *ctx);
drm_atomic_helper_page_flip	int drm_atomic_helper_page_flip(struct drm_crtc *crtc, struct drm_framebuffer *fb, struct drm_pending_vblank_event *event, uint32_t flags, struct drm_modeset_acquire_ctx *ctx);
drm_atomic_helper_plane_reset	void drm_atomic_helper_plane_reset(struct drm_plane *plane);
drm_atomic_helper_set_config	int drm_atomic_helper_set_config(struct drm_mode_set *set, struct drm_modeset_acquire_ctx *ctx);
drm_atomic_helper_swap_state	int drm_atomic_helper_swap_state(struct drm_atomic_state *state, bool stall);
drm_atomic_helper_update_plane	int drm_atomic_helper_update_plane(struct drm_plane *plane, struct drm_crtc *crtc, struct drm_framebuffer *fb, int crtc_x, int crtc_y, unsigned int crtc_w, unsigned int crtc_h, uint32_t src_x, uint32_t src_y, uint32_t src_w, uint32_t src_h, struct drm_modeset_acquire_ctx *ctx);
drm_atomic_set_crtc_for_connector	int drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state, struct drm_crtc *crtc);
drm_atomic_set_crtc_for_plane	int drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state, struct drm_crtc *crtc);
drm_atomic_set_fb_for_plane	void drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state, struct drm_framebuffer *fb);
drm_atomic_set_mode_prop_for_crtc	int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state, struct drm_property_blob *blob);
drm_atomic_state_alloc	struct drm_atomic_state *drm_atomic_state_alloc(struct drm_device *dev);
drm_atomic_state_default_clear	void drm_atomic_state_default_clear(struct drm_atomic_state *state);
drm_atomic_state_default_release	void drm_atomic_state_default_release(struct drm_atomic_state *state);
drm_atomic_state_init	int drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state);
drm_compat_ioctl	long drm_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
drm_connector_attach_encoder	int drm_connector_attach_encoder(struct drm_connector *connector, struct drm_encoder *encoder);
drm_connector_attach_vrr_capable_property	int drm_connector_attach_vrr_capable_property(struct drm_connector *connector);
drm_connector_cleanup	void drm_connector_cleanup(struct drm_connector *connector);
drm_connector_init	int drm_connector_init(struct drm_device *dev, struct drm_connector *connector, const struct drm_connector_funcs *funcs, int connector_type);
drm_connector_list_iter_begin	void drm_connector_list_iter_begin(struct drm_device *dev, struct drm_connector_list_iter *iter);
drm_connector_list_iter_end	void drm_connector_list_iter_end(struct drm_connector_list_iter *iter);
drm_connector_list_iter_next	struct drm_connector *drm_connector_list_iter_next(struct drm_connector_list_iter *iter);
drm_connector_register	int drm_connector_register(struct drm_connector *connector);
drm_connector_set_vrr_capable_property	void drm_connector_set_vrr_capable_property(struct drm_connector *connector, bool capable);
drm_connector_unregister	void drm_connector_unregister(struct drm_connector *connector);
drm_connector_update_edid_property	int drm_connector_update_edid_property(struct drm_connector *connector, const struct edid *edid);
drm_crtc_cleanup	void drm_crtc_cleanup(struct drm_crtc *crtc);
drm_crtc_init_with_planes	int drm_crtc_init_with_planes(struct drm_device *dev, struct drm_crtc *crtc, struct drm_plane *primary, struct drm_plane *cursor, const struct drm_crtc_funcs *funcs, const char *name, ...);
drm_crtc_send_vblank_event	void drm_crtc_send_vblank_event(struct drm_crtc *crtc, struct drm_pending_vblank_event *e);
drm_dev_alloc	struct drm_device *drm_dev_alloc(const struct drm_driver *driver, struct device *parent);
drm_dev_put	void drm_dev_put(struct drm_device *dev);
drm_dev_register	int drm_dev_register(struct drm_device *dev, unsigned long flags);
drm_dev_unregister	void drm_dev_unregister(struct drm_device *dev);
drm_encoder_cleanup	void drm_encoder_cleanup(struct drm_encoder *encoder);
drm_encoder_init	int drm_encoder_init(struct drm_device *dev, struct drm_encoder *encoder, const struct drm_encoder_funcs *funcs, int encoder_type, const char *name, ...);
drm_file_get_master	struct drm_master *drm_file_get_master(struct drm_file *file_priv);
drm_format_info	const struct drm_format_info *drm_format_info(u32 format);
drm_framebuffer_cleanup	void drm_framebuffer_cleanup(struct drm_framebuffer *fb);
drm_framebuffer_init	int drm_framebuffer_init(struct drm_device *dev, struct drm_framebuffer *fb, const struct drm_framebuffer_funcs *funcs);
drm_gem_create_mmap_offset	int drm_gem_create_mmap_offset(struct drm_gem_object *obj);
drm_gem_handle_create	int drm_gem_handle_create(struct drm_file *file_priv, struct drm_gem_object *obj, u32 *handlep);
drm_gem_handle_delete	int drm_gem_handle_delete(struct drm_file *filp, u32 handle);
drm_gem_mmap_obj	int drm_gem_mmap_obj(struct drm_gem_object *obj, unsigned long obj_size, struct vm_area_struct *vma);
drm_gem_object_free	void drm_gem_object_free(struct kref *kref);
drm_gem_object_lookup	struct drm_gem_object *drm_gem_object_lookup(struct drm_file *filp, u32 handle);
drm_gem_object_release	void drm_gem_object_release(struct drm_gem_object *obj);
drm_gem_prime_export	struct dma_buf *drm_gem_prime_export(struct drm_gem_object *obj, int flags);
drm_gem_prime_import	struct drm_gem_object *drm_gem_prime_import(struct drm_device *dev, struct dma_buf *dma_buf);
drm_gem_private_object_init	void drm_gem_private_object_init(struct drm_device *dev, struct drm_gem_object *obj, size_t size);
drm_gem_vm_close	void drm_gem_vm_close(struct vm_area_struct *vma);
drm_gem_vm_open	void drm_gem_vm_open(struct vm_area_struct *vma);
drm_helper_hpd_irq_event	bool drm_helper_hpd_irq_event(struct drm_device *dev);
drm_helper_mode_fill_fb_struct	void drm_helper_mode_fill_fb_struct(struct drm_device *dev, struct drm_framebuffer *fb, const struct drm_mode_fb_cmd2 *mode_cmd);
drm_helper_probe_single_connector_modes	int drm_helper_probe_single_connector_modes(struct drm_connector *connector, uint32_t maxX, uint32_t maxY);
drm_ioctl	long drm_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);
drm_kms_helper_hotplug_event	void drm_kms_helper_hotplug_event(struct drm_device *dev);
drm_kms_helper_poll_disable	void drm_kms_helper_poll_disable(struct drm_device *dev);
drm_kms_helper_poll_fini	void drm_kms_helper_poll_fini(struct drm_device *dev);
drm_kms_helper_poll_init	void drm_kms_helper_poll_init(struct drm_device *dev);
drm_master_put	void drm_master_put(struct drm_master **master);
drm_mode_config_cleanup	void drm_mode_config_cleanup(struct drm_device *dev);
drm_mode_create	struct drm_display_mode *drm_mode_create(struct drm_device *dev);
drm_mode_create_dvi_i_properties	int drm_mode_create_dvi_i_properties(struct drm_device *dev);
drm_mode_object_find	struct drm_mode_object *drm_mode_object_find(struct drm_device *dev, struct drm_file *file_priv, uint32_t id, uint32_t type);
drm_mode_object_put	void drm_mode_object_put(struct drm_mode_object *obj);
drm_mode_probed_add	void drm_mode_probed_add(struct drm_connector *connector, struct drm_display_mode *mode);
drm_mode_set_name	void drm_mode_set_name(struct drm_display_mode *mode);
drm_mode_vrefresh	int drm_mode_vrefresh(const struct drm_display_mode *mode);
drm_modeset_acquire_fini	void drm_modeset_acquire_fini(struct drm_modeset_acquire_ctx *ctx);
drm_modeset_acquire_init	void drm_modeset_acquire_init(struct drm_modeset_acquire_ctx *ctx, uint32_t flags);
drm_modeset_backoff	int drm_modeset_backoff(struct drm_modeset_acquire_ctx *ctx);
drm_modeset_drop_locks	void drm_modeset_drop_locks(struct drm_modeset_acquire_ctx *ctx);
drm_modeset_lock_all	void drm_modeset_lock_all(struct drm_device *dev);
drm_modeset_lock_all_ctx	int drm_modeset_lock_all_ctx(struct drm_device *dev, struct drm_modeset_acquire_ctx *ctx);
drm_modeset_unlock_all	void drm_modeset_unlock_all(struct drm_device *dev);
drm_object_attach_property	void drm_object_attach_property(struct drm_mode_object *obj, struct drm_property *property, uint64_t init_val);
drm_object_property_set_value	int drm_object_property_set_value(struct drm_mode_object *obj, struct drm_property *property, uint64_t val);
drm_open	int drm_open(struct inode *inode, struct file *filp);
drm_plane_cleanup	void drm_plane_cleanup(struct drm_plane *plane);
drm_plane_create_alpha_property	int drm_plane_create_alpha_property(struct drm_plane *plane);
drm_plane_create_blend_mode_property	int drm_plane_create_blend_mode_property(struct drm_plane *plane, unsigned int supported_modes);
drm_plane_create_rotation_property	int drm_plane_create_rotation_property(struct drm_plane *plane, unsigned int rotation, unsigned int supported_rotations);
drm_poll	__poll_t drm_poll(struct file *filp, struct poll_table_struct *wait);
drm_prime_gem_destroy	void drm_prime_gem_destroy(struct drm_gem_object *obj, struct sg_table *sg);
drm_prime_pages_to_sg	struct sg_table *drm_prime_pages_to_sg(struct drm_device *dev, struct page **pages, unsigned int nr_pages);
drm_property_blob_get	struct drm_property_blob *drm_property_blob_get(struct drm_property_blob *blob);
drm_property_blob_put	void drm_property_blob_put(struct drm_property_blob *blob);
drm_property_create	struct drm_property *drm_property_create(struct drm_device *dev, u32 flags, const char *name, int num_values);
drm_property_create_enum	struct drm_property *drm_property_create_enum(struct drm_device *dev, u32 flags, const char *name, const struct drm_prop_enum_list *props, int num_values);
drm_property_lookup_blob	struct drm_property_blob *drm_property_lookup_blob(struct drm_device *dev, uint32_t id);
drm_property_replace_blob	bool drm_property_replace_blob(struct drm_property_blob **blob, struct drm_property_blob *new_blob);
drm_read	ssize_t drm_read(struct file *filp, char __user *buffer, size_t count, loff_t *offset);
drm_release	int drm_release(struct inode *inode, struct file *filp);
drm_universal_plane_init	int drm_universal_plane_init(struct drm_device *dev, struct drm_plane *plane, uint32_t possible_crtcs, const struct drm_plane_funcs *funcs, const uint32_t *formats, unsigned int format_count, const uint64_t *format_modifiers, enum drm_plane_type type, const char *name, ...);
drm_vma_node_is_allowed	bool drm_vma_node_is_allowed(struct drm_vma_offset_node *node, struct drm_file *tag);
drm_vma_offset_lookup_locked	struct drm_vma_offset_node *drm_vma_offset_lookup_locked(struct drm_vma_offset_manager *mgr, unsigned long start, unsigned long pages);
drmm_mode_config_init	int drmm_mode_config_init(struct drm_device *dev);
dst_release	void dst_release(struct dst_entry *dst);
dump_stack	void dump_stack(void);
efi	struct efi efi
elfcorehdr_addr	unsigned long long elfcorehdr_addr;
emergency_restart	void emergency_restart(void);
enable_irq	void enable_irq(unsigned int irq);
eth_get_headlen	u32 eth_get_headlen(const struct net_device *dev, const void *data, u32 len);
eth_type_trans	__be16 eth_type_trans(struct sk_buff *skb, struct net_device *dev);
eth_validate_addr	int eth_validate_addr(struct net_device *dev);
ether_setup	void ether_setup(struct net_device *dev);
ethtool_op_get_link	u32 ethtool_op_get_link(struct net_device *dev);
ethtool_op_get_ts_info	int ethtool_op_get_ts_info(struct net_device *dev, struct ethtool_ts_info *eti);
ethtool_params_from_link_mode	void ethtool_params_from_link_mode(struct ethtool_link_ksettings *link_ksettings, enum ethtool_link_mode_bit_indices link_mode);
ethtool_sprintf	void ethtool_sprintf(u8 **data, const char *fmt, ...);
eventfd_ctx_fdget	struct eventfd_ctx *eventfd_ctx_fdget(int fd);
eventfd_ctx_put	void eventfd_ctx_put(struct eventfd_ctx *ctx);
eventfd_signal	__u64 eventfd_signal(struct eventfd_ctx *ctx, __u64 n);
fasync_helper	int fasync_helper(int fd, struct file *filp, int on, struct fasync_struct **fapp);
fd_install	void fd_install(unsigned int fd, struct file *file);
fget	struct file *fget(unsigned int fd);
fib_table_lookup	int fib_table_lookup(struct fib_table *tb, const struct flowi4 *flp, struct fib_result *res, int fib_flags);
filp_close	int filp_close(struct file *filp, fl_owner_t id);
filp_open	struct file *filp_open(const char *filename, int flags, umode_t mode);
find_vma	struct vm_area_struct *find_vma(struct mm_struct *mm, unsigned long addr);
find_vma_intersection	struct vm_area_struct *find_vma_intersection(struct mm_struct *mm, unsigned long start_addr, unsigned long end_addr);
finish_wait	void finish_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);
firmware_request_nowarn	int firmware_request_nowarn(const struct firmware **fw, const char *name, struct device *device);
flow_block_cb_alloc	struct flow_block_cb *flow_block_cb_alloc(flow_setup_cb_t *cb, void *cb_ident, void *cb_priv, void (*release)(void *cb_priv));
flow_block_cb_free	void flow_block_cb_free(struct flow_block_cb *block_cb);
flow_block_cb_lookup	struct flow_block_cb *flow_block_cb_lookup(struct flow_block *block, flow_setup_cb_t *cb, void *cb_ident);
flow_block_cb_setup_simple	int flow_block_cb_setup_simple(struct flow_block_offload *f, struct list_head *driver_list, flow_setup_cb_t *cb, void *cb_ident, void *cb_priv, bool ingress_only);
flow_indr_block_cb_alloc	struct flow_block_cb *flow_indr_block_cb_alloc(flow_setup_cb_t *cb, void *cb_ident, void *cb_priv, void (*release)(void *cb_priv), struct flow_block_offload *bo, struct net_device *dev, struct Qdisc *sch, void *data, void *indr_cb_priv, void (*cleanup)(struct flow_block_cb *block_cb));
flow_indr_dev_register	int flow_indr_dev_register(flow_indr_block_bind_cb_t *cb, void *cb_priv);
flow_indr_dev_unregister	void flow_indr_dev_unregister(flow_indr_block_bind_cb_t *cb, void *cb_priv, void (*release)(void *cb_priv));
flow_keys_dissector	struct flow_dissector flow_keys_dissector;
flow_resources_add	void flow_resources_add(struct ib_uflow_resources *uflow_res, enum ib_flow_spec_type type, void *ibobj);
flow_resources_alloc	struct ib_uflow_resources *flow_resources_alloc(size_t num_specs);
flow_rule_match_basic	void flow_rule_match_basic(const struct flow_rule *rule, struct flow_match_basic *out);
flow_rule_match_control	void flow_rule_match_control(const struct flow_rule *rule, struct flow_match_control *out);
flow_rule_match_ct	void flow_rule_match_ct(const struct flow_rule *rule, struct flow_match_ct *out);
flow_rule_match_cvlan	void flow_rule_match_cvlan(const struct flow_rule *rule, struct flow_match_vlan *out);
flow_rule_match_enc_control	void flow_rule_match_enc_control(const struct flow_rule *rule, struct flow_match_control *out);
flow_rule_match_enc_ip	void flow_rule_match_enc_ip(const struct flow_rule *rule, struct flow_match_ip *out);
flow_rule_match_enc_ipv4_addrs	void flow_rule_match_enc_ipv4_addrs(const struct flow_rule *rule, struct flow_match_ipv4_addrs *out);
flow_rule_match_enc_ipv6_addrs	void flow_rule_match_enc_ipv6_addrs(const struct flow_rule *rule, struct flow_match_ipv6_addrs *out);
flow_rule_match_enc_keyid	void flow_rule_match_enc_keyid(const struct flow_rule *rule, struct flow_match_enc_keyid *out);
flow_rule_match_enc_opts	void flow_rule_match_enc_opts(const struct flow_rule *rule, struct flow_match_enc_opts *out);
flow_rule_match_enc_ports	void flow_rule_match_enc_ports(const struct flow_rule *rule, struct flow_match_ports *out);
flow_rule_match_eth_addrs	void flow_rule_match_eth_addrs(const struct flow_rule *rule, struct flow_match_eth_addrs *out);
flow_rule_match_icmp	void flow_rule_match_icmp(const struct flow_rule *rule, struct flow_match_icmp *out);
flow_rule_match_ip	void flow_rule_match_ip(const struct flow_rule *rule, struct flow_match_ip *out);
flow_rule_match_ipv4_addrs	void flow_rule_match_ipv4_addrs(const struct flow_rule *rule, struct flow_match_ipv4_addrs *out);
flow_rule_match_ipv6_addrs	void flow_rule_match_ipv6_addrs(const struct flow_rule *rule, struct flow_match_ipv6_addrs *out);
flow_rule_match_l2tpv3	void flow_rule_match_l2tpv3(const struct flow_rule *rule, struct flow_match_l2tpv3 *out);
flow_rule_match_meta	void flow_rule_match_meta(const struct flow_rule *rule, struct flow_match_meta *out);
flow_rule_match_mpls	void flow_rule_match_mpls(const struct flow_rule *rule, struct flow_match_mpls *out);
flow_rule_match_ports	void flow_rule_match_ports(const struct flow_rule *rule, struct flow_match_ports *out);
flow_rule_match_pppoe	void flow_rule_match_pppoe(const struct flow_rule *rule, struct flow_match_pppoe *out);
flow_rule_match_tcp	void flow_rule_match_tcp(const struct flow_rule *rule, struct flow_match_tcp *out);
flow_rule_match_vlan	void flow_rule_match_vlan(const struct flow_rule *rule, struct flow_match_vlan *out);
follow_pfn	int follow_pfn(struct vm_area_struct *vma, unsigned long address, unsigned long *pfn);
fortify_panic	void fortify_panic(const char *name);
fput	void fput(struct file *);
free_cpumask_var	void free_cpumask_var(cpumask_var_t mask);		否
free_fib_info	void free_fib_info(struct fib_info *fi);
free_iova	void free_iova(struct iova_domain *iovad, unsigned long pfn);
free_iova_fast	void free_iova_fast(struct iova_domain *iovad, unsigned long pfn, unsigned long size);
free_irq	const void *free_irq(unsigned int irq, void *dev_id);
free_irq_cpu_rmap	void free_irq_cpu_rmap(struct cpu_rmap *rmap);
free_netdev	void free_netdev(struct net_device *dev);
free_pages	void free_pages(unsigned long addr, unsigned int order);
free_pages_exact	void free_pages_exact(void *virt, size_t size);
free_percpu	void free_percpu(void __percpu *__pdata);
freezing_slow_path	bool freezing_slow_path(struct task_struct *p);
full_name_hash	unsigned int full_name_hash(const void *salt, const char *name, unsigned int len);
gen_pool_avail	size_t gen_pool_avail(struct gen_pool *);
gen_pool_size	size_t gen_pool_size(struct gen_pool *);
gen_pool_virt_to_phys	phys_addr_t gen_pool_virt_to_phys(struct gen_pool *pool, unsigned long);
genl_register_family	int genl_register_family(struct genl_family *family);
genl_unregister_family	int genl_unregister_family(const struct genl_family *family);
genlmsg_put	void *genlmsg_put(struct sk_buff *skb, u32 portid, u32 seq, const struct genl_family *family, int flags, u8 cmd);
get_device	struct device *get_device(struct device *dev);
get_device_system_crosststamp	int get_device_system_crosststamp(int (*get_time_fn)(ktime_t *device_time, struct system_counterval_t *system_counterval, void *ctx), void *ctx, struct system_time_snapshot *history, struct system_device_crosststamp *xtstamp);
get_net_ns_by_fd	struct net *get_net_ns_by_fd(int fd);
get_net_ns_by_pid	struct net *get_net_ns_by_pid(pid_t pid);
get_pid_task	struct task_struct *get_pid_task(struct pid *pid, enum pid_type);
get_random_bytes	void get_random_bytes(void *buf, size_t len);
get_random_u32	u32 get_random_u32(void);
get_task_mm	struct mm_struct *get_task_mm(struct task_struct *task);
get_task_pid	struct pid *get_task_pid(struct task_struct *task, enum pid_type type);
get_unused_fd_flags	int get_unused_fd_flags(unsigned flags);
get_user_pages_remote	long get_user_pages_remote(struct mm_struct *mm, unsigned long start, unsigned long nr_pages, unsigned int gup_flags, struct page **pages, int *locked);
get_zeroed_page	unsigned long get_zeroed_page(gfp_t gfp_mask);
gfn_to_pfn	kvm_pfn_t gfn_to_pfn(struct kvm *kvm, gfn_t gfn);
gpio_free	void gpio_free(unsigned gpio);
gpio_request	int gpio_request(unsigned gpio, const char *label);
gpio_to_desc	struct gpio_desc *gpio_to_desc(unsigned gpio);
gpiod_get_raw_value	int gpiod_get_raw_value(const struct gpio_desc *desc);
hex_dump_to_buffer	int hex_dump_to_buffer(const void *buf, size_t len, int rowsize, int groupsize, char *linebuf, size_t linebuflen, bool ascii);
hmm_range_fault	int hmm_range_fault(struct hmm_range *range);
hugetlb_optimize_vmemmap_key	DEFINE_STATIC_KEY_FALSE(hugetlb_optimize_vmemmap_key);		否
hwmon_device_register_with_info	struct device *hwmon_device_register_with_info(struct device *dev, const char *name, void *drvdata, const struct hwmon_chip_info *info, const struct attribute_group **extra_groups);
hwmon_device_unregister	void hwmon_device_unregister(struct device *dev);
hwmon_notify_event	int hwmon_notify_event(struct device *dev, enum hwmon_sensor_types type, u32 attr, int channel);
i2c_add_adapter	int i2c_add_adapter(struct i2c_adapter *adap);
i2c_del_adapter	void i2c_del_adapter(struct i2c_adapter *adap);
ib_alloc_xrcd_user	struct ib_xrcd *ib_alloc_xrcd_user(struct ib_device *device, struct inode *inode, struct ib_udata *udata);
ib_attach_mcast	int ib_attach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid);
ib_cache_gid_parse_type_str	int ib_cache_gid_parse_type_str(const char *buf);
ib_cache_gid_type_str	const char *ib_cache_gid_type_str(enum ib_gid_type gid_type);
ib_cm_init_qp_attr	int ib_cm_init_qp_attr(struct ib_cm_id *cm_id, struct ib_qp_attr *qp_attr, int *qp_attr_mask);
ib_cm_insert_listen	struct ib_cm_id *ib_cm_insert_listen(struct ib_device *device, ib_cm_handler cm_handler, __be64 service_id);
ib_cm_listen	int ib_cm_listen(struct ib_cm_id *cm_id, __be64 service_id);
ib_cm_notify	int ib_cm_notify(struct ib_cm_id *cm_id, enum ib_event_type event);
ib_copy_ah_attr_to_user	void ib_copy_ah_attr_to_user(struct ib_device *device, struct ib_uverbs_ah_attr *dst, struct rdma_ah_attr *src);
ib_copy_path_rec_to_user	void ib_copy_path_rec_to_user(struct ib_user_path_rec *dst, struct sa_path_rec *src);
ib_copy_qp_attr_to_user	void ib_copy_qp_attr_to_user(struct ib_device *device, struct ib_uverbs_qp_attr *dst, struct ib_qp_attr *src);
ib_create_ah_from_wc	struct ib_ah *ib_create_ah_from_wc(struct ib_pd *pd, const struct ib_wc *wc, const struct ib_grh *grh, u32 port_num);
ib_create_cm_id	struct ib_cm_id *ib_create_cm_id(struct ib_device *device, ib_cm_handler cm_handler, void *context);
ib_create_qp_kernel	struct ib_qp *ib_create_qp_kernel(struct ib_pd *pd, struct ib_qp_init_attr *qp_init_attr, const char *caller);
ib_create_qp_user	struct ib_qp *ib_create_qp_user(struct ib_device *dev, struct ib_pd *pd, struct ib_qp_init_attr *attr, struct ib_udata *udata, struct ib_uqp_object *uobj, const char *caller);
ib_create_send_mad	struct ib_mad_send_buf *ib_create_send_mad(struct ib_mad_agent *mad_agent, u32 remote_qpn, u16 pkey_index, int rmpp_active, int hdr_len, int data_len, gfp_t gfp_mask, u8 base_version);
ib_create_srq_user	struct ib_srq *ib_create_srq_user(struct ib_pd *pd, struct ib_srq_init_attr *srq_init_attr, struct ib_usrq_object *uobject, struct ib_udata *udata);
ib_dealloc_device	void ib_dealloc_device(struct ib_device *device);
ib_dealloc_pd_user	int ib_dealloc_pd_user(struct ib_pd *pd, struct ib_udata *udata);
ib_dealloc_xrcd_user	int ib_dealloc_xrcd_user(struct ib_xrcd *xrcd, struct ib_udata *udata);
ib_dereg_mr_user	int ib_dereg_mr_user(struct ib_mr *mr, struct ib_udata *udata);
ib_destroy_cm_id	void ib_destroy_cm_id(struct ib_cm_id *cm_id);
ib_destroy_cq_user	int ib_destroy_cq_user(struct ib_cq *cq, struct ib_udata *udata);
ib_destroy_qp_user	int ib_destroy_qp_user(struct ib_qp *qp, struct ib_udata *udata);
ib_destroy_srq_user	int ib_destroy_srq_user(struct ib_srq *srq, struct ib_udata *udata);
ib_destroy_wq_user	int ib_destroy_wq_user(struct ib_wq *wq, struct ib_udata *udata);
ib_detach_mcast	int ib_detach_mcast(struct ib_qp *qp, union ib_gid *gid, u16 lid);
ib_dispatch_event	void ib_dispatch_event(const struct ib_event *event);
ib_find_cached_pkey	int ib_find_cached_pkey(struct ib_device *device, u32 port_num, u16 pkey, u16 *index);
ib_find_gid	int ib_find_gid(struct ib_device *device, union ib_gid *gid, u32 *port_num, u16 *index);
ib_find_pkey	int ib_find_pkey(struct ib_device *device, u32 port_num, u16 pkey, u16 *index);
ib_free_cq	void ib_free_cq(struct ib_cq *cq);
ib_free_recv_mad	void ib_free_recv_mad(struct ib_mad_recv_wc *mad_recv_wc);
ib_free_send_mad	void ib_free_send_mad(struct ib_mad_send_buf *send_buf);
ib_get_cached_pkey	int ib_get_cached_pkey(struct ib_device *device_handle, u32 port_num, int index, u16 *pkey);
ib_get_cached_port_state	int ib_get_cached_port_state(struct ib_device *device, u32 port_num, enum ib_port_state *port_active);
ib_get_device_fw_str	void ib_get_device_fw_str(struct ib_device *device, char *str);
ib_get_mad_data_offset	int ib_get_mad_data_offset(u8 mgmt_class);
ib_get_net_dev_by_params	struct net_device *ib_get_net_dev_by_params(struct ib_device *dev, u32 port, u16 pkey, const union ib_gid *gid, const struct sockaddr *addr);
ib_get_rmpp_segment	void *ib_get_rmpp_segment(struct ib_mad_send_buf *send_buf, int seg_num);
ib_get_vf_config	int ib_get_vf_config(struct ib_device *device, int vf, u32 port, struct ifla_vf_info *info);
ib_get_vf_guid	int ib_get_vf_guid(struct ib_device *device, int vf, u32 port, struct ifla_vf_guid *node_guid, struct ifla_vf_guid *port_guid);
ib_get_vf_stats	int ib_get_vf_stats(struct ib_device *device, int vf, u32 port, struct ifla_vf_stats *stats);
ib_init_ah_attr_from_path	int ib_init_ah_attr_from_path(struct ib_device *device, u32 port_num, struct sa_path_rec *rec, struct rdma_ah_attr *ah_attr, const struct ib_gid_attr *sgid_attr);
ib_init_ah_attr_from_wc	int ib_init_ah_attr_from_wc(struct ib_device *device, u32 port_num, const struct ib_wc *wc, const struct ib_grh *grh, struct rdma_ah_attr *ah_attr);
ib_init_ah_from_mcmember	int ib_init_ah_from_mcmember(struct ib_device *device, u32 port_num, struct ib_sa_mcmember_rec *rec, struct net_device *ndev, enum ib_gid_type gid_type, struct rdma_ah_attr *ah_attr);
ib_is_mad_class_rmpp	int ib_is_mad_class_rmpp(u8 mgmt_class);
ib_mad_kernel_rmpp_agent	int ib_mad_kernel_rmpp_agent(const struct ib_mad_agent *agent);
ib_modify_mad	int ib_modify_mad(struct ib_mad_send_buf *send_buf, u32 timeout_ms);
ib_modify_port	int ib_modify_port(struct ib_device *device, u32 port_num, int port_modify_mask, struct ib_port_modify *port_modify);
ib_modify_qp	int ib_modify_qp(struct ib_qp *qp, struct ib_qp_attr *qp_attr, int qp_attr_mask);
ib_modify_qp_is_ok	bool ib_modify_qp_is_ok(enum ib_qp_state cur_state, enum ib_qp_state next_state, enum ib_qp_type type, enum ib_qp_attr_mask mask);
ib_modify_qp_with_udata	int ib_modify_qp_with_udata(struct ib_qp *qp, struct ib_qp_attr *attr, int attr_mask, struct ib_udata *udata);
ib_open_qp	struct ib_qp *ib_open_qp(struct ib_xrcd *xrcd, struct ib_qp_open_attr *qp_open_attr);
ib_port_immutable_read	const struct ib_port_immutable *ib_port_immutable_read(struct ib_device *dev, unsigned int port);
ib_port_register_client_groups	int ib_port_register_client_groups(struct ib_device *ibdev, u32 port_num, const struct attribute_group **groups);
ib_port_unregister_client_groups	void ib_port_unregister_client_groups(struct ib_device *ibdev, u32 port_num, const struct attribute_group **groups);
ib_post_send_mad	int ib_post_send_mad(struct ib_mad_send_buf *send_buf, struct ib_mad_send_buf **bad_send_buf);
ib_process_cq_direct	int ib_process_cq_direct(struct ib_cq *cq, int budget);
ib_qp_usecnt_inc	void ib_qp_usecnt_inc(struct ib_qp *qp);
ib_query_pkey	int ib_query_pkey(struct ib_device *device, u32 port_num, u16 index, u16 *pkey);
ib_query_port	int ib_query_port(struct ib_device *device, u32 port_num, struct ib_port_attr *port_attr);
ib_query_qp	int ib_query_qp(struct ib_qp *qp, struct ib_qp_attr *qp_attr, int qp_attr_mask, struct ib_qp_init_attr *qp_init_attr);
ib_query_srq	int ib_query_srq(struct ib_srq *srq, struct ib_srq_attr *srq_attr);
ib_rate_to_mbps	int ib_rate_to_mbps(enum ib_rate rate);
ib_rdmacg_try_charge	int ib_rdmacg_try_charge(struct ib_rdmacg_object *cg_obj, struct ib_device *device, enum rdmacg_resource_type resource_index);
ib_rdmacg_uncharge	void ib_rdmacg_uncharge(struct ib_rdmacg_object *cg_obj, struct ib_device *device, enum rdmacg_resource_type resource_index);
ib_register_client	int ib_register_client(struct ib_client *client);
ib_register_device	int ib_register_device(struct ib_device *device, const char *name, struct device *dma_device);
ib_register_event_handler	void ib_register_event_handler(struct ib_event_handler *event_handler);
ib_register_mad_agent	struct ib_mad_agent *ib_register_mad_agent(struct ib_device *device, u32 port_num, enum ib_qp_type qp_type, struct ib_mad_reg_req *mad_reg_req, u8 rmpp_version, ib_mad_send_handler send_handler, ib_mad_recv_handler recv_handler, void *context, u32 registration_flags);
ib_response_mad	int ib_response_mad(const struct ib_mad_hdr *hdr);
ib_sa_cancel_query	void ib_sa_cancel_query(int id, struct ib_sa_query *query);
ib_sa_free_multicast	void ib_sa_free_multicast(struct ib_sa_multicast *multicast);
ib_sa_get_mcmember_rec	int ib_sa_get_mcmember_rec(struct ib_device *device, u32 port_num, union ib_gid *mgid, struct ib_sa_mcmember_rec *rec);
ib_sa_join_multicast	struct ib_sa_multicast *ib_sa_join_multicast(struct ib_sa_client *client, struct ib_device *device, u32 port_num, struct ib_sa_mcmember_rec *rec, ib_sa_comp_mask comp_mask, gfp_t gfp_mask, int (*callback)(int status, struct ib_sa_multicast *multicast), void *context);
ib_sa_pack_path	void ib_sa_pack_path(struct sa_path_rec *rec, void *attribute);
ib_sa_path_rec_get	int ib_sa_path_rec_get(struct ib_sa_client *client, struct ib_device *device, u32 port_num, struct sa_path_rec *rec, ib_sa_comp_mask comp_mask, unsigned long timeout_ms, gfp_t gfp_mask, void (*callback)(int status, struct sa_path_rec *resp, unsigned int num_prs, void *context), void *context, struct ib_sa_query **query);
ib_sa_register_client	void ib_sa_register_client(struct ib_sa_client *client);
ib_sa_unpack_path	void ib_sa_unpack_path(void *attribute, struct sa_path_rec *rec);
ib_sa_unregister_client	void ib_sa_unregister_client(struct ib_sa_client *client);
ib_send_cm_drep	int ib_send_cm_drep(struct ib_cm_id *cm_id, const void *private_data, u8 private_data_len);
ib_send_cm_dreq	int ib_send_cm_dreq(struct ib_cm_id *cm_id, const void *private_data, u8 private_data_len);
ib_send_cm_mra	int ib_send_cm_mra(struct ib_cm_id *cm_id, u8 service_timeout, const void *private_data, u8 private_data_len);
ib_send_cm_rej	int ib_send_cm_rej(struct ib_cm_id *cm_id, enum ib_cm_rej_reason reason, void *ari, u8 ari_length, const void *private_data, u8 private_data_len);
ib_send_cm_rep	int ib_send_cm_rep(struct ib_cm_id *cm_id, struct ib_cm_rep_param *param);
ib_send_cm_req	int ib_send_cm_req(struct ib_cm_id *cm_id, struct ib_cm_req_param *param);
ib_send_cm_rtu	int ib_send_cm_rtu(struct ib_cm_id *cm_id, const void *private_data, u8 private_data_len);
ib_send_cm_sidr_rep	int ib_send_cm_sidr_rep(struct ib_cm_id *cm_id, struct ib_cm_sidr_rep_param *param);
ib_send_cm_sidr_req	int ib_send_cm_sidr_req(struct ib_cm_id *cm_id, struct ib_cm_sidr_req_param *param);
ib_set_client_data	void ib_set_client_data(struct ib_device *device, struct ib_client *client, void *data);
ib_set_device_ops	void ib_set_device_ops(struct ib_device *device, const struct ib_device_ops *ops);
ib_set_vf_guid	int ib_set_vf_guid(struct ib_device *device, int vf, u32 port, u64 guid, int type);
ib_set_vf_link_state	int ib_set_vf_link_state(struct ib_device *device, int vf, u32 port, int state);
ib_sg_to_pages	int ib_sg_to_pages(struct ib_mr *mr, struct scatterlist *sgl, int sg_nents, unsigned int *sg_offset, int (*set_page)(struct ib_mr *, u64));
ib_umem_copy_from	int ib_umem_copy_from(void *dst, struct ib_umem *umem, size_t offset, size_t length);
ib_umem_dmabuf_get	struct ib_umem_dmabuf *ib_umem_dmabuf_get(struct ib_device *device, unsigned long offset, size_t size, int fd, int access, const struct dma_buf_attach_ops *ops);
ib_umem_dmabuf_get_pinned	struct ib_umem_dmabuf *ib_umem_dmabuf_get_pinned(struct ib_device *device, unsigned long offset, size_t size, int fd, int access);
ib_umem_dmabuf_map_pages	int ib_umem_dmabuf_map_pages(struct ib_umem_dmabuf *umem_dmabuf);
ib_umem_dmabuf_unmap_pages	void ib_umem_dmabuf_unmap_pages(struct ib_umem_dmabuf *umem_dmabuf);
ib_umem_find_best_pgsz	unsigned long ib_umem_find_best_pgsz(struct ib_umem *umem, unsigned long pgsz_bitmap, unsigned long virt);
ib_umem_odp_alloc_child	struct ib_umem_odp *ib_umem_odp_alloc_child(struct ib_umem_odp *root_umem, unsigned long addr, size_t size, const struct mmu_interval_notifier_ops *ops);
ib_umem_odp_alloc_implicit	struct ib_umem_odp *ib_umem_odp_alloc_implicit(struct ib_device *device, int access);
ib_umem_odp_get	struct ib_umem_odp *ib_umem_odp_get(struct ib_device *device, unsigned long addr, size_t size, int access, const struct mmu_interval_notifier_ops *ops);
ib_umem_odp_map_dma_and_lock	int ib_umem_odp_map_dma_and_lock(struct ib_umem_odp *umem_odp, u64 user_virt, u64 bcnt, u64 access_mask, bool fault);
ib_umem_odp_release	void ib_umem_odp_release(struct ib_umem_odp *umem_odp);
ib_umem_odp_unmap_dma_pages	void ib_umem_odp_unmap_dma_pages(struct ib_umem_odp *umem_odp, u64 start_offset, u64 bound);
ib_umem_release	void ib_umem_release(struct ib_umem *umem);
ib_unregister_client	void ib_unregister_client(struct ib_client *client);
ib_unregister_device	void ib_unregister_device(struct ib_device *device);
ib_unregister_event_handler	void ib_unregister_event_handler(struct ib_event_handler *event_handler);
ib_unregister_mad_agent	void ib_unregister_mad_agent(struct ib_mad_agent *mad_agent);
ib_uverbs_flow_resources_free	void ib_uverbs_flow_resources_free(struct ib_uflow_resources *uflow_res);
ib_uverbs_get_ucontext_file	struct ib_ucontext *ib_uverbs_get_ucontext_file(struct ib_uverbs_file *ufile);
ib_wc_status_msg	const char *ib_wc_status_msg(enum ib_wc_status status);
ibcm_reject_msg	const char *ibcm_reject_msg(int reason);
ibnl_put_attr	int ibnl_put_attr(struct sk_buff *skb, struct nlmsghdr *nlh, int len, void *data, int type);
ibnl_put_msg	void *ibnl_put_msg(struct sk_buff *skb, struct nlmsghdr **nlh, int seq, int len, int client, int op, int flags);
icmp6_send	void icmp6_send(struct sk_buff *skb, u8 type, u8 code, __u32 info, const struct in6_addr *force_saddr, const struct inet6_skb_parm *parm);
ida_alloc_range	int ida_alloc_range(struct ida *ida, unsigned int min, unsigned int max, gfp_t gfp);
ida_destroy	void ida_destroy(struct ida *ida);
ida_free	void ida_free(struct ida *ida, unsigned int id);
idr_alloc	int idr_alloc(struct idr *idr, void *ptr, int start, int end, gfp_t gfp);
idr_alloc_cyclic	int idr_alloc_cyclic(struct idr *idr, void *ptr, int start, int end, gfp_t gfp);
idr_alloc_u32	int idr_alloc_u32(struct idr *idr, void *ptr, u32 *nextid, unsigned long max, gfp_t gfp);
idr_destroy	void idr_destroy(struct idr *);
idr_find	void *idr_find(const struct idr *idr, unsigned long id);
idr_get_next	void *idr_get_next(struct idr *idr, int *nextid);
idr_get_next_ul	void *idr_get_next_ul(struct idr *idr, unsigned long *nextid);
idr_preload	void idr_preload(gfp_t gfp_mask);
idr_remove	void *idr_remove(struct idr *idr, unsigned long id);
igrab	struct inode *igrab(struct inode *inode);
in_dev_finish_destroy	void in_dev_finish_destroy(struct in_device *idev);
in_group_p	int in_group_p(kgid_t grp);
in4_pton	int in4_pton(const char *src, int srclen, u8 *dst, int delim, const char **end);
in6_dev_finish_destroy	void in6_dev_finish_destroy(struct inet6_dev *idev);
in6_pton	int in6_pton(const char *src, int srclen, u8 *dst, int delim, const char **end);
inet_confirm_addr	__be32 inet_confirm_addr(struct net *net, struct in_device *in_dev, __be32 dst, __be32 local, int scope);
inet_get_local_port_range	void inet_get_local_port_range(const struct net *net, int *low, int *high);
init_iova_domain	void init_iova_domain(struct iova_domain *iovad, unsigned long granule, unsigned long start_pfn);
init_net	struct net init_net;
init_on_alloc	DEFINE_STATIC_KEY_MAYBE(CONFIG_INIT_ON_ALLOC_DEFAULT_ON, init_on_alloc);
init_srcu_struct	int init_srcu_struct(struct srcu_struct *ssp);
init_task	struct task_struct init_task;
init_timer_key	void init_timer_key(struct timer_list *timer, void (*func)(struct timer_list *), unsigned int flags, const char *name, struct lock_class_key *key);
init_wait_entry	void init_wait_entry(struct wait_queue_entry *wq_entry, int flags);
int_pow	u64 int_pow(u64 base, unsigned int exp);
int_to_scsilun	void int_to_scsilun(u64 lun, struct scsi_lun *scsilun);
iomem_resource	struct resource iomem_resource;
iommu_attach_group	int iommu_attach_group(struct iommu_domain *domain, struct iommu_group *group);
iommu_detach_group	void iommu_detach_group(struct iommu_domain *domain, struct iommu_group *group);
iommu_domain_alloc	struct iommu_domain *iommu_domain_alloc(const struct bus_type *bus);
iommu_domain_free	void iommu_domain_free(struct iommu_domain *domain);
iommu_get_msi_cookie	int iommu_get_msi_cookie(struct iommu_domain *domain, dma_addr_t base);
iommu_group_get	struct iommu_group *iommu_group_get(struct device *dev);
iommu_map	int iommu_map(struct iommu_domain *domain, unsigned long iova, phys_addr_t paddr, size_t size, int prot, gfp_t gfp);
iommu_unmap	size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, size_t size);
iommu_unmap_fast	size_t iommu_unmap_fast(struct iommu_domain *domain, unsigned long iova, size_t size, struct iommu_iotlb_gather *iotlb_gather);
ioread16be	unsigned int ioread16be(const void __iomem *addr);		否
ioread32be	unsigned int ioread32be(const void __iomem *addr);		否
ioread8	unsigned int ioread8(const void __iomem *addr);		否
ioremap	void __iomem *ioremap(resource_size_t res_cookie, size_t size);		否
ioremap_cache	void __iomem *ioremap_cache(resource_size_t res_cookie, size_t size);		否
ioremap_wc	void __iomem *ioremap_wc(resource_size_t res_cookie, size_t size);		否
iounmap	void iounmap(volatile void __iomem *addr);
iov_iter_kvec	void iov_iter_kvec(struct iov_iter *i, unsigned int direction, const struct kvec *kvec, unsigned long nr_segs, size_t count);
iowrite32be	void iowrite32be(u32, void __iomem *);		否
ip_mc_inc_group	void ip_mc_inc_group(struct in_device *in_dev, __be32 addr);
ip_route_output_flow	struct rtable *ip_route_output_flow(struct net *, struct flowi4 *flp, const struct sock *sk);
ip_send_check	void ip_send_check(struct iphdr *ip);
ip_tos2prio	const __u8 ip_tos2prio[16]
ip6_dst_hoplimit	int ip6_dst_hoplimit(struct dst_entry *dst);
ip6_route_output_flags	struct dst_entry *ip6_route_output_flags(struct net *net, const struct sock *sk, struct flowi6 *fl6, int flags);
iput	void iput(struct inode *inode);
ipv6_chk_addr	int ipv6_chk_addr(struct net *net, const struct in6_addr *addr, const struct net_device *dev, int strict);
ipv6_ext_hdr	bool ipv6_ext_hdr(u8 nexthdr);
ipv6_find_hdr	int ipv6_find_hdr(const struct sk_buff *skb, unsigned int *offset, int target, unsigned short *fragoff, int *fragflg);
ipv6_mod_enabled	bool ipv6_mod_enabled(void);
ipv6_skip_exthdr	int ipv6_skip_exthdr(const struct sk_buff *, int start, u8 *nexthdrp, __be16 *frag_offp);
ipv6_stub	const struct ipv6_stub *ipv6_stub
irq_cpu_rmap_add	int irq_cpu_rmap_add(struct cpu_rmap *rmap, int irq);
irq_get_irq_data	struct irq_data *irq_get_irq_data(unsigned int irq);
irq_poll_complete	void irq_poll_complete(struct irq_poll *iop);
irq_poll_disable	void irq_poll_disable(struct irq_poll *iop);
irq_poll_enable	void irq_poll_enable(struct irq_poll *iop);
irq_poll_init	void irq_poll_init(struct irq_poll *iop, int weight, irq_poll_fn *poll_fn);
irq_poll_sched	void irq_poll_sched(struct irq_poll *iop);
irq_set_affinity_notifier	int irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify);
is_acpi_device_node	bool is_acpi_device_node(const struct fwnode_handle *fwnode);
is_vmalloc_addr	bool is_vmalloc_addr(const void *x);
iter_div_u64_rem	u32 iter_div_u64_rem(u64 dividend, u32 divisor, u64 *remainder);
iterate_fd	int iterate_fd(struct files_struct *files, unsigned n, int (*f)(const void *, struct file *, unsigned), const void *p);
iw_cm_accept	int iw_cm_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *iw_param);
iw_cm_connect	int iw_cm_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *iw_param);
iw_cm_disconnect	int iw_cm_disconnect(struct iw_cm_id *cm_id, int abrupt);
iw_cm_init_qp_attr	int iw_cm_init_qp_attr(struct iw_cm_id *cm_id, struct ib_qp_attr *qp_attr, int *qp_attr_mask);
iw_cm_listen	int iw_cm_listen(struct iw_cm_id *cm_id, int backlog);
iw_cm_reject	int iw_cm_reject(struct iw_cm_id *cm_id, const void *private_data, u8 private_data_len);
iw_create_cm_id	struct iw_cm_id *iw_create_cm_id(struct ib_device *device, iw_cm_handler cm_handler, void *context);
iw_destroy_cm_id	void iw_destroy_cm_id(struct iw_cm_id *cm_id);
iwcm_reject_msg	const char *attribute_const iwcm_reject_msg(int reason);
jiffies	unsigned long volatile jiffies
jiffies_to_msecs	unsigned int jiffies_to_msecs(const unsigned long j);
jiffies_to_timespec64	void jiffies_to_timespec64(const unsigned long jiffies, struct timespec64 *value);
jiffies_to_usecs	unsigned int jiffies_to_usecs(const unsigned long j);
kasprintf	char *kasprintf(gfp_t gfp, const char *fmt, ...);
kern_path	int kern_path(const char *name, unsigned int flags, struct path *path);
kernel_read	ssize_t kernel_read(struct file *file, void *buf, size_t count, loff_t *pos);
kernel_write	ssize_t kernel_write(struct file *file, const void *buf, size_t count, loff_t *pos);
kfree	void kfree(const void *objp);
kfree_skb_reason	void kfree_skb_reason(struct sk_buff *skb, enum skb_drop_reason reason);
kill_fasync	void kill_fasync(struct fasync_struct **fp, int sig, int band);
kmalloc_caches	struct kmem_cache *kmalloc_caches[NR_KMALLOC_TYPES][KMALLOC_SHIFT_HIGH + 1]
kmalloc_large	void *kmalloc_large(size_t size, gfp_t flags);
kmalloc_large_node	void *kmalloc_large_node(size_t size, gfp_t flags, int node);
kmalloc_node_trace	void *kmalloc_node_trace(struct kmem_cache *s, gfp_t gfpflags, int node, size_t size);
kmalloc_trace	void *kmalloc_trace(struct kmem_cache *s, gfp_t gfpflags, size_t size);
kmem_cache_alloc	void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags);
kmem_cache_create	struct kmem_cache *kmem_cache_create(const char *name, unsigned int size, unsigned int align, slab_flags_t flags, void (*ctor)(void *));
kmem_cache_destroy	void kmem_cache_destroy(struct kmem_cache *s);
kmem_cache_free	void kmem_cache_free(struct kmem_cache *s, void *objp);
kmemdup	void *kmemdup(const void *src, size_t len, gfp_t gfp);
kmsg_dump_get_buffer	bool kmsg_dump_get_buffer(struct kmsg_dump_iter *iter, bool syslog, char *buf, size_t size, size_t *len);
kmsg_dump_get_line	bool kmsg_dump_get_line(struct kmsg_dump_iter *iter, bool syslog, char *line, size_t size, size_t *len);
kmsg_dump_rewind	void kmsg_dump_rewind(struct kmsg_dump_iter *iter);
kobject_add	int kobject_add(struct kobject *kobj, struct kobject *parent, const char *fmt, ...);
kobject_create_and_add	struct kobject *kobject_create_and_add(const char *name, struct kobject *parent);
kobject_del	void kobject_del(struct kobject *kobj);
kobject_init	void kobject_init(struct kobject *kobj, const struct kobj_type *ktype);
kobject_init_and_add	int kobject_init_and_add(struct kobject *kobj, const struct kobj_type *ktype, struct kobject *parent, const char *fmt, ...);
kobject_put	void kobject_put(struct kobject *kobj);
kobject_set_name	int kobject_set_name(struct kobject *kobj, const char *name, ...);
kobject_uevent	int kobject_uevent(struct kobject *kobj, enum kobject_action action);
krealloc	void *krealloc(const void *p, size_t new_size, gfp_t flags);
ksize	size_t ksize(const void *objp);
kstrdup	char *kstrdup(const char *s, gfp_t gfp);
kstrtobool	int kstrtobool(const char *s, bool *res);
kstrtoint	int kstrtoint(const char *s, unsigned int base, int *res);
kstrtoll	int kstrtoll(const char *s, unsigned int base, long long *res);
kstrtos16	int kstrtos16(const char *s, unsigned int base, s16 *res);
kstrtou16	int kstrtou16(const char *s, unsigned int base, u16 *res);
kstrtou8	int kstrtou8(const char *s, unsigned int base, u8 *res);
kstrtouint	int kstrtouint(const char *s, unsigned int base, unsigned int *res);
kstrtouint_from_user	int kstrtouint_from_user(const char __user *s, size_t count, unsigned int base, unsigned int *res);
kthread_cancel_delayed_work_sync	bool kthread_cancel_delayed_work_sync(struct kthread_delayed_work *work);
kthread_cancel_work_sync	bool kthread_cancel_work_sync(struct kthread_work *work);
kthread_create_on_node	struct task_struct *kthread_create_on_node(int (*threadfn)(void *data), void *data, int node, const char namefmt[], ...);
kthread_create_worker	struct kthread_worker *kthread_create_worker(unsigned int flags, const char namefmt[], ...);
kthread_delayed_work_timer_fn	void kthread_delayed_work_timer_fn(struct timer_list *t);
kthread_destroy_worker	void kthread_destroy_worker(struct kthread_worker *worker);
kthread_queue_delayed_work	bool kthread_queue_delayed_work(struct kthread_worker *worker, struct kthread_delayed_work *dwork, unsigned long delay);
kthread_queue_work	bool kthread_queue_work(struct kthread_worker *worker, struct kthread_work *work);
kthread_should_stop	bool kthread_should_stop(void);
kthread_stop	int kthread_stop(struct task_struct *k);
kthread_unuse_mm	void kthread_unuse_mm(struct mm_struct *mm);
kthread_use_mm	void kthread_use_mm(struct mm_struct *mm);
ktime_get	ktime_t ktime_get(void);
ktime_get_coarse_real_ts64	void ktime_get_coarse_real_ts64(struct timespec64 *ts);
ktime_get_raw	ktime_t ktime_get_raw(void);
ktime_get_raw_ts64	void ktime_get_raw_ts64(struct timespec64 *ts);
ktime_get_real_seconds	time64_t ktime_get_real_seconds(void);
ktime_get_real_ts64	void ktime_get_real_ts64(struct timespec64 *ts);
ktime_get_with_offset	ktime_t ktime_get_with_offset(enum tk_offsets offs);
kvasprintf	char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
kvfree	void kvfree(const void *addr);
kvfree_call_rcu	void kvfree_call_rcu(struct rcu_head *head, void *ptr);
kvm_get_kvm	void kvm_get_kvm(struct kvm *kvm);
kvm_is_visible_gfn	bool kvm_is_visible_gfn(struct kvm *kvm, gfn_t gfn);
kvm_put_kvm	void kvm_put_kvm(struct kvm *kvm);
kvmalloc_node	void *kvmalloc_node(size_t size, gfp_t flags, int node);
llist_add_batch	bool llist_add_batch(struct llist_node *new_first, struct llist_node *new_last, struct llist_head *head);
macsec_get_real_dev	struct net_device *macsec_get_real_dev(const struct net_device *dev);
macsec_netdev_is_offloaded	bool macsec_netdev_is_offloaded(struct net_device *dev);
mem_section	struct mem_section **mem_section;
memchr_inv	void *memchr_inv(const void *s, int c, size_t n);
memcpy_fromio	void memcpy_fromio(void *buffer, const volatile void __iomem *addr, size_t size);		否
memcpy_toio	void memcpy_toio(volatile void __iomem *addr, const void *buffer, size_t size);		否
memdup_user	void *memdup_user(const void __user *src, size_t len);
mempool_alloc	void *mempool_alloc(mempool_t *pool, gfp_t gfp_mask);
mempool_create	mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn, mempool_free_t *free_fn, void *pool_data);
mempool_destroy	void mempool_destroy(mempool_t *pool);
mempool_free	void mempool_free(void *element, mempool_t *pool);
mempool_kfree	void mempool_kfree(void *element, void *pool_data);
mempool_kmalloc	void *mempool_kmalloc(gfp_t gfp_mask, void *pool_data);
metadata_dst_alloc	struct metadata_dst *metadata_dst_alloc(u8 optslen, enum metadata_type type, gfp_t flags);
metadata_dst_free	void metadata_dst_free(struct metadata_dst *md_dst);
migrate_vma_finalize	void migrate_vma_finalize(struct migrate_vma *migrate);
migrate_vma_pages	void migrate_vma_pages(struct migrate_vma *migrate);
migrate_vma_setup	int migrate_vma_setup(struct migrate_vma *args);
misc_deregister	void misc_deregister(struct miscdevice *misc);
misc_register	int misc_register(struct miscdevice *misc);
mmput	void mmput(struct mm_struct *mm);
mmput_async	void mmput_async(struct mm_struct *mm);
mmu_interval_notifier_insert	int mmu_interval_notifier_insert(struct mmu_interval_notifier *interval_sub, struct mm_struct *mm, unsigned long start, unsigned long length, const struct mmu_interval_notifier_ops *ops);
mmu_interval_notifier_remove	void mmu_interval_notifier_remove(struct mmu_interval_notifier *interval_sub);
mmu_interval_read_begin	unsigned long mmu_interval_read_begin(struct mmu_interval_notifier *interval_sub);
mmu_notifier_get_locked	struct mmu_notifier *mmu_notifier_get_locked(const struct mmu_notifier_ops *ops, struct mm_struct *mm);
mmu_notifier_put	void mmu_notifier_put(struct mmu_notifier *subscription);
mmu_notifier_synchronize	void mmu_notifier_synchronize(void);
mod_delayed_work_on	bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq, struct delayed_work *dwork, unsigned long delay);
mod_timer	int mod_timer(struct timer_list *timer, unsigned long expires);
module_layout	void module_layout(struct module *mod, struct modversion_info *ver, struct kernel_param *kp, struct kernel_symbol *ks, struct tracepoint * const *tp);
module_put	void module_put(struct module *module);
module_refcount	int module_refcount(struct module *mod);
msleep	void msleep(unsigned int msecs);
msleep_interruptible	unsigned long msleep_interruptible(unsigned int msecs);
mutex_is_locked	bool mutex_is_locked(struct mutex *lock);
mutex_lock	void mutex_lock(struct mutex *lock);
mutex_lock_interruptible	int mutex_lock_interruptible(struct mutex *lock);
mutex_trylock	int mutex_trylock(struct mutex *lock);
mutex_unlock	void mutex_unlock(struct mutex *lock);
napi_build_skb	struct sk_buff *napi_build_skb(void *data, unsigned int frag_size);
napi_busy_loop	void napi_busy_loop(unsigned int napi_id, bool (*loop_end)(void *, unsigned long), void *loop_end_arg, bool prefer_busy_poll, u16 budget);
napi_complete_done	bool napi_complete_done(struct napi_struct *n, int work_done);
napi_consume_skb	void napi_consume_skb(struct sk_buff *skb, int budget);
napi_disable	void napi_disable(struct napi_struct *n);
napi_enable	void napi_enable(struct napi_struct *n);
napi_gro_receive	gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb);
napi_schedule_prep	bool napi_schedule_prep(struct napi_struct *n);
ndo_dflt_bridge_getlink	int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq, struct net_device *dev, u16 mode, u32 flags, u32 mask, int nlflags, u32 filter_mask, int (*vlan_fill)(struct sk_buff *skb, struct net_device *dev, u32 filter_mask));
neigh_destroy	void neigh_destroy(struct neighbour *neigh);
neigh_lookup	struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey, struct net_device *dev);
net_dim	void net_dim(struct dim *dim, struct dim_sample end_sample);
net_dim_get_rx_moderation	struct dim_cq_moder net_dim_get_rx_moderation(u8 cq_period_mode, int ix);
net_namespace_list	struct list_head net_namespace_list;
net_ns_type_operations	const struct kobj_ns_type_operations net_ns_type_operations;
net_ratelimit	int net_ratelimit(void);
net_rwsem	struct rw_semaphore net_rwsem;
netdev_bind_sb_channel_queue	int netdev_bind_sb_channel_queue(struct net_device *dev, struct net_device *sb_dev, u8 tc, u16 count, u16 offset);
netdev_err	void netdev_err(const struct net_device *dev, const char *fmt, ...);
netdev_get_xmit_slave	struct net_device *netdev_get_xmit_slave(struct net_device *dev, struct sk_buff *skb, bool all_slaves);
netdev_has_upper_dev_all_rcu	bool netdev_has_upper_dev_all_rcu(struct net_device *dev, struct net_device *upper_dev);
netdev_info	void netdev_info(const struct net_device *dev, const char *fmt, ...);
netdev_lower_get_next	void *netdev_lower_get_next(struct net_device *dev, struct list_head **iter);
netdev_master_upper_dev_get	struct net_device *netdev_master_upper_dev_get(struct net_device *dev);
netdev_master_upper_dev_get_rcu	struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev);
netdev_notice	void netdev_notice(const struct net_device *dev, const char *fmt, ...);
netdev_pick_tx	u16 netdev_pick_tx(struct net_device *dev, struct sk_buff *skb, struct net_device *sb_dev);
netdev_port_same_parent_id	bool netdev_port_same_parent_id(struct net_device *a, struct net_device *b);
netdev_printk	void netdev_printk(const char *level, const struct net_device *dev, const char *format, ...);
netdev_reset_tc	void netdev_reset_tc(struct net_device *dev);
netdev_rss_key_fill	void netdev_rss_key_fill(void *buffer, size_t len);
netdev_set_num_tc	int netdev_set_num_tc(struct net_device *dev, u8 num_tc);
netdev_set_sb_channel	int netdev_set_sb_channel(struct net_device *dev, u16 channel);
netdev_set_tc_queue	int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset);
netdev_state_change	void netdev_state_change(struct net_device *dev);
netdev_stats_to_stats64	void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64, const struct net_device_stats *netdev_stats);
netdev_unbind_sb_channel	void netdev_unbind_sb_channel(struct net_device *dev, struct net_device *sb_dev);
netdev_update_features	void netdev_update_features(struct net_device *dev);
netdev_walk_all_lower_dev_rcu	int netdev_walk_all_lower_dev_rcu(struct net_device *dev, int (*fn)(struct net_device *lower_dev, struct netdev_nested_priv *priv), struct netdev_nested_priv *priv);
netdev_walk_all_upper_dev_rcu	int netdev_walk_all_upper_dev_rcu(struct net_device *dev, int (*fn)(struct net_device *upper_dev, struct netdev_nested_priv *priv), struct netdev_nested_priv *priv);
netdev_warn	void netdev_warn(const struct net_device *dev, const char *fmt, ...);
netif_carrier_event	void netif_carrier_event(struct net_device *dev);
netif_carrier_off	void netif_carrier_off(struct net_device *dev);
netif_carrier_on	void netif_carrier_on(struct net_device *dev);
netif_device_attach	void netif_device_attach(struct net_device *dev);
netif_device_detach	void netif_device_detach(struct net_device *dev);
netif_napi_add_weight	void netif_napi_add_weight(struct net_device *dev, struct napi_struct *napi, int (*poll)(struct napi_struct *, int), int weight);
netif_receive_skb	int netif_receive_skb(struct sk_buff *skb);
netif_schedule_queue	void netif_schedule_queue(struct netdev_queue *txq);
netif_set_real_num_rx_queues	int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxqs);
netif_set_real_num_tx_queues	int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq);
netif_set_tso_max_size	void netif_set_tso_max_size(struct net_device *dev, unsigned int size);
netif_set_xps_queue	int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask, u16 index);
netif_tx_lock	void netif_tx_lock(struct net_device *dev);
netif_tx_stop_all_queues	void netif_tx_stop_all_queues(struct net_device *dev);
netif_tx_unlock	void netif_tx_unlock(struct net_device *dev);
netif_tx_wake_queue	void netif_tx_wake_queue(struct netdev_queue *dev_queue);
netlink_ack	void netlink_ack(struct sk_buff *in_skb, struct nlmsghdr *nlh, int err, const struct netlink_ext_ack *extack);
netlink_broadcast	int netlink_broadcast(struct sock *ssk, struct sk_buff *skb, u32 portid, u32 group, gfp_t allocation);
netlink_capable	bool netlink_capable(const struct sk_buff *skb, int cap);
netlink_has_listeners	int netlink_has_listeners(struct sock *sk, unsigned int group);
netlink_kernel_release	void netlink_kernel_release(struct sock *sk);
netlink_ns_capable	bool netlink_ns_capable(const struct sk_buff *skb, struct user_namespace *user_ns, int cap);
netlink_unicast	int netlink_unicast(struct sock *ssk, struct sk_buff *skb, __u32 portid, int nonblock);
nla_find	struct nlattr *nla_find(const struct nlattr *head, int len, int attrtype);
nla_memcpy	int nla_memcpy(void *dest, const struct nlattr *src, int count);
nla_put	int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data);
nla_put_64bit	int nla_put_64bit(struct sk_buff *skb, int attrtype, int attrlen, const void *data, int padattr);
nla_strdup	char *nla_strdup(const struct nlattr *nla, gfp_t flags);
nla_strscpy	ssize_t nla_strscpy(char *dst, const struct nlattr *nla, size_t dstsize);
node_data	struct pglist_data *node_data[MAX_NUMNODES];
node_states	nodemask_t node_states[NR_NODE_STATES]
node_to_cpumask_map	cpumask_var_t node_to_cpumask_map[MAX_NUMNODES];
nonseekable_open	int nonseekable_open(struct inode *inode, struct file *filp);
noop_llseek	loff_t noop_llseek(struct file *file, loff_t offset, int whence);
nr_cpu_ids	unsigned int nr_cpu_ids;
ns_to_timespec64	struct timespec64 ns_to_timespec64(s64 nsec);
numa_node	DECLARE_PER_CPU(int, numa_node);
out_of_line_wait_on_bit_lock	int out_of_line_wait_on_bit_lock(void *word, int bit, wait_bit_action_f *action, unsigned mode);
page_frag_free	void page_frag_free(void *addr);
page_is_ram	int page_is_ram(unsigned long pfn);
page_offset_base	unsigned long page_offset_base;		否
page_pool_alloc_pages	struct page *page_pool_alloc_pages(struct page_pool *pool, gfp_t gfp);
page_pool_create	struct page_pool *page_pool_create(const struct page_pool_params *params);
page_pool_destroy	void page_pool_destroy(struct page_pool *pool);
page_pool_put_defragged_page	void page_pool_put_defragged_page(struct page_pool *pool, struct page *page, unsigned int dma_sync_size, bool allow_direct);
page_pool_update_nid	void page_pool_update_nid(struct page_pool *pool, int new_nid);
panic	void panic(const char *fmt, ...);
param_ops_bool	const struct kernel_param_ops param_ops_bool;
param_ops_charp	const struct kernel_param_ops param_ops_charp;
param_ops_int	const struct kernel_param_ops param_ops_int;
param_ops_uint	const struct kernel_param_ops param_ops_uint;
pat_enabled	bool pat_enabled(void);		否
path_put	void path_put(const struct path *);
pci_aer_clear_nonfatal_status	int pci_aer_clear_nonfatal_status(struct pci_dev *dev);
pci_alloc_irq_vectors	int pci_alloc_irq_vectors(struct pci_dev *dev, unsigned int min_vecs, unsigned int max_vecs, unsigned int flags);
pci_alloc_irq_vectors_affinity	int pci_alloc_irq_vectors_affinity(struct pci_dev *dev, unsigned int min_vecs, unsigned int max_vecs, unsigned int flags, struct irq_affinity *aff_desc);
pci_bus_find_capability	u8 pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap);
pci_bus_read_config_dword	int pci_bus_read_config_dword(struct pci_bus *bus, unsigned int devfn, int where, u32 *val);
pci_bus_read_config_word	int pci_bus_read_config_word(struct pci_bus *bus, unsigned int devfn, int where, u16 *val);
pci_bus_type	struct bus_type pci_bus_type;
pci_cfg_access_lock	void pci_cfg_access_lock(struct pci_dev *dev);
pci_cfg_access_unlock	void pci_cfg_access_unlock(struct pci_dev *dev);
pci_clear_master	void pci_clear_master(struct pci_dev *dev);
pci_dev_present	int pci_dev_present(const struct pci_device_id *ids);
pci_dev_put	void pci_dev_put(struct pci_dev *dev);
pci_device_is_present	bool pci_device_is_present(struct pci_dev *pdev);
pci_disable_device	void pci_disable_device(struct pci_dev *dev);
pci_disable_msi	void pci_disable_msi(struct pci_dev *dev);
pci_disable_msix	void pci_disable_msix(struct pci_dev *dev);
pci_disable_sriov	void pci_disable_sriov(struct pci_dev *dev);
pci_enable_atomic_ops_to_root	int pci_enable_atomic_ops_to_root(struct pci_dev *dev, u32 cap_mask);
pci_enable_device	int pci_enable_device(struct pci_dev *dev);
pci_enable_device_mem	int pci_enable_device_mem(struct pci_dev *dev);
pci_enable_msi	int pci_enable_msi(struct pci_dev *dev);
pci_enable_msix_range	int pci_enable_msix_range(struct pci_dev *dev, struct msix_entry *entries, int minvec, int maxvec);
pci_enable_sriov	int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn);
pci_enable_wake	int pci_enable_wake(struct pci_dev *pci_dev, pci_power_t state, bool enable);
pci_find_capability	u8 pci_find_capability(struct pci_dev *dev, int cap);
pci_find_ext_capability	u16 pci_find_ext_capability(struct pci_dev *dev, int cap);
pci_free_irq_vectors	void pci_free_irq_vectors(struct pci_dev *dev);
pci_get_class	struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from);
pci_get_device	struct pci_dev *pci_get_device(unsigned int vendor, unsigned int device, struct pci_dev *from);
pci_get_domain_bus_and_slot	struct pci_dev *pci_get_domain_bus_and_slot(int domain, unsigned int bus, unsigned int devfn);
pci_get_dsn	u64 pci_get_dsn(struct pci_dev *dev);
pci_iomap	void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen);
pci_ioremap_bar	void __iomem *pci_ioremap_bar(struct pci_dev *pdev, int bar);
pci_iounmap	void pci_iounmap(struct pci_dev *dev, void __iomem *addr);
pci_iov_get_pf_drvdata	void *pci_iov_get_pf_drvdata(struct pci_dev *dev, struct pci_driver *pf_driver);
pci_iov_vf_id	int pci_iov_vf_id(struct pci_dev *dev);
pci_iov_virtfn_devfn	int pci_iov_virtfn_devfn(struct pci_dev *dev, int id);
pci_irq_vector	int pci_irq_vector(struct pci_dev *dev, unsigned int nr);
pci_load_and_free_saved_state	int pci_load_and_free_saved_state(struct pci_dev *dev, struct pci_saved_state **state);
pci_lock_rescan_remove	void pci_lock_rescan_remove(void);
pci_match_id	const struct pci_device_id *pci_match_id(const struct pci_device_id *ids, struct pci_dev *dev);
pci_num_vf	int pci_num_vf(struct pci_dev *dev);
pci_read_config_byte	int pci_read_config_byte(const struct pci_dev *dev, int where, u8 *val);
pci_read_config_dword	int pci_read_config_dword(const struct pci_dev *dev, int where, u32 *val);
pci_read_config_word	int pci_read_config_word(const struct pci_dev *dev, int where, u16 *val);
pci_release_regions	void pci_release_regions(struct pci_dev *pdev);
pci_release_selected_regions	void pci_release_selected_regions(struct pci_dev *pdev, int bars);
pci_request_regions	int pci_request_regions(struct pci_dev *pdev, const char *res_name);
pci_request_selected_regions	int pci_request_selected_regions(struct pci_dev *pdev, int bars, const char *res_name);
pci_rescan_bus	unsigned int pci_rescan_bus(struct pci_bus *bus);
pci_reset_function	int pci_reset_function(struct pci_dev *dev);
pci_restore_msi_state	void pci_restore_msi_state(struct pci_dev *dev);
pci_restore_state	void pci_restore_state(struct pci_dev *dev);
pci_save_state	int pci_save_state(struct pci_dev *dev);
pci_select_bars	int pci_select_bars(struct pci_dev *dev, unsigned long flags);
pci_set_master	void pci_set_master(struct pci_dev *dev);
pci_set_power_state	int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
pci_sriov_get_totalvfs	int pci_sriov_get_totalvfs(struct pci_dev *dev);
pci_stop_and_remove_bus_device	void pci_stop_and_remove_bus_device(struct pci_dev *dev);
pci_store_saved_state	struct pci_saved_state *pci_store_saved_state(struct pci_dev *dev);
pci_try_reset_function	int pci_try_reset_function(struct pci_dev *dev);
pci_unlock_rescan_remove	void pci_unlock_rescan_remove(void);
pci_unregister_driver	void pci_unregister_driver(struct pci_driver *drv);
pci_vfs_assigned	int pci_vfs_assigned(struct pci_dev *dev);
pci_vpd_alloc	void *pci_vpd_alloc(struct pci_dev *dev, unsigned int *size);
pci_vpd_find_ro_info_keyword	int pci_vpd_find_ro_info_keyword(const void *buf, unsigned int len, const char *kw, unsigned int *size);
pci_wait_for_pending_transaction	int pci_wait_for_pending_transaction(struct pci_dev *dev);
pci_wake_from_d3	int pci_wake_from_d3(struct pci_dev *dev, bool enable);
pci_write_config_byte	int pci_write_config_byte(const struct pci_dev *dev, int where, u8 val);
pci_write_config_dword	int pci_write_config_dword(const struct pci_dev *dev, int where, u32 val);
pci_write_config_word	int pci_write_config_word(const struct pci_dev *dev, int where, u16 val);
pcibios_resource_to_bus	void pcibios_resource_to_bus(struct pci_bus *bus, struct pci_bus_region *region, struct resource *res);
pcie_bandwidth_available	u32 pcie_bandwidth_available(struct pci_dev *dev, struct pci_dev **limiting_dev, enum pci_bus_speed *speed, enum pcie_link_width *width);
pcie_capability_clear_and_set_word_locked	int pcie_capability_clear_and_set_word_locked(struct pci_dev *dev, int pos, u16 clear, u16 set);
pcie_capability_clear_and_set_word_unlocked	int pcie_capability_clear_and_set_word_unlocked(struct pci_dev *dev, int pos, u16 clear, u16 set);
pcie_capability_read_dword	int pcie_capability_read_dword(struct pci_dev *dev, int pos, u32 *val);
pcie_capability_read_word	int pcie_capability_read_word(struct pci_dev *dev, int pos, u16 *val);
pcie_flr	int pcie_flr(struct pci_dev *dev);
pcie_print_link_status	void pcie_print_link_status(struct pci_dev *dev);
pcie_relaxed_ordering_enabled	bool pcie_relaxed_ordering_enabled(struct pci_dev *dev);
pcim_iomap_regions	int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name);
pcim_iomap_table	void __iomem * const *pcim_iomap_table(struct pci_dev *pdev);
pcpu_hot	DEFINE_PER_CPU_ALIGNED(struct pcpu_hot, pcpu_hot)		否
perf_trace_buf_alloc	void *perf_trace_buf_alloc(int size, struct pt_regs **regs, int *rctxp);
perf_trace_run_bpf_submit	void perf_trace_run_bpf_submit(void *raw_data, int size, int rctx, struct trace_event_call *call, u64 count, struct pt_regs *regs, struct hlist_head *head, struct task_struct *task);
pfn_is_map_memory	int pfn_is_map_memory(unsigned long pfn);	否
pgprot_writecombine	pgprot_t pgprot_writecombine(pgprot_t prot);		否
phy_attached_info	void phy_attached_info(struct phy_device *phydev);
phy_find_first	struct phy_device *phy_find_first(struct mii_bus *bus);
phylink_connect_phy	int phylink_connect_phy(struct phylink *pl, struct phy_device *phy);
phylink_create	struct phylink *phylink_create(struct phylink_config *config, const struct fwnode_handle *fwnode, phy_interface_t iface, const struct phylink_mac_ops *mac_ops);
phylink_destroy	void phylink_destroy(struct phylink *pl);
phylink_disconnect_phy	void phylink_disconnect_phy(struct phylink *pl);
phylink_start	void phylink_start(struct phylink *pl);
phylink_stop	void phylink_stop(struct phylink *pl);
phys_base	unsigned long phys_base;		否
pin_user_pages	long pin_user_pages(unsigned long start, unsigned long nr_pages, unsigned int gup_flags, struct page **pages);
pin_user_pages_fast	int pin_user_pages_fast(unsigned long start, int nr_pages, unsigned int gup_flags, struct page **pages);
pin_user_pages_remote	long pin_user_pages_remote(struct mm_struct *mm, unsigned long start, unsigned long nr_pages, unsigned int gup_flags, struct page **pages, int *locked);
pldmfw_flash_image	int pldmfw_flash_image(struct pldmfw *context, const struct firmware *fw);
pldmfw_op_pci_match_record	bool pldmfw_op_pci_match_record(struct pldmfw *context, struct pldmfw_record *record);
pm_vt_switch_required	void pm_vt_switch_required(struct device *dev, bool required);
pm_vt_switch_unregister	void pm_vt_switch_unregister(struct device *dev);
prepare_to_wait_event	long prepare_to_wait_event(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state);
prepare_to_wait_exclusive	bool prepare_to_wait_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state);
print_hex_dump	void print_hex_dump(const char *level, const char *prefix_str, int prefix_type, int rowsize, int groupsize, const void *buf, size_t len, bool ascii);
priv_to_devlink	struct devlink *priv_to_devlink(void *priv);
proc_create_data	struct proc_dir_entry *proc_create_data(const char *name, umode_t mode, struct proc_dir_entry *parent, const struct proc_ops *proc_ops, void *data);
proc_dointvec	int proc_dointvec(struct ctl_table *table, int write, void *buffer, size_t *lenp, loff_t *ppos);
proc_mkdir	struct proc_dir_entry *proc_mkdir(const char *name, struct proc_dir_entry *parent);
proc_mkdir_mode	struct proc_dir_entry *proc_mkdir_mode(const char *name, umode_t mode, struct proc_dir_entry *parent);
proc_remove	void proc_remove(struct proc_dir_entry *de);
proc_symlink	struct proc_dir_entry *proc_symlink(const char *name, struct proc_dir_entry *parent, const char *dest);
psample_sample_packet	void psample_sample_packet(struct psample_group *group, struct sk_buff *skb, u32 sample_rate, const struct psample_metadata *md);
pskb_expand_head	int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail, gfp_t gfp_mask);
ptp_classify_raw	unsigned int ptp_classify_raw(const struct sk_buff *skb);
ptp_clock_event	void ptp_clock_event(struct ptp_clock *ptp, struct ptp_clock_event *event);
ptp_clock_index	int ptp_clock_index(struct ptp_clock *ptp);
ptp_clock_register	struct ptp_clock *ptp_clock_register(struct ptp_clock_info *info, struct device *parent);
ptp_clock_unregister	int ptp_clock_unregister(struct ptp_clock *ptp);
ptp_find_pin	int ptp_find_pin(struct ptp_clock *ptp, enum ptp_pin_function func, unsigned int chan);
ptp_parse_header	struct ptp_header *ptp_parse_header(struct sk_buff *skb, unsigned int type);
ptp_schedule_worker	int ptp_schedule_worker(struct ptp_clock *ptp, unsigned long delay);
put_device	void put_device(struct device *dev);
put_iova_domain	void put_iova_domain(struct iova_domain *iovad);
put_pid	void put_pid(struct pid *pid);
put_unused_fd	void put_unused_fd(unsigned int fd);
qdisc_reset	void qdisc_reset(struct Qdisc *qdisc);
queue_delayed_work_on	bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq, struct delayed_work *work, unsigned long delay);
queue_work_on	bool queue_work_on(int cpu, struct workqueue_struct *wq, struct work_struct *work);
radix_tree_delete	void *radix_tree_delete(struct radix_tree_root *root, unsigned long index);
radix_tree_gang_lookup	unsigned int radix_tree_gang_lookup(const struct radix_tree_root *root, void **results, unsigned long first_index, unsigned int max_items);
radix_tree_insert	int radix_tree_insert(struct radix_tree_root *root, unsigned long index, void *item);
radix_tree_iter_delete	void radix_tree_iter_delete(struct radix_tree_root *root, struct radix_tree_iter *iter, void **slot);
radix_tree_lookup	void *radix_tree_lookup(const struct radix_tree_root *, unsigned long);
radix_tree_lookup_slot	void __rcu **radix_tree_lookup_slot(const struct radix_tree_root *, unsigned long index);
radix_tree_next_chunk	void __rcu **radix_tree_next_chunk(const struct radix_tree_root *, struct radix_tree_iter *iter, unsigned flags);
radix_tree_replace_slot	void radix_tree_replace_slot(struct radix_tree_root *root, void __rcu **slot, void *item);
radix_tree_tagged	int radix_tree_tagged(const struct radix_tree_root *root, unsigned int tag);
raw_notifier_call_chain	int raw_notifier_call_chain(struct raw_notifier_head *nh, unsigned long val, void *v);
raw_notifier_chain_register	int raw_notifier_chain_register(struct raw_notifier_head *nh, struct notifier_block *nb);
raw_notifier_chain_unregister	int raw_notifier_chain_unregister(struct raw_notifier_head *nh, struct notifier_block *nb);
rb_erase	void rb_erase(struct rb_node *node, struct rb_root *root);
rb_first	struct rb_node *rb_first(const struct rb_root *root);
rb_first_postorder	struct rb_node *rb_first_postorder(const struct rb_root *root);
rb_insert_color	void rb_insert_color(struct rb_node *node, struct rb_root *root);
rb_last	struct rb_node *rb_last(const struct rb_root *);
rb_next	struct rb_node *rb_next(const struct rb_node *node);
rb_next_postorder	struct rb_node *rb_next_postorder(const struct rb_node *node);
rb_prev	struct rb_node *rb_prev(const struct rb_node *node);
rb_replace_node	void rb_replace_node(struct rb_node *victim, struct rb_node *new, struct rb_root *root);
rcuref_get_slowpath	bool rcuref_get_slowpath(rcuref_t *ref);
rdma_accept_ece	int rdma_accept_ece(struct rdma_cm_id *id, struct rdma_conn_param *conn_param, struct rdma_ucm_ece *ece);
rdma_addr_cancel	void rdma_addr_cancel(struct rdma_dev_addr *addr);
rdma_addr_size	int rdma_addr_size(const struct sockaddr *addr);
rdma_addr_size_in6	int rdma_addr_size_in6(struct sockaddr_in6 *addr);
rdma_addr_size_kss	int rdma_addr_size_kss(struct __kernel_sockaddr_storage *addr);
rdma_alloc_hw_stats_struct	struct rdma_hw_stats *rdma_alloc_hw_stats_struct(const struct rdma_stat_desc *descs, int num_counters, unsigned long lifespan);
rdma_alloc_netdev	struct net_device *rdma_alloc_netdev(struct ib_device *device, u32 port_num, enum rdma_netdev_t type, const char *name, unsigned char name_assign_type, void (*setup)(struct net_device *));
rdma_bind_addr	int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr);
rdma_connect_ece	int rdma_connect_ece(struct rdma_cm_id *id, struct rdma_conn_param *conn_param, struct rdma_ucm_ece *ece);
rdma_copy_src_l2_addr	void rdma_copy_src_l2_addr(struct rdma_dev_addr *dev_addr, const struct net_device *dev);
rdma_create_ah	struct ib_ah *rdma_create_ah(struct ib_pd *pd, struct rdma_ah_attr *ah_attr, u32 flags);
rdma_create_user_ah	struct ib_ah *rdma_create_user_ah(struct ib_pd *pd, struct rdma_ah_attr *ah_attr, struct ib_udata *udata);
rdma_create_user_id	struct rdma_cm_id *rdma_create_user_id(rdma_cm_event_handler event_handler, void *context, enum rdma_ucm_port_space ps, enum ib_qp_type qp_type);
rdma_destroy_ah_attr	void rdma_destroy_ah_attr(struct rdma_ah_attr *ah_attr);
rdma_destroy_ah_user	int rdma_destroy_ah_user(struct ib_ah *ah, u32 flags, struct ib_udata *udata);
rdma_destroy_id	void rdma_destroy_id(struct rdma_cm_id *id);
rdma_dev_access_netns	bool rdma_dev_access_netns(const struct ib_device *dev, const struct net *net);
rdma_disconnect	int rdma_disconnect(struct rdma_cm_id *id);
rdma_find_gid	const struct ib_gid_attr *rdma_find_gid(struct ib_device *device, const union ib_gid *gid, enum ib_gid_type gid_type, struct net_device *ndev);
rdma_find_gid_by_port	const struct ib_gid_attr *rdma_find_gid_by_port(struct ib_device *ib_dev, const union ib_gid *gid, enum ib_gid_type gid_type, u32 port, struct net_device *ndev);
rdma_get_gid_attr	const struct ib_gid_attr *rdma_get_gid_attr(struct ib_device *device, u32 port_num, int index);
rdma_get_service_id	__be64 rdma_get_service_id(struct rdma_cm_id *id, struct sockaddr *addr);
rdma_init_netdev	int rdma_init_netdev(struct ib_device *device, u32 port_num, enum rdma_netdev_t type, const char *name, unsigned char name_assign_type, void (*setup)(struct net_device *), struct net_device *netdev);
rdma_init_qp_attr	int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr, int *qp_attr_mask);
rdma_join_multicast	int rdma_join_multicast(struct rdma_cm_id *id, struct sockaddr *addr, u8 join_state, void *context);
rdma_leave_multicast	void rdma_leave_multicast(struct rdma_cm_id *id, struct sockaddr *addr);
rdma_listen	int rdma_listen(struct rdma_cm_id *id, int backlog);
rdma_lock_handler	void rdma_lock_handler(struct rdma_cm_id *id);
rdma_move_ah_attr	void rdma_move_ah_attr(struct rdma_ah_attr *dest, struct rdma_ah_attr *src);
rdma_nl_multicast	int rdma_nl_multicast(struct net *net, struct sk_buff *skb, unsigned int group, gfp_t flags);
rdma_nl_put_driver_string	int rdma_nl_put_driver_string(struct sk_buff *msg, const char *name, const char *str);
rdma_nl_register	void rdma_nl_register(unsigned int index, const struct rdma_nl_cbs cb_table[]);
rdma_nl_stat_hwcounter_entry	int rdma_nl_stat_hwcounter_entry(struct sk_buff *msg, const char *name, u64 value);
rdma_nl_unicast	int rdma_nl_unicast(struct net *net, struct sk_buff *skb, u32 pid);
rdma_nl_unicast_wait	int rdma_nl_unicast_wait(struct net *net, struct sk_buff *skb, __u32 pid);
rdma_nl_unregister	void rdma_nl_unregister(unsigned int index);
rdma_node_get_transport	enum rdma_transport_type rdma_node_get_transport(unsigned int node_type);
rdma_notify	int rdma_notify(struct rdma_cm_id *id, enum ib_event_type event);
rdma_port_get_link_layer	enum rdma_link_layer rdma_port_get_link_layer(struct ib_device *device, u32 port_num);
rdma_put_gid_attr	void rdma_put_gid_attr(const struct ib_gid_attr *attr);
rdma_query_gid	int rdma_query_gid(struct ib_device *device, u32 port_num, int index, union ib_gid *gid);
rdma_query_gid_table	ssize_t rdma_query_gid_table(struct ib_device *device, struct ib_uverbs_gid_entry *entries, size_t max_entries);
rdma_read_gid_attr_ndev_rcu	struct net_device *rdma_read_gid_attr_ndev_rcu(const struct ib_gid_attr *attr);
rdma_read_gid_l2_fields	int rdma_read_gid_l2_fields(const struct ib_gid_attr *attr, u16 *vlan_id, u8 *smac);
rdma_read_gids	void rdma_read_gids(struct rdma_cm_id *cm_id, union ib_gid *sgid, union ib_gid *dgid);
rdma_reject	int rdma_reject(struct rdma_cm_id *id, const void *private_data, u8 private_data_len, u8 reason);
rdma_resolve_addr	int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr, const struct sockaddr *dst_addr, unsigned long timeout_ms);
rdma_resolve_ip	int rdma_resolve_ip(struct sockaddr *src_addr, const struct sockaddr *dst_addr, struct rdma_dev_addr *addr, unsigned long timeout_ms, void (*callback)(int status, struct sockaddr *src_addr, struct rdma_dev_addr *addr, void *context), bool resolve_by_gid_attr, void *context);
rdma_resolve_route	int rdma_resolve_route(struct rdma_cm_id *id, unsigned long timeout_ms);
rdma_restrack_add	void rdma_restrack_add(struct rdma_restrack_entry *res);
rdma_restrack_del	void rdma_restrack_del(struct rdma_restrack_entry *res);
rdma_restrack_get	int rdma_restrack_get(struct rdma_restrack_entry *res);
rdma_restrack_new	void rdma_restrack_new(struct rdma_restrack_entry *res, enum rdma_restrack_type type);
rdma_restrack_parent_name	void rdma_restrack_parent_name(struct rdma_restrack_entry *dst, const struct rdma_restrack_entry *parent);
rdma_restrack_put	int rdma_restrack_put(struct rdma_restrack_entry *res);
rdma_restrack_set_name	void rdma_restrack_set_name(struct rdma_restrack_entry *res, const char *caller);
rdma_roce_rescan_device	void rdma_roce_rescan_device(struct ib_device *ibdev);
rdma_set_ack_timeout	int rdma_set_ack_timeout(struct rdma_cm_id *id, u8 timeout);
rdma_set_afonly	int rdma_set_afonly(struct rdma_cm_id *id, int afonly);
rdma_set_cq_moderation	int rdma_set_cq_moderation(struct ib_cq *cq, u16 cq_count, u16 cq_period);
rdma_set_ib_path	int rdma_set_ib_path(struct rdma_cm_id *id, struct sa_path_rec *path_rec);
rdma_set_reuseaddr	int rdma_set_reuseaddr(struct rdma_cm_id *id, int reuse);
rdma_set_service_type	void rdma_set_service_type(struct rdma_cm_id *id, int tos);
rdma_translate_ip	int rdma_translate_ip(const struct sockaddr *addr, struct rdma_dev_addr *dev_addr);
rdma_umap_priv_init	void rdma_umap_priv_init(struct rdma_umap_priv *priv, struct vm_area_struct *vma, struct rdma_user_mmap_entry *entry);
rdma_unlock_handler	void rdma_unlock_handler(struct rdma_cm_id *id);
rdma_user_mmap_entry_get_pgoff	struct rdma_user_mmap_entry *rdma_user_mmap_entry_get_pgoff(struct ib_ucontext *ucontext, unsigned long pgoff);
rdma_user_mmap_entry_insert_range	int rdma_user_mmap_entry_insert_range(struct ib_ucontext *ucontext, struct rdma_user_mmap_entry *entry, size_t length, u32 min_pgoff, u32 max_pgoff);
rdma_user_mmap_entry_put	void rdma_user_mmap_entry_put(struct rdma_user_mmap_entry *entry);
rdma_user_mmap_entry_remove	void rdma_user_mmap_entry_remove(struct rdma_user_mmap_entry *entry);
rdma_user_mmap_io	int rdma_user_mmap_io(struct ib_ucontext *ucontext, struct vm_area_struct *vma, unsigned long pfn, unsigned long size, pgprot_t prot, struct rdma_user_mmap_entry *entry);
rdmacg_register_device	void rdmacg_register_device(struct rdmacg_device *device);
rdmacg_try_charge	int rdmacg_try_charge(struct rdma_cgroup **rdmacg, struct rdmacg_device *device, enum rdmacg_resource_type index);
rdmacg_uncharge	void rdmacg_uncharge(struct rdma_cgroup *cg, struct rdmacg_device *device, enum rdmacg_resource_type index);
rdmacg_unregister_device	void rdmacg_unregister_device(struct rdmacg_device *device);
refcount_dec_and_mutex_lock	bool refcount_dec_and_mutex_lock(refcount_t *r, struct mutex *lock);
refcount_dec_if_one	bool refcount_dec_if_one(refcount_t *r);
refcount_warn_saturate	void refcount_warn_saturate(refcount_t *r, enum refcount_saturation_type t);
register_acpi_notifier	int register_acpi_notifier(struct notifier_block *nb);
register_blocking_lsm_notifier	int register_blocking_lsm_notifier(struct notifier_block *nb);
register_chrdev_region	int register_chrdev_region(dev_t from, unsigned count, const char *name);
register_fib_notifier	int register_fib_notifier(struct net *net, struct notifier_block *nb, void (*cb)(struct notifier_block *nb), struct netlink_ext_ack *extack);
register_inet6addr_notifier	int register_inet6addr_notifier(struct notifier_block *nb);
register_inetaddr_notifier	int register_inetaddr_notifier(struct notifier_block *nb);
register_net_sysctl_sz	struct ctl_table_header *register_net_sysctl_sz(struct net *net, const char *path, struct ctl_table *table, size_t table_size);
register_netdev	int register_netdev(struct net_device *dev);
register_netdevice	int register_netdevice(struct net_device *dev);
register_netdevice_notifier	int register_netdevice_notifier(struct notifier_block *nb);
register_netdevice_notifier_dev_net	int register_netdevice_notifier_dev_net(struct net_device *dev, struct notifier_block *nb, struct netdev_net_notifier *nn);
register_netdevice_notifier_net	int register_netdevice_notifier_net(struct net *net, struct notifier_block *nb);
register_netevent_notifier	int register_netevent_notifier(struct notifier_block *nb);
register_pernet_device	int register_pernet_device(struct pernet_operations *ops);
register_pernet_subsys	int register_pernet_subsys(struct pernet_operations *ops);
register_reboot_notifier	int register_reboot_notifier(struct notifier_block *nb);
register_switchdev_blocking_notifier	int register_switchdev_blocking_notifier(struct notifier_block *nb);
register_switchdev_notifier	int register_switchdev_notifier(struct notifier_block *nb);
release_firmware	void release_firmware(const struct firmware *fw);
remap_pfn_range	int remap_pfn_range(struct vm_area_struct *vma, unsigned long addr, unsigned long pfn, unsigned long size, pgprot_t prot);
remap_vmalloc_range	int remap_vmalloc_range(struct vm_area_struct *vma, void *addr, unsigned long pgoff);
remove_proc_entry	void remove_proc_entry(const char *name, struct proc_dir_entry *parent);
remove_proc_subtree	int remove_proc_subtree(const char *name, struct proc_dir_entry *parent);
rep_stos_alternative	unsigned long rep_stos_alternative(void __user *addr, unsigned long len);		否
request_firmware	int request_firmware(const struct firmware **fw, const char *name, struct device *device);
request_firmware_direct	int request_firmware_direct(const struct firmware **fw, const char *name, struct device *device);
request_threaded_irq	int request_threaded_irq(unsigned int irq, irq_handler_t handler, irq_handler_t thread_fn, unsigned long irqflags, const char *devname, void *dev_id);
reserve_iova	struct iova *reserve_iova(struct iova_domain *iovad, unsigned long pfn_lo, unsigned long pfn_hi);
reset_devices	unsigned int reset_devices;
rhashtable_destroy	void rhashtable_destroy(struct rhashtable *ht);
rhashtable_free_and_destroy	void rhashtable_free_and_destroy(struct rhashtable *ht, void (*free_fn)(void *ptr, void *arg), void *arg);
rhashtable_init	int rhashtable_init(struct rhashtable *ht, const struct rhashtable_params *params);
rhashtable_insert_slow	void *rhashtable_insert_slow(struct rhashtable *ht, const void *key, struct rhash_head *obj);
rhashtable_walk_enter	void rhashtable_walk_enter(struct rhashtable *ht, struct rhashtable_iter *iter);
rhashtable_walk_exit	void rhashtable_walk_exit(struct rhashtable_iter *iter);
rhashtable_walk_next	void *rhashtable_walk_next(struct rhashtable_iter *iter);
rhashtable_walk_start_check	int rhashtable_walk_start_check(struct rhashtable_iter *iter);
rhashtable_walk_stop	void rhashtable_walk_stop(struct rhashtable_iter *iter);
rhltable_init	int rhltable_init(struct rhltable *hlt, const struct rhashtable_params *params);
rht_bucket_nested	struct rhash_lock_head __rcu **rht_bucket_nested(const struct bucket_table *tbl, unsigned int hash);
rht_bucket_nested_insert	struct rhash_lock_head **rht_bucket_nested_insert(struct rhashtable *ht, struct bucket_table *tbl, unsigned int hash);
roce_gid_type_mask_support	unsigned long roce_gid_type_mask_support(struct ib_device *ib_dev, u32 port);
round_jiffies	unsigned long round_jiffies(unsigned long j);
round_jiffies_relative	unsigned long round_jiffies_relative(unsigned long j);
rps_may_expire_flow	bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index, u32 flow_id, u16 filter_id);
rt6_lookup	struct rt6_info *rt6_lookup(struct net *net, const struct in6_addr *daddr, const struct in6_addr *saddr, int oif, const struct sk_buff *skb, int flags);
rtnl_is_locked	int rtnl_is_locked(void);
rtnl_link_register	int rtnl_link_register(struct rtnl_link_ops *ops);
rtnl_link_unregister	void rtnl_link_unregister(struct rtnl_link_ops *ops);
rtnl_lock	void rtnl_lock(void);
rtnl_trylock	int rtnl_trylock(void);
rtnl_unlock	void rtnl_unlock(void);
sas_attach_transport	struct scsi_transport_template * sas_attach_transport(struct sas_function_template *ft);
sas_end_device_alloc	struct sas_rphy *sas_end_device_alloc(struct sas_port *parent);
sas_expander_alloc	struct sas_rphy *sas_expander_alloc(struct sas_port *parent, enum sas_device_type type);
sas_phy_add	int sas_phy_add(struct sas_phy *phy);
sas_phy_alloc	struct sas_phy *sas_phy_alloc(struct device *parent, int number);
sas_phy_delete	void sas_phy_delete(struct sas_phy *phy);
sas_phy_free	void sas_phy_free(struct sas_phy *phy);
sas_port_add	int sas_port_add(struct sas_port *port);
sas_port_add_phy	void sas_port_add_phy(struct sas_port *port, struct sas_phy *phy);
sas_port_alloc_num	struct sas_port *sas_port_alloc_num(struct device *parent);
sas_port_delete	void sas_port_delete(struct sas_port *port);
sas_port_delete_phy	void sas_port_delete_phy(struct sas_port *port, struct sas_phy *phy);
sas_port_free	void sas_port_free(struct sas_port *port);
sas_release_transport	void sas_release_transport(struct scsi_transport_template *t);
sas_remove_host	void sas_remove_host(struct Scsi_Host *shost);
sas_rphy_add	int sas_rphy_add(struct sas_rphy *rphy);
sas_rphy_free	void sas_rphy_free(struct sas_rphy *rphy);
sched_clock	u64 sched_clock(void);
sched_numa_hop_mask	const struct cpumask *sched_numa_hop_mask(unsigned int node, unsigned int hops);
sched_set_fifo_low	void sched_set_fifo_low(struct task_struct *p);
schedule	void schedule(void);
schedule_timeout	long schedule_timeout(long timeout);
scnprintf	int scnprintf(char *buf, size_t size, const char *fmt, ...);
screen_info	struct screen_info screen_info;
scsi_add_device	int scsi_add_device(struct Scsi_Host *host, uint channel, uint target, u64 lun);
scsi_add_host_with_dma	int scsi_add_host_with_dma(struct Scsi_Host *shost, struct device *dev, struct device *dma_dev);
scsi_block_requests	void scsi_block_requests(struct Scsi_Host *shost);
scsi_build_sense	void scsi_build_sense(struct scsi_cmnd *scmd, int desc, u8 key, u8 asc, u8 ascq);
scsi_build_sense_buffer	void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq);
scsi_change_queue_depth	int scsi_change_queue_depth(struct scsi_device *sdev, int depth);
scsi_device_type	const char *scsi_device_type(unsigned type);
scsi_dma_map	int scsi_dma_map(struct scsi_cmnd *cmd);
scsi_dma_unmap	void scsi_dma_unmap(struct scsi_cmnd *cmd);
scsi_done	void scsi_done(struct scsi_cmnd *cmd);
scsi_host_alloc	struct Scsi_Host *scsi_host_alloc(const struct scsi_host_template *sht, int privsize);
scsi_host_busy	int scsi_host_busy(struct Scsi_Host *shost);
scsi_host_put	void scsi_host_put(struct Scsi_Host *shost);
scsi_is_host_device	int scsi_is_host_device(const struct device *dev);
scsi_normalize_sense	bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len, struct scsi_sense_hdr *sshdr);
scsi_print_command	void scsi_print_command(struct scsi_cmnd *cmd);
scsi_remove_device	void scsi_remove_device(struct scsi_device *sdev);
scsi_remove_host	void scsi_remove_host(struct Scsi_Host *shost);
scsi_remove_target	void scsi_remove_target(struct device *dev);
scsi_rescan_device	int scsi_rescan_device(struct scsi_device *sdev);
scsi_scan_host	void scsi_scan_host(struct Scsi_Host *shost);
scsi_scan_target	void scsi_scan_target(struct device *parent, unsigned int channel, unsigned int id, u64 lun, enum scsi_scan_mode rescan);
scsi_unblock_requests	void scsi_unblock_requests(struct Scsi_Host *shost);
sdev_prefix_printk	void sdev_prefix_printk(const char *level, const struct scsi_device *sdev, const char *name, const char *fmt, ...);
security_ib_alloc_security	int security_ib_alloc_security(void **sec);
security_ib_endport_manage_subnet	int security_ib_endport_manage_subnet(void *sec, const char *dev_name, u8 port_num);
security_ib_free_security	void security_ib_free_security(void *sec);
security_ib_pkey_access	int security_ib_pkey_access(void *sec, u64 subnet_prefix, u16 pkey);
seq_lseek	loff_t seq_lseek(struct file *file, loff_t offset, int whence);
seq_open	int seq_open(struct file *file, const struct seq_operations *op);
seq_printf	void seq_printf(struct seq_file *m, const char *fmt, ...);
seq_putc	void seq_putc(struct seq_file *m, char c);
seq_puts	void seq_puts(struct seq_file *m, const char *s);
seq_read	ssize_t seq_read(struct file *file, char __user *buf, size_t size, loff_t *ppos);
seq_read_iter	ssize_t seq_read_iter(struct kiocb *iocb, struct iov_iter *iter);
seq_release	int seq_release(struct inode *inode, struct file *file);
set_memory_uc	int set_memory_uc(unsigned long addr, int numpages);		否
set_memory_wb	int set_memory_wb(unsigned long addr, int numpages);		否
set_normalized_timespec64	void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec);
set_page_dirty	bool set_page_dirty(struct page *page);
set_page_dirty_lock	int set_page_dirty_lock(struct page *page);
set_pages_array_uc	int set_pages_array_uc(struct page **pages, int numpages);		否
set_pages_array_wb	int set_pages_array_wb(struct page **pages, int numpages);		否
sg_alloc_append_table_from_pages	int sg_alloc_append_table_from_pages(struct sg_append_table *sgt, struct page **pages, unsigned int n_pages, unsigned int offset, unsigned long size, unsigned int max_segment, unsigned int left_pages, gfp_t gfp_mask);
sg_copy_from_buffer	size_t sg_copy_from_buffer(struct scatterlist *sgl, unsigned int nents, const void *buf, size_t buflen);
sg_copy_to_buffer	size_t sg_copy_to_buffer(struct scatterlist *sgl, unsigned int nents, void *buf, size_t buflen);
sg_free_append_table	void sg_free_append_table(struct sg_append_table *sgt);
sg_free_table	void sg_free_table(struct sg_table *table);
sg_next	struct scatterlist *sg_next(struct scatterlist *sg);
sg_pcopy_to_buffer	size_t sg_pcopy_to_buffer(struct scatterlist *sgl, unsigned int nents, void *buf, size_t buflen, off_t skip);
show_class_attr_string	ssize_t show_class_attr_string(const struct class *class, const struct class_attribute *attr, char *buf);
simple_attr_open	int simple_attr_open(struct inode *inode, struct file *file, int (*get)(void *, u64 *), int (*set)(void *, u64), const char *fmt);
simple_attr_release	int simple_attr_release(struct inode *inode, struct file *file);
simple_open	int simple_open(struct inode *inode, struct file *file);
simple_read_from_buffer	ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos, const void *from, size_t available);
simple_strtoul	unsigned long simple_strtoul(const char *cp, char **endp, unsigned int base);
simple_write_to_buffer	ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos, const void __user *from, size_t count);
single_open	int single_open(struct file , int ()(struct seq_file *, void *), void *);
single_release	int single_release(struct inode *, struct file *);
skb_add_rx_frag	void skb_add_rx_frag(struct sk_buff *skb, int i, struct page *page, int off, int size, unsigned int truesize);
skb_checksum	__wsum skb_checksum(const struct sk_buff *skb, int offset, int len, __wsum csum);
skb_checksum_help	int skb_checksum_help(struct sk_buff *skb);
skb_clone_tx_timestamp	void skb_clone_tx_timestamp(struct sk_buff *skb);
skb_copy_bits	int skb_copy_bits(const struct sk_buff *skb, int offset, void *to, int len);
skb_dequeue	struct sk_buff *skb_dequeue(struct sk_buff_head *list);
skb_ext_add	void *skb_ext_add(struct sk_buff *skb, enum skb_ext_id id);
skb_pull	void *skb_pull(struct sk_buff *skb, unsigned int len);
skb_push	void *skb_push(struct sk_buff *skb, unsigned int len);
skb_put	void *skb_put(struct sk_buff *skb, unsigned int len);
skb_queue_tail	void skb_queue_tail(struct sk_buff_head *list, struct sk_buff *newsk);
skb_trim	void skb_trim(struct sk_buff *skb, unsigned int len);
skb_tstamp_tx	void skb_tstamp_tx(struct sk_buff *orig_skb, struct skb_shared_hwtstamps *hwtstamps);
skb_vlan_pop	int skb_vlan_pop(struct sk_buff *skb);
sme_me_mask	u64 sme_me_mask;		否
snprintf	int snprintf(char *buf, size_t size, const char *fmt, ...);
sock_gen_put	void sock_gen_put(struct sock *sk);
softnet_data	DEFINE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
sort	void sort(void *base, size_t num, size_t size, cmp_func_t cmp_func, swap_func_t swap_func);
sprintf	int sprintf(char *buf, const char *fmt, ...);
sscanf	int sscanf(const char *, const char *, ...);
starget_for_each_device	void starget_for_each_device(struct scsi_target *, void *, void (*fn)(struct scsi_device *, void *));
static_key_count	int static_key_count(struct static_key *key);
static_key_disable	void static_key_disable(struct static_key *key);
static_key_enable	void static_key_enable(struct static_key *key);
stream_open	int stream_open(struct inode *inode, struct file *filp);
switchdev_handle_port_attr_set	int switchdev_handle_port_attr_set(struct net_device *dev, struct switchdev_notifier_port_attr_info *port_attr_info, bool (*check_cb)(const struct net_device *dev), int (*set_cb)(struct net_device *dev, const void *ctx, const struct switchdev_attr *attr, struct netlink_ext_ack *extack));
switchdev_handle_port_obj_add	int switchdev_handle_port_obj_add(struct net_device *dev, struct switchdev_notifier_port_obj_info *port_obj_info, bool (*check_cb)(const struct net_device *dev), int (*add_cb)(struct net_device *dev, const void *ctx, const struct switchdev_obj *obj, struct netlink_ext_ack *extack));
switchdev_handle_port_obj_del	int switchdev_handle_port_obj_del(struct net_device *dev, struct switchdev_notifier_port_obj_info *port_obj_info, bool (*check_cb)(const struct net_device *dev), int (*del_cb)(struct net_device *dev, const void *ctx, const struct switchdev_obj *obj));
synchronize_irq	void synchronize_irq(unsigned int irq);
synchronize_net	void synchronize_net(void);
synchronize_rcu	void synchronize_rcu(void);
synchronize_srcu	void synchronize_srcu(struct srcu_struct *ssp);
sys_tz	struct timezone sys_tz;
sysfs_add_file_to_group	int sysfs_add_file_to_group(struct kobject *kobj, const struct attribute *attr, const char *group);
sysfs_create_file_ns	int sysfs_create_file_ns(struct kobject *kobj, const struct attribute *attr, const void *ns);
sysfs_create_group	int sysfs_create_group(struct kobject *kobj, const struct attribute_group *grp);
sysfs_create_groups	int sysfs_create_groups(struct kobject *kobj, const struct attribute_group **groups);
sysfs_emit	int sysfs_emit(char *buf, const char *fmt, ...);
sysfs_remove_file_ns	void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr, const void *ns);
sysfs_remove_group	void sysfs_remove_group(struct kobject *kobj, const struct attribute_group *grp);
sysfs_remove_groups	void sysfs_remove_groups(struct kobject *kobj, const struct attribute_group **groups);
sysfs_streq	bool sysfs_streq(const char *s1, const char *s2);
system_state	enum system_states system_state
system_unbound_wq	struct workqueue_struct *system_unbound_wq
system_wq	struct workqueue_struct *system_wq;
tasklet_setup	void tasklet_setup(struct tasklet_struct *t, void (*callback)(struct tasklet_struct *));
tasklet_unlock_wait	void tasklet_unlock_wait(struct tasklet_struct *t);
tcp_gro_complete	void tcp_gro_complete(struct sk_buff *skb);
this_cpu_off	DEFINE_PER_CPU_READ_MOSTLY(unsigned long, this_cpu_off)		否
time64_to_tm	void time64_to_tm(time64_t totalsecs, int offset, struct tm *result);
timecounter_cyc2time	u64 timecounter_cyc2time(const struct timecounter *tc, u64 cycle_tstamp);
timecounter_init	void timecounter_init(struct timecounter *tc, const struct cyclecounter *cc, u64 start_tstamp);
timecounter_read	u64 timecounter_read(struct timecounter *tc);
timer_delete	int timer_delete(struct timer_list *timer);
timer_delete_sync	int timer_delete_sync(struct timer_list *timer);
tls_get_record	struct tls_record_info *tls_get_record(struct tls_offload_context_tx *context, u32 seq, u64 *p_record_sn);
tls_validate_xmit_skb	struct sk_buff *tls_validate_xmit_skb(struct sock *sk, struct net_device *dev, struct sk_buff *skb);
trace_event_buffer_commit	void trace_event_buffer_commit(struct trace_event_buffer *fbuffer);
trace_event_buffer_reserve	void *trace_event_buffer_reserve(struct trace_event_buffer *fbuffer, struct trace_event_file *trace_file, unsigned long len);
trace_event_printf	void trace_event_printf(struct trace_iterator *iter, const char *fmt, ...);
trace_event_raw_init	int trace_event_raw_init(struct trace_event_call *call);
trace_event_reg	int trace_event_reg(struct trace_event_call *event, enum trace_reg type, void *data);
trace_handle_return	enum print_line_t trace_handle_return(struct trace_seq *s);
trace_print_flags_seq	const char *trace_print_flags_seq(struct trace_seq *p, const char *delim, unsigned long flags, const struct trace_print_flags *flag_array);
trace_print_symbols_seq	const char *trace_print_symbols_seq(struct trace_seq *p, unsigned long val, const struct trace_print_flags *symbol_array);
trace_raw_output_prep	int trace_raw_output_prep(struct trace_iterator *iter, struct trace_event *event);
trace_seq_printf	void trace_seq_printf(struct trace_seq *s, const char *fmt, ...);
trace_seq_putc	void trace_seq_putc(struct trace_seq *s, unsigned char c);
try_module_get	bool try_module_get(struct module *module);
tty_buffer_request_room	int tty_buffer_request_room(struct tty_port *port, size_t size);
tty_driver_kref_put	void tty_driver_kref_put(struct tty_driver *driver);
tty_flip_buffer_push	void tty_flip_buffer_push(struct tty_port *port);
tty_port_destroy	void tty_port_destroy(struct tty_port *port);
tty_port_init	void tty_port_init(struct tty_port *port);
tty_port_link_device	void tty_port_link_device(struct tty_port *port, struct tty_driver *driver, unsigned index);
tty_register_driver	int tty_register_driver(struct tty_driver *driver);
tty_std_termios	struct ktermios tty_std_termios;
tty_termios_encode_baud_rate	void tty_termios_encode_baud_rate(struct ktermios *termios, speed_t ibaud, speed_t obaud);
tty_unregister_driver	void tty_unregister_driver(struct tty_driver *driver);
udp_tunnel_nic_ops	const struct udp_tunnel_nic_ops *udp_tunnel_nic_ops;
udp4_hwcsum	void udp4_hwcsum(struct sk_buff *skb, __be32 src, __be32 dst);
unlock_page	void unlock_page(struct page *page);
unmap_mapping_range	void unmap_mapping_range(struct address_space *mapping, loff_t const holebegin, loff_t const holelen, int even_cows);
unpin_user_page	void unpin_user_page(struct page *page);
unpin_user_page_range_dirty_lock	void unpin_user_page_range_dirty_lock(struct page *page, unsigned long npages, bool make_dirty);
unpin_user_pages_dirty_lock	void unpin_user_pages_dirty_lock(struct page **pages, unsigned long npages, bool make_dirty);
unregister_acpi_notifier	int unregister_acpi_notifier(struct notifier_block *nb);
unregister_blocking_lsm_notifier	int unregister_blocking_lsm_notifier(struct notifier_block *nb);
unregister_chrdev_region	void unregister_chrdev_region(dev_t, unsigned);
unregister_fib_notifier	int unregister_fib_notifier(struct net *net, struct notifier_block *nb);
unregister_inet6addr_notifier	int unregister_inet6addr_notifier(struct notifier_block *nb);
unregister_inetaddr_notifier	int unregister_inetaddr_notifier(struct notifier_block *nb);
unregister_net_sysctl_table	void unregister_net_sysctl_table(struct ctl_table_header *header);
unregister_netdev	void unregister_netdev(struct net_device *dev);
unregister_netdevice_many	void unregister_netdevice_many(struct list_head *head);
unregister_netdevice_notifier	int unregister_netdevice_notifier(struct notifier_block *nb);
unregister_netdevice_notifier_dev_net	int unregister_netdevice_notifier_dev_net(struct net_device *dev, struct notifier_block *nb, struct netdev_net_notifier *nn);
unregister_netdevice_notifier_net	int unregister_netdevice_notifier_net(struct net *net, struct notifier_block *nb);
unregister_netdevice_queue	void unregister_netdevice_queue(struct net_device *dev, struct list_head *head);
unregister_netevent_notifier	int unregister_netevent_notifier(struct notifier_block *nb);
unregister_pernet_device	void unregister_pernet_device(struct pernet_operations *ops);
unregister_pernet_subsys	void unregister_pernet_subsys(struct pernet_operations *ops);
unregister_reboot_notifier	int unregister_reboot_notifier(struct notifier_block *nb);
unregister_switchdev_blocking_notifier	int unregister_switchdev_blocking_notifier(struct notifier_block *nb);
unregister_switchdev_notifier	int unregister_switchdev_notifier(struct notifier_block *nb);
up	void up(struct semaphore *sem);
up_read	void up_read(struct rw_semaphore *sem);
up_write	void up_write(struct rw_semaphore *sem);
usleep_range_state	void usleep_range_state(unsigned long min, unsigned long max, unsigned int state);
uverbs_copy_to	int uverbs_copy_to(const struct uverbs_attr_bundle *bundle, size_t idx, const void *from, size_t size);
uverbs_copy_to_struct_or_zero	int uverbs_copy_to_struct_or_zero(const struct uverbs_attr_bundle *bundle, size_t idx, const void *from, size_t size);
uverbs_destroy_def_handler	int uverbs_destroy_def_handler(struct uverbs_attr_bundle *attrs);
uverbs_fd_class	const struct uverbs_obj_type_class uverbs_fd_class;
uverbs_finalize_uobj_create	void uverbs_finalize_uobj_create(const struct uverbs_attr_bundle *attrs_bundle, u16 idx);
uverbs_get_flags32	int uverbs_get_flags32(u32 *to, const struct uverbs_attr_bundle *attrs_bundle, size_t idx, u64 allowed_bits);
uverbs_idr_class	const struct uverbs_obj_type_class uverbs_idr_class;
uverbs_uobject_fd_release	int uverbs_uobject_fd_release(struct inode *inode, struct file *filp);
uverbs_uobject_put	void uverbs_uobject_put(struct ib_uobject *uobject);
vfio_info_add_capability	int vfio_info_add_capability(struct vfio_info_cap *caps, struct vfio_info_cap_header *cap, size_t size);
vfio_info_cap_shift	void vfio_info_cap_shift(struct vfio_info_cap *caps, size_t offset);
vfio_pin_pages	int vfio_pin_pages(struct vfio_device *device, dma_addr_t iova, int npage, int prot, struct page **pages);
vfio_set_irqs_validate_and_prepare	int vfio_set_irqs_validate_and_prepare(struct vfio_irq_set *hdr, int num_irqs, int max_irq_type, size_t *data_size);
vfio_unpin_pages	void vfio_unpin_pages(struct vfio_device *device, dma_addr_t iova, int npage);
vfio_virqfd_disable	void vfio_virqfd_disable(struct virqfd **pvirqfd);
vfio_virqfd_enable	int vfio_virqfd_enable(void *opaque, int (*handler)(void *, void *), void (*thread)(void *, void *), void *data, struct virqfd **pvirqfd, int fd);
vfree	void vfree(const void *addr);
vfs_getattr	int vfs_getattr(const struct path *path, struct kstat *stat, u32 request_mask, unsigned int query_flags);
vga_set_legacy_decoding	void vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes);
vlan_dev_real_dev	struct net_device *vlan_dev_real_dev(const struct net_device *dev);
vlan_dev_vlan_id	u16 vlan_dev_vlan_id(const struct net_device *dev);
vlan_dev_vlan_proto	__be16 vlan_dev_vlan_proto(const struct net_device *dev);
vm_get_page_prot	pgprot_t vm_get_page_prot(unsigned long vm_flags);
vm_insert_page	int vm_insert_page(struct vm_area_struct *vma, unsigned long addr, struct page *page);
vmalloc	void *vmalloc(unsigned long size);
vmalloc_to_page	struct page *vmalloc_to_page(const void *addr);
vmalloc_user	void *vmalloc_user(unsigned long size);
vmap	void *vmap(struct page **pages, unsigned int count, unsigned long flags, pgprot_t prot);
vmemmap_base	unsigned long vmemmap_base;		否
vmf_insert_pfn	vm_fault_t vmf_insert_pfn(struct vm_area_struct *vma, unsigned long addr, unsigned long pfn);
vmf_insert_pfn_prot	vm_fault_t vmf_insert_pfn_prot(struct vm_area_struct *vma, unsigned long addr, unsigned long pfn, pgprot_t pgprot);
vprintk	int vprintk(const char *s, va_list args);
vscnprintf	int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
vsnprintf	int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
vunmap	void vunmap(const void *addr);
vzalloc	void *vzalloc(unsigned long size);
wait_for_completion	void wait_for_completion(struct completion *);
wait_for_completion_interruptible	int wait_for_completion_interruptible(struct completion *x);
wait_for_completion_io_timeout	unsigned long wait_for_completion_io_timeout(struct completion *x, unsigned long timeout);
wait_for_completion_timeout	unsigned long wait_for_completion_timeout(struct completion *x, unsigned long timeout);
wait_for_random_bytes	int wait_for_random_bytes(void);
wake_up_bit	void wake_up_bit(void *word, int bit);
wake_up_process	int wake_up_process(struct task_struct *tsk);
ww_mutex_lock	int ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx);
ww_mutex_unlock	void ww_mutex_unlock(struct ww_mutex *lock);
xa_clear_mark	void xa_clear_mark(struct xarray *xa, unsigned long index, xa_mark_t mark);
xa_destroy	void xa_destroy(struct xarray *xa);
xa_erase	void *xa_erase(struct xarray *xa, unsigned long index);
xa_find	void *xa_find(struct xarray *xa, unsigned long *index, unsigned long max, xa_mark_t);
xa_find_after	void *xa_find_after(struct xarray *xa, unsigned long *index, unsigned long max, xa_mark_t);
xa_get_mark	bool xa_get_mark(struct xarray *xa, unsigned long index, xa_mark_t mark);
xa_load	void *xa_load(struct xarray *xa, unsigned long index);
xa_set_mark	void xa_set_mark(struct xarray *xa, unsigned long index, xa_mark_t mark);
xa_store	void *xa_store(struct xarray *xa, unsigned long index, void *entry, gfp_t gfp);
xas_find	void *xas_find(struct xa_state *xas, unsigned long max);
xas_find_marked	void *xas_find_marked(struct xa_state *xas, unsigned long max, xa_mark_t mark);
xas_load	void *xas_load(struct xa_state *xas);
xas_nomem	bool xas_nomem(struct xa_state *xas, gfp_t gfp);
xas_store	void *xas_store(struct xa_state *xas, void *entry);
xdp_convert_zc_to_xdp_frame	struct xdp_frame *xdp_convert_zc_to_xdp_frame(struct xdp_buff *xdp);
xdp_do_flush	void xdp_do_flush(void);
xdp_do_redirect	int xdp_do_redirect(struct net_device *dev, struct xdp_buff *xdp, struct bpf_prog *prog);
xdp_features_clear_redirect_target	void xdp_features_clear_redirect_target(struct net_device *dev);
xdp_features_set_redirect_target	void xdp_features_set_redirect_target(struct net_device *dev, bool support_sg);
xdp_flush_frame_bulk	void xdp_flush_frame_bulk(struct xdp_frame_bulk *bq);
xdp_master_redirect	u32 xdp_master_redirect(struct xdp_buff *xdp);
xdp_return_buff	void xdp_return_buff(struct xdp_buff *xdp);
xdp_return_frame	void xdp_return_frame(struct xdp_frame *xdpf);
xdp_return_frame_bulk	void xdp_return_frame_bulk(struct xdp_frame *xdpf, struct xdp_frame_bulk *bq);
xdp_return_frame_rx_napi	void xdp_return_frame_rx_napi(struct xdp_frame *xdpf);
xdp_rxq_info_is_reg	bool xdp_rxq_info_is_reg(struct xdp_rxq_info *xdp_rxq);
xdp_rxq_info_reg_mem_model	int xdp_rxq_info_reg_mem_model(struct xdp_rxq_info *xdp_rxq, enum xdp_mem_type type, void *allocator);
xdp_rxq_info_unreg	void xdp_rxq_info_unreg(struct xdp_rxq_info *xdp_rxq);
xdp_rxq_info_unreg_mem_model	void xdp_rxq_info_unreg_mem_model(struct xdp_rxq_info *xdp_rxq);
xdp_rxq_info_unused	void xdp_rxq_info_unused(struct xdp_rxq_info *xdp_rxq);
xdp_set_features_flag	void xdp_set_features_flag(struct net_device *dev, xdp_features_t val);
xdp_warn	void xdp_warn(const char *msg, const char *func, const int line);
xp_alloc	struct xdp_buff *xp_alloc(struct xsk_buff_pool *pool);
xp_alloc_batch	u32 xp_alloc_batch(struct xsk_buff_pool *pool, struct xdp_buff **xdp, u32 max);
xp_can_alloc	bool xp_can_alloc(struct xsk_buff_pool *pool, u32 count);
xp_dma_map	int xp_dma_map(struct xsk_buff_pool *pool, struct device *dev, unsigned long attrs, struct page **pages, u32 nr_pages);
xp_dma_sync_for_cpu_slow	void xp_dma_sync_for_cpu_slow(struct xdp_buff_xsk *xskb);
xp_dma_sync_for_device_slow	void xp_dma_sync_for_device_slow(struct xsk_buff_pool *pool, dma_addr_t dma, size_t size);
xp_dma_unmap	void xp_dma_unmap(struct xsk_buff_pool *pool, unsigned long attrs);
xp_free	void xp_free(struct xdp_buff_xsk *xskb);
xp_raw_get_data	void *xp_raw_get_data(struct xsk_buff_pool *pool, u64 addr);
xp_raw_get_dma	dma_addr_t xp_raw_get_dma(struct xsk_buff_pool *pool, u64 addr);
xp_set_rxq_info	void xp_set_rxq_info(struct xsk_buff_pool *pool, struct xdp_rxq_info *rxq);
xsk_clear_rx_need_wakeup	void xsk_clear_rx_need_wakeup(struct xsk_buff_pool *pool);
xsk_clear_tx_need_wakeup	void xsk_clear_tx_need_wakeup(struct xsk_buff_pool *pool);
xsk_get_pool_from_qid	struct xsk_buff_pool *xsk_get_pool_from_qid(struct net_device *dev, u16 queue_id);
xsk_set_rx_need_wakeup	void xsk_set_rx_need_wakeup(struct xsk_buff_pool *pool);
xsk_set_tx_need_wakeup	void xsk_set_tx_need_wakeup(struct xsk_buff_pool *pool);
xsk_tx_completed	void xsk_tx_completed(struct xsk_buff_pool *pool, u32 nb_entries);
xsk_tx_peek_desc	bool xsk_tx_peek_desc(struct xsk_buff_pool *pool, struct xdp_desc *desc);
xsk_tx_release	void xsk_tx_release(struct xsk_buff_pool *pool);
xsk_uses_need_wakeup	bool xsk_uses_need_wakeup(struct xsk_buff_pool *pool);
xz_dec_end	void xz_dec_end(struct xz_dec *s);
xz_dec_init	struct xz_dec *xz_dec_init(enum xz_mode mode, uint32_t dict_max);
xz_dec_run	enum xz_ret xz_dec_run(struct xz_dec *s, struct xz_buf *b);
zap_vma_ptes	void zap_vma_ptes(struct vm_area_struct *vma, unsigned long address, unsigned long size);
get_user_pages	long get_user_pages(unsigned long start, unsigned long nr_pages, unsigned int gup_flags, struct page **pages);
drm_vblank_init	int drm_vblank_init(struct drm_device *dev, unsigned int num_crtcs);
dma_resv_init	void dma_resv_init(struct dma_resv *obj);
acpi_bus_register_driver	int acpi_bus_register_driver(struct acpi_driver *driver);
acpi_bus_unregister_driver	void acpi_bus_unregister_driver(struct acpi_driver *driver);