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
 28struct 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
 41static u32 nsim_dev_id;
 42
 43static int nsim_num_vf(struct device *dev)
 44{
 45	struct netdevsim *ns = to_nsim(dev);
 46
 47	return ns->num_vfs;
 48}
 49
 50static struct bus_type nsim_bus = {
 51	.name		= DRV_NAME,
 52	.dev_name	= DRV_NAME,
 53	.num_vf		= nsim_num_vf,
 54};
 55
 56static 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
 67static void nsim_vfs_disable(struct netdevsim *ns)
 68{
 69	kfree(ns->vfconfigs);
 70	ns->vfconfigs = NULL;
 71	ns->num_vfs = 0;
 72}
 73
 74static ssize_t
 75nsim_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	}
101exit_good:
102	ret = count;
103exit_unlock:
104	rtnl_unlock();
105
106	return ret;
107}
108
109static ssize_t
110nsim_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
117static struct device_attribute nsim_numvfs_attr =
118	__ATTR(sriov_numvfs, 0664, nsim_numvfs_show, nsim_numvfs_store);
119
120static struct attribute *nsim_dev_attrs[] = {
121	&nsim_numvfs_attr.attr,
122	NULL,
123};
124
125static const struct attribute_group nsim_dev_attr_group = {
126	.attrs = nsim_dev_attrs,
127};
128
129static const struct attribute_group *nsim_dev_attr_groups[] = {
130	&nsim_dev_attr_group,
131	NULL,
132};
133
134static 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
142static struct device_type nsim_dev_type = {
143	.groups = nsim_dev_attr_groups,
144	.release = nsim_dev_release,
145};
146
147static 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
176err_unreg_dev:
177	device_unregister(&ns->dev);
178err_bpf_uninit:
179	nsim_bpf_uninit(ns);
180err_debugfs_destroy:
181	debugfs_remove_recursive(ns->ddir);
182	return err;
183}
184
185static 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
194static 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
202static 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
216static void nsim_set_rx_mode(struct net_device *dev)
217{
218}
219
220static 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
233static void
234nsim_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
246static int
247nsim_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
252static int
253nsim_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
272static 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
284static 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
299static 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
312static 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
323static 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
334static 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
345static int
346nsim_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
368static 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
389static int
390nsim_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
400static int
401nsim_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
411static 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
433static 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
455static 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
467static 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
474struct dentry *nsim_ddir;
475
476static 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
498err_dl_fini:
499	nsim_devlink_exit();
500err_unreg_bus:
501	bus_unregister(&nsim_bus);
502err_debugfs_destroy:
503	debugfs_remove_recursive(nsim_ddir);
504	return err;
505}
506
507static 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
515module_init(nsim_module_init);
516module_exit(nsim_module_exit);
517MODULE_LICENSE("GPL");
518MODULE_ALIAS_RTNL_LINK(DRV_NAME);