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