Ip6Driver.c@ 87965

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

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

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/NetworkPkg/Ip6Dxe/Ip6Driver.c@ 87965

Download in other formats: