xref: /linux/net/ethtool/rss.c (revision d677aebd663ddc287f2b2bda098474694a0ca875)
1 // SPDX-License-Identifier: GPL-2.0-only
2 
3 #include "netlink.h"
4 #include "common.h"
5 
6 struct rss_req_info {
7 	struct ethnl_req_info		base;
8 	u32				rss_context;
9 };
10 
11 struct rss_reply_data {
12 	struct ethnl_reply_data		base;
13 	bool				no_key_fields;
14 	u32				indir_size;
15 	u32				hkey_size;
16 	u32				hfunc;
17 	u32				input_xfrm;
18 	u32				*indir_table;
19 	u8				*hkey;
20 };
21 
22 #define RSS_REQINFO(__req_base) \
23 	container_of(__req_base, struct rss_req_info, base)
24 
25 #define RSS_REPDATA(__reply_base) \
26 	container_of(__reply_base, struct rss_reply_data, base)
27 
28 const struct nla_policy ethnl_rss_get_policy[] = {
29 	[ETHTOOL_A_RSS_HEADER] = NLA_POLICY_NESTED(ethnl_header_policy),
30 	[ETHTOOL_A_RSS_CONTEXT] = { .type = NLA_U32 },
31 	[ETHTOOL_A_RSS_START_CONTEXT] = { .type = NLA_U32 },
32 };
33 
34 static int
35 rss_parse_request(struct ethnl_req_info *req_info, struct nlattr **tb,
36 		  struct netlink_ext_ack *extack)
37 {
38 	struct rss_req_info *request = RSS_REQINFO(req_info);
39 
40 	if (tb[ETHTOOL_A_RSS_CONTEXT])
41 		request->rss_context = nla_get_u32(tb[ETHTOOL_A_RSS_CONTEXT]);
42 	if (tb[ETHTOOL_A_RSS_START_CONTEXT]) {
43 		NL_SET_BAD_ATTR(extack, tb[ETHTOOL_A_RSS_START_CONTEXT]);
44 		return -EINVAL;
45 	}
46 
47 	return 0;
48 }
49 
50 static int
51 rss_prepare_get(const struct rss_req_info *request, struct net_device *dev,
52 		struct rss_reply_data *data, const struct genl_info *info)
53 {
54 	struct ethtool_rxfh_param rxfh = {};
55 	const struct ethtool_ops *ops;
56 	u32 total_size, indir_bytes;
57 	u8 *rss_config;
58 	int ret;
59 
60 	ops = dev->ethtool_ops;
61 
62 	ret = ethnl_ops_begin(dev);
63 	if (ret < 0)
64 		return ret;
65 
66 	data->indir_size = 0;
67 	data->hkey_size = 0;
68 	if (ops->get_rxfh_indir_size)
69 		data->indir_size = ops->get_rxfh_indir_size(dev);
70 	if (ops->get_rxfh_key_size)
71 		data->hkey_size = ops->get_rxfh_key_size(dev);
72 
73 	indir_bytes = data->indir_size * sizeof(u32);
74 	total_size = indir_bytes + data->hkey_size;
75 	rss_config = kzalloc(total_size, GFP_KERNEL);
76 	if (!rss_config) {
77 		ret = -ENOMEM;
78 		goto out_ops;
79 	}
80 
81 	if (data->indir_size)
82 		data->indir_table = (u32 *)rss_config;
83 	if (data->hkey_size)
84 		data->hkey = rss_config + indir_bytes;
85 
86 	rxfh.indir_size = data->indir_size;
87 	rxfh.indir = data->indir_table;
88 	rxfh.key_size = data->hkey_size;
89 	rxfh.key = data->hkey;
90 
91 	ret = ops->get_rxfh(dev, &rxfh);
92 	if (ret)
93 		goto out_ops;
94 
95 	data->hfunc = rxfh.hfunc;
96 	data->input_xfrm = rxfh.input_xfrm;
97 out_ops:
98 	ethnl_ops_complete(dev);
99 	return ret;
100 }
101 
102 static int
103 rss_prepare_ctx(const struct rss_req_info *request, struct net_device *dev,
104 		struct rss_reply_data *data, const struct genl_info *info)
105 {
106 	struct ethtool_rxfh_context *ctx;
107 	u32 total_size, indir_bytes;
108 	u8 *rss_config;
109 
110 	ctx = xa_load(&dev->ethtool->rss_ctx, request->rss_context);
111 	if (!ctx)
112 		return -ENOENT;
113 
114 	data->indir_size = ctx->indir_size;
115 	data->hkey_size = ctx->key_size;
116 	data->hfunc = ctx->hfunc;
117 	data->input_xfrm = ctx->input_xfrm;
118 
119 	indir_bytes = data->indir_size * sizeof(u32);
120 	total_size = indir_bytes + data->hkey_size;
121 	rss_config = kzalloc(total_size, GFP_KERNEL);
122 	if (!rss_config)
123 		return -ENOMEM;
124 
125 	data->indir_table = (u32 *)rss_config;
126 	memcpy(data->indir_table, ethtool_rxfh_context_indir(ctx), indir_bytes);
127 
128 	if (data->hkey_size) {
129 		data->hkey = rss_config + indir_bytes;
130 		memcpy(data->hkey, ethtool_rxfh_context_key(ctx),
131 		       data->hkey_size);
132 	}
133 
134 	return 0;
135 }
136 
137 static int
138 rss_prepare_data(const struct ethnl_req_info *req_base,
139 		 struct ethnl_reply_data *reply_base,
140 		 const struct genl_info *info)
141 {
142 	struct rss_reply_data *data = RSS_REPDATA(reply_base);
143 	struct rss_req_info *request = RSS_REQINFO(req_base);
144 	struct net_device *dev = reply_base->dev;
145 	const struct ethtool_ops *ops;
146 
147 	ops = dev->ethtool_ops;
148 	if (!ops->get_rxfh)
149 		return -EOPNOTSUPP;
150 
151 	/* Some drivers don't handle rss_context */
152 	if (request->rss_context) {
153 		if (!ops->cap_rss_ctx_supported && !ops->create_rxfh_context)
154 			return -EOPNOTSUPP;
155 
156 		data->no_key_fields = !ops->rxfh_per_ctx_key;
157 		return rss_prepare_ctx(request, dev, data, info);
158 	}
159 
160 	return rss_prepare_get(request, dev, data, info);
161 }
162 
163 static int
164 rss_reply_size(const struct ethnl_req_info *req_base,
165 	       const struct ethnl_reply_data *reply_base)
166 {
167 	const struct rss_reply_data *data = RSS_REPDATA(reply_base);
168 	int len;
169 
170 	len = nla_total_size(sizeof(u32)) +	/* _RSS_CONTEXT */
171 	      nla_total_size(sizeof(u32)) +	/* _RSS_HFUNC */
172 	      nla_total_size(sizeof(u32)) +	/* _RSS_INPUT_XFRM */
173 	      nla_total_size(sizeof(u32) * data->indir_size) + /* _RSS_INDIR */
174 	      nla_total_size(data->hkey_size);	/* _RSS_HKEY */
175 
176 	return len;
177 }
178 
179 static int
180 rss_fill_reply(struct sk_buff *skb, const struct ethnl_req_info *req_base,
181 	       const struct ethnl_reply_data *reply_base)
182 {
183 	const struct rss_reply_data *data = RSS_REPDATA(reply_base);
184 	struct rss_req_info *request = RSS_REQINFO(req_base);
185 
186 	if (request->rss_context &&
187 	    nla_put_u32(skb, ETHTOOL_A_RSS_CONTEXT, request->rss_context))
188 		return -EMSGSIZE;
189 
190 	if ((data->indir_size &&
191 	     nla_put(skb, ETHTOOL_A_RSS_INDIR,
192 		     sizeof(u32) * data->indir_size, data->indir_table)))
193 		return -EMSGSIZE;
194 
195 	if (data->no_key_fields)
196 		return 0;
197 
198 	if ((data->hfunc &&
199 	     nla_put_u32(skb, ETHTOOL_A_RSS_HFUNC, data->hfunc)) ||
200 	    (data->input_xfrm &&
201 	     nla_put_u32(skb, ETHTOOL_A_RSS_INPUT_XFRM, data->input_xfrm)) ||
202 	    (data->hkey_size &&
203 	     nla_put(skb, ETHTOOL_A_RSS_HKEY, data->hkey_size, data->hkey)))
204 		return -EMSGSIZE;
205 
206 	return 0;
207 }
208 
209 static void rss_cleanup_data(struct ethnl_reply_data *reply_base)
210 {
211 	const struct rss_reply_data *data = RSS_REPDATA(reply_base);
212 
213 	kfree(data->indir_table);
214 }
215 
216 struct rss_nl_dump_ctx {
217 	unsigned long		ifindex;
218 	unsigned long		ctx_idx;
219 
220 	/* User wants to only dump contexts from given ifindex */
221 	unsigned int		match_ifindex;
222 	unsigned int		start_ctx;
223 };
224 
225 static struct rss_nl_dump_ctx *rss_dump_ctx(struct netlink_callback *cb)
226 {
227 	NL_ASSERT_CTX_FITS(struct rss_nl_dump_ctx);
228 
229 	return (struct rss_nl_dump_ctx *)cb->ctx;
230 }
231 
232 int ethnl_rss_dump_start(struct netlink_callback *cb)
233 {
234 	const struct genl_info *info = genl_info_dump(cb);
235 	struct rss_nl_dump_ctx *ctx = rss_dump_ctx(cb);
236 	struct ethnl_req_info req_info = {};
237 	struct nlattr **tb = info->attrs;
238 	int ret;
239 
240 	/* Filtering by context not supported */
241 	if (tb[ETHTOOL_A_RSS_CONTEXT]) {
242 		NL_SET_BAD_ATTR(info->extack, tb[ETHTOOL_A_RSS_CONTEXT]);
243 		return -EINVAL;
244 	}
245 	if (tb[ETHTOOL_A_RSS_START_CONTEXT]) {
246 		ctx->start_ctx = nla_get_u32(tb[ETHTOOL_A_RSS_START_CONTEXT]);
247 		ctx->ctx_idx = ctx->start_ctx;
248 	}
249 
250 	ret = ethnl_parse_header_dev_get(&req_info,
251 					 tb[ETHTOOL_A_RSS_HEADER],
252 					 sock_net(cb->skb->sk), cb->extack,
253 					 false);
254 	if (req_info.dev) {
255 		ctx->match_ifindex = req_info.dev->ifindex;
256 		ctx->ifindex = ctx->match_ifindex;
257 		ethnl_parse_header_dev_put(&req_info);
258 		req_info.dev = NULL;
259 	}
260 
261 	return ret;
262 }
263 
264 static int
265 rss_dump_one_ctx(struct sk_buff *skb, struct netlink_callback *cb,
266 		 struct net_device *dev, u32 rss_context)
267 {
268 	const struct genl_info *info = genl_info_dump(cb);
269 	struct rss_reply_data data = {};
270 	struct rss_req_info req = {};
271 	void *ehdr;
272 	int ret;
273 
274 	req.rss_context = rss_context;
275 
276 	ehdr = ethnl_dump_put(skb, cb, ETHTOOL_MSG_RSS_GET_REPLY);
277 	if (!ehdr)
278 		return -EMSGSIZE;
279 
280 	ret = ethnl_fill_reply_header(skb, dev, ETHTOOL_A_RSS_HEADER);
281 	if (ret < 0)
282 		goto err_cancel;
283 
284 	/* Context 0 is not currently storred or cached in the XArray */
285 	if (!rss_context)
286 		ret = rss_prepare_get(&req, dev, &data, info);
287 	else
288 		ret = rss_prepare_ctx(&req, dev, &data, info);
289 	if (ret)
290 		goto err_cancel;
291 
292 	ret = rss_fill_reply(skb, &req.base, &data.base);
293 	if (ret)
294 		goto err_cleanup;
295 	genlmsg_end(skb, ehdr);
296 
297 	rss_cleanup_data(&data.base);
298 	return 0;
299 
300 err_cleanup:
301 	rss_cleanup_data(&data.base);
302 err_cancel:
303 	genlmsg_cancel(skb, ehdr);
304 	return ret;
305 }
306 
307 static int
308 rss_dump_one_dev(struct sk_buff *skb, struct netlink_callback *cb,
309 		 struct net_device *dev)
310 {
311 	struct rss_nl_dump_ctx *ctx = rss_dump_ctx(cb);
312 	int ret;
313 
314 	if (!dev->ethtool_ops->get_rxfh)
315 		return 0;
316 
317 	if (!ctx->ctx_idx) {
318 		ret = rss_dump_one_ctx(skb, cb, dev, 0);
319 		if (ret)
320 			return ret;
321 		ctx->ctx_idx++;
322 	}
323 
324 	for (; xa_find(&dev->ethtool->rss_ctx, &ctx->ctx_idx,
325 		       ULONG_MAX, XA_PRESENT); ctx->ctx_idx++) {
326 		ret = rss_dump_one_ctx(skb, cb, dev, ctx->ctx_idx);
327 		if (ret)
328 			return ret;
329 	}
330 	ctx->ctx_idx = ctx->start_ctx;
331 
332 	return 0;
333 }
334 
335 int ethnl_rss_dumpit(struct sk_buff *skb, struct netlink_callback *cb)
336 {
337 	struct rss_nl_dump_ctx *ctx = rss_dump_ctx(cb);
338 	struct net *net = sock_net(skb->sk);
339 	struct net_device *dev;
340 	int ret = 0;
341 
342 	rtnl_lock();
343 	for_each_netdev_dump(net, dev, ctx->ifindex) {
344 		if (ctx->match_ifindex && ctx->match_ifindex != ctx->ifindex)
345 			break;
346 
347 		ret = rss_dump_one_dev(skb, cb, dev);
348 		if (ret)
349 			break;
350 	}
351 	rtnl_unlock();
352 
353 	return ret;
354 }
355 
356 const struct ethnl_request_ops ethnl_rss_request_ops = {
357 	.request_cmd		= ETHTOOL_MSG_RSS_GET,
358 	.reply_cmd		= ETHTOOL_MSG_RSS_GET_REPLY,
359 	.hdr_attr		= ETHTOOL_A_RSS_HEADER,
360 	.req_info_size		= sizeof(struct rss_req_info),
361 	.reply_data_size	= sizeof(struct rss_reply_data),
362 
363 	.parse_request		= rss_parse_request,
364 	.prepare_data		= rss_prepare_data,
365 	.reply_size		= rss_reply_size,
366 	.fill_reply		= rss_fill_reply,
367 	.cleanup_data		= rss_cleanup_data,
368 };
369