1 /** @file 2 The entry point of IScsi driver. 3 4 Copyright (c) 2004 - 2015, Intel Corporation. All rights reserved.<BR> 5 This program and the accompanying materials 6 are licensed and made available under the terms and conditions of the BSD License 7 which accompanies this distribution. The full text of the license may be found at 8 http://opensource.org/licenses/bsd-license.php 9 10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 12 13 **/ 14 15 #include "IScsiImpl.h" 16 17 EFI_DRIVER_BINDING_PROTOCOL gIScsiIp4DriverBinding = { 18 IScsiIp4DriverBindingSupported, 19 IScsiIp4DriverBindingStart, 20 IScsiIp4DriverBindingStop, 21 0xa, 22 NULL, 23 NULL 24 }; 25 26 EFI_DRIVER_BINDING_PROTOCOL gIScsiIp6DriverBinding = { 27 IScsiIp6DriverBindingSupported, 28 IScsiIp6DriverBindingStart, 29 IScsiIp6DriverBindingStop, 30 0xa, 31 NULL, 32 NULL 33 }; 34 35 EFI_GUID gIScsiV4PrivateGuid = ISCSI_V4_PRIVATE_GUID; 36 EFI_GUID gIScsiV6PrivateGuid = ISCSI_V6_PRIVATE_GUID; 37 ISCSI_PRIVATE_DATA *mPrivate = NULL; 38 39 /** 40 Tests to see if this driver supports the RemainingDevicePath. 41 42 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This 43 parameter is ignored by device drivers, and is optional for bus 44 drivers. For bus drivers, if this parameter is not NULL, then 45 the bus driver must determine if the bus controller specified 46 by ControllerHandle and the child controller specified 47 by RemainingDevicePath are both supported by this 48 bus driver. 49 50 @retval EFI_SUCCESS The RemainingDevicePath is supported or NULL. 51 @retval EFI_UNSUPPORTED The device specified by ControllerHandle and 52 RemainingDevicePath is not supported by the driver specified by This. 53 **/ 54 EFI_STATUS 55 IScsiIsDevicePathSupported ( 56 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL 57 ) 58 { 59 EFI_DEVICE_PATH_PROTOCOL *CurrentDevicePath; 60 61 CurrentDevicePath = RemainingDevicePath; 62 if (CurrentDevicePath != NULL) { 63 while (!IsDevicePathEnd (CurrentDevicePath)) { 64 if ((CurrentDevicePath->Type == MESSAGING_DEVICE_PATH) && (CurrentDevicePath->SubType == MSG_ISCSI_DP)) { 65 return EFI_SUCCESS; 66 } 67 68 CurrentDevicePath = NextDevicePathNode (CurrentDevicePath); 69 } 70 71 return EFI_UNSUPPORTED; 72 } 73 74 return EFI_SUCCESS; 75 } 76 77 /** 78 Check whether an iSCSI HBA adapter already installs an AIP instance with 79 network boot policy matching the value specified in PcdIScsiAIPNetworkBootPolicy. 80 If yes, return EFI_SUCCESS. 81 82 @retval EFI_SUCCESS Found an AIP with matching network boot policy. 83 @retval EFI_NOT_FOUND AIP is unavailable or the network boot policy 84 not matched. 85 **/ 86 EFI_STATUS 87 IScsiCheckAip ( 88 ) 89 { 90 UINTN AipHandleCount; 91 EFI_HANDLE *AipHandleBuffer; 92 UINTN AipIndex; 93 EFI_ADAPTER_INFORMATION_PROTOCOL *Aip; 94 EFI_EXT_SCSI_PASS_THRU_PROTOCOL *ExtScsiPassThru; 95 EFI_GUID *InfoTypesBuffer; 96 UINTN InfoTypeBufferCount; 97 UINTN TypeIndex; 98 VOID *InfoBlock; 99 UINTN InfoBlockSize; 100 BOOLEAN Supported; 101 EFI_ADAPTER_INFO_NETWORK_BOOT *NetworkBoot; 102 EFI_STATUS Status; 103 UINT8 NetworkBootPolicy; 104 105 // 106 // Check any AIP instances exist in system. 107 // 108 AipHandleCount = 0; 109 AipHandleBuffer = NULL; 110 Status = gBS->LocateHandleBuffer ( 111 ByProtocol, 112 &gEfiAdapterInformationProtocolGuid, 113 NULL, 114 &AipHandleCount, 115 &AipHandleBuffer 116 ); 117 if (EFI_ERROR (Status) || AipHandleCount == 0) { 118 return EFI_NOT_FOUND; 119 } 120 121 ASSERT (AipHandleBuffer != NULL); 122 123 InfoBlock = NULL; 124 125 for (AipIndex = 0; AipIndex < AipHandleCount; AipIndex++) { 126 Status = gBS->HandleProtocol ( 127 AipHandleBuffer[AipIndex], 128 &gEfiAdapterInformationProtocolGuid, 129 (VOID *) &Aip 130 ); 131 ASSERT_EFI_ERROR (Status); 132 ASSERT (Aip != NULL); 133 134 Status = gBS->HandleProtocol ( 135 AipHandleBuffer[AipIndex], 136 &gEfiExtScsiPassThruProtocolGuid, 137 (VOID *) &ExtScsiPassThru 138 ); 139 if (EFI_ERROR (Status) || ExtScsiPassThru == NULL) { 140 continue; 141 } 142 143 InfoTypesBuffer = NULL; 144 InfoTypeBufferCount = 0; 145 Status = Aip->GetSupportedTypes (Aip, &InfoTypesBuffer, &InfoTypeBufferCount); 146 if (EFI_ERROR (Status) || InfoTypesBuffer == NULL) { 147 continue; 148 } 149 // 150 // Check whether the AIP instance has Network boot information block. 151 // 152 Supported = FALSE; 153 for (TypeIndex = 0; TypeIndex < InfoTypeBufferCount; TypeIndex++) { 154 if (CompareGuid (&InfoTypesBuffer[TypeIndex], &gEfiAdapterInfoNetworkBootGuid)) { 155 Supported = TRUE; 156 break; 157 } 158 } 159 160 FreePool (InfoTypesBuffer); 161 if (!Supported) { 162 continue; 163 } 164 165 // 166 // We now have network boot information block. 167 // 168 InfoBlock = NULL; 169 InfoBlockSize = 0; 170 Status = Aip->GetInformation (Aip, &gEfiAdapterInfoNetworkBootGuid, &InfoBlock, &InfoBlockSize); 171 if (EFI_ERROR (Status) || InfoBlock == NULL) { 172 continue; 173 } 174 175 // 176 // Check whether the network boot policy matches. 177 // 178 NetworkBoot = (EFI_ADAPTER_INFO_NETWORK_BOOT *) InfoBlock; 179 NetworkBootPolicy = PcdGet8 (PcdIScsiAIPNetworkBootPolicy); 180 181 if (NetworkBootPolicy == STOP_UEFI_ISCSI_IF_HBA_INSTALL_AIP) { 182 Status = EFI_SUCCESS; 183 goto Exit; 184 } 185 if (((NetworkBootPolicy & STOP_UEFI_ISCSI_IF_AIP_SUPPORT_IP4) != 0 && 186 !NetworkBoot->iScsiIpv4BootCapablity) || 187 ((NetworkBootPolicy & STOP_UEFI_ISCSI_IF_AIP_SUPPORT_IP6) != 0 && 188 !NetworkBoot->iScsiIpv6BootCapablity) || 189 ((NetworkBootPolicy & STOP_UEFI_ISCSI_IF_AIP_SUPPORT_OFFLOAD) != 0 && 190 !NetworkBoot->OffloadCapability) || 191 ((NetworkBootPolicy & STOP_UEFI_ISCSI_IF_AIP_SUPPORT_MPIO) != 0 && 192 !NetworkBoot->iScsiMpioCapability) || 193 ((NetworkBootPolicy & STOP_UEFI_ISCSI_IF_AIP_CONFIGURED_IP4) != 0 && 194 !NetworkBoot->iScsiIpv4Boot) || 195 ((NetworkBootPolicy & STOP_UEFI_ISCSI_IF_AIP_CONFIGURED_IP6) != 0 && 196 !NetworkBoot->iScsiIpv6Boot)) { 197 FreePool (InfoBlock); 198 continue; 199 } 200 201 Status = EFI_SUCCESS; 202 goto Exit; 203 } 204 205 Status = EFI_NOT_FOUND; 206 207 Exit: 208 if (InfoBlock != NULL) { 209 FreePool (InfoBlock); 210 } 211 if (AipHandleBuffer != NULL) { 212 FreePool (AipHandleBuffer); 213 } 214 return Status; 215 } 216 217 /** 218 Tests to see if this driver supports a given controller. This is the worker function for 219 IScsiIp4(6)DriverBindingSupported. 220 221 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. 222 @param[in] ControllerHandle The handle of the controller to test. This handle 223 must support a protocol interface that supplies 224 an I/O abstraction to the driver. 225 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This 226 parameter is ignored by device drivers, and is optional for bus 227 drivers. For bus drivers, if this parameter is not NULL, then 228 the bus driver must determine if the bus controller specified 229 by ControllerHandle and the child controller specified 230 by RemainingDevicePath are both supported by this 231 bus driver. 232 @param[in] IpVersion IP_VERSION_4 or IP_VERSION_6. 233 234 @retval EFI_SUCCESS The device specified by ControllerHandle and 235 RemainingDevicePath is supported by the driver specified by This. 236 @retval EFI_ALREADY_STARTED The device specified by ControllerHandle and 237 RemainingDevicePath is already being managed by the driver 238 specified by This. 239 @retval EFI_UNSUPPORTED The device specified by ControllerHandle and 240 RemainingDevicePath is not supported by the driver specified by This. 241 **/ 242 EFI_STATUS 243 EFIAPI 244 IScsiSupported ( 245 IN EFI_DRIVER_BINDING_PROTOCOL *This, 246 IN EFI_HANDLE ControllerHandle, 247 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL, 248 IN UINT8 IpVersion 249 ) 250 { 251 EFI_STATUS Status; 252 EFI_GUID *IScsiServiceBindingGuid; 253 EFI_GUID *TcpServiceBindingGuid; 254 EFI_GUID *DhcpServiceBindingGuid; 255 256 if (IpVersion == IP_VERSION_4) { 257 IScsiServiceBindingGuid = &gIScsiV4PrivateGuid; 258 TcpServiceBindingGuid = &gEfiTcp4ServiceBindingProtocolGuid; 259 DhcpServiceBindingGuid = &gEfiDhcp4ServiceBindingProtocolGuid; 260 } else { 261 IScsiServiceBindingGuid = &gIScsiV6PrivateGuid; 262 TcpServiceBindingGuid = &gEfiTcp6ServiceBindingProtocolGuid; 263 DhcpServiceBindingGuid = &gEfiDhcp6ServiceBindingProtocolGuid; 264 } 265 266 Status = gBS->OpenProtocol ( 267 ControllerHandle, 268 IScsiServiceBindingGuid, 269 NULL, 270 This->DriverBindingHandle, 271 ControllerHandle, 272 EFI_OPEN_PROTOCOL_TEST_PROTOCOL 273 ); 274 if (!EFI_ERROR (Status)) { 275 return EFI_ALREADY_STARTED; 276 } 277 278 Status = gBS->OpenProtocol ( 279 ControllerHandle, 280 TcpServiceBindingGuid, 281 NULL, 282 This->DriverBindingHandle, 283 ControllerHandle, 284 EFI_OPEN_PROTOCOL_TEST_PROTOCOL 285 ); 286 if (EFI_ERROR (Status)) { 287 return EFI_UNSUPPORTED; 288 } 289 290 Status = IScsiIsDevicePathSupported (RemainingDevicePath); 291 if (EFI_ERROR (Status)) { 292 return EFI_UNSUPPORTED; 293 } 294 295 if (IScsiDhcpIsConfigured (ControllerHandle, IpVersion)) { 296 Status = gBS->OpenProtocol ( 297 ControllerHandle, 298 DhcpServiceBindingGuid, 299 NULL, 300 This->DriverBindingHandle, 301 ControllerHandle, 302 EFI_OPEN_PROTOCOL_TEST_PROTOCOL 303 ); 304 if (EFI_ERROR (Status)) { 305 return EFI_UNSUPPORTED; 306 } 307 } 308 309 return EFI_SUCCESS; 310 } 311 312 313 /** 314 Start to manage the controller. This is the worker function for 315 IScsiIp4(6)DriverBindingStart. 316 317 @param[in] Image Handle of the image. 318 @param[in] ControllerHandle Handle of the controller. 319 @param[in] IpVersion IP_VERSION_4 or IP_VERSION_6. 320 321 @retval EFI_SUCCES This driver was started. 322 @retval EFI_ALREADY_STARTED This driver is already running on this device. 323 @retval EFI_INVALID_PARAMETER Any input parameter is invalid. 324 @retval EFI_NOT_FOUND There is no sufficient information to establish 325 the iScsi session. 326 @retval EFI_DEVICE_ERROR Failed to get TCP connection device path. 327 328 **/ 329 EFI_STATUS 330 IScsiStart ( 331 IN EFI_HANDLE Image, 332 IN EFI_HANDLE ControllerHandle, 333 IN UINT8 IpVersion 334 ) 335 { 336 EFI_STATUS Status; 337 ISCSI_DRIVER_DATA *Private; 338 LIST_ENTRY *Entry; 339 LIST_ENTRY *NextEntry; 340 ISCSI_ATTEMPT_CONFIG_NVDATA *AttemptConfigData; 341 ISCSI_SESSION *Session; 342 UINT8 Index; 343 EFI_EXT_SCSI_PASS_THRU_PROTOCOL *ExistIScsiExtScsiPassThru; 344 ISCSI_DRIVER_DATA *ExistPrivate; 345 UINT8 *AttemptConfigOrder; 346 UINTN AttemptConfigOrderSize; 347 UINT8 BootSelected; 348 EFI_HANDLE *HandleBuffer; 349 UINTN NumberOfHandles; 350 EFI_DEVICE_PATH_PROTOCOL *DevicePath; 351 EFI_GUID *IScsiPrivateGuid; 352 EFI_GUID *TcpServiceBindingGuid; 353 CHAR16 MacString[ISCSI_MAX_MAC_STRING_LEN]; 354 BOOLEAN NeedUpdate; 355 VOID *Interface; 356 EFI_GUID *ProtocolGuid; 357 UINT8 NetworkBootPolicy; 358 359 // 360 // Test to see if iSCSI driver supports the given controller. 361 // 362 363 if (IpVersion == IP_VERSION_4) { 364 IScsiPrivateGuid = &gIScsiV4PrivateGuid; 365 TcpServiceBindingGuid = &gEfiTcp4ServiceBindingProtocolGuid; 366 ProtocolGuid = &gEfiTcp4ProtocolGuid; 367 } else if (IpVersion == IP_VERSION_6) { 368 IScsiPrivateGuid = &gIScsiV6PrivateGuid; 369 TcpServiceBindingGuid = &gEfiTcp6ServiceBindingProtocolGuid; 370 ProtocolGuid = &gEfiTcp6ProtocolGuid; 371 } else { 372 return EFI_INVALID_PARAMETER; 373 } 374 375 Status = gBS->OpenProtocol ( 376 ControllerHandle, 377 IScsiPrivateGuid, 378 NULL, 379 Image, 380 ControllerHandle, 381 EFI_OPEN_PROTOCOL_TEST_PROTOCOL 382 ); 383 if (!EFI_ERROR (Status)) { 384 return EFI_ALREADY_STARTED; 385 } 386 387 Status = gBS->OpenProtocol ( 388 ControllerHandle, 389 TcpServiceBindingGuid, 390 NULL, 391 Image, 392 ControllerHandle, 393 EFI_OPEN_PROTOCOL_TEST_PROTOCOL 394 ); 395 if (EFI_ERROR (Status)) { 396 return EFI_UNSUPPORTED; 397 } 398 399 NetworkBootPolicy = PcdGet8 (PcdIScsiAIPNetworkBootPolicy); 400 if (NetworkBootPolicy != ALWAYS_USE_UEFI_ISCSI_AND_IGNORE_AIP) { 401 // 402 // Check existing iSCSI AIP. 403 // 404 Status = IScsiCheckAip (); 405 if (!EFI_ERROR (Status)) { 406 // 407 // Find iSCSI AIP with specified network boot policy. return EFI_ABORTED. 408 // 409 return EFI_ABORTED; 410 } 411 } 412 413 // 414 // Record the incoming NIC info. 415 // 416 Status = IScsiAddNic (ControllerHandle); 417 if (EFI_ERROR (Status)) { 418 return Status; 419 } 420 421 // 422 // Create the instance private data. 423 // 424 Private = IScsiCreateDriverData (Image, ControllerHandle); 425 if (Private == NULL) { 426 return EFI_OUT_OF_RESOURCES; 427 } 428 429 // 430 // Create a underlayer child instance, but not need to configure it. Just open ChildHandle 431 // via BY_DRIVER. That is, establishing the relationship between ControllerHandle and ChildHandle. 432 // Therefore, when DisconnectController(), especially VLAN virtual controller handle, 433 // IScsiDriverBindingStop() will be called. 434 // 435 Status = NetLibCreateServiceChild ( 436 ControllerHandle, 437 Image, 438 TcpServiceBindingGuid, 439 &Private->ChildHandle 440 ); 441 442 if (EFI_ERROR (Status)) { 443 goto ON_ERROR; 444 } 445 446 Status = gBS->OpenProtocol ( 447 Private->ChildHandle, /// Default Tcp child 448 ProtocolGuid, 449 &Interface, 450 Image, 451 ControllerHandle, 452 EFI_OPEN_PROTOCOL_BY_DRIVER 453 ); 454 455 if (EFI_ERROR (Status)) { 456 goto ON_ERROR; 457 } 458 459 // 460 // Always install private protocol no matter what happens later. We need to 461 // keep the relationship between ControllerHandle and ChildHandle. 462 // 463 Status = gBS->InstallProtocolInterface ( 464 &ControllerHandle, 465 IScsiPrivateGuid, 466 EFI_NATIVE_INTERFACE, 467 &Private->IScsiIdentifier 468 ); 469 if (EFI_ERROR (Status)) { 470 goto ON_ERROR; 471 } 472 473 if (IpVersion == IP_VERSION_4) { 474 mPrivate->Ipv6Flag = FALSE; 475 } else { 476 mPrivate->Ipv6Flag = TRUE; 477 } 478 479 // 480 // Get the current iSCSI configuration data. 481 // 482 Status = IScsiGetConfigData (Private); 483 if (EFI_ERROR (Status)) { 484 goto ON_ERROR; 485 } 486 487 // 488 // If there is already a successul attempt, check whether this attempt is the 489 // first "enabled for MPIO" attempt. If not, still try the first attempt. 490 // In single path mode, try all attempts. 491 // 492 ExistPrivate = NULL; 493 Status = EFI_NOT_FOUND; 494 495 if (mPrivate->OneSessionEstablished && mPrivate->EnableMpio) { 496 AttemptConfigData = NULL; 497 NET_LIST_FOR_EACH (Entry, &mPrivate->AttemptConfigs) { 498 AttemptConfigData = NET_LIST_USER_STRUCT (Entry, ISCSI_ATTEMPT_CONFIG_NVDATA, Link); 499 if (AttemptConfigData->SessionConfigData.Enabled == ISCSI_ENABLED_FOR_MPIO) { 500 break; 501 } 502 } 503 504 if (AttemptConfigData == NULL) { 505 goto ON_ERROR; 506 } 507 508 if (AttemptConfigData->AttemptConfigIndex == mPrivate->BootSelectedIndex) { 509 goto ON_EXIT; 510 } 511 512 // 513 // Uninstall the original ExtScsiPassThru first. 514 // 515 516 // 517 // Locate all ExtScsiPassThru protocol instances. 518 // 519 Status = gBS->LocateHandleBuffer ( 520 ByProtocol, 521 &gEfiExtScsiPassThruProtocolGuid, 522 NULL, 523 &NumberOfHandles, 524 &HandleBuffer 525 ); 526 if (EFI_ERROR (Status)) { 527 goto ON_ERROR; 528 } 529 530 // 531 // Find ExtScsiPassThru protocol instance produced by this driver. 532 // 533 ExistIScsiExtScsiPassThru = NULL; 534 for (Index = 0; Index < NumberOfHandles && ExistIScsiExtScsiPassThru == NULL; Index++) { 535 Status = gBS->HandleProtocol ( 536 HandleBuffer[Index], 537 &gEfiDevicePathProtocolGuid, 538 (VOID **) &DevicePath 539 ); 540 if (EFI_ERROR (Status)) { 541 continue; 542 } 543 544 while (!IsDevicePathEnd (DevicePath)) { 545 if ((DevicePath->Type == MESSAGING_DEVICE_PATH) && (DevicePath->SubType == MSG_MAC_ADDR_DP)) { 546 // 547 // Get the ExtScsiPassThru protocol instance. 548 // 549 Status = gBS->HandleProtocol ( 550 HandleBuffer[Index], 551 &gEfiExtScsiPassThruProtocolGuid, 552 (VOID **) &ExistIScsiExtScsiPassThru 553 ); 554 ASSERT_EFI_ERROR (Status); 555 break; 556 } 557 558 DevicePath = NextDevicePathNode (DevicePath); 559 } 560 } 561 562 FreePool (HandleBuffer); 563 564 if (ExistIScsiExtScsiPassThru == NULL) { 565 Status = EFI_NOT_FOUND; 566 goto ON_ERROR; 567 } 568 569 ExistPrivate = ISCSI_DRIVER_DATA_FROM_EXT_SCSI_PASS_THRU (ExistIScsiExtScsiPassThru); 570 571 Status = gBS->UninstallProtocolInterface ( 572 ExistPrivate->ExtScsiPassThruHandle, 573 &gEfiExtScsiPassThruProtocolGuid, 574 &ExistPrivate->IScsiExtScsiPassThru 575 ); 576 if (EFI_ERROR (Status)) { 577 goto ON_ERROR; 578 } 579 } 580 581 // 582 // Install the Ext SCSI PASS THRU protocol. 583 // 584 Status = gBS->InstallProtocolInterface ( 585 &Private->ExtScsiPassThruHandle, 586 &gEfiExtScsiPassThruProtocolGuid, 587 EFI_NATIVE_INTERFACE, 588 &Private->IScsiExtScsiPassThru 589 ); 590 if (EFI_ERROR (Status)) { 591 goto ON_ERROR; 592 } 593 594 BootSelected = 0; 595 596 NET_LIST_FOR_EACH_SAFE (Entry, NextEntry, &mPrivate->AttemptConfigs) { 597 AttemptConfigData = NET_LIST_USER_STRUCT (Entry, ISCSI_ATTEMPT_CONFIG_NVDATA, Link); 598 // 599 // Don't process the attempt that does not associate with the current NIC or 600 // this attempt is disabled or established. 601 // 602 if (AttemptConfigData->NicIndex != mPrivate->CurrentNic || 603 AttemptConfigData->SessionConfigData.Enabled == ISCSI_DISABLED || 604 AttemptConfigData->ValidPath) { 605 continue; 606 } 607 608 // 609 // In multipath mode, don't process attempts configured for single path. 610 // In default single path mode, don't process attempts configured for multipath. 611 // 612 if ((mPrivate->EnableMpio && 613 AttemptConfigData->SessionConfigData.Enabled != ISCSI_ENABLED_FOR_MPIO) || 614 (!mPrivate->EnableMpio && 615 AttemptConfigData->SessionConfigData.Enabled != ISCSI_ENABLED)) { 616 continue; 617 } 618 619 // 620 // Don't process the attempt that fails to get the init/target information from DHCP. 621 // 622 if (AttemptConfigData->SessionConfigData.InitiatorInfoFromDhcp && 623 !AttemptConfigData->DhcpSuccess) { 624 if (!mPrivate->EnableMpio && mPrivate->ValidSinglePathCount > 0) { 625 mPrivate->ValidSinglePathCount--; 626 } 627 continue; 628 } 629 630 // 631 // Don't process the autoconfigure path if it is already established. 632 // 633 if (AttemptConfigData->SessionConfigData.IpMode == IP_MODE_AUTOCONFIG && 634 AttemptConfigData->AutoConfigureSuccess) { 635 continue; 636 } 637 638 // 639 // Don't process the attempt if its IP mode is not in the current IP version. 640 // 641 if (!mPrivate->Ipv6Flag) { 642 if (AttemptConfigData->SessionConfigData.IpMode == IP_MODE_IP6) { 643 continue; 644 } 645 if (AttemptConfigData->SessionConfigData.IpMode == IP_MODE_AUTOCONFIG && 646 AttemptConfigData->AutoConfigureMode == IP_MODE_AUTOCONFIG_IP6) { 647 continue; 648 } 649 } else { 650 if (AttemptConfigData->SessionConfigData.IpMode == IP_MODE_IP4) { 651 continue; 652 } 653 if (AttemptConfigData->SessionConfigData.IpMode == IP_MODE_AUTOCONFIG && 654 AttemptConfigData->AutoConfigureMode == IP_MODE_AUTOCONFIG_IP4) { 655 continue; 656 } 657 } 658 659 // 660 // Fill in the Session and init it. 661 // 662 Session = (ISCSI_SESSION *) AllocateZeroPool (sizeof (ISCSI_SESSION)); 663 if (Session == NULL) { 664 Status = EFI_OUT_OF_RESOURCES; 665 goto ON_ERROR; 666 } 667 668 Session->Private = Private; 669 Session->ConfigData = AttemptConfigData; 670 Session->AuthType = AttemptConfigData->AuthenticationType; 671 672 AsciiStrToUnicodeStr (AttemptConfigData->MacString, MacString); 673 UnicodeSPrint ( 674 mPrivate->PortString, 675 (UINTN) ISCSI_NAME_IFR_MAX_SIZE, 676 L"%s%d", 677 MacString, 678 (UINTN) AttemptConfigData->AttemptConfigIndex 679 ); 680 681 if (Session->AuthType == ISCSI_AUTH_TYPE_CHAP) { 682 Session->AuthData.CHAP.AuthConfig = &AttemptConfigData->AuthConfigData.CHAP; 683 } 684 685 IScsiSessionInit (Session, FALSE); 686 687 // 688 // Try to login and create an iSCSI session according to the configuration. 689 // 690 Status = IScsiSessionLogin (Session); 691 if (Status == EFI_MEDIA_CHANGED) { 692 // 693 // The specified target is not available, and the redirection information is 694 // received. Login the session again with the updated target address. 695 // 696 Status = IScsiSessionLogin (Session); 697 } else if (Status == EFI_NOT_READY) { 698 Status = IScsiSessionReLogin (Session); 699 } 700 701 if (EFI_ERROR (Status)) { 702 // 703 // In Single path mode, only the successful attempt will be recorded in iBFT; 704 // in multi-path mode, all the attempt entries in MPIO will be recorded in iBFT. 705 // 706 if (!mPrivate->EnableMpio && mPrivate->ValidSinglePathCount > 0) { 707 mPrivate->ValidSinglePathCount--; 708 } 709 710 FreePool (Session); 711 712 } else { 713 AttemptConfigData->ValidPath = TRUE; 714 715 // 716 // Do not record the attempt in iBFT if it login with KRB5. 717 // TODO: record KRB5 attempt information in the iSCSI device path. 718 // 719 if (Session->AuthType == ISCSI_AUTH_TYPE_KRB) { 720 if (!mPrivate->EnableMpio && mPrivate->ValidSinglePathCount > 0) { 721 mPrivate->ValidSinglePathCount--; 722 } 723 724 AttemptConfigData->ValidiBFTPath = FALSE; 725 } else { 726 AttemptConfigData->ValidiBFTPath = TRUE; 727 } 728 729 // 730 // IScsi session success. Update the attempt state to NVR. 731 // 732 if (AttemptConfigData->SessionConfigData.IpMode == IP_MODE_AUTOCONFIG) { 733 AttemptConfigData->AutoConfigureSuccess = TRUE; 734 } 735 736 gRT->SetVariable ( 737 mPrivate->PortString, 738 &gEfiIScsiInitiatorNameProtocolGuid, 739 ISCSI_CONFIG_VAR_ATTR, 740 sizeof (ISCSI_ATTEMPT_CONFIG_NVDATA), 741 AttemptConfigData 742 ); 743 744 // 745 // Select the first login session. Abort others. 746 // 747 if (Private->Session == NULL) { 748 Private->Session = Session; 749 BootSelected = AttemptConfigData->AttemptConfigIndex; 750 // 751 // Don't validate other attempt in multipath mode if one is success. 752 // 753 if (mPrivate->EnableMpio) { 754 break; 755 } 756 } else { 757 IScsiSessionAbort (Session); 758 FreePool (Session); 759 } 760 } 761 } 762 763 // 764 // All attempts configured for this driver instance are not valid. 765 // 766 if (Private->Session == NULL) { 767 Status = gBS->UninstallProtocolInterface ( 768 Private->ExtScsiPassThruHandle, 769 &gEfiExtScsiPassThruProtocolGuid, 770 &Private->IScsiExtScsiPassThru 771 ); 772 ASSERT_EFI_ERROR (Status); 773 Private->ExtScsiPassThruHandle = NULL; 774 775 // 776 // Reinstall the original ExtScsiPassThru back. 777 // 778 if (mPrivate->OneSessionEstablished && ExistPrivate != NULL) { 779 Status = gBS->InstallProtocolInterface ( 780 &ExistPrivate->ExtScsiPassThruHandle, 781 &gEfiExtScsiPassThruProtocolGuid, 782 EFI_NATIVE_INTERFACE, 783 &ExistPrivate->IScsiExtScsiPassThru 784 ); 785 if (EFI_ERROR (Status)) { 786 goto ON_ERROR; 787 } 788 789 goto ON_EXIT; 790 } 791 792 Status = EFI_NOT_FOUND; 793 794 goto ON_ERROR; 795 } 796 797 NeedUpdate = TRUE; 798 // 799 // More than one attempt successes. 800 // 801 if (Private->Session != NULL && mPrivate->OneSessionEstablished) { 802 803 AttemptConfigOrder = IScsiGetVariableAndSize ( 804 L"AttemptOrder", 805 &gIScsiConfigGuid, 806 &AttemptConfigOrderSize 807 ); 808 if (AttemptConfigOrder == NULL) { 809 goto ON_ERROR; 810 } 811 for (Index = 0; Index < AttemptConfigOrderSize / sizeof (UINT8); Index++) { 812 if (AttemptConfigOrder[Index] == mPrivate->BootSelectedIndex || 813 AttemptConfigOrder[Index] == BootSelected) { 814 break; 815 } 816 } 817 818 if (mPrivate->EnableMpio) { 819 // 820 // Use the attempt in earlier order. Abort the later one in MPIO. 821 // 822 if (AttemptConfigOrder[Index] == mPrivate->BootSelectedIndex) { 823 IScsiSessionAbort (Private->Session); 824 FreePool (Private->Session); 825 Private->Session = NULL; 826 gBS->UninstallProtocolInterface ( 827 Private->ExtScsiPassThruHandle, 828 &gEfiExtScsiPassThruProtocolGuid, 829 &Private->IScsiExtScsiPassThru 830 ); 831 Private->ExtScsiPassThruHandle = NULL; 832 833 // 834 // Reinstall the original ExtScsiPassThru back. 835 // 836 Status = gBS->InstallProtocolInterface ( 837 &ExistPrivate->ExtScsiPassThruHandle, 838 &gEfiExtScsiPassThruProtocolGuid, 839 EFI_NATIVE_INTERFACE, 840 &ExistPrivate->IScsiExtScsiPassThru 841 ); 842 if (EFI_ERROR (Status)) { 843 goto ON_ERROR; 844 } 845 846 goto ON_EXIT; 847 } else { 848 if (AttemptConfigOrder[Index] != BootSelected) { 849 goto ON_ERROR; 850 } 851 mPrivate->BootSelectedIndex = BootSelected; 852 // 853 // Clear the resource in ExistPrivate. 854 // 855 gBS->UninstallProtocolInterface ( 856 ExistPrivate->Controller, 857 IScsiPrivateGuid, 858 &ExistPrivate->IScsiIdentifier 859 ); 860 861 IScsiRemoveNic (ExistPrivate->Controller); 862 if (ExistPrivate->Session != NULL) { 863 IScsiSessionAbort (ExistPrivate->Session); 864 } 865 866 IScsiCleanDriverData (ExistPrivate); 867 } 868 } else { 869 // 870 // Use the attempt in earlier order as boot selected in single path mode. 871 // 872 if (AttemptConfigOrder[Index] == mPrivate->BootSelectedIndex) { 873 NeedUpdate = FALSE; 874 } 875 } 876 877 } 878 879 if (NeedUpdate) { 880 mPrivate->OneSessionEstablished = TRUE; 881 mPrivate->BootSelectedIndex = BootSelected; 882 } 883 884 // 885 // Duplicate the Session's tcp connection device path. The source port field 886 // will be set to zero as one iSCSI session is comprised of several iSCSI 887 // connections. 888 // 889 Private->DevicePath = IScsiGetTcpConnDevicePath (Private->Session); 890 if (Private->DevicePath == NULL) { 891 Status = EFI_DEVICE_ERROR; 892 goto ON_ERROR; 893 } 894 // 895 // Install the updated device path onto the ExtScsiPassThruHandle. 896 // 897 Status = gBS->InstallProtocolInterface ( 898 &Private->ExtScsiPassThruHandle, 899 &gEfiDevicePathProtocolGuid, 900 EFI_NATIVE_INTERFACE, 901 Private->DevicePath 902 ); 903 if (EFI_ERROR (Status)) { 904 goto ON_ERROR; 905 } 906 907 // 908 // ISCSI children should share the default Tcp child, just open the default Tcp child via BY_CHILD_CONTROLLER. 909 // 910 Status = gBS->OpenProtocol ( 911 Private->ChildHandle, /// Default Tcp child 912 ProtocolGuid, 913 &Interface, 914 Image, 915 Private->ExtScsiPassThruHandle, 916 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 917 ); 918 if (EFI_ERROR (Status)) { 919 gBS->UninstallMultipleProtocolInterfaces ( 920 Private->ExtScsiPassThruHandle, 921 &gEfiExtScsiPassThruProtocolGuid, 922 &Private->IScsiExtScsiPassThru, 923 &gEfiDevicePathProtocolGuid, 924 Private->DevicePath, 925 NULL 926 ); 927 928 goto ON_ERROR; 929 } 930 931 ON_EXIT: 932 933 // 934 // Update/Publish the iSCSI Boot Firmware Table. 935 // 936 if (mPrivate->BootSelectedIndex != 0) { 937 IScsiPublishIbft (); 938 } 939 940 return EFI_SUCCESS; 941 942 ON_ERROR: 943 944 if (Private->Session != NULL) { 945 IScsiSessionAbort (Private->Session); 946 } 947 948 return Status; 949 } 950 951 /** 952 Stops a device controller or a bus controller. This is the worker function for 953 IScsiIp4(6)DriverBindingStop. 954 955 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. 956 @param[in] ControllerHandle A handle to the device being stopped. The handle must 957 support a bus specific I/O protocol for the driver 958 to use to stop the device. 959 @param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer. 960 @param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL 961 if NumberOfChildren is 0. 962 @param[in] IpVersion IP_VERSION_4 or IP_VERSION_6. 963 964 @retval EFI_SUCCESS The device was stopped. 965 @retval EFI_DEVICE_ERROR The device could not be stopped due to a device error. 966 967 **/ 968 EFI_STATUS 969 EFIAPI 970 IScsiStop ( 971 IN EFI_DRIVER_BINDING_PROTOCOL *This, 972 IN EFI_HANDLE ControllerHandle, 973 IN UINTN NumberOfChildren, 974 IN EFI_HANDLE *ChildHandleBuffer OPTIONAL, 975 IN UINT8 IpVersion 976 ) 977 { 978 EFI_HANDLE IScsiController; 979 EFI_STATUS Status; 980 ISCSI_PRIVATE_PROTOCOL *IScsiIdentifier; 981 ISCSI_DRIVER_DATA *Private; 982 EFI_EXT_SCSI_PASS_THRU_PROTOCOL *PassThru; 983 ISCSI_CONNECTION *Conn; 984 EFI_GUID *ProtocolGuid; 985 EFI_GUID *TcpServiceBindingGuid; 986 EFI_GUID *TcpProtocolGuid; 987 988 989 if (NumberOfChildren != 0) { 990 // 991 // We should have only one child. 992 // 993 Status = gBS->OpenProtocol ( 994 ChildHandleBuffer[0], 995 &gEfiExtScsiPassThruProtocolGuid, 996 (VOID **) &PassThru, 997 This->DriverBindingHandle, 998 ControllerHandle, 999 EFI_OPEN_PROTOCOL_GET_PROTOCOL 1000 ); 1001 if (EFI_ERROR (Status)) { 1002 return EFI_DEVICE_ERROR; 1003 } 1004 1005 Private = ISCSI_DRIVER_DATA_FROM_EXT_SCSI_PASS_THRU (PassThru); 1006 Conn = NET_LIST_HEAD (&Private->Session->Conns, ISCSI_CONNECTION, Link); 1007 1008 // 1009 // Previously the TCP protocol is opened BY_CHILD_CONTROLLER. Just close 1010 // the protocol here, but do not uninstall the device path protocol and 1011 // EXT SCSI PASS THRU protocol installed on ExtScsiPassThruHandle. 1012 // 1013 if (IpVersion == IP_VERSION_4) { 1014 ProtocolGuid = &gEfiTcp4ProtocolGuid; 1015 } else { 1016 ProtocolGuid = &gEfiTcp6ProtocolGuid; 1017 } 1018 1019 gBS->CloseProtocol ( 1020 Private->ChildHandle, 1021 ProtocolGuid, 1022 Private->Image, 1023 Private->ExtScsiPassThruHandle 1024 ); 1025 1026 gBS->CloseProtocol ( 1027 Conn->TcpIo.Handle, 1028 ProtocolGuid, 1029 Private->Image, 1030 Private->ExtScsiPassThruHandle 1031 ); 1032 1033 return EFI_SUCCESS; 1034 } 1035 1036 // 1037 // Get the handle of the controller we are controling. 1038 // 1039 if (IpVersion == IP_VERSION_4) { 1040 ProtocolGuid = &gIScsiV4PrivateGuid; 1041 TcpProtocolGuid = &gEfiTcp4ProtocolGuid; 1042 TcpServiceBindingGuid = &gEfiTcp4ServiceBindingProtocolGuid; 1043 } else { 1044 ProtocolGuid = &gIScsiV6PrivateGuid; 1045 TcpProtocolGuid = &gEfiTcp6ProtocolGuid; 1046 TcpServiceBindingGuid = &gEfiTcp6ServiceBindingProtocolGuid; 1047 } 1048 IScsiController = NetLibGetNicHandle (ControllerHandle, TcpProtocolGuid); 1049 if (IScsiController == NULL) { 1050 return EFI_SUCCESS; 1051 } 1052 1053 Status = gBS->OpenProtocol ( 1054 IScsiController, 1055 ProtocolGuid, 1056 (VOID **) &IScsiIdentifier, 1057 This->DriverBindingHandle, 1058 ControllerHandle, 1059 EFI_OPEN_PROTOCOL_GET_PROTOCOL 1060 ); 1061 if (EFI_ERROR (Status)) { 1062 return EFI_DEVICE_ERROR; 1063 } 1064 1065 Private = ISCSI_DRIVER_DATA_FROM_IDENTIFIER (IScsiIdentifier); 1066 ASSERT (Private != NULL); 1067 1068 if (Private->ChildHandle != NULL) { 1069 Status = gBS->CloseProtocol ( 1070 Private->ChildHandle, 1071 TcpProtocolGuid, 1072 This->DriverBindingHandle, 1073 IScsiController 1074 ); 1075 1076 ASSERT (!EFI_ERROR (Status)); 1077 1078 Status = NetLibDestroyServiceChild ( 1079 IScsiController, 1080 This->DriverBindingHandle, 1081 TcpServiceBindingGuid, 1082 Private->ChildHandle 1083 ); 1084 1085 ASSERT (!EFI_ERROR (Status)); 1086 } 1087 1088 gBS->UninstallProtocolInterface ( 1089 IScsiController, 1090 ProtocolGuid, 1091 &Private->IScsiIdentifier 1092 ); 1093 1094 // 1095 // Remove this NIC. 1096 // 1097 IScsiRemoveNic (IScsiController); 1098 1099 // 1100 // Update the iSCSI Boot Firware Table. 1101 // 1102 IScsiPublishIbft (); 1103 1104 if (Private->Session != NULL) { 1105 IScsiSessionAbort (Private->Session); 1106 } 1107 1108 IScsiCleanDriverData (Private); 1109 1110 return EFI_SUCCESS; 1111 } 1112 1113 /** 1114 Tests to see if this driver supports a given controller. If a child device is provided, 1115 it tests to see if this driver supports creating a handle for the specified child device. 1116 1117 This function checks to see if the driver specified by This supports the device specified by 1118 ControllerHandle. Drivers typically use the device path attached to 1119 ControllerHandle and/or the services from the bus I/O abstraction attached to 1120 ControllerHandle to determine if the driver supports ControllerHandle. This function 1121 may be called many times during platform initialization. In order to reduce boot times, the tests 1122 performed by this function must be very small and take as little time as possible to execute. This 1123 function must not change the state of any hardware devices, and this function must be aware that the 1124 device specified by ControllerHandle may already be managed by the same driver or a 1125 different driver. This function must match its calls to AllocatePages() with FreePages(), 1126 AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol(). 1127 Since ControllerHandle may have been previously started by the same driver, if a protocol is 1128 already in the opened state, then it must not be closed with CloseProtocol(). This is required 1129 to guarantee the state of ControllerHandle is not modified by this function. 1130 1131 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. 1132 @param[in] ControllerHandle The handle of the controller to test. This handle 1133 must support a protocol interface that supplies 1134 an I/O abstraction to the driver. 1135 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This 1136 parameter is ignored by device drivers, and is optional for bus 1137 drivers. For bus drivers, if this parameter is not NULL, then 1138 the bus driver must determine if the bus controller specified 1139 by ControllerHandle and the child controller specified 1140 by RemainingDevicePath are both supported by this 1141 bus driver. 1142 1143 @retval EFI_SUCCESS The device specified by ControllerHandle and 1144 RemainingDevicePath is supported by the driver specified by This. 1145 @retval EFI_ALREADY_STARTED The device specified by ControllerHandle and 1146 RemainingDevicePath is already managed by the driver 1147 specified by This. 1148 @retval EFI_ACCESS_DENIED The device specified by ControllerHandle and 1149 RemainingDevicePath is already managed by a different 1150 driver or an application that requires exclusive access. 1151 Currently not implemented. 1152 @retval EFI_UNSUPPORTED The device specified by ControllerHandle and 1153 RemainingDevicePath is not supported by the driver specified by This. 1154 **/ 1155 EFI_STATUS 1156 EFIAPI 1157 IScsiIp4DriverBindingSupported ( 1158 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1159 IN EFI_HANDLE ControllerHandle, 1160 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL 1161 ) 1162 { 1163 return IScsiSupported ( 1164 This, 1165 ControllerHandle, 1166 RemainingDevicePath, 1167 IP_VERSION_4 1168 ); 1169 } 1170 1171 /** 1172 Starts a device controller or a bus controller. 1173 1174 The Start() function is designed to be invoked from the EFI boot service ConnectController(). 1175 As a result, much of the error checking on the parameters to Start() has been moved into this 1176 common boot service. It is legal to call Start() from other locations, 1177 but the following calling restrictions must be followed or the system behavior will not be deterministic. 1178 1. ControllerHandle must be a valid EFI_HANDLE. 1179 2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned 1180 EFI_DEVICE_PATH_PROTOCOL. 1181 3. Prior to calling Start(), the Supported() function for the driver specified by This must 1182 have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS. 1183 1184 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. 1185 @param[in] ControllerHandle The handle of the controller to start. This handle 1186 must support a protocol interface that supplies 1187 an I/O abstraction to the driver. 1188 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This 1189 parameter is ignored by device drivers, and is optional for bus 1190 drivers. For a bus driver, if this parameter is NULL, then handles 1191 for all the children of Controller are created by this driver. 1192 If this parameter is not NULL and the first Device Path Node is 1193 not the End of Device Path Node, then only the handle for the 1194 child device specified by the first Device Path Node of 1195 RemainingDevicePath is created by this driver. 1196 If the first Device Path Node of RemainingDevicePath is 1197 the End of Device Path Node, no child handle is created by this 1198 driver. 1199 1200 @retval EFI_SUCCESS The device was started. 1201 @retval EFI_DEVICE_ERROR The device could not be started due to a device error. Currently not implemented. 1202 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources. 1203 @retval Others The driver failed to start the device. 1204 1205 **/ 1206 EFI_STATUS 1207 EFIAPI 1208 IScsiIp4DriverBindingStart ( 1209 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1210 IN EFI_HANDLE ControllerHandle, 1211 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL 1212 ) 1213 { 1214 EFI_STATUS Status; 1215 1216 Status = IScsiStart (This->DriverBindingHandle, ControllerHandle, IP_VERSION_4); 1217 if (Status == EFI_ALREADY_STARTED) { 1218 Status = EFI_SUCCESS; 1219 } 1220 1221 return Status; 1222 } 1223 1224 /** 1225 Stops a device controller or a bus controller. 1226 1227 The Stop() function is designed to be invoked from the EFI boot service DisconnectController(). 1228 As a result, much of the error checking on the parameters to Stop() has been moved 1229 into this common boot service. It is legal to call Stop() from other locations, 1230 but the following calling restrictions must be followed or the system behavior will not be deterministic. 1231 1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this 1232 same driver's Start() function. 1233 2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid 1234 EFI_HANDLE. In addition, all of these handles must have been created in this driver's 1235 Start() function, and the Start() function must have called OpenProtocol() on 1236 ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER. 1237 1238 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. 1239 @param[in] ControllerHandle A handle to the device being stopped. The handle must 1240 support a bus specific I/O protocol for the driver 1241 to use to stop the device. 1242 @param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer. 1243 @param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL 1244 if NumberOfChildren is 0. 1245 1246 @retval EFI_SUCCESS The device was stopped. 1247 @retval EFI_DEVICE_ERROR The device could not be stopped due to a device error. 1248 1249 **/ 1250 EFI_STATUS 1251 EFIAPI 1252 IScsiIp4DriverBindingStop ( 1253 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1254 IN EFI_HANDLE ControllerHandle, 1255 IN UINTN NumberOfChildren, 1256 IN EFI_HANDLE *ChildHandleBuffer OPTIONAL 1257 ) 1258 { 1259 return IScsiStop ( 1260 This, 1261 ControllerHandle, 1262 NumberOfChildren, 1263 ChildHandleBuffer, 1264 IP_VERSION_4 1265 ); 1266 } 1267 1268 /** 1269 Tests to see if this driver supports a given controller. If a child device is provided, 1270 it tests to see if this driver supports creating a handle for the specified child device. 1271 1272 This function checks to see if the driver specified by This supports the device specified by 1273 ControllerHandle. Drivers typically use the device path attached to 1274 ControllerHandle and/or the services from the bus I/O abstraction attached to 1275 ControllerHandle to determine if the driver supports ControllerHandle. This function 1276 may be called many times during platform initialization. In order to reduce boot times, the tests 1277 performed by this function must be very small and take as little time as possible to execute. This 1278 function must not change the state of any hardware devices, and this function must be aware that the 1279 device specified by ControllerHandle may already be managed by the same driver or a 1280 different driver. This function must match its calls to AllocatePages() with FreePages(), 1281 AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol(). 1282 Since ControllerHandle may have been previously started by the same driver, if a protocol is 1283 already in the opened state, then it must not be closed with CloseProtocol(). This is required 1284 to guarantee the state of ControllerHandle is not modified by this function. 1285 1286 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. 1287 @param[in] ControllerHandle The handle of the controller to test. This handle 1288 must support a protocol interface that supplies 1289 an I/O abstraction to the driver. 1290 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This 1291 parameter is ignored by device drivers, and is optional for bus 1292 drivers. For bus drivers, if this parameter is not NULL, then 1293 the bus driver must determine if the bus controller specified 1294 by ControllerHandle and the child controller specified 1295 by RemainingDevicePath are both supported by this 1296 bus driver. 1297 1298 @retval EFI_SUCCESS The device specified by ControllerHandle and 1299 RemainingDevicePath is supported by the driver specified by This. 1300 @retval EFI_ALREADY_STARTED The device specified by ControllerHandle and 1301 RemainingDevicePath is already managed by the driver 1302 specified by This. 1303 @retval EFI_ACCESS_DENIED The device specified by ControllerHandle and 1304 RemainingDevicePath is already managed by a different 1305 driver or an application that requires exclusive access. 1306 Currently not implemented. 1307 @retval EFI_UNSUPPORTED The device specified by ControllerHandle and 1308 RemainingDevicePath is not supported by the driver specified by This. 1309 **/ 1310 EFI_STATUS 1311 EFIAPI 1312 IScsiIp6DriverBindingSupported ( 1313 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1314 IN EFI_HANDLE ControllerHandle, 1315 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL 1316 ) 1317 { 1318 return IScsiSupported ( 1319 This, 1320 ControllerHandle, 1321 RemainingDevicePath, 1322 IP_VERSION_6 1323 ); 1324 } 1325 1326 /** 1327 Starts a device controller or a bus controller. 1328 1329 The Start() function is designed to be invoked from the EFI boot service ConnectController(). 1330 As a result, much of the error checking on the parameters to Start() has been moved into this 1331 common boot service. It is legal to call Start() from other locations, 1332 but the following calling restrictions must be followed or the system behavior will not be deterministic. 1333 1. ControllerHandle must be a valid EFI_HANDLE. 1334 2. If RemainingDevicePath is not NULL, then it must be a pointer to a naturally aligned 1335 EFI_DEVICE_PATH_PROTOCOL. 1336 3. Prior to calling Start(), the Supported() function for the driver specified by This must 1337 have been called with the same calling parameters, and Supported() must have returned EFI_SUCCESS. 1338 1339 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. 1340 @param[in] ControllerHandle The handle of the controller to start. This handle 1341 must support a protocol interface that supplies 1342 an I/O abstraction to the driver. 1343 @param[in] RemainingDevicePath A pointer to the remaining portion of a device path. This 1344 parameter is ignored by device drivers, and is optional for bus 1345 drivers. For a bus driver, if this parameter is NULL, then handles 1346 for all the children of Controller are created by this driver. 1347 If this parameter is not NULL and the first Device Path Node is 1348 not the End of Device Path Node, then only the handle for the 1349 child device specified by the first Device Path Node of 1350 RemainingDevicePath is created by this driver. 1351 If the first Device Path Node of RemainingDevicePath is 1352 the End of Device Path Node, no child handle is created by this 1353 driver. 1354 1355 @retval EFI_SUCCESS The device was started. 1356 @retval EFI_DEVICE_ERROR The device could not be started due to a device error. Currently not implemented. 1357 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources. 1358 @retval Others The driver failed to start the device. 1359 1360 **/ 1361 EFI_STATUS 1362 EFIAPI 1363 IScsiIp6DriverBindingStart ( 1364 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1365 IN EFI_HANDLE ControllerHandle, 1366 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL 1367 ) 1368 { 1369 EFI_STATUS Status; 1370 1371 Status = IScsiStart (This->DriverBindingHandle, ControllerHandle, IP_VERSION_6); 1372 if (Status == EFI_ALREADY_STARTED) { 1373 Status = EFI_SUCCESS; 1374 } 1375 1376 return Status; 1377 } 1378 1379 /** 1380 Stops a device controller or a bus controller. 1381 1382 The Stop() function is designed to be invoked from the EFI boot service DisconnectController(). 1383 As a result, much of the error checking on the parameters to Stop() has been moved 1384 into this common boot service. It is legal to call Stop() from other locations, 1385 but the following calling restrictions must be followed or the system behavior will not be deterministic. 1386 1. ControllerHandle must be a valid EFI_HANDLE that was used on a previous call to this 1387 same driver's Start() function. 1388 2. The first NumberOfChildren handles of ChildHandleBuffer must all be a valid 1389 EFI_HANDLE. In addition, all of these handles must have been created in this driver's 1390 Start() function, and the Start() function must have called OpenProtocol() on 1391 ControllerHandle with an Attribute of EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER. 1392 1393 @param[in] This A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance. 1394 @param[in] ControllerHandle A handle to the device being stopped. The handle must 1395 support a bus specific I/O protocol for the driver 1396 to use to stop the device. 1397 @param[in] NumberOfChildren The number of child device handles in ChildHandleBuffer. 1398 @param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL 1399 if NumberOfChildren is 0. 1400 1401 @retval EFI_SUCCESS The device was stopped. 1402 @retval EFI_DEVICE_ERROR The device could not be stopped due to a device error. 1403 1404 **/ 1405 EFI_STATUS 1406 EFIAPI 1407 IScsiIp6DriverBindingStop ( 1408 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1409 IN EFI_HANDLE ControllerHandle, 1410 IN UINTN NumberOfChildren, 1411 IN EFI_HANDLE *ChildHandleBuffer OPTIONAL 1412 ) 1413 { 1414 return IScsiStop ( 1415 This, 1416 ControllerHandle, 1417 NumberOfChildren, 1418 ChildHandleBuffer, 1419 IP_VERSION_6 1420 ); 1421 } 1422 1423 /** 1424 Unload the iSCSI driver. 1425 1426 @param[in] ImageHandle The handle of the driver image. 1427 1428 @retval EFI_SUCCESS The driver is unloaded. 1429 @retval EFI_DEVICE_ERROR An unexpected error occurred. 1430 1431 **/ 1432 EFI_STATUS 1433 EFIAPI 1434 IScsiUnload ( 1435 IN EFI_HANDLE ImageHandle 1436 ) 1437 { 1438 EFI_STATUS Status; 1439 UINTN DeviceHandleCount; 1440 EFI_HANDLE *DeviceHandleBuffer; 1441 UINTN Index; 1442 EFI_COMPONENT_NAME_PROTOCOL *ComponentName; 1443 EFI_COMPONENT_NAME2_PROTOCOL *ComponentName2; 1444 1445 // 1446 // Try to disonnect the driver from the devices it's controlling. 1447 // 1448 Status = gBS->LocateHandleBuffer ( 1449 AllHandles, 1450 NULL, 1451 NULL, 1452 &DeviceHandleCount, 1453 &DeviceHandleBuffer 1454 ); 1455 if (EFI_ERROR (Status)) { 1456 return Status; 1457 } 1458 1459 // 1460 // Disconnect the iSCSI4 driver from the controlled device. 1461 // 1462 for (Index = 0; Index < DeviceHandleCount; Index++) { 1463 Status = IScsiTestManagedDevice ( 1464 DeviceHandleBuffer[Index], 1465 gIScsiIp4DriverBinding.DriverBindingHandle, 1466 &gEfiTcp4ProtocolGuid) 1467 ; 1468 if (EFI_ERROR (Status)) { 1469 continue; 1470 } 1471 Status = gBS->DisconnectController ( 1472 DeviceHandleBuffer[Index], 1473 gIScsiIp4DriverBinding.DriverBindingHandle, 1474 NULL 1475 ); 1476 if (EFI_ERROR (Status)) { 1477 goto ON_EXIT; 1478 } 1479 } 1480 1481 // 1482 // Disconnect the iSCSI6 driver from the controlled device. 1483 // 1484 for (Index = 0; Index < DeviceHandleCount; Index++) { 1485 Status = IScsiTestManagedDevice ( 1486 DeviceHandleBuffer[Index], 1487 gIScsiIp6DriverBinding.DriverBindingHandle, 1488 &gEfiTcp6ProtocolGuid 1489 ); 1490 if (EFI_ERROR (Status)) { 1491 continue; 1492 } 1493 Status = gBS->DisconnectController ( 1494 DeviceHandleBuffer[Index], 1495 gIScsiIp6DriverBinding.DriverBindingHandle, 1496 NULL 1497 ); 1498 if (EFI_ERROR (Status)) { 1499 goto ON_EXIT; 1500 } 1501 } 1502 1503 // 1504 // Unload the iSCSI configuration form. 1505 // 1506 Status = IScsiConfigFormUnload (gIScsiIp4DriverBinding.DriverBindingHandle); 1507 if (EFI_ERROR (Status)) { 1508 goto ON_EXIT; 1509 } 1510 1511 // 1512 // Uninstall the protocols installed by iSCSI driver. 1513 // 1514 Status = gBS->UninstallMultipleProtocolInterfaces ( 1515 ImageHandle, 1516 &gEfiAuthenticationInfoProtocolGuid, 1517 &gIScsiAuthenticationInfo, 1518 NULL 1519 ); 1520 if (EFI_ERROR (Status)) { 1521 goto ON_EXIT; 1522 } 1523 1524 if (gIScsiControllerNameTable!= NULL) { 1525 Status = FreeUnicodeStringTable (gIScsiControllerNameTable); 1526 if (EFI_ERROR (Status)) { 1527 goto ON_EXIT; 1528 } 1529 gIScsiControllerNameTable = NULL; 1530 } 1531 1532 // 1533 // Uninstall the ComponentName and ComponentName2 protocol from iSCSI4 driver binding handle 1534 // if it has been installed. 1535 // 1536 Status = gBS->HandleProtocol ( 1537 gIScsiIp4DriverBinding.DriverBindingHandle, 1538 &gEfiComponentNameProtocolGuid, 1539 (VOID **) &ComponentName 1540 ); 1541 if (!EFI_ERROR (Status)) { 1542 Status = gBS->UninstallMultipleProtocolInterfaces ( 1543 gIScsiIp4DriverBinding.DriverBindingHandle, 1544 &gEfiComponentNameProtocolGuid, 1545 ComponentName, 1546 NULL 1547 ); 1548 if (EFI_ERROR (Status)) { 1549 goto ON_EXIT; 1550 } 1551 } 1552 1553 Status = gBS->HandleProtocol ( 1554 gIScsiIp4DriverBinding.DriverBindingHandle, 1555 &gEfiComponentName2ProtocolGuid, 1556 (VOID **) &ComponentName2 1557 ); 1558 if (!EFI_ERROR (Status)) { 1559 gBS->UninstallMultipleProtocolInterfaces ( 1560 gIScsiIp4DriverBinding.DriverBindingHandle, 1561 &gEfiComponentName2ProtocolGuid, 1562 ComponentName2, 1563 NULL 1564 ); 1565 if (EFI_ERROR (Status)) { 1566 goto ON_EXIT; 1567 } 1568 } 1569 1570 // 1571 // Uninstall the ComponentName and ComponentName2 protocol from iSCSI6 driver binding handle 1572 // if it has been installed. 1573 // 1574 Status = gBS->HandleProtocol ( 1575 gIScsiIp6DriverBinding.DriverBindingHandle, 1576 &gEfiComponentNameProtocolGuid, 1577 (VOID **) &ComponentName 1578 ); 1579 if (!EFI_ERROR (Status)) { 1580 Status = gBS->UninstallMultipleProtocolInterfaces ( 1581 gIScsiIp6DriverBinding.DriverBindingHandle, 1582 &gEfiComponentNameProtocolGuid, 1583 ComponentName, 1584 NULL 1585 ); 1586 if (EFI_ERROR (Status)) { 1587 goto ON_EXIT; 1588 } 1589 } 1590 1591 Status = gBS->HandleProtocol ( 1592 gIScsiIp6DriverBinding.DriverBindingHandle, 1593 &gEfiComponentName2ProtocolGuid, 1594 (VOID **) &ComponentName2 1595 ); 1596 if (!EFI_ERROR (Status)) { 1597 gBS->UninstallMultipleProtocolInterfaces ( 1598 gIScsiIp6DriverBinding.DriverBindingHandle, 1599 &gEfiComponentName2ProtocolGuid, 1600 ComponentName2, 1601 NULL 1602 ); 1603 if (EFI_ERROR (Status)) { 1604 goto ON_EXIT; 1605 } 1606 } 1607 1608 // 1609 // Uninstall the IScsiInitiatorNameProtocol and all the driver binding protocols. 1610 // 1611 Status = gBS->UninstallMultipleProtocolInterfaces ( 1612 gIScsiIp4DriverBinding.DriverBindingHandle, 1613 &gEfiDriverBindingProtocolGuid, 1614 &gIScsiIp4DriverBinding, 1615 &gEfiIScsiInitiatorNameProtocolGuid, 1616 &gIScsiInitiatorName, 1617 NULL 1618 ); 1619 if (EFI_ERROR (Status)) { 1620 goto ON_EXIT; 1621 } 1622 1623 Status = gBS->UninstallMultipleProtocolInterfaces ( 1624 gIScsiIp6DriverBinding.DriverBindingHandle, 1625 &gEfiDriverBindingProtocolGuid, 1626 &gIScsiIp6DriverBinding, 1627 NULL 1628 ); 1629 1630 ON_EXIT: 1631 1632 if (DeviceHandleBuffer != NULL) { 1633 FreePool (DeviceHandleBuffer); 1634 } 1635 1636 return Status; 1637 } 1638 1639 /** 1640 This is the declaration of an EFI image entry point. This entry point is 1641 the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including 1642 both device drivers and bus drivers. 1643 1644 The entry point for iSCSI driver which initializes the global variables and 1645 installs the driver binding, component name protocol, iSCSI initiator name 1646 protocol and Authentication Info protocol on its image. 1647 1648 @param[in] ImageHandle The firmware allocated handle for the UEFI image. 1649 @param[in] SystemTable A pointer to the EFI System Table. 1650 1651 @retval EFI_SUCCESS The operation completed successfully. 1652 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources. 1653 1654 **/ 1655 EFI_STATUS 1656 EFIAPI 1657 IScsiDriverEntryPoint ( 1658 IN EFI_HANDLE ImageHandle, 1659 IN EFI_SYSTEM_TABLE *SystemTable 1660 ) 1661 { 1662 EFI_STATUS Status; 1663 EFI_ISCSI_INITIATOR_NAME_PROTOCOL *IScsiInitiatorName; 1664 EFI_AUTHENTICATION_INFO_PROTOCOL *AuthenticationInfo; 1665 1666 // 1667 // There should be only one EFI_ISCSI_INITIATOR_NAME_PROTOCOL. 1668 // 1669 Status = gBS->LocateProtocol ( 1670 &gEfiIScsiInitiatorNameProtocolGuid, 1671 NULL, 1672 (VOID **) &IScsiInitiatorName 1673 ); 1674 if (!EFI_ERROR (Status)) { 1675 return EFI_ACCESS_DENIED; 1676 } 1677 1678 // 1679 // Initialize the EFI Driver Library. 1680 // 1681 Status = EfiLibInstallDriverBindingComponentName2 ( 1682 ImageHandle, 1683 SystemTable, 1684 &gIScsiIp4DriverBinding, 1685 ImageHandle, 1686 &gIScsiComponentName, 1687 &gIScsiComponentName2 1688 ); 1689 if (EFI_ERROR (Status)) { 1690 return Status; 1691 } 1692 1693 Status = EfiLibInstallDriverBindingComponentName2 ( 1694 ImageHandle, 1695 SystemTable, 1696 &gIScsiIp6DriverBinding, 1697 NULL, 1698 &gIScsiComponentName, 1699 &gIScsiComponentName2 1700 ); 1701 if (EFI_ERROR (Status)) { 1702 goto Error1; 1703 } 1704 1705 // 1706 // Install the iSCSI Initiator Name Protocol. 1707 // 1708 Status = gBS->InstallProtocolInterface ( 1709 &ImageHandle, 1710 &gEfiIScsiInitiatorNameProtocolGuid, 1711 EFI_NATIVE_INTERFACE, 1712 &gIScsiInitiatorName 1713 ); 1714 if (EFI_ERROR (Status)) { 1715 goto Error2; 1716 } 1717 1718 // 1719 // Create the private data structures. 1720 // 1721 mPrivate = AllocateZeroPool (sizeof (ISCSI_PRIVATE_DATA)); 1722 if (mPrivate == NULL) { 1723 Status = EFI_OUT_OF_RESOURCES; 1724 goto Error3; 1725 } 1726 1727 InitializeListHead (&mPrivate->NicInfoList); 1728 InitializeListHead (&mPrivate->AttemptConfigs); 1729 1730 // 1731 // Initialize the configuration form of iSCSI. 1732 // 1733 Status = IScsiConfigFormInit (gIScsiIp4DriverBinding.DriverBindingHandle); 1734 if (EFI_ERROR (Status)) { 1735 goto Error4; 1736 } 1737 1738 // 1739 // There should be only one EFI_AUTHENTICATION_INFO_PROTOCOL. If already exists, 1740 // do not produce the protocol instance. 1741 // 1742 Status = gBS->LocateProtocol ( 1743 &gEfiAuthenticationInfoProtocolGuid, 1744 NULL, 1745 (VOID **) &AuthenticationInfo 1746 ); 1747 if (Status == EFI_NOT_FOUND) { 1748 Status = gBS->InstallProtocolInterface ( 1749 &ImageHandle, 1750 &gEfiAuthenticationInfoProtocolGuid, 1751 EFI_NATIVE_INTERFACE, 1752 &gIScsiAuthenticationInfo 1753 ); 1754 if (EFI_ERROR (Status)) { 1755 goto Error5; 1756 } 1757 } 1758 1759 return EFI_SUCCESS; 1760 1761 Error5: 1762 IScsiConfigFormUnload (gIScsiIp4DriverBinding.DriverBindingHandle); 1763 1764 Error4: 1765 FreePool (mPrivate); 1766 1767 Error3: 1768 gBS->UninstallMultipleProtocolInterfaces ( 1769 ImageHandle, 1770 &gEfiIScsiInitiatorNameProtocolGuid, 1771 &gIScsiInitiatorName, 1772 NULL 1773 ); 1774 1775 Error2: 1776 gBS->UninstallMultipleProtocolInterfaces ( 1777 gIScsiIp6DriverBinding.DriverBindingHandle, 1778 &gEfiDriverBindingProtocolGuid, 1779 &gIScsiIp6DriverBinding, 1780 &gEfiComponentName2ProtocolGuid, 1781 &gIScsiComponentName2, 1782 &gEfiComponentNameProtocolGuid, 1783 &gIScsiComponentName, 1784 NULL 1785 ); 1786 1787 Error1: 1788 gBS->UninstallMultipleProtocolInterfaces ( 1789 ImageHandle, 1790 &gEfiDriverBindingProtocolGuid, 1791 &gIScsiIp4DriverBinding, 1792 &gEfiComponentName2ProtocolGuid, 1793 &gIScsiComponentName2, 1794 &gEfiComponentNameProtocolGuid, 1795 &gIScsiComponentName, 1796 NULL 1797 ); 1798 1799 return Status; 1800 } 1801 1802
