Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b22b941b authored by Hannes Frederic Sowa's avatar Hannes Frederic Sowa Committed by David S. Miller
Browse files

rtnetlink: fix frame size warning in rtnl_fill_ifinfo 



Fix the following warning:

  CC      net/core/rtnetlink.o
net/core/rtnetlink.c: In function ‘rtnl_fill_ifinfo’:
net/core/rtnetlink.c:1308:1: warning: the frame size of 2864 bytes is larger than 2048 bytes [-Wframe-larger-than=]
 }
 ^
by splitting up the huge rtnl_fill_ifinfo into some smaller ones, so we
don't have the huge frame allocations at the same time.

Cc: Eric Dumazet <edumazet@google.com>
Signed-off-by: default avatarHannes Frederic Sowa <hannes@stressinduktion.org>
Acked-by: default avatarEric Dumazet <edumazet@google.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 19125c1a

net/core/rtnetlink.c

+152 −122
Original line number Diff line number Diff line
@@ -1045,127 +1045,50 @@ static int rtnl_phys_switch_id_fill(struct sk_buff *skb, struct net_device *dev) 
	return 0;

}



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)

static noinline_for_stack int rtnl_fill_stats(struct sk_buff *skb,

					      struct net_device *dev)

{

	struct ifinfomsg *ifm;

	struct nlmsghdr *nlh;

	struct rtnl_link_stats64 temp;

	const struct rtnl_link_stats64 *stats;

	struct nlattr *attr, *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) ||

#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 (1) {

		struct rtnl_link_ifmap map = {

			.mem_start   = dev->mem_start,

			.mem_end     = dev->mem_end,

			.base_addr   = dev->base_addr,

			.irq         = dev->irq,

			.dma         = dev->dma,

			.port        = dev->if_port,

		};

		if (nla_put(skb, IFLA_MAP, sizeof(map), &map))

			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;

	struct rtnl_link_stats64 temp;

	struct nlattr *attr;



	if (rtnl_phys_switch_id_fill(skb, dev))

		goto nla_put_failure;

	stats = dev_get_stats(dev, &temp);



	attr = nla_reserve(skb, IFLA_STATS,

			   sizeof(struct rtnl_link_stats));

	if (attr == NULL)

		goto nla_put_failure;

	if (!attr)

		return -EMSGSIZE;



	stats = dev_get_stats(dev, &temp);

	copy_rtnl_link_stats(nla_data(attr), stats);



	attr = nla_reserve(skb, IFLA_STATS64,

			   sizeof(struct rtnl_link_stats64));

	if (attr == NULL)

		goto nla_put_failure;

	copy_rtnl_link_stats64(nla_data(attr), stats);



	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 (!attr)

		return -EMSGSIZE;



	if (dev->netdev_ops->ndo_get_vf_config && dev->dev.parent

	    && (ext_filter_mask & RTEXT_FILTER_VF)) {

		int i;

	copy_rtnl_link_stats64(nla_data(attr), stats);



		struct nlattr *vfinfo, *vf, *vfstats;

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

	return 0;

}



		vfinfo = nla_nest_start(skb, IFLA_VFINFO_LIST);

		if (!vfinfo)

			goto nla_put_failure;

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

			struct ifla_vf_info ivi;

			struct ifla_vf_mac vf_mac;

			struct ifla_vf_vlan vf_vlan;

			struct ifla_vf_rate vf_rate;

			struct ifla_vf_tx_rate vf_tx_rate;

			struct ifla_vf_spoofchk vf_spoofchk;

			struct ifla_vf_link_state vf_linkstate;

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 ifla_vf_link_state vf_linkstate;

	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 nlattr *vf, *vfstats;

	struct ifla_vf_mac vf_mac;

	struct ifla_vf_info ivi;



			/*

			 * Not all SR-IOV capable drivers support the

	/* 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.
@@ -1178,8 +1101,9 @@ static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev, 
	 * IFLA_VF_LINK_STATE_AUTO which equals zero

	 */

	ivi.linkstate = 0;

			if (dev->netdev_ops->ndo_get_vf_config(dev, i, &ivi))

				break;

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

		return 0;



	vf_mac.vf =

		vf_vlan.vf =

		vf_rate.vf =
@@ -1202,7 +1126,7 @@ static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev, 
	vf = nla_nest_start(skb, IFLA_VF_INFO);

	if (!vf) {

		nla_nest_cancel(skb, vfinfo);

				goto nla_put_failure;

		return -EMSGSIZE;

	}

	if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) ||

	    nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) ||
@@ -1219,16 +1143,16 @@ static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev, 
		    &vf_rss_query_en) ||

	    nla_put(skb, IFLA_VF_TRUST,

		    sizeof(vf_trust), &vf_trust))

				goto nla_put_failure;

		return -EMSGSIZE;

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

	if (dev->netdev_ops->ndo_get_vf_stats)

				dev->netdev_ops->ndo_get_vf_stats(dev, i,

		dev->netdev_ops->ndo_get_vf_stats(dev, vfs_num,

						&vf_stats);

	vfstats = nla_nest_start(skb, IFLA_VF_STATS);

	if (!vfstats) {

		nla_nest_cancel(skb, vf);

		nla_nest_cancel(skb, vfinfo);

				goto nla_put_failure;

		return -EMSGSIZE;

	}

	if (nla_put_u64(skb, IFLA_VF_STATS_RX_PACKETS,

			vf_stats.rx_packets) ||
@@ -1242,10 +1166,116 @@ static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev, 
			vf_stats.broadcast) ||

	    nla_put_u64(skb, IFLA_VF_STATS_MULTICAST,

			vf_stats.multicast))

				goto nla_put_failure;

		return -EMSGSIZE;

	nla_nest_end(skb, vfstats);

	nla_nest_end(skb, vf);

	return 0;

}



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

{

	struct rtnl_link_ifmap map = {

		.mem_start   = dev->mem_start,

		.mem_end     = dev->mem_end,

		.base_addr   = dev->base_addr,

		.irq         = dev->irq,

		.dma         = dev->dma,

		.port        = dev->if_port,

	};

	if (nla_put(skb, IFLA_MAP, sizeof(map), &map))

		return -EMSGSIZE;



	return 0;

}



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)

{

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

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

	}