NetworkPkg/Ip6Dxe/Ip6Driver.c

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