DuetPkg/FSVariable/FileStorage.c

   1 /*++
   2
   3 Copyright (c) 2006 - 2007, 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     FileStorage.c
  15
  16 Abstract:
  17
  18     handles variable store/reads on file
  19
  20 Revision History
  21
  22 --*/
  23 #include "FSVariable.h"
  24
  25 VOID             *mSFSRegistration;
  26
  27 //
  28 // Prototypes
  29 //
  30
  31 VOID
  32 EFIAPI
  33 OnVirtualAddressChangeFs (
  34   IN EFI_EVENT            Event,
  35   IN VOID                 *Context
  36   );
  37
  38 EFI_STATUS
  39 EFIAPI
  40 FileEraseStore(
  41   IN VARIABLE_STORAGE     *This
  42   );
  43
  44 EFI_STATUS
  45 EFIAPI
  46 FileWriteStore (
  47   IN VARIABLE_STORAGE     *This,
  48   IN UINTN                Offset,
  49   IN UINTN                BufferSize,
  50   IN VOID                 *Buffer
  51   );
  52
  53 EFI_STATUS
  54 OpenStore (
  55   IN  EFI_DEVICE_PATH_PROTOCOL  *Device,
  56   IN  CHAR16                    *FilePathName,
  57   IN  UINT64                    OpenMode,
  58   OUT EFI_FILE                  **File
  59   );
  60
  61 //
  62 // Implementation below:
  63 //
  64 VOID
  65 FileClose (
  66   IN  EFI_FILE                   *File
  67   )
  68 {
  69   EFI_STATUS Status;
  70
  71   Status = File->Flush (File);
  72   ASSERT_EFI_ERROR (Status);
  73
  74   Status = File->Close (File);
  75   ASSERT_EFI_ERROR (Status);
  76 }
  77
  78 EFI_STATUS
  79 CheckStore (
  80   IN  EFI_HANDLE                 SimpleFileSystemHandle,
  81   IN  UINT32                     VolumeId,
  82   OUT EFI_DEVICE_PATH_PROTOCOL   **Device
  83   )
  84 {
  85 #define BLOCK_SIZE              0x200
  86 #define FAT16_VOLUME_ID_OFFSET  39
  87 #define FAT32_VOLUME_ID_OFFSET  67
  88   EFI_STATUS                      Status;
  89   EFI_BLOCK_IO_PROTOCOL           *BlkIo;
  90   UINT8                           BootSector[BLOCK_SIZE];
  91
  92   *Device = NULL;
  93   Status  = gBS->HandleProtocol (
  94                    SimpleFileSystemHandle,
  95                    &gEfiBlockIoProtocolGuid, // BlockIo should be supported if it supports SimpleFileSystem
  96                    (VOID*)&BlkIo
  97                    );
  98
  99   if (EFI_ERROR (Status)) {
 100     goto ErrHandle;
 101   }
 102   if (!BlkIo->Media->MediaPresent) {
 103     DEBUG ((EFI_D_ERROR, "FileStorage: Media not present!\n"));
 104     Status = EFI_NO_MEDIA;
 105     goto ErrHandle;
 106   }
 107   if (BlkIo->Media->ReadOnly) {
 108     DEBUG ((EFI_D_ERROR, "FileStorage: Media is read-only!\n"));
 109     Status = EFI_ACCESS_DENIED;
 110     goto ErrHandle;
 111   }
 112
 113   Status = BlkIo->ReadBlocks(
 114                     BlkIo,
 115                     BlkIo->Media->MediaId,
 116                     0,
 117                     BLOCK_SIZE,
 118                     BootSector
 119                     );
 120   ASSERT_EFI_ERROR (Status);
 121   if ((*(UINT32 *) &BootSector[FAT16_VOLUME_ID_OFFSET] != VolumeId) &&
 122       (*(UINT32 *) &BootSector[FAT32_VOLUME_ID_OFFSET] != VolumeId)
 123       ) {
 124     Status = EFI_NOT_FOUND;
 125     goto ErrHandle;
 126   }
 127
 128   *Device = DuplicateDevicePath (DevicePathFromHandle (SimpleFileSystemHandle));
 129   ASSERT (*Device != NULL);
 130
 131 ErrHandle:
 132   return Status;
 133 }
 134
 135 EFI_STATUS
 136 CheckStoreExists (
 137   IN  EFI_DEVICE_PATH_PROTOCOL   *Device
 138   )
 139 {
 140   EFI_HANDLE                        Handle;
 141   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL   *Volume;
 142   EFI_STATUS                        Status;
 143
 144   Status = gBS->LocateDevicePath (
 145                   &gEfiSimpleFileSystemProtocolGuid,
 146                   &Device,
 147                   &Handle
 148                   );
 149
 150   if (EFI_ERROR (Status)) {
 151     return Status;
 152   }
 153
 154   Status = gBS->HandleProtocol (
 155                   Handle,
 156                   &gEfiSimpleFileSystemProtocolGuid,
 157                   (VOID **) &Volume
 158                   );
 159   if (EFI_ERROR (Status)) {
 160     return Status;
 161   }
 162
 163   return EFI_SUCCESS;
 164 }
 165
 166 // this routine is still running in BS period, no limitation
 167 // call FileInitStorage(), which load variable content file to memory
 168 // read the store_header, init store_header if it has not been inited (read sth. about format/heathy)
 169 // reclaim space using scratch memory
 170
 171 VOID
 172 EFIAPI
 173 OnSimpleFileSystemInstall (
 174   IN EFI_EVENT        Event,
 175   IN VOID             *Context
 176   )
 177 {
 178   EFI_STATUS                Status;
 179   UINTN                     HandleSize;
 180   EFI_HANDLE                Handle;
 181   EFI_DEVICE_PATH_PROTOCOL  *Device;
 182   VS_DEV                    *Dev;
 183   EFI_FILE                  *File;
 184   UINTN                     NumBytes;
 185
 186   Dev = (VS_DEV *) Context;
 187
 188   if (VAR_FILE_DEVICEPATH (Dev) != NULL &&
 189       !EFI_ERROR (CheckStoreExists (VAR_FILE_DEVICEPATH (Dev)))
 190      ) {
 191     DEBUG ((EFI_D_ERROR, "FileStorage: Already mapped!\n"));
 192     return ;
 193   }
 194
 195   while (TRUE) {
 196     HandleSize = sizeof (EFI_HANDLE);
 197     Status = gBS->LocateHandle (
 198                     ByRegisterNotify,
 199                     NULL,
 200                     mSFSRegistration,
 201                     &HandleSize,
 202                     &Handle
 203                     );
 204     if (EFI_ERROR (Status)) {
 205       return ;
 206     }
 207
 208     Status = CheckStore (Handle, VAR_FILE_VOLUMEID (Dev), &Device);
 209     if (!EFI_ERROR (Status)) {
 210       break;
 211     }
 212   }
 213
 214   VAR_FILE_DEVICEPATH (Dev) = Device;
 215   Status = OpenStore (
 216              VAR_FILE_DEVICEPATH (Dev),
 217              VAR_FILE_FILEPATH (Dev),
 218              EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ | EFI_FILE_MODE_CREATE,
 219              &File
 220              );
 221   ASSERT_EFI_ERROR (Status);
 222
 223   NumBytes = Dev->Size;
 224   Status = File->Write (File, &NumBytes, VAR_DATA_PTR (Dev));
 225   ASSERT_EFI_ERROR (Status);
 226   // KEN: bugbug here if closing file, volume handle will be free,
 227   // and system will be hang when accessing volume handle in future.
 228   //FileClose (File);
 229   DEBUG ((EFI_D_ERROR, "FileStorage: Mapped to file!\n"));
 230 }
 231
 232 EFI_STATUS
 233 FileStorageConstructor (
 234   OUT VARIABLE_STORAGE      **VarStore,
 235   OUT EFI_EVENT_NOTIFY      *GoVirtualEvent,
 236   IN  EFI_PHYSICAL_ADDRESS  NvStorageBase,
 237   IN  UINTN                 Size,
 238   IN  UINT32                VolumeId,
 239   IN  CHAR16                *FilePath
 240   )
 241 {
 242   VS_DEV                    *Dev;
 243   EFI_STATUS                Status;
 244   EFI_EVENT                 Event;
 245
 246   Status = gBS->AllocatePool (EfiRuntimeServicesData, sizeof(VS_DEV), (VOID **) &Dev);
 247   ASSERT_EFI_ERROR (Status);
 248   ZeroMem (Dev, sizeof(VS_DEV));
 249
 250   Dev->Signature          = VARIABLE_STORE_SIGNATURE;
 251   Dev->Size               = Size;
 252   VAR_DATA_PTR (Dev)      = (UINT8 *) (UINTN) NvStorageBase;
 253   VAR_FILE_VOLUMEID (Dev) = VolumeId;
 254   StrCpy (VAR_FILE_FILEPATH (Dev), FilePath);
 255   Dev->VarStore.Erase     = FileEraseStore;
 256   Dev->VarStore.Write     = FileWriteStore;
 257
 258   DEBUG ((EFI_D_ERROR, "FileStorageConstructor(0x%0x:0x%0x): added!\n", NvStorageBase, Size));
 259
 260   // add notify on SFS's installation.
 261
 262   Status = gBS->CreateEvent (
 263                   EVT_NOTIFY_SIGNAL,
 264                   TPL_CALLBACK,
 265                   OnSimpleFileSystemInstall,
 266                   Dev,
 267                   &Event
 268                   );
 269   ASSERT_EFI_ERROR (Status);
 270
 271   Status = gBS->RegisterProtocolNotify (
 272                   &gEfiSimpleFileSystemProtocolGuid,
 273                   Event,
 274                   &mSFSRegistration
 275                   );
 276   ASSERT_EFI_ERROR (Status);
 277
 278   *VarStore       = &Dev->VarStore;
 279   *GoVirtualEvent = OnVirtualAddressChangeFs;
 280   return EFI_SUCCESS;
 281 }
 282
 283 EFI_STATUS
 284 EFIAPI
 285 FileEraseStore(
 286   IN VARIABLE_STORAGE   *This
 287   )
 288 {
 289   EFI_STATUS              Status;
 290   VS_DEV                  *Dev;
 291   EFI_FILE                *File;
 292   UINTN                   NumBytes;
 293
 294   Status = EFI_SUCCESS;
 295   Dev    = DEV_FROM_THIS(This);
 296
 297   SetMem (VAR_DATA_PTR (Dev), Dev->Size, VAR_DEFAULT_VALUE);
 298
 299   if (!EfiAtRuntime () && VAR_FILE_DEVICEPATH (Dev) != NULL) {
 300     Status = OpenStore (
 301                VAR_FILE_DEVICEPATH (Dev),
 302                VAR_FILE_FILEPATH (Dev),
 303                EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ,
 304                &File
 305                );
 306     ASSERT_EFI_ERROR (Status);
 307     NumBytes = Dev->Size;
 308     Status = File->Write (File, &NumBytes, VAR_DATA_PTR (Dev));
 309     ASSERT_EFI_ERROR (Status);
 310     FileClose (File);
 311   }
 312
 313   return Status;
 314 }
 315
 316 EFI_STATUS
 317 EFIAPI
 318 FileWriteStore (
 319   IN VARIABLE_STORAGE     *This,
 320   IN UINTN                Offset,
 321   IN UINTN                BufferSize,
 322   IN VOID                 *Buffer
 323   )
 324 {
 325   EFI_STATUS              Status;
 326   VS_DEV                  *Dev;
 327   EFI_FILE                *File;
 328
 329   Status = EFI_SUCCESS;
 330   Dev    = DEV_FROM_THIS(This);
 331
 332   ASSERT (Buffer != NULL);
 333   ASSERT (Offset + BufferSize <= Dev->Size);
 334
 335   CopyMem (VAR_DATA_PTR (Dev) + Offset, Buffer, BufferSize);
 336
 337   if (!EfiAtRuntime () && VAR_FILE_DEVICEPATH (Dev) != NULL) {
 338     Status = OpenStore (
 339                VAR_FILE_DEVICEPATH (Dev),
 340                VAR_FILE_FILEPATH (Dev),
 341                EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ,
 342                &File
 343                );
 344     Status = File->SetPosition (File, Offset);
 345     ASSERT_EFI_ERROR (Status);
 346     Status = File->Write (File, &BufferSize, Buffer);
 347     ASSERT_EFI_ERROR (Status);
 348     FileClose (File);
 349   }
 350   return Status;
 351 }
 352
 353 VOID
 354 EFIAPI
 355 OnVirtualAddressChangeFs (
 356   IN EFI_EVENT            Event,
 357   IN VOID                 *Context
 358   )
 359 {
 360   VS_DEV  *Dev;
 361
 362   Dev = DEV_FROM_THIS (Context);
 363
 364   EfiConvertPointer (0, (VOID **) &VAR_DATA_PTR (Dev));
 365   EfiConvertPointer (0, (VOID **) &Dev->VarStore.Erase);
 366   EfiConvertPointer (0, (VOID **) &Dev->VarStore.Write);
 367 }
 368
 369 EFI_STATUS
 370 OpenStore (
 371   IN  EFI_DEVICE_PATH_PROTOCOL  *Device,
 372   IN  CHAR16                    *FilePathName,
 373   IN  UINT64                    OpenMode,
 374   OUT EFI_FILE                  **File
 375   )
 376 {
 377   EFI_HANDLE                        Handle;
 378   EFI_FILE_HANDLE                   Root;
 379   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL   *Volume;
 380   EFI_STATUS                        Status;
 381
 382   *File = NULL;
 383
 384   Status = gBS->LocateDevicePath (
 385                   &gEfiSimpleFileSystemProtocolGuid,
 386                   &Device,
 387                   &Handle
 388                   );
 389
 390   if (EFI_ERROR (Status)) {
 391     return Status;
 392   }
 393
 394   Status = gBS->HandleProtocol (
 395                   Handle,
 396                   &gEfiSimpleFileSystemProtocolGuid,
 397                   (VOID **) &Volume
 398                   );
 399   if (EFI_ERROR (Status)) {
 400     return Status;
 401   }
 402
 403   //
 404   // Open the root directory of the volume
 405   //
 406   Root = NULL;
 407   Status = Volume->OpenVolume (
 408                      Volume,
 409                      &Root
 410                      );
 411   ASSERT_EFI_ERROR (Status);
 412   ASSERT (Root != NULL);
 413
 414   //
 415   // Open file
 416   //
 417   Status = Root->Open (
 418                    Root,
 419                    File,
 420                    FilePathName,
 421                    OpenMode,
 422                    0
 423                    );
 424   if (EFI_ERROR (Status)) {
 425     *File = NULL;
 426   }
 427
 428   //
 429   // Close the Root directory
 430   //
 431   Root->Close (Root);
 432   return Status;
 433 }