Ip6Driver.c@ 99404

Last change on this file since 99404 was 99404, checked in by vboxsync, 22 months ago
Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
Property svn:eol-style set to `native`
File size: 29.2 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/Ip6Dxe/Ip6Driver.c@ 99404

Download in other formats: