br_forward.c 6.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 *	Forwarding decision
 *	Linux ethernet bridge
 *
 *	Authors:
 *	Lennert Buytenhek		<buytenh@gnu.org>
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License
 *	as published by the Free Software Foundation; either version
 *	2 of the License, or (at your option) any later version.
 */

14
#include <linux/err.h>
15
#include <linux/slab.h>
L
Linus Torvalds 已提交
16 17
#include <linux/kernel.h>
#include <linux/netdevice.h>
W
WANG Cong 已提交
18
#include <linux/netpoll.h>
L
Linus Torvalds 已提交
19
#include <linux/skbuff.h>
20
#include <linux/if_vlan.h>
L
Linus Torvalds 已提交
21 22 23
#include <linux/netfilter_bridge.h>
#include "br_private.h"

24 25
static int deliver_clone(const struct net_bridge_port *prev,
			 struct sk_buff *skb,
26 27 28
			 void (*__packet_hook)(const struct net_bridge_port *p,
					       struct sk_buff *skb));

29
/* Don't forward packets to originating port or forwarding diasabled */
30
static inline int should_deliver(const struct net_bridge_port *p,
L
Linus Torvalds 已提交
31 32
				 const struct sk_buff *skb)
{
33 34
	return (((p->flags & BR_HAIRPIN_MODE) || skb->dev != p->dev) &&
		p->state == BR_STATE_FORWARDING);
L
Linus Torvalds 已提交
35 36
}

37 38 39 40 41
static inline unsigned packet_length(const struct sk_buff *skb)
{
	return skb->len - (skb->protocol == htons(ETH_P_8021Q) ? VLAN_HLEN : 0);
}

L
Linus Torvalds 已提交
42 43
int br_dev_queue_push_xmit(struct sk_buff *skb)
{
44
	/* drop mtu oversized packets except gso */
H
Herbert Xu 已提交
45
	if (packet_length(skb) > skb->dev->mtu && !skb_is_gso(skb))
L
Linus Torvalds 已提交
46 47
		kfree_skb(skb);
	else {
48
		/* ip_fragment doesn't copy the MAC header */
49 50
		if (nf_bridge_maybe_copy_header(skb))
			kfree_skb(skb);
51
		else {
52
			skb_push(skb, ETH_HLEN);
H
Herbert Xu 已提交
53
			dev_queue_xmit(skb);
54
		}
L
Linus Torvalds 已提交
55 56 57 58 59 60 61
	}

	return 0;
}

int br_forward_finish(struct sk_buff *skb)
{
62
	return NF_HOOK(NFPROTO_BRIDGE, NF_BR_POST_ROUTING, skb, NULL, skb->dev,
63
		       br_dev_queue_push_xmit);
L
Linus Torvalds 已提交
64 65 66 67 68 69

}

static void __br_deliver(const struct net_bridge_port *to, struct sk_buff *skb)
{
	skb->dev = to->dev;
H
Herbert Xu 已提交
70 71 72 73 74 75 76 77 78 79 80

	if (unlikely(netpoll_tx_running(to->dev))) {
		if (packet_length(skb) > skb->dev->mtu && !skb_is_gso(skb))
			kfree_skb(skb);
		else {
			skb_push(skb, ETH_HLEN);
			br_netpoll_send_skb(to, skb);
		}
		return;
	}

81 82
	NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT, skb, NULL, skb->dev,
		br_forward_finish);
L
Linus Torvalds 已提交
83 84 85 86 87 88
}

static void __br_forward(const struct net_bridge_port *to, struct sk_buff *skb)
{
	struct net_device *indev;

H
Herbert Xu 已提交
89 90 91 92 93
	if (skb_warn_if_lro(skb)) {
		kfree_skb(skb);
		return;
	}

L
Linus Torvalds 已提交
94 95
	indev = skb->dev;
	skb->dev = to->dev;
96
	skb_forward_csum(skb);
L
Linus Torvalds 已提交
97

98 99
	NF_HOOK(NFPROTO_BRIDGE, NF_BR_FORWARD, skb, indev, skb->dev,
		br_forward_finish);
L
Linus Torvalds 已提交
100 101 102 103 104 105 106 107 108 109 110 111 112 113
}

/* called with rcu_read_lock */
void br_deliver(const struct net_bridge_port *to, struct sk_buff *skb)
{
	if (should_deliver(to, skb)) {
		__br_deliver(to, skb);
		return;
	}

	kfree_skb(skb);
}

/* called with rcu_read_lock */
114
void br_forward(const struct net_bridge_port *to, struct sk_buff *skb, struct sk_buff *skb0)
L
Linus Torvalds 已提交
115
{
H
Herbert Xu 已提交
116
	if (should_deliver(to, skb)) {
117 118 119 120
		if (skb0)
			deliver_clone(to, skb, __br_forward);
		else
			__br_forward(to, skb);
L
Linus Torvalds 已提交
121 122 123
		return;
	}

124 125
	if (!skb0)
		kfree_skb(skb);
L
Linus Torvalds 已提交
126 127
}

128 129
static int deliver_clone(const struct net_bridge_port *prev,
			 struct sk_buff *skb,
130 131 132
			 void (*__packet_hook)(const struct net_bridge_port *p,
					       struct sk_buff *skb))
{
133 134
	struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev;

135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
	skb = skb_clone(skb, GFP_ATOMIC);
	if (!skb) {
		dev->stats.tx_dropped++;
		return -ENOMEM;
	}

	__packet_hook(prev, skb);
	return 0;
}

static struct net_bridge_port *maybe_deliver(
	struct net_bridge_port *prev, struct net_bridge_port *p,
	struct sk_buff *skb,
	void (*__packet_hook)(const struct net_bridge_port *p,
			      struct sk_buff *skb))
{
	int err;

	if (!should_deliver(p, skb))
		return prev;

	if (!prev)
		goto out;

	err = deliver_clone(prev, skb, __packet_hook);
	if (err)
		return ERR_PTR(err);

out:
	return p;
}

L
Linus Torvalds 已提交
167
/* called under bridge lock */
168
static void br_flood(struct net_bridge *br, struct sk_buff *skb,
169 170 171
		     struct sk_buff *skb0,
		     void (*__packet_hook)(const struct net_bridge_port *p,
					   struct sk_buff *skb))
L
Linus Torvalds 已提交
172 173 174 175 176 177 178
{
	struct net_bridge_port *p;
	struct net_bridge_port *prev;

	prev = NULL;

	list_for_each_entry_rcu(p, &br->port_list, list) {
179 180 181
		prev = maybe_deliver(prev, p, skb, __packet_hook);
		if (IS_ERR(prev))
			goto out;
L
Linus Torvalds 已提交
182 183
	}

184 185 186
	if (!prev)
		goto out;

187 188 189 190
	if (skb0)
		deliver_clone(prev, skb, __packet_hook);
	else
		__packet_hook(prev, skb);
191
	return;
L
Linus Torvalds 已提交
192

193 194 195
out:
	if (!skb0)
		kfree_skb(skb);
L
Linus Torvalds 已提交
196 197 198 199
}


/* called with rcu_read_lock */
200
void br_flood_deliver(struct net_bridge *br, struct sk_buff *skb)
L
Linus Torvalds 已提交
201
{
202
	br_flood(br, skb, NULL, __br_deliver);
L
Linus Torvalds 已提交
203 204 205
}

/* called under bridge lock */
206 207
void br_flood_forward(struct net_bridge *br, struct sk_buff *skb,
		      struct sk_buff *skb2)
L
Linus Torvalds 已提交
208
{
209
	br_flood(br, skb, skb2, __br_forward);
L
Linus Torvalds 已提交
210
}
211 212 213 214 215 216 217 218 219 220 221

#ifdef CONFIG_BRIDGE_IGMP_SNOOPING
/* called with rcu_read_lock */
static void br_multicast_flood(struct net_bridge_mdb_entry *mdst,
			       struct sk_buff *skb, struct sk_buff *skb0,
			       void (*__packet_hook)(
					const struct net_bridge_port *p,
					struct sk_buff *skb))
{
	struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev;
	struct net_bridge *br = netdev_priv(dev);
222
	struct net_bridge_port *prev = NULL;
223 224 225
	struct net_bridge_port_group *p;
	struct hlist_node *rp;

S
stephen hemminger 已提交
226
	rp = rcu_dereference(br->router_list.first);
227
	p = mdst ? rcu_dereference(mdst->ports) : NULL;
228
	while (p || rp) {
229 230
		struct net_bridge_port *port, *lport, *rport;

231 232 233 234 235 236 237 238 239 240 241 242
		lport = p ? p->port : NULL;
		rport = rp ? hlist_entry(rp, struct net_bridge_port, rlist) :
			     NULL;

		port = (unsigned long)lport > (unsigned long)rport ?
		       lport : rport;

		prev = maybe_deliver(prev, port, skb, __packet_hook);
		if (IS_ERR(prev))
			goto out;

		if ((unsigned long)lport >= (unsigned long)port)
243
			p = rcu_dereference(p->next);
244
		if ((unsigned long)rport >= (unsigned long)port)
S
stephen hemminger 已提交
245
			rp = rcu_dereference(rp->next);
246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
	}

	if (!prev)
		goto out;

	if (skb0)
		deliver_clone(prev, skb, __packet_hook);
	else
		__packet_hook(prev, skb);
	return;

out:
	if (!skb0)
		kfree_skb(skb);
}

/* called with rcu_read_lock */
void br_multicast_deliver(struct net_bridge_mdb_entry *mdst,
			  struct sk_buff *skb)
{
	br_multicast_flood(mdst, skb, NULL, __br_deliver);
}

/* called with rcu_read_lock */
void br_multicast_forward(struct net_bridge_mdb_entry *mdst,
			  struct sk_buff *skb, struct sk_buff *skb2)
{
	br_multicast_flood(mdst, skb, skb2, __br_forward);
}
#endif