2 * Copyright (c) 2014 VMware, Inc.
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:
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
31 #define OVS_DBG_MOD OVS_DBG_VPORT
34 #define VPORT_NIC_ENTER(_nic) \
35 OVS_LOG_TRACE("Enter: PortId: %x, NicIndex: %d", _nic->PortId, \
38 #define VPORT_NIC_EXIT(_nic) \
39 OVS_LOG_TRACE("Exit: PortId: %x, NicIndex: %d", _nic->PortId, \
42 #define VPORT_PORT_ENTER(_port) \
43 OVS_LOG_TRACE("Enter: PortId: %x", _port->PortId)
45 #define VPORT_PORT_EXIT(_port) \
46 OVS_LOG_TRACE("Exit: PortId: %x", _port->PortId)
48 #define OVS_VPORT_DEFAULT_WAIT_TIME_MICROSEC 100
50 extern POVS_SWITCH_CONTEXT gOvsSwitchContext;
52 static VOID OvsInitVportWithPortParam(POVS_VPORT_ENTRY vport,
53 PNDIS_SWITCH_PORT_PARAMETERS portParam);
54 static VOID OvsInitVportWithNicParam(POVS_SWITCH_CONTEXT switchContext,
55 POVS_VPORT_ENTRY vport, PNDIS_SWITCH_NIC_PARAMETERS nicParam);
56 static VOID OvsInitPhysNicVport(POVS_VPORT_ENTRY physExtVPort,
57 POVS_VPORT_ENTRY virtExtVport, UINT32 nicIndex);
58 static __inline VOID OvsWaitActivate(POVS_SWITCH_CONTEXT switchContext,
60 static NTSTATUS OvsGetExtInfoIoctl(POVS_VPORT_GET vportGet,
61 POVS_VPORT_EXT_INFO extInfo);
62 static NTSTATUS CreateNetlinkMesgForNetdev(POVS_VPORT_EXT_INFO info,
67 static POVS_VPORT_ENTRY OvsFindVportByHvNameW(POVS_SWITCH_CONTEXT switchContext,
68 PWSTR wsName, SIZE_T wstrSize);
69 static NDIS_STATUS InitHvVportCommon(POVS_SWITCH_CONTEXT switchContext,
70 POVS_VPORT_ENTRY vport,
74 * Functions implemented in relaton to NDIS port manipulation.
77 HvCreatePort(POVS_SWITCH_CONTEXT switchContext,
78 PNDIS_SWITCH_PORT_PARAMETERS portParam)
80 POVS_VPORT_ENTRY vport;
81 LOCK_STATE_EX lockState;
82 NDIS_STATUS status = NDIS_STATUS_SUCCESS;
83 BOOLEAN newPort = FALSE;
85 VPORT_PORT_ENTER(portParam);
87 NdisAcquireRWLockWrite(switchContext->dispatchLock, &lockState, 0);
88 /* Lookup by port ID. */
89 vport = OvsFindVportByPortIdAndNicIndex(switchContext,
90 portParam->PortId, 0);
92 OVS_LOG_ERROR("Port add failed due to duplicate port name, "
93 "port Id: %u", portParam->PortId);
94 status = STATUS_DATA_NOT_ACCEPTED;
95 goto create_port_done;
99 * Lookup by port name to see if this port with this name had been added
100 * (and deleted) previously.
102 vport = OvsFindVportByHvNameW(gOvsSwitchContext,
103 portParam->PortFriendlyName.String,
104 portParam->PortFriendlyName.Length);
105 if (vport && vport->isPresentOnHv == FALSE) {
106 OVS_LOG_ERROR("Port add failed since a port already exists on "
107 "the specified port Id: %u, ovsName: %s",
108 portParam->PortId, vport->ovsName);
109 status = STATUS_DATA_NOT_ACCEPTED;
110 goto create_port_done;
114 ASSERT(vport->isPresentOnHv);
115 ASSERT(vport->portNo != OVS_DPPORT_NUMBER_INVALID);
118 * It should be possible to simply just mark this port as "not deleted"
119 * given that the port Id and the name are the same and also provided
120 * that the other properties that we cache have not changed.
122 if (vport->portType != portParam->PortType) {
123 OVS_LOG_INFO("Port add failed due to PortType change, port Id: %u"
124 " old: %u, new: %u", portParam->PortId,
125 vport->portType, portParam->PortType);
126 status = STATUS_DATA_NOT_ACCEPTED;
127 goto create_port_done;
129 vport->isPresentOnHv = FALSE;
131 vport = (POVS_VPORT_ENTRY)OvsAllocateVport();
133 status = NDIS_STATUS_RESOURCES;
134 goto create_port_done;
138 OvsInitVportWithPortParam(vport, portParam);
139 InitHvVportCommon(switchContext, vport, newPort);
142 NdisReleaseRWLock(switchContext->dispatchLock, &lockState);
143 VPORT_PORT_EXIT(portParam);
149 * Function updating the port properties
152 HvUpdatePort(POVS_SWITCH_CONTEXT switchContext,
153 PNDIS_SWITCH_PORT_PARAMETERS portParam)
155 POVS_VPORT_ENTRY vport;
156 LOCK_STATE_EX lockState;
157 OVS_VPORT_STATE ovsState;
158 NDIS_SWITCH_NIC_STATE nicState;
160 VPORT_PORT_ENTER(portParam);
162 NdisAcquireRWLockWrite(switchContext->dispatchLock, &lockState, 0);
163 vport = OvsFindVportByPortIdAndNicIndex(switchContext,
164 portParam->PortId, 0);
166 * Update properties only for NETDEV ports for supprting PS script
167 * We don't allow changing the names of the internal or external ports
169 if (vport == NULL || (( vport->portType != NdisSwitchPortTypeSynthetic) &&
170 ( vport->portType != NdisSwitchPortTypeEmulated))) {
171 goto update_port_done;
174 /* Store the nic and the OVS states as Nic Create won't be called */
175 ovsState = vport->ovsState;
176 nicState = vport->nicState;
179 * Currently only the port friendly name is being updated
180 * Make sure that no other properties are changed
182 ASSERT(portParam->PortId == vport->portId);
183 ASSERT(portParam->PortState == vport->portState);
184 ASSERT(portParam->PortType == vport->portType);
187 * Call the set parameters function the handle all properties
188 * change in a single place in case future version supports change of
191 OvsInitVportWithPortParam(vport, portParam);
192 /* Retore the nic and OVS states */
193 vport->nicState = nicState;
194 vport->ovsState = ovsState;
197 NdisReleaseRWLock(switchContext->dispatchLock, &lockState);
198 VPORT_PORT_EXIT(portParam);
200 /* Must always return success */
201 return NDIS_STATUS_SUCCESS;
205 HvTeardownPort(POVS_SWITCH_CONTEXT switchContext,
206 PNDIS_SWITCH_PORT_PARAMETERS portParam)
208 POVS_VPORT_ENTRY vport;
209 LOCK_STATE_EX lockState;
211 VPORT_PORT_ENTER(portParam);
213 NdisAcquireRWLockWrite(switchContext->dispatchLock, &lockState, 0);
214 vport = OvsFindVportByPortIdAndNicIndex(switchContext,
215 portParam->PortId, 0);
217 /* add assertion here */
218 vport->portState = NdisSwitchPortStateTeardown;
219 vport->ovsState = OVS_STATE_PORT_TEAR_DOWN;
221 OVS_LOG_WARN("Vport not present.");
223 NdisReleaseRWLock(switchContext->dispatchLock, &lockState);
225 VPORT_PORT_EXIT(portParam);
230 HvDeletePort(POVS_SWITCH_CONTEXT switchContext,
231 PNDIS_SWITCH_PORT_PARAMETERS portParams)
233 POVS_VPORT_ENTRY vport;
234 LOCK_STATE_EX lockState;
236 VPORT_PORT_ENTER(portParams);
238 NdisAcquireRWLockWrite(switchContext->dispatchLock, &lockState, 0);
239 vport = OvsFindVportByPortIdAndNicIndex(switchContext,
240 portParams->PortId, 0);
243 * XXX: we can only destroy and remove the port if its datapath port
244 * counterpart was deleted. If the datapath port counterpart is present,
245 * we only mark the vport for deletion, so that a netlink command vport
246 * delete will delete the vport.
249 OvsRemoveAndDeleteVport(switchContext, vport, TRUE, FALSE, NULL);
251 OVS_LOG_WARN("Vport not present.");
253 NdisReleaseRWLock(switchContext->dispatchLock, &lockState);
255 VPORT_PORT_EXIT(portParams);
260 * Functions implemented in relaton to NDIS NIC manipulation.
263 HvCreateNic(POVS_SWITCH_CONTEXT switchContext,
264 PNDIS_SWITCH_NIC_PARAMETERS nicParam)
266 POVS_VPORT_ENTRY vport;
269 NDIS_STATUS status = NDIS_STATUS_SUCCESS;
271 LOCK_STATE_EX lockState;
273 VPORT_NIC_ENTER(nicParam);
275 /* Wait for lists to be initialized. */
276 OvsWaitActivate(switchContext, OVS_VPORT_DEFAULT_WAIT_TIME_MICROSEC);
278 if (!switchContext->isActivated) {
279 OVS_LOG_WARN("Switch is not activated yet.");
280 /* Veto the creation of nic */
281 status = NDIS_STATUS_NOT_SUPPORTED;
285 NdisAcquireRWLockWrite(switchContext->dispatchLock, &lockState, 0);
286 vport = OvsFindVportByPortIdAndNicIndex(switchContext, nicParam->PortId, 0);
288 OVS_LOG_ERROR("Create NIC without Switch Port,"
289 " PortId: %x, NicIndex: %d",
290 nicParam->PortId, nicParam->NicIndex);
291 status = NDIS_STATUS_INVALID_PARAMETER;
295 if (nicParam->NicType == NdisSwitchNicTypeExternal &&
296 nicParam->NicIndex != 0) {
297 POVS_VPORT_ENTRY virtExtVport =
298 (POVS_VPORT_ENTRY)switchContext->virtualExternalVport;
300 vport = (POVS_VPORT_ENTRY)OvsAllocateVport();
302 status = NDIS_STATUS_RESOURCES;
305 OvsInitPhysNicVport(vport, virtExtVport, nicParam->NicIndex);
306 status = InitHvVportCommon(switchContext, vport, TRUE);
307 if (status != NDIS_STATUS_SUCCESS) {
308 OvsFreeMemoryWithTag(vport, OVS_VPORT_POOL_TAG);
312 OvsInitVportWithNicParam(switchContext, vport, nicParam);
313 portNo = vport->portNo;
314 if (vport->ovsState == OVS_STATE_CONNECTED) {
315 event = OVS_EVENT_CONNECT | OVS_EVENT_LINK_UP;
316 } else if (vport->ovsState == OVS_STATE_NIC_CREATED) {
317 event = OVS_EVENT_CONNECT;
321 NdisReleaseRWLock(switchContext->dispatchLock, &lockState);
322 if (portNo != OVS_DPPORT_NUMBER_INVALID && event) {
323 OvsPostEvent(portNo, event);
327 VPORT_NIC_EXIT(nicParam);
328 OVS_LOG_TRACE("Exit: status %8x.\n", status);
334 /* Mark already created NIC as connected. */
336 HvConnectNic(POVS_SWITCH_CONTEXT switchContext,
337 PNDIS_SWITCH_NIC_PARAMETERS nicParam)
339 LOCK_STATE_EX lockState;
340 POVS_VPORT_ENTRY vport;
343 VPORT_NIC_ENTER(nicParam);
345 /* Wait for lists to be initialized. */
346 OvsWaitActivate(switchContext, OVS_VPORT_DEFAULT_WAIT_TIME_MICROSEC);
348 if (!switchContext->isActivated) {
349 OVS_LOG_WARN("Switch is not activated yet.");
353 NdisAcquireRWLockWrite(switchContext->dispatchLock, &lockState, 0);
354 vport = OvsFindVportByPortIdAndNicIndex(switchContext,
359 OVS_LOG_WARN("Vport not present.");
360 NdisReleaseRWLock(switchContext->dispatchLock, &lockState);
365 vport->ovsState = OVS_STATE_CONNECTED;
366 vport->nicState = NdisSwitchNicStateConnected;
367 portNo = vport->portNo;
369 NdisReleaseRWLock(switchContext->dispatchLock, &lockState);
371 /* XXX only if portNo != INVALID or always? */
372 OvsPostEvent(portNo, OVS_EVENT_LINK_UP);
374 if (nicParam->NicType == NdisSwitchNicTypeInternal) {
375 OvsInternalAdapterUp(portNo, &nicParam->NetCfgInstanceId);
379 VPORT_NIC_EXIT(nicParam);
383 HvUpdateNic(POVS_SWITCH_CONTEXT switchContext,
384 PNDIS_SWITCH_NIC_PARAMETERS nicParam)
386 POVS_VPORT_ENTRY vport;
387 LOCK_STATE_EX lockState;
389 UINT32 status = 0, portNo = 0;
391 VPORT_NIC_ENTER(nicParam);
393 /* Wait for lists to be initialized. */
394 OvsWaitActivate(switchContext, OVS_VPORT_DEFAULT_WAIT_TIME_MICROSEC);
396 if (!switchContext->isActivated) {
397 OVS_LOG_WARN("Switch is not activated yet.");
398 goto update_nic_done;
401 NdisAcquireRWLockWrite(switchContext->dispatchLock, &lockState, 0);
402 vport = OvsFindVportByPortIdAndNicIndex(switchContext,
406 NdisReleaseRWLock(switchContext->dispatchLock, &lockState);
407 OVS_LOG_WARN("Vport search failed.");
408 goto update_nic_done;
410 switch (nicParam->NicType) {
411 case NdisSwitchNicTypeExternal:
412 case NdisSwitchNicTypeInternal:
413 RtlCopyMemory(&vport->netCfgInstanceId, &nicParam->NetCfgInstanceId,
416 case NdisSwitchNicTypeSynthetic:
417 case NdisSwitchNicTypeEmulated:
418 if (!RtlEqualMemory(vport->vmMacAddress, nicParam->VMMacAddress,
419 sizeof (vport->vmMacAddress))) {
420 status |= OVS_EVENT_MAC_CHANGE;
421 RtlCopyMemory(vport->vmMacAddress, nicParam->VMMacAddress,
422 sizeof (vport->vmMacAddress));
428 if (!RtlEqualMemory(vport->permMacAddress, nicParam->PermanentMacAddress,
429 sizeof (vport->permMacAddress))) {
430 RtlCopyMemory(vport->permMacAddress, nicParam->PermanentMacAddress,
431 sizeof (vport->permMacAddress));
432 status |= OVS_EVENT_MAC_CHANGE;
434 if (!RtlEqualMemory(vport->currMacAddress, nicParam->CurrentMacAddress,
435 sizeof (vport->currMacAddress))) {
436 RtlCopyMemory(vport->currMacAddress, nicParam->CurrentMacAddress,
437 sizeof (vport->currMacAddress));
438 status |= OVS_EVENT_MAC_CHANGE;
441 if (vport->mtu != nicParam->MTU) {
442 vport->mtu = nicParam->MTU;
443 status |= OVS_EVENT_MTU_CHANGE;
445 vport->numaNodeId = nicParam->NumaNodeId;
446 portNo = vport->portNo;
448 NdisReleaseRWLock(switchContext->dispatchLock, &lockState);
449 if (status && portNo) {
450 OvsPostEvent(portNo, status);
453 VPORT_NIC_EXIT(nicParam);
458 HvDisconnectNic(POVS_SWITCH_CONTEXT switchContext,
459 PNDIS_SWITCH_NIC_PARAMETERS nicParam)
461 POVS_VPORT_ENTRY vport;
463 LOCK_STATE_EX lockState;
464 BOOLEAN isInternalPort = FALSE;
466 VPORT_NIC_ENTER(nicParam);
468 /* Wait for lists to be initialized. */
469 OvsWaitActivate(switchContext, OVS_VPORT_DEFAULT_WAIT_TIME_MICROSEC);
471 if (!switchContext->isActivated) {
472 OVS_LOG_WARN("Switch is not activated yet.");
476 NdisAcquireRWLockWrite(switchContext->dispatchLock, &lockState, 0);
477 vport = OvsFindVportByPortIdAndNicIndex(switchContext,
482 OVS_LOG_WARN("Vport not present.");
483 NdisReleaseRWLock(switchContext->dispatchLock, &lockState);
487 vport->nicState = NdisSwitchNicStateDisconnected;
488 vport->ovsState = OVS_STATE_NIC_CREATED;
489 portNo = vport->portNo;
491 if (vport->ovsType == OVS_VPORT_TYPE_INTERNAL) {
492 isInternalPort = TRUE;
495 NdisReleaseRWLock(switchContext->dispatchLock, &lockState);
497 /* XXX if portNo != INVALID or always? */
498 OvsPostEvent(portNo, OVS_EVENT_LINK_DOWN);
500 if (isInternalPort) {
501 OvsInternalAdapterDown();
505 VPORT_NIC_EXIT(nicParam);
510 HvDeleteNic(POVS_SWITCH_CONTEXT switchContext,
511 PNDIS_SWITCH_NIC_PARAMETERS nicParam)
513 LOCK_STATE_EX lockState;
514 POVS_VPORT_ENTRY vport;
517 VPORT_NIC_ENTER(nicParam);
518 /* Wait for lists to be initialized. */
519 OvsWaitActivate(switchContext, OVS_VPORT_DEFAULT_WAIT_TIME_MICROSEC);
521 if (!switchContext->isActivated) {
522 OVS_LOG_WARN("Switch is not activated yet.");
526 NdisAcquireRWLockWrite(switchContext->dispatchLock, &lockState, 0);
527 vport = OvsFindVportByPortIdAndNicIndex(switchContext,
532 OVS_LOG_WARN("Vport not present.");
533 NdisReleaseRWLock(switchContext->dispatchLock, &lockState);
537 portNo = vport->portNo;
538 if (vport->portType == NdisSwitchPortTypeExternal &&
539 vport->nicIndex != 0) {
540 OvsRemoveAndDeleteVport(switchContext, vport, TRUE, FALSE, NULL);
542 vport->nicState = NdisSwitchNicStateUnknown;
543 vport->ovsState = OVS_STATE_PORT_CREATED;
545 NdisReleaseRWLock(switchContext->dispatchLock, &lockState);
546 /* XXX if portNo != INVALID or always? */
547 OvsPostEvent(portNo, OVS_EVENT_DISCONNECT);
550 VPORT_NIC_EXIT(nicParam);
555 * OVS Vport related functionality.
558 OvsFindVportByPortNo(POVS_SWITCH_CONTEXT switchContext,
561 POVS_VPORT_ENTRY vport;
562 PLIST_ENTRY head, link;
563 UINT32 hash = OvsJhashBytes((const VOID *)&portNo, sizeof(portNo),
565 head = &(switchContext->portNoHashArray[hash & OVS_VPORT_MASK]);
566 LIST_FORALL(head, link) {
567 vport = CONTAINING_RECORD(link, OVS_VPORT_ENTRY, portNoLink);
568 if (vport->portNo == portNo) {
577 OvsFindVportByOvsName(POVS_SWITCH_CONTEXT switchContext,
580 POVS_VPORT_ENTRY vport;
581 PLIST_ENTRY head, link;
583 SIZE_T length = strlen(name) + 1;
585 hash = OvsJhashBytes((const VOID *)name, length, OVS_HASH_BASIS);
586 head = &(switchContext->ovsPortNameHashArray[hash & OVS_VPORT_MASK]);
588 LIST_FORALL(head, link) {
589 vport = CONTAINING_RECORD(link, OVS_VPORT_ENTRY, ovsNameLink);
590 if (!strcmp(name, vport->ovsName)) {
598 /* OvsFindVportByHvName: "name" is assumed to be null-terminated */
600 OvsFindVportByHvNameW(POVS_SWITCH_CONTEXT switchContext,
601 PWSTR wsName, SIZE_T wstrSize)
603 POVS_VPORT_ENTRY vport = NULL;
604 PLIST_ENTRY head, link;
607 for (i = 0; i < OVS_MAX_VPORT_ARRAY_SIZE; i++) {
608 head = &(switchContext->portIdHashArray[i]);
609 LIST_FORALL(head, link) {
610 vport = CONTAINING_RECORD(link, OVS_VPORT_ENTRY, portIdLink);
613 * NOTE about portFriendlyName:
614 * If the string is NULL-terminated, the Length member does not
615 * include the terminating NULL character.
617 if (vport->portFriendlyName.Length == wstrSize &&
618 RtlEqualMemory(wsName, vport->portFriendlyName.String,
619 vport->portFriendlyName.Length)) {
628 * Look in the list of ports that were added from the Hyper-V switch and
632 for (i = 0; i < OVS_MAX_VPORT_ARRAY_SIZE; i++) {
633 head = &(switchContext->portNoHashArray[i]);
634 LIST_FORALL(head, link) {
635 vport = CONTAINING_RECORD(link, OVS_VPORT_ENTRY, portNoLink);
636 if (vport->portFriendlyName.Length == wstrSize &&
637 RtlEqualMemory(wsName, vport->portFriendlyName.String,
638 vport->portFriendlyName.Length)) {
652 OvsFindVportByHvNameA(POVS_SWITCH_CONTEXT switchContext,
655 POVS_VPORT_ENTRY vport = NULL;
656 /* 'portFriendlyName' is not NUL-terminated. */
657 SIZE_T length = strlen(name);
658 SIZE_T wstrSize = length * sizeof(WCHAR);
661 PWSTR wsName = OvsAllocateMemoryWithTag(wstrSize, OVS_VPORT_POOL_TAG);
665 for (i = 0; i < length; i++) {
668 vport = OvsFindVportByHvNameW(switchContext, wsName, wstrSize);
669 OvsFreeMemoryWithTag(wsName, OVS_VPORT_POOL_TAG);
674 OvsFindVportByPortIdAndNicIndex(POVS_SWITCH_CONTEXT switchContext,
675 NDIS_SWITCH_PORT_ID portId,
676 NDIS_SWITCH_NIC_INDEX index)
678 if (switchContext->virtualExternalVport &&
679 portId == switchContext->virtualExternalPortId &&
680 index == switchContext->virtualExternalVport->nicIndex) {
681 return (POVS_VPORT_ENTRY)switchContext->virtualExternalVport;
682 } else if (switchContext->internalVport &&
683 portId == switchContext->internalPortId &&
684 index == switchContext->internalVport->nicIndex) {
685 return (POVS_VPORT_ENTRY)switchContext->internalVport;
687 PLIST_ENTRY head, link;
688 POVS_VPORT_ENTRY vport;
690 hash = OvsJhashWords((UINT32 *)&portId, 1, OVS_HASH_BASIS);
691 head = &(switchContext->portIdHashArray[hash & OVS_VPORT_MASK]);
692 LIST_FORALL(head, link) {
693 vport = CONTAINING_RECORD(link, OVS_VPORT_ENTRY, portIdLink);
694 if (portId == vport->portId && index == vport->nicIndex) {
703 OvsAllocateVport(VOID)
705 POVS_VPORT_ENTRY vport;
706 vport = (POVS_VPORT_ENTRY)OvsAllocateMemoryWithTag(
707 sizeof(OVS_VPORT_ENTRY), OVS_VPORT_POOL_TAG);
711 RtlZeroMemory(vport, sizeof (OVS_VPORT_ENTRY));
712 vport->ovsState = OVS_STATE_UNKNOWN;
713 vport->isPresentOnHv = FALSE;
714 vport->portNo = OVS_DPPORT_NUMBER_INVALID;
716 InitializeListHead(&vport->ovsNameLink);
717 InitializeListHead(&vport->portIdLink);
718 InitializeListHead(&vport->portNoLink);
724 OvsInitVportWithPortParam(POVS_VPORT_ENTRY vport,
725 PNDIS_SWITCH_PORT_PARAMETERS portParam)
727 vport->portType = portParam->PortType;
728 vport->portState = portParam->PortState;
729 vport->portId = portParam->PortId;
730 vport->nicState = NdisSwitchNicStateUnknown;
731 vport->isExternal = FALSE;
732 vport->isBridgeInternal = FALSE;
734 switch (vport->portType) {
735 case NdisSwitchPortTypeExternal:
736 vport->isExternal = TRUE;
737 vport->ovsType = OVS_VPORT_TYPE_NETDEV;
739 case NdisSwitchPortTypeInternal:
740 vport->ovsType = OVS_VPORT_TYPE_INTERNAL;
742 case NdisSwitchPortTypeSynthetic:
743 case NdisSwitchPortTypeEmulated:
744 vport->ovsType = OVS_VPORT_TYPE_NETDEV;
747 RtlCopyMemory(&vport->hvPortName, &portParam->PortName,
748 sizeof (NDIS_SWITCH_PORT_NAME));
749 /* For external and internal ports, 'portFriendlyName' is overwritten
751 RtlCopyMemory(&vport->portFriendlyName, &portParam->PortFriendlyName,
752 sizeof(NDIS_SWITCH_PORT_FRIENDLYNAME));
754 switch (vport->portState) {
755 case NdisSwitchPortStateCreated:
756 vport->ovsState = OVS_STATE_PORT_CREATED;
758 case NdisSwitchPortStateTeardown:
759 vport->ovsState = OVS_STATE_PORT_TEAR_DOWN;
761 case NdisSwitchPortStateDeleted:
762 vport->ovsState = OVS_STATE_PORT_DELETED;
769 OvsInitVportWithNicParam(POVS_SWITCH_CONTEXT switchContext,
770 POVS_VPORT_ENTRY vport,
771 PNDIS_SWITCH_NIC_PARAMETERS nicParam)
773 ASSERT(vport->portId == nicParam->PortId);
774 ASSERT(vport->ovsState == OVS_STATE_PORT_CREATED);
776 UNREFERENCED_PARAMETER(switchContext);
778 RtlCopyMemory(vport->permMacAddress, nicParam->PermanentMacAddress,
779 sizeof (nicParam->PermanentMacAddress));
780 RtlCopyMemory(vport->currMacAddress, nicParam->CurrentMacAddress,
781 sizeof (nicParam->CurrentMacAddress));
783 if (nicParam->NicType == NdisSwitchNicTypeSynthetic ||
784 nicParam->NicType == NdisSwitchNicTypeEmulated) {
785 RtlCopyMemory(vport->vmMacAddress, nicParam->VMMacAddress,
786 sizeof (nicParam->VMMacAddress));
787 RtlCopyMemory(&vport->vmName, &nicParam->VmName,
788 sizeof (nicParam->VmName));
790 RtlCopyMemory(&vport->netCfgInstanceId, &nicParam->NetCfgInstanceId,
791 sizeof (nicParam->NetCfgInstanceId));
793 RtlCopyMemory(&vport->nicName, &nicParam->NicName,
794 sizeof (nicParam->NicName));
795 vport->mtu = nicParam->MTU;
796 vport->nicState = nicParam->NicState;
797 vport->nicIndex = nicParam->NicIndex;
798 vport->numaNodeId = nicParam->NumaNodeId;
800 switch (vport->nicState) {
801 case NdisSwitchNicStateCreated:
802 vport->ovsState = OVS_STATE_NIC_CREATED;
804 case NdisSwitchNicStateConnected:
805 vport->ovsState = OVS_STATE_CONNECTED;
807 case NdisSwitchNicStateDisconnected:
808 vport->ovsState = OVS_STATE_NIC_CREATED;
810 case NdisSwitchNicStateDeleted:
811 vport->ovsState = OVS_STATE_PORT_CREATED;
817 * --------------------------------------------------------------------------
818 * Copies the relevant NDIS port properties from a virtual (pseudo) external
819 * NIC to a physical (real) external NIC.
820 * --------------------------------------------------------------------------
823 OvsInitPhysNicVport(POVS_VPORT_ENTRY physExtVport,
824 POVS_VPORT_ENTRY virtExtVport,
827 physExtVport->portType = virtExtVport->portType;
828 physExtVport->portState = virtExtVport->portState;
829 physExtVport->portId = virtExtVport->portId;
830 physExtVport->nicState = NdisSwitchNicStateUnknown;
831 physExtVport->ovsType = OVS_VPORT_TYPE_NETDEV;
832 physExtVport->isExternal = TRUE;
833 physExtVport->isBridgeInternal = FALSE;
834 physExtVport->nicIndex = (NDIS_SWITCH_NIC_INDEX)physNicIndex;
836 RtlCopyMemory(&physExtVport->hvPortName, &virtExtVport->hvPortName,
837 sizeof (NDIS_SWITCH_PORT_NAME));
839 /* 'portFriendlyName' is overwritten later. */
840 RtlCopyMemory(&physExtVport->portFriendlyName,
841 &virtExtVport->portFriendlyName,
842 sizeof(NDIS_SWITCH_PORT_FRIENDLYNAME));
844 physExtVport->ovsState = OVS_STATE_PORT_CREATED;
848 * --------------------------------------------------------------------------
849 * Initializes a tunnel vport.
850 * --------------------------------------------------------------------------
853 OvsInitTunnelVport(POVS_VPORT_ENTRY vport,
854 OVS_VPORT_TYPE ovsType,
857 NTSTATUS status = STATUS_SUCCESS;
859 vport->isBridgeInternal = FALSE;
860 vport->ovsType = ovsType;
861 vport->ovsState = OVS_STATE_PORT_CREATED;
863 case OVS_VPORT_TYPE_GRE:
865 case OVS_VPORT_TYPE_GRE64:
867 case OVS_VPORT_TYPE_VXLAN:
868 status = OvsInitVxlanTunnel(vport, dstPort);
877 * --------------------------------------------------------------------------
878 * Initializes a bridge internal vport ie. a port of type
879 * OVS_VPORT_TYPE_INTERNAL but not present on the Hyper-V switch.
880 * --------------------------------------------------------------------------
883 OvsInitBridgeInternalVport(POVS_VPORT_ENTRY vport)
885 vport->isBridgeInternal = TRUE;
886 vport->ovsType = OVS_VPORT_TYPE_INTERNAL;
887 /* Mark the status to be connected, since there is no other initialization
889 vport->ovsState = OVS_STATE_CONNECTED;
890 return STATUS_SUCCESS;
894 * --------------------------------------------------------------------------
895 * For external vports 'portFriendlyName' provided by Hyper-V is over-written
896 * by synthetic names.
897 * --------------------------------------------------------------------------
900 AssignNicNameSpecial(POVS_VPORT_ENTRY vport)
904 if (vport->portType == NdisSwitchPortTypeExternal) {
905 if (vport->nicIndex == 0) {
906 ASSERT(vport->nicIndex == 0);
907 RtlStringCbPrintfW(vport->portFriendlyName.String,
909 L"%s.virtualAdapter", OVS_DPPORT_EXTERNAL_NAME_W);
911 RtlStringCbPrintfW(vport->portFriendlyName.String,
913 L"%s.%lu", OVS_DPPORT_EXTERNAL_NAME_W,
914 (UINT32)vport->nicIndex);
917 RtlStringCbPrintfW(vport->portFriendlyName.String,
919 L"%s", OVS_DPPORT_INTERNAL_NAME_W);
922 RtlStringCbLengthW(vport->portFriendlyName.String, IF_MAX_STRING_SIZE,
924 vport->portFriendlyName.Length = (USHORT)len;
929 * --------------------------------------------------------------------------
930 * Functionality common to any port on the Hyper-V switch. This function is not
931 * to be called for a port that is not on the Hyper-V switch.
933 * Inserts the port into 'portIdHashArray' and caches the pointer in the
934 * 'switchContext' if needed.
936 * For external NIC, assigns the name for the NIC.
937 * --------------------------------------------------------------------------
940 InitHvVportCommon(POVS_SWITCH_CONTEXT switchContext,
941 POVS_VPORT_ENTRY vport,
946 switch (vport->portType) {
947 case NdisSwitchPortTypeExternal:
949 * Overwrite the 'portFriendlyName' of this external vport. The reason
950 * for having this in common code is to be able to call it from the NDIS
951 * Port callback as well as the NDIS NIC callback.
953 AssignNicNameSpecial(vport);
955 if (vport->nicIndex == 0) {
956 switchContext->virtualExternalPortId = vport->portId;
957 switchContext->virtualExternalVport = vport;
959 switchContext->numPhysicalNics++;
962 case NdisSwitchPortTypeInternal:
963 ASSERT(vport->isBridgeInternal == FALSE);
965 /* Overwrite the 'portFriendlyName' of the internal vport. */
966 AssignNicNameSpecial(vport);
967 switchContext->internalPortId = vport->portId;
968 switchContext->internalVport = vport;
970 case NdisSwitchPortTypeSynthetic:
971 case NdisSwitchPortTypeEmulated:
976 * It is important to not insert vport corresponding to virtual external
977 * port into the 'portIdHashArray' since the port should not be exposed to
980 if (vport->portType == NdisSwitchPortTypeExternal &&
981 vport->nicIndex == 0) {
982 return NDIS_STATUS_SUCCESS;
986 * NOTE: OvsJhashWords has portId as "1" word. This should be ok, even
987 * though sizeof(NDIS_SWITCH_PORT_ID) = 4, not 2, because the
988 * hyper-v switch seems to use only 2 bytes out of 4.
990 hash = OvsJhashWords(&vport->portId, 1, OVS_HASH_BASIS);
991 InsertHeadList(&switchContext->portIdHashArray[hash & OVS_VPORT_MASK],
994 switchContext->numHvVports++;
996 return NDIS_STATUS_SUCCESS;
1000 * --------------------------------------------------------------------------
1001 * Functionality common to any port added from OVS userspace.
1003 * Inserts the port into 'portIdHashArray', 'ovsPortNameHashArray' and caches
1004 * the pointer in the 'switchContext' if needed.
1005 * --------------------------------------------------------------------------
1008 InitOvsVportCommon(POVS_SWITCH_CONTEXT switchContext,
1009 POVS_VPORT_ENTRY vport)
1013 switch(vport->ovsType) {
1014 case OVS_VPORT_TYPE_VXLAN:
1015 ASSERT(switchContext->vxlanVport == NULL);
1016 switchContext->vxlanVport = vport;
1017 switchContext->numNonHvVports++;
1019 case OVS_VPORT_TYPE_INTERNAL:
1020 if (vport->isBridgeInternal) {
1021 switchContext->numNonHvVports++;
1028 * Insert the port into the hash array of ports: by port number and ovs
1029 * and ovs (datapath) port name.
1030 * NOTE: OvsJhashWords has portNo as "1" word. This is ok, because the
1031 * portNo is stored in 2 bytes only (max port number = MAXUINT16).
1033 hash = OvsJhashWords(&vport->portNo, 1, OVS_HASH_BASIS);
1034 InsertHeadList(&gOvsSwitchContext->portNoHashArray[hash & OVS_VPORT_MASK],
1035 &vport->portNoLink);
1037 hash = OvsJhashBytes(vport->ovsName, strlen(vport->ovsName) + 1,
1040 &gOvsSwitchContext->ovsPortNameHashArray[hash & OVS_VPORT_MASK],
1041 &vport->ovsNameLink);
1043 return STATUS_SUCCESS;
1048 * --------------------------------------------------------------------------
1049 * Provides functionality that is partly complementatry to
1050 * InitOvsVportCommon()/InitHvVportCommon().
1052 * 'hvDelete' indicates if caller is removing the vport as a result of the
1053 * port being removed on the Hyper-V switch.
1054 * 'ovsDelete' indicates if caller is removing the vport as a result of the
1055 * port being removed from OVS userspace.
1056 * --------------------------------------------------------------------------
1059 OvsRemoveAndDeleteVport(POVS_SWITCH_CONTEXT switchContext,
1060 POVS_VPORT_ENTRY vport,
1063 BOOLEAN *vportDeallocated)
1065 BOOLEAN hvSwitchPort = FALSE;
1066 BOOLEAN deletedOnOvs = FALSE, deletedOnHv = FALSE;
1068 if (vportDeallocated) {
1069 *vportDeallocated = FALSE;
1072 if (vport->isExternal) {
1073 if (vport->nicIndex == 0) {
1074 ASSERT(switchContext->numPhysicalNics == 0);
1075 switchContext->virtualExternalPortId = 0;
1076 switchContext->virtualExternalVport = NULL;
1077 OvsFreeMemoryWithTag(vport, OVS_VPORT_POOL_TAG);
1078 if (vportDeallocated) {
1079 *vportDeallocated = TRUE;
1083 ASSERT(switchContext->numPhysicalNics);
1084 switchContext->numPhysicalNics--;
1085 hvSwitchPort = TRUE;
1089 switch (vport->ovsType) {
1090 case OVS_VPORT_TYPE_INTERNAL:
1091 if (!vport->isBridgeInternal) {
1092 switchContext->internalPortId = 0;
1093 switchContext->internalVport = NULL;
1094 OvsInternalAdapterDown();
1095 hvSwitchPort = TRUE;
1098 case OVS_VPORT_TYPE_VXLAN:
1099 OvsCleanupVxlanTunnel(vport);
1100 switchContext->vxlanVport = NULL;
1102 case OVS_VPORT_TYPE_GRE:
1103 case OVS_VPORT_TYPE_GRE64:
1105 case OVS_VPORT_TYPE_NETDEV:
1106 hvSwitchPort = TRUE;
1112 * 'hvDelete' == TRUE indicates that the port should be removed from the
1113 * 'portIdHashArray', while 'ovsDelete' == TRUE indicates that the port
1114 * should be removed from 'portNoHashArray' and the 'ovsPortNameHashArray'.
1116 * Both 'hvDelete' and 'ovsDelete' can be set to TRUE by the caller.
1118 if (vport->isPresentOnHv == TRUE) {
1121 if (vport->portNo == OVS_DPPORT_NUMBER_INVALID) {
1122 deletedOnOvs = TRUE;
1125 if (hvDelete && !deletedOnHv) {
1126 vport->isPresentOnHv = TRUE;
1128 /* Remove the port from the relevant lists. */
1129 RemoveEntryList(&vport->portIdLink);
1130 InitializeListHead(&vport->portIdLink);
1133 if (ovsDelete && !deletedOnOvs) {
1134 vport->portNo = OVS_DPPORT_NUMBER_INVALID;
1135 vport->ovsName[0] = '\0';
1137 /* Remove the port from the relevant lists. */
1138 RemoveEntryList(&vport->ovsNameLink);
1139 InitializeListHead(&vport->ovsNameLink);
1140 RemoveEntryList(&vport->portNoLink);
1141 InitializeListHead(&vport->portNoLink);
1142 deletedOnOvs = TRUE;
1146 * Deallocate the port if it has been deleted on the Hyper-V switch as well
1149 if (deletedOnHv && deletedOnOvs) {
1151 switchContext->numHvVports--;
1153 switchContext->numNonHvVports--;
1155 OvsFreeMemoryWithTag(vport, OVS_VPORT_POOL_TAG);
1156 if (vportDeallocated) {
1157 *vportDeallocated = TRUE;
1163 OvsAddConfiguredSwitchPorts(POVS_SWITCH_CONTEXT switchContext)
1165 NDIS_STATUS status = NDIS_STATUS_SUCCESS;
1167 PNDIS_SWITCH_PORT_PARAMETERS portParam;
1168 PNDIS_SWITCH_PORT_ARRAY portArray = NULL;
1169 POVS_VPORT_ENTRY vport;
1171 OVS_LOG_TRACE("Enter: switchContext:%p", switchContext);
1173 status = OvsGetPortsOnSwitch(switchContext, &portArray);
1174 if (status != NDIS_STATUS_SUCCESS) {
1178 for (arrIndex = 0; arrIndex < portArray->NumElements; arrIndex++) {
1179 portParam = NDIS_SWITCH_PORT_AT_ARRAY_INDEX(portArray, arrIndex);
1181 if (portParam->IsValidationPort) {
1185 vport = (POVS_VPORT_ENTRY)OvsAllocateVport();
1186 if (vport == NULL) {
1187 status = NDIS_STATUS_RESOURCES;
1190 OvsInitVportWithPortParam(vport, portParam);
1191 status = InitHvVportCommon(switchContext, vport, TRUE);
1192 if (status != NDIS_STATUS_SUCCESS) {
1193 OvsFreeMemoryWithTag(vport, OVS_VPORT_POOL_TAG);
1199 if (status != NDIS_STATUS_SUCCESS) {
1200 OvsClearAllSwitchVports(switchContext);
1203 OvsFreeSwitchPortsArray(portArray);
1205 OVS_LOG_TRACE("Exit: status: %x", status);
1212 OvsInitConfiguredSwitchNics(POVS_SWITCH_CONTEXT switchContext)
1214 NDIS_STATUS status = NDIS_STATUS_SUCCESS;
1215 PNDIS_SWITCH_NIC_ARRAY nicArray = NULL;
1217 PNDIS_SWITCH_NIC_PARAMETERS nicParam;
1218 POVS_VPORT_ENTRY vport;
1220 OVS_LOG_TRACE("Enter: switchContext: %p", switchContext);
1222 * Now, get NIC list.
1224 status = OvsGetNicsOnSwitch(switchContext, &nicArray);
1225 if (status != NDIS_STATUS_SUCCESS) {
1228 for (arrIndex = 0; arrIndex < nicArray->NumElements; ++arrIndex) {
1230 nicParam = NDIS_SWITCH_NIC_AT_ARRAY_INDEX(nicArray, arrIndex);
1233 * XXX: Check if the port is configured with a VLAN. Disallow such a
1234 * configuration, since we don't support tag-in-tag.
1238 * XXX: Check if the port is connected to a VF. Disconnect the VF in
1242 if (nicParam->NicType == NdisSwitchNicTypeExternal &&
1243 nicParam->NicIndex != 0) {
1244 POVS_VPORT_ENTRY virtExtVport =
1245 (POVS_VPORT_ENTRY)switchContext->virtualExternalVport;
1247 vport = OvsAllocateVport();
1249 OvsInitPhysNicVport(vport, virtExtVport,
1250 nicParam->NicIndex);
1251 status = InitHvVportCommon(switchContext, vport, TRUE);
1252 if (status != NDIS_STATUS_SUCCESS) {
1253 OvsFreeMemoryWithTag(vport, OVS_VPORT_POOL_TAG);
1258 vport = OvsFindVportByPortIdAndNicIndex(switchContext,
1260 nicParam->NicIndex);
1262 if (vport == NULL) {
1263 OVS_LOG_ERROR("Fail to allocate vport");
1266 OvsInitVportWithNicParam(switchContext, vport, nicParam);
1267 if (nicParam->NicType == NdisSwitchNicTypeInternal) {
1268 OvsInternalAdapterUp(vport->portNo, &nicParam->NetCfgInstanceId);
1273 OvsFreeSwitchNicsArray(nicArray);
1275 OVS_LOG_TRACE("Exit: status: %x", status);
1280 * --------------------------------------------------------------------------
1281 * Deletes ports added from the Hyper-V switch as well as OVS usersapce. The
1282 * function deletes ports in 'portIdHashArray'. This will delete most of the
1283 * ports that are in the 'portNoHashArray' as well. Any remaining ports
1284 * are deleted by walking the the 'portNoHashArray'.
1285 * --------------------------------------------------------------------------
1288 OvsClearAllSwitchVports(POVS_SWITCH_CONTEXT switchContext)
1290 for (UINT hash = 0; hash < OVS_MAX_VPORT_ARRAY_SIZE; hash++) {
1291 PLIST_ENTRY head, link, next;
1293 head = &(switchContext->portIdHashArray[hash & OVS_VPORT_MASK]);
1294 LIST_FORALL_SAFE(head, link, next) {
1295 POVS_VPORT_ENTRY vport;
1296 vport = CONTAINING_RECORD(link, OVS_VPORT_ENTRY, portIdLink);
1297 OvsRemoveAndDeleteVport(switchContext, vport, TRUE, TRUE, NULL);
1301 * Remove 'virtualExternalVport' as well. This port is not part of the
1302 * 'portIdHashArray'.
1304 if (switchContext->virtualExternalVport) {
1305 OvsRemoveAndDeleteVport(switchContext,
1306 (POVS_VPORT_ENTRY)switchContext->virtualExternalVport, TRUE, TRUE,
1310 for (UINT hash = 0; hash < OVS_MAX_VPORT_ARRAY_SIZE; hash++) {
1311 PLIST_ENTRY head, link, next;
1313 head = &(switchContext->portNoHashArray[hash & OVS_VPORT_MASK]);
1314 LIST_FORALL_SAFE(head, link, next) {
1315 POVS_VPORT_ENTRY vport;
1316 vport = CONTAINING_RECORD(link, OVS_VPORT_ENTRY, portNoLink);
1317 ASSERT(OvsIsTunnelVportType(vport->ovsType) ||
1318 (vport->ovsType == OVS_VPORT_TYPE_INTERNAL &&
1319 vport->isBridgeInternal) || vport->isPresentOnHv == TRUE);
1320 OvsRemoveAndDeleteVport(switchContext, vport, TRUE, TRUE, NULL);
1324 ASSERT(switchContext->virtualExternalVport == NULL);
1325 ASSERT(switchContext->internalVport == NULL);
1326 ASSERT(switchContext->vxlanVport == NULL);
1331 OvsConvertIfCountedStrToAnsiStr(PIF_COUNTED_STRING wStr,
1336 UNICODE_STRING ustr;
1340 ustr.Buffer = wStr->String;
1341 ustr.Length = wStr->Length;
1342 ustr.MaximumLength = IF_MAX_STRING_SIZE;
1345 astr.MaximumLength = maxStrLen;
1348 size = RtlUnicodeStringToAnsiSize(&ustr);
1349 if (size > maxStrLen) {
1350 return STATUS_BUFFER_OVERFLOW;
1353 status = RtlUnicodeStringToAnsiString(&astr, &ustr, FALSE);
1355 ASSERT(status == STATUS_SUCCESS);
1356 if (status != STATUS_SUCCESS) {
1359 ASSERT(astr.Length <= maxStrLen);
1360 str[astr.Length] = 0;
1361 return STATUS_SUCCESS;
1365 * --------------------------------------------------------------------------
1366 * Utility function that populates a 'OVS_VPORT_EXT_INFO' structure for the
1368 * --------------------------------------------------------------------------
1371 OvsGetExtInfoIoctl(POVS_VPORT_GET vportGet,
1372 POVS_VPORT_EXT_INFO extInfo)
1374 POVS_VPORT_ENTRY vport;
1376 LOCK_STATE_EX lockState;
1377 NTSTATUS status = STATUS_SUCCESS;
1378 BOOLEAN doConvert = FALSE;
1380 RtlZeroMemory(extInfo, sizeof (POVS_VPORT_EXT_INFO));
1381 NdisAcquireRWLockRead(gOvsSwitchContext->dispatchLock, &lockState, 0);
1382 if (vportGet->portNo == 0) {
1383 StringCbLengthA(vportGet->name, OVS_MAX_PORT_NAME_LENGTH - 1, &len);
1384 vport = OvsFindVportByHvNameA(gOvsSwitchContext, vportGet->name);
1385 if (vport != NULL) {
1386 /* If the port is not a Hyper-V port and it has been added earlier,
1387 * we'll find it in 'ovsPortNameHashArray'. */
1388 vport = OvsFindVportByOvsName(gOvsSwitchContext, vportGet->name);
1391 vport = OvsFindVportByPortNo(gOvsSwitchContext, vportGet->portNo);
1393 if (vport == NULL || (vport->ovsState != OVS_STATE_CONNECTED &&
1394 vport->ovsState != OVS_STATE_NIC_CREATED)) {
1395 NdisReleaseRWLock(gOvsSwitchContext->dispatchLock, &lockState);
1396 if (vportGet->portNo) {
1397 OVS_LOG_WARN("vport %u does not exist any more", vportGet->portNo);
1399 OVS_LOG_WARN("vport %s does not exist any more", vportGet->name);
1401 status = STATUS_DEVICE_DOES_NOT_EXIST;
1404 extInfo->dpNo = vportGet->dpNo;
1405 extInfo->portNo = vport->portNo;
1406 RtlCopyMemory(extInfo->macAddress, vport->currMacAddress,
1407 sizeof (vport->currMacAddress));
1408 RtlCopyMemory(extInfo->permMACAddress, vport->permMacAddress,
1409 sizeof (vport->permMacAddress));
1410 if (vport->ovsType == OVS_VPORT_TYPE_NETDEV) {
1411 RtlCopyMemory(extInfo->vmMACAddress, vport->vmMacAddress,
1412 sizeof (vport->vmMacAddress));
1414 extInfo->nicIndex = vport->nicIndex;
1415 extInfo->portId = vport->portId;
1416 extInfo->type = vport->ovsType;
1417 extInfo->mtu = vport->mtu;
1421 if (vport->ovsState == OVS_STATE_NIC_CREATED) {
1422 extInfo->status = OVS_EVENT_CONNECT | OVS_EVENT_LINK_DOWN;
1423 } else if (vport->ovsState == OVS_STATE_CONNECTED) {
1424 extInfo->status = OVS_EVENT_CONNECT | OVS_EVENT_LINK_UP;
1426 extInfo->status = OVS_EVENT_DISCONNECT;
1428 if (extInfo->type == OVS_VPORT_TYPE_NETDEV &&
1429 (vport->ovsState == OVS_STATE_NIC_CREATED ||
1430 vport->ovsState == OVS_STATE_CONNECTED)) {
1433 extInfo->vmUUID[0] = 0;
1434 extInfo->vifUUID[0] = 0;
1436 NdisReleaseRWLock(gOvsSwitchContext->dispatchLock, &lockState);
1438 status = OvsConvertIfCountedStrToAnsiStr(&vport->portFriendlyName,
1440 OVS_MAX_PORT_NAME_LENGTH);
1441 if (status != STATUS_SUCCESS) {
1442 OVS_LOG_INFO("Fail to convert NIC name.");
1443 extInfo->vmUUID[0] = 0;
1446 status = OvsConvertIfCountedStrToAnsiStr(&vport->vmName,
1448 OVS_MAX_VM_UUID_LEN);
1449 if (status != STATUS_SUCCESS) {
1450 OVS_LOG_INFO("Fail to convert VM name.");
1451 extInfo->vmUUID[0] = 0;
1454 status = OvsConvertIfCountedStrToAnsiStr(&vport->nicName,
1456 OVS_MAX_VIF_UUID_LEN);
1457 if (status != STATUS_SUCCESS) {
1458 OVS_LOG_INFO("Fail to convert nic UUID");
1459 extInfo->vifUUID[0] = 0;
1462 * for now ignore status
1464 status = STATUS_SUCCESS;
1472 * --------------------------------------------------------------------------
1473 * Command Handler for 'OVS_WIN_NETDEV_CMD_GET'.
1474 * --------------------------------------------------------------------------
1477 OvsGetNetdevCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
1480 NTSTATUS status = STATUS_SUCCESS;
1481 POVS_MESSAGE msgIn = (POVS_MESSAGE)usrParamsCtx->inputBuffer;
1482 POVS_MESSAGE msgOut = (POVS_MESSAGE)usrParamsCtx->outputBuffer;
1483 NL_ERROR nlError = NL_ERROR_SUCCESS;
1484 OVS_VPORT_GET vportGet;
1485 OVS_VPORT_EXT_INFO info;
1487 static const NL_POLICY ovsNetdevPolicy[] = {
1488 [OVS_WIN_NETDEV_ATTR_NAME] = { .type = NL_A_STRING,
1490 .maxLen = IFNAMSIZ },
1492 PNL_ATTR netdevAttrs[ARRAY_SIZE(ovsNetdevPolicy)];
1494 /* input buffer has been validated while validating transaction dev op. */
1495 ASSERT(usrParamsCtx->inputBuffer != NULL &&
1496 usrParamsCtx->inputLength > sizeof *msgIn);
1498 if (msgOut == NULL || usrParamsCtx->outputLength < sizeof *msgOut) {
1499 return STATUS_INVALID_BUFFER_SIZE;
1502 if (!NlAttrParse((PNL_MSG_HDR)msgIn,
1503 NLMSG_HDRLEN + GENL_HDRLEN + OVS_HDRLEN,
1504 NlMsgAttrsLen((PNL_MSG_HDR)msgIn),
1505 ovsNetdevPolicy, netdevAttrs, ARRAY_SIZE(netdevAttrs))) {
1506 return STATUS_INVALID_PARAMETER;
1509 vportGet.portNo = 0;
1510 RtlCopyMemory(&vportGet.name, NlAttrGet(netdevAttrs[OVS_VPORT_ATTR_NAME]),
1511 NlAttrGetSize(netdevAttrs[OVS_VPORT_ATTR_NAME]));
1513 status = OvsGetExtInfoIoctl(&vportGet, &info);
1514 if (status == STATUS_DEVICE_DOES_NOT_EXIST) {
1515 nlError = NL_ERROR_NODEV;
1519 status = CreateNetlinkMesgForNetdev(&info, msgIn,
1520 usrParamsCtx->outputBuffer, usrParamsCtx->outputLength,
1521 gOvsSwitchContext->dpNo);
1522 if (status == STATUS_SUCCESS) {
1523 *replyLen = msgOut->nlMsg.nlmsgLen;
1527 if (nlError != NL_ERROR_SUCCESS) {
1528 POVS_MESSAGE_ERROR msgError = (POVS_MESSAGE_ERROR)
1529 usrParamsCtx->outputBuffer;
1531 NlBuildErrorMsg(msgIn, msgError, nlError);
1532 *replyLen = msgError->nlMsg.nlmsgLen;
1535 return STATUS_SUCCESS;
1540 * --------------------------------------------------------------------------
1541 * Utility function to construct an OVS_MESSAGE for the specified vport. The
1542 * OVS_MESSAGE contains the output of a netdev command.
1543 * --------------------------------------------------------------------------
1546 CreateNetlinkMesgForNetdev(POVS_VPORT_EXT_INFO info,
1555 UINT32 netdevFlags = 0;
1557 NlBufInit(&nlBuffer, outBuffer, outBufLen);
1559 ok = NlFillOvsMsg(&nlBuffer, msgIn->nlMsg.nlmsgType, NLM_F_MULTI,
1560 msgIn->nlMsg.nlmsgSeq, msgIn->nlMsg.nlmsgPid,
1561 msgIn->genlMsg.cmd, msgIn->genlMsg.version,
1564 return STATUS_INVALID_BUFFER_SIZE;
1567 ok = NlMsgPutTailU32(&nlBuffer, OVS_WIN_NETDEV_ATTR_PORT_NO,
1570 return STATUS_INVALID_BUFFER_SIZE;
1573 ok = NlMsgPutTailU32(&nlBuffer, OVS_WIN_NETDEV_ATTR_TYPE, info->type);
1575 return STATUS_INVALID_BUFFER_SIZE;
1578 ok = NlMsgPutTailString(&nlBuffer, OVS_WIN_NETDEV_ATTR_NAME,
1581 return STATUS_INVALID_BUFFER_SIZE;
1584 ok = NlMsgPutTailUnspec(&nlBuffer, OVS_WIN_NETDEV_ATTR_MAC_ADDR,
1585 (PCHAR)info->macAddress, sizeof (info->macAddress));
1587 return STATUS_INVALID_BUFFER_SIZE;
1590 ok = NlMsgPutTailU32(&nlBuffer, OVS_WIN_NETDEV_ATTR_MTU, info->mtu);
1592 return STATUS_INVALID_BUFFER_SIZE;
1595 if (info->status != OVS_EVENT_CONNECT) {
1596 netdevFlags = OVS_WIN_NETDEV_IFF_UP;
1598 ok = NlMsgPutTailU32(&nlBuffer, OVS_WIN_NETDEV_ATTR_IF_FLAGS,
1601 return STATUS_INVALID_BUFFER_SIZE;
1605 * XXX: add netdev_stats when we have the definition available in the
1609 nlMsg = (PNL_MSG_HDR)NlBufAt(&nlBuffer, 0, 0);
1610 nlMsg->nlmsgLen = NlBufSize(&nlBuffer);
1612 return STATUS_SUCCESS;
1615 static __inline VOID
1616 OvsWaitActivate(POVS_SWITCH_CONTEXT switchContext, ULONG sleepMicroSec)
1618 while ((!switchContext->isActivated) &&
1619 (!switchContext->isActivateFailed)) {
1620 /* Wait for the switch to be active and
1621 * the list of ports in OVS to be initialized. */
1622 NdisMSleep(sleepMicroSec);
1627 OvsCreateMsgFromVport(POVS_VPORT_ENTRY vport,
1634 OVS_VPORT_FULL_STATS vportStats;
1638 NlBufInit(&nlBuffer, outBuffer, outBufLen);
1640 ok = NlFillOvsMsg(&nlBuffer, msgIn->nlMsg.nlmsgType, NLM_F_MULTI,
1641 msgIn->nlMsg.nlmsgSeq, msgIn->nlMsg.nlmsgPid,
1642 msgIn->genlMsg.cmd, msgIn->genlMsg.version,
1645 return STATUS_INVALID_BUFFER_SIZE;
1648 ok = NlMsgPutTailU32(&nlBuffer, OVS_VPORT_ATTR_PORT_NO, vport->portNo);
1650 return STATUS_INVALID_BUFFER_SIZE;
1653 ok = NlMsgPutTailU32(&nlBuffer, OVS_VPORT_ATTR_TYPE, vport->ovsType);
1655 return STATUS_INVALID_BUFFER_SIZE;
1658 ok = NlMsgPutTailString(&nlBuffer, OVS_VPORT_ATTR_NAME, vport->ovsName);
1660 return STATUS_INVALID_BUFFER_SIZE;
1664 * XXX: when we implement OVS_DP_ATTR_USER_FEATURES in datapath,
1665 * we'll need to check the OVS_DP_F_VPORT_PIDS flag: if it is set,
1666 * it means we have an array of pids, instead of a single pid.
1667 * ATM we assume we have one pid only.
1670 ok = NlMsgPutTailU32(&nlBuffer, OVS_VPORT_ATTR_UPCALL_PID,
1673 return STATUS_INVALID_BUFFER_SIZE;
1677 vportStats.rxPackets = vport->stats.rxPackets;
1678 vportStats.rxBytes = vport->stats.rxBytes;
1679 vportStats.txPackets = vport->stats.txPackets;
1680 vportStats.txBytes = vport->stats.txBytes;
1681 vportStats.rxErrors = vport->errStats.rxErrors;
1682 vportStats.txErrors = vport->errStats.txErrors;
1683 vportStats.rxDropped = vport->errStats.rxDropped;
1684 vportStats.txDropped = vport->errStats.txDropped;
1686 ok = NlMsgPutTailUnspec(&nlBuffer, OVS_VPORT_ATTR_STATS,
1688 sizeof(OVS_VPORT_FULL_STATS));
1690 return STATUS_INVALID_BUFFER_SIZE;
1694 * XXX: when vxlan udp dest port becomes configurable, we will also need
1695 * to add vport options
1698 nlMsg = (PNL_MSG_HDR)NlBufAt(&nlBuffer, 0, 0);
1699 nlMsg->nlmsgLen = NlBufSize(&nlBuffer);
1701 return STATUS_SUCCESS;
1705 OvsGetVportDumpNext(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
1709 POVS_OPEN_INSTANCE instance =
1710 (POVS_OPEN_INSTANCE)usrParamsCtx->ovsInstance;
1711 LOCK_STATE_EX lockState;
1712 UINT32 i = OVS_MAX_VPORT_ARRAY_SIZE;
1715 * XXX: this function shares some code with other dump command(s).
1716 * In the future, we will need to refactor the dump functions
1719 ASSERT(usrParamsCtx->devOp == OVS_READ_DEV_OP);
1721 if (instance->dumpState.ovsMsg == NULL) {
1723 return STATUS_INVALID_DEVICE_STATE;
1726 /* Output buffer has been validated while validating read dev op. */
1727 ASSERT(usrParamsCtx->outputBuffer != NULL);
1729 msgIn = instance->dumpState.ovsMsg;
1732 * XXX: when we implement OVS_DP_ATTR_USER_FEATURES in datapath,
1733 * we'll need to check the OVS_DP_F_VPORT_PIDS flag: if it is set,
1734 * it means we have an array of pids, instead of a single pid.
1735 * ATM we assume we have one pid only.
1737 NdisAcquireRWLockRead(gOvsSwitchContext->dispatchLock, &lockState, 0);
1739 if (gOvsSwitchContext->numHvVports > 0 ||
1740 gOvsSwitchContext->numNonHvVports > 0) {
1741 /* inBucket: the bucket, used for lookup */
1742 UINT32 inBucket = instance->dumpState.index[0];
1743 /* inIndex: index within the given bucket, used for lookup */
1744 UINT32 inIndex = instance->dumpState.index[1];
1745 /* the bucket to be used for the next dump operation */
1746 UINT32 outBucket = 0;
1747 /* the index within the outBucket to be used for the next dump */
1748 UINT32 outIndex = 0;
1750 for (i = inBucket; i < OVS_MAX_VPORT_ARRAY_SIZE; i++) {
1751 PLIST_ENTRY head, link;
1752 head = &(gOvsSwitchContext->portNoHashArray[i]);
1753 POVS_VPORT_ENTRY vport = NULL;
1756 LIST_FORALL(head, link) {
1759 * if one or more dumps were previously done on this same bucket,
1760 * inIndex will be > 0, so we'll need to reply with the
1761 * inIndex + 1 vport from the bucket.
1763 if (outIndex >= inIndex) {
1764 vport = CONTAINING_RECORD(link, OVS_VPORT_ENTRY, portNoLink);
1766 ASSERT(vport->portNo != OVS_DPPORT_NUMBER_INVALID);
1767 OvsCreateMsgFromVport(vport, msgIn,
1768 usrParamsCtx->outputBuffer,
1769 usrParamsCtx->outputLength,
1770 gOvsSwitchContext->dpNo);
1783 * if no vport was found above, check the next bucket, beginning
1784 * with the first (i.e. index 0) elem from within that bucket
1791 /* XXX: what about NLMSG_DONE (as msg type)? */
1792 instance->dumpState.index[0] = outBucket;
1793 instance->dumpState.index[1] = outIndex;
1796 NdisReleaseRWLock(gOvsSwitchContext->dispatchLock, &lockState);
1798 /* if i < OVS_MAX_VPORT_ARRAY_SIZE => vport was found */
1799 if (i < OVS_MAX_VPORT_ARRAY_SIZE) {
1800 POVS_MESSAGE msgOut = (POVS_MESSAGE)usrParamsCtx->outputBuffer;
1801 *replyLen = msgOut->nlMsg.nlmsgLen;
1804 * if i >= OVS_MAX_VPORT_ARRAY_SIZE => vport was not found =>
1808 /* Free up the dump state, since there's no more data to continue. */
1809 FreeUserDumpState(instance);
1812 return STATUS_SUCCESS;
1816 OvsGetVport(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
1819 NTSTATUS status = STATUS_SUCCESS;
1820 LOCK_STATE_EX lockState;
1822 POVS_MESSAGE msgIn = (POVS_MESSAGE)usrParamsCtx->inputBuffer;
1823 POVS_MESSAGE msgOut = (POVS_MESSAGE)usrParamsCtx->outputBuffer;
1824 POVS_VPORT_ENTRY vport = NULL;
1825 NL_ERROR nlError = NL_ERROR_SUCCESS;
1826 PCHAR portName = NULL;
1827 UINT32 portNameLen = 0;
1828 UINT32 portNumber = OVS_DPPORT_NUMBER_INVALID;
1830 static const NL_POLICY ovsVportPolicy[] = {
1831 [OVS_VPORT_ATTR_PORT_NO] = { .type = NL_A_U32, .optional = TRUE },
1832 [OVS_VPORT_ATTR_NAME] = { .type = NL_A_STRING,
1837 PNL_ATTR vportAttrs[ARRAY_SIZE(ovsVportPolicy)];
1839 /* input buffer has been validated while validating write dev op. */
1840 ASSERT(usrParamsCtx->inputBuffer != NULL);
1842 if (!NlAttrParse((PNL_MSG_HDR)msgIn,
1843 NLMSG_HDRLEN + GENL_HDRLEN + OVS_HDRLEN,
1844 NlMsgAttrsLen((PNL_MSG_HDR)msgIn),
1845 ovsVportPolicy, vportAttrs, ARRAY_SIZE(vportAttrs))) {
1846 return STATUS_INVALID_PARAMETER;
1849 /* Output buffer has been validated while validating transact dev op. */
1850 ASSERT(msgOut != NULL && usrParamsCtx->outputLength >= sizeof *msgOut);
1852 NdisAcquireRWLockRead(gOvsSwitchContext->dispatchLock, &lockState, 0);
1853 if (vportAttrs[OVS_VPORT_ATTR_NAME] != NULL) {
1854 portName = NlAttrGet(vportAttrs[OVS_VPORT_ATTR_NAME]);
1855 portNameLen = NlAttrGetSize(vportAttrs[OVS_VPORT_ATTR_NAME]);
1857 /* the port name is expected to be null-terminated */
1858 ASSERT(portName[portNameLen - 1] == '\0');
1860 vport = OvsFindVportByOvsName(gOvsSwitchContext, portName);
1861 } else if (vportAttrs[OVS_VPORT_ATTR_PORT_NO] != NULL) {
1862 portNumber = NlAttrGetU32(vportAttrs[OVS_VPORT_ATTR_PORT_NO]);
1864 vport = OvsFindVportByPortNo(gOvsSwitchContext, portNumber);
1866 nlError = NL_ERROR_INVAL;
1867 NdisReleaseRWLock(gOvsSwitchContext->dispatchLock, &lockState);
1872 nlError = NL_ERROR_NODEV;
1873 NdisReleaseRWLock(gOvsSwitchContext->dispatchLock, &lockState);
1877 status = OvsCreateMsgFromVport(vport, msgIn, usrParamsCtx->outputBuffer,
1878 usrParamsCtx->outputLength,
1879 gOvsSwitchContext->dpNo);
1880 NdisReleaseRWLock(gOvsSwitchContext->dispatchLock, &lockState);
1882 *replyLen = msgOut->nlMsg.nlmsgLen;
1885 if (nlError != NL_ERROR_SUCCESS) {
1886 POVS_MESSAGE_ERROR msgError = (POVS_MESSAGE_ERROR)
1887 usrParamsCtx->outputBuffer;
1889 NlBuildErrorMsg(msgIn, msgError, nlError);
1890 *replyLen = msgError->nlMsg.nlmsgLen;
1893 return STATUS_SUCCESS;
1897 * --------------------------------------------------------------------------
1898 * Command Handler for 'OVS_VPORT_CMD_NEW'.
1900 * The function handles the initial call to setup the dump state, as well as
1901 * subsequent calls to continue dumping data.
1902 * --------------------------------------------------------------------------
1905 OvsGetVportCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
1910 switch (usrParamsCtx->devOp) {
1911 case OVS_WRITE_DEV_OP:
1912 return OvsSetupDumpStart(usrParamsCtx);
1914 case OVS_READ_DEV_OP:
1915 return OvsGetVportDumpNext(usrParamsCtx, replyLen);
1917 case OVS_TRANSACTION_DEV_OP:
1918 return OvsGetVport(usrParamsCtx, replyLen);
1921 return STATUS_INVALID_DEVICE_REQUEST;
1927 OvsComputeVportNo(POVS_SWITCH_CONTEXT switchContext)
1929 /* we are not allowed to create the port OVS_DPPORT_NUMBER_LOCAL */
1930 for (ULONG i = OVS_DPPORT_NUMBER_LOCAL + 1; i < MAXUINT16; ++i) {
1931 POVS_VPORT_ENTRY vport;
1933 vport = OvsFindVportByPortNo(switchContext, i);
1939 return OVS_DPPORT_NUMBER_INVALID;
1943 * --------------------------------------------------------------------------
1944 * Command Handler for 'OVS_VPORT_CMD_NEW'.
1945 * --------------------------------------------------------------------------
1948 OvsNewVportCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
1951 NDIS_STATUS status = STATUS_SUCCESS;
1952 LOCK_STATE_EX lockState;
1954 NL_ERROR nlError = NL_ERROR_SUCCESS;
1955 POVS_MESSAGE msgIn = (POVS_MESSAGE)usrParamsCtx->inputBuffer;
1956 POVS_MESSAGE msgOut = (POVS_MESSAGE)usrParamsCtx->outputBuffer;
1957 POVS_VPORT_ENTRY vport = NULL;
1961 BOOLEAN isBridgeInternal = FALSE;
1962 BOOLEAN vportAllocated = FALSE, vportInitialized = FALSE;
1963 BOOLEAN addInternalPortAsNetdev = FALSE;
1965 static const NL_POLICY ovsVportPolicy[] = {
1966 [OVS_VPORT_ATTR_PORT_NO] = { .type = NL_A_U32, .optional = TRUE },
1967 [OVS_VPORT_ATTR_TYPE] = { .type = NL_A_U32, .optional = FALSE },
1968 [OVS_VPORT_ATTR_NAME] = { .type = NL_A_STRING, .maxLen = IFNAMSIZ,
1970 [OVS_VPORT_ATTR_UPCALL_PID] = { .type = NL_A_UNSPEC,
1971 .optional = FALSE },
1972 [OVS_VPORT_ATTR_OPTIONS] = { .type = NL_A_NESTED, .optional = TRUE },
1975 PNL_ATTR vportAttrs[ARRAY_SIZE(ovsVportPolicy)];
1977 /* input buffer has been validated while validating write dev op. */
1978 ASSERT(usrParamsCtx->inputBuffer != NULL);
1980 /* Output buffer has been validated while validating transact dev op. */
1981 ASSERT(msgOut != NULL && usrParamsCtx->outputLength >= sizeof *msgOut);
1983 if (!NlAttrParse((PNL_MSG_HDR)msgIn,
1984 NLMSG_HDRLEN + GENL_HDRLEN + OVS_HDRLEN,
1985 NlMsgAttrsLen((PNL_MSG_HDR)msgIn),
1986 ovsVportPolicy, vportAttrs, ARRAY_SIZE(vportAttrs))) {
1987 return STATUS_INVALID_PARAMETER;
1990 portName = NlAttrGet(vportAttrs[OVS_VPORT_ATTR_NAME]);
1991 portNameLen = NlAttrGetSize(vportAttrs[OVS_VPORT_ATTR_NAME]);
1992 portType = NlAttrGetU32(vportAttrs[OVS_VPORT_ATTR_TYPE]);
1994 /* we are expecting null terminated strings to be passed */
1995 ASSERT(portName[portNameLen - 1] == '\0');
1997 NdisAcquireRWLockWrite(gOvsSwitchContext->dispatchLock, &lockState, 0);
1999 vport = OvsFindVportByOvsName(gOvsSwitchContext, portName);
2001 nlError = NL_ERROR_EXIST;
2005 if (portName && portType == OVS_VPORT_TYPE_NETDEV &&
2006 !strcmp(OVS_DPPORT_INTERNAL_NAME_A, portName)) {
2007 addInternalPortAsNetdev = TRUE;
2010 if (portName && portType == OVS_VPORT_TYPE_INTERNAL &&
2011 strcmp(OVS_DPPORT_INTERNAL_NAME_A, portName)) {
2012 isBridgeInternal = TRUE;
2015 if (portType == OVS_VPORT_TYPE_INTERNAL && !isBridgeInternal) {
2016 vport = gOvsSwitchContext->internalVport;
2017 } else if (portType == OVS_VPORT_TYPE_NETDEV) {
2018 /* External ports can also be looked up like VIF ports. */
2019 vport = OvsFindVportByHvNameA(gOvsSwitchContext, portName);
2021 ASSERT(OvsIsTunnelVportType(portType) ||
2022 (portType == OVS_VPORT_TYPE_INTERNAL && isBridgeInternal));
2023 ASSERT(OvsGetTunnelVport(gOvsSwitchContext, portType) == NULL ||
2024 !OvsIsTunnelVportType(portType));
2026 vport = (POVS_VPORT_ENTRY)OvsAllocateVport();
2027 if (vport == NULL) {
2028 nlError = NL_ERROR_NOMEM;
2031 vportAllocated = TRUE;
2033 if (OvsIsTunnelVportType(portType)) {
2034 status = OvsInitTunnelVport(vport, portType, VXLAN_UDP_PORT);
2035 nlError = NlMapStatusToNlErr(status);
2037 OvsInitBridgeInternalVport(vport);
2039 vportInitialized = TRUE;
2041 if (nlError == NL_ERROR_SUCCESS) {
2042 vport->ovsState = OVS_STATE_CONNECTED;
2043 vport->nicState = NdisSwitchNicStateConnected;
2046 * Allow the vport to be deleted, because there is no
2047 * corresponding hyper-v switch part.
2049 vport->isPresentOnHv = TRUE;
2054 nlError = NL_ERROR_INVAL;
2057 if (vport->portNo != OVS_DPPORT_NUMBER_INVALID) {
2058 nlError = NL_ERROR_EXIST;
2062 /* Initialize the vport with OVS specific properties. */
2063 if (addInternalPortAsNetdev != TRUE) {
2064 vport->ovsType = portType;
2066 if (vportAttrs[OVS_VPORT_ATTR_PORT_NO] != NULL) {
2068 * XXX: when we implement the limit for ovs port number to be
2069 * MAXUINT16, we'll need to check the port number received from the
2072 vport->portNo = NlAttrGetU32(vportAttrs[OVS_VPORT_ATTR_PORT_NO]);
2074 vport->portNo = OvsComputeVportNo(gOvsSwitchContext);
2075 if (vport->portNo == OVS_DPPORT_NUMBER_INVALID) {
2076 nlError = NL_ERROR_NOMEM;
2081 /* The ovs port name must be uninitialized. */
2082 ASSERT(vport->ovsName[0] == '\0');
2083 ASSERT(portNameLen <= OVS_MAX_PORT_NAME_LENGTH);
2085 RtlCopyMemory(vport->ovsName, portName, portNameLen);
2086 /* if we don't have options, then vport->portOptions will be NULL */
2087 vport->portOptions = vportAttrs[OVS_VPORT_ATTR_OPTIONS];
2090 * XXX: when we implement OVS_DP_ATTR_USER_FEATURES in datapath,
2091 * we'll need to check the OVS_DP_F_VPORT_PIDS flag: if it is set,
2092 * it means we have an array of pids, instead of a single pid.
2093 * ATM we assume we have one pid only.
2095 vport->upcallPid = NlAttrGetU32(vportAttrs[OVS_VPORT_ATTR_UPCALL_PID]);
2097 status = InitOvsVportCommon(gOvsSwitchContext, vport);
2098 ASSERT(status == STATUS_SUCCESS);
2100 status = OvsCreateMsgFromVport(vport, msgIn, usrParamsCtx->outputBuffer,
2101 usrParamsCtx->outputLength,
2102 gOvsSwitchContext->dpNo);
2104 *replyLen = msgOut->nlMsg.nlmsgLen;
2107 NdisReleaseRWLock(gOvsSwitchContext->dispatchLock, &lockState);
2109 if (nlError != NL_ERROR_SUCCESS) {
2110 POVS_MESSAGE_ERROR msgError = (POVS_MESSAGE_ERROR)
2111 usrParamsCtx->outputBuffer;
2113 if (vport && vportAllocated == TRUE) {
2114 if (vportInitialized == TRUE) {
2115 if (OvsIsTunnelVportType(portType)) {
2116 OvsCleanupVxlanTunnel(vport);
2119 OvsFreeMemoryWithTag(vport, OVS_VPORT_POOL_TAG);
2122 NlBuildErrorMsg(msgIn, msgError, nlError);
2123 *replyLen = msgError->nlMsg.nlmsgLen;
2126 return STATUS_SUCCESS;
2131 * --------------------------------------------------------------------------
2132 * Command Handler for 'OVS_VPORT_CMD_SET'.
2133 * --------------------------------------------------------------------------
2136 OvsSetVportCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
2139 NDIS_STATUS status = STATUS_SUCCESS;
2140 LOCK_STATE_EX lockState;
2142 POVS_MESSAGE msgIn = (POVS_MESSAGE)usrParamsCtx->inputBuffer;
2143 POVS_MESSAGE msgOut = (POVS_MESSAGE)usrParamsCtx->outputBuffer;
2144 POVS_VPORT_ENTRY vport = NULL;
2145 NL_ERROR nlError = NL_ERROR_SUCCESS;
2147 static const NL_POLICY ovsVportPolicy[] = {
2148 [OVS_VPORT_ATTR_PORT_NO] = { .type = NL_A_U32, .optional = TRUE },
2149 [OVS_VPORT_ATTR_TYPE] = { .type = NL_A_U32, .optional = TRUE },
2150 [OVS_VPORT_ATTR_NAME] = { .type = NL_A_STRING, .maxLen = IFNAMSIZ,
2152 [OVS_VPORT_ATTR_UPCALL_PID] = { .type = NL_A_UNSPEC,
2154 [OVS_VPORT_ATTR_STATS] = { .type = NL_A_UNSPEC,
2155 .minLen = sizeof(OVS_VPORT_FULL_STATS),
2156 .maxLen = sizeof(OVS_VPORT_FULL_STATS),
2158 [OVS_VPORT_ATTR_OPTIONS] = { .type = NL_A_NESTED, .optional = TRUE },
2160 PNL_ATTR vportAttrs[ARRAY_SIZE(ovsVportPolicy)];
2162 ASSERT(usrParamsCtx->inputBuffer != NULL);
2164 if (!NlAttrParse((PNL_MSG_HDR)msgIn,
2165 NLMSG_HDRLEN + GENL_HDRLEN + OVS_HDRLEN,
2166 NlMsgAttrsLen((PNL_MSG_HDR)msgIn),
2167 ovsVportPolicy, vportAttrs, ARRAY_SIZE(vportAttrs))) {
2168 return STATUS_INVALID_PARAMETER;
2171 /* Output buffer has been validated while validating transact dev op. */
2172 ASSERT(msgOut != NULL && usrParamsCtx->outputLength >= sizeof *msgOut);
2174 NdisAcquireRWLockWrite(gOvsSwitchContext->dispatchLock, &lockState, 0);
2175 if (vportAttrs[OVS_VPORT_ATTR_NAME] != NULL) {
2176 PSTR portName = NlAttrGet(vportAttrs[OVS_VPORT_ATTR_NAME]);
2178 UINT32 portNameLen = NlAttrGetSize(vportAttrs[OVS_VPORT_ATTR_NAME]);
2180 /* the port name is expected to be null-terminated */
2181 ASSERT(portName[portNameLen - 1] == '\0');
2183 vport = OvsFindVportByOvsName(gOvsSwitchContext, portName);
2184 } else if (vportAttrs[OVS_VPORT_ATTR_PORT_NO] != NULL) {
2185 vport = OvsFindVportByPortNo(gOvsSwitchContext,
2186 NlAttrGetU32(vportAttrs[OVS_VPORT_ATTR_PORT_NO]));
2190 nlError = NL_ERROR_NODEV;
2195 * XXX: when we implement OVS_DP_ATTR_USER_FEATURES in datapath,
2196 * we'll need to check the OVS_DP_F_VPORT_PIDS flag: if it is set,
2197 * it means we have an array of pids, instead of a single pid.
2198 * Currently, we support only one pid.
2200 if (vportAttrs[OVS_VPORT_ATTR_UPCALL_PID]) {
2201 vport->upcallPid = NlAttrGetU32(vportAttrs[OVS_VPORT_ATTR_UPCALL_PID]);
2204 if (vportAttrs[OVS_VPORT_ATTR_TYPE]) {
2205 OVS_VPORT_TYPE type = NlAttrGetU32(vportAttrs[OVS_VPORT_ATTR_TYPE]);
2206 if (type != vport->ovsType) {
2207 nlError = NL_ERROR_INVAL;
2212 if (vportAttrs[OVS_VPORT_ATTR_OPTIONS]) {
2213 OVS_LOG_ERROR("Vport options not supported");
2214 nlError = NL_ERROR_NOTSUPP;
2218 status = OvsCreateMsgFromVport(vport, msgIn, usrParamsCtx->outputBuffer,
2219 usrParamsCtx->outputLength,
2220 gOvsSwitchContext->dpNo);
2222 *replyLen = msgOut->nlMsg.nlmsgLen;
2225 NdisReleaseRWLock(gOvsSwitchContext->dispatchLock, &lockState);
2227 if (nlError != NL_ERROR_SUCCESS) {
2228 POVS_MESSAGE_ERROR msgError = (POVS_MESSAGE_ERROR)
2229 usrParamsCtx->outputBuffer;
2231 NlBuildErrorMsg(msgIn, msgError, nlError);
2232 *replyLen = msgError->nlMsg.nlmsgLen;
2235 return STATUS_SUCCESS;
2239 * --------------------------------------------------------------------------
2240 * Command Handler for 'OVS_VPORT_CMD_DEL'.
2241 * --------------------------------------------------------------------------
2244 OvsDeleteVportCmdHandler(POVS_USER_PARAMS_CONTEXT usrParamsCtx,
2247 NDIS_STATUS status = STATUS_SUCCESS;
2248 LOCK_STATE_EX lockState;
2250 POVS_MESSAGE msgIn = (POVS_MESSAGE)usrParamsCtx->inputBuffer;
2251 POVS_MESSAGE msgOut = (POVS_MESSAGE)usrParamsCtx->outputBuffer;
2252 POVS_VPORT_ENTRY vport = NULL;
2253 NL_ERROR nlError = NL_ERROR_SUCCESS;
2254 PSTR portName = NULL;
2255 UINT32 portNameLen = 0;
2257 static const NL_POLICY ovsVportPolicy[] = {
2258 [OVS_VPORT_ATTR_PORT_NO] = { .type = NL_A_U32, .optional = TRUE },
2259 [OVS_VPORT_ATTR_NAME] = { .type = NL_A_STRING, .maxLen = IFNAMSIZ,
2262 PNL_ATTR vportAttrs[ARRAY_SIZE(ovsVportPolicy)];
2264 ASSERT(usrParamsCtx->inputBuffer != NULL);
2266 if (!NlAttrParse((PNL_MSG_HDR)msgIn,
2267 NLMSG_HDRLEN + GENL_HDRLEN + OVS_HDRLEN,
2268 NlMsgAttrsLen((PNL_MSG_HDR)msgIn),
2269 ovsVportPolicy, vportAttrs, ARRAY_SIZE(vportAttrs))) {
2270 return STATUS_INVALID_PARAMETER;
2273 /* Output buffer has been validated while validating transact dev op. */
2274 ASSERT(msgOut != NULL && usrParamsCtx->outputLength >= sizeof *msgOut);
2276 NdisAcquireRWLockWrite(gOvsSwitchContext->dispatchLock, &lockState, 0);
2277 if (vportAttrs[OVS_VPORT_ATTR_NAME] != NULL) {
2278 portName = NlAttrGet(vportAttrs[OVS_VPORT_ATTR_NAME]);
2279 portNameLen = NlAttrGetSize(vportAttrs[OVS_VPORT_ATTR_NAME]);
2281 /* the port name is expected to be null-terminated */
2282 ASSERT(portName[portNameLen - 1] == '\0');
2284 vport = OvsFindVportByOvsName(gOvsSwitchContext, portName);
2286 else if (vportAttrs[OVS_VPORT_ATTR_PORT_NO] != NULL) {
2287 vport = OvsFindVportByPortNo(gOvsSwitchContext,
2288 NlAttrGetU32(vportAttrs[OVS_VPORT_ATTR_PORT_NO]));
2292 nlError = NL_ERROR_NODEV;
2296 status = OvsCreateMsgFromVport(vport, msgIn, usrParamsCtx->outputBuffer,
2297 usrParamsCtx->outputLength,
2298 gOvsSwitchContext->dpNo);
2301 * Mark the port as deleted from OVS userspace. If the port does not exist
2302 * on the Hyper-V switch, it gets deallocated. Otherwise, it stays.
2304 OvsRemoveAndDeleteVport(gOvsSwitchContext, vport, FALSE, TRUE, NULL);
2306 *replyLen = msgOut->nlMsg.nlmsgLen;
2309 NdisReleaseRWLock(gOvsSwitchContext->dispatchLock, &lockState);
2311 if (nlError != NL_ERROR_SUCCESS) {
2312 POVS_MESSAGE_ERROR msgError = (POVS_MESSAGE_ERROR)
2313 usrParamsCtx->outputBuffer;
2315 NlBuildErrorMsg(msgIn, msgError, nlError);
2316 *replyLen = msgError->nlMsg.nlmsgLen;
2319 return STATUS_SUCCESS;