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