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 const 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 * @to: destination port 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(const struct net_bridge_port *to, 160 struct sk_buff *skb, bool local_rcv, bool local_orig) 161 { 162 struct br_fwd_dst fwd; 163 164 if (unlikely(!to)) 165 goto out; 166 167 /* redirect to backup link if the destination port is down */ 168 if (rcu_access_pointer(to->backup_port) && 169 (!netif_carrier_ok(to->dev) || !netif_running(to->dev))) { 170 struct net_bridge_port *backup_port; 171 172 backup_port = rcu_dereference(to->backup_port); 173 if (unlikely(!backup_port)) 174 goto out; 175 BR_INPUT_SKB_CB(skb)->backup_nhid = READ_ONCE(to->backup_nhid); 176 to = backup_port; 177 } 178 179 fwd.port = to; 180 fwd.vlan = NULL; 181 if (should_deliver(&fwd, skb)) { 182 if (local_rcv) 183 deliver_clone(&fwd, skb, local_orig); 184 else 185 __br_forward(&fwd, skb, local_orig); 186 return; 187 } 188 189 out: 190 if (!local_rcv) 191 kfree_skb(skb); 192 } 193 EXPORT_SYMBOL_GPL(br_forward); 194 195 static int maybe_deliver(struct br_fwd_dst *prev, const struct br_fwd_dst *fwd, 196 struct sk_buff *skb, bool local_orig) 197 { 198 const struct net_bridge_port *p = fwd->port; 199 u8 igmp_type = br_multicast_igmp_type(skb); 200 int err; 201 202 if (!should_deliver(fwd, skb)) 203 return 0; 204 205 nbp_switchdev_frame_mark_tx_fwd_to_hwdom(p, skb); 206 207 if (!prev->port) 208 goto out; 209 210 err = deliver_clone(prev, skb, local_orig); 211 if (err) 212 return err; 213 out: 214 br_multicast_count(p->br, p, skb, igmp_type, BR_MCAST_DIR_TX); 215 *prev = *fwd; 216 217 return 0; 218 } 219 220 static void br_flood_finish(const struct br_fwd_dst *fwd, int err, 221 struct sk_buff *skb, 222 bool local_rcv, bool local_orig) 223 { 224 enum skb_drop_reason reason = SKB_DROP_REASON_NO_TX_TARGET; 225 226 if (err || !fwd->port) { 227 if (err) 228 reason = err == -ENOMEM ? SKB_DROP_REASON_NOMEM : 229 SKB_DROP_REASON_NOT_SPECIFIED; 230 231 if (!local_rcv) 232 kfree_skb_reason(skb, reason); 233 return; 234 } 235 236 if (local_rcv) 237 deliver_clone(fwd, skb, local_orig); 238 else 239 __br_forward(fwd, skb, local_orig); 240 } 241 242 static int br_flood_port(struct br_fwd_dst *prev, 243 const struct br_fwd_dst *fwd, struct sk_buff *skb, 244 enum br_pkt_type pkt_type, bool local_orig) 245 { 246 const struct net_bridge_port *p = fwd->port; 247 248 /* Do not flood unicast traffic to ports that turn it off, nor 249 * other traffic if flood off, except for traffic we originate 250 */ 251 switch (pkt_type) { 252 case BR_PKT_UNICAST: 253 if (!test_bit(BR_FLOOD_BIT, &p->flags)) 254 return 0; 255 break; 256 case BR_PKT_MULTICAST: 257 if (!test_bit(BR_MCAST_FLOOD_BIT, &p->flags) && 258 skb->dev != p->br->dev) 259 return 0; 260 break; 261 case BR_PKT_BROADCAST: 262 if (!test_bit(BR_BCAST_FLOOD_BIT, &p->flags) && 263 skb->dev != p->br->dev) 264 return 0; 265 break; 266 } 267 268 /* Do not flood to ports that enable proxy ARP */ 269 if (test_bit(BR_PROXYARP_BIT, &p->flags)) 270 return 0; 271 if (BR_INPUT_SKB_CB(skb)->proxyarp_replied) { 272 if (test_bit(BR_PROXYARP_WIFI_BIT, &p->flags)) 273 return 0; 274 /* For gratuitous ARPs/NAs, check neigh_forward_grat. 275 * For regular ARPs/NDs, check only neigh_suppress. 276 */ 277 if (br_is_neigh_suppress_enabled(p, fwd->vlan) && 278 (!BR_INPUT_SKB_CB(skb)->grat_arp || 279 !br_is_neigh_forward_grat_enabled(p, fwd->vlan))) 280 return 0; 281 } 282 283 return maybe_deliver(prev, fwd, skb, local_orig); 284 } 285 286 static int br_flood_vlan(struct br_fwd_dst *prev, 287 struct net_bridge_vlan *v, struct sk_buff *skb, 288 enum br_pkt_type pkt_type, bool local_orig) 289 { 290 struct net_bridge_vlan_port_array *array; 291 struct net_bridge_vlan *masterv, *pv; 292 struct br_fwd_dst dst; 293 int err; 294 295 masterv = br_vlan_is_master(v) ? v : v->brvlan; 296 array = rcu_dereference(masterv->port_array); 297 if (array) { 298 unsigned int i; 299 300 for (i = 0; i < array->count; i++) { 301 pv = array->vlans[i]; 302 dst.port = pv->port; 303 dst.vlan = pv; 304 err = br_flood_port(prev, &dst, skb, pkt_type, 305 local_orig); 306 if (err) 307 return err; 308 } 309 } else { 310 list_for_each_entry_rcu(pv, &masterv->port_vlist, port_vlist) { 311 dst.port = pv->port; 312 dst.vlan = pv; 313 err = br_flood_port(prev, &dst, skb, pkt_type, 314 local_orig); 315 if (err) 316 return err; 317 } 318 } 319 320 return 0; 321 } 322 323 /* called under rcu_read_lock */ 324 void br_flood(struct net_bridge *br, struct net_bridge_vlan *v, 325 struct sk_buff *skb, enum br_pkt_type pkt_type, 326 bool local_rcv, bool local_orig) 327 { 328 struct br_fwd_dst prev = {}; 329 int err = 0; 330 331 br_tc_skb_miss_set(skb, pkt_type != BR_PKT_BROADCAST); 332 333 if (v) { 334 err = br_flood_vlan(&prev, v, skb, pkt_type, local_orig); 335 } else { 336 struct net_bridge_port *p; 337 338 list_for_each_entry_rcu(p, &br->port_list, list) { 339 struct br_fwd_dst fwd = { 340 .port = p, 341 }; 342 343 err = br_flood_port(&prev, &fwd, skb, pkt_type, 344 local_orig); 345 if (err) 346 break; 347 } 348 } 349 350 br_flood_finish(&prev, err, skb, local_rcv, local_orig); 351 } 352 353 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING 354 static void maybe_deliver_addr(struct net_bridge_port *p, struct sk_buff *skb, 355 const unsigned char *addr, bool local_orig) 356 { 357 struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev; 358 const unsigned char *src = eth_hdr(skb)->h_source; 359 struct br_fwd_dst fwd = { 360 .port = p, 361 }; 362 struct sk_buff *nskb; 363 364 if (!should_deliver(&fwd, skb)) 365 return; 366 367 /* Even with hairpin, no soliloquies - prevent breaking IPv6 DAD */ 368 if (skb->dev == p->dev && ether_addr_equal(src, addr)) 369 return; 370 371 __skb_push(skb, ETH_HLEN); 372 nskb = pskb_copy(skb, GFP_ATOMIC); 373 __skb_pull(skb, ETH_HLEN); 374 if (!nskb) { 375 DEV_STATS_INC(dev, tx_dropped); 376 return; 377 } 378 379 skb = nskb; 380 __skb_pull(skb, ETH_HLEN); 381 if (!is_broadcast_ether_addr(addr)) 382 memcpy(eth_hdr(skb)->h_dest, addr, ETH_ALEN); 383 384 __br_forward(&fwd, skb, local_orig); 385 } 386 387 /* called with rcu_read_lock */ 388 void br_multicast_flood(struct net_bridge_mdb_entry *mdst, 389 struct sk_buff *skb, 390 struct net_bridge_mcast *brmctx, 391 bool local_rcv, bool local_orig) 392 { 393 struct net_bridge_port_group *p; 394 bool allow_mode_include = true; 395 struct br_fwd_dst prev = {}; 396 struct hlist_node *rp; 397 int err = 0; 398 399 rp = br_multicast_get_first_rport_node(brmctx, skb); 400 401 if (mdst) { 402 p = rcu_dereference(mdst->ports); 403 if (br_multicast_should_handle_mode(brmctx, mdst->addr.proto) && 404 br_multicast_is_star_g(&mdst->addr)) 405 allow_mode_include = false; 406 } else { 407 p = NULL; 408 br_tc_skb_miss_set(skb, true); 409 } 410 411 while (p || rp) { 412 struct net_bridge_port *port, *lport, *rport; 413 struct br_fwd_dst fwd = {}; 414 415 lport = p ? p->key.port : NULL; 416 rport = br_multicast_rport_from_node_skb(rp, skb); 417 418 if ((unsigned long)lport > (unsigned long)rport) { 419 port = lport; 420 421 if (test_bit(BR_MULTICAST_TO_UNICAST_BIT, 422 &port->flags)) { 423 maybe_deliver_addr(lport, skb, p->eth_addr, 424 local_orig); 425 goto delivered; 426 } 427 if ((!allow_mode_include && 428 p->filter_mode == MCAST_INCLUDE) || 429 (p->flags & MDB_PG_FLAGS_BLOCKED)) 430 goto delivered; 431 } else { 432 port = rport; 433 } 434 435 fwd.port = port; 436 err = maybe_deliver(&prev, &fwd, skb, local_orig); 437 if (err) 438 break; 439 440 delivered: 441 if ((unsigned long)lport >= (unsigned long)port) 442 p = rcu_dereference(p->next); 443 if ((unsigned long)rport >= (unsigned long)port) 444 rp = rcu_dereference(hlist_next_rcu(rp)); 445 } 446 447 br_flood_finish(&prev, err, skb, local_rcv, local_orig); 448 } 449 #endif 450