]> git.proxmox.com Git - mirror_ovs.git/blob - datapath/flow.c
projects / mirror_ovs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
datapath: Remove flow refcount functionality.
[mirror_ovs.git] / datapath / flow.c
1 /*
2 * Copyright (c) 2007-2011 Nicira, Inc.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of version 2 of the GNU General Public
6 * License as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
16 * 02110-1301, USA
17 */
18
19 #include "flow.h"
20 #include "datapath.h"
21 #include <linux/uaccess.h>
22 #include <linux/netdevice.h>
23 #include <linux/etherdevice.h>
24 #include <linux/if_ether.h>
25 #include <linux/if_vlan.h>
26 #include <net/llc_pdu.h>
27 #include <linux/kernel.h>
28 #include <linux/jhash.h>
29 #include <linux/jiffies.h>
30 #include <linux/llc.h>
31 #include <linux/module.h>
32 #include <linux/in.h>
33 #include <linux/rcupdate.h>
34 #include <linux/if_arp.h>
35 #include <linux/ip.h>
36 #include <linux/ipv6.h>
37 #include <linux/tcp.h>
38 #include <linux/udp.h>
39 #include <linux/icmp.h>
40 #include <linux/icmpv6.h>
41 #include <linux/rculist.h>
42 #include <net/ip.h>
43 #include <net/ipv6.h>
44 #include <net/ndisc.h>
45
46 #include "vlan.h"
47
48 static struct kmem_cache *flow_cache;
49
50 static int check_header(struct sk_buff *skb, int len)
51 {
52 if (unlikely(skb->len < len))
53 return -EINVAL;
54 if (unlikely(!pskb_may_pull(skb, len)))
55 return -ENOMEM;
56 return 0;
57 }
58
59 static bool arphdr_ok(struct sk_buff *skb)
60 {
61 return pskb_may_pull(skb, skb_network_offset(skb) +
62 sizeof(struct arp_eth_header));
63 }
64
65 static int check_iphdr(struct sk_buff *skb)
66 {
67 unsigned int nh_ofs = skb_network_offset(skb);
68 unsigned int ip_len;
69 int err;
70
71 err = check_header(skb, nh_ofs + sizeof(struct iphdr));
72 if (unlikely(err))
73 return err;
74
75 ip_len = ip_hdrlen(skb);
76 if (unlikely(ip_len < sizeof(struct iphdr) ||
77 skb->len < nh_ofs + ip_len))
78 return -EINVAL;
79
80 skb_set_transport_header(skb, nh_ofs + ip_len);
81 return 0;
82 }
83
84 static bool tcphdr_ok(struct sk_buff *skb)
85 {
86 int th_ofs = skb_transport_offset(skb);
87 int tcp_len;
88
89 if (unlikely(!pskb_may_pull(skb, th_ofs + sizeof(struct tcphdr))))
90 return false;
91
92 tcp_len = tcp_hdrlen(skb);
93 if (unlikely(tcp_len < sizeof(struct tcphdr) ||
94 skb->len < th_ofs + tcp_len))
95 return false;
96
97 return true;
98 }
99
100 static bool udphdr_ok(struct sk_buff *skb)
101 {
102 return pskb_may_pull(skb, skb_transport_offset(skb) +
103 sizeof(struct udphdr));
104 }
105
106 static bool icmphdr_ok(struct sk_buff *skb)
107 {
108 return pskb_may_pull(skb, skb_transport_offset(skb) +
109 sizeof(struct icmphdr));
110 }
111
112 u64 ovs_flow_used_time(unsigned long flow_jiffies)
113 {
114 struct timespec cur_ts;
115 u64 cur_ms, idle_ms;
116
117 ktime_get_ts(&cur_ts);
118 idle_ms = jiffies_to_msecs(jiffies - flow_jiffies);
119 cur_ms = (u64)cur_ts.tv_sec * MSEC_PER_SEC +
120 cur_ts.tv_nsec / NSEC_PER_MSEC;
121
122 return cur_ms - idle_ms;
123 }
124
125 #define SW_FLOW_KEY_OFFSET(field) \
126 (offsetof(struct sw_flow_key, field) + \
127 FIELD_SIZEOF(struct sw_flow_key, field))
128
129 static int parse_ipv6hdr(struct sk_buff *skb, struct sw_flow_key *key,
130 int *key_lenp)
131 {
132 unsigned int nh_ofs = skb_network_offset(skb);
133 unsigned int nh_len;
134 int payload_ofs;
135 struct ipv6hdr *nh;
136 uint8_t nexthdr;
137 __be16 frag_off;
138 int err;
139
140 *key_lenp = SW_FLOW_KEY_OFFSET(ipv6.label);
141
142 err = check_header(skb, nh_ofs + sizeof(*nh));
143 if (unlikely(err))
144 return err;
145
146 nh = ipv6_hdr(skb);
147 nexthdr = nh->nexthdr;
148 payload_ofs = (u8 *)(nh + 1) - skb->data;
149
150 key->ip.proto = NEXTHDR_NONE;
151 key->ip.tos = ipv6_get_dsfield(nh);
152 key->ip.ttl = nh->hop_limit;
153 key->ipv6.label = *(__be32 *)nh & htonl(IPV6_FLOWINFO_FLOWLABEL);
154 key->ipv6.addr.src = nh->saddr;
155 key->ipv6.addr.dst = nh->daddr;
156
157 payload_ofs = ipv6_skip_exthdr(skb, payload_ofs, &nexthdr, &frag_off);
158 if (unlikely(payload_ofs < 0))
159 return -EINVAL;
160
161 if (frag_off) {
162 if (frag_off & htons(~0x7))
163 key->ip.frag = OVS_FRAG_TYPE_LATER;
164 else
165 key->ip.frag = OVS_FRAG_TYPE_FIRST;
166 }
167
168 nh_len = payload_ofs - nh_ofs;
169 skb_set_transport_header(skb, nh_ofs + nh_len);
170 key->ip.proto = nexthdr;
171 return nh_len;
172 }
173
174 static bool icmp6hdr_ok(struct sk_buff *skb)
175 {
176 return pskb_may_pull(skb, skb_transport_offset(skb) +
177 sizeof(struct icmp6hdr));
178 }
179
180 #define TCP_FLAGS_OFFSET 13
181 #define TCP_FLAG_MASK 0x3f
182
183 void ovs_flow_used(struct sw_flow *flow, struct sk_buff *skb)
184 {
185 u8 tcp_flags = 0;
186
187 if ((flow->key.eth.type == htons(ETH_P_IP) ||
188 flow->key.eth.type == htons(ETH_P_IPV6)) &&
189 flow->key.ip.proto == IPPROTO_TCP &&
190 likely(skb->len >= skb_transport_offset(skb) + sizeof(struct tcphdr))) {
191 u8 *tcp = (u8 *)tcp_hdr(skb);
192 tcp_flags = *(tcp + TCP_FLAGS_OFFSET) & TCP_FLAG_MASK;
193 }
194
195 spin_lock(&flow->lock);
196 flow->used = jiffies;
197 flow->packet_count++;
198 flow->byte_count += skb->len;
199 flow->tcp_flags |= tcp_flags;
200 spin_unlock(&flow->lock);
201 }
202
203 struct sw_flow_actions *ovs_flow_actions_alloc(const struct nlattr *actions)
204 {
205 int actions_len = nla_len(actions);
206 struct sw_flow_actions *sfa;
207
208 if (actions_len > MAX_ACTIONS_BUFSIZE)
209 return ERR_PTR(-EINVAL);
210
211 sfa = kmalloc(sizeof(*sfa) + actions_len, GFP_KERNEL);
212 if (!sfa)
213 return ERR_PTR(-ENOMEM);
214
215 sfa->actions_len = actions_len;
216 memcpy(sfa->actions, nla_data(actions), actions_len);
217 return sfa;
218 }
219
220 struct sw_flow *ovs_flow_alloc(void)
221 {
222 struct sw_flow *flow;
223
224 flow = kmem_cache_alloc(flow_cache, GFP_KERNEL);
225 if (!flow)
226 return ERR_PTR(-ENOMEM);
227
228 spin_lock_init(&flow->lock);
229 flow->sf_acts = NULL;
230
231 return flow;
232 }
233
234 static struct hlist_head *find_bucket(struct flow_table *table, u32 hash)
235 {
236 hash = jhash_1word(hash, table->hash_seed);
237 return flex_array_get(table->buckets,
238 (hash & (table->n_buckets - 1)));
239 }
240
241 static struct flex_array *alloc_buckets(unsigned int n_buckets)
242 {
243 struct flex_array *buckets;
244 int i, err;
245
246 buckets = flex_array_alloc(sizeof(struct hlist_head *),
247 n_buckets, GFP_KERNEL);
248 if (!buckets)
249 return NULL;
250
251 err = flex_array_prealloc(buckets, 0, n_buckets, GFP_KERNEL);
252 if (err) {
253 flex_array_free(buckets);
254 return NULL;
255 }
256
257 for (i = 0; i < n_buckets; i++)
258 INIT_HLIST_HEAD((struct hlist_head *)
259 flex_array_get(buckets, i));
260
261 return buckets;
262 }
263
264 static void free_buckets(struct flex_array *buckets)
265 {
266 flex_array_free(buckets);
267 }
268
269 struct flow_table *ovs_flow_tbl_alloc(int new_size)
270 {
271 struct flow_table *table = kmalloc(sizeof(*table), GFP_KERNEL);
272
273 if (!table)
274 return NULL;
275
276 table->buckets = alloc_buckets(new_size);
277
278 if (!table->buckets) {
279 kfree(table);
280 return NULL;
281 }
282 table->n_buckets = new_size;
283 table->count = 0;
284 table->node_ver = 0;
285 table->keep_flows = false;
286 get_random_bytes(&table->hash_seed, sizeof(u32));
287
288 return table;
289 }
290
291 void ovs_flow_tbl_destroy(struct flow_table *table)
292 {
293 int i;
294
295 if (!table)
296 return;
297
298 if (table->keep_flows)
299 goto skip_flows;
300
301 for (i = 0; i < table->n_buckets; i++) {
302 struct sw_flow *flow;
303 struct hlist_head *head = flex_array_get(table->buckets, i);
304 struct hlist_node *node, *n;
305 int ver = table->node_ver;
306
307 hlist_for_each_entry_safe(flow, node, n, head, hash_node[ver]) {
308 hlist_del_rcu(&flow->hash_node[ver]);
309 ovs_flow_free(flow);
310 }
311 }
312
313 skip_flows:
314 free_buckets(table->buckets);
315 kfree(table);
316 }
317
318 static void flow_tbl_destroy_rcu_cb(struct rcu_head *rcu)
319 {
320 struct flow_table *table = container_of(rcu, struct flow_table, rcu);
321
322 ovs_flow_tbl_destroy(table);
323 }
324
325 void ovs_flow_tbl_deferred_destroy(struct flow_table *table)
326 {
327 if (!table)
328 return;
329
330 call_rcu(&table->rcu, flow_tbl_destroy_rcu_cb);
331 }
332
333 struct sw_flow *ovs_flow_tbl_next(struct flow_table *table, u32 *bucket, u32 *last)
334 {
335 struct sw_flow *flow;
336 struct hlist_head *head;
337 struct hlist_node *n;
338 int ver;
339 int i;
340
341 ver = table->node_ver;
342 while (*bucket < table->n_buckets) {
343 i = 0;
344 head = flex_array_get(table->buckets, *bucket);
345 hlist_for_each_entry_rcu(flow, n, head, hash_node[ver]) {
346 if (i < *last) {
347 i++;
348 continue;
349 }
350 *last = i + 1;
351 return flow;
352 }
353 (*bucket)++;
354 *last = 0;
355 }
356
357 return NULL;
358 }
359
360 static void __flow_tbl_insert(struct flow_table *table, struct sw_flow *flow)
361 {
362 struct hlist_head *head;
363 head = find_bucket(table, flow->hash);
364 hlist_add_head_rcu(&flow->hash_node[table->node_ver], head);
365 table->count++;
366 }
367
368 static void flow_table_copy_flows(struct flow_table *old, struct flow_table *new)
369 {
370 int old_ver;
371 int i;
372
373 old_ver = old->node_ver;
374 new->node_ver = !old_ver;
375
376 /* Insert in new table. */
377 for (i = 0; i < old->n_buckets; i++) {
378 struct sw_flow *flow;
379 struct hlist_head *head;
380 struct hlist_node *n;
381
382 head = flex_array_get(old->buckets, i);
383
384 hlist_for_each_entry(flow, n, head, hash_node[old_ver])
385 __flow_tbl_insert(new, flow);
386 }
387 old->keep_flows = true;
388 }
389
390 static struct flow_table *__flow_tbl_rehash(struct flow_table *table, int n_buckets)
391 {
392 struct flow_table *new_table;
393
394 new_table = ovs_flow_tbl_alloc(n_buckets);
395 if (!new_table)
396 return ERR_PTR(-ENOMEM);
397
398 flow_table_copy_flows(table, new_table);
399
400 return new_table;
401 }
402
403 struct flow_table *ovs_flow_tbl_rehash(struct flow_table *table)
404 {
405 return __flow_tbl_rehash(table, table->n_buckets);
406 }
407
408 struct flow_table *ovs_flow_tbl_expand(struct flow_table *table)
409 {
410 return __flow_tbl_rehash(table, table->n_buckets * 2);
411 }
412
413 void ovs_flow_free(struct sw_flow *flow)
414 {
415 if (unlikely(!flow))
416 return;
417
418 kfree((struct sf_flow_acts __force *)flow->sf_acts);
419 kmem_cache_free(flow_cache, flow);
420 }
421
422 /* RCU callback used by ovs_flow_deferred_free. */
423 static void rcu_free_flow_callback(struct rcu_head *rcu)
424 {
425 struct sw_flow *flow = container_of(rcu, struct sw_flow, rcu);
426
427 ovs_flow_free(flow);
428 }
429
430 /* Schedules 'flow' to be freed after the next RCU grace period.
431 * The caller must hold rcu_read_lock for this to be sensible. */
432 void ovs_flow_deferred_free(struct sw_flow *flow)
433 {
434 call_rcu(&flow->rcu, rcu_free_flow_callback);
435 }
436
437 /* RCU callback used by ovs_flow_deferred_free_acts. */
438 static void rcu_free_acts_callback(struct rcu_head *rcu)
439 {
440 struct sw_flow_actions *sf_acts = container_of(rcu,
441 struct sw_flow_actions, rcu);
442 kfree(sf_acts);
443 }
444
445 /* Schedules 'sf_acts' to be freed after the next RCU grace period.
446 * The caller must hold rcu_read_lock for this to be sensible. */
447 void ovs_flow_deferred_free_acts(struct sw_flow_actions *sf_acts)
448 {
449 call_rcu(&sf_acts->rcu, rcu_free_acts_callback);
450 }
451
452 static int parse_vlan(struct sk_buff *skb, struct sw_flow_key *key)
453 {
454 struct qtag_prefix {
455 __be16 eth_type; /* ETH_P_8021Q */
456 __be16 tci;
457 };
458 struct qtag_prefix *qp;
459
460 if (unlikely(skb->len < sizeof(struct qtag_prefix) + sizeof(__be16)))
461 return 0;
462
463 if (unlikely(!pskb_may_pull(skb, sizeof(struct qtag_prefix) +
464 sizeof(__be16))))
465 return -ENOMEM;
466
467 qp = (struct qtag_prefix *) skb->data;
468 key->eth.tci = qp->tci | htons(VLAN_TAG_PRESENT);
469 __skb_pull(skb, sizeof(struct qtag_prefix));
470
471 return 0;
472 }
473
474 static __be16 parse_ethertype(struct sk_buff *skb)
475 {
476 struct llc_snap_hdr {
477 u8 dsap; /* Always 0xAA */
478 u8 ssap; /* Always 0xAA */
479 u8 ctrl;
480 u8 oui[3];
481 __be16 ethertype;
482 };
483 struct llc_snap_hdr *llc;
484 __be16 proto;
485
486 proto = *(__be16 *) skb->data;
487 __skb_pull(skb, sizeof(__be16));
488
489 if (ntohs(proto) >= 1536)
490 return proto;
491
492 if (skb->len < sizeof(struct llc_snap_hdr))
493 return htons(ETH_P_802_2);
494
495 if (unlikely(!pskb_may_pull(skb, sizeof(struct llc_snap_hdr))))
496 return htons(0);
497
498 llc = (struct llc_snap_hdr *) skb->data;
499 if (llc->dsap != LLC_SAP_SNAP ||
500 llc->ssap != LLC_SAP_SNAP ||
501 (llc->oui[0] | llc->oui[1] | llc->oui[2]) != 0)
502 return htons(ETH_P_802_2);
503
504 __skb_pull(skb, sizeof(struct llc_snap_hdr));
505 return llc->ethertype;
506 }
507
508 static int parse_icmpv6(struct sk_buff *skb, struct sw_flow_key *key,
509 int *key_lenp, int nh_len)
510 {
511 struct icmp6hdr *icmp = icmp6_hdr(skb);
512 int error = 0;
513 int key_len;
514
515 /* The ICMPv6 type and code fields use the 16-bit transport port
516 * fields, so we need to store them in 16-bit network byte order.
517 */
518 key->ipv6.tp.src = htons(icmp->icmp6_type);
519 key->ipv6.tp.dst = htons(icmp->icmp6_code);
520 key_len = SW_FLOW_KEY_OFFSET(ipv6.tp);
521
522 if (icmp->icmp6_code == 0 &&
523 (icmp->icmp6_type == NDISC_NEIGHBOUR_SOLICITATION ||
524 icmp->icmp6_type == NDISC_NEIGHBOUR_ADVERTISEMENT)) {
525 int icmp_len = skb->len - skb_transport_offset(skb);
526 struct nd_msg *nd;
527 int offset;
528
529 key_len = SW_FLOW_KEY_OFFSET(ipv6.nd);
530
531 /* In order to process neighbor discovery options, we need the
532 * entire packet.
533 */
534 if (unlikely(icmp_len < sizeof(*nd)))
535 goto out;
536 if (unlikely(skb_linearize(skb))) {
537 error = -ENOMEM;
538 goto out;
539 }
540
541 nd = (struct nd_msg *)skb_transport_header(skb);
542 key->ipv6.nd.target = nd->target;
543 key_len = SW_FLOW_KEY_OFFSET(ipv6.nd);
544
545 icmp_len -= sizeof(*nd);
546 offset = 0;
547 while (icmp_len >= 8) {
548 struct nd_opt_hdr *nd_opt =
549 (struct nd_opt_hdr *)(nd->opt + offset);
550 int opt_len = nd_opt->nd_opt_len * 8;
551
552 if (unlikely(!opt_len || opt_len > icmp_len))
553 goto invalid;
554
555 /* Store the link layer address if the appropriate
556 * option is provided. It is considered an error if
557 * the same link layer option is specified twice.
558 */
559 if (nd_opt->nd_opt_type == ND_OPT_SOURCE_LL_ADDR
560 && opt_len == 8) {
561 if (unlikely(!is_zero_ether_addr(key->ipv6.nd.sll)))
562 goto invalid;
563 memcpy(key->ipv6.nd.sll,
564 &nd->opt[offset+sizeof(*nd_opt)], ETH_ALEN);
565 } else if (nd_opt->nd_opt_type == ND_OPT_TARGET_LL_ADDR
566 && opt_len == 8) {
567 if (unlikely(!is_zero_ether_addr(key->ipv6.nd.tll)))
568 goto invalid;
569 memcpy(key->ipv6.nd.tll,
570 &nd->opt[offset+sizeof(*nd_opt)], ETH_ALEN);
571 }
572
573 icmp_len -= opt_len;
574 offset += opt_len;
575 }
576 }
577
578 goto out;
579
580 invalid:
581 memset(&key->ipv6.nd.target, 0, sizeof(key->ipv6.nd.target));
582 memset(key->ipv6.nd.sll, 0, sizeof(key->ipv6.nd.sll));
583 memset(key->ipv6.nd.tll, 0, sizeof(key->ipv6.nd.tll));
584
585 out:
586 *key_lenp = key_len;
587 return error;
588 }
589
590 /**
591 * ovs_flow_extract - extracts a flow key from an Ethernet frame.
592 * @skb: sk_buff that contains the frame, with skb->data pointing to the
593 * Ethernet header
594 * @in_port: port number on which @skb was received.
595 * @key: output flow key
596 * @key_lenp: length of output flow key
597 *
598 * The caller must ensure that skb->len >= ETH_HLEN.
599 *
600 * Returns 0 if successful, otherwise a negative errno value.
601 *
602 * Initializes @skb header pointers as follows:
603 *
604 * - skb->mac_header: the Ethernet header.
605 *
606 * - skb->network_header: just past the Ethernet header, or just past the
607 * VLAN header, to the first byte of the Ethernet payload.
608 *
609 * - skb->transport_header: If key->dl_type is ETH_P_IP or ETH_P_IPV6
610 * on output, then just past the IP header, if one is present and
611 * of a correct length, otherwise the same as skb->network_header.
612 * For other key->dl_type values it is left untouched.
613 */
614 int ovs_flow_extract(struct sk_buff *skb, u16 in_port, struct sw_flow_key *key,
615 int *key_lenp)
616 {
617 int error = 0;
618 int key_len = SW_FLOW_KEY_OFFSET(eth);
619 struct ethhdr *eth;
620
621 memset(key, 0, sizeof(*key));
622
623 key->phy.priority = skb->priority;
624 if (OVS_CB(skb)->tun_key)
625 memcpy(&key->phy.tun.tun_key, OVS_CB(skb)->tun_key, sizeof(key->phy.tun.tun_key));
626 key->phy.in_port = in_port;
627
628 skb_reset_mac_header(skb);
629
630 /* Link layer. We are guaranteed to have at least the 14 byte Ethernet
631 * header in the linear data area.
632 */
633 eth = eth_hdr(skb);
634 memcpy(key->eth.src, eth->h_source, ETH_ALEN);
635 memcpy(key->eth.dst, eth->h_dest, ETH_ALEN);
636
637 __skb_pull(skb, 2 * ETH_ALEN);
638
639 if (vlan_tx_tag_present(skb))
640 key->eth.tci = htons(vlan_get_tci(skb));
641 else if (eth->h_proto == htons(ETH_P_8021Q))
642 if (unlikely(parse_vlan(skb, key)))
643 return -ENOMEM;
644
645 key->eth.type = parse_ethertype(skb);
646 if (unlikely(key->eth.type == htons(0)))
647 return -ENOMEM;
648
649 skb_reset_network_header(skb);
650 __skb_push(skb, skb->data - skb_mac_header(skb));
651
652 /* Network layer. */
653 if (key->eth.type == htons(ETH_P_IP)) {
654 struct iphdr *nh;
655 __be16 offset;
656
657 key_len = SW_FLOW_KEY_OFFSET(ipv4.addr);
658
659 error = check_iphdr(skb);
660 if (unlikely(error)) {
661 if (error == -EINVAL) {
662 skb->transport_header = skb->network_header;
663 error = 0;
664 }
665 goto out;
666 }
667
668 nh = ip_hdr(skb);
669 key->ipv4.addr.src = nh->saddr;
670 key->ipv4.addr.dst = nh->daddr;
671
672 key->ip.proto = nh->protocol;
673 key->ip.tos = nh->tos;
674 key->ip.ttl = nh->ttl;
675
676 offset = nh->frag_off & htons(IP_OFFSET);
677 if (offset) {
678 key->ip.frag = OVS_FRAG_TYPE_LATER;
679 goto out;
680 }
681 if (nh->frag_off & htons(IP_MF) ||
682 skb_shinfo(skb)->gso_type & SKB_GSO_UDP)
683 key->ip.frag = OVS_FRAG_TYPE_FIRST;
684
685 /* Transport layer. */
686 if (key->ip.proto == IPPROTO_TCP) {
687 key_len = SW_FLOW_KEY_OFFSET(ipv4.tp);
688 if (tcphdr_ok(skb)) {
689 struct tcphdr *tcp = tcp_hdr(skb);
690 key->ipv4.tp.src = tcp->source;
691 key->ipv4.tp.dst = tcp->dest;
692 }
693 } else if (key->ip.proto == IPPROTO_UDP) {
694 key_len = SW_FLOW_KEY_OFFSET(ipv4.tp);
695 if (udphdr_ok(skb)) {
696 struct udphdr *udp = udp_hdr(skb);
697 key->ipv4.tp.src = udp->source;
698 key->ipv4.tp.dst = udp->dest;
699 }
700 } else if (key->ip.proto == IPPROTO_ICMP) {
701 key_len = SW_FLOW_KEY_OFFSET(ipv4.tp);
702 if (icmphdr_ok(skb)) {
703 struct icmphdr *icmp = icmp_hdr(skb);
704 /* The ICMP type and code fields use the 16-bit
705 * transport port fields, so we need to store
706 * them in 16-bit network byte order. */
707 key->ipv4.tp.src = htons(icmp->type);
708 key->ipv4.tp.dst = htons(icmp->code);
709 }
710 }
711
712 } else if ((key->eth.type == htons(ETH_P_ARP) ||
713 key->eth.type == htons(ETH_P_RARP)) && arphdr_ok(skb)) {
714 struct arp_eth_header *arp;
715
716 arp = (struct arp_eth_header *)skb_network_header(skb);
717
718 if (arp->ar_hrd == htons(ARPHRD_ETHER)
719 && arp->ar_pro == htons(ETH_P_IP)
720 && arp->ar_hln == ETH_ALEN
721 && arp->ar_pln == 4) {
722
723 /* We only match on the lower 8 bits of the opcode. */
724 if (ntohs(arp->ar_op) <= 0xff)
725 key->ip.proto = ntohs(arp->ar_op);
726 memcpy(&key->ipv4.addr.src, arp->ar_sip, sizeof(key->ipv4.addr.src));
727 memcpy(&key->ipv4.addr.dst, arp->ar_tip, sizeof(key->ipv4.addr.dst));
728 memcpy(key->ipv4.arp.sha, arp->ar_sha, ETH_ALEN);
729 memcpy(key->ipv4.arp.tha, arp->ar_tha, ETH_ALEN);
730 key_len = SW_FLOW_KEY_OFFSET(ipv4.arp);
731 }
732 } else if (key->eth.type == htons(ETH_P_IPV6)) {
733 int nh_len; /* IPv6 Header + Extensions */
734
735 nh_len = parse_ipv6hdr(skb, key, &key_len);
736 if (unlikely(nh_len < 0)) {
737 if (nh_len == -EINVAL)
738 skb->transport_header = skb->network_header;
739 else
740 error = nh_len;
741 goto out;
742 }
743
744 if (key->ip.frag == OVS_FRAG_TYPE_LATER)
745 goto out;
746 if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP)
747 key->ip.frag = OVS_FRAG_TYPE_FIRST;
748
749 /* Transport layer. */
750 if (key->ip.proto == NEXTHDR_TCP) {
751 key_len = SW_FLOW_KEY_OFFSET(ipv6.tp);
752 if (tcphdr_ok(skb)) {
753 struct tcphdr *tcp = tcp_hdr(skb);
754 key->ipv6.tp.src = tcp->source;
755 key->ipv6.tp.dst = tcp->dest;
756 }
757 } else if (key->ip.proto == NEXTHDR_UDP) {
758 key_len = SW_FLOW_KEY_OFFSET(ipv6.tp);
759 if (udphdr_ok(skb)) {
760 struct udphdr *udp = udp_hdr(skb);
761 key->ipv6.tp.src = udp->source;
762 key->ipv6.tp.dst = udp->dest;
763 }
764 } else if (key->ip.proto == NEXTHDR_ICMP) {
765 key_len = SW_FLOW_KEY_OFFSET(ipv6.tp);
766 if (icmp6hdr_ok(skb)) {
767 error = parse_icmpv6(skb, key, &key_len, nh_len);
768 if (error < 0)
769 goto out;
770 }
771 }
772 }
773
774 out:
775 *key_lenp = key_len;
776 return error;
777 }
778
779 static u32 ovs_flow_hash(const struct sw_flow_key *key, int key_start, int key_len)
780 {
781 return jhash2((u32 *)((u8 *)key + key_start),
782 DIV_ROUND_UP(key_len - key_start, sizeof(u32)), 0);
783 }
784
785 static int flow_key_start(struct sw_flow_key *key)
786 {
787 if (key->phy.tun.tun_key.ipv4_dst)
788 return 0;
789 else
790 return offsetof(struct sw_flow_key, phy.priority);
791 }
792
793 struct sw_flow *ovs_flow_tbl_lookup(struct flow_table *table,
794 struct sw_flow_key *key, int key_len)
795 {
796 struct sw_flow *flow;
797 struct hlist_node *n;
798 struct hlist_head *head;
799 u8 *_key;
800 int key_start;
801 u32 hash;
802
803 key_start = flow_key_start(key);
804 hash = ovs_flow_hash(key, key_start, key_len);
805
806 _key = (u8 *) key + key_start;
807 head = find_bucket(table, hash);
808 hlist_for_each_entry_rcu(flow, n, head, hash_node[table->node_ver]) {
809
810 if (flow->hash == hash &&
811 !memcmp((u8 *)&flow->key + key_start, _key, key_len - key_start)) {
812 return flow;
813 }
814 }
815 return NULL;
816 }
817
818 void ovs_flow_tbl_insert(struct flow_table *table, struct sw_flow *flow,
819 struct sw_flow_key *key, int key_len)
820 {
821 flow->hash = ovs_flow_hash(key, flow_key_start(key), key_len);
822 memcpy(&flow->key, key, sizeof(flow->key));
823 __flow_tbl_insert(table, flow);
824 }
825
826 void ovs_flow_tbl_remove(struct flow_table *table, struct sw_flow *flow)
827 {
828 hlist_del_rcu(&flow->hash_node[table->node_ver]);
829 table->count--;
830 BUG_ON(table->count < 0);
831 }
832
833 /* The size of the argument for each %OVS_KEY_ATTR_* Netlink attribute. */
834 const int ovs_key_lens[OVS_KEY_ATTR_MAX + 1] = {
835 [OVS_KEY_ATTR_ENCAP] = -1,
836 [OVS_KEY_ATTR_PRIORITY] = sizeof(u32),
837 [OVS_KEY_ATTR_IN_PORT] = sizeof(u32),
838 [OVS_KEY_ATTR_ETHERNET] = sizeof(struct ovs_key_ethernet),
839 [OVS_KEY_ATTR_VLAN] = sizeof(__be16),
840 [OVS_KEY_ATTR_ETHERTYPE] = sizeof(__be16),
841 [OVS_KEY_ATTR_IPV4] = sizeof(struct ovs_key_ipv4),
842 [OVS_KEY_ATTR_IPV6] = sizeof(struct ovs_key_ipv6),
843 [OVS_KEY_ATTR_TCP] = sizeof(struct ovs_key_tcp),
844 [OVS_KEY_ATTR_UDP] = sizeof(struct ovs_key_udp),
845 [OVS_KEY_ATTR_ICMP] = sizeof(struct ovs_key_icmp),
846 [OVS_KEY_ATTR_ICMPV6] = sizeof(struct ovs_key_icmpv6),
847 [OVS_KEY_ATTR_ARP] = sizeof(struct ovs_key_arp),
848 [OVS_KEY_ATTR_ND] = sizeof(struct ovs_key_nd),
849
850 /* Not upstream. */
851 [OVS_KEY_ATTR_TUN_ID] = sizeof(__be64),
852 [OVS_KEY_ATTR_IPV4_TUNNEL] = sizeof(struct ovs_key_ipv4_tunnel),
853 };
854
855 static int ipv4_flow_from_nlattrs(struct sw_flow_key *swkey, int *key_len,
856 const struct nlattr *a[], u64 *attrs)
857 {
858 const struct ovs_key_icmp *icmp_key;
859 const struct ovs_key_tcp *tcp_key;
860 const struct ovs_key_udp *udp_key;
861
862 switch (swkey->ip.proto) {
863 case IPPROTO_TCP:
864 if (!(*attrs & (1 << OVS_KEY_ATTR_TCP)))
865 return -EINVAL;
866 *attrs &= ~(1 << OVS_KEY_ATTR_TCP);
867
868 *key_len = SW_FLOW_KEY_OFFSET(ipv4.tp);
869 tcp_key = nla_data(a[OVS_KEY_ATTR_TCP]);
870 swkey->ipv4.tp.src = tcp_key->tcp_src;
871 swkey->ipv4.tp.dst = tcp_key->tcp_dst;
872 break;
873
874 case IPPROTO_UDP:
875 if (!(*attrs & (1 << OVS_KEY_ATTR_UDP)))
876 return -EINVAL;
877 *attrs &= ~(1 << OVS_KEY_ATTR_UDP);
878
879 *key_len = SW_FLOW_KEY_OFFSET(ipv4.tp);
880 udp_key = nla_data(a[OVS_KEY_ATTR_UDP]);
881 swkey->ipv4.tp.src = udp_key->udp_src;
882 swkey->ipv4.tp.dst = udp_key->udp_dst;
883 break;
884
885 case IPPROTO_ICMP:
886 if (!(*attrs & (1 << OVS_KEY_ATTR_ICMP)))
887 return -EINVAL;
888 *attrs &= ~(1 << OVS_KEY_ATTR_ICMP);
889
890 *key_len = SW_FLOW_KEY_OFFSET(ipv4.tp);
891 icmp_key = nla_data(a[OVS_KEY_ATTR_ICMP]);
892 swkey->ipv4.tp.src = htons(icmp_key->icmp_type);
893 swkey->ipv4.tp.dst = htons(icmp_key->icmp_code);
894 break;
895 }
896
897 return 0;
898 }
899
900 static int ipv6_flow_from_nlattrs(struct sw_flow_key *swkey, int *key_len,
901 const struct nlattr *a[], u64 *attrs)
902 {
903 const struct ovs_key_icmpv6 *icmpv6_key;
904 const struct ovs_key_tcp *tcp_key;
905 const struct ovs_key_udp *udp_key;
906
907 switch (swkey->ip.proto) {
908 case IPPROTO_TCP:
909 if (!(*attrs & (1 << OVS_KEY_ATTR_TCP)))
910 return -EINVAL;
911 *attrs &= ~(1 << OVS_KEY_ATTR_TCP);
912
913 *key_len = SW_FLOW_KEY_OFFSET(ipv6.tp);
914 tcp_key = nla_data(a[OVS_KEY_ATTR_TCP]);
915 swkey->ipv6.tp.src = tcp_key->tcp_src;
916 swkey->ipv6.tp.dst = tcp_key->tcp_dst;
917 break;
918
919 case IPPROTO_UDP:
920 if (!(*attrs & (1 << OVS_KEY_ATTR_UDP)))
921 return -EINVAL;
922 *attrs &= ~(1 << OVS_KEY_ATTR_UDP);
923
924 *key_len = SW_FLOW_KEY_OFFSET(ipv6.tp);
925 udp_key = nla_data(a[OVS_KEY_ATTR_UDP]);
926 swkey->ipv6.tp.src = udp_key->udp_src;
927 swkey->ipv6.tp.dst = udp_key->udp_dst;
928 break;
929
930 case IPPROTO_ICMPV6:
931 if (!(*attrs & (1 << OVS_KEY_ATTR_ICMPV6)))
932 return -EINVAL;
933 *attrs &= ~(1 << OVS_KEY_ATTR_ICMPV6);
934
935 *key_len = SW_FLOW_KEY_OFFSET(ipv6.tp);
936 icmpv6_key = nla_data(a[OVS_KEY_ATTR_ICMPV6]);
937 swkey->ipv6.tp.src = htons(icmpv6_key->icmpv6_type);
938 swkey->ipv6.tp.dst = htons(icmpv6_key->icmpv6_code);
939
940 if (swkey->ipv6.tp.src == htons(NDISC_NEIGHBOUR_SOLICITATION) ||
941 swkey->ipv6.tp.src == htons(NDISC_NEIGHBOUR_ADVERTISEMENT)) {
942 const struct ovs_key_nd *nd_key;
943
944 if (!(*attrs & (1 << OVS_KEY_ATTR_ND)))
945 return -EINVAL;
946 *attrs &= ~(1 << OVS_KEY_ATTR_ND);
947
948 *key_len = SW_FLOW_KEY_OFFSET(ipv6.nd);
949 nd_key = nla_data(a[OVS_KEY_ATTR_ND]);
950 memcpy(&swkey->ipv6.nd.target, nd_key->nd_target,
951 sizeof(swkey->ipv6.nd.target));
952 memcpy(swkey->ipv6.nd.sll, nd_key->nd_sll, ETH_ALEN);
953 memcpy(swkey->ipv6.nd.tll, nd_key->nd_tll, ETH_ALEN);
954 }
955 break;
956 }
957
958 return 0;
959 }
960
961 static int parse_flow_nlattrs(const struct nlattr *attr,
962 const struct nlattr *a[], u64 *attrsp)
963 {
964 const struct nlattr *nla;
965 u64 attrs;
966 int rem;
967
968 attrs = 0;
969 nla_for_each_nested(nla, attr, rem) {
970 u16 type = nla_type(nla);
971 int expected_len;
972
973 if (type > OVS_KEY_ATTR_MAX || attrs & (1ULL << type))
974 return -EINVAL;
975
976 expected_len = ovs_key_lens[type];
977 if (nla_len(nla) != expected_len && expected_len != -1)
978 return -EINVAL;
979
980 attrs |= 1ULL << type;
981 a[type] = nla;
982 }
983 if (rem)
984 return -EINVAL;
985
986 *attrsp = attrs;
987 return 0;
988 }
989
990 /**
991 * ovs_flow_from_nlattrs - parses Netlink attributes into a flow key.
992 * @swkey: receives the extracted flow key.
993 * @key_lenp: number of bytes used in @swkey.
994 * @attr: Netlink attribute holding nested %OVS_KEY_ATTR_* Netlink attribute
995 * sequence.
996 */
997 int ovs_flow_from_nlattrs(struct sw_flow_key *swkey, int *key_lenp,
998 const struct nlattr *attr)
999 {
1000 const struct nlattr *a[OVS_KEY_ATTR_MAX + 1];
1001 const struct ovs_key_ethernet *eth_key;
1002 int key_len;
1003 u64 attrs;
1004 int err;
1005
1006 memset(swkey, 0, sizeof(struct sw_flow_key));
1007 key_len = SW_FLOW_KEY_OFFSET(eth);
1008
1009 err = parse_flow_nlattrs(attr, a, &attrs);
1010 if (err)
1011 return err;
1012
1013 /* Metadata attributes. */
1014 if (attrs & (1 << OVS_KEY_ATTR_PRIORITY)) {
1015 swkey->phy.priority = nla_get_u32(a[OVS_KEY_ATTR_PRIORITY]);
1016 attrs &= ~(1 << OVS_KEY_ATTR_PRIORITY);
1017 }
1018 if (attrs & (1 << OVS_KEY_ATTR_IN_PORT)) {
1019 u32 in_port = nla_get_u32(a[OVS_KEY_ATTR_IN_PORT]);
1020 if (in_port >= DP_MAX_PORTS)
1021 return -EINVAL;
1022 swkey->phy.in_port = in_port;
1023 attrs &= ~(1 << OVS_KEY_ATTR_IN_PORT);
1024 } else {
1025 swkey->phy.in_port = DP_MAX_PORTS;
1026 }
1027
1028 if (attrs & (1ULL << OVS_KEY_ATTR_TUN_ID) &&
1029 attrs & (1ULL << OVS_KEY_ATTR_IPV4_TUNNEL)) {
1030 struct ovs_key_ipv4_tunnel *tun_key;
1031 __be64 tun_id;
1032
1033 tun_key = nla_data(a[OVS_KEY_ATTR_IPV4_TUNNEL]);
1034
1035 if (!tun_key->ipv4_dst)
1036 return -EINVAL;
1037 if (!(tun_key->tun_flags & OVS_FLOW_TNL_F_KEY))
1038 return -EINVAL;
1039
1040 tun_id = nla_get_be64(a[OVS_KEY_ATTR_TUN_ID]);
1041 if (tun_id != tun_key->tun_id)
1042 return -EINVAL;
1043
1044 memcpy(&swkey->phy.tun.tun_key, tun_key, sizeof(swkey->phy.tun.tun_key));
1045 attrs &= ~(1ULL << OVS_KEY_ATTR_TUN_ID);
1046 attrs &= ~(1ULL << OVS_KEY_ATTR_IPV4_TUNNEL);
1047 } else if (attrs & (1ULL << OVS_KEY_ATTR_TUN_ID)) {
1048 swkey->phy.tun.tun_key.tun_id = nla_get_be64(a[OVS_KEY_ATTR_TUN_ID]);
1049 swkey->phy.tun.tun_key.tun_flags |= OVS_FLOW_TNL_F_KEY;
1050
1051 attrs &= ~(1ULL << OVS_KEY_ATTR_TUN_ID);
1052 } else if (attrs & (1ULL << OVS_KEY_ATTR_IPV4_TUNNEL)) {
1053 struct ovs_key_ipv4_tunnel *tun_key;
1054 tun_key = nla_data(a[OVS_KEY_ATTR_IPV4_TUNNEL]);
1055
1056 if (!tun_key->ipv4_dst)
1057 return -EINVAL;
1058
1059 memcpy(&swkey->phy.tun.tun_key, tun_key, sizeof(swkey->phy.tun.tun_key));
1060 attrs &= ~(1ULL << OVS_KEY_ATTR_IPV4_TUNNEL);
1061 }
1062
1063 /* Data attributes. */
1064 if (!(attrs & (1 << OVS_KEY_ATTR_ETHERNET)))
1065 return -EINVAL;
1066 attrs &= ~(1 << OVS_KEY_ATTR_ETHERNET);
1067
1068 eth_key = nla_data(a[OVS_KEY_ATTR_ETHERNET]);
1069 memcpy(swkey->eth.src, eth_key->eth_src, ETH_ALEN);
1070 memcpy(swkey->eth.dst, eth_key->eth_dst, ETH_ALEN);
1071
1072 if (attrs & (1u << OVS_KEY_ATTR_ETHERTYPE) &&
1073 nla_get_be16(a[OVS_KEY_ATTR_ETHERTYPE]) == htons(ETH_P_8021Q)) {
1074 const struct nlattr *encap;
1075 __be16 tci;
1076
1077 if (attrs != ((1 << OVS_KEY_ATTR_VLAN) |
1078 (1 << OVS_KEY_ATTR_ETHERTYPE) |
1079 (1 << OVS_KEY_ATTR_ENCAP)))
1080 return -EINVAL;
1081
1082 encap = a[OVS_KEY_ATTR_ENCAP];
1083 tci = nla_get_be16(a[OVS_KEY_ATTR_VLAN]);
1084 if (tci & htons(VLAN_TAG_PRESENT)) {
1085 swkey->eth.tci = tci;
1086
1087 err = parse_flow_nlattrs(encap, a, &attrs);
1088 if (err)
1089 return err;
1090 } else if (!tci) {
1091 /* Corner case for truncated 802.1Q header. */
1092 if (nla_len(encap))
1093 return -EINVAL;
1094
1095 swkey->eth.type = htons(ETH_P_8021Q);
1096 *key_lenp = key_len;
1097 return 0;
1098 } else {
1099 return -EINVAL;
1100 }
1101 }
1102
1103 if (attrs & (1 << OVS_KEY_ATTR_ETHERTYPE)) {
1104 swkey->eth.type = nla_get_be16(a[OVS_KEY_ATTR_ETHERTYPE]);
1105 if (ntohs(swkey->eth.type) < 1536)
1106 return -EINVAL;
1107 attrs &= ~(1 << OVS_KEY_ATTR_ETHERTYPE);
1108 } else {
1109 swkey->eth.type = htons(ETH_P_802_2);
1110 }
1111
1112 if (swkey->eth.type == htons(ETH_P_IP)) {
1113 const struct ovs_key_ipv4 *ipv4_key;
1114
1115 if (!(attrs & (1 << OVS_KEY_ATTR_IPV4)))
1116 return -EINVAL;
1117 attrs &= ~(1 << OVS_KEY_ATTR_IPV4);
1118
1119 key_len = SW_FLOW_KEY_OFFSET(ipv4.addr);
1120 ipv4_key = nla_data(a[OVS_KEY_ATTR_IPV4]);
1121 if (ipv4_key->ipv4_frag > OVS_FRAG_TYPE_MAX)
1122 return -EINVAL;
1123 swkey->ip.proto = ipv4_key->ipv4_proto;
1124 swkey->ip.tos = ipv4_key->ipv4_tos;
1125 swkey->ip.ttl = ipv4_key->ipv4_ttl;
1126 swkey->ip.frag = ipv4_key->ipv4_frag;
1127 swkey->ipv4.addr.src = ipv4_key->ipv4_src;
1128 swkey->ipv4.addr.dst = ipv4_key->ipv4_dst;
1129
1130 if (swkey->ip.frag != OVS_FRAG_TYPE_LATER) {
1131 err = ipv4_flow_from_nlattrs(swkey, &key_len, a, &attrs);
1132 if (err)
1133 return err;
1134 }
1135 } else if (swkey->eth.type == htons(ETH_P_IPV6)) {
1136 const struct ovs_key_ipv6 *ipv6_key;
1137
1138 if (!(attrs & (1 << OVS_KEY_ATTR_IPV6)))
1139 return -EINVAL;
1140 attrs &= ~(1 << OVS_KEY_ATTR_IPV6);
1141
1142 key_len = SW_FLOW_KEY_OFFSET(ipv6.label);
1143 ipv6_key = nla_data(a[OVS_KEY_ATTR_IPV6]);
1144 if (ipv6_key->ipv6_frag > OVS_FRAG_TYPE_MAX)
1145 return -EINVAL;
1146 swkey->ipv6.label = ipv6_key->ipv6_label;
1147 swkey->ip.proto = ipv6_key->ipv6_proto;
1148 swkey->ip.tos = ipv6_key->ipv6_tclass;
1149 swkey->ip.ttl = ipv6_key->ipv6_hlimit;
1150 swkey->ip.frag = ipv6_key->ipv6_frag;
1151 memcpy(&swkey->ipv6.addr.src, ipv6_key->ipv6_src,
1152 sizeof(swkey->ipv6.addr.src));
1153 memcpy(&swkey->ipv6.addr.dst, ipv6_key->ipv6_dst,
1154 sizeof(swkey->ipv6.addr.dst));
1155
1156 if (swkey->ip.frag != OVS_FRAG_TYPE_LATER) {
1157 err = ipv6_flow_from_nlattrs(swkey, &key_len, a, &attrs);
1158 if (err)
1159 return err;
1160 }
1161 } else if (swkey->eth.type == htons(ETH_P_ARP) ||
1162 swkey->eth.type == htons(ETH_P_RARP)) {
1163 const struct ovs_key_arp *arp_key;
1164
1165 if (!(attrs & (1 << OVS_KEY_ATTR_ARP)))
1166 return -EINVAL;
1167 attrs &= ~(1 << OVS_KEY_ATTR_ARP);
1168
1169 key_len = SW_FLOW_KEY_OFFSET(ipv4.arp);
1170 arp_key = nla_data(a[OVS_KEY_ATTR_ARP]);
1171 swkey->ipv4.addr.src = arp_key->arp_sip;
1172 swkey->ipv4.addr.dst = arp_key->arp_tip;
1173 if (arp_key->arp_op & htons(0xff00))
1174 return -EINVAL;
1175 swkey->ip.proto = ntohs(arp_key->arp_op);
1176 memcpy(swkey->ipv4.arp.sha, arp_key->arp_sha, ETH_ALEN);
1177 memcpy(swkey->ipv4.arp.tha, arp_key->arp_tha, ETH_ALEN);
1178 }
1179
1180 if (attrs)
1181 return -EINVAL;
1182 *key_lenp = key_len;
1183
1184 return 0;
1185 }
1186
1187 /**
1188 * ovs_flow_metadata_from_nlattrs - parses Netlink attributes into a flow key.
1189 * @in_port: receives the extracted input port.
1190 * @tun_id: receives the extracted tunnel ID.
1191 * @key: Netlink attribute holding nested %OVS_KEY_ATTR_* Netlink attribute
1192 * sequence.
1193 *
1194 * This parses a series of Netlink attributes that form a flow key, which must
1195 * take the same form accepted by flow_from_nlattrs(), but only enough of it to
1196 * get the metadata, that is, the parts of the flow key that cannot be
1197 * extracted from the packet itself.
1198 */
1199
1200 int ovs_flow_metadata_from_nlattrs(struct sw_flow *flow, int key_len, const struct nlattr *attr)
1201 {
1202 struct ovs_key_ipv4_tunnel *tun_key = &flow->key.phy.tun.tun_key;
1203 const struct nlattr *nla;
1204 int rem;
1205 __be64 tun_id = 0;
1206
1207 flow->key.phy.in_port = DP_MAX_PORTS;
1208 flow->key.phy.priority = 0;
1209 memset(tun_key, 0, sizeof(flow->key.phy.tun.tun_key));
1210
1211 nla_for_each_nested(nla, attr, rem) {
1212 int type = nla_type(nla);
1213
1214 if (type <= OVS_KEY_ATTR_MAX && ovs_key_lens[type] > 0) {
1215 if (nla_len(nla) != ovs_key_lens[type])
1216 return -EINVAL;
1217
1218 switch (type) {
1219 case OVS_KEY_ATTR_PRIORITY:
1220 flow->key.phy.priority = nla_get_u32(nla);
1221 break;
1222
1223 case OVS_KEY_ATTR_TUN_ID:
1224 tun_id = nla_get_be64(nla);
1225
1226 if (tun_key->ipv4_dst) {
1227 if (!(tun_key->tun_flags & OVS_FLOW_TNL_F_KEY))
1228 return -EINVAL;
1229 if (tun_key->tun_id != tun_id)
1230 return -EINVAL;
1231 break;
1232 }
1233 tun_key->tun_id = tun_id;
1234 tun_key->tun_flags |= OVS_FLOW_TNL_F_KEY;
1235
1236 break;
1237
1238 case OVS_KEY_ATTR_IPV4_TUNNEL:
1239 if (tun_key->tun_flags & OVS_FLOW_TNL_F_KEY) {
1240 tun_id = tun_key->tun_id;
1241
1242 memcpy(tun_key, nla_data(nla), sizeof(*tun_key));
1243 if (!(tun_key->tun_flags & OVS_FLOW_TNL_F_KEY))
1244 return -EINVAL;
1245
1246 if (tun_key->tun_id != tun_id)
1247 return -EINVAL;
1248 } else
1249 memcpy(tun_key, nla_data(nla), sizeof(*tun_key));
1250
1251 if (!tun_key->ipv4_dst)
1252 return -EINVAL;
1253 break;
1254
1255 case OVS_KEY_ATTR_IN_PORT:
1256 if (nla_get_u32(nla) >= DP_MAX_PORTS)
1257 return -EINVAL;
1258 flow->key.phy.in_port = nla_get_u32(nla);
1259 break;
1260 }
1261 }
1262 }
1263 if (rem)
1264 return -EINVAL;
1265
1266 flow->hash = ovs_flow_hash(&flow->key,
1267 flow_key_start(&flow->key), key_len);
1268
1269 return 0;
1270 }
1271
1272 int ovs_flow_to_nlattrs(const struct sw_flow_key *swkey, struct sk_buff *skb)
1273 {
1274 struct ovs_key_ethernet *eth_key;
1275 struct nlattr *nla, *encap;
1276
1277 if (swkey->phy.priority &&
1278 nla_put_u32(skb, OVS_KEY_ATTR_PRIORITY, swkey->phy.priority))
1279 goto nla_put_failure;
1280
1281 if (swkey->phy.tun.tun_key.ipv4_dst) {
1282 struct ovs_key_ipv4_tunnel *tun_key;
1283 nla = nla_reserve(skb, OVS_KEY_ATTR_IPV4_TUNNEL, sizeof(*tun_key));
1284 if (!nla)
1285 goto nla_put_failure;
1286 tun_key = nla_data(nla);
1287 memcpy(tun_key, &swkey->phy.tun.tun_key, sizeof(*tun_key));
1288 }
1289 if ((swkey->phy.tun.tun_key.tun_flags & OVS_FLOW_TNL_F_KEY) &&
1290 nla_put_be64(skb, OVS_KEY_ATTR_TUN_ID, swkey->phy.tun.tun_key.tun_id))
1291 goto nla_put_failure;
1292
1293 if (swkey->phy.in_port != DP_MAX_PORTS &&
1294 nla_put_u32(skb, OVS_KEY_ATTR_IN_PORT, swkey->phy.in_port))
1295 goto nla_put_failure;
1296
1297 nla = nla_reserve(skb, OVS_KEY_ATTR_ETHERNET, sizeof(*eth_key));
1298 if (!nla)
1299 goto nla_put_failure;
1300 eth_key = nla_data(nla);
1301 memcpy(eth_key->eth_src, swkey->eth.src, ETH_ALEN);
1302 memcpy(eth_key->eth_dst, swkey->eth.dst, ETH_ALEN);
1303
1304 if (swkey->eth.tci || swkey->eth.type == htons(ETH_P_8021Q)) {
1305 if (nla_put_be16(skb, OVS_KEY_ATTR_ETHERTYPE, htons(ETH_P_8021Q)) ||
1306 nla_put_be16(skb, OVS_KEY_ATTR_VLAN, swkey->eth.tci))
1307 goto nla_put_failure;
1308 encap = nla_nest_start(skb, OVS_KEY_ATTR_ENCAP);
1309 if (!swkey->eth.tci)
1310 goto unencap;
1311 } else {
1312 encap = NULL;
1313 }
1314
1315 if (swkey->eth.type == htons(ETH_P_802_2))
1316 goto unencap;
1317
1318 if (nla_put_be16(skb, OVS_KEY_ATTR_ETHERTYPE, swkey->eth.type))
1319 goto nla_put_failure;
1320
1321 if (swkey->eth.type == htons(ETH_P_IP)) {
1322 struct ovs_key_ipv4 *ipv4_key;
1323
1324 nla = nla_reserve(skb, OVS_KEY_ATTR_IPV4, sizeof(*ipv4_key));
1325 if (!nla)
1326 goto nla_put_failure;
1327 ipv4_key = nla_data(nla);
1328 ipv4_key->ipv4_src = swkey->ipv4.addr.src;
1329 ipv4_key->ipv4_dst = swkey->ipv4.addr.dst;
1330 ipv4_key->ipv4_proto = swkey->ip.proto;
1331 ipv4_key->ipv4_tos = swkey->ip.tos;
1332 ipv4_key->ipv4_ttl = swkey->ip.ttl;
1333 ipv4_key->ipv4_frag = swkey->ip.frag;
1334 } else if (swkey->eth.type == htons(ETH_P_IPV6)) {
1335 struct ovs_key_ipv6 *ipv6_key;
1336
1337 nla = nla_reserve(skb, OVS_KEY_ATTR_IPV6, sizeof(*ipv6_key));
1338 if (!nla)
1339 goto nla_put_failure;
1340 ipv6_key = nla_data(nla);
1341 memcpy(ipv6_key->ipv6_src, &swkey->ipv6.addr.src,
1342 sizeof(ipv6_key->ipv6_src));
1343 memcpy(ipv6_key->ipv6_dst, &swkey->ipv6.addr.dst,
1344 sizeof(ipv6_key->ipv6_dst));
1345 ipv6_key->ipv6_label = swkey->ipv6.label;
1346 ipv6_key->ipv6_proto = swkey->ip.proto;
1347 ipv6_key->ipv6_tclass = swkey->ip.tos;
1348 ipv6_key->ipv6_hlimit = swkey->ip.ttl;
1349 ipv6_key->ipv6_frag = swkey->ip.frag;
1350 } else if (swkey->eth.type == htons(ETH_P_ARP) ||
1351 swkey->eth.type == htons(ETH_P_RARP)) {
1352 struct ovs_key_arp *arp_key;
1353
1354 nla = nla_reserve(skb, OVS_KEY_ATTR_ARP, sizeof(*arp_key));
1355 if (!nla)
1356 goto nla_put_failure;
1357 arp_key = nla_data(nla);
1358 memset(arp_key, 0, sizeof(struct ovs_key_arp));
1359 arp_key->arp_sip = swkey->ipv4.addr.src;
1360 arp_key->arp_tip = swkey->ipv4.addr.dst;
1361 arp_key->arp_op = htons(swkey->ip.proto);
1362 memcpy(arp_key->arp_sha, swkey->ipv4.arp.sha, ETH_ALEN);
1363 memcpy(arp_key->arp_tha, swkey->ipv4.arp.tha, ETH_ALEN);
1364 }
1365
1366 if ((swkey->eth.type == htons(ETH_P_IP) ||
1367 swkey->eth.type == htons(ETH_P_IPV6)) &&
1368 swkey->ip.frag != OVS_FRAG_TYPE_LATER) {
1369
1370 if (swkey->ip.proto == IPPROTO_TCP) {
1371 struct ovs_key_tcp *tcp_key;
1372
1373 nla = nla_reserve(skb, OVS_KEY_ATTR_TCP, sizeof(*tcp_key));
1374 if (!nla)
1375 goto nla_put_failure;
1376 tcp_key = nla_data(nla);
1377 if (swkey->eth.type == htons(ETH_P_IP)) {
1378 tcp_key->tcp_src = swkey->ipv4.tp.src;
1379 tcp_key->tcp_dst = swkey->ipv4.tp.dst;
1380 } else if (swkey->eth.type == htons(ETH_P_IPV6)) {
1381 tcp_key->tcp_src = swkey->ipv6.tp.src;
1382 tcp_key->tcp_dst = swkey->ipv6.tp.dst;
1383 }
1384 } else if (swkey->ip.proto == IPPROTO_UDP) {
1385 struct ovs_key_udp *udp_key;
1386
1387 nla = nla_reserve(skb, OVS_KEY_ATTR_UDP, sizeof(*udp_key));
1388 if (!nla)
1389 goto nla_put_failure;
1390 udp_key = nla_data(nla);
1391 if (swkey->eth.type == htons(ETH_P_IP)) {
1392 udp_key->udp_src = swkey->ipv4.tp.src;
1393 udp_key->udp_dst = swkey->ipv4.tp.dst;
1394 } else if (swkey->eth.type == htons(ETH_P_IPV6)) {
1395 udp_key->udp_src = swkey->ipv6.tp.src;
1396 udp_key->udp_dst = swkey->ipv6.tp.dst;
1397 }
1398 } else if (swkey->eth.type == htons(ETH_P_IP) &&
1399 swkey->ip.proto == IPPROTO_ICMP) {
1400 struct ovs_key_icmp *icmp_key;
1401
1402 nla = nla_reserve(skb, OVS_KEY_ATTR_ICMP, sizeof(*icmp_key));
1403 if (!nla)
1404 goto nla_put_failure;
1405 icmp_key = nla_data(nla);
1406 icmp_key->icmp_type = ntohs(swkey->ipv4.tp.src);
1407 icmp_key->icmp_code = ntohs(swkey->ipv4.tp.dst);
1408 } else if (swkey->eth.type == htons(ETH_P_IPV6) &&
1409 swkey->ip.proto == IPPROTO_ICMPV6) {
1410 struct ovs_key_icmpv6 *icmpv6_key;
1411
1412 nla = nla_reserve(skb, OVS_KEY_ATTR_ICMPV6,
1413 sizeof(*icmpv6_key));
1414 if (!nla)
1415 goto nla_put_failure;
1416 icmpv6_key = nla_data(nla);
1417 icmpv6_key->icmpv6_type = ntohs(swkey->ipv6.tp.src);
1418 icmpv6_key->icmpv6_code = ntohs(swkey->ipv6.tp.dst);
1419
1420 if (icmpv6_key->icmpv6_type == NDISC_NEIGHBOUR_SOLICITATION ||
1421 icmpv6_key->icmpv6_type == NDISC_NEIGHBOUR_ADVERTISEMENT) {
1422 struct ovs_key_nd *nd_key;
1423
1424 nla = nla_reserve(skb, OVS_KEY_ATTR_ND, sizeof(*nd_key));
1425 if (!nla)
1426 goto nla_put_failure;
1427 nd_key = nla_data(nla);
1428 memcpy(nd_key->nd_target, &swkey->ipv6.nd.target,
1429 sizeof(nd_key->nd_target));
1430 memcpy(nd_key->nd_sll, swkey->ipv6.nd.sll, ETH_ALEN);
1431 memcpy(nd_key->nd_tll, swkey->ipv6.nd.tll, ETH_ALEN);
1432 }
1433 }
1434 }
1435
1436 unencap:
1437 if (encap)
1438 nla_nest_end(skb, encap);
1439
1440 return 0;
1441
1442 nla_put_failure:
1443 return -EMSGSIZE;
1444 }
1445
1446 /* Initializes the flow module.
1447 * Returns zero if successful or a negative error code. */
1448 int ovs_flow_init(void)
1449 {
1450 flow_cache = kmem_cache_create("sw_flow", sizeof(struct sw_flow), 0,
1451 0, NULL);
1452 if (flow_cache == NULL)
1453 return -ENOMEM;
1454
1455 return 0;
1456 }
1457
1458 /* Uninitializes the flow module. */
1459 void ovs_flow_exit(void)
1460 {
1461 kmem_cache_destroy(flow_cache);
1462 }
openvswitch mirror