MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Driver.c

   1 /** @file
   2   The driver binding and service binding protocol for IP4 driver.
   3
   4 Copyright (c) 2005 - 2012, 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 "Ip4Impl.h"
  16
  17 EFI_DRIVER_BINDING_PROTOCOL gIp4DriverBinding = {
  18   Ip4DriverBindingSupported,
  19   Ip4DriverBindingStart,
  20   Ip4DriverBindingStop,
  21   0xa,
  22   NULL,
  23   NULL
  24 };
  25
  26 /**
  27   This is the declaration of an EFI image entry point. This entry point is
  28   the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including
  29   both device drivers and bus drivers.
  30
  31   The entry point for IP4 driver which install the driver
  32   binding and component name protocol on its image.
  33
  34   @param[in]  ImageHandle           The firmware allocated handle for the UEFI image.
  35   @param[in]  SystemTable           A pointer to the EFI System Table.
  36
  37   @retval EFI_SUCCESS           The operation completed successfully.
  38   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
  39
  40 **/
  41 EFI_STATUS
  42 EFIAPI
  43 Ip4DriverEntryPoint (
  44   IN EFI_HANDLE             ImageHandle,
  45   IN EFI_SYSTEM_TABLE       *SystemTable
  46   )
  47 {
  48   return EfiLibInstallDriverBindingComponentName2 (
  49            ImageHandle,
  50            SystemTable,
  51            &gIp4DriverBinding,
  52            ImageHandle,
  53            &gIp4ComponentName,
  54            &gIp4ComponentName2
  55            );
  56 }
  57
  58 /**
  59   Test to see if this driver supports ControllerHandle. This service
  60   is called by the EFI boot service ConnectController(). In
  61   order to make drivers as small as possible, there are a few calling
  62   restrictions for this service. ConnectController() must
  63   follow these calling restrictions. If any other agent wishes to call
  64   Supported() it must also follow these calling restrictions.
  65
  66   @param[in]  This                Protocol instance pointer.
  67   @param[in]  ControllerHandle    Handle of device to test
  68   @param[in]  RemainingDevicePath Optional parameter use to pick a specific child
  69                                   device to start.
  70
  71   @retval EFI_SUCCESS         This driver supports this device
  72   @retval EFI_ALREADY_STARTED This driver is already running on this device
  73   @retval other               This driver does not support this device
  74
  75 **/
  76 EFI_STATUS
  77 EFIAPI
  78 Ip4DriverBindingSupported (
  79   IN EFI_DRIVER_BINDING_PROTOCOL  * This,
  80   IN EFI_HANDLE                   ControllerHandle,
  81   IN EFI_DEVICE_PATH_PROTOCOL     * RemainingDevicePath OPTIONAL
  82   )
  83 {
  84   EFI_STATUS                Status;
  85
  86   //
  87   // Test for the MNP service binding Protocol
  88   //
  89   Status = gBS->OpenProtocol (
  90                   ControllerHandle,
  91                   &gEfiManagedNetworkServiceBindingProtocolGuid,
  92                   NULL,
  93                   This->DriverBindingHandle,
  94                   ControllerHandle,
  95                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
  96                   );
  97
  98   if (EFI_ERROR (Status)) {
  99     return Status;
 100   }
 101
 102   //
 103   // Test for the Arp service binding Protocol
 104   //
 105   Status = gBS->OpenProtocol (
 106                   ControllerHandle,
 107                   &gEfiArpServiceBindingProtocolGuid,
 108                   NULL,
 109                   This->DriverBindingHandle,
 110                   ControllerHandle,
 111                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 112                   );
 113
 114   return Status;
 115 }
 116
 117 /**
 118   Clean up a IP4 service binding instance. It will release all
 119   the resource allocated by the instance. The instance may be
 120   partly initialized, or partly destroyed. If a resource is
 121   destroyed, it is marked as that in case the destroy failed and
 122   being called again later.
 123
 124   @param[in]  IpSb               The IP4 serviceing binding instance to clean up
 125
 126   @retval EFI_SUCCESS            The resource used by the instance are cleaned up
 127   @retval other                  Failed to clean up some of the resources.
 128
 129 **/
 130 EFI_STATUS
 131 Ip4CleanService (
 132   IN IP4_SERVICE            *IpSb
 133   );
 134
 135
 136 /**
 137   Create a new IP4 driver service binding private instance.
 138
 139   @param  Controller         The controller that has MNP service binding
 140                              installed
 141   @param  ImageHandle        The IP4 driver's image handle
 142   @param  Service            The variable to receive the newly created IP4
 143                              service.
 144
 145   @retval EFI_OUT_OF_RESOURCES   Failed to allocate some resource
 146   @retval EFI_SUCCESS            A new IP4 service binding private is created.
 147   @retval other                  Other error occurs.
 148
 149 **/
 150 EFI_STATUS
 151 Ip4CreateService (
 152   IN  EFI_HANDLE            Controller,
 153   IN  EFI_HANDLE            ImageHandle,
 154   OUT IP4_SERVICE           **Service
 155   )
 156 {
 157   IP4_SERVICE               *IpSb;
 158   EFI_STATUS                Status;
 159
 160   ASSERT (Service != NULL);
 161
 162   *Service = NULL;
 163
 164   //
 165   // allocate a service private data then initialize all the filed to
 166   // empty resources, so if any thing goes wrong when allocating
 167   // resources, Ip4CleanService can be called to clean it up.
 168   //
 169   IpSb = AllocatePool (sizeof (IP4_SERVICE));
 170
 171   if (IpSb == NULL) {
 172     return EFI_OUT_OF_RESOURCES;
 173   }
 174
 175   IpSb->Signature                   = IP4_SERVICE_SIGNATURE;
 176   IpSb->ServiceBinding.CreateChild  = Ip4ServiceBindingCreateChild;
 177   IpSb->ServiceBinding.DestroyChild = Ip4ServiceBindingDestroyChild;
 178   IpSb->State                       = IP4_SERVICE_UNSTARTED;
 179
 180   IpSb->NumChildren                 = 0;
 181   InitializeListHead (&IpSb->Children);
 182
 183   InitializeListHead (&IpSb->Interfaces);
 184   IpSb->DefaultInterface            = NULL;
 185   IpSb->DefaultRouteTable           = NULL;
 186
 187   Ip4InitAssembleTable (&IpSb->Assemble);
 188
 189   IpSb->IgmpCtrl.Igmpv1QuerySeen    = 0;
 190   InitializeListHead (&IpSb->IgmpCtrl.Groups);
 191
 192   IpSb->Image                       = ImageHandle;
 193   IpSb->Controller                  = Controller;
 194
 195   IpSb->MnpChildHandle              = NULL;
 196   IpSb->Mnp                         = NULL;
 197
 198   IpSb->MnpConfigData.ReceivedQueueTimeoutValue = 0;
 199   IpSb->MnpConfigData.TransmitQueueTimeoutValue = 0;
 200   IpSb->MnpConfigData.ProtocolTypeFilter        = IP4_ETHER_PROTO;
 201   IpSb->MnpConfigData.EnableUnicastReceive      = TRUE;
 202   IpSb->MnpConfigData.EnableMulticastReceive    = TRUE;
 203   IpSb->MnpConfigData.EnableBroadcastReceive    = TRUE;
 204   IpSb->MnpConfigData.EnablePromiscuousReceive  = FALSE;
 205   IpSb->MnpConfigData.FlushQueuesOnReset        = TRUE;
 206   IpSb->MnpConfigData.EnableReceiveTimestamps   = FALSE;
 207   IpSb->MnpConfigData.DisableBackgroundPolling  = FALSE;
 208
 209   ZeroMem (&IpSb->SnpMode, sizeof (EFI_SIMPLE_NETWORK_MODE));
 210
 211   IpSb->Timer                       = NULL;
 212   IpSb->Ip4Config                   = NULL;
 213   IpSb->DoneEvent                   = NULL;
 214   IpSb->ReconfigEvent               = NULL;
 215   IpSb->ActiveEvent                 = NULL;
 216
 217   //
 218   // Create various resources. First create the route table, timer
 219   // event and MNP child. IGMP, interface's initialization depend
 220   // on the MNP child.
 221   //
 222   IpSb->DefaultRouteTable = Ip4CreateRouteTable ();
 223
 224   if (IpSb->DefaultRouteTable == NULL) {
 225     Status = EFI_OUT_OF_RESOURCES;
 226     goto ON_ERROR;
 227   }
 228
 229   Status = gBS->CreateEvent (
 230                   EVT_NOTIFY_SIGNAL | EVT_TIMER,
 231                   TPL_CALLBACK,
 232                   Ip4TimerTicking,
 233                   IpSb,
 234                   &IpSb->Timer
 235                   );
 236
 237   if (EFI_ERROR (Status)) {
 238     goto ON_ERROR;
 239   }
 240
 241   Status = NetLibCreateServiceChild (
 242              Controller,
 243              ImageHandle,
 244              &gEfiManagedNetworkServiceBindingProtocolGuid,
 245              &IpSb->MnpChildHandle
 246              );
 247
 248   if (EFI_ERROR (Status)) {
 249     goto ON_ERROR;
 250   }
 251
 252   Status = gBS->OpenProtocol (
 253                   IpSb->MnpChildHandle,
 254                   &gEfiManagedNetworkProtocolGuid,
 255                   (VOID **) &IpSb->Mnp,
 256                   ImageHandle,
 257                   Controller,
 258                   EFI_OPEN_PROTOCOL_BY_DRIVER
 259                   );
 260
 261   if (EFI_ERROR (Status)) {
 262     goto ON_ERROR;
 263   }
 264
 265   Status = Ip4ServiceConfigMnp (IpSb, TRUE);
 266
 267   if (EFI_ERROR (Status)) {
 268     goto ON_ERROR;
 269   }
 270
 271   Status = IpSb->Mnp->GetModeData (IpSb->Mnp, NULL, &IpSb->SnpMode);
 272
 273   if (EFI_ERROR (Status)) {
 274     goto ON_ERROR;
 275   }
 276
 277   Status = Ip4InitIgmp (IpSb);
 278
 279   if (EFI_ERROR (Status)) {
 280     goto ON_ERROR;
 281   }
 282
 283   IpSb->DefaultInterface = Ip4CreateInterface (IpSb->Mnp, Controller, ImageHandle);
 284
 285   if (IpSb->DefaultInterface == NULL) {
 286     Status = EFI_OUT_OF_RESOURCES;
 287     goto ON_ERROR;
 288   }
 289
 290   InsertHeadList (&IpSb->Interfaces, &IpSb->DefaultInterface->Link);
 291
 292   IpSb->MaxPacketSize = IpSb->SnpMode.MaxPacketSize - sizeof (IP4_HEAD);
 293   if (NetLibGetVlanId (IpSb->Controller) != 0) {
 294     //
 295     // This is a VLAN device, reduce MTU by VLAN tag length
 296     //
 297     IpSb->MaxPacketSize -= NET_VLAN_TAG_LEN;
 298   }
 299   IpSb->OldMaxPacketSize = IpSb->MaxPacketSize;
 300   IpSb->MacString = NULL;
 301
 302   *Service = IpSb;
 303   return EFI_SUCCESS;
 304
 305 ON_ERROR:
 306   Ip4CleanService (IpSb);
 307   FreePool (IpSb);
 308
 309   return Status;
 310 }
 311
 312
 313 /**
 314   Clean up a IP4 service binding instance. It will release all
 315   the resource allocated by the instance. The instance may be
 316   partly initialized, or partly destroyed. If a resource is
 317   destroyed, it is marked as that in case the destroy failed and
 318   being called again later.
 319
 320   @param[in]  IpSb               The IP4 serviceing binding instance to clean up
 321
 322   @retval EFI_SUCCESS            The resource used by the instance are cleaned up
 323   @retval other                  Failed to clean up some of the resources.
 324
 325 **/
 326 EFI_STATUS
 327 Ip4CleanService (
 328   IN IP4_SERVICE            *IpSb
 329   )
 330 {
 331   EFI_STATUS                Status;
 332
 333   if (IpSb->DefaultInterface != NULL) {
 334     Status = Ip4FreeInterface (IpSb->DefaultInterface, NULL);
 335
 336     if (EFI_ERROR (Status)) {
 337       return Status;
 338     }
 339
 340     IpSb->DefaultInterface = NULL;
 341   }
 342
 343   if (IpSb->DefaultRouteTable != NULL) {
 344     Ip4FreeRouteTable (IpSb->DefaultRouteTable);
 345     IpSb->DefaultRouteTable = NULL;
 346   }
 347
 348   Ip4CleanAssembleTable (&IpSb->Assemble);
 349
 350   if (IpSb->MnpChildHandle != NULL) {
 351     if (IpSb->Mnp != NULL) {
 352       gBS->CloseProtocol (
 353              IpSb->MnpChildHandle,
 354              &gEfiManagedNetworkProtocolGuid,
 355              IpSb->Image,
 356              IpSb->Controller
 357              );
 358
 359       IpSb->Mnp = NULL;
 360     }
 361
 362     NetLibDestroyServiceChild (
 363       IpSb->Controller,
 364       IpSb->Image,
 365       &gEfiManagedNetworkServiceBindingProtocolGuid,
 366       IpSb->MnpChildHandle
 367       );
 368
 369     IpSb->MnpChildHandle = NULL;
 370   }
 371
 372   if (IpSb->Timer != NULL) {
 373     gBS->SetTimer (IpSb->Timer, TimerCancel, 0);
 374     gBS->CloseEvent (IpSb->Timer);
 375
 376     IpSb->Timer = NULL;
 377   }
 378
 379   if (IpSb->Ip4Config != NULL) {
 380     IpSb->Ip4Config->Stop (IpSb->Ip4Config);
 381
 382     gBS->CloseProtocol (
 383           IpSb->Controller,
 384           &gEfiIp4ConfigProtocolGuid,
 385           IpSb->Image,
 386           IpSb->Controller
 387           );
 388
 389     gBS->CloseEvent (IpSb->DoneEvent);
 390     gBS->CloseEvent (IpSb->ReconfigEvent);
 391     IpSb->ActiveEvent = NULL;
 392     IpSb->Ip4Config = NULL;
 393   }
 394
 395   return EFI_SUCCESS;
 396 }
 397
 398 /**
 399   Callback function which provided by user to remove one node in NetDestroyLinkList process.
 400
 401   @param[in]    Entry           The entry to be removed.
 402   @param[in]    Context         Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
 403
 404   @retval EFI_SUCCESS           The entry has been removed successfully.
 405   @retval Others                Fail to remove the entry.
 406
 407 **/
 408 EFI_STATUS
 409 Ip4DestroyChildEntryInHandleBuffer (
 410   IN LIST_ENTRY         *Entry,
 411   IN VOID               *Context
 412 )
 413 {
 414   IP4_PROTOCOL                  *IpInstance;
 415   EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
 416   UINTN                         NumberOfChildren;
 417   EFI_HANDLE                    *ChildHandleBuffer;
 418
 419   if (Entry == NULL || Context == NULL) {
 420     return EFI_INVALID_PARAMETER;
 421   }
 422
 423   IpInstance = NET_LIST_USER_STRUCT_S (Entry, IP4_PROTOCOL, Link, IP4_PROTOCOL_SIGNATURE);
 424   ServiceBinding    = ((IP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ServiceBinding;
 425   NumberOfChildren  = ((IP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->NumberOfChildren;
 426   ChildHandleBuffer = ((IP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ChildHandleBuffer;
 427
 428   if (!NetIsInHandleBuffer (IpInstance->Handle, NumberOfChildren, ChildHandleBuffer)) {
 429     return EFI_SUCCESS;
 430   }
 431
 432   return ServiceBinding->DestroyChild (ServiceBinding, IpInstance->Handle);
 433 }
 434
 435 /**
 436   Start this driver on ControllerHandle. This service is called by the
 437   EFI boot service ConnectController(). In order to make
 438   drivers as small as possible, there are a few calling restrictions for
 439   this service. ConnectController() must follow these
 440   calling restrictions. If any other agent wishes to call Start() it
 441   must also follow these calling restrictions.
 442
 443   @param[in]  This                 Protocol instance pointer.
 444   @param[in]  ControllerHandle     Handle of device to bind driver to
 445   @param[in]  RemainingDevicePath  Optional parameter use to pick a specific child
 446                                    device to start.
 447
 448   @retval EFI_SUCCESS          This driver is added to ControllerHandle
 449   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle
 450   @retval other                This driver does not support this device
 451
 452 **/
 453 EFI_STATUS
 454 EFIAPI
 455 Ip4DriverBindingStart (
 456   IN EFI_DRIVER_BINDING_PROTOCOL  * This,
 457   IN EFI_HANDLE                   ControllerHandle,
 458   IN EFI_DEVICE_PATH_PROTOCOL     * RemainingDevicePath OPTIONAL
 459   )
 460 {
 461   IP4_SERVICE               *IpSb;
 462   EFI_STATUS                Status;
 463
 464   //
 465   // Test for the Ip4 service binding protocol
 466   //
 467   Status = gBS->OpenProtocol (
 468                   ControllerHandle,
 469                   &gEfiIp4ServiceBindingProtocolGuid,
 470                   NULL,
 471                   This->DriverBindingHandle,
 472                   ControllerHandle,
 473                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 474                   );
 475
 476   if (Status == EFI_SUCCESS) {
 477     return EFI_ALREADY_STARTED;
 478   }
 479
 480   Status = Ip4CreateService (ControllerHandle, This->DriverBindingHandle, &IpSb);
 481
 482   if (EFI_ERROR (Status)) {
 483     return Status;
 484   }
 485   ASSERT (IpSb != NULL);
 486
 487   //
 488   // Install the Ip4ServiceBinding Protocol onto ControlerHandle
 489   //
 490   Status = gBS->InstallMultipleProtocolInterfaces (
 491                   &ControllerHandle,
 492                   &gEfiIp4ServiceBindingProtocolGuid,
 493                   &IpSb->ServiceBinding,
 494                   NULL
 495                   );
 496
 497   if (EFI_ERROR (Status)) {
 498     goto FREE_SERVICE;
 499   }
 500
 501   //
 502   // ready to go: start the receiving and timer
 503   //
 504   Status = Ip4ReceiveFrame (IpSb->DefaultInterface, NULL, Ip4AccpetFrame, IpSb);
 505
 506   if (EFI_ERROR (Status)) {
 507     goto UNINSTALL_PROTOCOL;
 508   }
 509
 510   Status = gBS->SetTimer (IpSb->Timer, TimerPeriodic, TICKS_PER_SECOND);
 511
 512   if (EFI_ERROR (Status)) {
 513     goto UNINSTALL_PROTOCOL;
 514   }
 515
 516   //
 517   // Initialize the IP4 ID
 518   //
 519   mIp4Id = (UINT16)NET_RANDOM (NetRandomInitSeed ());
 520
 521   Ip4SetVariableData (IpSb);
 522
 523   return Status;
 524
 525 UNINSTALL_PROTOCOL:
 526   gBS->UninstallProtocolInterface (
 527          ControllerHandle,
 528          &gEfiIp4ServiceBindingProtocolGuid,
 529          &IpSb->ServiceBinding
 530          );
 531
 532 FREE_SERVICE:
 533   Ip4CleanService (IpSb);
 534   FreePool (IpSb);
 535
 536   return Status;
 537 }
 538
 539
 540 /**
 541   Stop this driver on ControllerHandle. This service is called by the
 542   EFI boot service DisconnectController(). In order to
 543   make drivers as small as possible, there are a few calling
 544   restrictions for this service. DisconnectController()
 545   must follow these calling restrictions. If any other agent wishes
 546   to call Stop() it must also follow these calling restrictions.
 547
 548   @param[in]  This              Protocol instance pointer.
 549   @param[in]  ControllerHandle  Handle of device to stop driver on
 550   @param[in]  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number
 551                                 of children is zero stop the entire bus driver.
 552   @param[in]  ChildHandleBuffer List of Child Handles to Stop.
 553
 554   @retval EFI_SUCCESS           This driver is removed ControllerHandle
 555   @retval other                 This driver was not removed from this device
 556
 557 **/
 558 EFI_STATUS
 559 EFIAPI
 560 Ip4DriverBindingStop (
 561   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 562   IN  EFI_HANDLE                   ControllerHandle,
 563   IN  UINTN                        NumberOfChildren,
 564   IN  EFI_HANDLE                   *ChildHandleBuffer
 565   )
 566 {
 567   EFI_SERVICE_BINDING_PROTOCOL             *ServiceBinding;
 568   IP4_SERVICE                              *IpSb;
 569   EFI_HANDLE                               NicHandle;
 570   EFI_STATUS                               Status;
 571   INTN                                     State;
 572   LIST_ENTRY                               *List;
 573   IP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT  Context;
 574
 575   //
 576   // IP4 driver opens the MNP child, ARP children or the IP4_CONFIG protocol
 577   // by driver. So the ControllerHandle may be the MNP child handle, ARP child
 578   // handle, or the NIC (UNDI) handle because IP4_CONFIG protocol is installed
 579   // in the NIC handle.
 580   //
 581   //
 582   // First, check whether it is the IP4_CONFIG protocol being uninstalled.
 583   // IP4_CONFIG protocol is installed on the NIC handle. It isn't necessary
 584   // to clean up the default configuration if IP4_CONFIG is being stopped.
 585   //
 586   Status = gBS->OpenProtocol (
 587                   ControllerHandle,
 588                   &gEfiIp4ConfigProtocolGuid,
 589                   NULL,
 590                   This->DriverBindingHandle,
 591                   ControllerHandle,
 592                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 593                   );
 594   if (Status == EFI_SUCCESS) {
 595     //
 596     // Retrieve the IP4 service binding protocol. If failed, it is
 597     // likely that Ip4 ServiceBinding is uninstalled already. In this
 598     // case, return immediately.
 599     //
 600     Status = gBS->OpenProtocol (
 601                     ControllerHandle,
 602                     &gEfiIp4ServiceBindingProtocolGuid,
 603                     (VOID **) &ServiceBinding,
 604                     This->DriverBindingHandle,
 605                     ControllerHandle,
 606                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 607                     );
 608     if (EFI_ERROR (Status)) {
 609       return EFI_DEVICE_ERROR;
 610     }
 611
 612     IpSb = IP4_SERVICE_FROM_PROTOCOL (ServiceBinding);
 613     if (IpSb->Ip4Config != NULL && (IpSb->State != IP4_SERVICE_DESTROY)) {
 614
 615       IpSb->Ip4Config->Stop (IpSb->Ip4Config);
 616
 617       Status = gBS->CloseProtocol (
 618                       ControllerHandle,
 619                       &gEfiIp4ConfigProtocolGuid,
 620                       IpSb->Image,
 621                       ControllerHandle
 622                       );
 623       if (EFI_ERROR (Status)) {
 624         return Status;
 625       }
 626
 627       //
 628       // If the auto configure hasn't complete, mark it as not started.
 629       //
 630       if (IpSb->State == IP4_SERVICE_STARTED) {
 631         IpSb->State = IP4_SERVICE_UNSTARTED;
 632       }
 633
 634       IpSb->Ip4Config = NULL;
 635       gBS->CloseEvent (IpSb->DoneEvent);
 636       gBS->CloseEvent (IpSb->ReconfigEvent);
 637     }
 638
 639     return EFI_SUCCESS;
 640   }
 641
 642   //
 643   // Either MNP or ARP protocol is being uninstalled. The controller
 644   // handle is either the MNP child or ARP child. But, the IP4's
 645   // service binding is installed on the NIC handle. So, need to open
 646   // the protocol info to find the NIC handle.
 647   //
 648   NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiManagedNetworkProtocolGuid);
 649   if (NicHandle == NULL) {
 650     NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiArpProtocolGuid);
 651     if (NicHandle == NULL) {
 652       return EFI_SUCCESS;
 653     }
 654   }
 655
 656   //
 657   // Retrieve the IP4 service binding protocol
 658   //
 659   Status = gBS->OpenProtocol (
 660                   NicHandle,
 661                   &gEfiIp4ServiceBindingProtocolGuid,
 662                   (VOID **) &ServiceBinding,
 663                   This->DriverBindingHandle,
 664                   NicHandle,
 665                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 666                   );
 667   if (EFI_ERROR (Status)) {
 668     return EFI_DEVICE_ERROR;
 669   }
 670
 671   IpSb   = IP4_SERVICE_FROM_PROTOCOL (ServiceBinding);
 672   if (NumberOfChildren != 0) {
 673     List = &IpSb->Children;
 674     Context.ServiceBinding    = ServiceBinding;
 675     Context.NumberOfChildren  = NumberOfChildren;
 676     Context.ChildHandleBuffer = ChildHandleBuffer;
 677     Status = NetDestroyLinkList (
 678                List,
 679                Ip4DestroyChildEntryInHandleBuffer,
 680                &Context,
 681                NULL
 682                );
 683   } else if (IsListEmpty (&IpSb->Children)) {
 684     State           = IpSb->State;
 685     IpSb->State     = IP4_SERVICE_DESTROY;
 686
 687     //
 688     // Clear the variable data.
 689     //
 690     Ip4ClearVariableData (IpSb);
 691
 692     //
 693     // OK, clean other resources then uninstall the service binding protocol.
 694     //
 695     Status = Ip4CleanService (IpSb);
 696     if (EFI_ERROR (Status)) {
 697       IpSb->State = State;
 698       goto ON_ERROR;
 699     }
 700
 701     gBS->UninstallProtocolInterface (
 702            NicHandle,
 703            &gEfiIp4ServiceBindingProtocolGuid,
 704            ServiceBinding
 705            );
 706
 707     if (gIp4ControllerNameTable != NULL) {
 708       FreeUnicodeStringTable (gIp4ControllerNameTable);
 709       gIp4ControllerNameTable = NULL;
 710     }
 711     FreePool (IpSb);
 712   }
 713
 714 ON_ERROR:
 715   return Status;
 716 }
 717
 718
 719 /**
 720   Creates a child handle and installs a protocol.
 721
 722   The CreateChild() function installs a protocol on ChildHandle.
 723   If ChildHandle is a pointer to NULL, then a new handle is created and returned in ChildHandle.
 724   If ChildHandle is not a pointer to NULL, then the protocol installs on the existing ChildHandle.
 725
 726   @param  This        Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
 727   @param  ChildHandle Pointer to the handle of the child to create. If it is NULL,
 728                       then a new handle is created. If it is a pointer to an existing UEFI handle,
 729                       then the protocol is added to the existing UEFI handle.
 730
 731   @retval EFI_SUCCES            The protocol was added to ChildHandle.
 732   @retval EFI_INVALID_PARAMETER ChildHandle is NULL.
 733   @retval EFI_OUT_OF_RESOURCES  There are not enough resources availabe to create
 734                                 the child
 735   @retval other                 The child handle was not created
 736
 737 **/
 738 EFI_STATUS
 739 EFIAPI
 740 Ip4ServiceBindingCreateChild (
 741   IN EFI_SERVICE_BINDING_PROTOCOL  *This,
 742   IN OUT EFI_HANDLE                *ChildHandle
 743   )
 744 {
 745   IP4_SERVICE               *IpSb;
 746   IP4_PROTOCOL              *IpInstance;
 747   EFI_TPL                   OldTpl;
 748   EFI_STATUS                Status;
 749   VOID                      *Mnp;
 750
 751   if ((This == NULL) || (ChildHandle == NULL)) {
 752     return EFI_INVALID_PARAMETER;
 753   }
 754
 755   IpSb       = IP4_SERVICE_FROM_PROTOCOL (This);
 756   IpInstance = AllocatePool (sizeof (IP4_PROTOCOL));
 757
 758   if (IpInstance == NULL) {
 759     return EFI_OUT_OF_RESOURCES;
 760   }
 761
 762   Ip4InitProtocol (IpSb, IpInstance);
 763
 764   //
 765   // Install Ip4 onto ChildHandle
 766   //
 767   Status = gBS->InstallMultipleProtocolInterfaces (
 768                   ChildHandle,
 769                   &gEfiIp4ProtocolGuid,
 770                   &IpInstance->Ip4Proto,
 771                   NULL
 772                   );
 773
 774   if (EFI_ERROR (Status)) {
 775     goto ON_ERROR;
 776   }
 777
 778   IpInstance->Handle = *ChildHandle;
 779
 780   //
 781   // Open the Managed Network protocol BY_CHILD.
 782   //
 783   Status = gBS->OpenProtocol (
 784                   IpSb->MnpChildHandle,
 785                   &gEfiManagedNetworkProtocolGuid,
 786                   (VOID **) &Mnp,
 787                   gIp4DriverBinding.DriverBindingHandle,
 788                   IpInstance->Handle,
 789                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 790                   );
 791   if (EFI_ERROR (Status)) {
 792     gBS->UninstallMultipleProtocolInterfaces (
 793            ChildHandle,
 794            &gEfiIp4ProtocolGuid,
 795            &IpInstance->Ip4Proto,
 796            NULL
 797            );
 798
 799     goto ON_ERROR;
 800   }
 801
 802   //
 803   // Insert it into the service binding instance.
 804   //
 805   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 806
 807   InsertTailList (&IpSb->Children, &IpInstance->Link);
 808   IpSb->NumChildren++;
 809
 810   gBS->RestoreTPL (OldTpl);
 811
 812 ON_ERROR:
 813
 814   if (EFI_ERROR (Status)) {
 815
 816     Ip4CleanProtocol (IpInstance);
 817
 818     FreePool (IpInstance);
 819   }
 820
 821   return Status;
 822 }
 823
 824
 825 /**
 826   Destroys a child handle with a protocol installed on it.
 827
 828   The DestroyChild() function does the opposite of CreateChild(). It removes a protocol
 829   that was installed by CreateChild() from ChildHandle. If the removed protocol is the
 830   last protocol on ChildHandle, then ChildHandle is destroyed.
 831
 832   @param  This        Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
 833   @param  ChildHandle Handle of the child to destroy
 834
 835   @retval EFI_SUCCES            The protocol was removed from ChildHandle.
 836   @retval EFI_UNSUPPORTED       ChildHandle does not support the protocol that is being removed.
 837   @retval EFI_INVALID_PARAMETER Child handle is NULL.
 838   @retval EFI_ACCESS_DENIED     The protocol could not be removed from the ChildHandle
 839                                 because its services are being used.
 840   @retval other                 The child handle was not destroyed
 841
 842 **/
 843 EFI_STATUS
 844 EFIAPI
 845 Ip4ServiceBindingDestroyChild (
 846   IN EFI_SERVICE_BINDING_PROTOCOL  *This,
 847   IN EFI_HANDLE                    ChildHandle
 848   )
 849 {
 850   EFI_STATUS                Status;
 851   IP4_SERVICE               *IpSb;
 852   IP4_PROTOCOL              *IpInstance;
 853   EFI_IP4_PROTOCOL          *Ip4;
 854   EFI_TPL                   OldTpl;
 855   INTN                      State;
 856
 857   if ((This == NULL) || (ChildHandle == NULL)) {
 858     return EFI_INVALID_PARAMETER;
 859   }
 860
 861   //
 862   // Retrieve the private context data structures
 863   //
 864   IpSb   = IP4_SERVICE_FROM_PROTOCOL (This);
 865
 866   Status = gBS->OpenProtocol (
 867                   ChildHandle,
 868                   &gEfiIp4ProtocolGuid,
 869                   (VOID **) &Ip4,
 870                   gIp4DriverBinding.DriverBindingHandle,
 871                   ChildHandle,
 872                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 873                   );
 874
 875   if (EFI_ERROR (Status)) {
 876     return EFI_UNSUPPORTED;
 877   }
 878
 879   IpInstance = IP4_INSTANCE_FROM_PROTOCOL (Ip4);
 880
 881   if (IpInstance->Service != IpSb) {
 882     return EFI_INVALID_PARAMETER;
 883   }
 884
 885   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 886
 887   //
 888   // A child can be destroyed more than once. For example,
 889   // Ip4DriverBindingStop will destroy all of its children.
 890   // when UDP driver is being stopped, it will destroy all
 891   // the IP child it opens.
 892   //
 893   if (IpInstance->State == IP4_STATE_DESTROY) {
 894     gBS->RestoreTPL (OldTpl);
 895     return EFI_SUCCESS;
 896   }
 897
 898   State             = IpInstance->State;
 899   IpInstance->State = IP4_STATE_DESTROY;
 900
 901   //
 902   // Close the Managed Network protocol.
 903   //
 904   gBS->CloseProtocol (
 905          IpSb->MnpChildHandle,
 906          &gEfiManagedNetworkProtocolGuid,
 907          gIp4DriverBinding.DriverBindingHandle,
 908          ChildHandle
 909          );
 910
 911   if (IpInstance->Interface != NULL && IpInstance->Interface->Arp != NULL) {
 912     gBS->CloseProtocol (
 913            IpInstance->Interface->ArpHandle,
 914            &gEfiArpProtocolGuid,
 915            gIp4DriverBinding.DriverBindingHandle,
 916            ChildHandle
 917            );
 918   }
 919
 920   //
 921   // Uninstall the IP4 protocol first. Many thing happens during
 922   // this:
 923   // 1. The consumer of the IP4 protocol will be stopped if it
 924   // opens the protocol BY_DRIVER. For eaxmple, if MNP driver is
 925   // stopped, IP driver's stop function will be called, and uninstall
 926   // EFI_IP4_PROTOCOL will trigger the UDP's stop function. This
 927   // makes it possible to create the network stack bottom up, and
 928   // stop it top down.
 929   // 2. the upper layer will recycle the received packet. The recycle
 930   // event's TPL is higher than this function. The recycle events
 931   // will be called back before preceeding. If any packets not recycled,
 932   // that means there is a resource leak.
 933   //
 934   gBS->RestoreTPL (OldTpl);
 935   Status = gBS->UninstallProtocolInterface (
 936                   ChildHandle,
 937                   &gEfiIp4ProtocolGuid,
 938                   &IpInstance->Ip4Proto
 939                   );
 940   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 941   if (EFI_ERROR (Status)) {
 942     goto ON_ERROR;
 943   }
 944
 945   Status = Ip4CleanProtocol (IpInstance);
 946
 947   Ip4SetVariableData (IpSb);
 948
 949   if (EFI_ERROR (Status)) {
 950     gBS->InstallMultipleProtocolInterfaces (
 951            &ChildHandle,
 952            &gEfiIp4ProtocolGuid,
 953            Ip4,
 954            NULL
 955            );
 956
 957     goto ON_ERROR;
 958   }
 959
 960   RemoveEntryList (&IpInstance->Link);
 961   IpSb->NumChildren--;
 962
 963   gBS->RestoreTPL (OldTpl);
 964
 965   FreePool (IpInstance);
 966   return EFI_SUCCESS;
 967
 968 ON_ERROR:
 969   IpInstance->State = State;
 970   gBS->RestoreTPL (OldTpl);
 971
 972   return Status;
 973 }