VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/Dhcp4Dxe/Dhcp4Driver.c@ 99404

Last change on this file since 99404 was 99404, checked in by vboxsync, 2 years ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 20.2 KB
Line 
1/** @file
2
3Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
4SPDX-License-Identifier: BSD-2-Clause-Patent
5
6**/
7
8#include "Dhcp4Impl.h"
9#include "Dhcp4Driver.h"
10
11EFI_DRIVER_BINDING_PROTOCOL gDhcp4DriverBinding = {
12 Dhcp4DriverBindingSupported,
13 Dhcp4DriverBindingStart,
14 Dhcp4DriverBindingStop,
15 0xa,
16 NULL,
17 NULL
18};
19
20EFI_SERVICE_BINDING_PROTOCOL mDhcp4ServiceBindingTemplate = {
21 Dhcp4ServiceBindingCreateChild,
22 Dhcp4ServiceBindingDestroyChild
23};
24
25/**
26 This is the declaration of an EFI image entry point. This entry point is
27 the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including
28 both device drivers and bus drivers.
29
30 Entry point of the DHCP driver to install various protocols.
31
32 @param[in] ImageHandle The firmware allocated handle for the UEFI image.
33 @param[in] SystemTable A pointer to the EFI System Table.
34
35 @retval EFI_SUCCESS The operation completed successfully.
36 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
37
38**/
39EFI_STATUS
40EFIAPI
41Dhcp4DriverEntryPoint (
42 IN EFI_HANDLE ImageHandle,
43 IN EFI_SYSTEM_TABLE *SystemTable
44 )
45{
46 return EfiLibInstallDriverBindingComponentName2 (
47 ImageHandle,
48 SystemTable,
49 &gDhcp4DriverBinding,
50 ImageHandle,
51 &gDhcp4ComponentName,
52 &gDhcp4ComponentName2
53 );
54}
55
56/**
57 Test to see if this driver supports ControllerHandle. This service
58 is called by the EFI boot service ConnectController(). In
59 order to make drivers as small as possible, there are a few calling
60 restrictions for this service. ConnectController() must
61 follow these calling restrictions. If any other agent wishes to call
62 Supported() it must also follow these calling restrictions.
63
64 @param[in] This Protocol instance pointer.
65 @param[in] ControllerHandle Handle of device to test
66 @param[in] RemainingDevicePath Optional parameter use to pick a specific child
67 device to start.
68
69 @retval EFI_SUCCESS This driver supports this device
70 @retval EFI_ALREADY_STARTED This driver is already running on this device
71 @retval other This driver does not support this device
72
73**/
74EFI_STATUS
75EFIAPI
76Dhcp4DriverBindingSupported (
77 IN EFI_DRIVER_BINDING_PROTOCOL *This,
78 IN EFI_HANDLE ControllerHandle,
79 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
80 )
81{
82 EFI_STATUS Status;
83
84 Status = gBS->OpenProtocol (
85 ControllerHandle,
86 &gEfiUdp4ServiceBindingProtocolGuid,
87 NULL,
88 This->DriverBindingHandle,
89 ControllerHandle,
90 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
91 );
92
93 return Status;
94}
95
96/**
97 Configure the default UDP child to receive all the DHCP traffics
98 on this network interface.
99
100 @param[in] UdpIo The UDP IO to configure
101 @param[in] Context The context to the function
102
103 @retval EFI_SUCCESS The UDP IO is successfully configured.
104 @retval Others Failed to configure the UDP child.
105
106**/
107EFI_STATUS
108EFIAPI
109DhcpConfigUdpIo (
110 IN UDP_IO *UdpIo,
111 IN VOID *Context
112 )
113{
114 EFI_UDP4_CONFIG_DATA UdpConfigData;
115
116 UdpConfigData.AcceptBroadcast = TRUE;
117 UdpConfigData.AcceptPromiscuous = FALSE;
118 UdpConfigData.AcceptAnyPort = FALSE;
119 UdpConfigData.AllowDuplicatePort = TRUE;
120 UdpConfigData.TypeOfService = 0;
121 UdpConfigData.TimeToLive = 64;
122 UdpConfigData.DoNotFragment = FALSE;
123 UdpConfigData.ReceiveTimeout = 0;
124 UdpConfigData.TransmitTimeout = 0;
125
126 UdpConfigData.UseDefaultAddress = FALSE;
127 UdpConfigData.StationPort = DHCP_CLIENT_PORT;
128 UdpConfigData.RemotePort = DHCP_SERVER_PORT;
129
130 ZeroMem (&UdpConfigData.StationAddress, sizeof (EFI_IPv4_ADDRESS));
131 ZeroMem (&UdpConfigData.SubnetMask, sizeof (EFI_IPv4_ADDRESS));
132 ZeroMem (&UdpConfigData.RemoteAddress, sizeof (EFI_IPv4_ADDRESS));
133
134 return UdpIo->Protocol.Udp4->Configure (UdpIo->Protocol.Udp4, &UdpConfigData);
135}
136
137/**
138 Destroy the DHCP service. The Dhcp4 service may be partly initialized,
139 or partly destroyed. If a resource is destroyed, it is marked as so in
140 case the destroy failed and being called again later.
141
142 @param[in] DhcpSb The DHCP service instance to destroy.
143
144 @retval EFI_SUCCESS Always return success.
145
146**/
147EFI_STATUS
148Dhcp4CloseService (
149 IN DHCP_SERVICE *DhcpSb
150 )
151{
152 DhcpCleanLease (DhcpSb);
153
154 if (DhcpSb->UdpIo != NULL) {
155 UdpIoFreeIo (DhcpSb->UdpIo);
156 DhcpSb->UdpIo = NULL;
157 }
158
159 if (DhcpSb->Timer != NULL) {
160 gBS->SetTimer (DhcpSb->Timer, TimerCancel, 0);
161 gBS->CloseEvent (DhcpSb->Timer);
162
163 DhcpSb->Timer = NULL;
164 }
165
166 return EFI_SUCCESS;
167}
168
169/**
170 Create a new DHCP service binding instance for the controller.
171
172 @param[in] Controller The controller to install DHCP service binding
173 protocol onto
174 @param[in] ImageHandle The driver's image handle
175 @param[out] Service The variable to receive the created DHCP service
176 instance.
177
178 @retval EFI_OUT_OF_RESOURCES Failed to allocate resource .
179 @retval EFI_SUCCESS The DHCP service instance is created.
180 @retval other Other error occurs.
181
182**/
183EFI_STATUS
184Dhcp4CreateService (
185 IN EFI_HANDLE Controller,
186 IN EFI_HANDLE ImageHandle,
187 OUT DHCP_SERVICE **Service
188 )
189{
190 DHCP_SERVICE *DhcpSb;
191 EFI_STATUS Status;
192
193 *Service = NULL;
194 DhcpSb = AllocateZeroPool (sizeof (DHCP_SERVICE));
195
196 if (DhcpSb == NULL) {
197 return EFI_OUT_OF_RESOURCES;
198 }
199
200 DhcpSb->Signature = DHCP_SERVICE_SIGNATURE;
201 DhcpSb->ServiceState = DHCP_UNCONFIGED;
202 DhcpSb->Controller = Controller;
203 DhcpSb->Image = ImageHandle;
204 InitializeListHead (&DhcpSb->Children);
205 DhcpSb->DhcpState = Dhcp4Stopped;
206 DhcpSb->Xid = NET_RANDOM (NetRandomInitSeed ());
207 CopyMem (
208 &DhcpSb->ServiceBinding,
209 &mDhcp4ServiceBindingTemplate,
210 sizeof (EFI_SERVICE_BINDING_PROTOCOL)
211 );
212 //
213 // Create various resources, UdpIo, Timer, and get Mac address
214 //
215 Status = gBS->CreateEvent (
216 EVT_NOTIFY_SIGNAL | EVT_TIMER,
217 TPL_CALLBACK,
218 DhcpOnTimerTick,
219 DhcpSb,
220 &DhcpSb->Timer
221 );
222
223 if (EFI_ERROR (Status)) {
224 goto ON_ERROR;
225 }
226
227 DhcpSb->UdpIo = UdpIoCreateIo (
228 Controller,
229 ImageHandle,
230 DhcpConfigUdpIo,
231 UDP_IO_UDP4_VERSION,
232 NULL
233 );
234
235 if (DhcpSb->UdpIo == NULL) {
236 Status = EFI_OUT_OF_RESOURCES;
237 goto ON_ERROR;
238 }
239
240 DhcpSb->HwLen = (UINT8)DhcpSb->UdpIo->SnpMode.HwAddressSize;
241 DhcpSb->HwType = DhcpSb->UdpIo->SnpMode.IfType;
242 CopyMem (&DhcpSb->Mac, &DhcpSb->UdpIo->SnpMode.CurrentAddress, sizeof (DhcpSb->Mac));
243
244 *Service = DhcpSb;
245 return EFI_SUCCESS;
246
247ON_ERROR:
248 Dhcp4CloseService (DhcpSb);
249 FreePool (DhcpSb);
250
251 return Status;
252}
253
254/**
255 Start this driver on ControllerHandle. This service is called by the
256 EFI boot service ConnectController(). In order to make
257 drivers as small as possible, there are a few calling restrictions for
258 this service. ConnectController() must follow these
259 calling restrictions. If any other agent wishes to call Start() it
260 must also follow these calling restrictions.
261
262 @param[in] This Protocol instance pointer.
263 @param[in] ControllerHandle Handle of device to bind driver to
264 @param[in] RemainingDevicePath Optional parameter use to pick a specific child
265 device to start.
266
267 @retval EFI_SUCCESS This driver is added to ControllerHandle
268 @retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle
269 @retval other This driver does not support this device
270
271**/
272EFI_STATUS
273EFIAPI
274Dhcp4DriverBindingStart (
275 IN EFI_DRIVER_BINDING_PROTOCOL *This,
276 IN EFI_HANDLE ControllerHandle,
277 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
278 )
279{
280 DHCP_SERVICE *DhcpSb;
281 EFI_STATUS Status;
282
283 //
284 // First: test for the DHCP4 Protocol
285 //
286 Status = gBS->OpenProtocol (
287 ControllerHandle,
288 &gEfiDhcp4ServiceBindingProtocolGuid,
289 NULL,
290 This->DriverBindingHandle,
291 ControllerHandle,
292 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
293 );
294
295 if (Status == EFI_SUCCESS) {
296 return EFI_ALREADY_STARTED;
297 }
298
299 Status = Dhcp4CreateService (ControllerHandle, This->DriverBindingHandle, &DhcpSb);
300
301 if (EFI_ERROR (Status)) {
302 return Status;
303 }
304
305 ASSERT (DhcpSb != NULL);
306
307 //
308 // Start the receiving
309 //
310 Status = UdpIoRecvDatagram (DhcpSb->UdpIo, DhcpInput, DhcpSb, 0);
311
312 if (EFI_ERROR (Status)) {
313 goto ON_ERROR;
314 }
315
316 Status = gBS->SetTimer (DhcpSb->Timer, TimerPeriodic, TICKS_PER_SECOND);
317
318 if (EFI_ERROR (Status)) {
319 goto ON_ERROR;
320 }
321
322 //
323 // Install the Dhcp4ServiceBinding Protocol onto ControllerHandle
324 //
325 Status = gBS->InstallMultipleProtocolInterfaces (
326 &ControllerHandle,
327 &gEfiDhcp4ServiceBindingProtocolGuid,
328 &DhcpSb->ServiceBinding,
329 NULL
330 );
331
332 if (EFI_ERROR (Status)) {
333 goto ON_ERROR;
334 }
335
336 return Status;
337
338ON_ERROR:
339 Dhcp4CloseService (DhcpSb);
340 FreePool (DhcpSb);
341 return Status;
342}
343
344/**
345 Callback function which provided by user to remove one node in NetDestroyLinkList process.
346
347 @param[in] Entry The entry to be removed.
348 @param[in] Context Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
349
350 @retval EFI_SUCCESS The entry has been removed successfully.
351 @retval Others Fail to remove the entry.
352
353**/
354EFI_STATUS
355EFIAPI
356Dhcp4DestroyChildEntry (
357 IN LIST_ENTRY *Entry,
358 IN VOID *Context
359 )
360{
361 DHCP_PROTOCOL *Instance;
362 EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
363
364 if ((Entry == NULL) || (Context == NULL)) {
365 return EFI_INVALID_PARAMETER;
366 }
367
368 Instance = NET_LIST_USER_STRUCT_S (Entry, DHCP_PROTOCOL, Link, DHCP_PROTOCOL_SIGNATURE);
369 ServiceBinding = (EFI_SERVICE_BINDING_PROTOCOL *)Context;
370
371 return ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);
372}
373
374/**
375 Stop this driver on ControllerHandle. This service is called by the
376 EFI boot service DisconnectController(). In order to
377 make drivers as small as possible, there are a few calling
378 restrictions for this service. DisconnectController()
379 must follow these calling restrictions. If any other agent wishes
380 to call Stop() it must also follow these calling restrictions.
381
382 @param[in] This Protocol instance pointer.
383 @param[in] ControllerHandle Handle of device to stop driver on
384 @param[in] NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
385 children is zero stop the entire bus driver.
386 @param[in] ChildHandleBuffer List of Child Handles to Stop.
387
388 @retval EFI_SUCCESS This driver is removed ControllerHandle
389 @retval other This driver was not removed from this device
390
391**/
392EFI_STATUS
393EFIAPI
394Dhcp4DriverBindingStop (
395 IN EFI_DRIVER_BINDING_PROTOCOL *This,
396 IN EFI_HANDLE ControllerHandle,
397 IN UINTN NumberOfChildren,
398 IN EFI_HANDLE *ChildHandleBuffer
399 )
400{
401 EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
402 DHCP_SERVICE *DhcpSb;
403 EFI_HANDLE NicHandle;
404 EFI_STATUS Status;
405 LIST_ENTRY *List;
406 UINTN ListLength;
407
408 //
409 // DHCP driver opens UDP child, So, the ControllerHandle is the
410 // UDP child handle. locate the Nic handle first.
411 //
412 NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiUdp4ProtocolGuid);
413
414 if (NicHandle == NULL) {
415 return EFI_SUCCESS;
416 }
417
418 Status = gBS->OpenProtocol (
419 NicHandle,
420 &gEfiDhcp4ServiceBindingProtocolGuid,
421 (VOID **)&ServiceBinding,
422 This->DriverBindingHandle,
423 NicHandle,
424 EFI_OPEN_PROTOCOL_GET_PROTOCOL
425 );
426
427 if (EFI_ERROR (Status)) {
428 return EFI_DEVICE_ERROR;
429 }
430
431 DhcpSb = DHCP_SERVICE_FROM_THIS (ServiceBinding);
432 if (!IsListEmpty (&DhcpSb->Children)) {
433 //
434 // Destroy all the children instances before destroy the service.
435 //
436 List = &DhcpSb->Children;
437 Status = NetDestroyLinkList (
438 List,
439 Dhcp4DestroyChildEntry,
440 ServiceBinding,
441 &ListLength
442 );
443 if (EFI_ERROR (Status) || (ListLength != 0)) {
444 Status = EFI_DEVICE_ERROR;
445 }
446 }
447
448 if ((NumberOfChildren == 0) && !IsListEmpty (&DhcpSb->Children)) {
449 Status = EFI_DEVICE_ERROR;
450 }
451
452 if ((NumberOfChildren == 0) && IsListEmpty (&DhcpSb->Children)) {
453 //
454 // Destroy the service itself if no child instance left.
455 //
456 DhcpSb->ServiceState = DHCP_DESTROY;
457
458 gBS->UninstallProtocolInterface (
459 NicHandle,
460 &gEfiDhcp4ServiceBindingProtocolGuid,
461 ServiceBinding
462 );
463
464 Dhcp4CloseService (DhcpSb);
465
466 if (gDhcpControllerNameTable != NULL) {
467 FreeUnicodeStringTable (gDhcpControllerNameTable);
468 gDhcpControllerNameTable = NULL;
469 }
470
471 FreePool (DhcpSb);
472
473 Status = EFI_SUCCESS;
474 }
475
476 return Status;
477}
478
479/**
480 Initialize a new DHCP instance.
481
482 @param DhcpSb The dhcp service instance
483 @param Instance The dhcp instance to initialize
484
485**/
486VOID
487DhcpInitProtocol (
488 IN DHCP_SERVICE *DhcpSb,
489 IN OUT DHCP_PROTOCOL *Instance
490 )
491{
492 Instance->Signature = DHCP_PROTOCOL_SIGNATURE;
493 CopyMem (&Instance->Dhcp4Protocol, &mDhcp4ProtocolTemplate, sizeof (Instance->Dhcp4Protocol));
494 InitializeListHead (&Instance->Link);
495 Instance->Handle = NULL;
496 Instance->Service = DhcpSb;
497 Instance->InDestroy = FALSE;
498 Instance->CompletionEvent = NULL;
499 Instance->RenewRebindEvent = NULL;
500 Instance->Token = NULL;
501 Instance->UdpIo = NULL;
502 Instance->ElaspedTime = 0;
503 NetbufQueInit (&Instance->ResponseQueue);
504}
505
506/**
507 Creates a child handle and installs a protocol.
508
509 The CreateChild() function installs a protocol on ChildHandle.
510 If ChildHandle is a pointer to NULL, then a new handle is created and returned in ChildHandle.
511 If ChildHandle is not a pointer to NULL, then the protocol installs on the existing ChildHandle.
512
513 @param This Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
514 @param ChildHandle Pointer to the handle of the child to create. If it is NULL,
515 then a new handle is created. If it is a pointer to an existing UEFI handle,
516 then the protocol is added to the existing UEFI handle.
517
518 @retval EFI_SUCCESS The protocol was added to ChildHandle.
519 @retval EFI_INVALID_PARAMETER ChildHandle is NULL.
520 @retval EFI_OUT_OF_RESOURCES There are not enough resources available to create
521 the child
522 @retval other The child handle was not created
523
524**/
525EFI_STATUS
526EFIAPI
527Dhcp4ServiceBindingCreateChild (
528 IN EFI_SERVICE_BINDING_PROTOCOL *This,
529 IN EFI_HANDLE *ChildHandle
530 )
531{
532 DHCP_SERVICE *DhcpSb;
533 DHCP_PROTOCOL *Instance;
534 EFI_STATUS Status;
535 EFI_TPL OldTpl;
536 VOID *Udp4;
537
538 if ((This == NULL) || (ChildHandle == NULL)) {
539 return EFI_INVALID_PARAMETER;
540 }
541
542 Instance = AllocatePool (sizeof (*Instance));
543
544 if (Instance == NULL) {
545 return EFI_OUT_OF_RESOURCES;
546 }
547
548 DhcpSb = DHCP_SERVICE_FROM_THIS (This);
549 DhcpInitProtocol (DhcpSb, Instance);
550
551 //
552 // Install DHCP4 onto ChildHandle
553 //
554 Status = gBS->InstallMultipleProtocolInterfaces (
555 ChildHandle,
556 &gEfiDhcp4ProtocolGuid,
557 &Instance->Dhcp4Protocol,
558 NULL
559 );
560
561 if (EFI_ERROR (Status)) {
562 FreePool (Instance);
563 return Status;
564 }
565
566 Instance->Handle = *ChildHandle;
567
568 //
569 // Open the Udp4 protocol BY_CHILD.
570 //
571 Status = gBS->OpenProtocol (
572 DhcpSb->UdpIo->UdpHandle,
573 &gEfiUdp4ProtocolGuid,
574 (VOID **)&Udp4,
575 gDhcp4DriverBinding.DriverBindingHandle,
576 Instance->Handle,
577 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
578 );
579 if (EFI_ERROR (Status)) {
580 gBS->UninstallMultipleProtocolInterfaces (
581 Instance->Handle,
582 &gEfiDhcp4ProtocolGuid,
583 &Instance->Dhcp4Protocol,
584 NULL
585 );
586
587 FreePool (Instance);
588 return Status;
589 }
590
591 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
592
593 InsertTailList (&DhcpSb->Children, &Instance->Link);
594 DhcpSb->NumChildren++;
595
596 gBS->RestoreTPL (OldTpl);
597
598 return EFI_SUCCESS;
599}
600
601/**
602 Destroys a child handle with a protocol installed on it.
603
604 The DestroyChild() function does the opposite of CreateChild(). It removes a protocol
605 that was installed by CreateChild() from ChildHandle. If the removed protocol is the
606 last protocol on ChildHandle, then ChildHandle is destroyed.
607
608 @param This Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
609 @param ChildHandle Handle of the child to destroy
610
611 @retval EFI_SUCCESS The protocol was removed from ChildHandle.
612 @retval EFI_UNSUPPORTED ChildHandle does not support the protocol that is being removed.
613 @retval EFI_INVALID_PARAMETER Child handle is NULL.
614 @retval EFI_ACCESS_DENIED The protocol could not be removed from the ChildHandle
615 because its services are being used.
616 @retval other The child handle was not destroyed
617
618**/
619EFI_STATUS
620EFIAPI
621Dhcp4ServiceBindingDestroyChild (
622 IN EFI_SERVICE_BINDING_PROTOCOL *This,
623 IN EFI_HANDLE ChildHandle
624 )
625{
626 DHCP_SERVICE *DhcpSb;
627 DHCP_PROTOCOL *Instance;
628 EFI_DHCP4_PROTOCOL *Dhcp;
629 EFI_TPL OldTpl;
630 EFI_STATUS Status;
631
632 if ((This == NULL) || (ChildHandle == NULL)) {
633 return EFI_INVALID_PARAMETER;
634 }
635
636 //
637 // Retrieve the private context data structures
638 //
639 Status = gBS->OpenProtocol (
640 ChildHandle,
641 &gEfiDhcp4ProtocolGuid,
642 (VOID **)&Dhcp,
643 gDhcp4DriverBinding.DriverBindingHandle,
644 ChildHandle,
645 EFI_OPEN_PROTOCOL_GET_PROTOCOL
646 );
647
648 if (EFI_ERROR (Status)) {
649 return EFI_UNSUPPORTED;
650 }
651
652 Instance = DHCP_INSTANCE_FROM_THIS (Dhcp);
653 DhcpSb = DHCP_SERVICE_FROM_THIS (This);
654
655 if (Instance->Service != DhcpSb) {
656 return EFI_INVALID_PARAMETER;
657 }
658
659 //
660 // A child can be destroyed more than once. For example,
661 // Dhcp4DriverBindingStop will destroy all of its children.
662 // when caller driver is being stopped, it will destroy the
663 // dhcp child it opens.
664 //
665 if (Instance->InDestroy) {
666 return EFI_SUCCESS;
667 }
668
669 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
670 Instance->InDestroy = TRUE;
671
672 //
673 // Close the Udp4 protocol.
674 //
675 gBS->CloseProtocol (
676 DhcpSb->UdpIo->UdpHandle,
677 &gEfiUdp4ProtocolGuid,
678 gDhcp4DriverBinding.DriverBindingHandle,
679 ChildHandle
680 );
681
682 //
683 // Uninstall the DHCP4 protocol first to enable a top down destruction.
684 //
685 gBS->RestoreTPL (OldTpl);
686 Status = gBS->UninstallProtocolInterface (
687 ChildHandle,
688 &gEfiDhcp4ProtocolGuid,
689 Dhcp
690 );
691 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
692 if (EFI_ERROR (Status)) {
693 Instance->InDestroy = FALSE;
694
695 gBS->RestoreTPL (OldTpl);
696 return Status;
697 }
698
699 if (DhcpSb->ActiveChild == Instance) {
700 DhcpYieldControl (DhcpSb);
701 }
702
703 RemoveEntryList (&Instance->Link);
704 DhcpSb->NumChildren--;
705
706 if (Instance->UdpIo != NULL) {
707 UdpIoCleanIo (Instance->UdpIo);
708 gBS->CloseProtocol (
709 Instance->UdpIo->UdpHandle,
710 &gEfiUdp4ProtocolGuid,
711 Instance->Service->Image,
712 Instance->Handle
713 );
714 UdpIoFreeIo (Instance->UdpIo);
715 Instance->UdpIo = NULL;
716 Instance->Token = NULL;
717 }
718
719 gBS->RestoreTPL (OldTpl);
720
721 FreePool (Instance);
722 return EFI_SUCCESS;
723}
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette