| 1 |
// SPDX-License-Identifier: GPL-2.0-or-later |
| 2 |
/* |
| 3 |
* Bridge per vlan tunnel port dst_metadata netlink control interface |
| 4 |
* |
| 5 |
* Authors: |
| 6 |
* Roopa Prabhu <[email protected]> |
| 7 |
*/ |
| 8 |
|
| 9 |
#include <linux/kernel.h> |
| 10 |
#include <linux/slab.h> |
| 11 |
#include <linux/etherdevice.h> |
| 12 |
#include <net/rtnetlink.h> |
| 13 |
#include <net/net_namespace.h> |
| 14 |
#include <net/sock.h> |
| 15 |
#include <uapi/linux/if_bridge.h> |
| 16 |
#include <net/dst_metadata.h> |
| 17 |
|
| 18 |
#include "br_private.h" |
| 19 |
#include "br_private_tunnel.h" |
| 20 |
|
| 21 |
static size_t __get_vlan_tinfo_size(void) |
| 22 |
{ |
| 23 |
return nla_total_size(0) + /* nest IFLA_BRIDGE_VLAN_TUNNEL_INFO */ |
| 24 |
nla_total_size(sizeof(u32)) + /* IFLA_BRIDGE_VLAN_TUNNEL_ID */ |
| 25 |
nla_total_size(sizeof(u16)) + /* IFLA_BRIDGE_VLAN_TUNNEL_VID */ |
| 26 |
nla_total_size(sizeof(u16)); /* IFLA_BRIDGE_VLAN_TUNNEL_FLAGS */ |
| 27 |
} |
| 28 |
|
| 29 |
bool vlan_tunid_inrange(const struct net_bridge_vlan *v_curr, |
| 30 |
const struct net_bridge_vlan *v_last) |
| 31 |
{ |
| 32 |
__be32 tunid_curr = tunnel_id_to_key32(v_curr->tinfo.tunnel_id); |
| 33 |
__be32 tunid_last = tunnel_id_to_key32(v_last->tinfo.tunnel_id); |
| 34 |
|
| 35 |
return (be32_to_cpu(tunid_curr) - be32_to_cpu(tunid_last)) == 1; |
| 36 |
} |
| 37 |
|
| 38 |
static int __get_num_vlan_tunnel_infos(struct net_bridge_vlan_group *vg) |
| 39 |
{ |
| 40 |
struct net_bridge_vlan *v, *vtbegin = NULL, *vtend = NULL; |
| 41 |
int num_tinfos = 0; |
| 42 |
|
| 43 |
/* Count number of vlan infos */ |
| 44 |
list_for_each_entry_rcu(v, &vg->vlan_list, vlist) { |
| 45 |
/* only a context, bridge vlan not activated */ |
| 46 |
if (!br_vlan_should_use(v) || !v->tinfo.tunnel_id) |
| 47 |
continue; |
| 48 |
|
| 49 |
if (!vtbegin) { |
| 50 |
goto initvars; |
| 51 |
} else if ((v->vid - vtend->vid) == 1 && |
| 52 |
vlan_tunid_inrange(v, vtend)) { |
| 53 |
vtend = v; |
| 54 |
continue; |
| 55 |
} else { |
| 56 |
if ((vtend->vid - vtbegin->vid) > 0) |
| 57 |
num_tinfos += 2; |
| 58 |
else |
| 59 |
num_tinfos += 1; |
| 60 |
} |
| 61 |
initvars: |
| 62 |
vtbegin = v; |
| 63 |
vtend = v; |
| 64 |
} |
| 65 |
|
| 66 |
if (vtbegin && vtend) { |
| 67 |
if ((vtend->vid - vtbegin->vid) > 0) |
| 68 |
num_tinfos += 2; |
| 69 |
else |
| 70 |
num_tinfos += 1; |
| 71 |
} |
| 72 |
|
| 73 |
return num_tinfos; |
| 74 |
} |
| 75 |
|
| 76 |
int br_get_vlan_tunnel_info_size(struct net_bridge_vlan_group *vg) |
| 77 |
{ |
| 78 |
int num_tinfos; |
| 79 |
|
| 80 |
if (!vg) |
| 81 |
return 0; |
| 82 |
|
| 83 |
rcu_read_lock(); |
| 84 |
num_tinfos = __get_num_vlan_tunnel_infos(vg); |
| 85 |
rcu_read_unlock(); |
| 86 |
|
| 87 |
return num_tinfos * __get_vlan_tinfo_size(); |
| 88 |
} |
| 89 |
|
| 90 |
static int br_fill_vlan_tinfo(struct sk_buff *skb, u16 vid, |
| 91 |
__be64 tunnel_id, u16 flags) |
| 92 |
{ |
| 93 |
__be32 tid = tunnel_id_to_key32(tunnel_id); |
| 94 |
struct nlattr *tmap; |
| 95 |
|
| 96 |
tmap = nla_nest_start_noflag(skb, IFLA_BRIDGE_VLAN_TUNNEL_INFO); |
| 97 |
if (!tmap) |
| 98 |
return -EMSGSIZE; |
| 99 |
if (nla_put_u32(skb, IFLA_BRIDGE_VLAN_TUNNEL_ID, |
| 100 |
be32_to_cpu(tid))) |
| 101 |
goto nla_put_failure; |
| 102 |
if (nla_put_u16(skb, IFLA_BRIDGE_VLAN_TUNNEL_VID, |
| 103 |
vid)) |
| 104 |
goto nla_put_failure; |
| 105 |
if (nla_put_u16(skb, IFLA_BRIDGE_VLAN_TUNNEL_FLAGS, |
| 106 |
flags)) |
| 107 |
goto nla_put_failure; |
| 108 |
nla_nest_end(skb, tmap); |
| 109 |
|
| 110 |
return 0; |
| 111 |
|
| 112 |
nla_put_failure: |
| 113 |
nla_nest_cancel(skb, tmap); |
| 114 |
|
| 115 |
return -EMSGSIZE; |
| 116 |
} |
| 117 |
|
| 118 |
static int br_fill_vlan_tinfo_range(struct sk_buff *skb, |
| 119 |
struct net_bridge_vlan *vtbegin, |
| 120 |
struct net_bridge_vlan *vtend) |
| 121 |
{ |
| 122 |
int err; |
| 123 |
|
| 124 |
if (vtend && (vtend->vid - vtbegin->vid) > 0) { |
| 125 |
/* add range to skb */ |
| 126 |
err = br_fill_vlan_tinfo(skb, vtbegin->vid, |
| 127 |
vtbegin->tinfo.tunnel_id, |
| 128 |
BRIDGE_VLAN_INFO_RANGE_BEGIN); |
| 129 |
if (err) |
| 130 |
return err; |
| 131 |
|
| 132 |
err = br_fill_vlan_tinfo(skb, vtend->vid, |
| 133 |
vtend->tinfo.tunnel_id, |
| 134 |
BRIDGE_VLAN_INFO_RANGE_END); |
| 135 |
if (err) |
| 136 |
return err; |
| 137 |
} else { |
| 138 |
err = br_fill_vlan_tinfo(skb, vtbegin->vid, |
| 139 |
vtbegin->tinfo.tunnel_id, |
| 140 |
0); |
| 141 |
if (err) |
| 142 |
return err; |
| 143 |
} |
| 144 |
|
| 145 |
return 0; |
| 146 |
} |
| 147 |
|
| 148 |
int br_fill_vlan_tunnel_info(struct sk_buff *skb, |
| 149 |
struct net_bridge_vlan_group *vg) |
| 150 |
{ |
| 151 |
struct net_bridge_vlan *vtbegin = NULL; |
| 152 |
struct net_bridge_vlan *vtend = NULL; |
| 153 |
struct net_bridge_vlan *v; |
| 154 |
int err; |
| 155 |
|
| 156 |
/* Count number of vlan infos */ |
| 157 |
list_for_each_entry_rcu(v, &vg->vlan_list, vlist) { |
| 158 |
/* only a context, bridge vlan not activated */ |
| 159 |
if (!br_vlan_should_use(v)) |
| 160 |
continue; |
| 161 |
|
| 162 |
if (!v->tinfo.tunnel_dst) |
| 163 |
continue; |
| 164 |
|
| 165 |
if (!vtbegin) { |
| 166 |
goto initvars; |
| 167 |
} else if ((v->vid - vtend->vid) == 1 && |
| 168 |
vlan_tunid_inrange(v, vtend)) { |
| 169 |
vtend = v; |
| 170 |
continue; |
| 171 |
} else { |
| 172 |
err = br_fill_vlan_tinfo_range(skb, vtbegin, vtend); |
| 173 |
if (err) |
| 174 |
return err; |
| 175 |
} |
| 176 |
initvars: |
| 177 |
vtbegin = v; |
| 178 |
vtend = v; |
| 179 |
} |
| 180 |
|
| 181 |
if (vtbegin) { |
| 182 |
err = br_fill_vlan_tinfo_range(skb, vtbegin, vtend); |
| 183 |
if (err) |
| 184 |
return err; |
| 185 |
} |
| 186 |
|
| 187 |
return 0; |
| 188 |
} |
| 189 |
|
| 190 |
static const struct nla_policy vlan_tunnel_policy[IFLA_BRIDGE_VLAN_TUNNEL_MAX + 1] = { |
| 191 |
[IFLA_BRIDGE_VLAN_TUNNEL_UNSPEC] = { |
| 192 |
.strict_start_type = IFLA_BRIDGE_VLAN_TUNNEL_FLAGS + 1 |
| 193 |
}, |
| 194 |
[IFLA_BRIDGE_VLAN_TUNNEL_ID] = { .type = NLA_U32 }, |
| 195 |
[IFLA_BRIDGE_VLAN_TUNNEL_VID] = { .type = NLA_U16 }, |
| 196 |
[IFLA_BRIDGE_VLAN_TUNNEL_FLAGS] = { .type = NLA_U16 }, |
| 197 |
}; |
| 198 |
|
| 199 |
int br_vlan_tunnel_info(const struct net_bridge_port *p, int cmd, |
| 200 |
u16 vid, u32 tun_id, bool *changed) |
| 201 |
{ |
| 202 |
int err = 0; |
| 203 |
|
| 204 |
if (!p) |
| 205 |
return -EINVAL; |
| 206 |
|
| 207 |
switch (cmd) { |
| 208 |
case RTM_SETLINK: |
| 209 |
err = nbp_vlan_tunnel_info_add(p, vid, tun_id); |
| 210 |
if (!err) |
| 211 |
*changed = true; |
| 212 |
break; |
| 213 |
case RTM_DELLINK: |
| 214 |
if (!nbp_vlan_tunnel_info_delete(p, vid)) |
| 215 |
*changed = true; |
| 216 |
break; |
| 217 |
} |
| 218 |
|
| 219 |
return err; |
| 220 |
} |
| 221 |
|
| 222 |
int br_parse_vlan_tunnel_info(struct nlattr *attr, |
| 223 |
struct vtunnel_info *tinfo) |
| 224 |
{ |
| 225 |
struct nlattr *tb[IFLA_BRIDGE_VLAN_TUNNEL_MAX + 1]; |
| 226 |
u32 tun_id; |
| 227 |
u16 vid, flags = 0; |
| 228 |
int err; |
| 229 |
|
| 230 |
memset(tinfo, 0, sizeof(*tinfo)); |
| 231 |
|
| 232 |
err = nla_parse_nested_deprecated(tb, IFLA_BRIDGE_VLAN_TUNNEL_MAX, |
| 233 |
attr, vlan_tunnel_policy, NULL); |
| 234 |
if (err < 0) |
| 235 |
return err; |
| 236 |
|
| 237 |
if (!tb[IFLA_BRIDGE_VLAN_TUNNEL_ID] || |
| 238 |
!tb[IFLA_BRIDGE_VLAN_TUNNEL_VID]) |
| 239 |
return -EINVAL; |
| 240 |
|
| 241 |
tun_id = nla_get_u32(tb[IFLA_BRIDGE_VLAN_TUNNEL_ID]); |
| 242 |
vid = nla_get_u16(tb[IFLA_BRIDGE_VLAN_TUNNEL_VID]); |
| 243 |
if (vid >= VLAN_VID_MASK) |
| 244 |
return -ERANGE; |
| 245 |
|
| 246 |
if (tb[IFLA_BRIDGE_VLAN_TUNNEL_FLAGS]) |
| 247 |
flags = nla_get_u16(tb[IFLA_BRIDGE_VLAN_TUNNEL_FLAGS]); |
| 248 |
|
| 249 |
tinfo->tunid = tun_id; |
| 250 |
tinfo->vid = vid; |
| 251 |
tinfo->flags = flags; |
| 252 |
|
| 253 |
return 0; |
| 254 |
} |
| 255 |
|
| 256 |
/* send a notification if v_curr can't enter the range and start a new one */ |
| 257 |
static void __vlan_tunnel_handle_range(const struct net_bridge_port *p, |
| 258 |
struct net_bridge_vlan **v_start, |
| 259 |
struct net_bridge_vlan **v_end, |
| 260 |
int v_curr, bool curr_change) |
| 261 |
{ |
| 262 |
struct net_bridge_vlan_group *vg; |
| 263 |
struct net_bridge_vlan *v; |
| 264 |
|
| 265 |
vg = nbp_vlan_group(p); |
| 266 |
if (!vg) |
| 267 |
return; |
| 268 |
|
| 269 |
v = br_vlan_find(vg, v_curr); |
| 270 |
|
| 271 |
if (!*v_start) |
| 272 |
goto out_init; |
| 273 |
|
| 274 |
if (v && curr_change && br_vlan_can_enter_range(v, *v_end)) { |
| 275 |
*v_end = v; |
| 276 |
return; |
| 277 |
} |
| 278 |
|
| 279 |
br_vlan_notify(p->br, p, (*v_start)->vid, (*v_end)->vid, RTM_NEWVLAN); |
| 280 |
out_init: |
| 281 |
/* we start a range only if there are any changes to notify about */ |
| 282 |
*v_start = curr_change ? v : NULL; |
| 283 |
*v_end = *v_start; |
| 284 |
} |
| 285 |
|
| 286 |
int br_process_vlan_tunnel_info(const struct net_bridge *br, |
| 287 |
const struct net_bridge_port *p, int cmd, |
| 288 |
struct vtunnel_info *tinfo_curr, |
| 289 |
struct vtunnel_info *tinfo_last, |
| 290 |
bool *changed) |
| 291 |
{ |
| 292 |
int err; |
| 293 |
|
| 294 |
if (tinfo_curr->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) { |
| 295 |
if (tinfo_last->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN) |
| 296 |
return -EINVAL; |
| 297 |
memcpy(tinfo_last, tinfo_curr, sizeof(struct vtunnel_info)); |
| 298 |
} else if (tinfo_curr->flags & BRIDGE_VLAN_INFO_RANGE_END) { |
| 299 |
struct net_bridge_vlan *v_start = NULL, *v_end = NULL; |
| 300 |
int t, v; |
| 301 |
|
| 302 |
if (!(tinfo_last->flags & BRIDGE_VLAN_INFO_RANGE_BEGIN)) |
| 303 |
return -EINVAL; |
| 304 |
if ((tinfo_curr->vid - tinfo_last->vid) != |
| 305 |
(tinfo_curr->tunid - tinfo_last->tunid)) |
| 306 |
return -EINVAL; |
| 307 |
t = tinfo_last->tunid; |
| 308 |
for (v = tinfo_last->vid; v <= tinfo_curr->vid; v++) { |
| 309 |
bool curr_change = false; |
| 310 |
|
| 311 |
err = br_vlan_tunnel_info(p, cmd, v, t, &curr_change); |
| 312 |
if (err) |
| 313 |
break; |
| 314 |
t++; |
| 315 |
|
| 316 |
if (curr_change) |
| 317 |
*changed = curr_change; |
| 318 |
__vlan_tunnel_handle_range(p, &v_start, &v_end, v, |
| 319 |
curr_change); |
| 320 |
} |
| 321 |
if (v_start && v_end) |
| 322 |
br_vlan_notify(br, p, v_start->vid, v_end->vid, |
| 323 |
RTM_NEWVLAN); |
| 324 |
if (err) |
| 325 |
return err; |
| 326 |
|
| 327 |
memset(tinfo_last, 0, sizeof(struct vtunnel_info)); |
| 328 |
memset(tinfo_curr, 0, sizeof(struct vtunnel_info)); |
| 329 |
} else { |
| 330 |
if (tinfo_last->flags) |
| 331 |
return -EINVAL; |
| 332 |
err = br_vlan_tunnel_info(p, cmd, tinfo_curr->vid, |
| 333 |
tinfo_curr->tunid, changed); |
| 334 |
if (err) |
| 335 |
return err; |
| 336 |
br_vlan_notify(br, p, tinfo_curr->vid, 0, RTM_NEWVLAN); |
| 337 |
memset(tinfo_last, 0, sizeof(struct vtunnel_info)); |
| 338 |
memset(tinfo_curr, 0, sizeof(struct vtunnel_info)); |
| 339 |
} |
| 340 |
|
| 341 |
return 0; |
| 342 |
} |