Loading...
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);
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 LIST_HEAD(nsim_block_cb_list);
213
214static int
215nsim_setup_tc(struct net_device *dev, enum tc_setup_type type, void *type_data)
216{
217 struct netdevsim *ns = netdev_priv(dev);
218
219 switch (type) {
220 case TC_SETUP_BLOCK:
221 return flow_block_cb_setup_simple(type_data,
222 &nsim_block_cb_list,
223 nsim_setup_tc_block_cb,
224 ns, ns, true);
225 default:
226 return -EOPNOTSUPP;
227 }
228}
229
230static int
231nsim_set_features(struct net_device *dev, netdev_features_t features)
232{
233 struct netdevsim *ns = netdev_priv(dev);
234
235 if ((dev->features & NETIF_F_HW_TC) > (features & NETIF_F_HW_TC))
236 return nsim_bpf_disable_tc(ns);
237
238 return 0;
239}
240
241static const struct net_device_ops nsim_netdev_ops = {
242 .ndo_start_xmit = nsim_start_xmit,
243 .ndo_set_rx_mode = nsim_set_rx_mode,
244 .ndo_set_mac_address = eth_mac_addr,
245 .ndo_validate_addr = eth_validate_addr,
246 .ndo_change_mtu = nsim_change_mtu,
247 .ndo_get_stats64 = nsim_get_stats64,
248 .ndo_set_vf_mac = nsim_set_vf_mac,
249 .ndo_set_vf_vlan = nsim_set_vf_vlan,
250 .ndo_set_vf_rate = nsim_set_vf_rate,
251 .ndo_set_vf_spoofchk = nsim_set_vf_spoofchk,
252 .ndo_set_vf_trust = nsim_set_vf_trust,
253 .ndo_get_vf_config = nsim_get_vf_config,
254 .ndo_set_vf_link_state = nsim_set_vf_link_state,
255 .ndo_set_vf_rss_query_en = nsim_set_vf_rss_query_en,
256 .ndo_setup_tc = nsim_setup_tc,
257 .ndo_set_features = nsim_set_features,
258 .ndo_bpf = nsim_bpf,
259};
260
261static const struct net_device_ops nsim_vf_netdev_ops = {
262 .ndo_start_xmit = nsim_start_xmit,
263 .ndo_set_rx_mode = nsim_set_rx_mode,
264 .ndo_set_mac_address = eth_mac_addr,
265 .ndo_validate_addr = eth_validate_addr,
266 .ndo_change_mtu = nsim_change_mtu,
267 .ndo_get_stats64 = nsim_get_stats64,
268 .ndo_setup_tc = nsim_setup_tc,
269 .ndo_set_features = nsim_set_features,
270};
271
272static void nsim_setup(struct net_device *dev)
273{
274 ether_setup(dev);
275 eth_hw_addr_random(dev);
276
277 dev->tx_queue_len = 0;
278 dev->flags |= IFF_NOARP;
279 dev->flags &= ~IFF_MULTICAST;
280 dev->priv_flags |= IFF_LIVE_ADDR_CHANGE |
281 IFF_NO_QUEUE;
282 dev->features |= NETIF_F_HIGHDMA |
283 NETIF_F_SG |
284 NETIF_F_FRAGLIST |
285 NETIF_F_HW_CSUM |
286 NETIF_F_TSO;
287 dev->hw_features |= NETIF_F_HW_TC;
288 dev->max_mtu = ETH_MAX_MTU;
289}
290
291static int nsim_init_netdevsim(struct netdevsim *ns)
292{
293 int err;
294
295 ns->netdev->netdev_ops = &nsim_netdev_ops;
296
297 err = nsim_udp_tunnels_info_create(ns->nsim_dev, ns->netdev);
298 if (err)
299 return err;
300
301 rtnl_lock();
302 err = nsim_bpf_init(ns);
303 if (err)
304 goto err_utn_destroy;
305
306 nsim_ipsec_init(ns);
307
308 err = register_netdevice(ns->netdev);
309 if (err)
310 goto err_ipsec_teardown;
311 rtnl_unlock();
312 return 0;
313
314err_ipsec_teardown:
315 nsim_ipsec_teardown(ns);
316 nsim_bpf_uninit(ns);
317err_utn_destroy:
318 rtnl_unlock();
319 nsim_udp_tunnels_info_destroy(ns->netdev);
320 return err;
321}
322
323static int nsim_init_netdevsim_vf(struct netdevsim *ns)
324{
325 int err;
326
327 ns->netdev->netdev_ops = &nsim_vf_netdev_ops;
328 rtnl_lock();
329 err = register_netdevice(ns->netdev);
330 rtnl_unlock();
331 return err;
332}
333
334struct netdevsim *
335nsim_create(struct nsim_dev *nsim_dev, struct nsim_dev_port *nsim_dev_port)
336{
337 struct net_device *dev;
338 struct netdevsim *ns;
339 int err;
340
341 dev = alloc_netdev_mq(sizeof(*ns), "eth%d", NET_NAME_UNKNOWN, nsim_setup,
342 nsim_dev->nsim_bus_dev->num_queues);
343 if (!dev)
344 return ERR_PTR(-ENOMEM);
345
346 dev_net_set(dev, nsim_dev_net(nsim_dev));
347 ns = netdev_priv(dev);
348 ns->netdev = dev;
349 u64_stats_init(&ns->syncp);
350 ns->nsim_dev = nsim_dev;
351 ns->nsim_dev_port = nsim_dev_port;
352 ns->nsim_bus_dev = nsim_dev->nsim_bus_dev;
353 SET_NETDEV_DEV(dev, &ns->nsim_bus_dev->dev);
354 SET_NETDEV_DEVLINK_PORT(dev, &nsim_dev_port->devlink_port);
355 nsim_ethtool_init(ns);
356 if (nsim_dev_port_is_pf(nsim_dev_port))
357 err = nsim_init_netdevsim(ns);
358 else
359 err = nsim_init_netdevsim_vf(ns);
360 if (err)
361 goto err_free_netdev;
362 return ns;
363
364err_free_netdev:
365 free_netdev(dev);
366 return ERR_PTR(err);
367}
368
369void nsim_destroy(struct netdevsim *ns)
370{
371 struct net_device *dev = ns->netdev;
372
373 rtnl_lock();
374 unregister_netdevice(dev);
375 if (nsim_dev_port_is_pf(ns->nsim_dev_port)) {
376 nsim_ipsec_teardown(ns);
377 nsim_bpf_uninit(ns);
378 }
379 rtnl_unlock();
380 if (nsim_dev_port_is_pf(ns->nsim_dev_port))
381 nsim_udp_tunnels_info_destroy(dev);
382 free_netdev(dev);
383}
384
385static int nsim_validate(struct nlattr *tb[], struct nlattr *data[],
386 struct netlink_ext_ack *extack)
387{
388 NL_SET_ERR_MSG_MOD(extack,
389 "Please use: echo \"[ID] [PORT_COUNT] [NUM_QUEUES]\" > /sys/bus/netdevsim/new_device");
390 return -EOPNOTSUPP;
391}
392
393static struct rtnl_link_ops nsim_link_ops __read_mostly = {
394 .kind = DRV_NAME,
395 .validate = nsim_validate,
396};
397
398static int __init nsim_module_init(void)
399{
400 int err;
401
402 err = nsim_dev_init();
403 if (err)
404 return err;
405
406 err = nsim_bus_init();
407 if (err)
408 goto err_dev_exit;
409
410 err = rtnl_link_register(&nsim_link_ops);
411 if (err)
412 goto err_bus_exit;
413
414 return 0;
415
416err_bus_exit:
417 nsim_bus_exit();
418err_dev_exit:
419 nsim_dev_exit();
420 return err;
421}
422
423static void __exit nsim_module_exit(void)
424{
425 rtnl_link_unregister(&nsim_link_ops);
426 nsim_bus_exit();
427 nsim_dev_exit();
428}
429
430module_init(nsim_module_init);
431module_exit(nsim_module_exit);
432MODULE_LICENSE("GPL");
433MODULE_ALIAS_RTNL_LINK(DRV_NAME);