xref: /openbmc/linux/drivers/net/netdevsim/netdev.c (revision 08aca659)
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 #include <net/udp_tunnel.h>
26 
27 #include "netdevsim.h"
28 
nsim_start_xmit(struct sk_buff * skb,struct net_device * dev)29 static netdev_tx_t nsim_start_xmit(struct sk_buff *skb, struct net_device *dev)
30 {
31 	struct netdevsim *ns = netdev_priv(dev);
32 
33 	if (!nsim_ipsec_tx(ns, skb))
34 		goto out;
35 
36 	u64_stats_update_begin(&ns->syncp);
37 	ns->tx_packets++;
38 	ns->tx_bytes += skb->len;
39 	u64_stats_update_end(&ns->syncp);
40 
41 out:
42 	dev_kfree_skb(skb);
43 
44 	return NETDEV_TX_OK;
45 }
46 
nsim_set_rx_mode(struct net_device * dev)47 static void nsim_set_rx_mode(struct net_device *dev)
48 {
49 }
50 
nsim_change_mtu(struct net_device * dev,int new_mtu)51 static int nsim_change_mtu(struct net_device *dev, int new_mtu)
52 {
53 	struct netdevsim *ns = netdev_priv(dev);
54 
55 	if (ns->xdp.prog && new_mtu > NSIM_XDP_MAX_MTU)
56 		return -EBUSY;
57 
58 	dev->mtu = new_mtu;
59 
60 	return 0;
61 }
62 
63 static void
nsim_get_stats64(struct net_device * dev,struct rtnl_link_stats64 * stats)64 nsim_get_stats64(struct net_device *dev, struct rtnl_link_stats64 *stats)
65 {
66 	struct netdevsim *ns = netdev_priv(dev);
67 	unsigned int start;
68 
69 	do {
70 		start = u64_stats_fetch_begin(&ns->syncp);
71 		stats->tx_bytes = ns->tx_bytes;
72 		stats->tx_packets = ns->tx_packets;
73 	} while (u64_stats_fetch_retry(&ns->syncp, start));
74 }
75 
76 static int
nsim_setup_tc_block_cb(enum tc_setup_type type,void * type_data,void * cb_priv)77 nsim_setup_tc_block_cb(enum tc_setup_type type, void *type_data, void *cb_priv)
78 {
79 	return nsim_bpf_setup_tc_block_cb(type, type_data, cb_priv);
80 }
81 
nsim_set_vf_mac(struct net_device * dev,int vf,u8 * mac)82 static int nsim_set_vf_mac(struct net_device *dev, int vf, u8 *mac)
83 {
84 	struct netdevsim *ns = netdev_priv(dev);
85 	struct nsim_dev *nsim_dev = ns->nsim_dev;
86 
87 	/* Only refuse multicast addresses, zero address can mean unset/any. */
88 	if (vf >= nsim_dev_get_vfs(nsim_dev) || is_multicast_ether_addr(mac))
89 		return -EINVAL;
90 	memcpy(nsim_dev->vfconfigs[vf].vf_mac, mac, ETH_ALEN);
91 
92 	return 0;
93 }
94 
nsim_set_vf_vlan(struct net_device * dev,int vf,u16 vlan,u8 qos,__be16 vlan_proto)95 static int nsim_set_vf_vlan(struct net_device *dev, int vf,
96 			    u16 vlan, u8 qos, __be16 vlan_proto)
97 {
98 	struct netdevsim *ns = netdev_priv(dev);
99 	struct nsim_dev *nsim_dev = ns->nsim_dev;
100 
101 	if (vf >= nsim_dev_get_vfs(nsim_dev) || vlan > 4095 || qos > 7)
102 		return -EINVAL;
103 
104 	nsim_dev->vfconfigs[vf].vlan = vlan;
105 	nsim_dev->vfconfigs[vf].qos = qos;
106 	nsim_dev->vfconfigs[vf].vlan_proto = vlan_proto;
107 
108 	return 0;
109 }
110 
nsim_set_vf_rate(struct net_device * dev,int vf,int min,int max)111 static int nsim_set_vf_rate(struct net_device *dev, int vf, int min, int max)
112 {
113 	struct netdevsim *ns = netdev_priv(dev);
114 	struct nsim_dev *nsim_dev = ns->nsim_dev;
115 
116 	if (nsim_esw_mode_is_switchdev(ns->nsim_dev)) {
117 		pr_err("Not supported in switchdev mode. Please use devlink API.\n");
118 		return -EOPNOTSUPP;
119 	}
120 
121 	if (vf >= nsim_dev_get_vfs(nsim_dev))
122 		return -EINVAL;
123 
124 	nsim_dev->vfconfigs[vf].min_tx_rate = min;
125 	nsim_dev->vfconfigs[vf].max_tx_rate = max;
126 
127 	return 0;
128 }
129 
nsim_set_vf_spoofchk(struct net_device * dev,int vf,bool val)130 static int nsim_set_vf_spoofchk(struct net_device *dev, int vf, bool val)
131 {
132 	struct netdevsim *ns = netdev_priv(dev);
133 	struct nsim_dev *nsim_dev = ns->nsim_dev;
134 
135 	if (vf >= nsim_dev_get_vfs(nsim_dev))
136 		return -EINVAL;
137 	nsim_dev->vfconfigs[vf].spoofchk_enabled = val;
138 
139 	return 0;
140 }
141 
nsim_set_vf_rss_query_en(struct net_device * dev,int vf,bool val)142 static int nsim_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)
143 {
144 	struct netdevsim *ns = netdev_priv(dev);
145 	struct nsim_dev *nsim_dev = ns->nsim_dev;
146 
147 	if (vf >= nsim_dev_get_vfs(nsim_dev))
148 		return -EINVAL;
149 	nsim_dev->vfconfigs[vf].rss_query_enabled = val;
150 
151 	return 0;
152 }
153 
nsim_set_vf_trust(struct net_device * dev,int vf,bool val)154 static int nsim_set_vf_trust(struct net_device *dev, int vf, bool val)
155 {
156 	struct netdevsim *ns = netdev_priv(dev);
157 	struct nsim_dev *nsim_dev = ns->nsim_dev;
158 
159 	if (vf >= nsim_dev_get_vfs(nsim_dev))
160 		return -EINVAL;
161 	nsim_dev->vfconfigs[vf].trusted = val;
162 
163 	return 0;
164 }
165 
166 static int
nsim_get_vf_config(struct net_device * dev,int vf,struct ifla_vf_info * ivi)167 nsim_get_vf_config(struct net_device *dev, int vf, struct ifla_vf_info *ivi)
168 {
169 	struct netdevsim *ns = netdev_priv(dev);
170 	struct nsim_dev *nsim_dev = ns->nsim_dev;
171 
172 	if (vf >= nsim_dev_get_vfs(nsim_dev))
173 		return -EINVAL;
174 
175 	ivi->vf = vf;
176 	ivi->linkstate = nsim_dev->vfconfigs[vf].link_state;
177 	ivi->min_tx_rate = nsim_dev->vfconfigs[vf].min_tx_rate;
178 	ivi->max_tx_rate = nsim_dev->vfconfigs[vf].max_tx_rate;
179 	ivi->vlan = nsim_dev->vfconfigs[vf].vlan;
180 	ivi->vlan_proto = nsim_dev->vfconfigs[vf].vlan_proto;
181 	ivi->qos = nsim_dev->vfconfigs[vf].qos;
182 	memcpy(&ivi->mac, nsim_dev->vfconfigs[vf].vf_mac, ETH_ALEN);
183 	ivi->spoofchk = nsim_dev->vfconfigs[vf].spoofchk_enabled;
184 	ivi->trusted = nsim_dev->vfconfigs[vf].trusted;
185 	ivi->rss_query_en = nsim_dev->vfconfigs[vf].rss_query_enabled;
186 
187 	return 0;
188 }
189 
nsim_set_vf_link_state(struct net_device * dev,int vf,int state)190 static int nsim_set_vf_link_state(struct net_device *dev, int vf, int state)
191 {
192 	struct netdevsim *ns = netdev_priv(dev);
193 	struct nsim_dev *nsim_dev = ns->nsim_dev;
194 
195 	if (vf >= nsim_dev_get_vfs(nsim_dev))
196 		return -EINVAL;
197 
198 	switch (state) {
199 	case IFLA_VF_LINK_STATE_AUTO:
200 	case IFLA_VF_LINK_STATE_ENABLE:
201 	case IFLA_VF_LINK_STATE_DISABLE:
202 		break;
203 	default:
204 		return -EINVAL;
205 	}
206 
207 	nsim_dev->vfconfigs[vf].link_state = state;
208 
209 	return 0;
210 }
211 
nsim_taprio_stats(struct tc_taprio_qopt_stats * stats)212 static void nsim_taprio_stats(struct tc_taprio_qopt_stats *stats)
213 {
214 	stats->window_drops = 0;
215 	stats->tx_overruns = 0;
216 }
217 
nsim_setup_tc_taprio(struct net_device * dev,struct tc_taprio_qopt_offload * offload)218 static int nsim_setup_tc_taprio(struct net_device *dev,
219 				struct tc_taprio_qopt_offload *offload)
220 {
221 	int err = 0;
222 
223 	switch (offload->cmd) {
224 	case TAPRIO_CMD_REPLACE:
225 	case TAPRIO_CMD_DESTROY:
226 		break;
227 	case TAPRIO_CMD_STATS:
228 		nsim_taprio_stats(&offload->stats);
229 		break;
230 	default:
231 		err = -EOPNOTSUPP;
232 	}
233 
234 	return err;
235 }
236 
237 static LIST_HEAD(nsim_block_cb_list);
238 
239 static int
nsim_setup_tc(struct net_device * dev,enum tc_setup_type type,void * type_data)240 nsim_setup_tc(struct net_device *dev, enum tc_setup_type type, void *type_data)
241 {
242 	struct netdevsim *ns = netdev_priv(dev);
243 
244 	switch (type) {
245 	case TC_SETUP_QDISC_TAPRIO:
246 		return nsim_setup_tc_taprio(dev, type_data);
247 	case TC_SETUP_BLOCK:
248 		return flow_block_cb_setup_simple(type_data,
249 						  &nsim_block_cb_list,
250 						  nsim_setup_tc_block_cb,
251 						  ns, ns, true);
252 	default:
253 		return -EOPNOTSUPP;
254 	}
255 }
256 
257 static int
nsim_set_features(struct net_device * dev,netdev_features_t features)258 nsim_set_features(struct net_device *dev, netdev_features_t features)
259 {
260 	struct netdevsim *ns = netdev_priv(dev);
261 
262 	if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC))
263 		return nsim_bpf_disable_tc(ns);
264 
265 	return 0;
266 }
267 
268 static const struct net_device_ops nsim_netdev_ops = {
269 	.ndo_start_xmit		= nsim_start_xmit,
270 	.ndo_set_rx_mode	= nsim_set_rx_mode,
271 	.ndo_set_mac_address	= eth_mac_addr,
272 	.ndo_validate_addr	= eth_validate_addr,
273 	.ndo_change_mtu		= nsim_change_mtu,
274 	.ndo_get_stats64	= nsim_get_stats64,
275 	.ndo_set_vf_mac		= nsim_set_vf_mac,
276 	.ndo_set_vf_vlan	= nsim_set_vf_vlan,
277 	.ndo_set_vf_rate	= nsim_set_vf_rate,
278 	.ndo_set_vf_spoofchk	= nsim_set_vf_spoofchk,
279 	.ndo_set_vf_trust	= nsim_set_vf_trust,
280 	.ndo_get_vf_config	= nsim_get_vf_config,
281 	.ndo_set_vf_link_state	= nsim_set_vf_link_state,
282 	.ndo_set_vf_rss_query_en = nsim_set_vf_rss_query_en,
283 	.ndo_setup_tc		= nsim_setup_tc,
284 	.ndo_set_features	= nsim_set_features,
285 	.ndo_bpf		= nsim_bpf,
286 };
287 
288 static const struct net_device_ops nsim_vf_netdev_ops = {
289 	.ndo_start_xmit		= nsim_start_xmit,
290 	.ndo_set_rx_mode	= nsim_set_rx_mode,
291 	.ndo_set_mac_address	= eth_mac_addr,
292 	.ndo_validate_addr	= eth_validate_addr,
293 	.ndo_change_mtu		= nsim_change_mtu,
294 	.ndo_get_stats64	= nsim_get_stats64,
295 	.ndo_setup_tc		= nsim_setup_tc,
296 	.ndo_set_features	= nsim_set_features,
297 };
298 
nsim_setup(struct net_device * dev)299 static void nsim_setup(struct net_device *dev)
300 {
301 	ether_setup(dev);
302 	eth_hw_addr_random(dev);
303 
304 	dev->tx_queue_len = 0;
305 	dev->flags |= IFF_NOARP;
306 	dev->flags &= ~IFF_MULTICAST;
307 	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE |
308 			   IFF_NO_QUEUE;
309 	dev->features |= NETIF_F_HIGHDMA |
310 			 NETIF_F_SG |
311 			 NETIF_F_FRAGLIST |
312 			 NETIF_F_HW_CSUM |
313 			 NETIF_F_TSO;
314 	dev->hw_features |= NETIF_F_HW_TC;
315 	dev->max_mtu = ETH_MAX_MTU;
316 	dev->xdp_features = NETDEV_XDP_ACT_HW_OFFLOAD;
317 }
318 
nsim_init_netdevsim(struct netdevsim * ns)319 static int nsim_init_netdevsim(struct netdevsim *ns)
320 {
321 	struct mock_phc *phc;
322 	int err;
323 
324 	phc = mock_phc_create(&ns->nsim_bus_dev->dev);
325 	if (IS_ERR(phc))
326 		return PTR_ERR(phc);
327 
328 	ns->phc = phc;
329 	ns->netdev->netdev_ops = &nsim_netdev_ops;
330 
331 	err = nsim_udp_tunnels_info_create(ns->nsim_dev, ns->netdev);
332 	if (err)
333 		goto err_phc_destroy;
334 
335 	rtnl_lock();
336 	err = nsim_bpf_init(ns);
337 	if (err)
338 		goto err_utn_destroy;
339 
340 	nsim_macsec_init(ns);
341 	nsim_ipsec_init(ns);
342 
343 	err = register_netdevice(ns->netdev);
344 	if (err)
345 		goto err_ipsec_teardown;
346 	rtnl_unlock();
347 	return 0;
348 
349 err_ipsec_teardown:
350 	nsim_ipsec_teardown(ns);
351 	nsim_macsec_teardown(ns);
352 	nsim_bpf_uninit(ns);
353 err_utn_destroy:
354 	rtnl_unlock();
355 	nsim_udp_tunnels_info_destroy(ns->netdev);
356 err_phc_destroy:
357 	mock_phc_destroy(ns->phc);
358 	return err;
359 }
360 
nsim_init_netdevsim_vf(struct netdevsim * ns)361 static int nsim_init_netdevsim_vf(struct netdevsim *ns)
362 {
363 	int err;
364 
365 	ns->netdev->netdev_ops = &nsim_vf_netdev_ops;
366 	rtnl_lock();
367 	err = register_netdevice(ns->netdev);
368 	rtnl_unlock();
369 	return err;
370 }
371 
nsim_exit_netdevsim(struct netdevsim * ns)372 static void nsim_exit_netdevsim(struct netdevsim *ns)
373 {
374 	nsim_udp_tunnels_info_destroy(ns->netdev);
375 	mock_phc_destroy(ns->phc);
376 }
377 
378 struct netdevsim *
nsim_create(struct nsim_dev * nsim_dev,struct nsim_dev_port * nsim_dev_port)379 nsim_create(struct nsim_dev *nsim_dev, struct nsim_dev_port *nsim_dev_port)
380 {
381 	struct net_device *dev;
382 	struct netdevsim *ns;
383 	int err;
384 
385 	dev = alloc_netdev_mq(sizeof(*ns), "eth%d", NET_NAME_UNKNOWN, nsim_setup,
386 			      nsim_dev->nsim_bus_dev->num_queues);
387 	if (!dev)
388 		return ERR_PTR(-ENOMEM);
389 
390 	dev_net_set(dev, nsim_dev_net(nsim_dev));
391 	ns = netdev_priv(dev);
392 	ns->netdev = dev;
393 	u64_stats_init(&ns->syncp);
394 	ns->nsim_dev = nsim_dev;
395 	ns->nsim_dev_port = nsim_dev_port;
396 	ns->nsim_bus_dev = nsim_dev->nsim_bus_dev;
397 	SET_NETDEV_DEV(dev, &ns->nsim_bus_dev->dev);
398 	SET_NETDEV_DEVLINK_PORT(dev, &nsim_dev_port->devlink_port);
399 	nsim_ethtool_init(ns);
400 	if (nsim_dev_port_is_pf(nsim_dev_port))
401 		err = nsim_init_netdevsim(ns);
402 	else
403 		err = nsim_init_netdevsim_vf(ns);
404 	if (err)
405 		goto err_free_netdev;
406 	return ns;
407 
408 err_free_netdev:
409 	free_netdev(dev);
410 	return ERR_PTR(err);
411 }
412 
nsim_destroy(struct netdevsim * ns)413 void nsim_destroy(struct netdevsim *ns)
414 {
415 	struct net_device *dev = ns->netdev;
416 
417 	rtnl_lock();
418 	unregister_netdevice(dev);
419 	if (nsim_dev_port_is_pf(ns->nsim_dev_port)) {
420 		nsim_macsec_teardown(ns);
421 		nsim_ipsec_teardown(ns);
422 		nsim_bpf_uninit(ns);
423 	}
424 	rtnl_unlock();
425 	if (nsim_dev_port_is_pf(ns->nsim_dev_port))
426 		nsim_exit_netdevsim(ns);
427 	free_netdev(dev);
428 }
429 
nsim_validate(struct nlattr * tb[],struct nlattr * data[],struct netlink_ext_ack * extack)430 static int nsim_validate(struct nlattr *tb[], struct nlattr *data[],
431 			 struct netlink_ext_ack *extack)
432 {
433 	NL_SET_ERR_MSG_MOD(extack,
434 			   "Please use: echo \"[ID] [PORT_COUNT] [NUM_QUEUES]\" > /sys/bus/netdevsim/new_device");
435 	return -EOPNOTSUPP;
436 }
437 
438 static struct rtnl_link_ops nsim_link_ops __read_mostly = {
439 	.kind		= DRV_NAME,
440 	.validate	= nsim_validate,
441 };
442 
nsim_module_init(void)443 static int __init nsim_module_init(void)
444 {
445 	int err;
446 
447 	err = nsim_dev_init();
448 	if (err)
449 		return err;
450 
451 	err = nsim_bus_init();
452 	if (err)
453 		goto err_dev_exit;
454 
455 	err = rtnl_link_register(&nsim_link_ops);
456 	if (err)
457 		goto err_bus_exit;
458 
459 	return 0;
460 
461 err_bus_exit:
462 	nsim_bus_exit();
463 err_dev_exit:
464 	nsim_dev_exit();
465 	return err;
466 }
467 
nsim_module_exit(void)468 static void __exit nsim_module_exit(void)
469 {
470 	rtnl_link_unregister(&nsim_link_ops);
471 	nsim_bus_exit();
472 	nsim_dev_exit();
473 }
474 
475 module_init(nsim_module_init);
476 module_exit(nsim_module_exit);
477 MODULE_LICENSE("GPL");
478 MODULE_ALIAS_RTNL_LINK(DRV_NAME);
479