SHEL21
[efi/shell/.git] / dmpstore / dmpstore.c
1 /*++
2
3 Copyright (c) 2005 - 2009, Intel Corporation                                                         
4 All rights reserved. This program and the accompanying materials                          
5 are licensed and made available under the terms and conditions of the BSD License         
6 which accompanies this distribution. The full text of the license may be found at         
7 http://opensource.org/licenses/bsd-license.php                                            
8                                                                                           
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             
11
12 Module Name:
13
14   dmpstore.c
15   
16 Abstract:
17
18   Shell app "dmpstore"
19
20
21
22 Revision History
23
24 --*/
25
26 #include "EfiShellLib.h"
27 #include "dmpstore.h"
28
29 extern UINT8  STRING_ARRAY_NAME[];
30
31 //
32 // This is the generated header file which includes whatever needs to be exported (strings + IFR)
33 //
34 #include STRING_DEFINES_FILE
35
36 #define INIT_NAME_BUFFER_SIZE  128
37 #define INIT_DATA_BUFFER_SIZE  1024
38
39 STATIC CHAR16   *AttrType[] = {
40   L"invalid",   // 000
41   L"invalid",   // 001
42   L"BS",        // 010
43   L"NV+BS",     // 011
44   L"RT+BS",     // 100
45   L"NV+RT+BS",  // 101
46   L"RT+BS",     // 110
47   L"NV+RT+BS",  // 111
48 };
49
50 //
51 //
52 //
53 EFI_STATUS
54 InitializeDumpStore (
55   IN EFI_HANDLE         ImageHandle,
56   IN EFI_SYSTEM_TABLE   *SystemTable
57   );
58
59 EFI_STATUS
60 LoadVariableStore (
61   IN CHAR16   *VarName,
62   IN CHAR16   *FileName
63   );
64
65 EFI_STATUS
66 DumpVariableStore (
67   IN CHAR16           *VarName,
68   IN BOOLEAN          Delete,
69   IN EFI_FILE_HANDLE  FileHandle  
70   );
71
72 EFI_STATUS
73 CreateOutputFile (
74   IN CHAR16           *FileName, 
75   OUT EFI_FILE_HANDLE *FileHandle
76   );
77
78 EFI_STATUS
79 GetFileVariable (
80   IN EFI_FILE_HANDLE FileHandle,
81   OUT UINTN          *VariableNameSize,
82   IN OUT UINTN       *NameBufferSize,
83   IN OUT CHAR16      **VariableName,
84   IN EFI_GUID        *VendorGuid,
85   OUT UINT32         *Attributes,
86   OUT UINTN          *DataSize,
87   IN OUT UINTN       *DataBufferSize,
88   IN OUT VOID        **Data
89   );
90
91 EFI_STATUS
92 SetFileVariable (
93   IN EFI_FILE_HANDLE FileHandle,
94   IN UINTN           VariableNameSize,
95   IN CHAR16          *VariableName,
96   IN EFI_GUID        *VendorGuid,
97   IN UINT32          Attributes,
98   IN UINTN           DataSize,
99   IN VOID            *Data  
100   );
101
102 //
103 // Global Variables
104 //
105 EFI_HII_HANDLE  HiiHandle;
106 EFI_GUID        EfiDmpstoreGuid = EFI_DMPSTORE_GUID;
107 SHELL_VAR_CHECK_ITEM    DmpstoreCheckList[] = {
108   {
109     L"-b",
110     0x01,
111     0,
112     FlagTypeSingle
113   },
114   {
115     L"-?",
116     0x02,
117     0,
118     FlagTypeSingle
119   },
120   {
121     L"-d",
122     0x04,
123     0x18,
124     FlagTypeSingle
125   },
126   {
127     L"-s",
128     0x08,
129     0x14,
130     FlagTypeNeedVar
131   },  
132   {
133     L"-l",
134     0x10,
135     0x0c,
136     FlagTypeNeedVar
137   },  
138   {
139     NULL,
140     0,
141     0,
142     0
143   }
144 };
145
146 EFI_BOOTSHELL_CODE(
147   EFI_APPLICATION_ENTRY_POINT(InitializeDumpStore)
148 )
149
150 EFI_STATUS
151 InitializeDumpStore (
152   IN EFI_HANDLE         ImageHandle,
153   IN EFI_SYSTEM_TABLE   *SystemTable
154   )
155 /*++
156
157 Routine Description:
158
159   Command entry point
160
161 Arguments:
162
163   ImageHandle - The image handle
164   SystemTable - The system table
165
166 Returns:
167
168   EFI_SUCCESS - Success
169
170 --*/
171 {
172   CHAR16                  *VarName;
173   EFI_STATUS              Status;
174   BOOLEAN                 Delete;
175   EFI_FILE_HANDLE         FileHandle;
176   SHELL_VAR_CHECK_CODE    RetCode;
177   CHAR16                  *Useful;
178   SHELL_VAR_CHECK_PACKAGE ChkPck;
179   SHELL_ARG_LIST          *Item;
180
181   ZeroMem (&ChkPck, sizeof (SHELL_VAR_CHECK_PACKAGE));
182   //
183   // We are no being installed as an internal command driver, initialize
184   // as an nshell app and run
185   //
186   EFI_SHELL_APP_INIT (ImageHandle, SystemTable);
187
188   //
189   // Enable tab key which can pause the output
190   //
191   EnableOutputTabPause();
192    
193   //
194   // Register our string package with HII and return the handle to it.
195   // If previously registered we will simply receive the handle
196   //
197   Status = LibInitializeStrings (&HiiHandle, STRING_ARRAY_NAME, &EfiDmpstoreGuid);
198   if (EFI_ERROR (Status)) {
199     return Status;
200   }
201
202   VarName    = NULL;
203   Status     = EFI_SUCCESS;
204   Delete     = FALSE;
205   FileHandle = NULL;
206
207   LibFilterNullArgs ();
208   //
209   // Check flags
210   //
211   Useful  = NULL;
212   RetCode = LibCheckVariables (SI, DmpstoreCheckList, &ChkPck, &Useful);
213   if (VarCheckOk != RetCode) {
214     switch (RetCode) {
215     case VarCheckConflict:
216       PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_FLAG_CONFLICT), HiiHandle, L"dmpstore", Useful);
217       break;
218           
219     case VarCheckDuplicate:
220       PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_DUP_FLAG), HiiHandle, L"dmpstore", Useful);
221       break;
222
223     case VarCheckUnknown:
224       PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_UNKNOWN_FLAG), HiiHandle, L"dmpstore", Useful);
225       break;
226
227     case VarCheckLackValue:
228       PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_LACK_ARG), HiiHandle, L"dmpstore", Useful);
229       break;
230       
231     default:
232       break;
233     }
234
235     Status = EFI_INVALID_PARAMETER;
236     goto Done;
237   }
238
239   if (LibCheckVarGetFlag (&ChkPck, L"-b") != NULL) {
240     EnablePageBreak (DEFAULT_INIT_ROW, DEFAULT_AUTO_LF);
241   }
242
243   if (LibCheckVarGetFlag (&ChkPck, L"-?")) {
244     if (ChkPck.ValueCount > 0 ||
245         ChkPck.FlagCount > 2 ||
246         (2 == ChkPck.FlagCount && !LibCheckVarGetFlag (&ChkPck, L"-b"))
247         ) {
248       PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiHandle, L"dmpstore");
249       Status = EFI_INVALID_PARAMETER;
250     } else {
251       PrintToken (STRING_TOKEN (STR_DMPSTORE_VERBOSEHELP), HiiHandle);
252       Status = EFI_SUCCESS;
253     }
254
255     goto Done;
256   }
257
258   if (ChkPck.ValueCount > 1) {
259     PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_TOO_MANY), HiiHandle, L"dmpstore");
260     Status = EFI_INVALID_PARAMETER;
261     goto Done;
262   }
263
264   if (NULL != ChkPck.VarList) {
265     VarName = ChkPck.VarList->VarStr;
266   }
267   
268   Item = LibCheckVarGetFlag (&ChkPck, L"-l");
269   if (Item != NULL) {
270     //
271     // Load and set variables from previous saved file
272     //
273     Status = LoadVariableStore (VarName, Item->VarStr);
274     goto Done;
275   }
276
277   Item = LibCheckVarGetFlag (&ChkPck, L"-s");
278   if (Item != NULL) {
279     //
280     // Create output file for saving variables
281     //
282     Status = CreateOutputFile (Item->VarStr, &FileHandle);
283     if (EFI_ERROR (Status)) {
284       goto Done;
285     }
286   }
287
288   if (LibCheckVarGetFlag (&ChkPck, L"-d") != NULL) {
289     Delete = TRUE;
290   }
291       
292   //
293   // Dump variables in store
294   //
295   Status = DumpVariableStore (VarName, Delete, FileHandle);
296
297   //
298   // Done
299   //
300 Done:
301   LibCheckVarFreeVarList (&ChkPck);
302   LibUnInitializeStrings ();
303   if (FileHandle != NULL) {
304     LibCloseFile (FileHandle);
305   };
306   return Status;
307 }
308
309 EFI_STATUS
310 LoadVariableStore (
311   IN CHAR16   *VarName,
312   IN CHAR16   *FileName
313   )
314 {
315   EFI_STATUS         Status;
316   EFI_FILE_HANDLE    FileHandle;  
317   EFI_GUID           Guid;
318   UINT32             Attributes;
319   CHAR16             *Name;
320   UINTN              NameBufferSize;
321   UINTN              NameSize;
322   VOID               *Data;
323   UINTN              DataBufferSize;
324   UINTN              DataSize;
325   BOOLEAN            Found;
326   EFI_FILE_INFO      *FileInfo;
327
328   Found      = FALSE;
329   FileHandle = NULL;
330   FileInfo   = NULL;
331   
332   NameBufferSize = INIT_NAME_BUFFER_SIZE;
333   DataBufferSize = INIT_DATA_BUFFER_SIZE;
334   Name           = AllocateZeroPool (NameBufferSize);
335   Data           = AllocatePool (DataBufferSize);
336   if (Name == NULL || Data == NULL) {
337     Status = EFI_OUT_OF_RESOURCES;
338     goto Done;
339   }
340   //
341   // Open the previous saved output file
342   //  
343   Status = LibOpenFileByName (
344              FileName,
345              &FileHandle,
346              EFI_FILE_MODE_READ,
347              0
348              );
349   if (EFI_ERROR (Status)) {
350     PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_CANNOT_OPEN_FILE), HiiHandle, L"dmpstore", FileName);
351     goto Done;
352   }
353   
354   //
355   // If the file is directory, abort
356   //
357   FileInfo = LibGetFileInfo (FileHandle);
358   if (FileInfo == NULL) {
359     Status = EFI_ABORTED;
360     PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_CANNOT_OPEN_FILE), HiiHandle, L"dmpstore", FileName);
361     goto Done;
362   } else if (FileInfo->Attribute & EFI_FILE_DIRECTORY) {
363     Status = EFI_ABORTED;
364     PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_CANNOT_OPEN_FILE), HiiHandle, L"dmpstore", FileName);
365     goto Done;
366   }
367   
368   PrintToken (STRING_TOKEN (STR_DMPSTORE_LOAD), HiiHandle);
369   do {
370     //
371     // Break the execution?
372     //
373     if (GetExecutionBreak ()) {
374       break;
375     }
376     
377     Status = GetFileVariable (FileHandle, &NameSize, &NameBufferSize, &Name, &Guid, &Attributes, &DataSize, &DataBufferSize, &Data);
378     if (Status == EFI_NOT_FOUND) {
379       Status = EFI_SUCCESS;
380       break;
381     }
382     if (EFI_ERROR (Status)) {
383       PrintToken (STRING_TOKEN (STR_DMPSTORE_LOAD_ERR2), HiiHandle);
384       goto Done;
385     }
386  
387     if (VarName != NULL) {
388       if (!MetaiMatch (Name, VarName)) {
389         continue;
390       }
391     }
392     
393     Found = TRUE;
394     //
395     // Dump variable name
396     //        
397     PrintToken (
398       STRING_TOKEN (STR_DMPSTORE_VAR),
399       HiiHandle,
400       AttrType[Attributes & 7],
401       &Guid,
402       Name,
403       DataSize
404       );    
405  
406     Status = RT->SetVariable (Name, &Guid, Attributes, DataSize, Data);
407     if (EFI_ERROR (Status)) {
408       PrintToken (STRING_TOKEN (STR_DMPSTORE_LOAD_ERR), HiiHandle);
409       goto Done;
410     }
411   } while (!EFI_ERROR (Status));
412
413   if (!Found) {
414     if (VarName != NULL) {
415       PrintToken (STRING_TOKEN (STR_DMPSTORE_VAR_NOT_FOUND), HiiHandle, VarName);
416     } else {
417       PrintToken (STRING_TOKEN (STR_DMPSTORE_VAR_EMPTY), HiiHandle);
418     }
419   }
420
421 Done:
422   if (FileInfo != NULL) {
423     FreePool (FileInfo); 
424   }  
425   if (FileHandle != NULL) {
426     LibCloseFile (FileHandle);
427   }
428   if (Name != NULL) {
429     FreePool (Name);
430   }
431   if (Data != NULL) {
432     FreePool (Data);
433   }
434   return Status;
435 }
436
437 EFI_STATUS
438 DumpVariableStore (
439   IN CHAR16           *VarName,
440   IN BOOLEAN          Delete,
441   IN EFI_FILE_HANDLE  FileHandle
442   )
443 {
444   EFI_STATUS  Status;
445   EFI_GUID    Guid;
446   UINT32      Attributes;
447   CHAR16      *Name;
448   UINTN       NameBufferSize; // Allocated Name buffer size
449   UINTN       NameSize;
450   CHAR16      *OldName;
451   UINTN       OldNameBufferSize;
452   VOID        *Data;
453   UINTN       DataBufferSize; // Allocated Name buffer size
454   UINTN       DataSize;
455   BOOLEAN     Found;
456
457   Found  = FALSE;
458   Status = EFI_SUCCESS;
459
460   if (VarName != NULL) {
461     if (Delete) {
462       PrintToken (STRING_TOKEN (STR_DMPSTORE_DELETE_ONE_VAR), HiiHandle, VarName);
463     } else if (FileHandle != NULL) {
464       PrintToken (STRING_TOKEN (STR_DMPSTORE_SAVE_ONE_VAR), HiiHandle, VarName);
465     } else {
466       PrintToken (STRING_TOKEN (STR_DMPSTORE_DUMP_ONE_VAR), HiiHandle, VarName);
467     }
468   } else {
469     if (Delete) {
470       PrintToken (STRING_TOKEN (STR_DMPSTORE_DELETE), HiiHandle);
471     } else if (FileHandle != NULL) {
472       PrintToken (STRING_TOKEN (STR_DMPSTORE_SAVE), HiiHandle);
473     } else {
474       PrintToken (STRING_TOKEN (STR_DMPSTORE_DUMP), HiiHandle);
475     }    
476   }
477
478   NameBufferSize = INIT_NAME_BUFFER_SIZE;
479   DataBufferSize = INIT_DATA_BUFFER_SIZE;
480   Name           = AllocateZeroPool (NameBufferSize);
481   Data           = AllocatePool (DataBufferSize);
482   if (Name == NULL || Data == NULL) {
483     Status = EFI_OUT_OF_RESOURCES;
484     goto Done;
485   }
486   do {
487     //
488     // Break the execution?
489     //
490     if (GetExecutionBreak ()) {
491       goto Done;
492     }
493     
494     NameSize  = NameBufferSize;
495     Status    = RT->GetNextVariableName (&NameSize, Name, &Guid);
496     if (Status == EFI_BUFFER_TOO_SMALL) {
497       OldName           = Name;
498       OldNameBufferSize = NameBufferSize;
499       //
500       // Expand at least twice to avoid reallocate many times
501       //
502       NameBufferSize = NameSize > NameBufferSize * 2 ? NameSize : NameBufferSize * 2;
503       Name           = AllocateZeroPool (NameBufferSize);
504       if (Name == NULL) {
505         Status = EFI_OUT_OF_RESOURCES;
506         FreePool (OldName);
507         goto Done;
508       }
509       //
510       // Preserve the original content to get correct iteration for GetNextVariableName() call
511       //
512       CopyMem (Name, OldName, OldNameBufferSize);
513       FreePool (OldName);
514       NameSize = NameBufferSize;
515       Status = RT->GetNextVariableName (&NameSize, Name, &Guid);
516     }
517     if (!EFI_ERROR (Status)) {
518       if (VarName != NULL) {
519         if (!MetaiMatch (Name, VarName)) {
520           continue;
521         }
522       }      
523
524       Found     = TRUE;
525       DataSize  = DataBufferSize;
526       Status    = RT->GetVariable (Name, &Guid, &Attributes, &DataSize, Data);
527       if (Status == EFI_BUFFER_TOO_SMALL) {
528         //
529         // Expand at least twice to avoid reallocate many times
530         //
531         FreePool (Data);
532         DataBufferSize = DataSize > DataBufferSize * 2 ? DataSize : DataBufferSize * 2;
533         Data           = AllocatePool (DataBufferSize);
534         if (Data == NULL) {
535           Status = EFI_OUT_OF_RESOURCES;
536           goto Done;
537         }
538         DataSize = DataBufferSize;
539         Status   = RT->GetVariable (Name, &Guid, &Attributes, &DataSize, Data);
540       }
541       if (!EFI_ERROR (Status)) {
542         //
543         // Dump variable name
544         //        
545         PrintToken (
546           STRING_TOKEN (STR_DMPSTORE_VAR),
547           HiiHandle,
548           AttrType[Attributes & 7],
549           &Guid,
550           Name,
551           DataSize
552           );
553         if (Delete) {
554           //
555           // Delete variables
556           //
557           DataSize = 0;
558           Status   = RT->SetVariable (Name, &Guid, Attributes, DataSize, Data);
559           if (EFI_ERROR (Status)) {
560             PrintToken (STRING_TOKEN (STR_DMPSTORE_DELETE_ERR), HiiHandle);
561             goto Done;
562           } else {
563             Name[0] = 0x0000;
564           }
565         } else if (FileHandle != NULL) {
566           //
567           // Save variables to output file
568           //
569           Status = SetFileVariable (FileHandle, NameSize, Name, &Guid, Attributes, DataSize, Data);
570           if (EFI_ERROR (Status)) {
571             PrintToken (STRING_TOKEN (STR_DMPSTORE_SAVE_ERR), HiiHandle);
572             goto Done;
573           }
574         } else {
575           //
576           // Dump variable data
577           //
578           PrivateDumpHex (2, 0, DataSize, Data);
579         }
580       }
581     } else if (Status == EFI_NOT_FOUND) {
582       Status = EFI_SUCCESS;
583       break;
584     }
585   } while (!EFI_ERROR (Status));
586
587   if (!Found) {
588     if (VarName != NULL) {
589       PrintToken (STRING_TOKEN (STR_DMPSTORE_VAR_NOT_FOUND), HiiHandle, VarName);
590     } else {
591       PrintToken (STRING_TOKEN (STR_DMPSTORE_VAR_EMPTY), HiiHandle);
592     }
593   }
594
595 Done:
596   if (Name != NULL) {
597     FreePool (Name);
598   }
599   if (Data != NULL) {
600     FreePool (Data);
601   }
602   return Status;
603 }
604
605 EFI_STATUS
606 CreateOutputFile (
607   IN CHAR16           *FileName, 
608   OUT EFI_FILE_HANDLE *FileHandle
609   )
610 {
611   EFI_STATUS     Status;
612   EFI_FILE_INFO  *FileInfo;
613
614   FileInfo = NULL;
615   
616   //
617   // Delete the output file first if it exist
618   //  
619   Status = LibOpenFileByName (
620              FileName,
621              FileHandle,
622              EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE,
623              0
624              );
625   if (!EFI_ERROR (Status)) {
626     //
627     // If the existing file is directory, abort
628     //
629     FileInfo = LibGetFileInfo (*FileHandle);
630     if (FileInfo == NULL) {
631       Status = EFI_ABORTED;
632       goto Done;
633     } else if (FileInfo->Attribute & EFI_FILE_DIRECTORY) {
634       Status = EFI_ABORTED;
635       goto Done;
636     }    
637     LibDeleteFile (*FileHandle);
638   } else if (Status != EFI_NOT_FOUND) {
639     goto Done;
640   }
641
642   //
643   // Create the output file
644   //
645   Status = LibOpenFileByName (
646              FileName,
647              FileHandle,
648              EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE,
649              0
650              );
651   
652 Done: 
653   if (FileInfo != NULL) {
654     FreePool (FileInfo); 
655   }
656   if (EFI_ERROR (Status)) {
657     PrintToken (STRING_TOKEN (STR_SHELLENV_GNC_CANNOT_OPEN_FILE), HiiHandle, L"dmpstore", FileName);
658   }
659   return Status;
660 }
661
662 EFI_STATUS
663 GetFileVariable (
664   IN EFI_FILE_HANDLE FileHandle,
665   OUT UINTN          *VariableNameSize,
666   IN OUT UINTN       *NameBufferSize,
667   IN OUT CHAR16      **VariableName,
668   IN EFI_GUID        *VendorGuid,
669   OUT UINT32         *Attributes,
670   OUT UINTN          *DataSize,
671   IN OUT UINTN       *DataBufferSize,
672   IN OUT VOID        **Data
673   )
674 {
675   EFI_STATUS  Status;
676   UINTN       BufferSize;
677   UINTN       NameSize;
678   UINTN       Size;
679   
680   NameSize   = 0;
681   BufferSize = sizeof (UINT32);
682   Status     = LibReadFile (FileHandle, &BufferSize, &NameSize);
683   if (!EFI_ERROR (Status) && (BufferSize == 0)) {
684     return EFI_NOT_FOUND; // End of file
685   }
686   if (EFI_ERROR (Status) || (BufferSize != sizeof (UINT32))) {
687     return EFI_ABORTED;
688   }
689   
690   if (NameSize > *NameBufferSize) {
691     //
692     // Expand at least twice to avoid reallocate many times
693     //
694     FreePool (*VariableName);
695     *NameBufferSize = NameSize > *NameBufferSize * 2 ? NameSize : *NameBufferSize * 2;
696     *VariableName   = AllocateZeroPool (*NameBufferSize);
697     if (*VariableName == NULL) {
698       return EFI_OUT_OF_RESOURCES;
699     }
700   }
701   BufferSize = NameSize;
702   Status     = LibReadFile (FileHandle, &BufferSize, *VariableName);
703   if (EFI_ERROR (Status) || (BufferSize != NameSize)) {
704     return EFI_ABORTED;
705   }
706
707   BufferSize = sizeof (EFI_GUID);
708   Status     = LibReadFile (FileHandle, &BufferSize, VendorGuid);
709   if (EFI_ERROR (Status) || (BufferSize != sizeof (EFI_GUID))) {
710     return EFI_ABORTED;
711   }
712
713   BufferSize = sizeof (UINT32);
714   Status     = LibReadFile (FileHandle, &BufferSize, Attributes);
715   if (EFI_ERROR (Status) || (BufferSize != sizeof (UINT32))) {
716     return EFI_ABORTED;
717   }
718
719   Size       = 0;
720   BufferSize = sizeof (UINT32);
721   Status     = LibReadFile (FileHandle, &BufferSize, &Size);
722   if (EFI_ERROR (Status) || (BufferSize != sizeof (UINT32))) {
723     return EFI_ABORTED;
724   }
725   
726   if (Size > *DataBufferSize) {
727     //
728     // Expand at least twice to avoid reallocate many times
729     //
730     FreePool (*Data);
731     *DataBufferSize = Size > *DataBufferSize * 2 ? Size : *DataBufferSize * 2;
732     *Data           = AllocatePool (*DataBufferSize);
733     if (*Data == NULL) {
734       return EFI_OUT_OF_RESOURCES;
735     }
736   }
737   BufferSize = Size;
738   Status     = LibReadFile (FileHandle, &BufferSize, *Data);
739   if (EFI_ERROR (Status) || (BufferSize != Size)) {
740     return EFI_ABORTED;
741   }
742   
743   *VariableNameSize = NameSize;
744   *DataSize         = Size;
745   return EFI_SUCCESS;
746 }
747
748 EFI_STATUS
749 SetFileVariable (
750   IN EFI_FILE_HANDLE FileHandle,
751   IN UINTN           VariableNameSize,
752   IN CHAR16          *VariableName,
753   IN EFI_GUID        *VendorGuid,
754   IN UINT32          Attributes,
755   IN UINTN           DataSize,
756   IN VOID            *Data  
757   )
758 {
759   EFI_STATUS  Status;
760   UINTN       BufferSize;
761
762   BufferSize = sizeof (UINT32);
763   Status = LibWriteFile (FileHandle, &BufferSize, &VariableNameSize);
764   if (EFI_ERROR (Status)) {
765     return Status;
766   }
767   
768   BufferSize = VariableNameSize;
769   Status = LibWriteFile (FileHandle, &BufferSize, VariableName);
770   if (EFI_ERROR (Status)) {
771     return Status;
772   }
773
774   BufferSize = sizeof (EFI_GUID);
775   Status = LibWriteFile (FileHandle, &BufferSize, VendorGuid);
776   if (EFI_ERROR (Status)) {
777     return Status;
778   }
779
780   BufferSize = sizeof (UINT32);
781   Status = LibWriteFile (FileHandle, &BufferSize, &Attributes);
782   if (EFI_ERROR (Status)) {
783     return Status;
784   }
785
786   BufferSize = sizeof (UINT32);
787   Status = LibWriteFile (FileHandle, &BufferSize, &DataSize);
788   if (EFI_ERROR (Status)) {
789     return Status;
790   }
791
792   BufferSize = DataSize;
793   Status = LibWriteFile (FileHandle, &BufferSize, Data);
794
795   return Status;
796 }
797
798 EFI_STATUS
799 InitializeDumpStoreGetLineHelp (
800   OUT CHAR16                **Str
801   )
802 /*++
803
804 Routine Description:
805
806   Get this command's line help
807
808 Arguments:
809
810   Str - The line help
811
812 Returns:
813
814   EFI_SUCCESS   - Success
815
816 --*/
817 {
818   return LibCmdGetStringByToken (STRING_ARRAY_NAME, &EfiDmpstoreGuid, STRING_TOKEN (STR_DMPSTORE_LINEHELP), Str);
819 }