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 READ_ONCE(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 | .parse_protocol = eth_header_parse_protocol, |
391 | }; |
392 | |
393 | static void ipvlan_adjust_mtu(struct ipvl_dev *ipvlan, struct net_device *dev) |
394 | { |
395 | ipvlan->dev->mtu = dev->mtu; |
396 | } |
397 | |
398 | static bool netif_is_ipvlan(const struct net_device *dev) |
399 | { |
400 | /* both ipvlan and ipvtap devices use the same netdev_ops */ |
401 | return dev->netdev_ops == &ipvlan_netdev_ops; |
402 | } |
403 | |
404 | static int ipvlan_ethtool_get_link_ksettings(struct net_device *dev, |
405 | struct ethtool_link_ksettings *cmd) |
406 | { |
407 | const struct ipvl_dev *ipvlan = netdev_priv(dev); |
408 | |
409 | return __ethtool_get_link_ksettings(dev: ipvlan->phy_dev, link_ksettings: cmd); |
410 | } |
411 | |
412 | static void ipvlan_ethtool_get_drvinfo(struct net_device *dev, |
413 | struct ethtool_drvinfo *drvinfo) |
414 | { |
415 | strscpy(drvinfo->driver, IPVLAN_DRV, sizeof(drvinfo->driver)); |
416 | strscpy(drvinfo->version, IPV_DRV_VER, sizeof(drvinfo->version)); |
417 | } |
418 | |
419 | static u32 ipvlan_ethtool_get_msglevel(struct net_device *dev) |
420 | { |
421 | const struct ipvl_dev *ipvlan = netdev_priv(dev); |
422 | |
423 | return ipvlan->msg_enable; |
424 | } |
425 | |
426 | static void ipvlan_ethtool_set_msglevel(struct net_device *dev, u32 value) |
427 | { |
428 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
429 | |
430 | ipvlan->msg_enable = value; |
431 | } |
432 | |
433 | static const struct ethtool_ops ipvlan_ethtool_ops = { |
434 | .get_link = ethtool_op_get_link, |
435 | .get_link_ksettings = ipvlan_ethtool_get_link_ksettings, |
436 | .get_drvinfo = ipvlan_ethtool_get_drvinfo, |
437 | .get_msglevel = ipvlan_ethtool_get_msglevel, |
438 | .set_msglevel = ipvlan_ethtool_set_msglevel, |
439 | }; |
440 | |
441 | static int ipvlan_nl_changelink(struct net_device *dev, |
442 | struct nlattr *tb[], struct nlattr *data[], |
443 | struct netlink_ext_ack *extack) |
444 | { |
445 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
446 | struct ipvl_port *port = ipvlan_port_get_rtnl(d: ipvlan->phy_dev); |
447 | int err = 0; |
448 | |
449 | if (!data) |
450 | return 0; |
451 | if (!ns_capable(ns: dev_net(dev: ipvlan->phy_dev)->user_ns, CAP_NET_ADMIN)) |
452 | return -EPERM; |
453 | |
454 | if (data[IFLA_IPVLAN_MODE]) { |
455 | u16 nmode = nla_get_u16(nla: data[IFLA_IPVLAN_MODE]); |
456 | |
457 | err = ipvlan_set_port_mode(port, nval: nmode, extack); |
458 | } |
459 | |
460 | if (!err && data[IFLA_IPVLAN_FLAGS]) { |
461 | u16 flags = nla_get_u16(nla: data[IFLA_IPVLAN_FLAGS]); |
462 | |
463 | if (flags & IPVLAN_F_PRIVATE) |
464 | ipvlan_mark_private(port); |
465 | else |
466 | ipvlan_clear_private(port); |
467 | |
468 | if (flags & IPVLAN_F_VEPA) |
469 | ipvlan_mark_vepa(port); |
470 | else |
471 | ipvlan_clear_vepa(port); |
472 | } |
473 | |
474 | return err; |
475 | } |
476 | |
477 | static size_t ipvlan_nl_getsize(const struct net_device *dev) |
478 | { |
479 | return (0 |
480 | + nla_total_size(payload: 2) /* IFLA_IPVLAN_MODE */ |
481 | + nla_total_size(payload: 2) /* IFLA_IPVLAN_FLAGS */ |
482 | ); |
483 | } |
484 | |
485 | static int ipvlan_nl_validate(struct nlattr *tb[], struct nlattr *data[], |
486 | struct netlink_ext_ack *extack) |
487 | { |
488 | if (!data) |
489 | return 0; |
490 | |
491 | if (data[IFLA_IPVLAN_MODE]) { |
492 | u16 mode = nla_get_u16(nla: data[IFLA_IPVLAN_MODE]); |
493 | |
494 | if (mode >= IPVLAN_MODE_MAX) |
495 | return -EINVAL; |
496 | } |
497 | if (data[IFLA_IPVLAN_FLAGS]) { |
498 | u16 flags = nla_get_u16(nla: data[IFLA_IPVLAN_FLAGS]); |
499 | |
500 | /* Only two bits are used at this moment. */ |
501 | if (flags & ~(IPVLAN_F_PRIVATE | IPVLAN_F_VEPA)) |
502 | return -EINVAL; |
503 | /* Also both flags can't be active at the same time. */ |
504 | if ((flags & (IPVLAN_F_PRIVATE | IPVLAN_F_VEPA)) == |
505 | (IPVLAN_F_PRIVATE | IPVLAN_F_VEPA)) |
506 | return -EINVAL; |
507 | } |
508 | |
509 | return 0; |
510 | } |
511 | |
512 | static int ipvlan_nl_fillinfo(struct sk_buff *skb, |
513 | const struct net_device *dev) |
514 | { |
515 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
516 | struct ipvl_port *port = ipvlan_port_get_rtnl(d: ipvlan->phy_dev); |
517 | int ret = -EINVAL; |
518 | |
519 | if (!port) |
520 | goto err; |
521 | |
522 | ret = -EMSGSIZE; |
523 | if (nla_put_u16(skb, attrtype: IFLA_IPVLAN_MODE, value: port->mode)) |
524 | goto err; |
525 | if (nla_put_u16(skb, attrtype: IFLA_IPVLAN_FLAGS, value: port->flags)) |
526 | goto err; |
527 | |
528 | return 0; |
529 | |
530 | err: |
531 | return ret; |
532 | } |
533 | |
534 | int ipvlan_link_new(struct net *src_net, struct net_device *dev, |
535 | struct nlattr *tb[], struct nlattr *data[], |
536 | struct netlink_ext_ack *extack) |
537 | { |
538 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
539 | struct ipvl_port *port; |
540 | struct net_device *phy_dev; |
541 | int err; |
542 | u16 mode = IPVLAN_MODE_L3; |
543 | |
544 | if (!tb[IFLA_LINK]) |
545 | return -EINVAL; |
546 | |
547 | phy_dev = __dev_get_by_index(net: src_net, ifindex: nla_get_u32(nla: tb[IFLA_LINK])); |
548 | if (!phy_dev) |
549 | return -ENODEV; |
550 | |
551 | if (netif_is_ipvlan(dev: phy_dev)) { |
552 | struct ipvl_dev *tmp = netdev_priv(dev: phy_dev); |
553 | |
554 | phy_dev = tmp->phy_dev; |
555 | if (!ns_capable(ns: dev_net(dev: phy_dev)->user_ns, CAP_NET_ADMIN)) |
556 | return -EPERM; |
557 | } else if (!netif_is_ipvlan_port(dev: phy_dev)) { |
558 | /* Exit early if the underlying link is invalid or busy */ |
559 | if (phy_dev->type != ARPHRD_ETHER || |
560 | phy_dev->flags & IFF_LOOPBACK) { |
561 | netdev_err(dev: phy_dev, |
562 | format: "Master is either lo or non-ether device\n" ); |
563 | return -EINVAL; |
564 | } |
565 | |
566 | if (netdev_is_rx_handler_busy(dev: phy_dev)) { |
567 | netdev_err(dev: phy_dev, format: "Device is already in use.\n" ); |
568 | return -EBUSY; |
569 | } |
570 | } |
571 | |
572 | ipvlan->phy_dev = phy_dev; |
573 | ipvlan->dev = dev; |
574 | ipvlan->sfeatures = IPVLAN_FEATURES; |
575 | if (!tb[IFLA_MTU]) |
576 | ipvlan_adjust_mtu(ipvlan, dev: phy_dev); |
577 | INIT_LIST_HEAD(list: &ipvlan->addrs); |
578 | spin_lock_init(&ipvlan->addrs_lock); |
579 | |
580 | /* TODO Probably put random address here to be presented to the |
581 | * world but keep using the physical-dev address for the outgoing |
582 | * packets. |
583 | */ |
584 | eth_hw_addr_set(dev, addr: phy_dev->dev_addr); |
585 | |
586 | dev->priv_flags |= IFF_NO_RX_HANDLER; |
587 | |
588 | err = register_netdevice(dev); |
589 | if (err < 0) |
590 | return err; |
591 | |
592 | /* ipvlan_init() would have created the port, if required */ |
593 | port = ipvlan_port_get_rtnl(d: phy_dev); |
594 | ipvlan->port = port; |
595 | |
596 | /* If the port-id base is at the MAX value, then wrap it around and |
597 | * begin from 0x1 again. This may be due to a busy system where lots |
598 | * of slaves are getting created and deleted. |
599 | */ |
600 | if (port->dev_id_start == 0xFFFE) |
601 | port->dev_id_start = 0x1; |
602 | |
603 | /* Since L2 address is shared among all IPvlan slaves including |
604 | * master, use unique 16 bit dev-ids to differentiate among them. |
605 | * Assign IDs between 0x1 and 0xFFFE (used by the master) to each |
606 | * slave link [see addrconf_ifid_eui48()]. |
607 | */ |
608 | err = ida_alloc_range(&port->ida, min: port->dev_id_start, max: 0xFFFD, |
609 | GFP_KERNEL); |
610 | if (err < 0) |
611 | err = ida_alloc_range(&port->ida, min: 0x1, max: port->dev_id_start - 1, |
612 | GFP_KERNEL); |
613 | if (err < 0) |
614 | goto unregister_netdev; |
615 | dev->dev_id = err; |
616 | |
617 | /* Increment id-base to the next slot for the future assignment */ |
618 | port->dev_id_start = err + 1; |
619 | |
620 | err = netdev_upper_dev_link(dev: phy_dev, upper_dev: dev, extack); |
621 | if (err) |
622 | goto remove_ida; |
623 | |
624 | /* Flags are per port and latest update overrides. User has |
625 | * to be consistent in setting it just like the mode attribute. |
626 | */ |
627 | if (data && data[IFLA_IPVLAN_FLAGS]) |
628 | port->flags = nla_get_u16(nla: data[IFLA_IPVLAN_FLAGS]); |
629 | |
630 | if (data && data[IFLA_IPVLAN_MODE]) |
631 | mode = nla_get_u16(nla: data[IFLA_IPVLAN_MODE]); |
632 | |
633 | err = ipvlan_set_port_mode(port, nval: mode, extack); |
634 | if (err) |
635 | goto unlink_netdev; |
636 | |
637 | list_add_tail_rcu(new: &ipvlan->pnode, head: &port->ipvlans); |
638 | netif_stacked_transfer_operstate(rootdev: phy_dev, dev); |
639 | return 0; |
640 | |
641 | unlink_netdev: |
642 | netdev_upper_dev_unlink(dev: phy_dev, upper_dev: dev); |
643 | remove_ida: |
644 | ida_free(&port->ida, id: dev->dev_id); |
645 | unregister_netdev: |
646 | unregister_netdevice(dev); |
647 | return err; |
648 | } |
649 | EXPORT_SYMBOL_GPL(ipvlan_link_new); |
650 | |
651 | void ipvlan_link_delete(struct net_device *dev, struct list_head *head) |
652 | { |
653 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
654 | struct ipvl_addr *addr, *next; |
655 | |
656 | spin_lock_bh(lock: &ipvlan->addrs_lock); |
657 | list_for_each_entry_safe(addr, next, &ipvlan->addrs, anode) { |
658 | ipvlan_ht_addr_del(addr); |
659 | list_del_rcu(entry: &addr->anode); |
660 | kfree_rcu(addr, rcu); |
661 | } |
662 | spin_unlock_bh(lock: &ipvlan->addrs_lock); |
663 | |
664 | ida_free(&ipvlan->port->ida, id: dev->dev_id); |
665 | list_del_rcu(entry: &ipvlan->pnode); |
666 | unregister_netdevice_queue(dev, head); |
667 | netdev_upper_dev_unlink(dev: ipvlan->phy_dev, upper_dev: dev); |
668 | } |
669 | EXPORT_SYMBOL_GPL(ipvlan_link_delete); |
670 | |
671 | void ipvlan_link_setup(struct net_device *dev) |
672 | { |
673 | ether_setup(dev); |
674 | |
675 | dev->max_mtu = ETH_MAX_MTU; |
676 | dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING); |
677 | dev->priv_flags |= IFF_UNICAST_FLT | IFF_NO_QUEUE; |
678 | dev->netdev_ops = &ipvlan_netdev_ops; |
679 | dev->needs_free_netdev = true; |
680 | dev->header_ops = &ipvlan_header_ops; |
681 | dev->ethtool_ops = &ipvlan_ethtool_ops; |
682 | } |
683 | EXPORT_SYMBOL_GPL(ipvlan_link_setup); |
684 | |
685 | static const struct nla_policy ipvlan_nl_policy[IFLA_IPVLAN_MAX + 1] = |
686 | { |
687 | [IFLA_IPVLAN_MODE] = { .type = NLA_U16 }, |
688 | [IFLA_IPVLAN_FLAGS] = { .type = NLA_U16 }, |
689 | }; |
690 | |
691 | static struct net *ipvlan_get_link_net(const struct net_device *dev) |
692 | { |
693 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
694 | |
695 | return dev_net(dev: ipvlan->phy_dev); |
696 | } |
697 | |
698 | static struct rtnl_link_ops ipvlan_link_ops = { |
699 | .kind = "ipvlan" , |
700 | .priv_size = sizeof(struct ipvl_dev), |
701 | |
702 | .setup = ipvlan_link_setup, |
703 | .newlink = ipvlan_link_new, |
704 | .dellink = ipvlan_link_delete, |
705 | .get_link_net = ipvlan_get_link_net, |
706 | }; |
707 | |
708 | int ipvlan_link_register(struct rtnl_link_ops *ops) |
709 | { |
710 | ops->get_size = ipvlan_nl_getsize; |
711 | ops->policy = ipvlan_nl_policy; |
712 | ops->validate = ipvlan_nl_validate; |
713 | ops->fill_info = ipvlan_nl_fillinfo; |
714 | ops->changelink = ipvlan_nl_changelink; |
715 | ops->maxtype = IFLA_IPVLAN_MAX; |
716 | return rtnl_link_register(ops); |
717 | } |
718 | EXPORT_SYMBOL_GPL(ipvlan_link_register); |
719 | |
720 | static int ipvlan_device_event(struct notifier_block *unused, |
721 | unsigned long event, void *ptr) |
722 | { |
723 | struct netlink_ext_ack *extack = netdev_notifier_info_to_extack(info: ptr); |
724 | struct netdev_notifier_pre_changeaddr_info *prechaddr_info; |
725 | struct net_device *dev = netdev_notifier_info_to_dev(info: ptr); |
726 | struct ipvl_dev *ipvlan, *next; |
727 | struct ipvl_port *port; |
728 | LIST_HEAD(lst_kill); |
729 | int err; |
730 | |
731 | if (!netif_is_ipvlan_port(dev)) |
732 | return NOTIFY_DONE; |
733 | |
734 | port = ipvlan_port_get_rtnl(d: dev); |
735 | |
736 | switch (event) { |
737 | case NETDEV_UP: |
738 | case NETDEV_CHANGE: |
739 | list_for_each_entry(ipvlan, &port->ipvlans, pnode) |
740 | netif_stacked_transfer_operstate(rootdev: ipvlan->phy_dev, |
741 | dev: ipvlan->dev); |
742 | break; |
743 | |
744 | case NETDEV_REGISTER: { |
745 | struct net *oldnet, *newnet = dev_net(dev); |
746 | |
747 | oldnet = read_pnet(pnet: &port->pnet); |
748 | if (net_eq(net1: newnet, net2: oldnet)) |
749 | break; |
750 | |
751 | write_pnet(pnet: &port->pnet, net: newnet); |
752 | |
753 | if (port->mode == IPVLAN_MODE_L3S) |
754 | ipvlan_migrate_l3s_hook(oldnet, newnet); |
755 | break; |
756 | } |
757 | case NETDEV_UNREGISTER: |
758 | if (dev->reg_state != NETREG_UNREGISTERING) |
759 | break; |
760 | |
761 | list_for_each_entry_safe(ipvlan, next, &port->ipvlans, pnode) |
762 | ipvlan->dev->rtnl_link_ops->dellink(ipvlan->dev, |
763 | &lst_kill); |
764 | unregister_netdevice_many(head: &lst_kill); |
765 | break; |
766 | |
767 | case NETDEV_FEAT_CHANGE: |
768 | list_for_each_entry(ipvlan, &port->ipvlans, pnode) { |
769 | netif_inherit_tso_max(to: ipvlan->dev, from: dev); |
770 | netdev_update_features(dev: ipvlan->dev); |
771 | } |
772 | break; |
773 | |
774 | case NETDEV_CHANGEMTU: |
775 | list_for_each_entry(ipvlan, &port->ipvlans, pnode) |
776 | ipvlan_adjust_mtu(ipvlan, dev); |
777 | break; |
778 | |
779 | case NETDEV_PRE_CHANGEADDR: |
780 | prechaddr_info = ptr; |
781 | list_for_each_entry(ipvlan, &port->ipvlans, pnode) { |
782 | err = dev_pre_changeaddr_notify(dev: ipvlan->dev, |
783 | addr: prechaddr_info->dev_addr, |
784 | extack); |
785 | if (err) |
786 | return notifier_from_errno(err); |
787 | } |
788 | break; |
789 | |
790 | case NETDEV_CHANGEADDR: |
791 | list_for_each_entry(ipvlan, &port->ipvlans, pnode) { |
792 | eth_hw_addr_set(dev: ipvlan->dev, addr: dev->dev_addr); |
793 | call_netdevice_notifiers(val: NETDEV_CHANGEADDR, dev: ipvlan->dev); |
794 | } |
795 | break; |
796 | |
797 | case NETDEV_PRE_TYPE_CHANGE: |
798 | /* Forbid underlying device to change its type. */ |
799 | return NOTIFY_BAD; |
800 | } |
801 | return NOTIFY_DONE; |
802 | } |
803 | |
804 | /* the caller must held the addrs lock */ |
805 | static int ipvlan_add_addr(struct ipvl_dev *ipvlan, void *iaddr, bool is_v6) |
806 | { |
807 | struct ipvl_addr *addr; |
808 | |
809 | addr = kzalloc(size: sizeof(struct ipvl_addr), GFP_ATOMIC); |
810 | if (!addr) |
811 | return -ENOMEM; |
812 | |
813 | addr->master = ipvlan; |
814 | if (!is_v6) { |
815 | memcpy(&addr->ip4addr, iaddr, sizeof(struct in_addr)); |
816 | addr->atype = IPVL_IPV4; |
817 | #if IS_ENABLED(CONFIG_IPV6) |
818 | } else { |
819 | memcpy(&addr->ip6addr, iaddr, sizeof(struct in6_addr)); |
820 | addr->atype = IPVL_IPV6; |
821 | #endif |
822 | } |
823 | |
824 | list_add_tail_rcu(new: &addr->anode, head: &ipvlan->addrs); |
825 | |
826 | /* If the interface is not up, the address will be added to the hash |
827 | * list by ipvlan_open. |
828 | */ |
829 | if (netif_running(dev: ipvlan->dev)) |
830 | ipvlan_ht_addr_add(ipvlan, addr); |
831 | |
832 | return 0; |
833 | } |
834 | |
835 | static void ipvlan_del_addr(struct ipvl_dev *ipvlan, void *iaddr, bool is_v6) |
836 | { |
837 | struct ipvl_addr *addr; |
838 | |
839 | spin_lock_bh(lock: &ipvlan->addrs_lock); |
840 | addr = ipvlan_find_addr(ipvlan, iaddr, is_v6); |
841 | if (!addr) { |
842 | spin_unlock_bh(lock: &ipvlan->addrs_lock); |
843 | return; |
844 | } |
845 | |
846 | ipvlan_ht_addr_del(addr); |
847 | list_del_rcu(entry: &addr->anode); |
848 | spin_unlock_bh(lock: &ipvlan->addrs_lock); |
849 | kfree_rcu(addr, rcu); |
850 | } |
851 | |
852 | static bool ipvlan_is_valid_dev(const struct net_device *dev) |
853 | { |
854 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
855 | |
856 | if (!netif_is_ipvlan(dev)) |
857 | return false; |
858 | |
859 | if (!ipvlan || !ipvlan->port) |
860 | return false; |
861 | |
862 | return true; |
863 | } |
864 | |
865 | #if IS_ENABLED(CONFIG_IPV6) |
866 | static int ipvlan_add_addr6(struct ipvl_dev *ipvlan, struct in6_addr *ip6_addr) |
867 | { |
868 | int ret = -EINVAL; |
869 | |
870 | spin_lock_bh(lock: &ipvlan->addrs_lock); |
871 | if (ipvlan_addr_busy(port: ipvlan->port, iaddr: ip6_addr, is_v6: true)) |
872 | netif_err(ipvlan, ifup, ipvlan->dev, |
873 | "Failed to add IPv6=%pI6c addr for %s intf\n" , |
874 | ip6_addr, ipvlan->dev->name); |
875 | else |
876 | ret = ipvlan_add_addr(ipvlan, iaddr: ip6_addr, is_v6: true); |
877 | spin_unlock_bh(lock: &ipvlan->addrs_lock); |
878 | return ret; |
879 | } |
880 | |
881 | static void ipvlan_del_addr6(struct ipvl_dev *ipvlan, struct in6_addr *ip6_addr) |
882 | { |
883 | return ipvlan_del_addr(ipvlan, iaddr: ip6_addr, is_v6: true); |
884 | } |
885 | |
886 | static int ipvlan_addr6_event(struct notifier_block *unused, |
887 | unsigned long event, void *ptr) |
888 | { |
889 | struct inet6_ifaddr *if6 = (struct inet6_ifaddr *)ptr; |
890 | struct net_device *dev = (struct net_device *)if6->idev->dev; |
891 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
892 | |
893 | if (!ipvlan_is_valid_dev(dev)) |
894 | return NOTIFY_DONE; |
895 | |
896 | switch (event) { |
897 | case NETDEV_UP: |
898 | if (ipvlan_add_addr6(ipvlan, ip6_addr: &if6->addr)) |
899 | return NOTIFY_BAD; |
900 | break; |
901 | |
902 | case NETDEV_DOWN: |
903 | ipvlan_del_addr6(ipvlan, ip6_addr: &if6->addr); |
904 | break; |
905 | } |
906 | |
907 | return NOTIFY_OK; |
908 | } |
909 | |
910 | static int ipvlan_addr6_validator_event(struct notifier_block *unused, |
911 | unsigned long event, void *ptr) |
912 | { |
913 | struct in6_validator_info *i6vi = (struct in6_validator_info *)ptr; |
914 | struct net_device *dev = (struct net_device *)i6vi->i6vi_dev->dev; |
915 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
916 | |
917 | if (!ipvlan_is_valid_dev(dev)) |
918 | return NOTIFY_DONE; |
919 | |
920 | switch (event) { |
921 | case NETDEV_UP: |
922 | if (ipvlan_addr_busy(port: ipvlan->port, iaddr: &i6vi->i6vi_addr, is_v6: true)) { |
923 | NL_SET_ERR_MSG(i6vi->extack, |
924 | "Address already assigned to an ipvlan device" ); |
925 | return notifier_from_errno(err: -EADDRINUSE); |
926 | } |
927 | break; |
928 | } |
929 | |
930 | return NOTIFY_OK; |
931 | } |
932 | #endif |
933 | |
934 | static int ipvlan_add_addr4(struct ipvl_dev *ipvlan, struct in_addr *ip4_addr) |
935 | { |
936 | int ret = -EINVAL; |
937 | |
938 | spin_lock_bh(lock: &ipvlan->addrs_lock); |
939 | if (ipvlan_addr_busy(port: ipvlan->port, iaddr: ip4_addr, is_v6: false)) |
940 | netif_err(ipvlan, ifup, ipvlan->dev, |
941 | "Failed to add IPv4=%pI4 on %s intf.\n" , |
942 | ip4_addr, ipvlan->dev->name); |
943 | else |
944 | ret = ipvlan_add_addr(ipvlan, iaddr: ip4_addr, is_v6: false); |
945 | spin_unlock_bh(lock: &ipvlan->addrs_lock); |
946 | return ret; |
947 | } |
948 | |
949 | static void ipvlan_del_addr4(struct ipvl_dev *ipvlan, struct in_addr *ip4_addr) |
950 | { |
951 | return ipvlan_del_addr(ipvlan, iaddr: ip4_addr, is_v6: false); |
952 | } |
953 | |
954 | static int ipvlan_addr4_event(struct notifier_block *unused, |
955 | unsigned long event, void *ptr) |
956 | { |
957 | struct in_ifaddr *if4 = (struct in_ifaddr *)ptr; |
958 | struct net_device *dev = (struct net_device *)if4->ifa_dev->dev; |
959 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
960 | struct in_addr ip4_addr; |
961 | |
962 | if (!ipvlan_is_valid_dev(dev)) |
963 | return NOTIFY_DONE; |
964 | |
965 | switch (event) { |
966 | case NETDEV_UP: |
967 | ip4_addr.s_addr = if4->ifa_address; |
968 | if (ipvlan_add_addr4(ipvlan, ip4_addr: &ip4_addr)) |
969 | return NOTIFY_BAD; |
970 | break; |
971 | |
972 | case NETDEV_DOWN: |
973 | ip4_addr.s_addr = if4->ifa_address; |
974 | ipvlan_del_addr4(ipvlan, ip4_addr: &ip4_addr); |
975 | break; |
976 | } |
977 | |
978 | return NOTIFY_OK; |
979 | } |
980 | |
981 | static int ipvlan_addr4_validator_event(struct notifier_block *unused, |
982 | unsigned long event, void *ptr) |
983 | { |
984 | struct in_validator_info *ivi = (struct in_validator_info *)ptr; |
985 | struct net_device *dev = (struct net_device *)ivi->ivi_dev->dev; |
986 | struct ipvl_dev *ipvlan = netdev_priv(dev); |
987 | |
988 | if (!ipvlan_is_valid_dev(dev)) |
989 | return NOTIFY_DONE; |
990 | |
991 | switch (event) { |
992 | case NETDEV_UP: |
993 | if (ipvlan_addr_busy(port: ipvlan->port, iaddr: &ivi->ivi_addr, is_v6: false)) { |
994 | NL_SET_ERR_MSG(ivi->extack, |
995 | "Address already assigned to an ipvlan device" ); |
996 | return notifier_from_errno(err: -EADDRINUSE); |
997 | } |
998 | break; |
999 | } |
1000 | |
1001 | return NOTIFY_OK; |
1002 | } |
1003 | |
1004 | static struct notifier_block ipvlan_addr4_notifier_block __read_mostly = { |
1005 | .notifier_call = ipvlan_addr4_event, |
1006 | }; |
1007 | |
1008 | static struct notifier_block ipvlan_addr4_vtor_notifier_block __read_mostly = { |
1009 | .notifier_call = ipvlan_addr4_validator_event, |
1010 | }; |
1011 | |
1012 | static struct notifier_block ipvlan_notifier_block __read_mostly = { |
1013 | .notifier_call = ipvlan_device_event, |
1014 | }; |
1015 | |
1016 | #if IS_ENABLED(CONFIG_IPV6) |
1017 | static struct notifier_block ipvlan_addr6_notifier_block __read_mostly = { |
1018 | .notifier_call = ipvlan_addr6_event, |
1019 | }; |
1020 | |
1021 | static struct notifier_block ipvlan_addr6_vtor_notifier_block __read_mostly = { |
1022 | .notifier_call = ipvlan_addr6_validator_event, |
1023 | }; |
1024 | #endif |
1025 | |
1026 | static int __init ipvlan_init_module(void) |
1027 | { |
1028 | int err; |
1029 | |
1030 | ipvlan_init_secret(); |
1031 | register_netdevice_notifier(nb: &ipvlan_notifier_block); |
1032 | #if IS_ENABLED(CONFIG_IPV6) |
1033 | register_inet6addr_notifier(nb: &ipvlan_addr6_notifier_block); |
1034 | register_inet6addr_validator_notifier( |
1035 | nb: &ipvlan_addr6_vtor_notifier_block); |
1036 | #endif |
1037 | register_inetaddr_notifier(nb: &ipvlan_addr4_notifier_block); |
1038 | register_inetaddr_validator_notifier(nb: &ipvlan_addr4_vtor_notifier_block); |
1039 | |
1040 | err = ipvlan_l3s_init(); |
1041 | if (err < 0) |
1042 | goto error; |
1043 | |
1044 | err = ipvlan_link_register(&ipvlan_link_ops); |
1045 | if (err < 0) { |
1046 | ipvlan_l3s_cleanup(); |
1047 | goto error; |
1048 | } |
1049 | |
1050 | return 0; |
1051 | error: |
1052 | unregister_inetaddr_notifier(nb: &ipvlan_addr4_notifier_block); |
1053 | unregister_inetaddr_validator_notifier( |
1054 | nb: &ipvlan_addr4_vtor_notifier_block); |
1055 | #if IS_ENABLED(CONFIG_IPV6) |
1056 | unregister_inet6addr_notifier(nb: &ipvlan_addr6_notifier_block); |
1057 | unregister_inet6addr_validator_notifier( |
1058 | nb: &ipvlan_addr6_vtor_notifier_block); |
1059 | #endif |
1060 | unregister_netdevice_notifier(nb: &ipvlan_notifier_block); |
1061 | return err; |
1062 | } |
1063 | |
1064 | static void __exit ipvlan_cleanup_module(void) |
1065 | { |
1066 | rtnl_link_unregister(ops: &ipvlan_link_ops); |
1067 | ipvlan_l3s_cleanup(); |
1068 | unregister_netdevice_notifier(nb: &ipvlan_notifier_block); |
1069 | unregister_inetaddr_notifier(nb: &ipvlan_addr4_notifier_block); |
1070 | unregister_inetaddr_validator_notifier( |
1071 | nb: &ipvlan_addr4_vtor_notifier_block); |
1072 | #if IS_ENABLED(CONFIG_IPV6) |
1073 | unregister_inet6addr_notifier(nb: &ipvlan_addr6_notifier_block); |
1074 | unregister_inet6addr_validator_notifier( |
1075 | nb: &ipvlan_addr6_vtor_notifier_block); |
1076 | #endif |
1077 | } |
1078 | |
1079 | module_init(ipvlan_init_module); |
1080 | module_exit(ipvlan_cleanup_module); |
1081 | |
1082 | MODULE_LICENSE("GPL" ); |
1083 | MODULE_AUTHOR("Mahesh Bandewar <maheshb@google.com>" ); |
1084 | MODULE_DESCRIPTION("Driver for L3 (IPv6/IPv4) based VLANs" ); |
1085 | MODULE_ALIAS_RTNL_LINK("ipvlan" ); |
1086 | |