disable kernel build waring

hc

2024-05-10 093a6c67005148ae32a5c9e4553491b9f5c2457b

 kernel/drivers/net/netdevsim/netdev.c
..
..
@@ -22,244 +22,9 @@
22
22
 #include <net/netlink.h>
23
23
 #include <net/pkt_cls.h>
24
24
 #include <net/rtnetlink.h>
25
-#include <net/switchdev.h>
25
+#include <net/udp_tunnel.h>
26
26
 
27
27
 #include "netdevsim.h"
28
-
29
-struct nsim_vf_config {
30
-	int link_state;
31
-	u16 min_tx_rate;
32
-	u16 max_tx_rate;
33
-	u16 vlan;
34
-	__be16 vlan_proto;
35
-	u16 qos;
36
-	u8 vf_mac[ETH_ALEN];
37
-	bool spoofchk_enabled;
38
-	bool trusted;
39
-	bool rss_query_enabled;
40
-};
41
-
42
-static u32 nsim_dev_id;
43
-
44
-static struct dentry *nsim_ddir;
45
-static struct dentry *nsim_sdev_ddir;
46
-
47
-static int nsim_num_vf(struct device *dev)
48
-{
49
-	struct netdevsim *ns = to_nsim(dev);
50
-
51
-	return ns->num_vfs;
52
-}
53
-
54
-static struct bus_type nsim_bus = {
55
-	.name		= DRV_NAME,
56
-	.dev_name	= DRV_NAME,
57
-	.num_vf		= nsim_num_vf,
58
-};
59
-
60
-static int nsim_vfs_enable(struct netdevsim *ns, unsigned int num_vfs)
61
-{
62
-	ns->vfconfigs = kcalloc(num_vfs, sizeof(struct nsim_vf_config),
63
-				GFP_KERNEL);
64
-	if (!ns->vfconfigs)
65
-		return -ENOMEM;
66
-	ns->num_vfs = num_vfs;
67
-
68
-	return 0;
69
-}
70
-
71
-static void nsim_vfs_disable(struct netdevsim *ns)
72
-{
73
-	kfree(ns->vfconfigs);
74
-	ns->vfconfigs = NULL;
75
-	ns->num_vfs = 0;
76
-}
77
-
78
-static ssize_t
79
-nsim_numvfs_store(struct device *dev, struct device_attribute *attr,
80
-		  const char *buf, size_t count)
81
-{
82
-	struct netdevsim *ns = to_nsim(dev);
83
-	unsigned int num_vfs;
84
-	int ret;
85
-
86
-	ret = kstrtouint(buf, 0, &num_vfs);
87
-	if (ret)
88
-		return ret;
89
-
90
-	rtnl_lock();
91
-	if (ns->num_vfs == num_vfs)
92
-		goto exit_good;
93
-	if (ns->num_vfs && num_vfs) {
94
-		ret = -EBUSY;
95
-		goto exit_unlock;
96
-	}
97
-
98
-	if (num_vfs) {
99
-		ret = nsim_vfs_enable(ns, num_vfs);
100
-		if (ret)
101
-			goto exit_unlock;
102
-	} else {
103
-		nsim_vfs_disable(ns);
104
-	}
105
-exit_good:
106
-	ret = count;
107
-exit_unlock:
108
-	rtnl_unlock();
109
-
110
-	return ret;
111
-}
112
-
113
-static ssize_t
114
-nsim_numvfs_show(struct device *dev, struct device_attribute *attr, char *buf)
115
-{
116
-	struct netdevsim *ns = to_nsim(dev);
117
-
118
-	return sprintf(buf, "%u\n", ns->num_vfs);
119
-}
120
-
121
-static struct device_attribute nsim_numvfs_attr =
122
-	__ATTR(sriov_numvfs, 0664, nsim_numvfs_show, nsim_numvfs_store);
123
-
124
-static struct attribute *nsim_dev_attrs[] = {
125
-	&nsim_numvfs_attr.attr,
126
-	NULL,
127
-};
128
-
129
-static const struct attribute_group nsim_dev_attr_group = {
130
-	.attrs = nsim_dev_attrs,
131
-};
132
-
133
-static const struct attribute_group *nsim_dev_attr_groups[] = {
134
-	&nsim_dev_attr_group,
135
-	NULL,
136
-};
137
-
138
-static void nsim_dev_release(struct device *dev)
139
-{
140
-	struct netdevsim *ns = to_nsim(dev);
141
-
142
-	nsim_vfs_disable(ns);
143
-	free_netdev(ns->netdev);
144
-}
145
-
146
-static struct device_type nsim_dev_type = {
147
-	.groups = nsim_dev_attr_groups,
148
-	.release = nsim_dev_release,
149
-};
150
-
151
-static int
152
-nsim_port_attr_get(struct net_device *dev, struct switchdev_attr *attr)
153
-{
154
-	struct netdevsim *ns = netdev_priv(dev);
155
-
156
-	switch (attr->id) {
157
-	case SWITCHDEV_ATTR_ID_PORT_PARENT_ID:
158
-		attr->u.ppid.id_len = sizeof(ns->sdev->switch_id);
159
-		memcpy(&attr->u.ppid.id, &ns->sdev->switch_id,
160
-		       attr->u.ppid.id_len);
161
-		return 0;
162
-	default:
163
-		return -EOPNOTSUPP;
164
-	}
165
-}
166
-
167
-static const struct switchdev_ops nsim_switchdev_ops = {
168
-	.switchdev_port_attr_get	= nsim_port_attr_get,
169
-};
170
-
171
-static int nsim_init(struct net_device *dev)
172
-{
173
-	char sdev_ddir_name[10], sdev_link_name[32];
174
-	struct netdevsim *ns = netdev_priv(dev);
175
-	int err;
176
-
177
-	ns->netdev = dev;
178
-	ns->ddir = debugfs_create_dir(netdev_name(dev), nsim_ddir);
179
-	if (IS_ERR_OR_NULL(ns->ddir))
180
-		return -ENOMEM;
181
-
182
-	if (!ns->sdev) {
183
-		ns->sdev = kzalloc(sizeof(*ns->sdev), GFP_KERNEL);
184
-		if (!ns->sdev) {
185
-			err = -ENOMEM;
186
-			goto err_debugfs_destroy;
187
-		}
188
-		ns->sdev->refcnt = 1;
189
-		ns->sdev->switch_id = nsim_dev_id;
190
-		sprintf(sdev_ddir_name, "%u", ns->sdev->switch_id);
191
-		ns->sdev->ddir = debugfs_create_dir(sdev_ddir_name,
192
-						    nsim_sdev_ddir);
193
-		if (IS_ERR_OR_NULL(ns->sdev->ddir)) {
194
-			err = PTR_ERR_OR_ZERO(ns->sdev->ddir) ?: -EINVAL;
195
-			goto err_sdev_free;
196
-		}
197
-	} else {
198
-		sprintf(sdev_ddir_name, "%u", ns->sdev->switch_id);
199
-		ns->sdev->refcnt++;
200
-	}
201
-
202
-	sprintf(sdev_link_name, "../../" DRV_NAME "_sdev/%s", sdev_ddir_name);
203
-	debugfs_create_symlink("sdev", ns->ddir, sdev_link_name);
204
-
205
-	err = nsim_bpf_init(ns);
206
-	if (err)
207
-		goto err_sdev_destroy;
208
-
209
-	ns->dev.id = nsim_dev_id++;
210
-	ns->dev.bus = &nsim_bus;
211
-	ns->dev.type = &nsim_dev_type;
212
-	err = device_register(&ns->dev);
213
-	if (err)
214
-		goto err_bpf_uninit;
215
-
216
-	SET_NETDEV_DEV(dev, &ns->dev);
217
-	SWITCHDEV_SET_OPS(dev, &nsim_switchdev_ops);
218
-
219
-	err = nsim_devlink_setup(ns);
220
-	if (err)
221
-		goto err_unreg_dev;
222
-
223
-	nsim_ipsec_init(ns);
224
-
225
-	return 0;
226
-
227
-err_unreg_dev:
228
-	device_unregister(&ns->dev);
229
-err_bpf_uninit:
230
-	nsim_bpf_uninit(ns);
231
-err_sdev_destroy:
232
-	if (!--ns->sdev->refcnt) {
233
-		debugfs_remove_recursive(ns->sdev->ddir);
234
-err_sdev_free:
235
-		kfree(ns->sdev);
236
-	}
237
-err_debugfs_destroy:
238
-	debugfs_remove_recursive(ns->ddir);
239
-	return err;
240
-}
241
-
242
-static void nsim_uninit(struct net_device *dev)
243
-{
244
-	struct netdevsim *ns = netdev_priv(dev);
245
-
246
-	nsim_ipsec_teardown(ns);
247
-	nsim_devlink_teardown(ns);
248
-	debugfs_remove_recursive(ns->ddir);
249
-	nsim_bpf_uninit(ns);
250
-	if (!--ns->sdev->refcnt) {
251
-		debugfs_remove_recursive(ns->sdev->ddir);
252
-		kfree(ns->sdev);
253
-	}
254
-}
255
-
256
-static void nsim_free(struct net_device *dev)
257
-{
258
-	struct netdevsim *ns = netdev_priv(dev);
259
-
260
-	device_unregister(&ns->dev);
261
-	/* netdev and vf state will be freed out of device_release() */
262
-}
263
28
 
264
29
 static netdev_tx_t nsim_start_xmit(struct sk_buff *skb, struct net_device *dev)
265
30
 {
..
..
@@ -302,10 +67,10 @@
302
67
 	unsigned int start;
303
68
 
304
69
 	do {
305
-		start = u64_stats_fetch_begin(&ns->syncp);
70
+		start = u64_stats_fetch_begin_irq(&ns->syncp);
306
71
 		stats->tx_bytes = ns->tx_bytes;
307
72
 		stats->tx_packets = ns->tx_packets;
308
-	} while (u64_stats_fetch_retry(&ns->syncp, start));
73
+	} while (u64_stats_fetch_retry_irq(&ns->syncp, start));
309
74
 }
310
75
 
311
76
 static int
..
..
@@ -314,34 +79,15 @@
314
79
 	return nsim_bpf_setup_tc_block_cb(type, type_data, cb_priv);
315
80
 }
316
81
 
317
-static int
318
-nsim_setup_tc_block(struct net_device *dev, struct tc_block_offload *f)
319
-{
320
-	struct netdevsim *ns = netdev_priv(dev);
321
-
322
-	if (f->binder_type != TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
323
-		return -EOPNOTSUPP;
324
-
325
-	switch (f->command) {
326
-	case TC_BLOCK_BIND:
327
-		return tcf_block_cb_register(f->block, nsim_setup_tc_block_cb,
328
-					     ns, ns, f->extack);
329
-	case TC_BLOCK_UNBIND:
330
-		tcf_block_cb_unregister(f->block, nsim_setup_tc_block_cb, ns);
331
-		return 0;
332
-	default:
333
-		return -EOPNOTSUPP;
334
-	}
335
-}
336
-
337
82
 static int nsim_set_vf_mac(struct net_device *dev, int vf, u8 *mac)
338
83
 {
339
84
 	struct netdevsim *ns = netdev_priv(dev);
85
+	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
340
86
 
341
87
 	/* Only refuse multicast addresses, zero address can mean unset/any. */
342
-	if (vf >= ns->num_vfs || is_multicast_ether_addr(mac))
88
+	if (vf >= nsim_bus_dev->num_vfs || is_multicast_ether_addr(mac))
343
89
 		return -EINVAL;
344
-	memcpy(ns->vfconfigs[vf].vf_mac, mac, ETH_ALEN);
90
+	memcpy(nsim_bus_dev->vfconfigs[vf].vf_mac, mac, ETH_ALEN);
345
91
 
346
92
 	return 0;
347
93
 }
..
..
@@ -350,13 +96,14 @@
350
96
 			    u16 vlan, u8 qos, __be16 vlan_proto)
351
97
 {
352
98
 	struct netdevsim *ns = netdev_priv(dev);
99
+	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
353
100
 
354
-	if (vf >= ns->num_vfs || vlan > 4095 || qos > 7)
101
+	if (vf >= nsim_bus_dev->num_vfs || vlan > 4095 || qos > 7)
355
102
 		return -EINVAL;
356
103
 
357
-	ns->vfconfigs[vf].vlan = vlan;
358
-	ns->vfconfigs[vf].qos = qos;
359
-	ns->vfconfigs[vf].vlan_proto = vlan_proto;
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;
360
107
 
361
108
 	return 0;
362
109
 }
..
..
@@ -364,12 +111,13 @@
364
111
 static int nsim_set_vf_rate(struct net_device *dev, int vf, int min, int max)
365
112
 {
366
113
 	struct netdevsim *ns = netdev_priv(dev);
114
+	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
367
115
 
368
-	if (vf >= ns->num_vfs)
116
+	if (vf >= nsim_bus_dev->num_vfs)
369
117
 		return -EINVAL;
370
118
 
371
-	ns->vfconfigs[vf].min_tx_rate = min;
372
-	ns->vfconfigs[vf].max_tx_rate = max;
119
+	nsim_bus_dev->vfconfigs[vf].min_tx_rate = min;
120
+	nsim_bus_dev->vfconfigs[vf].max_tx_rate = max;
373
121
 
374
122
 	return 0;
375
123
 }
..
..
@@ -377,10 +125,11 @@
377
125
 static int nsim_set_vf_spoofchk(struct net_device *dev, int vf, bool val)
378
126
 {
379
127
 	struct netdevsim *ns = netdev_priv(dev);
128
+	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
380
129
 
381
-	if (vf >= ns->num_vfs)
130
+	if (vf >= nsim_bus_dev->num_vfs)
382
131
 		return -EINVAL;
383
-	ns->vfconfigs[vf].spoofchk_enabled = val;
132
+	nsim_bus_dev->vfconfigs[vf].spoofchk_enabled = val;
384
133
 
385
134
 	return 0;
386
135
 }
..
..
@@ -388,10 +137,11 @@
388
137
 static int nsim_set_vf_rss_query_en(struct net_device *dev, int vf, bool val)
389
138
 {
390
139
 	struct netdevsim *ns = netdev_priv(dev);
140
+	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
391
141
 
392
-	if (vf >= ns->num_vfs)
142
+	if (vf >= nsim_bus_dev->num_vfs)
393
143
 		return -EINVAL;
394
-	ns->vfconfigs[vf].rss_query_enabled = val;
144
+	nsim_bus_dev->vfconfigs[vf].rss_query_enabled = val;
395
145
 
396
146
 	return 0;
397
147
 }
..
..
@@ -399,10 +149,11 @@
399
149
 static int nsim_set_vf_trust(struct net_device *dev, int vf, bool val)
400
150
 {
401
151
 	struct netdevsim *ns = netdev_priv(dev);
152
+	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
402
153
 
403
-	if (vf >= ns->num_vfs)
154
+	if (vf >= nsim_bus_dev->num_vfs)
404
155
 		return -EINVAL;
405
-	ns->vfconfigs[vf].trusted = val;
156
+	nsim_bus_dev->vfconfigs[vf].trusted = val;
406
157
 
407
158
 	return 0;
408
159
 }
..
..
@@ -411,21 +162,22 @@
411
162
 nsim_get_vf_config(struct net_device *dev, int vf, struct ifla_vf_info *ivi)
412
163
 {
413
164
 	struct netdevsim *ns = netdev_priv(dev);
165
+	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
414
166
 
415
-	if (vf >= ns->num_vfs)
167
+	if (vf >= nsim_bus_dev->num_vfs)
416
168
 		return -EINVAL;
417
169
 
418
170
 	ivi->vf = vf;
419
-	ivi->linkstate = ns->vfconfigs[vf].link_state;
420
-	ivi->min_tx_rate = ns->vfconfigs[vf].min_tx_rate;
421
-	ivi->max_tx_rate = ns->vfconfigs[vf].max_tx_rate;
422
-	ivi->vlan = ns->vfconfigs[vf].vlan;
423
-	ivi->vlan_proto = ns->vfconfigs[vf].vlan_proto;
424
-	ivi->qos = ns->vfconfigs[vf].qos;
425
-	memcpy(&ivi->mac, ns->vfconfigs[vf].vf_mac, ETH_ALEN);
426
-	ivi->spoofchk = ns->vfconfigs[vf].spoofchk_enabled;
427
-	ivi->trusted = ns->vfconfigs[vf].trusted;
428
-	ivi->rss_query_en = ns->vfconfigs[vf].rss_query_enabled;
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;
429
181
 
430
182
 	return 0;
431
183
 }
..
..
@@ -433,8 +185,9 @@
433
185
 static int nsim_set_vf_link_state(struct net_device *dev, int vf, int state)
434
186
 {
435
187
 	struct netdevsim *ns = netdev_priv(dev);
188
+	struct nsim_bus_dev *nsim_bus_dev = ns->nsim_bus_dev;
436
189
 
437
-	if (vf >= ns->num_vfs)
190
+	if (vf >= nsim_bus_dev->num_vfs)
438
191
 		return -EINVAL;
439
192
 
440
193
 	switch (state) {
..
..
@@ -446,17 +199,24 @@
446
199
 		return -EINVAL;
447
200
 	}
448
201
 
449
-	ns->vfconfigs[vf].link_state = state;
202
+	nsim_bus_dev->vfconfigs[vf].link_state = state;
450
203
 
451
204
 	return 0;
452
205
 }
453
206
 
207
+static LIST_HEAD(nsim_block_cb_list);
208
+
454
209
 static int
455
210
 nsim_setup_tc(struct net_device *dev, enum tc_setup_type type, void *type_data)
456
211
 {
212
+	struct netdevsim *ns = netdev_priv(dev);
213
+
457
214
 	switch (type) {
458
215
 	case TC_SETUP_BLOCK:
459
-		return nsim_setup_tc_block(dev, type_data);
216
+		return flow_block_cb_setup_simple(type_data,
217
+						  &nsim_block_cb_list,
218
+						  nsim_setup_tc_block_cb,
219
+						  ns, ns, true);
460
220
 	default:
461
221
 		return -EOPNOTSUPP;
462
222
 	}
..
..
@@ -473,9 +233,14 @@
473
233
 	return 0;
474
234
 }
475
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
+
476
243
 static const struct net_device_ops nsim_netdev_ops = {
477
-	.ndo_init		= nsim_init,
478
-	.ndo_uninit		= nsim_uninit,
479
244
 	.ndo_start_xmit		= nsim_start_xmit,
480
245
 	.ndo_set_rx_mode	= nsim_set_rx_mode,
481
246
 	.ndo_set_mac_address	= eth_mac_addr,
..
..
@@ -493,15 +258,15 @@
493
258
 	.ndo_setup_tc		= nsim_setup_tc,
494
259
 	.ndo_set_features	= nsim_set_features,
495
260
 	.ndo_bpf		= nsim_bpf,
261
+	.ndo_udp_tunnel_add	= udp_tunnel_nic_add_port,
262
+	.ndo_udp_tunnel_del	= udp_tunnel_nic_del_port,
263
+	.ndo_get_devlink_port	= nsim_get_devlink_port,
496
264
 };
497
265
 
498
266
 static void nsim_setup(struct net_device *dev)
499
267
 {
500
268
 	ether_setup(dev);
501
269
 	eth_hw_addr_random(dev);
502
-
503
-	dev->netdev_ops = &nsim_netdev_ops;
504
-	dev->priv_destructor = nsim_free;
505
270
 
506
271
 	dev->tx_queue_len = 0;
507
272
 	dev->flags |= IFF_NOARP;
..
..
@@ -517,104 +282,112 @@
517
282
 	dev->max_mtu = ETH_MAX_MTU;
518
283
 }
519
284
 
285
+struct netdevsim *
286
+nsim_create(struct nsim_dev *nsim_dev, struct nsim_dev_port *nsim_dev_port)
287
+{
288
+	struct net_device *dev;
289
+	struct netdevsim *ns;
290
+	int err;
291
+
292
+	dev = alloc_netdev(sizeof(*ns), "eth%d", NET_NAME_UNKNOWN, nsim_setup);
293
+	if (!dev)
294
+		return ERR_PTR(-ENOMEM);
295
+
296
+	dev_net_set(dev, nsim_dev_net(nsim_dev));
297
+	ns = netdev_priv(dev);
298
+	ns->netdev = dev;
299
+	u64_stats_init(&ns->syncp);
300
+	ns->nsim_dev = nsim_dev;
301
+	ns->nsim_dev_port = nsim_dev_port;
302
+	ns->nsim_bus_dev = nsim_dev->nsim_bus_dev;
303
+	SET_NETDEV_DEV(dev, &ns->nsim_bus_dev->dev);
304
+	dev->netdev_ops = &nsim_netdev_ops;
305
+	nsim_ethtool_init(ns);
306
+
307
+	err = nsim_udp_tunnels_info_create(nsim_dev, dev);
308
+	if (err)
309
+		goto err_free_netdev;
310
+
311
+	rtnl_lock();
312
+	err = nsim_bpf_init(ns);
313
+	if (err)
314
+		goto err_utn_destroy;
315
+
316
+	nsim_ipsec_init(ns);
317
+
318
+	err = register_netdevice(dev);
319
+	if (err)
320
+		goto err_ipsec_teardown;
321
+	rtnl_unlock();
322
+
323
+	return ns;
324
+
325
+err_ipsec_teardown:
326
+	nsim_ipsec_teardown(ns);
327
+	nsim_bpf_uninit(ns);
328
+err_utn_destroy:
329
+	rtnl_unlock();
330
+	nsim_udp_tunnels_info_destroy(dev);
331
+err_free_netdev:
332
+	free_netdev(dev);
333
+	return ERR_PTR(err);
334
+}
335
+
336
+void nsim_destroy(struct netdevsim *ns)
337
+{
338
+	struct net_device *dev = ns->netdev;
339
+
340
+	rtnl_lock();
341
+	unregister_netdevice(dev);
342
+	nsim_ipsec_teardown(ns);
343
+	nsim_bpf_uninit(ns);
344
+	rtnl_unlock();
345
+	nsim_udp_tunnels_info_destroy(dev);
346
+	free_netdev(dev);
347
+}
348
+
520
349
 static int nsim_validate(struct nlattr *tb[], struct nlattr *data[],
521
350
 			 struct netlink_ext_ack *extack)
522
351
 {
523
-	if (tb[IFLA_ADDRESS]) {
524
-		if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
525
-			return -EINVAL;
526
-		if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
527
-			return -EADDRNOTAVAIL;
528
-	}
529
-	return 0;
530
-}
531
-
532
-static int nsim_newlink(struct net *src_net, struct net_device *dev,
533
-			struct nlattr *tb[], struct nlattr *data[],
534
-			struct netlink_ext_ack *extack)
535
-{
536
-	struct netdevsim *ns = netdev_priv(dev);
537
-
538
-	if (tb[IFLA_LINK]) {
539
-		struct net_device *joindev;
540
-		struct netdevsim *joinns;
541
-
542
-		joindev = __dev_get_by_index(src_net,
543
-					     nla_get_u32(tb[IFLA_LINK]));
544
-		if (!joindev)
545
-			return -ENODEV;
546
-		if (joindev->netdev_ops != &nsim_netdev_ops)
547
-			return -EINVAL;
548
-
549
-		joinns = netdev_priv(joindev);
550
-		if (!joinns->sdev || !joinns->sdev->refcnt)
551
-			return -EINVAL;
552
-		ns->sdev = joinns->sdev;
553
-	}
554
-
555
-	return register_netdevice(dev);
556
-}
557
-
558
-static void nsim_dellink(struct net_device *dev, struct list_head *head)
559
-{
560
-	unregister_netdevice_queue(dev, head);
352
+	NL_SET_ERR_MSG_MOD(extack, "Please use: echo \"[ID] [PORT_COUNT]\" > /sys/bus/netdevsim/new_device");
353
+	return -EOPNOTSUPP;
561
354
 }
562
355
 
563
356
 static struct rtnl_link_ops nsim_link_ops __read_mostly = {
564
357
 	.kind		= DRV_NAME,
565
-	.priv_size	= sizeof(struct netdevsim),
566
-	.setup		= nsim_setup,
567
358
 	.validate	= nsim_validate,
568
-	.newlink	= nsim_newlink,
569
-	.dellink	= nsim_dellink,
570
359
 };
571
360
 
572
361
 static int __init nsim_module_init(void)
573
362
 {
574
363
 	int err;
575
364
 
576
-	nsim_ddir = debugfs_create_dir(DRV_NAME, NULL);
577
-	if (IS_ERR_OR_NULL(nsim_ddir))
578
-		return -ENOMEM;
579
-
580
-	nsim_sdev_ddir = debugfs_create_dir(DRV_NAME "_sdev", NULL);
581
-	if (IS_ERR_OR_NULL(nsim_sdev_ddir)) {
582
-		err = -ENOMEM;
583
-		goto err_debugfs_destroy;
584
-	}
585
-
586
-	err = bus_register(&nsim_bus);
365
+	err = nsim_dev_init();
587
366
 	if (err)
588
-		goto err_sdir_destroy;
367
+		return err;
589
368
 
590
-	err = nsim_devlink_init();
369
+	err = nsim_bus_init();
591
370
 	if (err)
592
-		goto err_unreg_bus;
371
+		goto err_dev_exit;
593
372
 
594
373
 	err = rtnl_link_register(&nsim_link_ops);
595
374
 	if (err)
596
-		goto err_dl_fini;
375
+		goto err_bus_exit;
597
376
 
598
377
 	return 0;
599
378
 
600
-err_dl_fini:
601
-	nsim_devlink_exit();
602
-err_unreg_bus:
603
-	bus_unregister(&nsim_bus);
604
-err_sdir_destroy:
605
-	debugfs_remove_recursive(nsim_sdev_ddir);
606
-err_debugfs_destroy:
607
-	debugfs_remove_recursive(nsim_ddir);
379
+err_bus_exit:
380
+	nsim_bus_exit();
381
+err_dev_exit:
382
+	nsim_dev_exit();
608
383
 	return err;
609
384
 }
610
385
 
611
386
 static void __exit nsim_module_exit(void)
612
387
 {
613
388
 	rtnl_link_unregister(&nsim_link_ops);
614
-	nsim_devlink_exit();
615
-	bus_unregister(&nsim_bus);
616
-	debugfs_remove_recursive(nsim_sdev_ddir);
617
-	debugfs_remove_recursive(nsim_ddir);
389
+	nsim_bus_exit();
390
+	nsim_dev_exit();
618
391
 }
619
392
 
620
393
 module_init(nsim_module_init);