2 Main file for map shell level 2 command.
4 Copyright (c) 2009 - 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
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.
15 #include "UefiShellLevel2CommandsLib.h"
16 #include <Protocol/SimpleFileSystem.h>
17 #include <Protocol/BlockIo.h>
18 #include <Library/DevicePathLib.h>
19 #include <Library/HandleParsingLib.h>
20 #include <Library/SortLib.h>
23 Determine if a string has only numbers and letters.
25 This is useful for such things as Map names which can only be letters and numbers.
27 @param[in] String pointer to the string to analyze,
28 @param[in] Len Number of characters to analyze.
30 @retval TRUE String has only numbers and letters
31 @retval FALSE String has at least one other character.
36 IN CONST CHAR16
*String
,
41 for (Count
= 0 ; Count
< Len
&& String
!= NULL
&& *String
!= CHAR_NULL
; String
++,Count
++) {
42 if (! ((*String
>= L
'a' && *String
<= L
'z') ||
43 (*String
>= L
'A' && *String
<= L
'Z') ||
44 (*String
>= L
'0' && *String
<= L
'9'))
53 Do a search in the Target delimited list.
55 @param[in] List The list to seatch in.
56 @param[in] MetaTarget The item to search for. MetaMatching supported.
57 @param[out] FullName Optional pointer to an allocated buffer containing
59 @param[in] Meta TRUE to use MetaMatching.
60 @param[in] SkipTrailingNumbers TRUE to allow for numbers after the MetaTarget.
61 @param[in] Target The single character that delimits list
67 IN CONST CHAR16
*List
,
68 IN CONST CHAR16
*MetaTarget
,
69 OUT CHAR16
**FullName OPTIONAL
,
70 IN CONST BOOLEAN Meta
,
71 IN CONST BOOLEAN SkipTrailingNumbers
,
72 IN CONST CHAR16
*Target
77 CONST CHAR16
*ListWalker
;
81 for (ListWalker
= List
, TempList
= NULL
82 ; ListWalker
!= NULL
&& *ListWalker
!= CHAR_NULL
85 TempList
= StrnCatGrow(&TempList
, NULL
, ListWalker
, 0);
86 ASSERT(TempList
!= NULL
);
87 TempSpot
= StrStr(TempList
, Target
);
88 if (TempSpot
!= NULL
) {
89 *TempSpot
= CHAR_NULL
;
92 while (SkipTrailingNumbers
&& (ShellIsDecimalDigitCharacter(TempList
[StrLen(TempList
)-1]) || TempList
[StrLen(TempList
)-1] == L
':')) {
93 TempList
[StrLen(TempList
)-1] = CHAR_NULL
;
96 ListWalker
= StrStr(ListWalker
, Target
);
97 while(ListWalker
!= NULL
&& *ListWalker
== *Target
) {
101 Result
= gUnicodeCollation
->MetaiMatch(gUnicodeCollation
, (CHAR16
*)TempList
, (CHAR16
*)MetaTarget
);
103 Result
= (BOOLEAN
)(StrCmp(TempList
, MetaTarget
)==0);
106 if (FullName
!= NULL
) {
107 *FullName
= TempList
;
121 Add mappings for any devices without one. Do not change any existing maps.
123 @retval EFI_SUCCESS The operation was successful.
132 EFI_HANDLE
*HandleList
;
134 EFI_DEVICE_PATH_PROTOCOL
**DevicePathList
;
135 CHAR16
*NewDefaultName
;
136 CHAR16
*NewConsistName
;
137 EFI_DEVICE_PATH_PROTOCOL
**ConsistMappingTable
;
140 Status
= EFI_SUCCESS
;
143 // remove mappings that represent removed devices.
147 // Find each handle with Simple File System
149 HandleList
= GetHandleListByProtocol(&gEfiSimpleFileSystemProtocolGuid
);
150 if (HandleList
!= NULL
) {
152 // Do a count of the handles
154 for (Count
= 0 ; HandleList
[Count
] != NULL
; Count
++);
157 // Get all Device Paths
159 DevicePathList
= AllocateZeroPool(sizeof(EFI_DEVICE_PATH_PROTOCOL
*) * Count
);
160 ASSERT(DevicePathList
!= NULL
);
162 for (Count
= 0 ; HandleList
[Count
] != NULL
; Count
++) {
163 DevicePathList
[Count
] = DevicePathFromHandle(HandleList
[Count
]);
167 // Sort all DevicePaths
169 PerformQuickSort(DevicePathList
, Count
, sizeof(EFI_DEVICE_PATH_PROTOCOL
*), DevicePathCompare
);
171 ShellCommandConsistMappingInitialize(&ConsistMappingTable
);
174 // Assign new Mappings to remainders
176 for (Count
= 0 ; HandleList
[Count
] != NULL
&& !EFI_ERROR(Status
); Count
++) {
178 // Skip ones that already have
180 if (gEfiShellProtocol
->GetMapFromDevicePath(&DevicePathList
[Count
]) != NULL
) {
186 NewDefaultName
= ShellCommandCreateNewMappingName(MappingTypeFileSystem
);
187 ASSERT(NewDefaultName
!= NULL
);
190 // Call shell protocol SetMap function now...
192 Status
= gEfiShellProtocol
->SetMap(DevicePathList
[Count
], NewDefaultName
);
194 if (!EFI_ERROR(Status
)) {
196 // Now do consistent name
198 NewConsistName
= ShellCommandConsistMappingGenMappingName(DevicePathList
[Count
], ConsistMappingTable
);
199 if (NewConsistName
!= NULL
) {
200 Status
= gEfiShellProtocol
->SetMap(DevicePathList
[Count
], NewConsistName
);
201 FreePool(NewConsistName
);
205 FreePool(NewDefaultName
);
207 ShellCommandConsistMappingUnInitialize(ConsistMappingTable
);
208 SHELL_FREE_NON_NULL(HandleList
);
209 SHELL_FREE_NON_NULL(DevicePathList
);
216 // Do it all over again for gEfiBlockIoProtocolGuid
223 Determine what type of device is represented and return it's string. The
224 string is in allocated memory and must be callee freed. The HII is is listed below.
225 The actual string cannot be determined.
227 @param[in] DevicePath The device to analyze.
229 @retval STR_MAP_MEDIA_UNKNOWN The media type is unknown.
230 @retval STR_MAP_MEDIA_HARDDISK The media is a hard drive.
231 @retval STR_MAP_MEDIA_CDROM The media is a CD ROM.
232 @retval STR_MAP_MEDIA_FLOPPY The media is a floppy drive.
237 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
240 ACPI_HID_DEVICE_PATH
*Acpi
;
243 // Parse the device path:
244 // Devicepath sub type mediatype
245 // MEDIA_HANRDDRIVE_DP -> Hard Disk
246 // MEDIA_CDROM_DP -> CD Rom
247 // Acpi.HID = 0X0604 -> Floppy
249 if (NULL
== DevicePath
) {
250 return HiiGetString(gShellLevel2HiiHandle
, STRING_TOKEN(STR_MAP_MEDIA_UNKNOWN
), NULL
);
253 for (;!IsDevicePathEndType (DevicePath
) ;DevicePath
= NextDevicePathNode (DevicePath
)) {
254 if (DevicePathType (DevicePath
) == MEDIA_DEVICE_PATH
) {
255 switch (DevicePathSubType (DevicePath
)) {
256 case MEDIA_HARDDRIVE_DP
:
257 return HiiGetString(gShellLevel2HiiHandle
, STRING_TOKEN(STR_MAP_MEDIA_HARDDISK
), NULL
);
259 return HiiGetString(gShellLevel2HiiHandle
, STRING_TOKEN(STR_MAP_MEDIA_CDROM
), NULL
);
261 } else if (DevicePathType (DevicePath
) == ACPI_DEVICE_PATH
) {
262 Acpi
= (ACPI_HID_DEVICE_PATH
*) DevicePath
;
263 if (EISA_ID_TO_NUM (Acpi
->HID
) == 0x0604) {
264 return HiiGetString(gShellLevel2HiiHandle
, STRING_TOKEN(STR_MAP_MEDIA_FLOPPY
), NULL
);
269 return HiiGetString(gShellLevel2HiiHandle
, STRING_TOKEN(STR_MAP_MEDIA_UNKNOWN
), NULL
);
273 Function to detemine if a handle has removable storage.
275 @param[in] DevicePath DevicePath to test.
277 @retval TRUE The handle has removable storage.
278 @retval FALSE The handle does not have removable storage.
283 IN EFI_DEVICE_PATH_PROTOCOL
*DevicePath
286 if (NULL
== DevicePath
) {
290 while (!IsDevicePathEndType (DevicePath
)) {
291 if (DevicePathType (DevicePath
) == MESSAGING_DEVICE_PATH
) {
292 switch (DevicePathSubType (DevicePath
)) {
300 DevicePath
= NextDevicePathNode (DevicePath
);
306 Function to detemine if a something on the map list matches.
308 @param[in] MapList The pointer to the list to test.
309 @param[in] Specific The pointer to a specific name to test for.
310 @param[in] TypeString The pointer to the list of types.
311 @param[in] Normal Always show normal mappings.
312 @param[in] Consist Always show consistent mappings.
314 @retval TRUE The map should be displayed.
315 @retval FALSE The map should not be displayed.
320 IN CONST CHAR16
*MapList
,
321 IN CONST CHAR16
*Specific
,
322 IN CONST CHAR16
*TypeString
,
323 IN CONST BOOLEAN Normal
,
324 IN CONST BOOLEAN Consist
329 // specific has priority
331 if (Specific
!= NULL
) {
332 NewSpecific
= AllocateZeroPool(StrSize(Specific
) + sizeof(CHAR16
));
333 StrCpy(NewSpecific
, Specific
);
334 if (NewSpecific
[StrLen(NewSpecific
)-1] != L
':') {
335 StrCat(NewSpecific
, L
":");
338 if (SearchList(MapList
, NewSpecific
, NULL
, TRUE
, FALSE
, L
";")) {
339 FreePool(NewSpecific
);
342 FreePool(NewSpecific
);
345 && (SearchList(MapList
, L
"HD*", NULL
, TRUE
, TRUE
, L
";")
346 ||SearchList(MapList
, L
"CD*", NULL
, TRUE
, TRUE
, L
";")
347 ||SearchList(MapList
, L
"AnyF*", NULL
, TRUE
, TRUE
, L
";")
348 ||SearchList(MapList
, L
"FP*", NULL
, TRUE
, TRUE
, L
";"))){
353 && (SearchList(MapList
, L
"FS", NULL
, FALSE
, TRUE
, L
";")
354 ||SearchList(MapList
, L
"BLK", NULL
, FALSE
, TRUE
, L
";"))){
358 if (TypeString
!= NULL
&& SearchList(MapList
, TypeString
, NULL
, TRUE
, TRUE
, L
";")) {
366 Display a single map line for device Handle if conditions are met.
368 @param[in] Verbose TRUE to display (extra) verbose information.
369 @param[in] Consist TRUE to display consistent mappings.
370 @param[in] Normal TRUE to display normal (not consist) mappings.
371 @param[in] TypeString pointer to string of filter types.
372 @param[in] SFO TRUE to display output in Standard Output Format.
373 @param[in] Specific pointer to string for specific map to display.
374 @param[in] Handle The handle to display from.
376 @retval EFI_SUCCESS The mapping was displayed.
380 PerformSingleMappingDisplay(
381 IN CONST BOOLEAN Verbose
,
382 IN CONST BOOLEAN Consist
,
383 IN CONST BOOLEAN Normal
,
384 IN CONST CHAR16
*TypeString
,
385 IN CONST BOOLEAN SFO
,
386 IN CONST CHAR16
*Specific OPTIONAL
,
387 IN CONST EFI_HANDLE Handle
390 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
391 EFI_DEVICE_PATH_PROTOCOL
*DevPathCopy
;
392 CONST CHAR16
*MapList
;
395 CHAR16
*DevPathString
;
399 CONST CHAR16
*TempSpot2
;
401 DevPath
= DevicePathFromHandle(Handle
);
402 DevPathCopy
= DevPath
;
403 MapList
= gEfiShellProtocol
->GetMapFromDevicePath(&DevPathCopy
);
404 if (MapList
== NULL
) {
405 return EFI_NOT_FOUND
;
408 if (!MappingListHasType(MapList
, Specific
, TypeString
, Normal
, Consist
)){
409 return EFI_NOT_FOUND
;
413 CurrentName
= StrnCatGrow(&CurrentName
, 0, MapList
, 0);
414 TempSpot
= StrStr(CurrentName
, L
";");
415 if (TempSpot
!= NULL
) {
416 *TempSpot
= CHAR_NULL
;
418 DevPathString
= gDevPathToText
->ConvertDevicePathToText(DevPath
, TRUE
, FALSE
);
420 TempLen
= StrLen(CurrentName
);
425 STRING_TOKEN (STR_MAP_ENTRY
),
426 gShellLevel2HiiHandle
,
428 TempLen
< StrLen(MapList
)?MapList
+ TempLen
+1:L
"",
433 // also print handle, media type, removable (y/n), and current directory
435 MediaType
= GetDeviceMediaType(DevPath
);
436 if ((TypeString
!= NULL
&&MediaType
!= NULL
&& StrStr(TypeString
, MediaType
) != NULL
) || TypeString
== NULL
) {
437 Removable
= IsRemoveableDevice(DevPath
);
438 TempSpot2
= ShellGetCurrentDir(CurrentName
);
443 STRING_TOKEN (STR_MAP_ENTRY_VERBOSE
),
444 gShellLevel2HiiHandle
,
445 ConvertHandleToHandleIndex(Handle
),
447 Removable
?L
"Yes":L
"No",
454 TempLen
= StrLen(CurrentName
);
459 STRING_TOKEN (STR_MAP_SFO_MAPPINGS
),
460 gShellLevel2HiiHandle
,
463 TempLen
< StrLen(MapList
)?MapList
+ TempLen
+1:L
""
466 FreePool(DevPathString
);
467 FreePool(CurrentName
);
472 Delete Specific from the list of maps for device Handle.
474 @param[in] Specific The name to delete.
475 @param[in] Handle The device to look on.
477 @retval EFI_SUCCESS The delete was successful.
478 @retval EFI_NOT_FOUND Name was not a map on Handle.
482 PerformSingleMappingDelete(
483 IN CONST CHAR16
*Specific
,
484 IN CONST EFI_HANDLE Handle
487 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
488 EFI_DEVICE_PATH_PROTOCOL
*DevPathCopy
;
489 CONST CHAR16
*MapList
;
492 DevPath
= DevicePathFromHandle(Handle
);
493 DevPathCopy
= DevPath
;
494 MapList
= gEfiShellProtocol
->GetMapFromDevicePath(&DevPathCopy
);
497 if (MapList
== NULL
) {
498 return (EFI_NOT_FOUND
);
501 // if there is a specific and its not on the list...
503 if (!SearchList(MapList
, Specific
, &CurrentName
, TRUE
, FALSE
, L
";")) {
504 return (EFI_NOT_FOUND
);
506 return (gEfiShellProtocol
->SetMap(NULL
, CurrentName
));
509 CONST CHAR16 Cd
[] = L
"cd*";
510 CONST CHAR16 Hd
[] = L
"hd*";
511 CONST CHAR16 Fp
[] = L
"fp*";
512 CONST CHAR16 AnyF
[] = L
"F*";
514 Function to display mapping information to the user.
516 if Specific is specified then Consist and Normal will be ignored since information will
517 be printed for the specific item only.
519 @param[in] Verbose TRUE to display (extra) verbose information
520 @param[in] Consist TRUE to display consistent mappings
521 @param[in] Normal TRUE to display normal (not consist) mappings
522 @param[in] TypeString pointer to string of filter types
523 @param[in] SFO TRUE to display output in Standard Output Format
524 @param[in] Specific pointer to string for specific map to display
526 @retval SHELL_SUCCESS the display was printed
527 @retval SHELL_INVALID_PARAMETER one of Consist or Normal must be TRUE if no Specific
532 PerformMappingDisplay(
533 IN CONST BOOLEAN Verbose
,
534 IN CONST BOOLEAN Consist
,
535 IN CONST BOOLEAN Normal
,
536 IN CONST CHAR16
*TypeString
,
537 IN CONST BOOLEAN SFO
,
538 IN CONST CHAR16
*Specific OPTIONAL
,
539 IN CONST BOOLEAN Header
543 EFI_HANDLE
*HandleBuffer
;
549 if (!Consist
&& !Normal
&& Specific
== NULL
&& TypeString
== NULL
) {
550 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_TOO_FEW
), gShellLevel2HiiHandle
);
551 return (SHELL_INVALID_PARAMETER
);
554 if (TypeString
!= NULL
) {
556 if (StrnCmp(TypeString
, Test
, StrLen(Test
)-1) != 0) {
558 if (StrnCmp(TypeString
, Test
, StrLen(Test
)-1) != 0) {
560 if (StrnCmp(TypeString
, Test
, StrLen(Test
)-1) != 0) {
561 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_PROBLEM
), gShellLevel2HiiHandle
, TypeString
);
562 return (SHELL_INVALID_PARAMETER
);
564 } else if (Test
== NULL
) {
565 Test
= (CHAR16
*)AnyF
;
577 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_MAP_HEADER
), gShellLevel2HiiHandle
);
579 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_SFO_HEADER
), gShellLevel2HiiHandle
, L
"map");
587 // Look up all SimpleFileSystems in the platform
589 Status
= gBS
->LocateHandle(
591 &gEfiSimpleFileSystemProtocolGuid
,
595 if (Status
== EFI_BUFFER_TOO_SMALL
) {
596 HandleBuffer
= AllocateZeroPool(BufferSize
);
597 if (HandleBuffer
== NULL
) {
598 return (SHELL_OUT_OF_RESOURCES
);
600 Status
= gBS
->LocateHandle(
602 &gEfiSimpleFileSystemProtocolGuid
,
609 // Get the map name(s) for each one.
611 for ( LoopVar
= 0, Found
= FALSE
612 ; LoopVar
< (BufferSize
/ sizeof(EFI_HANDLE
))
615 Status
= PerformSingleMappingDisplay(
622 HandleBuffer
[LoopVar
]);
623 if (!EFI_ERROR(Status
)) {
629 // Look up all BlockIo in the platform
631 Status
= gBS
->LocateHandle(
633 &gEfiBlockIoProtocolGuid
,
637 if (Status
== EFI_BUFFER_TOO_SMALL
) {
638 FreePool(HandleBuffer
);
639 HandleBuffer
= AllocateZeroPool(BufferSize
);
640 if (HandleBuffer
== NULL
) {
641 return (SHELL_OUT_OF_RESOURCES
);
643 Status
= gBS
->LocateHandle(
645 &gEfiBlockIoProtocolGuid
,
650 if (!EFI_ERROR(Status
)) {
652 // Get the map name(s) for each one.
655 ; LoopVar
< BufferSize
/ sizeof(EFI_HANDLE
)
659 // Skip any that were already done...
661 if (gBS
->OpenProtocol(
662 HandleBuffer
[LoopVar
],
663 &gEfiSimpleFileSystemProtocolGuid
,
667 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
) == EFI_SUCCESS
) {
670 Status
= PerformSingleMappingDisplay(
677 HandleBuffer
[LoopVar
]);
678 if (!EFI_ERROR(Status
)) {
682 FreePool(HandleBuffer
);
685 ShellPrintHiiEx(gST
->ConOut
->Mode
->CursorColumn
, gST
->ConOut
->Mode
->CursorRow
-1, NULL
, STRING_TOKEN (STR_MAP_NF
), gShellLevel2HiiHandle
, Specific
);
687 return (SHELL_SUCCESS
);
691 Perform a mapping display and parse for multiple types in the TypeString.
693 @param[in] Verbose TRUE to use verbose output.
694 @param[in] Consist TRUE to display consistent names.
695 @param[in] Normal TRUE to display normal names.
696 @param[in] TypeString An optional comma-delimited list of types.
697 @param[in] SFO TRUE to display in SFO format. See Spec.
698 @param[in] Specific An optional specific map name to display alone.
700 @retval SHELL_INVALID_PARAMETER A parameter was invalid.
701 @retval SHELL_SUCCESS The display was successful.
702 @sa PerformMappingDisplay
706 PerformMappingDisplay2(
707 IN CONST BOOLEAN Verbose
,
708 IN CONST BOOLEAN Consist
,
709 IN CONST BOOLEAN Normal
,
710 IN CONST CHAR16
*TypeString
,
711 IN CONST BOOLEAN SFO
,
712 IN CONST CHAR16
*Specific OPTIONAL
715 CONST CHAR16
*TypeWalker
;
716 SHELL_STATUS ShellStatus
;
720 if (TypeString
== NULL
) {
721 return (PerformMappingDisplay(Verbose
, Consist
, Normal
, NULL
, SFO
, Specific
, TRUE
));
723 ShellStatus
= SHELL_SUCCESS
;
724 for (TypeWalker
= TypeString
; TypeWalker
!= NULL
&& *TypeWalker
!= CHAR_NULL
;) {
725 Comma
= StrStr(TypeWalker
, L
",");
727 if (ShellStatus
== SHELL_SUCCESS
) {
728 ShellStatus
= PerformMappingDisplay(Verbose
, Consist
, Normal
, TypeWalker
, SFO
, Specific
, (BOOLEAN
)(TypeWalker
== TypeString
));
730 PerformMappingDisplay(Verbose
, Consist
, Normal
, TypeWalker
, SFO
, Specific
, (BOOLEAN
)(TypeWalker
== TypeString
));
735 if (ShellStatus
== SHELL_SUCCESS
) {
736 ShellStatus
= PerformMappingDisplay(Verbose
, Consist
, Normal
, TypeWalker
, SFO
, Specific
, (BOOLEAN
)(TypeWalker
== TypeString
));
738 PerformMappingDisplay(Verbose
, Consist
, Normal
, TypeWalker
, SFO
, Specific
, (BOOLEAN
)(TypeWalker
== TypeString
));
741 TypeWalker
= Comma
+ 1;
745 return (ShellStatus
);
749 Delete a specific map.
751 @param[in] Specific The pointer to the name of the map to delete.
753 @retval EFI_INVALID_PARAMETER Specific was NULL.
754 @retval EFI_SUCCESS The operation was successful.
755 @retval EFI_NOT_FOUND Specific could not be found.
759 PerformMappingDelete(
760 IN CONST CHAR16
*Specific
764 EFI_HANDLE
*HandleBuffer
;
769 if (Specific
== NULL
) {
770 return (EFI_INVALID_PARAMETER
);
778 // Look up all SimpleFileSystems in the platform
780 Status
= gBS
->LocateHandle(
782 &gEfiDevicePathProtocolGuid
,
786 if (Status
== EFI_BUFFER_TOO_SMALL
) {
787 HandleBuffer
= AllocateZeroPool(BufferSize
);
788 if (HandleBuffer
== NULL
) {
789 return (EFI_OUT_OF_RESOURCES
);
791 Status
= gBS
->LocateHandle(
793 &gEfiDevicePathProtocolGuid
,
798 if (EFI_ERROR(Status
)) {
799 SHELL_FREE_NON_NULL(HandleBuffer
);
803 if (HandleBuffer
!= NULL
) {
805 // Get the map name(s) for each one.
808 ; LoopVar
< BufferSize
/ sizeof(EFI_HANDLE
)
811 if (PerformSingleMappingDelete(Specific
,HandleBuffer
[LoopVar
]) == SHELL_SUCCESS
) {
817 // Look up all BlockIo in the platform
819 Status
= gBS
->LocateHandle(
821 &gEfiBlockIoProtocolGuid
,
825 if (Status
== EFI_BUFFER_TOO_SMALL
) {
826 FreePool(HandleBuffer
);
827 HandleBuffer
= AllocateZeroPool(BufferSize
);
828 if (HandleBuffer
== NULL
) {
829 return (EFI_OUT_OF_RESOURCES
);
831 Status
= gBS
->LocateHandle(
833 &gEfiBlockIoProtocolGuid
,
838 if (EFI_ERROR(Status
)) {
839 SHELL_FREE_NON_NULL(HandleBuffer
);
843 if (HandleBuffer
!= NULL
) {
845 // Get the map name(s) for each one.
848 ; LoopVar
< BufferSize
/ sizeof(EFI_HANDLE
)
852 // Skip any that were already done...
854 if (gBS
->OpenProtocol(
855 HandleBuffer
[LoopVar
],
856 &gEfiDevicePathProtocolGuid
,
860 EFI_OPEN_PROTOCOL_TEST_PROTOCOL
) == EFI_SUCCESS
) {
863 if (PerformSingleMappingDelete(Specific
,HandleBuffer
[LoopVar
]) == SHELL_SUCCESS
) {
868 SHELL_FREE_NON_NULL(HandleBuffer
);
870 return (EFI_NOT_FOUND
);
872 return (EFI_SUCCESS
);
876 function to add a mapping from mapping.
878 This function will get the device path associated with the mapping and call SetMap.
880 @param[in] Map The Map to add a mapping for
881 @param[in] SName The name of the new mapping
883 @retval SHELL_SUCCESS the mapping was added
884 @retval SHELL_INVALID_PARAMETER the device path for Map could not be retrieved.
885 @return Shell version of a return value from EfiShellProtocol->SetMap
890 AddMappingFromMapping(
891 IN CONST CHAR16
*Map
,
892 IN CONST CHAR16
*SName
895 CONST EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
899 NewSName
= AllocateZeroPool(StrSize(SName
) + sizeof(CHAR16
));
900 StrCpy(NewSName
, SName
);
901 if (NewSName
[StrLen(NewSName
)-1] != L
':') {
902 StrCat(NewSName
, L
":");
905 if (!IsNumberLetterOnly(NewSName
, StrLen(NewSName
)-1)) {
907 return (SHELL_INVALID_PARAMETER
);
910 DevPath
= gEfiShellProtocol
->GetDevicePathFromMap(Map
);
911 if (DevPath
== NULL
) {
913 return (SHELL_INVALID_PARAMETER
);
916 Status
= gEfiShellProtocol
->SetMap(DevPath
, NewSName
);
918 if (EFI_ERROR(Status
)) {
919 return (SHELL_DEVICE_ERROR
);
921 return (SHELL_SUCCESS
);
925 function to add a mapping from an EFI_HANDLE.
927 This function will get the device path associated with the Handle and call SetMap.
929 @param[in] Handle The handle to add a mapping for
930 @param[in] SName The name of the new mapping
932 @retval SHELL_SUCCESS the mapping was added
933 @retval SHELL_INVALID_PARAMETER SName was not valid for a map name.
934 @return Shell version of a return value from either
935 gBS->OpenProtocol or EfiShellProtocol->SetMap
940 AddMappingFromHandle(
941 IN CONST EFI_HANDLE Handle
,
942 IN CONST CHAR16
*SName
945 EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
949 NewSName
= AllocateZeroPool(StrSize(SName
) + sizeof(CHAR16
));
950 StrCpy(NewSName
, SName
);
951 if (NewSName
[StrLen(NewSName
)-1] != L
':') {
952 StrCat(NewSName
, L
":");
955 if (!IsNumberLetterOnly(NewSName
, StrLen(NewSName
)-1)) {
957 return (SHELL_INVALID_PARAMETER
);
960 Status
= gBS
->OpenProtocol(
962 &gEfiDevicePathProtocolGuid
,
966 EFI_OPEN_PROTOCOL_GET_PROTOCOL
968 if (EFI_ERROR(Status
)) {
970 return (SHELL_DEVICE_ERROR
);
972 Status
= gEfiShellProtocol
->SetMap(DevPath
, NewSName
);
974 if (EFI_ERROR(Status
)) {
975 return (SHELL_DEVICE_ERROR
);
977 return (SHELL_SUCCESS
);
980 STATIC CONST SHELL_PARAM_ITEM MapParamList
[] = {
988 {L
"-sfo", TypeValue
},
993 Function for 'map' command.
995 @param[in] ImageHandle Handle to the Image (NULL if Internal).
996 @param[in] SystemTable Pointer to the System Table (NULL if Internal).
1000 ShellCommandRunMap (
1001 IN EFI_HANDLE ImageHandle
,
1002 IN EFI_SYSTEM_TABLE
*SystemTable
1006 LIST_ENTRY
*Package
;
1007 CHAR16
*ProblemParam
;
1008 CONST CHAR16
*SName
;
1009 CONST CHAR16
*Mapping
;
1010 EFI_HANDLE MapAsHandle
;
1011 CONST EFI_DEVICE_PATH_PROTOCOL
*DevPath
;
1012 SHELL_STATUS ShellStatus
;
1016 CONST CHAR16
*Param1
;
1017 CONST CHAR16
*TypeString
;
1018 UINTN TempStringLength
;
1020 ProblemParam
= NULL
;
1024 ShellStatus
= SHELL_SUCCESS
;
1028 // initialize the shell lib (we must be in non-auto-init...)
1030 Status
= ShellInitialize();
1031 ASSERT_EFI_ERROR(Status
);
1033 Status
= CommandInit();
1034 ASSERT_EFI_ERROR(Status
);
1037 // parse the command line
1039 Status
= ShellCommandLineParse (MapParamList
, &Package
, &ProblemParam
, TRUE
);
1040 if (EFI_ERROR(Status
)) {
1041 if (Status
== EFI_VOLUME_CORRUPTED
&& ProblemParam
!= NULL
) {
1042 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_PROBLEM
), gShellLevel2HiiHandle
, ProblemParam
);
1043 FreePool(ProblemParam
);
1044 ShellStatus
= SHELL_INVALID_PARAMETER
;
1052 SfoMode
= ShellCommandLineGetFlag(Package
, L
"-sfo");
1053 ConstMode
= ShellCommandLineGetFlag(Package
, L
"-c");
1054 NormlMode
= ShellCommandLineGetFlag(Package
, L
"-f");
1055 if (ShellCommandLineGetFlag(Package
, L
"-?")) {
1057 } else if (ShellCommandLineGetRawValue(Package
, 3) != NULL
) {
1058 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_TOO_MANY
), gShellLevel2HiiHandle
);
1059 ShellStatus
= SHELL_INVALID_PARAMETER
;
1062 // Deleting a map name...
1064 if (ShellCommandLineGetFlag(Package
, L
"-d")) {
1065 if ( ShellCommandLineGetFlag(Package
, L
"-r")
1066 || ShellCommandLineGetFlag(Package
, L
"-v")
1069 || ShellCommandLineGetFlag(Package
, L
"-u")
1070 || ShellCommandLineGetFlag(Package
, L
"-t")
1072 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_PARAM_CON
), gShellLevel2HiiHandle
);
1073 ShellStatus
= SHELL_INVALID_PARAMETER
;
1075 SName
= ShellCommandLineGetValue(Package
, L
"-d");
1076 if (SName
!= NULL
) {
1077 Status
= PerformMappingDelete(SName
);
1078 if (EFI_ERROR(Status
)) {
1080 case EFI_ACCESS_DENIED
:
1081 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_ERR_AD
), gShellLevel2HiiHandle
);
1082 ShellStatus
= SHELL_ACCESS_DENIED
;
1085 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_MAP_NF
), gShellLevel2HiiHandle
, SName
);
1086 ShellStatus
= SHELL_INVALID_PARAMETER
;
1089 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_ERR_UK
), gShellLevel2HiiHandle
, Status
);
1090 ShellStatus
= SHELL_UNSUPPORTED
;
1094 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_TOO_FEW
), gShellLevel2HiiHandle
);
1095 ShellStatus
= SHELL_INVALID_PARAMETER
;
1098 } else if ( ShellCommandLineGetFlag(Package
, L
"-r")
1099 // || ShellCommandLineGetFlag(Package, L"-v")
1102 || ShellCommandLineGetFlag(Package
, L
"-u")
1103 || ShellCommandLineGetFlag(Package
, L
"-t")
1105 if ( ShellCommandLineGetFlag(Package
, L
"-r")) {
1109 Status
= ShellCommandCreateInitialMappingsAndPaths();
1110 if (EFI_ERROR(Status
)) {
1111 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_ERR_UK
), gShellLevel2HiiHandle
, Status
);
1112 ShellStatus
= SHELL_UNSUPPORTED
;
1115 if ( ShellStatus
== SHELL_SUCCESS
&& ShellCommandLineGetFlag(Package
, L
"-u")) {
1119 Status
= UpdateMapping();
1120 if (EFI_ERROR(Status
)) {
1121 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_ERR_UK
), gShellLevel2HiiHandle
, Status
);
1122 ShellStatus
= SHELL_UNSUPPORTED
;
1125 if (ShellStatus
== SHELL_SUCCESS
) {
1126 Param1
= ShellCommandLineGetRawValue(Package
, 1);
1127 TypeString
= ShellCommandLineGetValue(Package
, L
"-t");
1130 &&TypeString
== NULL
1133 // now do the display...
1135 ShellStatus
= PerformMappingDisplay(
1136 ShellCommandLineGetFlag(Package
, L
"-v"),
1146 // now do the display...
1148 ShellStatus
= PerformMappingDisplay2(
1149 ShellCommandLineGetFlag(Package
, L
"-v"),
1160 // adding or displaying (there were no flags)
1162 SName
= ShellCommandLineGetRawValue(Package
, 1);
1163 Mapping
= ShellCommandLineGetRawValue(Package
, 2);
1168 // display only since no flags
1170 ShellStatus
= PerformMappingDisplay(
1171 ShellCommandLineGetFlag(Package
, L
"-v"),
1179 } else if ( SName
== NULL
1183 // Display only the one specified
1185 ShellStatus
= PerformMappingDisplay(
1191 SName
, // note the variable here...
1195 if (ShellIsHexOrDecimalNumber(Mapping
, TRUE
, FALSE
)) {
1196 MapAsHandle
= ConvertHandleIndexToHandle(ShellStrToUintn(Mapping
));
1200 if (MapAsHandle
== NULL
&& Mapping
[StrLen(Mapping
)-1] != L
':') {
1201 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_PROBLEM
), gShellLevel2HiiHandle
, Mapping
);
1202 ShellStatus
= SHELL_INVALID_PARAMETER
;
1204 if (MapAsHandle
!= NULL
) {
1205 TempStringLength
= StrLen(SName
);
1206 if (!IsNumberLetterOnly(SName
, TempStringLength
-(SName
[TempStringLength
-1]==L
':'?1:0))) {
1207 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_PROBLEM
), gShellLevel2HiiHandle
, SName
);
1208 ShellStatus
= SHELL_INVALID_PARAMETER
;
1210 ShellStatus
= AddMappingFromHandle(MapAsHandle
, SName
);
1213 TempStringLength
= StrLen(SName
);
1214 if (!IsNumberLetterOnly(SName
, TempStringLength
-(SName
[TempStringLength
-1]==L
':'?1:0))) {
1215 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_PROBLEM
), gShellLevel2HiiHandle
, SName
);
1216 ShellStatus
= SHELL_INVALID_PARAMETER
;
1218 ShellStatus
= AddMappingFromMapping(Mapping
, SName
);
1221 if (ShellStatus
!= SHELL_SUCCESS
) {
1222 switch (ShellStatus
) {
1223 case SHELL_ACCESS_DENIED
:
1224 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_ERR_AD
), gShellLevel2HiiHandle
);
1226 case SHELL_INVALID_PARAMETER
:
1227 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_PARAM_INV
), gShellLevel2HiiHandle
);
1229 case SHELL_DEVICE_ERROR
:
1230 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_MAP_NOF
), gShellLevel2HiiHandle
, Mapping
);
1233 ShellPrintHiiEx(-1, -1, NULL
, STRING_TOKEN (STR_GEN_ERR_UK
), gShellLevel2HiiHandle
, ShellStatus
|MAX_BIT
);
1237 // now do the display...
1239 ShellStatus
= PerformMappingDisplay(
1248 } // we were sucessful so do an output
1249 } // got a valid map target
1250 } // got 2 variables
1251 } // we are adding a mapping
1252 } // got valid parameters
1256 // free the command line package
1258 ShellCommandLineFreeVarList (Package
);
1260 return (ShellStatus
);