1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Forwarding decision 4 * Linux ethernet bridge 5 * 6 * Authors: 7 * Lennert Buytenhek <buytenh@gnu.org> 8 */ 9 10 #include <linux/slab.h> 11 #include <linux/kernel.h> 12 #include <linux/netdevice.h> 13 #include <linux/netpoll.h> 14 #include <linux/skbuff.h> 15 #include <linux/if_vlan.h> 16 #include <linux/netfilter_bridge.h> 17 #include "br_private.h" 18 19 struct br_fwd_dst { 20 struct net_bridge_port *port; 21 struct net_bridge_vlan *vlan; 22 }; 23 24 static bool should_deliver_vlan(const struct br_fwd_dst *fwd, 25 const struct sk_buff *skb) 26 { 27 if (fwd->vlan) 28 return br_vlan_state_allowed(br_vlan_get_state(fwd->vlan), 29 false); 30 31 return br_allowed_egress(nbp_vlan_group_rcu(fwd->port), skb); 32 } 33 34 /* Don't forward packets to originating port or forwarding disabled */ 35 static __always_inline bool should_deliver(const struct br_fwd_dst *fwd, 36 const struct sk_buff *skb) 37 { 38 const struct net_bridge_port *p = fwd->port; 39 40 return (test_bit(BR_HAIRPIN_MODE_BIT, &p->flags) || skb->dev != p->dev) && 41 (br_mst_is_enabled(p) || p->state == BR_STATE_FORWARDING) && 42 should_deliver_vlan(fwd, skb) && 43 nbp_switchdev_allowed_egress(p, skb) && 44 !br_skb_isolated(p, skb); 45 } 46 47 int br_dev_queue_push_xmit(struct net *net, struct sock *sk, struct sk_buff *skb) 48 { 49 skb_push(skb, ETH_HLEN); 50 if (!is_skb_forwardable(skb->dev, skb)) 51 goto drop; 52 53 br_drop_fake_rtable(skb); 54 55 if (skb->ip_summed == CHECKSUM_PARTIAL && 56 eth_type_vlan(skb->protocol)) { 57 int depth; 58 59 if (!vlan_get_protocol_and_depth(skb, skb->protocol, &depth)) 60 goto drop; 61 62 skb_set_network_header(skb, depth); 63 } 64 65 br_switchdev_frame_set_offload_fwd_mark(skb); 66 67 dev_queue_xmit(skb); 68 69 return 0; 70 71 drop: 72 kfree_skb(skb); 73 return 0; 74 } 75 EXPORT_SYMBOL_GPL(br_dev_queue_push_xmit); 76 77 int br_forward_finish(struct net *net, struct sock *sk, struct sk_buff *skb) 78 { 79 skb_clear_tstamp(skb); 80 return NF_HOOK(NFPROTO_BRIDGE, NF_BR_POST_ROUTING, 81 net, sk, skb, NULL, skb->dev, 82 br_dev_queue_push_xmit); 83 84 } 85 EXPORT_SYMBOL_GPL(br_forward_finish); 86 87 static void __br_forward(const struct br_fwd_dst *fwd, 88 struct sk_buff *skb, bool local_orig) 89 { 90 const struct net_bridge_port *to = fwd->port; 91 struct net_bridge_vlan_group *vg; 92 struct net_device *indev; 93 struct net *net; 94 int br_hook; 95 96 /* Mark the skb for forwarding offload early so that br_handle_vlan() 97 * can know whether to pop the VLAN header on egress or keep it. 98 */ 99 nbp_switchdev_frame_mark_tx_fwd_offload(to, skb); 100 101 vg = fwd->vlan ? NULL : nbp_vlan_group_rcu(to); 102 skb = br_handle_vlan(to->br, to, vg, fwd->vlan, skb); 103 if (!skb) 104 return; 105 106 indev = skb->dev; 107 skb->dev = to->dev; 108 if (!local_orig) { 109 if (skb_warn_if_lro(skb)) { 110 kfree_skb(skb); 111 return; 112 } 113 br_hook = NF_BR_FORWARD; 114 skb_forward_csum(skb); 115 net = dev_net(indev); 116 } else { 117 if (unlikely(netpoll_tx_running(to->br->dev))) { 118 skb_push(skb, ETH_HLEN); 119 if (!is_skb_forwardable(skb->dev, skb)) 120 kfree_skb(skb); 121 else 122 br_netpoll_send_skb(to, skb); 123 return; 124 } 125 br_hook = NF_BR_LOCAL_OUT; 126 net = dev_net(skb->dev); 127 indev = NULL; 128 } 129 130 NF_HOOK(NFPROTO_BRIDGE, br_hook, 131 net, NULL, skb, indev, skb->dev, 132 br_forward_finish); 133 } 134 135 static int deliver_clone(const struct br_fwd_dst *fwd, 136 struct sk_buff *skb, bool local_orig) 137 { 138 struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev; 139 140 skb = skb_clone(skb, GFP_ATOMIC); 141 if (!skb) { 142 DEV_STATS_INC(dev, tx_dropped); 143 return -ENOMEM; 144 } 145 146 __br_forward(fwd, skb, local_orig); 147 return 0; 148 } 149 150 /** 151 * br_forward - forward a packet to a specific port 152 * @dst: bridge destination 153 * @skb: packet being forwarded 154 * @local_rcv: packet will be received locally after forwarding 155 * @local_orig: packet is locally originated 156 * 157 * Should be called with rcu_read_lock. 158 */ 159 void br_forward(struct net_bridge_dst dst, 160 struct sk_buff *skb, bool local_rcv, bool local_orig) 161 { 162 struct br_fwd_dst fwd; 163 164 br_dst_decode(dst, &fwd.port, &fwd.vlan); 165 166 if (unlikely(!fwd.port)) 167 goto out; 168 169 /* redirect to backup link if the destination port is down */ 170 if (rcu_access_pointer(fwd.port->backup_port) && 171 (!netif_carrier_ok(fwd.port->dev) || 172 !netif_running(fwd.port->dev))) { 173 struct net_bridge_port *backup_port; 174 175 backup_port = rcu_dereference(fwd.port->backup_port); 176 if (unlikely(!backup_port)) 177 goto out; 178 BR_INPUT_SKB_CB(skb)->backup_nhid = READ_ONCE(fwd.port->backup_nhid); 179 fwd.port = backup_port; 180 fwd.vlan = NULL; 181 } 182 183 if (should_deliver(&fwd, skb)) { 184 if (local_rcv) 185 deliver_clone(&fwd, skb, local_orig); 186 else 187 __br_forward(&fwd, skb, local_orig); 188 return; 189 } 190 191 out: 192 if (!local_rcv) 193 kfree_skb(skb); 194 } 195 EXPORT_SYMBOL_GPL(br_forward); 196 197 static int maybe_deliver(struct br_fwd_dst *prev, const struct br_fwd_dst *fwd, 198 struct sk_buff *skb, bool local_orig) 199 { 200 const struct net_bridge_port *p = fwd->port; 201 u8 igmp_type = br_multicast_igmp_type(skb); 202 int err; 203 204 if (!should_deliver(fwd, skb)) 205 return 0; 206 207 nbp_switchdev_frame_mark_tx_fwd_to_hwdom(p, skb); 208 209 if (!prev->port) 210 goto out; 211 212 err = deliver_clone(prev, skb, local_orig); 213 if (err) 214 return err; 215 out: 216 br_multicast_count(p->br, p, skb, igmp_type, BR_MCAST_DIR_TX); 217 *prev = *fwd; 218 219 return 0; 220 } 221 222 static void br_flood_finish(const struct br_fwd_dst *fwd, int err, 223 struct sk_buff *skb, 224 bool local_rcv, bool local_orig) 225 { 226 enum skb_drop_reason reason = SKB_DROP_REASON_NO_TX_TARGET; 227 228 if (err || !fwd->port) { 229 if (err) 230 reason = err == -ENOMEM ? SKB_DROP_REASON_NOMEM : 231 SKB_DROP_REASON_NOT_SPECIFIED; 232 233 if (!local_rcv) 234 kfree_skb_reason(skb, reason); 235 return; 236 } 237 238 if (local_rcv) 239 deliver_clone(fwd, skb, local_orig); 240 else 241 __br_forward(fwd, skb, local_orig); 242 } 243 244 static int br_flood_port(struct br_fwd_dst *prev, 245 const struct br_fwd_dst *fwd, struct sk_buff *skb, 246 enum br_pkt_type pkt_type, bool local_orig) 247 { 248 const struct net_bridge_port *p = fwd->port; 249 250 /* Do not flood unicast traffic to ports that turn it off, nor 251 * other traffic if flood off, except for traffic we originate 252 */ 253 switch (pkt_type) { 254 case BR_PKT_UNICAST: 255 if (!test_bit(BR_FLOOD_BIT, &p->flags)) 256 return 0; 257 break; 258 case BR_PKT_MULTICAST: 259 if (!test_bit(BR_MCAST_FLOOD_BIT, &p->flags) && 260 skb->dev != p->br->dev) 261 return 0; 262 break; 263 case BR_PKT_BROADCAST: 264 if (!test_bit(BR_BCAST_FLOOD_BIT, &p->flags) && 265 skb->dev != p->br->dev) 266 return 0; 267 break; 268 } 269 270 /* Do not flood to ports that enable proxy ARP */ 271 if (test_bit(BR_PROXYARP_BIT, &p->flags)) 272 return 0; 273 if (BR_INPUT_SKB_CB(skb)->proxyarp_replied) { 274 if (test_bit(BR_PROXYARP_WIFI_BIT, &p->flags)) 275 return 0; 276 /* For gratuitous ARPs/NAs, check neigh_forward_grat. 277 * For regular ARPs/NDs, check only neigh_suppress. 278 */ 279 if (br_is_neigh_suppress_enabled(p, fwd->vlan) && 280 (!BR_INPUT_SKB_CB(skb)->grat_arp || 281 !br_is_neigh_forward_grat_enabled(p, fwd->vlan))) 282 return 0; 283 } 284 285 return maybe_deliver(prev, fwd, skb, local_orig); 286 } 287 288 static int br_flood_vlan(struct br_fwd_dst *prev, 289 struct net_bridge_vlan *v, struct sk_buff *skb, 290 enum br_pkt_type pkt_type, bool local_orig) 291 { 292 struct net_bridge_vlan_port_array *array; 293 struct net_bridge_vlan *masterv, *pv; 294 struct br_fwd_dst fwd; 295 int err; 296 297 masterv = br_vlan_is_master(v) ? v : v->brvlan; 298 array = rcu_dereference(masterv->port_array); 299 if (array) { 300 unsigned int i; 301 302 for (i = 0; i < array->count; i++) { 303 pv = array->vlans[i]; 304 fwd.port = pv->port; 305 fwd.vlan = pv; 306 err = br_flood_port(prev, &fwd, skb, pkt_type, 307 local_orig); 308 if (err) 309 return err; 310 } 311 } else { 312 list_for_each_entry_rcu(pv, &masterv->port_vlist, port_vlist) { 313 fwd.port = pv->port; 314 fwd.vlan = pv; 315 err = br_flood_port(prev, &fwd, skb, pkt_type, 316 local_orig); 317 if (err) 318 return err; 319 } 320 } 321 322 return 0; 323 } 324 325 /* called under rcu_read_lock */ 326 void br_flood(struct net_bridge *br, struct net_bridge_vlan *v, 327 struct sk_buff *skb, enum br_pkt_type pkt_type, 328 bool local_rcv, bool local_orig) 329 { 330 struct br_fwd_dst prev = {}; 331 int err = 0; 332 333 br_tc_skb_miss_set(skb, pkt_type != BR_PKT_BROADCAST); 334 335 if (v) { 336 err = br_flood_vlan(&prev, v, skb, pkt_type, local_orig); 337 } else { 338 struct net_bridge_port *p; 339 340 list_for_each_entry_rcu(p, &br->port_list, list) { 341 struct br_fwd_dst fwd = { 342 .port = p, 343 }; 344 345 err = br_flood_port(&prev, &fwd, skb, pkt_type, 346 local_orig); 347 if (err) 348 break; 349 } 350 } 351 352 br_flood_finish(&prev, err, skb, local_rcv, local_orig); 353 } 354 355 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING 356 static void maybe_deliver_addr(struct net_bridge_port *p, struct sk_buff *skb, 357 const unsigned char *addr, bool local_orig) 358 { 359 struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev; 360 const unsigned char *src = eth_hdr(skb)->h_source; 361 struct br_fwd_dst fwd = { 362 .port = p, 363 }; 364 struct sk_buff *nskb; 365 366 if (!should_deliver(&fwd, skb)) 367 return; 368 369 /* Even with hairpin, no soliloquies - prevent breaking IPv6 DAD */ 370 if (skb->dev == p->dev && ether_addr_equal(src, addr)) 371 return; 372 373 __skb_push(skb, ETH_HLEN); 374 nskb = pskb_copy(skb, GFP_ATOMIC); 375 __skb_pull(skb, ETH_HLEN); 376 if (!nskb) { 377 DEV_STATS_INC(dev, tx_dropped); 378 return; 379 } 380 381 skb = nskb; 382 __skb_pull(skb, ETH_HLEN); 383 if (!is_broadcast_ether_addr(addr)) 384 memcpy(eth_hdr(skb)->h_dest, addr, ETH_ALEN); 385 386 __br_forward(&fwd, skb, local_orig); 387 } 388 389 /* called with rcu_read_lock */ 390 void br_multicast_flood(struct net_bridge_mdb_entry *mdst, 391 struct sk_buff *skb, 392 struct net_bridge_mcast *brmctx, 393 bool local_rcv, bool local_orig) 394 { 395 struct net_bridge_port_group *p; 396 bool allow_mode_include = true; 397 struct br_fwd_dst prev = {}; 398 struct hlist_node *rp; 399 int err = 0; 400 401 rp = br_multicast_get_first_rport_node(brmctx, skb); 402 403 if (mdst) { 404 p = rcu_dereference(mdst->ports); 405 if (br_multicast_should_handle_mode(brmctx, mdst->addr.proto) && 406 br_multicast_is_star_g(&mdst->addr)) 407 allow_mode_include = false; 408 } else { 409 p = NULL; 410 br_tc_skb_miss_set(skb, true); 411 } 412 413 while (p || rp) { 414 struct net_bridge_port *port, *lport, *rport; 415 struct br_fwd_dst fwd = {}; 416 417 lport = p ? p->key.port : NULL; 418 rport = br_multicast_rport_from_node_skb(rp, skb); 419 420 if ((unsigned long)lport > (unsigned long)rport) { 421 port = lport; 422 423 if (test_bit(BR_MULTICAST_TO_UNICAST_BIT, 424 &port->flags)) { 425 maybe_deliver_addr(lport, skb, p->eth_addr, 426 local_orig); 427 goto delivered; 428 } 429 if ((!allow_mode_include && 430 p->filter_mode == MCAST_INCLUDE) || 431 (p->flags & MDB_PG_FLAGS_BLOCKED)) 432 goto delivered; 433 } else { 434 port = rport; 435 } 436 437 fwd.port = port; 438 err = maybe_deliver(&prev, &fwd, skb, local_orig); 439 if (err) 440 break; 441 442 delivered: 443 if ((unsigned long)lport >= (unsigned long)port) 444 p = rcu_dereference(p->next); 445 if ((unsigned long)rport >= (unsigned long)port) 446 rp = rcu_dereference(hlist_next_rcu(rp)); 447 } 448 449 br_flood_finish(&prev, err, skb, local_rcv, local_orig); 450 } 451 #endif 452