xref: /openbmc/linux/drivers/net/netdevsim/netdev.c (revision 867e6d38)
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 
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 
47 static void nsim_set_rx_mode(struct net_device *dev)
48 {
49 }
50 
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
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
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 
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_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
86 
87 	/* Only refuse multicast addresses, zero address can mean unset/any. */
88 	if (vf >= nsim_bus_dev->num_vfs || is_multicast_ether_addr(mac))
89 		return -EINVAL;
90 	memcpy(nsim_bus_dev->vfconfigs[vf].vf_mac, mac, ETH_ALEN);
91 
92 	return 0;
93 }
94 
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_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
100 
101 	if (vf >= nsim_bus_dev->num_vfs || vlan > 4095 || qos > 7)
102 		return -EINVAL;
103 
104 	nsim_bus_dev->vfconfigs[vf].vlan = vlan;
105 	nsim_bus_dev->vfconfigs[vf].qos = qos;
106 	nsim_bus_dev->vfconfigs[vf].vlan_proto = vlan_proto;
107 
108 	return 0;
109 }
110 
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_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
115 
116 	if (vf >= nsim_bus_dev->num_vfs)
117 		return -EINVAL;
118 
119 	nsim_bus_dev->vfconfigs[vf].min_tx_rate = min;
120 	nsim_bus_dev->vfconfigs[vf].max_tx_rate = max;
121 
122 	return 0;
123 }
124 
125 static int nsim_set_vf_spoofchk(struct net_device *dev, int vf, bool val)
126 {
127 	struct netdevsim *ns = netdev_priv(dev);
128 	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
129 
130 	if (vf >= nsim_bus_dev->num_vfs)
131 		return -EINVAL;
132 	nsim_bus_dev->vfconfigs[vf].spoofchk_enabled = val;
133 
134 	return 0;
135 }
136 
137 static int nsim_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)
138 {
139 	struct netdevsim *ns = netdev_priv(dev);
140 	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
141 
142 	if (vf >= nsim_bus_dev->num_vfs)
143 		return -EINVAL;
144 	nsim_bus_dev->vfconfigs[vf].rss_query_enabled = val;
145 
146 	return 0;
147 }
148 
149 static int nsim_set_vf_trust(struct net_device *dev, int vf, bool val)
150 {
151 	struct netdevsim *ns = netdev_priv(dev);
152 	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
153 
154 	if (vf >= nsim_bus_dev->num_vfs)
155 		return -EINVAL;
156 	nsim_bus_dev->vfconfigs[vf].trusted = val;
157 
158 	return 0;
159 }
160 
161 static int
162 nsim_get_vf_config(struct net_device *dev, int vf, struct ifla_vf_info *ivi)
163 {
164 	struct netdevsim *ns = netdev_priv(dev);
165 	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
166 
167 	if (vf >= nsim_bus_dev->num_vfs)
168 		return -EINVAL;
169 
170 	ivi->vf = vf;
171 	ivi->linkstate = nsim_bus_dev->vfconfigs[vf].link_state;
172 	ivi->min_tx_rate = nsim_bus_dev->vfconfigs[vf].min_tx_rate;
173 	ivi->max_tx_rate = nsim_bus_dev->vfconfigs[vf].max_tx_rate;
174 	ivi->vlan = nsim_bus_dev->vfconfigs[vf].vlan;
175 	ivi->vlan_proto = nsim_bus_dev->vfconfigs[vf].vlan_proto;
176 	ivi->qos = nsim_bus_dev->vfconfigs[vf].qos;
177 	memcpy(&ivi->mac, nsim_bus_dev->vfconfigs[vf].vf_mac, ETH_ALEN);
178 	ivi->spoofchk = nsim_bus_dev->vfconfigs[vf].spoofchk_enabled;
179 	ivi->trusted = nsim_bus_dev->vfconfigs[vf].trusted;
180 	ivi->rss_query_en = nsim_bus_dev->vfconfigs[vf].rss_query_enabled;
181 
182 	return 0;
183 }
184 
185 static int nsim_set_vf_link_state(struct net_device *dev, int vf, int state)
186 {
187 	struct netdevsim *ns = netdev_priv(dev);
188 	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
189 
190 	if (vf >= nsim_bus_dev->num_vfs)
191 		return -EINVAL;
192 
193 	switch (state) {
194 	case IFLA_VF_LINK_STATE_AUTO:
195 	case IFLA_VF_LINK_STATE_ENABLE:
196 	case IFLA_VF_LINK_STATE_DISABLE:
197 		break;
198 	default:
199 		return -EINVAL;
200 	}
201 
202 	nsim_bus_dev->vfconfigs[vf].link_state = state;
203 
204 	return 0;
205 }
206 
207 static LIST_HEAD(nsim_block_cb_list);
208 
209 static int
210 nsim_setup_tc(struct net_device *dev, enum tc_setup_type type, void *type_data)
211 {
212 	struct netdevsim *ns = netdev_priv(dev);
213 
214 	switch (type) {
215 	case TC_SETUP_BLOCK:
216 		return flow_block_cb_setup_simple(type_data,
217 						  &nsim_block_cb_list,
218 						  nsim_setup_tc_block_cb,
219 						  ns, ns, true);
220 	default:
221 		return -EOPNOTSUPP;
222 	}
223 }
224 
225 static int
226 nsim_set_features(struct net_device *dev, netdev_features_t features)
227 {
228 	struct netdevsim *ns = netdev_priv(dev);
229 
230 	if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC))
231 		return nsim_bpf_disable_tc(ns);
232 
233 	return 0;
234 }
235 
236 static struct devlink_port *nsim_get_devlink_port(struct net_device *dev)
237 {
238 	struct netdevsim *ns = netdev_priv(dev);
239 
240 	return &ns->nsim_dev_port->devlink_port;
241 }
242 
243 static const struct net_device_ops nsim_netdev_ops = {
244 	.ndo_start_xmit		= nsim_start_xmit,
245 	.ndo_set_rx_mode	= nsim_set_rx_mode,
246 	.ndo_set_mac_address	= eth_mac_addr,
247 	.ndo_validate_addr	= eth_validate_addr,
248 	.ndo_change_mtu		= nsim_change_mtu,
249 	.ndo_get_stats64	= nsim_get_stats64,
250 	.ndo_set_vf_mac		= nsim_set_vf_mac,
251 	.ndo_set_vf_vlan	= nsim_set_vf_vlan,
252 	.ndo_set_vf_rate	= nsim_set_vf_rate,
253 	.ndo_set_vf_spoofchk	= nsim_set_vf_spoofchk,
254 	.ndo_set_vf_trust	= nsim_set_vf_trust,
255 	.ndo_get_vf_config	= nsim_get_vf_config,
256 	.ndo_set_vf_link_state	= nsim_set_vf_link_state,
257 	.ndo_set_vf_rss_query_en = nsim_set_vf_rss_query_en,
258 	.ndo_setup_tc		= nsim_setup_tc,
259 	.ndo_set_features	= nsim_set_features,
260 	.ndo_bpf		= nsim_bpf,
261 	.ndo_get_devlink_port	= nsim_get_devlink_port,
262 };
263 
264 static void nsim_setup(struct net_device *dev)
265 {
266 	ether_setup(dev);
267 	eth_hw_addr_random(dev);
268 
269 	dev->tx_queue_len = 0;
270 	dev->flags |= IFF_NOARP;
271 	dev->flags &= ~IFF_MULTICAST;
272 	dev->priv_flags |= IFF_LIVE_ADDR_CHANGE |
273 			   IFF_NO_QUEUE;
274 	dev->features |= NETIF_F_HIGHDMA |
275 			 NETIF_F_SG |
276 			 NETIF_F_FRAGLIST |
277 			 NETIF_F_HW_CSUM |
278 			 NETIF_F_TSO;
279 	dev->hw_features |= NETIF_F_HW_TC;
280 	dev->max_mtu = ETH_MAX_MTU;
281 }
282 
283 struct netdevsim *
284 nsim_create(struct nsim_dev *nsim_dev, struct nsim_dev_port *nsim_dev_port)
285 {
286 	struct net_device *dev;
287 	struct netdevsim *ns;
288 	int err;
289 
290 	dev = alloc_netdev(sizeof(*ns), "eth%d", NET_NAME_UNKNOWN, nsim_setup);
291 	if (!dev)
292 		return ERR_PTR(-ENOMEM);
293 
294 	dev_net_set(dev, nsim_dev_net(nsim_dev));
295 	ns = netdev_priv(dev);
296 	ns->netdev = dev;
297 	u64_stats_init(&ns->syncp);
298 	ns->nsim_dev = nsim_dev;
299 	ns->nsim_dev_port = nsim_dev_port;
300 	ns->nsim_bus_dev = nsim_dev->nsim_bus_dev;
301 	SET_NETDEV_DEV(dev, &ns->nsim_bus_dev->dev);
302 	dev->netdev_ops = &nsim_netdev_ops;
303 	nsim_ethtool_init(ns);
304 
305 	err = nsim_udp_tunnels_info_create(nsim_dev, dev);
306 	if (err)
307 		goto err_free_netdev;
308 
309 	rtnl_lock();
310 	err = nsim_bpf_init(ns);
311 	if (err)
312 		goto err_utn_destroy;
313 
314 	nsim_ipsec_init(ns);
315 
316 	err = register_netdevice(dev);
317 	if (err)
318 		goto err_ipsec_teardown;
319 	rtnl_unlock();
320 
321 	return ns;
322 
323 err_ipsec_teardown:
324 	nsim_ipsec_teardown(ns);
325 	nsim_bpf_uninit(ns);
326 err_utn_destroy:
327 	rtnl_unlock();
328 	nsim_udp_tunnels_info_destroy(dev);
329 err_free_netdev:
330 	free_netdev(dev);
331 	return ERR_PTR(err);
332 }
333 
334 void nsim_destroy(struct netdevsim *ns)
335 {
336 	struct net_device *dev = ns->netdev;
337 
338 	rtnl_lock();
339 	unregister_netdevice(dev);
340 	nsim_ipsec_teardown(ns);
341 	nsim_bpf_uninit(ns);
342 	rtnl_unlock();
343 	nsim_udp_tunnels_info_destroy(dev);
344 	free_netdev(dev);
345 }
346 
347 static int nsim_validate(struct nlattr *tb[], struct nlattr *data[],
348 			 struct netlink_ext_ack *extack)
349 {
350 	NL_SET_ERR_MSG_MOD(extack, "Please use: echo \"[ID] [PORT_COUNT]\" > /sys/bus/netdevsim/new_device");
351 	return -EOPNOTSUPP;
352 }
353 
354 static struct rtnl_link_ops nsim_link_ops __read_mostly = {
355 	.kind		= DRV_NAME,
356 	.validate	= nsim_validate,
357 };
358 
359 static int __init nsim_module_init(void)
360 {
361 	int err;
362 
363 	err = nsim_dev_init();
364 	if (err)
365 		return err;
366 
367 	err = nsim_bus_init();
368 	if (err)
369 		goto err_dev_exit;
370 
371 	err = rtnl_link_register(&nsim_link_ops);
372 	if (err)
373 		goto err_bus_exit;
374 
375 	return 0;
376 
377 err_bus_exit:
378 	nsim_bus_exit();
379 err_dev_exit:
380 	nsim_dev_exit();
381 	return err;
382 }
383 
384 static void __exit nsim_module_exit(void)
385 {
386 	rtnl_link_unregister(&nsim_link_ops);
387 	nsim_bus_exit();
388 	nsim_dev_exit();
389 }
390 
391 module_init(nsim_module_init);
392 module_exit(nsim_module_exit);
393 MODULE_LICENSE("GPL");
394 MODULE_ALIAS_RTNL_LINK(DRV_NAME);
395