boot/environ/lib/io/etfs.c

   1 /*
   2  * COPYRIGHT:       See COPYING.ARM in the top level directory
   3  * PROJECT:         ReactOS UEFI Boot Library
   4  * FILE:            boot/environ/lib/io/etfs.c
   5  * PURPOSE:         Boot Library El Torito File System Management Routines
   6  * PROGRAMMER:      Alex Ionescu (alex.ionescu@reactos.org)
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include <bl.h>
  12 #include <cdfs_new/cd.h>
  13 typedef struct _RAW_ET_VD
  14 {
  15     UCHAR BootIndicator;
  16     UCHAR StandardId[5];
  17     UCHAR Version;
  18     UCHAR SystemId[32];
  19     UCHAR Reserved[32];
  20     ULONG BootCatalogOffset;
  21     UCHAR Padding[1973];
  22 } RAW_ET_VD, *PRAW_ET_VD;
  23
  24 /* DATA VARIABLES ************************************************************/
  25
  26 typedef struct _BL_ETFS_DEVICE
  27 {
  28     ULONG RootDirOffset;
  29     ULONG RootDirSize;
  30     ULONG BlockSize;
  31     ULONG VolumeSize;
  32     BOOLEAN IsIso;
  33     PUCHAR MemoryBlock;
  34     ULONG Offset;
  35 } BL_ETFS_DEVICE, *PBL_ETFS_DEVICE;
  36
  37 typedef struct _BL_ETFS_FILE
  38 {
  39     ULONG DiskOffset;
  40     ULONG DirOffset;
  41     ULONG DirEntOffset;
  42
  43     BL_FILE_INFORMATION;
  44
  45     ULONG DeviceId;
  46 } BL_ETFS_FILE, *PBL_ETFS_FILE;
  47
  48 ULONG EtfsDeviceTableEntries;
  49 PVOID* EtfsDeviceTable;
  50
  51 NTSTATUS
  52 EtfsOpen (
  53     _In_ PBL_FILE_ENTRY Directory,
  54     _In_ PWCHAR FileName,
  55     _In_ ULONG Flags,
  56     _Out_ PBL_FILE_ENTRY *FileEntry
  57     );
  58
  59 NTSTATUS
  60 EtfsGetInformation (
  61     _In_ PBL_FILE_ENTRY FileEntry,
  62     _Out_ PBL_FILE_INFORMATION FileInfo
  63     );
  64
  65 NTSTATUS
  66 EtfsSetInformation (
  67     _In_ PBL_FILE_ENTRY FileEntry,
  68     _In_ PBL_FILE_INFORMATION FileInfo
  69     );
  70
  71 NTSTATUS
  72 EtfsRead (
  73     _In_ PBL_FILE_ENTRY FileEntry,
  74     _In_ PVOID Buffer,
  75     _In_ ULONG Size,
  76     _Out_opt_ PULONG BytesReturned
  77     );
  78
  79 BL_FILE_CALLBACKS EtfsFunctionTable =
  80 {
  81     EtfsOpen,
  82     NULL,
  83     EtfsRead,
  84     NULL,
  85     NULL,
  86     EtfsGetInformation,
  87     EtfsSetInformation
  88 };
  89
  90 /* FUNCTIONS *****************************************************************/
  91
  92 VOID
  93 EtfspGetDirectoryInfo (
  94     _In_ PBL_ETFS_DEVICE EtfsDevice,
  95     _In_ PRAW_DIR_REC DirEntry,
  96     _Out_ PULONG FileOffset,
  97     _Out_ PULONG FileSize,
  98     _Out_opt_ PBOOLEAN IsDirectory
  99     )
 100 {
 101     ULONG SectorOffset;
 102     BOOLEAN IsDir;
 103
 104     *FileOffset = *(PULONG)DirEntry->FileLoc * EtfsDevice->BlockSize;
 105     *FileOffset += (DirEntry->XarLen * EtfsDevice->BlockSize);
 106
 107     SectorOffset = ALIGN_DOWN_BY(*FileOffset, CD_SECTOR_SIZE);
 108
 109     *FileSize = *(PULONG)DirEntry->DataLen;
 110
 111     IsDir = DE_FILE_FLAGS(EtfsDevice->IsIso, DirEntry) & ISO_ATTR_DIRECTORY;
 112     if (IsDir)
 113     {
 114         *FileSize += ALIGN_UP_BY(SectorOffset, CD_SECTOR_SIZE) - SectorOffset;
 115     }
 116
 117     if (IsDirectory)
 118     {
 119         *IsDirectory = IsDir;
 120     }
 121 }
 122
 123 USHORT
 124 EtfspGetDirentNameLength (
 125     _In_ PRAW_DIR_REC DirEntry
 126     )
 127 {
 128     USHORT Length, RealLength;
 129     PUCHAR Pos;
 130
 131     RealLength = Length = DirEntry->FileIdLen;
 132     for (Pos = DirEntry->FileId + Length - 1; Length; --Pos)
 133     {
 134         --Length;
 135
 136         if (*Pos == ';')
 137         {
 138             RealLength = Length;
 139             break;
 140         }
 141     }
 142
 143     Length = RealLength;
 144     for (Pos = DirEntry->FileId + Length - 1; Length; --Pos)
 145     {
 146         --Length;
 147
 148         if (*Pos != '.')
 149         {
 150             break;
 151         }
 152
 153         RealLength = Length;
 154     }
 155
 156     return RealLength;
 157 }
 158
 159 LONG
 160 EtfspCompareNames (
 161     __in PSTRING Name1,
 162     __in PUNICODE_STRING Name2
 163     )
 164 {
 165     ULONG i, l1, l2, l;
 166
 167     l1 = Name1->Length;
 168     l2 = Name2->Length / sizeof(WCHAR);
 169     l = min(l1, l2);
 170
 171     for (i = 0; i < l; i++)
 172     {
 173         if (toupper(Name1->Buffer[i]) != toupper(Name2->Buffer[i]))
 174         {
 175             return toupper(Name1->Buffer[i]) - toupper(Name2->Buffer[i]);
 176         }
 177     }
 178
 179     if (l2 <= l1)
 180     {
 181         return l2 < l1;
 182     }
 183     else
 184     {
 185         return -1;
 186     }
 187 }
 188
 189 BOOLEAN
 190 EtfspFileMatch (
 191     _In_ PRAW_DIR_REC DirEntry,
 192     _In_ PUNICODE_STRING FileName
 193     )
 194 {
 195     BOOLEAN Match;
 196     USHORT Length;
 197     ANSI_STRING DirName;
 198
 199     if ((DirEntry->FileIdLen != 1) ||
 200         ((DirEntry->FileId[0] != 0) && (DirEntry->FileId[0] != 1)))
 201     {
 202         Length = EtfspGetDirentNameLength(DirEntry);
 203         DirName.Length = Length;
 204         DirName.MaximumLength = Length;
 205         DirName.Buffer = (PCHAR)DirEntry->FileId;
 206
 207         Match = EtfspCompareNames(&DirName, FileName);
 208     }
 209     else
 210     {
 211         Match = -1;
 212     }
 213     return Match;
 214 }
 215
 216 NTSTATUS
 217 EtfspGetDirent (
 218     _In_ PBL_FILE_ENTRY DirectoryEntry,
 219     _Out_ PRAW_DIR_REC *DirEntry,
 220     _Inout_ PULONG DirentOffset
 221     )
 222 {
 223     PBL_ETFS_FILE EtfsFile;
 224     ULONG FileOffset, DirectoryOffset, AlignedOffset, RemainderOffset;
 225     ULONG DeviceId, ReadSize, DirLen;
 226     PBL_ETFS_DEVICE EtfsDevice;
 227     BOOLEAN NeedRead, IsMulti;
 228     NTSTATUS result;
 229     PRAW_DIR_REC DirEnt;
 230     PUCHAR MemoryBlock;
 231
 232     EtfsFile = DirectoryEntry->FsSpecificData;
 233     DeviceId = EtfsFile->DeviceId;
 234     FileOffset = EtfsFile->DiskOffset;
 235     EtfsDevice = EtfsDeviceTable[DeviceId];
 236
 237     DirectoryOffset = *DirentOffset;
 238     MemoryBlock = EtfsDevice->MemoryBlock;
 239
 240     IsMulti = 0;
 241
 242     AlignedOffset = (FileOffset + *DirentOffset) & ~CD_SECTOR_SIZE;
 243     RemainderOffset = *DirentOffset + FileOffset - AlignedOffset;
 244
 245     ReadSize = 2048 - RemainderOffset;
 246     NeedRead = AlignedOffset == EtfsDevice->Offset ? 0 : 1;
 247
 248 ReadAgain:
 249     if (DirectoryOffset >= EtfsFile->Size)
 250     {
 251         return STATUS_NO_SUCH_FILE;
 252     }
 253
 254     while (ReadSize < MIN_DIR_REC_SIZE)
 255     {
 256         DirectoryOffset += ReadSize;
 257         AlignedOffset += 2048;
 258         ReadSize = 2048;
 259         RemainderOffset = 0;
 260         NeedRead = 1;
 261         if (DirectoryOffset >= EtfsFile->Size)
 262         {
 263             return STATUS_NO_SUCH_FILE;
 264         }
 265     }
 266
 267     if (NeedRead)
 268     {
 269         result = BlDeviceReadAtOffset(DirectoryEntry->DeviceId,
 270                                       CD_SECTOR_SIZE,
 271                                       AlignedOffset,
 272                                       MemoryBlock,
 273                                       NULL);
 274         if (!NT_SUCCESS(result))
 275         {
 276             EfiPrintf(L"Device read failed %lx\r\n", result);
 277             return result;
 278         }
 279
 280         NeedRead = FALSE;
 281         EtfsDevice->Offset = AlignedOffset;
 282     }
 283
 284     if (!*(MemoryBlock + RemainderOffset))
 285     {
 286         AlignedOffset += 2048;
 287         NeedRead = TRUE;
 288
 289         RemainderOffset = 0;
 290         DirectoryOffset += ReadSize;
 291         ReadSize = 2048;
 292         goto ReadAgain;
 293     }
 294
 295     DirEnt = (PRAW_DIR_REC)(MemoryBlock + RemainderOffset);
 296     DirLen = DirEnt->DirLen;
 297     if (DirLen > ReadSize)
 298     {
 299         EfiPrintf(L"Dir won't fit %lx %lx\r\n", DirLen, ReadSize);
 300         return STATUS_NO_SUCH_FILE;
 301     }
 302
 303     if (IsMulti)
 304     {
 305         if (!(DE_FILE_FLAGS(EtfsDevice->IsIso, DirEnt) & ISO_ATTR_MULTI))
 306         {
 307             IsMulti = TRUE;
 308         }
 309     }
 310     else if (DE_FILE_FLAGS(EtfsDevice->IsIso, DirEnt) & ISO_ATTR_MULTI)
 311     {
 312         IsMulti = TRUE;
 313     }
 314     else
 315     {
 316         if ((DirEnt->FileIdLen != 1) ||
 317             ((DirEnt->FileId[0] != 0) && (DirEnt->FileId[0] != 1)))
 318         {
 319             goto Quickie;
 320         }
 321     }
 322
 323     RemainderOffset += DirLen;
 324     DirectoryOffset += DirLen;
 325     ReadSize -= DirLen;
 326     goto ReadAgain;
 327
 328 Quickie:
 329     *DirEntry = DirEnt;
 330     *DirentOffset = DirectoryOffset;
 331     return STATUS_SUCCESS;
 332 }
 333
 334 NTSTATUS
 335 EtfspSearchForDirent (
 336     _In_ PBL_FILE_ENTRY DirectoryEntry,
 337     _In_ PWCHAR FileName,
 338     _Out_ PRAW_DIR_REC *DirEntry,
 339     _Out_ PULONG DirentOffset
 340     )
 341 {
 342     UNICODE_STRING Name;
 343     ULONG NextOffset;
 344     PRAW_DIR_REC DirEnt;
 345     NTSTATUS Status;
 346
 347     RtlInitUnicodeString(&Name, FileName);
 348     for (NextOffset = *DirentOffset;
 349          ;
 350          NextOffset = NextOffset + DirEnt->DirLen)
 351     {
 352         Status = EtfspGetDirent(DirectoryEntry, &DirEnt, &NextOffset);
 353         if (!NT_SUCCESS(Status))
 354         {
 355             return STATUS_NO_SUCH_FILE;
 356         }
 357
 358         if (!EtfspFileMatch(DirEnt, &Name))
 359         {
 360             break;
 361         }
 362     }
 363
 364     *DirEntry = DirEnt;
 365     *DirentOffset = NextOffset;
 366     return 0;
 367 }
 368
 369 NTSTATUS
 370 EtfspCachedSearchForDirent (
 371     _In_ PBL_FILE_ENTRY DirectoryEntry,
 372     _In_ PWCHAR FileName,
 373     _Out_ PRAW_DIR_REC *DirEntry,
 374     _Out_ PULONG DirOffset,
 375     _In_ BOOLEAN KeepOffset
 376     )
 377 {
 378     PBL_ETFS_FILE EtfsFile;
 379     PBL_ETFS_DEVICE EtfsDevice;
 380     NTSTATUS Status;
 381     ULONG DirentOffset;
 382     PRAW_DIR_REC Dirent;
 383     UNICODE_STRING Name;
 384
 385     EtfsFile = DirectoryEntry->FsSpecificData;
 386     EtfsDevice = EtfsDeviceTable[EtfsFile->DeviceId];
 387     RtlInitUnicodeString(&Name, FileName);
 388     DirentOffset = EtfsFile->DirEntOffset;
 389
 390     if ((KeepOffset) ||
 391         (ALIGN_DOWN_BY((DirentOffset + EtfsFile->DiskOffset), CD_SECTOR_SIZE) ==
 392          EtfsDevice->Offset))
 393     {
 394         Status = EtfspGetDirent(DirectoryEntry, &Dirent, &DirentOffset);
 395         if (NT_SUCCESS(Status))
 396         {
 397             if (!EtfspFileMatch(Dirent, &Name))
 398             {
 399                 *DirEntry = Dirent;
 400                 *DirOffset = DirentOffset;
 401                 return STATUS_SUCCESS;
 402             }
 403         }
 404         else
 405         {
 406             DirentOffset = 0;
 407         }
 408     }
 409     else
 410     {
 411         DirentOffset = 0;
 412     }
 413
 414     Status = EtfspSearchForDirent(DirectoryEntry,
 415                                   FileName,
 416                                   DirEntry,
 417                                   &DirentOffset);
 418     if (!(NT_SUCCESS(Status)) && (DirentOffset))
 419     {
 420         DirentOffset = 0;
 421         Status = EtfspSearchForDirent(DirectoryEntry,
 422                                       FileName,
 423                                       DirEntry,
 424                                       &DirentOffset);
 425     }
 426
 427     if (NT_SUCCESS(Status))
 428     {
 429         *DirOffset = DirentOffset;
 430     }
 431
 432     return Status;
 433 }
 434
 435 NTSTATUS
 436 EtfsRead (
 437     _In_ PBL_FILE_ENTRY FileEntry,
 438     _In_ PVOID Buffer,
 439     _In_ ULONG Size,
 440     _Out_opt_ PULONG BytesReturned
 441     )
 442 {
 443     ULONG BytesRead;
 444     PBL_ETFS_FILE EtfsFile;
 445     NTSTATUS Status;
 446
 447     /* Assume failure for now */
 448     BytesRead = 0;
 449
 450     /* Make sure that the read is within the file's boundaries */
 451     EtfsFile = FileEntry->FsSpecificData;
 452     if ((Size + EtfsFile->Offset) > EtfsFile->Size)
 453     {
 454         /* Bail out otherwise */
 455         Status = STATUS_INVALID_PARAMETER;
 456     }
 457     else
 458     {
 459         /* Read the offset that matches this file's offset, on the disk */
 460         Status = BlDeviceReadAtOffset(FileEntry->DeviceId,
 461                                       Size,
 462                                       EtfsFile->Offset + EtfsFile->DiskOffset,
 463                                       Buffer,
 464                                       &BytesRead);
 465         if (NT_SUCCESS(Status))
 466         {
 467             /* Update the file offset and return the size as having been read */
 468             EtfsFile->Offset += Size;
 469             BytesRead = Size;
 470         }
 471     }
 472
 473     /* Check if caller wanted to know how many bytes were read */
 474     if (BytesReturned)
 475     {
 476         /* Return the value */
 477         *BytesReturned = BytesRead;
 478     }
 479
 480     /* All done */
 481     return Status;
 482 }
 483
 484 NTSTATUS
 485 EtfsSetInformation (
 486     _In_ PBL_FILE_ENTRY FileEntry,
 487     _In_ PBL_FILE_INFORMATION FileInfo
 488     )
 489 {
 490     PBL_ETFS_FILE EtfsFile;
 491     BL_FILE_INFORMATION LocalFileInfo;
 492
 493     /* Get the underlying ETFS file data structure */
 494     EtfsFile = (PBL_ETFS_FILE)FileEntry->FsSpecificData;
 495
 496     /* Make a copy of the incoming attributes, but ignore the new offset */
 497     LocalFileInfo = *FileInfo;
 498     LocalFileInfo.Offset = EtfsFile->Offset;
 499
 500     /* Check if these match exactly the current file */
 501     if (!RtlEqualMemory(&LocalFileInfo, &EtfsFile->Size, sizeof(*FileInfo)))
 502     {
 503         /* Nope -- which means caller is trying to change an immutable */
 504         EfiPrintf(L"Incorrect information change\r\n");
 505         return STATUS_INVALID_PARAMETER;
 506     }
 507
 508     /* Is the offset past the end of the file? */
 509     if (FileInfo->Offset >= EtfsFile->Size)
 510     {
 511         /* Don't allow EOF */
 512         EfiPrintf(L"Offset too large: %lx vs %lx\r\n", FileInfo->Offset, EtfsFile->Size);
 513         return STATUS_INVALID_PARAMETER;
 514     }
 515
 516     /* Update the offset */
 517     EtfsFile->Offset = FileInfo->Offset;
 518     return STATUS_SUCCESS;
 519 }
 520
 521 NTSTATUS
 522 EtfsGetInformation (
 523     _In_ PBL_FILE_ENTRY FileEntry,
 524     _Out_ PBL_FILE_INFORMATION FileInfo
 525     )
 526 {
 527     PBL_ETFS_FILE EtfsFile;
 528
 529     /* Get the underlying ETFS file data structure */
 530     EtfsFile = (PBL_ETFS_FILE)FileEntry->FsSpecificData;
 531
 532     /* Copy the cached information structure within it */
 533     RtlCopyMemory(FileInfo, &EtfsFile->Size, sizeof(*FileInfo));
 534     return STATUS_SUCCESS;
 535 }
 536
 537 NTSTATUS
 538 EtfsOpen (
 539     _In_ PBL_FILE_ENTRY Directory,
 540     _In_ PWCHAR FileName,
 541     _In_ ULONG Flags,
 542     _Out_ PBL_FILE_ENTRY *FileEntry
 543     )
 544 {
 545     PBL_ETFS_DEVICE EtfsDevice;
 546     NTSTATUS Status;
 547     PBL_FILE_ENTRY NewFile;
 548     PWCHAR FilePath, FormatString;
 549     PBL_ETFS_FILE EtfsFile;
 550     ULONG DeviceId, FileSize, DirOffset, FileOffset;
 551     SIZE_T Size;
 552     PRAW_DIR_REC DirEntry;
 553     BOOLEAN IsDirectory;
 554
 555     EtfsFile = Directory->FsSpecificData;
 556     DeviceId = EtfsFile->DeviceId;
 557     EtfsDevice = EtfsDeviceTable[DeviceId];
 558
 559     /* Find the given file (or directory) in the given directory */
 560     Status = EtfspCachedSearchForDirent(Directory,
 561                                         FileName,
 562                                         &DirEntry,
 563                                         &DirOffset,
 564                                         FALSE);
 565     if (!NT_SUCCESS(Status))
 566     {
 567         return Status;
 568     }
 569
 570     /* Find out information about the file (or directory) we found */
 571     EtfspGetDirectoryInfo(EtfsDevice,
 572                           DirEntry,
 573                           &FileOffset,
 574                           &FileSize,
 575                           &IsDirectory);
 576
 577     /* Allocate a file entry */
 578     NewFile = BlMmAllocateHeap(sizeof(*NewFile));
 579     if (!NewFile)
 580     {
 581         return STATUS_NO_MEMORY;
 582     }
 583
 584     /* Zero it out */
 585     RtlZeroMemory(NewFile, sizeof(*NewFile));
 586
 587     /* Figure out the size of the path and filename plus a slash and NUL */
 588     Size = wcslen(Directory->FilePath) + wcslen(FileName) + 2;
 589     FilePath = BlMmAllocateHeap(Size * sizeof(WCHAR));
 590     if (!FilePath)
 591     {
 592         Status = STATUS_NO_MEMORY;
 593         goto Quickie;
 594     }
 595
 596     /* Allocate an ETFS file entry */
 597     EtfsFile = (PBL_ETFS_FILE)BlMmAllocateHeap(sizeof(*EtfsFile));
 598     if (!EtfsFile)
 599     {
 600         Status = STATUS_NO_MEMORY;
 601         goto Quickie;
 602     }
 603
 604     /* Zero it out */
 605     RtlZeroMemory(EtfsFile, sizeof(*EtfsFile));
 606
 607     /* Capture the device ID of the directory */
 608     NewFile->DeviceId = Directory->DeviceId;
 609
 610     /* Check if this is the root or a filename\directory under */
 611     FormatString = L"%ls%ls";
 612     if (Directory->FilePath[1])
 613     {
 614         FormatString = L"%ls\\%ls";
 615     }
 616
 617     /* Combine the paths, and save the final path in the file entry */
 618     _snwprintf(FilePath, Size, FormatString, Directory->FilePath, FileName);
 619     NewFile->FilePath = FilePath;
 620
 621     /* Copy the ETFS function callbacks into the file netry */
 622     RtlCopyMemory(&NewFile->Callbacks,
 623                   &EtfsFunctionTable,
 624                   sizeof(NewFile->Callbacks));
 625
 626     /* Fill out the rest of the details */
 627     EtfsFile->DiskOffset = FileOffset;
 628     EtfsFile->DirOffset = DirOffset;
 629     EtfsFile->Size = FileSize;
 630     EtfsFile->DeviceId = DeviceId;
 631
 632     /* Check if this is a directory */
 633     if (IsDirectory)
 634     {
 635         EtfsFile->Flags |= BL_ETFS_FILE_ENTRY_DIRECTORY;
 636         NewFile->Flags |= BL_FILE_ENTRY_DIRECTORY;
 637     }
 638
 639     /* Write down the name of the filesystem */
 640     EtfsFile->FsName = L"cdfs";
 641
 642     /* All done, return the file entry, and save the ETFS side */
 643     NewFile->FsSpecificData = EtfsFile;
 644     *FileEntry = NewFile;
 645     return Status;
 646
 647 Quickie:
 648     /* Failure path -- free the file path if we had one */
 649     if (NewFile->FilePath)
 650     {
 651         BlMmFreeHeap(NewFile->FilePath);
 652     }
 653
 654     /* Free the ETFS file entry if we had one */
 655     if (NewFile->FsSpecificData)
 656     {
 657         BlMmFreeHeap(NewFile->FsSpecificData);
 658     }
 659
 660     /* Free the file entry itself, and return the error code */
 661     BlMmFreeHeap(NewFile);
 662     return Status;
 663 }
 664
 665 NTSTATUS
 666 EtfspCheckCdfs (
 667     _In_ PBL_ETFS_DEVICE EtfsDevice,
 668     _In_ ULONG DeviceId,
 669     _Out_ PRAW_ISO_VD *VolumeDescriptor,
 670     _Out_ PBOOLEAN VolumeIsIso
 671     )
 672 {
 673     EfiPrintf(L"Raw Cdfs not implemented\r\n");
 674     return STATUS_NOT_IMPLEMENTED;
 675 }
 676
 677 NTSTATUS
 678 EtfspCheckEtfs (
 679     _In_ PBL_ETFS_DEVICE EtfsDevice,
 680     _In_ ULONG DeviceId,
 681     _Out_ PRAW_ISO_VD *VolumeDescriptor,
 682     _Out_ PBOOLEAN VolumeIsIso
 683     )
 684 {
 685     PRAW_ISO_VD IsoVd;
 686     PRAW_ET_VD EtVd;
 687     NTSTATUS Status;
 688     BOOLEAN IsIso;
 689     BL_DEVICE_INFORMATION DeviceInformation;
 690     ULONG Unknown, BytesRead;
 691     ANSI_STRING CompareString, String;
 692
 693     /* Save our static buffer pointer */
 694     IsoVd = (PRAW_ISO_VD)EtfsDevice->MemoryBlock;
 695     EtVd = (PRAW_ET_VD)IsoVd;
 696
 697     /* First, read the El Torito Volume Descriptor */
 698     BlDeviceGetInformation(DeviceId, &DeviceInformation);
 699     Unknown = DeviceInformation.BlockDeviceInfo.Unknown;
 700     DeviceInformation.BlockDeviceInfo.Unknown |= 1;
 701     BlDeviceSetInformation(DeviceId, &DeviceInformation);
 702     Status = BlDeviceReadAtOffset(DeviceId,
 703                                   CD_SECTOR_SIZE,
 704                                   (FIRST_VD_SECTOR + 1) * CD_SECTOR_SIZE,
 705                                   EtfsDevice->MemoryBlock,
 706                                   &BytesRead);
 707     DeviceInformation.BlockDeviceInfo.Unknown = Unknown;
 708     BlDeviceSetInformation(DeviceId, &DeviceInformation);
 709     if (!NT_SUCCESS(Status))
 710     {
 711         EfiPrintf(L" read failed\r\n");
 712         return Status;
 713     }
 714
 715     /* Remember that's where we last read */
 716     EtfsDevice->Offset = (FIRST_VD_SECTOR + 1) * CD_SECTOR_SIZE;
 717
 718     /* Check if it's EL TORITO! */
 719     RtlInitString(&String, "EL TORITO SPECIFICATION");
 720     CompareString.Buffer = (PCHAR)EtVd->SystemId;
 721     CompareString.Length = 23;
 722     CompareString.MaximumLength = 23;
 723     if (!RtlEqualString(&CompareString, &String, TRUE))
 724     {
 725         return STATUS_UNSUCCESSFUL;
 726     }
 727
 728     /* Check the version and boot indicator */
 729     if ((EtVd->Version != 1) || (EtVd->BootIndicator))
 730     {
 731         return STATUS_UNSUCCESSFUL;
 732     }
 733
 734     /* Check if it has the CD0001 identifier */
 735     RtlInitString(&String, ISO_VOL_ID);
 736     CompareString.Buffer = (PCHAR)EtVd->StandardId;
 737     CompareString.Length = 5;
 738     CompareString.MaximumLength = 5;
 739     if (!RtlEqualString(&CompareString, &String, TRUE))
 740     {
 741         return STATUS_UNSUCCESSFUL;
 742     }
 743
 744     /* Step two, we now want to read the ISO Volume Descriptor */
 745     DeviceInformation.BlockDeviceInfo.Unknown |= 1u;
 746     BlDeviceSetInformation(DeviceId, &DeviceInformation);
 747     Status = BlDeviceReadAtOffset(DeviceId,
 748                                   CD_SECTOR_SIZE,
 749                                   FIRST_VD_SECTOR * CD_SECTOR_SIZE,
 750                                   EtfsDevice->MemoryBlock,
 751                                   &BytesRead);
 752     DeviceInformation.BlockDeviceInfo.Unknown = Unknown;
 753     BlDeviceSetInformation(DeviceId, &DeviceInformation);
 754     if (!NT_SUCCESS(Status))
 755     {
 756         return Status;
 757     }
 758
 759     /* Remember where we left off */
 760     EtfsDevice->Offset = FIRST_VD_SECTOR  * CD_SECTOR_SIZE;
 761
 762     /* This should also say CD0001 */
 763     CompareString.Buffer = (PCHAR)IsoVd->StandardId;
 764     CompareString.Length = 5;
 765     CompareString.MaximumLength = 5;
 766     IsIso = RtlEqualString(&CompareString, &String, TRUE);
 767     if (!IsIso)
 768     {
 769         return STATUS_UNSUCCESSFUL;
 770     }
 771
 772     /* And should be a version we support */
 773     if ((IsoVd->Version != VERSION_1) || (IsoVd->DescType != VD_PRIMARY))
 774     {
 775         return STATUS_UNSUCCESSFUL;
 776     }
 777
 778     /* Return back to the caller */
 779     *VolumeDescriptor = IsoVd;
 780     *VolumeIsIso = IsIso;
 781     return STATUS_SUCCESS;
 782 }
 783
 784 NTSTATUS
 785 EtfspDeviceContextDestroy (
 786     _In_ PBL_ETFS_DEVICE EtfsDevice
 787     )
 788 {
 789     if (EtfsDevice->MemoryBlock)
 790     {
 791         BlMmFreeHeap(EtfsDevice->MemoryBlock);
 792     }
 793
 794     BlMmFreeHeap(EtfsDevice);
 795
 796     return STATUS_SUCCESS;
 797 }
 798
 799 NTSTATUS
 800 EtfspCreateContext (
 801     _In_ ULONG DeviceId,
 802     _Out_ PBL_ETFS_DEVICE *EtfsDevice
 803     )
 804 {
 805     PBL_ETFS_DEVICE NewContext;
 806     PVOID MemoryBlock;
 807     NTSTATUS Status;
 808     BOOLEAN IsIso;
 809     PRAW_ISO_VD RawVd;
 810
 811     NewContext = (PBL_ETFS_DEVICE)BlMmAllocateHeap(sizeof(*NewContext));
 812     if (!NewContext)
 813     {
 814         return STATUS_NO_MEMORY;
 815     }
 816     RtlZeroMemory(NewContext, sizeof(*NewContext));
 817
 818     MemoryBlock = BlMmAllocateHeap(CD_SECTOR_SIZE);
 819     NewContext->MemoryBlock = MemoryBlock;
 820     if (!MemoryBlock)
 821     {
 822         Status = STATUS_NO_MEMORY;
 823         goto Quickie;
 824     }
 825
 826     Status = EtfspCheckEtfs(NewContext, DeviceId, &RawVd, &IsIso);
 827     if (!NT_SUCCESS(Status))
 828     {
 829         EfiPrintf(L"Drive not EDFS. Checking for CDFS: %lx\r\n");
 830         Status = EtfspCheckCdfs(NewContext, DeviceId, &RawVd, &IsIso);
 831     }
 832
 833     if (!NT_SUCCESS(Status))
 834     {
 835         EfiPrintf(L"Drive not CDFS. Failing: %lx\r\n");
 836         goto Quickie;
 837     }
 838
 839     NewContext->IsIso = IsIso;
 840     NewContext->BlockSize = RVD_LB_SIZE(RawVd, IsIso);
 841     NewContext->VolumeSize = RVD_VOL_SIZE(RawVd, IsIso);
 842
 843     EtfspGetDirectoryInfo(NewContext,
 844                           (PRAW_DIR_REC)RVD_ROOT_DE(RawVd, IsIso),
 845                           &NewContext->RootDirOffset,
 846                           &NewContext->RootDirSize,
 847                           0);
 848     Status = STATUS_SUCCESS;
 849
 850 Quickie:
 851     if (!NT_SUCCESS(Status))
 852     {
 853         EtfspDeviceContextDestroy(NewContext);
 854         NewContext = NULL;
 855     }
 856
 857     *EtfsDevice = NewContext;
 858     return Status;
 859 }
 860
 861 NTSTATUS
 862 EtfspDeviceTableDestroyEntry (
 863     _In_ PBL_ETFS_DEVICE EtfsDevice,
 864     _In_ ULONG Index
 865     )
 866 {
 867     EtfspDeviceContextDestroy(EtfsDevice);
 868     EtfsDeviceTable[Index] = NULL;
 869
 870     return STATUS_SUCCESS;
 871 }
 872
 873 NTSTATUS
 874 EtfsMount (
 875     _In_ ULONG DeviceId,
 876     _In_ ULONG Unknown,
 877     _Out_ PBL_FILE_ENTRY* FileEntry
 878     )
 879 {
 880     PBL_ETFS_DEVICE EtfsDevice = NULL;
 881     PBL_FILE_ENTRY RootEntry;
 882     NTSTATUS Status;
 883     PBL_ETFS_FILE EtfsFile;
 884
 885     EfiPrintf(L"Trying to mount as ETFS...\r\n");
 886
 887     Status = EtfspCreateContext(DeviceId, &EtfsDevice);
 888     if (!NT_SUCCESS(Status))
 889     {
 890         EfiPrintf(L"ETFS context failed: %lx\r\n");
 891         return Status;
 892     }
 893
 894     Status = BlTblSetEntry(&EtfsDeviceTable,
 895                            &EtfsDeviceTableEntries,
 896                            EtfsDevice,
 897                            &DeviceId,
 898                            TblDoNotPurgeEntry);
 899     if (!NT_SUCCESS(Status))
 900     {
 901         EtfspDeviceContextDestroy(EtfsDevice);
 902         return Status;
 903     }
 904
 905     RootEntry = BlMmAllocateHeap(sizeof(*RootEntry));
 906     if (!RootEntry)
 907     {
 908         Status = STATUS_NO_MEMORY;
 909         goto Quickie;
 910     }
 911
 912     RtlZeroMemory(RootEntry, sizeof(*RootEntry));
 913
 914     RootEntry->FilePath = BlMmAllocateHeap(4);
 915     if (!RootEntry->FilePath)
 916     {
 917         Status = STATUS_NO_MEMORY;
 918         goto Quickie;
 919     }
 920
 921     wcsncpy(RootEntry->FilePath, L"\\", 1);
 922
 923     RootEntry->DeviceId = DeviceId;
 924     RtlCopyMemory(&RootEntry->Callbacks,
 925                   &EtfsFunctionTable,
 926                   sizeof(RootEntry->Callbacks));
 927
 928     EtfsFile = (PBL_ETFS_FILE)BlMmAllocateHeap(sizeof(*EtfsFile));
 929     if (!EtfsFile)
 930     {
 931         Status = STATUS_NO_MEMORY;
 932         goto Quickie;
 933     }
 934
 935     RootEntry->Flags |= 0x10000;
 936
 937     RtlZeroMemory(EtfsFile, sizeof(*EtfsFile));
 938     RootEntry->FsSpecificData = EtfsFile;
 939     EtfsFile->DeviceId = DeviceId;
 940     EtfsFile->Flags |= 1;
 941     EtfsFile->DiskOffset = EtfsDevice->RootDirOffset;
 942     EtfsFile->DirOffset = 0;
 943     EtfsFile->Size = EtfsDevice->RootDirSize;
 944     EtfsFile->FsName = L"cdfs";
 945     *FileEntry = RootEntry;
 946
 947     return STATUS_SUCCESS;
 948
 949 Quickie:
 950     if (RootEntry->FilePath)
 951     {
 952         BlMmFreeHeap(RootEntry->FilePath);
 953     }
 954     if (RootEntry->FsSpecificData)
 955     {
 956         BlMmFreeHeap(RootEntry->FsSpecificData);
 957     }
 958     if (RootEntry)
 959     {
 960         BlMmFreeHeap(RootEntry);
 961     }
 962
 963     EtfspDeviceTableDestroyEntry(EtfsDevice, DeviceId);
 964
 965     return Status;
 966 }
 967
 968 NTSTATUS
 969 EtfsInitialize (
 970     VOID
 971     )
 972 {
 973     NTSTATUS Status;
 974
 975     /* Allocate the device table with 2 entries*/
 976     EtfsDeviceTableEntries = 2;
 977     EtfsDeviceTable = BlMmAllocateHeap(sizeof(PBL_FILE_ENTRY) *
 978                                        EtfsDeviceTableEntries);
 979     if (EtfsDeviceTable)
 980     {
 981         /* Zero it out */
 982         RtlZeroMemory(EtfsDeviceTable,
 983                       sizeof(PBL_FILE_ENTRY) * EtfsDeviceTableEntries);
 984         Status = STATUS_SUCCESS;
 985     }
 986     else
 987     {
 988         /* No memory, fail */
 989         Status = STATUS_NO_MEMORY;
 990     }
 991
 992     /* Return back to caller */
 993     return Status;
 994 }
 995