~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/openvswitch/flow.c

Version: ~ [ linux-5.17-rc1 ] ~ [ linux-5.16.2 ] ~ [ linux-5.15.16 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.93 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.173 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.225 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.262 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.297 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.299 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Copyright (c) 2007-2014 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 <linux/uaccess.h>
 20 #include <linux/netdevice.h>
 21 #include <linux/etherdevice.h>
 22 #include <linux/if_ether.h>
 23 #include <linux/if_vlan.h>
 24 #include <net/llc_pdu.h>
 25 #include <linux/kernel.h>
 26 #include <linux/jhash.h>
 27 #include <linux/jiffies.h>
 28 #include <linux/llc.h>
 29 #include <linux/module.h>
 30 #include <linux/in.h>
 31 #include <linux/rcupdate.h>
 32 #include <linux/if_arp.h>
 33 #include <linux/ip.h>
 34 #include <linux/ipv6.h>
 35 #include <linux/mpls.h>
 36 #include <linux/sctp.h>
 37 #include <linux/smp.h>
 38 #include <linux/tcp.h>
 39 #include <linux/udp.h>
 40 #include <linux/icmp.h>
 41 #include <linux/icmpv6.h>
 42 #include <linux/rculist.h>
 43 #include <net/ip.h>
 44 #include <net/ip_tunnels.h>
 45 #include <net/ipv6.h>
 46 #include <net/mpls.h>
 47 #include <net/ndisc.h>
 48 
 49 #include "datapath.h"
 50 #include "flow.h"
 51 #include "flow_netlink.h"
 52 
 53 u64 ovs_flow_used_time(unsigned long flow_jiffies)
 54 {
 55         struct timespec cur_ts;
 56         u64 cur_ms, idle_ms;
 57 
 58         ktime_get_ts(&cur_ts);
 59         idle_ms = jiffies_to_msecs(jiffies - flow_jiffies);
 60         cur_ms = (u64)cur_ts.tv_sec * MSEC_PER_SEC +
 61                  cur_ts.tv_nsec / NSEC_PER_MSEC;
 62 
 63         return cur_ms - idle_ms;
 64 }
 65 
 66 #define TCP_FLAGS_BE16(tp) (*(__be16 *)&tcp_flag_word(tp) & htons(0x0FFF))
 67 
 68 void ovs_flow_stats_update(struct sw_flow *flow, __be16 tcp_flags,
 69                            const struct sk_buff *skb)
 70 {
 71         struct flow_stats *stats;
 72         int node = numa_node_id();
 73         int len = skb->len + (skb_vlan_tag_present(skb) ? VLAN_HLEN : 0);
 74 
 75         stats = rcu_dereference(flow->stats[node]);
 76 
 77         /* Check if already have node-specific stats. */
 78         if (likely(stats)) {
 79                 spin_lock(&stats->lock);
 80                 /* Mark if we write on the pre-allocated stats. */
 81                 if (node == 0 && unlikely(flow->stats_last_writer != node))
 82                         flow->stats_last_writer = node;
 83         } else {
 84                 stats = rcu_dereference(flow->stats[0]); /* Pre-allocated. */
 85                 spin_lock(&stats->lock);
 86 
 87                 /* If the current NUMA-node is the only writer on the
 88                  * pre-allocated stats keep using them.
 89                  */
 90                 if (unlikely(flow->stats_last_writer != node)) {
 91                         /* A previous locker may have already allocated the
 92                          * stats, so we need to check again.  If node-specific
 93                          * stats were already allocated, we update the pre-
 94                          * allocated stats as we have already locked them.
 95                          */
 96                         if (likely(flow->stats_last_writer != NUMA_NO_NODE)
 97                             && likely(!rcu_access_pointer(flow->stats[node]))) {
 98                                 /* Try to allocate node-specific stats. */
 99                                 struct flow_stats *new_stats;
100 
101                                 new_stats =
102                                         kmem_cache_alloc_node(flow_stats_cache,
103                                                               GFP_THISNODE |
104                                                               __GFP_NOMEMALLOC,
105                                                               node);
106                                 if (likely(new_stats)) {
107                                         new_stats->used = jiffies;
108                                         new_stats->packet_count = 1;
109                                         new_stats->byte_count = len;
110                                         new_stats->tcp_flags = tcp_flags;
111                                         spin_lock_init(&new_stats->lock);
112 
113                                         rcu_assign_pointer(flow->stats[node],
114                                                            new_stats);
115                                         goto unlock;
116                                 }
117                         }
118                         flow->stats_last_writer = node;
119                 }
120         }
121 
122         stats->used = jiffies;
123         stats->packet_count++;
124         stats->byte_count += len;
125         stats->tcp_flags |= tcp_flags;
126 unlock:
127         spin_unlock(&stats->lock);
128 }
129 
130 /* Must be called with rcu_read_lock or ovs_mutex. */
131 void ovs_flow_stats_get(const struct sw_flow *flow,
132                         struct ovs_flow_stats *ovs_stats,
133                         unsigned long *used, __be16 *tcp_flags)
134 {
135         int node;
136 
137         *used = 0;
138         *tcp_flags = 0;
139         memset(ovs_stats, 0, sizeof(*ovs_stats));
140 
141         for_each_node(node) {
142                 struct flow_stats *stats = rcu_dereference_ovsl(flow->stats[node]);
143 
144                 if (stats) {
145                         /* Local CPU may write on non-local stats, so we must
146                          * block bottom-halves here.
147                          */
148                         spin_lock_bh(&stats->lock);
149                         if (!*used || time_after(stats->used, *used))
150                                 *used = stats->used;
151                         *tcp_flags |= stats->tcp_flags;
152                         ovs_stats->n_packets += stats->packet_count;
153                         ovs_stats->n_bytes += stats->byte_count;
154                         spin_unlock_bh(&stats->lock);
155                 }
156         }
157 }
158 
159 /* Called with ovs_mutex. */
160 void ovs_flow_stats_clear(struct sw_flow *flow)
161 {
162         int node;
163 
164         for_each_node(node) {
165                 struct flow_stats *stats = ovsl_dereference(flow->stats[node]);
166 
167                 if (stats) {
168                         spin_lock_bh(&stats->lock);
169                         stats->used = 0;
170                         stats->packet_count = 0;
171                         stats->byte_count = 0;
172                         stats->tcp_flags = 0;
173                         spin_unlock_bh(&stats->lock);
174                 }
175         }
176 }
177 
178 static int check_header(struct sk_buff *skb, int len)
179 {
180         if (unlikely(skb->len < len))
181                 return -EINVAL;
182         if (unlikely(!pskb_may_pull(skb, len)))
183                 return -ENOMEM;
184         return 0;
185 }
186 
187 static bool arphdr_ok(struct sk_buff *skb)
188 {
189         return pskb_may_pull(skb, skb_network_offset(skb) +
190                                   sizeof(struct arp_eth_header));
191 }
192 
193 static int check_iphdr(struct sk_buff *skb)
194 {
195         unsigned int nh_ofs = skb_network_offset(skb);
196         unsigned int ip_len;
197         int err;
198 
199         err = check_header(skb, nh_ofs + sizeof(struct iphdr));
200         if (unlikely(err))
201                 return err;
202 
203         ip_len = ip_hdrlen(skb);
204         if (unlikely(ip_len < sizeof(struct iphdr) ||
205                      skb->len < nh_ofs + ip_len))
206                 return -EINVAL;
207 
208         skb_set_transport_header(skb, nh_ofs + ip_len);
209         return 0;
210 }
211 
212 static bool tcphdr_ok(struct sk_buff *skb)
213 {
214         int th_ofs = skb_transport_offset(skb);
215         int tcp_len;
216 
217         if (unlikely(!pskb_may_pull(skb, th_ofs + sizeof(struct tcphdr))))
218                 return false;
219 
220         tcp_len = tcp_hdrlen(skb);
221         if (unlikely(tcp_len < sizeof(struct tcphdr) ||
222                      skb->len < th_ofs + tcp_len))
223                 return false;
224 
225         return true;
226 }
227 
228 static bool udphdr_ok(struct sk_buff *skb)
229 {
230         return pskb_may_pull(skb, skb_transport_offset(skb) +
231                                   sizeof(struct udphdr));
232 }
233 
234 static bool sctphdr_ok(struct sk_buff *skb)
235 {
236         return pskb_may_pull(skb, skb_transport_offset(skb) +
237                                   sizeof(struct sctphdr));
238 }
239 
240 static bool icmphdr_ok(struct sk_buff *skb)
241 {
242         return pskb_may_pull(skb, skb_transport_offset(skb) +
243                                   sizeof(struct icmphdr));
244 }
245 
246 static int parse_ipv6hdr(struct sk_buff *skb, struct sw_flow_key *key)
247 {
248         unsigned int nh_ofs = skb_network_offset(skb);
249         unsigned int nh_len;
250         int payload_ofs;
251         struct ipv6hdr *nh;
252         uint8_t nexthdr;
253         __be16 frag_off;
254         int err;
255 
256         err = check_header(skb, nh_ofs + sizeof(*nh));
257         if (unlikely(err))
258                 return err;
259 
260         nh = ipv6_hdr(skb);
261         nexthdr = nh->nexthdr;
262         payload_ofs = (u8 *)(nh + 1) - skb->data;
263 
264         key->ip.proto = NEXTHDR_NONE;
265         key->ip.tos = ipv6_get_dsfield(nh);
266         key->ip.ttl = nh->hop_limit;
267         key->ipv6.label = *(__be32 *)nh & htonl(IPV6_FLOWINFO_FLOWLABEL);
268         key->ipv6.addr.src = nh->saddr;
269         key->ipv6.addr.dst = nh->daddr;
270 
271         payload_ofs = ipv6_skip_exthdr(skb, payload_ofs, &nexthdr, &frag_off);
272         if (unlikely(payload_ofs < 0))
273                 return -EINVAL;
274 
275         if (frag_off) {
276                 if (frag_off & htons(~0x7))
277                         key->ip.frag = OVS_FRAG_TYPE_LATER;
278                 else
279                         key->ip.frag = OVS_FRAG_TYPE_FIRST;
280         } else {
281                 key->ip.frag = OVS_FRAG_TYPE_NONE;
282         }
283 
284         nh_len = payload_ofs - nh_ofs;
285         skb_set_transport_header(skb, nh_ofs + nh_len);
286         key->ip.proto = nexthdr;
287         return nh_len;
288 }
289 
290 static bool icmp6hdr_ok(struct sk_buff *skb)
291 {
292         return pskb_may_pull(skb, skb_transport_offset(skb) +
293                                   sizeof(struct icmp6hdr));
294 }
295 
296 static int parse_vlan(struct sk_buff *skb, struct sw_flow_key *key)
297 {
298         struct qtag_prefix {
299                 __be16 eth_type; /* ETH_P_8021Q */
300                 __be16 tci;
301         };
302         struct qtag_prefix *qp;
303 
304         if (unlikely(skb->len < sizeof(struct qtag_prefix) + sizeof(__be16)))
305                 return 0;
306 
307         if (unlikely(!pskb_may_pull(skb, sizeof(struct qtag_prefix) +
308                                          sizeof(__be16))))
309                 return -ENOMEM;
310 
311         qp = (struct qtag_prefix *) skb->data;
312         key->eth.tci = qp->tci | htons(VLAN_TAG_PRESENT);
313         __skb_pull(skb, sizeof(struct qtag_prefix));
314 
315         return 0;
316 }
317 
318 static __be16 parse_ethertype(struct sk_buff *skb)
319 {
320         struct llc_snap_hdr {
321                 u8  dsap;  /* Always 0xAA */
322                 u8  ssap;  /* Always 0xAA */
323                 u8  ctrl;
324                 u8  oui[3];
325                 __be16 ethertype;
326         };
327         struct llc_snap_hdr *llc;
328         __be16 proto;
329 
330         proto = *(__be16 *) skb->data;
331         __skb_pull(skb, sizeof(__be16));
332 
333         if (ntohs(proto) >= ETH_P_802_3_MIN)
334                 return proto;
335 
336         if (skb->len < sizeof(struct llc_snap_hdr))
337                 return htons(ETH_P_802_2);
338 
339         if (unlikely(!pskb_may_pull(skb, sizeof(struct llc_snap_hdr))))
340                 return htons(0);
341 
342         llc = (struct llc_snap_hdr *) skb->data;
343         if (llc->dsap != LLC_SAP_SNAP ||
344             llc->ssap != LLC_SAP_SNAP ||
345             (llc->oui[0] | llc->oui[1] | llc->oui[2]) != 0)
346                 return htons(ETH_P_802_2);
347 
348         __skb_pull(skb, sizeof(struct llc_snap_hdr));
349 
350         if (ntohs(llc->ethertype) >= ETH_P_802_3_MIN)
351                 return llc->ethertype;
352 
353         return htons(ETH_P_802_2);
354 }
355 
356 static int parse_icmpv6(struct sk_buff *skb, struct sw_flow_key *key,
357                         int nh_len)
358 {
359         struct icmp6hdr *icmp = icmp6_hdr(skb);
360 
361         /* The ICMPv6 type and code fields use the 16-bit transport port
362          * fields, so we need to store them in 16-bit network byte order.
363          */
364         key->tp.src = htons(icmp->icmp6_type);
365         key->tp.dst = htons(icmp->icmp6_code);
366         memset(&key->ipv6.nd, 0, sizeof(key->ipv6.nd));
367 
368         if (icmp->icmp6_code == 0 &&
369             (icmp->icmp6_type == NDISC_NEIGHBOUR_SOLICITATION ||
370              icmp->icmp6_type == NDISC_NEIGHBOUR_ADVERTISEMENT)) {
371                 int icmp_len = skb->len - skb_transport_offset(skb);
372                 struct nd_msg *nd;
373                 int offset;
374 
375                 /* In order to process neighbor discovery options, we need the
376                  * entire packet.
377                  */
378                 if (unlikely(icmp_len < sizeof(*nd)))
379                         return 0;
380 
381                 if (unlikely(skb_linearize(skb)))
382                         return -ENOMEM;
383 
384                 nd = (struct nd_msg *)skb_transport_header(skb);
385                 key->ipv6.nd.target = nd->target;
386 
387                 icmp_len -= sizeof(*nd);
388                 offset = 0;
389                 while (icmp_len >= 8) {
390                         struct nd_opt_hdr *nd_opt =
391                                  (struct nd_opt_hdr *)(nd->opt + offset);
392                         int opt_len = nd_opt->nd_opt_len * 8;
393 
394                         if (unlikely(!opt_len || opt_len > icmp_len))
395                                 return 0;
396 
397                         /* Store the link layer address if the appropriate
398                          * option is provided.  It is considered an error if
399                          * the same link layer option is specified twice.
400                          */
401                         if (nd_opt->nd_opt_type == ND_OPT_SOURCE_LL_ADDR
402                             && opt_len == 8) {
403                                 if (unlikely(!is_zero_ether_addr(key->ipv6.nd.sll)))
404                                         goto invalid;
405                                 ether_addr_copy(key->ipv6.nd.sll,
406                                                 &nd->opt[offset+sizeof(*nd_opt)]);
407                         } else if (nd_opt->nd_opt_type == ND_OPT_TARGET_LL_ADDR
408                                    && opt_len == 8) {
409                                 if (unlikely(!is_zero_ether_addr(key->ipv6.nd.tll)))
410                                         goto invalid;
411                                 ether_addr_copy(key->ipv6.nd.tll,
412                                                 &nd->opt[offset+sizeof(*nd_opt)]);
413                         }
414 
415                         icmp_len -= opt_len;
416                         offset += opt_len;
417                 }
418         }
419 
420         return 0;
421 
422 invalid:
423         memset(&key->ipv6.nd.target, 0, sizeof(key->ipv6.nd.target));
424         memset(key->ipv6.nd.sll, 0, sizeof(key->ipv6.nd.sll));
425         memset(key->ipv6.nd.tll, 0, sizeof(key->ipv6.nd.tll));
426 
427         return 0;
428 }
429 
430 /**
431  * key_extract - extracts a flow key from an Ethernet frame.
432  * @skb: sk_buff that contains the frame, with skb->data pointing to the
433  * Ethernet header
434  * @key: output flow key
435  *
436  * The caller must ensure that skb->len >= ETH_HLEN.
437  *
438  * Returns 0 if successful, otherwise a negative errno value.
439  *
440  * Initializes @skb header pointers as follows:
441  *
442  *    - skb->mac_header: the Ethernet header.
443  *
444  *    - skb->network_header: just past the Ethernet header, or just past the
445  *      VLAN header, to the first byte of the Ethernet payload.
446  *
447  *    - skb->transport_header: If key->eth.type is ETH_P_IP or ETH_P_IPV6
448  *      on output, then just past the IP header, if one is present and
449  *      of a correct length, otherwise the same as skb->network_header.
450  *      For other key->eth.type values it is left untouched.
451  */
452 static int key_extract(struct sk_buff *skb, struct sw_flow_key *key)
453 {
454         int error;
455         struct ethhdr *eth;
456 
457         /* Flags are always used as part of stats */
458         key->tp.flags = 0;
459 
460         skb_reset_mac_header(skb);
461 
462         /* Link layer.  We are guaranteed to have at least the 14 byte Ethernet
463          * header in the linear data area.
464          */
465         eth = eth_hdr(skb);
466         ether_addr_copy(key->eth.src, eth->h_source);
467         ether_addr_copy(key->eth.dst, eth->h_dest);
468 
469         __skb_pull(skb, 2 * ETH_ALEN);
470         /* We are going to push all headers that we pull, so no need to
471          * update skb->csum here.
472          */
473 
474         key->eth.tci = 0;
475         if (skb_vlan_tag_present(skb))
476                 key->eth.tci = htons(skb->vlan_tci);
477         else if (eth->h_proto == htons(ETH_P_8021Q))
478                 if (unlikely(parse_vlan(skb, key)))
479                         return -ENOMEM;
480 
481         key->eth.type = parse_ethertype(skb);
482         if (unlikely(key->eth.type == htons(0)))
483                 return -ENOMEM;
484 
485         skb_reset_network_header(skb);
486         skb_reset_mac_len(skb);
487         __skb_push(skb, skb->data - skb_mac_header(skb));
488 
489         /* Network layer. */
490         if (key->eth.type == htons(ETH_P_IP)) {
491                 struct iphdr *nh;
492                 __be16 offset;
493 
494                 error = check_iphdr(skb);
495                 if (unlikely(error)) {
496                         memset(&key->ip, 0, sizeof(key->ip));
497                         memset(&key->ipv4, 0, sizeof(key->ipv4));
498                         if (error == -EINVAL) {
499                                 skb->transport_header = skb->network_header;
500                                 error = 0;
501                         }
502                         return error;
503                 }
504 
505                 nh = ip_hdr(skb);
506                 key->ipv4.addr.src = nh->saddr;
507                 key->ipv4.addr.dst = nh->daddr;
508 
509                 key->ip.proto = nh->protocol;
510                 key->ip.tos = nh->tos;
511                 key->ip.ttl = nh->ttl;
512 
513                 offset = nh->frag_off & htons(IP_OFFSET);
514                 if (offset) {
515                         key->ip.frag = OVS_FRAG_TYPE_LATER;
516                         return 0;
517                 }
518                 if (nh->frag_off & htons(IP_MF) ||
519                         skb_shinfo(skb)->gso_type & SKB_GSO_UDP)
520                         key->ip.frag = OVS_FRAG_TYPE_FIRST;
521                 else
522                         key->ip.frag = OVS_FRAG_TYPE_NONE;
523 
524                 /* Transport layer. */
525                 if (key->ip.proto == IPPROTO_TCP) {
526                         if (tcphdr_ok(skb)) {
527                                 struct tcphdr *tcp = tcp_hdr(skb);
528                                 key->tp.src = tcp->source;
529                                 key->tp.dst = tcp->dest;
530                                 key->tp.flags = TCP_FLAGS_BE16(tcp);
531                         } else {
532                                 memset(&key->tp, 0, sizeof(key->tp));
533                         }
534 
535                 } else if (key->ip.proto == IPPROTO_UDP) {
536                         if (udphdr_ok(skb)) {
537                                 struct udphdr *udp = udp_hdr(skb);
538                                 key->tp.src = udp->source;
539                                 key->tp.dst = udp->dest;
540                         } else {
541                                 memset(&key->tp, 0, sizeof(key->tp));
542                         }
543                 } else if (key->ip.proto == IPPROTO_SCTP) {
544                         if (sctphdr_ok(skb)) {
545                                 struct sctphdr *sctp = sctp_hdr(skb);
546                                 key->tp.src = sctp->source;
547                                 key->tp.dst = sctp->dest;
548                         } else {
549                                 memset(&key->tp, 0, sizeof(key->tp));
550                         }
551                 } else if (key->ip.proto == IPPROTO_ICMP) {
552                         if (icmphdr_ok(skb)) {
553                                 struct icmphdr *icmp = icmp_hdr(skb);
554                                 /* The ICMP type and code fields use the 16-bit
555                                  * transport port fields, so we need to store
556                                  * them in 16-bit network byte order. */
557                                 key->tp.src = htons(icmp->type);
558                                 key->tp.dst = htons(icmp->code);
559                         } else {
560                                 memset(&key->tp, 0, sizeof(key->tp));
561                         }
562                 }
563 
564         } else if (key->eth.type == htons(ETH_P_ARP) ||
565                    key->eth.type == htons(ETH_P_RARP)) {
566                 struct arp_eth_header *arp;
567                 bool arp_available = arphdr_ok(skb);
568 
569                 arp = (struct arp_eth_header *)skb_network_header(skb);
570 
571                 if (arp_available &&
572                     arp->ar_hrd == htons(ARPHRD_ETHER) &&
573                     arp->ar_pro == htons(ETH_P_IP) &&
574                     arp->ar_hln == ETH_ALEN &&
575                     arp->ar_pln == 4) {
576 
577                         /* We only match on the lower 8 bits of the opcode. */
578                         if (ntohs(arp->ar_op) <= 0xff)
579                                 key->ip.proto = ntohs(arp->ar_op);
580                         else
581                                 key->ip.proto = 0;
582 
583                         memcpy(&key->ipv4.addr.src, arp->ar_sip, sizeof(key->ipv4.addr.src));
584                         memcpy(&key->ipv4.addr.dst, arp->ar_tip, sizeof(key->ipv4.addr.dst));
585                         ether_addr_copy(key->ipv4.arp.sha, arp->ar_sha);
586                         ether_addr_copy(key->ipv4.arp.tha, arp->ar_tha);
587                 } else {
588                         memset(&key->ip, 0, sizeof(key->ip));
589                         memset(&key->ipv4, 0, sizeof(key->ipv4));
590                 }
591         } else if (eth_p_mpls(key->eth.type)) {
592                 size_t stack_len = MPLS_HLEN;
593 
594                 /* In the presence of an MPLS label stack the end of the L2
595                  * header and the beginning of the L3 header differ.
596                  *
597                  * Advance network_header to the beginning of the L3
598                  * header. mac_len corresponds to the end of the L2 header.
599                  */
600                 while (1) {
601                         __be32 lse;
602 
603                         error = check_header(skb, skb->mac_len + stack_len);
604                         if (unlikely(error))
605                                 return 0;
606 
607                         memcpy(&lse, skb_network_header(skb), MPLS_HLEN);
608 
609                         if (stack_len == MPLS_HLEN)
610                                 memcpy(&key->mpls.top_lse, &lse, MPLS_HLEN);
611 
612                         skb_set_network_header(skb, skb->mac_len + stack_len);
613                         if (lse & htonl(MPLS_LS_S_MASK))
614                                 break;
615 
616                         stack_len += MPLS_HLEN;
617                 }
618         } else if (key->eth.type == htons(ETH_P_IPV6)) {
619                 int nh_len;             /* IPv6 Header + Extensions */
620 
621                 nh_len = parse_ipv6hdr(skb, key);
622                 if (unlikely(nh_len < 0)) {
623                         memset(&key->ip, 0, sizeof(key->ip));
624                         memset(&key->ipv6.addr, 0, sizeof(key->ipv6.addr));
625                         if (nh_len == -EINVAL) {
626                                 skb->transport_header = skb->network_header;
627                                 error = 0;
628                         } else {
629                                 error = nh_len;
630                         }
631                         return error;
632                 }
633 
634                 if (key->ip.frag == OVS_FRAG_TYPE_LATER)
635                         return 0;
636                 if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP)
637                         key->ip.frag = OVS_FRAG_TYPE_FIRST;
638 
639                 /* Transport layer. */
640                 if (key->ip.proto == NEXTHDR_TCP) {
641                         if (tcphdr_ok(skb)) {
642                                 struct tcphdr *tcp = tcp_hdr(skb);
643                                 key->tp.src = tcp->source;
644                                 key->tp.dst = tcp->dest;
645                                 key->tp.flags = TCP_FLAGS_BE16(tcp);
646                         } else {
647                                 memset(&key->tp, 0, sizeof(key->tp));
648                         }
649                 } else if (key->ip.proto == NEXTHDR_UDP) {
650                         if (udphdr_ok(skb)) {
651                                 struct udphdr *udp = udp_hdr(skb);
652                                 key->tp.src = udp->source;
653                                 key->tp.dst = udp->dest;
654                         } else {
655                                 memset(&key->tp, 0, sizeof(key->tp));
656                         }
657                 } else if (key->ip.proto == NEXTHDR_SCTP) {
658                         if (sctphdr_ok(skb)) {
659                                 struct sctphdr *sctp = sctp_hdr(skb);
660                                 key->tp.src = sctp->source;
661                                 key->tp.dst = sctp->dest;
662                         } else {
663                                 memset(&key->tp, 0, sizeof(key->tp));
664                         }
665                 } else if (key->ip.proto == NEXTHDR_ICMP) {
666                         if (icmp6hdr_ok(skb)) {
667                                 error = parse_icmpv6(skb, key, nh_len);
668                                 if (error)
669                                         return error;
670                         } else {
671                                 memset(&key->tp, 0, sizeof(key->tp));
672                         }
673                 }
674         }
675         return 0;
676 }
677 
678 int ovs_flow_key_update(struct sk_buff *skb, struct sw_flow_key *key)
679 {
680         return key_extract(skb, key);
681 }
682 
683 int ovs_flow_key_extract(const struct ovs_tunnel_info *tun_info,
684                          struct sk_buff *skb, struct sw_flow_key *key)
685 {
686         /* Extract metadata from packet. */
687         if (tun_info) {
688                 memcpy(&key->tun_key, &tun_info->tunnel, sizeof(key->tun_key));
689 
690                 if (tun_info->options) {
691                         BUILD_BUG_ON((1 << (sizeof(tun_info->options_len) *
692                                                    8)) - 1
693                                         > sizeof(key->tun_opts));
694                         memcpy(TUN_METADATA_OPTS(key, tun_info->options_len),
695                                tun_info->options, tun_info->options_len);
696                         key->tun_opts_len = tun_info->options_len;
697                 } else {
698                         key->tun_opts_len = 0;
699                 }
700         } else  {
701                 key->tun_opts_len = 0;
702                 memset(&key->tun_key, 0, sizeof(key->tun_key));
703         }
704 
705         key->phy.priority = skb->priority;
706         key->phy.in_port = OVS_CB(skb)->input_vport->port_no;
707         key->phy.skb_mark = skb->mark;
708         key->ovs_flow_hash = 0;
709         key->recirc_id = 0;
710 
711         return key_extract(skb, key);
712 }
713 
714 int ovs_flow_key_extract_userspace(const struct nlattr *attr,
715                                    struct sk_buff *skb,
716                                    struct sw_flow_key *key, bool log)
717 {
718         int err;
719 
720         memset(key, 0, OVS_SW_FLOW_KEY_METADATA_SIZE);
721 
722         /* Extract metadata from netlink attributes. */
723         err = ovs_nla_get_flow_metadata(attr, key, log);
724         if (err)
725                 return err;
726 
727         return key_extract(skb, key);
728 }
729 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp