Dh.c@ 48674

Last change on this file since 48674 was 48674, checked in by vboxsync, 11 years ago
EFI: Export newly imported tinaocore UEFI sources to OSE.
Property svn:eol-style set to `native`
File size: 28.6 KB

Line
1	/** @file
2	Main file for Dh shell Driver1 function.
3
4	Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
5	This program and the accompanying materials
6	are licensed and made available under the terms and conditions of the BSD License
7	which accompanies this distribution. The full text of the license may be found at
8	http://opensource.org/licenses/bsd-license.php
9
10	THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11	WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13	**/
14
15	#include "UefiShellDriver1CommandsLib.h"
16
17	STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
18	{L"-p", TypeValue},
19	{L"-d", TypeFlag},
20	{L"-v", TypeFlag},
21	{L"-verbose", TypeFlag},
22	{L"-sfo", TypeFlag},
23	{L"-l", TypeValue},
24	{NULL, TypeMax}
25	};
26
27	STATIC CONST EFI_GUID *UefiDriverModelProtocolsGuidArray[] = {
28	&gEfiDriverBindingProtocolGuid,
29	&gEfiPlatformDriverOverrideProtocolGuid,
30	&gEfiBusSpecificDriverOverrideProtocolGuid,
31	&gEfiDriverDiagnosticsProtocolGuid,
32	&gEfiDriverDiagnostics2ProtocolGuid,
33	&gEfiComponentNameProtocolGuid,
34	&gEfiComponentName2ProtocolGuid,
35	&gEfiPlatformToDriverConfigurationProtocolGuid,
36	&gEfiDriverSupportedEfiVersionProtocolGuid,
37	&gEfiDriverFamilyOverrideProtocolGuid,
38	&gEfiDriverHealthProtocolGuid,
39	&gEfiLoadedImageProtocolGuid,
40	NULL
41	};
42
43	/**
44	Get the name of a driver by it's handle.
45
46	If a name is found the memory must be callee freed.
47
48	@param[in] TheHandle The driver's handle.
49	@param[in] Language The language to use.
50	@param[in] NameFound Upon a successful return the name found.
51
52	@retval EFI_SUCCESS The name was found.
53	**/
54	EFI_STATUS
55	EFIAPI
56	GetDriverName (
57	IN EFI_HANDLE TheHandle,
58	IN CONST CHAR8 *Language,
59	IN CHAR16 **NameFound
60	)
61	{
62	CHAR8 *Lang;
63	CHAR8 *TempChar;
64	EFI_STATUS Status;
65	EFI_COMPONENT_NAME2_PROTOCOL *CompName2;
66	CHAR16 *NameToReturn;
67	//
68	// Go through those handles until we get one that passes for GetComponentName
69	//
70	Status = gBS->OpenProtocol(
71	TheHandle,
72	&gEfiComponentName2ProtocolGuid,
73	(VOID**)&CompName2,
74	gImageHandle,
75	NULL,
76	EFI_OPEN_PROTOCOL_GET_PROTOCOL);
77	if (EFI_ERROR(Status)) {
78	Status = gBS->OpenProtocol(
79	TheHandle,
80	&gEfiComponentNameProtocolGuid,
81	(VOID**)&CompName2,
82	gImageHandle,
83	NULL,
84	EFI_OPEN_PROTOCOL_GET_PROTOCOL);
85	}
86
87	if (EFI_ERROR(Status)) {
88	return (EFI_NOT_FOUND);
89	}
90	if (Language == NULL) {
91	Lang = AllocateZeroPool(AsciiStrSize(CompName2->SupportedLanguages));
92	if (Lang == NULL) {
93	return (EFI_OUT_OF_RESOURCES);
94	}
95	AsciiStrCpy(Lang, CompName2->SupportedLanguages);
96	TempChar = AsciiStrStr(Lang, ";");
97	if (TempChar != NULL){
98	*TempChar = CHAR_NULL;
99	}
100	} else {
101	Lang = AllocateZeroPool(AsciiStrSize(Language));
102	if (Lang == NULL) {
103	return (EFI_OUT_OF_RESOURCES);
104	}
105	AsciiStrCpy(Lang, Language);
106	}
107	Status = CompName2->GetDriverName(CompName2, Lang, &NameToReturn);
108	FreePool(Lang);
109
110	if (!EFI_ERROR(Status) && NameToReturn != NULL) {
111	*NameFound = NULL;
112	StrnCatGrow(NameFound, NULL, NameToReturn, 0);
113	}
114	return (Status);
115	}
116
117	/**
118	Discover if a protocol guid is one of the UEFI Driver Model Protocols.
119
120	@param[in] Guid The guid to test.
121
122	@retval TRUE The guid does represent a driver model protocol.
123	@retval FALSE The guid does not represent a driver model protocol.
124	**/
125	BOOLEAN
126	EFIAPI
127	IsDriverProt (
128	IN CONST EFI_GUID *Guid
129	)
130	{
131	CONST EFI_GUID **GuidWalker;
132	BOOLEAN GuidFound;
133	GuidFound = FALSE;
134	for (GuidWalker = UefiDriverModelProtocolsGuidArray
135	; GuidWalker != NULL && *GuidWalker != NULL
136	; GuidWalker++
137	){
138	if (CompareGuid(*GuidWalker, Guid)) {
139	GuidFound = TRUE;
140	break;
141	}
142	}
143	return (GuidFound);
144	}
145
146	/**
147	Get information for a handle.
148
149	@param[in] TheHandle The handles to show info on.
150	@param[in] Language Language string per UEFI specification.
151	@param[in] Seperator Separator string between information blocks.
152	@param[in] Verbose TRUE for extra info, FALSE otherwise.
153	@param[in] ExtraInfo TRUE for extra info, FALSE otherwise.
154
155	@retval SHELL_SUCCESS The operation was successful.
156	@retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
157	**/
158	CHAR16*
159	EFIAPI
160	GetProtocolInfoString(
161	IN CONST EFI_HANDLE TheHandle,
162	IN CONST CHAR8 *Language,
163	IN CONST CHAR16 *Seperator,
164	IN CONST BOOLEAN Verbose,
165	IN CONST BOOLEAN ExtraInfo
166	)
167	{
168	EFI_GUID **ProtocolGuidArray;
169	UINTN ArrayCount;
170	UINTN ProtocolIndex;
171	EFI_STATUS Status;
172	CHAR16 *RetVal;
173	UINTN Size;
174	CHAR16 *Temp;
175
176	ProtocolGuidArray = NULL;
177	RetVal = NULL;
178	Size = 0;
179
180	Status = gBS->ProtocolsPerHandle (
181	TheHandle,
182	&ProtocolGuidArray,
183	&ArrayCount
184	);
185	if (!EFI_ERROR (Status)) {
186	for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
187	Temp = GetStringNameFromGuid(ProtocolGuidArray[ProtocolIndex], Language);
188	if (Temp != NULL) {
189	ASSERT((RetVal == NULL && Size == 0) \|\| (RetVal != NULL));
190	if (Size != 0) {
191	StrnCatGrow(&RetVal, &Size, Seperator, 0);
192	}
193	StrnCatGrow(&RetVal, &Size, L"%H", 0);
194	StrnCatGrow(&RetVal, &Size, Temp, 0);
195	StrnCatGrow(&RetVal, &Size, L"%N", 0);
196	FreePool(Temp);
197	}
198	if (ExtraInfo) {
199	Temp = GetProtocolInformationDump(TheHandle, ProtocolGuidArray[ProtocolIndex], Verbose);
200	if (Temp != NULL) {
201	ASSERT((RetVal == NULL && Size == 0) \|\| (RetVal != NULL));
202	if (!Verbose) {
203	StrnCatGrow(&RetVal, &Size, L"(", 0);
204	StrnCatGrow(&RetVal, &Size, Temp, 0);
205	StrnCatGrow(&RetVal, &Size, L")", 0);
206	} else {
207	StrnCatGrow(&RetVal, &Size, Seperator, 0);
208	StrnCatGrow(&RetVal, &Size, Temp, 0);
209	}
210	FreePool(Temp);
211	}
212	}
213	}
214	}
215
216	SHELL_FREE_NON_NULL(ProtocolGuidArray);
217
218	if (RetVal == NULL) {
219	return (NULL);
220	}
221
222	ASSERT((RetVal == NULL && Size == 0) \|\| (RetVal != NULL));
223	StrnCatGrow(&RetVal, &Size, Seperator, 0);
224	return (RetVal);
225	}
226
227	/**
228	Gets the name of the loaded image.
229
230	@param[in] TheHandle The handle of the driver to get info on.
231	@param[out] Name The pointer to the pointer. Valid upon a successful return.
232
233	@retval EFI_SUCCESS The operation was successful.
234	**/
235	EFI_STATUS
236	EFIAPI
237	GetDriverImageName (
238	IN EFI_HANDLE TheHandle,
239	OUT CHAR16 **Name
240	)
241	{
242	// get loaded image and devicepathtotext on image->Filepath
243	EFI_LOADED_IMAGE_PROTOCOL *LoadedImage;
244	EFI_STATUS Status;
245	EFI_DEVICE_PATH_PROTOCOL *DevicePath;
246
247	if (TheHandle == NULL \|\| Name == NULL) {
248	return (EFI_INVALID_PARAMETER);
249	}
250
251	Status = gBS->OpenProtocol (
252	TheHandle,
253	&gEfiLoadedImageProtocolGuid,
254	(VOID **) &LoadedImage,
255	gImageHandle,
256	NULL,
257	EFI_OPEN_PROTOCOL_GET_PROTOCOL
258	);
259	if (EFI_ERROR(Status)) {
260	return (Status);
261	}
262	DevicePath = LoadedImage->FilePath;
263	*Name = gDevPathToText->ConvertDevicePathToText(DevicePath, TRUE, TRUE);
264	return (EFI_SUCCESS);
265	}
266
267	/**
268	Display driver model information for a given handle.
269
270	@param[in] Handle The handle to display info on.
271	@param[in] BestName Use the best name?
272	@param[in] Language The language to output in.
273	**/
274	EFI_STATUS
275	EFIAPI
276	DisplayDriverModelHandle (
277	IN EFI_HANDLE Handle,
278	IN BOOLEAN BestName,
279	IN CONST CHAR8 *Language OPTIONAL
280	)
281	{
282	EFI_STATUS Status;
283	BOOLEAN ConfigurationStatus;
284	BOOLEAN DiagnosticsStatus;
285	UINTN DriverBindingHandleCount;
286	EFI_HANDLE *DriverBindingHandleBuffer;
287	UINTN ParentControllerHandleCount;
288	EFI_HANDLE *ParentControllerHandleBuffer;
289	UINTN ChildControllerHandleCount;
290	EFI_HANDLE *ChildControllerHandleBuffer;
291	CHAR16 *TempStringPointer;
292	EFI_DEVICE_PATH_PROTOCOL *DevicePath;
293	UINTN Index;
294	CHAR16 *DriverName;
295	EFI_DRIVER_BINDING_PROTOCOL *DriverBinding;
296	UINTN NumberOfChildren;
297	UINTN HandleIndex;
298	UINTN ControllerHandleCount;
299	EFI_HANDLE *ControllerHandleBuffer;
300	UINTN ChildIndex;
301	BOOLEAN Image;
302
303	//
304	// See if Handle is a device handle and display its details.
305	//
306	DriverBindingHandleBuffer = NULL;
307	Status = PARSE_HANDLE_DATABASE_UEFI_DRIVERS (
308	Handle,
309	&DriverBindingHandleCount,
310	&DriverBindingHandleBuffer
311	);
312
313	ParentControllerHandleBuffer = NULL;
314	Status = PARSE_HANDLE_DATABASE_PARENTS (
315	Handle,
316	&ParentControllerHandleCount,
317	&ParentControllerHandleBuffer
318	);
319
320	ChildControllerHandleBuffer = NULL;
321	Status = ParseHandleDatabaseForChildControllers (
322	Handle,
323	&ChildControllerHandleCount,
324	&ChildControllerHandleBuffer
325	);
326
327	DiagnosticsStatus = FALSE;
328	ConfigurationStatus = FALSE;
329
330	if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverConfigurationProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
331	ConfigurationStatus = TRUE;
332	}
333	if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverConfiguration2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
334	ConfigurationStatus = TRUE;
335	}
336	if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverDiagnosticsProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
337	DiagnosticsStatus = TRUE;
338	}
339	if (!EFI_ERROR(gBS->OpenProtocol(Handle, &gEfiDriverDiagnostics2ProtocolGuid, NULL, NULL, gImageHandle, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
340	DiagnosticsStatus = TRUE;
341	}
342
343	Status = EFI_SUCCESS;
344
345	if (DriverBindingHandleCount > 0 \|\| ParentControllerHandleCount > 0 \|\| ChildControllerHandleCount > 0) {
346
347
348
349	DevicePath = NULL;
350	TempStringPointer = NULL;
351	Status = gBS->HandleProtocol (Handle, &gEfiDevicePathProtocolGuid, (VOID**)&DevicePath);
352
353	Status = gEfiShellProtocol->GetDeviceName(Handle, EFI_DEVICE_NAME_USE_COMPONENT_NAME\|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
354	ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DH_OUTPUT_DRIVER1), gShellDriver1HiiHandle, TempStringPointer!=NULL?TempStringPointer:L"<Unknown>");
355	SHELL_FREE_NON_NULL(TempStringPointer);
356
357	TempStringPointer = gDevPathToText->ConvertDevicePathToText(DevicePath, TRUE, FALSE);
358	ShellPrintHiiEx(
359	-1,
360	-1,
361	NULL,
362	STRING_TOKEN (STR_DH_OUTPUT_DRIVER2),
363	gShellDriver1HiiHandle,
364	TempStringPointer!=NULL?TempStringPointer:L"<None>",
365	ParentControllerHandleCount == 0?L"ROOT":(ChildControllerHandleCount > 0)?L"BUS":L"DEVICE",
366	ConfigurationStatus?L"YES":L"NO",
367	DiagnosticsStatus?L"YES":L"NO"
368	);
369
370	SHELL_FREE_NON_NULL(TempStringPointer);
371
372	if (DriverBindingHandleCount == 0) {
373	ShellPrintHiiEx(
374	-1,
375	-1,
376	NULL,
377	STRING_TOKEN (STR_DH_OUTPUT_DRIVER3),
378	gShellDriver1HiiHandle,
379	L"<None>"
380	);
381	} else {
382	ShellPrintHiiEx(
383	-1,
384	-1,
385	NULL,
386	STRING_TOKEN (STR_DH_OUTPUT_DRIVER3),
387	gShellDriver1HiiHandle,
388	L""
389	);
390	for (Index = 0; Index < DriverBindingHandleCount; Index++) {
391	Image = FALSE;
392	Status = GetDriverName (
393	DriverBindingHandleBuffer[Index],
394	Language,
395	&DriverName
396	);
397	if (DriverName == NULL) {
398	Status = GetDriverImageName (
399	DriverBindingHandleBuffer[Index],
400	&DriverName
401	);
402	}
403
404	if (Image) {
405	ShellPrintHiiEx(
406	-1,
407	-1,
408	NULL,
409	STRING_TOKEN (STR_DH_OUTPUT_DRIVER4A),
410	gShellDriver1HiiHandle,
411	ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),
412	DriverName!=NULL?DriverName:L"<Unknown>"
413	);
414	} else {
415	ShellPrintHiiEx(
416	-1,
417	-1,
418	NULL,
419	STRING_TOKEN (STR_DH_OUTPUT_DRIVER4B),
420	gShellDriver1HiiHandle,
421	ConvertHandleToHandleIndex (DriverBindingHandleBuffer[Index]),
422	DriverName!=NULL?DriverName:L"<Unknown>"
423	);
424	}
425	SHELL_FREE_NON_NULL(DriverName);
426	}
427	}
428
429	if (ParentControllerHandleCount == 0) {
430	ShellPrintHiiEx(
431	-1,
432	-1,
433	NULL,
434	STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),
435	gShellDriver1HiiHandle,
436	L"<None>"
437	);
438	} else {
439	ShellPrintHiiEx(
440	-1,
441	-1,
442	NULL,
443	STRING_TOKEN (STR_DH_OUTPUT_DRIVER5),
444	gShellDriver1HiiHandle,
445	L""
446	);
447	for (Index = 0; Index < ParentControllerHandleCount; Index++) {
448	Status = gEfiShellProtocol->GetDeviceName(ParentControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME\|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
449	ShellPrintHiiEx(
450	-1,
451	-1,
452	NULL,
453	STRING_TOKEN (STR_DH_OUTPUT_DRIVER5B),
454	gShellDriver1HiiHandle,
455	ConvertHandleToHandleIndex (ParentControllerHandleBuffer[Index]),
456	TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
457	);
458	SHELL_FREE_NON_NULL(TempStringPointer);
459	}
460	}
461
462	if (ChildControllerHandleCount == 0) {
463	ShellPrintHiiEx(
464	-1,
465	-1,
466	NULL,
467	STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
468	gShellDriver1HiiHandle,
469	L"<None>"
470	);
471	} else {
472	ShellPrintHiiEx(
473	-1,
474	-1,
475	NULL,
476	STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
477	gShellDriver1HiiHandle,
478	L""
479	);
480	for (Index = 0; Index < ChildControllerHandleCount; Index++) {
481	Status = gEfiShellProtocol->GetDeviceName(ChildControllerHandleBuffer[Index], EFI_DEVICE_NAME_USE_COMPONENT_NAME\|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
482	ShellPrintHiiEx(
483	-1,
484	-1,
485	NULL,
486	STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),
487	gShellDriver1HiiHandle,
488	ConvertHandleToHandleIndex (ChildControllerHandleBuffer[Index]),
489	TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
490	);
491	SHELL_FREE_NON_NULL(TempStringPointer);
492	}
493	}
494	}
495
496	SHELL_FREE_NON_NULL(DriverBindingHandleBuffer);
497
498	SHELL_FREE_NON_NULL(ParentControllerHandleBuffer);
499
500	SHELL_FREE_NON_NULL(ChildControllerHandleBuffer);
501
502	if (EFI_ERROR (Status)) {
503	return Status;
504	}
505	//
506	// See if Handle is a driver binding handle and display its details.
507	//
508	Status = gBS->OpenProtocol (
509	Handle,
510	&gEfiDriverBindingProtocolGuid,
511	(VOID **) &DriverBinding,
512	NULL,
513	NULL,
514	EFI_OPEN_PROTOCOL_GET_PROTOCOL
515	);
516	if (EFI_ERROR (Status)) {
517	return EFI_SUCCESS;
518	}
519
520	NumberOfChildren = 0;
521	ControllerHandleBuffer = NULL;
522	Status = PARSE_HANDLE_DATABASE_DEVICES (
523	Handle,
524	&ControllerHandleCount,
525	&ControllerHandleBuffer
526	);
527	if (ControllerHandleCount > 0) {
528	for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {
529	Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
530	Handle,
531	ControllerHandleBuffer[HandleIndex],
532	&ChildControllerHandleCount,
533	NULL
534	);
535	NumberOfChildren += ChildControllerHandleCount;
536	}
537	}
538
539	Status = GetDriverName (Handle, Language, &DriverName);
540
541	ShellPrintHiiEx(
542	-1,
543	-1,
544	NULL,
545	STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),
546	gShellDriver1HiiHandle,
547	ConvertHandleToHandleIndex(Handle),
548	DriverName!=NULL?DriverName:L"<Unknown>"
549	);
550	SHELL_FREE_NON_NULL(DriverName);
551	DriverName = NULL;
552	Status = GetDriverImageName (
553	Handle,
554	&DriverName
555	);
556	ShellPrintHiiEx(
557	-1,
558	-1,
559	NULL,
560	STRING_TOKEN (STR_DH_OUTPUT_DRIVER7B),
561	gShellDriver1HiiHandle,
562	DriverName!=NULL?DriverName:L"<Unknown>"
563	);
564	SHELL_FREE_NON_NULL(DriverName);
565
566	ShellPrintHiiEx(
567	-1,
568	-1,
569	NULL,
570	STRING_TOKEN (STR_DH_OUTPUT_DRIVER8),
571	gShellDriver1HiiHandle,
572	DriverBinding->Version,
573	NumberOfChildren > 0?L"Bus":ControllerHandleCount > 0?L"Device":L"<Unknown>",
574	ConfigurationStatus?L"YES":L"NO",
575	DiagnosticsStatus?L"YES":L"NO"
576	);
577
578	if (ControllerHandleCount == 0) {
579	ShellPrintHiiEx(
580	-1,
581	-1,
582	NULL,
583	STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
584	gShellDriver1HiiHandle,
585	L"None"
586	);
587	} else {
588	ShellPrintHiiEx(
589	-1,
590	-1,
591	NULL,
592	STRING_TOKEN (STR_DH_OUTPUT_DRIVER6),
593	gShellDriver1HiiHandle,
594	L""
595	);
596	for (HandleIndex = 0; HandleIndex < ControllerHandleCount; HandleIndex++) {
597	Status = gEfiShellProtocol->GetDeviceName(ControllerHandleBuffer[HandleIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME\|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
598
599	ShellPrintHiiEx(
600	-1,
601	-1,
602	NULL,
603	STRING_TOKEN (STR_DH_OUTPUT_DRIVER9B),
604	gShellDriver1HiiHandle,
605	ConvertHandleToHandleIndex(ControllerHandleBuffer[HandleIndex]),
606	TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
607	);
608	SHELL_FREE_NON_NULL(TempStringPointer);
609
610	Status = PARSE_HANDLE_DATABASE_MANAGED_CHILDREN (
611	Handle,
612	ControllerHandleBuffer[HandleIndex],
613	&ChildControllerHandleCount,
614	&ChildControllerHandleBuffer
615	);
616	if (!EFI_ERROR (Status)) {
617	for (ChildIndex = 0; ChildIndex < ChildControllerHandleCount; ChildIndex++) {
618	Status = gEfiShellProtocol->GetDeviceName(ChildControllerHandleBuffer[ChildIndex], EFI_DEVICE_NAME_USE_COMPONENT_NAME\|EFI_DEVICE_NAME_USE_DEVICE_PATH, (CHAR8*)Language, &TempStringPointer);
619
620	ShellPrintHiiEx(
621	-1,
622	-1,
623	NULL,
624	STRING_TOKEN (STR_DH_OUTPUT_DRIVER6B),
625	gShellDriver1HiiHandle,
626	ConvertHandleToHandleIndex(ChildControllerHandleBuffer[ChildIndex]),
627	TempStringPointer!=NULL?TempStringPointer:L"<Unknown>"
628	);
629	SHELL_FREE_NON_NULL(TempStringPointer);
630	}
631
632	SHELL_FREE_NON_NULL (ChildControllerHandleBuffer);
633	}
634	}
635
636	SHELL_FREE_NON_NULL (ControllerHandleBuffer);
637	}
638
639	return EFI_SUCCESS;
640	}
641
642	/**
643	Display information for a handle.
644
645	@param[in] TheHandle The handles to show info on.
646	@param[in] Verbose TRUE for extra info, FALSE otherwise.
647	@param[in] Sfo TRUE to output in standard format output (spec).
648	@param[in] Language Language string per UEFI specification.
649	@param[in] DriverInfo TRUE to show all info about the handle.
650	@param[in] Multiple TRUE indicates more than will be output,
651	FALSE for a single one.
652
653	@retval SHELL_SUCCESS The operation was successful.
654	@retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
655	**/
656	SHELL_STATUS
657	EFIAPI
658	DoDhByHandle(
659	IN CONST EFI_HANDLE TheHandle,
660	IN CONST BOOLEAN Verbose,
661	IN CONST BOOLEAN Sfo,
662	IN CONST CHAR8 *Language,
663	IN CONST BOOLEAN DriverInfo,
664	IN CONST BOOLEAN Multiple
665	)
666	{
667	CHAR16 *ProtocolInfoString;
668	SHELL_STATUS ShellStatus;
669	EFI_STATUS Status;
670
671	Status = EFI_SUCCESS;
672	ShellStatus = SHELL_SUCCESS;
673	ProtocolInfoString = NULL;
674
675	if (!Sfo) {
676	if (Multiple) {
677	ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L" ", Verbose, TRUE);
678	ShellPrintHiiEx(
679	-1,
680	-1,
681	NULL,
682	STRING_TOKEN (STR_DH_OUTPUT),
683	gShellDriver1HiiHandle,
684	ConvertHandleToHandleIndex(TheHandle),
685	ProtocolInfoString==NULL?L"":ProtocolInfoString);
686	} else {
687	ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L"\r\n", Verbose, TRUE);
688	ShellPrintHiiEx(
689	-1,
690	-1,
691	NULL,
692	STRING_TOKEN (STR_DH_OUTPUT_SINGLE),
693	gShellDriver1HiiHandle,
694	ConvertHandleToHandleIndex(TheHandle),
695	TheHandle,
696	ProtocolInfoString==NULL?L"":ProtocolInfoString);
697	}
698
699	if (DriverInfo) {
700	DisplayDriverModelHandle ((EFI_HANDLE)TheHandle, TRUE, Language);
701	}
702	} else {
703	ProtocolInfoString = GetProtocolInfoString(TheHandle, Language, L";", FALSE, FALSE);
704	ShellPrintHiiEx(
705	-1,
706	-1,
707	NULL,
708	STRING_TOKEN (STR_DH_OUTPUT_SFO),
709	gShellDriver1HiiHandle,
710	Multiple ?L"HandlesInfo":L"HandleInfo",
711	L"DriverName",
712	L"ControllerName",
713	ConvertHandleToHandleIndex(TheHandle),
714	L"DevPath",
715	ProtocolInfoString==NULL?L"":ProtocolInfoString);
716
717
718	}
719
720
721	if (ProtocolInfoString != NULL) {
722	FreePool(ProtocolInfoString);
723	}
724	return (ShellStatus);
725	}
726
727	/**
728	Display information for all handles on a list.
729
730	@param[in] HandleList The NULL-terminated list of handles.
731	@param[in] Sfo TRUE to output in standard format output (spec).
732	@param[in] Language Language string per UEFI specification.
733	@param[in] DriverInfo TRUE to show all info about the handle.
734
735	@retval SHELL_SUCCESS The operation was successful.
736	@retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
737	**/
738	SHELL_STATUS
739	EFIAPI
740	DoDhForHandleList(
741	IN CONST EFI_HANDLE *HandleList,
742	IN CONST BOOLEAN Sfo,
743	IN CONST CHAR8 *Language,
744	IN CONST BOOLEAN DriverInfo
745	)
746	{
747	CONST EFI_HANDLE *HandleWalker;
748	SHELL_STATUS ShellStatus;
749
750	ShellStatus = SHELL_SUCCESS;
751
752	for (HandleWalker = HandleList ; HandleWalker != NULL && *HandleWalker != NULL && ShellStatus == SHELL_SUCCESS; HandleWalker++) {
753	ShellStatus = DoDhByHandle(
754	*HandleWalker,
755	FALSE,
756	Sfo,
757	Language,
758	DriverInfo,
759	TRUE
760	);
761	}
762	return (ShellStatus);
763	}
764
765	/**
766	Display information for all handles.
767
768	@param[in] Sfo TRUE to output in standard format output (spec).
769	@param[in] Language Language string per UEFI specification.
770	@param[in] DriverInfo TRUE to show all info about the handle.
771
772	@retval SHELL_SUCCESS The operation was successful.
773	@retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
774	**/
775	SHELL_STATUS
776	EFIAPI
777	DoDhForAll(
778	IN CONST BOOLEAN Sfo,
779	IN CONST CHAR8 *Language,
780	IN CONST BOOLEAN DriverInfo
781	)
782	{
783	EFI_HANDLE *HandleList;
784	SHELL_STATUS ShellStatus;
785
786	HandleList = GetHandleListByProtocol(NULL);
787
788	ShellStatus = DoDhForHandleList(
789	HandleList,
790	Sfo,
791	Language,
792	DriverInfo);
793
794	FreePool(HandleList);
795
796	return (ShellStatus);
797	}
798
799	/**
800	Display information for all handles which have a specific protocol.
801
802	@param[in] ProtocolName The pointer to the name of the protocol.
803	@param[in] Sfo TRUE to output in standard format output (spec).
804	@param[in] Language Language string per UEFI specification.
805	@param[in] DriverInfo TRUE to show all info about the handle.
806
807	@retval SHELL_SUCCESS The operation was successful.
808	@retval SHELL_INVALID_PARAMETER ProtocolName was NULL or invalid.
809	**/
810	SHELL_STATUS
811	EFIAPI
812	DoDhByProtocol(
813	IN CONST CHAR16 *ProtocolName,
814	IN CONST BOOLEAN Sfo,
815	IN CONST CHAR8 *Language,
816	IN CONST BOOLEAN DriverInfo
817	)
818	{
819	EFI_GUID *Guid;
820	EFI_STATUS Status;
821	EFI_HANDLE *HandleList;
822	SHELL_STATUS ShellStatus;
823
824	if (ProtocolName == NULL) {
825	return (SHELL_INVALID_PARAMETER);
826	}
827
828	Status = GetGuidFromStringName(ProtocolName, Language, &Guid);
829	if (EFI_ERROR(Status)) {
830	ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DH_NO_GUID_FOUND), gShellDriver1HiiHandle, ProtocolName);
831	return (SHELL_INVALID_PARAMETER);
832	}
833
834	HandleList = GetHandleListByProtocol(Guid);
835
836	ShellStatus = DoDhForHandleList(
837	HandleList,
838	Sfo,
839	Language,
840	DriverInfo);
841
842	SHELL_FREE_NON_NULL(HandleList);
843
844	return (ShellStatus);
845	}
846
847	/**
848	Function for 'dh' command.
849
850	@param[in] ImageHandle Handle to the Image (NULL if Internal).
851	@param[in] SystemTable Pointer to the System Table (NULL if Internal).
852	**/
853	SHELL_STATUS
854	EFIAPI
855	ShellCommandRunDh (
856	IN EFI_HANDLE ImageHandle,
857	IN EFI_SYSTEM_TABLE *SystemTable
858	)
859	{
860	EFI_STATUS Status;
861	LIST_ENTRY *Package;
862	CHAR16 *ProblemParam;
863	SHELL_STATUS ShellStatus;
864	CHAR8 *Language;
865	CONST CHAR16 *Lang;
866	CONST CHAR16 *Temp2;
867	BOOLEAN SfoMode;
868	BOOLEAN FlagD;
869	BOOLEAN Verbose;
870	UINT64 Intermediate;
871
872	ShellStatus = SHELL_SUCCESS;
873	Status = EFI_SUCCESS;
874	Language = NULL;
875
876	//
877	// initialize the shell lib (we must be in non-auto-init...)
878	//
879	Status = ShellInitialize();
880	ASSERT_EFI_ERROR(Status);
881
882	Status = CommandInit();
883	ASSERT_EFI_ERROR(Status);
884
885	//
886	// parse the command line
887	//
888	Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
889	if (EFI_ERROR(Status)) {
890	if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
891	ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDriver1HiiHandle, ProblemParam);
892	FreePool(ProblemParam);
893	ShellStatus = SHELL_INVALID_PARAMETER;
894	} else {
895	ASSERT(FALSE);
896	}
897	} else {
898	if (ShellCommandLineGetCount(Package) > 2) {
899	ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);
900	ShellCommandLineFreeVarList (Package);
901	return (SHELL_INVALID_PARAMETER);
902	}
903
904	Lang = ShellCommandLineGetValue(Package, L"-l");
905	if (Lang != NULL) {
906	Language = AllocateZeroPool(StrSize(Lang));
907	AsciiSPrint(Language, StrSize(Lang), "%S", Lang);
908	} else if (!ShellCommandLineGetFlag(Package, L"-l")){
909	Language = AllocateZeroPool(10);
910	AsciiSPrint(Language, 10, "en-us");
911	} else {
912	ASSERT(Language == NULL);
913	ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");
914	ShellCommandLineFreeVarList (Package);
915	return (SHELL_INVALID_PARAMETER);
916	}
917
918	SfoMode = ShellCommandLineGetFlag(Package, L"-sfo");
919	FlagD = ShellCommandLineGetFlag(Package, L"-d");
920	Verbose = (BOOLEAN)(ShellCommandLineGetFlag(Package, L"-v") \|\| ShellCommandLineGetFlag(Package, L"-verbose"));
921
922	if (ShellCommandLineGetFlag(Package, L"-p")) {
923	if (ShellCommandLineGetCount(Package) > 1) {
924	ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellDriver1HiiHandle);
925	ShellStatus = SHELL_INVALID_PARAMETER;
926	} else if (ShellCommandLineGetValue(Package, L"-p") == NULL) {
927	ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-p");
928	ShellStatus = SHELL_INVALID_PARAMETER;
929	} else {
930	//
931	// print by protocol
932	//
933	ShellStatus = DoDhByProtocol(
934	ShellCommandLineGetValue(Package, L"-p"),
935	SfoMode,
936	Lang==NULL?NULL:Language,
937	FlagD
938	);
939	}
940	} else {
941	Temp2 = ShellCommandLineGetRawValue(Package, 1);
942	if (Temp2 == NULL) {
943	//
944	// Print everything
945	//
946	ShellStatus = DoDhForAll(
947	SfoMode,
948	Lang==NULL?NULL:Language,
949	FlagD
950	);
951	} else {
952	Status = ShellConvertStringToUint64(Temp2, &Intermediate, TRUE, FALSE);
953	if (EFI_ERROR(Status) \|\| ConvertHandleIndexToHandle((UINTN)Intermediate) == NULL) {
954	ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Temp2);
955	ShellStatus = SHELL_INVALID_PARAMETER;
956	} else {
957	//
958	// print 1 handle
959	//
960	ShellStatus = DoDhByHandle(
961	ConvertHandleIndexToHandle((UINTN)Intermediate),
962	Verbose,
963	SfoMode,
964	Lang==NULL?NULL:Language,
965	FlagD,
966	FALSE
967	);
968	}
969	}
970	}
971
972
973	ShellCommandLineFreeVarList (Package);
974	SHELL_FREE_NON_NULL(Language);
975	}
976
977	return (ShellStatus);
978	}

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

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDriver1CommandsLib/Dh.c@ 48674

Download in other formats: