VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/NetworkPkg/Udp4Dxe/Udp4Driver.c@ 106129

Last change on this file since 106129 was 105670, checked in by vboxsync, 8 months ago

Devices/EFI/FirmwareNew: Merge edk2-stable-202405 and make it build on aarch64, bugref:4643
  • Property svn:eol-style set to native
File size: 17.3 KB
Line 
1/** @file
2
3Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>
4Copyright (c) Microsoft Corporation
5SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include "Udp4Impl.h"
10
11EFI_DRIVER_BINDING_PROTOCOL gUdp4DriverBinding = {
12 Udp4DriverBindingSupported,
13 Udp4DriverBindingStart,
14 Udp4DriverBindingStop,
15 0xa,
16 NULL,
17 NULL
18};
19
20EFI_SERVICE_BINDING_PROTOCOL mUdp4ServiceBinding = {
21 Udp4ServiceBindingCreateChild,
22 Udp4ServiceBindingDestroyChild
23};
24
25/**
26 Callback function which provided by user to remove one node in NetDestroyLinkList process.
27
28 @param[in] Entry The entry to be removed.
29 @param[in] Context Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
30
31 @retval EFI_SUCCESS The entry has been removed successfully.
32 @retval Others Fail to remove the entry.
33
34**/
35EFI_STATUS
36EFIAPI
37Udp4DestroyChildEntryInHandleBuffer (
38 IN LIST_ENTRY *Entry,
39 IN VOID *Context
40 )
41{
42 UDP4_INSTANCE_DATA *Instance;
43 EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
44 UINTN NumberOfChildren;
45 EFI_HANDLE *ChildHandleBuffer;
46
47 if ((Entry == NULL) || (Context == NULL)) {
48 return EFI_INVALID_PARAMETER;
49 }
50
51 Instance = NET_LIST_USER_STRUCT_S (Entry, UDP4_INSTANCE_DATA, Link, UDP4_INSTANCE_DATA_SIGNATURE);
52 ServiceBinding = ((UDP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *)Context)->ServiceBinding;
53 NumberOfChildren = ((UDP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *)Context)->NumberOfChildren;
54 ChildHandleBuffer = ((UDP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *)Context)->ChildHandleBuffer;
55
56 if (!NetIsInHandleBuffer (Instance->ChildHandle, NumberOfChildren, ChildHandleBuffer)) {
57 return EFI_SUCCESS;
58 }
59
60 return ServiceBinding->DestroyChild (ServiceBinding, Instance->ChildHandle);
61}
62
63/**
64 Test to see if this driver supports ControllerHandle. This service
65 is called by the EFI boot service ConnectController(). In
66 order to make drivers as small as possible, there are a few calling
67 restrictions for this service. ConnectController() must
68 follow these calling restrictions. If any other agent wishes to call
69 Supported() it must also follow these calling restrictions.
70
71 @param[in] This Protocol instance pointer.
72 @param[in] ControllerHandle Handle of device to test
73 @param[in] RemainingDevicePath Optional parameter use to pick a specific child
74 device to start.
75
76 @retval EFI_SUCCESS This driver supports this device
77 @retval EFI_ALREADY_STARTED This driver is already running on this device
78 @retval other This driver does not support this device
79
80**/
81EFI_STATUS
82EFIAPI
83Udp4DriverBindingSupported (
84 IN EFI_DRIVER_BINDING_PROTOCOL *This,
85 IN EFI_HANDLE ControllerHandle,
86 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
87 )
88{
89 EFI_STATUS Status;
90
91 //
92 // Test for the Udp4ServiceBinding Protocol
93 //
94 Status = gBS->OpenProtocol (
95 ControllerHandle,
96 &gEfiUdp4ServiceBindingProtocolGuid,
97 NULL,
98 This->DriverBindingHandle,
99 ControllerHandle,
100 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
101 );
102 if (!EFI_ERROR (Status)) {
103 return EFI_ALREADY_STARTED;
104 }
105
106 //
107 // Test for the Ip4 Protocol
108 //
109 Status = gBS->OpenProtocol (
110 ControllerHandle,
111 &gEfiIp4ServiceBindingProtocolGuid,
112 NULL,
113 This->DriverBindingHandle,
114 ControllerHandle,
115 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
116 );
117
118 return Status;
119}
120
121/**
122 Start this driver on ControllerHandle. This service is called by the
123 EFI boot service ConnectController(). In order to make
124 drivers as small as possible, there are a few calling restrictions for
125 this service. ConnectController() must follow these
126 calling restrictions. If any other agent wishes to call Start() it
127 must also follow these calling restrictions.
128
129 @param[in] This Protocol instance pointer.
130 @param[in] ControllerHandle Handle of device to bind driver to
131 @param[in] RemainingDevicePath Optional parameter use to pick a specific child
132 device to start.
133
134 @retval EFI_SUCCESS This driver is added to ControllerHandle
135 @retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle
136 @retval other This driver does not support this device
137
138**/
139EFI_STATUS
140EFIAPI
141Udp4DriverBindingStart (
142 IN EFI_DRIVER_BINDING_PROTOCOL *This,
143 IN EFI_HANDLE ControllerHandle,
144 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL
145 )
146{
147 EFI_STATUS Status;
148 UDP4_SERVICE_DATA *Udp4Service;
149
150 //
151 // Allocate Private Context Data Structure.
152 //
153 Udp4Service = AllocatePool (sizeof (UDP4_SERVICE_DATA));
154 if (Udp4Service == NULL) {
155 return EFI_OUT_OF_RESOURCES;
156 }
157
158 Status = Udp4CreateService (Udp4Service, This->DriverBindingHandle, ControllerHandle);
159 if (EFI_ERROR (Status)) {
160 FreePool (Udp4Service);
161 return Status;
162 }
163
164 //
165 // Install the Udp4ServiceBindingProtocol on the ControllerHandle.
166 //
167 Status = gBS->InstallMultipleProtocolInterfaces (
168 &ControllerHandle,
169 &gEfiUdp4ServiceBindingProtocolGuid,
170 &Udp4Service->ServiceBinding,
171 NULL
172 );
173 if (EFI_ERROR (Status)) {
174 Udp4CleanService (Udp4Service);
175 FreePool (Udp4Service);
176 }
177
178 return Status;
179}
180
181/**
182 Stop this driver on ControllerHandle. This service is called by the
183 EFI boot service DisconnectController(). In order to
184 make drivers as small as possible, there are a few calling
185 restrictions for this service. DisconnectController()
186 must follow these calling restrictions. If any other agent wishes
187 to call Stop() it must also follow these calling restrictions.
188
189 @param[in] This Protocol instance pointer.
190 @param[in] ControllerHandle Handle of device to stop driver on
191 @param[in] NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
192 children is zero stop the entire bus driver.
193 @param[in] ChildHandleBuffer List of Child Handles to Stop.
194
195 @retval EFI_SUCCESS This driver is removed ControllerHandle
196 @retval other This driver was not removed from this device
197
198**/
199EFI_STATUS
200EFIAPI
201Udp4DriverBindingStop (
202 IN EFI_DRIVER_BINDING_PROTOCOL *This,
203 IN EFI_HANDLE ControllerHandle,
204 IN UINTN NumberOfChildren,
205 IN EFI_HANDLE *ChildHandleBuffer
206 )
207{
208 EFI_STATUS Status;
209 EFI_HANDLE NicHandle;
210 EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
211 UDP4_SERVICE_DATA *Udp4Service;
212 UDP4_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT Context;
213 LIST_ENTRY *List;
214
215 //
216 // Find the NicHandle where UDP4 ServiceBinding Protocol is installed.
217 //
218 NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiIp4ProtocolGuid);
219 if (NicHandle == NULL) {
220 return EFI_SUCCESS;
221 }
222
223 //
224 // Retrieve the UDP4 ServiceBinding Protocol.
225 //
226 Status = gBS->OpenProtocol (
227 NicHandle,
228 &gEfiUdp4ServiceBindingProtocolGuid,
229 (VOID **)&ServiceBinding,
230 This->DriverBindingHandle,
231 NicHandle,
232 EFI_OPEN_PROTOCOL_GET_PROTOCOL
233 );
234 if (EFI_ERROR (Status)) {
235 return EFI_DEVICE_ERROR;
236 }
237
238 Udp4Service = UDP4_SERVICE_DATA_FROM_THIS (ServiceBinding);
239 if (NumberOfChildren != 0) {
240 //
241 // NumberOfChildren is not zero, destroy the children instances in ChildHandleBuffer.
242 //
243 List = &Udp4Service->ChildrenList;
244 Context.ServiceBinding = ServiceBinding;
245 Context.NumberOfChildren = NumberOfChildren;
246 Context.ChildHandleBuffer = ChildHandleBuffer;
247 Status = NetDestroyLinkList (
248 List,
249 Udp4DestroyChildEntryInHandleBuffer,
250 &Context,
251 NULL
252 );
253 } else {
254 gBS->UninstallMultipleProtocolInterfaces (
255 NicHandle,
256 &gEfiUdp4ServiceBindingProtocolGuid,
257 &Udp4Service->ServiceBinding,
258 NULL
259 );
260
261 Udp4CleanService (Udp4Service);
262
263 if (gUdpControllerNameTable != NULL) {
264 FreeUnicodeStringTable (gUdpControllerNameTable);
265 gUdpControllerNameTable = NULL;
266 }
267
268 FreePool (Udp4Service);
269 }
270
271 return Status;
272}
273
274/**
275 Creates a child handle and installs a protocol.
276
277 The CreateChild() function installs a protocol on ChildHandle.
278 If ChildHandle is a pointer to NULL, then a new handle is created and returned in ChildHandle.
279 If ChildHandle is not a pointer to NULL, then the protocol installs on the existing ChildHandle.
280
281 @param[in] This Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
282 @param[in] ChildHandle Pointer to the handle of the child to create. If it is NULL,
283 then a new handle is created. If it is a pointer to an existing UEFI handle,
284 then the protocol is added to the existing UEFI handle.
285
286 @retval EFI_SUCCESS The protocol was added to ChildHandle.
287 @retval EFI_INVALID_PARAMETER ChildHandle is NULL.
288 @retval EFI_OUT_OF_RESOURCES There are not enough resources available to create
289 the child
290 @retval other The child handle was not created
291
292**/
293EFI_STATUS
294EFIAPI
295Udp4ServiceBindingCreateChild (
296 IN EFI_SERVICE_BINDING_PROTOCOL *This,
297 IN EFI_HANDLE *ChildHandle
298 )
299{
300 EFI_STATUS Status;
301 UDP4_SERVICE_DATA *Udp4Service;
302 UDP4_INSTANCE_DATA *Instance;
303 EFI_TPL OldTpl;
304 VOID *Ip4;
305
306 if ((This == NULL) || (ChildHandle == NULL)) {
307 return EFI_INVALID_PARAMETER;
308 }
309
310 Udp4Service = UDP4_SERVICE_DATA_FROM_THIS (This);
311
312 //
313 // Allocate the instance private data structure.
314 //
315 Instance = AllocateZeroPool (sizeof (UDP4_INSTANCE_DATA));
316 if (Instance == NULL) {
317 return EFI_OUT_OF_RESOURCES;
318 }
319
320 Udp4InitInstance (Udp4Service, Instance);
321
322 //
323 // Add an IpInfo for this instance.
324 //
325 Instance->IpInfo = IpIoAddIp (Udp4Service->IpIo);
326 if (Instance->IpInfo == NULL) {
327 Status = EFI_OUT_OF_RESOURCES;
328 goto ON_ERROR;
329 }
330
331 //
332 // Install the Udp4Protocol for this instance.
333 //
334 Status = gBS->InstallMultipleProtocolInterfaces (
335 ChildHandle,
336 &gEfiUdp4ProtocolGuid,
337 &Instance->Udp4Proto,
338 NULL
339 );
340 if (EFI_ERROR (Status)) {
341 goto ON_ERROR;
342 }
343
344 Instance->ChildHandle = *ChildHandle;
345
346 //
347 // Open the default Ip4 protocol in the IP_IO BY_CHILD.
348 //
349 Status = gBS->OpenProtocol (
350 Udp4Service->IpIo->ChildHandle,
351 &gEfiIp4ProtocolGuid,
352 (VOID **)&Ip4,
353 gUdp4DriverBinding.DriverBindingHandle,
354 Instance->ChildHandle,
355 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
356 );
357 if (EFI_ERROR (Status)) {
358 goto ON_ERROR;
359 }
360
361 //
362 // Open this instance's Ip4 protocol in the IpInfo BY_CHILD.
363 //
364 Status = gBS->OpenProtocol (
365 Instance->IpInfo->ChildHandle,
366 &gEfiIp4ProtocolGuid,
367 (VOID **)&Ip4,
368 gUdp4DriverBinding.DriverBindingHandle,
369 Instance->ChildHandle,
370 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
371 );
372 if (EFI_ERROR (Status)) {
373 goto ON_ERROR;
374 }
375
376 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
377
378 //
379 // Link this instance into the service context data and increase the ChildrenNumber.
380 //
381 InsertTailList (&Udp4Service->ChildrenList, &Instance->Link);
382 Udp4Service->ChildrenNumber++;
383
384 gBS->RestoreTPL (OldTpl);
385
386 return EFI_SUCCESS;
387
388ON_ERROR:
389
390 if (Instance->ChildHandle != NULL) {
391 gBS->UninstallMultipleProtocolInterfaces (
392 Instance->ChildHandle,
393 &gEfiUdp4ProtocolGuid,
394 &Instance->Udp4Proto,
395 NULL
396 );
397 }
398
399 if (Instance->IpInfo != NULL) {
400 IpIoRemoveIp (Udp4Service->IpIo, Instance->IpInfo);
401 }
402
403 Udp4CleanInstance (Instance);
404
405 FreePool (Instance);
406
407 return Status;
408}
409
410/**
411 Destroys a child handle with a protocol installed on it.
412
413 The DestroyChild() function does the opposite of CreateChild(). It removes a protocol
414 that was installed by CreateChild() from ChildHandle. If the removed protocol is the
415 last protocol on ChildHandle, then ChildHandle is destroyed.
416
417 @param[in] This Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
418 @param[in] ChildHandle Handle of the child to destroy
419
420 @retval EFI_SUCCESS The protocol was removed from ChildHandle.
421 @retval EFI_UNSUPPORTED ChildHandle does not support the protocol that is being removed.
422 @retval EFI_INVALID_PARAMETER Child handle is NULL.
423 @retval EFI_ACCESS_DENIED The protocol could not be removed from the ChildHandle
424 because its services are being used.
425 @retval other The child handle was not destroyed
426
427**/
428EFI_STATUS
429EFIAPI
430Udp4ServiceBindingDestroyChild (
431 IN EFI_SERVICE_BINDING_PROTOCOL *This,
432 IN EFI_HANDLE ChildHandle
433 )
434{
435 EFI_STATUS Status;
436 UDP4_SERVICE_DATA *Udp4Service;
437 EFI_UDP4_PROTOCOL *Udp4Proto;
438 UDP4_INSTANCE_DATA *Instance;
439 EFI_TPL OldTpl;
440
441 if ((This == NULL) || (ChildHandle == NULL)) {
442 return EFI_INVALID_PARAMETER;
443 }
444
445 Udp4Service = UDP4_SERVICE_DATA_FROM_THIS (This);
446
447 //
448 // Try to get the Udp4 protocol from the ChildHandle.
449 //
450 Status = gBS->OpenProtocol (
451 ChildHandle,
452 &gEfiUdp4ProtocolGuid,
453 (VOID **)&Udp4Proto,
454 gUdp4DriverBinding.DriverBindingHandle,
455 ChildHandle,
456 EFI_OPEN_PROTOCOL_GET_PROTOCOL
457 );
458 if (EFI_ERROR (Status)) {
459 return EFI_UNSUPPORTED;
460 }
461
462 Instance = UDP4_INSTANCE_DATA_FROM_THIS (Udp4Proto);
463
464 if (Instance->InDestroy) {
465 return EFI_SUCCESS;
466 }
467
468 //
469 // Use the Destroyed flag to avoid the re-entering of the following code.
470 //
471 Instance->InDestroy = TRUE;
472
473 //
474 // Close the Ip4 protocol.
475 //
476 gBS->CloseProtocol (
477 Udp4Service->IpIo->ChildHandle,
478 &gEfiIp4ProtocolGuid,
479 gUdp4DriverBinding.DriverBindingHandle,
480 Instance->ChildHandle
481 );
482 //
483 // Close the Ip4 protocol on this instance's IpInfo.
484 //
485 gBS->CloseProtocol (
486 Instance->IpInfo->ChildHandle,
487 &gEfiIp4ProtocolGuid,
488 gUdp4DriverBinding.DriverBindingHandle,
489 Instance->ChildHandle
490 );
491
492 //
493 // Uninstall the Udp4Protocol previously installed on the ChildHandle.
494 //
495 Status = gBS->UninstallMultipleProtocolInterfaces (
496 ChildHandle,
497 &gEfiUdp4ProtocolGuid,
498 (VOID *)&Instance->Udp4Proto,
499 NULL
500 );
501 if (EFI_ERROR (Status)) {
502 Instance->InDestroy = FALSE;
503 return Status;
504 }
505
506 //
507 // Reset the configuration in case the instance's consumer forgets to do this.
508 //
509 Udp4Proto->Configure (Udp4Proto, NULL);
510
511 //
512 // Remove the IpInfo this instance consumes.
513 //
514 IpIoRemoveIp (Udp4Service->IpIo, Instance->IpInfo);
515
516 OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
517
518 //
519 // Remove this instance from the service context data's ChildrenList.
520 //
521 RemoveEntryList (&Instance->Link);
522 Udp4Service->ChildrenNumber--;
523
524 //
525 // Clean the instance.
526 //
527 Udp4CleanInstance (Instance);
528
529 gBS->RestoreTPL (OldTpl);
530
531 FreePool (Instance);
532
533 return EFI_SUCCESS;
534}
535
536/**
537 This is the declaration of an EFI image entry point. This entry point is
538 the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including
539 both device drivers and bus drivers.
540
541 The entry point for Udp4 driver which installs the driver binding
542 and component name protocol on its ImageHandle.
543
544 @param[in] ImageHandle The firmware allocated handle for the UEFI image.
545 @param[in] SystemTable A pointer to the EFI System Table.
546
547 @retval EFI_SUCCESS The operation completed successfully.
548 @retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
549
550**/
551EFI_STATUS
552EFIAPI
553Udp4DriverEntryPoint (
554 IN EFI_HANDLE ImageHandle,
555 IN EFI_SYSTEM_TABLE *SystemTable
556 )
557{
558 EFI_STATUS Status;
559 UINT32 Random;
560
561 Status = PseudoRandomU32 (&Random);
562 if (EFI_ERROR (Status)) {
563 DEBUG ((DEBUG_ERROR, "%a failed to generate random number: %r\n", __func__, Status));
564 return Status;
565 }
566
567 //
568 // Install the Udp4DriverBinding and Udp4ComponentName protocols.
569 //
570 Status = EfiLibInstallDriverBindingComponentName2 (
571 ImageHandle,
572 SystemTable,
573 &gUdp4DriverBinding,
574 ImageHandle,
575 &gUdp4ComponentName,
576 &gUdp4ComponentName2
577 );
578 if (!EFI_ERROR (Status)) {
579 //
580 // Initialize the UDP random port.
581 //
582 mUdp4RandomPort = (UINT16)(((UINT16)Random) % UDP4_PORT_KNOWN + UDP4_PORT_KNOWN);
583 }
584
585 return Status;
586}
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