xref: /openbmc/linux/drivers/net/netdevsim/netdev.c (revision ba61bb17) 
1 /*
2  * Copyright (C) 2017 Netronome Systems, Inc.
3  *
4  * This software is licensed under the GNU General License Version 2,
5  * June 1991 as shown in the file COPYING in the top-level directory of this
6  * source tree.
7  *
8  * THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS"
9  * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
10  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
11  * FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE
12  * OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME
13  * THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
14  */
15 
16 #include <linux/debugfs.h>
17 #include <linux/etherdevice.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/netdevice.h>
21 #include <linux/slab.h>
22 #include <net/netlink.h>
23 #include <net/pkt_cls.h>
24 #include <net/rtnetlink.h>
25 
26 #include "netdevsim.h"
27 
28 struct nsim_vf_config {
29 	int link_state;
30 	u16 min_tx_rate;
31 	u16 max_tx_rate;
32 	u16 vlan;
33 	__be16 vlan_proto;
34 	u16 qos;
35 	u8 vf_mac[ETH_ALEN];
36 	bool spoofchk_enabled;
37 	bool trusted;
38 	bool rss_query_enabled;
39 };
40 
41 static u32 nsim_dev_id;
42 
43 static int nsim_num_vf(struct device *dev)
44 {
45 	struct netdevsim *ns = to_nsim(dev);
46 
47 	return ns->num_vfs;
48 }
49 
50 static struct bus_type nsim_bus = {
51 	.name		= DRV_NAME,
52 	.dev_name	= DRV_NAME,
53 	.num_vf		= nsim_num_vf,
54 };
55 
56 static int nsim_vfs_enable(struct netdevsim *ns, unsigned int num_vfs)
57 {
58 	ns->vfconfigs = kcalloc(num_vfs, sizeof(struct nsim_vf_config),
59 				GFP_KERNEL);
60 	if (!ns->vfconfigs)
61 		return -ENOMEM;
62 	ns->num_vfs = num_vfs;
63 
64 	return 0;
65 }
66 
67 static void nsim_vfs_disable(struct netdevsim *ns)
68 {
69 	kfree(ns->vfconfigs);
70 	ns->vfconfigs = NULL;
71 	ns->num_vfs = 0;
72 }
73 
74 static ssize_t
75 nsim_numvfs_store(struct device *dev, struct device_attribute *attr,
76 		  const char *buf, size_t count)
77 {
78 	struct netdevsim *ns = to_nsim(dev);
79 	unsigned int num_vfs;
80 	int ret;
81 
82 	ret = kstrtouint(buf, 0, &num_vfs);
83 	if (ret)
84 		return ret;
85 
86 	rtnl_lock();
87 	if (ns->num_vfs == num_vfs)
88 		goto exit_good;
89 	if (ns->num_vfs && num_vfs) {
90 		ret = -EBUSY;
91 		goto exit_unlock;
92 	}
93 
94 	if (num_vfs) {
95 		ret = nsim_vfs_enable(ns, num_vfs);
96 		if (ret)
97 			goto exit_unlock;
98 	} else {
99 		nsim_vfs_disable(ns);
100 	}
101 exit_good:
102 	ret = count;
103 exit_unlock:
104 	rtnl_unlock();
105 
106 	return ret;
107 }
108 
109 static ssize_t
110 nsim_numvfs_show(struct device *dev, struct device_attribute *attr, char *buf)
111 {
112 	struct netdevsim *ns = to_nsim(dev);
113 
114 	return sprintf(buf, "%u\n", ns->num_vfs);
115 }
116 
117 static struct device_attribute nsim_numvfs_attr =
118 	__ATTR(sriov_numvfs, 0664, nsim_numvfs_show, nsim_numvfs_store);
119 
120 static struct attribute *nsim_dev_attrs[] = {
121 	&nsim_numvfs_attr.attr,
122 	NULL,
123 };
124 
125 static const struct attribute_group nsim_dev_attr_group = {
126 	.attrs = nsim_dev_attrs,
127 };
128 
129 static const struct attribute_group *nsim_dev_attr_groups[] = {
130 	&nsim_dev_attr_group,
131 	NULL,
132 };
133 
134 static void nsim_dev_release(struct device *dev)
135 {
136 	struct netdevsim *ns = to_nsim(dev);
137 
138 	nsim_vfs_disable(ns);
139 	free_netdev(ns->netdev);
140 }
141 
142 static struct device_type nsim_dev_type = {
143 	.groups = nsim_dev_attr_groups,
144 	.release = nsim_dev_release,
145 };
146 
147 static int nsim_init(struct net_device *dev)
148 {
149 	struct netdevsim *ns = netdev_priv(dev);
150 	int err;
151 
152 	ns->netdev = dev;
153 	ns->ddir = debugfs_create_dir(netdev_name(dev), nsim_ddir);
154 	if (IS_ERR_OR_NULL(ns->ddir))
155 		return -ENOMEM;
156 
157 	err = nsim_bpf_init(ns);
158 	if (err)
159 		goto err_debugfs_destroy;
160 
161 	ns->dev.id = nsim_dev_id++;
162 	ns->dev.bus = &nsim_bus;
163 	ns->dev.type = &nsim_dev_type;
164 	err = device_register(&ns->dev);
165 	if (err)
166 		goto err_bpf_uninit;
167 
168 	SET_NETDEV_DEV(dev, &ns->dev);
169 
170 	err = nsim_devlink_setup(ns);
171 	if (err)
172 		goto err_unreg_dev;
173 
174 	return 0;
175 
176 err_unreg_dev:
177 	device_unregister(&ns->dev);
178 err_bpf_uninit:
179 	nsim_bpf_uninit(ns);
180 err_debugfs_destroy:
181 	debugfs_remove_recursive(ns->ddir);
182 	return err;
183 }
184 
185 static void nsim_uninit(struct net_device *dev)
186 {
187 	struct netdevsim *ns = netdev_priv(dev);
188 
189 	nsim_devlink_teardown(ns);
190 	debugfs_remove_recursive(ns->ddir);
191 	nsim_bpf_uninit(ns);
192 }
193 
194 static void nsim_free(struct net_device *dev)
195 {
196 	struct netdevsim *ns = netdev_priv(dev);
197 
198 	device_unregister(&ns->dev);
199 	/* netdev and vf state will be freed out of device_release() */
200 }
201 
202 static netdev_tx_t nsim_start_xmit(struct sk_buff *skb, struct net_device *dev)
203 {
204 	struct netdevsim *ns = netdev_priv(dev);
205 
206 	u64_stats_update_begin(&ns->syncp);
207 	ns->tx_packets++;
208 	ns->tx_bytes += skb->len;
209 	u64_stats_update_end(&ns->syncp);
210 
211 	dev_kfree_skb(skb);
212 
213 	return NETDEV_TX_OK;
214 }
215 
216 static void nsim_set_rx_mode(struct net_device *dev)
217 {
218 }
219 
220 static int nsim_change_mtu(struct net_device *dev, int new_mtu)
221 {
222 	struct netdevsim *ns = netdev_priv(dev);
223 
224 	if (ns->xdp_prog_mode == XDP_ATTACHED_DRV &&
225 	    new_mtu > NSIM_XDP_MAX_MTU)
226 		return -EBUSY;
227 
228 	dev->mtu = new_mtu;
229 
230 	return 0;
231 }
232 
233 static void
234 nsim_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
235 {
236 	struct netdevsim *ns = netdev_priv(dev);
237 	unsigned int start;
238 
239 	do {
240 		start = u64_stats_fetch_begin(&ns->syncp);
241 		stats->tx_bytes = ns->tx_bytes;
242 		stats->tx_packets = ns->tx_packets;
243 	} while (u64_stats_fetch_retry(&ns->syncp, start));
244 }
245 
246 static int
247 nsim_setup_tc_block_cb(enum tc_setup_type type, void *type_data, void *cb_priv)
248 {
249 	return nsim_bpf_setup_tc_block_cb(type, type_data, cb_priv);
250 }
251 
252 static int
253 nsim_setup_tc_block(struct net_device *dev, struct tc_block_offload *f)
254 {
255 	struct netdevsim *ns = netdev_priv(dev);
256 
257 	if (f->binder_type != TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
258 		return -EOPNOTSUPP;
259 
260 	switch (f->command) {
261 	case TC_BLOCK_BIND:
262 		return tcf_block_cb_register(f->block, nsim_setup_tc_block_cb,
263 					     ns, ns);
264 	case TC_BLOCK_UNBIND:
265 		tcf_block_cb_unregister(f->block, nsim_setup_tc_block_cb, ns);
266 		return 0;
267 	default:
268 		return -EOPNOTSUPP;
269 	}
270 }
271 
272 static int nsim_set_vf_mac(struct net_device *dev, int vf, u8 *mac)
273 {
274 	struct netdevsim *ns = netdev_priv(dev);
275 
276 	/* Only refuse multicast addresses, zero address can mean unset/any. */
277 	if (vf >= ns->num_vfs || is_multicast_ether_addr(mac))
278 		return -EINVAL;
279 	memcpy(ns->vfconfigs[vf].vf_mac, mac, ETH_ALEN);
280 
281 	return 0;
282 }
283 
284 static int nsim_set_vf_vlan(struct net_device *dev, int vf,
285 			    u16 vlan, u8 qos, __be16 vlan_proto)
286 {
287 	struct netdevsim *ns = netdev_priv(dev);
288 
289 	if (vf >= ns->num_vfs || vlan > 4095 || qos > 7)
290 		return -EINVAL;
291 
292 	ns->vfconfigs[vf].vlan = vlan;
293 	ns->vfconfigs[vf].qos = qos;
294 	ns->vfconfigs[vf].vlan_proto = vlan_proto;
295 
296 	return 0;
297 }
298 
299 static int nsim_set_vf_rate(struct net_device *dev, int vf, int min, int max)
300 {
301 	struct netdevsim *ns = netdev_priv(dev);
302 
303 	if (vf >= ns->num_vfs)
304 		return -EINVAL;
305 
306 	ns->vfconfigs[vf].min_tx_rate = min;
307 	ns->vfconfigs[vf].max_tx_rate = max;
308 
309 	return 0;
310 }
311 
312 static int nsim_set_vf_spoofchk(struct net_device *dev, int vf, bool val)
313 {
314 	struct netdevsim *ns = netdev_priv(dev);
315 
316 	if (vf >= ns->num_vfs)
317 		return -EINVAL;
318 	ns->vfconfigs[vf].spoofchk_enabled = val;
319 
320 	return 0;
321 }
322 
323 static int nsim_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)
324 {
325 	struct netdevsim *ns = netdev_priv(dev);
326 
327 	if (vf >= ns->num_vfs)
328 		return -EINVAL;
329 	ns->vfconfigs[vf].rss_query_enabled = val;
330 
331 	return 0;
332 }
333 
334 static int nsim_set_vf_trust(struct net_device *dev, int vf, bool val)
335 {
336 	struct netdevsim *ns = netdev_priv(dev);
337 
338 	if (vf >= ns->num_vfs)
339 		return -EINVAL;
340 	ns->vfconfigs[vf].trusted = val;
341 
342 	return 0;
343 }
344 
345 static int
346 nsim_get_vf_config(struct net_device *dev, int vf, struct ifla_vf_info *ivi)
347 {
348 	struct netdevsim *ns = netdev_priv(dev);
349 
350 	if (vf >= ns->num_vfs)
351 		return -EINVAL;
352 
353 	ivi->vf = vf;
354 	ivi->linkstate = ns->vfconfigs[vf].link_state;
355 	ivi->min_tx_rate = ns->vfconfigs[vf].min_tx_rate;
356 	ivi->max_tx_rate = ns->vfconfigs[vf].max_tx_rate;
357 	ivi->vlan = ns->vfconfigs[vf].vlan;
358 	ivi->vlan_proto = ns->vfconfigs[vf].vlan_proto;
359 	ivi->qos = ns->vfconfigs[vf].qos;
360 	memcpy(&ivi->mac, ns->vfconfigs[vf].vf_mac, ETH_ALEN);
361 	ivi->spoofchk = ns->vfconfigs[vf].spoofchk_enabled;
362 	ivi->trusted = ns->vfconfigs[vf].trusted;
363 	ivi->rss_query_en = ns->vfconfigs[vf].rss_query_enabled;
364 
365 	return 0;
366 }
367 
368 static int nsim_set_vf_link_state(struct net_device *dev, int vf, int state)
369 {
370 	struct netdevsim *ns = netdev_priv(dev);
371 
372 	if (vf >= ns->num_vfs)
373 		return -EINVAL;
374 
375 	switch (state) {
376 	case IFLA_VF_LINK_STATE_AUTO:
377 	case IFLA_VF_LINK_STATE_ENABLE:
378 	case IFLA_VF_LINK_STATE_DISABLE:
379 		break;
380 	default:
381 		return -EINVAL;
382 	}
383 
384 	ns->vfconfigs[vf].link_state = state;
385 
386 	return 0;
387 }
388 
389 static int
390 nsim_setup_tc(struct net_device *dev, enum tc_setup_type type, void *type_data)
391 {
392 	switch (type) {
393 	case TC_SETUP_BLOCK:
394 		return nsim_setup_tc_block(dev, type_data);
395 	default:
396 		return -EOPNOTSUPP;
397 	}
398 }
399 
400 static int
401 nsim_set_features(struct net_device *dev, netdev_features_t features)
402 {
403 	struct netdevsim *ns = netdev_priv(dev);
404 
405 	if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC))
406 		return nsim_bpf_disable_tc(ns);
407 
408 	return 0;
409 }
410 
411 static const struct net_device_ops nsim_netdev_ops = {
412 	.ndo_init		= nsim_init,
413 	.ndo_uninit		= nsim_uninit,
414 	.ndo_start_xmit		= nsim_start_xmit,
415 	.ndo_set_rx_mode	= nsim_set_rx_mode,
416 	.ndo_set_mac_address	= eth_mac_addr,
417 	.ndo_validate_addr	= eth_validate_addr,
418 	.ndo_change_mtu		= nsim_change_mtu,
419 	.ndo_get_stats64	= nsim_get_stats64,
420 	.ndo_set_vf_mac		= nsim_set_vf_mac,
421 	.ndo_set_vf_vlan	= nsim_set_vf_vlan,
422 	.ndo_set_vf_rate	= nsim_set_vf_rate,
423 	.ndo_set_vf_spoofchk	= nsim_set_vf_spoofchk,
424 	.ndo_set_vf_trust	= nsim_set_vf_trust,
425 	.ndo_get_vf_config	= nsim_get_vf_config,
426 	.ndo_set_vf_link_state	= nsim_set_vf_link_state,
427 	.ndo_set_vf_rss_query_en = nsim_set_vf_rss_query_en,
428 	.ndo_setup_tc		= nsim_setup_tc,
429 	.ndo_set_features	= nsim_set_features,
430 	.ndo_bpf		= nsim_bpf,
431 };
432 
433 static void nsim_setup(struct net_device *dev)
434 {
435 	ether_setup(dev);
436 	eth_hw_addr_random(dev);
437 
438 	dev->netdev_ops = &nsim_netdev_ops;
439 	dev->priv_destructor = nsim_free;
440 
441 	dev->tx_queue_len = 0;
442 	dev->flags |= IFF_NOARP;
443 	dev->flags &= ~IFF_MULTICAST;
444 	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE |
445 			   IFF_NO_QUEUE;
446 	dev->features |= NETIF_F_HIGHDMA |
447 			 NETIF_F_SG |
448 			 NETIF_F_FRAGLIST |
449 			 NETIF_F_HW_CSUM |
450 			 NETIF_F_TSO;
451 	dev->hw_features |= NETIF_F_HW_TC;
452 	dev->max_mtu = ETH_MAX_MTU;
453 }
454 
455 static int nsim_validate(struct nlattr *tb[], struct nlattr *data[],
456 			 struct netlink_ext_ack *extack)
457 {
458 	if (tb[IFLA_ADDRESS]) {
459 		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
460 			return -EINVAL;
461 		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
462 			return -EADDRNOTAVAIL;
463 	}
464 	return 0;
465 }
466 
467 static struct rtnl_link_ops nsim_link_ops __read_mostly = {
468 	.kind		= DRV_NAME,
469 	.priv_size	= sizeof(struct netdevsim),
470 	.setup		= nsim_setup,
471 	.validate	= nsim_validate,
472 };
473 
474 struct dentry *nsim_ddir;
475 
476 static int __init nsim_module_init(void)
477 {
478 	int err;
479 
480 	nsim_ddir = debugfs_create_dir(DRV_NAME, NULL);
481 	if (IS_ERR_OR_NULL(nsim_ddir))
482 		return -ENOMEM;
483 
484 	err = bus_register(&nsim_bus);
485 	if (err)
486 		goto err_debugfs_destroy;
487 
488 	err = nsim_devlink_init();
489 	if (err)
490 		goto err_unreg_bus;
491 
492 	err = rtnl_link_register(&nsim_link_ops);
493 	if (err)
494 		goto err_dl_fini;
495 
496 	return 0;
497 
498 err_dl_fini:
499 	nsim_devlink_exit();
500 err_unreg_bus:
501 	bus_unregister(&nsim_bus);
502 err_debugfs_destroy:
503 	debugfs_remove_recursive(nsim_ddir);
504 	return err;
505 }
506 
507 static void __exit nsim_module_exit(void)
508 {
509 	rtnl_link_unregister(&nsim_link_ops);
510 	nsim_devlink_exit();
511 	bus_unregister(&nsim_bus);
512 	debugfs_remove_recursive(nsim_ddir);
513 }
514 
515 module_init(nsim_module_init);
516 module_exit(nsim_module_exit);
517 MODULE_LICENSE("GPL");
518 MODULE_ALIAS_RTNL_LINK(DRV_NAME);
519