From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mx0a-002e3701.pphosted.com (mx0a-002e3701.pphosted.com [148.163.147.86]) by mx.groups.io with SMTP id smtpd.web12.8967.1604589877363133388 for ; Thu, 05 Nov 2020 07:24:37 -0800 Authentication-Results: mx.groups.io; dkim=pass header.i=@hpe.com header.s=pps0720 header.b=Yp0gMC5Y; spf=pass (domain: hpe.com, ip: 148.163.147.86, mailfrom: prvs=0578d2b66c=abner.chang@hpe.com) Received: from pps.filterd (m0150242.ppops.net [127.0.0.1]) by mx0a-002e3701.pphosted.com (8.16.0.42/8.16.0.42) with SMTP id 0A5FIJ7V013276; Thu, 5 Nov 2020 15:24:35 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=hpe.com; h=from : to : cc : subject : date : message-id : in-reply-to : references; s=pps0720; bh=5qzLBsoFPwzT079xlSj/0aTYykNsmttPFknj/nL3ETU=; b=Yp0gMC5YGmSo1TcS+Euvy6+W0MITbjfvryYWfTlJH1g+pEHSE/DUIBUl3kYL7FGl8An6 qigbVA8ctyUhJXgrqtbjRNfDjHU8hf1fgSLo/15GL8yPi7I6lPkeyCaRiRwJwZ6s/NVR AGe/QjLEaD5q4CDv9tnWOApnuj8eNAdK87fGLbV/pZSL5dQ41R5IHfjEE4cLMj/Fwkzk gtFGyMVtmeyZxccshEDzp3/VlfTGDgFj9xOMdcEin6j1RlZA1Z6I+uH0ojadJOaaoW9R FzkJbA2Gzw0EeQvwJB3J8Aq9bU4o4G2/5o+AvEbG7HLXNpYBoc7QmuJxlrYnaY4O5vb6 6Q== Received: from g4t3425.houston.hpe.com (g4t3425.houston.hpe.com [15.241.140.78]) by mx0a-002e3701.pphosted.com with ESMTP id 34kc7v1q87-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Thu, 05 Nov 2020 15:24:35 +0000 Received: from g9t2301.houston.hpecorp.net (g9t2301.houston.hpecorp.net [16.220.97.129]) by g4t3425.houston.hpe.com (Postfix) with ESMTP id 32EADB8; Thu, 5 Nov 2020 15:24:34 +0000 (UTC) Received: from abner-virtual-machine.asiapacific.hpqcorp.net (abner-virtual-machine.asiapacific.hpqcorp.net [15.119.210.153]) by g9t2301.houston.hpecorp.net (Postfix) with ESMTP id C684148; Thu, 5 Nov 2020 15:24:32 +0000 (UTC) From: "Abner Chang" To: devel@edk2.groups.io Cc: Jordan Justen , Andrew Fish , Ray Ni , Nickle Wang , Peter O'Hanley Subject: [Platform Redfish Host Interface PATCH 3/6] EmulatorPkg/RedfishPlatformHostInterfaceLib library Date: Thu, 5 Nov 2020 22:38:50 +0800 Message-Id: <20201105143853.2180-4-abner.chang@hpe.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20201105143853.2180-1-abner.chang@hpe.com> References: <20201105143853.2180-1-abner.chang@hpe.com> X-HPE-SCL: -1 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:6.0.312,18.0.737 definitions=2020-11-05_09:2020-11-05,2020-11-05 signatures=0 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 clxscore=1015 priorityscore=1501 adultscore=0 bulkscore=0 mlxlogscore=999 impostorscore=0 malwarescore=0 lowpriorityscore=0 mlxscore=0 suspectscore=3 spamscore=0 phishscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2009150000 definitions=main-2011050105 Platform specific implementation of providing Redfish host interface information. Signed-off-by: Jiaxin Wu Signed-off-by: Ting Ye Signed-off-by: Siyuan Fu Signed-off-by: Fan Wang Signed-off-by: Abner Chang Cc: Jordan Justen Cc: Andrew Fish Cc: Ray Ni Cc: Nickle Wang Cc: Peter O'Hanley --- EmulatorPkg/EmulatorPkg.dec | 1 + .../RedfishPlatformHostInterfaceLib.c | 528 ++++++++++++++++++ .../RedfishPlatformHostInterfaceLib.inf | 47 ++ 3 files changed, 576 insertions(+) create mode 100644 EmulatorPkg/Library/RedfishPlatformHostInterfaceLib/RedfishPlatformHostInterfaceLib.c create mode 100644 EmulatorPkg/Library/RedfishPlatformHostInterfaceLib/RedfishPlatformHostInterfaceLib.inf diff --git a/EmulatorPkg/EmulatorPkg.dec b/EmulatorPkg/EmulatorPkg.dec index 064f963c72..5d7fe6473e 100644 --- a/EmulatorPkg/EmulatorPkg.dec +++ b/EmulatorPkg/EmulatorPkg.dec @@ -46,6 +46,7 @@ gEmuSystemConfigGuid = { 0xF8626165, 0x6CEB, 0x924A, { 0xBA, 0xFC, 0xF1, 0x3A, 0xB9, 0xD6, 0x57, 0x28 } } gEmuVirtualDisksGuid = { 0xf2ba331a, 0x8985, 0x11db, { 0xa4, 0x06, 0x00, 0x40, 0xd0, 0x2b, 0x18, 0x35 } } gEmuPhysicalDisksGuid = { 0xf2bdcc96, 0x8985, 0x11db, { 0x87, 0x19, 0x00, 0x40, 0xd0, 0x2b, 0x18, 0x35 } } + gEmuRedfishServiceGuid = { 0x3fb208ac, 0x2185, 0x498c, { 0xbf, 0x46, 0xdc, 0x23, 0xda, 0x58, 0x7b, 0x55 } } [PcdsFeatureFlag] ## If TRUE, if symbols only load on breakpoints and gdb entry diff --git a/EmulatorPkg/Library/RedfishPlatformHostInterfaceLib/RedfishPlatformHostInterfaceLib.c b/EmulatorPkg/Library/RedfishPlatformHostInterfaceLib/RedfishPlatformHostInterfaceLib.c new file mode 100644 index 0000000000..4e7bb65c06 --- /dev/null +++ b/EmulatorPkg/Library/RedfishPlatformHostInterfaceLib/RedfishPlatformHostInterfaceLib.c @@ -0,0 +1,528 @@ +/** @file + PCI/PCIe network interface instace of RedfishPlatformHostInterfaceLib + + Copyright (c) 2019, Intel Corporation. All rights reserved.
+ (C) Copyright 2020 Hewlett Packard Enterprise Development LP
+ + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#define VERBOSE_COLUME_SIZE (16) + +REDFISH_OVER_IP_PROTOCOL_DATA *mRedfishOverIpProtocolData; +UINT8 mRedfishProtocolDataSize; + +/** + Get the MAC address of NIC. + + @param[out] MacAddress Pointer to retrieve MAC address + + @retval EFI_SUCCESS MAC address is returned in MacAddress + +**/ +EFI_STATUS +GetMacAddressInformation ( + OUT EFI_MAC_ADDRESS *MacAddress + ) +{ + MAC_ADDR_DEVICE_PATH *Mac; + REST_EX_SERVICE_DEVICE_PATH_DATA *RestExServiceDevicePathData; + EFI_DEVICE_PATH_PROTOCOL *RestExServiceDevicePath; + MAC_ADDR_DEVICE_PATH *MacAddressDevicePath; + + Mac = NULL; + RestExServiceDevicePathData = NULL; + RestExServiceDevicePath = NULL; + + RestExServiceDevicePathData = (REST_EX_SERVICE_DEVICE_PATH_DATA *)PcdGetPtr(PcdRedfishRestExServiceDevicePath); + if (RestExServiceDevicePathData == NULL || + RestExServiceDevicePathData->DevicePathNum == 0 || + !IsDevicePathValid (RestExServiceDevicePathData->DevicePath, 0)) { + return EFI_NOT_FOUND; + } + + RestExServiceDevicePath = RestExServiceDevicePathData->DevicePath; + if (RestExServiceDevicePathData->DevicePathMatchMode != DEVICE_PATH_MATCH_MAC_NODE) { + return EFI_NOT_FOUND; + } + + // + // Find Mac DevicePath Node. + // + while (!IsDevicePathEnd (RestExServiceDevicePath) && + ((DevicePathType (RestExServiceDevicePath) != MESSAGING_DEVICE_PATH) || + (DevicePathSubType (RestExServiceDevicePath) != MSG_MAC_ADDR_DP))) { + RestExServiceDevicePath = NextDevicePathNode (RestExServiceDevicePath); + } + + if (!IsDevicePathEnd (RestExServiceDevicePath)) { + MacAddressDevicePath = (MAC_ADDR_DEVICE_PATH *)RestExServiceDevicePath; + CopyMem ((VOID *)MacAddress, (VOID *)&MacAddressDevicePath->MacAddress, sizeof (EFI_MAC_ADDRESS)); + return EFI_SUCCESS; + } + return EFI_NOT_FOUND; +} + +/** + Get platform Redfish host interface device descriptor. + + @param[out] DeviceType Pointer to retrieve device type. + @param[out] DeviceDescriptor Pointer to retrieve REDFISH_INTERFACE_DATA, caller has to free + this memory using FreePool(). + @retval EFI_SUCCESS Device descriptor is returned successfully in DeviceDescriptor. + @retval EFI_NOT_FOUND No Redfish host interface descriptor provided on this platform. + @retval Others Fail to get device descriptor. +**/ +EFI_STATUS +RedfishPlatformHostInterfaceDeviceDescriptor ( + OUT UINT8 *DeviceType, + OUT REDFISH_INTERFACE_DATA **DeviceDescriptor +) +{ + EFI_STATUS Status; + EFI_MAC_ADDRESS MacAddress; + REDFISH_INTERFACE_DATA *RedfishInterfaceData; + PCI_OR_PCIE_INTERFACE_DEVICE_DESCRIPTOR_V2 *ThisDeviceDescriptor; + + RedfishInterfaceData = AllocateZeroPool (sizeof (PCI_OR_PCIE_INTERFACE_DEVICE_DESCRIPTOR_V2) + 1); + if (RedfishInterfaceData == NULL) { + return EFI_OUT_OF_RESOURCES; + } + RedfishInterfaceData->DeviceType = REDFISH_HOST_INTERFACE_DEVICE_TYPE_PCI_PCIE_V2; + // + // Fill up device type information. + // + ThisDeviceDescriptor = (PCI_OR_PCIE_INTERFACE_DEVICE_DESCRIPTOR_V2 *)((UINT8 *)RedfishInterfaceData + 1); + ThisDeviceDescriptor->Length = sizeof (PCI_OR_PCIE_INTERFACE_DEVICE_DESCRIPTOR_V2) + 1; + Status = GetMacAddressInformation (&MacAddress); + if (EFI_ERROR (Status)) { + FreePool (RedfishInterfaceData); + return EFI_NOT_FOUND; + } + CopyMem ((VOID *)&ThisDeviceDescriptor->MacAddress, (VOID *)&MacAddress, sizeof (ThisDeviceDescriptor->MacAddress)); + *DeviceType = REDFISH_HOST_INTERFACE_DEVICE_TYPE_PCI_PCIE_V2; + *DeviceDescriptor = RedfishInterfaceData; + return EFI_SUCCESS; +} +/** + Get platform Redfish host interface protocol data. + Caller should pass NULL in ProtocolRecord to retrive the first protocol record. + Then continuously pass previous ProtocolRecord for retrieving the next ProtocolRecord. + + @param[out] ProtocolRecord Pointer to retrieve the protocol record. + caller has to free the new protocol record returned from + this function using FreePool(). + @param[in] IndexOfProtocolData The index of protocol data. + + @retval EFI_SUCCESS Protocol records are all returned. + @retval EFI_NOT_FOUND No more protocol records. + @retval Others Fail to get protocol records. +**/ +EFI_STATUS +RedfishPlatformHostInterfaceProtocolData ( + OUT MC_HOST_INTERFACE_PROTOCOL_RECORD **ProtocolRecord, + IN UINT8 IndexOfProtocolData +) +{ + MC_HOST_INTERFACE_PROTOCOL_RECORD *ThisProtocolRecord; + + if (mRedfishOverIpProtocolData == 0) { + return EFI_NOT_FOUND; + } + if (IndexOfProtocolData == 0) { + // + // Return the first Redfish protocol data to caller. We only have + // one protocol data in this case. + // + ThisProtocolRecord = (MC_HOST_INTERFACE_PROTOCOL_RECORD *) AllocatePool (mRedfishProtocolDataSize + sizeof (MC_HOST_INTERFACE_PROTOCOL_RECORD) - 1); + ThisProtocolRecord->ProtocolType = MCHostInterfaceProtocolTypeRedfishOverIP; + ThisProtocolRecord->ProtocolTypeDataLen = mRedfishProtocolDataSize; + CopyMem ((VOID *)&ThisProtocolRecord->ProtocolTypeData, (VOID *)mRedfishOverIpProtocolData, mRedfishProtocolDataSize); + *ProtocolRecord = ThisProtocolRecord; + return EFI_SUCCESS; + } + return EFI_NOT_FOUND; +} +/** + Dump IPv4 address. + + @param[in] Ip IPv4 address +**/ +VOID +InternalDumpIp4Addr ( + IN EFI_IPv4_ADDRESS *Ip + ) +{ + UINTN Index; + + for (Index = 0; Index < 4; Index++) { + DEBUG ((DEBUG_VERBOSE, "%d", Ip->Addr[Index])); + if (Index < 3) { + DEBUG ((DEBUG_VERBOSE, ".")); + } + } + + DEBUG ((DEBUG_VERBOSE, "\n")); +} +/** + Dump IPv6 address. + + @param[in] Ip IPv6 address +**/ +VOID +InternalDumpIp6Addr ( + IN EFI_IPv6_ADDRESS *Ip + ) +{ + UINTN Index; + + for (Index = 0; Index < 16; Index++) { + if (Ip->Addr[Index] != 0) { + DEBUG ((DEBUG_VERBOSE, "%x", Ip->Addr[Index])); + } + Index++; + + if (Index > 15) { + return; + } + + if (((Ip->Addr[Index] & 0xf0) == 0) && (Ip->Addr[Index - 1] != 0)) { + DEBUG ((DEBUG_VERBOSE, "0")); + } + DEBUG ((DEBUG_VERBOSE, "%x", Ip->Addr[Index])); + + if (Index < 15) { + DEBUG ((DEBUG_VERBOSE, ":")); + } + } + DEBUG ((DEBUG_VERBOSE, "\n")); +} +/** + Dump data + + @param[in] Data Pointer to data. + @param[in] Size size of data to dump. +**/ +VOID +InternalDumpData ( + IN UINT8 *Data, + IN UINTN Size + ) +{ + UINTN Index; + for (Index = 0; Index < Size; Index++) { + DEBUG ((DEBUG_VERBOSE, "%02x ", (UINTN)Data[Index])); + } +} +/** + Dump hex data + + @param[in] Data Pointer to hex data. + @param[in] Size size of hex data to dump. +**/ +VOID +InternalDumpHex ( + IN UINT8 *Data, + IN UINTN Size + ) +{ + UINTN Index; + UINTN Count; + UINTN Left; + + Count = Size / VERBOSE_COLUME_SIZE; + Left = Size % VERBOSE_COLUME_SIZE; + for (Index = 0; Index < Count; Index++) { + InternalDumpData (Data + Index * VERBOSE_COLUME_SIZE, VERBOSE_COLUME_SIZE); + DEBUG ((DEBUG_VERBOSE, "\n")); + } + + if (Left != 0) { + InternalDumpData (Data + Index * VERBOSE_COLUME_SIZE, Left); + DEBUG ((DEBUG_VERBOSE, "\n")); + } + + DEBUG ((DEBUG_VERBOSE, "\n")); +} +/** + Dump Redfish over IP protocol data + + @param[in] RedfishProtocolData Pointer to REDFISH_OVER_IP_PROTOCOL_DATA + @param[in] RedfishProtocolDataSize size of data to dump. +**/ +VOID +DumpRedfishIpProtocolData ( + IN REDFISH_OVER_IP_PROTOCOL_DATA *RedfishProtocolData, + IN UINT8 RedfishProtocolDataSize + ) +{ + CHAR16 Hostname[16]; + + DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData: \n")); + InternalDumpHex ((UINT8 *) RedfishProtocolData, RedfishProtocolDataSize); + + DEBUG ((DEBUG_VERBOSE, "Parsing as below: \n")); + + DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->ServiceUuid - %g\n", &(RedfishProtocolData->ServiceUuid))); + + DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->HostIpAssignmentType - %d\n", RedfishProtocolData->HostIpAssignmentType)); + + DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->HostIpAddressFormat - %d\n", RedfishProtocolData->HostIpAddressFormat)); + + DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->HostIpAddress: \n")); + if (RedfishProtocolData->HostIpAddressFormat == 0x01) { + InternalDumpIp4Addr ((EFI_IPv4_ADDRESS *) (RedfishProtocolData->HostIpAddress)); + } else { + InternalDumpIp6Addr ((EFI_IPv6_ADDRESS *) (RedfishProtocolData->HostIpAddress)); + } + + DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->HostIpMask: \n")); + if (RedfishProtocolData->HostIpAddressFormat == 0x01) { + InternalDumpIp4Addr ((EFI_IPv4_ADDRESS *) (RedfishProtocolData->HostIpMask)); + } else { + InternalDumpIp6Addr ((EFI_IPv6_ADDRESS *) (RedfishProtocolData->HostIpMask)); + } + + DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpDiscoveryType - %d\n", RedfishProtocolData->RedfishServiceIpDiscoveryType)); + + DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpAddressFormat - %d\n", RedfishProtocolData->RedfishServiceIpAddressFormat)); + + DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpAddress: \n")); + if (RedfishProtocolData->RedfishServiceIpAddressFormat == 0x01) { + InternalDumpIp4Addr ((EFI_IPv4_ADDRESS *) (RedfishProtocolData->RedfishServiceIpAddress)); + } else { + InternalDumpIp6Addr ((EFI_IPv6_ADDRESS *) (RedfishProtocolData->RedfishServiceIpAddress)); + } + + DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpMask: \n")); + if (RedfishProtocolData->RedfishServiceIpAddressFormat == 0x01) { + InternalDumpIp4Addr ((EFI_IPv4_ADDRESS *) (RedfishProtocolData->RedfishServiceIpMask)); + } else { + InternalDumpIp6Addr ((EFI_IPv6_ADDRESS *) (RedfishProtocolData->RedfishServiceIpMask)); + } + + DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceIpPort - %d\n", RedfishProtocolData->RedfishServiceIpPort)); + + DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceVlanId - %d\n", RedfishProtocolData->RedfishServiceVlanId)); + + DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceHostnameLength - %d\n", RedfishProtocolData->RedfishServiceHostnameLength)); + + AsciiStrToUnicodeStrS((CHAR8 *) RedfishProtocolData->RedfishServiceHostname, Hostname, sizeof (Hostname) / sizeof (Hostname[0])); + DEBUG ((DEBUG_VERBOSE, "RedfishProtocolData->RedfishServiceHostname - %s\n", Hostname)); +} + +/** + Get Redfish host interface protocol data from variale. + + @param[out] RedfishProtocolData Pointer to retrieve REDFISH_OVER_IP_PROTOCOL_DATA. + @param[out] RedfishProtocolDataSize Size of REDFISH_OVER_IP_PROTOCOL_DATA. + + @retval EFI_SUCESS REDFISH_OVER_IP_PROTOCOL_DATA is returned successfully. +**/ +EFI_STATUS +GetRedfishRecordFromVariable ( + OUT REDFISH_OVER_IP_PROTOCOL_DATA **RedfishProtocolData, + OUT UINT8 *RedfishProtocolDataSize + ) +{ + EFI_STATUS Status; + UINT8 HostIpAssignmentType; + UINTN HostIpAssignmentTypeSize; + EFI_IPv4_ADDRESS HostIpAddress; + UINTN IPv4DataSize; + EFI_IPv4_ADDRESS HostIpMask; + EFI_IPv4_ADDRESS RedfishServiceIpAddress; + EFI_IPv4_ADDRESS RedfishServiceIpMask; + UINT16 RedfishServiceIpPort; + UINTN IpPortDataSize; + UINT8 HostNameSize; + CHAR8 RedfishHostName[20]; + + if (RedfishProtocolData == NULL || RedfishProtocolDataSize == NULL) { + return EFI_INVALID_PARAMETER; + } + + // + // 1. Retrieve Address Information from variable. + // + Status = gRT->GetVariable ( + L"HostIpAssignmentType", + &gEmuRedfishServiceGuid, + NULL, + &HostIpAssignmentTypeSize, + &HostIpAssignmentType + ); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable HostIpAssignmentType - %r\n", Status)); + return Status; + } + + IPv4DataSize = sizeof (EFI_IPv4_ADDRESS); + if (HostIpAssignmentType == 1 ) { + Status = gRT->GetVariable ( + L"HostIpAddress", + &gEmuRedfishServiceGuid, + NULL, + &IPv4DataSize, + &HostIpAddress + ); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable HostIpAddress - %r\n", Status)); + return Status; + } + + Status = gRT->GetVariable ( + L"HostIpMask", + &gEmuRedfishServiceGuid, + NULL, + &IPv4DataSize, + &HostIpMask + ); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable HostIpMask - %r\n", Status)); + return Status; + } + } + + Status = gRT->GetVariable ( + L"RedfishServiceIpAddress", + &gEmuRedfishServiceGuid, + NULL, + &IPv4DataSize, + &RedfishServiceIpAddress + ); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable RedfishServiceIpAddress - %r\n", Status)); + return Status; + } + + Status = gRT->GetVariable ( + L"RedfishServiceIpMask", + &gEmuRedfishServiceGuid, + NULL, + &IPv4DataSize, + &RedfishServiceIpMask + ); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable RedfishServiceIpMask - %r\n", Status)); + return Status; + } + + Status = gRT->GetVariable ( + L"RedfishServiceIpPort", + &gEmuRedfishServiceGuid, + NULL, + &IpPortDataSize, + &RedfishServiceIpPort + ); + if (EFI_ERROR (Status)) { + DEBUG ((DEBUG_ERROR, "RedfishPlatformDxe: GetVariable RedfishServiceIpPort - %r\n", Status)); + return Status; + } + + AsciiSPrint ( + RedfishHostName, + sizeof (RedfishHostName), + "%d.%d.%d.%d", + RedfishServiceIpAddress.Addr[0], + RedfishServiceIpAddress.Addr[1], + RedfishServiceIpAddress.Addr[2], + RedfishServiceIpAddress.Addr[3] + ); + + HostNameSize = (UINT8) AsciiStrLen (RedfishHostName) + 1; + + // + // 2. Protocol Data Size. + // + *RedfishProtocolDataSize = sizeof (REDFISH_OVER_IP_PROTOCOL_DATA) - 1 + HostNameSize; + + // + // 3. Protocol Data. + // + *RedfishProtocolData = (REDFISH_OVER_IP_PROTOCOL_DATA *) AllocateZeroPool (*RedfishProtocolDataSize); + if (*RedfishProtocolData == NULL) { + return EFI_OUT_OF_RESOURCES; + } + + CopyGuid (&(*RedfishProtocolData)->ServiceUuid, &gEmuRedfishServiceGuid); + + (*RedfishProtocolData)->HostIpAssignmentType = HostIpAssignmentType; + (*RedfishProtocolData)->HostIpAddressFormat = 1; // Only support IPv4 + + if (HostIpAssignmentType == 1 ) { + (*RedfishProtocolData)->HostIpAddress[0] = HostIpAddress.Addr[0]; + (*RedfishProtocolData)->HostIpAddress[1] = HostIpAddress.Addr[1]; + (*RedfishProtocolData)->HostIpAddress[2] = HostIpAddress.Addr[2]; + (*RedfishProtocolData)->HostIpAddress[3] = HostIpAddress.Addr[3]; + + (*RedfishProtocolData)->HostIpMask[0] = HostIpMask.Addr[0]; + (*RedfishProtocolData)->HostIpMask[1] = HostIpMask.Addr[1]; + (*RedfishProtocolData)->HostIpMask[2] = HostIpMask.Addr[2]; + (*RedfishProtocolData)->HostIpMask[3] = HostIpMask.Addr[3]; + } + + (*RedfishProtocolData)->RedfishServiceIpDiscoveryType = 1; // Use static IP address + (*RedfishProtocolData)->RedfishServiceIpAddressFormat = 1; // Only support IPv4 + + (*RedfishProtocolData)->RedfishServiceIpAddress[0] = RedfishServiceIpAddress.Addr[0]; + (*RedfishProtocolData)->RedfishServiceIpAddress[1] = RedfishServiceIpAddress.Addr[1]; + (*RedfishProtocolData)->RedfishServiceIpAddress[2] = RedfishServiceIpAddress.Addr[2]; + (*RedfishProtocolData)->RedfishServiceIpAddress[3] = RedfishServiceIpAddress.Addr[3]; + + (*RedfishProtocolData)->RedfishServiceIpMask[0] = RedfishServiceIpMask.Addr[0]; + (*RedfishProtocolData)->RedfishServiceIpMask[1] = RedfishServiceIpMask.Addr[1]; + (*RedfishProtocolData)->RedfishServiceIpMask[2] = RedfishServiceIpMask.Addr[2]; + (*RedfishProtocolData)->RedfishServiceIpMask[3] = RedfishServiceIpMask.Addr[3]; + + (*RedfishProtocolData)->RedfishServiceIpPort = RedfishServiceIpPort; + (*RedfishProtocolData)->RedfishServiceVlanId = 0xffffffff; + + (*RedfishProtocolData)->RedfishServiceHostnameLength = HostNameSize; + AsciiStrCpyS ((CHAR8 *) ((*RedfishProtocolData)->RedfishServiceHostname), HostNameSize, RedfishHostName); + + return Status; +} + +/** + Construct Redfish host interface protocol data. + + @param ImageHandle The image handle. + @param SystemTable The system table. + + @retval EFI_SUCEESS Install Boot manager menu success. + @retval Other Return error status. + +**/ +EFI_STATUS +EFIAPI +RedfishPlatformHostInterfaceConstructor ( + IN EFI_HANDLE ImageHandle, + IN EFI_SYSTEM_TABLE *SystemTable +) +{ + EFI_STATUS Status; + + Status = GetRedfishRecordFromVariable (&mRedfishOverIpProtocolData, &mRedfishProtocolDataSize); + DEBUG ((DEBUG_INFO, "%a: GetRedfishRecordFromVariable() - %r\n", __FUNCTION__, Status)); + if (!EFI_ERROR (Status)) { + DumpRedfishIpProtocolData (mRedfishOverIpProtocolData, mRedfishProtocolDataSize); + } + return EFI_SUCCESS; +} diff --git a/EmulatorPkg/Library/RedfishPlatformHostInterfaceLib/RedfishPlatformHostInterfaceLib.inf b/EmulatorPkg/Library/RedfishPlatformHostInterfaceLib/RedfishPlatformHostInterfaceLib.inf new file mode 100644 index 0000000000..6fe5d9b32b --- /dev/null +++ b/EmulatorPkg/Library/RedfishPlatformHostInterfaceLib/RedfishPlatformHostInterfaceLib.inf @@ -0,0 +1,47 @@ +## @file +# NULL instance of RedfishPlatformHostInterfaceLib +# +# (C) Copyright 2020 Hewlett Packard Enterprise Development LP
+# +# SPDX-License-Identifier: BSD-2-Clause-Patent +# +## + +[Defines] + INF_VERSION = 0x0001000b + BASE_NAME = RedfishPlatformHostInterfaceLib + FILE_GUID = D5ECB7F2-4906-94E2-45B1-31BF4FD90122 + MODULE_TYPE = DXE_DRIVER + VERSION_STRING = 1.0 + LIBRARY_CLASS = RedfishPlatformHostInterfaceLib + CONSTRUCTOR = RedfishPlatformHostInterfaceConstructor +# +# VALID_ARCHITECTURES = IA32 X64 +# + +[Sources] + RedfishPlatformHostInterfaceLib.c + +[Packages] + EmulatorPkg/EmulatorPkg.dec + MdePkg/MdePkg.dec + MdeModulePkg/MdeModulePkg.dec + RedfishPkg/RedfishPkg.dec + +[LibraryClasses] + UefiLib + BaseLib + BaseMemoryLib + DebugLib + PcdLib + MemoryAllocationLib + +[Pcd] + gEfiRedfishPkgTokenSpaceGuid.PcdRedfishRestExServiceDevicePath ## CONSUMES + +[Guids] + gEmuRedfishServiceGuid + +[Depex] + gEfiVariableArchProtocolGuid AND + gEfiVariableWriteArchProtocolGuid -- 2.17.1