Map.c

Last change on this file was 105670, checked in by vboxsync, 8 months ago
Devices/EFI/FirmwareNew: Merge edk2-stable-202405 and make it build on aarch64, bugref:4643
Property svn:eol-style set to `native`
File size: 39.7 KB

Line
1	/** @file
2	Main file for map shell level 2 command.
3
4	Copyright (c) 2009 - 2018, Intel Corporation. All rights reserved.<BR>
5	(C) Copyright 2013-2015 Hewlett-Packard Development Company, L.P.<BR>
6	(C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
7
8	SPDX-License-Identifier: BSD-2-Clause-Patent
9
10	**/
11
12	#include "UefiShellLevel2CommandsLib.h"
13	#include <Protocol/SimpleFileSystem.h>
14	#include <Protocol/BlockIo.h>
15	#include <Library/DevicePathLib.h>
16	#include <Library/HandleParsingLib.h>
17	#include <Library/SortLib.h>
18
19	/**
20	Determine if a string has only numbers and letters.
21
22	This is useful for such things as Map names which can only be letters and numbers.
23
24	@param[in] String pointer to the string to analyze,
25	@param[in] Len Number of characters to analyze.
26
27	@retval TRUE String has only numbers and letters
28	@retval FALSE String has at least one other character.
29	**/
30	BOOLEAN
31	IsNumberLetterOnly (
32	IN CONST CHAR16 *String,
33	IN CONST UINTN Len
34	)
35	{
36	UINTN Count;
37
38	for (Count = 0; Count < Len && String != NULL && *String != CHAR_NULL; String++, Count++) {
39	if (!(((String >= L'a') && (String <= L'z')) \|\|
40	((String >= L'A') && (String <= L'Z')) \|\|
41	((String >= L'0') && (String <= L'9')))
42	)
43	{
44	return (FALSE);
45	}
46	}
47
48	return (TRUE);
49	}
50
51	/**
52	Do a search in the Target delimited list.
53
54	@param[in] List The list to seatch in.
55	@param[in] MetaTarget The item to search for. MetaMatching supported.
56	@param[out] FullName Optional pointer to an allocated buffer containing
57	the match.
58	@param[in] Meta TRUE to use MetaMatching.
59	@param[in] SkipTrailingNumbers TRUE to allow for numbers after the MetaTarget.
60	@param[in] Target The single character that delimits list
61	items (";" normally).
62	**/
63	BOOLEAN
64	SearchList (
65	IN CONST CHAR16 *List,
66	IN CONST CHAR16 *MetaTarget,
67	OUT CHAR16 **FullName OPTIONAL,
68	IN CONST BOOLEAN Meta,
69	IN CONST BOOLEAN SkipTrailingNumbers,
70	IN CONST CHAR16 *Target
71
72	)
73	{
74	CHAR16 *TempList;
75	CONST CHAR16 *ListWalker;
76	BOOLEAN Result;
77	CHAR16 *TempSpot;
78
79	for (ListWalker = List, TempList = NULL
80	; ListWalker != NULL && *ListWalker != CHAR_NULL
81	;
82	)
83	{
84	TempList = StrnCatGrow (&TempList, NULL, ListWalker, 0);
85	ASSERT (TempList != NULL);
86	TempSpot = StrStr (TempList, Target);
87	if (TempSpot != NULL) {
88	*TempSpot = CHAR_NULL;
89	}
90
91	while (SkipTrailingNumbers && (ShellIsDecimalDigitCharacter (TempList[StrLen (TempList)-1]) \|\| TempList[StrLen (TempList)-1] == L':')) {
92	TempList[StrLen (TempList)-1] = CHAR_NULL;
93	}
94
95	ListWalker = StrStr (ListWalker, Target);
96	while (ListWalker != NULL && ListWalker == Target) {
97	ListWalker++;
98	}
99
100	if (Meta) {
101	Result = gUnicodeCollation->MetaiMatch (gUnicodeCollation, (CHAR16 )TempList, (CHAR16 )MetaTarget);
102	} else {
103	Result = (BOOLEAN)(StrCmp (TempList, MetaTarget) == 0);
104	}
105
106	if (Result) {
107	if (FullName != NULL) {
108	*FullName = TempList;
109	} else {
110	FreePool (TempList);
111	}
112
113	return (TRUE);
114	}
115
116	FreePool (TempList);
117	TempList = NULL;
118	}
119
120	return (FALSE);
121	}
122
123	/**
124	Determine what type of device is represented and return it's string. The
125	string is in allocated memory and must be callee freed. The HII is is listed below.
126	The actual string cannot be determined.
127
128	@param[in] DevicePath The device to analyze.
129
130	@retval STR_MAP_MEDIA_UNKNOWN The media type is unknown.
131	@retval STR_MAP_MEDIA_HARDDISK The media is a hard drive.
132	@retval STR_MAP_MEDIA_CDROM The media is a CD ROM.
133	@retval STR_MAP_MEDIA_FLOPPY The media is a floppy drive.
134	**/
135	CHAR16 *
136	GetDeviceMediaType (
137	IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
138	)
139	{
140	ACPI_HID_DEVICE_PATH *Acpi;
141
142	//
143	// Parse the device path:
144	// Devicepath sub type mediatype
145	// MEDIA_HANRDDRIVE_DP -> Hard Disk
146	// MEDIA_CDROM_DP -> CD Rom
147	// Acpi.HID = 0X0604 -> Floppy
148	//
149	if (NULL == DevicePath) {
150	return HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_MAP_MEDIA_UNKNOWN), NULL);
151	}
152
153	for ( ; !IsDevicePathEndType (DevicePath); DevicePath = NextDevicePathNode (DevicePath)) {
154	if (DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) {
155	switch (DevicePathSubType (DevicePath)) {
156	case MEDIA_HARDDRIVE_DP:
157	return HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_MAP_MEDIA_HARDDISK), NULL);
158	case MEDIA_CDROM_DP:
159	return HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_MAP_MEDIA_CDROM), NULL);
160	}
161	} else if (DevicePathType (DevicePath) == ACPI_DEVICE_PATH) {
162	Acpi = (ACPI_HID_DEVICE_PATH *)DevicePath;
163	if (EISA_ID_TO_NUM (Acpi->HID) == 0x0604) {
164	return HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_MAP_MEDIA_FLOPPY), NULL);
165	}
166	}
167	}
168
169	return HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_MAP_MEDIA_UNKNOWN), NULL);
170	}
171
172	/**
173	Function to detemine if a handle has removable storage.
174
175	@param[in] DevicePath DevicePath to test.
176
177	@retval TRUE The handle has removable storage.
178	@retval FALSE The handle does not have removable storage.
179	**/
180	BOOLEAN
181	IsRemoveableDevice (
182	IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
183	)
184	{
185	if (NULL == DevicePath) {
186	return FALSE;
187	}
188
189	while (!IsDevicePathEndType (DevicePath)) {
190	if (DevicePathType (DevicePath) == MESSAGING_DEVICE_PATH) {
191	switch (DevicePathSubType (DevicePath)) {
192	case MSG_USB_DP:
193	case MSG_SCSI_DP:
194	return TRUE;
195	default:
196	return FALSE;
197	}
198	}
199
200	DevicePath = NextDevicePathNode (DevicePath);
201	}
202
203	return FALSE;
204	}
205
206	/**
207	Function to detemine if a something on the map list matches.
208
209	@param[in] MapList The pointer to the list to test.
210	@param[in] Specific The pointer to a specific name to test for.
211	@param[in] TypeString The pointer to the list of types.
212	@param[in] Normal Always show normal mappings.
213	@param[in] Consist Always show consistent mappings.
214
215	@retval TRUE The map should be displayed.
216	@retval FALSE The map should not be displayed.
217	**/
218	BOOLEAN
219	MappingListHasType (
220	IN CONST CHAR16 *MapList,
221	IN CONST CHAR16 *Specific,
222	IN CONST CHAR16 *TypeString,
223	IN CONST BOOLEAN Normal,
224	IN CONST BOOLEAN Consist
225	)
226	{
227	CHAR16 *NewSpecific;
228	RETURN_STATUS Status;
229	UINTN Length;
230
231	//
232	// specific has priority
233	//
234	if (Specific != NULL) {
235	Length = StrLen (Specific);
236	//
237	// Allocate enough buffer for Specific and potential ":"
238	//
239	NewSpecific = AllocatePool ((Length + 2) * sizeof (CHAR16));
240	if (NewSpecific == NULL) {
241	return FALSE;
242	}
243
244	StrCpyS (NewSpecific, Length + 2, Specific);
245	if (Specific[Length - 1] != L':') {
246	Status = StrnCatS (NewSpecific, Length + 2, L":", StrLen (L":"));
247	if (EFI_ERROR (Status)) {
248	FreePool (NewSpecific);
249	return FALSE;
250	}
251	}
252
253	if (SearchList (MapList, NewSpecific, NULL, TRUE, FALSE, L";")) {
254	FreePool (NewSpecific);
255	return (TRUE);
256	}
257
258	FreePool (NewSpecific);
259	}
260
261	if ( Consist
262	&& (Specific == NULL)
263	&& ( SearchList (MapList, L"HD*", NULL, TRUE, TRUE, L";")
264	\|\| SearchList (MapList, L"CD*", NULL, TRUE, TRUE, L";")
265	\|\| SearchList (MapList, L"F*", NULL, TRUE, TRUE, L";")
266	\|\| SearchList (MapList, L"FP*", NULL, TRUE, TRUE, L";")))
267	{
268	return (TRUE);
269	}
270
271	if ( Normal
272	&& (Specific == NULL)
273	&& ( SearchList (MapList, L"FS", NULL, FALSE, TRUE, L";")
274	\|\| SearchList (MapList, L"BLK", NULL, FALSE, TRUE, L";")))
275	{
276	return (TRUE);
277	}
278
279	if ((TypeString != NULL) && SearchList (MapList, TypeString, NULL, TRUE, TRUE, L";")) {
280	return (TRUE);
281	}
282
283	return (FALSE);
284	}
285
286	/**
287	Display a single map line for device Handle if conditions are met.
288
289	@param[in] Verbose TRUE to display (extra) verbose information.
290	@param[in] Consist TRUE to display consistent mappings.
291	@param[in] Normal TRUE to display normal (not consist) mappings.
292	@param[in] TypeString pointer to string of filter types.
293	@param[in] SFO TRUE to display output in Standard Output Format.
294	@param[in] Specific pointer to string for specific map to display.
295	@param[in] Handle The handle to display from.
296
297	@retval EFI_SUCCESS The mapping was displayed.
298	**/
299	EFI_STATUS
300	PerformSingleMappingDisplay (
301	IN CONST BOOLEAN Verbose,
302	IN CONST BOOLEAN Consist,
303	IN CONST BOOLEAN Normal,
304	IN CONST CHAR16 *TypeString,
305	IN CONST BOOLEAN SFO,
306	IN CONST CHAR16 *Specific OPTIONAL,
307	IN CONST EFI_HANDLE Handle
308	)
309	{
310	EFI_DEVICE_PATH_PROTOCOL *DevPath;
311	EFI_DEVICE_PATH_PROTOCOL *DevPathCopy;
312	CONST CHAR16 *MapList;
313	CHAR16 *CurrentName;
314	CHAR16 *MediaType;
315	CHAR16 *DevPathString;
316	CHAR16 *TempSpot;
317	CHAR16 *Alias;
318	UINTN TempLen;
319	BOOLEAN Removable;
320	CONST CHAR16 *TempSpot2;
321
322	Alias = NULL;
323	TempSpot2 = NULL;
324	CurrentName = NULL;
325	DevPath = DevicePathFromHandle (Handle);
326	DevPathCopy = DevPath;
327	MapList = gEfiShellProtocol->GetMapFromDevicePath (&DevPathCopy);
328	if (MapList == NULL) {
329	return EFI_NOT_FOUND;
330	}
331
332	if (!MappingListHasType (MapList, Specific, TypeString, Normal, Consist)) {
333	return EFI_NOT_FOUND;
334	}
335
336	if (Normal \|\| !Consist) {
337	//
338	// need the Normal here since people can use both on command line. otherwise unused.
339	//
340
341	//
342	// Allocate a name
343	//
344	CurrentName = NULL;
345	CurrentName = StrnCatGrow (&CurrentName, 0, MapList, 0);
346	if (CurrentName == NULL) {
347	return (EFI_OUT_OF_RESOURCES);
348	}
349
350	//
351	// Chop off the other names that become "Alias(s)"
352	// leaving just the normal name
353	//
354	TempSpot = StrStr (CurrentName, L";");
355	if (TempSpot != NULL) {
356	*TempSpot = CHAR_NULL;
357	}
358	} else {
359	CurrentName = NULL;
360
361	//
362	// Skip the first name. This is the standard name.
363	//
364	TempSpot = StrStr (MapList, L";");
365	if (TempSpot != NULL) {
366	TempSpot++;
367	}
368
369	SearchList (TempSpot, L"HD*", &CurrentName, TRUE, FALSE, L";");
370	if (CurrentName == NULL) {
371	SearchList (TempSpot, L"CD*", &CurrentName, TRUE, FALSE, L";");
372	}
373
374	if (CurrentName == NULL) {
375	SearchList (TempSpot, L"FP*", &CurrentName, TRUE, FALSE, L";");
376	}
377
378	if (CurrentName == NULL) {
379	SearchList (TempSpot, L"F*", &CurrentName, TRUE, FALSE, L";");
380	}
381
382	if (CurrentName == NULL) {
383	//
384	// We didnt find anything, so just the first one in the list...
385	//
386	CurrentName = StrnCatGrow (&CurrentName, 0, MapList, 0);
387	if (CurrentName == NULL) {
388	return (EFI_OUT_OF_RESOURCES);
389	}
390
391	TempSpot = StrStr (CurrentName, L";");
392	if (TempSpot != NULL) {
393	*TempSpot = CHAR_NULL;
394	}
395	} else {
396	Alias = StrnCatGrow (&Alias, 0, MapList, 0);
397	if (Alias == NULL) {
398	return EFI_OUT_OF_RESOURCES;
399	}
400
401	TempSpot = StrStr (Alias, CurrentName);
402	if (TempSpot != NULL) {
403	TempSpot2 = StrStr (TempSpot, L";");
404	if (TempSpot2 != NULL) {
405	TempSpot2++; // Move past ";" from CurrentName
406	CopyMem (TempSpot, TempSpot2, StrSize (TempSpot2));
407	} else {
408	*TempSpot = CHAR_NULL;
409	}
410	}
411
412	if (Alias[StrLen (Alias)-1] == L';') {
413	Alias[StrLen (Alias)-1] = CHAR_NULL;
414	}
415	}
416	}
417
418	DevPathString = ConvertDevicePathToText (DevPath, TRUE, FALSE);
419	TempLen = StrLen (CurrentName);
420	if (!SFO) {
421	ShellPrintHiiEx (
422	-1,
423	-1,
424	NULL,
425	STRING_TOKEN (STR_MAP_ENTRY),
426	gShellLevel2HiiHandle,
427	CurrentName,
428	Alias != NULL ? Alias : (TempLen < StrLen (MapList) ? MapList + TempLen+1 : L""),
429	DevPathString
430	);
431	if (Verbose) {
432	//
433	// also print handle, media type, removable (y/n), and current directory
434	//
435	MediaType = GetDeviceMediaType (DevPath);
436	if (((TypeString != NULL) && (MediaType != NULL) && (StrStr (TypeString, MediaType) != NULL)) \|\| (TypeString == NULL)) {
437	Removable = IsRemoveableDevice (DevPath);
438	TempSpot2 = ShellGetCurrentDir (CurrentName);
439	ShellPrintHiiEx (
440	-1,
441	-1,
442	NULL,
443	STRING_TOKEN (STR_MAP_ENTRY_VERBOSE),
444	gShellLevel2HiiHandle,
445	ConvertHandleToHandleIndex (Handle),
446	MediaType,
447	Removable ? L"Yes" : L"No",
448	TempSpot2
449	);
450	}
451
452	SHELL_FREE_NON_NULL (MediaType);
453	}
454	} else {
455	ShellPrintHiiEx (
456	-1,
457	-1,
458	NULL,
459	STRING_TOKEN (STR_MAP_SFO_MAPPINGS),
460	gShellLevel2HiiHandle,
461	CurrentName,
462	DevPathString,
463	Consist ? L"" : (TempLen < StrLen (MapList) ? MapList + TempLen+1 : L"")
464	);
465	}
466
467	SHELL_FREE_NON_NULL (DevPathString);
468	SHELL_FREE_NON_NULL (CurrentName);
469	SHELL_FREE_NON_NULL (Alias);
470	return EFI_SUCCESS;
471	}
472
473	/**
474	Delete Specific from the list of maps for device Handle.
475
476	@param[in] Specific The name to delete.
477	@param[in] Handle The device to look on.
478
479	@retval EFI_SUCCESS The delete was successful.
480	@retval EFI_NOT_FOUND Name was not a map on Handle.
481	**/
482	EFI_STATUS
483	PerformSingleMappingDelete (
484	IN CONST CHAR16 *Specific,
485	IN CONST EFI_HANDLE Handle
486	)
487	{
488	EFI_DEVICE_PATH_PROTOCOL *DevPath;
489	EFI_DEVICE_PATH_PROTOCOL *DevPathCopy;
490	CONST CHAR16 *MapList;
491	CHAR16 *CurrentName;
492
493	DevPath = DevicePathFromHandle (Handle);
494	DevPathCopy = DevPath;
495	MapList = gEfiShellProtocol->GetMapFromDevicePath (&DevPathCopy);
496	CurrentName = NULL;
497
498	if (MapList == NULL) {
499	return (EFI_NOT_FOUND);
500	}
501
502	//
503	// if there is a specific and its not on the list...
504	//
505	if (!SearchList (MapList, Specific, &CurrentName, TRUE, FALSE, L";")) {
506	return (EFI_NOT_FOUND);
507	}
508
509	return (gEfiShellProtocol->SetMap (NULL, CurrentName));
510	}
511
512	CONST CHAR16 Cd[] = L"cd*";
513	CONST CHAR16 Hd[] = L"hd*";
514	CONST CHAR16 Fp[] = L"fp*";
515	CONST CHAR16 AnyF[] = L"F*";
516
517	/**
518	Function to display mapping information to the user.
519
520	If Specific is specified then Consist and Normal will be ignored since information will
521	be printed for the specific item only.
522
523	@param[in] Verbose TRUE to display (extra) verbose information.
524	@param[in] Consist TRUE to display consistent mappings.
525	@param[in] Normal TRUE to display normal (not consist) mappings.
526	@param[in] TypeString Pointer to string of filter types.
527	@param[in] SFO TRUE to display output in Standard Output Format.
528	@param[in] Specific Pointer to string for specific map to display.
529	@param[in] Header TRUE to print the header block.
530
531	@retval SHELL_SUCCESS The display was printed.
532	@retval SHELL_INVALID_PARAMETER One of Consist or Normal must be TRUE if no Specific.
533
534	**/
535	SHELL_STATUS
536	PerformMappingDisplay (
537	IN CONST BOOLEAN Verbose,
538	IN CONST BOOLEAN Consist,
539	IN CONST BOOLEAN Normal,
540	IN CONST CHAR16 *TypeString,
541	IN CONST BOOLEAN SFO,
542	IN CONST CHAR16 *Specific OPTIONAL,
543	IN CONST BOOLEAN Header
544	)
545	{
546	EFI_STATUS Status;
547	EFI_HANDLE *HandleBuffer;
548	UINTN BufferSize;
549	UINTN LoopVar;
550	CHAR16 *Test;
551	BOOLEAN Found;
552
553	if (!Consist && !Normal && (Specific == NULL) && (TypeString == NULL)) {
554	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellLevel2HiiHandle, L"map");
555	return (SHELL_INVALID_PARAMETER);
556	}
557
558	if (TypeString != NULL) {
559	Test = (CHAR16 *)Cd;
560	if (StrnCmp (TypeString, Test, StrLen (Test)-1) != 0) {
561	Test = (CHAR16 *)Hd;
562	if (StrnCmp (TypeString, Test, StrLen (Test)-1) != 0) {
563	Test = (CHAR16 *)Fp;
564	if (StrnCmp (TypeString, Test, StrLen (Test)-1) != 0) {
565	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"map", TypeString);
566	return (SHELL_INVALID_PARAMETER);
567	}
568	} else if (Test == NULL) {
569	Test = (CHAR16 *)AnyF;
570	}
571	}
572	} else {
573	Test = NULL;
574	}
575
576	if (Header) {
577	//
578	// Print the header
579	//
580	if (!SFO) {
581	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_MAP_HEADER), gShellLevel2HiiHandle);
582	} else {
583	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_SFO_HEADER), gShellLevel2HiiHandle, L"map");
584	}
585	}
586
587	BufferSize = 0;
588	HandleBuffer = NULL;
589
590	//
591	// Look up all SimpleFileSystems in the platform
592	//
593	Status = gBS->LocateHandle (
594	ByProtocol,
595	&gEfiSimpleFileSystemProtocolGuid,
596	NULL,
597	&BufferSize,
598	HandleBuffer
599	);
600	if (Status == EFI_BUFFER_TOO_SMALL) {
601	HandleBuffer = AllocateZeroPool (BufferSize);
602	if (HandleBuffer == NULL) {
603	return (SHELL_OUT_OF_RESOURCES);
604	}
605
606	Status = gBS->LocateHandle (
607	ByProtocol,
608	&gEfiSimpleFileSystemProtocolGuid,
609	NULL,
610	&BufferSize,
611	HandleBuffer
612	);
613	}
614
615	//
616	// Get the map name(s) for each one.
617	//
618	for ( LoopVar = 0, Found = FALSE
619	; LoopVar < (BufferSize / sizeof (EFI_HANDLE)) && HandleBuffer != NULL
620	; LoopVar++
621	)
622	{
623	Status = PerformSingleMappingDisplay (
624	Verbose,
625	Consist,
626	Normal,
627	Test,
628	SFO,
629	Specific,
630	HandleBuffer[LoopVar]
631	);
632	if (!EFI_ERROR (Status)) {
633	Found = TRUE;
634	}
635	}
636
637	//
638	// Look up all BlockIo in the platform
639	//
640	Status = gBS->LocateHandle (
641	ByProtocol,
642	&gEfiBlockIoProtocolGuid,
643	NULL,
644	&BufferSize,
645	HandleBuffer
646	);
647	if (Status == EFI_BUFFER_TOO_SMALL) {
648	SHELL_FREE_NON_NULL (HandleBuffer);
649	HandleBuffer = AllocateZeroPool (BufferSize);
650	if (HandleBuffer == NULL) {
651	return (SHELL_OUT_OF_RESOURCES);
652	}
653
654	Status = gBS->LocateHandle (
655	ByProtocol,
656	&gEfiBlockIoProtocolGuid,
657	NULL,
658	&BufferSize,
659	HandleBuffer
660	);
661	}
662
663	if (!EFI_ERROR (Status) && (HandleBuffer != NULL)) {
664	//
665	// Get the map name(s) for each one.
666	//
667	for ( LoopVar = 0
668	; LoopVar < BufferSize / sizeof (EFI_HANDLE)
669	; LoopVar++
670	)
671	{
672	//
673	// Skip any that were already done...
674	//
675	if (gBS->OpenProtocol (
676	HandleBuffer[LoopVar],
677	&gEfiSimpleFileSystemProtocolGuid,
678	NULL,
679	gImageHandle,
680	NULL,
681	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
682	) == EFI_SUCCESS)
683	{
684	continue;
685	}
686
687	Status = PerformSingleMappingDisplay (
688	Verbose,
689	Consist,
690	Normal,
691	Test,
692	SFO,
693	Specific,
694	HandleBuffer[LoopVar]
695	);
696	if (!EFI_ERROR (Status)) {
697	Found = TRUE;
698	}
699	}
700
701	FreePool (HandleBuffer);
702	}
703
704	if (!Found) {
705	if (Specific != NULL) {
706	ShellPrintHiiEx (gST->ConOut->Mode->CursorColumn, gST->ConOut->Mode->CursorRow-1, NULL, STRING_TOKEN (STR_MAP_NF), gShellLevel2HiiHandle, L"map", Specific);
707	} else {
708	ShellPrintHiiEx (gST->ConOut->Mode->CursorColumn, gST->ConOut->Mode->CursorRow-1, NULL, STRING_TOKEN (STR_CD_NF), gShellLevel2HiiHandle, L"map");
709	}
710	}
711
712	return (SHELL_SUCCESS);
713	}
714
715	/**
716	Perform a mapping display and parse for multiple types in the TypeString.
717
718	@param[in] Verbose TRUE to use verbose output.
719	@param[in] Consist TRUE to display consistent names.
720	@param[in] Normal TRUE to display normal names.
721	@param[in] TypeString An optional comma-delimited list of types.
722	@param[in] SFO TRUE to display in SFO format. See Spec.
723	@param[in] Specific An optional specific map name to display alone.
724
725	@retval SHELL_INVALID_PARAMETER A parameter was invalid.
726	@retval SHELL_SUCCESS The display was successful.
727	@sa PerformMappingDisplay
728	**/
729	SHELL_STATUS
730	PerformMappingDisplay2 (
731	IN CONST BOOLEAN Verbose,
732	IN CONST BOOLEAN Consist,
733	IN CONST BOOLEAN Normal,
734	IN CONST CHAR16 *TypeString,
735	IN CONST BOOLEAN SFO,
736	IN CONST CHAR16 *Specific OPTIONAL
737	)
738	{
739	CONST CHAR16 *TypeWalker;
740	SHELL_STATUS ShellStatus;
741	CHAR16 *Comma;
742
743	if (TypeString == NULL) {
744	return (PerformMappingDisplay (Verbose, Consist, Normal, NULL, SFO, Specific, TRUE));
745	}
746
747	ShellStatus = SHELL_SUCCESS;
748	for (TypeWalker = TypeString; TypeWalker != NULL && *TypeWalker != CHAR_NULL;) {
749	Comma = StrStr (TypeWalker, L",");
750	if (Comma == NULL) {
751	if (ShellStatus == SHELL_SUCCESS) {
752	ShellStatus = PerformMappingDisplay (Verbose, Consist, Normal, TypeWalker, SFO, Specific, (BOOLEAN)(TypeWalker == TypeString));
753	} else {
754	PerformMappingDisplay (Verbose, Consist, Normal, TypeWalker, SFO, Specific, (BOOLEAN)(TypeWalker == TypeString));
755	}
756
757	break;
758	} else {
759	*Comma = CHAR_NULL;
760	if (ShellStatus == SHELL_SUCCESS) {
761	ShellStatus = PerformMappingDisplay (Verbose, Consist, Normal, TypeWalker, SFO, Specific, (BOOLEAN)(TypeWalker == TypeString));
762	} else {
763	PerformMappingDisplay (Verbose, Consist, Normal, TypeWalker, SFO, Specific, (BOOLEAN)(TypeWalker == TypeString));
764	}
765
766	*Comma = L',';
767	TypeWalker = Comma + 1;
768	}
769	}
770
771	return (ShellStatus);
772	}
773
774	/**
775	Delete a specific map.
776
777	@param[in] Specific The pointer to the name of the map to delete.
778
779	@retval EFI_INVALID_PARAMETER Specific was NULL.
780	@retval EFI_SUCCESS The operation was successful.
781	@retval EFI_NOT_FOUND Specific could not be found.
782	**/
783	EFI_STATUS
784	PerformMappingDelete (
785	IN CONST CHAR16 *Specific
786	)
787	{
788	EFI_STATUS Status;
789	EFI_HANDLE *HandleBuffer;
790	UINTN BufferSize;
791	UINTN LoopVar;
792	BOOLEAN Deleted;
793
794	if (Specific == NULL) {
795	return (EFI_INVALID_PARAMETER);
796	}
797
798	BufferSize = 0;
799	HandleBuffer = NULL;
800	Deleted = FALSE;
801
802	//
803	// Look up all SimpleFileSystems in the platform
804	//
805	Status = gBS->LocateHandle (
806	ByProtocol,
807	&gEfiDevicePathProtocolGuid,
808	NULL,
809	&BufferSize,
810	HandleBuffer
811	);
812	if (Status == EFI_BUFFER_TOO_SMALL) {
813	HandleBuffer = AllocateZeroPool (BufferSize);
814	if (HandleBuffer == NULL) {
815	return (EFI_OUT_OF_RESOURCES);
816	}
817
818	Status = gBS->LocateHandle (
819	ByProtocol,
820	&gEfiDevicePathProtocolGuid,
821	NULL,
822	&BufferSize,
823	HandleBuffer
824	);
825	}
826
827	if (EFI_ERROR (Status)) {
828	SHELL_FREE_NON_NULL (HandleBuffer);
829	return (Status);
830	}
831
832	if (HandleBuffer != NULL) {
833	//
834	// Get the map name(s) for each one.
835	//
836	for ( LoopVar = 0
837	; LoopVar < BufferSize / sizeof (EFI_HANDLE)
838	; LoopVar++
839	)
840	{
841	if (PerformSingleMappingDelete (Specific, HandleBuffer[LoopVar]) == SHELL_SUCCESS) {
842	Deleted = TRUE;
843	}
844	}
845	}
846
847	//
848	// Look up all BlockIo in the platform
849	//
850	Status = gBS->LocateHandle (
851	ByProtocol,
852	&gEfiBlockIoProtocolGuid,
853	NULL,
854	&BufferSize,
855	HandleBuffer
856	);
857	if (Status == EFI_BUFFER_TOO_SMALL) {
858	FreePool (HandleBuffer);
859	HandleBuffer = AllocateZeroPool (BufferSize);
860	if (HandleBuffer == NULL) {
861	return (EFI_OUT_OF_RESOURCES);
862	}
863
864	Status = gBS->LocateHandle (
865	ByProtocol,
866	&gEfiBlockIoProtocolGuid,
867	NULL,
868	&BufferSize,
869	HandleBuffer
870	);
871	}
872
873	if (EFI_ERROR (Status)) {
874	SHELL_FREE_NON_NULL (HandleBuffer);
875	return (Status);
876	}
877
878	if (HandleBuffer != NULL) {
879	//
880	// Get the map name(s) for each one.
881	//
882	for ( LoopVar = 0
883	; LoopVar < BufferSize / sizeof (EFI_HANDLE)
884	; LoopVar++
885	)
886	{
887	//
888	// Skip any that were already done...
889	//
890	if (gBS->OpenProtocol (
891	HandleBuffer[LoopVar],
892	&gEfiDevicePathProtocolGuid,
893	NULL,
894	gImageHandle,
895	NULL,
896	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
897	) == EFI_SUCCESS)
898	{
899	continue;
900	}
901
902	if (PerformSingleMappingDelete (Specific, HandleBuffer[LoopVar]) == SHELL_SUCCESS) {
903	Deleted = TRUE;
904	}
905	}
906	}
907
908	SHELL_FREE_NON_NULL (HandleBuffer);
909	if (!Deleted) {
910	return (EFI_NOT_FOUND);
911	}
912
913	return (EFI_SUCCESS);
914	}
915
916	/**
917	function to add a mapping from mapping.
918
919	This function will get the device path associated with the mapping and call SetMap.
920
921	@param[in] Map The Map to add a mapping for
922	@param[in] SName The name of the new mapping
923
924	@retval SHELL_SUCCESS the mapping was added
925	@retval SHELL_INVALID_PARAMETER the device path for Map could not be retrieved.
926	@return Shell version of a return value from EfiShellProtocol->SetMap
927
928	**/
929	SHELL_STATUS
930	AddMappingFromMapping (
931	IN CONST CHAR16 *Map,
932	IN CONST CHAR16 *SName
933	)
934	{
935	CONST EFI_DEVICE_PATH_PROTOCOL *DevPath;
936	EFI_STATUS Status;
937	CHAR16 *NewSName;
938	RETURN_STATUS StrRetStatus;
939
940	NewSName = AllocateCopyPool (StrSize (SName) + sizeof (CHAR16), SName);
941	if (NewSName == NULL) {
942	return (SHELL_OUT_OF_RESOURCES);
943	}
944
945	if (NewSName[StrLen (NewSName)-1] != L':') {
946	StrRetStatus = StrnCatS (NewSName, (StrSize (SName) + sizeof (CHAR16))/sizeof (CHAR16), L":", StrLen (L":"));
947	if (EFI_ERROR (StrRetStatus)) {
948	FreePool (NewSName);
949	return ((SHELL_STATUS)(StrRetStatus & (~MAX_BIT)));
950	}
951	}
952
953	if (!IsNumberLetterOnly (NewSName, StrLen (NewSName)-1)) {
954	FreePool (NewSName);
955	return (SHELL_INVALID_PARAMETER);
956	}
957
958	DevPath = gEfiShellProtocol->GetDevicePathFromMap (Map);
959	if (DevPath == NULL) {
960	FreePool (NewSName);
961	return (SHELL_INVALID_PARAMETER);
962	}
963
964	Status = gEfiShellProtocol->SetMap (DevPath, NewSName);
965	FreePool (NewSName);
966	if (EFI_ERROR (Status)) {
967	return (SHELL_DEVICE_ERROR);
968	}
969
970	return (SHELL_SUCCESS);
971	}
972
973	/**
974	function to add a mapping from an EFI_HANDLE.
975
976	This function will get the device path associated with the Handle and call SetMap.
977
978	@param[in] Handle The handle to add a mapping for
979	@param[in] SName The name of the new mapping
980
981	@retval SHELL_SUCCESS the mapping was added
982	@retval SHELL_INVALID_PARAMETER SName was not valid for a map name.
983	@return Shell version of a return value from either
984	gBS->OpenProtocol or EfiShellProtocol->SetMap
985
986	**/
987	SHELL_STATUS
988	AddMappingFromHandle (
989	IN CONST EFI_HANDLE Handle,
990	IN CONST CHAR16 *SName
991	)
992	{
993	EFI_DEVICE_PATH_PROTOCOL *DevPath;
994	EFI_STATUS Status;
995	CHAR16 *NewSName;
996	RETURN_STATUS StrRetStatus;
997
998	NewSName = AllocateCopyPool (StrSize (SName) + sizeof (CHAR16), SName);
999	if (NewSName == NULL) {
1000	return (SHELL_OUT_OF_RESOURCES);
1001	}
1002
1003	if (NewSName[StrLen (NewSName)-1] != L':') {
1004	StrRetStatus = StrnCatS (NewSName, (StrSize (SName) + sizeof (CHAR16))/sizeof (CHAR16), L":", StrLen (L":"));
1005	if (EFI_ERROR (StrRetStatus)) {
1006	FreePool (NewSName);
1007	return ((SHELL_STATUS)(StrRetStatus & (~MAX_BIT)));
1008	}
1009	}
1010
1011	if (!IsNumberLetterOnly (NewSName, StrLen (NewSName)-1)) {
1012	FreePool (NewSName);
1013	return (SHELL_INVALID_PARAMETER);
1014	}
1015
1016	Status = gBS->OpenProtocol (
1017	Handle,
1018	&gEfiDevicePathProtocolGuid,
1019	(VOID **)&DevPath,
1020	gImageHandle,
1021	NULL,
1022	EFI_OPEN_PROTOCOL_GET_PROTOCOL
1023	);
1024	if (EFI_ERROR (Status)) {
1025	FreePool (NewSName);
1026	return (SHELL_DEVICE_ERROR);
1027	}
1028
1029	Status = gEfiShellProtocol->SetMap (DevPath, NewSName);
1030	FreePool (NewSName);
1031	if (EFI_ERROR (Status)) {
1032	return (SHELL_DEVICE_ERROR);
1033	}
1034
1035	return (SHELL_SUCCESS);
1036	}
1037
1038	STATIC CONST SHELL_PARAM_ITEM MapParamList[] = {
1039	{ L"-d", TypeValue },
1040	{ L"-r", TypeFlag },
1041	{ L"-v", TypeFlag },
1042	{ L"-c", TypeFlag },
1043	{ L"-f", TypeFlag },
1044	{ L"-u", TypeFlag },
1045	{ L"-t", TypeValue },
1046	{ L"-sfo", TypeValue },
1047	{ NULL, TypeMax }
1048	};
1049
1050	/**
1051	The routine issues dummy read for every physical block device to cause
1052	the BlockIo re-installed if media change happened.
1053	**/
1054	VOID
1055	ProbeForMediaChange (
1056	VOID
1057	)
1058	{
1059	EFI_STATUS Status;
1060	UINTN HandleCount;
1061	EFI_HANDLE *Handles;
1062	EFI_BLOCK_IO_PROTOCOL *BlockIo;
1063	UINTN Index;
1064
1065	gBS->LocateHandleBuffer (
1066	ByProtocol,
1067	&gEfiBlockIoProtocolGuid,
1068	NULL,
1069	&HandleCount,
1070	&Handles
1071	);
1072	//
1073	// Probe for media change for every physical block io
1074	//
1075	for (Index = 0; Index < HandleCount; Index++) {
1076	Status = gBS->HandleProtocol (
1077	Handles[Index],
1078	&gEfiBlockIoProtocolGuid,
1079	(VOID **)&BlockIo
1080	);
1081	if (!EFI_ERROR (Status)) {
1082	if (!BlockIo->Media->LogicalPartition) {
1083	//
1084	// Per spec:
1085	// The function (ReadBlocks) must return EFI_NO_MEDIA or
1086	// EFI_MEDIA_CHANGED even if LBA, BufferSize, or Buffer are invalid so the caller can probe
1087	// for changes in media state.
1088	//
1089	BlockIo->ReadBlocks (
1090	BlockIo,
1091	BlockIo->Media->MediaId,
1092	0,
1093	0,
1094	NULL
1095	);
1096	}
1097	}
1098	}
1099	}
1100
1101	/**
1102	Function for 'map' command.
1103
1104	@param[in] ImageHandle Handle to the Image (NULL if Internal).
1105	@param[in] SystemTable Pointer to the System Table (NULL if Internal).
1106	**/
1107	SHELL_STATUS
1108	EFIAPI
1109	ShellCommandRunMap (
1110	IN EFI_HANDLE ImageHandle,
1111	IN EFI_SYSTEM_TABLE *SystemTable
1112	)
1113	{
1114	EFI_STATUS Status;
1115	LIST_ENTRY *Package;
1116	CHAR16 *ProblemParam;
1117	CONST CHAR16 *SName;
1118	CONST CHAR16 *Mapping;
1119	EFI_HANDLE MapAsHandle;
1120	SHELL_STATUS ShellStatus;
1121	BOOLEAN SfoMode;
1122	BOOLEAN ConstMode;
1123	BOOLEAN NormlMode;
1124	CONST CHAR16 *Param1;
1125	CONST CHAR16 *TypeString;
1126	UINTN TempStringLength;
1127
1128	ProblemParam = NULL;
1129	Mapping = NULL;
1130	SName = NULL;
1131	ShellStatus = SHELL_SUCCESS;
1132	MapAsHandle = NULL;
1133
1134	//
1135	// initialize the shell lib (we must be in non-auto-init...)
1136	//
1137	Status = ShellInitialize ();
1138	ASSERT_EFI_ERROR (Status);
1139
1140	Status = CommandInit ();
1141	ASSERT_EFI_ERROR (Status);
1142
1143	//
1144	// parse the command line
1145	//
1146	Status = ShellCommandLineParse (MapParamList, &Package, &ProblemParam, TRUE);
1147	if (EFI_ERROR (Status)) {
1148	if ((Status == EFI_VOLUME_CORRUPTED) && (ProblemParam != NULL)) {
1149	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel2HiiHandle, L"map", ProblemParam);
1150	FreePool (ProblemParam);
1151	ShellStatus = SHELL_INVALID_PARAMETER;
1152	} else {
1153	ASSERT (FALSE);
1154	}
1155	} else {
1156	//
1157	// check for "-?"
1158	//
1159	SfoMode = ShellCommandLineGetFlag (Package, L"-sfo");
1160	ConstMode = ShellCommandLineGetFlag (Package, L"-c");
1161	NormlMode = ShellCommandLineGetFlag (Package, L"-f");
1162	if (ShellCommandLineGetFlag (Package, L"-?")) {
1163	ASSERT (FALSE);
1164	} else if (ShellCommandLineGetRawValue (Package, 3) != NULL) {
1165	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel2HiiHandle, L"map");
1166	ShellStatus = SHELL_INVALID_PARAMETER;
1167	} else {
1168	//
1169	// Deleting a map name...
1170	//
1171	if (ShellCommandLineGetFlag (Package, L"-d")) {
1172	if ( ShellCommandLineGetFlag (Package, L"-r")
1173	\|\| ShellCommandLineGetFlag (Package, L"-v")
1174	\|\| ConstMode
1175	\|\| NormlMode
1176	\|\| ShellCommandLineGetFlag (Package, L"-u")
1177	\|\| ShellCommandLineGetFlag (Package, L"-t")
1178	)
1179	{
1180	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CON), gShellLevel2HiiHandle, L"map");
1181	ShellStatus = SHELL_INVALID_PARAMETER;
1182	} else {
1183	SName = ShellCommandLineGetValue (Package, L"-d");
1184	if (SName != NULL) {
1185	Status = PerformMappingDelete (SName);
1186	if (EFI_ERROR (Status)) {
1187	if (Status == EFI_ACCESS_DENIED) {
1188	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_AD), gShellLevel2HiiHandle, L"map");
1189	ShellStatus = SHELL_ACCESS_DENIED;
1190	} else if (Status == EFI_NOT_FOUND) {
1191	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_MAP_NF), gShellLevel2HiiHandle, L"map", SName);
1192	ShellStatus = SHELL_INVALID_PARAMETER;
1193	} else {
1194	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"map", Status);
1195	ShellStatus = SHELL_UNSUPPORTED;
1196	}
1197	}
1198	} else {
1199	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellLevel2HiiHandle, L"map");
1200	ShellStatus = SHELL_INVALID_PARAMETER;
1201	}
1202	}
1203	} else if ( ShellCommandLineGetFlag (Package, L"-r")
1204	// \|\| ShellCommandLineGetFlag(Package, L"-v")
1205	\|\| ConstMode
1206	\|\| NormlMode
1207	\|\| ShellCommandLineGetFlag (Package, L"-u")
1208	\|\| ShellCommandLineGetFlag (Package, L"-t")
1209	)
1210	{
1211	ProbeForMediaChange ();
1212	if ( ShellCommandLineGetFlag (Package, L"-r")) {
1213	//
1214	// Do the reset
1215	//
1216	Status = ShellCommandCreateInitialMappingsAndPaths ();
1217	if (EFI_ERROR (Status)) {
1218	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"map", Status);
1219	ShellStatus = SHELL_UNSUPPORTED;
1220	}
1221	}
1222
1223	if ((ShellStatus == SHELL_SUCCESS) && ShellCommandLineGetFlag (Package, L"-u")) {
1224	//
1225	// Do the Update
1226	//
1227	Status = ShellCommandUpdateMapping ();
1228	if (EFI_ERROR (Status)) {
1229	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"map", Status);
1230	ShellStatus = SHELL_UNSUPPORTED;
1231	}
1232	}
1233
1234	if (ShellStatus == SHELL_SUCCESS) {
1235	Param1 = ShellCommandLineGetRawValue (Package, 1);
1236	TypeString = ShellCommandLineGetValue (Package, L"-t");
1237	if ( !ConstMode
1238	&& !NormlMode
1239	&& (TypeString == NULL)
1240	)
1241	{
1242	//
1243	// now do the display...
1244	//
1245	ShellStatus = PerformMappingDisplay (
1246	ShellCommandLineGetFlag (Package, L"-v"),
1247	TRUE,
1248	TRUE,
1249	NULL,
1250	SfoMode,
1251	Param1,
1252	TRUE
1253	);
1254	} else {
1255	//
1256	// now do the display...
1257	//
1258	ShellStatus = PerformMappingDisplay2 (
1259	ShellCommandLineGetFlag (Package, L"-v"),
1260	ConstMode,
1261	NormlMode,
1262	TypeString,
1263	SfoMode,
1264	Param1
1265	);
1266	}
1267	}
1268	} else {
1269	//
1270	// adding or displaying (there were no flags)
1271	//
1272	SName = ShellCommandLineGetRawValue (Package, 1);
1273	Mapping = ShellCommandLineGetRawValue (Package, 2);
1274	if ( (SName == NULL)
1275	&& (Mapping == NULL)
1276	)
1277	{
1278	//
1279	// display only since no flags
1280	//
1281	ShellStatus = PerformMappingDisplay (
1282	ShellCommandLineGetFlag (Package, L"-v"),
1283	TRUE,
1284	TRUE,
1285	NULL,
1286	SfoMode,
1287	NULL,
1288	TRUE
1289	);
1290	} else if ( (SName == NULL)
1291	\|\| (Mapping == NULL)
1292	)
1293	{
1294	//
1295	// Display only the one specified
1296	//
1297	ShellStatus = PerformMappingDisplay (
1298	FALSE,
1299	FALSE,
1300	FALSE,
1301	NULL,
1302	SfoMode,
1303	SName, // note the variable here...
1304	TRUE
1305	);
1306	} else {
1307	if (ShellIsHexOrDecimalNumber (Mapping, TRUE, FALSE)) {
1308	MapAsHandle = ConvertHandleIndexToHandle (ShellStrToUintn (Mapping));
1309	} else {
1310	MapAsHandle = NULL;
1311	}
1312
1313	if ((MapAsHandle == NULL) && (Mapping[StrLen (Mapping)-1] != L':')) {
1314	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"map", Mapping);
1315	ShellStatus = SHELL_INVALID_PARAMETER;
1316	} else {
1317	TempStringLength = StrLen (SName);
1318	if (!IsNumberLetterOnly (SName, TempStringLength-((SName[TempStringLength-1] == L':') ? 1 : 0))) {
1319	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"map", SName);
1320	ShellStatus = SHELL_INVALID_PARAMETER;
1321	}
1322
1323	if (ShellStatus == SHELL_SUCCESS) {
1324	if (MapAsHandle != NULL) {
1325	ShellStatus = AddMappingFromHandle (MapAsHandle, SName);
1326	} else {
1327	ShellStatus = AddMappingFromMapping (Mapping, SName);
1328	}
1329
1330	if (ShellStatus != SHELL_SUCCESS) {
1331	switch (ShellStatus) {
1332	case SHELL_ACCESS_DENIED:
1333	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_AD), gShellLevel2HiiHandle, L"map");
1334	break;
1335	case SHELL_INVALID_PARAMETER:
1336	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle, L"map", Mapping);
1337	break;
1338	case SHELL_DEVICE_ERROR:
1339	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_MAP_NOF), gShellLevel2HiiHandle, L"map", Mapping);
1340	break;
1341	default:
1342	ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, L"map", ShellStatus\|MAX_BIT);
1343	}
1344	} else {
1345	//
1346	// now do the display...
1347	//
1348	ShellStatus = PerformMappingDisplay (
1349	FALSE,
1350	FALSE,
1351	FALSE,
1352	NULL,
1353	SfoMode,
1354	SName,
1355	TRUE
1356	);
1357	} // we were successful so do an output
1358	}
1359	} // got a valid map target
1360	} // got 2 variables
1361	} // we are adding a mapping
1362	} // got valid parameters
1363	}
1364
1365	//
1366	// free the command line package
1367	//
1368	ShellCommandLineFreeVarList (Package);
1369
1370	return (ShellStatus);
1371	}

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

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/Map.c

Download in other formats: