Loading...
1/*
2 * net/l3mdev/l3mdev.c - L3 master device implementation
3 * Copyright (c) 2015 Cumulus Networks
4 * Copyright (c) 2015 David Ahern <dsa@cumulusnetworks.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 */
11
12#include <linux/netdevice.h>
13#include <net/l3mdev.h>
14
15/**
16 * l3mdev_master_ifindex - get index of L3 master device
17 * @dev: targeted interface
18 */
19
20int l3mdev_master_ifindex_rcu(const struct net_device *dev)
21{
22 int ifindex = 0;
23
24 if (!dev)
25 return 0;
26
27 if (netif_is_l3_master(dev)) {
28 ifindex = dev->ifindex;
29 } else if (netif_is_l3_slave(dev)) {
30 struct net_device *master;
31 struct net_device *_dev = (struct net_device *)dev;
32
33 /* netdev_master_upper_dev_get_rcu calls
34 * list_first_or_null_rcu to walk the upper dev list.
35 * list_first_or_null_rcu does not handle a const arg. We aren't
36 * making changes, just want the master device from that list so
37 * typecast to remove the const
38 */
39 master = netdev_master_upper_dev_get_rcu(_dev);
40 if (master)
41 ifindex = master->ifindex;
42 }
43
44 return ifindex;
45}
46EXPORT_SYMBOL_GPL(l3mdev_master_ifindex_rcu);
47
48/**
49 * l3mdev_fib_table - get FIB table id associated with an L3
50 * master interface
51 * @dev: targeted interface
52 */
53
54u32 l3mdev_fib_table_rcu(const struct net_device *dev)
55{
56 u32 tb_id = 0;
57
58 if (!dev)
59 return 0;
60
61 if (netif_is_l3_master(dev)) {
62 if (dev->l3mdev_ops->l3mdev_fib_table)
63 tb_id = dev->l3mdev_ops->l3mdev_fib_table(dev);
64 } else if (netif_is_l3_slave(dev)) {
65 /* Users of netdev_master_upper_dev_get_rcu need non-const,
66 * but current inet_*type functions take a const
67 */
68 struct net_device *_dev = (struct net_device *) dev;
69 const struct net_device *master;
70
71 master = netdev_master_upper_dev_get_rcu(_dev);
72 if (master &&
73 master->l3mdev_ops->l3mdev_fib_table)
74 tb_id = master->l3mdev_ops->l3mdev_fib_table(master);
75 }
76
77 return tb_id;
78}
79EXPORT_SYMBOL_GPL(l3mdev_fib_table_rcu);
80
81u32 l3mdev_fib_table_by_index(struct net *net, int ifindex)
82{
83 struct net_device *dev;
84 u32 tb_id = 0;
85
86 if (!ifindex)
87 return 0;
88
89 rcu_read_lock();
90
91 dev = dev_get_by_index_rcu(net, ifindex);
92 if (dev)
93 tb_id = l3mdev_fib_table_rcu(dev);
94
95 rcu_read_unlock();
96
97 return tb_id;
98}
99EXPORT_SYMBOL_GPL(l3mdev_fib_table_by_index);
1/*
2 * net/l3mdev/l3mdev.c - L3 master device implementation
3 * Copyright (c) 2015 Cumulus Networks
4 * Copyright (c) 2015 David Ahern <dsa@cumulusnetworks.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 */
11
12#include <linux/netdevice.h>
13#include <net/fib_rules.h>
14#include <net/l3mdev.h>
15
16/**
17 * l3mdev_master_ifindex - get index of L3 master device
18 * @dev: targeted interface
19 */
20
21int l3mdev_master_ifindex_rcu(const struct net_device *dev)
22{
23 int ifindex = 0;
24
25 if (!dev)
26 return 0;
27
28 if (netif_is_l3_master(dev)) {
29 ifindex = dev->ifindex;
30 } else if (netif_is_l3_slave(dev)) {
31 struct net_device *master;
32 struct net_device *_dev = (struct net_device *)dev;
33
34 /* netdev_master_upper_dev_get_rcu calls
35 * list_first_or_null_rcu to walk the upper dev list.
36 * list_first_or_null_rcu does not handle a const arg. We aren't
37 * making changes, just want the master device from that list so
38 * typecast to remove the const
39 */
40 master = netdev_master_upper_dev_get_rcu(_dev);
41 if (master)
42 ifindex = master->ifindex;
43 }
44
45 return ifindex;
46}
47EXPORT_SYMBOL_GPL(l3mdev_master_ifindex_rcu);
48
49/**
50 * l3mdev_fib_table - get FIB table id associated with an L3
51 * master interface
52 * @dev: targeted interface
53 */
54
55u32 l3mdev_fib_table_rcu(const struct net_device *dev)
56{
57 u32 tb_id = 0;
58
59 if (!dev)
60 return 0;
61
62 if (netif_is_l3_master(dev)) {
63 if (dev->l3mdev_ops->l3mdev_fib_table)
64 tb_id = dev->l3mdev_ops->l3mdev_fib_table(dev);
65 } else if (netif_is_l3_slave(dev)) {
66 /* Users of netdev_master_upper_dev_get_rcu need non-const,
67 * but current inet_*type functions take a const
68 */
69 struct net_device *_dev = (struct net_device *) dev;
70 const struct net_device *master;
71
72 master = netdev_master_upper_dev_get_rcu(_dev);
73 if (master &&
74 master->l3mdev_ops->l3mdev_fib_table)
75 tb_id = master->l3mdev_ops->l3mdev_fib_table(master);
76 }
77
78 return tb_id;
79}
80EXPORT_SYMBOL_GPL(l3mdev_fib_table_rcu);
81
82u32 l3mdev_fib_table_by_index(struct net *net, int ifindex)
83{
84 struct net_device *dev;
85 u32 tb_id = 0;
86
87 if (!ifindex)
88 return 0;
89
90 rcu_read_lock();
91
92 dev = dev_get_by_index_rcu(net, ifindex);
93 if (dev)
94 tb_id = l3mdev_fib_table_rcu(dev);
95
96 rcu_read_unlock();
97
98 return tb_id;
99}
100EXPORT_SYMBOL_GPL(l3mdev_fib_table_by_index);
101
102/**
103 * l3mdev_link_scope_lookup - IPv6 route lookup based on flow for link
104 * local and multicast addresses
105 * @net: network namespace for device index lookup
106 * @fl6: IPv6 flow struct for lookup
107 */
108
109struct dst_entry *l3mdev_link_scope_lookup(struct net *net,
110 struct flowi6 *fl6)
111{
112 struct dst_entry *dst = NULL;
113 struct net_device *dev;
114
115 if (fl6->flowi6_oif) {
116 rcu_read_lock();
117
118 dev = dev_get_by_index_rcu(net, fl6->flowi6_oif);
119 if (dev && netif_is_l3_slave(dev))
120 dev = netdev_master_upper_dev_get_rcu(dev);
121
122 if (dev && netif_is_l3_master(dev) &&
123 dev->l3mdev_ops->l3mdev_link_scope_lookup)
124 dst = dev->l3mdev_ops->l3mdev_link_scope_lookup(dev, fl6);
125
126 rcu_read_unlock();
127 }
128
129 return dst;
130}
131EXPORT_SYMBOL_GPL(l3mdev_link_scope_lookup);
132
133/**
134 * l3mdev_fib_rule_match - Determine if flowi references an
135 * L3 master device
136 * @net: network namespace for device index lookup
137 * @fl: flow struct
138 */
139
140int l3mdev_fib_rule_match(struct net *net, struct flowi *fl,
141 struct fib_lookup_arg *arg)
142{
143 struct net_device *dev;
144 int rc = 0;
145
146 rcu_read_lock();
147
148 dev = dev_get_by_index_rcu(net, fl->flowi_oif);
149 if (dev && netif_is_l3_master(dev) &&
150 dev->l3mdev_ops->l3mdev_fib_table) {
151 arg->table = dev->l3mdev_ops->l3mdev_fib_table(dev);
152 rc = 1;
153 goto out;
154 }
155
156 dev = dev_get_by_index_rcu(net, fl->flowi_iif);
157 if (dev && netif_is_l3_master(dev) &&
158 dev->l3mdev_ops->l3mdev_fib_table) {
159 arg->table = dev->l3mdev_ops->l3mdev_fib_table(dev);
160 rc = 1;
161 goto out;
162 }
163
164out:
165 rcu_read_unlock();
166
167 return rc;
168}
169
170void l3mdev_update_flow(struct net *net, struct flowi *fl)
171{
172 struct net_device *dev;
173 int ifindex;
174
175 rcu_read_lock();
176
177 if (fl->flowi_oif) {
178 dev = dev_get_by_index_rcu(net, fl->flowi_oif);
179 if (dev) {
180 ifindex = l3mdev_master_ifindex_rcu(dev);
181 if (ifindex) {
182 fl->flowi_oif = ifindex;
183 fl->flowi_flags |= FLOWI_FLAG_SKIP_NH_OIF;
184 goto out;
185 }
186 }
187 }
188
189 if (fl->flowi_iif) {
190 dev = dev_get_by_index_rcu(net, fl->flowi_iif);
191 if (dev) {
192 ifindex = l3mdev_master_ifindex_rcu(dev);
193 if (ifindex) {
194 fl->flowi_iif = ifindex;
195 fl->flowi_flags |= FLOWI_FLAG_SKIP_NH_OIF;
196 }
197 }
198 }
199
200out:
201 rcu_read_unlock();
202}
203EXPORT_SYMBOL_GPL(l3mdev_update_flow);