ShellPkg/Library/UefiShellLevel2CommandsLib/Load.c

   1 /** @file
   2   Main file for attrib shell level 2 function.
   3
   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
   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 "UefiShellLevel2CommandsLib.h"
  16
  17 // This function was from from the BdsLib implementation in
  18 // IntelFrameworkModulePkg\Library\GenericBdsLib\BdsConnect.c
  19 // function name: BdsLibConnectAllEfi
  20 /**
  21   This function will connect all current system handles recursively. The
  22   connection will finish until every handle's child handle created if it have.
  23
  24   @retval EFI_SUCCESS           All handles and it's child handle have been
  25                                 connected
  26   @retval EFI_STATUS            Return the status of gBS->LocateHandleBuffer().
  27
  28 **/
  29 EFI_STATUS
  30 EFIAPI
  31 ConnectAllEfi (
  32   VOID
  33   )
  34 {
  35   EFI_STATUS  Status;
  36   UINTN       HandleCount;
  37   EFI_HANDLE  *HandleBuffer;
  38   UINTN       Index;
  39
  40   Status = gBS->LocateHandleBuffer (
  41                   AllHandles,
  42                   NULL,
  43                   NULL,
  44                   &HandleCount,
  45                   &HandleBuffer
  46                  );
  47   if (EFI_ERROR (Status)) {
  48     return Status;
  49   }
  50
  51   for (Index = 0; Index < HandleCount; Index++) {
  52     Status = gBS->ConnectController (HandleBuffer[Index], NULL, NULL, TRUE);
  53   }
  54
  55   if (HandleBuffer != NULL) {
  56     FreePool (HandleBuffer);
  57   }
  58
  59   return EFI_SUCCESS;
  60 }
  61
  62 /**
  63   function to load a .EFI driver into memory and possible connect the driver.
  64
  65   if FileName is NULL then ASSERT.
  66
  67   @param[in] FileName           FileName of the driver to load
  68   @param[in] Connect            Whether to connect or not
  69
  70   @retval EFI_SUCCESS           the driver was loaded and if Connect was
  71                                 true then connect was attempted. Connection may
  72                                 have failed.
  73   @retval EFI_OUT_OF_RESOURCES  there was insufficient memory
  74 **/
  75 EFI_STATUS
  76 EFIAPI
  77 LoadDriver(
  78   IN CONST CHAR16   *FileName,
  79   IN CONST BOOLEAN  Connect
  80   )
  81 {
  82   EFI_HANDLE                    LoadedDriverHandle;
  83   EFI_STATUS                    Status;
  84   EFI_DEVICE_PATH_PROTOCOL      *Node;
  85   EFI_DEVICE_PATH_PROTOCOL      *FilePath;
  86   EFI_LOADED_IMAGE_PROTOCOL     *LoadedDriverImage;
  87
  88   LoadedDriverImage   = NULL;
  89   FilePath            = NULL;
  90   Node                = NULL;
  91   LoadedDriverHandle  = NULL;
  92   Status              = EFI_SUCCESS;
  93
  94   ASSERT (FileName != NULL);
  95
  96   //
  97   // Fix local copies of the protocol pointers
  98   //
  99   Status = CommandInit();
 100   ASSERT_EFI_ERROR(Status);
 101
 102   //
 103   // Convert to DEVICE_PATH
 104   //
 105   FilePath = gEfiShellProtocol->GetDevicePathFromFilePath(FileName);
 106
 107   if (FilePath == NULL) {
 108     ASSERT(FALSE);
 109     return (EFI_INVALID_PARAMETER);
 110   }
 111
 112   //
 113   // Use LoadImage to get it into memory
 114   //
 115   Status = gBS->LoadImage(
 116     FALSE,
 117     gImageHandle,
 118     FilePath,
 119     NULL,
 120     0,
 121     &LoadedDriverHandle);
 122
 123   if (EFI_ERROR(Status)) {
 124     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_LOAD_NOT_IMAGE), gShellLevel2HiiHandle, FileName, Status);
 125   } else {
 126     //
 127     // Make sure it is a driver image
 128     //
 129     Status = gBS->HandleProtocol (LoadedDriverHandle, &gEfiLoadedImageProtocolGuid, (VOID *) &LoadedDriverImage);
 130
 131     ASSERT (LoadedDriverImage != NULL);
 132
 133     if ( EFI_ERROR(Status)
 134       || ( LoadedDriverImage->ImageCodeType != EfiBootServicesCode
 135         && LoadedDriverImage->ImageCodeType != EfiRuntimeServicesCode)
 136      ){
 137       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_LOAD_NOT_DRIVER), gShellLevel2HiiHandle, FileName);
 138
 139       //
 140       // Exit and unload the non-driver image
 141       //
 142       gBS->Exit(LoadedDriverHandle, EFI_INVALID_PARAMETER, 0, NULL);
 143       Status = EFI_INVALID_PARAMETER;
 144     }
 145   }
 146
 147   if (!EFI_ERROR(Status)) {
 148     //
 149     // Start the image
 150     //
 151     Status = gBS->StartImage(LoadedDriverHandle, NULL, NULL);
 152     if (EFI_ERROR(Status)) {
 153       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_LOAD_ERROR), gShellLevel2HiiHandle, FileName, Status);
 154     } else {
 155       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_LOAD_LOADED), gShellLevel2HiiHandle, FileName, LoadedDriverImage->ImageBase, Status);
 156     }
 157   }
 158
 159   if (!EFI_ERROR(Status) && Connect) {
 160     //
 161     // Connect it...
 162     //
 163     Status = ConnectAllEfi();
 164   }
 165
 166   //
 167   // clean up memory...
 168   //
 169   if (FilePath != NULL) {
 170     FreePool(FilePath);
 171   }
 172
 173   return (Status);
 174 }
 175
 176 STATIC CONST SHELL_PARAM_ITEM LoadParamList[] = {
 177   {L"-nc", TypeFlag},
 178   {NULL, TypeMax}
 179   };
 180
 181 /**
 182   Function for 'load' command.
 183
 184   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
 185   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
 186 **/
 187 SHELL_STATUS
 188 EFIAPI
 189 ShellCommandRunLoad (
 190   IN EFI_HANDLE        ImageHandle,
 191   IN EFI_SYSTEM_TABLE  *SystemTable
 192   )
 193 {
 194   EFI_STATUS          Status;
 195   LIST_ENTRY          *Package;
 196   CHAR16              *ProblemParam;
 197   SHELL_STATUS        ShellStatus;
 198   UINTN               ParamCount;
 199   EFI_SHELL_FILE_INFO *ListHead;
 200   EFI_SHELL_FILE_INFO *Node;
 201
 202   ListHead            = NULL;
 203   ProblemParam        = NULL;
 204   ShellStatus         = SHELL_SUCCESS;
 205
 206   //
 207   // initialize the shell lib (we must be in non-auto-init...)
 208   //
 209   Status = ShellInitialize();
 210   ASSERT_EFI_ERROR(Status);
 211
 212   //
 213   // parse the command line
 214   //
 215   Status = ShellCommandLineParse (LoadParamList, &Package, &ProblemParam, TRUE);
 216   if (EFI_ERROR(Status)) {
 217     if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
 218       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel2HiiHandle, ProblemParam);
 219       FreePool(ProblemParam);
 220       ShellStatus = SHELL_INVALID_PARAMETER;
 221     } else {
 222       ASSERT(FALSE);
 223     }
 224   } else {
 225     //
 226     // check for "-?"
 227     //
 228     if (ShellCommandLineGetFlag(Package, L"-?")) {
 229       ASSERT(FALSE);
 230     } else if (ShellCommandLineGetRawValue(Package, 1) == NULL) {
 231       //
 232       // we didnt get a single file to load parameter
 233       //
 234       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellLevel2HiiHandle);
 235       ShellStatus = SHELL_INVALID_PARAMETER;
 236     } else {
 237       for ( ParamCount = 1
 238           ; ShellCommandLineGetRawValue(Package, ParamCount) != NULL
 239           ; ParamCount++
 240          ){
 241         Status = ShellOpenFileMetaArg((CHAR16*)ShellCommandLineGetRawValue(Package, ParamCount), EFI_FILE_MODE_READ, &ListHead);
 242         if (!EFI_ERROR(Status)) {
 243           for ( Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&ListHead->Link)
 244               ; !IsNull(&ListHead->Link, &Node->Link)
 245               ; Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&ListHead->Link, &Node->Link)
 246              ){
 247             //
 248             // once we have an error preserve that value, but finish the loop.
 249             //
 250             if (EFI_ERROR(Status)) {
 251               LoadDriver(Node->FullName, (BOOLEAN)(ShellCommandLineGetFlag(Package, L"-nc")==FALSE));
 252             } else {
 253               Status = LoadDriver(Node->FullName, (BOOLEAN)(ShellCommandLineGetFlag(Package, L"-nc")==FALSE));
 254             }
 255           } // for loop for multi-open
 256           if (EFI_ERROR(Status)) {
 257             ShellCloseFileMetaArg(&ListHead);
 258           } else {
 259             Status = ShellCloseFileMetaArg(&ListHead);;
 260           }
 261         } else {
 262           //
 263           // no files found.
 264           //
 265           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_NF), gShellLevel2HiiHandle, (CHAR16*)ShellCommandLineGetRawValue(Package, ParamCount));
 266           ShellStatus = SHELL_NOT_FOUND;
 267         }
 268       } // for loop for params
 269     }
 270
 271     //
 272     // free the command line package
 273     //
 274     ShellCommandLineFreeVarList (Package);
 275   }
 276
 277   if (EFI_ERROR(Status) && ShellStatus == SHELL_SUCCESS) {
 278     ShellStatus = SHELL_DEVICE_ERROR;
 279   }
 280
 281   return (ShellStatus);
 282 }