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