/*
   * 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>
   *
   *		This program is free software; you can redistribute it and/or
   *		modify it under the terms of the GNU General Public License
   *		as published by the Free Software Foundation; either version
   *		2 of the License, or (at your option) any later version.
   *
   *	Fixes:
   *	Vitaly E. Lavrov		RTA_OK arithmetics 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/switchdev.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>

  struct rtnl_link {

  	rtnl_doit_func		doit;
  	rtnl_dumpit_func	dumpit;

  	unsigned int		flags;

  };

  static DEFINE_MUTEX(rtnl_mutex);

  
  void rtnl_lock(void)
  {

  	mutex_lock(&rtnl_mutex);

  }

  EXPORT_SYMBOL(rtnl_lock);

  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;

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

  #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 */

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

  static refcount_t rtnl_msg_handlers_ref[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;
  }

  /**
   * __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 modifiy 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.
   *
   * Returns 0 on success or a negative error code.
   */
  int __rtnl_register(int protocol, int msgtype,

  		    rtnl_doit_func doit, rtnl_dumpit_func dumpit,

  		    unsigned int flags)

  {
  	struct rtnl_link *tab;
  	int msgindex;

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

  	msgindex = rtm_msgindex(msgtype);

  	tab = rcu_dereference_raw(rtnl_msg_handlers[protocol]);

  	if (tab == NULL) {
  		tab = kcalloc(RTM_NR_MSGTYPES, sizeof(*tab), GFP_KERNEL);
  		if (tab == NULL)
  			return -ENOBUFS;

  		rcu_assign_pointer(rtnl_msg_handlers[protocol], tab);

  	}
  
  	if (doit)
  		tab[msgindex].doit = doit;

  	if (dumpit)
  		tab[msgindex].dumpit = dumpit;

  	tab[msgindex].flags |= flags;

  
  	return 0;
  }

  EXPORT_SYMBOL_GPL(__rtnl_register);
  
  /**
   * rtnl_register - Register a rtnetlink message type
   *
   * Identical to __rtnl_register() but panics on failure. This is useful
   * as failure of this function is very unlikely, it can only happen due
   * to lack of memory when allocating the chain to store all message
   * handlers for a protocol. Meant for use in init functions where lack

   * of memory implies no sense in continuing.

   */
  void rtnl_register(int protocol, int msgtype,

  		   rtnl_doit_func doit, rtnl_dumpit_func dumpit,

  		   unsigned int flags)

  {

  	if (__rtnl_register(protocol, msgtype, doit, dumpit, flags) < 0)

  		panic("Unable to register rtnetlink message handler, "
  		      "protocol = %d, message type = %d
  ",
  		      protocol, msgtype);
  }

  EXPORT_SYMBOL_GPL(rtnl_register);
  
  /**
   * 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)
  {

  	struct rtnl_link *handlers;

  	int msgindex;

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

  	msgindex = rtm_msgindex(msgtype);

  	rtnl_lock();
  	handlers = rtnl_dereference(rtnl_msg_handlers[protocol]);
  	if (!handlers) {
  		rtnl_unlock();

  		return -ENOENT;

  	}

  	handlers[msgindex].doit = NULL;
  	handlers[msgindex].dumpit = NULL;

  	handlers[msgindex].flags = 0;

  	rtnl_unlock();

  
  	return 0;
  }

  EXPORT_SYMBOL_GPL(rtnl_unregister);
  
  /**
   * 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)
  {

  	struct rtnl_link *handlers;

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

  	rtnl_lock();

  	handlers = rtnl_dereference(rtnl_msg_handlers[protocol]);
  	RCU_INIT_POINTER(rtnl_msg_handlers[protocol], NULL);

  	rtnl_unlock();

  	synchronize_net();

  	while (refcount_read(&rtnl_msg_handlers_ref[protocol]) > 1)

  		schedule();
  	kfree(handlers);

  }

  EXPORT_SYMBOL_GPL(rtnl_unregister_all);

  static LIST_HEAD(link_ops);

  static const struct rtnl_link_ops *rtnl_link_ops_get(const char *kind)
  {
  	const struct rtnl_link_ops *ops;
  
  	list_for_each_entry(ops, &link_ops, list) {
  		if (!strcmp(ops->kind, kind))
  			return ops;
  	}
  	return NULL;
  }

  /**
   * __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)
  {

  	if (rtnl_link_ops_get(ops->kind))
  		return -EEXIST;

  	/* The check for 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->setup && !ops->dellink)

  		ops->dellink = unregister_netdevice_queue;

  	list_add_tail(&ops->list, &link_ops);
  	return 0;
  }

  EXPORT_SYMBOL_GPL(__rtnl_link_register);
  
  /**
   * 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)
  {
  	int err;
  
  	rtnl_lock();
  	err = __rtnl_link_register(ops);
  	rtnl_unlock();
  	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);

  }

  /**
   * __rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
   * @ops: struct rtnl_link_ops * to unregister
   *

   * The caller must hold the rtnl_mutex.

   */
  void __rtnl_link_unregister(struct rtnl_link_ops *ops)
  {

  	struct net *net;

  	for_each_net(net) {

  		__rtnl_kill_links(net, ops);

  	}

  	list_del(&ops->list);
  }

  EXPORT_SYMBOL_GPL(__rtnl_link_unregister);

  /* Return with the rtnl_lock held when there are no network
   * devices unregistering in any network namespace.
   */
  static void rtnl_lock_unregistering_all(void)
  {
  	struct net *net;
  	bool unregistering;

  	DEFINE_WAIT_FUNC(wait, woken_wake_function);

  	add_wait_queue(&netdev_unregistering_wq, &wait);

  	for (;;) {

  		unregistering = false;
  		rtnl_lock();
  		for_each_net(net) {
  			if (net->dev_unreg_count > 0) {
  				unregistering = true;
  				break;
  			}
  		}
  		if (!unregistering)
  			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)
  {

  	/* Close the race with cleanup_net() */
  	mutex_lock(&net_mutex);
  	rtnl_lock_unregistering_all();

  	__rtnl_link_unregister(ops);
  	rtnl_unlock();

  	mutex_unlock(&net_mutex);

  }

  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 || !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 const struct rtnl_af_ops *rtnl_af_lookup(const int family)
  {
  	const struct rtnl_af_ops *ops;
  
  	list_for_each_entry(ops, &rtnl_af_ops, list) {
  		if (ops->family == family)
  			return ops;
  	}
  
  	return NULL;
  }
  
  /**

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

  {

  	rtnl_lock();

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

  	rtnl_unlock();

  }
  EXPORT_SYMBOL_GPL(rtnl_af_register);
  
  /**
   * __rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink.
   * @ops: struct rtnl_af_ops * to unregister
   *
   * The caller must hold the rtnl_mutex.
   */
  void __rtnl_af_unregister(struct rtnl_af_ops *ops)
  {
  	list_del(&ops->list);
  }
  EXPORT_SYMBOL_GPL(__rtnl_af_unregister);
  
  /**
   * 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();
  	__rtnl_af_unregister(ops);
  	rtnl_unlock();
  }
  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));
  
  	list_for_each_entry(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);

  		}
  	}
  
  	return size;
  }

  static bool rtnl_have_link_slave_info(const struct net_device *dev)

  {

  	struct net_device *master_dev;

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

  	if (master_dev && master_dev->rtnl_link_ops)

  		return true;
  	return false;
  }
  
  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(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(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(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;

  	int err = 0;

  	NETLINK_CB(skb).dst_group = group;

  	if (echo)

  		refcount_inc(&skb->users);

  	netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL);
  	if (echo)
  		err = netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT);
  	return err;
  }

  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,
  		 struct nlmsghdr *nlh, gfp_t flags)

  {

  	struct sock *rtnl = net->rtnl;

  	int report = 0;
  
  	if (nlh)
  		report = nlmsg_report(nlh);

  	nlmsg_notify(rtnl, skb, pid, group, report, 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;
  
  	mx = nla_nest_start(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;

  				if (!user_features)
  					continue;

  				BUILD_BUG_ON(RTAX_FEATURE_MASK & DST_FEATURE_MASK);
  				if (nla_put_u32(skb, i + 1, user_features))
  					goto nla_put_failure;

  			} else {
  				if (nla_put_u32(skb, i + 1, metrics[i]))
  					goto nla_put_failure;
  			}

  			valid++;

  		}

  	}

  	if (!valid) {
  		nla_nest_cancel(skb, mx);
  		return 0;
  	}

  
  	return nla_nest_end(skb, mx);
  
  nla_put_failure:

  	nla_nest_cancel(skb, mx);
  	return -EMSGSIZE;

  }

  EXPORT_SYMBOL(rtnetlink_put_metrics);

  int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,

  		       long expires, u32 error)

  {
  	struct rta_cacheinfo ci = {

  		.rta_lastuse = jiffies_delta_to_clock_t(jiffies - dst->lastuse),

  		.rta_used = dst->__use,
  		.rta_clntref = atomic_read(&(dst->__refcnt)),
  		.rta_error = error,
  		.rta_id =  id,

  	};

  	if (expires) {
  		unsigned long clock;

  		clock = jiffies_to_clock_t(abs(expires));
  		clock = min_t(unsigned long, clock, INT_MAX);
  		ci.rta_expires = (expires > 0) ? clock : -clock;
  	}

  	return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci);
  }

  EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);

  static void set_operstate(struct net_device *dev, unsigned char transition)

  {
  	unsigned char operstate = dev->operstate;

  	switch (transition) {

  	case IF_OPER_UP:
  		if ((operstate == IF_OPER_DORMANT ||
  		     operstate == IF_OPER_UNKNOWN) &&
  		    !netif_dormant(dev))
  			operstate = IF_OPER_UP;
  		break;
  
  	case IF_OPER_DORMANT:
  		if (operstate == IF_OPER_UP ||
  		    operstate == IF_OPER_UNKNOWN)
  			operstate = IF_OPER_DORMANT;
  		break;

  	}

  
  	if (dev->operstate != operstate) {
  		write_lock_bh(&dev_base_lock);
  		dev->operstate = operstate;
  		write_unlock_bh(&dev_base_lock);

  		netdev_state_change(dev);
  	}

  }

  static unsigned int rtnl_dev_get_flags(const struct net_device *dev)
  {
  	return (dev->flags & ~(IFF_PROMISC | IFF_ALLMULTI)) |
  	       (dev->gflags & (IFF_PROMISC | IFF_ALLMULTI));
  }

  static unsigned int rtnl_dev_combine_flags(const struct net_device *dev,
  					   const struct ifinfomsg *ifm)
  {
  	unsigned int flags = ifm->ifi_flags;
  
  	/* bugwards compatibility: ifi_change == 0 is treated as ~0 */
  	if (ifm->ifi_change)
  		flags = (flags & ifm->ifi_change) |

  			(rtnl_dev_get_flags(dev) & ~ifm->ifi_change);

  
  	return flags;
  }

  static void copy_rtnl_link_stats(struct rtnl_link_stats *a,

  				 const struct rtnl_link_stats64 *b)

  {

  	a->rx_packets = b->rx_packets;
  	a->tx_packets = b->tx_packets;
  	a->rx_bytes = b->rx_bytes;
  	a->tx_bytes = b->tx_bytes;
  	a->rx_errors = b->rx_errors;
  	a->tx_errors = b->tx_errors;
  	a->rx_dropped = b->rx_dropped;
  	a->tx_dropped = b->tx_dropped;
  
  	a->multicast = b->multicast;
  	a->collisions = b->collisions;
  
  	a->rx_length_errors = b->rx_length_errors;
  	a->rx_over_errors = b->rx_over_errors;
  	a->rx_crc_errors = b->rx_crc_errors;
  	a->rx_frame_errors = b->rx_frame_errors;
  	a->rx_fifo_errors = b->rx_fifo_errors;
  	a->rx_missed_errors = b->rx_missed_errors;
  
  	a->tx_aborted_errors = b->tx_aborted_errors;
  	a->tx_carrier_errors = b->tx_carrier_errors;
  	a->tx_fifo_errors = b->tx_fifo_errors;
  	a->tx_heartbeat_errors = b->tx_heartbeat_errors;
  	a->tx_window_errors = b->tx_window_errors;
  
  	a->rx_compressed = b->rx_compressed;
  	a->tx_compressed = b->tx_compressed;

  
  	a->rx_nohandler = b->rx_nohandler;

  }

  /* All VF info */

  static inline int rtnl_vfinfo_size(const struct net_device *dev,
  				   u32 ext_filter_mask)

  {

  	if (dev->dev.parent && (ext_filter_mask & RTEXT_FILTER_VF)) {

  		int num_vfs = dev_num_vf(dev->dev.parent);

  		size_t size = nla_total_size(0);

  		size += num_vfs *

  			(nla_total_size(0) +
  			 nla_total_size(sizeof(struct ifla_vf_mac)) +
  			 nla_total_size(sizeof(struct ifla_vf_vlan)) +
  			 nla_total_size(0) + /* nest IFLA_VF_VLAN_LIST */

  			 nla_total_size(MAX_VLAN_LIST_LEN *
  					sizeof(struct ifla_vf_vlan_info)) +

  			 nla_total_size(sizeof(struct ifla_vf_spoofchk)) +

  			 nla_total_size(sizeof(struct ifla_vf_tx_rate)) +

  			 nla_total_size(sizeof(struct ifla_vf_rate)) +

  			 nla_total_size(sizeof(struct ifla_vf_link_state)) +

  			 nla_total_size(sizeof(struct ifla_vf_rss_query_en)) +

  			 nla_total_size(0) + /* nest IFLA_VF_STATS */

  			 /* IFLA_VF_STATS_RX_PACKETS */

  			 nla_total_size_64bit(sizeof(__u64)) +

  			 /* IFLA_VF_STATS_TX_PACKETS */

  			 nla_total_size_64bit(sizeof(__u64)) +

  			 /* IFLA_VF_STATS_RX_BYTES */

  			 nla_total_size_64bit(sizeof(__u64)) +

  			 /* IFLA_VF_STATS_TX_BYTES */

  			 nla_total_size_64bit(sizeof(__u64)) +

  			 /* IFLA_VF_STATS_BROADCAST */

  			 nla_total_size_64bit(sizeof(__u64)) +

  			 /* IFLA_VF_STATS_MULTICAST */

  			 nla_total_size_64bit(sizeof(__u64)) +

  			 nla_total_size(sizeof(struct ifla_vf_trust)));

  		return size;
  	} else

  		return 0;
  }

  static size_t rtnl_port_size(const struct net_device *dev,
  			     u32 ext_filter_mask)

  {
  	size_t port_size = nla_total_size(4)		/* PORT_VF */
  		+ nla_total_size(PORT_PROFILE_MAX)	/* PORT_PROFILE */

  		+ nla_total_size(PORT_UUID_MAX)		/* PORT_INSTANCE_UUID */
  		+ nla_total_size(PORT_UUID_MAX)		/* PORT_HOST_UUID */
  		+ nla_total_size(1)			/* PROT_VDP_REQUEST */
  		+ nla_total_size(2);			/* PORT_VDP_RESPONSE */
  	size_t vf_ports_size = nla_total_size(sizeof(struct nlattr));
  	size_t vf_port_size = nla_total_size(sizeof(struct nlattr))
  		+ port_size;
  	size_t port_self_size = nla_total_size(sizeof(struct nlattr))
  		+ port_size;

  	if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
  	    !(ext_filter_mask & RTEXT_FILTER_VF))

  		return 0;
  	if (dev_num_vf(dev->dev.parent))
  		return port_self_size + vf_ports_size +
  			vf_port_size * dev_num_vf(dev->dev.parent);
  	else
  		return port_self_size;
  }

  static size_t rtnl_xdp_size(void)

  {

  	size_t xdp_size = nla_total_size(0) +	/* nest IFLA_XDP */

  			  nla_total_size(1) +	/* XDP_ATTACHED */
  			  nla_total_size(4);	/* XDP_PROG_ID */

  	return xdp_size;

  }

  static noinline size_t if_nlmsg_size(const struct net_device *dev,
  				     u32 ext_filter_mask)

  {
  	return NLMSG_ALIGN(sizeof(struct ifinfomsg))
  	       + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */

  	       + nla_total_size(IFALIASZ) /* IFLA_IFALIAS */

  	       + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */

  	       + nla_total_size_64bit(sizeof(struct rtnl_link_ifmap))

  	       + nla_total_size(sizeof(struct rtnl_link_stats))

  	       + nla_total_size_64bit(sizeof(struct rtnl_link_stats64))

  	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
  	       + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */
  	       + nla_total_size(4) /* IFLA_TXQLEN */
  	       + nla_total_size(4) /* IFLA_WEIGHT */
  	       + nla_total_size(4) /* IFLA_MTU */
  	       + nla_total_size(4) /* IFLA_LINK */
  	       + nla_total_size(4) /* IFLA_MASTER */

  	       + nla_total_size(1) /* IFLA_CARRIER */

  	       + nla_total_size(4) /* IFLA_PROMISCUITY */

  	       + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */
  	       + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */

  	       + nla_total_size(4) /* IFLA_GSO_MAX_SEGS */
  	       + nla_total_size(4) /* IFLA_GSO_MAX_SIZE */

  	       + nla_total_size(1) /* IFLA_OPERSTATE */

  	       + nla_total_size(1) /* IFLA_LINKMODE */

  	       + nla_total_size(4) /* IFLA_CARRIER_CHANGES */

  	       + nla_total_size(4) /* IFLA_LINK_NETNSID */

  	       + nla_total_size(4) /* IFLA_GROUP */

  	       + nla_total_size(ext_filter_mask
  			        & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */
  	       + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */

  	       + rtnl_port_size(dev, ext_filter_mask) /* IFLA_VF_PORTS + IFLA_PORT_SELF */

  	       + rtnl_link_get_size(dev) /* IFLA_LINKINFO */

  	       + rtnl_link_get_af_size(dev, ext_filter_mask) /* IFLA_AF_SPEC */

  	       + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_PORT_ID */

  	       + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_SWITCH_ID */

  	       + nla_total_size(IFNAMSIZ) /* IFLA_PHYS_PORT_NAME */

  	       + rtnl_xdp_size() /* IFLA_XDP */

  	       + nla_total_size(4)  /* IFLA_EVENT */

  	       + nla_total_size(1); /* IFLA_PROTO_DOWN */

  }

  static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev)
  {
  	struct nlattr *vf_ports;
  	struct nlattr *vf_port;
  	int vf;
  	int err;
  
  	vf_ports = nla_nest_start(skb, IFLA_VF_PORTS);
  	if (!vf_ports)
  		return -EMSGSIZE;
  
  	for (vf = 0; vf < dev_num_vf(dev->dev.parent); vf++) {
  		vf_port = nla_nest_start(skb, IFLA_VF_PORT);

  		if (!vf_port)
  			goto nla_put_failure;

  		if (nla_put_u32(skb, IFLA_PORT_VF, vf))
  			goto nla_put_failure;

  		err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb);

  		if (err == -EMSGSIZE)
  			goto nla_put_failure;

  		if (err) {

  			nla_nest_cancel(skb, vf_port);
  			continue;
  		}
  		nla_nest_end(skb, vf_port);
  	}
  
  	nla_nest_end(skb, vf_ports);
  
  	return 0;

  
  nla_put_failure:
  	nla_nest_cancel(skb, vf_ports);
  	return -EMSGSIZE;

  }
  
  static int rtnl_port_self_fill(struct sk_buff *skb, struct net_device *dev)
  {
  	struct nlattr *port_self;
  	int err;
  
  	port_self = nla_nest_start(skb, IFLA_PORT_SELF);
  	if (!port_self)
  		return -EMSGSIZE;
  
  	err = dev->netdev_ops->ndo_get_vf_port(dev, PORT_SELF_VF, skb);
  	if (err) {
  		nla_nest_cancel(skb, port_self);

  		return (err == -EMSGSIZE) ? err : 0;

  	}
  
  	nla_nest_end(skb, port_self);
  
  	return 0;
  }

  static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev,
  			  u32 ext_filter_mask)

  {
  	int err;

  	if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
  	    !(ext_filter_mask & RTEXT_FILTER_VF))

  		return 0;
  
  	err = rtnl_port_self_fill(skb, dev);
  	if (err)
  		return err;
  
  	if (dev_num_vf(dev->dev.parent)) {
  		err = rtnl_vf_ports_fill(skb, dev);
  		if (err)
  			return err;
  	}
  
  	return 0;
  }

  static int rtnl_phys_port_id_fill(struct sk_buff *skb, struct net_device *dev)
  {
  	int err;

  	struct netdev_phys_item_id ppid;

  
  	err = dev_get_phys_port_id(dev, &ppid);
  	if (err) {
  		if (err == -EOPNOTSUPP)
  			return 0;
  		return err;
  	}
  
  	if (nla_put(skb, IFLA_PHYS_PORT_ID, ppid.id_len, ppid.id))
  		return -EMSGSIZE;
  
  	return 0;
  }

  static int rtnl_phys_port_name_fill(struct sk_buff *skb, struct net_device *dev)
  {
  	char name[IFNAMSIZ];
  	int err;
  
  	err = dev_get_phys_port_name(dev, name, sizeof(name));
  	if (err) {
  		if (err == -EOPNOTSUPP)
  			return 0;
  		return err;
  	}

  	if (nla_put_string(skb, IFLA_PHYS_PORT_NAME, name))

  		return -EMSGSIZE;
  
  	return 0;
  }

  static int rtnl_phys_switch_id_fill(struct sk_buff *skb, struct net_device *dev)
  {
  	int err;

  	struct switchdev_attr attr = {

  		.orig_dev = dev,

  		.id = SWITCHDEV_ATTR_ID_PORT_PARENT_ID,

  		.flags = SWITCHDEV_F_NO_RECURSE,
  	};

  	err = switchdev_port_attr_get(dev, &attr);

  	if (err) {
  		if (err == -EOPNOTSUPP)
  			return 0;
  		return err;
  	}

  	if (nla_put(skb, IFLA_PHYS_SWITCH_ID, attr.u.ppid.id_len,
  		    attr.u.ppid.id))

  		return -EMSGSIZE;
  
  	return 0;
  }

  static noinline_for_stack int rtnl_fill_stats(struct sk_buff *skb,
  					      struct net_device *dev)
  {

  	struct rtnl_link_stats64 *sp;

  	struct nlattr *attr;

  	attr = nla_reserve_64bit(skb, IFLA_STATS64,
  				 sizeof(struct rtnl_link_stats64), IFLA_PAD);

  	if (!attr)
  		return -EMSGSIZE;

  	sp = nla_data(attr);
  	dev_get_stats(dev, sp);

  	attr = nla_reserve(skb, IFLA_STATS,
  			   sizeof(struct rtnl_link_stats));

  	if (!attr)
  		return -EMSGSIZE;

  	copy_rtnl_link_stats(nla_data(attr), sp);

  
  	return 0;
  }
  
  static noinline_for_stack int rtnl_fill_vfinfo(struct sk_buff *skb,
  					       struct net_device *dev,
  					       int vfs_num,
  					       struct nlattr *vfinfo)
  {
  	struct ifla_vf_rss_query_en vf_rss_query_en;

  	struct nlattr *vf, *vfstats, *vfvlanlist;

  	struct ifla_vf_link_state vf_linkstate;

  	struct ifla_vf_vlan_info vf_vlan_info;

  	struct ifla_vf_spoofchk vf_spoofchk;
  	struct ifla_vf_tx_rate vf_tx_rate;
  	struct ifla_vf_stats vf_stats;
  	struct ifla_vf_trust vf_trust;
  	struct ifla_vf_vlan vf_vlan;
  	struct ifla_vf_rate vf_rate;

  	struct ifla_vf_mac vf_mac;
  	struct ifla_vf_info ivi;

  	memset(&ivi, 0, sizeof(ivi));

  	/* Not all SR-IOV capable drivers support the
  	 * spoofcheck and "RSS query enable" query.  Preset to
  	 * -1 so the user space tool can detect that the driver
  	 * didn't report anything.
  	 */
  	ivi.spoofchk = -1;
  	ivi.rss_query_en = -1;
  	ivi.trusted = -1;

  	/* The default value for VF link state is "auto"
  	 * IFLA_VF_LINK_STATE_AUTO which equals zero
  	 */
  	ivi.linkstate = 0;

  	/* VLAN Protocol by default is 802.1Q */
  	ivi.vlan_proto = htons(ETH_P_8021Q);

  	if (dev->netdev_ops->ndo_get_vf_config(dev, vfs_num, &ivi))
  		return 0;

  	memset(&vf_vlan_info, 0, sizeof(vf_vlan_info));

  	vf_mac.vf =
  		vf_vlan.vf =

  		vf_vlan_info.vf =

  		vf_rate.vf =
  		vf_tx_rate.vf =
  		vf_spoofchk.vf =
  		vf_linkstate.vf =
  		vf_rss_query_en.vf =
  		vf_trust.vf = ivi.vf;
  
  	memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac));
  	vf_vlan.vlan = ivi.vlan;
  	vf_vlan.qos = ivi.qos;

  	vf_vlan_info.vlan = ivi.vlan;
  	vf_vlan_info.qos = ivi.qos;
  	vf_vlan_info.vlan_proto = ivi.vlan_proto;

  	vf_tx_rate.rate = ivi.max_tx_rate;
  	vf_rate.min_tx_rate = ivi.min_tx_rate;
  	vf_rate.max_tx_rate = ivi.max_tx_rate;
  	vf_spoofchk.setting = ivi.spoofchk;
  	vf_linkstate.link_state = ivi.linkstate;
  	vf_rss_query_en.setting = ivi.rss_query_en;
  	vf_trust.setting = ivi.trusted;
  	vf = nla_nest_start(skb, IFLA_VF_INFO);

  	if (!vf)
  		goto nla_put_vfinfo_failure;

  	if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) ||
  	    nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) ||
  	    nla_put(skb, IFLA_VF_RATE, sizeof(vf_rate),
  		    &vf_rate) ||
  	    nla_put(skb, IFLA_VF_TX_RATE, sizeof(vf_tx_rate),
  		    &vf_tx_rate) ||
  	    nla_put(skb, IFLA_VF_SPOOFCHK, sizeof(vf_spoofchk),
  		    &vf_spoofchk) ||
  	    nla_put(skb, IFLA_VF_LINK_STATE, sizeof(vf_linkstate),
  		    &vf_linkstate) ||
  	    nla_put(skb, IFLA_VF_RSS_QUERY_EN,
  		    sizeof(vf_rss_query_en),
  		    &vf_rss_query_en) ||
  	    nla_put(skb, IFLA_VF_TRUST,
  		    sizeof(vf_trust), &vf_trust))

  		goto nla_put_vf_failure;
  	vfvlanlist = nla_nest_start(skb, IFLA_VF_VLAN_LIST);
  	if (!vfvlanlist)
  		goto nla_put_vf_failure;
  	if (nla_put(skb, IFLA_VF_VLAN_INFO, sizeof(vf_vlan_info),
  		    &vf_vlan_info)) {
  		nla_nest_cancel(skb, vfvlanlist);
  		goto nla_put_vf_failure;
  	}
  	nla_nest_end(skb, vfvlanlist);

  	memset(&vf_stats, 0, sizeof(vf_stats));
  	if (dev->netdev_ops->ndo_get_vf_stats)
  		dev->netdev_ops->ndo_get_vf_stats(dev, vfs_num,
  						&vf_stats);
  	vfstats = nla_nest_start(skb, IFLA_VF_STATS);

  	if (!vfstats)
  		goto nla_put_vf_failure;

  	if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS,
  			      vf_stats.rx_packets, IFLA_VF_STATS_PAD) ||
  	    nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS,
  			      vf_stats.tx_packets, IFLA_VF_STATS_PAD) ||
  	    nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES,
  			      vf_stats.rx_bytes, IFLA_VF_STATS_PAD) ||
  	    nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES,
  			      vf_stats.tx_bytes, IFLA_VF_STATS_PAD) ||
  	    nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST,
  			      vf_stats.broadcast, IFLA_VF_STATS_PAD) ||
  	    nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST,

  			      vf_stats.multicast, IFLA_VF_STATS_PAD)) {
  		nla_nest_cancel(skb, vfstats);
  		goto nla_put_vf_failure;
  	}

  	nla_nest_end(skb, vfstats);
  	nla_nest_end(skb, vf);
  	return 0;

  
  nla_put_vf_failure:
  	nla_nest_cancel(skb, vf);
  nla_put_vfinfo_failure:
  	nla_nest_cancel(skb, vfinfo);
  	return -EMSGSIZE;

  }
  
  static int rtnl_fill_link_ifmap(struct sk_buff *skb, struct net_device *dev)
  {

  	struct rtnl_link_ifmap map;
  
  	memset(&map, 0, sizeof(map));
  	map.mem_start   = dev->mem_start;
  	map.mem_end     = dev->mem_end;
  	map.base_addr   = dev->base_addr;
  	map.irq         = dev->irq;
  	map.dma         = dev->dma;
  	map.port        = dev->if_port;

  	if (nla_put_64bit(skb, IFLA_MAP, sizeof(map), &map, IFLA_PAD))

  		return -EMSGSIZE;
  
  	return 0;
  }

  static u8 rtnl_xdp_attached_mode(struct net_device *dev, u32 *prog_id)

  {
  	const struct net_device_ops *ops = dev->netdev_ops;

  	const struct bpf_prog *generic_xdp_prog;

  
  	ASSERT_RTNL();

  	*prog_id = 0;
  	generic_xdp_prog = rtnl_dereference(dev->xdp_prog);
  	if (generic_xdp_prog) {
  		*prog_id = generic_xdp_prog->aux->id;

  		return XDP_ATTACHED_SKB;

  	}

  	if (!ops->ndo_xdp)
  		return XDP_ATTACHED_NONE;

  	return __dev_xdp_attached(dev, ops->ndo_xdp, prog_id);

  }

  static int rtnl_xdp_fill(struct sk_buff *skb, struct net_device *dev)
  {

  	struct nlattr *xdp;

  	u32 prog_id;

  	int err;

  	xdp = nla_nest_start(skb, IFLA_XDP);
  	if (!xdp)
  		return -EMSGSIZE;

  
  	err = nla_put_u8(skb, IFLA_XDP_ATTACHED,

  			 rtnl_xdp_attached_mode(dev, &prog_id));

  	if (err)
  		goto err_cancel;

  	if (prog_id) {
  		err = nla_put_u32(skb, IFLA_XDP_PROG_ID, prog_id);
  		if (err)
  			goto err_cancel;
  	}

  	nla_nest_end(skb, xdp);
  	return 0;
  
  err_cancel:
  	nla_nest_cancel(skb, xdp);
  	return err;
  }

  static u32 rtnl_get_event(unsigned long event)
  {
  	u32 rtnl_event_type = IFLA_EVENT_NONE;
  
  	switch (event) {
  	case NETDEV_REBOOT:
  		rtnl_event_type = IFLA_EVENT_REBOOT;
  		break;
  	case NETDEV_FEAT_CHANGE:
  		rtnl_event_type = IFLA_EVENT_FEATURES;
  		break;
  	case NETDEV_BONDING_FAILOVER:
  		rtnl_event_type = IFLA_EVENT_BONDING_FAILOVER;
  		break;
  	case NETDEV_NOTIFY_PEERS:
  		rtnl_event_type = IFLA_EVENT_NOTIFY_PEERS;
  		break;
  	case NETDEV_RESEND_IGMP:
  		rtnl_event_type = IFLA_EVENT_IGMP_RESEND;
  		break;
  	case NETDEV_CHANGEINFODATA:
  		rtnl_event_type = IFLA_EVENT_BONDING_OPTIONS;
  		break;
  	default:
  		break;
  	}
  
  	return rtnl_event_type;
  }

  static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,

  			    int type, u32 pid, u32 seq, u32 change,

  			    unsigned int flags, u32 ext_filter_mask,
  			    u32 event)

  {
  	struct ifinfomsg *ifm;
  	struct nlmsghdr *nlh;

  	struct nlattr *af_spec;

  	struct rtnl_af_ops *af_ops;

  	struct net_device *upper_dev = netdev_master_upper_dev_get(dev);

  	ASSERT_RTNL();

  	nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
  	if (nlh == NULL)

  		return -EMSGSIZE;

  	ifm = nlmsg_data(nlh);
  	ifm->ifi_family = AF_UNSPEC;
  	ifm->__ifi_pad = 0;
  	ifm->ifi_type = dev->type;
  	ifm->ifi_index = dev->ifindex;
  	ifm->ifi_flags = dev_get_flags(dev);
  	ifm->ifi_change = change;

  	if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
  	    nla_put_u32(skb, IFLA_TXQLEN, dev->tx_queue_len) ||
  	    nla_put_u8(skb, IFLA_OPERSTATE,
  		       netif_running(dev) ? dev->operstate : IF_OPER_DOWN) ||
  	    nla_put_u8(skb, IFLA_LINKMODE, dev->link_mode) ||
  	    nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
  	    nla_put_u32(skb, IFLA_GROUP, dev->group) ||

  	    nla_put_u32(skb, IFLA_PROMISCUITY, dev->promiscuity) ||

  	    nla_put_u32(skb, IFLA_NUM_TX_QUEUES, dev->num_tx_queues) ||

  	    nla_put_u32(skb, IFLA_GSO_MAX_SEGS, dev->gso_max_segs) ||
  	    nla_put_u32(skb, IFLA_GSO_MAX_SIZE, dev->gso_max_size) ||

  #ifdef CONFIG_RPS

  	    nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) ||

  #endif

  	    (dev->ifindex != dev_get_iflink(dev) &&
  	     nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))) ||

  	    (upper_dev &&
  	     nla_put_u32(skb, IFLA_MASTER, upper_dev->ifindex)) ||

  	    nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) ||

  	    (dev->qdisc &&
  	     nla_put_string(skb, IFLA_QDISC, dev->qdisc->ops->id)) ||
  	    (dev->ifalias &&

  	     nla_put_string(skb, IFLA_IFALIAS, dev->ifalias)) ||
  	    nla_put_u32(skb, IFLA_CARRIER_CHANGES,

  			atomic_read(&dev->carrier_changes)) ||
  	    nla_put_u8(skb, IFLA_PROTO_DOWN, dev->proto_down))

  		goto nla_put_failure;

  	if (event != IFLA_EVENT_NONE) {
  		if (nla_put_u32(skb, IFLA_EVENT, event))
  			goto nla_put_failure;
  	}

  	if (rtnl_fill_link_ifmap(skb, dev))
  		goto nla_put_failure;

  
  	if (dev->addr_len) {

  		if (nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr) ||
  		    nla_put(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast))
  			goto nla_put_failure;

  	}

  	if (rtnl_phys_port_id_fill(skb, dev))
  		goto nla_put_failure;

  	if (rtnl_phys_port_name_fill(skb, dev))
  		goto nla_put_failure;

  	if (rtnl_phys_switch_id_fill(skb, dev))
  		goto nla_put_failure;

  	if (rtnl_fill_stats(skb, dev))

  		goto nla_put_failure;

  	if (dev->dev.parent && (ext_filter_mask & RTEXT_FILTER_VF) &&
  	    nla_put_u32(skb, IFLA_NUM_VF, dev_num_vf(dev->dev.parent)))
  		goto nla_put_failure;

  	if (dev->netdev_ops->ndo_get_vf_config && dev->dev.parent &&
  	    ext_filter_mask & RTEXT_FILTER_VF) {

  		int i;

  		struct nlattr *vfinfo;

  		int num_vfs = dev_num_vf(dev->dev.parent);

  		vfinfo = nla_nest_start(skb, IFLA_VFINFO_LIST);
  		if (!vfinfo)
  			goto nla_put_failure;
  		for (i = 0; i < num_vfs; i++) {

  			if (rtnl_fill_vfinfo(skb, dev, i, vfinfo))

  				goto nla_put_failure;

  		}

  		nla_nest_end(skb, vfinfo);

  	}

  	if (rtnl_port_fill(skb, dev, ext_filter_mask))

  		goto nla_put_failure;

  	if (rtnl_xdp_fill(skb, dev))
  		goto nla_put_failure;

  	if (dev->rtnl_link_ops || rtnl_have_link_slave_info(dev)) {

  		if (rtnl_link_fill(skb, dev) < 0)
  			goto nla_put_failure;
  	}

  	if (dev->rtnl_link_ops &&
  	    dev->rtnl_link_ops->get_link_net) {
  		struct net *link_net = dev->rtnl_link_ops->get_link_net(dev);
  
  		if (!net_eq(dev_net(dev), link_net)) {

  			int id = peernet2id_alloc(dev_net(dev), link_net);

  
  			if (nla_put_s32(skb, IFLA_LINK_NETNSID, id))
  				goto nla_put_failure;
  		}
  	}

  	if (!(af_spec = nla_nest_start(skb, IFLA_AF_SPEC)))
  		goto nla_put_failure;
  
  	list_for_each_entry(af_ops, &rtnl_af_ops, list) {
  		if (af_ops->fill_link_af) {
  			struct nlattr *af;
  			int err;
  
  			if (!(af = nla_nest_start(skb, af_ops->family)))
  				goto nla_put_failure;

  			err = af_ops->fill_link_af(skb, dev, ext_filter_mask);

  
  			/*
  			 * Caller may return ENODATA to indicate that there
  			 * was no data to be dumped. This is not an error, it
  			 * means we should trim the attribute header and
  			 * continue.
  			 */
  			if (err == -ENODATA)
  				nla_nest_cancel(skb, af);
  			else if (err < 0)
  				goto nla_put_failure;
  
  			nla_nest_end(skb, af);
  		}
  	}
  
  	nla_nest_end(skb, af_spec);

  	nlmsg_end(skb, nlh);
  	return 0;

  
  nla_put_failure:

  	nlmsg_cancel(skb, nlh);
  	return -EMSGSIZE;

  }

  static const struct nla_policy ifla_policy[IFLA_MAX+1] = {

  	[IFLA_IFNAME]		= { .type = NLA_STRING, .len = IFNAMSIZ-1 },

  	[IFLA_ADDRESS]		= { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
  	[IFLA_BROADCAST]	= { .type = NLA_BINARY, .len = MAX_ADDR_LEN },

  	[IFLA_MAP]		= { .len = sizeof(struct rtnl_link_ifmap) },

  	[IFLA_MTU]		= { .type = NLA_U32 },

  	[IFLA_LINK]		= { .type = NLA_U32 },

  	[IFLA_MASTER]		= { .type = NLA_U32 },

  	[IFLA_CARRIER]		= { .type = NLA_U8 },

  	[IFLA_TXQLEN]		= { .type = NLA_U32 },
  	[IFLA_WEIGHT]		= { .type = NLA_U32 },
  	[IFLA_OPERSTATE]	= { .type = NLA_U8 },
  	[IFLA_LINKMODE]		= { .type = NLA_U8 },

  	[IFLA_LINKINFO]		= { .type = NLA_NESTED },

  	[IFLA_NET_NS_PID]	= { .type = NLA_U32 },

  	[IFLA_NET_NS_FD]	= { .type = NLA_U32 },

  	/* IFLA_IFALIAS is a string, but policy is set to NLA_BINARY to
  	 * allow 0-length string (needed to remove an alias).
  	 */
  	[IFLA_IFALIAS]	        = { .type = NLA_BINARY, .len = IFALIASZ - 1 },

  	[IFLA_VFINFO_LIST]	= {. type = NLA_NESTED },

  	[IFLA_VF_PORTS]		= { .type = NLA_NESTED },
  	[IFLA_PORT_SELF]	= { .type = NLA_NESTED },

  	[IFLA_AF_SPEC]		= { .type = NLA_NESTED },

  	[IFLA_EXT_MASK]		= { .type = NLA_U32 },

  	[IFLA_PROMISCUITY]	= { .type = NLA_U32 },

  	[IFLA_NUM_TX_QUEUES]	= { .type = NLA_U32 },
  	[IFLA_NUM_RX_QUEUES]	= { .type = NLA_U32 },

  	[IFLA_PHYS_PORT_ID]	= { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },

  	[IFLA_CARRIER_CHANGES]	= { .type = NLA_U32 },  /* ignored */

  	[IFLA_PHYS_SWITCH_ID]	= { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },

  	[IFLA_LINK_NETNSID]	= { .type = NLA_S32 },

  	[IFLA_PROTO_DOWN]	= { .type = NLA_U8 },

  	[IFLA_XDP]		= { .type = NLA_NESTED },

  	[IFLA_EVENT]		= { .type = NLA_U32 },

  	[IFLA_GROUP]		= { .type = NLA_U32 },

  };

  static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
  	[IFLA_INFO_KIND]	= { .type = NLA_STRING },
  	[IFLA_INFO_DATA]	= { .type = NLA_NESTED },

  	[IFLA_INFO_SLAVE_KIND]	= { .type = NLA_STRING },
  	[IFLA_INFO_SLAVE_DATA]	= { .type = NLA_NESTED },

  };

  static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = {

  	[IFLA_VF_MAC]		= { .len = sizeof(struct ifla_vf_mac) },
  	[IFLA_VF_VLAN]		= { .len = sizeof(struct ifla_vf_vlan) },

  	[IFLA_VF_VLAN_LIST]     = { .type = NLA_NESTED },

  	[IFLA_VF_TX_RATE]	= { .len = sizeof(struct ifla_vf_tx_rate) },
  	[IFLA_VF_SPOOFCHK]	= { .len = sizeof(struct ifla_vf_spoofchk) },
  	[IFLA_VF_RATE]		= { .len = sizeof(struct ifla_vf_rate) },
  	[IFLA_VF_LINK_STATE]	= { .len = sizeof(struct ifla_vf_link_state) },

  	[IFLA_VF_RSS_QUERY_EN]	= { .len = sizeof(struct ifla_vf_rss_query_en) },

  	[IFLA_VF_STATS]		= { .type = NLA_NESTED },

  	[IFLA_VF_TRUST]		= { .len = sizeof(struct ifla_vf_trust) },

  	[IFLA_VF_IB_NODE_GUID]	= { .len = sizeof(struct ifla_vf_guid) },
  	[IFLA_VF_IB_PORT_GUID]	= { .len = sizeof(struct ifla_vf_guid) },

  };

  static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = {
  	[IFLA_PORT_VF]		= { .type = NLA_U32 },
  	[IFLA_PORT_PROFILE]	= { .type = NLA_STRING,
  				    .len = PORT_PROFILE_MAX },

  	[IFLA_PORT_INSTANCE_UUID] = { .type = NLA_BINARY,
  				      .len = PORT_UUID_MAX },
  	[IFLA_PORT_HOST_UUID]	= { .type = NLA_STRING,
  				    .len = PORT_UUID_MAX },
  	[IFLA_PORT_REQUEST]	= { .type = NLA_U8, },
  	[IFLA_PORT_RESPONSE]	= { .type = NLA_U16, },

  
  	/* Unused, but we need to keep it here since user space could
  	 * fill it. It's also broken with regard to NLA_BINARY use in
  	 * combination with structs.
  	 */
  	[IFLA_PORT_VSI_TYPE]	= { .type = NLA_BINARY,
  				    .len = sizeof(struct ifla_port_vsi) },

  };

  static const struct nla_policy ifla_xdp_policy[IFLA_XDP_MAX + 1] = {
  	[IFLA_XDP_FD]		= { .type = NLA_S32 },
  	[IFLA_XDP_ATTACHED]	= { .type = NLA_U8 },

  	[IFLA_XDP_FLAGS]	= { .type = NLA_U32 },

  	[IFLA_XDP_PROG_ID]	= { .type = NLA_U32 },

  };

  static const struct rtnl_link_ops *linkinfo_to_kind_ops(const struct nlattr *nla)
  {
  	const struct rtnl_link_ops *ops = NULL;
  	struct nlattr *linfo[IFLA_INFO_MAX + 1];

  	if (nla_parse_nested(linfo, IFLA_INFO_MAX, nla,
  			     ifla_info_policy, NULL) < 0)

  		return NULL;
  
  	if (linfo[IFLA_INFO_KIND]) {
  		char kind[MODULE_NAME_LEN];
  
  		nla_strlcpy(kind, linfo[IFLA_INFO_KIND], sizeof(kind));
  		ops = rtnl_link_ops_get(kind);
  	}
  
  	return ops;
  }
  
  static bool link_master_filtered(struct net_device *dev, int master_idx)
  {
  	struct net_device *master;
  
  	if (!master_idx)
  		return false;
  
  	master = netdev_master_upper_dev_get(dev);
  	if (!master || master->ifindex != master_idx)
  		return true;
  
  	return false;
  }
  
  static bool link_kind_filtered(const struct net_device *dev,
  			       const struct rtnl_link_ops *kind_ops)
  {
  	if (kind_ops && dev->rtnl_link_ops != kind_ops)
  		return true;
  
  	return false;
  }
  
  static bool link_dump_filtered(struct net_device *dev,
  			       int master_idx,
  			       const struct rtnl_link_ops *kind_ops)
  {
  	if (link_master_filtered(dev, master_idx) ||
  	    link_kind_filtered(dev, kind_ops))
  		return true;
  
  	return false;
  }

  static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
  {
  	struct net *net = sock_net(skb->sk);
  	int h, s_h;
  	int idx = 0, s_idx;
  	struct net_device *dev;
  	struct hlist_head *head;
  	struct nlattr *tb[IFLA_MAX+1];
  	u32 ext_filter_mask = 0;

  	const struct rtnl_link_ops *kind_ops = NULL;
  	unsigned int flags = NLM_F_MULTI;
  	int master_idx = 0;

  	int err;

  	int hdrlen;

  
  	s_h = cb->args[0];
  	s_idx = cb->args[1];

  	/* A hack to preserve kernel<->userspace interface.
  	 * The correct header is ifinfomsg. It is consistent with rtnl_getlink.
  	 * However, before Linux v3.9 the code here assumed rtgenmsg and that's
  	 * what iproute2 < v3.9.0 used.
  	 * We can detect the old iproute2. Even including the IFLA_EXT_MASK
  	 * attribute, its netlink message is shorter than struct ifinfomsg.
  	 */
  	hdrlen = nlmsg_len(cb->nlh) < sizeof(struct ifinfomsg) ?
  		 sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);

  	if (nlmsg_parse(cb->nlh, hdrlen, tb, IFLA_MAX,
  			ifla_policy, NULL) >= 0) {

  		if (tb[IFLA_EXT_MASK])
  			ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);

  
  		if (tb[IFLA_MASTER])
  			master_idx = nla_get_u32(tb[IFLA_MASTER]);
  
  		if (tb[IFLA_LINKINFO])
  			kind_ops = linkinfo_to_kind_ops(tb[IFLA_LINKINFO]);
  
  		if (master_idx || kind_ops)
  			flags |= NLM_F_DUMP_FILTERED;

  	}
  
  	for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
  		idx = 0;
  		head = &net->dev_index_head[h];

  		hlist_for_each_entry(dev, head, index_hlist) {

  			if (link_dump_filtered(dev, master_idx, kind_ops))

  				goto cont;

  			if (idx < s_idx)
  				goto cont;

  			err = rtnl_fill_ifinfo(skb, dev, RTM_NEWLINK,
  					       NETLINK_CB(cb->skb).portid,
  					       cb->nlh->nlmsg_seq, 0,

  					       flags,

  					       ext_filter_mask, 0);

  			if (err < 0) {
  				if (likely(skb->len))
  					goto out;
  
  				goto out_err;
  			}

  cont:
  			idx++;
  		}
  	}
  out:

  	err = skb->len;
  out_err:

  	cb->args[1] = idx;
  	cb->args[0] = h;

  	cb->seq = net->dev_base_seq;
  	nl_dump_check_consistent(cb, nlmsg_hdr(skb));

  	return err;

  }

  int rtnl_nla_parse_ifla(struct nlattr **tb, const struct nlattr *head, int len,
  			struct netlink_ext_ack *exterr)

  {

  	return nla_parse(tb, IFLA_MAX, head, len, ifla_policy, exterr);

  }
  EXPORT_SYMBOL(rtnl_nla_parse_ifla);

  struct net *rtnl_link_get_net(struct net *src_net, struct nlattr *tb[])
  {
  	struct net *net;
  	/* Examine the link attributes and figure out which
  	 * network namespace we are talking about.
  	 */
  	if (tb[IFLA_NET_NS_PID])
  		net = get_net_ns_by_pid(nla_get_u32(tb[IFLA_NET_NS_PID]));

  	else if (tb[IFLA_NET_NS_FD])
  		net = get_net_ns_by_fd(nla_get_u32(tb[IFLA_NET_NS_FD]));

  	else
  		net = get_net(src_net);
  	return net;
  }
  EXPORT_SYMBOL(rtnl_link_get_net);

  static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[])
  {
  	if (dev) {
  		if (tb[IFLA_ADDRESS] &&
  		    nla_len(tb[IFLA_ADDRESS]) < dev->addr_len)
  			return -EINVAL;
  
  		if (tb[IFLA_BROADCAST] &&
  		    nla_len(tb[IFLA_BROADCAST]) < dev->addr_len)
  			return -EINVAL;
  	}

  	if (tb[IFLA_AF_SPEC]) {
  		struct nlattr *af;
  		int rem, err;
  
  		nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
  			const struct rtnl_af_ops *af_ops;
  
  			if (!(af_ops = rtnl_af_lookup(nla_type(af))))
  				return -EAFNOSUPPORT;
  
  			if (!af_ops->set_link_af)
  				return -EOPNOTSUPP;
  
  			if (af_ops->validate_link_af) {

  				err = af_ops->validate_link_af(dev, af);

  				if (err < 0)
  					return err;
  			}
  		}
  	}

  	return 0;
  }

  static int handle_infiniband_guid(struct net_device *dev, struct ifla_vf_guid *ivt,
  				  int guid_type)
  {
  	const struct net_device_ops *ops = dev->netdev_ops;
  
  	return ops->ndo_set_vf_guid(dev, ivt->vf, ivt->guid, guid_type);
  }
  
  static int handle_vf_guid(struct net_device *dev, struct ifla_vf_guid *ivt, int guid_type)
  {
  	if (dev->type != ARPHRD_INFINIBAND)
  		return -EOPNOTSUPP;
  
  	return handle_infiniband_guid(dev, ivt, guid_type);
  }

  static int do_setvfinfo(struct net_device *dev, struct nlattr **tb)

  {

  	const struct net_device_ops *ops = dev->netdev_ops;

  	int err = -EINVAL;

  	if (tb[IFLA_VF_MAC]) {
  		struct ifla_vf_mac *ivm = nla_data(tb[IFLA_VF_MAC]);

  		err = -EOPNOTSUPP;
  		if (ops->ndo_set_vf_mac)
  			err = ops->ndo_set_vf_mac(dev, ivm->vf,
  						  ivm->mac);
  		if (err < 0)
  			return err;
  	}
  
  	if (tb[IFLA_VF_VLAN]) {
  		struct ifla_vf_vlan *ivv = nla_data(tb[IFLA_VF_VLAN]);
  
  		err = -EOPNOTSUPP;
  		if (ops->ndo_set_vf_vlan)
  			err = ops->ndo_set_vf_vlan(dev, ivv->vf, ivv->vlan,

  						   ivv->qos,
  						   htons(ETH_P_8021Q));
  		if (err < 0)
  			return err;
  	}
  
  	if (tb[IFLA_VF_VLAN_LIST]) {
  		struct ifla_vf_vlan_info *ivvl[MAX_VLAN_LIST_LEN];
  		struct nlattr *attr;
  		int rem, len = 0;
  
  		err = -EOPNOTSUPP;
  		if (!ops->ndo_set_vf_vlan)
  			return err;
  
  		nla_for_each_nested(attr, tb[IFLA_VF_VLAN_LIST], rem) {
  			if (nla_type(attr) != IFLA_VF_VLAN_INFO ||
  			    nla_len(attr) < NLA_HDRLEN) {
  				return -EINVAL;
  			}
  			if (len >= MAX_VLAN_LIST_LEN)
  				return -EOPNOTSUPP;
  			ivvl[len] = nla_data(attr);
  
  			len++;
  		}

  		if (len == 0)
  			return -EINVAL;

  		err = ops->ndo_set_vf_vlan(dev, ivvl[0]->vf, ivvl[0]->vlan,
  					   ivvl[0]->qos, ivvl[0]->vlan_proto);

  		if (err < 0)
  			return err;

  	}

  
  	if (tb[IFLA_VF_TX_RATE]) {
  		struct ifla_vf_tx_rate *ivt = nla_data(tb[IFLA_VF_TX_RATE]);
  		struct ifla_vf_info ivf;
  
  		err = -EOPNOTSUPP;
  		if (ops->ndo_get_vf_config)
  			err = ops->ndo_get_vf_config(dev, ivt->vf, &ivf);
  		if (err < 0)
  			return err;
  
  		err = -EOPNOTSUPP;
  		if (ops->ndo_set_vf_rate)
  			err = ops->ndo_set_vf_rate(dev, ivt->vf,
  						   ivf.min_tx_rate,
  						   ivt->rate);
  		if (err < 0)
  			return err;
  	}
  
  	if (tb[IFLA_VF_RATE]) {
  		struct ifla_vf_rate *ivt = nla_data(tb[IFLA_VF_RATE]);
  
  		err = -EOPNOTSUPP;
  		if (ops->ndo_set_vf_rate)
  			err = ops->ndo_set_vf_rate(dev, ivt->vf,
  						   ivt->min_tx_rate,
  						   ivt->max_tx_rate);
  		if (err < 0)
  			return err;
  	}
  
  	if (tb[IFLA_VF_SPOOFCHK]) {
  		struct ifla_vf_spoofchk *ivs = nla_data(tb[IFLA_VF_SPOOFCHK]);
  
  		err = -EOPNOTSUPP;
  		if (ops->ndo_set_vf_spoofchk)
  			err = ops->ndo_set_vf_spoofchk(dev, ivs->vf,
  						       ivs->setting);
  		if (err < 0)
  			return err;
  	}
  
  	if (tb[IFLA_VF_LINK_STATE]) {
  		struct ifla_vf_link_state *ivl = nla_data(tb[IFLA_VF_LINK_STATE]);
  
  		err = -EOPNOTSUPP;
  		if (ops->ndo_set_vf_link_state)
  			err = ops->ndo_set_vf_link_state(dev, ivl->vf,
  							 ivl->link_state);
  		if (err < 0)
  			return err;
  	}
  
  	if (tb[IFLA_VF_RSS_QUERY_EN]) {
  		struct ifla_vf_rss_query_en *ivrssq_en;
  
  		err = -EOPNOTSUPP;
  		ivrssq_en = nla_data(tb[IFLA_VF_RSS_QUERY_EN]);
  		if (ops->ndo_set_vf_rss_query_en)
  			err = ops->ndo_set_vf_rss_query_en(dev, ivrssq_en->vf,
  							   ivrssq_en->setting);
  		if (err < 0)
  			return err;
  	}

  	if (tb[IFLA_VF_TRUST]) {
  		struct ifla_vf_trust *ivt = nla_data(tb[IFLA_VF_TRUST]);
  
  		err = -EOPNOTSUPP;
  		if (ops->ndo_set_vf_trust)
  			err = ops->ndo_set_vf_trust(dev, ivt->vf, ivt->setting);
  		if (err < 0)
  			return err;
  	}

  	if (tb[IFLA_VF_IB_NODE_GUID]) {
  		struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_NODE_GUID]);
  
  		if (!ops->ndo_set_vf_guid)
  			return -EOPNOTSUPP;
  
  		return handle_vf_guid(dev, ivt, IFLA_VF_IB_NODE_GUID);
  	}
  
  	if (tb[IFLA_VF_IB_PORT_GUID]) {
  		struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_PORT_GUID]);
  
  		if (!ops->ndo_set_vf_guid)
  			return -EOPNOTSUPP;
  
  		return handle_vf_guid(dev, ivt, IFLA_VF_IB_PORT_GUID);
  	}

  	return err;
  }

  static int do_set_master(struct net_device *dev, int ifindex)
  {

  	struct net_device *upper_dev = netdev_master_upper_dev_get(dev);

  	const struct net_device_ops *ops;
  	int err;

  	if (upper_dev) {
  		if (upper_dev->ifindex == ifindex)

  			return 0;

  		ops = upper_dev->netdev_ops;

  		if (ops->ndo_del_slave) {

  			err = ops->ndo_del_slave(upper_dev, dev);

  			if (err)
  				return err;
  		} else {
  			return -EOPNOTSUPP;
  		}
  	}
  
  	if (ifindex) {

  		upper_dev = __dev_get_by_index(dev_net(dev), ifindex);
  		if (!upper_dev)

  			return -EINVAL;

  		ops = upper_dev->netdev_ops;

  		if (ops->ndo_add_slave) {

  			err = ops->ndo_add_slave(upper_dev, dev);

  			if (err)
  				return err;
  		} else {
  			return -EOPNOTSUPP;
  		}
  	}
  	return 0;
  }

  #define DO_SETLINK_MODIFIED	0x01

  /* notify flag means notify + modified. */
  #define DO_SETLINK_NOTIFY	0x03

  static int do_setlink(const struct sk_buff *skb,
  		      struct net_device *dev, struct ifinfomsg *ifm,

  		      struct netlink_ext_ack *extack,

  		      struct nlattr **tb, char *ifname, int status)

  {

  	const struct net_device_ops *ops = dev->netdev_ops;

  	int err;

  	err = validate_linkmsg(dev, tb);
  	if (err < 0)
  		return err;

  	if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]) {

  		struct net *net = rtnl_link_get_net(dev_net(dev), tb);

  		if (IS_ERR(net)) {
  			err = PTR_ERR(net);
  			goto errout;
  		}

  		if (!netlink_ns_capable(skb, net->user_ns, CAP_NET_ADMIN)) {

  			put_net(net);

  			err = -EPERM;
  			goto errout;
  		}

  		err = dev_change_net_namespace(dev, net, ifname);
  		put_net(net);
  		if (err)
  			goto errout;

  		status |= DO_SETLINK_MODIFIED;

  	}

  	if (tb[IFLA_MAP]) {

  		struct rtnl_link_ifmap *u_map;
  		struct ifmap k_map;

  		if (!ops->ndo_set_config) {

  			err = -EOPNOTSUPP;

  			goto errout;

  		}
  
  		if (!netif_device_present(dev)) {
  			err = -ENODEV;

  			goto errout;

  		}

  		u_map = nla_data(tb[IFLA_MAP]);

  		k_map.mem_start = (unsigned long) u_map->mem_start;
  		k_map.mem_end = (unsigned long) u_map->mem_end;
  		k_map.base_addr = (unsigned short) u_map->base_addr;
  		k_map.irq = (unsigned char) u_map->irq;
  		k_map.dma = (unsigned char) u_map->dma;
  		k_map.port = (unsigned char) u_map->port;

  		err = ops->ndo_set_config(dev, &k_map);