1// SPDX-License-Identifier: GPL-2.0-only
  2
  3#include "netlink.h"
  4#include "common.h"
  5
  6struct rings_req_info {
  7	struct ethnl_req_info		base;
  8};
  9
 10struct rings_reply_data {
 11	struct ethnl_reply_data		base;
 12	struct ethtool_ringparam	ringparam;
 13};
 14
 15#define RINGS_REPDATA(__reply_base) \
 16	container_of(__reply_base, struct rings_reply_data, base)
 17
 18static const struct nla_policy
 19rings_get_policy[ETHTOOL_A_RINGS_MAX + 1] = {
 20	[ETHTOOL_A_RINGS_UNSPEC]		= { .type = NLA_REJECT },
 21	[ETHTOOL_A_RINGS_HEADER]		= { .type = NLA_NESTED },
 22	[ETHTOOL_A_RINGS_RX_MAX]		= { .type = NLA_REJECT },
 23	[ETHTOOL_A_RINGS_RX_MINI_MAX]		= { .type = NLA_REJECT },
 24	[ETHTOOL_A_RINGS_RX_JUMBO_MAX]		= { .type = NLA_REJECT },
 25	[ETHTOOL_A_RINGS_TX_MAX]		= { .type = NLA_REJECT },
 26	[ETHTOOL_A_RINGS_RX]			= { .type = NLA_REJECT },
 27	[ETHTOOL_A_RINGS_RX_MINI]		= { .type = NLA_REJECT },
 28	[ETHTOOL_A_RINGS_RX_JUMBO]		= { .type = NLA_REJECT },
 29	[ETHTOOL_A_RINGS_TX]			= { .type = NLA_REJECT },
 30};
 31
 32static int rings_prepare_data(const struct ethnl_req_info *req_base,
 33			      struct ethnl_reply_data *reply_base,
 34			      struct genl_info *info)
 35{
 36	struct rings_reply_data *data = RINGS_REPDATA(reply_base);
 37	struct net_device *dev = reply_base->dev;
 38	int ret;
 39
 40	if (!dev->ethtool_ops->get_ringparam)
 41		return -EOPNOTSUPP;
 42	ret = ethnl_ops_begin(dev);
 43	if (ret < 0)
 44		return ret;
 45	dev->ethtool_ops->get_ringparam(dev, &data->ringparam);
 46	ethnl_ops_complete(dev);
 47
 48	return 0;
 49}
 50
 51static int rings_reply_size(const struct ethnl_req_info *req_base,
 52			    const struct ethnl_reply_data *reply_base)
 53{
 54	return nla_total_size(sizeof(u32)) +	/* _RINGS_RX_MAX */
 55	       nla_total_size(sizeof(u32)) +	/* _RINGS_RX_MINI_MAX */
 56	       nla_total_size(sizeof(u32)) +	/* _RINGS_RX_JUMBO_MAX */
 57	       nla_total_size(sizeof(u32)) +	/* _RINGS_TX_MAX */
 58	       nla_total_size(sizeof(u32)) +	/* _RINGS_RX */
 59	       nla_total_size(sizeof(u32)) +	/* _RINGS_RX_MINI */
 60	       nla_total_size(sizeof(u32)) +	/* _RINGS_RX_JUMBO */
 61	       nla_total_size(sizeof(u32));	/* _RINGS_TX */
 62}
 63
 64static int rings_fill_reply(struct sk_buff *skb,
 65			    const struct ethnl_req_info *req_base,
 66			    const struct ethnl_reply_data *reply_base)
 67{
 68	const struct rings_reply_data *data = RINGS_REPDATA(reply_base);
 69	const struct ethtool_ringparam *ringparam = &data->ringparam;
 70
 71	if ((ringparam->rx_max_pending &&
 72	     (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_MAX,
 73			  ringparam->rx_max_pending) ||
 74	      nla_put_u32(skb, ETHTOOL_A_RINGS_RX,
 75			  ringparam->rx_pending))) ||
 76	    (ringparam->rx_mini_max_pending &&
 77	     (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_MINI_MAX,
 78			  ringparam->rx_mini_max_pending) ||
 79	      nla_put_u32(skb, ETHTOOL_A_RINGS_RX_MINI,
 80			  ringparam->rx_mini_pending))) ||
 81	    (ringparam->rx_jumbo_max_pending &&
 82	     (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_JUMBO_MAX,
 83			  ringparam->rx_jumbo_max_pending) ||
 84	      nla_put_u32(skb, ETHTOOL_A_RINGS_RX_JUMBO,
 85			  ringparam->rx_jumbo_pending))) ||
 86	    (ringparam->tx_max_pending &&
 87	     (nla_put_u32(skb, ETHTOOL_A_RINGS_TX_MAX,
 88			  ringparam->tx_max_pending) ||
 89	      nla_put_u32(skb, ETHTOOL_A_RINGS_TX,
 90			  ringparam->tx_pending))))
 91		return -EMSGSIZE;
 92
 93	return 0;
 94}
 95
 96const struct ethnl_request_ops ethnl_rings_request_ops = {
 97	.request_cmd		= ETHTOOL_MSG_RINGS_GET,
 98	.reply_cmd		= ETHTOOL_MSG_RINGS_GET_REPLY,
 99	.hdr_attr		= ETHTOOL_A_RINGS_HEADER,
100	.max_attr		= ETHTOOL_A_RINGS_MAX,
101	.req_info_size		= sizeof(struct rings_req_info),
102	.reply_data_size	= sizeof(struct rings_reply_data),
103	.request_policy		= rings_get_policy,
104
105	.prepare_data		= rings_prepare_data,
106	.reply_size		= rings_reply_size,
107	.fill_reply		= rings_fill_reply,
108};
109
110/* RINGS_SET */
111
112static const struct nla_policy
113rings_set_policy[ETHTOOL_A_RINGS_MAX + 1] = {
114	[ETHTOOL_A_RINGS_UNSPEC]		= { .type = NLA_REJECT },
115	[ETHTOOL_A_RINGS_HEADER]		= { .type = NLA_NESTED },
116	[ETHTOOL_A_RINGS_RX_MAX]		= { .type = NLA_REJECT },
117	[ETHTOOL_A_RINGS_RX_MINI_MAX]		= { .type = NLA_REJECT },
118	[ETHTOOL_A_RINGS_RX_JUMBO_MAX]		= { .type = NLA_REJECT },
119	[ETHTOOL_A_RINGS_TX_MAX]		= { .type = NLA_REJECT },
120	[ETHTOOL_A_RINGS_RX]			= { .type = NLA_U32 },
121	[ETHTOOL_A_RINGS_RX_MINI]		= { .type = NLA_U32 },
122	[ETHTOOL_A_RINGS_RX_JUMBO]		= { .type = NLA_U32 },
123	[ETHTOOL_A_RINGS_TX]			= { .type = NLA_U32 },
124};
125
126int ethnl_set_rings(struct sk_buff *skb, struct genl_info *info)
127{
128	struct nlattr *tb[ETHTOOL_A_RINGS_MAX + 1];
129	struct ethtool_ringparam ringparam = {};
130	struct ethnl_req_info req_info = {};
131	const struct nlattr *err_attr;
132	const struct ethtool_ops *ops;
133	struct net_device *dev;
134	bool mod = false;
135	int ret;
136
137	ret = nlmsg_parse(info->nlhdr, GENL_HDRLEN, tb,
138			  ETHTOOL_A_RINGS_MAX, rings_set_policy,
139			  info->extack);
140	if (ret < 0)
141		return ret;
142	ret = ethnl_parse_header_dev_get(&req_info,
143					 tb[ETHTOOL_A_RINGS_HEADER],
144					 genl_info_net(info), info->extack,
145					 true);
146	if (ret < 0)
147		return ret;
148	dev = req_info.dev;
149	ops = dev->ethtool_ops;
150	ret = -EOPNOTSUPP;
151	if (!ops->get_ringparam || !ops->set_ringparam)
152		goto out_dev;
153
154	rtnl_lock();
155	ret = ethnl_ops_begin(dev);
156	if (ret < 0)
157		goto out_rtnl;
158	ops->get_ringparam(dev, &ringparam);
159
160	ethnl_update_u32(&ringparam.rx_pending, tb[ETHTOOL_A_RINGS_RX], &mod);
161	ethnl_update_u32(&ringparam.rx_mini_pending,
162			 tb[ETHTOOL_A_RINGS_RX_MINI], &mod);
163	ethnl_update_u32(&ringparam.rx_jumbo_pending,
164			 tb[ETHTOOL_A_RINGS_RX_JUMBO], &mod);
165	ethnl_update_u32(&ringparam.tx_pending, tb[ETHTOOL_A_RINGS_TX], &mod);
166	ret = 0;
167	if (!mod)
168		goto out_ops;
169
170	/* ensure new ring parameters are within limits */
171	if (ringparam.rx_pending > ringparam.rx_max_pending)
172		err_attr = tb[ETHTOOL_A_RINGS_RX];
173	else if (ringparam.rx_mini_pending > ringparam.rx_mini_max_pending)
174		err_attr = tb[ETHTOOL_A_RINGS_RX_MINI];
175	else if (ringparam.rx_jumbo_pending > ringparam.rx_jumbo_max_pending)
176		err_attr = tb[ETHTOOL_A_RINGS_RX_JUMBO];
177	else if (ringparam.tx_pending > ringparam.tx_max_pending)
178		err_attr = tb[ETHTOOL_A_RINGS_TX];
179	else
180		err_attr = NULL;
181	if (err_attr) {
182		ret = -EINVAL;
183		NL_SET_ERR_MSG_ATTR(info->extack, err_attr,
184				    "requested ring size exceeds maximum");
185		goto out_ops;
186	}
187
188	ret = dev->ethtool_ops->set_ringparam(dev, &ringparam);
189	if (ret < 0)
190		goto out_ops;
191	ethtool_notify(dev, ETHTOOL_MSG_RINGS_NTF, NULL);
192
193out_ops:
194	ethnl_ops_complete(dev);
195out_rtnl:
196	rtnl_unlock();
197out_dev:
198	dev_put(dev);
199	return ret;
200}