VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/IScsiDxe/IScsiMisc.c@ 99404

Last change on this file since 99404 was 99404, checked in by vboxsync, 2 years ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 74.8 KB
Line 
1/** @file
2 Miscellaneous routines for iSCSI driver.
3
4Copyright (c) 2004 - 2018, Intel Corporation. All rights reserved.<BR>
5SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include "IScsiImpl.h"
10
11GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 IScsiHexString[] = "0123456789ABCDEFabcdef";
12
13/**
14 Removes (trims) specified leading and trailing characters from a string.
15
16 @param[in, out] Str Pointer to the null-terminated string to be trimmed.
17 On return, Str will hold the trimmed string.
18
19 @param[in] CharC Character will be trimmed from str.
20
21**/
22VOID
23IScsiStrTrim (
24 IN OUT CHAR16 *Str,
25 IN CHAR16 CharC
26 )
27{
28 CHAR16 *Pointer1;
29 CHAR16 *Pointer2;
30
31 if (*Str == 0) {
32 return;
33 }
34
35 //
36 // Trim off the leading and trailing characters c
37 //
38 for (Pointer1 = Str; (*Pointer1 != 0) && (*Pointer1 == CharC); Pointer1++) {
39 }
40
41 Pointer2 = Str;
42 if (Pointer2 == Pointer1) {
43 while (*Pointer1 != 0) {
44 Pointer2++;
45 Pointer1++;
46 }
47 } else {
48 while (*Pointer1 != 0) {
49 *Pointer2 = *Pointer1;
50 Pointer1++;
51 Pointer2++;
52 }
53
54 *Pointer2 = 0;
55 }
56
57 for (Pointer1 = Str + StrLen (Str) - 1; Pointer1 >= Str && *Pointer1 == CharC; Pointer1--) {
58 }
59
60 if (Pointer1 != Str + StrLen (Str) - 1) {
61 *(Pointer1 + 1) = 0;
62 }
63}
64
65/**
66 Calculate the prefix length of the IPv4 subnet mask.
67
68 @param[in] SubnetMask The IPv4 subnet mask.
69
70 @return The prefix length of the subnet mask.
71 @retval 0 Other errors as indicated.
72
73**/
74UINT8
75IScsiGetSubnetMaskPrefixLength (
76 IN EFI_IPv4_ADDRESS *SubnetMask
77 )
78{
79 UINT8 Len;
80 UINT32 ReverseMask;
81
82 //
83 // The SubnetMask is in network byte order.
84 //
85 ReverseMask = (SubnetMask->Addr[0] << 24) | (SubnetMask->Addr[1] << 16) | (SubnetMask->Addr[2] << 8) | (SubnetMask->Addr[3]);
86
87 //
88 // Reverse it.
89 //
90 ReverseMask = ~ReverseMask;
91
92 if ((ReverseMask & (ReverseMask + 1)) != 0) {
93 return 0;
94 }
95
96 Len = 0;
97
98 while (ReverseMask != 0) {
99 ReverseMask = ReverseMask >> 1;
100 Len++;
101 }
102
103 return (UINT8)(32 - Len);
104}
105
106/**
107 Convert the hexadecimal encoded LUN string into the 64-bit LUN.
108
109 @param[in] Str The hexadecimal encoded LUN string.
110 @param[out] Lun Storage to return the 64-bit LUN.
111
112 @retval EFI_SUCCESS The 64-bit LUN is stored in Lun.
113 @retval EFI_INVALID_PARAMETER The string is malformatted.
114
115**/
116EFI_STATUS
117IScsiAsciiStrToLun (
118 IN CHAR8 *Str,
119 OUT UINT8 *Lun
120 )
121{
122 UINTN Index, IndexValue, IndexNum, SizeStr;
123 CHAR8 TemStr[2];
124 UINT8 TemValue;
125 UINT16 Value[4];
126
127 ZeroMem (Lun, 8);
128 ZeroMem (TemStr, 2);
129 ZeroMem ((UINT8 *)Value, sizeof (Value));
130 SizeStr = AsciiStrLen (Str);
131 IndexValue = 0;
132 IndexNum = 0;
133
134 for (Index = 0; Index < SizeStr; Index++) {
135 TemStr[0] = Str[Index];
136 TemValue = (UINT8)AsciiStrHexToUint64 (TemStr);
137 if ((TemValue == 0) && (TemStr[0] != '0')) {
138 if ((TemStr[0] != '-') || (IndexNum == 0)) {
139 //
140 // Invalid Lun Char.
141 //
142 return EFI_INVALID_PARAMETER;
143 }
144 }
145
146 if ((TemValue == 0) && (TemStr[0] == '-')) {
147 //
148 // Next Lun value.
149 //
150 if (++IndexValue >= 4) {
151 //
152 // Max 4 Lun value.
153 //
154 return EFI_INVALID_PARAMETER;
155 }
156
157 //
158 // Restart str index for the next lun value.
159 //
160 IndexNum = 0;
161 continue;
162 }
163
164 if (++IndexNum > 4) {
165 //
166 // Each Lun Str can't exceed size 4, because it will be as UINT16 value.
167 //
168 return EFI_INVALID_PARAMETER;
169 }
170
171 //
172 // Combine UINT16 value.
173 //
174 Value[IndexValue] = (UINT16)((Value[IndexValue] << 4) + TemValue);
175 }
176
177 for (Index = 0; Index <= IndexValue; Index++) {
178 *((UINT16 *)&Lun[Index * 2]) = HTONS (Value[Index]);
179 }
180
181 return EFI_SUCCESS;
182}
183
184/**
185 Convert the 64-bit LUN into the hexadecimal encoded LUN string.
186
187 @param[in] Lun The 64-bit LUN.
188 @param[out] Str The storage to return the hexadecimal encoded LUN string.
189
190**/
191VOID
192IScsiLunToUnicodeStr (
193 IN UINT8 *Lun,
194 OUT CHAR16 *Str
195 )
196{
197 UINTN Index;
198 CHAR16 *TempStr;
199
200 TempStr = Str;
201
202 for (Index = 0; Index < 4; Index++) {
203 if ((Lun[2 * Index] | Lun[2 * Index + 1]) == 0) {
204 CopyMem (TempStr, L"0-", sizeof (L"0-"));
205 } else {
206 TempStr[0] = (CHAR16)IScsiHexString[Lun[2 * Index] >> 4];
207 TempStr[1] = (CHAR16)IScsiHexString[Lun[2 * Index] & 0x0F];
208 TempStr[2] = (CHAR16)IScsiHexString[Lun[2 * Index + 1] >> 4];
209 TempStr[3] = (CHAR16)IScsiHexString[Lun[2 * Index + 1] & 0x0F];
210 TempStr[4] = L'-';
211 TempStr[5] = 0;
212
213 IScsiStrTrim (TempStr, L'0');
214 }
215
216 TempStr += StrLen (TempStr);
217 }
218
219 //
220 // Remove the last '-'
221 //
222 ASSERT (StrLen (Str) >= 1);
223 Str[StrLen (Str) - 1] = 0;
224
225 for (Index = StrLen (Str) - 1; Index > 1; Index = Index - 2) {
226 if ((Str[Index] == L'0') && (Str[Index - 1] == L'-')) {
227 Str[Index - 1] = 0;
228 } else {
229 break;
230 }
231 }
232}
233
234/**
235 Convert the formatted IP address into the binary IP address.
236
237 @param[in] Str The UNICODE string.
238 @param[in] IpMode Indicates whether the IP address is v4 or v6.
239 @param[out] Ip The storage to return the ASCII string.
240
241 @retval EFI_SUCCESS The binary IP address is returned in Ip.
242 @retval EFI_INVALID_PARAMETER The IP string is malformatted or IpMode is
243 invalid.
244
245**/
246EFI_STATUS
247IScsiAsciiStrToIp (
248 IN CHAR8 *Str,
249 IN UINT8 IpMode,
250 OUT EFI_IP_ADDRESS *Ip
251 )
252{
253 EFI_STATUS Status;
254
255 if ((IpMode == IP_MODE_IP4) || (IpMode == IP_MODE_AUTOCONFIG_IP4)) {
256 return NetLibAsciiStrToIp4 (Str, &Ip->v4);
257 } else if ((IpMode == IP_MODE_IP6) || (IpMode == IP_MODE_AUTOCONFIG_IP6)) {
258 return NetLibAsciiStrToIp6 (Str, &Ip->v6);
259 } else if (IpMode == IP_MODE_AUTOCONFIG) {
260 Status = NetLibAsciiStrToIp4 (Str, &Ip->v4);
261 if (!EFI_ERROR (Status)) {
262 return Status;
263 }
264
265 return NetLibAsciiStrToIp6 (Str, &Ip->v6);
266 }
267
268 return EFI_INVALID_PARAMETER;
269}
270
271/**
272 Convert the mac address into a hexadecimal encoded "-" separated string.
273
274 @param[in] Mac The mac address.
275 @param[in] Len Length in bytes of the mac address.
276 @param[in] VlanId VLAN ID of the network device.
277 @param[out] Str The storage to return the mac string.
278
279**/
280VOID
281IScsiMacAddrToStr (
282 IN EFI_MAC_ADDRESS *Mac,
283 IN UINT32 Len,
284 IN UINT16 VlanId,
285 OUT CHAR16 *Str
286 )
287{
288 UINT32 Index;
289 CHAR16 *String;
290
291 for (Index = 0; Index < Len; Index++) {
292 Str[3 * Index] = (CHAR16)IScsiHexString[(Mac->Addr[Index] >> 4) & 0x0F];
293 Str[3 * Index + 1] = (CHAR16)IScsiHexString[Mac->Addr[Index] & 0x0F];
294 Str[3 * Index + 2] = L':';
295 }
296
297 String = &Str[3 * Index - 1];
298 if (VlanId != 0) {
299 String += UnicodeSPrint (String, 6 * sizeof (CHAR16), L"\\%04x", (UINTN)VlanId);
300 }
301
302 *String = L'\0';
303}
304
305/**
306 Convert the binary encoded buffer into a hexadecimal encoded string.
307
308 @param[in] BinBuffer The buffer containing the binary data.
309 @param[in] BinLength Length of the binary buffer.
310 @param[in, out] HexStr Pointer to the string.
311 @param[in, out] HexLength The length of the string.
312
313 @retval EFI_SUCCESS The binary data is converted to the hexadecimal string
314 and the length of the string is updated.
315 @retval EFI_BUFFER_TOO_SMALL The string is too small.
316 @retval EFI_BAD_BUFFER_SIZE BinLength is too large for hex encoding.
317 @retval EFI_INVALID_PARAMETER The IP string is malformatted.
318
319**/
320EFI_STATUS
321IScsiBinToHex (
322 IN UINT8 *BinBuffer,
323 IN UINT32 BinLength,
324 IN OUT CHAR8 *HexStr,
325 IN OUT UINT32 *HexLength
326 )
327{
328 UINT32 HexLengthMin;
329 UINT32 HexLengthProvided;
330 UINT32 Index;
331
332 if ((HexStr == NULL) || (BinBuffer == NULL) || (BinLength == 0)) {
333 return EFI_INVALID_PARAMETER;
334 }
335
336 //
337 // Safely calculate: HexLengthMin := BinLength * 2 + 3.
338 //
339 if (RETURN_ERROR (SafeUint32Mult (BinLength, 2, &HexLengthMin)) ||
340 RETURN_ERROR (SafeUint32Add (HexLengthMin, 3, &HexLengthMin)))
341 {
342 return EFI_BAD_BUFFER_SIZE;
343 }
344
345 HexLengthProvided = *HexLength;
346 *HexLength = HexLengthMin;
347 if (HexLengthProvided < HexLengthMin) {
348 return EFI_BUFFER_TOO_SMALL;
349 }
350
351 //
352 // Prefix for Hex String.
353 //
354 HexStr[0] = '0';
355 HexStr[1] = 'x';
356
357 for (Index = 0; Index < BinLength; Index++) {
358 HexStr[Index * 2 + 2] = IScsiHexString[BinBuffer[Index] >> 4];
359 HexStr[Index * 2 + 3] = IScsiHexString[BinBuffer[Index] & 0xf];
360 }
361
362 HexStr[Index * 2 + 2] = '\0';
363
364 return EFI_SUCCESS;
365}
366
367/**
368 Convert the hexadecimal string into a binary encoded buffer.
369
370 @param[in, out] BinBuffer The binary buffer.
371 @param[in, out] BinLength Length of the binary buffer.
372 @param[in] HexStr The hexadecimal string.
373
374 @retval EFI_SUCCESS The hexadecimal string is converted into a
375 binary encoded buffer.
376 @retval EFI_INVALID_PARAMETER Invalid hex encoding found in HexStr.
377 @retval EFI_BAD_BUFFER_SIZE The length of HexStr is too large for decoding:
378 the decoded size cannot be expressed in
379 BinLength on output.
380 @retval EFI_BUFFER_TOO_SMALL The binary buffer is too small to hold the
381 converted data.
382**/
383EFI_STATUS
384IScsiHexToBin (
385 IN OUT UINT8 *BinBuffer,
386 IN OUT UINT32 *BinLength,
387 IN CHAR8 *HexStr
388 )
389{
390 UINTN BinLengthMin;
391 UINT32 BinLengthProvided;
392 UINTN Index;
393 UINTN Length;
394 UINT8 Digit;
395 CHAR8 TemStr[2];
396
397 ZeroMem (TemStr, sizeof (TemStr));
398
399 //
400 // Find out how many hex characters the string has.
401 //
402 if ((HexStr[0] == '0') && ((HexStr[1] == 'x') || (HexStr[1] == 'X'))) {
403 HexStr += 2;
404 }
405
406 Length = AsciiStrLen (HexStr);
407
408 //
409 // Reject an empty hex string; reject a stray nibble.
410 //
411 if ((Length == 0) || (Length % 2 != 0)) {
412 return EFI_INVALID_PARAMETER;
413 }
414
415 //
416 // Check if the caller provides enough room for the decoded blob.
417 //
418 BinLengthMin = Length / 2;
419 if (BinLengthMin > MAX_UINT32) {
420 return EFI_BAD_BUFFER_SIZE;
421 }
422
423 BinLengthProvided = *BinLength;
424 *BinLength = (UINT32)BinLengthMin;
425 if (BinLengthProvided < BinLengthMin) {
426 return EFI_BUFFER_TOO_SMALL;
427 }
428
429 for (Index = 0; Index < Length; Index++) {
430 TemStr[0] = HexStr[Index];
431 Digit = (UINT8)AsciiStrHexToUint64 (TemStr);
432 if ((Digit == 0) && (TemStr[0] != '0')) {
433 //
434 // Invalid Hex Char.
435 //
436 return EFI_INVALID_PARAMETER;
437 }
438
439 if ((Index & 1) == 0) {
440 BinBuffer[Index/2] = Digit;
441 } else {
442 BinBuffer[Index/2] = (UINT8)((BinBuffer[Index/2] << 4) + Digit);
443 }
444 }
445
446 return EFI_SUCCESS;
447}
448
449/**
450 Convert the decimal-constant string or hex-constant string into a numerical value.
451
452 @param[in] Str String in decimal or hex.
453
454 @return The numerical value.
455
456**/
457UINTN
458IScsiNetNtoi (
459 IN CHAR8 *Str
460 )
461{
462 if ((Str[0] == '0') && ((Str[1] == 'x') || (Str[1] == 'X'))) {
463 Str += 2;
464
465 return AsciiStrHexToUintn (Str);
466 }
467
468 return AsciiStrDecimalToUintn (Str);
469}
470
471/**
472 Generate random numbers.
473
474 @param[in, out] Rand The buffer to contain random numbers.
475 @param[in] RandLength The length of the Rand buffer.
476
477**/
478VOID
479IScsiGenRandom (
480 IN OUT UINT8 *Rand,
481 IN UINTN RandLength
482 )
483{
484 UINT32 Random;
485
486 while (RandLength > 0) {
487 Random = NET_RANDOM (NetRandomInitSeed ());
488 *Rand++ = (UINT8)(Random);
489 RandLength--;
490 }
491}
492
493/**
494 Check whether UNDI protocol supports IPv6.
495
496 @param[in] ControllerHandle Controller handle.
497 @param[in] Image Handle of the image.
498 @param[out] Ipv6Support TRUE if UNDI supports IPv6.
499
500 @retval EFI_SUCCESS Get the result whether UNDI supports IPv6 by NII or AIP protocol successfully.
501 @retval EFI_NOT_FOUND Don't know whether UNDI supports IPv6 since NII or AIP is not available.
502
503**/
504EFI_STATUS
505IScsiCheckIpv6Support (
506 IN EFI_HANDLE ControllerHandle,
507 IN EFI_HANDLE Image,
508 OUT BOOLEAN *Ipv6Support
509 )
510{
511 EFI_HANDLE Handle;
512 EFI_ADAPTER_INFORMATION_PROTOCOL *Aip;
513 EFI_STATUS Status;
514 EFI_GUID *InfoTypesBuffer;
515 UINTN InfoTypeBufferCount;
516 UINTN TypeIndex;
517 BOOLEAN Supported;
518 VOID *InfoBlock;
519 UINTN InfoBlockSize;
520
521 EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL *Nii;
522
523 ASSERT (Ipv6Support != NULL);
524
525 //
526 // Check whether the UNDI supports IPv6 by NII protocol.
527 //
528 Status = gBS->OpenProtocol (
529 ControllerHandle,
530 &gEfiNetworkInterfaceIdentifierProtocolGuid_31,
531 (VOID **)&Nii,
532 Image,
533 ControllerHandle,
534 EFI_OPEN_PROTOCOL_GET_PROTOCOL
535 );
536 if (Status == EFI_SUCCESS) {
537 *Ipv6Support = Nii->Ipv6Supported;
538 return EFI_SUCCESS;
539 }
540
541 //
542 // Get the NIC handle by SNP protocol.
543 //
544 Handle = NetLibGetSnpHandle (ControllerHandle, NULL);
545 if (Handle == NULL) {
546 return EFI_NOT_FOUND;
547 }
548
549 Aip = NULL;
550 Status = gBS->HandleProtocol (
551 Handle,
552 &gEfiAdapterInformationProtocolGuid,
553 (VOID *)&Aip
554 );
555 if (EFI_ERROR (Status) || (Aip == NULL)) {
556 return EFI_NOT_FOUND;
557 }
558
559 InfoTypesBuffer = NULL;
560 InfoTypeBufferCount = 0;
561 Status = Aip->GetSupportedTypes (Aip, &InfoTypesBuffer, &InfoTypeBufferCount);
562 if (EFI_ERROR (Status) || (InfoTypesBuffer == NULL)) {
563 FreePool (InfoTypesBuffer);
564 return EFI_NOT_FOUND;
565 }
566
567 Supported = FALSE;
568 for (TypeIndex = 0; TypeIndex < InfoTypeBufferCount; TypeIndex++) {
569 if (CompareGuid (&InfoTypesBuffer[TypeIndex], &gEfiAdapterInfoUndiIpv6SupportGuid)) {
570 Supported = TRUE;
571 break;
572 }
573 }
574
575 FreePool (InfoTypesBuffer);
576 if (!Supported) {
577 return EFI_NOT_FOUND;
578 }
579
580 //
581 // We now have adapter information block.
582 //
583 InfoBlock = NULL;
584 InfoBlockSize = 0;
585 Status = Aip->GetInformation (Aip, &gEfiAdapterInfoUndiIpv6SupportGuid, &InfoBlock, &InfoBlockSize);
586 if (EFI_ERROR (Status) || (InfoBlock == NULL)) {
587 FreePool (InfoBlock);
588 return EFI_NOT_FOUND;
589 }
590
591 *Ipv6Support = ((EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT *)InfoBlock)->Ipv6Support;
592 FreePool (InfoBlock);
593
594 return EFI_SUCCESS;
595}
596
597/**
598 Record the NIC info in global structure.
599
600 @param[in] Controller The handle of the controller.
601 @param[in] Image Handle of the image.
602
603 @retval EFI_SUCCESS The operation is completed.
604 @retval EFI_OUT_OF_RESOURCES Do not have sufficient resources to finish this
605 operation.
606
607**/
608EFI_STATUS
609IScsiAddNic (
610 IN EFI_HANDLE Controller,
611 IN EFI_HANDLE Image
612 )
613{
614 EFI_STATUS Status;
615 ISCSI_NIC_INFO *NicInfo;
616 LIST_ENTRY *Entry;
617 EFI_MAC_ADDRESS MacAddr;
618 UINTN HwAddressSize;
619 UINT16 VlanId;
620
621 //
622 // Get MAC address of this network device.
623 //
624 Status = NetLibGetMacAddress (Controller, &MacAddr, &HwAddressSize);
625 if (EFI_ERROR (Status)) {
626 return Status;
627 }
628
629 //
630 // Get VLAN ID of this network device.
631 //
632 VlanId = NetLibGetVlanId (Controller);
633
634 //
635 // Check whether the NIC info already exists. Return directly if so.
636 //
637 NET_LIST_FOR_EACH (Entry, &mPrivate->NicInfoList) {
638 NicInfo = NET_LIST_USER_STRUCT (Entry, ISCSI_NIC_INFO, Link);
639 if ((NicInfo->HwAddressSize == HwAddressSize) &&
640 (CompareMem (&NicInfo->PermanentAddress, MacAddr.Addr, HwAddressSize) == 0) &&
641 (NicInfo->VlanId == VlanId))
642 {
643 mPrivate->CurrentNic = NicInfo->NicIndex;
644
645 //
646 // Set IPv6 available flag.
647 //
648 Status = IScsiCheckIpv6Support (Controller, Image, &NicInfo->Ipv6Available);
649 if (EFI_ERROR (Status)) {
650 //
651 // Fail to get the data whether UNDI supports IPv6.
652 // Set default value to TRUE.
653 //
654 NicInfo->Ipv6Available = TRUE;
655 }
656
657 return EFI_SUCCESS;
658 }
659
660 if (mPrivate->MaxNic < NicInfo->NicIndex) {
661 mPrivate->MaxNic = NicInfo->NicIndex;
662 }
663 }
664
665 //
666 // Record the NIC info in private structure.
667 //
668 NicInfo = AllocateZeroPool (sizeof (ISCSI_NIC_INFO));
669 if (NicInfo == NULL) {
670 return EFI_OUT_OF_RESOURCES;
671 }
672
673 CopyMem (&NicInfo->PermanentAddress, MacAddr.Addr, HwAddressSize);
674 NicInfo->HwAddressSize = (UINT32)HwAddressSize;
675 NicInfo->VlanId = VlanId;
676 NicInfo->NicIndex = (UINT8)(mPrivate->MaxNic + 1);
677 mPrivate->MaxNic = NicInfo->NicIndex;
678
679 //
680 // Set IPv6 available flag.
681 //
682 Status = IScsiCheckIpv6Support (Controller, Image, &NicInfo->Ipv6Available);
683 if (EFI_ERROR (Status)) {
684 //
685 // Fail to get the data whether UNDI supports IPv6.
686 // Set default value to TRUE.
687 //
688 NicInfo->Ipv6Available = TRUE;
689 }
690
691 //
692 // Get the PCI location.
693 //
694 IScsiGetNICPciLocation (
695 Controller,
696 &NicInfo->BusNumber,
697 &NicInfo->DeviceNumber,
698 &NicInfo->FunctionNumber
699 );
700
701 InsertTailList (&mPrivate->NicInfoList, &NicInfo->Link);
702 mPrivate->NicCount++;
703
704 mPrivate->CurrentNic = NicInfo->NicIndex;
705 return EFI_SUCCESS;
706}
707
708/**
709 Delete the recorded NIC info from global structure. Also delete corresponding
710 attempts.
711
712 @param[in] Controller The handle of the controller.
713
714 @retval EFI_SUCCESS The operation is completed.
715 @retval EFI_NOT_FOUND The NIC info to be deleted is not recorded.
716
717**/
718EFI_STATUS
719IScsiRemoveNic (
720 IN EFI_HANDLE Controller
721 )
722{
723 EFI_STATUS Status;
724 ISCSI_NIC_INFO *NicInfo;
725 LIST_ENTRY *Entry;
726 LIST_ENTRY *NextEntry;
727 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptConfigData;
728 ISCSI_NIC_INFO *ThisNic;
729 EFI_MAC_ADDRESS MacAddr;
730 UINTN HwAddressSize;
731 UINT16 VlanId;
732
733 //
734 // Get MAC address of this network device.
735 //
736 Status = NetLibGetMacAddress (Controller, &MacAddr, &HwAddressSize);
737 if (EFI_ERROR (Status)) {
738 return Status;
739 }
740
741 //
742 // Get VLAN ID of this network device.
743 //
744 VlanId = NetLibGetVlanId (Controller);
745
746 //
747 // Check whether the NIC information exists.
748 //
749 ThisNic = NULL;
750
751 NET_LIST_FOR_EACH (Entry, &mPrivate->NicInfoList) {
752 NicInfo = NET_LIST_USER_STRUCT (Entry, ISCSI_NIC_INFO, Link);
753 if ((NicInfo->HwAddressSize == HwAddressSize) &&
754 (CompareMem (&NicInfo->PermanentAddress, MacAddr.Addr, HwAddressSize) == 0) &&
755 (NicInfo->VlanId == VlanId))
756 {
757 ThisNic = NicInfo;
758 break;
759 }
760 }
761
762 if (ThisNic == NULL) {
763 return EFI_NOT_FOUND;
764 }
765
766 mPrivate->CurrentNic = ThisNic->NicIndex;
767
768 RemoveEntryList (&ThisNic->Link);
769 FreePool (ThisNic);
770 mPrivate->NicCount--;
771
772 //
773 // Remove all attempts related to this NIC.
774 //
775 NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, &mPrivate->AttemptConfigs) {
776 AttemptConfigData = NET_LIST_USER_STRUCT (Entry, ISCSI_ATTEMPT_CONFIG_NVDATA, Link);
777 if (AttemptConfigData->NicIndex == mPrivate->CurrentNic) {
778 RemoveEntryList (&AttemptConfigData->Link);
779 mPrivate->AttemptCount--;
780
781 if ((AttemptConfigData->SessionConfigData.Enabled == ISCSI_ENABLED_FOR_MPIO) && (mPrivate->MpioCount > 0)) {
782 if (--mPrivate->MpioCount == 0) {
783 mPrivate->EnableMpio = FALSE;
784 }
785
786 if ((AttemptConfigData->AuthenticationType == ISCSI_AUTH_TYPE_KRB) && (mPrivate->Krb5MpioCount > 0)) {
787 mPrivate->Krb5MpioCount--;
788 }
789 } else if ((AttemptConfigData->SessionConfigData.Enabled == ISCSI_ENABLED) && (mPrivate->SinglePathCount > 0)) {
790 mPrivate->SinglePathCount--;
791
792 if (mPrivate->ValidSinglePathCount > 0) {
793 mPrivate->ValidSinglePathCount--;
794 }
795 }
796
797 FreePool (AttemptConfigData);
798 }
799 }
800
801 return EFI_SUCCESS;
802}
803
804/**
805 Create and initialize the Attempts.
806
807 @param[in] AttemptNum The number of Attempts will be created.
808
809 @retval EFI_SUCCESS The Attempts have been created successfully.
810 @retval Others Failed to create the Attempt.
811
812**/
813EFI_STATUS
814IScsiCreateAttempts (
815 IN UINTN AttemptNum
816 )
817{
818 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptConfigData;
819 ISCSI_SESSION_CONFIG_NVDATA *ConfigData;
820 UINT8 *AttemptConfigOrder;
821 UINTN AttemptConfigOrderSize;
822 UINT8 *AttemptOrderTmp;
823 UINTN TotalNumber;
824 UINT8 Index;
825 EFI_STATUS Status;
826
827 for (Index = 1; Index <= AttemptNum; Index++) {
828 //
829 // Get the initialized attempt order. This is used to essure creating attempts by order.
830 //
831 AttemptConfigOrder = IScsiGetVariableAndSize (
832 L"InitialAttemptOrder",
833 &gIScsiConfigGuid,
834 &AttemptConfigOrderSize
835 );
836 TotalNumber = AttemptConfigOrderSize / sizeof (UINT8);
837 if (TotalNumber == AttemptNum) {
838 Status = EFI_SUCCESS;
839 break;
840 }
841
842 TotalNumber++;
843
844 //
845 // Append the new created attempt to the end.
846 //
847 AttemptOrderTmp = AllocateZeroPool (TotalNumber * sizeof (UINT8));
848 if (AttemptOrderTmp == NULL) {
849 if (AttemptConfigOrder != NULL) {
850 FreePool (AttemptConfigOrder);
851 }
852
853 return EFI_OUT_OF_RESOURCES;
854 }
855
856 if (AttemptConfigOrder != NULL) {
857 CopyMem (AttemptOrderTmp, AttemptConfigOrder, AttemptConfigOrderSize);
858 FreePool (AttemptConfigOrder);
859 }
860
861 AttemptOrderTmp[TotalNumber - 1] = Index;
862 AttemptConfigOrder = AttemptOrderTmp;
863 AttemptConfigOrderSize = TotalNumber * sizeof (UINT8);
864
865 Status = gRT->SetVariable (
866 L"InitialAttemptOrder",
867 &gIScsiConfigGuid,
868 EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_NON_VOLATILE,
869 AttemptConfigOrderSize,
870 AttemptConfigOrder
871 );
872 FreePool (AttemptConfigOrder);
873 if (EFI_ERROR (Status)) {
874 DEBUG ((
875 DEBUG_ERROR,
876 "%a: Failed to set 'InitialAttemptOrder' with Guid (%g): "
877 "%r\n",
878 __FUNCTION__,
879 &gIScsiConfigGuid,
880 Status
881 ));
882 return Status;
883 }
884
885 //
886 // Create new Attempt
887 //
888 AttemptConfigData = AllocateZeroPool (sizeof (ISCSI_ATTEMPT_CONFIG_NVDATA));
889 if (AttemptConfigData == NULL) {
890 return EFI_OUT_OF_RESOURCES;
891 }
892
893 ConfigData = &AttemptConfigData->SessionConfigData;
894 ConfigData->TargetPort = ISCSI_WELL_KNOWN_PORT;
895 ConfigData->ConnectTimeout = CONNECT_DEFAULT_TIMEOUT;
896 ConfigData->ConnectRetryCount = CONNECT_MIN_RETRY;
897
898 AttemptConfigData->AuthenticationType = ISCSI_AUTH_TYPE_CHAP;
899 AttemptConfigData->AuthConfigData.CHAP.CHAPType = ISCSI_CHAP_UNI;
900 //
901 // Configure the Attempt index and set variable.
902 //
903 AttemptConfigData->AttemptConfigIndex = Index;
904
905 //
906 // Set the attempt name according to the order.
907 //
908 UnicodeSPrint (
909 mPrivate->PortString,
910 (UINTN)ISCSI_NAME_IFR_MAX_SIZE,
911 L"Attempt %d",
912 (UINTN)AttemptConfigData->AttemptConfigIndex
913 );
914 UnicodeStrToAsciiStrS (mPrivate->PortString, AttemptConfigData->AttemptName, ATTEMPT_NAME_SIZE);
915
916 Status = gRT->SetVariable (
917 mPrivate->PortString,
918 &gEfiIScsiInitiatorNameProtocolGuid,
919 ISCSI_CONFIG_VAR_ATTR,
920 sizeof (ISCSI_ATTEMPT_CONFIG_NVDATA),
921 AttemptConfigData
922 );
923 FreePool (AttemptConfigData);
924 if (EFI_ERROR (Status)) {
925 DEBUG ((
926 DEBUG_ERROR,
927 "%a: Failed to set variable (mPrivate->PortString) with Guid (%g): "
928 "%r\n",
929 __FUNCTION__,
930 &gEfiIScsiInitiatorNameProtocolGuid,
931 Status
932 ));
933 return Status;
934 }
935 }
936
937 return EFI_SUCCESS;
938}
939
940/**
941 Create the iSCSI configuration Keywords for each attempt. You can find the keywords
942 defined in the "x-UEFI-ns" namespace (http://www.uefi.org/confignamespace).
943
944 @param[in] KeywordNum The number Sets of Keywords will be created.
945
946 @retval EFI_SUCCESS The operation is completed.
947 @retval Others Failed to create the Keywords.
948
949**/
950EFI_STATUS
951IScsiCreateKeywords (
952 IN UINTN KeywordNum
953 )
954{
955 VOID *StartOpCodeHandle;
956 EFI_IFR_GUID_LABEL *StartLabel;
957 VOID *EndOpCodeHandle;
958 EFI_IFR_GUID_LABEL *EndLabel;
959 UINTN Index;
960 EFI_STRING_ID StringToken;
961 CHAR16 StringId[64];
962 CHAR16 KeywordId[32];
963 EFI_STATUS Status;
964
965 Status = IScsiCreateOpCode (
966 KEYWORD_ENTRY_LABEL,
967 &StartOpCodeHandle,
968 &StartLabel,
969 &EndOpCodeHandle,
970 &EndLabel
971 );
972 if (EFI_ERROR (Status)) {
973 return EFI_OUT_OF_RESOURCES;
974 }
975
976 for (Index = 1; Index <= KeywordNum; Index++) {
977 //
978 // Create iSCSIAttemptName Keyword.
979 //
980 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_ATTEMPTT_NAME_PROMPT%d", Index);
981 StringToken = HiiSetString (
982 mCallbackInfo->RegisteredHandle,
983 0,
984 StringId,
985 NULL
986 );
987 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIAttemptName:%d", Index);
988 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
989 HiiCreateStringOpCode (
990 StartOpCodeHandle,
991 (EFI_QUESTION_ID)(ATTEMPT_ATTEMPT_NAME_QUESTION_ID + (Index - 1)),
992 CONFIGURATION_VARSTORE_ID,
993 (UINT16)(ATTEMPT_ATTEMPT_NAME_VAR_OFFSET + ATTEMPT_NAME_SIZE * (Index - 1) * sizeof (CHAR16)),
994 StringToken,
995 StringToken,
996 EFI_IFR_FLAG_READ_ONLY,
997 0,
998 0,
999 ATTEMPT_NAME_SIZE,
1000 NULL
1001 );
1002
1003 //
1004 // Create iSCSIBootEnable Keyword.
1005 //
1006 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_MODE_PROMPT%d", Index);
1007 StringToken = HiiSetString (
1008 mCallbackInfo->RegisteredHandle,
1009 0,
1010 StringId,
1011 NULL
1012 );
1013 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIBootEnable:%d", Index);
1014 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1015 HiiCreateNumericOpCode (
1016 StartOpCodeHandle,
1017 (EFI_QUESTION_ID)(ATTEMPT_BOOTENABLE_QUESTION_ID + (Index - 1)),
1018 CONFIGURATION_VARSTORE_ID,
1019 (UINT16)(ATTEMPT_BOOTENABLE_VAR_OFFSET + (Index - 1)),
1020 StringToken,
1021 StringToken,
1022 0,
1023 EFI_IFR_NUMERIC_SIZE_1,
1024 0,
1025 2,
1026 0,
1027 NULL
1028 );
1029
1030 //
1031 // Create iSCSIIpAddressType Keyword.
1032 //
1033 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_IP_MODE_PROMPT%d", Index);
1034 StringToken = HiiSetString (
1035 mCallbackInfo->RegisteredHandle,
1036 0,
1037 StringId,
1038 NULL
1039 );
1040 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIIpAddressType:%d", Index);
1041 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1042 HiiCreateNumericOpCode (
1043 StartOpCodeHandle,
1044 (EFI_QUESTION_ID)(ATTEMPT_ADDRESS_TYPE_QUESTION_ID + (Index - 1)),
1045 CONFIGURATION_VARSTORE_ID,
1046 (UINT16)(ATTEMPT_ADDRESS_TYPE_VAR_OFFSET + (Index - 1)),
1047 StringToken,
1048 StringToken,
1049 0,
1050 EFI_IFR_NUMERIC_SIZE_1,
1051 0,
1052 2,
1053 0,
1054 NULL
1055 );
1056
1057 //
1058 // Create iSCSIConnectRetry Keyword.
1059 //
1060 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_CONNECT_RETRY_PROMPT%d", Index);
1061 StringToken = HiiSetString (
1062 mCallbackInfo->RegisteredHandle,
1063 0,
1064 StringId,
1065 NULL
1066 );
1067 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIConnectRetry:%d", Index);
1068 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1069 HiiCreateNumericOpCode (
1070 StartOpCodeHandle,
1071 (EFI_QUESTION_ID)(ATTEMPT_CONNECT_RETRY_QUESTION_ID + (Index - 1)),
1072 CONFIGURATION_VARSTORE_ID,
1073 (UINT16)(ATTEMPT_CONNECT_RETRY_VAR_OFFSET + (Index - 1)),
1074 StringToken,
1075 StringToken,
1076 0,
1077 EFI_IFR_NUMERIC_SIZE_1,
1078 0,
1079 16,
1080 0,
1081 NULL
1082 );
1083
1084 //
1085 // Create iSCSIConnectTimeout Keyword.
1086 //
1087 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_CONNECT_TIMEOUT_PROMPT%d", Index);
1088 StringToken = HiiSetString (
1089 mCallbackInfo->RegisteredHandle,
1090 0,
1091 StringId,
1092 NULL
1093 );
1094 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIConnectTimeout:%d", Index);
1095 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1096 HiiCreateNumericOpCode (
1097 StartOpCodeHandle,
1098 (EFI_QUESTION_ID)(ATTEMPT_CONNECT_TIMEOUT_QUESTION_ID + (Index - 1)),
1099 CONFIGURATION_VARSTORE_ID,
1100 (UINT16)(ATTEMPT_CONNECT_TIMEOUT_VAR_OFFSET + 2 * (Index - 1)),
1101 StringToken,
1102 StringToken,
1103 0,
1104 EFI_IFR_NUMERIC_SIZE_2,
1105 CONNECT_MIN_TIMEOUT,
1106 CONNECT_MAX_TIMEOUT,
1107 0,
1108 NULL
1109 );
1110
1111 //
1112 // Create ISID Keyword.
1113 //
1114 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_ISID_PROMPT%d", Index);
1115 StringToken = HiiSetString (
1116 mCallbackInfo->RegisteredHandle,
1117 0,
1118 StringId,
1119 NULL
1120 );
1121 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIISID:%d", Index);
1122 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1123 HiiCreateStringOpCode (
1124 StartOpCodeHandle,
1125 (EFI_QUESTION_ID)(ATTEMPT_ISID_QUESTION_ID + (Index - 1)),
1126 CONFIGURATION_VARSTORE_ID,
1127 (UINT16)(ATTEMPT_ISID_VAR_OFFSET + sizeof (KEYWORD_STR) * (Index - 1)),
1128 StringToken,
1129 STRING_TOKEN (STR_ISCSI_ISID_HELP),
1130 0,
1131 0,
1132 ISID_CONFIGURABLE_MIN_LEN,
1133 ISID_CONFIGURABLE_STORAGE,
1134 NULL
1135 );
1136
1137 //
1138 // Create iSCSIInitiatorInfoViaDHCP Keyword.
1139 //
1140 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_INITIATOR_VIA_DHCP_PROMPT%d", Index);
1141 StringToken = HiiSetString (
1142 mCallbackInfo->RegisteredHandle,
1143 0,
1144 StringId,
1145 NULL
1146 );
1147 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIInitiatorInfoViaDHCP:%d", Index);
1148 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1149 HiiCreateNumericOpCode (
1150 StartOpCodeHandle,
1151 (EFI_QUESTION_ID)(ATTEMPT_INITIATOR_VIA_DHCP_QUESTION_ID + (Index - 1)),
1152 CONFIGURATION_VARSTORE_ID,
1153 (UINT16)(ATTEMPT_INITIATOR_VIA_DHCP_VAR_OFFSET + (Index - 1)),
1154 StringToken,
1155 StringToken,
1156 0,
1157 0,
1158 0,
1159 1,
1160 0,
1161 NULL
1162 );
1163
1164 //
1165 // Create iSCSIInitiatorIpAddress Keyword.
1166 //
1167 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_INITIATOR_IP_ADDRESS_PROMPT%d", Index);
1168 StringToken = HiiSetString (
1169 mCallbackInfo->RegisteredHandle,
1170 0,
1171 StringId,
1172 NULL
1173 );
1174 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIInitiatorIpAddress:%d", Index);
1175 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1176 HiiCreateStringOpCode (
1177 StartOpCodeHandle,
1178 (EFI_QUESTION_ID)(ATTEMPT_INITIATOR_IP_ADDRESS_QUESTION_ID + (Index - 1)),
1179 CONFIGURATION_VARSTORE_ID,
1180 (UINT16)(ATTEMPT_INITIATOR_IP_ADDRESS_VAR_OFFSET + sizeof (KEYWORD_STR) * (Index - 1)),
1181 StringToken,
1182 StringToken,
1183 0,
1184 0,
1185 IP4_MIN_SIZE,
1186 IP4_STR_MAX_SIZE,
1187 NULL
1188 );
1189
1190 //
1191 // Create iSCSIInitiatorNetmask Keyword.
1192 //
1193 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_INITIATOR_NET_MASK_PROMPT%d", Index);
1194 StringToken = HiiSetString (
1195 mCallbackInfo->RegisteredHandle,
1196 0,
1197 StringId,
1198 NULL
1199 );
1200 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIInitiatorNetmask:%d", Index);
1201 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1202 HiiCreateStringOpCode (
1203 StartOpCodeHandle,
1204 (EFI_QUESTION_ID)(ATTEMPT_INITIATOR_NET_MASK_QUESTION_ID + (Index - 1)),
1205 CONFIGURATION_VARSTORE_ID,
1206 (UINT16)(ATTEMPT_INITIATOR_NET_MASK_VAR_OFFSET + sizeof (KEYWORD_STR) * (Index - 1)),
1207 StringToken,
1208 StringToken,
1209 0,
1210 0,
1211 IP4_MIN_SIZE,
1212 IP4_STR_MAX_SIZE,
1213 NULL
1214 );
1215
1216 //
1217 // Create iSCSIInitiatorGateway Keyword.
1218 //
1219 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_INITIATOR_GATE_PROMPT%d", Index);
1220 StringToken = HiiSetString (
1221 mCallbackInfo->RegisteredHandle,
1222 0,
1223 StringId,
1224 NULL
1225 );
1226 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIInitiatorGateway:%d", Index);
1227 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1228 HiiCreateStringOpCode (
1229 StartOpCodeHandle,
1230 (EFI_QUESTION_ID)(ATTEMPT_INITIATOR_GATE_WAY_QUESTION_ID + (Index - 1)),
1231 CONFIGURATION_VARSTORE_ID,
1232 (UINT16)(ATTEMPT_INITIATOR_GATE_WAY_VAR_OFFSET + sizeof (KEYWORD_STR) * (Index - 1)),
1233 StringToken,
1234 StringToken,
1235 0,
1236 0,
1237 IP4_MIN_SIZE,
1238 IP4_STR_MAX_SIZE,
1239 NULL
1240 );
1241
1242 //
1243 // Create iSCSITargetInfoViaDHCP Keyword.
1244 //
1245 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_TARGET_VIA_DHCP_PROMPT%d", Index);
1246 StringToken = HiiSetString (
1247 mCallbackInfo->RegisteredHandle,
1248 0,
1249 StringId,
1250 NULL
1251 );
1252 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSITargetInfoViaDHCP:%d", Index);
1253 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1254 HiiCreateNumericOpCode (
1255 StartOpCodeHandle,
1256 (EFI_QUESTION_ID)(ATTEMPT_TARGET_VIA_DHCP_QUESTION_ID + (Index - 1)),
1257 CONFIGURATION_VARSTORE_ID,
1258 (UINT16)(ATTEMPT_TARGET_VIA_DHCP_VAR_OFFSET + (Index - 1)),
1259 StringToken,
1260 StringToken,
1261 0,
1262 0,
1263 0,
1264 1,
1265 0,
1266 NULL
1267 );
1268
1269 //
1270 // Create iSCSITargetTcpPort Keyword.
1271 //
1272 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_TARGET_TCP_PORT_PROMPT%d", Index);
1273 StringToken = HiiSetString (
1274 mCallbackInfo->RegisteredHandle,
1275 0,
1276 StringId,
1277 NULL
1278 );
1279 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSITargetTcpPort:%d", Index);
1280 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1281 HiiCreateNumericOpCode (
1282 StartOpCodeHandle,
1283 (EFI_QUESTION_ID)(ATTEMPT_TARGET_TCP_PORT_QUESTION_ID + (Index - 1)),
1284 CONFIGURATION_VARSTORE_ID,
1285 (UINT16)(ATTEMPT_TARGET_TCP_PORT_VAR_OFFSET + 2 * (Index - 1)),
1286 StringToken,
1287 StringToken,
1288 0,
1289 EFI_IFR_NUMERIC_SIZE_2,
1290 TARGET_PORT_MIN_NUM,
1291 TARGET_PORT_MAX_NUM,
1292 0,
1293 NULL
1294 );
1295
1296 //
1297 // Create iSCSITargetName Keyword.
1298 //
1299 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_TARGET_NAME_PROMPT%d", Index);
1300 StringToken = HiiSetString (
1301 mCallbackInfo->RegisteredHandle,
1302 0,
1303 StringId,
1304 NULL
1305 );
1306 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSITargetName:%d", Index);
1307 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1308 HiiCreateStringOpCode (
1309 StartOpCodeHandle,
1310 (EFI_QUESTION_ID)(ATTEMPT_TARGET_NAME_QUESTION_ID + (Index - 1)),
1311 CONFIGURATION_VARSTORE_ID,
1312 (UINT16)(ATTEMPT_TARGET_NAME_VAR_OFFSET + sizeof (KEYWORD_STR) * (Index - 1)),
1313 StringToken,
1314 StringToken,
1315 0,
1316 0,
1317 ISCSI_NAME_IFR_MIN_SIZE,
1318 ISCSI_NAME_IFR_MAX_SIZE,
1319 NULL
1320 );
1321
1322 //
1323 // Create iSCSITargetIpAddress Keyword.
1324 //
1325 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_TARGET_IP_ADDRESS_PROMPT%d", Index);
1326 StringToken = HiiSetString (
1327 mCallbackInfo->RegisteredHandle,
1328 0,
1329 StringId,
1330 NULL
1331 );
1332 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSITargetIpAddress:%d", Index);
1333 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1334 HiiCreateStringOpCode (
1335 StartOpCodeHandle,
1336 (EFI_QUESTION_ID)(ATTEMPT_TARGET_IP_ADDRESS_QUESTION_ID + (Index - 1)),
1337 CONFIGURATION_VARSTORE_ID,
1338 (UINT16)(ATTEMPT_TARGET_IP_ADDRESS_VAR_OFFSET + sizeof (KEYWORD_STR) * (Index - 1)),
1339 StringToken,
1340 StringToken,
1341 0,
1342 0,
1343 IP_MIN_SIZE,
1344 IP_STR_MAX_SIZE,
1345 NULL
1346 );
1347
1348 //
1349 // Create iSCSILUN Keyword.
1350 //
1351 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_LUN_PROMPT%d", Index);
1352 StringToken = HiiSetString (
1353 mCallbackInfo->RegisteredHandle,
1354 0,
1355 StringId,
1356 NULL
1357 );
1358 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSILUN:%d", Index);
1359 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1360 HiiCreateStringOpCode (
1361 StartOpCodeHandle,
1362 (EFI_QUESTION_ID)(ATTEMPT_LUN_QUESTION_ID + (Index - 1)),
1363 CONFIGURATION_VARSTORE_ID,
1364 (UINT16)(ATTEMPT_LUN_VAR_OFFSET + sizeof (KEYWORD_STR) * (Index - 1)),
1365 StringToken,
1366 StringToken,
1367 0,
1368 0,
1369 LUN_MIN_SIZE,
1370 LUN_MAX_SIZE,
1371 NULL
1372 );
1373
1374 //
1375 // Create iSCSIAuthenticationMethod Keyword.
1376 //
1377 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_AUTHENTICATION_METHOD_PROMPT%d", Index);
1378 StringToken = HiiSetString (
1379 mCallbackInfo->RegisteredHandle,
1380 0,
1381 StringId,
1382 NULL
1383 );
1384 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIAuthenticationMethod:%d", Index);
1385 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1386 HiiCreateNumericOpCode (
1387 StartOpCodeHandle,
1388 (EFI_QUESTION_ID)(ATTEMPT_AUTHENTICATION_METHOD_QUESTION_ID + (Index - 1)),
1389 CONFIGURATION_VARSTORE_ID,
1390 (UINT16)(ATTEMPT_AUTHENTICATION_METHOD_VAR_OFFSET + (Index - 1)),
1391 StringToken,
1392 StringToken,
1393 0,
1394 0,
1395 0,
1396 1,
1397 0,
1398 NULL
1399 );
1400
1401 //
1402 // Create iSCSIChapType Keyword.
1403 //
1404 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_CHARTYPE_PROMPT%d", Index);
1405 StringToken = HiiSetString (
1406 mCallbackInfo->RegisteredHandle,
1407 0,
1408 StringId,
1409 NULL
1410 );
1411 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIChapType:%d", Index);
1412 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1413 HiiCreateNumericOpCode (
1414 StartOpCodeHandle,
1415 (EFI_QUESTION_ID)(ATTEMPT_CHARTYPE_QUESTION_ID + (Index - 1)),
1416 CONFIGURATION_VARSTORE_ID,
1417 (UINT16)(ATTEMPT_CHARTYPE_VAR_OFFSET + (Index - 1)),
1418 StringToken,
1419 StringToken,
1420 0,
1421 0,
1422 0,
1423 1,
1424 0,
1425 NULL
1426 );
1427
1428 //
1429 // Create iSCSIChapUsername Keyword.
1430 //
1431 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_CHAR_USER_NAME_PROMPT%d", Index);
1432 StringToken = HiiSetString (
1433 mCallbackInfo->RegisteredHandle,
1434 0,
1435 StringId,
1436 NULL
1437 );
1438 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIChapUsername:%d", Index);
1439 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1440 HiiCreateStringOpCode (
1441 StartOpCodeHandle,
1442 (EFI_QUESTION_ID)(ATTEMPT_CHAR_USER_NAME_QUESTION_ID + (Index - 1)),
1443 CONFIGURATION_VARSTORE_ID,
1444 (UINT16)(ATTEMPT_CHAR_USER_NAME_VAR_OFFSET + sizeof (KEYWORD_STR) * (Index - 1)),
1445 StringToken,
1446 StringToken,
1447 0,
1448 0,
1449 0,
1450 ISCSI_CHAP_NAME_MAX_LEN,
1451 NULL
1452 );
1453
1454 //
1455 // Create iSCSIChapSecret Keyword.
1456 //
1457 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_CHAR_SECRET_PROMPT%d", Index);
1458 StringToken = HiiSetString (
1459 mCallbackInfo->RegisteredHandle,
1460 0,
1461 StringId,
1462 NULL
1463 );
1464 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIChapSecret:%d", Index);
1465 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1466 HiiCreateStringOpCode (
1467 StartOpCodeHandle,
1468 (EFI_QUESTION_ID)(ATTEMPT_CHAR_SECRET_QUESTION_ID + (Index - 1)),
1469 CONFIGURATION_VARSTORE_ID,
1470 (UINT16)(ATTEMPT_CHAR_SECRET_VAR_OFFSET + sizeof (KEYWORD_STR) * (Index - 1)),
1471 StringToken,
1472 StringToken,
1473 0,
1474 0,
1475 ISCSI_CHAP_SECRET_MIN_LEN,
1476 ISCSI_CHAP_SECRET_MAX_LEN,
1477 NULL
1478 );
1479
1480 //
1481 // Create iSCSIReverseChapUsername Keyword.
1482 //
1483 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_CHAR_REVERSE_USER_NAME_PROMPT%d", Index);
1484 StringToken = HiiSetString (
1485 mCallbackInfo->RegisteredHandle,
1486 0,
1487 StringId,
1488 NULL
1489 );
1490 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIReverseChapUsername:%d", Index);
1491 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1492 HiiCreateStringOpCode (
1493 StartOpCodeHandle,
1494 (EFI_QUESTION_ID)(ATTEMPT_CHAR_REVERSE_USER_NAME_QUESTION_ID + (Index - 1)),
1495 CONFIGURATION_VARSTORE_ID,
1496 (UINT16)(ATTEMPT_CHAR_REVERSE_USER_NAME_VAR_OFFSET + sizeof (KEYWORD_STR) * (Index - 1)),
1497 StringToken,
1498 StringToken,
1499 0,
1500 0,
1501 0,
1502 ISCSI_CHAP_NAME_MAX_LEN,
1503 NULL
1504 );
1505
1506 //
1507 // Create iSCSIReverseChapSecret Keyword.
1508 //
1509 UnicodeSPrint (StringId, sizeof (StringId), L"STR_ISCSI_CHAR_REVERSE_SECRET_PROMPT%d", Index);
1510 StringToken = HiiSetString (
1511 mCallbackInfo->RegisteredHandle,
1512 0,
1513 StringId,
1514 NULL
1515 );
1516 UnicodeSPrint (KeywordId, sizeof (KeywordId), L"iSCSIReverseChapSecret:%d", Index);
1517 HiiSetString (mCallbackInfo->RegisteredHandle, StringToken, KeywordId, "x-UEFI-ns");
1518 HiiCreateStringOpCode (
1519 StartOpCodeHandle,
1520 (EFI_QUESTION_ID)(ATTEMPT_CHAR_REVERSE_SECRET_QUESTION_ID + (Index - 1)),
1521 CONFIGURATION_VARSTORE_ID,
1522 (UINT16)(ATTEMPT_CHAR_REVERSE_SECRET_VAR_OFFSET + sizeof (KEYWORD_STR) * (Index - 1)),
1523 StringToken,
1524 StringToken,
1525 0,
1526 0,
1527 ISCSI_CHAP_SECRET_MIN_LEN,
1528 ISCSI_CHAP_SECRET_MAX_LEN,
1529 NULL
1530 );
1531 }
1532
1533 Status = HiiUpdateForm (
1534 mCallbackInfo->RegisteredHandle, // HII handle
1535 &gIScsiConfigGuid, // Formset GUID
1536 FORMID_ATTEMPT_FORM, // Form ID
1537 StartOpCodeHandle, // Label for where to insert opcodes
1538 EndOpCodeHandle // Replace data
1539 );
1540
1541 HiiFreeOpCodeHandle (StartOpCodeHandle);
1542 HiiFreeOpCodeHandle (EndOpCodeHandle);
1543
1544 return Status;
1545}
1546
1547/**
1548
1549 Free the attempt configure data variable.
1550
1551**/
1552VOID
1553IScsiCleanAttemptVariable (
1554 IN VOID
1555 )
1556{
1557 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptConfigData;
1558 UINT8 *AttemptConfigOrder;
1559 UINTN AttemptConfigOrderSize;
1560 UINTN Index;
1561
1562 //
1563 // Get the initialized attempt order.
1564 //
1565 AttemptConfigOrder = IScsiGetVariableAndSize (
1566 L"InitialAttemptOrder",
1567 &gIScsiConfigGuid,
1568 &AttemptConfigOrderSize
1569 );
1570 if ((AttemptConfigOrder == NULL) || (AttemptConfigOrderSize == 0)) {
1571 return;
1572 }
1573
1574 for (Index = 1; Index < AttemptConfigOrderSize / sizeof (UINT8); Index++) {
1575 UnicodeSPrint (
1576 mPrivate->PortString,
1577 (UINTN)ISCSI_NAME_IFR_MAX_SIZE,
1578 L"Attempt %d",
1579 Index
1580 );
1581
1582 GetVariable2 (
1583 mPrivate->PortString,
1584 &gEfiIScsiInitiatorNameProtocolGuid,
1585 (VOID **)&AttemptConfigData,
1586 NULL
1587 );
1588
1589 if (AttemptConfigData != NULL) {
1590 gRT->SetVariable (
1591 mPrivate->PortString,
1592 &gEfiIScsiInitiatorNameProtocolGuid,
1593 0,
1594 0,
1595 NULL
1596 );
1597 }
1598 }
1599
1600 return;
1601}
1602
1603/**
1604 Get the recorded NIC info from global structure by the Index.
1605
1606 @param[in] NicIndex The index indicates the position of NIC info.
1607
1608 @return Pointer to the NIC info, or NULL if not found.
1609
1610**/
1611ISCSI_NIC_INFO *
1612IScsiGetNicInfoByIndex (
1613 IN UINT8 NicIndex
1614 )
1615{
1616 LIST_ENTRY *Entry;
1617 ISCSI_NIC_INFO *NicInfo;
1618
1619 NET_LIST_FOR_EACH (Entry, &mPrivate->NicInfoList) {
1620 NicInfo = NET_LIST_USER_STRUCT (Entry, ISCSI_NIC_INFO, Link);
1621 if (NicInfo->NicIndex == NicIndex) {
1622 return NicInfo;
1623 }
1624 }
1625
1626 return NULL;
1627}
1628
1629/**
1630 Get the NIC's PCI location and return it according to the composited
1631 format defined in iSCSI Boot Firmware Table.
1632
1633 @param[in] Controller The handle of the controller.
1634 @param[out] Bus The bus number.
1635 @param[out] Device The device number.
1636 @param[out] Function The function number.
1637
1638 @return The composited representation of the NIC PCI location.
1639
1640**/
1641UINT16
1642IScsiGetNICPciLocation (
1643 IN EFI_HANDLE Controller,
1644 OUT UINTN *Bus,
1645 OUT UINTN *Device,
1646 OUT UINTN *Function
1647 )
1648{
1649 EFI_STATUS Status;
1650 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
1651 EFI_HANDLE PciIoHandle;
1652 EFI_PCI_IO_PROTOCOL *PciIo;
1653 UINTN Segment;
1654
1655 Status = gBS->HandleProtocol (
1656 Controller,
1657 &gEfiDevicePathProtocolGuid,
1658 (VOID **)&DevicePath
1659 );
1660 if (EFI_ERROR (Status)) {
1661 return 0;
1662 }
1663
1664 Status = gBS->LocateDevicePath (
1665 &gEfiPciIoProtocolGuid,
1666 &DevicePath,
1667 &PciIoHandle
1668 );
1669 if (EFI_ERROR (Status)) {
1670 return 0;
1671 }
1672
1673 Status = gBS->HandleProtocol (PciIoHandle, &gEfiPciIoProtocolGuid, (VOID **)&PciIo);
1674 if (EFI_ERROR (Status)) {
1675 return 0;
1676 }
1677
1678 Status = PciIo->GetLocation (PciIo, &Segment, Bus, Device, Function);
1679 if (EFI_ERROR (Status)) {
1680 return 0;
1681 }
1682
1683 return (UINT16)((*Bus << 8) | (*Device << 3) | *Function);
1684}
1685
1686/**
1687 Read the EFI variable (VendorGuid/Name) and return a dynamically allocated
1688 buffer, and the size of the buffer. If failure, return NULL.
1689
1690 @param[in] Name String part of EFI variable name.
1691 @param[in] VendorGuid GUID part of EFI variable name.
1692 @param[out] VariableSize Returns the size of the EFI variable that was read.
1693
1694 @return Dynamically allocated memory that contains a copy of the EFI variable.
1695 @return Caller is responsible freeing the buffer.
1696 @retval NULL Variable was not read.
1697
1698**/
1699VOID *
1700IScsiGetVariableAndSize (
1701 IN CHAR16 *Name,
1702 IN EFI_GUID *VendorGuid,
1703 OUT UINTN *VariableSize
1704 )
1705{
1706 EFI_STATUS Status;
1707 UINTN BufferSize;
1708 VOID *Buffer;
1709
1710 Buffer = NULL;
1711
1712 //
1713 // Pass in a zero size buffer to find the required buffer size.
1714 //
1715 BufferSize = 0;
1716 Status = gRT->GetVariable (Name, VendorGuid, NULL, &BufferSize, Buffer);
1717 if (Status == EFI_BUFFER_TOO_SMALL) {
1718 //
1719 // Allocate the buffer to return
1720 //
1721 Buffer = AllocateZeroPool (BufferSize);
1722 if (Buffer == NULL) {
1723 return NULL;
1724 }
1725
1726 //
1727 // Read variable into the allocated buffer.
1728 //
1729 Status = gRT->GetVariable (Name, VendorGuid, NULL, &BufferSize, Buffer);
1730 if (EFI_ERROR (Status)) {
1731 BufferSize = 0;
1732 }
1733 }
1734
1735 *VariableSize = BufferSize;
1736 return Buffer;
1737}
1738
1739/**
1740 Create the iSCSI driver data.
1741
1742 @param[in] Image The handle of the driver image.
1743 @param[in] Controller The handle of the controller.
1744
1745 @return The iSCSI driver data created.
1746 @retval NULL Other errors as indicated.
1747
1748**/
1749ISCSI_DRIVER_DATA *
1750IScsiCreateDriverData (
1751 IN EFI_HANDLE Image,
1752 IN EFI_HANDLE Controller
1753 )
1754{
1755 ISCSI_DRIVER_DATA *Private;
1756 EFI_STATUS Status;
1757
1758 Private = AllocateZeroPool (sizeof (ISCSI_DRIVER_DATA));
1759 if (Private == NULL) {
1760 return NULL;
1761 }
1762
1763 Private->Signature = ISCSI_DRIVER_DATA_SIGNATURE;
1764 Private->Image = Image;
1765 Private->Controller = Controller;
1766 Private->Session = NULL;
1767
1768 //
1769 // Create an event to be signaled when the BS to RT transition is triggerd so
1770 // as to abort the iSCSI session.
1771 //
1772 Status = gBS->CreateEventEx (
1773 EVT_NOTIFY_SIGNAL,
1774 TPL_CALLBACK,
1775 IScsiOnExitBootService,
1776 Private,
1777 &gEfiEventExitBootServicesGuid,
1778 &Private->ExitBootServiceEvent
1779 );
1780 if (EFI_ERROR (Status)) {
1781 FreePool (Private);
1782 return NULL;
1783 }
1784
1785 Private->ExtScsiPassThruHandle = NULL;
1786 CopyMem (&Private->IScsiExtScsiPassThru, &gIScsiExtScsiPassThruProtocolTemplate, sizeof (EFI_EXT_SCSI_PASS_THRU_PROTOCOL));
1787
1788 //
1789 // 0 is designated to the TargetId, so use another value for the AdapterId.
1790 //
1791 Private->ExtScsiPassThruMode.AdapterId = 2;
1792 Private->ExtScsiPassThruMode.Attributes = EFI_EXT_SCSI_PASS_THRU_ATTRIBUTES_PHYSICAL | EFI_EXT_SCSI_PASS_THRU_ATTRIBUTES_LOGICAL;
1793 Private->ExtScsiPassThruMode.IoAlign = 4;
1794 Private->IScsiExtScsiPassThru.Mode = &Private->ExtScsiPassThruMode;
1795
1796 return Private;
1797}
1798
1799/**
1800 Clean the iSCSI driver data.
1801
1802 @param[in] Private The iSCSI driver data.
1803
1804 @retval EFI_SUCCESS The clean operation is successful.
1805 @retval Others Other errors as indicated.
1806
1807**/
1808EFI_STATUS
1809IScsiCleanDriverData (
1810 IN ISCSI_DRIVER_DATA *Private
1811 )
1812{
1813 EFI_STATUS Status;
1814
1815 Status = EFI_SUCCESS;
1816
1817 if (Private->DevicePath != NULL) {
1818 Status = gBS->UninstallProtocolInterface (
1819 Private->ExtScsiPassThruHandle,
1820 &gEfiDevicePathProtocolGuid,
1821 Private->DevicePath
1822 );
1823 if (EFI_ERROR (Status)) {
1824 goto EXIT;
1825 }
1826
1827 FreePool (Private->DevicePath);
1828 }
1829
1830 if (Private->ExtScsiPassThruHandle != NULL) {
1831 Status = gBS->UninstallProtocolInterface (
1832 Private->ExtScsiPassThruHandle,
1833 &gEfiExtScsiPassThruProtocolGuid,
1834 &Private->IScsiExtScsiPassThru
1835 );
1836 if (!EFI_ERROR (Status)) {
1837 mPrivate->OneSessionEstablished = FALSE;
1838 }
1839 }
1840
1841EXIT:
1842 if (Private->ExitBootServiceEvent != NULL) {
1843 gBS->CloseEvent (Private->ExitBootServiceEvent);
1844 }
1845
1846 mCallbackInfo->Current = NULL;
1847
1848 FreePool (Private);
1849 return Status;
1850}
1851
1852/**
1853 Check wheather the Controller handle is configured to use DHCP protocol.
1854
1855 @param[in] Controller The handle of the controller.
1856 @param[in] IpVersion IP_VERSION_4 or IP_VERSION_6.
1857
1858 @retval TRUE The handle of the controller need the Dhcp protocol.
1859 @retval FALSE The handle of the controller does not need the Dhcp protocol.
1860
1861**/
1862BOOLEAN
1863IScsiDhcpIsConfigured (
1864 IN EFI_HANDLE Controller,
1865 IN UINT8 IpVersion
1866 )
1867{
1868 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptTmp;
1869 UINT8 *AttemptConfigOrder;
1870 UINTN AttemptConfigOrderSize;
1871 UINTN Index;
1872 EFI_STATUS Status;
1873 EFI_MAC_ADDRESS MacAddr;
1874 UINTN HwAddressSize;
1875 UINT16 VlanId;
1876 CHAR16 MacString[ISCSI_MAX_MAC_STRING_LEN];
1877 CHAR16 AttemptMacString[ISCSI_MAX_MAC_STRING_LEN];
1878 CHAR16 AttemptName[ISCSI_NAME_IFR_MAX_SIZE];
1879
1880 AttemptConfigOrder = IScsiGetVariableAndSize (
1881 L"AttemptOrder",
1882 &gIScsiConfigGuid,
1883 &AttemptConfigOrderSize
1884 );
1885 if ((AttemptConfigOrder == NULL) || (AttemptConfigOrderSize == 0)) {
1886 return FALSE;
1887 }
1888
1889 //
1890 // Get MAC address of this network device.
1891 //
1892 Status = NetLibGetMacAddress (Controller, &MacAddr, &HwAddressSize);
1893 if (EFI_ERROR (Status)) {
1894 return FALSE;
1895 }
1896
1897 //
1898 // Get VLAN ID of this network device.
1899 //
1900 VlanId = NetLibGetVlanId (Controller);
1901 IScsiMacAddrToStr (&MacAddr, (UINT32)HwAddressSize, VlanId, MacString);
1902
1903 for (Index = 0; Index < AttemptConfigOrderSize / sizeof (UINT8); Index++) {
1904 UnicodeSPrint (
1905 AttemptName,
1906 (UINTN)128,
1907 L"Attempt %d",
1908 (UINTN)AttemptConfigOrder[Index]
1909 );
1910 Status = GetVariable2 (
1911 AttemptName,
1912 &gEfiIScsiInitiatorNameProtocolGuid,
1913 (VOID **)&AttemptTmp,
1914 NULL
1915 );
1916 if ((AttemptTmp == NULL) || EFI_ERROR (Status)) {
1917 continue;
1918 }
1919
1920 ASSERT (AttemptConfigOrder[Index] == AttemptTmp->AttemptConfigIndex);
1921
1922 if (AttemptTmp->SessionConfigData.Enabled == ISCSI_DISABLED) {
1923 FreePool (AttemptTmp);
1924 continue;
1925 }
1926
1927 if ((AttemptTmp->SessionConfigData.IpMode != IP_MODE_AUTOCONFIG) &&
1928 (AttemptTmp->SessionConfigData.IpMode != ((IpVersion == IP_VERSION_4) ? IP_MODE_IP4 : IP_MODE_IP6)))
1929 {
1930 FreePool (AttemptTmp);
1931 continue;
1932 }
1933
1934 AsciiStrToUnicodeStrS (AttemptTmp->MacString, AttemptMacString, sizeof (AttemptMacString) / sizeof (AttemptMacString[0]));
1935
1936 if ((AttemptTmp->Actived == ISCSI_ACTIVE_DISABLED) || StrCmp (MacString, AttemptMacString)) {
1937 continue;
1938 }
1939
1940 if ((AttemptTmp->SessionConfigData.IpMode == IP_MODE_AUTOCONFIG) ||
1941 (AttemptTmp->SessionConfigData.InitiatorInfoFromDhcp == TRUE) ||
1942 (AttemptTmp->SessionConfigData.TargetInfoFromDhcp == TRUE))
1943 {
1944 FreePool (AttemptTmp);
1945 FreePool (AttemptConfigOrder);
1946 return TRUE;
1947 }
1948
1949 FreePool (AttemptTmp);
1950 }
1951
1952 FreePool (AttemptConfigOrder);
1953 return FALSE;
1954}
1955
1956/**
1957 Check whether the Controller handle is configured to use DNS protocol.
1958
1959 @param[in] Controller The handle of the controller.
1960
1961 @retval TRUE The handle of the controller need the Dns protocol.
1962 @retval FALSE The handle of the controller does not need the Dns protocol.
1963
1964**/
1965BOOLEAN
1966IScsiDnsIsConfigured (
1967 IN EFI_HANDLE Controller
1968 )
1969{
1970 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptTmp;
1971 UINT8 *AttemptConfigOrder;
1972 UINTN AttemptConfigOrderSize;
1973 UINTN Index;
1974 EFI_STATUS Status;
1975 EFI_MAC_ADDRESS MacAddr;
1976 UINTN HwAddressSize;
1977 UINT16 VlanId;
1978 CHAR16 AttemptMacString[ISCSI_MAX_MAC_STRING_LEN];
1979 CHAR16 MacString[ISCSI_MAX_MAC_STRING_LEN];
1980 CHAR16 AttemptName[ISCSI_NAME_IFR_MAX_SIZE];
1981
1982 AttemptConfigOrder = IScsiGetVariableAndSize (
1983 L"AttemptOrder",
1984 &gIScsiConfigGuid,
1985 &AttemptConfigOrderSize
1986 );
1987 if ((AttemptConfigOrder == NULL) || (AttemptConfigOrderSize == 0)) {
1988 return FALSE;
1989 }
1990
1991 //
1992 // Get MAC address of this network device.
1993 //
1994 Status = NetLibGetMacAddress (Controller, &MacAddr, &HwAddressSize);
1995 if (EFI_ERROR (Status)) {
1996 return FALSE;
1997 }
1998
1999 //
2000 // Get VLAN ID of this network device.
2001 //
2002 VlanId = NetLibGetVlanId (Controller);
2003 IScsiMacAddrToStr (&MacAddr, (UINT32)HwAddressSize, VlanId, MacString);
2004
2005 for (Index = 0; Index < AttemptConfigOrderSize / sizeof (UINT8); Index++) {
2006 UnicodeSPrint (
2007 AttemptName,
2008 (UINTN)128,
2009 L"Attempt %d",
2010 (UINTN)AttemptConfigOrder[Index]
2011 );
2012
2013 Status = GetVariable2 (
2014 AttemptName,
2015 &gEfiIScsiInitiatorNameProtocolGuid,
2016 (VOID **)&AttemptTmp,
2017 NULL
2018 );
2019 if ((AttemptTmp == NULL) || EFI_ERROR (Status)) {
2020 continue;
2021 }
2022
2023 ASSERT (AttemptConfigOrder[Index] == AttemptTmp->AttemptConfigIndex);
2024
2025 AsciiStrToUnicodeStrS (AttemptTmp->MacString, AttemptMacString, sizeof (AttemptMacString) / sizeof (AttemptMacString[0]));
2026
2027 if ((AttemptTmp->SessionConfigData.Enabled == ISCSI_DISABLED) || StrCmp (MacString, AttemptMacString)) {
2028 FreePool (AttemptTmp);
2029 continue;
2030 }
2031
2032 if (AttemptTmp->SessionConfigData.DnsMode || AttemptTmp->SessionConfigData.TargetInfoFromDhcp) {
2033 FreePool (AttemptTmp);
2034 FreePool (AttemptConfigOrder);
2035 return TRUE;
2036 } else {
2037 FreePool (AttemptTmp);
2038 continue;
2039 }
2040 }
2041
2042 FreePool (AttemptConfigOrder);
2043 return FALSE;
2044}
2045
2046/**
2047 Get the various configuration data.
2048
2049 @param[in] Private The iSCSI driver data.
2050
2051 @retval EFI_SUCCESS The configuration data is retrieved.
2052 @retval EFI_NOT_FOUND This iSCSI driver is not configured yet.
2053 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory.
2054
2055**/
2056EFI_STATUS
2057IScsiGetConfigData (
2058 IN ISCSI_DRIVER_DATA *Private
2059 )
2060{
2061 EFI_STATUS Status;
2062 CHAR16 MacString[ISCSI_MAX_MAC_STRING_LEN];
2063 CHAR16 AttemptMacString[ISCSI_MAX_MAC_STRING_LEN];
2064 UINTN Index;
2065 ISCSI_NIC_INFO *NicInfo;
2066 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptConfigData;
2067 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptTmp;
2068 UINT8 *AttemptConfigOrder;
2069 UINTN AttemptConfigOrderSize;
2070 CHAR16 IScsiMode[64];
2071 CHAR16 IpMode[64];
2072
2073 //
2074 // There should be at least one attempt configured.
2075 //
2076 AttemptConfigOrder = IScsiGetVariableAndSize (
2077 L"AttemptOrder",
2078 &gIScsiConfigGuid,
2079 &AttemptConfigOrderSize
2080 );
2081 if ((AttemptConfigOrder == NULL) || (AttemptConfigOrderSize == 0)) {
2082 return EFI_NOT_FOUND;
2083 }
2084
2085 //
2086 // Get the iSCSI Initiator Name.
2087 //
2088 mPrivate->InitiatorNameLength = ISCSI_NAME_MAX_SIZE;
2089 Status = gIScsiInitiatorName.Get (
2090 &gIScsiInitiatorName,
2091 &mPrivate->InitiatorNameLength,
2092 mPrivate->InitiatorName
2093 );
2094 if (EFI_ERROR (Status)) {
2095 return Status;
2096 }
2097
2098 //
2099 // Get the normal configuration.
2100 //
2101 for (Index = 0; Index < AttemptConfigOrderSize / sizeof (UINT8); Index++) {
2102 //
2103 // Check whether the attempt exists in AttemptConfig.
2104 //
2105 AttemptTmp = IScsiConfigGetAttemptByConfigIndex (AttemptConfigOrder[Index]);
2106 if ((AttemptTmp != NULL) && (AttemptTmp->SessionConfigData.Enabled == ISCSI_DISABLED)) {
2107 continue;
2108 } else if ((AttemptTmp != NULL) && (AttemptTmp->SessionConfigData.Enabled != ISCSI_DISABLED)) {
2109 //
2110 // Check the autoconfig path to see whether it should be retried.
2111 //
2112 if ((AttemptTmp->SessionConfigData.IpMode == IP_MODE_AUTOCONFIG) &&
2113 !AttemptTmp->AutoConfigureSuccess)
2114 {
2115 if (mPrivate->Ipv6Flag &&
2116 (AttemptTmp->AutoConfigureMode == IP_MODE_AUTOCONFIG_IP6))
2117 {
2118 //
2119 // Autoconfigure for IP6 already attempted but failed. Do not try again.
2120 //
2121 continue;
2122 } else if (!mPrivate->Ipv6Flag &&
2123 (AttemptTmp->AutoConfigureMode == IP_MODE_AUTOCONFIG_IP4))
2124 {
2125 //
2126 // Autoconfigure for IP4 already attempted but failed. Do not try again.
2127 //
2128 continue;
2129 } else {
2130 //
2131 // Try another approach for this autoconfigure path.
2132 //
2133 AttemptTmp->AutoConfigureMode =
2134 (UINT8)(mPrivate->Ipv6Flag ? IP_MODE_AUTOCONFIG_IP6 : IP_MODE_AUTOCONFIG_IP4);
2135 AttemptTmp->SessionConfigData.InitiatorInfoFromDhcp = TRUE;
2136 AttemptTmp->SessionConfigData.TargetInfoFromDhcp = TRUE;
2137 AttemptTmp->DhcpSuccess = FALSE;
2138
2139 //
2140 // Get some information from the dhcp server.
2141 //
2142 if (!mPrivate->Ipv6Flag) {
2143 Status = IScsiDoDhcp (Private->Image, Private->Controller, AttemptTmp);
2144 if (!EFI_ERROR (Status)) {
2145 AttemptTmp->DhcpSuccess = TRUE;
2146 }
2147 } else {
2148 Status = IScsiDoDhcp6 (Private->Image, Private->Controller, AttemptTmp);
2149 if (!EFI_ERROR (Status)) {
2150 AttemptTmp->DhcpSuccess = TRUE;
2151 }
2152 }
2153
2154 //
2155 // Refresh the state of this attempt to NVR.
2156 //
2157 UnicodeSPrint (
2158 mPrivate->PortString,
2159 (UINTN)ISCSI_NAME_IFR_MAX_SIZE,
2160 L"Attempt %d",
2161 (UINTN)AttemptTmp->AttemptConfigIndex
2162 );
2163
2164 gRT->SetVariable (
2165 mPrivate->PortString,
2166 &gEfiIScsiInitiatorNameProtocolGuid,
2167 ISCSI_CONFIG_VAR_ATTR,
2168 sizeof (ISCSI_ATTEMPT_CONFIG_NVDATA),
2169 AttemptTmp
2170 );
2171
2172 continue;
2173 }
2174 } else if (AttemptTmp->SessionConfigData.InitiatorInfoFromDhcp &&
2175 !AttemptTmp->ValidPath &&
2176 (AttemptTmp->NicIndex == mPrivate->CurrentNic))
2177 {
2178 //
2179 // If the attempt associates with the current NIC, we can
2180 // get DHCP information for already added, but failed, attempt.
2181 //
2182 AttemptTmp->DhcpSuccess = FALSE;
2183 if (!mPrivate->Ipv6Flag && (AttemptTmp->SessionConfigData.IpMode == IP_MODE_IP4)) {
2184 Status = IScsiDoDhcp (Private->Image, Private->Controller, AttemptTmp);
2185 if (!EFI_ERROR (Status)) {
2186 AttemptTmp->DhcpSuccess = TRUE;
2187 }
2188 } else if (mPrivate->Ipv6Flag && (AttemptTmp->SessionConfigData.IpMode == IP_MODE_IP6)) {
2189 Status = IScsiDoDhcp6 (Private->Image, Private->Controller, AttemptTmp);
2190 if (!EFI_ERROR (Status)) {
2191 AttemptTmp->DhcpSuccess = TRUE;
2192 }
2193 }
2194
2195 //
2196 // Refresh the state of this attempt to NVR.
2197 //
2198 UnicodeSPrint (
2199 mPrivate->PortString,
2200 (UINTN)ISCSI_NAME_IFR_MAX_SIZE,
2201 L"Attempt %d",
2202 (UINTN)AttemptTmp->AttemptConfigIndex
2203 );
2204
2205 gRT->SetVariable (
2206 mPrivate->PortString,
2207 &gEfiIScsiInitiatorNameProtocolGuid,
2208 ISCSI_CONFIG_VAR_ATTR,
2209 sizeof (ISCSI_ATTEMPT_CONFIG_NVDATA),
2210 AttemptTmp
2211 );
2212
2213 continue;
2214 } else {
2215 continue;
2216 }
2217 }
2218
2219 //
2220 // This attempt does not exist in AttemptConfig. Try to add a new one.
2221 //
2222
2223 NicInfo = IScsiGetNicInfoByIndex (mPrivate->CurrentNic);
2224 ASSERT (NicInfo != NULL);
2225 IScsiMacAddrToStr (&NicInfo->PermanentAddress, NicInfo->HwAddressSize, NicInfo->VlanId, MacString);
2226 UnicodeSPrint (
2227 mPrivate->PortString,
2228 (UINTN)ISCSI_NAME_IFR_MAX_SIZE,
2229 L"Attempt %d",
2230 (UINTN)AttemptConfigOrder[Index]
2231 );
2232
2233 GetVariable2 (
2234 mPrivate->PortString,
2235 &gEfiIScsiInitiatorNameProtocolGuid,
2236 (VOID **)&AttemptConfigData,
2237 NULL
2238 );
2239 AsciiStrToUnicodeStrS (AttemptConfigData->MacString, AttemptMacString, sizeof (AttemptMacString) / sizeof (AttemptMacString[0]));
2240
2241 if ((AttemptConfigData == NULL) || (AttemptConfigData->Actived == ISCSI_ACTIVE_DISABLED) ||
2242 StrCmp (MacString, AttemptMacString))
2243 {
2244 continue;
2245 }
2246
2247 ASSERT (AttemptConfigOrder[Index] == AttemptConfigData->AttemptConfigIndex);
2248
2249 AttemptConfigData->NicIndex = NicInfo->NicIndex;
2250 AttemptConfigData->DhcpSuccess = FALSE;
2251 AttemptConfigData->ValidiBFTPath = (BOOLEAN)(mPrivate->EnableMpio ? TRUE : FALSE);
2252 AttemptConfigData->ValidPath = FALSE;
2253
2254 if (AttemptConfigData->SessionConfigData.IpMode == IP_MODE_AUTOCONFIG) {
2255 AttemptConfigData->SessionConfigData.InitiatorInfoFromDhcp = TRUE;
2256 AttemptConfigData->SessionConfigData.TargetInfoFromDhcp = TRUE;
2257
2258 AttemptConfigData->AutoConfigureMode =
2259 (UINT8)(mPrivate->Ipv6Flag ? IP_MODE_AUTOCONFIG_IP6 : IP_MODE_AUTOCONFIG_IP4);
2260 AttemptConfigData->AutoConfigureSuccess = FALSE;
2261 }
2262
2263 //
2264 // Get some information from dhcp server.
2265 //
2266 if ((AttemptConfigData->SessionConfigData.Enabled != ISCSI_DISABLED) &&
2267 AttemptConfigData->SessionConfigData.InitiatorInfoFromDhcp)
2268 {
2269 if (!mPrivate->Ipv6Flag &&
2270 ((AttemptConfigData->SessionConfigData.IpMode == IP_MODE_IP4) ||
2271 (AttemptConfigData->AutoConfigureMode == IP_MODE_AUTOCONFIG_IP4)))
2272 {
2273 Status = IScsiDoDhcp (Private->Image, Private->Controller, AttemptConfigData);
2274 if (!EFI_ERROR (Status)) {
2275 AttemptConfigData->DhcpSuccess = TRUE;
2276 }
2277 } else if (mPrivate->Ipv6Flag &&
2278 ((AttemptConfigData->SessionConfigData.IpMode == IP_MODE_IP6) ||
2279 (AttemptConfigData->AutoConfigureMode == IP_MODE_AUTOCONFIG_IP6)))
2280 {
2281 Status = IScsiDoDhcp6 (Private->Image, Private->Controller, AttemptConfigData);
2282 if (!EFI_ERROR (Status)) {
2283 AttemptConfigData->DhcpSuccess = TRUE;
2284 }
2285 }
2286
2287 //
2288 // Refresh the state of this attempt to NVR.
2289 //
2290 UnicodeSPrint (
2291 mPrivate->PortString,
2292 (UINTN)ISCSI_NAME_IFR_MAX_SIZE,
2293 L"Attempt %d",
2294 (UINTN)AttemptConfigData->AttemptConfigIndex
2295 );
2296
2297 gRT->SetVariable (
2298 mPrivate->PortString,
2299 &gEfiIScsiInitiatorNameProtocolGuid,
2300 ISCSI_CONFIG_VAR_ATTR,
2301 sizeof (ISCSI_ATTEMPT_CONFIG_NVDATA),
2302 AttemptConfigData
2303 );
2304 }
2305
2306 //
2307 // Update Attempt Help Info.
2308 //
2309
2310 if (AttemptConfigData->SessionConfigData.Enabled == ISCSI_DISABLED) {
2311 UnicodeSPrint (IScsiMode, 64, L"Disabled");
2312 } else if (AttemptConfigData->SessionConfigData.Enabled == ISCSI_ENABLED) {
2313 UnicodeSPrint (IScsiMode, 64, L"Enabled");
2314 } else if (AttemptConfigData->SessionConfigData.Enabled == ISCSI_ENABLED_FOR_MPIO) {
2315 UnicodeSPrint (IScsiMode, 64, L"Enabled for MPIO");
2316 }
2317
2318 if (AttemptConfigData->SessionConfigData.IpMode == IP_MODE_IP4) {
2319 UnicodeSPrint (IpMode, 64, L"IP4");
2320 } else if (AttemptConfigData->SessionConfigData.IpMode == IP_MODE_IP6) {
2321 UnicodeSPrint (IpMode, 64, L"IP6");
2322 } else if (AttemptConfigData->SessionConfigData.IpMode == IP_MODE_AUTOCONFIG) {
2323 UnicodeSPrint (IpMode, 64, L"Autoconfigure");
2324 }
2325
2326 UnicodeSPrint (
2327 mPrivate->PortString,
2328 (UINTN)ISCSI_NAME_IFR_MAX_SIZE,
2329 L"MAC: %s, PFA: Bus %d | Dev %d | Func %d, iSCSI mode: %s, IP version: %s",
2330 MacString,
2331 NicInfo->BusNumber,
2332 NicInfo->DeviceNumber,
2333 NicInfo->FunctionNumber,
2334 IScsiMode,
2335 IpMode
2336 );
2337
2338 AttemptConfigData->AttemptTitleHelpToken = HiiSetString (
2339 mCallbackInfo->RegisteredHandle,
2340 0,
2341 mPrivate->PortString,
2342 NULL
2343 );
2344 if (AttemptConfigData->AttemptTitleHelpToken == 0) {
2345 return EFI_OUT_OF_RESOURCES;
2346 }
2347
2348 //
2349 // Record the attempt in global link list.
2350 //
2351 InsertTailList (&mPrivate->AttemptConfigs, &AttemptConfigData->Link);
2352 mPrivate->AttemptCount++;
2353
2354 if (AttemptConfigData->SessionConfigData.Enabled == ISCSI_ENABLED_FOR_MPIO) {
2355 mPrivate->MpioCount++;
2356 mPrivate->EnableMpio = TRUE;
2357
2358 if (AttemptConfigData->AuthenticationType == ISCSI_AUTH_TYPE_KRB) {
2359 mPrivate->Krb5MpioCount++;
2360 }
2361 } else if (AttemptConfigData->SessionConfigData.Enabled == ISCSI_ENABLED) {
2362 mPrivate->SinglePathCount++;
2363 }
2364 }
2365
2366 //
2367 // Reorder the AttemptConfig by the configured order.
2368 //
2369 for (Index = 0; Index < AttemptConfigOrderSize / sizeof (UINT8); Index++) {
2370 AttemptConfigData = IScsiConfigGetAttemptByConfigIndex (AttemptConfigOrder[Index]);
2371 if (AttemptConfigData == NULL) {
2372 continue;
2373 }
2374
2375 RemoveEntryList (&AttemptConfigData->Link);
2376 InsertTailList (&mPrivate->AttemptConfigs, &AttemptConfigData->Link);
2377 }
2378
2379 //
2380 // Update the Main Form.
2381 //
2382 IScsiConfigUpdateAttempt ();
2383
2384 FreePool (AttemptConfigOrder);
2385
2386 //
2387 // There should be at least one attempt configuration.
2388 //
2389 if (!mPrivate->EnableMpio) {
2390 if (mPrivate->SinglePathCount == 0) {
2391 return EFI_NOT_FOUND;
2392 }
2393
2394 mPrivate->ValidSinglePathCount = mPrivate->SinglePathCount;
2395 }
2396
2397 return EFI_SUCCESS;
2398}
2399
2400/**
2401 Get the device path of the iSCSI tcp connection and update it.
2402
2403 @param Session The iSCSI session.
2404
2405 @return The updated device path.
2406 @retval NULL Other errors as indicated.
2407
2408**/
2409EFI_DEVICE_PATH_PROTOCOL *
2410IScsiGetTcpConnDevicePath (
2411 IN ISCSI_SESSION *Session
2412 )
2413{
2414 ISCSI_CONNECTION *Conn;
2415 EFI_DEVICE_PATH_PROTOCOL *DevicePath;
2416 EFI_STATUS Status;
2417 EFI_DEV_PATH *DPathNode;
2418 UINTN PathLen;
2419
2420 if (Session->State != SESSION_STATE_LOGGED_IN) {
2421 return NULL;
2422 }
2423
2424 Conn = NET_LIST_USER_STRUCT_S (
2425 Session->Conns.ForwardLink,
2426 ISCSI_CONNECTION,
2427 Link,
2428 ISCSI_CONNECTION_SIGNATURE
2429 );
2430
2431 Status = gBS->HandleProtocol (
2432 Conn->TcpIo.Handle,
2433 &gEfiDevicePathProtocolGuid,
2434 (VOID **)&DevicePath
2435 );
2436 if (EFI_ERROR (Status)) {
2437 return NULL;
2438 }
2439
2440 //
2441 // Duplicate it.
2442 //
2443 DevicePath = DuplicateDevicePath (DevicePath);
2444 if (DevicePath == NULL) {
2445 return NULL;
2446 }
2447
2448 DPathNode = (EFI_DEV_PATH *)DevicePath;
2449
2450 while (!IsDevicePathEnd (&DPathNode->DevPath)) {
2451 if (DevicePathType (&DPathNode->DevPath) == MESSAGING_DEVICE_PATH) {
2452 if (!Conn->Ipv6Flag && (DevicePathSubType (&DPathNode->DevPath) == MSG_IPv4_DP)) {
2453 DPathNode->Ipv4.LocalPort = 0;
2454
2455 DPathNode->Ipv4.StaticIpAddress =
2456 (BOOLEAN)(!Session->ConfigData->SessionConfigData.InitiatorInfoFromDhcp);
2457
2458 //
2459 // Add a judgement here to support previous versions of IPv4_DEVICE_PATH.
2460 // In previous versions of IPv4_DEVICE_PATH, GatewayIpAddress and SubnetMask
2461 // do not exist.
2462 // In new version of IPv4_DEVICE_PATH, structure length is 27.
2463 //
2464
2465 PathLen = DevicePathNodeLength (&DPathNode->Ipv4);
2466
2467 if (PathLen == IP4_NODE_LEN_NEW_VERSIONS) {
2468 IP4_COPY_ADDRESS (
2469 &DPathNode->Ipv4.GatewayIpAddress,
2470 &Session->ConfigData->SessionConfigData.Gateway
2471 );
2472
2473 IP4_COPY_ADDRESS (
2474 &DPathNode->Ipv4.SubnetMask,
2475 &Session->ConfigData->SessionConfigData.SubnetMask
2476 );
2477 }
2478
2479 break;
2480 } else if (Conn->Ipv6Flag && (DevicePathSubType (&DPathNode->DevPath) == MSG_IPv6_DP)) {
2481 DPathNode->Ipv6.LocalPort = 0;
2482
2483 //
2484 // Add a judgement here to support previous versions of IPv6_DEVICE_PATH.
2485 // In previous versions of IPv6_DEVICE_PATH, IpAddressOrigin, PrefixLength
2486 // and GatewayIpAddress do not exist.
2487 // In new version of IPv6_DEVICE_PATH, structure length is 60, while in
2488 // old versions, the length is 43.
2489 //
2490
2491 PathLen = DevicePathNodeLength (&DPathNode->Ipv6);
2492
2493 if (PathLen == IP6_NODE_LEN_NEW_VERSIONS ) {
2494 DPathNode->Ipv6.IpAddressOrigin = 0;
2495 DPathNode->Ipv6.PrefixLength = IP6_PREFIX_LENGTH;
2496 ZeroMem (&DPathNode->Ipv6.GatewayIpAddress, sizeof (EFI_IPv6_ADDRESS));
2497 } else if (PathLen == IP6_NODE_LEN_OLD_VERSIONS) {
2498 //
2499 // StaticIPAddress is a field in old versions of IPv6_DEVICE_PATH, while ignored in new
2500 // version. Set StaticIPAddress through its' offset in old IPv6_DEVICE_PATH.
2501 //
2502 *((UINT8 *)(&DPathNode->Ipv6) + IP6_OLD_IPADDRESS_OFFSET) =
2503 (BOOLEAN)(!Session->ConfigData->SessionConfigData.InitiatorInfoFromDhcp);
2504 }
2505
2506 break;
2507 }
2508 }
2509
2510 DPathNode = (EFI_DEV_PATH *)NextDevicePathNode (&DPathNode->DevPath);
2511 }
2512
2513 return DevicePath;
2514}
2515
2516/**
2517 Abort the session when the transition from BS to RT is initiated.
2518
2519 @param[in] Event The event signaled.
2520 @param[in] Context The iSCSI driver data.
2521
2522**/
2523VOID
2524EFIAPI
2525IScsiOnExitBootService (
2526 IN EFI_EVENT Event,
2527 IN VOID *Context
2528 )
2529{
2530 ISCSI_DRIVER_DATA *Private;
2531
2532 Private = (ISCSI_DRIVER_DATA *)Context;
2533
2534 gBS->CloseEvent (Private->ExitBootServiceEvent);
2535 Private->ExitBootServiceEvent = NULL;
2536
2537 if (Private->Session != NULL) {
2538 IScsiSessionAbort (Private->Session);
2539 }
2540}
2541
2542/**
2543 Tests whether a controller handle is being managed by IScsi driver.
2544
2545 This function tests whether the driver specified by DriverBindingHandle is
2546 currently managing the controller specified by ControllerHandle. This test
2547 is performed by evaluating if the protocol specified by ProtocolGuid is
2548 present on ControllerHandle and is was opened by DriverBindingHandle and Nic
2549 Device handle with an attribute of EFI_OPEN_PROTOCOL_BY_DRIVER.
2550 If ProtocolGuid is NULL, then ASSERT().
2551
2552 @param ControllerHandle A handle for a controller to test.
2553 @param DriverBindingHandle Specifies the driver binding handle for the
2554 driver.
2555 @param ProtocolGuid Specifies the protocol that the driver specified
2556 by DriverBindingHandle opens in its Start()
2557 function.
2558
2559 @retval EFI_SUCCESS ControllerHandle is managed by the driver
2560 specified by DriverBindingHandle.
2561 @retval EFI_UNSUPPORTED ControllerHandle is not managed by the driver
2562 specified by DriverBindingHandle.
2563
2564**/
2565EFI_STATUS
2566EFIAPI
2567IScsiTestManagedDevice (
2568 IN EFI_HANDLE ControllerHandle,
2569 IN EFI_HANDLE DriverBindingHandle,
2570 IN EFI_GUID *ProtocolGuid
2571 )
2572{
2573 EFI_STATUS Status;
2574 VOID *ManagedInterface;
2575 EFI_HANDLE NicControllerHandle;
2576
2577 ASSERT (ProtocolGuid != NULL);
2578
2579 NicControllerHandle = NetLibGetNicHandle (ControllerHandle, ProtocolGuid);
2580 if (NicControllerHandle == NULL) {
2581 return EFI_UNSUPPORTED;
2582 }
2583
2584 Status = gBS->OpenProtocol (
2585 ControllerHandle,
2586 (EFI_GUID *)ProtocolGuid,
2587 &ManagedInterface,
2588 DriverBindingHandle,
2589 NicControllerHandle,
2590 EFI_OPEN_PROTOCOL_BY_DRIVER
2591 );
2592 if (!EFI_ERROR (Status)) {
2593 gBS->CloseProtocol (
2594 ControllerHandle,
2595 (EFI_GUID *)ProtocolGuid,
2596 DriverBindingHandle,
2597 NicControllerHandle
2598 );
2599 return EFI_UNSUPPORTED;
2600 }
2601
2602 if (Status != EFI_ALREADY_STARTED) {
2603 return EFI_UNSUPPORTED;
2604 }
2605
2606 return EFI_SUCCESS;
2607}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette