// 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, <kuznet@ms2.inr.ac.ru>

*

* 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/netdev_lock.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 50

#define RTNL_SLAVE_MAX_TYPE 44

struct rtnl_link {

rtnl_doit_func doit;

rtnl_dumpit_func dumpit;

struct module *owner;

unsigned int flags;

struct rcu_head rcu;

};

static DEFINE_MUTEX(rtnl_mutex);

void rtnl_lock(void)

{

mutex_lock(&rtnl_mutex);

}

EXPORT_SYMBOL(rtnl_lock);

int rtnl_lock_interruptible(void)

{

return mutex_lock_interruptible(&rtnl_mutex);

}

int rtnl_lock_killable(void)

{

return mutex_lock_killable(&rtnl_mutex);

}

static struct sk_buff *defer_kfree_skb_list;

void rtnl_kfree_skbs(struct sk_buff *head, struct sk_buff *tail)

{

if (head && tail) {

tail->next = defer_kfree_skb_list;

defer_kfree_skb_list = head;

}

}

EXPORT_SYMBOL(rtnl_kfree_skbs);

void __rtnl_unlock(void)

{

struct sk_buff *head = defer_kfree_skb_list;

defer_kfree_skb_list = NULL;

/* Ensure that we didn't actually add any TODO item when __rtnl_unlock()

* is used. In some places, e.g. in cfg80211, we have code that will do

* something like

* rtnl_lock()

* wiphy_lock()

* ...

* rtnl_unlock()

*

* and because netdev_run_todo() acquires the RTNL for items on the list

* we could cause a situation such as this:

* Thread 1 Thread 2

* rtnl_lock()

* unregister_netdevice()

* __rtnl_unlock()

* rtnl_lock()

* wiphy_lock()

* rtnl_unlock()

* netdev_run_todo()

* __rtnl_unlock()

*

* // list not empty now

* // because of thread 2

* rtnl_lock()

* while (!list_empty(...))

* rtnl_lock()

* wiphy_lock()

* **** DEADLOCK ****

*

* However, usage of __rtnl_unlock() is rare, and so we can ensure that

* it's not used in cases where something is added to do the list.

*/

WARN_ON(!list_empty(&net_todo_list));

mutex_unlock(&rtnl_mutex);

while (head) {

struct sk_buff *next = head->next;

kfree_skb(head);

cond_resched();

head = next;

}

}

void rtnl_unlock(void)

{

/* This fellow will unlock it for us. */

netdev_run_todo();

}

EXPORT_SYMBOL(rtnl_unlock);

int rtnl_trylock(void)

{

return mutex_trylock(&rtnl_mutex);

}

EXPORT_SYMBOL(rtnl_trylock);

int rtnl_is_locked(void)

{

return mutex_is_locked(&rtnl_mutex);

}

EXPORT_SYMBOL(rtnl_is_locked);

bool refcount_dec_and_rtnl_lock(refcount_t *r)

{

return refcount_dec_and_mutex_lock(r, &rtnl_mutex);

}

EXPORT_SYMBOL(refcount_dec_and_rtnl_lock);

#ifdef CONFIG_PROVE_LOCKING

bool lockdep_rtnl_is_held(void)

{

return lockdep_is_held(&rtnl_mutex);

}

EXPORT_SYMBOL(lockdep_rtnl_is_held);

#endif /* #ifdef CONFIG_PROVE_LOCKING */

#ifdef CONFIG_DEBUG_NET_SMALL_RTNL

void __rtnl_net_lock(struct net *net)

{

ASSERT_RTNL();

mutex_lock(&net->rtnl_mutex);

}

EXPORT_SYMBOL(__rtnl_net_lock);

void __rtnl_net_unlock(struct net *net)

{

ASSERT_RTNL();

mutex_unlock(&net->rtnl_mutex);

}

EXPORT_SYMBOL(__rtnl_net_unlock);

void rtnl_net_lock(struct net *net)

{

rtnl_lock();

__rtnl_net_lock(net);

}

EXPORT_SYMBOL(rtnl_net_lock);

void rtnl_net_unlock(struct net *net)

{

__rtnl_net_unlock(net);

rtnl_unlock();

}

EXPORT_SYMBOL(rtnl_net_unlock);

int rtnl_net_trylock(struct net *net)

{

int ret = rtnl_trylock();

if (ret)

__rtnl_net_lock(net);

return ret;

}

EXPORT_SYMBOL(rtnl_net_trylock);

int rtnl_net_lock_killable(struct net *net)

{

int ret = rtnl_lock_killable();

if (!ret)

__rtnl_net_lock(net);

return ret;

}

static int rtnl_net_cmp_locks(const struct net *net_a, const struct net *net_b)

{

if (net_eq(net_a, net_b))

return 0;

/* always init_net first */

if (net_eq(net_a, &init_net))

return -1;

if (net_eq(net_b, &init_net))

return 1;

/* otherwise lock in ascending order */

return net_a < net_b ? -1 : 1;

}

int rtnl_net_lock_cmp_fn(const struct lockdep_map *a, const struct lockdep_map *b)

{

const struct net *net_a, *net_b;

net_a = container_of(a, struct net, rtnl_mutex.dep_map);

net_b = container_of(b, struct net, rtnl_mutex.dep_map);

return rtnl_net_cmp_locks(net_a, net_b);

}

bool rtnl_net_is_locked(struct net *net)

{

return rtnl_is_locked() && mutex_is_locked(&net->rtnl_mutex);

}

EXPORT_SYMBOL(rtnl_net_is_locked);

bool lockdep_rtnl_net_is_held(struct net *net)

{

return lockdep_rtnl_is_held() && lockdep_is_held(&net->rtnl_mutex);

}

EXPORT_SYMBOL(lockdep_rtnl_net_is_held);

#else

static int rtnl_net_cmp_locks(const struct net *net_a, const struct net *net_b)

{

/* No need to swap */

return -1;

}

#endif

struct rtnl_nets {

/* ->newlink() needs to freeze 3 netns at most;

* 2 for the new device, 1 for its peer.

*/

struct net *net[3];

unsigned char len;

};

static void rtnl_nets_init(struct rtnl_nets *rtnl_nets)

{

memset(rtnl_nets, 0, sizeof(*rtnl_nets));

}

static void rtnl_nets_destroy(struct rtnl_nets *rtnl_nets)

{

int i;

for (i = 0; i < rtnl_nets->len; i++) {

put_net(rtnl_nets->net[i]);

rtnl_nets->net[i] = NULL;

}

rtnl_nets->len = 0;

}

/**

* rtnl_nets_add - Add netns to be locked before ->newlink().

*

* @rtnl_nets: rtnl_nets pointer passed to ->get_peer_net().

* @net: netns pointer with an extra refcnt held.

*

* The extra refcnt is released in rtnl_nets_destroy().

*/

static void rtnl_nets_add(struct rtnl_nets *rtnl_nets, struct net *net)

{

int i;

DEBUG_NET_WARN_ON_ONCE(rtnl_nets->len == ARRAY_SIZE(rtnl_nets->net));

for (i = 0; i < rtnl_nets->len; i++) {

switch (rtnl_net_cmp_locks(rtnl_nets->net[i], net)) {

case 0:

put_net(net);

return;

case 1:

swap(rtnl_nets->net[i], net);

}

}

rtnl_nets->net[i] = net;

rtnl_nets->len++;

}

static void rtnl_nets_lock(struct rtnl_nets *rtnl_nets)

{

int i;

rtnl_lock();

for (i = 0; i < rtnl_nets->len; i++)

__rtnl_net_lock(rtnl_nets->net[i]);

}

static void rtnl_nets_unlock(struct rtnl_nets *rtnl_nets)

{

int i;

for (i = 0; i < rtnl_nets->len; i++)

__rtnl_net_unlock(rtnl_nets->net[i]);

rtnl_unlock();

}

static struct rtnl_link __rcu *__rcu *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1];

static inline int rtm_msgindex(int msgtype)

{

int msgindex = msgtype - RTM_BASE;

/*

* msgindex < 0 implies someone tried to register a netlink

* control code. msgindex >= RTM_NR_MSGTYPES may indicate that

* the message type has not been added to linux/rtnetlink.h

*/

BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES);

return msgindex;

}

static struct rtnl_link *rtnl_get_link(int protocol, int msgtype)

{

struct rtnl_link __rcu **tab;

if (protocol >= ARRAY_SIZE(rtnl_msg_handlers))

protocol = PF_UNSPEC;

tab = rcu_dereference_rtnl(rtnl_msg_handlers[protocol]);

if (!tab)

tab = rcu_dereference_rtnl(rtnl_msg_handlers[PF_UNSPEC]);

return rcu_dereference_rtnl(tab[msgtype]);

}

static int rtnl_register_internal(struct module *owner,

int protocol, int msgtype,

rtnl_doit_func doit, rtnl_dumpit_func dumpit,

unsigned int flags)

{

struct rtnl_link *link, *old;

struct rtnl_link __rcu **tab;

int msgindex;

int ret = -ENOBUFS;

BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);

msgindex = rtm_msgindex(msgtype);

rtnl_lock();

tab = rtnl_dereference(rtnl_msg_handlers[protocol]);

if (tab == NULL) {

tab = kcalloc(RTM_NR_MSGTYPES, sizeof(void *), GFP_KERNEL);

if (!tab)

goto unlock;

/* ensures we see the 0 stores */

rcu_assign_pointer(rtnl_msg_handlers[protocol], tab);

}

old = rtnl_dereference(tab[msgindex]);

if (old) {

link = kmemdup(old, sizeof(*old), GFP_KERNEL);

if (!link)

goto unlock;

} else {

link = kzalloc_obj(*link);

if (!link)

goto unlock;

}

WARN_ON(link->owner && link->owner != owner);

link->owner = owner;

WARN_ON(doit && link->doit && link->doit != doit);

if (doit)

link->doit = doit;

WARN_ON(dumpit && link->dumpit && link->dumpit != dumpit);

if (dumpit)

link->dumpit = dumpit;

WARN_ON(rtnl_msgtype_kind(msgtype) != RTNL_KIND_DEL &&

(flags & RTNL_FLAG_BULK_DEL_SUPPORTED));

link->flags |= flags;

/* publish protocol:msgtype */

rcu_assign_pointer(tab[msgindex], link);

ret = 0;

if (old)

kfree_rcu(old, rcu);

unlock:

rtnl_unlock();

return ret;

}

/**

* 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.

*/

static int rtnl_unregister(int protocol, int msgtype)

{

struct rtnl_link __rcu **tab;

struct rtnl_link *link;

int msgindex;

BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);

msgindex = rtm_msgindex(msgtype);

rtnl_lock();

tab = rtnl_dereference(rtnl_msg_handlers[protocol]);

if (!tab) {

rtnl_unlock();

return -ENOENT;

}

link = rcu_replace_pointer_rtnl(tab[msgindex], NULL);

rtnl_unlock();

kfree_rcu(link, rcu);

return 0;

}

/**

* rtnl_unregister_all - Unregister all rtnetlink message type of a protocol

* @protocol : Protocol family or PF_UNSPEC

*

* Identical to calling rtnl_unregister() for all registered message types

* of a certain protocol family.

*/

void rtnl_unregister_all(int protocol)

{

struct rtnl_link __rcu **tab;

struct rtnl_link *link;

int msgindex;

BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);

rtnl_lock();

tab = rcu_replace_pointer_rtnl(rtnl_msg_handlers[protocol], NULL);

if (!tab) {

rtnl_unlock();

return;

}

for (msgindex = 0; msgindex < RTM_NR_MSGTYPES; msgindex++) {

link = rcu_replace_pointer_rtnl(tab[msgindex], NULL);

kfree_rcu(link, rcu);

}

rtnl_unlock();

synchronize_net();

kfree(tab);

}

EXPORT_SYMBOL_GPL(rtnl_unregister_all);

/**

* __rtnl_register_many - Register rtnetlink message types

* @handlers: Array of struct rtnl_msg_handlers

* @n: The length of @handlers

*

* 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.

*

* When one element of @handlers fails to register,

* 1) built-in: panics.

* 2) modules : the previous successful registrations are unwinded

* and an error is returned.

*

* Use rtnl_register_many().

*/

int __rtnl_register_many(const struct rtnl_msg_handler *handlers, int n)

{

const struct rtnl_msg_handler *handler;

int i, err;

for (i = 0, handler = handlers; i < n; i++, handler++) {

err = rtnl_register_internal(handler->owner, handler->protocol,

handler->msgtype, handler->doit,

handler->dumpit, handler->flags);

if (err) {

if (!handler->owner)

panic("Unable to register rtnetlink message "

"handlers, %pS\n", handlers);

__rtnl_unregister_many(handlers, i);

break;

}

}

return err;

}

EXPORT_SYMBOL_GPL(__rtnl_register_many);

void __rtnl_unregister_many(const struct rtnl_msg_handler *handlers, int n)

{

const struct rtnl_msg_handler *handler;

int i;

for (i = n - 1, handler = handlers + n - 1; i >= 0; i--, handler--)

rtnl_unregister(handler->protocol, handler->msgtype);

}

EXPORT_SYMBOL_GPL(__rtnl_unregister_many);

static DEFINE_MUTEX(link_ops_mutex);

static LIST_HEAD(link_ops);

static struct rtnl_link_ops *rtnl_link_ops_get(const char *kind, int *srcu_index)

{

struct rtnl_link_ops *ops;

rcu_read_lock();

list_for_each_entry_rcu(ops, &link_ops, list) {

if (!strcmp(ops->kind, kind)) {

*srcu_index = srcu_read_lock(&ops->srcu);

goto unlock;

}

}

ops = NULL;

unlock:

rcu_read_unlock();

return ops;

}

static void rtnl_link_ops_put(struct rtnl_link_ops *ops, int srcu_index)

{

srcu_read_unlock(&ops->srcu, srcu_index);

}

/**

* 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)

{

struct rtnl_link_ops *tmp;

int err;

/* Sanity-check max sizes to avoid stack buffer overflow. */

if (WARN_ON(ops->maxtype > RTNL_MAX_TYPE ||

ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE))

return -EINVAL;

/* The check for alloc/setup is here because if ops

* does not have that filled up, it is not possible

* to use the ops for creating device. So do not

* fill up dellink as well. That disables rtnl_dellink.

*/

if ((ops->alloc || ops->setup) && !ops->dellink)

ops->dellink = unregister_netdevice_queue;

err = init_srcu_struct(&ops->srcu);

if (err)

return err;

mutex_lock(&link_ops_mutex);

list_for_each_entry(tmp, &link_ops, list) {

if (!strcmp(ops->kind, tmp->kind)) {

err = -EEXIST;

goto unlock;

}

}

list_add_tail_rcu(&ops->list, &link_ops);

unlock:

mutex_unlock(&link_ops_mutex);

if (err)

cleanup_srcu_struct(&ops->srcu);

return err;

}

EXPORT_SYMBOL_GPL(rtnl_link_register);

static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops)

{

struct net_device *dev;

LIST_HEAD(list_kill);

for_each_netdev(net, dev) {

if (dev->rtnl_link_ops == ops)

ops->dellink(dev, &list_kill);

}

unregister_netdevice_many(&list_kill);

}

/* Return with the rtnl_lock held when there are no network

* devices unregistering in any network namespace.

*/

static void rtnl_lock_unregistering_all(void)

{

DEFINE_WAIT_FUNC(wait, woken_wake_function);

add_wait_queue(&netdev_unregistering_wq, &wait);

for (;;) {

rtnl_lock();

/* We held write locked pernet_ops_rwsem, and parallel

* setup_net() and cleanup_net() are not possible.

*/

if (!atomic_read(&dev_unreg_count))

break;

__rtnl_unlock();

wait_woken(&wait, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);

}

remove_wait_queue(&netdev_unregistering_wq, &wait);

}

/**

* 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)

{

struct net *net;

mutex_lock(&link_ops_mutex);

list_del_rcu(&ops->list);

mutex_unlock(&link_ops_mutex);

synchronize_srcu(&ops->srcu);

cleanup_srcu_struct(&ops->srcu);

/* Close the race with setup_net() and cleanup_net() */

down_write(&pernet_ops_rwsem);

rtnl_lock_unregistering_all();

for_each_net(net)

__rtnl_kill_links(net, ops);

rtnl_unlock();

up_write(&pernet_ops_rwsem);

}

EXPORT_SYMBOL_GPL(rtnl_link_unregister);

static size_t rtnl_link_get_slave_info_data_size(const struct net_device *dev)

{

struct net_device *master_dev;

const struct rtnl_link_ops *ops;

size_t size = 0;

rcu_read_lock();

master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev);

if (!master_dev)

goto out;

ops = master_dev->rtnl_link_ops;

if (!ops)

goto out;

size += nla_total_size(strlen(ops->kind) + 1); /* IFLA_INFO_SLAVE_KIND */

if (!ops->get_slave_size)

goto out;

/* IFLA_INFO_SLAVE_DATA + nested data */

size += nla_total_size(sizeof(struct nlattr)) +

ops->get_slave_size(master_dev, dev);

out:

rcu_read_unlock();

return size;

}

static size_t rtnl_link_get_size(const struct net_device *dev)

{

const struct rtnl_link_ops *ops = dev->rtnl_link_ops;

size_t size;

if (!ops)

return 0;

size = nla_total_size(sizeof(struct nlattr)) + /* IFLA_LINKINFO */

nla_total_size(strlen(ops->kind) + 1); /* IFLA_INFO_KIND */

if (ops->get_size)

/* IFLA_INFO_DATA + nested data */

size += nla_total_size(sizeof(struct nlattr)) +

ops->get_size(dev);

if (ops->get_xstats_size)

/* IFLA_INFO_XSTATS */

size += nla_total_size(ops->get_xstats_size(dev));

size += rtnl_link_get_slave_info_data_size(dev);

return size;

}

static LIST_HEAD(rtnl_af_ops);

static struct rtnl_af_ops *rtnl_af_lookup(const int family, int *srcu_index)

{

struct rtnl_af_ops *ops;

ASSERT_RTNL();

rcu_read_lock();

list_for_each_entry_rcu(ops, &rtnl_af_ops, list) {

if (ops->family == family) {

*srcu_index = srcu_read_lock(&ops->srcu);

goto unlock;

}

}

ops = NULL;

unlock:

rcu_read_unlock();

return ops;

}

static void rtnl_af_put(struct rtnl_af_ops *ops, int srcu_index)

{

srcu_read_unlock(&ops->srcu, srcu_index);

}

/**

* rtnl_af_register - Register rtnl_af_ops with rtnetlink.

* @ops: struct rtnl_af_ops * to register

*

* Return: 0 on success or a negative error code.

*/

int rtnl_af_register(struct rtnl_af_ops *ops)

{

int err = init_srcu_struct(&ops->srcu);

if (err)

return err;

rtnl_lock();

list_add_tail_rcu(&ops->list, &rtnl_af_ops);

rtnl_unlock();

return 0;

}

EXPORT_SYMBOL_GPL(rtnl_af_register);

/**

* 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)

{

rtnl_lock();

list_del_rcu(&ops->list);

rtnl_unlock();

synchronize_rcu();

synchronize_srcu(&ops->srcu);

cleanup_srcu_struct(&ops->srcu);

}

EXPORT_SYMBOL_GPL(rtnl_af_unregister);

static size_t rtnl_link_get_af_size(const struct net_device *dev,

u32 ext_filter_mask)

{

struct rtnl_af_ops *af_ops;

size_t size;

/* IFLA_AF_SPEC */

size = nla_total_size(sizeof(struct nlattr));

rcu_read_lock();

list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {

if (af_ops->get_link_af_size) {

/* AF_* + nested data */

size += nla_total_size(sizeof(struct nlattr)) +

af_ops->get_link_af_size(dev, ext_filter_mask);

}

}

rcu_read_unlock();

return size;

}

static bool rtnl_have_link_slave_info(const struct net_device *dev)

{

struct net_device *master_dev;

bool ret = false;

rcu_read_lock();

master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev);

if (master_dev && master_dev->rtnl_link_ops)

ret = true;

rcu_read_unlock();

return ret;

}

static int rtnl_link_slave_info_fill(struct sk_buff *skb,

const struct net_device *dev)

{

struct net_device *master_dev;

const struct rtnl_link_ops *ops;

struct nlattr *slave_data;

int err;

master_dev = netdev_master_upper_dev_get((struct net_device *) dev);

if (!master_dev)

return 0;

ops = master_dev->rtnl_link_ops;

if (!ops)

return 0;

if (nla_put_string(skb, IFLA_INFO_SLAVE_KIND, ops->kind) < 0)

return -EMSGSIZE;

if (ops->fill_slave_info) {

slave_data = nla_nest_start_noflag(skb, IFLA_INFO_SLAVE_DATA);

if (!slave_data)

return -EMSGSIZE;

err = ops->fill_slave_info(skb, master_dev, dev);

if (err < 0)

goto err_cancel_slave_data;

nla_nest_end(skb, slave_data);

}

return 0;

err_cancel_slave_data:

nla_nest_cancel(skb, slave_data);

return err;

}

static int rtnl_link_info_fill(struct sk_buff *skb,

const struct net_device *dev)

{

const struct rtnl_link_ops *ops = dev->rtnl_link_ops;

struct nlattr *data;

int err;

if (!ops)

return 0;

if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0)

return -EMSGSIZE;

if (ops->fill_xstats) {

err = ops->fill_xstats(skb, dev);

if (err < 0)

return err;

}

if (ops->fill_info) {

data = nla_nest_start_noflag(skb, IFLA_INFO_DATA);

if (data == NULL)

return -EMSGSIZE;

err = ops->fill_info(skb, dev);

if (err < 0)

goto err_cancel_data;

nla_nest_end(skb, data);

}

return 0;

err_cancel_data:

nla_nest_cancel(skb, data);

return err;

}

static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev)

{

struct nlattr *linkinfo;

int err = -EMSGSIZE;

linkinfo = nla_nest_start_noflag(skb, IFLA_LINKINFO);

if (linkinfo == NULL)

goto out;

err = rtnl_link_info_fill(skb, dev);

if (err < 0)

goto err_cancel_link;

err = rtnl_link_slave_info_fill(skb, dev);

if (err < 0)

goto err_cancel_link;

nla_nest_end(skb, linkinfo);

return 0;

err_cancel_link:

nla_nest_cancel(skb, linkinfo);

out:

return err;

}

int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo)

{

struct sock *rtnl = net->rtnl;

return nlmsg_notify(rtnl, skb, pid, group, echo, GFP_KERNEL);

}

int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid)

{

struct sock *rtnl = net->rtnl;

return nlmsg_unicast(rtnl, skb, pid);

}

EXPORT_SYMBOL(rtnl_unicast);

void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group,

const struct nlmsghdr *nlh, gfp_t flags)

{

struct sock *rtnl = net->rtnl;

nlmsg_notify(rtnl, skb, pid, group, nlmsg_report(nlh), flags);

}

EXPORT_SYMBOL(rtnl_notify);

void rtnl_set_sk_err(struct net *net, u32 group, int error)

{

struct sock *rtnl = net->rtnl;

netlink_set_err(rtnl, 0, group, error);

}

EXPORT_SYMBOL(rtnl_set_sk_err);

int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)

{

struct nlattr *mx;

int i, valid = 0;

/* nothing is dumped for dst_default_metrics, so just skip the loop */

if (metrics == dst_default_metrics.metrics)

return 0;

mx = nla_nest_start_noflag(skb, RTA_METRICS);

if (mx == NULL)

return -ENOBUFS;

for (i = 0; i < RTAX_MAX; i++) {

if (metrics[i]) {

if (i == RTAX_CC_ALGO - 1) {

char tmp[TCP_CA_NAME_MAX], *name;

name = tcp_ca_get_name_by_key(metrics[i], tmp);

if (!name)

continue;

if (nla_put_string(skb, i + 1, name))

goto nla_put_failure;

} else if (i == RTAX_FEATURES - 1) {

u32 user_features = metrics[i] & RTAX_FEATURE_MASK;