1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* Copyright (c) 2014 Mahesh Bandewar <maheshb@google.com> |
3 | */ |
4 | |
5 | #include <linux/ethtool.h> |
6 | |
7 | #include "ipvlan.h" |
8 | |
9 | static int ipvlan_set_port_mode(struct ipvl_port *port, u16 nval, |
10 | struct netlink_ext_ack *extack) |
11 | { |
12 | struct ipvl_dev *ipvlan; |
13 | unsigned int flags; |
14 | int err; |
15 | |
16 | ASSERT_RTNL(); |
17 | if (port->mode != nval) { |
18 | list_for_each_entry(ipvlan, &port->ipvlans, pnode) { |
19 | flags = ipvlan->dev->flags; |
20 | if (nval == IPVLAN_MODE_L3 || nval == IPVLAN_MODE_L3S) { |
21 | err = dev_change_flags(dev: ipvlan->dev, |
22 | flags: flags | IFF_NOARP, |
23 | extack); |
24 | } else { |
25 | err = dev_change_flags(dev: ipvlan->dev, |
26 | flags: flags & ~IFF_NOARP, |
27 | extack); |
28 | } |
29 | if (unlikely(err)) |
30 | goto fail; |
31 | } |
32 | if (nval == IPVLAN_MODE_L3S) { |
33 | /* New mode is L3S */ |
34 | err = ipvlan_l3s_register(port); |
35 | if (err) |
36 | goto fail; |
37 | } else if (port->mode == IPVLAN_MODE_L3S) { |
38 | /* Old mode was L3S */ |
39 | ipvlan_l3s_unregister(port); |
40 | } |
41 | port->mode = nval; |
42 | } |
43 | return 0; |
44 | |
45 | fail: |
46 | /* Undo the flags changes that have been done so far. */ |
47 | list_for_each_entry_continue_reverse(ipvlan, &port->ipvlans, pnode) { |
48 | flags = ipvlan->dev->flags; |
49 | if (port->mode == IPVLAN_MODE_L3 || |
50 | port->mode == IPVLAN_MODE_L3S) |
51 | dev_change_flags(dev: ipvlan->dev, flags: flags | IFF_NOARP, |
52 | NULL); |
53 | else |
54 | dev_change_flags(dev: ipvlan->dev, flags: flags & ~IFF_NOARP, |
55 | NULL); |
56 | } |
57 | |
58 | return err; |
59 | } |
60 | |
61 | static int ipvlan_port_create(struct net_device *dev) |
62 | { |
63 | struct ipvl_port *port; |
64 | int err, idx; |
65 | |
66 | port = kzalloc(size: sizeof(struct ipvl_port), GFP_KERNEL); |
67 | if (!port) |
68 | return -ENOMEM; |
69 | |
70 | write_pnet(pnet: &port->pnet, net: dev_net(dev)); |
71 | port->dev = dev; |
72 | port->mode = IPVLAN_MODE_L3; |
73 | INIT_LIST_HEAD(list: &port->ipvlans); |
74 | for (idx = 0; idx < IPVLAN_HASH_SIZE; idx++) |
75 | INIT_HLIST_HEAD(&port->hlhead[idx]); |
76 | |
77 | skb_queue_head_init(list: &port->backlog); |
78 | INIT_WORK(&port->wq, ipvlan_process_multicast); |
79 | ida_init(ida: &port->ida); |
80 | port->dev_id_start = 1; |
81 | |
82 | err = netdev_rx_handler_register(dev, rx_handler: ipvlan_handle_frame, rx_handler_data: port); |
83 | if (err) |
84 | goto err; |
85 | |
86 | netdev_hold(dev, tracker: &port->dev_tracker, GFP_KERNEL); |
87 | return 0; |
88 | |
89 | err: |
90 | kfree(objp: port); |
91 | return err; |
92 | } |
93 | |
94 | static void ipvlan_port_destroy(struct net_device *dev) |
95 | { |
96 | struct ipvl_port *port = ipvlan_port_get_rtnl(d: dev); |
97 | struct sk_buff *skb; |
98 | |
99 | netdev_put(dev, tracker: &port->dev_tracker); |
100 | if (port->mode == IPVLAN_MODE_L3S) |
101 | ipvlan_l3s_unregister(port); |
102 | netdev_rx_handler_unregister(dev); |
103 | cancel_work_sync(work: &port->wq); |
104 | while ((skb = __skb_dequeue(list: &port->backlog)) != NULL) { |
105 | dev_put(dev: skb->dev); |
106 | kfree_skb(skb); |
107 | } |
108 | ida_destroy(ida: &port->ida); |
109 | kfree(objp: port); |
110 | } |
111 | |
112 | #define IPVLAN_ALWAYS_ON_OFLOADS \ |
113 | (NETIF_F_SG | NETIF_F_HW_CSUM | \ |
114 | NETIF_F_GSO_ROBUST | NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ENCAP_ALL) |
115 | |
116 | #define IPVLAN_ALWAYS_ON \ |
117 | (IPVLAN_ALWAYS_ON_OFLOADS | NETIF_F_LLTX | NETIF_F_VLAN_CHALLENGED) |
118 | |
119 | #define IPVLAN_FEATURES \ |
120 | (NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \ |
121 | NETIF_F_GSO | NETIF_F_ALL_TSO | NETIF_F_GSO_ROBUST | \ |
122 | NETIF_F_GRO | NETIF_F_RXCSUM | \ |
123 | NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_STAG_FILTER) |
124 | |
125 | /* NETIF_F_GSO_ENCAP_ALL NETIF_F_GSO_SOFTWARE Newly added */ |
126 | |
127 | #define IPVLAN_STATE_MASK \ |
128 | ((1<<__LINK_STATE_NOCARRIER) | (1<<__LINK_STATE_DORMANT)) |
129 | |
130 | static int ipvlan_init(struct net_device *dev) |
131 | { |
132 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
133 | struct net_device *phy_dev = ipvlan->phy_dev; |
134 | struct ipvl_port *port; |
135 | int err; |
136 | |
137 | dev->state = (dev->state & ~IPVLAN_STATE_MASK) | |
138 | (phy_dev->state & IPVLAN_STATE_MASK); |
139 | dev->features = phy_dev->features & IPVLAN_FEATURES; |
140 | dev->features |= IPVLAN_ALWAYS_ON; |
141 | dev->vlan_features = phy_dev->vlan_features & IPVLAN_FEATURES; |
142 | dev->vlan_features |= IPVLAN_ALWAYS_ON_OFLOADS; |
143 | dev->hw_enc_features |= dev->features; |
144 | netif_inherit_tso_max(to: dev, from: phy_dev); |
145 | dev->hard_header_len = phy_dev->hard_header_len; |
146 | |
147 | netdev_lockdep_set_classes(dev); |
148 | |
149 | ipvlan->pcpu_stats = netdev_alloc_pcpu_stats(struct ipvl_pcpu_stats); |
150 | if (!ipvlan->pcpu_stats) |
151 | return -ENOMEM; |
152 | |
153 | if (!netif_is_ipvlan_port(dev: phy_dev)) { |
154 | err = ipvlan_port_create(dev: phy_dev); |
155 | if (err < 0) { |
156 | free_percpu(pdata: ipvlan->pcpu_stats); |
157 | return err; |
158 | } |
159 | } |
160 | port = ipvlan_port_get_rtnl(d: phy_dev); |
161 | port->count += 1; |
162 | return 0; |
163 | } |
164 | |
165 | static void ipvlan_uninit(struct net_device *dev) |
166 | { |
167 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
168 | struct net_device *phy_dev = ipvlan->phy_dev; |
169 | struct ipvl_port *port; |
170 | |
171 | free_percpu(pdata: ipvlan->pcpu_stats); |
172 | |
173 | port = ipvlan_port_get_rtnl(d: phy_dev); |
174 | port->count -= 1; |
175 | if (!port->count) |
176 | ipvlan_port_destroy(dev: port->dev); |
177 | } |
178 | |
179 | static int ipvlan_open(struct net_device *dev) |
180 | { |
181 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
182 | struct ipvl_addr *addr; |
183 | |
184 | if (ipvlan->port->mode == IPVLAN_MODE_L3 || |
185 | ipvlan->port->mode == IPVLAN_MODE_L3S) |
186 | dev->flags |= IFF_NOARP; |
187 | else |
188 | dev->flags &= ~IFF_NOARP; |
189 | |
190 | rcu_read_lock(); |
191 | list_for_each_entry_rcu(addr, &ipvlan->addrs, anode) |
192 | ipvlan_ht_addr_add(ipvlan, addr); |
193 | rcu_read_unlock(); |
194 | |
195 | return 0; |
196 | } |
197 | |
198 | static int ipvlan_stop(struct net_device *dev) |
199 | { |
200 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
201 | struct net_device *phy_dev = ipvlan->phy_dev; |
202 | struct ipvl_addr *addr; |
203 | |
204 | dev_uc_unsync(to: phy_dev, from: dev); |
205 | dev_mc_unsync(to: phy_dev, from: dev); |
206 | |
207 | rcu_read_lock(); |
208 | list_for_each_entry_rcu(addr, &ipvlan->addrs, anode) |
209 | ipvlan_ht_addr_del(addr); |
210 | rcu_read_unlock(); |
211 | |
212 | return 0; |
213 | } |
214 | |
215 | static netdev_tx_t ipvlan_start_xmit(struct sk_buff *skb, |
216 | struct net_device *dev) |
217 | { |
218 | const struct ipvl_dev *ipvlan = netdev_priv(dev); |
219 | int skblen = skb->len; |
220 | int ret; |
221 | |
222 | ret = ipvlan_queue_xmit(skb, dev); |
223 | if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) { |
224 | struct ipvl_pcpu_stats *pcptr; |
225 | |
226 | pcptr = this_cpu_ptr(ipvlan->pcpu_stats); |
227 | |
228 | u64_stats_update_begin(syncp: &pcptr->syncp); |
229 | u64_stats_inc(p: &pcptr->tx_pkts); |
230 | u64_stats_add(p: &pcptr->tx_bytes, val: skblen); |
231 | u64_stats_update_end(syncp: &pcptr->syncp); |
232 | } else { |
233 | this_cpu_inc(ipvlan->pcpu_stats->tx_drps); |
234 | } |
235 | return ret; |
236 | } |
237 | |
238 | static netdev_features_t ipvlan_fix_features(struct net_device *dev, |
239 | netdev_features_t features) |
240 | { |
241 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
242 | |
243 | features |= NETIF_F_ALL_FOR_ALL; |
244 | features &= (ipvlan->sfeatures | ~IPVLAN_FEATURES); |
245 | features = netdev_increment_features(all: ipvlan->phy_dev->features, |
246 | one: features, mask: features); |
247 | features |= IPVLAN_ALWAYS_ON; |
248 | features &= (IPVLAN_FEATURES | IPVLAN_ALWAYS_ON); |
249 | |
250 | return features; |
251 | } |
252 | |
253 | static void ipvlan_change_rx_flags(struct net_device *dev, int change) |
254 | { |
255 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
256 | struct net_device *phy_dev = ipvlan->phy_dev; |
257 | |
258 | if (change & IFF_ALLMULTI) |
259 | dev_set_allmulti(dev: phy_dev, inc: dev->flags & IFF_ALLMULTI? 1 : -1); |
260 | } |
261 | |
262 | static void ipvlan_set_multicast_mac_filter(struct net_device *dev) |
263 | { |
264 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
265 | |
266 | if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) { |
267 | bitmap_fill(dst: ipvlan->mac_filters, IPVLAN_MAC_FILTER_SIZE); |
268 | } else { |
269 | struct netdev_hw_addr *ha; |
270 | DECLARE_BITMAP(mc_filters, IPVLAN_MAC_FILTER_SIZE); |
271 | |
272 | bitmap_zero(dst: mc_filters, IPVLAN_MAC_FILTER_SIZE); |
273 | netdev_for_each_mc_addr(ha, dev) |
274 | __set_bit(ipvlan_mac_hash(ha->addr), mc_filters); |
275 | |
276 | /* Turn-on broadcast bit irrespective of address family, |
277 | * since broadcast is deferred to a work-queue, hence no |
278 | * impact on fast-path processing. |
279 | */ |
280 | __set_bit(ipvlan_mac_hash(dev->broadcast), mc_filters); |
281 | |
282 | bitmap_copy(dst: ipvlan->mac_filters, src: mc_filters, |
283 | IPVLAN_MAC_FILTER_SIZE); |
284 | } |
285 | dev_uc_sync(to: ipvlan->phy_dev, from: dev); |
286 | dev_mc_sync(to: ipvlan->phy_dev, from: dev); |
287 | } |
288 | |
289 | static void ipvlan_get_stats64(struct net_device *dev, |
290 | struct rtnl_link_stats64 *s) |
291 | { |
292 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
293 | |
294 | if (ipvlan->pcpu_stats) { |
295 | struct ipvl_pcpu_stats *pcptr; |
296 | u64 rx_pkts, rx_bytes, rx_mcast, tx_pkts, tx_bytes; |
297 | u32 rx_errs = 0, tx_drps = 0; |
298 | u32 strt; |
299 | int idx; |
300 | |
301 | for_each_possible_cpu(idx) { |
302 | pcptr = per_cpu_ptr(ipvlan->pcpu_stats, idx); |
303 | do { |
304 | strt = u64_stats_fetch_begin(syncp: &pcptr->syncp); |
305 | rx_pkts = u64_stats_read(p: &pcptr->rx_pkts); |
306 | rx_bytes = u64_stats_read(p: &pcptr->rx_bytes); |
307 | rx_mcast = u64_stats_read(p: &pcptr->rx_mcast); |
308 | tx_pkts = u64_stats_read(p: &pcptr->tx_pkts); |
309 | tx_bytes = u64_stats_read(p: &pcptr->tx_bytes); |
310 | } while (u64_stats_fetch_retry(syncp: &pcptr->syncp, |
311 | start: strt)); |
312 | |
313 | s->rx_packets += rx_pkts; |
314 | s->rx_bytes += rx_bytes; |
315 | s->multicast += rx_mcast; |
316 | s->tx_packets += tx_pkts; |
317 | s->tx_bytes += tx_bytes; |
318 | |
319 | /* u32 values are updated without syncp protection. */ |
320 | rx_errs += READ_ONCE(pcptr->rx_errs); |
321 | tx_drps += READ_ONCE(pcptr->tx_drps); |
322 | } |
323 | s->rx_errors = rx_errs; |
324 | s->rx_dropped = rx_errs; |
325 | s->tx_dropped = tx_drps; |
326 | } |
327 | s->tx_errors = DEV_STATS_READ(dev, tx_errors); |
328 | } |
329 | |
330 | static int ipvlan_vlan_rx_add_vid(struct net_device *dev, __be16 proto, u16 vid) |
331 | { |
332 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
333 | struct net_device *phy_dev = ipvlan->phy_dev; |
334 | |
335 | return vlan_vid_add(dev: phy_dev, proto, vid); |
336 | } |
337 | |
338 | static int ipvlan_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, |
339 | u16 vid) |
340 | { |
341 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
342 | struct net_device *phy_dev = ipvlan->phy_dev; |
343 | |
344 | vlan_vid_del(dev: phy_dev, proto, vid); |
345 | return 0; |
346 | } |
347 | |
348 | static int ipvlan_get_iflink(const struct net_device *dev) |
349 | { |
350 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
351 | |
352 | return ipvlan->phy_dev->ifindex; |
353 | } |
354 | |
355 | static const struct net_device_ops ipvlan_netdev_ops = { |
356 | .ndo_init = ipvlan_init, |
357 | .ndo_uninit = ipvlan_uninit, |
358 | .ndo_open = ipvlan_open, |
359 | .ndo_stop = ipvlan_stop, |
360 | .ndo_start_xmit = ipvlan_start_xmit, |
361 | .ndo_fix_features = ipvlan_fix_features, |
362 | .ndo_change_rx_flags = ipvlan_change_rx_flags, |
363 | .ndo_set_rx_mode = ipvlan_set_multicast_mac_filter, |
364 | .ndo_get_stats64 = ipvlan_get_stats64, |
365 | .ndo_vlan_rx_add_vid = ipvlan_vlan_rx_add_vid, |
366 | .ndo_vlan_rx_kill_vid = ipvlan_vlan_rx_kill_vid, |
367 | .ndo_get_iflink = ipvlan_get_iflink, |
368 | }; |
369 | |
370 | static int (struct sk_buff *skb, struct net_device *dev, |
371 | unsigned short type, const void *daddr, |
372 | const void *saddr, unsigned len) |
373 | { |
374 | const struct ipvl_dev *ipvlan = netdev_priv(dev); |
375 | struct net_device *phy_dev = ipvlan->phy_dev; |
376 | |
377 | /* TODO Probably use a different field than dev_addr so that the |
378 | * mac-address on the virtual device is portable and can be carried |
379 | * while the packets use the mac-addr on the physical device. |
380 | */ |
381 | return dev_hard_header(skb, dev: phy_dev, type, daddr, |
382 | saddr: saddr ? : phy_dev->dev_addr, len); |
383 | } |
384 | |
385 | static const struct header_ops = { |
386 | .create = ipvlan_hard_header, |
387 | .parse = eth_header_parse, |
388 | .cache = eth_header_cache, |
389 | .cache_update = eth_header_cache_update, |
390 | }; |
391 | |
392 | static void ipvlan_adjust_mtu(struct ipvl_dev *ipvlan, struct net_device *dev) |
393 | { |
394 | ipvlan->dev->mtu = dev->mtu; |
395 | } |
396 | |
397 | static bool netif_is_ipvlan(const struct net_device *dev) |
398 | { |
399 | /* both ipvlan and ipvtap devices use the same netdev_ops */ |
400 | return dev->netdev_ops == &ipvlan_netdev_ops; |
401 | } |
402 | |
403 | static int ipvlan_ethtool_get_link_ksettings(struct net_device *dev, |
404 | struct ethtool_link_ksettings *cmd) |
405 | { |
406 | const struct ipvl_dev *ipvlan = netdev_priv(dev); |
407 | |
408 | return __ethtool_get_link_ksettings(dev: ipvlan->phy_dev, link_ksettings: cmd); |
409 | } |
410 | |
411 | static void ipvlan_ethtool_get_drvinfo(struct net_device *dev, |
412 | struct ethtool_drvinfo *drvinfo) |
413 | { |
414 | strscpy(p: drvinfo->driver, IPVLAN_DRV, size: sizeof(drvinfo->driver)); |
415 | strscpy(p: drvinfo->version, IPV_DRV_VER, size: sizeof(drvinfo->version)); |
416 | } |
417 | |
418 | static u32 ipvlan_ethtool_get_msglevel(struct net_device *dev) |
419 | { |
420 | const struct ipvl_dev *ipvlan = netdev_priv(dev); |
421 | |
422 | return ipvlan->msg_enable; |
423 | } |
424 | |
425 | static void ipvlan_ethtool_set_msglevel(struct net_device *dev, u32 value) |
426 | { |
427 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
428 | |
429 | ipvlan->msg_enable = value; |
430 | } |
431 | |
432 | static const struct ethtool_ops ipvlan_ethtool_ops = { |
433 | .get_link = ethtool_op_get_link, |
434 | .get_link_ksettings = ipvlan_ethtool_get_link_ksettings, |
435 | .get_drvinfo = ipvlan_ethtool_get_drvinfo, |
436 | .get_msglevel = ipvlan_ethtool_get_msglevel, |
437 | .set_msglevel = ipvlan_ethtool_set_msglevel, |
438 | }; |
439 | |
440 | static int ipvlan_nl_changelink(struct net_device *dev, |
441 | struct nlattr *tb[], struct nlattr *data[], |
442 | struct netlink_ext_ack *extack) |
443 | { |
444 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
445 | struct ipvl_port *port = ipvlan_port_get_rtnl(d: ipvlan->phy_dev); |
446 | int err = 0; |
447 | |
448 | if (!data) |
449 | return 0; |
450 | if (!ns_capable(ns: dev_net(dev: ipvlan->phy_dev)->user_ns, CAP_NET_ADMIN)) |
451 | return -EPERM; |
452 | |
453 | if (data[IFLA_IPVLAN_MODE]) { |
454 | u16 nmode = nla_get_u16(nla: data[IFLA_IPVLAN_MODE]); |
455 | |
456 | err = ipvlan_set_port_mode(port, nval: nmode, extack); |
457 | } |
458 | |
459 | if (!err && data[IFLA_IPVLAN_FLAGS]) { |
460 | u16 flags = nla_get_u16(nla: data[IFLA_IPVLAN_FLAGS]); |
461 | |
462 | if (flags & IPVLAN_F_PRIVATE) |
463 | ipvlan_mark_private(port); |
464 | else |
465 | ipvlan_clear_private(port); |
466 | |
467 | if (flags & IPVLAN_F_VEPA) |
468 | ipvlan_mark_vepa(port); |
469 | else |
470 | ipvlan_clear_vepa(port); |
471 | } |
472 | |
473 | return err; |
474 | } |
475 | |
476 | static size_t ipvlan_nl_getsize(const struct net_device *dev) |
477 | { |
478 | return (0 |
479 | + nla_total_size(payload: 2) /* IFLA_IPVLAN_MODE */ |
480 | + nla_total_size(payload: 2) /* IFLA_IPVLAN_FLAGS */ |
481 | ); |
482 | } |
483 | |
484 | static int ipvlan_nl_validate(struct nlattr *tb[], struct nlattr *data[], |
485 | struct netlink_ext_ack *extack) |
486 | { |
487 | if (!data) |
488 | return 0; |
489 | |
490 | if (data[IFLA_IPVLAN_MODE]) { |
491 | u16 mode = nla_get_u16(nla: data[IFLA_IPVLAN_MODE]); |
492 | |
493 | if (mode >= IPVLAN_MODE_MAX) |
494 | return -EINVAL; |
495 | } |
496 | if (data[IFLA_IPVLAN_FLAGS]) { |
497 | u16 flags = nla_get_u16(nla: data[IFLA_IPVLAN_FLAGS]); |
498 | |
499 | /* Only two bits are used at this moment. */ |
500 | if (flags & ~(IPVLAN_F_PRIVATE | IPVLAN_F_VEPA)) |
501 | return -EINVAL; |
502 | /* Also both flags can't be active at the same time. */ |
503 | if ((flags & (IPVLAN_F_PRIVATE | IPVLAN_F_VEPA)) == |
504 | (IPVLAN_F_PRIVATE | IPVLAN_F_VEPA)) |
505 | return -EINVAL; |
506 | } |
507 | |
508 | return 0; |
509 | } |
510 | |
511 | static int ipvlan_nl_fillinfo(struct sk_buff *skb, |
512 | const struct net_device *dev) |
513 | { |
514 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
515 | struct ipvl_port *port = ipvlan_port_get_rtnl(d: ipvlan->phy_dev); |
516 | int ret = -EINVAL; |
517 | |
518 | if (!port) |
519 | goto err; |
520 | |
521 | ret = -EMSGSIZE; |
522 | if (nla_put_u16(skb, attrtype: IFLA_IPVLAN_MODE, value: port->mode)) |
523 | goto err; |
524 | if (nla_put_u16(skb, attrtype: IFLA_IPVLAN_FLAGS, value: port->flags)) |
525 | goto err; |
526 | |
527 | return 0; |
528 | |
529 | err: |
530 | return ret; |
531 | } |
532 | |
533 | int ipvlan_link_new(struct net *src_net, struct net_device *dev, |
534 | struct nlattr *tb[], struct nlattr *data[], |
535 | struct netlink_ext_ack *extack) |
536 | { |
537 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
538 | struct ipvl_port *port; |
539 | struct net_device *phy_dev; |
540 | int err; |
541 | u16 mode = IPVLAN_MODE_L3; |
542 | |
543 | if (!tb[IFLA_LINK]) |
544 | return -EINVAL; |
545 | |
546 | phy_dev = __dev_get_by_index(net: src_net, ifindex: nla_get_u32(nla: tb[IFLA_LINK])); |
547 | if (!phy_dev) |
548 | return -ENODEV; |
549 | |
550 | if (netif_is_ipvlan(dev: phy_dev)) { |
551 | struct ipvl_dev *tmp = netdev_priv(dev: phy_dev); |
552 | |
553 | phy_dev = tmp->phy_dev; |
554 | if (!ns_capable(ns: dev_net(dev: phy_dev)->user_ns, CAP_NET_ADMIN)) |
555 | return -EPERM; |
556 | } else if (!netif_is_ipvlan_port(dev: phy_dev)) { |
557 | /* Exit early if the underlying link is invalid or busy */ |
558 | if (phy_dev->type != ARPHRD_ETHER || |
559 | phy_dev->flags & IFF_LOOPBACK) { |
560 | netdev_err(dev: phy_dev, |
561 | format: "Master is either lo or non-ether device\n" ); |
562 | return -EINVAL; |
563 | } |
564 | |
565 | if (netdev_is_rx_handler_busy(dev: phy_dev)) { |
566 | netdev_err(dev: phy_dev, format: "Device is already in use.\n" ); |
567 | return -EBUSY; |
568 | } |
569 | } |
570 | |
571 | ipvlan->phy_dev = phy_dev; |
572 | ipvlan->dev = dev; |
573 | ipvlan->sfeatures = IPVLAN_FEATURES; |
574 | if (!tb[IFLA_MTU]) |
575 | ipvlan_adjust_mtu(ipvlan, dev: phy_dev); |
576 | INIT_LIST_HEAD(list: &ipvlan->addrs); |
577 | spin_lock_init(&ipvlan->addrs_lock); |
578 | |
579 | /* TODO Probably put random address here to be presented to the |
580 | * world but keep using the physical-dev address for the outgoing |
581 | * packets. |
582 | */ |
583 | eth_hw_addr_set(dev, addr: phy_dev->dev_addr); |
584 | |
585 | dev->priv_flags |= IFF_NO_RX_HANDLER; |
586 | |
587 | err = register_netdevice(dev); |
588 | if (err < 0) |
589 | return err; |
590 | |
591 | /* ipvlan_init() would have created the port, if required */ |
592 | port = ipvlan_port_get_rtnl(d: phy_dev); |
593 | ipvlan->port = port; |
594 | |
595 | /* If the port-id base is at the MAX value, then wrap it around and |
596 | * begin from 0x1 again. This may be due to a busy system where lots |
597 | * of slaves are getting created and deleted. |
598 | */ |
599 | if (port->dev_id_start == 0xFFFE) |
600 | port->dev_id_start = 0x1; |
601 | |
602 | /* Since L2 address is shared among all IPvlan slaves including |
603 | * master, use unique 16 bit dev-ids to diffentiate among them. |
604 | * Assign IDs between 0x1 and 0xFFFE (used by the master) to each |
605 | * slave link [see addrconf_ifid_eui48()]. |
606 | */ |
607 | err = ida_simple_get(&port->ida, port->dev_id_start, 0xFFFE, |
608 | GFP_KERNEL); |
609 | if (err < 0) |
610 | err = ida_simple_get(&port->ida, 0x1, port->dev_id_start, |
611 | GFP_KERNEL); |
612 | if (err < 0) |
613 | goto unregister_netdev; |
614 | dev->dev_id = err; |
615 | |
616 | /* Increment id-base to the next slot for the future assignment */ |
617 | port->dev_id_start = err + 1; |
618 | |
619 | err = netdev_upper_dev_link(dev: phy_dev, upper_dev: dev, extack); |
620 | if (err) |
621 | goto remove_ida; |
622 | |
623 | /* Flags are per port and latest update overrides. User has |
624 | * to be consistent in setting it just like the mode attribute. |
625 | */ |
626 | if (data && data[IFLA_IPVLAN_FLAGS]) |
627 | port->flags = nla_get_u16(nla: data[IFLA_IPVLAN_FLAGS]); |
628 | |
629 | if (data && data[IFLA_IPVLAN_MODE]) |
630 | mode = nla_get_u16(nla: data[IFLA_IPVLAN_MODE]); |
631 | |
632 | err = ipvlan_set_port_mode(port, nval: mode, extack); |
633 | if (err) |
634 | goto unlink_netdev; |
635 | |
636 | list_add_tail_rcu(new: &ipvlan->pnode, head: &port->ipvlans); |
637 | netif_stacked_transfer_operstate(rootdev: phy_dev, dev); |
638 | return 0; |
639 | |
640 | unlink_netdev: |
641 | netdev_upper_dev_unlink(dev: phy_dev, upper_dev: dev); |
642 | remove_ida: |
643 | ida_simple_remove(&port->ida, dev->dev_id); |
644 | unregister_netdev: |
645 | unregister_netdevice(dev); |
646 | return err; |
647 | } |
648 | EXPORT_SYMBOL_GPL(ipvlan_link_new); |
649 | |
650 | void ipvlan_link_delete(struct net_device *dev, struct list_head *head) |
651 | { |
652 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
653 | struct ipvl_addr *addr, *next; |
654 | |
655 | spin_lock_bh(lock: &ipvlan->addrs_lock); |
656 | list_for_each_entry_safe(addr, next, &ipvlan->addrs, anode) { |
657 | ipvlan_ht_addr_del(addr); |
658 | list_del_rcu(entry: &addr->anode); |
659 | kfree_rcu(addr, rcu); |
660 | } |
661 | spin_unlock_bh(lock: &ipvlan->addrs_lock); |
662 | |
663 | ida_simple_remove(&ipvlan->port->ida, dev->dev_id); |
664 | list_del_rcu(entry: &ipvlan->pnode); |
665 | unregister_netdevice_queue(dev, head); |
666 | netdev_upper_dev_unlink(dev: ipvlan->phy_dev, upper_dev: dev); |
667 | } |
668 | EXPORT_SYMBOL_GPL(ipvlan_link_delete); |
669 | |
670 | void ipvlan_link_setup(struct net_device *dev) |
671 | { |
672 | ether_setup(dev); |
673 | |
674 | dev->max_mtu = ETH_MAX_MTU; |
675 | dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING); |
676 | dev->priv_flags |= IFF_UNICAST_FLT | IFF_NO_QUEUE; |
677 | dev->netdev_ops = &ipvlan_netdev_ops; |
678 | dev->needs_free_netdev = true; |
679 | dev->header_ops = &ipvlan_header_ops; |
680 | dev->ethtool_ops = &ipvlan_ethtool_ops; |
681 | } |
682 | EXPORT_SYMBOL_GPL(ipvlan_link_setup); |
683 | |
684 | static const struct nla_policy ipvlan_nl_policy[IFLA_IPVLAN_MAX + 1] = |
685 | { |
686 | [IFLA_IPVLAN_MODE] = { .type = NLA_U16 }, |
687 | [IFLA_IPVLAN_FLAGS] = { .type = NLA_U16 }, |
688 | }; |
689 | |
690 | static struct net *ipvlan_get_link_net(const struct net_device *dev) |
691 | { |
692 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
693 | |
694 | return dev_net(dev: ipvlan->phy_dev); |
695 | } |
696 | |
697 | static struct rtnl_link_ops ipvlan_link_ops = { |
698 | .kind = "ipvlan" , |
699 | .priv_size = sizeof(struct ipvl_dev), |
700 | |
701 | .setup = ipvlan_link_setup, |
702 | .newlink = ipvlan_link_new, |
703 | .dellink = ipvlan_link_delete, |
704 | .get_link_net = ipvlan_get_link_net, |
705 | }; |
706 | |
707 | int ipvlan_link_register(struct rtnl_link_ops *ops) |
708 | { |
709 | ops->get_size = ipvlan_nl_getsize; |
710 | ops->policy = ipvlan_nl_policy; |
711 | ops->validate = ipvlan_nl_validate; |
712 | ops->fill_info = ipvlan_nl_fillinfo; |
713 | ops->changelink = ipvlan_nl_changelink; |
714 | ops->maxtype = IFLA_IPVLAN_MAX; |
715 | return rtnl_link_register(ops); |
716 | } |
717 | EXPORT_SYMBOL_GPL(ipvlan_link_register); |
718 | |
719 | static int ipvlan_device_event(struct notifier_block *unused, |
720 | unsigned long event, void *ptr) |
721 | { |
722 | struct netlink_ext_ack *extack = netdev_notifier_info_to_extack(info: ptr); |
723 | struct netdev_notifier_pre_changeaddr_info *prechaddr_info; |
724 | struct net_device *dev = netdev_notifier_info_to_dev(info: ptr); |
725 | struct ipvl_dev *ipvlan, *next; |
726 | struct ipvl_port *port; |
727 | LIST_HEAD(lst_kill); |
728 | int err; |
729 | |
730 | if (!netif_is_ipvlan_port(dev)) |
731 | return NOTIFY_DONE; |
732 | |
733 | port = ipvlan_port_get_rtnl(d: dev); |
734 | |
735 | switch (event) { |
736 | case NETDEV_UP: |
737 | case NETDEV_CHANGE: |
738 | list_for_each_entry(ipvlan, &port->ipvlans, pnode) |
739 | netif_stacked_transfer_operstate(rootdev: ipvlan->phy_dev, |
740 | dev: ipvlan->dev); |
741 | break; |
742 | |
743 | case NETDEV_REGISTER: { |
744 | struct net *oldnet, *newnet = dev_net(dev); |
745 | |
746 | oldnet = read_pnet(pnet: &port->pnet); |
747 | if (net_eq(net1: newnet, net2: oldnet)) |
748 | break; |
749 | |
750 | write_pnet(pnet: &port->pnet, net: newnet); |
751 | |
752 | if (port->mode == IPVLAN_MODE_L3S) |
753 | ipvlan_migrate_l3s_hook(oldnet, newnet); |
754 | break; |
755 | } |
756 | case NETDEV_UNREGISTER: |
757 | if (dev->reg_state != NETREG_UNREGISTERING) |
758 | break; |
759 | |
760 | list_for_each_entry_safe(ipvlan, next, &port->ipvlans, pnode) |
761 | ipvlan->dev->rtnl_link_ops->dellink(ipvlan->dev, |
762 | &lst_kill); |
763 | unregister_netdevice_many(head: &lst_kill); |
764 | break; |
765 | |
766 | case NETDEV_FEAT_CHANGE: |
767 | list_for_each_entry(ipvlan, &port->ipvlans, pnode) { |
768 | netif_inherit_tso_max(to: ipvlan->dev, from: dev); |
769 | netdev_update_features(dev: ipvlan->dev); |
770 | } |
771 | break; |
772 | |
773 | case NETDEV_CHANGEMTU: |
774 | list_for_each_entry(ipvlan, &port->ipvlans, pnode) |
775 | ipvlan_adjust_mtu(ipvlan, dev); |
776 | break; |
777 | |
778 | case NETDEV_PRE_CHANGEADDR: |
779 | prechaddr_info = ptr; |
780 | list_for_each_entry(ipvlan, &port->ipvlans, pnode) { |
781 | err = dev_pre_changeaddr_notify(dev: ipvlan->dev, |
782 | addr: prechaddr_info->dev_addr, |
783 | extack); |
784 | if (err) |
785 | return notifier_from_errno(err); |
786 | } |
787 | break; |
788 | |
789 | case NETDEV_CHANGEADDR: |
790 | list_for_each_entry(ipvlan, &port->ipvlans, pnode) { |
791 | eth_hw_addr_set(dev: ipvlan->dev, addr: dev->dev_addr); |
792 | call_netdevice_notifiers(val: NETDEV_CHANGEADDR, dev: ipvlan->dev); |
793 | } |
794 | break; |
795 | |
796 | case NETDEV_PRE_TYPE_CHANGE: |
797 | /* Forbid underlying device to change its type. */ |
798 | return NOTIFY_BAD; |
799 | } |
800 | return NOTIFY_DONE; |
801 | } |
802 | |
803 | /* the caller must held the addrs lock */ |
804 | static int ipvlan_add_addr(struct ipvl_dev *ipvlan, void *iaddr, bool is_v6) |
805 | { |
806 | struct ipvl_addr *addr; |
807 | |
808 | addr = kzalloc(size: sizeof(struct ipvl_addr), GFP_ATOMIC); |
809 | if (!addr) |
810 | return -ENOMEM; |
811 | |
812 | addr->master = ipvlan; |
813 | if (!is_v6) { |
814 | memcpy(&addr->ip4addr, iaddr, sizeof(struct in_addr)); |
815 | addr->atype = IPVL_IPV4; |
816 | #if IS_ENABLED(CONFIG_IPV6) |
817 | } else { |
818 | memcpy(&addr->ip6addr, iaddr, sizeof(struct in6_addr)); |
819 | addr->atype = IPVL_IPV6; |
820 | #endif |
821 | } |
822 | |
823 | list_add_tail_rcu(new: &addr->anode, head: &ipvlan->addrs); |
824 | |
825 | /* If the interface is not up, the address will be added to the hash |
826 | * list by ipvlan_open. |
827 | */ |
828 | if (netif_running(dev: ipvlan->dev)) |
829 | ipvlan_ht_addr_add(ipvlan, addr); |
830 | |
831 | return 0; |
832 | } |
833 | |
834 | static void ipvlan_del_addr(struct ipvl_dev *ipvlan, void *iaddr, bool is_v6) |
835 | { |
836 | struct ipvl_addr *addr; |
837 | |
838 | spin_lock_bh(lock: &ipvlan->addrs_lock); |
839 | addr = ipvlan_find_addr(ipvlan, iaddr, is_v6); |
840 | if (!addr) { |
841 | spin_unlock_bh(lock: &ipvlan->addrs_lock); |
842 | return; |
843 | } |
844 | |
845 | ipvlan_ht_addr_del(addr); |
846 | list_del_rcu(entry: &addr->anode); |
847 | spin_unlock_bh(lock: &ipvlan->addrs_lock); |
848 | kfree_rcu(addr, rcu); |
849 | } |
850 | |
851 | static bool ipvlan_is_valid_dev(const struct net_device *dev) |
852 | { |
853 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
854 | |
855 | if (!netif_is_ipvlan(dev)) |
856 | return false; |
857 | |
858 | if (!ipvlan || !ipvlan->port) |
859 | return false; |
860 | |
861 | return true; |
862 | } |
863 | |
864 | #if IS_ENABLED(CONFIG_IPV6) |
865 | static int ipvlan_add_addr6(struct ipvl_dev *ipvlan, struct in6_addr *ip6_addr) |
866 | { |
867 | int ret = -EINVAL; |
868 | |
869 | spin_lock_bh(lock: &ipvlan->addrs_lock); |
870 | if (ipvlan_addr_busy(port: ipvlan->port, iaddr: ip6_addr, is_v6: true)) |
871 | netif_err(ipvlan, ifup, ipvlan->dev, |
872 | "Failed to add IPv6=%pI6c addr for %s intf\n" , |
873 | ip6_addr, ipvlan->dev->name); |
874 | else |
875 | ret = ipvlan_add_addr(ipvlan, iaddr: ip6_addr, is_v6: true); |
876 | spin_unlock_bh(lock: &ipvlan->addrs_lock); |
877 | return ret; |
878 | } |
879 | |
880 | static void ipvlan_del_addr6(struct ipvl_dev *ipvlan, struct in6_addr *ip6_addr) |
881 | { |
882 | return ipvlan_del_addr(ipvlan, iaddr: ip6_addr, is_v6: true); |
883 | } |
884 | |
885 | static int ipvlan_addr6_event(struct notifier_block *unused, |
886 | unsigned long event, void *ptr) |
887 | { |
888 | struct inet6_ifaddr *if6 = (struct inet6_ifaddr *)ptr; |
889 | struct net_device *dev = (struct net_device *)if6->idev->dev; |
890 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
891 | |
892 | if (!ipvlan_is_valid_dev(dev)) |
893 | return NOTIFY_DONE; |
894 | |
895 | switch (event) { |
896 | case NETDEV_UP: |
897 | if (ipvlan_add_addr6(ipvlan, ip6_addr: &if6->addr)) |
898 | return NOTIFY_BAD; |
899 | break; |
900 | |
901 | case NETDEV_DOWN: |
902 | ipvlan_del_addr6(ipvlan, ip6_addr: &if6->addr); |
903 | break; |
904 | } |
905 | |
906 | return NOTIFY_OK; |
907 | } |
908 | |
909 | static int ipvlan_addr6_validator_event(struct notifier_block *unused, |
910 | unsigned long event, void *ptr) |
911 | { |
912 | struct in6_validator_info *i6vi = (struct in6_validator_info *)ptr; |
913 | struct net_device *dev = (struct net_device *)i6vi->i6vi_dev->dev; |
914 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
915 | |
916 | if (!ipvlan_is_valid_dev(dev)) |
917 | return NOTIFY_DONE; |
918 | |
919 | switch (event) { |
920 | case NETDEV_UP: |
921 | if (ipvlan_addr_busy(port: ipvlan->port, iaddr: &i6vi->i6vi_addr, is_v6: true)) { |
922 | NL_SET_ERR_MSG(i6vi->extack, |
923 | "Address already assigned to an ipvlan device" ); |
924 | return notifier_from_errno(err: -EADDRINUSE); |
925 | } |
926 | break; |
927 | } |
928 | |
929 | return NOTIFY_OK; |
930 | } |
931 | #endif |
932 | |
933 | static int ipvlan_add_addr4(struct ipvl_dev *ipvlan, struct in_addr *ip4_addr) |
934 | { |
935 | int ret = -EINVAL; |
936 | |
937 | spin_lock_bh(lock: &ipvlan->addrs_lock); |
938 | if (ipvlan_addr_busy(port: ipvlan->port, iaddr: ip4_addr, is_v6: false)) |
939 | netif_err(ipvlan, ifup, ipvlan->dev, |
940 | "Failed to add IPv4=%pI4 on %s intf.\n" , |
941 | ip4_addr, ipvlan->dev->name); |
942 | else |
943 | ret = ipvlan_add_addr(ipvlan, iaddr: ip4_addr, is_v6: false); |
944 | spin_unlock_bh(lock: &ipvlan->addrs_lock); |
945 | return ret; |
946 | } |
947 | |
948 | static void ipvlan_del_addr4(struct ipvl_dev *ipvlan, struct in_addr *ip4_addr) |
949 | { |
950 | return ipvlan_del_addr(ipvlan, iaddr: ip4_addr, is_v6: false); |
951 | } |
952 | |
953 | static int ipvlan_addr4_event(struct notifier_block *unused, |
954 | unsigned long event, void *ptr) |
955 | { |
956 | struct in_ifaddr *if4 = (struct in_ifaddr *)ptr; |
957 | struct net_device *dev = (struct net_device *)if4->ifa_dev->dev; |
958 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
959 | struct in_addr ip4_addr; |
960 | |
961 | if (!ipvlan_is_valid_dev(dev)) |
962 | return NOTIFY_DONE; |
963 | |
964 | switch (event) { |
965 | case NETDEV_UP: |
966 | ip4_addr.s_addr = if4->ifa_address; |
967 | if (ipvlan_add_addr4(ipvlan, ip4_addr: &ip4_addr)) |
968 | return NOTIFY_BAD; |
969 | break; |
970 | |
971 | case NETDEV_DOWN: |
972 | ip4_addr.s_addr = if4->ifa_address; |
973 | ipvlan_del_addr4(ipvlan, ip4_addr: &ip4_addr); |
974 | break; |
975 | } |
976 | |
977 | return NOTIFY_OK; |
978 | } |
979 | |
980 | static int ipvlan_addr4_validator_event(struct notifier_block *unused, |
981 | unsigned long event, void *ptr) |
982 | { |
983 | struct in_validator_info *ivi = (struct in_validator_info *)ptr; |
984 | struct net_device *dev = (struct net_device *)ivi->ivi_dev->dev; |
985 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
986 | |
987 | if (!ipvlan_is_valid_dev(dev)) |
988 | return NOTIFY_DONE; |
989 | |
990 | switch (event) { |
991 | case NETDEV_UP: |
992 | if (ipvlan_addr_busy(port: ipvlan->port, iaddr: &ivi->ivi_addr, is_v6: false)) { |
993 | NL_SET_ERR_MSG(ivi->extack, |
994 | "Address already assigned to an ipvlan device" ); |
995 | return notifier_from_errno(err: -EADDRINUSE); |
996 | } |
997 | break; |
998 | } |
999 | |
1000 | return NOTIFY_OK; |
1001 | } |
1002 | |
1003 | static struct notifier_block ipvlan_addr4_notifier_block __read_mostly = { |
1004 | .notifier_call = ipvlan_addr4_event, |
1005 | }; |
1006 | |
1007 | static struct notifier_block ipvlan_addr4_vtor_notifier_block __read_mostly = { |
1008 | .notifier_call = ipvlan_addr4_validator_event, |
1009 | }; |
1010 | |
1011 | static struct notifier_block ipvlan_notifier_block __read_mostly = { |
1012 | .notifier_call = ipvlan_device_event, |
1013 | }; |
1014 | |
1015 | #if IS_ENABLED(CONFIG_IPV6) |
1016 | static struct notifier_block ipvlan_addr6_notifier_block __read_mostly = { |
1017 | .notifier_call = ipvlan_addr6_event, |
1018 | }; |
1019 | |
1020 | static struct notifier_block ipvlan_addr6_vtor_notifier_block __read_mostly = { |
1021 | .notifier_call = ipvlan_addr6_validator_event, |
1022 | }; |
1023 | #endif |
1024 | |
1025 | static int __init ipvlan_init_module(void) |
1026 | { |
1027 | int err; |
1028 | |
1029 | ipvlan_init_secret(); |
1030 | register_netdevice_notifier(nb: &ipvlan_notifier_block); |
1031 | #if IS_ENABLED(CONFIG_IPV6) |
1032 | register_inet6addr_notifier(nb: &ipvlan_addr6_notifier_block); |
1033 | register_inet6addr_validator_notifier( |
1034 | nb: &ipvlan_addr6_vtor_notifier_block); |
1035 | #endif |
1036 | register_inetaddr_notifier(nb: &ipvlan_addr4_notifier_block); |
1037 | register_inetaddr_validator_notifier(nb: &ipvlan_addr4_vtor_notifier_block); |
1038 | |
1039 | err = ipvlan_l3s_init(); |
1040 | if (err < 0) |
1041 | goto error; |
1042 | |
1043 | err = ipvlan_link_register(&ipvlan_link_ops); |
1044 | if (err < 0) { |
1045 | ipvlan_l3s_cleanup(); |
1046 | goto error; |
1047 | } |
1048 | |
1049 | return 0; |
1050 | error: |
1051 | unregister_inetaddr_notifier(nb: &ipvlan_addr4_notifier_block); |
1052 | unregister_inetaddr_validator_notifier( |
1053 | nb: &ipvlan_addr4_vtor_notifier_block); |
1054 | #if IS_ENABLED(CONFIG_IPV6) |
1055 | unregister_inet6addr_notifier(nb: &ipvlan_addr6_notifier_block); |
1056 | unregister_inet6addr_validator_notifier( |
1057 | nb: &ipvlan_addr6_vtor_notifier_block); |
1058 | #endif |
1059 | unregister_netdevice_notifier(nb: &ipvlan_notifier_block); |
1060 | return err; |
1061 | } |
1062 | |
1063 | static void __exit ipvlan_cleanup_module(void) |
1064 | { |
1065 | rtnl_link_unregister(ops: &ipvlan_link_ops); |
1066 | ipvlan_l3s_cleanup(); |
1067 | unregister_netdevice_notifier(nb: &ipvlan_notifier_block); |
1068 | unregister_inetaddr_notifier(nb: &ipvlan_addr4_notifier_block); |
1069 | unregister_inetaddr_validator_notifier( |
1070 | nb: &ipvlan_addr4_vtor_notifier_block); |
1071 | #if IS_ENABLED(CONFIG_IPV6) |
1072 | unregister_inet6addr_notifier(nb: &ipvlan_addr6_notifier_block); |
1073 | unregister_inet6addr_validator_notifier( |
1074 | nb: &ipvlan_addr6_vtor_notifier_block); |
1075 | #endif |
1076 | } |
1077 | |
1078 | module_init(ipvlan_init_module); |
1079 | module_exit(ipvlan_cleanup_module); |
1080 | |
1081 | MODULE_LICENSE("GPL" ); |
1082 | MODULE_AUTHOR("Mahesh Bandewar <maheshb@google.com>" ); |
1083 | MODULE_DESCRIPTION("Driver for L3 (IPv6/IPv4) based VLANs" ); |
1084 | MODULE_ALIAS_RTNL_LINK("ipvlan" ); |
1085 | |