NetworkPkg/Ip6Dxe/Ip6Driver.c

   1 /** @file
   2   The driver binding and service binding protocol for IP6 driver.
   3
   4   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
   5
   6   This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php.
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "Ip6Impl.h"
  17
  18 EFI_DRIVER_BINDING_PROTOCOL gIp6DriverBinding = {
  19   Ip6DriverBindingSupported,
  20   Ip6DriverBindingStart,
  21   Ip6DriverBindingStop,
  22   0xa,
  23   NULL,
  24   NULL
  25 };
  26
  27 /**
  28   This is the declaration of an EFI image entry point. This entry point is
  29   the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including
  30   both device drivers and bus drivers.
  31
  32   The entry point for IP6 driver which installs the driver
  33   binding and component name protocol on its image.
  34
  35   @param[in]  ImageHandle           The firmware allocated handle for the UEFI image.
  36   @param[in]  SystemTable           A pointer to the EFI System Table.
  37
  38   @retval EFI_SUCCESS           The operation completed successfully.
  39   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
  40
  41 **/
  42 EFI_STATUS
  43 EFIAPI
  44 Ip6DriverEntryPoint (
  45   IN EFI_HANDLE             ImageHandle,
  46   IN EFI_SYSTEM_TABLE       *SystemTable
  47   )
  48 {
  49   return EfiLibInstallDriverBindingComponentName2 (
  50            ImageHandle,
  51            SystemTable,
  52            &gIp6DriverBinding,
  53            ImageHandle,
  54            &gIp6ComponentName,
  55            &gIp6ComponentName2
  56            );
  57 }
  58
  59 /**
  60   Test to see if this driver supports ControllerHandle.
  61
  62   @param[in]  This                   Protocol instance pointer.
  63   @param[in]  ControllerHandle       Handle of device to test.
  64   @param[in]  RemainingDevicePath    Optional parameter use to pick a specific child
  65                                      device to start.
  66
  67   @retval EFI_SUCCESS                This driver supports this device.
  68   @retval EFI_ALREADY_STARTED        This driver is already running on this device.
  69   @retval other                      This driver does not support this device.
  70
  71 **/
  72 EFI_STATUS
  73 EFIAPI
  74 Ip6DriverBindingSupported (
  75   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  76   IN EFI_HANDLE                   ControllerHandle,
  77   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
  78   )
  79 {
  80   //
  81   // Test for the MNP service binding Protocol
  82   //
  83   return gBS->OpenProtocol (
  84                 ControllerHandle,
  85                 &gEfiManagedNetworkServiceBindingProtocolGuid,
  86                 NULL,
  87                 This->DriverBindingHandle,
  88                 ControllerHandle,
  89                 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
  90                 );
  91 }
  92
  93 /**
  94   Clean up an IP6 service binding instance. It releases all
  95   the resource allocated by the instance. The instance may be
  96   partly initialized, or partly destroyed. If a resource is
  97   destroyed, it is marked as that in case the destory failed and
  98   being called again later.
  99
 100   @param[in]  IpSb               The IP6 service binding instance to clean up.
 101
 102   @retval EFI_SUCCESS            The resource used by the instance are cleaned up.
 103   @retval Others                 Failed to clean up some of the resources.
 104
 105 **/
 106 EFI_STATUS
 107 Ip6CleanService (
 108   IN IP6_SERVICE            *IpSb
 109   )
 110 {
 111   EFI_STATUS                Status;
 112   EFI_IPv6_ADDRESS          AllNodes;
 113   IP6_NEIGHBOR_ENTRY        *NeighborCache;
 114
 115   Ip6ConfigCleanInstance (&IpSb->Ip6ConfigInstance);
 116
 117   //
 118   // Leave link-scope all-nodes multicast address (FF02::1)
 119   //
 120   Ip6SetToAllNodeMulticast (FALSE, IP6_LINK_LOCAL_SCOPE, &AllNodes);
 121
 122   Status = Ip6LeaveGroup (IpSb, &AllNodes);
 123   if (EFI_ERROR (Status)) {
 124     return Status;
 125   }
 126
 127   if (IpSb->DefaultInterface != NULL) {
 128     Ip6CleanInterface (IpSb->DefaultInterface, NULL);
 129     IpSb->DefaultInterface = NULL;
 130   }
 131
 132   Ip6CleanDefaultRouterList (IpSb);
 133
 134   Ip6CleanPrefixListTable (IpSb, &IpSb->OnlinkPrefix);
 135   Ip6CleanPrefixListTable (IpSb, &IpSb->AutonomousPrefix);
 136
 137   if (IpSb->RouteTable != NULL) {
 138     Ip6CleanRouteTable (IpSb->RouteTable);
 139     IpSb->RouteTable = NULL;
 140   }
 141
 142   if (IpSb->InterfaceId != NULL) {
 143     FreePool (IpSb->InterfaceId);
 144   }
 145
 146   IpSb->InterfaceId = NULL;
 147
 148   Ip6CleanAssembleTable (&IpSb->Assemble);
 149
 150   if (IpSb->MnpChildHandle != NULL) {
 151     if (IpSb->Mnp != NULL) {
 152       IpSb->Mnp->Cancel (IpSb->Mnp, NULL);
 153       IpSb->Mnp->Configure (IpSb->Mnp, NULL);
 154       gBS->CloseProtocol (
 155             IpSb->MnpChildHandle,
 156             &gEfiManagedNetworkProtocolGuid,
 157             IpSb->Image,
 158             IpSb->Controller
 159             );
 160
 161       IpSb->Mnp = NULL;
 162     }
 163
 164     NetLibDestroyServiceChild (
 165       IpSb->Controller,
 166       IpSb->Image,
 167       &gEfiManagedNetworkServiceBindingProtocolGuid,
 168       IpSb->MnpChildHandle
 169       );
 170
 171     IpSb->MnpChildHandle = NULL;
 172   }
 173
 174   if (IpSb->RecvRequest.MnpToken.Event != NULL) {
 175     gBS->CloseEvent (IpSb->RecvRequest.MnpToken.Event);
 176   }
 177
 178   if (IpSb->Timer != NULL) {
 179     gBS->SetTimer (IpSb->Timer, TimerCancel, 0);
 180     gBS->CloseEvent (IpSb->Timer);
 181
 182     IpSb->Timer = NULL;
 183   }
 184
 185   if (IpSb->FasterTimer != NULL) {
 186     gBS->SetTimer (IpSb->FasterTimer, TimerCancel, 0);
 187     gBS->CloseEvent (IpSb->FasterTimer);
 188
 189     IpSb->FasterTimer = NULL;
 190   }
 191   //
 192   // Free the Neighbor Discovery resources
 193   //
 194   while (!IsListEmpty (&IpSb->NeighborTable)) {
 195     NeighborCache = NET_LIST_HEAD (&IpSb->NeighborTable, IP6_NEIGHBOR_ENTRY, Link);
 196     Ip6FreeNeighborEntry (IpSb, NeighborCache, FALSE, TRUE, EFI_SUCCESS, NULL, NULL);
 197   }
 198
 199   return EFI_SUCCESS;
 200 }
 201
 202 /**
 203   Create a new IP6 driver service binding protocol.
 204
 205   @param[in]  Controller         The controller that has MNP service binding
 206                                  installed.
 207   @param[in]  ImageHandle        The IP6 driver's image handle.
 208   @param[out]  Service           The variable to receive the newly created IP6
 209                                  service.
 210
 211   @retval EFI_OUT_OF_RESOURCES   Failed to allocate some resources.
 212   @retval EFI_SUCCESS            A new IP6 service binding private is created.
 213
 214 **/
 215 EFI_STATUS
 216 Ip6CreateService (
 217   IN  EFI_HANDLE            Controller,
 218   IN  EFI_HANDLE            ImageHandle,
 219   OUT IP6_SERVICE           **Service
 220   )
 221 {
 222   IP6_SERVICE                           *IpSb;
 223   EFI_STATUS                            Status;
 224   EFI_MANAGED_NETWORK_COMPLETION_TOKEN  *MnpToken;
 225   EFI_MANAGED_NETWORK_CONFIG_DATA       *Config;
 226   IP6_CONFIG_DATA_ITEM                  *DataItem;
 227
 228   ASSERT (Service != NULL);
 229
 230   *Service = NULL;
 231
 232   //
 233   // allocate a service private data then initialize all the filed to
 234   // empty resources, so if any thing goes wrong when allocating
 235   // resources, Ip6CleanService can be called to clean it up.
 236   //
 237   IpSb = AllocateZeroPool (sizeof (IP6_SERVICE));
 238
 239   if (IpSb == NULL) {
 240     return EFI_OUT_OF_RESOURCES;
 241   }
 242
 243   IpSb->Signature                   = IP6_SERVICE_SIGNATURE;
 244   IpSb->ServiceBinding.CreateChild  = Ip6ServiceBindingCreateChild;
 245   IpSb->ServiceBinding.DestroyChild = Ip6ServiceBindingDestroyChild;
 246   IpSb->State                       = IP6_SERVICE_UNSTARTED;
 247   IpSb->InDestroy                   = FALSE;
 248
 249   IpSb->NumChildren                 = 0;
 250   InitializeListHead (&IpSb->Children);
 251
 252   InitializeListHead (&IpSb->Interfaces);
 253   IpSb->DefaultInterface            = NULL;
 254   IpSb->RouteTable                  = NULL;
 255
 256   IpSb->RecvRequest.Signature       = IP6_LINK_RX_SIGNATURE;
 257   IpSb->RecvRequest.CallBack        = NULL;
 258   IpSb->RecvRequest.Context         = NULL;
 259   MnpToken                          = &IpSb->RecvRequest.MnpToken;
 260   MnpToken->Event                   = NULL;
 261   MnpToken->Status                  = EFI_NOT_READY;
 262   MnpToken->Packet.RxData           = NULL;
 263
 264   Ip6CreateAssembleTable (&IpSb->Assemble);
 265
 266   IpSb->MldCtrl.Mldv1QuerySeen      = 0;
 267   InitializeListHead (&IpSb->MldCtrl.Groups);
 268
 269   ZeroMem (&IpSb->LinkLocalAddr, sizeof (EFI_IPv6_ADDRESS));
 270   IpSb->LinkLocalOk                 = FALSE;
 271   IpSb->LinkLocalDadFail            = FALSE;
 272   IpSb->Dhcp6NeedStart              = FALSE;
 273   IpSb->Dhcp6NeedInfoRequest        = FALSE;
 274
 275   IpSb->CurHopLimit                 = IP6_HOP_LIMIT;
 276   IpSb->LinkMTU                     = IP6_MIN_LINK_MTU;
 277   IpSb->BaseReachableTime           = IP6_REACHABLE_TIME;
 278   Ip6UpdateReachableTime (IpSb);
 279   //
 280   // RFC4861 RETRANS_TIMER: 1,000 milliseconds
 281   //
 282   IpSb->RetransTimer                = IP6_RETRANS_TIMER;
 283
 284   IpSb->RoundRobin                  = 0;
 285
 286   InitializeListHead (&IpSb->NeighborTable);
 287   InitializeListHead (&IpSb->DefaultRouterList);
 288   InitializeListHead (&IpSb->OnlinkPrefix);
 289   InitializeListHead (&IpSb->AutonomousPrefix);
 290
 291   IpSb->InterfaceIdLen              = IP6_IF_ID_LEN;
 292   IpSb->InterfaceId                 = NULL;
 293
 294   IpSb->RouterAdvertiseReceived     = FALSE;
 295   IpSb->SolicitTimer                = IP6_MAX_RTR_SOLICITATIONS;
 296   IpSb->Ticks                       = 0;
 297
 298   IpSb->Image                       = ImageHandle;
 299   IpSb->Controller                  = Controller;
 300
 301   IpSb->MnpChildHandle              = NULL;
 302   IpSb->Mnp                         = NULL;
 303
 304   Config                            = &IpSb->MnpConfigData;
 305   Config->ReceivedQueueTimeoutValue = 0;
 306   Config->TransmitQueueTimeoutValue = 0;
 307   Config->ProtocolTypeFilter        = IP6_ETHER_PROTO;
 308   Config->EnableUnicastReceive      = TRUE;
 309   Config->EnableMulticastReceive    = TRUE;
 310   Config->EnableBroadcastReceive    = TRUE;
 311   Config->EnablePromiscuousReceive  = FALSE;
 312   Config->FlushQueuesOnReset        = TRUE;
 313   Config->EnableReceiveTimestamps   = FALSE;
 314   Config->DisableBackgroundPolling  = FALSE;
 315
 316   ZeroMem (&IpSb->SnpMode, sizeof (EFI_SIMPLE_NETWORK_MODE));
 317
 318   IpSb->Timer                       = NULL;
 319   IpSb->FasterTimer                 = NULL;
 320
 321   ZeroMem (&IpSb->Ip6ConfigInstance, sizeof (IP6_CONFIG_INSTANCE));
 322
 323   IpSb->MacString                   = NULL;
 324
 325   //
 326   // Create various resources. First create the route table, timer
 327   // event, MNP token event and MNP child.
 328   //
 329
 330   IpSb->RouteTable = Ip6CreateRouteTable ();
 331   if (IpSb->RouteTable == NULL) {
 332     Status = EFI_OUT_OF_RESOURCES;
 333     goto ON_ERROR;
 334   }
 335
 336   Status = gBS->CreateEvent (
 337                   EVT_NOTIFY_SIGNAL | EVT_TIMER,
 338                   TPL_CALLBACK,
 339                   Ip6TimerTicking,
 340                   IpSb,
 341                   &IpSb->Timer
 342                   );
 343   if (EFI_ERROR (Status)) {
 344     goto ON_ERROR;
 345   }
 346
 347   Status = gBS->CreateEvent (
 348                   EVT_NOTIFY_SIGNAL | EVT_TIMER,
 349                   TPL_CALLBACK,
 350                   Ip6NdFasterTimerTicking,
 351                   IpSb,
 352                   &IpSb->FasterTimer
 353                   );
 354   if (EFI_ERROR (Status)) {
 355     goto ON_ERROR;
 356   }
 357
 358   Status = NetLibCreateServiceChild (
 359              Controller,
 360              ImageHandle,
 361              &gEfiManagedNetworkServiceBindingProtocolGuid,
 362              &IpSb->MnpChildHandle
 363              );
 364   if (EFI_ERROR (Status)) {
 365     goto ON_ERROR;
 366   }
 367
 368   Status = gBS->OpenProtocol (
 369                   IpSb->MnpChildHandle,
 370                   &gEfiManagedNetworkProtocolGuid,
 371                   (VOID **) (&IpSb->Mnp),
 372                   ImageHandle,
 373                   Controller,
 374                   EFI_OPEN_PROTOCOL_BY_DRIVER
 375                   );
 376   if (EFI_ERROR (Status)) {
 377     goto ON_ERROR;
 378   }
 379
 380   Status = Ip6ServiceConfigMnp (IpSb, TRUE);
 381   if (EFI_ERROR (Status)) {
 382     goto ON_ERROR;
 383   }
 384
 385   Status = IpSb->Mnp->GetModeData (IpSb->Mnp, NULL, &IpSb->SnpMode);
 386   if (EFI_ERROR (Status)) {
 387     goto ON_ERROR;
 388   }
 389
 390   IpSb->MaxPacketSize = IP6_MIN_LINK_MTU - sizeof (EFI_IP6_HEADER);
 391   if (NetLibGetVlanId (IpSb->Controller) != 0) {
 392     //
 393     // This is a VLAN device, reduce MTU by VLAN tag length
 394     //
 395     IpSb->MaxPacketSize -= NET_VLAN_TAG_LEN;
 396   }
 397   IpSb->OldMaxPacketSize = IpSb->MaxPacketSize;
 398
 399   //
 400   // Currently only ETHERNET is supported in IPv6 stack, since
 401   // link local address requires an IEEE 802 48-bit MACs for
 402   // EUI-64 format interface identifier mapping.
 403   //
 404   if (IpSb->SnpMode.IfType != NET_IFTYPE_ETHERNET) {
 405     Status = EFI_UNSUPPORTED;
 406     goto ON_ERROR;
 407   }
 408
 409   Status = Ip6InitMld (IpSb);
 410   if (EFI_ERROR (Status)) {
 411     goto ON_ERROR;
 412   }
 413
 414   //
 415   // The timer expires every 100 (IP6_TIMER_INTERVAL_IN_MS) milliseconds.
 416   //
 417   Status = gBS->SetTimer (IpSb->FasterTimer, TimerPeriodic, TICKS_PER_MS * IP6_TIMER_INTERVAL_IN_MS);
 418   if (EFI_ERROR (Status)) {
 419     goto ON_ERROR;
 420   }
 421
 422   //
 423   // The timer expires every 1000 (IP6_ONE_SECOND_IN_MS) milliseconds.
 424   //
 425   Status = gBS->SetTimer (IpSb->Timer, TimerPeriodic, TICKS_PER_MS * IP6_ONE_SECOND_IN_MS);
 426   if (EFI_ERROR (Status)) {
 427     goto ON_ERROR;
 428   }
 429
 430
 431   Status = gBS->CreateEvent (
 432                   EVT_NOTIFY_SIGNAL,
 433                   TPL_NOTIFY,
 434                   Ip6OnFrameReceived,
 435                   &IpSb->RecvRequest,
 436                   &MnpToken->Event
 437                   );
 438   if (EFI_ERROR (Status)) {
 439     goto ON_ERROR;
 440   }
 441
 442   Status = Ip6ReceiveFrame (Ip6AcceptFrame, IpSb);
 443   if (EFI_ERROR (Status)) {
 444     goto ON_ERROR;
 445   }
 446
 447   Status = NetLibGetMacString (IpSb->Controller, IpSb->Image, &IpSb->MacString);
 448   if (EFI_ERROR (Status)) {
 449     goto ON_ERROR;
 450   }
 451
 452   Status = Ip6ConfigInitInstance (&IpSb->Ip6ConfigInstance);
 453   if (EFI_ERROR (Status)) {
 454     goto ON_ERROR;
 455   }
 456
 457   IpSb->DefaultInterface = Ip6CreateInterface (IpSb, TRUE);
 458   if (IpSb->DefaultInterface == NULL) {
 459     Status = EFI_DEVICE_ERROR;
 460     goto ON_ERROR;
 461   }
 462
 463   //
 464   // If there is any manual address, set it.
 465   //
 466   DataItem = &IpSb->Ip6ConfigInstance.DataItem[Ip6ConfigDataTypeManualAddress];
 467   if (DataItem->Data.Ptr != NULL) {
 468     DataItem->SetData (
 469                 &IpSb->Ip6ConfigInstance,
 470                 DataItem->DataSize,
 471                 DataItem->Data.Ptr
 472                 );
 473   }
 474
 475   InsertHeadList (&IpSb->Interfaces, &IpSb->DefaultInterface->Link);
 476
 477   *Service = IpSb;
 478   return EFI_SUCCESS;
 479
 480 ON_ERROR:
 481   Ip6CleanService (IpSb);
 482   FreePool (IpSb);
 483   return Status;
 484 }
 485
 486
 487 /**
 488   Start this driver on ControllerHandle.
 489
 490   @param[in]  This                Protocol instance pointer.
 491   @param[in]  ControllerHandle    Handle of device to bind driver to.
 492   @param[in]  RemainingDevicePath Optional parameter used to pick a specific child
 493                                   device to start.
 494
 495   @retval EFI_SUCCES              This driver is added to ControllerHandle.
 496   @retval EFI_ALREADY_STARTED     This driver is already running on ControllerHandle.
 497   @retval other                   This driver does not support this device.
 498
 499 **/
 500 EFI_STATUS
 501 EFIAPI
 502 Ip6DriverBindingStart (
 503   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 504   IN EFI_HANDLE                   ControllerHandle,
 505   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
 506   )
 507 {
 508   IP6_SERVICE               *IpSb;
 509   EFI_STATUS                Status;
 510
 511   //
 512   // Test for the Ip6 service binding protocol
 513   //
 514   Status = gBS->OpenProtocol (
 515                   ControllerHandle,
 516                   &gEfiIp6ServiceBindingProtocolGuid,
 517                   NULL,
 518                   This->DriverBindingHandle,
 519                   ControllerHandle,
 520                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 521                   );
 522
 523   if (Status == EFI_SUCCESS) {
 524     return EFI_ALREADY_STARTED;
 525   }
 526
 527   Status = Ip6CreateService (ControllerHandle, This->DriverBindingHandle, &IpSb);
 528
 529   if (EFI_ERROR (Status)) {
 530     return Status;
 531   }
 532
 533   ASSERT (IpSb != NULL);
 534
 535   //
 536   // Install the Ip6ServiceBinding Protocol onto ControlerHandle
 537   //
 538   Status = gBS->InstallMultipleProtocolInterfaces (
 539                   &ControllerHandle,
 540                   &gEfiIp6ServiceBindingProtocolGuid,
 541                   &IpSb->ServiceBinding,
 542                   &gEfiIp6ConfigProtocolGuid,
 543                   &IpSb->Ip6ConfigInstance.Ip6Config,
 544                   NULL
 545                   );
 546
 547   if (EFI_ERROR (Status)) {
 548
 549     Ip6CleanService (IpSb);
 550     FreePool (IpSb);
 551   } else {
 552     //
 553     // Initialize the IP6 ID
 554     //
 555     mIp6Id = NET_RANDOM (NetRandomInitSeed ());
 556
 557     Ip6SetVariableData (IpSb);
 558   }
 559
 560   return Status;
 561 }
 562
 563 /**
 564   Stop this driver on ControllerHandle.
 565
 566   @param[in]  This               Protocol instance pointer.
 567   @param[in]  ControllerHandle   Handle of device to stop driver on.
 568   @param[in]  NumberOfChildren   Number of Handles in ChildHandleBuffer. If number
 569                                  of children is zero, stop the entire  bus driver.
 570   @param[in]  ChildHandleBuffer  An array of child handles to be freed. May be NULL
 571                                  if NumberOfChildren is 0.
 572
 573   @retval EFI_SUCCESS           The device was stopped.
 574   @retval EFI_DEVICE_ERROR      The device could not be stopped due to a device error.
 575
 576 **/
 577 EFI_STATUS
 578 EFIAPI
 579 Ip6DriverBindingStop (
 580   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 581   IN  EFI_HANDLE                   ControllerHandle,
 582   IN  UINTN                        NumberOfChildren,
 583   IN  EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
 584   )
 585 {
 586   EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
 587   IP6_SERVICE                   *IpSb;
 588   IP6_PROTOCOL                  *IpInstance;
 589   EFI_HANDLE                    NicHandle;
 590   EFI_STATUS                    Status;
 591   BOOLEAN                       IsDhcp6;
 592   EFI_TPL                       OldTpl;
 593   INTN                          State;
 594
 595   IsDhcp6   = FALSE;
 596   NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiDhcp6ProtocolGuid);
 597
 598   if (NicHandle != NULL) {
 599     //
 600     // DriverBindingStop is triggered by the uninstallation of the EFI DHCPv6
 601     // Protocol used by Ip6Config.
 602     //
 603     IsDhcp6 = TRUE;
 604   } else {
 605
 606     NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiManagedNetworkProtocolGuid);
 607
 608     if (NicHandle == NULL) {
 609       return EFI_DEVICE_ERROR;
 610     }
 611   }
 612
 613   Status = gBS->OpenProtocol (
 614                   NicHandle,
 615                   &gEfiIp6ServiceBindingProtocolGuid,
 616                   (VOID **) &ServiceBinding,
 617                   This->DriverBindingHandle,
 618                   NicHandle,
 619                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 620                   );
 621   if (EFI_ERROR (Status)) {
 622     return EFI_DEVICE_ERROR;
 623   }
 624
 625   IpSb = IP6_SERVICE_FROM_PROTOCOL (ServiceBinding);
 626
 627   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 628
 629   if (IpSb->InDestroy) {
 630     Status = EFI_SUCCESS;
 631     goto Exit;
 632   }
 633
 634   if (IsDhcp6) {
 635
 636     Status = Ip6ConfigDestroyDhcp6 (&IpSb->Ip6ConfigInstance);
 637     gBS->CloseEvent (IpSb->Ip6ConfigInstance.Dhcp6Event);
 638     IpSb->Ip6ConfigInstance.Dhcp6Event = NULL;
 639   } else if (NumberOfChildren == 0) {
 640
 641     IpSb->InDestroy = TRUE;
 642     State           = IpSb->State;
 643     IpSb->State     = IP6_SERVICE_DESTROY;
 644
 645     //
 646     // Clear the variable data.
 647     //
 648     Ip6ClearVariableData (IpSb);
 649
 650     Status = Ip6CleanService (IpSb);
 651     if (EFI_ERROR (Status)) {
 652       IpSb->State = State;
 653       goto Exit;
 654     }
 655
 656     Status = gBS->UninstallMultipleProtocolInterfaces (
 657                     NicHandle,
 658                     &gEfiIp6ServiceBindingProtocolGuid,
 659                     ServiceBinding,
 660                     &gEfiIp6ConfigProtocolGuid,
 661                     &IpSb->Ip6ConfigInstance.Ip6Config,
 662                     NULL
 663                     );
 664     ASSERT_EFI_ERROR (Status);
 665     FreePool (IpSb);
 666   } else {
 667     //
 668     // NumberOfChildren is not zero, destroy all IP6 children instances.
 669     //
 670     while (!IsListEmpty (&IpSb->Children)) {
 671       IpInstance = NET_LIST_HEAD (&IpSb->Children, IP6_PROTOCOL, Link);
 672       ServiceBinding->DestroyChild (ServiceBinding, IpInstance->Handle);
 673     }
 674
 675     if (IpSb->NumChildren != 0) {
 676       Status = EFI_DEVICE_ERROR;
 677     }
 678   }
 679
 680 Exit:
 681
 682   gBS->RestoreTPL (OldTpl);
 683
 684   return Status;
 685 }
 686
 687
 688 /**
 689   Creates a child handle with a set of I/O services.
 690
 691   @param[in]  This               Protocol instance pointer.
 692   @param[in]  ChildHandle        Pointer to the handle of the child to create.   If
 693                                  it is NULL, then a new handle is created.   If it
 694                                  is not NULL, then the I/O services are added to
 695                                  the existing child handle.
 696
 697   @retval EFI_SUCCES             The child handle was created with the I/O services.
 698   @retval EFI_OUT_OF_RESOURCES   There are not enough resources availabe to create
 699                                  the child.
 700   @retval other                  The child handle was not created.
 701
 702 **/
 703 EFI_STATUS
 704 EFIAPI
 705 Ip6ServiceBindingCreateChild (
 706   IN EFI_SERVICE_BINDING_PROTOCOL  *This,
 707   IN EFI_HANDLE                    *ChildHandle
 708   )
 709 {
 710   IP6_SERVICE               *IpSb;
 711   IP6_PROTOCOL              *IpInstance;
 712   EFI_TPL                   OldTpl;
 713   EFI_STATUS                Status;
 714   VOID                      *Mnp;
 715
 716   if ((This == NULL) || (ChildHandle == NULL)) {
 717     return EFI_INVALID_PARAMETER;
 718   }
 719
 720   IpSb       = IP6_SERVICE_FROM_PROTOCOL (This);
 721
 722   if (IpSb->LinkLocalDadFail) {
 723     return EFI_DEVICE_ERROR;
 724   }
 725
 726   IpInstance = AllocatePool (sizeof (IP6_PROTOCOL));
 727
 728   if (IpInstance == NULL) {
 729     return EFI_OUT_OF_RESOURCES;
 730   }
 731
 732   Ip6InitProtocol (IpSb, IpInstance);
 733
 734   //
 735   // Install Ip6 onto ChildHandle
 736   //
 737   Status = gBS->InstallMultipleProtocolInterfaces (
 738                   ChildHandle,
 739                   &gEfiIp6ProtocolGuid,
 740                   &IpInstance->Ip6Proto,
 741                   NULL
 742                   );
 743   if (EFI_ERROR (Status)) {
 744     goto ON_ERROR;
 745   }
 746
 747   IpInstance->Handle = *ChildHandle;
 748
 749   //
 750   // Open the Managed Network protocol BY_CHILD.
 751   //
 752   Status = gBS->OpenProtocol (
 753                   IpSb->MnpChildHandle,
 754                   &gEfiManagedNetworkProtocolGuid,
 755                   (VOID **) &Mnp,
 756                   gIp6DriverBinding.DriverBindingHandle,
 757                   IpInstance->Handle,
 758                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 759                   );
 760   if (EFI_ERROR (Status)) {
 761     gBS->UninstallMultipleProtocolInterfaces (
 762            ChildHandle,
 763            &gEfiIp6ProtocolGuid,
 764            &IpInstance->Ip6Proto,
 765            NULL
 766            );
 767
 768     goto ON_ERROR;
 769   }
 770
 771   //
 772   // Insert it into the service binding instance.
 773   //
 774   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 775
 776   InsertTailList (&IpSb->Children, &IpInstance->Link);
 777   IpSb->NumChildren++;
 778
 779   gBS->RestoreTPL (OldTpl);
 780
 781 ON_ERROR:
 782
 783   if (EFI_ERROR (Status)) {
 784
 785     Ip6CleanProtocol (IpInstance);
 786
 787     FreePool (IpInstance);
 788   }
 789
 790   return Status;
 791 }
 792
 793 /**
 794   Destroys a child handle with a set of I/O services.
 795
 796   @param[in]  This               Protocol instance pointer.
 797   @param[in]  ChildHandle        Handle of the child to destroy.
 798
 799   @retval EFI_SUCCES             The I/O services were removed from the child
 800                                  handle.
 801   @retval EFI_UNSUPPORTED        The child handle does not support the I/O services
 802                                   that are being removed.
 803   @retval EFI_INVALID_PARAMETER  Child handle is NULL.
 804   @retval EFI_ACCESS_DENIED      The child handle could not be destroyed because
 805                                  its I/O services are being used.
 806   @retval other                  The child handle was not destroyed.
 807
 808 **/
 809 EFI_STATUS
 810 EFIAPI
 811 Ip6ServiceBindingDestroyChild (
 812   IN EFI_SERVICE_BINDING_PROTOCOL  *This,
 813   IN EFI_HANDLE                    ChildHandle
 814   )
 815 {
 816   EFI_STATUS                Status;
 817   IP6_SERVICE               *IpSb;
 818   IP6_PROTOCOL              *IpInstance;
 819   EFI_IP6_PROTOCOL          *Ip6;
 820   EFI_TPL                   OldTpl;
 821   INTN                      State;
 822
 823   if ((This == NULL) || (ChildHandle == NULL)) {
 824     return EFI_INVALID_PARAMETER;
 825   }
 826
 827   //
 828   // Retrieve the private context data structures
 829   //
 830   IpSb   = IP6_SERVICE_FROM_PROTOCOL (This);
 831
 832   Status = gBS->OpenProtocol (
 833                   ChildHandle,
 834                   &gEfiIp6ProtocolGuid,
 835                   (VOID **) &Ip6,
 836                   gIp6DriverBinding.DriverBindingHandle,
 837                   ChildHandle,
 838                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 839                   );
 840
 841   if (EFI_ERROR (Status)) {
 842     return EFI_UNSUPPORTED;
 843   }
 844
 845   IpInstance = IP6_INSTANCE_FROM_PROTOCOL (Ip6);
 846
 847   if (IpInstance->Service != IpSb) {
 848     return EFI_INVALID_PARAMETER;
 849   }
 850
 851   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 852
 853   //
 854   // A child can be destroyed more than once. For example,
 855   // Ip6DriverBindingStop will destory all of its children.
 856   // when UDP driver is being stopped, it will destory all
 857   // the IP child it opens.
 858   //
 859   if (IpInstance->State == IP6_STATE_DESTROY) {
 860     gBS->RestoreTPL (OldTpl);
 861     return EFI_SUCCESS;
 862   }
 863
 864   State             = IpInstance->State;
 865   IpInstance->State = IP6_STATE_DESTROY;
 866
 867   //
 868   // Close the Managed Network protocol.
 869   //
 870   gBS->CloseProtocol (
 871          IpSb->MnpChildHandle,
 872          &gEfiManagedNetworkProtocolGuid,
 873          gIp6DriverBinding.DriverBindingHandle,
 874          ChildHandle
 875          );
 876
 877   //
 878   // Uninstall the IP6 protocol first. Many thing happens during
 879   // this:
 880   // 1. The consumer of the IP6 protocol will be stopped if it
 881   // opens the protocol BY_DRIVER. For eaxmple, if MNP driver is
 882   // stopped, IP driver's stop function will be called, and uninstall
 883   // EFI_IP6_PROTOCOL will trigger the UDP's stop function. This
 884   // makes it possible to create the network stack bottom up, and
 885   // stop it top down.
 886   // 2. the upper layer will recycle the received packet. The recycle
 887   // event's TPL is higher than this function. The recycle events
 888   // will be called back before preceeding. If any packets not recycled,
 889   // that means there is a resource leak.
 890   //
 891   Status = gBS->UninstallProtocolInterface (
 892                   ChildHandle,
 893                   &gEfiIp6ProtocolGuid,
 894                   &IpInstance->Ip6Proto
 895                   );
 896
 897   if (EFI_ERROR (Status)) {
 898     goto ON_ERROR;
 899   }
 900
 901   Status = Ip6CleanProtocol (IpInstance);
 902
 903   Ip6SetVariableData (IpSb);
 904
 905   if (EFI_ERROR (Status)) {
 906     gBS->InstallMultipleProtocolInterfaces (
 907            &ChildHandle,
 908            &gEfiIp6ProtocolGuid,
 909            Ip6,
 910            NULL
 911            );
 912
 913     goto ON_ERROR;
 914   }
 915
 916   RemoveEntryList (&IpInstance->Link);
 917   ASSERT (IpSb->NumChildren > 0);
 918   IpSb->NumChildren--;
 919
 920   gBS->RestoreTPL (OldTpl);
 921
 922   FreePool (IpInstance);
 923   return EFI_SUCCESS;
 924
 925 ON_ERROR:
 926   IpInstance->State = State;
 927   gBS->RestoreTPL (OldTpl);
 928
 929   return Status;
 930 }