blob: 66addb7a7911beb33f17c916caa7bb48ae84507e [file] [log] [blame]
David Ahern193125d2015-08-13 14:59:10 -06001/*
2 * vrf.c: device driver to encapsulate a VRF space
3 *
4 * Copyright (c) 2015 Cumulus Networks. All rights reserved.
5 * Copyright (c) 2015 Shrijeet Mukherjee <shm@cumulusnetworks.com>
6 * Copyright (c) 2015 David Ahern <dsa@cumulusnetworks.com>
7 *
8 * Based on dummy, team and ipvlan drivers
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 */
15
16#include <linux/module.h>
17#include <linux/kernel.h>
18#include <linux/netdevice.h>
19#include <linux/etherdevice.h>
20#include <linux/ip.h>
21#include <linux/init.h>
22#include <linux/moduleparam.h>
23#include <linux/netfilter.h>
24#include <linux/rtnetlink.h>
25#include <net/rtnetlink.h>
26#include <linux/u64_stats_sync.h>
27#include <linux/hashtable.h>
28
29#include <linux/inetdevice.h>
David Ahern8f583362015-08-27 10:10:50 -070030#include <net/arp.h>
David Ahern193125d2015-08-13 14:59:10 -060031#include <net/ip.h>
32#include <net/ip_fib.h>
David Ahern35402e32015-10-12 11:47:09 -070033#include <net/ip6_fib.h>
David Ahern193125d2015-08-13 14:59:10 -060034#include <net/ip6_route.h>
35#include <net/rtnetlink.h>
36#include <net/route.h>
37#include <net/addrconf.h>
David Ahernee15ee52015-09-29 20:07:12 -070038#include <net/l3mdev.h>
David Ahern193125d2015-08-13 14:59:10 -060039
David Ahern8cbb512c2015-10-05 08:51:26 -070040#define RT_FL_TOS(oldflp4) \
41 ((oldflp4)->flowi4_tos & (IPTOS_RT_MASK | RTO_ONLINK))
42
David Ahern193125d2015-08-13 14:59:10 -060043#define DRV_NAME "vrf"
44#define DRV_VERSION "1.0"
45
David Ahern193125d2015-08-13 14:59:10 -060046#define vrf_master_get_rcu(dev) \
47 ((struct net_device *)rcu_dereference(dev->rx_handler_data))
48
David Ahernec539512015-09-29 20:07:17 -070049struct net_vrf {
David Ahernec539512015-09-29 20:07:17 -070050 struct rtable *rth;
David Ahern35402e32015-10-12 11:47:09 -070051 struct rt6_info *rt6;
David Ahernec539512015-09-29 20:07:17 -070052 u32 tb_id;
53};
54
David Ahern193125d2015-08-13 14:59:10 -060055struct pcpu_dstats {
56 u64 tx_pkts;
57 u64 tx_bytes;
58 u64 tx_drps;
59 u64 rx_pkts;
60 u64 rx_bytes;
61 struct u64_stats_sync syncp;
62};
63
64static struct dst_entry *vrf_ip_check(struct dst_entry *dst, u32 cookie)
65{
66 return dst;
67}
68
Eric W. Biedermancf91a992015-10-07 16:48:45 -050069static int vrf_ip_local_out(struct net *net, struct sock *sk, struct sk_buff *skb)
David Ahern193125d2015-08-13 14:59:10 -060070{
Eric W. Biederman33224b12015-10-07 16:48:46 -050071 return ip_local_out(net, sk, skb);
David Ahern193125d2015-08-13 14:59:10 -060072}
73
74static unsigned int vrf_v4_mtu(const struct dst_entry *dst)
75{
76 /* TO-DO: return max ethernet size? */
77 return dst->dev->mtu;
78}
79
80static void vrf_dst_destroy(struct dst_entry *dst)
81{
82 /* our dst lives forever - or until the device is closed */
83}
84
85static unsigned int vrf_default_advmss(const struct dst_entry *dst)
86{
87 return 65535 - 40;
88}
89
90static struct dst_ops vrf_dst_ops = {
91 .family = AF_INET,
92 .local_out = vrf_ip_local_out,
93 .check = vrf_ip_check,
94 .mtu = vrf_v4_mtu,
95 .destroy = vrf_dst_destroy,
96 .default_advmss = vrf_default_advmss,
97};
98
David Ahern35402e32015-10-12 11:47:09 -070099/* neighbor handling is done with actual device; do not want
100 * to flip skb->dev for those ndisc packets. This really fails
101 * for multiple next protocols (e.g., NEXTHDR_HOP). But it is
102 * a start.
103 */
104#if IS_ENABLED(CONFIG_IPV6)
105static bool check_ipv6_frame(const struct sk_buff *skb)
106{
107 const struct ipv6hdr *ipv6h = (struct ipv6hdr *)skb->data;
108 size_t hlen = sizeof(*ipv6h);
109 bool rc = true;
110
111 if (skb->len < hlen)
112 goto out;
113
114 if (ipv6h->nexthdr == NEXTHDR_ICMP) {
115 const struct icmp6hdr *icmph;
116
117 if (skb->len < hlen + sizeof(*icmph))
118 goto out;
119
120 icmph = (struct icmp6hdr *)(skb->data + sizeof(*ipv6h));
121 switch (icmph->icmp6_type) {
122 case NDISC_ROUTER_SOLICITATION:
123 case NDISC_ROUTER_ADVERTISEMENT:
124 case NDISC_NEIGHBOUR_SOLICITATION:
125 case NDISC_NEIGHBOUR_ADVERTISEMENT:
126 case NDISC_REDIRECT:
127 rc = false;
128 break;
129 }
130 }
131
132out:
133 return rc;
134}
135#else
136static bool check_ipv6_frame(const struct sk_buff *skb)
137{
138 return false;
139}
140#endif
141
David Ahern193125d2015-08-13 14:59:10 -0600142static bool is_ip_rx_frame(struct sk_buff *skb)
143{
144 switch (skb->protocol) {
145 case htons(ETH_P_IP):
David Ahern193125d2015-08-13 14:59:10 -0600146 return true;
David Ahern35402e32015-10-12 11:47:09 -0700147 case htons(ETH_P_IPV6):
148 return check_ipv6_frame(skb);
David Ahern193125d2015-08-13 14:59:10 -0600149 }
150 return false;
151}
152
Nikolay Aleksandrov57b8efa2015-08-19 06:12:29 +0300153static void vrf_tx_error(struct net_device *vrf_dev, struct sk_buff *skb)
154{
155 vrf_dev->stats.tx_errors++;
156 kfree_skb(skb);
157}
158
David Ahern193125d2015-08-13 14:59:10 -0600159/* note: already called with rcu_read_lock */
160static rx_handler_result_t vrf_handle_frame(struct sk_buff **pskb)
161{
162 struct sk_buff *skb = *pskb;
163
164 if (is_ip_rx_frame(skb)) {
165 struct net_device *dev = vrf_master_get_rcu(skb->dev);
166 struct pcpu_dstats *dstats = this_cpu_ptr(dev->dstats);
167
168 u64_stats_update_begin(&dstats->syncp);
169 dstats->rx_pkts++;
170 dstats->rx_bytes += skb->len;
171 u64_stats_update_end(&dstats->syncp);
172
173 skb->dev = dev;
174
175 return RX_HANDLER_ANOTHER;
176 }
177 return RX_HANDLER_PASS;
178}
179
180static struct rtnl_link_stats64 *vrf_get_stats64(struct net_device *dev,
181 struct rtnl_link_stats64 *stats)
182{
183 int i;
184
185 for_each_possible_cpu(i) {
186 const struct pcpu_dstats *dstats;
187 u64 tbytes, tpkts, tdrops, rbytes, rpkts;
188 unsigned int start;
189
190 dstats = per_cpu_ptr(dev->dstats, i);
191 do {
192 start = u64_stats_fetch_begin_irq(&dstats->syncp);
193 tbytes = dstats->tx_bytes;
194 tpkts = dstats->tx_pkts;
195 tdrops = dstats->tx_drps;
196 rbytes = dstats->rx_bytes;
197 rpkts = dstats->rx_pkts;
198 } while (u64_stats_fetch_retry_irq(&dstats->syncp, start));
199 stats->tx_bytes += tbytes;
200 stats->tx_packets += tpkts;
201 stats->tx_dropped += tdrops;
202 stats->rx_bytes += rbytes;
203 stats->rx_packets += rpkts;
204 }
205 return stats;
206}
207
David Ahern35402e32015-10-12 11:47:09 -0700208#if IS_ENABLED(CONFIG_IPV6)
209static netdev_tx_t vrf_process_v6_outbound(struct sk_buff *skb,
210 struct net_device *dev)
211{
212 const struct ipv6hdr *iph = ipv6_hdr(skb);
213 struct net *net = dev_net(skb->dev);
214 struct flowi6 fl6 = {
215 /* needed to match OIF rule */
216 .flowi6_oif = dev->ifindex,
217 .flowi6_iif = LOOPBACK_IFINDEX,
218 .daddr = iph->daddr,
219 .saddr = iph->saddr,
220 .flowlabel = ip6_flowinfo(iph),
221 .flowi6_mark = skb->mark,
222 .flowi6_proto = iph->nexthdr,
223 .flowi6_flags = FLOWI_FLAG_L3MDEV_SRC | FLOWI_FLAG_SKIP_NH_OIF,
224 };
225 int ret = NET_XMIT_DROP;
226 struct dst_entry *dst;
227 struct dst_entry *dst_null = &net->ipv6.ip6_null_entry->dst;
228
229 dst = ip6_route_output(net, NULL, &fl6);
230 if (dst == dst_null)
231 goto err;
232
233 skb_dst_drop(skb);
234 skb_dst_set(skb, dst);
235
236 ret = ip6_local_out(net, skb->sk, skb);
237 if (unlikely(net_xmit_eval(ret)))
238 dev->stats.tx_errors++;
239 else
240 ret = NET_XMIT_SUCCESS;
241
242 return ret;
243err:
244 vrf_tx_error(dev, skb);
245 return NET_XMIT_DROP;
246}
247#else
David Ahern193125d2015-08-13 14:59:10 -0600248static netdev_tx_t vrf_process_v6_outbound(struct sk_buff *skb,
249 struct net_device *dev)
250{
Nikolay Aleksandrov57b8efa2015-08-19 06:12:29 +0300251 vrf_tx_error(dev, skb);
252 return NET_XMIT_DROP;
David Ahern193125d2015-08-13 14:59:10 -0600253}
David Ahern35402e32015-10-12 11:47:09 -0700254#endif
David Ahern193125d2015-08-13 14:59:10 -0600255
256static int vrf_send_v4_prep(struct sk_buff *skb, struct flowi4 *fl4,
257 struct net_device *vrf_dev)
258{
259 struct rtable *rt;
260 int err = 1;
261
262 rt = ip_route_output_flow(dev_net(vrf_dev), fl4, NULL);
263 if (IS_ERR(rt))
264 goto out;
265
266 /* TO-DO: what about broadcast ? */
267 if (rt->rt_type != RTN_UNICAST && rt->rt_type != RTN_LOCAL) {
268 ip_rt_put(rt);
269 goto out;
270 }
271
272 skb_dst_drop(skb);
273 skb_dst_set(skb, &rt->dst);
274 err = 0;
275out:
276 return err;
277}
278
279static netdev_tx_t vrf_process_v4_outbound(struct sk_buff *skb,
280 struct net_device *vrf_dev)
281{
282 struct iphdr *ip4h = ip_hdr(skb);
283 int ret = NET_XMIT_DROP;
284 struct flowi4 fl4 = {
285 /* needed to match OIF rule */
286 .flowi4_oif = vrf_dev->ifindex,
287 .flowi4_iif = LOOPBACK_IFINDEX,
288 .flowi4_tos = RT_TOS(ip4h->tos),
David Ahern6e2895a2015-10-05 08:51:23 -0700289 .flowi4_flags = FLOWI_FLAG_ANYSRC | FLOWI_FLAG_L3MDEV_SRC |
David Ahern58189ca2015-09-15 15:10:50 -0700290 FLOWI_FLAG_SKIP_NH_OIF,
David Ahern193125d2015-08-13 14:59:10 -0600291 .daddr = ip4h->daddr,
292 };
293
294 if (vrf_send_v4_prep(skb, &fl4, vrf_dev))
295 goto err;
296
297 if (!ip4h->saddr) {
298 ip4h->saddr = inet_select_addr(skb_dst(skb)->dev, 0,
299 RT_SCOPE_LINK);
300 }
301
Eric W. Biederman33224b12015-10-07 16:48:46 -0500302 ret = ip_local_out(dev_net(skb_dst(skb)->dev), skb->sk, skb);
David Ahern193125d2015-08-13 14:59:10 -0600303 if (unlikely(net_xmit_eval(ret)))
304 vrf_dev->stats.tx_errors++;
305 else
306 ret = NET_XMIT_SUCCESS;
307
308out:
309 return ret;
310err:
Nikolay Aleksandrov57b8efa2015-08-19 06:12:29 +0300311 vrf_tx_error(vrf_dev, skb);
David Ahern193125d2015-08-13 14:59:10 -0600312 goto out;
313}
314
315static netdev_tx_t is_ip_tx_frame(struct sk_buff *skb, struct net_device *dev)
316{
David Ahern8f583362015-08-27 10:10:50 -0700317 /* strip the ethernet header added for pass through VRF device */
318 __skb_pull(skb, skb_network_offset(skb));
319
David Ahern193125d2015-08-13 14:59:10 -0600320 switch (skb->protocol) {
321 case htons(ETH_P_IP):
322 return vrf_process_v4_outbound(skb, dev);
323 case htons(ETH_P_IPV6):
324 return vrf_process_v6_outbound(skb, dev);
325 default:
Nikolay Aleksandrov57b8efa2015-08-19 06:12:29 +0300326 vrf_tx_error(dev, skb);
David Ahern193125d2015-08-13 14:59:10 -0600327 return NET_XMIT_DROP;
328 }
329}
330
331static netdev_tx_t vrf_xmit(struct sk_buff *skb, struct net_device *dev)
332{
333 netdev_tx_t ret = is_ip_tx_frame(skb, dev);
334
335 if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {
336 struct pcpu_dstats *dstats = this_cpu_ptr(dev->dstats);
337
338 u64_stats_update_begin(&dstats->syncp);
339 dstats->tx_pkts++;
340 dstats->tx_bytes += skb->len;
341 u64_stats_update_end(&dstats->syncp);
342 } else {
343 this_cpu_inc(dev->dstats->tx_drps);
344 }
345
346 return ret;
347}
348
David Ahern35402e32015-10-12 11:47:09 -0700349#if IS_ENABLED(CONFIG_IPV6)
350static struct dst_entry *vrf_ip6_check(struct dst_entry *dst, u32 cookie)
351{
352 return dst;
353}
354
355static struct dst_ops vrf_dst_ops6 = {
356 .family = AF_INET6,
357 .local_out = ip6_local_out,
358 .check = vrf_ip6_check,
359 .mtu = vrf_v4_mtu,
360 .destroy = vrf_dst_destroy,
361 .default_advmss = vrf_default_advmss,
362};
363
364static int init_dst_ops6_kmem_cachep(void)
365{
366 vrf_dst_ops6.kmem_cachep = kmem_cache_create("vrf_ip6_dst_cache",
367 sizeof(struct rt6_info),
368 0,
369 SLAB_HWCACHE_ALIGN,
370 NULL);
371
372 if (!vrf_dst_ops6.kmem_cachep)
373 return -ENOMEM;
374
375 return 0;
376}
377
378static void free_dst_ops6_kmem_cachep(void)
379{
380 kmem_cache_destroy(vrf_dst_ops6.kmem_cachep);
381}
382
383static int vrf_input6(struct sk_buff *skb)
384{
385 skb->dev->stats.rx_errors++;
386 kfree_skb(skb);
387 return 0;
388}
389
390/* modelled after ip6_finish_output2 */
391static int vrf_finish_output6(struct net *net, struct sock *sk,
392 struct sk_buff *skb)
393{
394 struct dst_entry *dst = skb_dst(skb);
395 struct net_device *dev = dst->dev;
396 struct neighbour *neigh;
397 struct in6_addr *nexthop;
398 int ret;
399
400 skb->protocol = htons(ETH_P_IPV6);
401 skb->dev = dev;
402
403 rcu_read_lock_bh();
404 nexthop = rt6_nexthop((struct rt6_info *)dst, &ipv6_hdr(skb)->daddr);
405 neigh = __ipv6_neigh_lookup_noref(dst->dev, nexthop);
406 if (unlikely(!neigh))
407 neigh = __neigh_create(&nd_tbl, nexthop, dst->dev, false);
408 if (!IS_ERR(neigh)) {
409 ret = dst_neigh_output(dst, neigh, skb);
410 rcu_read_unlock_bh();
411 return ret;
412 }
413 rcu_read_unlock_bh();
414
415 IP6_INC_STATS(dev_net(dst->dev),
416 ip6_dst_idev(dst), IPSTATS_MIB_OUTNOROUTES);
417 kfree_skb(skb);
418 return -EINVAL;
419}
420
421/* modelled after ip6_output */
422static int vrf_output6(struct net *net, struct sock *sk, struct sk_buff *skb)
423{
424 return NF_HOOK_COND(NFPROTO_IPV6, NF_INET_POST_ROUTING,
425 net, sk, skb, NULL, skb_dst(skb)->dev,
426 vrf_finish_output6,
427 !(IP6CB(skb)->flags & IP6SKB_REROUTED));
428}
429
430static void vrf_rt6_destroy(struct net_vrf *vrf)
431{
432 dst_destroy(&vrf->rt6->dst);
433 free_percpu(vrf->rt6->rt6i_pcpu);
434 vrf->rt6 = NULL;
435}
436
437static int vrf_rt6_create(struct net_device *dev)
438{
439 struct net_vrf *vrf = netdev_priv(dev);
440 struct dst_entry *dst;
441 struct rt6_info *rt6;
442 int cpu;
443 int rc = -ENOMEM;
444
445 rt6 = dst_alloc(&vrf_dst_ops6, dev, 0,
446 DST_OBSOLETE_NONE,
447 (DST_HOST | DST_NOPOLICY | DST_NOXFRM));
448 if (!rt6)
449 goto out;
450
451 dst = &rt6->dst;
452
453 rt6->rt6i_pcpu = alloc_percpu_gfp(struct rt6_info *, GFP_KERNEL);
454 if (!rt6->rt6i_pcpu) {
455 dst_destroy(dst);
456 goto out;
457 }
458 for_each_possible_cpu(cpu) {
459 struct rt6_info **p = per_cpu_ptr(rt6->rt6i_pcpu, cpu);
460 *p = NULL;
461 }
462
463 memset(dst + 1, 0, sizeof(*rt6) - sizeof(*dst));
464
465 INIT_LIST_HEAD(&rt6->rt6i_siblings);
466 INIT_LIST_HEAD(&rt6->rt6i_uncached);
467
468 rt6->dst.input = vrf_input6;
469 rt6->dst.output = vrf_output6;
470
471 rt6->rt6i_table = fib6_get_table(dev_net(dev), vrf->tb_id);
472
473 atomic_set(&rt6->dst.__refcnt, 2);
474
475 vrf->rt6 = rt6;
476 rc = 0;
477out:
478 return rc;
479}
480#else
481static int init_dst_ops6_kmem_cachep(void)
482{
483 return 0;
484}
485
486static void free_dst_ops6_kmem_cachep(void)
487{
488}
489
490static void vrf_rt6_destroy(struct net_vrf *vrf)
491{
492}
493
494static int vrf_rt6_create(struct net_device *dev)
495{
496 return 0;
497}
498#endif
499
David Ahern8f583362015-08-27 10:10:50 -0700500/* modelled after ip_finish_output2 */
Eric W. Biederman0c4b51f2015-09-15 20:04:18 -0500501static int vrf_finish_output(struct net *net, struct sock *sk, struct sk_buff *skb)
David Ahern193125d2015-08-13 14:59:10 -0600502{
David Ahern8f583362015-08-27 10:10:50 -0700503 struct dst_entry *dst = skb_dst(skb);
504 struct rtable *rt = (struct rtable *)dst;
505 struct net_device *dev = dst->dev;
506 unsigned int hh_len = LL_RESERVED_SPACE(dev);
507 struct neighbour *neigh;
508 u32 nexthop;
509 int ret = -EINVAL;
510
511 /* Be paranoid, rather than too clever. */
512 if (unlikely(skb_headroom(skb) < hh_len && dev->header_ops)) {
513 struct sk_buff *skb2;
514
515 skb2 = skb_realloc_headroom(skb, LL_RESERVED_SPACE(dev));
516 if (!skb2) {
517 ret = -ENOMEM;
518 goto err;
519 }
520 if (skb->sk)
521 skb_set_owner_w(skb2, skb->sk);
522
523 consume_skb(skb);
524 skb = skb2;
525 }
526
527 rcu_read_lock_bh();
528
529 nexthop = (__force u32)rt_nexthop(rt, ip_hdr(skb)->daddr);
530 neigh = __ipv4_neigh_lookup_noref(dev, nexthop);
531 if (unlikely(!neigh))
532 neigh = __neigh_create(&arp_tbl, &nexthop, dev, false);
533 if (!IS_ERR(neigh))
534 ret = dst_neigh_output(dst, neigh, skb);
535
536 rcu_read_unlock_bh();
537err:
538 if (unlikely(ret < 0))
539 vrf_tx_error(skb->dev, skb);
540 return ret;
David Ahern193125d2015-08-13 14:59:10 -0600541}
542
Eric W. Biedermanede20592015-10-07 16:48:47 -0500543static int vrf_output(struct net *net, struct sock *sk, struct sk_buff *skb)
David Ahern193125d2015-08-13 14:59:10 -0600544{
545 struct net_device *dev = skb_dst(skb)->dev;
546
Eric W. Biederman29a26a52015-09-15 20:04:16 -0500547 IP_UPD_PO_STATS(net, IPSTATS_MIB_OUT, skb->len);
David Ahern193125d2015-08-13 14:59:10 -0600548
549 skb->dev = dev;
550 skb->protocol = htons(ETH_P_IP);
551
Eric W. Biederman29a26a52015-09-15 20:04:16 -0500552 return NF_HOOK_COND(NFPROTO_IPV4, NF_INET_POST_ROUTING,
553 net, sk, skb, NULL, dev,
David Ahern8f583362015-08-27 10:10:50 -0700554 vrf_finish_output,
David Ahern193125d2015-08-13 14:59:10 -0600555 !(IPCB(skb)->flags & IPSKB_REROUTED));
556}
557
558static void vrf_rtable_destroy(struct net_vrf *vrf)
559{
560 struct dst_entry *dst = (struct dst_entry *)vrf->rth;
561
Nikolay Aleksandrov3a4a27d2015-08-18 20:28:03 +0300562 dst_destroy(dst);
David Ahern193125d2015-08-13 14:59:10 -0600563 vrf->rth = NULL;
564}
565
566static struct rtable *vrf_rtable_create(struct net_device *dev)
567{
David Ahernb7503e02015-09-02 13:58:35 -0700568 struct net_vrf *vrf = netdev_priv(dev);
David Ahern193125d2015-08-13 14:59:10 -0600569 struct rtable *rth;
570
571 rth = dst_alloc(&vrf_dst_ops, dev, 2,
572 DST_OBSOLETE_NONE,
573 (DST_HOST | DST_NOPOLICY | DST_NOXFRM));
574 if (rth) {
575 rth->dst.output = vrf_output;
576 rth->rt_genid = rt_genid_ipv4(dev_net(dev));
577 rth->rt_flags = 0;
578 rth->rt_type = RTN_UNICAST;
579 rth->rt_is_input = 0;
580 rth->rt_iif = 0;
581 rth->rt_pmtu = 0;
582 rth->rt_gateway = 0;
583 rth->rt_uses_gateway = 0;
David Ahernb7503e02015-09-02 13:58:35 -0700584 rth->rt_table_id = vrf->tb_id;
David Ahern193125d2015-08-13 14:59:10 -0600585 INIT_LIST_HEAD(&rth->rt_uncached);
586 rth->rt_uncached_list = NULL;
David Ahern193125d2015-08-13 14:59:10 -0600587 }
588
589 return rth;
590}
591
592/**************************** device handling ********************/
593
594/* cycle interface to flush neighbor cache and move routes across tables */
595static void cycle_netdev(struct net_device *dev)
596{
597 unsigned int flags = dev->flags;
598 int ret;
599
600 if (!netif_running(dev))
601 return;
602
603 ret = dev_change_flags(dev, flags & ~IFF_UP);
604 if (ret >= 0)
605 ret = dev_change_flags(dev, flags);
606
607 if (ret < 0) {
608 netdev_err(dev,
609 "Failed to cycle device %s; route tables might be wrong!\n",
610 dev->name);
611 }
612}
613
David Ahern193125d2015-08-13 14:59:10 -0600614static int do_vrf_add_slave(struct net_device *dev, struct net_device *port_dev)
615{
Nikolay Aleksandrovbad53162015-11-24 14:29:16 +0100616 int ret;
David Ahern193125d2015-08-13 14:59:10 -0600617
David Ahern193125d2015-08-13 14:59:10 -0600618 /* register the packet handler for slave ports */
619 ret = netdev_rx_handler_register(port_dev, vrf_handle_frame, dev);
620 if (ret) {
621 netdev_err(port_dev,
622 "Device %s failed to register rx_handler\n",
623 port_dev->name);
Nikolay Aleksandrov15df5e72015-08-19 06:27:09 +0300624 goto out_fail;
David Ahern193125d2015-08-13 14:59:10 -0600625 }
626
Jiri Pirko29bf24a2015-12-03 12:12:11 +0100627 ret = netdev_master_upper_dev_link(port_dev, dev, NULL, NULL);
David Ahern193125d2015-08-13 14:59:10 -0600628 if (ret < 0)
629 goto out_unregister;
630
David Ahernfee6d4c2015-10-05 08:51:24 -0700631 port_dev->priv_flags |= IFF_L3MDEV_SLAVE;
David Ahern193125d2015-08-13 14:59:10 -0600632 cycle_netdev(port_dev);
633
634 return 0;
635
636out_unregister:
637 netdev_rx_handler_unregister(port_dev);
David Ahern193125d2015-08-13 14:59:10 -0600638out_fail:
David Ahern193125d2015-08-13 14:59:10 -0600639 return ret;
640}
641
642static int vrf_add_slave(struct net_device *dev, struct net_device *port_dev)
643{
David Ahernfee6d4c2015-10-05 08:51:24 -0700644 if (netif_is_l3_master(port_dev) || netif_is_l3_slave(port_dev))
David Ahern193125d2015-08-13 14:59:10 -0600645 return -EINVAL;
646
647 return do_vrf_add_slave(dev, port_dev);
648}
649
650/* inverse of do_vrf_add_slave */
651static int do_vrf_del_slave(struct net_device *dev, struct net_device *port_dev)
652{
David Ahern193125d2015-08-13 14:59:10 -0600653 netdev_upper_dev_unlink(port_dev, dev);
David Ahernfee6d4c2015-10-05 08:51:24 -0700654 port_dev->priv_flags &= ~IFF_L3MDEV_SLAVE;
David Ahern193125d2015-08-13 14:59:10 -0600655
656 netdev_rx_handler_unregister(port_dev);
657
David Ahern193125d2015-08-13 14:59:10 -0600658 cycle_netdev(port_dev);
659
David Ahern193125d2015-08-13 14:59:10 -0600660 return 0;
661}
662
663static int vrf_del_slave(struct net_device *dev, struct net_device *port_dev)
664{
David Ahern193125d2015-08-13 14:59:10 -0600665 return do_vrf_del_slave(dev, port_dev);
666}
667
668static void vrf_dev_uninit(struct net_device *dev)
669{
670 struct net_vrf *vrf = netdev_priv(dev);
Nikolay Aleksandrovbad53162015-11-24 14:29:16 +0100671 struct net_device *port_dev;
672 struct list_head *iter;
David Ahern193125d2015-08-13 14:59:10 -0600673
674 vrf_rtable_destroy(vrf);
David Ahern35402e32015-10-12 11:47:09 -0700675 vrf_rt6_destroy(vrf);
David Ahern193125d2015-08-13 14:59:10 -0600676
Nikolay Aleksandrovbad53162015-11-24 14:29:16 +0100677 netdev_for_each_lower_dev(dev, port_dev, iter)
678 vrf_del_slave(dev, port_dev);
David Ahern193125d2015-08-13 14:59:10 -0600679
Nikolay Aleksandrov3a4a27d2015-08-18 20:28:03 +0300680 free_percpu(dev->dstats);
David Ahern193125d2015-08-13 14:59:10 -0600681 dev->dstats = NULL;
682}
683
684static int vrf_dev_init(struct net_device *dev)
685{
686 struct net_vrf *vrf = netdev_priv(dev);
687
David Ahern193125d2015-08-13 14:59:10 -0600688 dev->dstats = netdev_alloc_pcpu_stats(struct pcpu_dstats);
689 if (!dev->dstats)
690 goto out_nomem;
691
692 /* create the default dst which points back to us */
693 vrf->rth = vrf_rtable_create(dev);
694 if (!vrf->rth)
695 goto out_stats;
696
David Ahern35402e32015-10-12 11:47:09 -0700697 if (vrf_rt6_create(dev) != 0)
698 goto out_rth;
699
David Ahern193125d2015-08-13 14:59:10 -0600700 dev->flags = IFF_MASTER | IFF_NOARP;
701
702 return 0;
703
David Ahern35402e32015-10-12 11:47:09 -0700704out_rth:
705 vrf_rtable_destroy(vrf);
David Ahern193125d2015-08-13 14:59:10 -0600706out_stats:
707 free_percpu(dev->dstats);
708 dev->dstats = NULL;
709out_nomem:
710 return -ENOMEM;
711}
712
713static const struct net_device_ops vrf_netdev_ops = {
714 .ndo_init = vrf_dev_init,
715 .ndo_uninit = vrf_dev_uninit,
716 .ndo_start_xmit = vrf_xmit,
717 .ndo_get_stats64 = vrf_get_stats64,
718 .ndo_add_slave = vrf_add_slave,
719 .ndo_del_slave = vrf_del_slave,
720};
721
David Ahernee15ee52015-09-29 20:07:12 -0700722static u32 vrf_fib_table(const struct net_device *dev)
723{
724 struct net_vrf *vrf = netdev_priv(dev);
725
726 return vrf->tb_id;
727}
728
729static struct rtable *vrf_get_rtable(const struct net_device *dev,
730 const struct flowi4 *fl4)
731{
732 struct rtable *rth = NULL;
733
David Ahern6e2895a2015-10-05 08:51:23 -0700734 if (!(fl4->flowi4_flags & FLOWI_FLAG_L3MDEV_SRC)) {
David Ahernee15ee52015-09-29 20:07:12 -0700735 struct net_vrf *vrf = netdev_priv(dev);
736
737 rth = vrf->rth;
738 atomic_inc(&rth->dst.__refcnt);
739 }
740
741 return rth;
742}
743
David Ahern8cbb512c2015-10-05 08:51:26 -0700744/* called under rcu_read_lock */
David Ahernb5bdacf2016-01-04 09:09:27 -0800745static int vrf_get_saddr(struct net_device *dev, struct flowi4 *fl4)
David Ahern8cbb512c2015-10-05 08:51:26 -0700746{
747 struct fib_result res = { .tclassid = 0 };
748 struct net *net = dev_net(dev);
749 u32 orig_tos = fl4->flowi4_tos;
750 u8 flags = fl4->flowi4_flags;
751 u8 scope = fl4->flowi4_scope;
752 u8 tos = RT_FL_TOS(fl4);
David Ahernb5bdacf2016-01-04 09:09:27 -0800753 int rc;
David Ahern8cbb512c2015-10-05 08:51:26 -0700754
755 if (unlikely(!fl4->daddr))
David Ahernb5bdacf2016-01-04 09:09:27 -0800756 return 0;
David Ahern8cbb512c2015-10-05 08:51:26 -0700757
758 fl4->flowi4_flags |= FLOWI_FLAG_SKIP_NH_OIF;
759 fl4->flowi4_iif = LOOPBACK_IFINDEX;
760 fl4->flowi4_tos = tos & IPTOS_RT_MASK;
761 fl4->flowi4_scope = ((tos & RTO_ONLINK) ?
762 RT_SCOPE_LINK : RT_SCOPE_UNIVERSE);
763
David Ahernb5bdacf2016-01-04 09:09:27 -0800764 rc = fib_lookup(net, fl4, &res, 0);
765 if (!rc) {
David Ahern8cbb512c2015-10-05 08:51:26 -0700766 if (res.type == RTN_LOCAL)
767 fl4->saddr = res.fi->fib_prefsrc ? : fl4->daddr;
768 else
769 fib_select_path(net, &res, fl4, -1);
770 }
771
772 fl4->flowi4_flags = flags;
773 fl4->flowi4_tos = orig_tos;
774 fl4->flowi4_scope = scope;
David Ahernb5bdacf2016-01-04 09:09:27 -0800775
776 return rc;
David Ahern8cbb512c2015-10-05 08:51:26 -0700777}
778
David Ahern35402e32015-10-12 11:47:09 -0700779#if IS_ENABLED(CONFIG_IPV6)
780static struct dst_entry *vrf_get_rt6_dst(const struct net_device *dev,
781 const struct flowi6 *fl6)
782{
783 struct rt6_info *rt = NULL;
784
785 if (!(fl6->flowi6_flags & FLOWI_FLAG_L3MDEV_SRC)) {
786 struct net_vrf *vrf = netdev_priv(dev);
787
788 rt = vrf->rt6;
789 atomic_inc(&rt->dst.__refcnt);
790 }
791
792 return (struct dst_entry *)rt;
793}
794#endif
795
David Ahernee15ee52015-09-29 20:07:12 -0700796static const struct l3mdev_ops vrf_l3mdev_ops = {
797 .l3mdev_fib_table = vrf_fib_table,
798 .l3mdev_get_rtable = vrf_get_rtable,
David Ahern8cbb512c2015-10-05 08:51:26 -0700799 .l3mdev_get_saddr = vrf_get_saddr,
David Ahern35402e32015-10-12 11:47:09 -0700800#if IS_ENABLED(CONFIG_IPV6)
801 .l3mdev_get_rt6_dst = vrf_get_rt6_dst,
802#endif
David Ahernee15ee52015-09-29 20:07:12 -0700803};
804
David Ahern193125d2015-08-13 14:59:10 -0600805static void vrf_get_drvinfo(struct net_device *dev,
806 struct ethtool_drvinfo *info)
807{
808 strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
809 strlcpy(info->version, DRV_VERSION, sizeof(info->version));
810}
811
812static const struct ethtool_ops vrf_ethtool_ops = {
813 .get_drvinfo = vrf_get_drvinfo,
814};
815
816static void vrf_setup(struct net_device *dev)
817{
818 ether_setup(dev);
819
820 /* Initialize the device structure. */
821 dev->netdev_ops = &vrf_netdev_ops;
David Ahernee15ee52015-09-29 20:07:12 -0700822 dev->l3mdev_ops = &vrf_l3mdev_ops;
David Ahern193125d2015-08-13 14:59:10 -0600823 dev->ethtool_ops = &vrf_ethtool_ops;
824 dev->destructor = free_netdev;
825
826 /* Fill in device structure with ethernet-generic values. */
827 eth_hw_addr_random(dev);
828
829 /* don't acquire vrf device's netif_tx_lock when transmitting */
830 dev->features |= NETIF_F_LLTX;
831
832 /* don't allow vrf devices to change network namespaces. */
833 dev->features |= NETIF_F_NETNS_LOCAL;
834}
835
836static int vrf_validate(struct nlattr *tb[], struct nlattr *data[])
837{
838 if (tb[IFLA_ADDRESS]) {
839 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
840 return -EINVAL;
841 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
842 return -EADDRNOTAVAIL;
843 }
844 return 0;
845}
846
847static void vrf_dellink(struct net_device *dev, struct list_head *head)
848{
David Ahern193125d2015-08-13 14:59:10 -0600849 unregister_netdevice_queue(dev, head);
850}
851
852static int vrf_newlink(struct net *src_net, struct net_device *dev,
853 struct nlattr *tb[], struct nlattr *data[])
854{
855 struct net_vrf *vrf = netdev_priv(dev);
David Ahern193125d2015-08-13 14:59:10 -0600856
857 if (!data || !data[IFLA_VRF_TABLE])
858 return -EINVAL;
859
860 vrf->tb_id = nla_get_u32(data[IFLA_VRF_TABLE]);
861
David Ahern007979e2015-09-29 20:07:10 -0700862 dev->priv_flags |= IFF_L3MDEV_MASTER;
David Ahern193125d2015-08-13 14:59:10 -0600863
Nikolay Aleksandrov7f109f72015-11-21 19:46:19 +0100864 return register_netdevice(dev);
David Ahern193125d2015-08-13 14:59:10 -0600865}
866
867static size_t vrf_nl_getsize(const struct net_device *dev)
868{
869 return nla_total_size(sizeof(u32)); /* IFLA_VRF_TABLE */
870}
871
872static int vrf_fillinfo(struct sk_buff *skb,
873 const struct net_device *dev)
874{
875 struct net_vrf *vrf = netdev_priv(dev);
876
877 return nla_put_u32(skb, IFLA_VRF_TABLE, vrf->tb_id);
878}
879
880static const struct nla_policy vrf_nl_policy[IFLA_VRF_MAX + 1] = {
881 [IFLA_VRF_TABLE] = { .type = NLA_U32 },
882};
883
884static struct rtnl_link_ops vrf_link_ops __read_mostly = {
885 .kind = DRV_NAME,
886 .priv_size = sizeof(struct net_vrf),
887
888 .get_size = vrf_nl_getsize,
889 .policy = vrf_nl_policy,
890 .validate = vrf_validate,
891 .fill_info = vrf_fillinfo,
892
893 .newlink = vrf_newlink,
894 .dellink = vrf_dellink,
895 .setup = vrf_setup,
896 .maxtype = IFLA_VRF_MAX,
897};
898
899static int vrf_device_event(struct notifier_block *unused,
900 unsigned long event, void *ptr)
901{
902 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
903
904 /* only care about unregister events to drop slave references */
905 if (event == NETDEV_UNREGISTER) {
David Ahern193125d2015-08-13 14:59:10 -0600906 struct net_device *vrf_dev;
907
David Ahernfee6d4c2015-10-05 08:51:24 -0700908 if (!netif_is_l3_slave(dev))
David Ahern193125d2015-08-13 14:59:10 -0600909 goto out;
910
Nikolay Aleksandrov58aa9082015-08-18 20:28:04 +0300911 vrf_dev = netdev_master_upper_dev_get(dev);
912 vrf_del_slave(vrf_dev, dev);
David Ahern193125d2015-08-13 14:59:10 -0600913 }
914out:
915 return NOTIFY_DONE;
916}
917
918static struct notifier_block vrf_notifier_block __read_mostly = {
919 .notifier_call = vrf_device_event,
920};
921
922static int __init vrf_init_module(void)
923{
924 int rc;
925
926 vrf_dst_ops.kmem_cachep =
927 kmem_cache_create("vrf_ip_dst_cache",
928 sizeof(struct rtable), 0,
Nikolay Aleksandrove367da02015-08-19 06:27:07 +0300929 SLAB_HWCACHE_ALIGN,
David Ahern193125d2015-08-13 14:59:10 -0600930 NULL);
931
932 if (!vrf_dst_ops.kmem_cachep)
933 return -ENOMEM;
934
David Ahern35402e32015-10-12 11:47:09 -0700935 rc = init_dst_ops6_kmem_cachep();
936 if (rc != 0)
937 goto error2;
938
David Ahern193125d2015-08-13 14:59:10 -0600939 register_netdevice_notifier(&vrf_notifier_block);
940
941 rc = rtnl_link_register(&vrf_link_ops);
942 if (rc < 0)
943 goto error;
944
945 return 0;
946
947error:
948 unregister_netdevice_notifier(&vrf_notifier_block);
David Ahern35402e32015-10-12 11:47:09 -0700949 free_dst_ops6_kmem_cachep();
950error2:
David Ahern193125d2015-08-13 14:59:10 -0600951 kmem_cache_destroy(vrf_dst_ops.kmem_cachep);
952 return rc;
953}
954
955static void __exit vrf_cleanup_module(void)
956{
957 rtnl_link_unregister(&vrf_link_ops);
958 unregister_netdevice_notifier(&vrf_notifier_block);
959 kmem_cache_destroy(vrf_dst_ops.kmem_cachep);
David Ahern35402e32015-10-12 11:47:09 -0700960 free_dst_ops6_kmem_cachep();
David Ahern193125d2015-08-13 14:59:10 -0600961}
962
963module_init(vrf_init_module);
964module_exit(vrf_cleanup_module);
965MODULE_AUTHOR("Shrijeet Mukherjee, David Ahern");
966MODULE_DESCRIPTION("Device driver to instantiate VRF domains");
967MODULE_LICENSE("GPL");
968MODULE_ALIAS_RTNL_LINK(DRV_NAME);
969MODULE_VERSION(DRV_VERSION);