2 * Distributed under the terms of the GNU GPL version 2.
3 * Copyright (c) 2007, 2008, 2009 Nicira Networks.
5 * Significant portions of this file may be copied from parts of the Linux
6 * kernel, by Linus Torvalds and others.
10 #include <linux/netdevice.h>
11 #include <linux/etherdevice.h>
12 #include <linux/if_ether.h>
13 #include <linux/if_vlan.h>
14 #include <net/llc_pdu.h>
15 #include <linux/kernel.h>
16 #include <linux/jiffies.h>
17 #include <linux/llc.h>
18 #include <linux/module.h>
20 #include <linux/rcupdate.h>
21 #include <linux/if_ether.h>
23 #include <linux/tcp.h>
24 #include <linux/udp.h>
25 #include <linux/icmp.h>
30 struct kmem_cache *flow_cache;
32 static inline int iphdr_ok(struct sk_buff *skb)
34 int nh_ofs = skb_network_offset(skb);
35 if (skb->len >= nh_ofs + sizeof(struct iphdr)) {
36 int ip_len = ip_hdrlen(skb);
37 return (ip_len >= sizeof(struct iphdr)
38 && pskb_may_pull(skb, nh_ofs + ip_len));
43 static inline int tcphdr_ok(struct sk_buff *skb)
45 int th_ofs = skb_transport_offset(skb);
46 if (pskb_may_pull(skb, th_ofs + sizeof(struct tcphdr))) {
47 int tcp_len = tcp_hdrlen(skb);
48 return (tcp_len >= sizeof(struct tcphdr)
49 && skb->len >= th_ofs + tcp_len);
54 static inline int udphdr_ok(struct sk_buff *skb)
56 int th_ofs = skb_transport_offset(skb);
57 return pskb_may_pull(skb, th_ofs + sizeof(struct udphdr));
60 static inline int icmphdr_ok(struct sk_buff *skb)
62 int th_ofs = skb_transport_offset(skb);
63 return pskb_may_pull(skb, th_ofs + sizeof(struct icmphdr));
66 #define TCP_FLAGS_OFFSET 13
67 #define TCP_FLAG_MASK 0x3f
69 static inline struct ovs_tcphdr *ovs_tcp_hdr(const struct sk_buff *skb)
71 return (struct ovs_tcphdr *)skb_transport_header(skb);
74 void flow_used(struct sw_flow *flow, struct sk_buff *skb)
79 if (flow->key.dl_type == htons(ETH_P_IP) && iphdr_ok(skb)) {
80 struct iphdr *nh = ip_hdr(skb);
81 flow->ip_tos = nh->tos;
82 if (flow->key.nw_proto == IPPROTO_TCP && tcphdr_ok(skb)) {
83 u8 *tcp = (u8 *)tcp_hdr(skb);
84 tcp_flags = *(tcp + TCP_FLAGS_OFFSET) & TCP_FLAG_MASK;
88 spin_lock_irqsave(&flow->lock, flags);
89 getnstimeofday(&flow->used);
91 flow->byte_count += skb->len;
92 flow->tcp_flags |= tcp_flags;
93 spin_unlock_irqrestore(&flow->lock, flags);
96 struct sw_flow_actions *flow_actions_alloc(size_t n_actions)
98 struct sw_flow_actions *sfa;
100 if (n_actions > (PAGE_SIZE - sizeof *sfa) / sizeof(union odp_action))
101 return ERR_PTR(-EINVAL);
103 sfa = kmalloc(sizeof *sfa + n_actions * sizeof(union odp_action),
106 return ERR_PTR(-ENOMEM);
108 sfa->n_actions = n_actions;
113 /* Frees 'flow' immediately. */
114 void flow_free(struct sw_flow *flow)
118 kfree(flow->sf_acts);
119 kmem_cache_free(flow_cache, flow);
122 /* RCU callback used by flow_deferred_free. */
123 static void rcu_free_flow_callback(struct rcu_head *rcu)
125 struct sw_flow *flow = container_of(rcu, struct sw_flow, rcu);
129 /* Schedules 'flow' to be freed after the next RCU grace period.
130 * The caller must hold rcu_read_lock for this to be sensible. */
131 void flow_deferred_free(struct sw_flow *flow)
133 call_rcu(&flow->rcu, rcu_free_flow_callback);
136 /* RCU callback used by flow_deferred_free_acts. */
137 static void rcu_free_acts_callback(struct rcu_head *rcu)
139 struct sw_flow_actions *sf_acts = container_of(rcu,
140 struct sw_flow_actions, rcu);
144 /* Schedules 'sf_acts' to be freed after the next RCU grace period.
145 * The caller must hold rcu_read_lock for this to be sensible. */
146 void flow_deferred_free_acts(struct sw_flow_actions *sf_acts)
148 call_rcu(&sf_acts->rcu, rcu_free_acts_callback);
151 #define SNAP_OUI_LEN 3
156 u8 dsap; /* Always 0xAA */
157 u8 ssap; /* Always 0xAA */
159 u8 oui[SNAP_OUI_LEN];
161 } __attribute__ ((packed));
163 static int is_snap(const struct eth_snap_hdr *esh)
165 return (esh->dsap == LLC_SAP_SNAP
166 && esh->ssap == LLC_SAP_SNAP
167 && !memcmp(esh->oui, "\0\0\0", 3));
170 /* Parses the Ethernet frame in 'skb', which was received on 'in_port',
171 * and initializes 'key' to match. Returns 1 if 'skb' contains an IP
172 * fragment, 0 otherwise. */
173 int flow_extract(struct sk_buff *skb, u16 in_port, struct odp_flow_key *key)
176 struct eth_snap_hdr *esh;
180 memset(key, 0, sizeof *key);
181 key->dl_vlan = htons(ODP_VLAN_NONE);
182 key->in_port = in_port;
184 if (skb->len < sizeof *eth)
186 if (!pskb_may_pull(skb, skb->len >= 64 ? 64 : skb->len)) {
190 skb_reset_mac_header(skb);
192 esh = (struct eth_snap_hdr *) eth;
193 nh_ofs = sizeof *eth;
194 if (likely(ntohs(eth->h_proto) >= ODP_DL_TYPE_ETH2_CUTOFF))
195 key->dl_type = eth->h_proto;
196 else if (skb->len >= sizeof *esh && is_snap(esh)) {
197 key->dl_type = esh->ethertype;
198 nh_ofs = sizeof *esh;
200 key->dl_type = htons(ODP_DL_TYPE_NOT_ETH_TYPE);
201 if (skb->len >= nh_ofs + sizeof(struct llc_pdu_un)) {
202 nh_ofs += sizeof(struct llc_pdu_un);
206 /* Check for a VLAN tag */
207 if (key->dl_type == htons(ETH_P_8021Q) &&
208 skb->len >= nh_ofs + sizeof(struct vlan_hdr)) {
209 struct vlan_hdr *vh = (struct vlan_hdr*)(skb->data + nh_ofs);
210 key->dl_type = vh->h_vlan_encapsulated_proto;
211 key->dl_vlan = vh->h_vlan_TCI & htons(VLAN_VID_MASK);
212 nh_ofs += sizeof(struct vlan_hdr);
214 memcpy(key->dl_src, eth->h_source, ETH_ALEN);
215 memcpy(key->dl_dst, eth->h_dest, ETH_ALEN);
216 skb_set_network_header(skb, nh_ofs);
219 if (key->dl_type == htons(ETH_P_IP) && iphdr_ok(skb)) {
220 struct iphdr *nh = ip_hdr(skb);
221 int th_ofs = nh_ofs + nh->ihl * 4;
222 key->nw_src = nh->saddr;
223 key->nw_dst = nh->daddr;
224 key->nw_proto = nh->protocol;
225 skb_set_transport_header(skb, th_ofs);
227 /* Transport layer. */
228 if (!(nh->frag_off & htons(IP_MF | IP_OFFSET))) {
229 if (key->nw_proto == IPPROTO_TCP) {
230 if (tcphdr_ok(skb)) {
231 struct tcphdr *tcp = tcp_hdr(skb);
232 key->tp_src = tcp->source;
233 key->tp_dst = tcp->dest;
235 /* Avoid tricking other code into
236 * thinking that this packet has an L4
240 } else if (key->nw_proto == IPPROTO_UDP) {
241 if (udphdr_ok(skb)) {
242 struct udphdr *udp = udp_hdr(skb);
243 key->tp_src = udp->source;
244 key->tp_dst = udp->dest;
246 /* Avoid tricking other code into
247 * thinking that this packet has an L4
251 } else if (key->nw_proto == IPPROTO_ICMP) {
252 if (icmphdr_ok(skb)) {
253 struct icmphdr *icmp = icmp_hdr(skb);
254 /* The ICMP type and code fields use the 16-bit
255 * transport port fields, so we need to store them
256 * in 16-bit network byte order. */
257 key->tp_src = htons(icmp->type);
258 key->tp_dst = htons(icmp->code);
260 /* Avoid tricking other code into
261 * thinking that this packet has an L4
270 skb_reset_transport_header(skb);
275 /* Initializes the flow module.
276 * Returns zero if successful or a negative error code. */
279 flow_cache = kmem_cache_create("sw_flow", sizeof(struct sw_flow), 0,
281 if (flow_cache == NULL)
287 /* Uninitializes the flow module. */
290 kmem_cache_destroy(flow_cache);
293 void print_flow(const struct odp_flow_key *key)
295 #define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
296 #define MAC_ARG(x) ((u8*)(x))[0],((u8*)(x))[1],((u8*)(x))[2],((u8*)(x))[3],((u8*)(x))[4],((u8*)(x))[5]
297 printk("port%04x:vlan%d mac"MAC_FMT"->"MAC_FMT" "
298 "type%04x proto%d ip%x->%x port%d->%d\n",
299 key->in_port, ntohs(key->dl_vlan),
300 MAC_ARG(key->dl_src), MAC_ARG(key->dl_dst),
301 ntohs(key->dl_type), key->nw_proto,
302 key->nw_src, key->nw_dst,
303 ntohs(key->tp_src), ntohs(key->tp_dst));