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
 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
 41out:
 42	dev_kfree_skb(skb);
 43
 44	return NETDEV_TX_OK;
 45}
 46
 47static void nsim_set_rx_mode(struct net_device *dev)
 48{
 49}
 50
 51static 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
 63static void
 64nsim_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
 76static int
 77nsim_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
 82static 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
 95static 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
111static 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
130static 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
142static 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
154static 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
166static int
167nsim_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
190static 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
212static void nsim_taprio_stats(struct tc_taprio_qopt_stats *stats)
213{
214	stats->window_drops = 0;
215	stats->tx_overruns = 0;
216}
217
218static 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
237static LIST_HEAD(nsim_block_cb_list);
238
239static int
240nsim_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
257static int
258nsim_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
268static 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
288static 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
299static 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
319static 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
349err_ipsec_teardown:
350	nsim_ipsec_teardown(ns);
351	nsim_macsec_teardown(ns);
352	nsim_bpf_uninit(ns);
353err_utn_destroy:
354	rtnl_unlock();
355	nsim_udp_tunnels_info_destroy(ns->netdev);
356err_phc_destroy:
357	mock_phc_destroy(ns->phc);
358	return err;
359}
360
361static 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
372static void nsim_exit_netdevsim(struct netdevsim *ns)
373{
374	nsim_udp_tunnels_info_destroy(ns->netdev);
375	mock_phc_destroy(ns->phc);
376}
377
378struct netdevsim *
379nsim_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
408err_free_netdev:
409	free_netdev(dev);
410	return ERR_PTR(err);
411}
412
413void 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
430static 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
438static struct rtnl_link_ops nsim_link_ops __read_mostly = {
439	.kind		= DRV_NAME,
440	.validate	= nsim_validate,
441};
442
443static 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
461err_bus_exit:
462	nsim_bus_exit();
463err_dev_exit:
464	nsim_dev_exit();
465	return err;
466}
467
468static void __exit nsim_module_exit(void)
469{
470	rtnl_link_unregister(&nsim_link_ops);
471	nsim_bus_exit();
472	nsim_dev_exit();
473}
474
475module_init(nsim_module_init);
476module_exit(nsim_module_exit);
477MODULE_LICENSE("GPL");
478MODULE_DESCRIPTION("Simulated networking device for testing");
479MODULE_ALIAS_RTNL_LINK(DRV_NAME);