Ip6Driver.c@ 58466

Last change on this file since 58466 was 58466, checked in by vboxsync, 9 years ago
EFI/Firmware: Merged in the svn:eol-style, svn:mime-type and trailing whitespace cleanup that was done after the initial UDK2014.SP1 import: svn merge ^{/vendor/edk2/UDK2014.SP1}/vendor/edk2/current .
Property svn:eol-style set to `native`
File size: 27.3 KB

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

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

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

Download in other formats: