DuetPkg/FSVariable/FileStorage.c

   1 /*++
   2
   3 Copyright (c) 2006 - 2010, 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_PROTOCOL         **File
  59   );
  60
  61 //
  62 // Implementation below:
  63 //
  64 VOID
  65 FileClose (
  66   IN  EFI_FILE_PROTOCOL          *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_PROTOCOL         *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   FileClose (File);
 227   DEBUG ((EFI_D_ERROR, "FileStorage: Mapped to file!\n"));
 228 }
 229
 230 EFI_STATUS
 231 FileStorageConstructor (
 232   OUT VARIABLE_STORAGE      **VarStore,
 233   OUT EFI_EVENT_NOTIFY      *GoVirtualEvent,
 234   IN  EFI_PHYSICAL_ADDRESS  NvStorageBase,
 235   IN  UINTN                 Size,
 236   IN  UINT32                VolumeId,
 237   IN  CHAR16                *FilePath
 238   )
 239 {
 240   VS_DEV                    *Dev;
 241   EFI_STATUS                Status;
 242   EFI_EVENT                 Event;
 243
 244   Status = gBS->AllocatePool (EfiRuntimeServicesData, sizeof(VS_DEV), (VOID **) &Dev);
 245   ASSERT_EFI_ERROR (Status);
 246   ZeroMem (Dev, sizeof(VS_DEV));
 247
 248   Dev->Signature          = VS_DEV_SIGNATURE;
 249   Dev->Size               = Size;
 250   VAR_DATA_PTR (Dev)      = (UINT8 *) (UINTN) NvStorageBase;
 251   VAR_FILE_VOLUMEID (Dev) = VolumeId;
 252   StrCpy (VAR_FILE_FILEPATH (Dev), FilePath);
 253   Dev->VarStore.Erase     = FileEraseStore;
 254   Dev->VarStore.Write     = FileWriteStore;
 255
 256   DEBUG ((EFI_D_ERROR, "FileStorageConstructor(0x%0x:0x%0x): added!\n", NvStorageBase, Size));
 257
 258   // add notify on SFS's installation.
 259
 260   Status = gBS->CreateEvent (
 261                   EVT_NOTIFY_SIGNAL,
 262                   TPL_CALLBACK,
 263                   OnSimpleFileSystemInstall,
 264                   Dev,
 265                   &Event
 266                   );
 267   ASSERT_EFI_ERROR (Status);
 268
 269   Status = gBS->RegisterProtocolNotify (
 270                   &gEfiSimpleFileSystemProtocolGuid,
 271                   Event,
 272                   &mSFSRegistration
 273                   );
 274   ASSERT_EFI_ERROR (Status);
 275
 276   *VarStore       = &Dev->VarStore;
 277   *GoVirtualEvent = OnVirtualAddressChangeFs;
 278   return EFI_SUCCESS;
 279 }
 280
 281 EFI_STATUS
 282 EFIAPI
 283 FileEraseStore(
 284   IN VARIABLE_STORAGE   *This
 285   )
 286 {
 287   EFI_STATUS              Status;
 288   VS_DEV                  *Dev;
 289   EFI_FILE_PROTOCOL       *File;
 290   UINTN                   NumBytes;
 291
 292   Status = EFI_SUCCESS;
 293   Dev    = DEV_FROM_THIS(This);
 294
 295   SetMem (VAR_DATA_PTR (Dev), Dev->Size, VAR_DEFAULT_VALUE);
 296
 297   if (!EfiAtRuntime () && VAR_FILE_DEVICEPATH (Dev) != NULL) {
 298     Status = OpenStore (
 299                VAR_FILE_DEVICEPATH (Dev),
 300                VAR_FILE_FILEPATH (Dev),
 301                EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ,
 302                &File
 303                );
 304     ASSERT_EFI_ERROR (Status);
 305     NumBytes = Dev->Size;
 306     Status = File->Write (File, &NumBytes, VAR_DATA_PTR (Dev));
 307     ASSERT_EFI_ERROR (Status);
 308     FileClose (File);
 309   }
 310
 311   return Status;
 312 }
 313
 314 EFI_STATUS
 315 EFIAPI
 316 FileWriteStore (
 317   IN VARIABLE_STORAGE     *This,
 318   IN UINTN                Offset,
 319   IN UINTN                BufferSize,
 320   IN VOID                 *Buffer
 321   )
 322 {
 323   EFI_STATUS              Status;
 324   VS_DEV                  *Dev;
 325   EFI_FILE_PROTOCOL       *File;
 326
 327   Status = EFI_SUCCESS;
 328   Dev    = DEV_FROM_THIS(This);
 329
 330   ASSERT (Buffer != NULL);
 331   ASSERT (Offset + BufferSize <= Dev->Size);
 332
 333   CopyMem (VAR_DATA_PTR (Dev) + Offset, Buffer, BufferSize);
 334
 335   if (!EfiAtRuntime () && VAR_FILE_DEVICEPATH (Dev) != NULL) {
 336     Status = OpenStore (
 337                VAR_FILE_DEVICEPATH (Dev),
 338                VAR_FILE_FILEPATH (Dev),
 339                EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ,
 340                &File
 341                );
 342     Status = File->SetPosition (File, Offset);
 343     ASSERT_EFI_ERROR (Status);
 344     Status = File->Write (File, &BufferSize, Buffer);
 345     ASSERT_EFI_ERROR (Status);
 346     FileClose (File);
 347   }
 348   return Status;
 349 }
 350
 351 VOID
 352 EFIAPI
 353 OnVirtualAddressChangeFs (
 354   IN EFI_EVENT            Event,
 355   IN VOID                 *Context
 356   )
 357 {
 358   VS_DEV  *Dev;
 359
 360   Dev = DEV_FROM_THIS (Context);
 361
 362   EfiConvertPointer (0, (VOID **) &VAR_DATA_PTR (Dev));
 363   EfiConvertPointer (0, (VOID **) &Dev->VarStore.Erase);
 364   EfiConvertPointer (0, (VOID **) &Dev->VarStore.Write);
 365 }
 366
 367 EFI_STATUS
 368 OpenStore (
 369   IN  EFI_DEVICE_PATH_PROTOCOL  *Device,
 370   IN  CHAR16                    *FilePathName,
 371   IN  UINT64                    OpenMode,
 372   OUT EFI_FILE_PROTOCOL         **File
 373   )
 374 {
 375   EFI_HANDLE                        Handle;
 376   EFI_FILE_HANDLE                   Root;
 377   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL   *Volume;
 378   EFI_STATUS                        Status;
 379
 380   *File = NULL;
 381
 382   Status = gBS->LocateDevicePath (
 383                   &gEfiSimpleFileSystemProtocolGuid,
 384                   &Device,
 385                   &Handle
 386                   );
 387
 388   if (EFI_ERROR (Status)) {
 389     return Status;
 390   }
 391
 392   Status = gBS->HandleProtocol (
 393                   Handle,
 394                   &gEfiSimpleFileSystemProtocolGuid,
 395                   (VOID **) &Volume
 396                   );
 397   if (EFI_ERROR (Status)) {
 398     return Status;
 399   }
 400
 401   //
 402   // Open the root directory of the volume
 403   //
 404   Root = NULL;
 405   Status = Volume->OpenVolume (
 406                      Volume,
 407                      &Root
 408                      );
 409   ASSERT_EFI_ERROR (Status);
 410   ASSERT (Root != NULL);
 411
 412   //
 413   // Open file
 414   //
 415   Status = Root->Open (
 416                    Root,
 417                    File,
 418                    FilePathName,
 419                    OpenMode,
 420                    0
 421                    );
 422   if (EFI_ERROR (Status)) {
 423     *File = NULL;
 424   }
 425
 426   //
 427   // Close the Root directory
 428   //
 429   Root->Close (Root);
 430   return Status;
 431 }