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
9static 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
45fail:
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
61static 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
89err:
90 kfree(objp: port);
91 return err;
92}
93
94static 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
130static 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
165static 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
179static 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
198static 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
215static 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
238static 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
253static 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
262static 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
289static 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
330static 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
338static 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
348static 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
355static 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
370static int ipvlan_hard_header(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
385static const struct header_ops ipvlan_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
392static void ipvlan_adjust_mtu(struct ipvl_dev *ipvlan, struct net_device *dev)
393{
394 ipvlan->dev->mtu = dev->mtu;
395}
396
397static 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
403static 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
411static 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
418static 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
425static 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
432static 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
440static 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
476static 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
484static 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
511static 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
529err:
530 return ret;
531}
532
533int 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
640unlink_netdev:
641 netdev_upper_dev_unlink(dev: phy_dev, upper_dev: dev);
642remove_ida:
643 ida_simple_remove(&port->ida, dev->dev_id);
644unregister_netdev:
645 unregister_netdevice(dev);
646 return err;
647}
648EXPORT_SYMBOL_GPL(ipvlan_link_new);
649
650void 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}
668EXPORT_SYMBOL_GPL(ipvlan_link_delete);
669
670void 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}
682EXPORT_SYMBOL_GPL(ipvlan_link_setup);
683
684static 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
690static 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
697static 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
707int 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}
717EXPORT_SYMBOL_GPL(ipvlan_link_register);
718
719static 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 */
804static 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
834static 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
851static 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)
865static 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
880static 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
885static 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
909static 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
933static 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
948static 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
953static 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
980static 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
1003static struct notifier_block ipvlan_addr4_notifier_block __read_mostly = {
1004 .notifier_call = ipvlan_addr4_event,
1005};
1006
1007static struct notifier_block ipvlan_addr4_vtor_notifier_block __read_mostly = {
1008 .notifier_call = ipvlan_addr4_validator_event,
1009};
1010
1011static struct notifier_block ipvlan_notifier_block __read_mostly = {
1012 .notifier_call = ipvlan_device_event,
1013};
1014
1015#if IS_ENABLED(CONFIG_IPV6)
1016static struct notifier_block ipvlan_addr6_notifier_block __read_mostly = {
1017 .notifier_call = ipvlan_addr6_event,
1018};
1019
1020static struct notifier_block ipvlan_addr6_vtor_notifier_block __read_mostly = {
1021 .notifier_call = ipvlan_addr6_validator_event,
1022};
1023#endif
1024
1025static 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;
1050error:
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
1063static 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
1078module_init(ipvlan_init_module);
1079module_exit(ipvlan_cleanup_module);
1080
1081MODULE_LICENSE("GPL");
1082MODULE_AUTHOR("Mahesh Bandewar <maheshb@google.com>");
1083MODULE_DESCRIPTION("Driver for L3 (IPv6/IPv4) based VLANs");
1084MODULE_ALIAS_RTNL_LINK("ipvlan");
1085

source code of linux/drivers/net/ipvlan/ipvlan_main.c