]> git.proxmox.com Git - mirror_ovs.git/blob - datapath-windows/ovsext/Flow.c
projects / mirror_ovs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
datapath-windows: Support for IRP cancelling mechanism
[mirror_ovs.git] / datapath-windows / ovsext / Flow.c
1 /*
2 * Copyright (c) 2014 VMware, Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "precomp.h"
18 #include "NetProto.h"
19 #include "Util.h"
20 #include "Jhash.h"
21 #include "Flow.h"
22 #include "PacketParser.h"
23 #include "Datapath.h"
24
25 #ifdef OVS_DBG_MOD
26 #undef OVS_DBG_MOD
27 #endif
28 #define OVS_DBG_MOD OVS_DBG_FLOW
29 #include "Debug.h"
30
31 #pragma warning( push )
32 #pragma warning( disable:4127 )
33
34 extern POVS_SWITCH_CONTEXT gOvsSwitchContext;
35 extern UINT64 ovsTimeIncrementPerTick;
36
37 static NTSTATUS ReportFlowInfo(OvsFlow *flow, UINT32 getFlags,
38 OvsFlowInfo *info);
39 static NTSTATUS HandleFlowPut(OvsFlowPut *put,
40 OVS_DATAPATH *datapath,
41 struct OvsFlowStats *stats);
42 static NTSTATUS OvsPrepareFlow(OvsFlow **flow, const OvsFlowPut *put,
43 UINT64 hash);
44 static VOID RemoveFlow(OVS_DATAPATH *datapath, OvsFlow **flow);
45 static VOID DeleteAllFlows(OVS_DATAPATH *datapath);
46 static NTSTATUS AddFlow(OVS_DATAPATH *datapath, OvsFlow *flow);
47 static VOID FreeFlow(OvsFlow *flow);
48 static VOID __inline *GetStartAddrNBL(const NET_BUFFER_LIST *_pNB);
49 static NTSTATUS _MapNlToFlowPut(POVS_MESSAGE msgIn, PNL_ATTR keyAttr,
50 PNL_ATTR actionAttr,
51 PNL_ATTR flowAttrClear,
52 OvsFlowPut *mappedFlow);
53 static VOID _MapKeyAttrToFlowPut(PNL_ATTR *keyAttrs,
54 PNL_ATTR *tunnelAttrs,
55 OvsFlowKey *destKey);
56
57 static VOID _MapTunAttrToFlowPut(PNL_ATTR *keyAttrs,
58 PNL_ATTR *tunnelAttrs,
59 OvsFlowKey *destKey);
60 static VOID _MapNlToFlowPutFlags(PGENL_MSG_HDR genlMsgHdr,
61 PNL_ATTR flowAttrClear,
62 OvsFlowPut *mappedFlow);
63
64 static NTSTATUS _FlowNlGetCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
65 UINT32 *replyLen);
66 static NTSTATUS _FlowNlDumpCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
67 UINT32 *replyLen);
68 static NTSTATUS _MapFlowInfoToNl(PNL_BUFFER nlBuf,
69 OvsFlowInfo *flowInfo);
70 static NTSTATUS _MapFlowStatsToNlStats(PNL_BUFFER nlBuf,
71 OvsFlowStats *flowStats);
72 static NTSTATUS _MapFlowActionToNlAction(PNL_BUFFER nlBuf,
73 uint32_t actionsLen,
74 PNL_ATTR actions);
75
76 static NTSTATUS _MapFlowIpv4KeyToNlKey(PNL_BUFFER nlBuf,
77 IpKey *ipv4FlowPutKey);
78 static NTSTATUS _MapFlowIpv6KeyToNlKey(PNL_BUFFER nlBuf,
79 Ipv6Key *ipv6FlowPutKey,
80 Icmp6Key *ipv6FlowPutIcmpKey);
81 static NTSTATUS _MapFlowArpKeyToNlKey(PNL_BUFFER nlBuf,
82 ArpKey *arpFlowPutKey);
83
84 static NTSTATUS OvsDoDumpFlows(OvsFlowDumpInput *dumpInput,
85 OvsFlowDumpOutput *dumpOutput,
86 UINT32 *replyLen);
87
88
89 #define OVS_FLOW_TABLE_SIZE 2048
90 #define OVS_FLOW_TABLE_MASK (OVS_FLOW_TABLE_SIZE -1)
91 #define HASH_BUCKET(hash) ((hash) & OVS_FLOW_TABLE_MASK)
92
93 /* Flow family related netlink policies */
94
95 /* For Parsing attributes in FLOW_* commands */
96 const NL_POLICY nlFlowPolicy[] = {
97 [OVS_FLOW_ATTR_KEY] = {.type = NL_A_NESTED, .optional = FALSE},
98 [OVS_FLOW_ATTR_MASK] = {.type = NL_A_NESTED, .optional = TRUE},
99 [OVS_FLOW_ATTR_ACTIONS] = {.type = NL_A_NESTED, .optional = TRUE},
100 [OVS_FLOW_ATTR_STATS] = {.type = NL_A_UNSPEC,
101 .minLen = sizeof(struct ovs_flow_stats),
102 .maxLen = sizeof(struct ovs_flow_stats),
103 .optional = TRUE},
104 [OVS_FLOW_ATTR_TCP_FLAGS] = {NL_A_U8, .optional = TRUE},
105 [OVS_FLOW_ATTR_USED] = {NL_A_U64, .optional = TRUE},
106 [OVS_FLOW_ATTR_PROBE] = {.type = NL_A_FLAG, .optional = TRUE}
107 };
108
109 /* For Parsing nested OVS_FLOW_ATTR_KEY attributes.
110 * Some of the attributes like OVS_KEY_ATTR_RECIRC_ID
111 * & OVS_KEY_ATTR_MPLS are not supported yet. */
112
113 const NL_POLICY nlFlowKeyPolicy[] = {
114 [OVS_KEY_ATTR_ENCAP] = {.type = NL_A_VAR_LEN, .optional = TRUE},
115 [OVS_KEY_ATTR_PRIORITY] = {.type = NL_A_UNSPEC, .minLen = 4,
116 .maxLen = 4, .optional = TRUE},
117 [OVS_KEY_ATTR_IN_PORT] = {.type = NL_A_UNSPEC, .minLen = 4,
118 .maxLen = 4, .optional = FALSE},
119 [OVS_KEY_ATTR_ETHERNET] = {.type = NL_A_UNSPEC,
120 .minLen = sizeof(struct ovs_key_ethernet),
121 .maxLen = sizeof(struct ovs_key_ethernet),
122 .optional = TRUE},
123 [OVS_KEY_ATTR_VLAN] = {.type = NL_A_UNSPEC, .minLen = 2,
124 .maxLen = 2, .optional = TRUE},
125 [OVS_KEY_ATTR_ETHERTYPE] = {.type = NL_A_UNSPEC, .minLen = 2,
126 .maxLen = 2, .optional = TRUE},
127 [OVS_KEY_ATTR_IPV4] = {.type = NL_A_UNSPEC,
128 .minLen = sizeof(struct ovs_key_ipv4),
129 .maxLen = sizeof(struct ovs_key_ipv4),
130 .optional = TRUE},
131 [OVS_KEY_ATTR_IPV6] = {.type = NL_A_UNSPEC,
132 .minLen = sizeof(struct ovs_key_ipv6),
133 .maxLen = sizeof(struct ovs_key_ipv6),
134 .optional = TRUE},
135 [OVS_KEY_ATTR_TCP] = {.type = NL_A_UNSPEC,
136 .minLen = sizeof(struct ovs_key_tcp),
137 .maxLen = sizeof(struct ovs_key_tcp),
138 .optional = TRUE},
139 [OVS_KEY_ATTR_UDP] = {.type = NL_A_UNSPEC,
140 .minLen = sizeof(struct ovs_key_udp),
141 .maxLen = sizeof(struct ovs_key_udp),
142 .optional = TRUE},
143 [OVS_KEY_ATTR_ICMP] = {.type = NL_A_UNSPEC,
144 .minLen = sizeof(struct ovs_key_icmp),
145 .maxLen = sizeof(struct ovs_key_icmp),
146 .optional = TRUE},
147 [OVS_KEY_ATTR_ICMPV6] = {.type = NL_A_UNSPEC,
148 .minLen = sizeof(struct ovs_key_icmpv6),
149 .maxLen = sizeof(struct ovs_key_icmpv6),
150 .optional = TRUE},
151 [OVS_KEY_ATTR_ARP] = {.type = NL_A_UNSPEC,
152 .minLen = sizeof(struct ovs_key_arp),
153 .maxLen = sizeof(struct ovs_key_arp),
154 .optional = TRUE},
155 [OVS_KEY_ATTR_ND] = {.type = NL_A_UNSPEC,
156 .minLen = sizeof(struct ovs_key_nd),
157 .maxLen = sizeof(struct ovs_key_nd),
158 .optional = TRUE},
159 [OVS_KEY_ATTR_SKB_MARK] = {.type = NL_A_UNSPEC, .minLen = 4,
160 .maxLen = 4, .optional = TRUE},
161 [OVS_KEY_ATTR_TUNNEL] = {.type = NL_A_VAR_LEN, .optional = TRUE},
162 [OVS_KEY_ATTR_SCTP] = {.type = NL_A_UNSPEC,
163 .minLen = sizeof(struct ovs_key_sctp),
164 .maxLen = sizeof(struct ovs_key_sctp),
165 .optional = TRUE},
166 [OVS_KEY_ATTR_TCP_FLAGS] = {.type = NL_A_UNSPEC,
167 .minLen = 2, .maxLen = 2,
168 .optional = TRUE},
169 [OVS_KEY_ATTR_DP_HASH] = {.type = NL_A_UNSPEC, .minLen = 4,
170 .maxLen = 4, .optional = TRUE},
171 [OVS_KEY_ATTR_RECIRC_ID] = {.type = NL_A_UNSPEC, .minLen = 4,
172 .maxLen = 4, .optional = TRUE},
173 [OVS_KEY_ATTR_MPLS] = {.type = NL_A_VAR_LEN, .optional = TRUE}
174 };
175 const UINT32 nlFlowKeyPolicyLen = ARRAY_SIZE(nlFlowKeyPolicy);
176
177 /* For Parsing nested OVS_KEY_ATTR_TUNNEL attributes */
178 const NL_POLICY nlFlowTunnelKeyPolicy[] = {
179 [OVS_TUNNEL_KEY_ATTR_ID] = {.type = NL_A_UNSPEC, .minLen = 8,
180 .maxLen = 8, .optional = TRUE},
181 [OVS_TUNNEL_KEY_ATTR_IPV4_SRC] = {.type = NL_A_UNSPEC, .minLen = 4,
182 .maxLen = 4, .optional = TRUE},
183 [OVS_TUNNEL_KEY_ATTR_IPV4_DST] = {.type = NL_A_UNSPEC, .minLen = 4 ,
184 .maxLen = 4, .optional = FALSE},
185 [OVS_TUNNEL_KEY_ATTR_TOS] = {.type = NL_A_UNSPEC, .minLen = 1,
186 .maxLen = 1, .optional = TRUE},
187 [OVS_TUNNEL_KEY_ATTR_TTL] = {.type = NL_A_UNSPEC, .minLen = 1,
188 .maxLen = 1, .optional = TRUE},
189 [OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT] = {.type = NL_A_UNSPEC, .minLen = 0,
190 .maxLen = 0, .optional = TRUE},
191 [OVS_TUNNEL_KEY_ATTR_CSUM] = {.type = NL_A_UNSPEC, .minLen = 0,
192 .maxLen = 0, .optional = TRUE},
193 [OVS_TUNNEL_KEY_ATTR_OAM] = {.type = NL_A_UNSPEC, .minLen = 0,
194 .maxLen = 0, .optional = TRUE},
195 [OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS] = {.type = NL_A_VAR_LEN,
196 .optional = TRUE}
197 };
198
199 /* For Parsing nested OVS_FLOW_ATTR_ACTIONS attributes */
200 const NL_POLICY nlFlowActionPolicy[] = {
201 [OVS_ACTION_ATTR_OUTPUT] = {.type = NL_A_UNSPEC, .minLen = sizeof(UINT32),
202 .maxLen = sizeof(UINT32), .optional = TRUE},
203 [OVS_ACTION_ATTR_USERSPACE] = {.type = NL_A_VAR_LEN, .optional = TRUE},
204 [OVS_ACTION_ATTR_PUSH_VLAN] = {.type = NL_A_UNSPEC,
205 .minLen =
206 sizeof(struct ovs_action_push_vlan),
207 .maxLen =
208 sizeof(struct ovs_action_push_vlan),
209 .optional = TRUE},
210 [OVS_ACTION_ATTR_POP_VLAN] = {.type = NL_A_UNSPEC, .optional = TRUE},
211 [OVS_ACTION_ATTR_PUSH_MPLS] = {.type = NL_A_UNSPEC,
212 .minLen =
213 sizeof(struct ovs_action_push_mpls),
214 .maxLen =
215 sizeof(struct ovs_action_push_mpls),
216 .optional = TRUE},
217 [OVS_ACTION_ATTR_POP_MPLS] = {.type = NL_A_UNSPEC,
218 .minLen = sizeof(UINT16),
219 .maxLen = sizeof(UINT16),
220 .optional = TRUE},
221 [OVS_ACTION_ATTR_RECIRC] = {.type = NL_A_UNSPEC,
222 .minLen = sizeof(UINT32),
223 .maxLen = sizeof(UINT32),
224 .optional = TRUE},
225 [OVS_ACTION_ATTR_HASH] = {.type = NL_A_UNSPEC,
226 .minLen = sizeof(struct ovs_action_hash),
227 .maxLen = sizeof(struct ovs_action_hash),
228 .optional = TRUE},
229 [OVS_ACTION_ATTR_SET] = {.type = NL_A_VAR_LEN, .optional = TRUE},
230 [OVS_ACTION_ATTR_SAMPLE] = {.type = NL_A_VAR_LEN, .optional = TRUE}
231 };
232
233 /*
234 *----------------------------------------------------------------------------
235 * Netlink interface for flow commands.
236 *----------------------------------------------------------------------------
237 */
238
239 /*
240 *----------------------------------------------------------------------------
241 * OvsFlowNewCmdHandler --
242 * Handler for OVS_FLOW_CMD_NEW/SET/DEL command.
243 * It also handles FLUSH case (DEL w/o any key in input)
244 *----------------------------------------------------------------------------
245 */
246 NTSTATUS
247 OvsFlowNlCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
248 UINT32 *replyLen)
249 {
250 NTSTATUS rc = STATUS_SUCCESS;
251 BOOLEAN ok;
252 POVS_MESSAGE msgIn = (POVS_MESSAGE)usrParamsCtx->inputBuffer;
253 POVS_MESSAGE msgOut = (POVS_MESSAGE)usrParamsCtx->outputBuffer;
254 PNL_MSG_HDR nlMsgHdr = &(msgIn->nlMsg);
255 PGENL_MSG_HDR genlMsgHdr = &(msgIn->genlMsg);
256 POVS_HDR ovsHdr = &(msgIn->ovsHdr);
257 PNL_ATTR flowAttrs[__OVS_FLOW_ATTR_MAX];
258 UINT32 attrOffset = NLMSG_HDRLEN + GENL_HDRLEN + OVS_HDRLEN;
259 OvsFlowPut mappedFlow;
260 OvsFlowStats stats;
261 struct ovs_flow_stats replyStats;
262 NL_ERROR nlError = NL_ERROR_SUCCESS;
263 NL_BUFFER nlBuf;
264
265 RtlZeroMemory(&mappedFlow, sizeof(OvsFlowPut));
266 RtlZeroMemory(&stats, sizeof(stats));
267 RtlZeroMemory(&replyStats, sizeof(replyStats));
268
269 if (!(usrParamsCtx->outputBuffer)) {
270 /* No output buffer */
271 rc = STATUS_INVALID_BUFFER_SIZE;
272 goto done;
273 }
274
275 /* Get all the top level Flow attributes */
276 if ((NlAttrParse(nlMsgHdr, attrOffset, NlMsgAttrsLen(nlMsgHdr),
277 nlFlowPolicy, ARRAY_SIZE(nlFlowPolicy),
278 flowAttrs, ARRAY_SIZE(flowAttrs)))
279 != TRUE) {
280 OVS_LOG_ERROR("Attr Parsing failed for msg: %p",
281 nlMsgHdr);
282 rc = STATUS_INVALID_PARAMETER;
283 goto done;
284 }
285
286 /* FLOW_DEL command w/o any key input is a flush case. */
287 if ((genlMsgHdr->cmd == OVS_FLOW_CMD_DEL) &&
288 (!(flowAttrs[OVS_FLOW_ATTR_KEY]))) {
289
290 rc = OvsFlushFlowIoctl(ovsHdr->dp_ifindex);
291
292 if (rc == STATUS_SUCCESS) {
293 /* XXX: refactor this code. */
294 /* So far so good. Prepare the reply for userspace */
295 NlBufInit(&nlBuf, usrParamsCtx->outputBuffer,
296 usrParamsCtx->outputLength);
297
298 /* Prepare nl Msg headers */
299 ok = NlFillOvsMsg(&nlBuf, nlMsgHdr->nlmsgType, 0,
300 nlMsgHdr->nlmsgSeq, nlMsgHdr->nlmsgPid,
301 genlMsgHdr->cmd, OVS_FLOW_VERSION,
302 ovsHdr->dp_ifindex);
303 if (ok) {
304 *replyLen = msgOut->nlMsg.nlmsgLen;
305 } else {
306 rc = STATUS_INVALID_BUFFER_SIZE;
307 }
308 }
309
310 goto done;
311 }
312
313 if (flowAttrs[OVS_FLOW_ATTR_PROBE]) {
314 OVS_LOG_ERROR("Attribute OVS_FLOW_ATTR_PROBE not supported");
315 nlError = NL_ERROR_NOENT;
316 goto done;
317 }
318
319 if ((rc = _MapNlToFlowPut(msgIn, flowAttrs[OVS_FLOW_ATTR_KEY],
320 flowAttrs[OVS_FLOW_ATTR_ACTIONS], flowAttrs[OVS_FLOW_ATTR_CLEAR],
321 &mappedFlow))
322 != STATUS_SUCCESS) {
323 OVS_LOG_ERROR("Conversion to OvsFlowPut failed");
324 goto done;
325 }
326
327 rc = OvsPutFlowIoctl(&mappedFlow, sizeof (struct OvsFlowPut),
328 &stats);
329 if (rc != STATUS_SUCCESS) {
330 OVS_LOG_ERROR("OvsPutFlowIoctl failed.");
331 goto done;
332 }
333
334 replyStats.n_packets = stats.packetCount;
335 replyStats.n_bytes = stats.byteCount;
336
337 /* So far so good. Prepare the reply for userspace */
338 NlBufInit(&nlBuf, usrParamsCtx->outputBuffer,
339 usrParamsCtx->outputLength);
340
341 /* Prepare nl Msg headers */
342 ok = NlFillOvsMsg(&nlBuf, nlMsgHdr->nlmsgType, 0,
343 nlMsgHdr->nlmsgSeq, nlMsgHdr->nlmsgPid,
344 genlMsgHdr->cmd, OVS_FLOW_VERSION,
345 ovsHdr->dp_ifindex);
346 if (!ok) {
347 rc = STATUS_INVALID_BUFFER_SIZE;
348 goto done;
349 } else {
350 rc = STATUS_SUCCESS;
351 }
352
353 /* Append OVS_FLOW_ATTR_STATS attribute */
354 if (!NlMsgPutTailUnspec(&nlBuf, OVS_FLOW_ATTR_STATS,
355 (PCHAR)(&replyStats), sizeof(replyStats))) {
356 OVS_LOG_ERROR("Adding OVS_FLOW_ATTR_STATS attribute failed.");
357 rc = STATUS_INVALID_BUFFER_SIZE;
358 goto done;
359 }
360
361 msgOut->nlMsg.nlmsgLen = NLMSG_ALIGN(NlBufSize(&nlBuf));
362 *replyLen = msgOut->nlMsg.nlmsgLen;
363
364 done:
365
366 if (nlError != NL_ERROR_SUCCESS) {
367 POVS_MESSAGE_ERROR msgError = (POVS_MESSAGE_ERROR)
368 usrParamsCtx->outputBuffer;
369 NlBuildErrorMsg(msgIn, msgError, nlError);
370 *replyLen = msgError->nlMsg.nlmsgLen;
371 rc = STATUS_SUCCESS;
372 }
373
374 return rc;
375 }
376
377 /*
378 *----------------------------------------------------------------------------
379 * OvsFlowNlGetCmdHandler --
380 * Handler for OVS_FLOW_CMD_GET/DUMP commands.
381 *----------------------------------------------------------------------------
382 */
383 NTSTATUS
384 OvsFlowNlGetCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
385 UINT32 *replyLen)
386 {
387 NTSTATUS status = STATUS_SUCCESS;
388 NL_ERROR nlError = NL_ERROR_SUCCESS;
389 POVS_MESSAGE msgIn = (POVS_MESSAGE)usrParamsCtx->inputBuffer;
390
391 if (usrParamsCtx->devOp == OVS_TRANSACTION_DEV_OP) {
392 status = _FlowNlGetCmdHandler(usrParamsCtx, replyLen);
393
394 /* No trasanctional errors as of now.
395 * If we have something then we need to convert rc to
396 * nlError. */
397 if ((nlError != NL_ERROR_SUCCESS) &&
398 (usrParamsCtx->outputBuffer)) {
399 POVS_MESSAGE_ERROR msgError = (POVS_MESSAGE_ERROR)
400 usrParamsCtx->outputBuffer;
401 NlBuildErrorMsg(msgIn, msgError, nlError);
402 *replyLen = msgError->nlMsg.nlmsgLen;
403 status = STATUS_SUCCESS;
404 goto done;
405 }
406 } else {
407 status = _FlowNlDumpCmdHandler(usrParamsCtx, replyLen);
408 }
409
410 done:
411 return status;
412 }
413
414 /*
415 *----------------------------------------------------------------------------
416 * _FlowNlGetCmdHandler --
417 * Handler for OVS_FLOW_CMD_GET command.
418 *----------------------------------------------------------------------------
419 */
420 NTSTATUS
421 _FlowNlGetCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
422 UINT32 *replyLen)
423 {
424 NTSTATUS rc = STATUS_SUCCESS;
425 POVS_MESSAGE msgIn = (POVS_MESSAGE)usrParamsCtx->inputBuffer;
426 PNL_MSG_HDR nlMsgHdr = &(msgIn->nlMsg);
427 POVS_HDR ovsHdr = &(msgIn->ovsHdr);
428 PNL_MSG_HDR nlMsgOutHdr = NULL;
429 UINT32 attrOffset = NLMSG_HDRLEN + GENL_HDRLEN + OVS_HDRLEN;
430 PNL_ATTR nlAttrs[__OVS_FLOW_ATTR_MAX];
431
432 OvsFlowGetInput getInput;
433 OvsFlowGetOutput getOutput;
434 NL_BUFFER nlBuf;
435 PNL_ATTR keyAttrs[__OVS_KEY_ATTR_MAX];
436 PNL_ATTR tunnelAttrs[__OVS_TUNNEL_KEY_ATTR_MAX];
437
438 NlBufInit(&nlBuf, usrParamsCtx->outputBuffer,
439 usrParamsCtx->outputLength);
440 RtlZeroMemory(&getInput, sizeof(OvsFlowGetInput));
441 RtlZeroMemory(&getOutput, sizeof(OvsFlowGetOutput));
442 UINT32 keyAttrOffset = 0;
443 UINT32 tunnelKeyAttrOffset = 0;
444 BOOLEAN ok;
445
446 if (usrParamsCtx->inputLength > usrParamsCtx->outputLength) {
447 /* Should not be the case.
448 * We'll be copying the flow keys back from
449 * input buffer to output buffer. */
450 rc = STATUS_INVALID_PARAMETER;
451 OVS_LOG_ERROR("inputLength: %d GREATER THEN outputLength: %d",
452 usrParamsCtx->inputLength, usrParamsCtx->outputLength);
453 goto done;
454 }
455
456 /* Get all the top level Flow attributes */
457 if ((NlAttrParse(nlMsgHdr, attrOffset, NlMsgAttrsLen(nlMsgHdr),
458 nlFlowPolicy, ARRAY_SIZE(nlFlowPolicy),
459 nlAttrs, ARRAY_SIZE(nlAttrs)))
460 != TRUE) {
461 OVS_LOG_ERROR("Attr Parsing failed for msg: %p",
462 nlMsgHdr);
463 rc = STATUS_INVALID_PARAMETER;
464 goto done;
465 }
466
467 keyAttrOffset = (UINT32)((PCHAR) nlAttrs[OVS_FLOW_ATTR_KEY] -
468 (PCHAR)nlMsgHdr);
469
470 /* Get flow keys attributes */
471 if ((NlAttrParseNested(nlMsgHdr, keyAttrOffset,
472 NlAttrLen(nlAttrs[OVS_FLOW_ATTR_KEY]),
473 nlFlowKeyPolicy, ARRAY_SIZE(nlFlowKeyPolicy),
474 keyAttrs, ARRAY_SIZE(keyAttrs)))
475 != TRUE) {
476 OVS_LOG_ERROR("Key Attr Parsing failed for msg: %p",
477 nlMsgHdr);
478 rc = STATUS_INVALID_PARAMETER;
479 goto done;
480 }
481
482 if (keyAttrs[OVS_KEY_ATTR_TUNNEL]) {
483 tunnelKeyAttrOffset = (UINT32)((PCHAR)
484 (keyAttrs[OVS_KEY_ATTR_TUNNEL])
485 - (PCHAR)nlMsgHdr);
486
487 /* Get tunnel keys attributes */
488 if ((NlAttrParseNested(nlMsgHdr, tunnelKeyAttrOffset,
489 NlAttrLen(keyAttrs[OVS_KEY_ATTR_TUNNEL]),
490 nlFlowTunnelKeyPolicy,
491 ARRAY_SIZE(nlFlowTunnelKeyPolicy),
492 tunnelAttrs, ARRAY_SIZE(tunnelAttrs)))
493 != TRUE) {
494 OVS_LOG_ERROR("Tunnel key Attr Parsing failed for msg: %p",
495 nlMsgHdr);
496 rc = STATUS_INVALID_PARAMETER;
497 goto done;
498 }
499 }
500
501 _MapKeyAttrToFlowPut(keyAttrs, tunnelAttrs,
502 &(getInput.key));
503
504 getInput.dpNo = ovsHdr->dp_ifindex;
505 getInput.getFlags = FLOW_GET_STATS | FLOW_GET_ACTIONS;
506
507 /* 4th argument is a no op.
508 * We are keeping this argument to be compatible
509 * with our dpif-windows based interface. */
510 rc = OvsGetFlowIoctl(&getInput, &getOutput);
511 if (rc != STATUS_SUCCESS) {
512 OVS_LOG_ERROR("OvsGetFlowIoctl failed.");
513 goto done;
514 }
515
516 /* Lets prepare the reply. */
517 nlMsgOutHdr = (PNL_MSG_HDR)(NlBufAt(&nlBuf, 0, 0));
518
519 /* Input already has all the attributes for the flow key.
520 * Lets copy the values back. */
521 ok = NlMsgPutTail(&nlBuf, (PCHAR)(usrParamsCtx->inputBuffer),
522 usrParamsCtx->inputLength);
523 if (!ok) {
524 OVS_LOG_ERROR("Could not copy the data to the buffer tail");
525 goto done;
526 }
527
528 rc = _MapFlowStatsToNlStats(&nlBuf, &((getOutput.info).stats));
529 if (rc != STATUS_SUCCESS) {
530 OVS_LOG_ERROR("_OvsFlowMapFlowKeyToNlStats failed.");
531 goto done;
532 }
533
534 rc = _MapFlowActionToNlAction(&nlBuf, ((getOutput.info).actionsLen),
535 getOutput.info.actions);
536 if (rc != STATUS_SUCCESS) {
537 OVS_LOG_ERROR("_MapFlowActionToNlAction failed.");
538 goto done;
539 }
540
541 NlMsgSetSize(nlMsgOutHdr, NlBufSize(&nlBuf));
542 NlMsgAlignSize(nlMsgOutHdr);
543 *replyLen += NlMsgSize(nlMsgOutHdr);
544
545 done:
546 return rc;
547 }
548
549 /*
550 *----------------------------------------------------------------------------
551 * _FlowNlDumpCmdHandler --
552 * Handler for OVS_FLOW_CMD_DUMP command.
553 *----------------------------------------------------------------------------
554 */
555 NTSTATUS
556 _FlowNlDumpCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
557 UINT32 *replyLen)
558 {
559 NTSTATUS rc = STATUS_SUCCESS;
560 UINT32 temp = 0; /* To keep compiler happy for calling OvsDoDumpFlows */
561
562 POVS_OPEN_INSTANCE instance = (POVS_OPEN_INSTANCE)
563 (usrParamsCtx->ovsInstance);
564
565 if (usrParamsCtx->devOp == OVS_WRITE_DEV_OP) {
566 /* Dump Start */
567 OvsSetupDumpStart(usrParamsCtx);
568 goto done;
569 }
570
571 POVS_MESSAGE msgIn = instance->dumpState.ovsMsg;
572 PNL_MSG_HDR nlMsgHdr = &(msgIn->nlMsg);
573 PGENL_MSG_HDR genlMsgHdr = &(msgIn->genlMsg);
574 POVS_HDR ovsHdr = &(msgIn->ovsHdr);
575 PNL_MSG_HDR nlMsgOutHdr = NULL;
576 UINT32 hdrOffset = 0;
577
578 /* Get Next */
579 OvsFlowDumpOutput dumpOutput;
580 OvsFlowDumpInput dumpInput;
581 NL_BUFFER nlBuf;
582
583 NlBufInit(&nlBuf, usrParamsCtx->outputBuffer,
584 usrParamsCtx->outputLength);
585
586 ASSERT(usrParamsCtx->devOp == OVS_READ_DEV_OP);
587 ASSERT(usrParamsCtx->outputLength);
588
589 RtlZeroMemory(&dumpInput, sizeof(OvsFlowDumpInput));
590 RtlZeroMemory(&dumpOutput, sizeof(OvsFlowDumpOutput));
591
592 dumpInput.dpNo = ovsHdr->dp_ifindex;
593 dumpInput.getFlags = FLOW_GET_KEY | FLOW_GET_STATS | FLOW_GET_ACTIONS;
594
595 /* Lets provide as many flows to userspace as possible. */
596 do {
597 dumpInput.position[0] = instance->dumpState.index[0];
598 dumpInput.position[1] = instance->dumpState.index[1];
599
600 rc = OvsDoDumpFlows(&dumpInput, &dumpOutput, &temp);
601 if (rc != STATUS_SUCCESS) {
602 OVS_LOG_ERROR("OvsDoDumpFlows failed with rc: %d", rc);
603 break;
604 }
605
606 /* Done with Dump, send NLMSG_DONE */
607 if (!(dumpOutput.n)) {
608 BOOLEAN ok;
609
610 OVS_LOG_INFO("Dump Done");
611
612 nlMsgOutHdr = (PNL_MSG_HDR)(NlBufAt(&nlBuf, NlBufSize(&nlBuf), 0));
613 ok = NlFillNlHdr(&nlBuf, NLMSG_DONE, NLM_F_MULTI,
614 nlMsgHdr->nlmsgSeq, nlMsgHdr->nlmsgPid);
615
616 if (!ok) {
617 rc = STATUS_INVALID_BUFFER_SIZE;
618 OVS_LOG_ERROR("Unable to prepare DUMP_DONE reply.");
619 break;
620 } else {
621 rc = STATUS_SUCCESS;
622 }
623
624 NlMsgAlignSize(nlMsgOutHdr);
625 *replyLen += NlMsgSize(nlMsgOutHdr);
626
627 FreeUserDumpState(instance);
628 break;
629 } else {
630 BOOLEAN ok;
631
632 hdrOffset = NlBufSize(&nlBuf);
633 nlMsgOutHdr = (PNL_MSG_HDR)(NlBufAt(&nlBuf, hdrOffset, 0));
634
635 /* Netlink header */
636 ok = NlFillOvsMsg(&nlBuf, nlMsgHdr->nlmsgType, NLM_F_MULTI,
637 nlMsgHdr->nlmsgSeq, nlMsgHdr->nlmsgPid,
638 genlMsgHdr->cmd, genlMsgHdr->version,
639 ovsHdr->dp_ifindex);
640
641 if (!ok) {
642 /* Reset rc to success so that we can
643 * send already added messages to user space. */
644 rc = STATUS_SUCCESS;
645 break;
646 }
647
648 /* Time to add attributes */
649 rc = _MapFlowInfoToNl(&nlBuf, &(dumpOutput.flow));
650 if (rc != STATUS_SUCCESS) {
651 /* Adding the attribute failed, we are out of
652 space in the buffer, remove the appended OVS header */
653 NlMsgSetSize(nlMsgOutHdr,
654 NlMsgSize(nlMsgOutHdr) -
655 sizeof(struct _OVS_MESSAGE));
656
657 /* Reset rc to success so that we can
658 * send already added messages to user space. */
659 rc = STATUS_SUCCESS;
660 break;
661 }
662
663 NlMsgSetSize(nlMsgOutHdr, NlBufSize(&nlBuf) - hdrOffset);
664 NlMsgAlignSize(nlMsgOutHdr);
665 *replyLen += NlMsgSize(nlMsgOutHdr);
666 instance->dumpState.index[0] = dumpOutput.position[0];
667 instance->dumpState.index[1] = dumpOutput.position[1];
668 }
669 } while(TRUE);
670
671 done:
672 return rc;
673 }
674
675 /*
676 *----------------------------------------------------------------------------
677 * _MapFlowInfoToNl --
678 * Maps OvsFlowInfo to Netlink attributes.
679 *----------------------------------------------------------------------------
680 */
681 static NTSTATUS
682 _MapFlowInfoToNl(PNL_BUFFER nlBuf, OvsFlowInfo *flowInfo)
683 {
684 NTSTATUS rc = STATUS_SUCCESS;
685
686 rc = MapFlowKeyToNlKey(nlBuf, &(flowInfo->key), OVS_FLOW_ATTR_KEY,
687 OVS_KEY_ATTR_TUNNEL);
688 if (rc != STATUS_SUCCESS) {
689 goto done;
690 }
691
692 rc = _MapFlowStatsToNlStats(nlBuf, &(flowInfo->stats));
693 if (rc != STATUS_SUCCESS) {
694 goto done;
695 }
696
697 rc = _MapFlowActionToNlAction(nlBuf, flowInfo->actionsLen,
698 flowInfo->actions);
699 if (rc != STATUS_SUCCESS) {
700 goto done;
701 }
702
703 done:
704 return rc;
705 }
706
707 /*
708 *----------------------------------------------------------------------------
709 * _MapFlowStatsToNlStats --
710 * Maps OvsFlowStats to OVS_FLOW_ATTR_STATS attribute.
711 *----------------------------------------------------------------------------
712 */
713 static NTSTATUS
714 _MapFlowStatsToNlStats(PNL_BUFFER nlBuf, OvsFlowStats *flowStats)
715 {
716 NTSTATUS rc = STATUS_SUCCESS;
717 struct ovs_flow_stats replyStats;
718
719 replyStats.n_packets = flowStats->packetCount;
720 replyStats.n_bytes = flowStats->byteCount;
721
722 if (!NlMsgPutTailU64(nlBuf, OVS_FLOW_ATTR_USED, flowStats->used)) {
723 rc = STATUS_INVALID_BUFFER_SIZE;
724 goto done;
725 }
726
727 if (!NlMsgPutTailUnspec(nlBuf, OVS_FLOW_ATTR_STATS,
728 (PCHAR)(&replyStats),
729 sizeof(struct ovs_flow_stats))) {
730 rc = STATUS_INVALID_BUFFER_SIZE;
731 goto done;
732 }
733
734 if (!NlMsgPutTailU8(nlBuf, OVS_FLOW_ATTR_TCP_FLAGS, flowStats->tcpFlags)) {
735 rc = STATUS_INVALID_BUFFER_SIZE;
736 goto done;
737 }
738
739 done:
740 return rc;
741 }
742
743 /*
744 *----------------------------------------------------------------------------
745 * _MapFlowActionToNlAction --
746 * Maps flow actions to OVS_FLOW_ATTR_ACTION attribute.
747 *----------------------------------------------------------------------------
748 */
749 static NTSTATUS
750 _MapFlowActionToNlAction(PNL_BUFFER nlBuf, uint32_t actionsLen,
751 PNL_ATTR actions)
752 {
753 NTSTATUS rc = STATUS_SUCCESS;
754 UINT32 offset = 0;
755
756 offset = NlMsgStartNested(nlBuf, OVS_FLOW_ATTR_ACTIONS);
757 if (!offset) {
758 /* Starting the nested attribute failed. */
759 rc = STATUS_INVALID_BUFFER_SIZE;
760 goto error_nested_start;
761 }
762
763 if (!NlBufCopyAtTail(nlBuf, (PCHAR)actions, actionsLen)) {
764 /* Adding a nested attribute failed. */
765 rc = STATUS_INVALID_BUFFER_SIZE;
766 goto done;
767 }
768
769 done:
770 NlMsgEndNested(nlBuf, offset);
771 error_nested_start:
772 return rc;
773
774 }
775
776 /*
777 *----------------------------------------------------------------------------
778 * MapFlowKeyToNlKey --
779 * Maps OvsFlowKey to OVS_FLOW_ATTR_KEY attribute.
780 *----------------------------------------------------------------------------
781 */
782 NTSTATUS
783 MapFlowKeyToNlKey(PNL_BUFFER nlBuf,
784 OvsFlowKey *flowKey,
785 UINT16 keyType,
786 UINT16 tunKeyType)
787 {
788 NTSTATUS rc = STATUS_SUCCESS;
789 struct ovs_key_ethernet ethKey;
790 UINT32 offset = 0;
791
792 offset = NlMsgStartNested(nlBuf, keyType);
793 if (!offset) {
794 /* Starting the nested attribute failed. */
795 rc = STATUS_UNSUCCESSFUL;
796 goto error_nested_start;
797 }
798
799 /* Ethernet header */
800 RtlCopyMemory(&(ethKey.eth_src), flowKey->l2.dlSrc, ETH_ADDR_LEN);
801 RtlCopyMemory(&(ethKey.eth_dst), flowKey->l2.dlDst, ETH_ADDR_LEN);
802
803 if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_ETHERNET,
804 (PCHAR)(&ethKey),
805 sizeof(struct ovs_key_ethernet))) {
806 rc = STATUS_UNSUCCESSFUL;
807 goto done;
808 }
809
810 if (!NlMsgPutTailU32(nlBuf, OVS_KEY_ATTR_IN_PORT,
811 flowKey->l2.inPort)) {
812 rc = STATUS_UNSUCCESSFUL;
813 goto done;
814 }
815
816 if (!NlMsgPutTailU16(nlBuf, OVS_KEY_ATTR_ETHERTYPE,
817 flowKey->l2.dlType)) {
818 rc = STATUS_UNSUCCESSFUL;
819 goto done;
820 }
821
822 if (flowKey->l2.vlanTci) {
823 if (!NlMsgPutTailU16(nlBuf, OVS_KEY_ATTR_VLAN,
824 flowKey->l2.vlanTci)) {
825 rc = STATUS_UNSUCCESSFUL;
826 goto done;
827 }
828 }
829
830 /* ==== L3 + L4 ==== */
831 switch (ntohs(flowKey->l2.dlType)) {
832 case ETH_TYPE_IPV4: {
833 IpKey *ipv4FlowPutKey = &(flowKey->ipKey);
834 rc = _MapFlowIpv4KeyToNlKey(nlBuf, ipv4FlowPutKey);
835 break;
836 }
837
838 case ETH_TYPE_IPV6: {
839 Ipv6Key *ipv6FlowPutKey = &(flowKey->ipv6Key);
840 Icmp6Key *icmpv6FlowPutKey = &(flowKey->icmp6Key);
841 rc = _MapFlowIpv6KeyToNlKey(nlBuf, ipv6FlowPutKey,
842 icmpv6FlowPutKey);
843 break;
844 }
845
846 case ETH_TYPE_ARP:
847 case ETH_TYPE_RARP: {
848 ArpKey *arpFlowPutKey = &(flowKey->arpKey);
849 rc = _MapFlowArpKeyToNlKey(nlBuf, arpFlowPutKey);
850 break;
851 }
852
853 default:
854 break;
855 }
856
857 if (rc != STATUS_SUCCESS) {
858 goto done;
859 }
860
861 if (flowKey->tunKey.dst) {
862 rc = MapFlowTunKeyToNlKey(nlBuf, &(flowKey->tunKey),
863 tunKeyType);
864 if (rc != STATUS_SUCCESS) {
865 goto done;
866 }
867 }
868
869 done:
870 NlMsgEndNested(nlBuf, offset);
871 error_nested_start:
872 return rc;
873 }
874
875 /*
876 *----------------------------------------------------------------------------
877 * MapFlowTunKeyToNlKey --
878 * Maps OvsIPv4TunnelKey to OVS_TUNNEL_KEY_ATTR_ID attribute.
879 *----------------------------------------------------------------------------
880 */
881 NTSTATUS
882 MapFlowTunKeyToNlKey(PNL_BUFFER nlBuf,
883 OvsIPv4TunnelKey *tunKey,
884 UINT16 tunKeyType)
885 {
886 NTSTATUS rc = STATUS_SUCCESS;
887 UINT32 offset = 0;
888
889 offset = NlMsgStartNested(nlBuf, tunKeyType);
890 if (!offset) {
891 /* Starting the nested attribute failed. */
892 rc = STATUS_UNSUCCESSFUL;
893 goto error_nested_start;
894 }
895
896 if (!NlMsgPutTailU64(nlBuf, OVS_TUNNEL_KEY_ATTR_ID,
897 tunKey->tunnelId)) {
898 rc = STATUS_UNSUCCESSFUL;
899 goto done;
900 }
901
902 if (!NlMsgPutTailU32(nlBuf, OVS_TUNNEL_KEY_ATTR_IPV4_DST,
903 tunKey->dst)) {
904 rc = STATUS_UNSUCCESSFUL;
905 goto done;
906 }
907
908 if (!NlMsgPutTailU32(nlBuf, OVS_TUNNEL_KEY_ATTR_IPV4_SRC,
909 tunKey->src)) {
910 rc = STATUS_UNSUCCESSFUL;
911 goto done;
912 }
913
914 if (!NlMsgPutTailU8(nlBuf, OVS_TUNNEL_KEY_ATTR_TOS,
915 tunKey->tos)) {
916 rc = STATUS_UNSUCCESSFUL;
917 goto done;
918 }
919
920 if (!NlMsgPutTailU8(nlBuf, OVS_TUNNEL_KEY_ATTR_TTL,
921 tunKey->ttl)) {
922 rc = STATUS_UNSUCCESSFUL;
923 goto done;
924 }
925
926 done:
927 NlMsgEndNested(nlBuf, offset);
928 error_nested_start:
929 return rc;
930 }
931
932 /*
933 *----------------------------------------------------------------------------
934 * _MapFlowTunKeyToNlKey --
935 * Maps OvsIPv4FlowPutKey to OVS_KEY_ATTR_IPV4 attribute.
936 *----------------------------------------------------------------------------
937 */
938 static NTSTATUS
939 _MapFlowIpv4KeyToNlKey(PNL_BUFFER nlBuf, IpKey *ipv4FlowPutKey)
940 {
941 NTSTATUS rc = STATUS_SUCCESS;
942 struct ovs_key_ipv4 ipv4Key;
943
944 ipv4Key.ipv4_src = ipv4FlowPutKey->nwSrc;
945 ipv4Key.ipv4_dst = ipv4FlowPutKey->nwDst;
946 ipv4Key.ipv4_proto = ipv4FlowPutKey->nwProto;
947 ipv4Key.ipv4_tos = ipv4FlowPutKey->nwTos;
948 ipv4Key.ipv4_ttl = ipv4FlowPutKey->nwTtl;
949 ipv4Key.ipv4_frag = ipv4FlowPutKey->nwFrag;
950
951 if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_IPV4,
952 (PCHAR)(&ipv4Key),
953 sizeof(struct ovs_key_ipv4))) {
954 rc = STATUS_UNSUCCESSFUL;
955 goto done;
956 }
957
958 switch (ipv4Key.ipv4_proto) {
959 case IPPROTO_TCP: {
960 struct ovs_key_tcp tcpKey;
961 tcpKey.tcp_src = ipv4FlowPutKey->l4.tpSrc;
962 tcpKey.tcp_dst = ipv4FlowPutKey->l4.tpDst;
963 if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_TCP,
964 (PCHAR)(&tcpKey),
965 sizeof(tcpKey))) {
966 rc = STATUS_UNSUCCESSFUL;
967 goto done;
968 }
969 break;
970 }
971
972 case IPPROTO_UDP: {
973 struct ovs_key_udp udpKey;
974 udpKey.udp_src = ipv4FlowPutKey->l4.tpSrc;
975 udpKey.udp_dst = ipv4FlowPutKey->l4.tpDst;
976 if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_UDP,
977 (PCHAR)(&udpKey),
978 sizeof(udpKey))) {
979 rc = STATUS_UNSUCCESSFUL;
980 goto done;
981 }
982 break;
983 }
984
985 case IPPROTO_SCTP: {
986 struct ovs_key_sctp sctpKey;
987 sctpKey.sctp_src = ipv4FlowPutKey->l4.tpSrc;
988 sctpKey.sctp_dst = ipv4FlowPutKey->l4.tpDst;
989 if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_SCTP,
990 (PCHAR)(&sctpKey),
991 sizeof(sctpKey))) {
992 rc = STATUS_UNSUCCESSFUL;
993 goto done;
994 }
995 break;
996 }
997
998 case IPPROTO_ICMP: {
999 struct ovs_key_icmp icmpKey;
1000 /* XXX: revisit to see if htons is needed */
1001 icmpKey.icmp_type = (__u8)(ipv4FlowPutKey->l4.tpSrc);
1002 icmpKey.icmp_code = (__u8)(ipv4FlowPutKey->l4.tpDst);
1003
1004 if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_ICMP,
1005 (PCHAR)(&icmpKey),
1006 sizeof(icmpKey))) {
1007 rc = STATUS_UNSUCCESSFUL;
1008 goto done;
1009 }
1010 break;
1011 }
1012
1013 default:
1014 break;
1015 }
1016
1017 done:
1018 return rc;
1019 }
1020
1021 /*
1022 *----------------------------------------------------------------------------
1023 * _MapFlowIpv6KeyToNlKey --
1024 * Maps _MapFlowIpv6KeyToNlKey to OVS_KEY_ATTR_IPV6 attribute.
1025 *----------------------------------------------------------------------------
1026 */
1027 static NTSTATUS
1028 _MapFlowIpv6KeyToNlKey(PNL_BUFFER nlBuf, Ipv6Key *ipv6FlowPutKey,
1029 Icmp6Key *icmpv6FlowPutKey)
1030 {
1031 NTSTATUS rc = STATUS_SUCCESS;
1032 struct ovs_key_ipv6 ipv6Key;
1033
1034 RtlCopyMemory(&(ipv6Key.ipv6_src), &ipv6FlowPutKey->ipv6Src,
1035 sizeof ipv6Key.ipv6_src);
1036 RtlCopyMemory(&(ipv6Key.ipv6_dst), &ipv6FlowPutKey->ipv6Dst,
1037 sizeof ipv6Key.ipv6_dst);
1038
1039 ipv6Key.ipv6_label = ipv6FlowPutKey->ipv6Label;
1040 ipv6Key.ipv6_proto = ipv6FlowPutKey->nwProto;
1041 ipv6Key.ipv6_tclass = ipv6FlowPutKey->nwTos;
1042 ipv6Key.ipv6_hlimit = ipv6FlowPutKey->nwTtl;
1043 ipv6Key.ipv6_frag = ipv6FlowPutKey->nwFrag;
1044
1045 if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_IPV6,
1046 (PCHAR)(&ipv6Key),
1047 sizeof(ipv6Key))) {
1048 rc = STATUS_UNSUCCESSFUL;
1049 goto done;
1050 }
1051
1052 switch (ipv6Key.ipv6_proto) {
1053 case IPPROTO_TCP: {
1054 struct ovs_key_tcp tcpKey;
1055 tcpKey.tcp_src = ipv6FlowPutKey->l4.tpSrc;
1056 tcpKey.tcp_dst = ipv6FlowPutKey->l4.tpDst;
1057 if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_TCP,
1058 (PCHAR)(&tcpKey),
1059 sizeof(tcpKey))) {
1060 rc = STATUS_UNSUCCESSFUL;
1061 goto done;
1062 }
1063 break;
1064 }
1065
1066 case IPPROTO_UDP: {
1067 struct ovs_key_udp udpKey;
1068 udpKey.udp_src = ipv6FlowPutKey->l4.tpSrc;
1069 udpKey.udp_dst = ipv6FlowPutKey->l4.tpDst;
1070 if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_UDP,
1071 (PCHAR)(&udpKey),
1072 sizeof(udpKey))) {
1073 rc = STATUS_UNSUCCESSFUL;
1074 goto done;
1075 }
1076 break;
1077 }
1078
1079 case IPPROTO_SCTP: {
1080 struct ovs_key_sctp sctpKey;
1081 sctpKey.sctp_src = ipv6FlowPutKey->l4.tpSrc;
1082 sctpKey.sctp_dst = ipv6FlowPutKey->l4.tpDst;
1083 if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_SCTP,
1084 (PCHAR)(&sctpKey),
1085 sizeof(sctpKey))) {
1086 rc = STATUS_UNSUCCESSFUL;
1087 goto done;
1088 }
1089 break;
1090 }
1091
1092 case IPPROTO_ICMPV6: {
1093 struct ovs_key_icmpv6 icmpV6Key;
1094 struct ovs_key_nd ndKey;
1095
1096 /* XXX: revisit to see if htons is needed */
1097 icmpV6Key.icmpv6_type = (__u8)(icmpv6FlowPutKey->l4.tpSrc);
1098 icmpV6Key.icmpv6_code = (__u8)(icmpv6FlowPutKey->l4.tpDst);
1099
1100 if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_ICMPV6,
1101 (PCHAR)(&icmpV6Key),
1102 sizeof(icmpV6Key))) {
1103 rc = STATUS_UNSUCCESSFUL;
1104 goto done;
1105 }
1106
1107 RtlCopyMemory(&(ndKey.nd_target), &icmpv6FlowPutKey->ndTarget,
1108 sizeof(icmpv6FlowPutKey->ndTarget));
1109 RtlCopyMemory(&(ndKey.nd_sll), &icmpv6FlowPutKey->arpSha,
1110 ETH_ADDR_LEN);
1111 RtlCopyMemory(&(ndKey.nd_tll), &icmpv6FlowPutKey->arpTha,
1112 ETH_ADDR_LEN);
1113 if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_ND,
1114 (PCHAR)(&ndKey),
1115 sizeof(ndKey))) {
1116 rc = STATUS_UNSUCCESSFUL;
1117 goto done;
1118 }
1119
1120 break;
1121 }
1122
1123 default:
1124 break;
1125 }
1126
1127 done:
1128 return rc;
1129 }
1130
1131 /*
1132 *----------------------------------------------------------------------------
1133 * _MapFlowArpKeyToNlKey --
1134 * Maps _MapFlowArpKeyToNlKey to OVS_KEY_ATTR_ARP attribute.
1135 *----------------------------------------------------------------------------
1136 */
1137 static NTSTATUS
1138 _MapFlowArpKeyToNlKey(PNL_BUFFER nlBuf, ArpKey *arpFlowPutKey)
1139 {
1140 NTSTATUS rc = STATUS_SUCCESS;
1141 struct ovs_key_arp arpKey;
1142
1143 arpKey.arp_sip = arpFlowPutKey->nwSrc;
1144 arpKey.arp_tip = arpFlowPutKey->nwDst;
1145
1146 RtlCopyMemory(&(arpKey.arp_sha), arpFlowPutKey->arpSha, ETH_ADDR_LEN);
1147 RtlCopyMemory(&(arpKey.arp_tha), arpFlowPutKey->arpTha, ETH_ADDR_LEN);
1148
1149 /*
1150 * Flow_Extract() stores 'nwProto' in host order for ARP since 'nwProto' is
1151 * 1 byte field and the ARP opcode is 2 bytes, and all of the kernel code
1152 * understand this while looking at an ARP key.
1153 * While we pass up the ARP key to userspace, convert from host order to
1154 * network order. Likewise, when processing an ARP key from userspace,
1155 * convert from network order to host order.
1156 *
1157 * It is important to note that the flow table stores the ARP opcode field
1158 * in host order.
1159 */
1160 arpKey.arp_op = htons(arpFlowPutKey->nwProto);
1161
1162 if (!NlMsgPutTailUnspec(nlBuf, OVS_KEY_ATTR_ARP,
1163 (PCHAR)(&arpKey),
1164 sizeof(arpKey))) {
1165 rc = STATUS_UNSUCCESSFUL;
1166 goto done;
1167 }
1168
1169 done:
1170 return rc;
1171 }
1172
1173 /*
1174 *----------------------------------------------------------------------------
1175 * _MapNlToFlowPut --
1176 * Maps input netlink message to OvsFlowPut.
1177 *----------------------------------------------------------------------------
1178 */
1179 static NTSTATUS
1180 _MapNlToFlowPut(POVS_MESSAGE msgIn, PNL_ATTR keyAttr,
1181 PNL_ATTR actionAttr, PNL_ATTR flowAttrClear,
1182 OvsFlowPut *mappedFlow)
1183 {
1184 NTSTATUS rc = STATUS_SUCCESS;
1185 PNL_MSG_HDR nlMsgHdr = &(msgIn->nlMsg);
1186 PGENL_MSG_HDR genlMsgHdr = &(msgIn->genlMsg);
1187 POVS_HDR ovsHdr = &(msgIn->ovsHdr);
1188
1189 UINT32 keyAttrOffset = (UINT32)((PCHAR)keyAttr - (PCHAR)nlMsgHdr);
1190 UINT32 tunnelKeyAttrOffset;
1191
1192 PNL_ATTR keyAttrs[__OVS_KEY_ATTR_MAX] = {NULL};
1193 PNL_ATTR tunnelAttrs[__OVS_TUNNEL_KEY_ATTR_MAX] = {NULL};
1194
1195 /* Get flow keys attributes */
1196 if ((NlAttrParseNested(nlMsgHdr, keyAttrOffset, NlAttrLen(keyAttr),
1197 nlFlowKeyPolicy, ARRAY_SIZE(nlFlowKeyPolicy),
1198 keyAttrs, ARRAY_SIZE(keyAttrs)))
1199 != TRUE) {
1200 OVS_LOG_ERROR("Key Attr Parsing failed for msg: %p",
1201 nlMsgHdr);
1202 rc = STATUS_INVALID_PARAMETER;
1203 goto done;
1204 }
1205
1206 if (keyAttrs[OVS_KEY_ATTR_TUNNEL]) {
1207 tunnelKeyAttrOffset = (UINT32)((PCHAR)
1208 (keyAttrs[OVS_KEY_ATTR_TUNNEL])
1209 - (PCHAR)nlMsgHdr);
1210
1211 /* Get tunnel keys attributes */
1212 if ((NlAttrParseNested(nlMsgHdr, tunnelKeyAttrOffset,
1213 NlAttrLen(keyAttrs[OVS_KEY_ATTR_TUNNEL]),
1214 nlFlowTunnelKeyPolicy,
1215 ARRAY_SIZE(nlFlowTunnelKeyPolicy),
1216 tunnelAttrs, ARRAY_SIZE(tunnelAttrs)))
1217 != TRUE) {
1218 OVS_LOG_ERROR("Tunnel key Attr Parsing failed for msg: %p",
1219 nlMsgHdr);
1220 rc = STATUS_INVALID_PARAMETER;
1221 goto done;
1222 }
1223 }
1224
1225 _MapKeyAttrToFlowPut(keyAttrs, tunnelAttrs,
1226 &(mappedFlow->key));
1227
1228 /* Map the action */
1229 if (actionAttr) {
1230 mappedFlow->actionsLen = NlAttrGetSize(actionAttr);
1231 mappedFlow->actions = NlAttrGet(actionAttr);
1232 }
1233
1234 mappedFlow->dpNo = ovsHdr->dp_ifindex;
1235
1236 _MapNlToFlowPutFlags(genlMsgHdr, flowAttrClear,
1237 mappedFlow);
1238
1239 done:
1240 return rc;
1241 }
1242
1243 /*
1244 *----------------------------------------------------------------------------
1245 * _MapNlToFlowPutFlags --
1246 * Maps netlink message to OvsFlowPut->flags.
1247 *----------------------------------------------------------------------------
1248 */
1249 static VOID
1250 _MapNlToFlowPutFlags(PGENL_MSG_HDR genlMsgHdr,
1251 PNL_ATTR flowAttrClear, OvsFlowPut *mappedFlow)
1252 {
1253 uint32_t flags = 0;
1254
1255 switch (genlMsgHdr->cmd) {
1256 case OVS_FLOW_CMD_NEW:
1257 flags |= OVSWIN_FLOW_PUT_CREATE;
1258 break;
1259 case OVS_FLOW_CMD_DEL:
1260 flags |= OVSWIN_FLOW_PUT_DELETE;
1261 break;
1262 case OVS_FLOW_CMD_SET:
1263 flags |= OVSWIN_FLOW_PUT_MODIFY;
1264 break;
1265 default:
1266 ASSERT(0);
1267 }
1268
1269 if (flowAttrClear) {
1270 flags |= OVSWIN_FLOW_PUT_CLEAR;
1271 }
1272
1273 mappedFlow->flags = flags;
1274 }
1275
1276 /*
1277 *----------------------------------------------------------------------------
1278 * _MapKeyAttrToFlowPut --
1279 * Converts FLOW_KEY attribute to OvsFlowPut->key.
1280 *----------------------------------------------------------------------------
1281 */
1282 static VOID
1283 _MapKeyAttrToFlowPut(PNL_ATTR *keyAttrs,
1284 PNL_ATTR *tunnelAttrs,
1285 OvsFlowKey *destKey)
1286 {
1287 _MapTunAttrToFlowPut(keyAttrs, tunnelAttrs, destKey);
1288
1289 /* ===== L2 headers ===== */
1290 destKey->l2.inPort = NlAttrGetU32(keyAttrs[OVS_KEY_ATTR_IN_PORT]);
1291
1292 if (keyAttrs[OVS_KEY_ATTR_ETHERNET]) {
1293 const struct ovs_key_ethernet *eth_key;
1294 eth_key = NlAttrGet(keyAttrs[OVS_KEY_ATTR_ETHERNET]);
1295 RtlCopyMemory(destKey->l2.dlSrc, eth_key->eth_src, ETH_ADDR_LEN);
1296 RtlCopyMemory(destKey->l2.dlDst, eth_key->eth_dst, ETH_ADDR_LEN);
1297 }
1298
1299 /* TODO: Ideally ETHERTYPE should not be optional.
1300 * But during vswitchd bootup we are seeing FLOW_ADD
1301 * requests with no ETHERTYPE attributes.
1302 * Need to verify this. */
1303 if (keyAttrs[OVS_KEY_ATTR_ETHERTYPE]) {
1304 destKey->l2.dlType = (NlAttrGetU16(keyAttrs
1305 [OVS_KEY_ATTR_ETHERTYPE]));
1306 }
1307
1308 if (keyAttrs[OVS_KEY_ATTR_VLAN]) {
1309 destKey->l2.vlanTci = NlAttrGetU16(keyAttrs[OVS_KEY_ATTR_VLAN]);
1310 }
1311
1312 /* ==== L3 + L4. ==== */
1313 destKey->l2.keyLen = OVS_WIN_TUNNEL_KEY_SIZE + OVS_L2_KEY_SIZE
1314 - destKey->l2.offset;
1315
1316 switch (ntohs(destKey->l2.dlType)) {
1317 case ETH_TYPE_IPV4: {
1318
1319 if (keyAttrs[OVS_KEY_ATTR_IPV4]) {
1320 const struct ovs_key_ipv4 *ipv4Key;
1321
1322 ipv4Key = NlAttrGet(keyAttrs[OVS_KEY_ATTR_IPV4]);
1323 IpKey *ipv4FlowPutKey = &(destKey->ipKey);
1324 ipv4FlowPutKey->nwSrc = ipv4Key->ipv4_src;
1325 ipv4FlowPutKey->nwDst = ipv4Key->ipv4_dst;
1326 ipv4FlowPutKey->nwProto = ipv4Key->ipv4_proto;
1327 ipv4FlowPutKey->nwTos = ipv4Key->ipv4_tos;
1328 ipv4FlowPutKey->nwTtl = ipv4Key->ipv4_ttl;
1329 ipv4FlowPutKey->nwFrag = ipv4Key->ipv4_frag;
1330
1331 if (keyAttrs[OVS_KEY_ATTR_TCP]) {
1332 const struct ovs_key_tcp *tcpKey;
1333 tcpKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_TCP]);
1334 ipv4FlowPutKey->l4.tpSrc = tcpKey->tcp_src;
1335 ipv4FlowPutKey->l4.tpDst = tcpKey->tcp_dst;
1336 }
1337
1338 if (keyAttrs[OVS_KEY_ATTR_UDP]) {
1339 const struct ovs_key_udp *udpKey;
1340 udpKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_UDP]);
1341 ipv4FlowPutKey->l4.tpSrc = udpKey->udp_src;
1342 ipv4FlowPutKey->l4.tpDst = udpKey->udp_dst;
1343 }
1344
1345 if (keyAttrs[OVS_KEY_ATTR_SCTP]) {
1346 const struct ovs_key_sctp *sctpKey;
1347 sctpKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_SCTP]);
1348 ipv4FlowPutKey->l4.tpSrc = sctpKey->sctp_src;
1349 ipv4FlowPutKey->l4.tpDst = sctpKey->sctp_dst;
1350 }
1351
1352 destKey->l2.keyLen += OVS_IP_KEY_SIZE;
1353 }
1354 break;
1355 }
1356 case ETH_TYPE_IPV6: {
1357
1358 if (keyAttrs[OVS_KEY_ATTR_IPV6]) {
1359 const struct ovs_key_ipv6 *ipv6Key;
1360
1361 ipv6Key = NlAttrGet(keyAttrs[OVS_KEY_ATTR_IPV6]);
1362 Ipv6Key *ipv6FlowPutKey = &(destKey->ipv6Key);
1363
1364 RtlCopyMemory(&ipv6FlowPutKey->ipv6Src, ipv6Key->ipv6_src,
1365 sizeof ipv6Key->ipv6_src);
1366 RtlCopyMemory(&ipv6FlowPutKey->ipv6Dst, ipv6Key->ipv6_dst,
1367 sizeof ipv6Key->ipv6_dst);
1368
1369 ipv6FlowPutKey->ipv6Label = ipv6Key->ipv6_label;
1370 ipv6FlowPutKey->nwProto = ipv6Key->ipv6_proto;
1371 ipv6FlowPutKey->nwTos = ipv6Key->ipv6_tclass;
1372 ipv6FlowPutKey->nwTtl = ipv6Key->ipv6_hlimit;
1373 ipv6FlowPutKey->nwFrag = ipv6Key->ipv6_frag;
1374
1375 if (keyAttrs[OVS_KEY_ATTR_TCP]) {
1376 const struct ovs_key_tcp *tcpKey;
1377 tcpKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_TCP]);
1378 ipv6FlowPutKey->l4.tpSrc = tcpKey->tcp_src;
1379 ipv6FlowPutKey->l4.tpDst = tcpKey->tcp_dst;
1380 }
1381
1382 if (keyAttrs[OVS_KEY_ATTR_UDP]) {
1383 const struct ovs_key_udp *udpKey;
1384 udpKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_UDP]);
1385 ipv6FlowPutKey->l4.tpSrc = udpKey->udp_src;
1386 ipv6FlowPutKey->l4.tpDst = udpKey->udp_dst;
1387 }
1388
1389 if (keyAttrs[OVS_KEY_ATTR_SCTP]) {
1390 const struct ovs_key_sctp *sctpKey;
1391 sctpKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_SCTP]);
1392 ipv6FlowPutKey->l4.tpSrc = sctpKey->sctp_src;
1393 ipv6FlowPutKey->l4.tpDst = sctpKey->sctp_dst;
1394 }
1395
1396 if (keyAttrs[OVS_KEY_ATTR_ICMPV6]) {
1397 const struct ovs_key_icmpv6 *icmpv6Key;
1398
1399 Icmp6Key *icmp6FlowPutKey= &(destKey->icmp6Key);
1400
1401 icmpv6Key = NlAttrGet(keyAttrs[OVS_KEY_ATTR_ICMPV6]);
1402
1403 icmp6FlowPutKey->l4.tpSrc = icmpv6Key->icmpv6_type;
1404 icmp6FlowPutKey->l4.tpDst = icmpv6Key->icmpv6_code;
1405
1406 if (keyAttrs[OVS_KEY_ATTR_ND]) {
1407 const struct ovs_key_nd *ndKey;
1408
1409 ndKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_ND]);
1410 RtlCopyMemory(&icmp6FlowPutKey->ndTarget,
1411 ndKey->nd_target, sizeof (icmp6FlowPutKey->ndTarget));
1412 RtlCopyMemory(icmp6FlowPutKey->arpSha,
1413 ndKey->nd_sll, ETH_ADDR_LEN);
1414 RtlCopyMemory(icmp6FlowPutKey->arpTha,
1415 ndKey->nd_tll, ETH_ADDR_LEN);
1416 }
1417
1418 destKey->l2.keyLen += OVS_ICMPV6_KEY_SIZE;
1419
1420 } else {
1421
1422 destKey->l2.keyLen += OVS_IPV6_KEY_SIZE;
1423 }
1424
1425 ipv6FlowPutKey->pad = 0;
1426 }
1427 break;
1428 }
1429 case ETH_TYPE_ARP:
1430 case ETH_TYPE_RARP: {
1431
1432 if (keyAttrs[OVS_KEY_ATTR_ARP]) {
1433 ArpKey *arpFlowPutKey = &destKey->arpKey;
1434 const struct ovs_key_arp *arpKey;
1435
1436 arpKey = NlAttrGet(keyAttrs[OVS_KEY_ATTR_ARP]);
1437
1438 arpFlowPutKey->nwSrc = arpKey->arp_sip;
1439 arpFlowPutKey->nwDst = arpKey->arp_tip;
1440
1441 RtlCopyMemory(arpFlowPutKey->arpSha, arpKey->arp_sha, ETH_ADDR_LEN);
1442 RtlCopyMemory(arpFlowPutKey->arpTha, arpKey->arp_tha, ETH_ADDR_LEN);
1443 /* Kernel datapath assumes 'arpFlowPutKey->nwProto' to be in host
1444 * order. */
1445 arpFlowPutKey->nwProto = (UINT8)ntohs((arpKey->arp_op));
1446 arpFlowPutKey->pad[0] = 0;
1447 arpFlowPutKey->pad[1] = 0;
1448 arpFlowPutKey->pad[2] = 0;
1449 destKey->l2.keyLen += OVS_ARP_KEY_SIZE;
1450 break;
1451 }
1452 }
1453 }
1454 }
1455
1456 /*
1457 *----------------------------------------------------------------------------
1458 * _MapTunAttrToFlowPut --
1459 * Converts FLOW_TUNNEL_KEY attribute to OvsFlowKey->tunKey.
1460 *----------------------------------------------------------------------------
1461 */
1462 static VOID
1463 _MapTunAttrToFlowPut(PNL_ATTR *keyAttrs,
1464 PNL_ATTR *tunAttrs,
1465 OvsFlowKey *destKey)
1466 {
1467 if (keyAttrs[OVS_KEY_ATTR_TUNNEL]) {
1468
1469 if (tunAttrs[OVS_TUNNEL_KEY_ATTR_ID]) {
1470 destKey->tunKey.tunnelId = NlAttrGetU64
1471 (tunAttrs[OVS_TUNNEL_KEY_ATTR_ID]);
1472 destKey->tunKey.flags |= OVS_TNL_F_KEY;
1473 }
1474
1475 if (tunAttrs[OVS_TUNNEL_KEY_ATTR_IPV4_DST]) {
1476 destKey->tunKey.dst = NlAttrGetU32
1477 (tunAttrs[OVS_TUNNEL_KEY_ATTR_IPV4_DST]);
1478 }
1479
1480 if (tunAttrs[OVS_TUNNEL_KEY_ATTR_IPV4_SRC]) {
1481 destKey->tunKey.src = NlAttrGetU32
1482 (tunAttrs[OVS_TUNNEL_KEY_ATTR_IPV4_SRC]);
1483 }
1484
1485 if (tunAttrs[OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT]) {
1486 destKey->tunKey.flags |= OVS_TNL_F_DONT_FRAGMENT;
1487 }
1488
1489 if (tunAttrs[OVS_TUNNEL_KEY_ATTR_CSUM]) {
1490 destKey->tunKey.flags |= OVS_TNL_F_CSUM;
1491 }
1492
1493 if (tunAttrs[OVS_TUNNEL_KEY_ATTR_TOS]) {
1494 destKey->tunKey.tos = NlAttrGetU8
1495 (tunAttrs[OVS_TUNNEL_KEY_ATTR_TOS]);
1496 }
1497
1498 if (tunAttrs[OVS_TUNNEL_KEY_ATTR_TTL]) {
1499 destKey->tunKey.ttl = NlAttrGetU8
1500 (tunAttrs[OVS_TUNNEL_KEY_ATTR_TTL]);
1501 }
1502
1503 destKey->tunKey.pad = 0;
1504 destKey->l2.offset = 0;
1505 } else {
1506 destKey->tunKey.attr[0] = 0;
1507 destKey->tunKey.attr[1] = 0;
1508 destKey->tunKey.attr[2] = 0;
1509 destKey->l2.offset = sizeof destKey->tunKey;
1510 }
1511 }
1512
1513 /*
1514 *----------------------------------------------------------------------------
1515 * OvsDeleteFlowTable --
1516 * Results:
1517 * NDIS_STATUS_SUCCESS always.
1518 *----------------------------------------------------------------------------
1519 */
1520 NDIS_STATUS
1521 OvsDeleteFlowTable(OVS_DATAPATH *datapath)
1522 {
1523 if (datapath == NULL || datapath->flowTable == NULL) {
1524 return NDIS_STATUS_SUCCESS;
1525 }
1526
1527 DeleteAllFlows(datapath);
1528 OvsFreeMemoryWithTag(datapath->flowTable, OVS_FLOW_POOL_TAG);
1529 datapath->flowTable = NULL;
1530
1531 if (datapath->lock == NULL) {
1532 return NDIS_STATUS_SUCCESS;
1533 }
1534
1535 NdisFreeRWLock(datapath->lock);
1536
1537 return NDIS_STATUS_SUCCESS;
1538 }
1539
1540 /*
1541 *----------------------------------------------------------------------------
1542 * OvsAllocateFlowTable --
1543 * Results:
1544 * NDIS_STATUS_SUCCESS on success.
1545 * NDIS_STATUS_RESOURCES if memory couldn't be allocated
1546 *----------------------------------------------------------------------------
1547 */
1548 NDIS_STATUS
1549 OvsAllocateFlowTable(OVS_DATAPATH *datapath,
1550 POVS_SWITCH_CONTEXT switchContext)
1551 {
1552 PLIST_ENTRY bucket;
1553 int i;
1554
1555 datapath->flowTable = OvsAllocateMemoryWithTag(
1556 OVS_FLOW_TABLE_SIZE * sizeof(LIST_ENTRY), OVS_FLOW_POOL_TAG);
1557 if (!datapath->flowTable) {
1558 return NDIS_STATUS_RESOURCES;
1559 }
1560 for (i = 0; i < OVS_FLOW_TABLE_SIZE; i++) {
1561 bucket = &(datapath->flowTable[i]);
1562 InitializeListHead(bucket);
1563 }
1564 datapath->lock = NdisAllocateRWLock(switchContext->NdisFilterHandle);
1565
1566 if (!datapath->lock) {
1567 return NDIS_STATUS_RESOURCES;
1568 }
1569
1570 return NDIS_STATUS_SUCCESS;
1571 }
1572
1573
1574 /*
1575 *----------------------------------------------------------------------------
1576 * GetStartAddrNBL --
1577 * Get the virtual address of the frame.
1578 *
1579 * Results:
1580 * Virtual address of the frame.
1581 *----------------------------------------------------------------------------
1582 */
1583 static __inline VOID *
1584 GetStartAddrNBL(const NET_BUFFER_LIST *_pNB)
1585 {
1586 PMDL curMdl;
1587 PUINT8 curBuffer;
1588 PEthHdr curHeader;
1589
1590 ASSERT(_pNB);
1591
1592 // Ethernet Header is a guaranteed safe access.
1593 curMdl = (NET_BUFFER_LIST_FIRST_NB(_pNB))->CurrentMdl;
1594 curBuffer = MmGetSystemAddressForMdlSafe(curMdl, LowPagePriority);
1595 if (!curBuffer) {
1596 return NULL;
1597 }
1598
1599 curHeader = (PEthHdr)
1600 (curBuffer + (NET_BUFFER_LIST_FIRST_NB(_pNB))->CurrentMdlOffset);
1601
1602 return (VOID *) curHeader;
1603 }
1604
1605 VOID
1606 OvsFlowUsed(OvsFlow *flow,
1607 const NET_BUFFER_LIST *packet,
1608 const POVS_PACKET_HDR_INFO layers)
1609 {
1610 LARGE_INTEGER tickCount;
1611
1612 KeQueryTickCount(&tickCount);
1613 flow->used = tickCount.QuadPart * ovsTimeIncrementPerTick;
1614 flow->packetCount++;
1615 flow->byteCount += OvsPacketLenNBL(packet);
1616 flow->tcpFlags |= OvsGetTcpFlags(packet, &flow->key, layers);
1617 }
1618
1619
1620 VOID
1621 DeleteAllFlows(OVS_DATAPATH *datapath)
1622 {
1623 INT i;
1624 PLIST_ENTRY bucket;
1625
1626 for (i = 0; i < OVS_FLOW_TABLE_SIZE; i++) {
1627 PLIST_ENTRY next;
1628 bucket = &(datapath->flowTable[i]);
1629 while (!IsListEmpty(bucket)) {
1630 OvsFlow *flow;
1631 next = bucket->Flink;
1632 flow = CONTAINING_RECORD(next, OvsFlow, ListEntry);
1633 RemoveFlow(datapath, &flow);
1634 }
1635 }
1636 }
1637
1638 /*
1639 *----------------------------------------------------------------------------
1640 * Initializes 'flow' members from 'packet', 'skb_priority', 'tun_id', and
1641 * 'ofp_in_port'.
1642 *
1643 * Initializes 'packet' header pointers as follows:
1644 *
1645 * - packet->l2 to the start of the Ethernet header.
1646 *
1647 * - packet->l3 to just past the Ethernet header, or just past the
1648 * vlan_header if one is present, to the first byte of the payload of the
1649 * Ethernet frame.
1650 *
1651 * - packet->l4 to just past the IPv4 header, if one is present and has a
1652 * correct length, and otherwise NULL.
1653 *
1654 * - packet->l7 to just past the TCP or UDP or ICMP header, if one is
1655 * present and has a correct length, and otherwise NULL.
1656 *
1657 * Returns NDIS_STATUS_SUCCESS normally. Fails only if packet data cannot be accessed
1658 * (e.g. if Pkt_CopyBytesOut() returns an error).
1659 *----------------------------------------------------------------------------
1660 */
1661 NDIS_STATUS
1662 OvsExtractFlow(const NET_BUFFER_LIST *packet,
1663 UINT32 inPort,
1664 OvsFlowKey *flow,
1665 POVS_PACKET_HDR_INFO layers,
1666 OvsIPv4TunnelKey *tunKey)
1667 {
1668 struct Eth_Header *eth;
1669 UINT8 offset = 0;
1670 PVOID vlanTagValue;
1671
1672 layers->value = 0;
1673
1674 if (tunKey) {
1675 ASSERT(tunKey->dst != 0);
1676 RtlMoveMemory(&flow->tunKey, tunKey, sizeof flow->tunKey);
1677 flow->l2.offset = 0;
1678 } else {
1679 flow->tunKey.dst = 0;
1680 flow->l2.offset = OVS_WIN_TUNNEL_KEY_SIZE;
1681 }
1682
1683 flow->l2.inPort = inPort;
1684
1685 if ( OvsPacketLenNBL(packet) < ETH_HEADER_LEN_DIX) {
1686 flow->l2.keyLen = OVS_WIN_TUNNEL_KEY_SIZE + 8 - flow->l2.offset;
1687 return NDIS_STATUS_SUCCESS;
1688 }
1689
1690 /* Link layer. */
1691 eth = (Eth_Header *)GetStartAddrNBL((NET_BUFFER_LIST *)packet);
1692 memcpy(flow->l2.dlSrc, eth->src, ETH_ADDR_LENGTH);
1693 memcpy(flow->l2.dlDst, eth->dst, ETH_ADDR_LENGTH);
1694
1695 /*
1696 * vlan_tci.
1697 */
1698 vlanTagValue = NET_BUFFER_LIST_INFO(packet, Ieee8021QNetBufferListInfo);
1699 if (vlanTagValue) {
1700 PNDIS_NET_BUFFER_LIST_8021Q_INFO vlanTag =
1701 (PNDIS_NET_BUFFER_LIST_8021Q_INFO)(PVOID *)&vlanTagValue;
1702 flow->l2.vlanTci = htons(vlanTag->TagHeader.VlanId | OVSWIN_VLAN_CFI |
1703 (vlanTag->TagHeader.UserPriority << 13));
1704 } else {
1705 if (eth->dix.typeNBO == ETH_TYPE_802_1PQ_NBO) {
1706 Eth_802_1pq_Tag *tag= (Eth_802_1pq_Tag *)&eth->dix.typeNBO;
1707 flow->l2.vlanTci = ((UINT16)tag->priority << 13) |
1708 OVSWIN_VLAN_CFI |
1709 ((UINT16)tag->vidHi << 8) | tag->vidLo;
1710 offset = sizeof (Eth_802_1pq_Tag);
1711 } else {
1712 flow->l2.vlanTci = 0;
1713 }
1714 /*
1715 * XXX
1716 * Please note after this point, src mac and dst mac should
1717 * not be accessed through eth
1718 */
1719 eth = (Eth_Header *)((UINT8 *)eth + offset);
1720 }
1721
1722 /*
1723 * dl_type.
1724 *
1725 * XXX assume that at least the first
1726 * 12 bytes of received packets are mapped. This code has the stronger
1727 * assumption that at least the first 22 bytes of 'packet' is mapped (if my
1728 * arithmetic is right).
1729 */
1730 if (ETH_TYPENOT8023(eth->dix.typeNBO)) {
1731 flow->l2.dlType = eth->dix.typeNBO;
1732 layers->l3Offset = ETH_HEADER_LEN_DIX + offset;
1733 } else if (OvsPacketLenNBL(packet) >= ETH_HEADER_LEN_802_3 &&
1734 eth->e802_3.llc.dsap == 0xaa &&
1735 eth->e802_3.llc.ssap == 0xaa &&
1736 eth->e802_3.llc.control == ETH_LLC_CONTROL_UFRAME &&
1737 eth->e802_3.snap.snapOrg[0] == 0x00 &&
1738 eth->e802_3.snap.snapOrg[1] == 0x00 &&
1739 eth->e802_3.snap.snapOrg[2] == 0x00) {
1740 flow->l2.dlType = eth->e802_3.snap.snapType.typeNBO;
1741 layers->l3Offset = ETH_HEADER_LEN_802_3 + offset;
1742 } else {
1743 flow->l2.dlType = htons(OVSWIN_DL_TYPE_NONE);
1744 layers->l3Offset = ETH_HEADER_LEN_DIX + offset;
1745 }
1746
1747 flow->l2.keyLen = OVS_WIN_TUNNEL_KEY_SIZE + OVS_L2_KEY_SIZE - flow->l2.offset;
1748 /* Network layer. */
1749 if (flow->l2.dlType == htons(ETH_TYPE_IPV4)) {
1750 struct IPHdr ip_storage;
1751 const struct IPHdr *nh;
1752 IpKey *ipKey = &flow->ipKey;
1753
1754 flow->l2.keyLen += OVS_IP_KEY_SIZE;
1755 layers->isIPv4 = 1;
1756 nh = OvsGetIp(packet, layers->l3Offset, &ip_storage);
1757 if (nh) {
1758 layers->l4Offset = layers->l3Offset + nh->ihl * 4;
1759
1760 ipKey->nwSrc = nh->saddr;
1761 ipKey->nwDst = nh->daddr;
1762 ipKey->nwProto = nh->protocol;
1763
1764 ipKey->nwTos = nh->tos;
1765 if (nh->frag_off & htons(IP_MF | IP_OFFSET)) {
1766 ipKey->nwFrag = OVSWIN_NW_FRAG_ANY;
1767 if (nh->frag_off & htons(IP_OFFSET)) {
1768 ipKey->nwFrag |= OVSWIN_NW_FRAG_LATER;
1769 }
1770 } else {
1771 ipKey->nwFrag = 0;
1772 }
1773
1774 ipKey->nwTtl = nh->ttl;
1775 ipKey->l4.tpSrc = 0;
1776 ipKey->l4.tpDst = 0;
1777
1778 if (!(nh->frag_off & htons(IP_OFFSET))) {
1779 if (ipKey->nwProto == SOCKET_IPPROTO_TCP) {
1780 OvsParseTcp(packet, &ipKey->l4, layers);
1781 } else if (ipKey->nwProto == SOCKET_IPPROTO_UDP) {
1782 OvsParseUdp(packet, &ipKey->l4, layers);
1783 } else if (ipKey->nwProto == SOCKET_IPPROTO_ICMP) {
1784 ICMPHdr icmpStorage;
1785 const ICMPHdr *icmp;
1786
1787 icmp = OvsGetIcmp(packet, layers->l4Offset, &icmpStorage);
1788 if (icmp) {
1789 ipKey->l4.tpSrc = htons(icmp->type);
1790 ipKey->l4.tpDst = htons(icmp->code);
1791 layers->l7Offset = layers->l4Offset + sizeof *icmp;
1792 }
1793 }
1794 }
1795 } else {
1796 ((UINT64 *)ipKey)[0] = 0;
1797 ((UINT64 *)ipKey)[1] = 0;
1798 }
1799 } else if (flow->l2.dlType == htons(ETH_TYPE_IPV6)) {
1800 NDIS_STATUS status;
1801 flow->l2.keyLen += OVS_IPV6_KEY_SIZE;
1802 status = OvsParseIPv6(packet, flow, layers);
1803 if (status != NDIS_STATUS_SUCCESS) {
1804 memset(&flow->ipv6Key, 0, sizeof (Ipv6Key));
1805 return status;
1806 }
1807 layers->isIPv6 = 1;
1808 flow->ipv6Key.l4.tpSrc = 0;
1809 flow->ipv6Key.l4.tpDst = 0;
1810 flow->ipv6Key.pad = 0;
1811
1812 if (flow->ipv6Key.nwProto == SOCKET_IPPROTO_TCP) {
1813 OvsParseTcp(packet, &(flow->ipv6Key.l4), layers);
1814 } else if (flow->ipv6Key.nwProto == SOCKET_IPPROTO_UDP) {
1815 OvsParseUdp(packet, &(flow->ipv6Key.l4), layers);
1816 } else if (flow->ipv6Key.nwProto == SOCKET_IPPROTO_ICMPV6) {
1817 OvsParseIcmpV6(packet, flow, layers);
1818 flow->l2.keyLen += (OVS_ICMPV6_KEY_SIZE - OVS_IPV6_KEY_SIZE);
1819 }
1820 } else if (flow->l2.dlType == htons(ETH_TYPE_ARP)) {
1821 EtherArp arpStorage;
1822 const EtherArp *arp;
1823 ArpKey *arpKey = &flow->arpKey;
1824 ((UINT64 *)arpKey)[0] = 0;
1825 ((UINT64 *)arpKey)[1] = 0;
1826 ((UINT64 *)arpKey)[2] = 0;
1827 flow->l2.keyLen += OVS_ARP_KEY_SIZE;
1828 arp = OvsGetArp(packet, layers->l3Offset, &arpStorage);
1829 if (arp && arp->ea_hdr.ar_hrd == htons(1) &&
1830 arp->ea_hdr.ar_pro == htons(ETH_TYPE_IPV4) &&
1831 arp->ea_hdr.ar_hln == ETH_ADDR_LENGTH &&
1832 arp->ea_hdr.ar_pln == 4) {
1833 /* We only match on the lower 8 bits of the opcode. */
1834 if (ntohs(arp->ea_hdr.ar_op) <= 0xff) {
1835 arpKey->nwProto = (UINT8)ntohs(arp->ea_hdr.ar_op);
1836 }
1837 if (arpKey->nwProto == ARPOP_REQUEST
1838 || arpKey->nwProto == ARPOP_REPLY) {
1839 memcpy(&arpKey->nwSrc, arp->arp_spa, 4);
1840 memcpy(&arpKey->nwDst, arp->arp_tpa, 4);
1841 memcpy(arpKey->arpSha, arp->arp_sha, ETH_ADDR_LENGTH);
1842 memcpy(arpKey->arpTha, arp->arp_tha, ETH_ADDR_LENGTH);
1843 }
1844 }
1845 }
1846
1847 return NDIS_STATUS_SUCCESS;
1848 }
1849
1850 __inline BOOLEAN
1851 FlowEqual(UINT64 *src, UINT64 *dst, UINT32 size)
1852 {
1853 UINT32 i;
1854 ASSERT((size & 0x7) == 0);
1855 ASSERT(((UINT64)src & 0x7) == 0);
1856 ASSERT(((UINT64)dst & 0x7) == 0);
1857 for (i = 0; i < (size >> 3); i++) {
1858 if (src[i] != dst[i]) {
1859 return FALSE;
1860 }
1861 }
1862 return TRUE;
1863 }
1864
1865
1866 /*
1867 * ----------------------------------------------------------------------------
1868 * AddFlow --
1869 * Add a flow to flow table.
1870 *
1871 * Results:
1872 * NDIS_STATUS_SUCCESS if no same flow in the flow table.
1873 * ----------------------------------------------------------------------------
1874 */
1875 NTSTATUS
1876 AddFlow(OVS_DATAPATH *datapath, OvsFlow *flow)
1877 {
1878 PLIST_ENTRY head;
1879
1880 if (OvsLookupFlow(datapath, &flow->key, &flow->hash, TRUE) != NULL) {
1881 return STATUS_INVALID_HANDLE;
1882 }
1883
1884 head = &(datapath->flowTable[HASH_BUCKET(flow->hash)]);
1885 /*
1886 * We need fence here to make sure flow's nextPtr is updated before
1887 * head->nextPtr is updated.
1888 */
1889 KeMemoryBarrier();
1890
1891 //KeAcquireSpinLock(&FilterDeviceExtension->NblQueueLock, &oldIrql);
1892 InsertTailList(head, &flow->ListEntry);
1893 //KeReleaseSpinLock(&FilterDeviceExtension->NblQueueLock, oldIrql);
1894
1895 datapath->nFlows++;
1896
1897 return STATUS_SUCCESS;
1898 }
1899
1900
1901 /* ----------------------------------------------------------------------------
1902 * RemoveFlow --
1903 * Remove a flow from flow table, and added to wait list
1904 * ----------------------------------------------------------------------------
1905 */
1906 VOID
1907 RemoveFlow(OVS_DATAPATH *datapath,
1908 OvsFlow **flow)
1909 {
1910 OvsFlow *f = *flow;
1911 *flow = NULL;
1912
1913 ASSERT(datapath->nFlows);
1914 datapath->nFlows--;
1915 // Remove the flow from queue
1916 RemoveEntryList(&f->ListEntry);
1917 FreeFlow(f);
1918 }
1919
1920
1921 /*
1922 * ----------------------------------------------------------------------------
1923 * OvsLookupFlow --
1924 *
1925 * Find flow from flow table based on flow key.
1926 * Caller should either hold portset handle or should
1927 * have a flowRef in datapath or Acquired datapath.
1928 *
1929 * Results:
1930 * Flow pointer if lookup successful.
1931 * NULL if not exists.
1932 * ----------------------------------------------------------------------------
1933 */
1934 OvsFlow *
1935 OvsLookupFlow(OVS_DATAPATH *datapath,
1936 const OvsFlowKey *key,
1937 UINT64 *hash,
1938 BOOLEAN hashValid)
1939 {
1940 PLIST_ENTRY link, head;
1941 UINT16 offset = key->l2.offset;
1942 UINT16 size = key->l2.keyLen;
1943 UINT8 *start;
1944
1945 ASSERT(key->tunKey.dst || offset == sizeof (OvsIPv4TunnelKey));
1946 ASSERT(!key->tunKey.dst || offset == 0);
1947
1948 start = (UINT8 *)key + offset;
1949
1950 if (!hashValid) {
1951 *hash = OvsJhashBytes(start, size, 0);
1952 }
1953
1954 head = &datapath->flowTable[HASH_BUCKET(*hash)];
1955 link = head->Flink;
1956 while (link != head) {
1957 OvsFlow *flow = CONTAINING_RECORD(link, OvsFlow, ListEntry);
1958
1959 if (flow->hash == *hash &&
1960 flow->key.l2.val == key->l2.val &&
1961 FlowEqual((UINT64 *)((uint8 *)&flow->key + offset),
1962 (UINT64 *)start, size)) {
1963 return flow;
1964 }
1965 link = link->Flink;
1966 }
1967 return NULL;
1968 }
1969
1970
1971 /*
1972 * ----------------------------------------------------------------------------
1973 * OvsHashFlow --
1974 * Calculate the hash for the given flow key.
1975 * ----------------------------------------------------------------------------
1976 */
1977 UINT64
1978 OvsHashFlow(const OvsFlowKey *key)
1979 {
1980 UINT16 offset = key->l2.offset;
1981 UINT16 size = key->l2.keyLen;
1982 UINT8 *start;
1983
1984 ASSERT(key->tunKey.dst || offset == sizeof (OvsIPv4TunnelKey));
1985 ASSERT(!key->tunKey.dst || offset == 0);
1986 start = (UINT8 *)key + offset;
1987 return OvsJhashBytes(start, size, 0);
1988 }
1989
1990
1991 /*
1992 * ----------------------------------------------------------------------------
1993 * FreeFlow --
1994 * Free a flow and its actions.
1995 * ----------------------------------------------------------------------------
1996 */
1997 VOID
1998 FreeFlow(OvsFlow *flow)
1999 {
2000 ASSERT(flow);
2001 OvsFreeMemoryWithTag(flow, OVS_FLOW_POOL_TAG);
2002 }
2003
2004 NTSTATUS
2005 OvsDoDumpFlows(OvsFlowDumpInput *dumpInput,
2006 OvsFlowDumpOutput *dumpOutput,
2007 UINT32 *replyLen)
2008 {
2009 UINT32 dpNo;
2010 OVS_DATAPATH *datapath = NULL;
2011 OvsFlow *flow;
2012 PLIST_ENTRY node, head;
2013 UINT32 column = 0;
2014 UINT32 rowIndex, columnIndex;
2015 LOCK_STATE_EX dpLockState;
2016 NTSTATUS status = STATUS_SUCCESS;
2017 BOOLEAN findNextNonEmpty = FALSE;
2018
2019 dpNo = dumpInput->dpNo;
2020 if (gOvsSwitchContext->dpNo != dpNo) {
2021 status = STATUS_INVALID_PARAMETER;
2022 goto exit;
2023 }
2024
2025 rowIndex = dumpInput->position[0];
2026 if (rowIndex >= OVS_FLOW_TABLE_SIZE) {
2027 dumpOutput->n = 0;
2028 *replyLen = sizeof(*dumpOutput);
2029 goto exit;
2030 }
2031
2032 columnIndex = dumpInput->position[1];
2033
2034 datapath = &gOvsSwitchContext->datapath;
2035 ASSERT(datapath);
2036 OvsAcquireDatapathRead(datapath, &dpLockState, FALSE);
2037
2038 head = &datapath->flowTable[rowIndex];
2039 node = head->Flink;
2040
2041 while (column < columnIndex) {
2042 if (node == head) {
2043 break;
2044 }
2045 node = node->Flink;
2046 column++;
2047 }
2048
2049 if (node == head) {
2050 findNextNonEmpty = TRUE;
2051 columnIndex = 0;
2052 }
2053
2054 if (findNextNonEmpty) {
2055 while (head == node) {
2056 if (++rowIndex >= OVS_FLOW_TABLE_SIZE) {
2057 dumpOutput->n = 0;
2058 goto dp_unlock;
2059 }
2060 head = &datapath->flowTable[rowIndex];
2061 node = head->Flink;
2062 }
2063 }
2064
2065 ASSERT(node != head);
2066 ASSERT(rowIndex < OVS_FLOW_TABLE_SIZE);
2067
2068 flow = CONTAINING_RECORD(node, OvsFlow, ListEntry);
2069 status = ReportFlowInfo(flow, dumpInput->getFlags, &dumpOutput->flow);
2070
2071 if (status == STATUS_BUFFER_TOO_SMALL) {
2072 dumpOutput->n = sizeof(OvsFlowDumpOutput) + flow->actionsLen;
2073 *replyLen = sizeof(*dumpOutput);
2074 } else {
2075 dumpOutput->n = 1; //one flow reported.
2076 *replyLen = sizeof(*dumpOutput) + dumpOutput->flow.actionsLen;
2077 }
2078
2079 dumpOutput->position[0] = rowIndex;
2080 dumpOutput->position[1] = ++columnIndex;
2081
2082 dp_unlock:
2083 OvsReleaseDatapath(datapath, &dpLockState);
2084
2085 exit:
2086 return status;
2087 }
2088
2089 static NTSTATUS
2090 ReportFlowInfo(OvsFlow *flow,
2091 UINT32 getFlags,
2092 OvsFlowInfo *info)
2093 {
2094 NTSTATUS status = STATUS_SUCCESS;
2095
2096 if (getFlags & FLOW_GET_KEY) {
2097 // always copy the tunnel key part
2098 RtlCopyMemory(&info->key, &flow->key,
2099 flow->key.l2.keyLen + flow->key.l2.offset);
2100 }
2101
2102 if (getFlags & FLOW_GET_STATS) {
2103 OvsFlowStats *stats = &info->stats;
2104 stats->packetCount = flow->packetCount;
2105 stats->byteCount = flow->byteCount;
2106 stats->used = (UINT32)flow->used;
2107 stats->tcpFlags = flow->tcpFlags;
2108 }
2109
2110 if (getFlags & FLOW_GET_ACTIONS) {
2111 if (flow->actionsLen == 0) {
2112 info->actionsLen = 0;
2113 } else {
2114 info->actions = flow->actions;
2115 info->actionsLen = flow->actionsLen;
2116 }
2117 }
2118
2119 return status;
2120 }
2121
2122 NTSTATUS
2123 OvsPutFlowIoctl(PVOID inputBuffer,
2124 UINT32 inputLength,
2125 struct OvsFlowStats *stats)
2126 {
2127 NTSTATUS status = STATUS_SUCCESS;
2128 OVS_DATAPATH *datapath = NULL;
2129 ULONG actionsLen;
2130 OvsFlowPut *put;
2131 UINT32 dpNo;
2132 LOCK_STATE_EX dpLockState;
2133
2134 if ((inputLength < sizeof(OvsFlowPut)) || (inputBuffer == NULL)) {
2135 return STATUS_INFO_LENGTH_MISMATCH;
2136 }
2137
2138 put = (OvsFlowPut *)inputBuffer;
2139 if (put->actionsLen > 0) {
2140 actionsLen = put->actionsLen;
2141 } else {
2142 actionsLen = 0;
2143 }
2144
2145 dpNo = put->dpNo;
2146 if (gOvsSwitchContext->dpNo != dpNo) {
2147 status = STATUS_INVALID_PARAMETER;
2148 goto exit;
2149 }
2150
2151 datapath = &gOvsSwitchContext->datapath;
2152 ASSERT(datapath);
2153 OvsAcquireDatapathWrite(datapath, &dpLockState, FALSE);
2154 status = HandleFlowPut(put, datapath, stats);
2155 OvsReleaseDatapath(datapath, &dpLockState);
2156
2157 exit:
2158 return status;
2159 }
2160
2161
2162 /* Handles flow add, modify as well as delete */
2163 static NTSTATUS
2164 HandleFlowPut(OvsFlowPut *put,
2165 OVS_DATAPATH *datapath,
2166 struct OvsFlowStats *stats)
2167 {
2168 BOOLEAN mayCreate, mayModify, mayDelete;
2169 OvsFlow *KernelFlow;
2170 UINT64 hash;
2171 NTSTATUS status = STATUS_SUCCESS;
2172
2173 mayCreate = (put->flags & OVSWIN_FLOW_PUT_CREATE) != 0;
2174 mayModify = (put->flags & OVSWIN_FLOW_PUT_MODIFY) != 0;
2175 mayDelete = (put->flags & OVSWIN_FLOW_PUT_DELETE) != 0;
2176
2177 if ((mayCreate || mayModify) == mayDelete) {
2178 return STATUS_INVALID_PARAMETER;
2179 }
2180
2181 KernelFlow = OvsLookupFlow(datapath, &put->key, &hash, FALSE);
2182 if (!KernelFlow) {
2183 if (!mayCreate) {
2184 return STATUS_INVALID_PARAMETER;
2185 }
2186
2187 status = OvsPrepareFlow(&KernelFlow, put, hash);
2188 if (status != STATUS_SUCCESS) {
2189 return STATUS_UNSUCCESSFUL;
2190 }
2191
2192 status = AddFlow(datapath, KernelFlow);
2193 if (status != STATUS_SUCCESS) {
2194 FreeFlow(KernelFlow);
2195 return STATUS_UNSUCCESSFUL;
2196 }
2197
2198 /* Validate the flow addition */
2199 {
2200 UINT64 newHash;
2201 OvsFlow *flow = OvsLookupFlow(datapath, &put->key, &newHash,
2202 FALSE);
2203 ASSERT(flow);
2204 ASSERT(newHash == hash);
2205 if (!flow || newHash != hash) {
2206 return STATUS_UNSUCCESSFUL;
2207 }
2208 }
2209 } else {
2210 stats->packetCount = KernelFlow->packetCount;
2211 stats->byteCount = KernelFlow->byteCount;
2212 stats->tcpFlags = KernelFlow->tcpFlags;
2213 stats->used = (UINT32)KernelFlow->used;
2214
2215 if (mayModify) {
2216 OvsFlow *newFlow;
2217 status = OvsPrepareFlow(&newFlow, put, hash);
2218 if (status != STATUS_SUCCESS) {
2219 return STATUS_UNSUCCESSFUL;
2220 }
2221
2222 KernelFlow = OvsLookupFlow(datapath, &put->key, &hash, TRUE);
2223 if (KernelFlow) {
2224 if ((put->flags & OVSWIN_FLOW_PUT_CLEAR) == 0) {
2225 newFlow->packetCount = KernelFlow->packetCount;
2226 newFlow->byteCount = KernelFlow->byteCount;
2227 newFlow->tcpFlags = KernelFlow->tcpFlags;
2228 }
2229 RemoveFlow(datapath, &KernelFlow);
2230 } else {
2231 if ((put->flags & OVSWIN_FLOW_PUT_CLEAR) == 0) {
2232 newFlow->packetCount = stats->packetCount;
2233 newFlow->byteCount = stats->byteCount;
2234 newFlow->tcpFlags = stats->tcpFlags;
2235 }
2236 }
2237 status = AddFlow(datapath, newFlow);
2238 ASSERT(status == STATUS_SUCCESS);
2239
2240 /* Validate the flow addition */
2241 {
2242 UINT64 newHash;
2243 OvsFlow *testflow = OvsLookupFlow(datapath, &put->key,
2244 &newHash, FALSE);
2245 ASSERT(testflow);
2246 ASSERT(newHash == hash);
2247 if (!testflow || newHash != hash) {
2248 FreeFlow(newFlow);
2249 return STATUS_UNSUCCESSFUL;
2250 }
2251 }
2252 } else {
2253 if (mayDelete) {
2254 if (KernelFlow) {
2255 RemoveFlow(datapath, &KernelFlow);
2256 }
2257 } else {
2258 /* Return success if an identical flow already exists. */
2259 /* XXX: should we return EEXIST in a netlink error? */
2260 return STATUS_SUCCESS;
2261 }
2262 }
2263 }
2264 return STATUS_SUCCESS;
2265 }
2266
2267 static NTSTATUS
2268 OvsPrepareFlow(OvsFlow **flow,
2269 const OvsFlowPut *put,
2270 UINT64 hash)
2271 {
2272 OvsFlow *localFlow = *flow;
2273 NTSTATUS status = STATUS_SUCCESS;
2274
2275 do {
2276 *flow = localFlow =
2277 OvsAllocateMemoryWithTag(sizeof(OvsFlow) + put->actionsLen,
2278 OVS_FLOW_POOL_TAG);
2279 if (localFlow == NULL) {
2280 status = STATUS_NO_MEMORY;
2281 break;
2282 }
2283
2284 localFlow->key = put->key;
2285 localFlow->actionsLen = put->actionsLen;
2286 if (put->actionsLen) {
2287 NdisMoveMemory((PUCHAR)localFlow->actions, put->actions,
2288 put->actionsLen);
2289 }
2290 localFlow->userActionsLen = 0; // 0 indicate no conversion is made
2291 localFlow->used = 0;
2292 localFlow->packetCount = 0;
2293 localFlow->byteCount = 0;
2294 localFlow->tcpFlags = 0;
2295 localFlow->hash = hash;
2296 } while(FALSE);
2297
2298 return status;
2299 }
2300
2301 NTSTATUS
2302 OvsGetFlowIoctl(PVOID inputBuffer,
2303 PVOID outputBuffer)
2304 {
2305 NTSTATUS status = STATUS_SUCCESS;
2306 OVS_DATAPATH *datapath = NULL;
2307 OvsFlow *flow;
2308 UINT32 getFlags, getActionsLen;
2309 OvsFlowGetInput *getInput;
2310 OvsFlowGetOutput *getOutput;
2311 UINT64 hash;
2312 UINT32 dpNo;
2313 LOCK_STATE_EX dpLockState;
2314
2315 getInput = (OvsFlowGetInput *) inputBuffer;
2316 getFlags = getInput->getFlags;
2317 getActionsLen = getInput->actionsLen;
2318
2319 if (outputBuffer == NULL) {
2320 return STATUS_INFO_LENGTH_MISMATCH;
2321 }
2322
2323 dpNo = getInput->dpNo;
2324 if (gOvsSwitchContext->dpNo != dpNo) {
2325 status = STATUS_INVALID_PARAMETER;
2326 goto exit;
2327 }
2328
2329 datapath = &gOvsSwitchContext->datapath;
2330 ASSERT(datapath);
2331 OvsAcquireDatapathRead(datapath, &dpLockState, FALSE);
2332 flow = OvsLookupFlow(datapath, &getInput->key, &hash, FALSE);
2333 if (!flow) {
2334 status = STATUS_INVALID_PARAMETER;
2335 goto dp_unlock;
2336 }
2337
2338 getOutput = (OvsFlowGetOutput *)outputBuffer;
2339 ReportFlowInfo(flow, getFlags, &getOutput->info);
2340
2341 dp_unlock:
2342 OvsReleaseDatapath(datapath, &dpLockState);
2343 exit:
2344 return status;
2345 }
2346
2347 NTSTATUS
2348 OvsFlushFlowIoctl(UINT32 dpNo)
2349 {
2350 NTSTATUS status = STATUS_SUCCESS;
2351 OVS_DATAPATH *datapath = NULL;
2352 LOCK_STATE_EX dpLockState;
2353
2354 if (gOvsSwitchContext->dpNo != dpNo) {
2355 status = STATUS_INVALID_PARAMETER;
2356 goto exit;
2357 }
2358
2359 datapath = &gOvsSwitchContext->datapath;
2360 ASSERT(datapath);
2361 OvsAcquireDatapathWrite(datapath, &dpLockState, FALSE);
2362 DeleteAllFlows(datapath);
2363 OvsReleaseDatapath(datapath, &dpLockState);
2364
2365 exit:
2366 return status;
2367 }
2368
2369 UINT32
2370 OvsFlowKeyAttrSize(void)
2371 {
2372 return NlAttrTotalSize(4) /* OVS_KEY_ATTR_PRIORITY */
2373 + NlAttrTotalSize(0) /* OVS_KEY_ATTR_TUNNEL */
2374 + OvsTunKeyAttrSize()
2375 + NlAttrTotalSize(4) /* OVS_KEY_ATTR_IN_PORT */
2376 + NlAttrTotalSize(4) /* OVS_KEY_ATTR_SKB_MARK */
2377 + NlAttrTotalSize(4) /* OVS_KEY_ATTR_DP_HASH */
2378 + NlAttrTotalSize(4) /* OVS_KEY_ATTR_RECIRC_ID */
2379 + NlAttrTotalSize(12) /* OVS_KEY_ATTR_ETHERNET */
2380 + NlAttrTotalSize(2) /* OVS_KEY_ATTR_ETHERTYPE */
2381 + NlAttrTotalSize(4) /* OVS_KEY_ATTR_VLAN */
2382 + NlAttrTotalSize(0) /* OVS_KEY_ATTR_ENCAP */
2383 + NlAttrTotalSize(2) /* OVS_KEY_ATTR_ETHERTYPE */
2384 + NlAttrTotalSize(40) /* OVS_KEY_ATTR_IPV6 */
2385 + NlAttrTotalSize(2) /* OVS_KEY_ATTR_ICMPV6 */
2386 + NlAttrTotalSize(28); /* OVS_KEY_ATTR_ND */
2387 }
2388
2389 UINT32
2390 OvsTunKeyAttrSize(void)
2391 {
2392 /* Whenever adding new OVS_TUNNEL_KEY_ FIELDS, we should consider
2393 * updating this function.
2394 */
2395 return NlAttrTotalSize(8) /* OVS_TUNNEL_KEY_ATTR_ID */
2396 + NlAttrTotalSize(4) /* OVS_TUNNEL_KEY_ATTR_IPV4_SRC */
2397 + NlAttrTotalSize(4) /* OVS_TUNNEL_KEY_ATTR_IPV4_DST */
2398 + NlAttrTotalSize(1) /* OVS_TUNNEL_KEY_ATTR_TOS */
2399 + NlAttrTotalSize(1) /* OVS_TUNNEL_KEY_ATTR_TTL */
2400 + NlAttrTotalSize(0) /* OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT */
2401 + NlAttrTotalSize(0) /* OVS_TUNNEL_KEY_ATTR_CSUM */
2402 + NlAttrTotalSize(0) /* OVS_TUNNEL_KEY_ATTR_OAM */
2403 + NlAttrTotalSize(256) /* OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS */
2404 + NlAttrTotalSize(2) /* OVS_TUNNEL_KEY_ATTR_TP_SRC */
2405 + NlAttrTotalSize(2); /* OVS_TUNNEL_KEY_ATTR_TP_DST */
2406 }
2407
2408 #pragma warning( pop )
openvswitch mirror