// SPDX-License-Identifier: GPL-2.0-or-later /* * INET An implementation of the TCP/IP protocol suite for the LINUX * operating system. INET is implemented using the BSD Socket * interface as the means of communication with the user level. * * Routing netlink socket interface: protocol independent part. * * Authors: Alexey Kuznetsov, <[email protected]> * * Fixes: * Vitaly E. Lavrov RTA_OK arithmetic was wrong. */ #include <linux/bitops.h> #include <linux/errno.h> #include <linux/module.h> #include <linux/types.h> #include <linux/socket.h> #include <linux/kernel.h> #include <linux/timer.h> #include <linux/string.h> #include <linux/sockios.h> #include <linux/net.h> #include <linux/fcntl.h> #include <linux/mm.h> #include <linux/slab.h> #include <linux/interrupt.h> #include <linux/capability.h> #include <linux/skbuff.h> #include <linux/init.h> #include <linux/security.h> #include <linux/mutex.h> #include <linux/if_addr.h> #include <linux/if_bridge.h> #include <linux/if_vlan.h> #include <linux/pci.h> #include <linux/etherdevice.h> #include <linux/bpf.h> #include <linux/uaccess.h> #include <linux/inet.h> #include <linux/netdevice.h> #include <net/ip.h> #include <net/protocol.h> #include <net/arp.h> #include <net/route.h> #include <net/udp.h> #include <net/tcp.h> #include <net/sock.h> #include <net/pkt_sched.h> #include <net/fib_rules.h> #include <net/rtnetlink.h> #include <net/net_namespace.h> #include <net/devlink.h> #if IS_ENABLED(CONFIG_IPV6) #include <net/addrconf.h> #endif #include <linux/dpll.h> #include "dev.h" #define RTNL_MAX_TYPE … #define RTNL_SLAVE_MAX_TYPE … struct rtnl_link { … }; static DEFINE_MUTEX(rtnl_mutex); void rtnl_lock(void) { … } EXPORT_SYMBOL(…); int rtnl_lock_killable(void) { … } EXPORT_SYMBOL(…); static struct sk_buff *defer_kfree_skb_list; void rtnl_kfree_skbs(struct sk_buff *head, struct sk_buff *tail) { … } EXPORT_SYMBOL(…); void __rtnl_unlock(void) { … } void rtnl_unlock(void) { … } EXPORT_SYMBOL(…); int rtnl_trylock(void) { … } EXPORT_SYMBOL(…); int rtnl_is_locked(void) { … } EXPORT_SYMBOL(…); bool refcount_dec_and_rtnl_lock(refcount_t *r) { … } EXPORT_SYMBOL(…); #ifdef CONFIG_PROVE_LOCKING bool lockdep_rtnl_is_held(void) { … } EXPORT_SYMBOL(…); #endif /* #ifdef CONFIG_PROVE_LOCKING */ static struct rtnl_link __rcu *__rcu *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1]; static inline int rtm_msgindex(int msgtype) { … } static struct rtnl_link *rtnl_get_link(int protocol, int msgtype) { … } static int rtnl_register_internal(struct module *owner, int protocol, int msgtype, rtnl_doit_func doit, rtnl_dumpit_func dumpit, unsigned int flags) { … } /** * rtnl_register_module - Register a rtnetlink message type * * @owner: module registering the hook (THIS_MODULE) * @protocol: Protocol family or PF_UNSPEC * @msgtype: rtnetlink message type * @doit: Function pointer called for each request message * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message * @flags: rtnl_link_flags to modify behaviour of doit/dumpit functions * * Like rtnl_register, but for use by removable modules. */ int rtnl_register_module(struct module *owner, int protocol, int msgtype, rtnl_doit_func doit, rtnl_dumpit_func dumpit, unsigned int flags) { … } EXPORT_SYMBOL_GPL(…); /** * rtnl_register - Register a rtnetlink message type * @protocol: Protocol family or PF_UNSPEC * @msgtype: rtnetlink message type * @doit: Function pointer called for each request message * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message * @flags: rtnl_link_flags to modify behaviour of doit/dumpit functions * * Registers the specified function pointers (at least one of them has * to be non-NULL) to be called whenever a request message for the * specified protocol family and message type is received. * * The special protocol family PF_UNSPEC may be used to define fallback * function pointers for the case when no entry for the specific protocol * family exists. */ void rtnl_register(int protocol, int msgtype, rtnl_doit_func doit, rtnl_dumpit_func dumpit, unsigned int flags) { … } /** * rtnl_unregister - Unregister a rtnetlink message type * @protocol: Protocol family or PF_UNSPEC * @msgtype: rtnetlink message type * * Returns 0 on success or a negative error code. */ int rtnl_unregister(int protocol, int msgtype) { … } EXPORT_SYMBOL_GPL(…); /** * rtnl_unregister_all - Unregister all rtnetlink message type of a protocol * @protocol : Protocol family or PF_UNSPEC * * Identical to calling rtnl_unregster() for all registered message types * of a certain protocol family. */ void rtnl_unregister_all(int protocol) { … } EXPORT_SYMBOL_GPL(…); static LIST_HEAD(link_ops); static const struct rtnl_link_ops *rtnl_link_ops_get(const char *kind) { … } /** * __rtnl_link_register - Register rtnl_link_ops with rtnetlink. * @ops: struct rtnl_link_ops * to register * * The caller must hold the rtnl_mutex. This function should be used * by drivers that create devices during module initialization. It * must be called before registering the devices. * * Returns 0 on success or a negative error code. */ int __rtnl_link_register(struct rtnl_link_ops *ops) { … } EXPORT_SYMBOL_GPL(…); /** * rtnl_link_register - Register rtnl_link_ops with rtnetlink. * @ops: struct rtnl_link_ops * to register * * Returns 0 on success or a negative error code. */ int rtnl_link_register(struct rtnl_link_ops *ops) { … } EXPORT_SYMBOL_GPL(…); static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops) { … } /** * __rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink. * @ops: struct rtnl_link_ops * to unregister * * The caller must hold the rtnl_mutex and guarantee net_namespace_list * integrity (hold pernet_ops_rwsem for writing to close the race * with setup_net() and cleanup_net()). */ void __rtnl_link_unregister(struct rtnl_link_ops *ops) { … } EXPORT_SYMBOL_GPL(…); /* Return with the rtnl_lock held when there are no network * devices unregistering in any network namespace. */ static void rtnl_lock_unregistering_all(void) { … } /** * rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink. * @ops: struct rtnl_link_ops * to unregister */ void rtnl_link_unregister(struct rtnl_link_ops *ops) { … } EXPORT_SYMBOL_GPL(…); static size_t rtnl_link_get_slave_info_data_size(const struct net_device *dev) { … } static size_t rtnl_link_get_size(const struct net_device *dev) { … } static LIST_HEAD(rtnl_af_ops); static const struct rtnl_af_ops *rtnl_af_lookup(const int family) { … } /** * rtnl_af_register - Register rtnl_af_ops with rtnetlink. * @ops: struct rtnl_af_ops * to register * * Returns 0 on success or a negative error code. */ void rtnl_af_register(struct rtnl_af_ops *ops) { … } EXPORT_SYMBOL_GPL(…); /** * rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink. * @ops: struct rtnl_af_ops * to unregister */ void rtnl_af_unregister(struct rtnl_af_ops *ops) { … } EXPORT_SYMBOL_GPL(…); static size_t rtnl_link_get_af_size(const struct net_device *dev, u32 ext_filter_mask) { … } static bool rtnl_have_link_slave_info(const struct net_device *dev) { … } static int rtnl_link_slave_info_fill(struct sk_buff *skb, const struct net_device *dev) { … } static int rtnl_link_info_fill(struct sk_buff *skb, const struct net_device *dev) { … } static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev) { … } int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo) { … } int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid) { … } EXPORT_SYMBOL(…); void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group, const struct nlmsghdr *nlh, gfp_t flags) { … } EXPORT_SYMBOL(…); void rtnl_set_sk_err(struct net *net, u32 group, int error) { … } EXPORT_SYMBOL(…); int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics) { … } EXPORT_SYMBOL(…); int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id, long expires, u32 error) { … } EXPORT_SYMBOL_GPL(…); void netdev_set_operstate(struct net_device *dev, int newstate) { … } EXPORT_SYMBOL(…); static void set_operstate(struct net_device *dev, unsigned char transition) { … } static unsigned int rtnl_dev_get_flags(const struct net_device *dev) { … } static unsigned int rtnl_dev_combine_flags(const struct net_device *dev, const struct ifinfomsg *ifm) { … } static void copy_rtnl_link_stats(struct rtnl_link_stats *a, const struct rtnl_link_stats64 *b) { … } /* All VF info */ static inline int rtnl_vfinfo_size(const struct net_device *dev, u32 ext_filter_mask) { … } static size_t rtnl_port_size(const struct net_device *dev, u32 ext_filter_mask) { … } static size_t rtnl_xdp_size(void) { … } static size_t rtnl_prop_list_size(const struct net_device *dev) { … } static size_t rtnl_proto_down_size(const struct net_device *dev) { … } static size_t rtnl_devlink_port_size(const struct net_device *dev) { … } static size_t rtnl_dpll_pin_size(const struct net_device *dev) { … } static noinline size_t if_nlmsg_size(const struct net_device *dev, u32 ext_filter_mask) { … } static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev) { … } static int rtnl_port_self_fill(struct sk_buff *skb, struct net_device *dev) { … } static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev, u32 ext_filter_mask) { … } static int rtnl_phys_port_id_fill(struct sk_buff *skb, struct net_device *dev) { … } static int rtnl_phys_port_name_fill(struct sk_buff *skb, struct net_device *dev) { … } static int rtnl_phys_switch_id_fill(struct sk_buff *skb, struct net_device *dev) { … } static noinline_for_stack int rtnl_fill_stats(struct sk_buff *skb, struct net_device *dev) { … } static noinline_for_stack int rtnl_fill_vfinfo(struct sk_buff *skb, struct net_device *dev, int vfs_num, u32 ext_filter_mask) { … } static noinline_for_stack int rtnl_fill_vf(struct sk_buff *skb, struct net_device *dev, u32 ext_filter_mask) { … } static int rtnl_fill_link_ifmap(struct sk_buff *skb, const struct net_device *dev) { … } static u32 rtnl_xdp_prog_skb(struct net_device *dev) { … } static u32 rtnl_xdp_prog_drv(struct net_device *dev) { … } static u32 rtnl_xdp_prog_hw(struct net_device *dev) { … } static int rtnl_xdp_report_one(struct sk_buff *skb, struct net_device *dev, u32 *prog_id, u8 *mode, u8 tgt_mode, u32 attr, u32 (*get_prog_id)(struct net_device *dev)) { … } static int rtnl_xdp_fill(struct sk_buff *skb, struct net_device *dev) { … } static u32 rtnl_get_event(unsigned long event) { … } static int put_master_ifindex(struct sk_buff *skb, struct net_device *dev) { … } static int nla_put_iflink(struct sk_buff *skb, const struct net_device *dev, bool force) { … } static noinline_for_stack int nla_put_ifalias(struct sk_buff *skb, struct net_device *dev) { … } static int rtnl_fill_link_netnsid(struct sk_buff *skb, const struct net_device *dev, struct net *src_net, gfp_t gfp) { … } static int rtnl_fill_link_af(struct sk_buff *skb, const struct net_device *dev, u32 ext_filter_mask) { … } static int rtnl_fill_alt_ifnames(struct sk_buff *skb, const struct net_device *dev) { … } /* RCU protected. */ static int rtnl_fill_prop_list(struct sk_buff *skb, const struct net_device *dev) { … } static int rtnl_fill_proto_down(struct sk_buff *skb, const struct net_device *dev) { … } static int rtnl_fill_devlink_port(struct sk_buff *skb, const struct net_device *dev) { … } static int rtnl_fill_dpll_pin(struct sk_buff *skb, const struct net_device *dev) { … } static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev, struct net *src_net, int type, u32 pid, u32 seq, u32 change, unsigned int flags, u32 ext_filter_mask, u32 event, int *new_nsid, int new_ifindex, int tgt_netnsid, gfp_t gfp) { … } static const struct nla_policy ifla_policy[IFLA_MAX+1] = …; static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = …; static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = …; static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = …; static const struct nla_policy ifla_xdp_policy[IFLA_XDP_MAX + 1] = …; static const struct rtnl_link_ops *linkinfo_to_kind_ops(const struct nlattr *nla) { … } static bool link_master_filtered(struct net_device *dev, int master_idx) { … } static bool link_kind_filtered(const struct net_device *dev, const struct rtnl_link_ops *kind_ops) { … } static bool link_dump_filtered(struct net_device *dev, int master_idx, const struct rtnl_link_ops *kind_ops) { … } /** * rtnl_get_net_ns_capable - Get netns if sufficiently privileged. * @sk: netlink socket * @netnsid: network namespace identifier * * Returns the network namespace identified by netnsid on success or an error * pointer on failure. */ struct net *rtnl_get_net_ns_capable(struct sock *sk, int netnsid) { … } EXPORT_SYMBOL_GPL(…); static int rtnl_valid_dump_ifinfo_req(const struct nlmsghdr *nlh, bool strict_check, struct nlattr **tb, struct netlink_ext_ack *extack) { … } static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb) { … } int rtnl_nla_parse_ifinfomsg(struct nlattr **tb, const struct nlattr *nla_peer, struct netlink_ext_ack *exterr) { … } EXPORT_SYMBOL(…); struct net *rtnl_link_get_net(struct net *src_net, struct nlattr *tb[]) { … } EXPORT_SYMBOL(…); /* Figure out which network namespace we are talking about by * examining the link attributes in the following order: * * 1. IFLA_NET_NS_PID * 2. IFLA_NET_NS_FD * 3. IFLA_TARGET_NETNSID */ static struct net *rtnl_link_get_net_by_nlattr(struct net *src_net, struct nlattr *tb[]) { … } static struct net *rtnl_link_get_net_capable(const struct sk_buff *skb, struct net *src_net, struct nlattr *tb[], int cap) { … } /* Verify that rtnetlink requests do not pass additional properties * potentially referring to different network namespaces. */ static int rtnl_ensure_unique_netns(struct nlattr *tb[], struct netlink_ext_ack *extack, bool netns_id_only) { … } static int rtnl_set_vf_rate(struct net_device *dev, int vf, int min_tx_rate, int max_tx_rate) { … } static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[], struct netlink_ext_ack *extack) { … } static int handle_infiniband_guid(struct net_device *dev, struct ifla_vf_guid *ivt, int guid_type) { … } static int handle_vf_guid(struct net_device *dev, struct ifla_vf_guid *ivt, int guid_type) { … } static int do_setvfinfo(struct net_device *dev, struct nlattr **tb) { … } static int do_set_master(struct net_device *dev, int ifindex, struct netlink_ext_ack *extack) { … } static const struct nla_policy ifla_proto_down_reason_policy[IFLA_PROTO_DOWN_REASON_VALUE + 1] = …; static int do_set_proto_down(struct net_device *dev, struct nlattr *nl_proto_down, struct nlattr *nl_proto_down_reason, struct netlink_ext_ack *extack) { … } #define DO_SETLINK_MODIFIED … /* notify flag means notify + modified. */ #define DO_SETLINK_NOTIFY … static int do_setlink(const struct sk_buff *skb, struct net_device *dev, struct ifinfomsg *ifm, struct netlink_ext_ack *extack, struct nlattr **tb, int status) { … } static struct net_device *rtnl_dev_get(struct net *net, struct nlattr *tb[]) { … } static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static int rtnl_group_dellink(const struct net *net, int group) { … } int rtnl_delete_link(struct net_device *dev, u32 portid, const struct nlmsghdr *nlh) { … } EXPORT_SYMBOL_GPL(…); static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } int rtnl_configure_link(struct net_device *dev, const struct ifinfomsg *ifm, u32 portid, const struct nlmsghdr *nlh) { … } EXPORT_SYMBOL(…); struct net_device *rtnl_create_link(struct net *net, const char *ifname, unsigned char name_assign_type, const struct rtnl_link_ops *ops, struct nlattr *tb[], struct netlink_ext_ack *extack) { … } EXPORT_SYMBOL(…); static int rtnl_group_changelink(const struct sk_buff *skb, struct net *net, int group, struct ifinfomsg *ifm, struct netlink_ext_ack *extack, struct nlattr **tb) { … } static int rtnl_newlink_create(struct sk_buff *skb, struct ifinfomsg *ifm, const struct rtnl_link_ops *ops, const struct nlmsghdr *nlh, struct nlattr **tb, struct nlattr **data, struct netlink_ext_ack *extack) { … } struct rtnl_newlink_tbs { … }; static int __rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh, struct rtnl_newlink_tbs *tbs, struct netlink_ext_ack *extack) { … } static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static int rtnl_valid_getlink_req(struct sk_buff *skb, const struct nlmsghdr *nlh, struct nlattr **tb, struct netlink_ext_ack *extack) { … } static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static int rtnl_alt_ifname(int cmd, struct net_device *dev, struct nlattr *attr, bool *changed, struct netlink_ext_ack *extack) { … } static int rtnl_linkprop(int cmd, struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static int rtnl_newlinkprop(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static int rtnl_dellinkprop(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static noinline_for_stack u32 rtnl_calcit(struct sk_buff *skb, struct nlmsghdr *nlh) { … } static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb) { … } struct sk_buff *rtmsg_ifinfo_build_skb(int type, struct net_device *dev, unsigned int change, u32 event, gfp_t flags, int *new_nsid, int new_ifindex, u32 portid, const struct nlmsghdr *nlh) { … } void rtmsg_ifinfo_send(struct sk_buff *skb, struct net_device *dev, gfp_t flags, u32 portid, const struct nlmsghdr *nlh) { … } static void rtmsg_ifinfo_event(int type, struct net_device *dev, unsigned int change, u32 event, gfp_t flags, int *new_nsid, int new_ifindex, u32 portid, const struct nlmsghdr *nlh) { … } void rtmsg_ifinfo(int type, struct net_device *dev, unsigned int change, gfp_t flags, u32 portid, const struct nlmsghdr *nlh) { … } void rtmsg_ifinfo_newnet(int type, struct net_device *dev, unsigned int change, gfp_t flags, int *new_nsid, int new_ifindex) { … } static int nlmsg_populate_fdb_fill(struct sk_buff *skb, struct net_device *dev, u8 *addr, u16 vid, u32 pid, u32 seq, int type, unsigned int flags, int nlflags, u16 ndm_state) { … } static inline size_t rtnl_fdb_nlmsg_size(const struct net_device *dev) { … } static void rtnl_fdb_notify(struct net_device *dev, u8 *addr, u16 vid, int type, u16 ndm_state) { … } /* * ndo_dflt_fdb_add - default netdevice operation to add an FDB entry */ int ndo_dflt_fdb_add(struct ndmsg *ndm, struct nlattr *tb[], struct net_device *dev, const unsigned char *addr, u16 vid, u16 flags) { … } EXPORT_SYMBOL(…); static int fdb_vid_parse(struct nlattr *vlan_attr, u16 *p_vid, struct netlink_ext_ack *extack) { … } static int rtnl_fdb_add(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } /* * ndo_dflt_fdb_del - default netdevice operation to delete an FDB entry */ int ndo_dflt_fdb_del(struct ndmsg *ndm, struct nlattr *tb[], struct net_device *dev, const unsigned char *addr, u16 vid) { … } EXPORT_SYMBOL(…); static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static int nlmsg_populate_fdb(struct sk_buff *skb, struct netlink_callback *cb, struct net_device *dev, int *idx, struct netdev_hw_addr_list *list) { … } /** * ndo_dflt_fdb_dump - default netdevice operation to dump an FDB table. * @skb: socket buffer to store message in * @cb: netlink callback * @dev: netdevice * @filter_dev: ignored * @idx: the number of FDB table entries dumped is added to *@idx * * Default netdevice operation to dump the existing unicast address list. * Returns number of addresses from list put in skb. */ int ndo_dflt_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb, struct net_device *dev, struct net_device *filter_dev, int *idx) { … } EXPORT_SYMBOL(…); static int valid_fdb_dump_strict(const struct nlmsghdr *nlh, int *br_idx, int *brport_idx, struct netlink_ext_ack *extack) { … } static int valid_fdb_dump_legacy(const struct nlmsghdr *nlh, int *br_idx, int *brport_idx, struct netlink_ext_ack *extack) { … } static int rtnl_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb) { … } static int valid_fdb_get_strict(const struct nlmsghdr *nlh, struct nlattr **tb, u8 *ndm_flags, int *br_idx, int *brport_idx, u8 **addr, u16 *vid, struct netlink_ext_ack *extack) { … } static int rtnl_fdb_get(struct sk_buff *in_skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static int brport_nla_put_flag(struct sk_buff *skb, u32 flags, u32 mask, unsigned int attrnum, unsigned int flag) { … } 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)) { … } EXPORT_SYMBOL_GPL(…); static int valid_bridge_getlink_req(const struct nlmsghdr *nlh, bool strict_check, u32 *filter_mask, struct netlink_ext_ack *extack) { … } static int rtnl_bridge_getlink(struct sk_buff *skb, struct netlink_callback *cb) { … } static inline size_t bridge_nlmsg_size(void) { … } static int rtnl_bridge_notify(struct net_device *dev) { … } static int rtnl_bridge_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static int rtnl_bridge_dellink(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static bool stats_attr_valid(unsigned int mask, int attrid, int idxattr) { … } static bool rtnl_offload_xstats_have_ndo(const struct net_device *dev, int attr_id) { … } static unsigned int rtnl_offload_xstats_get_size_ndo(const struct net_device *dev, int attr_id) { … } static int rtnl_offload_xstats_fill_ndo(struct net_device *dev, int attr_id, struct sk_buff *skb) { … } static unsigned int rtnl_offload_xstats_get_size_stats(const struct net_device *dev, enum netdev_offload_xstats_type type) { … } struct rtnl_offload_xstats_request_used { … }; static int rtnl_offload_xstats_get_stats(struct net_device *dev, enum netdev_offload_xstats_type type, struct rtnl_offload_xstats_request_used *ru, struct rtnl_hw_stats64 *stats, struct netlink_ext_ack *extack) { … } static int rtnl_offload_xstats_fill_hw_s_info_one(struct sk_buff *skb, int attr_id, struct rtnl_offload_xstats_request_used *ru) { … } static int rtnl_offload_xstats_fill_hw_s_info(struct sk_buff *skb, struct net_device *dev, struct netlink_ext_ack *extack) { … } static int rtnl_offload_xstats_fill(struct sk_buff *skb, struct net_device *dev, int *prividx, u32 off_filter_mask, struct netlink_ext_ack *extack) { … } static unsigned int rtnl_offload_xstats_get_size_hw_s_info_one(const struct net_device *dev, enum netdev_offload_xstats_type type) { … } static unsigned int rtnl_offload_xstats_get_size_hw_s_info(const struct net_device *dev) { … } static int rtnl_offload_xstats_get_size(const struct net_device *dev, u32 off_filter_mask) { … } struct rtnl_stats_dump_filters { … }; static int rtnl_fill_statsinfo(struct sk_buff *skb, struct net_device *dev, int type, u32 pid, u32 seq, u32 change, unsigned int flags, const struct rtnl_stats_dump_filters *filters, int *idxattr, int *prividx, struct netlink_ext_ack *extack) { … } static size_t if_nlmsg_stats_size(const struct net_device *dev, const struct rtnl_stats_dump_filters *filters) { … } #define RTNL_STATS_OFFLOAD_XSTATS_VALID … static const struct nla_policy rtnl_stats_get_policy_filters[IFLA_STATS_MAX + 1] = …; static const struct nla_policy rtnl_stats_get_policy[IFLA_STATS_GETSET_MAX + 1] = …; static const struct nla_policy ifla_stats_set_policy[IFLA_STATS_GETSET_MAX + 1] = …; static int rtnl_stats_get_parse_filters(struct nlattr *ifla_filters, struct rtnl_stats_dump_filters *filters, struct netlink_ext_ack *extack) { … } static int rtnl_stats_get_parse(const struct nlmsghdr *nlh, u32 filter_mask, struct rtnl_stats_dump_filters *filters, struct netlink_ext_ack *extack) { … } static int rtnl_valid_stats_req(const struct nlmsghdr *nlh, bool strict_check, bool is_dump, struct netlink_ext_ack *extack) { … } static int rtnl_stats_get(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static int rtnl_stats_dump(struct sk_buff *skb, struct netlink_callback *cb) { … } void rtnl_offload_xstats_notify(struct net_device *dev) { … } EXPORT_SYMBOL(…); static int rtnl_stats_set(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static int rtnl_mdb_valid_dump_req(const struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } struct rtnl_mdb_dump_ctx { … }; static int rtnl_mdb_dump(struct sk_buff *skb, struct netlink_callback *cb) { … } static int rtnl_validate_mdb_entry_get(const struct nlattr *attr, struct netlink_ext_ack *extack) { … } static const struct nla_policy mdba_get_policy[MDBA_GET_ENTRY_MAX + 1] = …; static int rtnl_mdb_get(struct sk_buff *in_skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static int rtnl_validate_mdb_entry(const struct nlattr *attr, struct netlink_ext_ack *extack) { … } static const struct nla_policy mdba_policy[MDBA_SET_ENTRY_MAX + 1] = …; static int rtnl_mdb_add(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static int rtnl_validate_mdb_entry_del_bulk(const struct nlattr *attr, struct netlink_ext_ack *extack) { … } static const struct nla_policy mdba_del_bulk_policy[MDBA_SET_ENTRY_MAX + 1] = …; static int rtnl_mdb_del(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } /* Process one rtnetlink message. */ static int rtnl_dumpit(struct sk_buff *skb, struct netlink_callback *cb) { … } static int rtnetlink_dump_start(struct sock *ssk, struct sk_buff *skb, const struct nlmsghdr *nlh, struct netlink_dump_control *control) { … } static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, struct netlink_ext_ack *extack) { … } static void rtnetlink_rcv(struct sk_buff *skb) { … } static int rtnetlink_bind(struct net *net, int group) { … } static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr) { … } static struct notifier_block rtnetlink_dev_notifier = …; static int __net_init rtnetlink_net_init(struct net *net) { … } static void __net_exit rtnetlink_net_exit(struct net *net) { … } static struct pernet_operations rtnetlink_net_ops = …; void __init rtnetlink_init(void) { … }
Codebase Browser
linux