Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef __NET_RTNETLINK_H
       3                 :            : #define __NET_RTNETLINK_H
       4                 :            : 
       5                 :            : #include <linux/rtnetlink.h>
       6                 :            : #include <net/netlink.h>
       7                 :            : 
       8                 :            : typedef int (*rtnl_doit_func)(struct sk_buff *, struct nlmsghdr *,
       9                 :            :                               struct netlink_ext_ack *);
      10                 :            : typedef int (*rtnl_dumpit_func)(struct sk_buff *, struct netlink_callback *);
      11                 :            : 
      12                 :            : enum rtnl_link_flags {
      13                 :            :         RTNL_FLAG_DOIT_UNLOCKED = 1,
      14                 :            : };
      15                 :            : 
      16                 :            : void rtnl_register(int protocol, int msgtype,
      17                 :            :                    rtnl_doit_func, rtnl_dumpit_func, unsigned int flags);
      18                 :            : int rtnl_register_module(struct module *owner, int protocol, int msgtype,
      19                 :            :                          rtnl_doit_func, rtnl_dumpit_func, unsigned int flags);
      20                 :            : int rtnl_unregister(int protocol, int msgtype);
      21                 :            : void rtnl_unregister_all(int protocol);
      22                 :            : 
      23                 :            : static inline int rtnl_msg_family(const struct nlmsghdr *nlh)
      24                 :            : {
      25                 :          0 :         if (nlmsg_len(nlh) >= sizeof(struct rtgenmsg))
      26                 :          0 :                 return ((struct rtgenmsg *) nlmsg_data(nlh))->rtgen_family;
      27                 :            :         else
      28                 :            :                 return AF_UNSPEC;
      29                 :            : }
      30                 :            : 
      31                 :            : /**
      32                 :            :  *      struct rtnl_link_ops - rtnetlink link operations
      33                 :            :  *
      34                 :            :  *      @list: Used internally
      35                 :            :  *      @kind: Identifier
      36                 :            :  *      @maxtype: Highest device specific netlink attribute number
      37                 :            :  *      @policy: Netlink policy for device specific attribute validation
      38                 :            :  *      @validate: Optional validation function for netlink/changelink parameters
      39                 :            :  *      @priv_size: sizeof net_device private space
      40                 :            :  *      @setup: net_device setup function
      41                 :            :  *      @newlink: Function for configuring and registering a new device
      42                 :            :  *      @changelink: Function for changing parameters of an existing device
      43                 :            :  *      @dellink: Function to remove a device
      44                 :            :  *      @get_size: Function to calculate required room for dumping device
      45                 :            :  *                 specific netlink attributes
      46                 :            :  *      @fill_info: Function to dump device specific netlink attributes
      47                 :            :  *      @get_xstats_size: Function to calculate required room for dumping device
      48                 :            :  *                        specific statistics
      49                 :            :  *      @fill_xstats: Function to dump device specific statistics
      50                 :            :  *      @get_num_tx_queues: Function to determine number of transmit queues
      51                 :            :  *                          to create when creating a new device.
      52                 :            :  *      @get_num_rx_queues: Function to determine number of receive queues
      53                 :            :  *                          to create when creating a new device.
      54                 :            :  *      @get_link_net: Function to get the i/o netns of the device
      55                 :            :  *      @get_linkxstats_size: Function to calculate the required room for
      56                 :            :  *                            dumping device-specific extended link stats
      57                 :            :  *      @fill_linkxstats: Function to dump device-specific extended link stats
      58                 :            :  */
      59                 :            : struct rtnl_link_ops {
      60                 :            :         struct list_head        list;
      61                 :            : 
      62                 :            :         const char              *kind;
      63                 :            : 
      64                 :            :         size_t                  priv_size;
      65                 :            :         void                    (*setup)(struct net_device *dev);
      66                 :            : 
      67                 :            :         unsigned int            maxtype;
      68                 :            :         const struct nla_policy *policy;
      69                 :            :         int                     (*validate)(struct nlattr *tb[],
      70                 :            :                                             struct nlattr *data[],
      71                 :            :                                             struct netlink_ext_ack *extack);
      72                 :            : 
      73                 :            :         int                     (*newlink)(struct net *src_net,
      74                 :            :                                            struct net_device *dev,
      75                 :            :                                            struct nlattr *tb[],
      76                 :            :                                            struct nlattr *data[],
      77                 :            :                                            struct netlink_ext_ack *extack);
      78                 :            :         int                     (*changelink)(struct net_device *dev,
      79                 :            :                                               struct nlattr *tb[],
      80                 :            :                                               struct nlattr *data[],
      81                 :            :                                               struct netlink_ext_ack *extack);
      82                 :            :         void                    (*dellink)(struct net_device *dev,
      83                 :            :                                            struct list_head *head);
      84                 :            : 
      85                 :            :         size_t                  (*get_size)(const struct net_device *dev);
      86                 :            :         int                     (*fill_info)(struct sk_buff *skb,
      87                 :            :                                              const struct net_device *dev);
      88                 :            : 
      89                 :            :         size_t                  (*get_xstats_size)(const struct net_device *dev);
      90                 :            :         int                     (*fill_xstats)(struct sk_buff *skb,
      91                 :            :                                                const struct net_device *dev);
      92                 :            :         unsigned int            (*get_num_tx_queues)(void);
      93                 :            :         unsigned int            (*get_num_rx_queues)(void);
      94                 :            : 
      95                 :            :         unsigned int            slave_maxtype;
      96                 :            :         const struct nla_policy *slave_policy;
      97                 :            :         int                     (*slave_changelink)(struct net_device *dev,
      98                 :            :                                                     struct net_device *slave_dev,
      99                 :            :                                                     struct nlattr *tb[],
     100                 :            :                                                     struct nlattr *data[],
     101                 :            :                                                     struct netlink_ext_ack *extack);
     102                 :            :         size_t                  (*get_slave_size)(const struct net_device *dev,
     103                 :            :                                                   const struct net_device *slave_dev);
     104                 :            :         int                     (*fill_slave_info)(struct sk_buff *skb,
     105                 :            :                                                    const struct net_device *dev,
     106                 :            :                                                    const struct net_device *slave_dev);
     107                 :            :         struct net              *(*get_link_net)(const struct net_device *dev);
     108                 :            :         size_t                  (*get_linkxstats_size)(const struct net_device *dev,
     109                 :            :                                                        int attr);
     110                 :            :         int                     (*fill_linkxstats)(struct sk_buff *skb,
     111                 :            :                                                    const struct net_device *dev,
     112                 :            :                                                    int *prividx, int attr);
     113                 :            : };
     114                 :            : 
     115                 :            : int __rtnl_link_register(struct rtnl_link_ops *ops);
     116                 :            : void __rtnl_link_unregister(struct rtnl_link_ops *ops);
     117                 :            : 
     118                 :            : int rtnl_link_register(struct rtnl_link_ops *ops);
     119                 :            : void rtnl_link_unregister(struct rtnl_link_ops *ops);
     120                 :            : 
     121                 :            : /**
     122                 :            :  *      struct rtnl_af_ops - rtnetlink address family operations
     123                 :            :  *
     124                 :            :  *      @list: Used internally
     125                 :            :  *      @family: Address family
     126                 :            :  *      @fill_link_af: Function to fill IFLA_AF_SPEC with address family
     127                 :            :  *                     specific netlink attributes.
     128                 :            :  *      @get_link_af_size: Function to calculate size of address family specific
     129                 :            :  *                         netlink attributes.
     130                 :            :  *      @validate_link_af: Validate a IFLA_AF_SPEC attribute, must check attr
     131                 :            :  *                         for invalid configuration settings.
     132                 :            :  *      @set_link_af: Function to parse a IFLA_AF_SPEC attribute and modify
     133                 :            :  *                    net_device accordingly.
     134                 :            :  */
     135                 :            : struct rtnl_af_ops {
     136                 :            :         struct list_head        list;
     137                 :            :         int                     family;
     138                 :            : 
     139                 :            :         int                     (*fill_link_af)(struct sk_buff *skb,
     140                 :            :                                                 const struct net_device *dev,
     141                 :            :                                                 u32 ext_filter_mask);
     142                 :            :         size_t                  (*get_link_af_size)(const struct net_device *dev,
     143                 :            :                                                     u32 ext_filter_mask);
     144                 :            : 
     145                 :            :         int                     (*validate_link_af)(const struct net_device *dev,
     146                 :            :                                                     const struct nlattr *attr);
     147                 :            :         int                     (*set_link_af)(struct net_device *dev,
     148                 :            :                                                const struct nlattr *attr);
     149                 :            : 
     150                 :            :         int                     (*fill_stats_af)(struct sk_buff *skb,
     151                 :            :                                                  const struct net_device *dev);
     152                 :            :         size_t                  (*get_stats_af_size)(const struct net_device *dev);
     153                 :            : };
     154                 :            : 
     155                 :            : void rtnl_af_register(struct rtnl_af_ops *ops);
     156                 :            : void rtnl_af_unregister(struct rtnl_af_ops *ops);
     157                 :            : 
     158                 :            : struct net *rtnl_link_get_net(struct net *src_net, struct nlattr *tb[]);
     159                 :            : struct net_device *rtnl_create_link(struct net *net, const char *ifname,
     160                 :            :                                     unsigned char name_assign_type,
     161                 :            :                                     const struct rtnl_link_ops *ops,
     162                 :            :                                     struct nlattr *tb[],
     163                 :            :                                     struct netlink_ext_ack *extack);
     164                 :            : int rtnl_delete_link(struct net_device *dev);
     165                 :            : int rtnl_configure_link(struct net_device *dev, const struct ifinfomsg *ifm);
     166                 :            : 
     167                 :            : int rtnl_nla_parse_ifla(struct nlattr **tb, const struct nlattr *head, int len,
     168                 :            :                         struct netlink_ext_ack *exterr);
     169                 :            : struct net *rtnl_get_net_ns_capable(struct sock *sk, int netnsid);
     170                 :            : 
     171                 :            : #define MODULE_ALIAS_RTNL_LINK(kind) MODULE_ALIAS("rtnl-link-" kind)
     172                 :            : 
     173                 :            : #endif