ArmPlatformPkg/FileSystem/BootMonFs/BootMonFsDir.c

   1 /** @file
   2 *
   3 *  Copyright (c) 2012-2014, ARM Limited. All rights reserved.
   4 *
   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 "BootMonFsInternal.h"
  16
  17 EFIAPI
  18 EFI_STATUS
  19 OpenBootMonFsOpenVolume (
  20   IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
  21   OUT EFI_FILE_PROTOCOL              **Root
  22   )
  23 {
  24   BOOTMON_FS_INSTANCE *Instance;
  25
  26   Instance = BOOTMON_FS_FROM_FS_THIS (This);
  27   if (Instance == NULL) {
  28     return EFI_DEVICE_ERROR;
  29   }
  30
  31   *Root = &Instance->RootFile->File;
  32
  33   return EFI_SUCCESS;
  34 }
  35
  36 UINT32
  37 BootMonFsGetImageLength (
  38   IN BOOTMON_FS_FILE      *File
  39   )
  40 {
  41   UINT32                   Index;
  42   UINT32                   FileSize;
  43   LIST_ENTRY              *RegionToFlushLink;
  44   BOOTMON_FS_FILE_REGION  *Region;
  45
  46   FileSize = 0;
  47
  48   // Look at all Flash areas to determine file size
  49   for (Index = 0; Index < HW_IMAGE_DESCRIPTION_REGION_MAX; Index++) {
  50     FileSize += File->HwDescription.Region[Index].Size;
  51   }
  52
  53   // Add the regions that have not been flushed yet
  54   for (RegionToFlushLink = GetFirstNode (&File->RegionToFlushLink);
  55        !IsNull (&File->RegionToFlushLink, RegionToFlushLink);
  56        RegionToFlushLink = GetNextNode (&File->RegionToFlushLink, RegionToFlushLink)
  57        )
  58   {
  59     Region = (BOOTMON_FS_FILE_REGION*)RegionToFlushLink;
  60     if (Region->Offset + Region->Size > FileSize) {
  61       FileSize += Region->Offset + Region->Size;
  62     }
  63   }
  64
  65   return FileSize;
  66 }
  67
  68 UINTN
  69 BootMonFsGetPhysicalSize (
  70   IN BOOTMON_FS_FILE* File
  71   )
  72 {
  73   // Return 0 for files that haven't yet been flushed to media
  74   if (File->HwDescription.RegionCount == 0) {
  75     return 0;
  76   }
  77
  78   return ((File->HwDescription.BlockEnd - File->HwDescription.BlockStart) + 1 )
  79           * File->Instance->Media->BlockSize;
  80 }
  81
  82 EFIAPI
  83 EFI_STATUS
  84 BootMonFsSetDirPosition (
  85   IN EFI_FILE_PROTOCOL  *This,
  86   IN UINT64             Position
  87   )
  88 {
  89   BOOTMON_FS_FILE       *File;
  90
  91   File = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
  92   if (File == NULL) {
  93     return EFI_INVALID_PARAMETER;
  94   }
  95
  96   // UEFI Spec section 12.5:
  97   // "The seek request for nonzero is not valid on open directories."
  98   if (Position != 0) {
  99     return EFI_UNSUPPORTED;
 100   }
 101   File->Position = Position;
 102
 103   return EFI_SUCCESS;
 104 }
 105
 106 EFI_STATUS
 107 BootMonFsOpenDirectory (
 108   OUT EFI_FILE_PROTOCOL **NewHandle,
 109   IN CHAR16             *FileName,
 110   IN BOOTMON_FS_INSTANCE *Volume
 111   )
 112 {
 113   ASSERT(0);
 114
 115   return EFI_UNSUPPORTED;
 116 }
 117 EFI_STATUS
 118 GetFileSystemVolumeLabelInfo (
 119   IN BOOTMON_FS_INSTANCE *Instance,
 120   IN OUT UINTN          *BufferSize,
 121   OUT VOID              *Buffer
 122   )
 123 {
 124   UINTN                         Size;
 125   EFI_FILE_SYSTEM_VOLUME_LABEL *Label;
 126   EFI_STATUS                    Status;
 127
 128   Label = Buffer;
 129
 130   // Value returned by StrSize includes null terminator.
 131   Size = SIZE_OF_EFI_FILE_SYSTEM_VOLUME_LABEL
 132          + StrSize (Instance->FsInfo.VolumeLabel);
 133
 134   if (*BufferSize >= Size) {
 135     CopyMem (&Label->VolumeLabel, &Instance->FsInfo.VolumeLabel, Size);
 136     Status = EFI_SUCCESS;
 137   } else {
 138     Status = EFI_BUFFER_TOO_SMALL;
 139   }
 140   *BufferSize = Size;
 141   return Status;
 142 }
 143
 144 // Helper function that calculates a rough "free space" by:
 145 // - Taking the media size
 146 // - Subtracting the sum of all file sizes
 147 // - Subtracting the block size times the number of files
 148 //    (To account for the blocks containing the HW_IMAGE_INFO
 149 STATIC
 150 UINT64
 151 ComputeFreeSpace (
 152   IN BOOTMON_FS_INSTANCE *Instance
 153   )
 154 {
 155   LIST_ENTRY   *FileLink;
 156   UINT64        FileSizeSum;
 157   UINT64        MediaSize;
 158   UINTN         NumFiles;
 159   EFI_BLOCK_IO_MEDIA *Media;
 160   BOOTMON_FS_FILE *File;
 161
 162   Media = Instance->BlockIo->Media;
 163   MediaSize = Media->BlockSize * (Media->LastBlock + 1);
 164
 165   NumFiles = 0;
 166   FileSizeSum = 0;
 167   for (FileLink = GetFirstNode (&Instance->RootFile->Link);
 168          !IsNull (&Instance->RootFile->Link, FileLink);
 169          FileLink = GetNextNode (&Instance->RootFile->Link, FileLink)
 170          )
 171   {
 172     File = BOOTMON_FS_FILE_FROM_LINK_THIS (FileLink);
 173     FileSizeSum += BootMonFsGetImageLength (File);
 174
 175     NumFiles++;
 176   }
 177
 178   return MediaSize - (FileSizeSum + (Media->BlockSize + NumFiles));
 179 }
 180
 181 EFI_STATUS
 182 GetFilesystemInfo (
 183   IN BOOTMON_FS_INSTANCE *Instance,
 184   IN OUT UINTN          *BufferSize,
 185   OUT VOID              *Buffer
 186   )
 187 {
 188   EFI_STATUS              Status;
 189
 190   if (*BufferSize >= Instance->FsInfo.Size) {
 191     Instance->FsInfo.FreeSpace = ComputeFreeSpace (Instance);
 192     CopyMem (Buffer, &Instance->FsInfo, Instance->FsInfo.Size);
 193     Status = EFI_SUCCESS;
 194   } else {
 195     Status = EFI_BUFFER_TOO_SMALL;
 196   }
 197
 198   *BufferSize = Instance->FsInfo.Size;
 199   return Status;
 200 }
 201
 202 EFI_STATUS
 203 GetFileInfo (
 204   IN BOOTMON_FS_INSTANCE *Instance,
 205   IN BOOTMON_FS_FILE     *File,
 206   IN OUT UINTN           *BufferSize,
 207   OUT VOID               *Buffer
 208   )
 209 {
 210   EFI_FILE_INFO   *Info;
 211   UINTN           ResultSize;
 212   UINTN           NameSize;
 213   UINTN           Index;
 214
 215   if (File == Instance->RootFile) {
 216     NameSize = 0;
 217     ResultSize = SIZE_OF_EFI_FILE_INFO + sizeof (CHAR16);
 218   } else {
 219     NameSize   = AsciiStrLen (File->HwDescription.Footer.Filename) + 1;
 220     ResultSize = SIZE_OF_EFI_FILE_INFO + (NameSize * sizeof (CHAR16));
 221   }
 222
 223   if (*BufferSize < ResultSize) {
 224     *BufferSize = ResultSize;
 225     return EFI_BUFFER_TOO_SMALL;
 226   }
 227
 228   Info = Buffer;
 229
 230   // Zero out the structure
 231   ZeroMem (Info, ResultSize);
 232
 233   // Fill in the structure
 234   Info->Size = ResultSize;
 235
 236   if (File == Instance->RootFile) {
 237     Info->Attribute    = EFI_FILE_READ_ONLY | EFI_FILE_DIRECTORY;
 238     Info->FileName[0]  = L'\0';
 239   } else {
 240     Info->FileSize     = BootMonFsGetImageLength (File);
 241     Info->PhysicalSize = BootMonFsGetPhysicalSize (File);
 242
 243     for (Index = 0; Index < NameSize; Index++) {
 244       Info->FileName[Index] = File->HwDescription.Footer.Filename[Index];
 245     }
 246   }
 247
 248   *BufferSize = ResultSize;
 249
 250   return EFI_SUCCESS;
 251 }
 252
 253 STATIC
 254 EFI_STATUS
 255 SetFileName (
 256   IN  BOOTMON_FS_FILE *File,
 257   IN  CHAR16          *FileNameUnicode
 258   )
 259 {
 260   CHAR8                 *FileNameAscii;
 261   UINT16                 SavedChar;
 262   UINTN                  FileNameSize;
 263   BOOTMON_FS_FILE       *SameFile;
 264   EFI_STATUS             Status;
 265
 266   // EFI Shell inserts '\' in front of the filename that must be stripped
 267   if (FileNameUnicode[0] == L'\\') {
 268     FileNameUnicode++;
 269   }
 270   //
 271   // Convert Unicode into Ascii
 272   //
 273   SavedChar = L'\0';
 274   FileNameSize = StrLen (FileNameUnicode) + 1;
 275   FileNameAscii = AllocatePool (FileNameSize * sizeof (CHAR8));
 276   if (FileNameAscii == NULL) {
 277     return EFI_OUT_OF_RESOURCES;
 278   }
 279   // If Unicode string is too long then truncate it.
 280   if (FileNameSize > MAX_NAME_LENGTH) {
 281     SavedChar = FileNameUnicode[MAX_NAME_LENGTH - 1];
 282     FileNameUnicode[MAX_NAME_LENGTH - 1] = L'\0';
 283   }
 284   UnicodeStrToAsciiStr (FileNameUnicode, FileNameAscii);
 285   // If the unicode string was truncated then restore its original content.
 286   if (SavedChar != L'\0') {
 287     FileNameUnicode[MAX_NAME_LENGTH - 1] = SavedChar;
 288   }
 289
 290   // If we're changing the file name
 291   if (AsciiStrCmp (FileNameAscii, File->HwDescription.Footer.Filename)) {
 292     // Check a file with that filename doesn't already exist
 293     if (BootMonGetFileFromAsciiFileName (
 294           File->Instance,
 295           File->HwDescription.Footer.Filename,
 296           &SameFile) != EFI_NOT_FOUND) {
 297       Status = EFI_ACCESS_DENIED;
 298     } else {
 299       AsciiStrCpy (FileNameAscii, File->HwDescription.Footer.Filename);
 300       Status = EFI_SUCCESS;
 301     }
 302   } else {
 303     // No change to filename
 304     Status = EFI_SUCCESS;
 305   }
 306
 307   FreePool (FileNameAscii);
 308   return Status;
 309 }
 310
 311 // Set the file's size (NB "size", not "physical size"). If the change amounts
 312 // to an increase, simply do a write followed by a flush.
 313 // (This is a helper function for SetFileInfo.)
 314 STATIC
 315 EFI_STATUS
 316 SetFileSize (
 317   IN BOOTMON_FS_INSTANCE *Instance,
 318   IN BOOTMON_FS_FILE     *BootMonFsFile,
 319   IN UINTN               Size
 320   )
 321 {
 322   UINT64             StoredPosition;
 323   EFI_STATUS         Status;
 324   EFI_FILE_PROTOCOL *File;
 325   CHAR8              Buffer;
 326   UINTN              BufferSize;
 327
 328   Buffer = 0;
 329   BufferSize = sizeof (Buffer);
 330
 331   File = &BootMonFsFile->File;
 332
 333   if (!(BootMonFsFile->OpenMode & EFI_FILE_MODE_WRITE)) {
 334     return EFI_ACCESS_DENIED;
 335   }
 336
 337   if (Size <= BootMonFsFile->HwDescription.Region[0].Size) {
 338     BootMonFsFile->HwDescription.Region[0].Size = Size;
 339   } else {
 340     // Increasing a file's size is potentially complicated as it may require
 341     // moving the image description on media. The simplest way to do it is to
 342     // seek past the end of the file (which is valid in UEFI) and perform a
 343     // Write.
 344
 345     // Save position
 346     Status = File->GetPosition (File, &StoredPosition);
 347     if (EFI_ERROR (Status)) {
 348       return Status;
 349     }
 350
 351     Status = File->SetPosition (File, Size - 1);
 352     if (EFI_ERROR (Status)) {
 353       return Status;
 354     }
 355     Status = File->Write (File, &BufferSize, &Buffer);
 356     if (EFI_ERROR (Status)) {
 357       return Status;
 358     }
 359
 360     // Restore saved position
 361     Status = File->SetPosition (File, Size - 1);
 362     if (EFI_ERROR (Status)) {
 363       return Status;
 364     }
 365
 366     Status = File->Flush (File);
 367     if (EFI_ERROR (Status)) {
 368       return Status;
 369     }
 370   }
 371   return EFI_SUCCESS;
 372 }
 373
 374 EFI_STATUS
 375 SetFileInfo (
 376   IN BOOTMON_FS_INSTANCE *Instance,
 377   IN BOOTMON_FS_FILE     *File,
 378   IN UINTN                BufferSize,
 379   IN EFI_FILE_INFO       *Info
 380   )
 381 {
 382   EFI_STATUS             Status;
 383   EFI_BLOCK_IO_PROTOCOL *BlockIo;
 384   UINT8                 *DataBuffer;
 385   UINTN                  BlockSize;
 386
 387   Status  = EFI_SUCCESS;
 388   BlockIo = Instance->BlockIo;
 389
 390   // Note that a call to this function on a file opened read-only is only
 391   // invalid if it actually changes fields, so  we don't immediately fail if the
 392   // OpenMode is wrong.
 393   // Also note that the only fields supported are filename and size, others are
 394   // ignored.
 395
 396   if (File != Instance->RootFile) {
 397     if (!(File->OpenMode & EFI_FILE_MODE_WRITE)) {
 398       return EFI_ACCESS_DENIED;
 399     }
 400
 401     SetFileName (File, Info->FileName);
 402     if (EFI_ERROR (Status)) {
 403       return Status;
 404     }
 405
 406     // Update file size
 407     Status = SetFileSize (Instance, File, Info->FileSize);
 408     if (EFI_ERROR (Status)) {
 409       return Status;
 410     }
 411
 412     //
 413     // Update the last block
 414     //
 415     BlockSize = BlockIo->Media->BlockSize;
 416     DataBuffer = AllocatePool (BlockSize);
 417     if (DataBuffer == NULL) {
 418       return EFI_OUT_OF_RESOURCES;
 419     }
 420     Status = BlockIo->ReadBlocks (BlockIo, Instance->Media->MediaId,
 421         File->HwDescription.BlockEnd, BlockSize, DataBuffer);
 422     if (EFI_ERROR (Status)) {
 423       FreePool (DataBuffer);
 424       return Status;
 425     }
 426     CopyMem (DataBuffer + BlockSize - sizeof (File->HwDescription), &File->HwDescription, sizeof (File->HwDescription));
 427     Status = BlockIo->WriteBlocks (BlockIo, Instance->Media->MediaId,
 428             File->HwDescription.BlockEnd, BlockSize, DataBuffer);
 429     FreePool (DataBuffer);
 430   }
 431   return Status;
 432 }
 433
 434 EFIAPI
 435 EFI_STATUS
 436 BootMonFsGetInfo (
 437   IN EFI_FILE_PROTOCOL  *This,
 438   IN EFI_GUID           *InformationType,
 439   IN OUT UINTN          *BufferSize,
 440   OUT VOID              *Buffer
 441   )
 442 {
 443   EFI_STATUS           Status;
 444   BOOTMON_FS_FILE     *File;
 445   BOOTMON_FS_INSTANCE *Instance;
 446
 447   File = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
 448   if (File == NULL) {
 449     return EFI_DEVICE_ERROR;
 450   }
 451
 452   Instance = File->Instance;
 453
 454   // If the instance has not been initialized yet then do it ...
 455   if (!Instance->Initialized) {
 456     Status = BootMonFsInitialize (Instance);
 457   } else {
 458     Status = EFI_SUCCESS;
 459   }
 460
 461   if (!EFI_ERROR (Status)) {
 462     if (CompareGuid (InformationType, &gEfiFileSystemVolumeLabelInfoIdGuid)
 463         != 0) {
 464       Status = GetFileSystemVolumeLabelInfo (Instance, BufferSize, Buffer);
 465     } else if (CompareGuid (InformationType, &gEfiFileSystemInfoGuid) != 0) {
 466       Status = GetFilesystemInfo (Instance, BufferSize, Buffer);
 467     } else if (CompareGuid (InformationType, &gEfiFileInfoGuid) != 0) {
 468       Status = GetFileInfo (Instance, File, BufferSize, Buffer);
 469     } else {
 470       Status = EFI_UNSUPPORTED;
 471     }
 472   }
 473
 474   return Status;
 475 }
 476
 477 EFIAPI
 478 EFI_STATUS
 479 BootMonFsSetInfo (
 480   IN EFI_FILE_PROTOCOL  *This,
 481   IN EFI_GUID           *InformationType,
 482   IN UINTN              BufferSize,
 483   IN VOID               *Buffer
 484   )
 485 {
 486   EFI_STATUS           Status;
 487   BOOTMON_FS_FILE     *File;
 488   BOOTMON_FS_INSTANCE *Instance;
 489
 490   File = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
 491   if (File == NULL) {
 492     return EFI_DEVICE_ERROR;
 493   }
 494
 495   Instance = File->Instance;
 496
 497   if (CompareGuid (InformationType, &gEfiFileInfoGuid) != 0) {
 498     Status = SetFileInfo (Instance, File, BufferSize, (EFI_FILE_INFO *) Buffer);
 499   } else {
 500     // The only writable field in the other two information types
 501     // (i.e. EFI_FILE_SYSTEM_INFO and EFI_FILE_SYSTEM_VOLUME_LABEL) is the
 502     // filesystem volume label. This can be retrieved with GetInfo, but it is
 503     // hard-coded into this driver, not stored on media.
 504     Status = EFI_UNSUPPORTED;
 505   }
 506
 507   return Status;
 508 }
 509
 510 EFIAPI
 511 EFI_STATUS
 512 BootMonFsReadDirectory (
 513   IN EFI_FILE_PROTOCOL    *This,
 514   IN OUT UINTN            *BufferSize,
 515   OUT VOID                *Buffer
 516   )
 517 {
 518   BOOTMON_FS_INSTANCE *Instance;
 519   BOOTMON_FS_FILE     *RootFile;
 520   BOOTMON_FS_FILE     *File;
 521   EFI_FILE_INFO       *Info;
 522   UINTN               NameSize;
 523   UINTN               ResultSize;
 524   EFI_STATUS          Status;
 525   UINTN               Index;
 526
 527   RootFile = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
 528   if (RootFile == NULL) {
 529     return EFI_INVALID_PARAMETER;
 530   }
 531
 532   Instance = RootFile->Instance;
 533   Status = BootMonGetFileFromPosition (Instance, RootFile->Position, &File);
 534   if (EFI_ERROR (Status)) {
 535     // No more file
 536     *BufferSize = 0;
 537     return EFI_SUCCESS;
 538   }
 539
 540   NameSize   = AsciiStrLen (File->HwDescription.Footer.Filename) + 1;
 541   ResultSize = SIZE_OF_EFI_FILE_INFO + (NameSize * sizeof (CHAR16));
 542   if (*BufferSize < ResultSize) {
 543     *BufferSize = ResultSize;
 544     return EFI_BUFFER_TOO_SMALL;
 545   }
 546
 547   // Zero out the structure
 548   Info = Buffer;
 549   ZeroMem (Info, ResultSize);
 550
 551   // Fill in the structure
 552   Info->Size         = ResultSize;
 553   Info->FileSize     = BootMonFsGetImageLength (File);
 554   Info->PhysicalSize = BootMonFsGetPhysicalSize (File);
 555   for (Index = 0; Index < NameSize; Index++) {
 556     Info->FileName[Index] = File->HwDescription.Footer.Filename[Index];
 557   }
 558
 559   *BufferSize = ResultSize;
 560   RootFile->Position++;
 561
 562   return EFI_SUCCESS;
 563 }
 564
 565 EFIAPI
 566 EFI_STATUS
 567 BootMonFsFlushDirectory (
 568   IN EFI_FILE_PROTOCOL  *This
 569   )
 570 {
 571   BOOTMON_FS_FILE *RootFile;
 572   LIST_ENTRY      *ListFiles;
 573   LIST_ENTRY      *Link;
 574   BOOTMON_FS_FILE *File;
 575
 576   RootFile = BOOTMON_FS_FILE_FROM_FILE_THIS (This);
 577   if (RootFile == NULL) {
 578     return EFI_INVALID_PARAMETER;
 579   }
 580
 581   ListFiles = &RootFile->Link;
 582
 583   if (IsListEmpty (ListFiles)) {
 584     return EFI_SUCCESS;
 585   }
 586
 587   //
 588   // Flush all the files that need to be flushed
 589   //
 590
 591   // Go through all the list of files to flush them
 592   for (Link = GetFirstNode (ListFiles);
 593        !IsNull (ListFiles, Link);
 594        Link = GetNextNode (ListFiles, Link)
 595        )
 596   {
 597     File = BOOTMON_FS_FILE_FROM_LINK_THIS (Link);
 598     File->File.Flush (&File->File);
 599   }
 600
 601   return EFI_SUCCESS;
 602 }