]> git.proxmox.com Git - mirror_edk2.git/blob - NetworkPkg/Mtftp6Dxe/Mtftp6Driver.c
ShellPkg/UefiShellAcpiViewCommandLib: Fix VS2017 compilation errors
[mirror_edk2.git] / NetworkPkg / Mtftp6Dxe / Mtftp6Driver.c
1 /** @file
2 Driver Binding functions and Service Binding functions
3 implementation for Mtftp6 Driver.
4
5 Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
6
7 This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php.
11
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14
15 **/
16
17 #include "Mtftp6Impl.h"
18
19
20 EFI_DRIVER_BINDING_PROTOCOL gMtftp6DriverBinding = {
21 Mtftp6DriverBindingSupported,
22 Mtftp6DriverBindingStart,
23 Mtftp6DriverBindingStop,
24 0xa,
25 NULL,
26 NULL
27 };
28
29 EFI_SERVICE_BINDING_PROTOCOL gMtftp6ServiceBindingTemplate = {
30 Mtftp6ServiceBindingCreateChild,
31 Mtftp6ServiceBindingDestroyChild
32 };
33
34
35 /**
36 Destroy the MTFTP6 service. The MTFTP6 service may be partly initialized,
37 or partly destroyed. If a resource is destroyed, it is marked as such in
38 case the destroy failed and is called again later.
39
40 @param[in] Service The MTFTP6 service to be destroyed.
41
42 **/
43 VOID
44 Mtftp6DestroyService (
45 IN MTFTP6_SERVICE *Service
46 )
47 {
48 //
49 // Make sure all children instances have been already destroyed.
50 //
51 ASSERT (Service->ChildrenNum == 0);
52
53 if (Service->DummyUdpIo != NULL) {
54 UdpIoFreeIo (Service->DummyUdpIo);
55 }
56
57 if (Service->Timer != NULL) {
58 gBS->CloseEvent (Service->Timer);
59 }
60
61 FreePool (Service);
62 }
63
64
65 /**
66 Create then initialize a MTFTP6 service binding instance.
67
68 @param[in] Controller The controller to install the MTFTP6 service
69 binding on.
70 @param[in] Image The driver binding image of the MTFTP6 driver.
71 @param[out] Service The variable to receive the created service
72 binding instance.
73
74 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources to create the instance
75 @retval EFI_DEVICE_ERROR Failed to create a NULL UDP port to keep connection with UDP.
76 @retval EFI_SUCCESS The service instance is created for the controller.
77
78 **/
79 EFI_STATUS
80 Mtftp6CreateService (
81 IN EFI_HANDLE Controller,
82 IN EFI_HANDLE Image,
83 OUT MTFTP6_SERVICE **Service
84 )
85 {
86 MTFTP6_SERVICE *Mtftp6Srv;
87 EFI_STATUS Status;
88
89 ASSERT (Service != NULL);
90
91 *Service = NULL;
92 Mtftp6Srv = AllocateZeroPool (sizeof (MTFTP6_SERVICE));
93
94 if (Mtftp6Srv == NULL) {
95 return EFI_OUT_OF_RESOURCES;
96 }
97
98 Mtftp6Srv->Signature = MTFTP6_SERVICE_SIGNATURE;
99 Mtftp6Srv->Controller = Controller;
100 Mtftp6Srv->Image = Image;
101 Mtftp6Srv->ChildrenNum = 0;
102
103 CopyMem (
104 &Mtftp6Srv->ServiceBinding,
105 &gMtftp6ServiceBindingTemplate,
106 sizeof (EFI_SERVICE_BINDING_PROTOCOL)
107 );
108
109 InitializeListHead (&Mtftp6Srv->Children);
110
111 //
112 // Create a internal timer for all instances.
113 //
114 Status = gBS->CreateEvent (
115 EVT_NOTIFY_SIGNAL | EVT_TIMER,
116 TPL_CALLBACK,
117 Mtftp6OnTimerTick,
118 Mtftp6Srv,
119 &Mtftp6Srv->Timer
120 );
121
122 if (EFI_ERROR (Status)) {
123 FreePool (Mtftp6Srv);
124 return Status;
125 }
126
127 //
128 // Create a dummy Udp6Io to build parent-child relationship between Udp6 driver
129 // and Mtftp6 driver.
130 //
131 Mtftp6Srv->DummyUdpIo = UdpIoCreateIo (
132 Controller,
133 Image,
134 Mtftp6ConfigDummyUdpIo,
135 UDP_IO_UDP6_VERSION,
136 NULL
137 );
138
139 if (Mtftp6Srv->DummyUdpIo == NULL) {
140 gBS->CloseEvent (Mtftp6Srv->Timer);
141 FreePool (Mtftp6Srv);
142 return EFI_DEVICE_ERROR;
143 }
144
145 *Service = Mtftp6Srv;
146 return EFI_SUCCESS;
147 }
148
149
150 /**
151 Destroy the MTFTP6 instance and recycle the resources.
152
153 @param[in] Instance The pointer to the MTFTP6 instance.
154
155 **/
156 VOID
157 Mtftp6DestroyInstance (
158 IN MTFTP6_INSTANCE *Instance
159 )
160 {
161 LIST_ENTRY *Entry;
162 LIST_ENTRY *Next;
163 MTFTP6_BLOCK_RANGE *Block;
164
165 if (Instance->Config != NULL) {
166 FreePool (Instance->Config);
167 }
168
169 if (Instance->Token != NULL && Instance->Token->Event != NULL) {
170 gBS->SignalEvent (Instance->Token->Event);
171 }
172
173 if (Instance->LastPacket != NULL) {
174 NetbufFree (Instance->LastPacket);
175 }
176
177 if (Instance->UdpIo!= NULL) {
178 UdpIoFreeIo (Instance->UdpIo);
179 }
180
181 if (Instance->McastUdpIo != NULL) {
182 UdpIoFreeIo (Instance->McastUdpIo);
183 }
184
185 NET_LIST_FOR_EACH_SAFE (Entry, Next, &Instance->BlkList) {
186 Block = NET_LIST_USER_STRUCT (Entry, MTFTP6_BLOCK_RANGE, Link);
187 RemoveEntryList (Entry);
188 FreePool (Block);
189 }
190
191 FreePool (Instance);
192 }
193
194
195 /**
196 Create the MTFTP6 instance and initialize it.
197
198 @param[in] Service The pointer to the MTFTP6 service.
199 @param[out] Instance The pointer to the MTFTP6 instance.
200
201 @retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
202 @retval EFI_SUCCESS The MTFTP6 instance is created.
203
204 **/
205 EFI_STATUS
206 Mtftp6CreateInstance (
207 IN MTFTP6_SERVICE *Service,
208 OUT MTFTP6_INSTANCE **Instance
209 )
210 {
211 MTFTP6_INSTANCE *Mtftp6Ins;
212
213 *Instance = NULL;
214 Mtftp6Ins = AllocateZeroPool (sizeof (MTFTP6_INSTANCE));
215
216 if (Mtftp6Ins == NULL) {
217 return EFI_OUT_OF_RESOURCES;
218 }
219
220 Mtftp6Ins->Signature = MTFTP6_INSTANCE_SIGNATURE;
221 Mtftp6Ins->InDestroy = FALSE;
222 Mtftp6Ins->Service = Service;
223
224 CopyMem (
225 &Mtftp6Ins->Mtftp6,
226 &gMtftp6ProtocolTemplate,
227 sizeof (EFI_MTFTP6_PROTOCOL)
228 );
229
230 InitializeListHead (&Mtftp6Ins->Link);
231 InitializeListHead (&Mtftp6Ins->BlkList);
232
233 *Instance = Mtftp6Ins;
234
235 return EFI_SUCCESS;
236 }
237
238
239 /**
240 Callback function which provided by user to remove one node in NetDestroyLinkList process.
241
242 @param[in] Entry The entry to be removed.
243 @param[in] Context Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
244
245 @retval EFI_SUCCESS The entry has been removed successfully.
246 @retval Others Fail to remove the entry.
247
248 **/
249 EFI_STATUS
250 EFIAPI
251 Mtftp6DestroyChildEntryInHandleBuffer (
252 IN LIST_ENTRY *Entry,
253 IN VOID *Context
254 )
255 {
256 MTFTP6_INSTANCE *Instance;
257 EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
258 UINTN NumberOfChildren;
259 EFI_HANDLE *ChildHandleBuffer;
260
261 if (Entry == NULL || Context == NULL) {
262 return EFI_INVALID_PARAMETER;
263 }
264
265 Instance = NET_LIST_USER_STRUCT_S (Entry, MTFTP6_INSTANCE, Link, MTFTP6_INSTANCE_SIGNATURE);
266 ServiceBinding = ((MTFTP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ServiceBinding;
267 NumberOfChildren = ((MTFTP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->NumberOfChildren;
268 ChildHandleBuffer = ((MTFTP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ChildHandleBuffer;
269
270 if (!NetIsInHandleBuffer (Instance->Handle, NumberOfChildren, ChildHandleBuffer)) {
271 return EFI_SUCCESS;
272 }
273
274 return ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);
275 }
276
277
278 /**
279 This is the declaration of an EFI image entry point. This entry point is
280 the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers, including
281 both device drivers and bus drivers.
282
283 Entry point of the MTFTP6 driver to install various protocols.
284
285 @param[in] ImageHandle The firmware allocated handle for the UEFI image.
286 @param[in] SystemTable The pointer to the EFI System Table.
287
288 @retval EFI_SUCCESS The operation completed successfully.
289 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
290
291 **/
292 EFI_STATUS
293 EFIAPI
294 Mtftp6DriverEntryPoint (
295 IN EFI_HANDLE ImageHandle,
296 IN EFI_SYSTEM_TABLE *SystemTable
297 )
298 {
299 return EfiLibInstallDriverBindingComponentName2 (
300 ImageHandle,
301 SystemTable,
302 &gMtftp6DriverBinding,
303 ImageHandle,
304 &gMtftp6ComponentName,
305 &gMtftp6ComponentName2
306 );
307 }
308
309
310 /**
311 Test to see if this driver supports Controller. This service
312 is called by the EFI boot service ConnectController(). In
313 order to make drivers as small as possible, there are calling
314 restrictions for this service. ConnectController() must
315 follow these calling restrictions. If any other agent wishes to call
316 Supported(), it must also follow these calling restrictions.
317
318 @param[in] This Protocol instance pointer.
319 @param[in] Controller Handle of device to test
320 @param[in] RemainingDevicePath Optional parameter use to pick a specific child.
321 device to start.
322
323 @retval EFI_SUCCESS This driver supports this device.
324 @retval Others This driver does not support this device.
325
326 **/
327 EFI_STATUS
328 EFIAPI
329 Mtftp6DriverBindingSupported (
330 IN EFI_DRIVER_BINDING_PROTOCOL *This,
331 IN EFI_HANDLE Controller,
332 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
333 )
334 {
335 return gBS->OpenProtocol (
336 Controller,
337 &gEfiUdp6ServiceBindingProtocolGuid,
338 NULL,
339 This->DriverBindingHandle,
340 Controller,
341 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
342 );
343 }
344
345
346 /**
347 Start this driver on Controller. This service is called by the
348 EFI boot service ConnectController(). In order to make
349 drivers as small as possible, there are calling restrictions for
350 this service. ConnectController() must follow these
351 calling restrictions. If any other agent wishes to call Start() it
352 must also follow these calling restrictions.
353
354 @param[in] This Protocol instance pointer.
355 @param[in] Controller Handle of device to bind driver to.
356 @param[in] RemainingDevicePath Optional parameter use to pick a specific child
357 device to start.
358
359 @retval EFI_SUCCESS This driver is added to Controller.
360 @retval EFI_ALREADY_STARTED This driver is already running on Controller.
361 @retval Others This driver does not support this device.
362
363 **/
364 EFI_STATUS
365 EFIAPI
366 Mtftp6DriverBindingStart (
367 IN EFI_DRIVER_BINDING_PROTOCOL *This,
368 IN EFI_HANDLE Controller,
369 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
370 )
371 {
372 MTFTP6_SERVICE *Service;
373 EFI_STATUS Status;
374
375 //
376 // Directly return if driver is already running on this Nic handle.
377 //
378 Status = gBS->OpenProtocol (
379 Controller,
380 &gEfiMtftp6ServiceBindingProtocolGuid,
381 NULL,
382 This->DriverBindingHandle,
383 Controller,
384 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
385 );
386
387 if (!EFI_ERROR (Status)) {
388 return EFI_ALREADY_STARTED;
389 }
390
391 //
392 // Create Mtftp6 service for this Nic handle
393 //
394 Status = Mtftp6CreateService (
395 Controller,
396 This->DriverBindingHandle,
397 &Service
398 );
399
400 if (EFI_ERROR (Status)) {
401 return Status;
402 }
403
404 ASSERT (Service != NULL);
405
406 //
407 // Start the internal timer to track the packet retransmission.
408 //
409 Status = gBS->SetTimer (
410 Service->Timer,
411 TimerPeriodic,
412 TICKS_PER_SECOND
413 );
414
415 if (EFI_ERROR (Status)) {
416 goto ON_ERROR;
417 }
418
419 //
420 // Install the Mtftp6 service on the Nic handle.
421 //
422 Status = gBS->InstallMultipleProtocolInterfaces (
423 &Controller,
424 &gEfiMtftp6ServiceBindingProtocolGuid,
425 &Service->ServiceBinding,
426 NULL
427 );
428
429 if (EFI_ERROR (Status)) {
430 goto ON_ERROR;
431 }
432
433 return EFI_SUCCESS;
434
435 ON_ERROR:
436
437 Mtftp6DestroyService (Service);
438 return Status;
439 }
440
441
442 /**
443 Stop this driver on Controller. This service is called by the
444 EFI boot service DisconnectController(). In order to
445 make drivers as small as possible, there are calling
446 restrictions for this service. DisconnectController()
447 must follow these calling restrictions. If any other agent wishes
448 to call Stop(), it must also follow these calling restrictions.
449
450 @param[in] This Protocol instance pointer.
451 @param[in] Controller Handle of device to stop driver on
452 @param[in] NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
453 children is zero, stop the entire bus driver.
454 @param[in] ChildHandleBuffer List of Child Handles to Stop.
455
456 @retval EFI_SUCCESS This driver is removed Controller.
457 @retval EFI_DEVICE_ERROR An unexpected error.
458 @retval Others This driver was not removed from this device.
459
460 **/
461 EFI_STATUS
462 EFIAPI
463 Mtftp6DriverBindingStop (
464 IN EFI_DRIVER_BINDING_PROTOCOL *This,
465 IN EFI_HANDLE Controller,
466 IN UINTN NumberOfChildren,
467 IN EFI_HANDLE *ChildHandleBuffer
468 )
469 {
470 EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
471 MTFTP6_SERVICE *Service;
472 EFI_HANDLE NicHandle;
473 EFI_STATUS Status;
474 LIST_ENTRY *List;
475 MTFTP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT Context;
476
477 //
478 // Locate the Nic handle to retrieve the Mtftp6 private data.
479 //
480 NicHandle = NetLibGetNicHandle (Controller, &gEfiUdp6ProtocolGuid);
481
482 if (NicHandle == NULL) {
483 return EFI_SUCCESS;
484 }
485
486 Status = gBS->OpenProtocol (
487 NicHandle,
488 &gEfiMtftp6ServiceBindingProtocolGuid,
489 (VOID **) &ServiceBinding,
490 This->DriverBindingHandle,
491 NicHandle,
492 EFI_OPEN_PROTOCOL_GET_PROTOCOL
493 );
494
495 if (EFI_ERROR (Status)) {
496 return EFI_DEVICE_ERROR;
497 }
498
499 Service = MTFTP6_SERVICE_FROM_THIS (ServiceBinding);
500
501 if (!IsListEmpty (&Service->Children)) {
502 //
503 // Destroy the Mtftp6 child instance in ChildHandleBuffer.
504 //
505 List = &Service->Children;
506 Context.ServiceBinding = ServiceBinding;
507 Context.NumberOfChildren = NumberOfChildren;
508 Context.ChildHandleBuffer = ChildHandleBuffer;
509 Status = NetDestroyLinkList (
510 List,
511 Mtftp6DestroyChildEntryInHandleBuffer,
512 &Context,
513 NULL
514 );
515 }
516
517 if (NumberOfChildren == 0 && IsListEmpty (&Service->Children)) {
518 //
519 // Destroy the Mtftp6 service if there is no Mtftp6 child instance left.
520 //
521 gBS->UninstallProtocolInterface (
522 NicHandle,
523 &gEfiMtftp6ServiceBindingProtocolGuid,
524 ServiceBinding
525 );
526
527 Mtftp6DestroyService (Service);
528 Status = EFI_SUCCESS;
529 }
530
531 return Status;
532 }
533
534
535 /**
536 Creates a child handle and installs a protocol.
537
538 The CreateChild() function installs a protocol on ChildHandle.
539 If ChildHandle is a pointer to NULL, then a new handle is created and returned in ChildHandle.
540 If ChildHandle is not a pointer to NULL, then the protocol installs on the existing ChildHandle.
541
542 @param[in] This Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
543 @param[in, out] ChildHandle Pointer to the handle of the child to create. If it is NULL,
544 then a new handle is created. If it is a pointer to an existing
545 UEFI handle, then the protocol is added to the existing UEFI handle.
546
547 @retval EFI_SUCCES The protocol was added to ChildHandle.
548 @retval EFI_INVALID_PARAMETER ChildHandle is NULL.
549 @retval Others The child handle was not created.
550
551 **/
552 EFI_STATUS
553 EFIAPI
554 Mtftp6ServiceBindingCreateChild (
555 IN EFI_SERVICE_BINDING_PROTOCOL *This,
556 IN OUT EFI_HANDLE *ChildHandle
557 )
558 {
559 MTFTP6_SERVICE *Service;
560 MTFTP6_INSTANCE *Instance;
561 EFI_STATUS Status;
562 EFI_TPL OldTpl;
563 VOID *Udp6;
564
565 if (This == NULL || ChildHandle == NULL) {
566 return EFI_INVALID_PARAMETER;
567 }
568
569 Service = MTFTP6_SERVICE_FROM_THIS (This);
570
571 Status = Mtftp6CreateInstance (Service, &Instance);
572
573 if (EFI_ERROR (Status)) {
574 return Status;
575 }
576
577 ASSERT (Instance != NULL);
578
579 //
580 // Install the Mtftp6 protocol on the new child handle.
581 //
582 Status = gBS->InstallMultipleProtocolInterfaces (
583 ChildHandle,
584 &gEfiMtftp6ProtocolGuid,
585 &Instance->Mtftp6,
586 NULL
587 );
588
589 if (EFI_ERROR (Status)) {
590 goto ON_ERROR;
591 }
592
593 Instance->Handle = *ChildHandle;
594
595 //
596 // Open the Udp6 protocol by child.
597 //
598 Status = gBS->OpenProtocol (
599 Service->DummyUdpIo->UdpHandle,
600 &gEfiUdp6ProtocolGuid,
601 (VOID **) &Udp6,
602 gMtftp6DriverBinding.DriverBindingHandle,
603 Instance->Handle,
604 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
605 );
606
607 if (EFI_ERROR (Status)) {
608 gBS->UninstallMultipleProtocolInterfaces (
609 Instance->Handle,
610 &gEfiMtftp6ProtocolGuid,
611 &Instance->Mtftp6,
612 NULL
613 );
614
615 goto ON_ERROR;
616 }
617
618 //
619 // Add the new Mtftp6 instance into the children list of Mtftp6 service.
620 //
621 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
622
623 InsertTailList (&Service->Children, &Instance->Link);
624 Service->ChildrenNum++;
625
626 gBS->RestoreTPL (OldTpl);
627 return EFI_SUCCESS;
628
629 ON_ERROR:
630
631 Mtftp6DestroyInstance (Instance);
632 return Status;
633 }
634
635
636 /**
637 Destroys a child handle with a protocol installed on it.
638
639 The DestroyChild() function does the opposite of CreateChild(). It removes a protocol
640 that was installed by CreateChild() from ChildHandle. If the removed protocol is the
641 last protocol on ChildHandle, then ChildHandle is destroyed.
642
643 @param[in] This Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
644 @param[in] ChildHandle Handle of the child to destroy.
645
646 @retval EFI_SUCCES The protocol was removed from ChildHandle.
647 @retval EFI_UNSUPPORTED ChildHandle does not support the protocol that is being removed.
648 @retval EFI_INVALID_PARAMETER Child handle is NULL.
649 @retval Others The child handle was not destroyed
650
651 **/
652 EFI_STATUS
653 EFIAPI
654 Mtftp6ServiceBindingDestroyChild (
655 IN EFI_SERVICE_BINDING_PROTOCOL *This,
656 IN EFI_HANDLE ChildHandle
657 )
658 {
659 MTFTP6_SERVICE *Service;
660 MTFTP6_INSTANCE *Instance;
661 EFI_MTFTP6_PROTOCOL *Mtftp6;
662 EFI_STATUS Status;
663 EFI_TPL OldTpl;
664
665 if (This == NULL || ChildHandle == NULL) {
666 return EFI_INVALID_PARAMETER;
667 }
668
669 //
670 // Locate the Nic handle to retrieve the Mtftp6 private data.
671 //
672 Status = gBS->OpenProtocol (
673 ChildHandle,
674 &gEfiMtftp6ProtocolGuid,
675 (VOID **) &Mtftp6,
676 gMtftp6DriverBinding.DriverBindingHandle,
677 ChildHandle,
678 EFI_OPEN_PROTOCOL_GET_PROTOCOL
679 );
680
681 if (EFI_ERROR (Status)) {
682 return EFI_UNSUPPORTED;
683 }
684
685 Instance = MTFTP6_INSTANCE_FROM_THIS (Mtftp6);
686 Service = MTFTP6_SERVICE_FROM_THIS (This);
687
688 if (Instance->Service != Service) {
689 return EFI_INVALID_PARAMETER;
690 }
691
692 //
693 // Check whether the instance already in Destroy state.
694 //
695 if (Instance->InDestroy) {
696 return EFI_SUCCESS;
697 }
698
699 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
700
701 Instance->InDestroy = TRUE;
702
703 gBS->CloseProtocol (
704 Service->DummyUdpIo->UdpHandle,
705 &gEfiUdp6ProtocolGuid,
706 gMtftp6DriverBinding.DriverBindingHandle,
707 ChildHandle
708 );
709
710 if (Instance->UdpIo != NULL) {
711 gBS->CloseProtocol (
712 Instance->UdpIo->UdpHandle,
713 &gEfiUdp6ProtocolGuid,
714 gMtftp6DriverBinding.DriverBindingHandle,
715 Instance->Handle
716 );
717 }
718
719 if (Instance->McastUdpIo != NULL) {
720 gBS->CloseProtocol (
721 Instance->McastUdpIo->UdpHandle,
722 &gEfiUdp6ProtocolGuid,
723 gMtftp6DriverBinding.DriverBindingHandle,
724 Instance->Handle
725 );
726 }
727
728 //
729 // Uninstall the MTFTP6 protocol first to enable a top down destruction.
730 //
731 gBS->RestoreTPL (OldTpl);
732 Status = gBS->UninstallProtocolInterface (
733 ChildHandle,
734 &gEfiMtftp6ProtocolGuid,
735 Mtftp6
736 );
737 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
738 if (EFI_ERROR (Status)) {
739 Instance->InDestroy = FALSE;
740 gBS->RestoreTPL (OldTpl);
741 return Status;
742 }
743
744 //
745 // Remove the Mtftp6 instance from the children list of Mtftp6 service.
746 //
747 RemoveEntryList (&Instance->Link);
748 Service->ChildrenNum --;
749
750 gBS->RestoreTPL (OldTpl);
751
752 Mtftp6DestroyInstance (Instance);
753
754 return EFI_SUCCESS;
755 }