2 * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
3 * Copyright (c) 2013 Simon Horman
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
19 #include "odp-execute.h"
26 #include "odp-netlink.h"
28 #include "packet-dpif.h"
31 #include "unaligned.h"
35 odp_eth_set_addrs(struct ofpbuf
*packet
,
36 const struct ovs_key_ethernet
*eth_key
)
38 struct eth_header
*eh
= ofpbuf_l2(packet
);
41 memcpy(eh
->eth_src
, eth_key
->eth_src
, sizeof eh
->eth_src
);
42 memcpy(eh
->eth_dst
, eth_key
->eth_dst
, sizeof eh
->eth_dst
);
47 odp_set_tunnel_action(const struct nlattr
*a
, struct flow_tnl
*tun_key
)
49 enum odp_key_fitness fitness
;
51 fitness
= odp_tun_key_from_attr(a
, tun_key
);
52 ovs_assert(fitness
!= ODP_FIT_ERROR
);
56 set_arp(struct ofpbuf
*packet
, const struct ovs_key_arp
*arp_key
)
58 struct arp_eth_header
*arp
= ofpbuf_l3(packet
);
60 arp
->ar_op
= arp_key
->arp_op
;
61 memcpy(arp
->ar_sha
, arp_key
->arp_sha
, ETH_ADDR_LEN
);
62 put_16aligned_be32(&arp
->ar_spa
, arp_key
->arp_sip
);
63 memcpy(arp
->ar_tha
, arp_key
->arp_tha
, ETH_ADDR_LEN
);
64 put_16aligned_be32(&arp
->ar_tpa
, arp_key
->arp_tip
);
68 odp_execute_set_action(struct dpif_packet
*packet
, const struct nlattr
*a
,
69 struct pkt_metadata
*md
)
71 enum ovs_key_attr type
= nl_attr_type(a
);
72 const struct ovs_key_ipv4
*ipv4_key
;
73 const struct ovs_key_ipv6
*ipv6_key
;
74 const struct ovs_key_tcp
*tcp_key
;
75 const struct ovs_key_udp
*udp_key
;
76 const struct ovs_key_sctp
*sctp_key
;
79 case OVS_KEY_ATTR_PRIORITY
:
80 md
->skb_priority
= nl_attr_get_u32(a
);
83 case OVS_KEY_ATTR_TUNNEL
:
84 odp_set_tunnel_action(a
, &md
->tunnel
);
87 case OVS_KEY_ATTR_SKB_MARK
:
88 md
->pkt_mark
= nl_attr_get_u32(a
);
91 case OVS_KEY_ATTR_ETHERNET
:
92 odp_eth_set_addrs(&packet
->ofpbuf
,
93 nl_attr_get_unspec(a
, sizeof(struct ovs_key_ethernet
)));
96 case OVS_KEY_ATTR_IPV4
:
97 ipv4_key
= nl_attr_get_unspec(a
, sizeof(struct ovs_key_ipv4
));
98 packet_set_ipv4(&packet
->ofpbuf
, ipv4_key
->ipv4_src
,
99 ipv4_key
->ipv4_dst
, ipv4_key
->ipv4_tos
,
103 case OVS_KEY_ATTR_IPV6
:
104 ipv6_key
= nl_attr_get_unspec(a
, sizeof(struct ovs_key_ipv6
));
105 packet_set_ipv6(&packet
->ofpbuf
, ipv6_key
->ipv6_proto
,
106 ipv6_key
->ipv6_src
, ipv6_key
->ipv6_dst
,
107 ipv6_key
->ipv6_tclass
, ipv6_key
->ipv6_label
,
108 ipv6_key
->ipv6_hlimit
);
111 case OVS_KEY_ATTR_TCP
:
112 tcp_key
= nl_attr_get_unspec(a
, sizeof(struct ovs_key_tcp
));
113 packet_set_tcp_port(&packet
->ofpbuf
, tcp_key
->tcp_src
,
117 case OVS_KEY_ATTR_UDP
:
118 udp_key
= nl_attr_get_unspec(a
, sizeof(struct ovs_key_udp
));
119 packet_set_udp_port(&packet
->ofpbuf
, udp_key
->udp_src
,
123 case OVS_KEY_ATTR_SCTP
:
124 sctp_key
= nl_attr_get_unspec(a
, sizeof(struct ovs_key_sctp
));
125 packet_set_sctp_port(&packet
->ofpbuf
, sctp_key
->sctp_src
,
129 case OVS_KEY_ATTR_MPLS
:
130 set_mpls_lse(&packet
->ofpbuf
, nl_attr_get_be32(a
));
133 case OVS_KEY_ATTR_ARP
:
134 set_arp(&packet
->ofpbuf
,
135 nl_attr_get_unspec(a
, sizeof(struct ovs_key_arp
)));
138 case OVS_KEY_ATTR_DP_HASH
:
139 md
->dp_hash
= nl_attr_get_u32(a
);
140 dpif_packet_set_dp_hash(packet
, md
->dp_hash
);
143 case OVS_KEY_ATTR_RECIRC_ID
:
144 md
->recirc_id
= nl_attr_get_u32(a
);
147 case OVS_KEY_ATTR_UNSPEC
:
148 case OVS_KEY_ATTR_ENCAP
:
149 case OVS_KEY_ATTR_ETHERTYPE
:
150 case OVS_KEY_ATTR_IN_PORT
:
151 case OVS_KEY_ATTR_VLAN
:
152 case OVS_KEY_ATTR_ICMP
:
153 case OVS_KEY_ATTR_ICMPV6
:
154 case OVS_KEY_ATTR_ND
:
155 case OVS_KEY_ATTR_TCP_FLAGS
:
156 case __OVS_KEY_ATTR_MAX
:
163 odp_execute_actions__(void *dp
, struct dpif_packet
**packets
, int cnt
,
164 bool steal
, struct pkt_metadata
*,
165 const struct nlattr
*actions
, size_t actions_len
,
166 odp_execute_cb dp_execute_action
, bool more_actions
);
169 odp_execute_sample(void *dp
, struct dpif_packet
*packet
, bool steal
,
170 struct pkt_metadata
*md
, const struct nlattr
*action
,
171 odp_execute_cb dp_execute_action
, bool more_actions
)
173 const struct nlattr
*subactions
= NULL
;
174 const struct nlattr
*a
;
177 NL_NESTED_FOR_EACH_UNSAFE (a
, left
, action
) {
178 int type
= nl_attr_type(a
);
180 switch ((enum ovs_sample_attr
) type
) {
181 case OVS_SAMPLE_ATTR_PROBABILITY
:
182 if (random_uint32() >= nl_attr_get_u32(a
)) {
187 case OVS_SAMPLE_ATTR_ACTIONS
:
191 case OVS_SAMPLE_ATTR_UNSPEC
:
192 case __OVS_SAMPLE_ATTR_MAX
:
198 odp_execute_actions__(dp
, &packet
, 1, steal
, md
, nl_attr_get(subactions
),
199 nl_attr_get_size(subactions
), dp_execute_action
,
204 odp_execute_actions__(void *dp
, struct dpif_packet
**packets
, int cnt
,
205 bool steal
, struct pkt_metadata
*md
,
206 const struct nlattr
*actions
, size_t actions_len
,
207 odp_execute_cb dp_execute_action
, bool more_actions
)
209 const struct nlattr
*a
;
214 NL_ATTR_FOR_EACH_UNSAFE (a
, left
, actions
, actions_len
) {
215 int type
= nl_attr_type(a
);
217 switch ((enum ovs_action_attr
) type
) {
218 /* These only make sense in the context of a datapath. */
219 case OVS_ACTION_ATTR_OUTPUT
:
220 case OVS_ACTION_ATTR_USERSPACE
:
221 case OVS_ACTION_ATTR_RECIRC
:
222 if (dp_execute_action
) {
223 /* Allow 'dp_execute_action' to steal the packet data if we do
224 * not need it any more. */
225 bool may_steal
= steal
&& (!more_actions
226 && left
<= NLA_ALIGN(a
->nla_len
)
227 && type
!= OVS_ACTION_ATTR_RECIRC
);
228 dp_execute_action(dp
, packets
, cnt
, md
, a
, may_steal
);
232 case OVS_ACTION_ATTR_HASH
: {
233 const struct ovs_action_hash
*hash_act
= nl_attr_get(a
);
235 /* Calculate a hash value directly. This might not match the
236 * value computed by the datapath, but it is much less expensive,
237 * and the current use case (bonding) does not require a strict
238 * match to work properly. */
239 if (hash_act
->hash_alg
== OVS_HASH_ALG_L4
) {
243 for (i
= 0; i
< cnt
; i
++) {
244 struct ofpbuf
*buf
= &packets
[i
]->ofpbuf
;
246 flow_extract(buf
, md
, &flow
);
247 hash
= flow_hash_5tuple(&flow
, hash_act
->hash_basis
);
249 /* The hash of the first packet is in shared metadata */
251 md
->dp_hash
= hash
? hash
: 1;
254 /* We also store the hash value with each packet */
255 dpif_packet_set_dp_hash(packets
[i
], hash
? hash
: 1);
258 /* Assert on unknown hash algorithm. */
264 case OVS_ACTION_ATTR_PUSH_VLAN
: {
265 const struct ovs_action_push_vlan
*vlan
= nl_attr_get(a
);
267 for (i
= 0; i
< cnt
; i
++) {
268 struct ofpbuf
*buf
= &packets
[i
]->ofpbuf
;
270 eth_push_vlan(buf
, htons(ETH_TYPE_VLAN
), vlan
->vlan_tci
);
275 case OVS_ACTION_ATTR_POP_VLAN
:
276 for (i
= 0; i
< cnt
; i
++) {
277 struct ofpbuf
*buf
= &packets
[i
]->ofpbuf
;
283 case OVS_ACTION_ATTR_PUSH_MPLS
: {
284 const struct ovs_action_push_mpls
*mpls
= nl_attr_get(a
);
286 for (i
= 0; i
< cnt
; i
++) {
287 struct ofpbuf
*buf
= &packets
[i
]->ofpbuf
;
289 push_mpls(buf
, mpls
->mpls_ethertype
, mpls
->mpls_lse
);
294 case OVS_ACTION_ATTR_POP_MPLS
:
295 for (i
= 0; i
< cnt
; i
++) {
296 struct ofpbuf
*buf
= &packets
[i
]->ofpbuf
;
298 pop_mpls(buf
, nl_attr_get_be16(a
));
302 case OVS_ACTION_ATTR_SET
:
303 for (i
= 0; i
< cnt
; i
++) {
304 odp_execute_set_action(packets
[i
], nl_attr_get(a
),
309 case OVS_ACTION_ATTR_SAMPLE
:
310 for (i
= 0; i
< cnt
; i
++) {
311 odp_execute_sample(dp
, packets
[i
], steal
, md
, a
,
314 left
> NLA_ALIGN(a
->nla_len
));
318 case OVS_ACTION_ATTR_UNSPEC
:
319 case __OVS_ACTION_ATTR_MAX
:
326 odp_execute_actions(void *dp
, struct dpif_packet
**packets
, int cnt
,
327 bool steal
, struct pkt_metadata
*md
,
328 const struct nlattr
*actions
, size_t actions_len
,
329 odp_execute_cb dp_execute_action
)
331 odp_execute_actions__(dp
, packets
, cnt
, steal
, md
, actions
, actions_len
,
332 dp_execute_action
, false);
334 if (!actions_len
&& steal
) {
338 for (i
= 0; i
< cnt
; i
++) {
339 dpif_packet_delete(packets
[i
]);