public inbox for devel@edk2.groups.io
 help / color / mirror / Atom feed
* [PATCH 0/4] read-only UDF file system support
@ 2017-08-08 19:31 Paulo Alcantara
  2017-08-08 19:31 ` [PATCH 1/4] MdeModulePkg/PartitionDxe: Add UDF/ECMA-167 " Paulo Alcantara
                   ` (4 more replies)
  0 siblings, 5 replies; 17+ messages in thread
From: Paulo Alcantara @ 2017-08-08 19:31 UTC (permalink / raw)
  To: edk2-devel
  Cc: Paulo Alcantara, Laszlo Ersek, Jordan Justen, Andrew Fish,
	Michael D Kinney, Liming Gao, Star Zeng, Eric Dong, Mark Doran

Hi,

I'm posting this series again after ~3 years that introduces UDF file
system support in UEFI. Why? Because Laszlo (or Red Hat) seemed to be
interested in such support.

I started working on this driver just as an excuse to learn UEFI
development at that time. This work isn't based on any previous one and
it's BSD licensed. I also *never* intended to replace it with the
default FAT file system. On the contrary, I was looking to give people
an opportunity to use file system features that current FAT file system
lacks.

This series was never reviewed or fully tested. I basically used Linux
and mkudffs[1] to test different UDF disks, as well as booting a Linux
(EFI stub) rootfs from UDF file systems. Please, I'd really appreciate
if some of one could help reviewing or testing it.

Note that UDF file system support was *only* added to OVMF platform and
it's disabled by default through UDF_ENABLE build option. There's also a
feature PCD flag that turns on or off parsing of UDF volumes during
partition discovery in PartitionDxe driver.

Branch: https://github.com/pcacjr/edk2/tree/udf-fs

Cc: Laszlo Ersek <lersek@redhat.com>
Cc: Jordan Justen <jordan.l.justen@intel.com>
Cc: Andrew Fish <afish@apple.com>
Cc: Michael D Kinney <michael.d.kinney@intel.com>
Cc: Liming Gao <liming.gao@intel.com>
Cc: Star Zeng <star.zeng@intel.com>
Cc: Eric Dong <eric.dong@intel.com>
Cc: Mark Doran <mark.doran@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Paulo Alcantara <pcacjr@zytor.com>
---

Paulo Alcantara (4):
  MdeModulePkg/PartitionDxe: Add UDF/ECMA-167 file system support
  MdeModulePkg: Initial UDF/ECMA-167 file system support
  MdeModulePkg/UdfDxe: Add seek, read and listing support on files
  OvmfPkg: Introduce UDF_ENABLE build flag

 MdeModulePkg/MdeModulePkg.dec                      |    6 +
 .../Universal/Disk/PartitionDxe/Partition.c        |    3 +-
 .../Universal/Disk/PartitionDxe/Partition.h        |   41 +-
 .../Universal/Disk/PartitionDxe/PartitionDxe.inf   |   10 +-
 MdeModulePkg/Universal/Disk/PartitionDxe/Udf.c     |  335 +++
 MdeModulePkg/Universal/Disk/UdfDxe/ComponentName.c |  185 ++
 MdeModulePkg/Universal/Disk/UdfDxe/File.c          |  901 +++++++
 MdeModulePkg/Universal/Disk/UdfDxe/FileName.c      |  195 ++
 .../Universal/Disk/UdfDxe/FileSystemOperations.c   | 2532 ++++++++++++++++++++
 MdeModulePkg/Universal/Disk/UdfDxe/Udf.c           |  407 ++++
 MdeModulePkg/Universal/Disk/UdfDxe/Udf.h           | 1276 ++++++++++
 MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf      |   66 +
 MdePkg/Include/IndustryStandard/Udf.h              |   78 +
 OvmfPkg/OvmfPkgIa32.dsc                            |    7 +
 OvmfPkg/OvmfPkgIa32.fdf                            |    3 +
 OvmfPkg/OvmfPkgIa32X64.dsc                         |    7 +
 OvmfPkg/OvmfPkgIa32X64.fdf                         |    3 +
 OvmfPkg/OvmfPkgX64.dsc                             |    7 +
 OvmfPkg/OvmfPkgX64.fdf                             |    3 +
 19 files changed, 6057 insertions(+), 8 deletions(-)
 create mode 100644 MdeModulePkg/Universal/Disk/PartitionDxe/Udf.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/ComponentName.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/File.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/FileName.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/FileSystemOperations.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/Udf.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/Udf.h
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
 create mode 100644 MdePkg/Include/IndustryStandard/Udf.h

-- 
2.11.0



^ permalink raw reply	[flat|nested] 17+ messages in thread

* [PATCH 1/4] MdeModulePkg/PartitionDxe: Add UDF/ECMA-167 file system support
  2017-08-08 19:31 [PATCH 0/4] read-only UDF file system support Paulo Alcantara
@ 2017-08-08 19:31 ` Paulo Alcantara
  2017-08-08 19:31 ` [PATCH 2/4] MdeModulePkg: Initial " Paulo Alcantara
                   ` (3 subsequent siblings)
  4 siblings, 0 replies; 17+ messages in thread
From: Paulo Alcantara @ 2017-08-08 19:31 UTC (permalink / raw)
  To: edk2-devel
  Cc: Paulo Alcantara, Michael D Kinney, Liming Gao, Star Zeng,
	Eric Dong, Laszlo Ersek

UDF revision 2.00 or higher is the only supported.

Cc: Michael D Kinney <michael.d.kinney@intel.com>
Cc: Liming Gao <liming.gao@intel.com>
Cc: Star Zeng <star.zeng@intel.com>
Cc: Eric Dong <eric.dong@intel.com>
Cc: Laszlo Ersek <lersek@redhat.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Paulo Alcantara <pcacjr@zytor.com>
---
 MdeModulePkg/MdeModulePkg.dec                      |   6 +
 .../Universal/Disk/PartitionDxe/Partition.c        |   3 +-
 .../Universal/Disk/PartitionDxe/Partition.h        |  41 ++-
 .../Universal/Disk/PartitionDxe/PartitionDxe.inf   |  10 +-
 MdeModulePkg/Universal/Disk/PartitionDxe/Udf.c     | 335 +++++++++++++++++++++
 MdePkg/Include/IndustryStandard/Udf.h              |  78 +++++
 6 files changed, 465 insertions(+), 8 deletions(-)
 create mode 100644 MdeModulePkg/Universal/Disk/PartitionDxe/Udf.c
 create mode 100644 MdePkg/Include/IndustryStandard/Udf.h

diff --git a/MdeModulePkg/MdeModulePkg.dec b/MdeModulePkg/MdeModulePkg.dec
index 593bff357a..3bc3b65ebb 100644
--- a/MdeModulePkg/MdeModulePkg.dec
+++ b/MdeModulePkg/MdeModulePkg.dec
@@ -794,6 +794,12 @@
   # @Prompt Turn on PS2 Mouse Extended Verification
   gEfiMdeModulePkgTokenSpaceGuid.PcdPs2MouseExtendedVerification|TRUE|BOOLEAN|0x00010075
 
+  ## Indicates if UDF/ECMA-167 filesystem will be supported.<BR><BR>
+  #   TRUE  -  UDF/ECMA-167 filesystem will be supported.<BR>
+  #   FALSE - UDF/ECMA-167 filesystem will not be supported.<BR>
+  # @Prompt Enable UDF/ECMA-167 filesystem support.
+  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|FALSE|BOOLEAN|0x00010077
+
   ## Indicates whether 64-bit PCI MMIO BARs should degrade to 32-bit in the presence of an option ROM
   #  On X64 platforms, Option ROMs may contain code that executes in the context of a legacy BIOS (CSM),
   #  which requires that all PCI MMIO BARs are located below 4 GB
diff --git a/MdeModulePkg/Universal/Disk/PartitionDxe/Partition.c b/MdeModulePkg/Universal/Disk/PartitionDxe/Partition.c
index 5a7d119b43..152bc72738 100644
--- a/MdeModulePkg/Universal/Disk/PartitionDxe/Partition.c
+++ b/MdeModulePkg/Universal/Disk/PartitionDxe/Partition.c
@@ -2,7 +2,7 @@
   Partition driver that produces logical BlockIo devices from a physical
   BlockIo device. The logical BlockIo devices are based on the format
   of the raw block devices media. Currently "El Torito CD-ROM", Legacy
-  MBR, and GPT partition schemes are supported.
+  MBR, GPT partition and UDF/ECMA-167 volume schemes are supported.
 
 Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
@@ -45,6 +45,7 @@ PARTITION_DETECT_ROUTINE mPartitionDetectRoutineTable[] = {
   PartitionInstallGptChildHandles,
   PartitionInstallElToritoChildHandles,
   PartitionInstallMbrChildHandles,
+  PartitionInstallUdfChildHandles,
   NULL
 };
 
diff --git a/MdeModulePkg/Universal/Disk/PartitionDxe/Partition.h b/MdeModulePkg/Universal/Disk/PartitionDxe/Partition.h
index f2f6185317..a205e3e47b 100644
--- a/MdeModulePkg/Universal/Disk/PartitionDxe/Partition.h
+++ b/MdeModulePkg/Universal/Disk/PartitionDxe/Partition.h
@@ -1,8 +1,8 @@
 /** @file
-  Partition driver that produces logical BlockIo devices from a physical 
+  Partition driver that produces logical BlockIo devices from a physical
   BlockIo device. The logical BlockIo devices are based on the format
-  of the raw block devices media. Currently "El Torito CD-ROM", Legacy 
-  MBR, and GPT partition schemes are supported.
+  of the raw block devices media. Currently "El Torito CD-ROM", Legacy
+  MBR, GPT partition and UDF/ECMA-167 volume schemes are supported.
 
 Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>
 This program and the accompanying materials
@@ -15,8 +15,8 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 
 **/
 
-#ifndef _PARTITION_H_ 
-#define _PARTITION_H_ 
+#ifndef _PARTITION_H_
+#define _PARTITION_H_
 
 #include <Uefi.h>
 #include <Protocol/BlockIo.h>
@@ -39,6 +39,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 
 #include <IndustryStandard/Mbr.h>
 #include <IndustryStandard/ElTorito.h>
+#include <IndustryStandard/Udf.h>
 
 
 //
@@ -428,7 +429,7 @@ PartitionInstallElToritoChildHandles (
   @param[in]  BlockIo           Parent BlockIo interface.
   @param[in]  BlockIo2          Parent BlockIo2 interface.
   @param[in]  DevicePath        Parent Device Path.
-   
+
   @retval EFI_SUCCESS       A child handle was added.
   @retval EFI_MEDIA_CHANGED Media change was detected.
   @retval Others            MBR partition was not found.
@@ -445,6 +446,34 @@ PartitionInstallMbrChildHandles (
   IN  EFI_DEVICE_PATH_PROTOCOL     *DevicePath
   );
 
+/**
+  Install child handles if the Handle supports UDF/ECMA-167 volume format.
+
+  @param[in]  This        Calling context.
+  @param[in]  Handle      Parent Handle.
+  @param[in]  DiskIo      Parent DiskIo interface.
+  @param[in]  DiskIo2     Parent DiskIo2 interface.
+  @param[in]  BlockIo     Parent BlockIo interface.
+  @param[in]  BlockIo2    Parent BlockIo2 interface.
+  @param[in]  DevicePath  Parent Device Path
+
+
+  @retval EFI_SUCCESS         Child handle(s) was added.
+  @retval EFI_MEDIA_CHANGED   Media changed Detected.
+  @retval other               no child handle was added.
+
+**/
+EFI_STATUS
+PartitionInstallUdfChildHandles (
+  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN  EFI_HANDLE                   Handle,
+  IN  EFI_DISK_IO_PROTOCOL         *DiskIo,
+  IN  EFI_DISK_IO2_PROTOCOL        *DiskIo2,
+  IN  EFI_BLOCK_IO_PROTOCOL        *BlockIo,
+  IN  EFI_BLOCK_IO2_PROTOCOL       *BlockIo2,
+  IN  EFI_DEVICE_PATH_PROTOCOL     *DevicePath
+  );
+
 typedef
 EFI_STATUS
 (*PARTITION_DETECT_ROUTINE) (
diff --git a/MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf b/MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf
index 48212773e8..1dfe5509a0 100644
--- a/MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf
+++ b/MdeModulePkg/Universal/Disk/PartitionDxe/PartitionDxe.inf
@@ -4,7 +4,7 @@
 #  This module produces the logical Block I/O device that represents
 #  the bytes from Start to End of the Parent Block I/O device.
 #  The partition of physical BlockIo device supported is one of legacy MBR, GPT,
-#  and "El Torito" partitions.
+#  "El Torito" partitions and UDF/ECMA-167 volumes.
 #
 #  Caution: This module requires additional review when modified.
 #  This driver will have external input - disk partition.
@@ -46,12 +46,14 @@
   Mbr.c
   Gpt.c
   ElTorito.c
+  Udf.c
   Partition.c
   Partition.h
 
 
 [Packages]
   MdePkg/MdePkg.dec
+  MdeModulePkg/MdeModulePkg.dec
 
 
 [LibraryClasses]
@@ -63,6 +65,7 @@
   BaseLib
   UefiDriverEntryPoint
   DebugLib
+  PcdLib
 
 
 [Guids]
@@ -86,5 +89,10 @@
   gEfiDiskIoProtocolGuid                        ## TO_START
   gEfiDiskIo2ProtocolGuid                       ## TO_START
 
+
+[FeaturePcd]
+  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport  ## CONSUMES
+
+
 [UserExtensions.TianoCore."ExtraFiles"]
   PartitionDxeExtra.uni
diff --git a/MdeModulePkg/Universal/Disk/PartitionDxe/Udf.c b/MdeModulePkg/Universal/Disk/PartitionDxe/Udf.c
new file mode 100644
index 0000000000..333b93d666
--- /dev/null
+++ b/MdeModulePkg/Universal/Disk/PartitionDxe/Udf.c
@@ -0,0 +1,335 @@
+/** @file
+  Decode a UDF/ECMA-167 formatted media.
+
+  Copyright (C) 2014-2017 Paulo Alcantara <pcacjr@zytor.com>
+
+  This program and the accompanying materials are licensed and made available
+  under the terms and conditions of the BSD License which accompanies this
+  distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
+  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+**/
+
+#include "Partition.h"
+
+EFI_GUID gUdfVolumeSignatureGuid = {
+  0xC5BD4D42, 0x1A76, 0x4996,
+  { 0x89, 0x56, 0x73, 0xCD, 0xA3, 0x26, 0xCD, 0x0A }
+};
+
+//
+// The UDF/ECMA-167 file system driver only supports UDF revision 2.00 or
+// higher.
+//
+// Note the "NSR03" identifier.
+//
+UDF_STANDARD_IDENTIFIER gUdfStandardIdentifiers[NR_STANDARD_IDENTIFIERS] = {
+  { { 'B', 'E', 'A', '0', '1' } },
+  { { 'N', 'S', 'R', '0', '3' } },
+  { { 'T', 'E', 'A', '0', '1' } },
+};
+
+typedef struct {
+  VENDOR_DEVICE_PATH        DevicePath;
+  EFI_DEVICE_PATH_PROTOCOL  End;
+} UDF_DEVICE_PATH;
+
+//
+// C5BD4D42-1A76-4996-8956-73CDA326CD0A
+//
+#define EFI_UDF_DEVICE_PATH_GUID \
+  { 0xC5BD4D42, 0x1A76, 0x4996, \
+    { 0x89, 0x56, 0x73, 0xCD, 0xA3, 0x26, 0xCD, 0x0A } \
+  }
+
+UDF_DEVICE_PATH gUdfDevicePath = {
+  { { MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP,
+      { sizeof (VENDOR_DEVICE_PATH), 0 } },
+    EFI_UDF_DEVICE_PATH_GUID
+  },
+  { END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE,
+    { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }
+  }
+};
+
+EFI_STATUS
+FindAnchorVolumeDescriptorPointer (
+  IN   EFI_BLOCK_IO_PROTOCOL                 *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL                  *DiskIo,
+  OUT  UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER  *AnchorPoint
+  )
+{
+  EFI_STATUS  Status;
+  UINT32      BlockSize;
+  EFI_LBA     EndLBA;
+
+  BlockSize  = BlockIo->Media->BlockSize;
+  EndLBA     = BlockIo->Media->LastBlock;
+
+  //
+  // Look for AVDP at LBA 256.
+  //
+  Status = DiskIo->ReadDisk (
+    DiskIo,
+    BlockIo->Media->MediaId,
+    256ULL * BlockSize,
+    sizeof (UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER),
+    (VOID *)AnchorPoint
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (IS_AVDP (AnchorPoint)) {
+    return EFI_SUCCESS;
+  }
+
+  //
+  // Look for AVDP at last LBA - 256.
+  //
+  Status = DiskIo->ReadDisk (
+    DiskIo,
+    BlockIo->Media->MediaId,
+    MultU64x32 (EndLBA - 256, BlockSize),
+    sizeof (UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER),
+    (VOID *)AnchorPoint
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (IS_AVDP (AnchorPoint)) {
+    return EFI_SUCCESS;
+  }
+
+  //
+  // Look for AVDP at last LBA.
+  //
+  Status = DiskIo->ReadDisk (
+    DiskIo,
+    BlockIo->Media->MediaId,
+    MultU64x32 (EndLBA, BlockSize),
+    sizeof (UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER),
+    (VOID *)AnchorPoint
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (IS_AVDP (AnchorPoint)) {
+    return EFI_SUCCESS;
+  }
+
+  //
+  // No AVDP found in this media.
+  //
+  return EFI_VOLUME_CORRUPTED;
+}
+
+EFI_STATUS
+SupportUdfFileSystem (
+  IN EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN EFI_DISK_IO_PROTOCOL   *DiskIo
+  )
+{
+  EFI_STATUS                            Status;
+  UINT64                                Offset;
+  UINT64                                EndDiskOffset;
+  UDF_VOLUME_DESCRIPTOR                 VolDescriptor;
+  UDF_VOLUME_DESCRIPTOR                 TerminatingVolDescriptor;
+  UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER  AnchorPoint;
+
+  ZeroMem ((VOID *)&TerminatingVolDescriptor, sizeof (UDF_VOLUME_DESCRIPTOR));
+
+  //
+  // Start Volume Recognition Sequence.
+  //
+  EndDiskOffset = MultU64x32 (BlockIo->Media->LastBlock, BlockIo->Media->BlockSize);
+
+  for (Offset = UDF_VRS_START_OFFSET; Offset < EndDiskOffset;
+       Offset += UDF_LOGICAL_SECTOR_SIZE) {
+    Status = DiskIo->ReadDisk (
+      DiskIo,
+      BlockIo->Media->MediaId,
+      Offset,
+      sizeof (UDF_VOLUME_DESCRIPTOR),
+      (VOID *)&VolDescriptor
+      );
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    if (CompareMem ((VOID *)&VolDescriptor.StandardIdentifier,
+                    (VOID *)&gUdfStandardIdentifiers[BEA_IDENTIFIER],
+                    UDF_STANDARD_IDENTIFIER_LENGTH) == 0) {
+      break;
+    }
+
+    if ((CompareMem ((VOID *)&VolDescriptor.StandardIdentifier,
+                     (VOID *)UDF_CDROM_VOLUME_IDENTIFIER,
+                     UDF_STANDARD_IDENTIFIER_LENGTH) != 0) ||
+        CompareMem ((VOID *)&VolDescriptor,
+                    (VOID *)&TerminatingVolDescriptor,
+                    sizeof (UDF_VOLUME_DESCRIPTOR)) == 0) {
+      return EFI_UNSUPPORTED;
+    }
+  }
+
+  //
+  // Look for "NSR03" identifier in the Extended Area.
+  //
+  Offset += UDF_LOGICAL_SECTOR_SIZE;
+  if (Offset >= EndDiskOffset) {
+    return EFI_UNSUPPORTED;
+  }
+
+  Status = DiskIo->ReadDisk (
+                          DiskIo,
+                          BlockIo->Media->MediaId,
+                          Offset,
+                          sizeof (UDF_VOLUME_DESCRIPTOR),
+                          (VOID *)&VolDescriptor
+                          );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (CompareMem ((VOID *)&VolDescriptor.StandardIdentifier,
+                  (VOID *)&gUdfStandardIdentifiers[VSD_IDENTIFIER],
+                  UDF_STANDARD_IDENTIFIER_LENGTH) != 0) {
+    return EFI_UNSUPPORTED;
+  }
+
+  //
+  // Look for "TEA01" identifier in the Extended Area
+  //
+  Offset += UDF_LOGICAL_SECTOR_SIZE;
+  if (Offset >= EndDiskOffset) {
+    return EFI_UNSUPPORTED;
+  }
+
+  Status = DiskIo->ReadDisk (
+    DiskIo,
+    BlockIo->Media->MediaId,
+    Offset,
+    sizeof (UDF_VOLUME_DESCRIPTOR),
+    (VOID *)&VolDescriptor
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (CompareMem ((VOID *)&VolDescriptor.StandardIdentifier,
+                  (VOID *)&gUdfStandardIdentifiers[TEA_IDENTIFIER],
+                  UDF_STANDARD_IDENTIFIER_LENGTH) != 0) {
+    return EFI_UNSUPPORTED;
+  }
+
+  Status = FindAnchorVolumeDescriptorPointer (BlockIo, DiskIo, &AnchorPoint);
+  if (EFI_ERROR (Status)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Install child handles if the Handle supports UDF/ECMA-167 volume format.
+
+  @param[in]  This        Calling context.
+  @param[in]  Handle      Parent Handle.
+  @param[in]  DiskIo      Parent DiskIo interface.
+  @param[in]  DiskIo2     Parent DiskIo2 interface.
+  @param[in]  BlockIo     Parent BlockIo interface.
+  @param[in]  BlockIo2    Parent BlockIo2 interface.
+  @param[in]  DevicePath  Parent Device Path
+
+
+  @retval EFI_SUCCESS         Child handle(s) was added.
+  @retval EFI_MEDIA_CHANGED   Media changed Detected.
+  @retval other               no child handle was added.
+
+**/
+EFI_STATUS
+PartitionInstallUdfChildHandles (
+  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN  EFI_HANDLE                   Handle,
+  IN  EFI_DISK_IO_PROTOCOL         *DiskIo,
+  IN  EFI_DISK_IO2_PROTOCOL        *DiskIo2,
+  IN  EFI_BLOCK_IO_PROTOCOL        *BlockIo,
+  IN  EFI_BLOCK_IO2_PROTOCOL       *BlockIo2,
+  IN  EFI_DEVICE_PATH_PROTOCOL     *DevicePath
+  )
+{
+  EFI_STATUS                   Status;
+  EFI_BLOCK_IO_MEDIA           *Media;
+  EFI_DEVICE_PATH_PROTOCOL     *LastDevicePathNode;
+  EFI_DEVICE_PATH_PROTOCOL     *DevicePathNode;
+  EFI_GUID                     *VendorDevGuid;
+  EFI_GUID                     UdfDevGuid = EFI_UDF_DEVICE_PATH_GUID;
+  EFI_PARTITION_INFO_PROTOCOL  PartitionInfo;
+
+  Media = BlockIo->Media;
+
+  //
+  // Check if platform supports UDF file system.
+  //
+  if (!FeaturePcdGet (PcdUdfFileSystemSupport)) {
+    return EFI_NOT_FOUND;
+  }
+
+  //
+  // Check if UDF logical block size is multiple of underlying device block
+  // size.
+  //
+  if ((UDF_LOGICAL_SECTOR_SIZE % Media->BlockSize) != 0 ||
+      (Media->BlockSize > UDF_LOGICAL_SECTOR_SIZE)) {
+    return EFI_NOT_FOUND;
+  }
+
+  Status = SupportUdfFileSystem (BlockIo, DiskIo);
+  if (EFI_ERROR (Status)) {
+    return EFI_NOT_FOUND;
+  }
+
+  LastDevicePathNode = NULL;
+  DevicePathNode = DevicePath;
+  while (!IsDevicePathEnd (DevicePathNode)) {
+    LastDevicePathNode  = DevicePathNode;
+    DevicePathNode      = NextDevicePathNode (DevicePathNode);
+  }
+  if (LastDevicePathNode) {
+    VendorDevGuid = (EFI_GUID *)((UINT8 *)LastDevicePathNode +
+                                 OFFSET_OF (VENDOR_DEVICE_PATH, Guid));
+    if (DevicePathSubType (LastDevicePathNode) == MEDIA_VENDOR_DP &&
+        CompareGuid (VendorDevGuid, &UdfDevGuid)) {
+      return EFI_NOT_FOUND;
+    }
+  }
+
+  ZeroMem (&PartitionInfo, sizeof (EFI_PARTITION_INFO_PROTOCOL));
+  PartitionInfo.Revision = EFI_PARTITION_INFO_PROTOCOL_REVISION;
+  PartitionInfo.Type = PARTITION_TYPE_OTHER;
+
+  Status = PartitionInstallChildHandle (
+    This,
+    Handle,
+    DiskIo,
+    DiskIo2,
+    BlockIo,
+    BlockIo2,
+    DevicePath,
+    (EFI_DEVICE_PATH_PROTOCOL *)&gUdfDevicePath,
+    &PartitionInfo,
+    0,
+    Media->LastBlock,
+    Media->BlockSize
+    );
+  if (!EFI_ERROR (Status)) {
+    Status = EFI_NOT_FOUND;
+  }
+
+  return Status;
+}
diff --git a/MdePkg/Include/IndustryStandard/Udf.h b/MdePkg/Include/IndustryStandard/Udf.h
new file mode 100644
index 0000000000..d571424315
--- /dev/null
+++ b/MdePkg/Include/IndustryStandard/Udf.h
@@ -0,0 +1,78 @@
+/** @file
+  UDF/ECMA-167 Volume and File Structure Format Definition.
+
+  Copyright (C) 2014-2017 Paulo Alcantara <pcacjr@zytor.com>
+
+  This program and the accompanying materials are licensed and made available
+  under the terms and conditions of the BSD License which accompanies this
+  distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
+  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+**/
+
+#ifndef _UDF_H_
+#define _UDF_H_
+
+#define UDF_LOGICAL_SECTOR_SHIFT  11
+#define UDF_LOGICAL_SECTOR_SIZE   ((UINT64)(1ULL << UDF_LOGICAL_SECTOR_SHIFT))
+#define UDF_VRS_START_OFFSET      ((UINT64)(16ULL << UDF_LOGICAL_SECTOR_SHIFT))
+#define UDF_STANDARD_IDENTIFIER_LENGTH  5
+#define UDF_CDROM_VOLUME_IDENTIFIER     "CD001"
+
+#define _GET_TAG_ID(_Pointer) \
+  (((UDF_DESCRIPTOR_TAG *) (_Pointer))->TagIdentifier)
+
+#define IS_PVD(_Pointer) \
+  ((BOOLEAN)(_GET_TAG_ID (_Pointer) == 1))
+#define IS_AVDP(_Pointer) \
+  ((BOOLEAN)(_GET_TAG_ID (_Pointer) == 2))
+
+typedef struct {
+  UINT8 StandardIdentifier[UDF_STANDARD_IDENTIFIER_LENGTH];
+} UDF_STANDARD_IDENTIFIER;
+
+enum {
+  BEA_IDENTIFIER,
+  VSD_IDENTIFIER,
+  TEA_IDENTIFIER,
+  NR_STANDARD_IDENTIFIERS,
+};
+
+#pragma pack(1)
+
+typedef struct {
+  UINT16  TagIdentifier;
+  UINT16  DescriptorVersion;
+  UINT8   TagChecksum;
+  UINT8   Reserved;
+  UINT16  TagSerialNumber;
+  UINT16  DescriptorCRC;
+  UINT16  DescriptorCRCLength;
+  UINT32  TagLocation;
+} UDF_DESCRIPTOR_TAG;
+
+typedef struct {
+  UINT32  ExtentLength;
+  UINT32  ExtentLocation;
+} UDF_EXTENT_AD;
+
+typedef struct {
+  UINT8  StructureType;
+  UINT8  StandardIdentifier[UDF_STANDARD_IDENTIFIER_LENGTH];
+  UINT8  StructureVersion;
+  UINT8  Reserved;
+  UINT8  StructureData[2040];
+} UDF_VOLUME_DESCRIPTOR;
+
+typedef struct {
+  UDF_DESCRIPTOR_TAG  DescriptorTag;
+  UDF_EXTENT_AD       MainVolumeDescriptorSequenceExtent;
+  UDF_EXTENT_AD       ReserveVolumeDescriptorSequenceExtent;
+  UINT8               Reserved[480];
+} UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER;
+
+#pragma pack()
+
+#endif // _UDF_H_
-- 
2.11.0



^ permalink raw reply related	[flat|nested] 17+ messages in thread

* [PATCH 2/4] MdeModulePkg: Initial UDF/ECMA-167 file system support
  2017-08-08 19:31 [PATCH 0/4] read-only UDF file system support Paulo Alcantara
  2017-08-08 19:31 ` [PATCH 1/4] MdeModulePkg/PartitionDxe: Add UDF/ECMA-167 " Paulo Alcantara
@ 2017-08-08 19:31 ` Paulo Alcantara
  2017-08-08 19:31 ` [PATCH 3/4] MdeModulePkg/UdfDxe: Add seek, read and listing support on files Paulo Alcantara
                   ` (2 subsequent siblings)
  4 siblings, 0 replies; 17+ messages in thread
From: Paulo Alcantara @ 2017-08-08 19:31 UTC (permalink / raw)
  To: edk2-devel; +Cc: Paulo Alcantara, Star Zeng, Eric Dong, Laszlo Ersek

A new child device handle will be installed if the Controller handle which
has BlockIo and DiskIo contains an UDF 2.00 (or higher) volume in it.

Find root directory, lookup and open operations on regular, directory and
symlink files are supported.

Cc: Star Zeng <star.zeng@intel.com>
Cc: Eric Dong <eric.dong@intel.com>
Cc: Laszlo Ersek <lersek@redhat.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Paulo Alcantara <pcacjr@zytor.com>
---
 MdeModulePkg/Universal/Disk/UdfDxe/ComponentName.c |  185 ++
 MdeModulePkg/Universal/Disk/UdfDxe/File.c          |  651 ++++++
 MdeModulePkg/Universal/Disk/UdfDxe/FileName.c      |  195 ++
 .../Universal/Disk/UdfDxe/FileSystemOperations.c   | 2472 ++++++++++++++++++++
 MdeModulePkg/Universal/Disk/UdfDxe/Udf.c           |  407 ++++
 MdeModulePkg/Universal/Disk/UdfDxe/Udf.h           | 1243 ++++++++++
 MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf      |   66 +
 7 files changed, 5219 insertions(+)
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/ComponentName.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/File.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/FileName.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/FileSystemOperations.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/Udf.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/Udf.h
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf

diff --git a/MdeModulePkg/Universal/Disk/UdfDxe/ComponentName.c b/MdeModulePkg/Universal/Disk/UdfDxe/ComponentName.c
new file mode 100644
index 0000000000..0b0d6afbf0
--- /dev/null
+++ b/MdeModulePkg/Universal/Disk/UdfDxe/ComponentName.c
@@ -0,0 +1,185 @@
+/** @file
+  UEFI Component Name protocol for UDF/ECMA-167 file system driver.
+
+  Copyright (C) 2014-2017 Paulo Alcantara <pcacjr@zytor.com>
+
+  This program and the accompanying materials are licensed and made available
+  under the terms and conditions of the BSD License which accompanies this
+  distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
+  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+**/
+
+#include "Udf.h"
+
+//
+// EFI Component Name Protocol
+//
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME_PROTOCOL  gUdfComponentName = {
+  UdfComponentNameGetDriverName,
+  UdfComponentNameGetControllerName,
+  "eng"
+};
+
+//
+// EFI Component Name 2 Protocol
+//
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL gUdfComponentName2 = {
+  (EFI_COMPONENT_NAME2_GET_DRIVER_NAME) UdfComponentNameGetDriverName,
+  (EFI_COMPONENT_NAME2_GET_CONTROLLER_NAME) UdfComponentNameGetControllerName,
+  "en"
+};
+
+//
+// Driver name table for Udf module.
+// It is shared by the implementation of ComponentName & ComponentName2 Protocol.
+//
+GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE mUdfDriverNameTable[] = {
+  {
+    "eng;en",
+    L"UDF Filesystem Driver"
+  },
+  {
+    NULL,
+    NULL
+  }
+};
+
+/**
+  Retrieves a Unicode string that is the user readable name of the driver.
+
+  This function retrieves the user readable name of a driver in the form of a
+  Unicode string. If the driver specified by This has a user readable name in
+  the language specified by Language, then a pointer to the driver name is
+  returned in DriverName, and EFI_SUCCESS is returned. If the driver specified
+  by This does not support the language specified by Language,
+  then EFI_UNSUPPORTED is returned.
+
+  @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
+                                EFI_COMPONENT_NAME_PROTOCOL instance.
+
+  @param  Language[in]          A pointer to a Null-terminated ASCII string
+                                array indicating the language. This is the
+                                language of the driver name that the caller is
+                                requesting, and it must match one of the
+                                languages specified in SupportedLanguages. The
+                                number of languages supported by a driver is up
+                                to the driver writer. Language is specified
+                                in RFC 4646 or ISO 639-2 language code format.
+
+  @param  DriverName[out]       A pointer to the Unicode string to return.
+                                This Unicode string is the name of the
+                                driver specified by This in the language
+                                specified by Language.
+
+  @retval EFI_SUCCESS           The Unicode string for the Driver specified by
+                                This and the language specified by Language was
+                                returned in DriverName.
+
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+
+  @retval EFI_INVALID_PARAMETER DriverName is NULL.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support
+                                the language specified by Language.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfComponentNameGetDriverName (
+  IN   EFI_COMPONENT_NAME_PROTOCOL  *This,
+  IN   CHAR8                        *Language,
+  OUT  CHAR16                       **DriverName
+  )
+{
+  return LookupUnicodeString2 (
+    Language,
+    This->SupportedLanguages,
+    mUdfDriverNameTable,
+    DriverName,
+    (BOOLEAN)(This == &gUdfComponentName)
+    );
+}
+
+/**
+  Retrieves a Unicode string that is the user readable name of the controller
+  that is being managed by a driver.
+
+  This function retrieves the user readable name of the controller specified by
+  ControllerHandle and ChildHandle in the form of a Unicode string. If the
+  driver specified by This has a user readable name in the language specified by
+  Language, then a pointer to the controller name is returned in ControllerName,
+  and EFI_SUCCESS is returned.  If the driver specified by This is not currently
+  managing the controller specified by ControllerHandle and ChildHandle,
+  then EFI_UNSUPPORTED is returned.  If the driver specified by This does not
+  support the language specified by Language, then EFI_UNSUPPORTED is returned.
+
+  @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
+                                EFI_COMPONENT_NAME_PROTOCOL instance.
+
+  @param  ControllerHandle[in]  The handle of a controller that the driver
+                                specified by This is managing.  This handle
+                                specifies the controller whose name is to be
+                                returned.
+
+  @param  ChildHandle[in]       The handle of the child controller to retrieve
+                                the name of.  This is an optional parameter that
+                                may be NULL.  It will be NULL for device
+                                drivers.  It will also be NULL for a bus drivers
+                                that wish to retrieve the name of the bus
+                                controller.  It will not be NULL for a bus
+                                driver that wishes to retrieve the name of a
+                                child controller.
+
+  @param  Language[in]          A pointer to a Null-terminated ASCII string
+                                array indicating the language.  This is the
+                                language of the driver name that the caller is
+                                requesting, and it must match one of the
+                                languages specified in SupportedLanguages. The
+                                number of languages supported by a driver is up
+                                to the driver writer. Language is specified in
+                                RFC 4646 or ISO 639-2 language code format.
+
+  @param  ControllerName[out]   A pointer to the Unicode string to return.
+                                This Unicode string is the name of the
+                                controller specified by ControllerHandle and
+                                ChildHandle in the language specified by
+                                Language from the point of view of the driver
+                                specified by This.
+
+  @retval EFI_SUCCESS           The Unicode string for the user readable name in
+                                the language specified by Language for the
+                                driver specified by This was returned in
+                                DriverName.
+
+  @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
+
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
+                                EFI_HANDLE.
+
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+
+  @retval EFI_INVALID_PARAMETER ControllerName is NULL.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This is not currently
+                                managing the controller specified by
+                                ControllerHandle and ChildHandle.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support
+                                the language specified by Language.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfComponentNameGetControllerName (
+  IN   EFI_COMPONENT_NAME_PROTOCOL  *This,
+  IN   EFI_HANDLE                   ControllerHandle,
+  IN   EFI_HANDLE                   ChildHandle OPTIONAL,
+  IN   CHAR8                        *Language,
+  OUT  CHAR16                       **ControllerName
+  )
+{
+  return EFI_UNSUPPORTED;
+}
diff --git a/MdeModulePkg/Universal/Disk/UdfDxe/File.c b/MdeModulePkg/Universal/Disk/UdfDxe/File.c
new file mode 100644
index 0000000000..dcb9ff2cf5
--- /dev/null
+++ b/MdeModulePkg/Universal/Disk/UdfDxe/File.c
@@ -0,0 +1,651 @@
+/** @file
+  Handle operations in files and directories from UDF/ECMA-167 file systems.
+
+  Copyright (C) 2014-2017 Paulo Alcantara <pcacjr@zytor.com>
+
+  This program and the accompanying materials are licensed and made available
+  under the terms and conditions of the BSD License which accompanies this
+  distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
+  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+**/
+
+#include "Udf.h"
+
+EFI_FILE_PROTOCOL gUdfFileIoOps = {
+  EFI_FILE_PROTOCOL_REVISION,
+  UdfOpen,
+  UdfClose,
+  UdfDelete,
+  UdfRead,
+  UdfWrite,
+  UdfGetPosition,
+  UdfSetPosition,
+  UdfGetInfo,
+  UdfSetInfo,
+  UdfFlush,
+  NULL,
+  NULL,
+  NULL,
+  NULL
+};
+
+#define _ROOT_FILE(_PrivData) (_PrivData)->Root
+#define _PARENT_FILE(_PrivData) \
+  ((_PrivData)->IsRootDirectory ? (_PrivData)->Root : &(_PrivData)->File)
+#define _FILE(_PrivData) _PARENT_FILE(_PrivData)
+
+/**
+  Open the root directory on a volume.
+
+  @param  This Protocol instance pointer.
+  @param  Root Returns an Open file handle for the root directory
+
+  @retval EFI_SUCCESS          The device was opened.
+  @retval EFI_UNSUPPORTED      This volume does not support the file system.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_ACCESS_DENIED    The service denied access to the file.
+  @retval EFI_OUT_OF_RESOURCES The volume was not opened due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfOpenVolume (
+  IN   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *This,
+  OUT  EFI_FILE_PROTOCOL                **Root
+  )
+{
+  EFI_TPL                     OldTpl;
+  EFI_STATUS                  Status;
+  PRIVATE_UDF_SIMPLE_FS_DATA  *PrivFsData;
+  PRIVATE_UDF_FILE_DATA       *PrivFileData;
+
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+
+  if (This == NULL || Root == NULL) {
+    Status = EFI_INVALID_PARAMETER;
+    goto Error_Invalid_Params;
+  }
+
+  PrivFsData = PRIVATE_UDF_SIMPLE_FS_DATA_FROM_THIS (This);
+
+  if (PrivFsData->OpenFiles == 0) {
+    //
+    // There is no more open files. Read volume information again since it was
+    // cleaned up on the last UdfClose() call.
+    //
+    Status = ReadUdfVolumeInformation (
+      PrivFsData->BlockIo,
+      PrivFsData->DiskIo,
+      &PrivFsData->Volume
+      );
+    if (EFI_ERROR (Status)) {
+      goto Error_Read_Udf_Volume;
+    }
+  }
+
+  CleanupFileInformation (&PrivFsData->Root);
+
+  //
+  // Find root directory file.
+  //
+  Status = FindRootDirectory (PrivFsData->BlockIo,
+                              PrivFsData->DiskIo,
+                              &PrivFsData->Volume,
+                              &PrivFsData->Root);
+  if (EFI_ERROR (Status)) {
+    goto Error_Find_Root_Dir;
+  }
+
+  PrivFileData =
+    (PRIVATE_UDF_FILE_DATA *) AllocateZeroPool (sizeof (PRIVATE_UDF_FILE_DATA));
+  if (PrivFileData == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto Error_Alloc_Priv_File_Data;
+  }
+
+  PrivFileData->Signature        = PRIVATE_UDF_FILE_DATA_SIGNATURE;
+  PrivFileData->SimpleFs         = This;
+  PrivFileData->Root             = &PrivFsData->Root;
+  PrivFileData->IsRootDirectory  = TRUE;
+
+  CopyMem ((VOID *)&PrivFileData->FileIo, (VOID *)&gUdfFileIoOps,
+           sizeof (EFI_FILE_PROTOCOL));
+
+  *Root = &PrivFileData->FileIo;
+
+  PrivFsData->OpenFiles++;
+
+  gBS->RestoreTPL (OldTpl);
+
+  return EFI_SUCCESS;
+
+Error_Alloc_Priv_File_Data:
+  CleanupFileInformation (&PrivFsData->Root);
+
+Error_Find_Root_Dir:
+  CleanupVolumeInformation (&PrivFsData->Volume);
+
+Error_Read_Udf_Volume:
+Error_Invalid_Params:
+  gBS->RestoreTPL (OldTpl);
+
+  return Status;
+}
+
+/**
+  Opens a new file relative to the source file's location.
+
+  @param  This       The protocol instance pointer.
+  @param  NewHandle  Returns File Handle for FileName.
+  @param  FileName   Null terminated string. "\", ".", and ".." are supported.
+  @param  OpenMode   Open mode for file.
+  @param  Attributes Only used for EFI_FILE_MODE_CREATE.
+
+  @retval EFI_SUCCESS          The device was opened.
+  @retval EFI_NOT_FOUND        The specified file could not be found on the
+                               device.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_MEDIA_CHANGED    The media has changed.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_ACCESS_DENIED    The service denied access to the file.
+  @retval EFI_OUT_OF_RESOURCES The volume was not opened due to lack of
+                               resources.
+  @retval EFI_VOLUME_FULL      The volume is full.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfOpen (
+  IN   EFI_FILE_PROTOCOL  *This,
+  OUT  EFI_FILE_PROTOCOL  **NewHandle,
+  IN   CHAR16             *FileName,
+  IN   UINT64             OpenMode,
+  IN   UINT64             Attributes
+  )
+{
+  EFI_TPL                     OldTpl;
+  EFI_STATUS                  Status;
+  PRIVATE_UDF_FILE_DATA       *PrivFileData;
+  PRIVATE_UDF_SIMPLE_FS_DATA  *PrivFsData;
+  CHAR16                      FilePath[UDF_PATH_LENGTH] = { 0 };
+  UDF_FILE_INFO               File;
+  PRIVATE_UDF_FILE_DATA       *NewPrivFileData;
+  CHAR16                      *TempFileName;
+
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+
+  if (This == NULL || NewHandle == NULL || FileName == NULL) {
+    Status = EFI_INVALID_PARAMETER;
+    goto Error_Invalid_Params;
+  }
+
+  if (OpenMode != EFI_FILE_MODE_READ) {
+    Status = EFI_WRITE_PROTECTED;
+    goto Error_Invalid_Params;
+  }
+
+  PrivFileData = PRIVATE_UDF_FILE_DATA_FROM_THIS (This);
+
+  PrivFsData = PRIVATE_UDF_SIMPLE_FS_DATA_FROM_THIS (PrivFileData->SimpleFs);
+
+  //
+  // Build full path
+  //
+  if (FileName[0] == L'\\') {
+    StrCpyS (FilePath, UDF_PATH_LENGTH, FileName);
+  } else {
+    StrCpyS (FilePath, UDF_PATH_LENGTH, PrivFileData->AbsoluteFileName);
+    StrCatS (FilePath, UDF_PATH_LENGTH, L"\\");
+    StrCatS (FilePath, UDF_PATH_LENGTH, FileName);
+  }
+
+  MangleFileName (FilePath);
+  if (FilePath[0] == L'\0') {
+    Status = EFI_NOT_FOUND;
+    goto Error_Bad_FileName;
+  }
+
+  Status = FindFile (
+    PrivFsData->BlockIo,
+    PrivFsData->DiskIo,
+    &PrivFsData->Volume,
+    FilePath,
+    _ROOT_FILE (PrivFileData),
+    _PARENT_FILE (PrivFileData),
+    &_PARENT_FILE(PrivFileData)->FileIdentifierDesc->Icb,
+    &File
+    );
+  if (EFI_ERROR (Status)) {
+    goto Error_Find_File;
+  }
+
+  NewPrivFileData =
+    (PRIVATE_UDF_FILE_DATA *)AllocateZeroPool (sizeof (PRIVATE_UDF_FILE_DATA));
+  if (NewPrivFileData == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto Error_Alloc_New_Priv_File_Data;
+  }
+
+  CopyMem ((VOID *)NewPrivFileData, (VOID *)PrivFileData,
+           sizeof (PRIVATE_UDF_FILE_DATA));
+  CopyMem ((VOID *)&NewPrivFileData->File, &File, sizeof (UDF_FILE_INFO));
+
+  NewPrivFileData->IsRootDirectory = FALSE;
+
+  StrCpyS (NewPrivFileData->AbsoluteFileName, UDF_PATH_LENGTH, FilePath);
+  FileName = NewPrivFileData->AbsoluteFileName;
+
+  while ((TempFileName = StrStr (FileName, L"\\")) != NULL) {
+    FileName = TempFileName + 1;
+  }
+
+  StrCpyS (NewPrivFileData->FileName, UDF_PATH_LENGTH, FileName);
+  Status = GetFileSize (
+    PrivFsData->BlockIo,
+    PrivFsData->DiskIo,
+    &PrivFsData->Volume,
+    &NewPrivFileData->File,
+    &NewPrivFileData->FileSize
+    );
+  if (EFI_ERROR (Status)) {
+    goto Error_Get_File_Size;
+  }
+
+  NewPrivFileData->FilePosition = 0;
+  ZeroMem ((VOID *)&NewPrivFileData->ReadDirInfo,
+           sizeof (UDF_READ_DIRECTORY_INFO));
+
+  *NewHandle = &NewPrivFileData->FileIo;
+
+  PrivFsData->OpenFiles++;
+
+  gBS->RestoreTPL (OldTpl);
+
+  return Status;
+
+Error_Get_File_Size:
+  FreePool ((VOID *)NewPrivFileData);
+
+Error_Alloc_New_Priv_File_Data:
+  CleanupFileInformation (&File);
+
+Error_Find_File:
+Error_Bad_FileName:
+Error_Invalid_Params:
+  gBS->RestoreTPL (OldTpl);
+
+  return Status;
+}
+
+/**
+  Read data from the file.
+
+  @param  This       Protocol instance pointer.
+  @param  BufferSize On input size of buffer, on output amount of data in
+                     buffer.
+  @param  Buffer     The buffer in which data is read.
+
+  @retval EFI_SUCCESS          Data was read.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_BUFFER_TO_SMALL  BufferSize is too small. BufferSize contains
+                               required size.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfRead (
+  IN      EFI_FILE_PROTOCOL  *This,
+  IN OUT  UINTN              *BufferSize,
+  OUT     VOID               *Buffer
+  )
+{
+  return EFI_VOLUME_CORRUPTED;
+}
+
+/**
+  Close the file handle.
+
+  @param  This Protocol instance pointer.
+
+  @retval EFI_SUCCESS The file was closed.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfClose (
+  IN EFI_FILE_PROTOCOL *This
+  )
+{
+  EFI_TPL                     OldTpl;
+  EFI_STATUS                  Status;
+  PRIVATE_UDF_FILE_DATA       *PrivFileData;
+  PRIVATE_UDF_SIMPLE_FS_DATA  *PrivFsData;
+
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+
+  Status = EFI_SUCCESS;
+
+  if (This == NULL) {
+    Status = EFI_INVALID_PARAMETER;
+    goto Exit;
+  }
+
+  PrivFileData = PRIVATE_UDF_FILE_DATA_FROM_THIS (This);
+
+  PrivFsData = PRIVATE_UDF_SIMPLE_FS_DATA_FROM_THIS (PrivFileData->SimpleFs);
+
+  if (!PrivFileData->IsRootDirectory) {
+    CleanupFileInformation (&PrivFileData->File);
+
+    if (PrivFileData->ReadDirInfo.DirectoryData) {
+      FreePool (PrivFileData->ReadDirInfo.DirectoryData);
+    }
+  }
+
+  if (--PrivFsData->OpenFiles == 0) {
+    CleanupVolumeInformation (&PrivFsData->Volume);
+  }
+
+  FreePool ((VOID *)PrivFileData);
+
+Exit:
+  gBS->RestoreTPL (OldTpl);
+
+  return Status;
+}
+
+/**
+  Close and delete the file handle.
+
+  @param  This                     Protocol instance pointer.
+
+  @retval EFI_SUCCESS              The file was closed and deleted.
+  @retval EFI_WARN_DELETE_FAILURE  The handle was closed but the file was not
+                                   deleted.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfDelete (
+  IN EFI_FILE_PROTOCOL  *This
+  )
+{
+  PRIVATE_UDF_FILE_DATA *PrivFileData;
+
+  if (This == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  PrivFileData = PRIVATE_UDF_FILE_DATA_FROM_THIS (This);
+
+  (VOID)PrivFileData->FileIo.Close(This);
+
+  return EFI_WARN_DELETE_FAILURE;
+}
+
+/**
+  Write data to a file.
+
+  @param  This       Protocol instance pointer.
+  @param  BufferSize On input size of buffer, on output amount of data in
+                     buffer.
+  @param  Buffer     The buffer in which data to write.
+
+  @retval EFI_SUCCESS          Data was written.
+  @retval EFI_UNSUPPORTED      Writes to Open directory are not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_DEVICE_ERROR     An attempt was made to write to a deleted file.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The device is write protected.
+  @retval EFI_ACCESS_DENIED    The file was open for read only.
+  @retval EFI_VOLUME_FULL      The volume is full.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfWrite (
+  IN      EFI_FILE_PROTOCOL  *This,
+  IN OUT  UINTN              *BufferSize,
+  IN      VOID               *Buffer
+  )
+{
+  return EFI_UNSUPPORTED;
+}
+
+/**
+  Get file's current position.
+
+  @param  This      Protocol instance pointer.
+  @param  Position  Byte position from the start of the file.
+
+  @retval EFI_SUCCESS      Position was updated.
+  @retval EFI_UNSUPPORTED  Seek request for directories is not valid.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfGetPosition (
+  IN   EFI_FILE_PROTOCOL  *This,
+  OUT  UINT64             *Position
+  )
+{
+  return EFI_UNSUPPORTED;
+}
+
+/**
+  Set file's current position.
+
+  @param  This      Protocol instance pointer.
+  @param  Position  Byte position from the start of the file.
+
+  @retval EFI_SUCCESS      Position was updated.
+  @retval EFI_UNSUPPORTED  Seek request for non-zero is not valid on open.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfSetPosition (
+  IN EFI_FILE_PROTOCOL  *This,
+  IN UINT64             Position
+  )
+{
+  return EFI_UNSUPPORTED;
+}
+
+/**
+  Get information about a file.
+
+  @param  This            Protocol instance pointer.
+  @param  InformationType Type of information to return in Buffer.
+  @param  BufferSize      On input size of buffer, on output amount of data in
+                          buffer.
+  @param  Buffer          The buffer to return data.
+
+  @retval EFI_SUCCESS          Data was returned.
+  @retval EFI_UNSUPPORTED      InformationType is not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The device is write protected.
+  @retval EFI_ACCESS_DENIED    The file was open for read only.
+  @retval EFI_BUFFER_TOO_SMALL Buffer was too small; required size returned in
+                               BufferSize.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfGetInfo (
+  IN      EFI_FILE_PROTOCOL  *This,
+  IN      EFI_GUID           *InformationType,
+  IN OUT  UINTN              *BufferSize,
+  OUT     VOID               *Buffer
+  )
+{
+  EFI_STATUS                  Status;
+  PRIVATE_UDF_FILE_DATA       *PrivFileData;
+  PRIVATE_UDF_SIMPLE_FS_DATA  *PrivFsData;
+  EFI_FILE_SYSTEM_INFO        *FileSystemInfo;
+  UINTN                       FileSystemInfoLength;
+  CHAR16                      *String;
+  UDF_FILE_SET_DESCRIPTOR     *FileSetDesc;
+  UINTN                       Index;
+  UINT8                       *OstaCompressed;
+  UINT8                       CompressionId;
+  UINT64                      VolumeSize;
+  UINT64                      FreeSpaceSize;
+  CHAR16                      VolumeLabel[64];
+
+  if (This == NULL || InformationType == NULL || BufferSize == 0 ||
+      (*BufferSize != 0 && Buffer == NULL)) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  PrivFileData = PRIVATE_UDF_FILE_DATA_FROM_THIS (This);
+
+  PrivFsData = PRIVATE_UDF_SIMPLE_FS_DATA_FROM_THIS (PrivFileData->SimpleFs);
+
+  Status = EFI_UNSUPPORTED;
+
+  if (CompareGuid (InformationType, &gEfiFileInfoGuid)) {
+    Status = SetFileInfo (
+      _FILE (PrivFileData),
+      PrivFileData->FileSize,
+      PrivFileData->FileName,
+      BufferSize,
+      Buffer
+      );
+  } else if (CompareGuid (InformationType, &gEfiFileSystemInfoGuid)) {
+    String = VolumeLabel;
+
+    FileSetDesc = PrivFsData->Volume.FileSetDescs[0];
+
+    OstaCompressed = &FileSetDesc->LogicalVolumeIdentifier[0];
+
+    CompressionId = OstaCompressed[0];
+    if (!IS_VALID_COMPRESSION_ID (CompressionId)) {
+      return EFI_VOLUME_CORRUPTED;
+    }
+
+    for (Index = 1; Index < 128; Index++) {
+      if (CompressionId == 16) {
+        *String = *(UINT8 *)(OstaCompressed + Index) << 8;
+        Index++;
+      } else {
+        *String = 0;
+      }
+
+      if (Index < 128) {
+        *String |= *(UINT8 *)(OstaCompressed + Index);
+      }
+
+      //
+      // Unlike FID Identifiers, Logical Volume Identifier is stored in a
+      // NULL-terminated OSTA compressed format, so we must check for the NULL
+      // character.
+      //
+      if (!*String) {
+        break;
+      }
+
+      String++;
+    }
+
+    *String = L'\0';
+
+    FileSystemInfoLength = StrSize (VolumeLabel) +
+                           sizeof (EFI_FILE_SYSTEM_INFO);
+    if (*BufferSize < FileSystemInfoLength) {
+      *BufferSize = FileSystemInfoLength;
+      return EFI_BUFFER_TOO_SMALL;
+    }
+
+    FileSystemInfo = (EFI_FILE_SYSTEM_INFO *)Buffer;
+    StrCpyS (FileSystemInfo->VolumeLabel, ARRAY_SIZE (VolumeLabel),
+             VolumeLabel);
+    Status = GetVolumeSize (
+      PrivFsData->BlockIo,
+      PrivFsData->DiskIo,
+      &PrivFsData->Volume,
+      &VolumeSize,
+      &FreeSpaceSize
+      );
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    FileSystemInfo->Size        = FileSystemInfoLength;
+    FileSystemInfo->ReadOnly    = TRUE;
+    FileSystemInfo->BlockSize   =
+      LV_BLOCK_SIZE (&PrivFsData->Volume, UDF_DEFAULT_LV_NUM);
+    FileSystemInfo->VolumeSize  = VolumeSize;
+    FileSystemInfo->FreeSpace   = FreeSpaceSize;
+
+    *BufferSize = FileSystemInfoLength;
+    Status = EFI_SUCCESS;
+  }
+
+  return Status;
+}
+
+/**
+  Set information about a file.
+
+  @param  File            Protocol instance pointer.
+  @param  InformationType Type of information in Buffer.
+  @param  BufferSize      Size of buffer.
+  @param  Buffer          The data to write.
+
+  @retval EFI_SUCCESS          Data was set.
+  @retval EFI_UNSUPPORTED      InformationType is not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The device is write protected.
+  @retval EFI_ACCESS_DENIED    The file was open for read only.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfSetInfo (
+  IN EFI_FILE_PROTOCOL  *This,
+  IN EFI_GUID           *InformationType,
+  IN UINTN              BufferSize,
+  IN VOID               *Buffer
+  )
+{
+  return EFI_WRITE_PROTECTED;
+}
+
+/**
+  Flush data back for the file handle.
+
+  @param  This Protocol instance pointer.
+
+  @retval EFI_SUCCESS          Data was flushed.
+  @retval EFI_UNSUPPORTED      Writes to Open directory are not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The device is write protected.
+  @retval EFI_ACCESS_DENIED    The file was open for read only.
+  @retval EFI_VOLUME_FULL      The volume is full.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfFlush (
+  IN EFI_FILE_PROTOCOL *This
+  )
+{
+  return EFI_WRITE_PROTECTED;
+}
diff --git a/MdeModulePkg/Universal/Disk/UdfDxe/FileName.c b/MdeModulePkg/Universal/Disk/UdfDxe/FileName.c
new file mode 100644
index 0000000000..1c4bd091bf
--- /dev/null
+++ b/MdeModulePkg/Universal/Disk/UdfDxe/FileName.c
@@ -0,0 +1,195 @@
+/** @file
+  Helper functions for mangling file names in UDF/ECMA-167 file systems.
+
+  Copyright (C) 2014-2017 Paulo Alcantara <pcacjr@zytor.com>
+
+  This program and the accompanying materials are licensed and made available
+  under the terms and conditions of the BSD License which accompanies this
+  distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
+  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+**/
+
+#include "Udf.h"
+
+CHAR16 *
+TrimString (
+  IN CHAR16    *String
+  )
+{
+  CHAR16       *TempString;
+
+  for ( ; *String != L'\0' && *String == L' '; String++) {
+    ;
+  }
+
+  TempString = String + StrLen (String) - 1;
+  while ((TempString >= String) && (*TempString == L' ')) {
+    TempString--;
+  }
+
+  *(TempString + 1) = L'\0';
+
+  return String;
+}
+
+VOID
+ReplaceLeft (
+  IN CHAR16         *Destination,
+  IN CONST CHAR16   *Source
+  )
+{
+  CONST CHAR16      *EndString;
+
+  EndString = Source + StrLen (Source);
+  while (Source <= EndString) {
+    *Destination++ = *Source++;
+  }
+}
+
+CHAR16 *
+ExcludeTrailingBackslashes (
+  IN CHAR16                    *String
+  )
+{
+  CHAR16                       *TempString;
+
+  switch (*(String + 1)) {
+  case L'\\':
+    break;
+  case L'\0':
+  default:
+    String++;
+    goto Exit;
+  }
+
+  TempString = String;
+  while (*TempString != L'\0' && *TempString == L'\\') {
+    TempString++;
+  }
+
+  if (TempString - 1 > String) {
+    ReplaceLeft (String + 1, TempString);
+  }
+
+  String++;
+
+Exit:
+  return String;
+}
+
+/**
+  Mangle a filename by cutting off trailing whitespaces, "\\", "." and "..".
+
+  @param[in] FileName Filename.
+
+  @retval @p FileName Filename mangled.
+
+**/
+CHAR16 *
+MangleFileName (
+  IN CHAR16        *FileName
+  )
+{
+  CHAR16           *FileNameSavedPointer;
+  CHAR16           *TempFileName;
+  UINTN            BackslashesNo;
+
+  if (FileName == NULL || *FileName == L'\0') {
+    FileName = NULL;
+    goto Exit;
+  }
+
+  FileName = TrimString (FileName);
+  if (*FileName == L'\0') {
+    goto Exit;
+  }
+
+  if ((StrLen (FileName) > 1) && (FileName[StrLen (FileName) - 1] == L'\\')) {
+    FileName[StrLen (FileName) - 1] = L'\0';
+  }
+
+  FileNameSavedPointer = FileName;
+
+  if (FileName[0] == L'.') {
+    if (FileName[1] == L'.') {
+      if (FileName[2] == L'\0') {
+        goto Exit;
+      } else {
+        FileName += 2;
+      }
+    } else if (FileName[1] == L'\0') {
+      goto Exit;
+    }
+  }
+
+  while (*FileName != L'\0') {
+    if (*FileName == L'\\') {
+      FileName = ExcludeTrailingBackslashes (FileName);
+    } else if (*FileName == L'.') {
+      switch (*(FileName + 1)) {
+      case L'\0':
+        *FileName = L'\0';
+        break;
+      case L'\\':
+        TempFileName = FileName + 1;
+        TempFileName = ExcludeTrailingBackslashes (TempFileName);
+        ReplaceLeft (FileName, TempFileName);
+        break;
+      case '.':
+        if ((*(FileName - 1) != L'\\') && ((*(FileName + 2) != L'\\') ||
+                                           (*(FileName + 2) != L'\0'))) {
+          FileName++;
+          continue;
+        }
+
+        BackslashesNo = 0;
+        TempFileName = FileName - 1;
+        while (TempFileName >= FileNameSavedPointer) {
+          if (*TempFileName == L'\\') {
+            if (++BackslashesNo == 2) {
+              break;
+            }
+          }
+
+          TempFileName--;
+        }
+
+        TempFileName++;
+
+        if ((*TempFileName == L'.') && (*(TempFileName + 1) == L'.')) {
+          FileName += 2;
+        } else {
+          if (*(FileName + 2) != L'\0') {
+            ReplaceLeft (TempFileName, FileName + 3);
+            if (*(TempFileName - 1) == L'\\') {
+              FileName = TempFileName;
+              ExcludeTrailingBackslashes (TempFileName - 1);
+              TempFileName = FileName;
+            }
+          } else {
+            *TempFileName = L'\0';
+          }
+
+          FileName = TempFileName;
+        }
+
+        break;
+      default:
+        FileName++;
+      }
+    } else {
+      FileName++;
+    }
+  }
+
+  FileName = FileNameSavedPointer;
+  if ((StrLen (FileName) > 1) && (FileName [StrLen (FileName) - 1] == L'\\')) {
+    FileName [StrLen (FileName) - 1] = L'\0';
+  }
+
+Exit:
+  return FileName;
+}
diff --git a/MdeModulePkg/Universal/Disk/UdfDxe/FileSystemOperations.c b/MdeModulePkg/Universal/Disk/UdfDxe/FileSystemOperations.c
new file mode 100644
index 0000000000..2f7f945479
--- /dev/null
+++ b/MdeModulePkg/Universal/Disk/UdfDxe/FileSystemOperations.c
@@ -0,0 +1,2472 @@
+/** @file
+  Handle on-disk format and volume structures in UDF/ECMA-167 file systems.
+
+  Copyright (C) 2014-2017 Paulo Alcantara <pcacjr@zytor.com>
+
+  This program and the accompanying materials are licensed and made available
+  under the terms and conditions of the BSD License which accompanies this
+  distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
+  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+**/
+
+#include "Udf.h"
+
+//
+// This driver *only* supports UDF revision 2.00 or higher.
+//
+// Note the "NSR03" identifier.
+//
+UDF_STANDARD_IDENTIFIER gUdfStandardIdentifiers[NR_STANDARD_IDENTIFIERS] = {
+  { { 'B', 'E', 'A', '0', '1' } },
+  { { 'N', 'S', 'R', '0', '3' } },
+  { { 'T', 'E', 'A', '0', '1' } },
+};
+
+EFI_STATUS
+FindAnchorVolumeDescriptorPointer (
+  IN   EFI_BLOCK_IO_PROTOCOL                 *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL                  *DiskIo,
+  OUT  UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER  *AnchorPoint
+  )
+{
+  EFI_STATUS  Status;
+  UINT32      BlockSize;
+  EFI_LBA     EndLBA;
+
+  BlockSize  = BlockIo->Media->BlockSize;
+  EndLBA     = BlockIo->Media->LastBlock;
+
+  //
+  // Look for AVDP at LBA 256.
+  //
+  Status = DiskIo->ReadDisk (
+    DiskIo,
+    BlockIo->Media->MediaId,
+    256ULL * BlockSize,
+    sizeof (UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER),
+    (VOID *)AnchorPoint
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (IS_AVDP (AnchorPoint)) {
+    return EFI_SUCCESS;
+  }
+
+  //
+  // Look for AVDP at last LBA - 256.
+  //
+  Status = DiskIo->ReadDisk (
+    DiskIo,
+    BlockIo->Media->MediaId,
+    MultU64x32 (EndLBA - 256, BlockSize),
+    sizeof (UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER),
+    (VOID *)AnchorPoint
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (IS_AVDP (AnchorPoint)) {
+    return EFI_SUCCESS;
+  }
+
+  //
+  // Look for AVDP at last LBA.
+  //
+  Status = DiskIo->ReadDisk (
+    DiskIo,
+    BlockIo->Media->MediaId,
+    MultU64x32 (EndLBA, BlockSize),
+    sizeof (UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER),
+    (VOID *)AnchorPoint
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (IS_AVDP (AnchorPoint)) {
+    return EFI_SUCCESS;
+  }
+
+  //
+  // No AVDP found in this media.
+  //
+  return EFI_VOLUME_CORRUPTED;
+}
+
+EFI_STATUS
+StartMainVolumeDescriptorSequence (
+  IN   EFI_BLOCK_IO_PROTOCOL                 *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL                  *DiskIo,
+  IN   UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER  *AnchorPoint,
+  OUT  UDF_VOLUME_INFO                       *Volume
+  )
+{
+  EFI_STATUS                     Status;
+  UINT32                         BlockSize;
+  UDF_EXTENT_AD                  *ExtentAd;
+  UINT64                         StartingLsn;
+  UINT64                         EndingLsn;
+  VOID                           *Buffer;
+  UDF_LOGICAL_VOLUME_DESCRIPTOR  *LogicalVolDesc;
+  UDF_PARTITION_DESCRIPTOR       *PartitionDesc;
+  UINTN                          Index;
+  UINT32                         LogicalBlockSize;
+
+  //
+  // We've alreay found an ADVP on the volume. It contains the extent
+  // (MainVolumeDescriptorSequenceExtent) where the Main Volume Descriptor
+  // Sequence starts. Therefore, we'll look for Logical Volume Descriptors and
+  // Partitions Descriptors and save them in memory accordingly.
+  //
+  // Note also that each descriptor will be aligned on a block size (BlockSize)
+  // boundary, so we need to read one block at a time.
+  //
+  BlockSize    = BlockIo->Media->BlockSize;
+  ExtentAd     = &AnchorPoint->MainVolumeDescriptorSequenceExtent;
+  StartingLsn  = (UINT64)ExtentAd->ExtentLocation;
+  EndingLsn    = StartingLsn + DivU64x32 (
+                                     (UINT64)ExtentAd->ExtentLength,
+                                     BlockSize
+                                     );
+
+  Volume->LogicalVolDescs =
+    (UDF_LOGICAL_VOLUME_DESCRIPTOR **)AllocateZeroPool (ExtentAd->ExtentLength);
+  if (Volume->LogicalVolDescs == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  Volume->PartitionDescs =
+    (UDF_PARTITION_DESCRIPTOR **)AllocateZeroPool (ExtentAd->ExtentLength);
+  if (Volume->PartitionDescs == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto Error_Alloc_Pds;
+  }
+
+  Buffer = AllocateZeroPool (BlockSize);
+  if (Buffer == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto Error_Alloc_Buf;
+  }
+
+  Volume->LogicalVolDescsNo  = 0;
+  Volume->PartitionDescsNo   = 0;
+
+  while (StartingLsn <= EndingLsn) {
+    Status = DiskIo->ReadDisk (
+      DiskIo,
+      BlockIo->Media->MediaId,
+      MultU64x32 (StartingLsn, BlockSize),
+      BlockSize,
+      Buffer
+      );
+    if (EFI_ERROR (Status)) {
+      goto Error_Read_Disk_Blk;
+    }
+
+    if (IS_TD (Buffer)) {
+      //
+      // Found a Terminating Descriptor. Stop the sequence then.
+      //
+      break;
+    }
+
+    if (IS_LVD (Buffer)) {
+      //
+      // Found a Logical Volume Descriptor.
+      //
+      LogicalVolDesc =
+        (UDF_LOGICAL_VOLUME_DESCRIPTOR *)
+        AllocateZeroPool (sizeof (UDF_LOGICAL_VOLUME_DESCRIPTOR));
+      if (LogicalVolDesc == NULL) {
+        Status = EFI_OUT_OF_RESOURCES;
+        goto Error_Alloc_Lvd;
+      }
+
+      CopyMem ((VOID *)LogicalVolDesc, Buffer,
+               sizeof (UDF_LOGICAL_VOLUME_DESCRIPTOR));
+
+      Volume->LogicalVolDescs[Volume->LogicalVolDescsNo] = LogicalVolDesc;
+      Volume->LogicalVolDescsNo++;
+    } else if (IS_PD (Buffer)) {
+      //
+      // Found a Partition Descriptor.
+      //
+      PartitionDesc =
+        (UDF_PARTITION_DESCRIPTOR *)
+        AllocateZeroPool (sizeof (UDF_PARTITION_DESCRIPTOR));
+      if (PartitionDesc == NULL) {
+        Status = EFI_OUT_OF_RESOURCES;
+        goto Error_Alloc_Pd;
+      }
+
+      CopyMem ((VOID *)PartitionDesc, Buffer,
+               sizeof (UDF_PARTITION_DESCRIPTOR));
+
+      Volume->PartitionDescs[Volume->PartitionDescsNo] = PartitionDesc;
+      Volume->PartitionDescsNo++;
+    }
+
+    StartingLsn++;
+  }
+
+  //
+  // When an UDF volume (revision 2.00 or higher) contains a File Entry rather
+  // than an Extended File Entry (which is not recommended as per spec), we need
+  // to make sure the size of a FE will be _at least_ 2048
+  // (UDF_LOGICAL_SECTOR_SIZE) bytes long to keep backward compatibility.
+  //
+  LogicalBlockSize = LV_BLOCK_SIZE (Volume, UDF_DEFAULT_LV_NUM);
+  if (LogicalBlockSize >= UDF_LOGICAL_SECTOR_SIZE) {
+    Volume->FileEntrySize = LogicalBlockSize;
+  } else {
+    Volume->FileEntrySize = UDF_LOGICAL_SECTOR_SIZE;
+  }
+
+  FreePool (Buffer);
+
+  return EFI_SUCCESS;
+
+Error_Alloc_Pd:
+Error_Alloc_Lvd:
+  for (Index = 0; Index < Volume->PartitionDescsNo; Index++) {
+    FreePool ((VOID *)Volume->PartitionDescs[Index]);
+  }
+
+  for (Index = 0; Index < Volume->LogicalVolDescsNo; Index++) {
+    FreePool ((VOID *)Volume->LogicalVolDescs[Index]);
+  }
+
+Error_Read_Disk_Blk:
+  FreePool (Buffer);
+
+Error_Alloc_Buf:
+  FreePool ((VOID *)Volume->PartitionDescs);
+  Volume->PartitionDescs = NULL;
+
+Error_Alloc_Pds:
+  FreePool ((VOID *)Volume->LogicalVolDescs);
+  Volume->LogicalVolDescs = NULL;
+
+  return Status;
+}
+
+//
+// Return a Partition Descriptor given a Long Allocation Descriptor. This is
+// necessary to calculate the right extent (LongAd) offset which is added up
+// with partition's starting location.
+//
+UDF_PARTITION_DESCRIPTOR *
+GetPdFromLongAd (
+  IN UDF_VOLUME_INFO                 *Volume,
+  IN UDF_LONG_ALLOCATION_DESCRIPTOR  *LongAd
+  )
+{
+  UINTN                     Index;
+  UDF_PARTITION_DESCRIPTOR  *PartitionDesc;
+  UINT16                    PartitionNum;
+
+  for (Index = 0; Index < Volume->PartitionDescsNo; Index++) {
+    PartitionDesc = Volume->PartitionDescs[Index];
+
+    PartitionNum = PartitionDesc->PartitionNumber;
+    if (PartitionNum == LongAd->ExtentLocation.PartitionReferenceNumber) {
+      return PartitionDesc;
+    }
+  }
+
+  return NULL;
+}
+
+//
+// Return logical sector number of the given Long Allocation Descriptor.
+//
+UINT64
+GetLongAdLsn (
+  IN UDF_VOLUME_INFO                 *Volume,
+  IN UDF_LONG_ALLOCATION_DESCRIPTOR  *LongAd
+  )
+{
+  UDF_PARTITION_DESCRIPTOR *PartitionDesc;
+
+  PartitionDesc = GetPdFromLongAd (Volume, LongAd);
+
+  return (UINT64)PartitionDesc->PartitionStartingLocation +
+                 LongAd->ExtentLocation.LogicalBlockNumber;
+}
+
+//
+// Return logical sector number of the given Short Allocation Descriptor.
+//
+UINT64
+GetShortAdLsn (
+  IN UDF_PARTITION_DESCRIPTOR         *PartitionDesc,
+  IN UDF_SHORT_ALLOCATION_DESCRIPTOR  *ShortAd
+  )
+{
+  return (UINT64)PartitionDesc->PartitionStartingLocation +
+                 ShortAd->ExtentPosition;
+}
+
+//
+// Find File Set Descriptor of the given Logical Volume Descriptor.
+//
+// The found FSD will contain the extent (LogicalVolumeContentsUse) where our
+// root directory is.
+//
+EFI_STATUS
+FindFileSetDescriptor (
+  IN   EFI_BLOCK_IO_PROTOCOL    *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL     *DiskIo,
+  IN   UDF_VOLUME_INFO          *Volume,
+  IN   UINTN                    LogicalVolDescNo,
+  OUT  UDF_FILE_SET_DESCRIPTOR  *FileSetDesc
+  )
+{
+  EFI_STATUS                     Status;
+  UINT64                         Lsn;
+  UDF_LOGICAL_VOLUME_DESCRIPTOR  *LogicalVolDesc;
+
+  LogicalVolDesc  = Volume->LogicalVolDescs[LogicalVolDescNo];
+  Lsn             = GetLongAdLsn (Volume,
+                                  &LogicalVolDesc->LogicalVolumeContentsUse);
+
+  //
+  // Read extent (Long Ad).
+  //
+  Status = DiskIo->ReadDisk (
+    DiskIo,
+    BlockIo->Media->MediaId,
+    MultU64x32 (Lsn, LogicalVolDesc->LogicalBlockSize),
+    sizeof (UDF_FILE_SET_DESCRIPTOR),
+    (VOID *)FileSetDesc
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Check if the read extent contains a valid FSD's tag identifier.
+  //
+  if (!IS_FSD (FileSetDesc)) {
+    return EFI_VOLUME_CORRUPTED;
+  }
+
+  return EFI_SUCCESS;
+}
+
+//
+// Get all File Set Descriptors for each Logical Volume Descriptor.
+//
+EFI_STATUS
+GetFileSetDescriptors (
+  IN      EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN      EFI_DISK_IO_PROTOCOL   *DiskIo,
+  IN OUT  UDF_VOLUME_INFO        *Volume
+  )
+{
+  EFI_STATUS               Status;
+  UINTN                    Index;
+  UDF_FILE_SET_DESCRIPTOR  *FileSetDesc;
+  UINTN                    Count;
+
+  Volume->FileSetDescs =
+    (UDF_FILE_SET_DESCRIPTOR **)AllocateZeroPool (
+      Volume->LogicalVolDescsNo * sizeof (UDF_FILE_SET_DESCRIPTOR));
+  if (Volume->FileSetDescs == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  for (Index = 0; Index < Volume->LogicalVolDescsNo; Index++) {
+    FileSetDesc = AllocateZeroPool (sizeof (UDF_FILE_SET_DESCRIPTOR));
+    if (!FileSetDesc) {
+      Status = EFI_OUT_OF_RESOURCES;
+      goto Error_Alloc_Fsd;
+    }
+
+    //
+    // Find a FSD for this LVD.
+    //
+    Status = FindFileSetDescriptor (
+      BlockIo,
+      DiskIo,
+      Volume,
+      Index,
+      FileSetDesc
+      );
+    if (EFI_ERROR (Status)) {
+      goto Error_Find_Fsd;
+    }
+
+    //
+    // Got one. Save it.
+    //
+    Volume->FileSetDescs[Index] = FileSetDesc;
+  }
+
+  Volume->FileSetDescsNo = Volume->LogicalVolDescsNo;
+
+  return EFI_SUCCESS;
+
+Error_Find_Fsd:
+  Count = Index + 1;
+  for (Index = 0; Index < Count; Index++) {
+    FreePool ((VOID *)Volume->FileSetDescs[Index]);
+  }
+
+  FreePool ((VOID *)Volume->FileSetDescs);
+  Volume->FileSetDescs = NULL;
+
+Error_Alloc_Fsd:
+  return Status;
+}
+
+//
+// Read Volume and File Structure of an UDF file system.
+//
+EFI_STATUS
+ReadVolumeFileStructure (
+  IN   EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL   *DiskIo,
+  OUT  UDF_VOLUME_INFO        *Volume
+  )
+{
+  EFI_STATUS                            Status;
+  UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER  AnchorPoint;
+
+  //
+  // Find an AVDP.
+  //
+  Status = FindAnchorVolumeDescriptorPointer (
+    BlockIo,
+    DiskIo,
+    &AnchorPoint
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // AVDP has been found. Start MVDS.
+  //
+  Status = StartMainVolumeDescriptorSequence (
+    BlockIo,
+    DiskIo,
+    &AnchorPoint,
+    Volume
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  return Status;
+}
+
+//
+// Calculate length of the given File Identifier Descriptor.
+//
+UINT64
+GetFidDescriptorLength (
+  IN UDF_FILE_IDENTIFIER_DESCRIPTOR  *FileIdentifierDesc
+  )
+{
+  return (UINT64)(
+             (INTN)((OFFSET_OF (UDF_FILE_IDENTIFIER_DESCRIPTOR, Data[0]) + 3 +
+		     FileIdentifierDesc->LengthOfFileIdentifier +
+		     FileIdentifierDesc->LengthOfImplementationUse) >> 2) << 2
+             );
+}
+
+//
+// Duplicate a given File Identifier Descriptor.
+//
+VOID
+DuplicateFid (
+  IN   UDF_FILE_IDENTIFIER_DESCRIPTOR  *FileIdentifierDesc,
+  OUT  UDF_FILE_IDENTIFIER_DESCRIPTOR  **NewFileIdentifierDesc
+  )
+{
+  *NewFileIdentifierDesc =
+    (UDF_FILE_IDENTIFIER_DESCRIPTOR *)AllocateCopyPool (
+      GetFidDescriptorLength (FileIdentifierDesc), FileIdentifierDesc);
+}
+
+//
+// Duplicate either a given File Entry or a given Extended File Entry.
+//
+VOID
+DuplicateFe (
+  IN   EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN   UDF_VOLUME_INFO        *Volume,
+  IN   VOID                   *FileEntry,
+  OUT  VOID                   **NewFileEntry
+  )
+{
+  *NewFileEntry = AllocateCopyPool (Volume->FileEntrySize, FileEntry);
+}
+
+//
+// Get raw data + length of the given File Entry or Extended File Entry.
+//
+// The file's recorded data can contain either real file content (inline) or
+// a sequence of extents (or Allocation Descriptors) which tells where file's
+// content is stored in.
+//
+// NOTE: The FE/EFE can be thought it was an inode.
+//
+VOID
+GetFileEntryData (
+  IN   VOID    *FileEntryData,
+  OUT  VOID    **Data,
+  OUT  UINT64  *Length
+  )
+{
+  UDF_EXTENDED_FILE_ENTRY  *ExtendedFileEntry;
+  UDF_FILE_ENTRY           *FileEntry;
+
+  if (IS_EFE (FileEntryData)) {
+    ExtendedFileEntry = (UDF_EXTENDED_FILE_ENTRY *)FileEntryData;
+
+    *Length  = ExtendedFileEntry->InformationLength;
+    *Data    = (VOID *)((UINT8 *)&ExtendedFileEntry->Data[0] +
+                        ExtendedFileEntry->LengthOfExtendedAttributes);
+  } else if (IS_FE (FileEntryData)) {
+    FileEntry = (UDF_FILE_ENTRY *)FileEntryData;
+
+    *Length  = FileEntry->InformationLength;
+    *Data    = (VOID *)((UINT8 *)&FileEntry->Data[0] +
+                        FileEntry->LengthOfExtendedAttributes);
+  }
+}
+
+//
+// Get Allocation Descriptors' data information from the given FE/EFE.
+//
+VOID
+GetAdsInformation (
+  IN   VOID    *FileEntryData,
+  OUT  VOID    **AdsData,
+  OUT  UINT64  *Length
+  )
+{
+  UDF_EXTENDED_FILE_ENTRY  *ExtendedFileEntry;
+  UDF_FILE_ENTRY           *FileEntry;
+
+  if (IS_EFE (FileEntryData)) {
+    ExtendedFileEntry = (UDF_EXTENDED_FILE_ENTRY *)FileEntryData;
+
+    *Length = ExtendedFileEntry->LengthOfAllocationDescriptors;
+    *AdsData = (VOID *)((UINT8 *)&ExtendedFileEntry->Data[0] +
+                        ExtendedFileEntry->LengthOfExtendedAttributes);
+  } else if (IS_FE (FileEntryData)) {
+    FileEntry = (UDF_FILE_ENTRY *)FileEntryData;
+
+    *Length = FileEntry->LengthOfAllocationDescriptors;
+    *AdsData = (VOID *)((UINT8 *)&FileEntry->Data[0] +
+                        FileEntry->LengthOfExtendedAttributes);
+  }
+}
+
+//
+// Read next Short Allocation Descriptor from the given file's data.
+//
+EFI_STATUS
+GetLongAdFromAds (
+  IN      VOID                            *Data,
+  IN OUT  UINT64                          *Offset,
+  IN      UINT64                          Length,
+  OUT     UDF_LONG_ALLOCATION_DESCRIPTOR  **FoundLongAd
+  )
+{
+  UDF_LONG_ALLOCATION_DESCRIPTOR  *LongAd;
+  UDF_EXTENT_FLAGS                ExtentFlags;
+
+  for (;;) {
+    if (*Offset >= Length) {
+      //
+      // No more Long Allocation Descriptors.
+      //
+      return EFI_DEVICE_ERROR;
+    }
+
+    LongAd =
+      (UDF_LONG_ALLOCATION_DESCRIPTOR *)((UINT8 *)Data + *Offset);
+
+    //
+    // If it's either an indirect AD (Extended Alllocation Descriptor) or an
+    // allocated AD, then return it.
+    //
+    ExtentFlags = GET_EXTENT_FLAGS (LONG_ADS_SEQUENCE, LongAd);
+    if (ExtentFlags == EXTENT_IS_NEXT_EXTENT ||
+        ExtentFlags == EXTENT_RECORDED_AND_ALLOCATED) {
+      break;
+    }
+
+    //
+    // This AD is either not recorded but allocated, or not recorded and not
+    // allocated. Skip it.
+    //
+    *Offset += AD_LENGTH (LONG_ADS_SEQUENCE);
+  }
+
+  *FoundLongAd = LongAd;
+
+  return EFI_SUCCESS;
+}
+
+//
+// Read next Short Allocation Descriptor from the given file's data.
+//
+EFI_STATUS
+GetShortAdFromAds (
+  IN      VOID                             *Data,
+  IN OUT  UINT64                           *Offset,
+  IN      UINT64                           Length,
+  OUT     UDF_SHORT_ALLOCATION_DESCRIPTOR  **FoundShortAd
+  )
+{
+  UDF_SHORT_ALLOCATION_DESCRIPTOR *ShortAd;
+  UDF_EXTENT_FLAGS                ExtentFlags;
+
+  for (;;) {
+    if (*Offset >= Length) {
+      //
+      // No more Short Allocation Descriptors.
+      //
+      return EFI_DEVICE_ERROR;
+    }
+
+    ShortAd =
+      (UDF_SHORT_ALLOCATION_DESCRIPTOR *)((UINT8 *)Data + *Offset);
+
+    //
+    // If it's either an indirect AD (Extended Alllocation Descriptor) or an
+    // allocated AD, then return it.
+    //
+    ExtentFlags = GET_EXTENT_FLAGS (SHORT_ADS_SEQUENCE, ShortAd);
+    if (ExtentFlags == EXTENT_IS_NEXT_EXTENT ||
+        ExtentFlags == EXTENT_RECORDED_AND_ALLOCATED) {
+      break;
+    }
+
+    //
+    // This AD is either not recorded but allocated, or not recorded and not
+    // allocated. Skip it.
+    //
+    *Offset += AD_LENGTH (SHORT_ADS_SEQUENCE);
+  }
+
+  *FoundShortAd = ShortAd;
+
+  return EFI_SUCCESS;
+}
+
+//
+// Get either a Short Allocation Descriptor or a Long Allocation Descriptor from
+// the given file's data.
+//
+EFI_STATUS
+GetAllocationDescriptor (
+  IN      UDF_FE_RECORDING_FLAGS  RecordingFlags,
+  IN      VOID                    *Data,
+  IN OUT  UINT64                  *Offset,
+  IN      UINT64                  Length,
+  OUT     VOID                    **FoundAd
+  )
+{
+  if (RecordingFlags == LONG_ADS_SEQUENCE) {
+    return GetLongAdFromAds (
+      Data,
+      Offset,
+      Length,
+      (UDF_LONG_ALLOCATION_DESCRIPTOR **)FoundAd
+      );
+  } else if (RecordingFlags == SHORT_ADS_SEQUENCE) {
+    return GetShortAdFromAds (
+      Data,
+      Offset,
+      Length,
+      (UDF_SHORT_ALLOCATION_DESCRIPTOR **)FoundAd
+      );
+  }
+
+  return EFI_DEVICE_ERROR;
+}
+
+//
+// Return logical sector number of either Short or Long Allocation Descriptor.
+//
+UINT64
+GetAllocationDescriptorLsn (
+  IN UDF_FE_RECORDING_FLAGS          RecordingFlags,
+  IN UDF_VOLUME_INFO                 *Volume,
+  IN UDF_LONG_ALLOCATION_DESCRIPTOR  *ParentIcb,
+  IN VOID                            *Ad
+  )
+{
+  if (RecordingFlags == LONG_ADS_SEQUENCE) {
+    return GetLongAdLsn (Volume, (UDF_LONG_ALLOCATION_DESCRIPTOR *)Ad);
+  } else if (RecordingFlags == SHORT_ADS_SEQUENCE) {
+    return GetShortAdLsn (
+      GetPdFromLongAd (Volume, ParentIcb),
+      (UDF_SHORT_ALLOCATION_DESCRIPTOR *)Ad
+      );
+  }
+
+  return 0;
+}
+
+//
+// Return offset + length of a given indirect Allocation Descriptor (AED).
+//
+EFI_STATUS
+GetAedAdsOffset (
+  IN   EFI_BLOCK_IO_PROTOCOL           *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL            *DiskIo,
+  IN   UDF_VOLUME_INFO                 *Volume,
+  IN   UDF_LONG_ALLOCATION_DESCRIPTOR  *ParentIcb,
+  IN   UDF_FE_RECORDING_FLAGS          RecordingFlags,
+  IN   VOID                            *Ad,
+  OUT  UINT64                          *Offset,
+  OUT  UINT64                          *Length
+  )
+{
+  EFI_STATUS                        Status;
+  UINT32                            ExtentLength;
+  UINT64                            Lsn;
+  VOID                              *Data;
+  UINT32                            LogicalBlockSize;
+  UDF_ALLOCATION_EXTENT_DESCRIPTOR  *AllocExtDesc;
+
+  ExtentLength  = GET_EXTENT_LENGTH (RecordingFlags, Ad);
+  Lsn           = GetAllocationDescriptorLsn (RecordingFlags,
+                                              Volume,
+                                              ParentIcb,
+                                              Ad);
+
+  Data = AllocatePool (ExtentLength);
+  if (Data == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  LogicalBlockSize = LV_BLOCK_SIZE (Volume, UDF_DEFAULT_LV_NUM);
+
+  //
+  // Read extent.
+  //
+  Status = DiskIo->ReadDisk (
+    DiskIo,
+    BlockIo->Media->MediaId,
+    MultU64x32 (Lsn, LogicalBlockSize),
+    ExtentLength,
+    Data
+    );
+  if (EFI_ERROR (Status)) {
+    goto Exit;
+  }
+
+  //
+  // Check if read extent contains a valid tag identifier for AED.
+  //
+  AllocExtDesc = (UDF_ALLOCATION_EXTENT_DESCRIPTOR *)Data;
+  if (!IS_AED (AllocExtDesc)) {
+    Status = EFI_VOLUME_CORRUPTED;
+    goto Exit;
+  }
+
+  //
+  // Get AED's block offset and its length.
+  //
+  *Offset = MultU64x32 (Lsn, LogicalBlockSize) +
+    sizeof (UDF_ALLOCATION_EXTENT_DESCRIPTOR);
+  *Length = AllocExtDesc->LengthOfAllocationDescriptors;
+
+Exit:
+  FreePool (Data);
+
+  return Status;
+}
+
+//
+// Read Allocation Extent Descriptor into memory.
+//
+EFI_STATUS
+GetAedAdsData (
+  IN   EFI_BLOCK_IO_PROTOCOL           *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL            *DiskIo,
+  IN   UDF_VOLUME_INFO                 *Volume,
+  IN   UDF_LONG_ALLOCATION_DESCRIPTOR  *ParentIcb,
+  IN   UDF_FE_RECORDING_FLAGS          RecordingFlags,
+  IN   VOID                            *Ad,
+  OUT  VOID                            **Data,
+  OUT  UINT64                          *Length
+  )
+{
+  EFI_STATUS  Status;
+  UINT64      Offset;
+
+  //
+  // Get AED's offset + length.
+  //
+  Status = GetAedAdsOffset (
+    BlockIo,
+    DiskIo,
+    Volume,
+    ParentIcb,
+    RecordingFlags,
+    Ad,
+    &Offset,
+    Length
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Allocate buffer to read in AED's data.
+  //
+  *Data = AllocatePool (*Length);
+  if (*Data == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  return DiskIo->ReadDisk (
+    DiskIo,
+    BlockIo->Media->MediaId,
+    Offset,
+    *Length,
+    *Data
+    );
+}
+
+//
+// Function used to serialise reads of Allocation Descriptors.
+//
+EFI_STATUS
+GrowUpBufferToNextAd (
+  IN      UDF_FE_RECORDING_FLAGS  RecordingFlags,
+  IN      VOID                    *Ad,
+  IN OUT  VOID                    **Buffer,
+  IN      UINT64                  Length
+  )
+{
+  UINT32 ExtentLength;
+
+  ExtentLength = GET_EXTENT_LENGTH (RecordingFlags, Ad);
+
+  if (*Buffer == NULL) {
+    *Buffer = AllocatePool (ExtentLength);
+    if (*Buffer == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+  } else {
+    *Buffer = ReallocatePool (Length, Length + ExtentLength, *Buffer);
+    if (*Buffer == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+  }
+
+  return EFI_SUCCESS;
+}
+
+//
+// Read data or size of either a File Entry or an Extended File Entry.
+//
+EFI_STATUS
+ReadFile (
+  IN      EFI_BLOCK_IO_PROTOCOL           *BlockIo,
+  IN      EFI_DISK_IO_PROTOCOL            *DiskIo,
+  IN      UDF_VOLUME_INFO                 *Volume,
+  IN      UDF_LONG_ALLOCATION_DESCRIPTOR  *ParentIcb,
+  IN      VOID                            *FileEntryData,
+  IN OUT  UDF_READ_FILE_INFO              *ReadFileInfo
+  )
+{
+  EFI_STATUS              Status;
+  UINT32                  LogicalBlockSize;
+  VOID                    *Data;
+  UINT64                  Length;
+  VOID                    *Ad;
+  UINT64                  AdOffset;
+  UINT64                  Lsn;
+  BOOLEAN                 DoFreeAed;
+  UINT64                  FilePosition;
+  UINT64                  Offset;
+  UINT64                  DataOffset;
+  UINT64                  BytesLeft;
+  UINT64                  DataLength;
+  BOOLEAN                 FinishedSeeking;
+  UINT32                  ExtentLength;
+  UDF_FE_RECORDING_FLAGS  RecordingFlags;
+
+  LogicalBlockSize  = LV_BLOCK_SIZE (Volume, UDF_DEFAULT_LV_NUM);
+  DoFreeAed         = FALSE;
+
+  switch (ReadFileInfo->Flags) {
+  case READ_FILE_GET_FILESIZE:
+  case READ_FILE_ALLOCATE_AND_READ:
+    //
+    // Initialise ReadFileInfo structure for starting get file's size or read
+    // file's recorded data.
+    //
+    ReadFileInfo->ReadLength = 0;
+    ReadFileInfo->FileData = NULL;
+    break;
+  case READ_FILE_SEEK_AND_READ:
+    //
+    // About to seek a file and/or read its data.
+    //
+    Length = ReadFileInfo->FileSize - ReadFileInfo->FilePosition;
+    if (ReadFileInfo->FileDataSize > Length) {
+      //
+      // About to read beyond the EOF -- truncate it.
+      //
+      ReadFileInfo->FileDataSize = Length;
+    }
+
+    //
+    // Initialise data to start seeking and/or reading a file.
+    //
+    BytesLeft = ReadFileInfo->FileDataSize;
+    DataOffset = 0;
+    FilePosition = 0;
+    FinishedSeeking = FALSE;
+
+    break;
+  }
+
+  RecordingFlags = GET_FE_RECORDING_FLAGS (FileEntryData);
+  switch (RecordingFlags) {
+  case INLINE_DATA:
+    //
+    // There is no extents for this FE/EFE. All its data is inline.
+    //
+    GetFileEntryData (FileEntryData, &Data, &Length);
+
+    if (ReadFileInfo->Flags == READ_FILE_GET_FILESIZE) {
+      ReadFileInfo->ReadLength = Length;
+    } else if (ReadFileInfo->Flags == READ_FILE_ALLOCATE_AND_READ) {
+      //
+      // Allocate buffer for starting read data.
+      //
+      ReadFileInfo->FileData = AllocatePool (Length);
+      if (!ReadFileInfo->FileData) {
+        return EFI_OUT_OF_RESOURCES;
+      }
+
+      //
+      // Read all inline data into ReadFileInfo->FileData
+      //
+      CopyMem (ReadFileInfo->FileData, Data, Length);
+      ReadFileInfo->ReadLength = Length;
+    } else if (ReadFileInfo->Flags == READ_FILE_SEEK_AND_READ) {
+      //
+      // If FilePosition is non-zero, seek file to FilePosition, read
+      // FileDataSize bytes and then updates FilePosition.
+      //
+      CopyMem (
+        ReadFileInfo->FileData,
+        (VOID *)((UINT8 *)Data + ReadFileInfo->FilePosition),
+        ReadFileInfo->FileDataSize
+        );
+
+      ReadFileInfo->FilePosition += ReadFileInfo->FileDataSize;
+    }
+
+    break;
+  case LONG_ADS_SEQUENCE:
+  case SHORT_ADS_SEQUENCE:
+    //
+    // This FE/EFE contains a run of Allocation Descriptors. Get data + size
+    // for start reading them.
+    //
+    GetAdsInformation (FileEntryData, &Data, &Length);
+    AdOffset = 0;
+
+    for (;;) {
+      //
+      // Read AD.
+      //
+      Status = GetAllocationDescriptor (
+        RecordingFlags,
+        Data,
+        &AdOffset,
+        Length,
+        &Ad
+        );
+      if (Status == EFI_DEVICE_ERROR) {
+        Status = EFI_SUCCESS;
+        goto Done;
+      }
+
+      //
+      // Check if AD is an indirect one. If so, read Allocation Extent
+      // Descriptor and read their extents (ADs).
+      //
+      if (GET_EXTENT_FLAGS (RecordingFlags, Ad) == EXTENT_IS_NEXT_EXTENT) {
+        if (!DoFreeAed) {
+          DoFreeAed = TRUE;
+        } else {
+          FreePool (Data);
+        }
+
+        Status = GetAedAdsData (
+          BlockIo,
+          DiskIo,
+          Volume,
+          ParentIcb,
+          RecordingFlags,
+          Ad,
+          &Data,
+          &Length
+          );
+        if (EFI_ERROR (Status)) {
+          goto Error_Get_Aed;
+        }
+
+        AdOffset = 0;
+        continue;
+      }
+
+      ExtentLength = GET_EXTENT_LENGTH (RecordingFlags, Ad);
+
+      Lsn = GetAllocationDescriptorLsn (RecordingFlags,
+                                        Volume,
+                                        ParentIcb,
+                                        Ad);
+
+      switch (ReadFileInfo->Flags) {
+	  case READ_FILE_GET_FILESIZE:
+	    ReadFileInfo->ReadLength += ExtentLength;
+	    break;
+	  case READ_FILE_ALLOCATE_AND_READ:
+	    //
+	    // Increase FileData (if necessary) to read next extent.
+	    //
+	    Status = GrowUpBufferToNextAd (
+          RecordingFlags,
+          Ad,
+          &ReadFileInfo->FileData,
+          ReadFileInfo->ReadLength
+          );
+	    if (EFI_ERROR (Status)) {
+	      goto Error_Alloc_Buffer_To_Next_Ad;
+	    }
+
+	    //
+	    // Read extent's data into FileData.
+	    //
+	    Status = DiskIo->ReadDisk (
+          DiskIo,
+          BlockIo->Media->MediaId,
+          MultU64x32 (Lsn, LogicalBlockSize),
+          ExtentLength,
+          (VOID *)((UINT8 *)ReadFileInfo->FileData +
+                   ReadFileInfo->ReadLength)
+          );
+	    if (EFI_ERROR (Status)) {
+	      goto Error_Read_Disk_Blk;
+	    }
+
+	    ReadFileInfo->ReadLength += ExtentLength;
+	    break;
+	  case READ_FILE_SEEK_AND_READ:
+	    //
+	    // Seek file first before reading in its data.
+	    //
+	    if (FinishedSeeking) {
+	      Offset = 0;
+	      goto Skip_File_Seek;
+	    }
+
+	    if (FilePosition + ExtentLength < ReadFileInfo->FilePosition) {
+	      FilePosition += ExtentLength;
+	      goto Skip_Ad;
+	    }
+
+	    if (FilePosition + ExtentLength > ReadFileInfo->FilePosition) {
+	      Offset = ReadFileInfo->FilePosition - FilePosition;
+	      if (Offset < 0) {
+            Offset = -(Offset);
+	      }
+	    } else {
+	      Offset = 0;
+	    }
+
+	    //
+	    // Done with seeking file. Start reading its data.
+	    //
+	    FinishedSeeking = TRUE;
+
+      Skip_File_Seek:
+	    //
+	    // Make sure we don't read more data than really wanted.
+	    //
+	    if (ExtentLength - Offset > BytesLeft) {
+	      DataLength = BytesLeft;
+	    } else {
+	      DataLength = ExtentLength - Offset;
+	    }
+
+	    //
+	    // Read extent's data into FileData.
+	    //
+	    Status = DiskIo->ReadDisk (
+          DiskIo,
+          BlockIo->Media->MediaId,
+          Offset + MultU64x32 (Lsn, LogicalBlockSize),
+          DataLength,
+          (VOID *)((UINT8 *)ReadFileInfo->FileData +
+                   DataOffset)
+          );
+	    if (EFI_ERROR (Status)) {
+	      goto Error_Read_Disk_Blk;
+	    }
+
+        //
+        // Update current file's position.
+	    //
+	    DataOffset += DataLength;
+	    ReadFileInfo->FilePosition += DataLength;
+
+	    BytesLeft -= DataLength;
+	    if (!BytesLeft) {
+	      //
+	      // There is no more file data to read.
+	      //
+	      Status = EFI_SUCCESS;
+	      goto Done;
+	    }
+
+	    break;
+      }
+
+    Skip_Ad:
+      //
+      // Point to the next AD (extent).
+      //
+      AdOffset += AD_LENGTH (RecordingFlags);
+    }
+
+    break;
+  case EXTENDED_ADS_SEQUENCE:
+    // Not supported. Haven't got a volume with that yet.
+    Status = EFI_UNSUPPORTED;
+    break;
+  }
+
+Done:
+  if (DoFreeAed) {
+    FreePool (Data);
+  }
+
+  return Status;
+
+Error_Read_Disk_Blk:
+Error_Alloc_Buffer_To_Next_Ad:
+  if (ReadFileInfo->Flags != READ_FILE_SEEK_AND_READ) {
+    FreePool (ReadFileInfo->FileData);
+  }
+
+  if (DoFreeAed) {
+    FreePool (Data);
+  }
+
+Error_Get_Aed:
+  return Status;
+}
+
+//
+// Find a file by its filename from the given Parent file.
+//
+EFI_STATUS
+InternalFindFile (
+  IN   EFI_BLOCK_IO_PROTOCOL           *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL            *DiskIo,
+  IN   UDF_VOLUME_INFO                 *Volume,
+  IN   CHAR16                          *FileName,
+  IN   UDF_FILE_INFO                   *Parent,
+  IN   UDF_LONG_ALLOCATION_DESCRIPTOR  *Icb,
+  OUT  UDF_FILE_INFO                   *File
+  )
+{
+  EFI_STATUS                      Status;
+  UDF_FILE_IDENTIFIER_DESCRIPTOR  *FileIdentifierDesc;
+  UDF_READ_DIRECTORY_INFO         ReadDirInfo;
+  BOOLEAN                         Found;
+  UINTN                           FileNameLength;
+  CHAR16                          FoundFileName[UDF_FILENAME_LENGTH];
+  VOID                            *CompareFileEntry;
+
+  //
+  // Check if parent file is really directory.
+  //
+  if (!IS_FE_DIRECTORY (Parent->FileEntry)) {
+    return EFI_NOT_FOUND;
+  }
+
+  //
+  // If FileName is current file or working directory, just duplicate Parent's
+  // FE/EFE and FID descriptors.
+  //
+  if (!StrCmp (FileName, L".")) {
+    DuplicateFe (BlockIo, Volume, Parent->FileEntry, &File->FileEntry);
+    DuplicateFid (Parent->FileIdentifierDesc, &File->FileIdentifierDesc);
+
+    return EFI_SUCCESS;
+  }
+
+  //
+  // Start directory listing.
+  //
+  ZeroMem ((VOID *)&ReadDirInfo, sizeof (UDF_READ_DIRECTORY_INFO));
+  Found = FALSE;
+  FileNameLength = StrLen (FileName);
+
+  for (;;) {
+    Status = ReadDirectoryEntry (
+      BlockIo,
+      DiskIo,
+      Volume,
+      Parent->FileIdentifierDesc ?
+      &Parent->FileIdentifierDesc->Icb :
+      Icb,
+      Parent->FileEntry,
+      &ReadDirInfo,
+      &FileIdentifierDesc
+      );
+    if (EFI_ERROR (Status)) {
+      if (Status == EFI_DEVICE_ERROR) {
+        Status = EFI_NOT_FOUND;
+      }
+
+      break;
+    }
+
+    if (IS_FID_PARENT_FILE (FileIdentifierDesc)) {
+      //
+      // This FID contains the location (FE/EFE) of the parent directory of this
+      // directory (Parent), and if FileName is either ".." or "\\", then it's
+      // the expected FID.
+      //
+      if (!StrCmp (FileName, L"..") || !StrCmp (FileName, L"\\")) {
+        Found = TRUE;
+        break;
+      }
+    } else {
+      //
+      // Check if both filename lengths match each other. Otherwise, we don't
+      // need to read in FID's filename.
+      //
+      if (FileNameLength != FileIdentifierDesc->LengthOfFileIdentifier - 1) {
+        goto Skip_Fid;
+      }
+
+      //
+      // OK - their filename lengths match. Now, compare if their filenames.
+      //
+      Status = GetFileNameFromFid (FileIdentifierDesc, FoundFileName);
+      if (EFI_ERROR (Status)) {
+        break;
+      }
+
+      if (!StrCmp (FileName, FoundFileName)) {
+        //
+        // FID has been found. Prepare to find its respective FE/EFE.
+        //
+        Found = TRUE;
+        break;
+      }
+    }
+
+  Skip_Fid:
+    FreePool ((VOID *)FileIdentifierDesc);
+  }
+
+  if (ReadDirInfo.DirectoryData) {
+    //
+    // Free all allocated resources for the directory listing.
+    //
+    FreePool (ReadDirInfo.DirectoryData);
+  }
+
+  if (Found) {
+    Status = EFI_SUCCESS;
+
+    File->FileIdentifierDesc = FileIdentifierDesc;
+
+    //
+    // If the requested file is root directory, then the FE/EFE was already
+    // retrieved in UdfOpenVolume() function, thus no need to find it again.
+    //
+    // Otherwise, find FE/EFE from the respective FID.
+    //
+    if (StrCmp (FileName, L"\\")) {
+      Status = FindFileEntry (
+        BlockIo,
+        DiskIo,
+        Volume,
+        &FileIdentifierDesc->Icb,
+        &CompareFileEntry
+        );
+      if (EFI_ERROR (Status)) {
+        goto Error_Find_Fe;
+      }
+
+      //
+      // Make sure that both Parent's FE/EFE and found FE/EFE are not equal.
+      //
+      if (CompareMem ((VOID *)Parent->FileEntry, (VOID *)CompareFileEntry,
+                      Volume->FileEntrySize) != 0) {
+        File->FileEntry = CompareFileEntry;
+      } else {
+        FreePool ((VOID *)FileIdentifierDesc);
+        FreePool ((VOID *)CompareFileEntry);
+        Status = EFI_NOT_FOUND;
+      }
+    }
+  }
+
+  return Status;
+
+Error_Find_Fe:
+  FreePool ((VOID *)FileIdentifierDesc);
+
+  return Status;
+}
+
+/**
+  Check if medium contains an UDF file system.
+
+  @param[in]   BlockIo  BlockIo interface.
+  @param[in]   DiskIo   DiskIo interface.
+
+  @retval EFI_SUCCESS          UDF file system found.
+  @retval EFI_UNSUPPORTED      UDF file system not found.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The scan was not successful due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+SupportUdfFileSystem (
+  IN EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN EFI_DISK_IO_PROTOCOL   *DiskIo
+  )
+{
+  EFI_STATUS                            Status;
+  UINT64                                Offset;
+  UINT64                                EndDiskOffset;
+  UDF_VOLUME_DESCRIPTOR                 VolDescriptor;
+  UDF_VOLUME_DESCRIPTOR                 TerminatingVolDescriptor;
+  UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER  AnchorPoint;
+
+  ZeroMem ((VOID *)&TerminatingVolDescriptor, sizeof (UDF_VOLUME_DESCRIPTOR));
+
+  //
+  // Start Volume Recognition Sequence
+  //
+  EndDiskOffset = BlockIo->Media->LastBlock * BlockIo->Media->BlockSize;
+
+  for (Offset = UDF_VRS_START_OFFSET; Offset < EndDiskOffset;
+       Offset += UDF_LOGICAL_SECTOR_SIZE) {
+    Status = DiskIo->ReadDisk (
+      DiskIo,
+      BlockIo->Media->MediaId,
+      Offset,
+      sizeof (UDF_VOLUME_DESCRIPTOR),
+      (VOID *)&VolDescriptor
+      );
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    if (CompareMem ((VOID *)&VolDescriptor.StandardIdentifier,
+                    (VOID *)&gUdfStandardIdentifiers[BEA_IDENTIFIER],
+                    UDF_STANDARD_IDENTIFIER_LENGTH) == 0) {
+      break;
+    }
+
+    if ((CompareMem ((VOID *)&VolDescriptor.StandardIdentifier,
+                     (VOID *)UDF_CDROM_VOLUME_IDENTIFIER,
+                     UDF_STANDARD_IDENTIFIER_LENGTH) != 0) ||
+        (CompareMem ((VOID *)&VolDescriptor,
+                     (VOID *)&TerminatingVolDescriptor,
+                     sizeof (UDF_VOLUME_DESCRIPTOR)) == 0)) {
+      return EFI_UNSUPPORTED;
+    }
+  }
+
+  //
+  // Look for "NSR03" identifier in the Extended Area
+  //
+  Offset += UDF_LOGICAL_SECTOR_SIZE;
+  if (Offset >= EndDiskOffset) {
+    return EFI_UNSUPPORTED;
+  }
+
+  Status = DiskIo->ReadDisk (
+    DiskIo,
+    BlockIo->Media->MediaId,
+    Offset,
+    sizeof (UDF_VOLUME_DESCRIPTOR),
+    (VOID *)&VolDescriptor
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (CompareMem ((VOID *)&VolDescriptor.StandardIdentifier,
+                  (VOID *)&gUdfStandardIdentifiers[VSD_IDENTIFIER],
+                  UDF_STANDARD_IDENTIFIER_LENGTH) != 0) {
+    return EFI_UNSUPPORTED;
+  }
+
+  //
+  // Look for "TEA01" identifier in the Extended Area
+  //
+  Offset += UDF_LOGICAL_SECTOR_SIZE;
+  if (Offset >= EndDiskOffset) {
+    return EFI_UNSUPPORTED;
+  }
+
+  Status = DiskIo->ReadDisk (
+    DiskIo,
+    BlockIo->Media->MediaId,
+    Offset,
+    sizeof (UDF_VOLUME_DESCRIPTOR),
+    (VOID *)&VolDescriptor
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (CompareMem ((VOID *)&VolDescriptor.StandardIdentifier,
+                  (VOID *)&gUdfStandardIdentifiers[TEA_IDENTIFIER],
+                  UDF_STANDARD_IDENTIFIER_LENGTH) != 0) {
+    return EFI_UNSUPPORTED;
+  }
+
+  Status = FindAnchorVolumeDescriptorPointer (BlockIo, DiskIo, &AnchorPoint);
+  if (EFI_ERROR (Status)) {
+    return EFI_UNSUPPORTED;
+  }
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Read volume information on a medium which contains a valid UDF file system.
+
+  @param[in]   BlockIo  BlockIo interface.
+  @param[in]   DiskIo   DiskIo interface.
+  @param[out]  Volume   UDF volume information structure.
+
+  @retval EFI_SUCCESS          Volume information read.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The volume was not read due to lack of resources.
+
+**/
+EFI_STATUS
+ReadUdfVolumeInformation (
+  IN   EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL   *DiskIo,
+  OUT  UDF_VOLUME_INFO        *Volume
+  )
+{
+  EFI_STATUS Status;
+
+  Status = ReadVolumeFileStructure (
+    BlockIo,
+    DiskIo,
+    Volume
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  Status = GetFileSetDescriptors (
+    BlockIo,
+    DiskIo,
+    Volume
+    );
+  if (EFI_ERROR (Status)) {
+    CleanupVolumeInformation (Volume);
+  }
+
+  return Status;
+}
+
+/**
+  Find the root directory on an UDF volume.
+
+  @param[in]   BlockIo  BlockIo interface.
+  @param[in]   DiskIo   DiskIo interface.
+  @param[in]   Volume   UDF volume information structure.
+  @param[out]  File     Root directory file.
+
+  @retval EFI_SUCCESS          Root directory found.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The root directory was not found due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+FindRootDirectory (
+  IN   EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL   *DiskIo,
+  IN   UDF_VOLUME_INFO        *Volume,
+  OUT  UDF_FILE_INFO          *File
+  )
+{
+  EFI_STATUS     Status;
+  UDF_FILE_INFO  Parent;
+
+  Status = FindFileEntry (
+    BlockIo,
+    DiskIo,
+    Volume,
+    &Volume->FileSetDescs[0]->RootDirectoryIcb,
+    &File->FileEntry
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  Parent.FileEntry = File->FileEntry;
+  Parent.FileIdentifierDesc = NULL;
+
+  Status = FindFile (
+    BlockIo,
+    DiskIo,
+    Volume,
+    L"\\",
+    NULL,
+    &Parent,
+    &Volume->FileSetDescs[0]->RootDirectoryIcb,
+    File
+    );
+  if (EFI_ERROR (Status)) {
+    FreePool (File->FileEntry);
+  }
+
+  return Status;
+}
+
+/**
+  Find either a File Entry or a Extended File Entry from a given ICB.
+
+  @param[in]   BlockIo    BlockIo interface.
+  @param[in]   DiskIo     DiskIo interface.
+  @param[in]   Volume     UDF volume information structure.
+  @param[in]   Icb        ICB of the FID.
+  @param[out]  FileEntry  File Entry or Extended File Entry.
+
+  @retval EFI_SUCCESS          File Entry or Extended File Entry found.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The FE/EFE entry was not found due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+FindFileEntry (
+  IN   EFI_BLOCK_IO_PROTOCOL           *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL            *DiskIo,
+  IN   UDF_VOLUME_INFO                 *Volume,
+  IN   UDF_LONG_ALLOCATION_DESCRIPTOR  *Icb,
+  OUT  VOID                            **FileEntry
+  )
+{
+  EFI_STATUS  Status;
+  UINT64      Lsn;
+  UINT32      LogicalBlockSize;
+
+  Lsn               = GetLongAdLsn (Volume, Icb);
+  LogicalBlockSize  = LV_BLOCK_SIZE (Volume, UDF_DEFAULT_LV_NUM);
+
+  *FileEntry = AllocateZeroPool (Volume->FileEntrySize);
+  if (*FileEntry == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  //
+  // Read extent.
+  //
+  Status = DiskIo->ReadDisk (
+    DiskIo,
+    BlockIo->Media->MediaId,
+    MultU64x32 (Lsn, LogicalBlockSize),
+    Volume->FileEntrySize,
+    *FileEntry
+    );
+  if (EFI_ERROR (Status)) {
+    goto Error_Read_Disk_Blk;
+  }
+
+  //
+  // Check if the read extent contains a valid Tag Identifier for the expected
+  // FE/EFE.
+  //
+  if (!IS_FE (*FileEntry) && !IS_EFE (*FileEntry)) {
+    Status = EFI_VOLUME_CORRUPTED;
+    goto Error_Invalid_Fe;
+  }
+
+  return EFI_SUCCESS;
+
+Error_Invalid_Fe:
+Error_Read_Disk_Blk:
+  FreePool (*FileEntry);
+
+  return Status;
+}
+
+/**
+  Find a file given its absolute path on an UDF volume.
+
+  @param[in]   BlockIo   BlockIo interface.
+  @param[in]   DiskIo    DiskIo interface.
+  @param[in]   Volume    UDF volume information structure.
+  @param[in]   FilePath  File's absolute path.
+  @param[in]   Root      Root directory file.
+  @param[in]   Parent    Parent directory file.
+  @param[out]  File      Found file.
+
+  @retval EFI_SUCCESS          @p FilePath was found.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The @p FilePath file was not found due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+FindFile (
+  IN   EFI_BLOCK_IO_PROTOCOL           *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL            *DiskIo,
+  IN   UDF_VOLUME_INFO                 *Volume,
+  IN   CHAR16                          *FilePath,
+  IN   UDF_FILE_INFO                   *Root,
+  IN   UDF_FILE_INFO                   *Parent,
+  IN   UDF_LONG_ALLOCATION_DESCRIPTOR  *Icb,
+  OUT  UDF_FILE_INFO                   *File
+  )
+{
+  EFI_STATUS     Status;
+  CHAR16         FileName[UDF_FILENAME_LENGTH];
+  CHAR16         *FileNamePointer;
+  UDF_FILE_INFO  PreviousFile;
+  VOID           *FileEntry;
+
+  Status = EFI_NOT_FOUND;
+
+  CopyMem ((VOID *)&PreviousFile, (VOID *)Parent, sizeof (UDF_FILE_INFO));
+  while (*FilePath != L'\0') {
+    FileNamePointer = FileName;
+    while (*FilePath != L'\0' && *FilePath != L'\\') {
+      *FileNamePointer++ = *FilePath++;
+    }
+
+    *FileNamePointer = L'\0';
+    if (FileName[0] == L'\0') {
+      //
+      // Open root directory.
+      //
+      if (!Root) {
+        //
+        // There is no file found for the root directory yet. So, find only its
+        // FID by now.
+        //
+        // See UdfOpenVolume() function.
+        //
+        Status = InternalFindFile (BlockIo,
+                                   DiskIo,
+                                   Volume,
+                                   L"\\",
+                                   &PreviousFile,
+                                   Icb,
+                                   File);
+      } else {
+        //
+        // We've already a file pointer (Root) for the root directory. Duplicate
+        // its FE/EFE and FID descriptors.
+        //
+        DuplicateFe (BlockIo, Volume, Root->FileEntry, &File->FileEntry);
+        DuplicateFid (Root->FileIdentifierDesc, &File->FileIdentifierDesc);
+        Status = EFI_SUCCESS;
+      }
+    } else {
+      //
+      // No root directory. Find filename from the current directory.
+      //
+      Status = InternalFindFile (BlockIo,
+                                 DiskIo,
+                                 Volume,
+                                 FileName,
+                                 &PreviousFile,
+                                 Icb,
+                                 File);
+    }
+
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    //
+    // If the found file is a symlink, then find its respective FE/EFE and
+    // FID descriptors.
+    //
+    if (IS_FE_SYMLINK (File->FileEntry)) {
+      FreePool ((VOID *)File->FileIdentifierDesc);
+
+      FileEntry = File->FileEntry;
+
+      Status = ResolveSymlink (BlockIo,
+                               DiskIo,
+                               Volume,
+                               &PreviousFile,
+                               FileEntry,
+                               File);
+
+      FreePool (FileEntry);
+
+      if (EFI_ERROR (Status)) {
+        return Status;
+      }
+    }
+
+    if (CompareMem ((VOID *)&PreviousFile, (VOID *)Parent,
+                    sizeof (UDF_FILE_INFO)) != 0) {
+      CleanupFileInformation (&PreviousFile);
+    }
+
+    CopyMem ((VOID *)&PreviousFile, (VOID *)File, sizeof (UDF_FILE_INFO));
+    if (*FilePath != L'\0' && *FilePath == L'\\') {
+      FilePath++;
+    }
+  }
+
+  return Status;
+}
+
+/**
+  Read a directory entry at a time on an UDF volume.
+
+  @param[in]      BlockIo        BlockIo interface.
+  @param[in]      DiskIo         DiskIo interface.
+  @param[in]      Volume         UDF volume information structure.
+  @param[in]      ParentIcb      ICB of the parent file.
+  @param[in]      FileEntryData  FE/EFE of the parent file.
+  @param[in out]  ReadDirInfo    Next read directory listing structure
+                                 information.
+  @param[out]     FoundFid       File Identifier Descriptor pointer.
+
+  @retval EFI_SUCCESS          Directory entry read.
+  @retval EFI_UNSUPPORTED      Extended Allocation Descriptors not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The directory entry was not read due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+ReadDirectoryEntry (
+  IN      EFI_BLOCK_IO_PROTOCOL           *BlockIo,
+  IN      EFI_DISK_IO_PROTOCOL            *DiskIo,
+  IN      UDF_VOLUME_INFO                 *Volume,
+  IN      UDF_LONG_ALLOCATION_DESCRIPTOR  *ParentIcb,
+  IN      VOID                            *FileEntryData,
+  IN OUT  UDF_READ_DIRECTORY_INFO         *ReadDirInfo,
+  OUT     UDF_FILE_IDENTIFIER_DESCRIPTOR  **FoundFid
+  )
+{
+  EFI_STATUS                      Status;
+  UDF_READ_FILE_INFO              ReadFileInfo;
+  UDF_FILE_IDENTIFIER_DESCRIPTOR  *FileIdentifierDesc;
+
+  if (!ReadDirInfo->DirectoryData) {
+    //
+    // The directory's recorded data has not been read yet. So let's cache it
+    // into memory and the next calls won't need to read it again.
+    //
+    ReadFileInfo.Flags = READ_FILE_ALLOCATE_AND_READ;
+
+    Status = ReadFile (
+      BlockIo,
+      DiskIo,
+      Volume,
+      ParentIcb,
+      FileEntryData,
+      &ReadFileInfo
+      );
+    if (EFI_ERROR (Status)) {
+      return Status;
+    }
+
+    //
+    // Fill in ReadDirInfo structure with the read directory's data information.
+    //
+    ReadDirInfo->DirectoryData = ReadFileInfo.FileData;
+    ReadDirInfo->DirectoryLength = ReadFileInfo.ReadLength;
+  }
+
+  do {
+    if (ReadDirInfo->FidOffset >= ReadDirInfo->DirectoryLength) {
+      //
+      // There aren't FIDS for this directory anymore. The EFI_DEVICE_ERROR will
+      // indicate end of directory listing.
+      //
+      return EFI_DEVICE_ERROR;
+    }
+
+    //
+    // Get FID for this entry.
+    //
+    FileIdentifierDesc =
+      GET_FID_FROM_ADS (ReadDirInfo->DirectoryData,
+                        ReadDirInfo->FidOffset);
+    //
+    // Update FidOffset to point to the next FID.
+    //
+    ReadDirInfo->FidOffset += GetFidDescriptorLength (FileIdentifierDesc);
+  } while (IS_FID_DELETED_FILE (FileIdentifierDesc));
+
+  DuplicateFid (FileIdentifierDesc, FoundFid);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Get a filename (encoded in OSTA-compressed format) from a File Identifier
+  Descriptor on an UDF volume.
+
+  @param[in]   FileIdentifierDesc  File Identifier Descriptor pointer.
+  @param[out]  FileName            Decoded filename.
+
+  @retval EFI_SUCCESS           Filename decoded and read.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+**/
+EFI_STATUS
+GetFileNameFromFid (
+  IN   UDF_FILE_IDENTIFIER_DESCRIPTOR  *FileIdentifierDesc,
+  OUT  CHAR16                          *FileName
+  )
+{
+  UINT8 *OstaCompressed;
+  UINT8 CompressionId;
+  UINT8 Length;
+  UINTN Index;
+
+  OstaCompressed =
+    (UINT8 *)(
+      (UINT8 *)&FileIdentifierDesc->Data[0] +
+      FileIdentifierDesc->LengthOfImplementationUse
+      );
+
+  CompressionId = OstaCompressed[0];
+  if (!IS_VALID_COMPRESSION_ID (CompressionId)) {
+    return EFI_VOLUME_CORRUPTED;
+  }
+
+  //
+  // Decode filename.
+  //
+  Length = FileIdentifierDesc->LengthOfFileIdentifier;
+  for (Index = 1; Index < Length; Index++) {
+    if (CompressionId == 16) {
+      *FileName = OstaCompressed[Index++] << 8;
+    } else {
+      *FileName = 0;
+    }
+
+    if (Index < Length) {
+      *FileName |= OstaCompressed[Index];
+    }
+
+    FileName++;
+  }
+
+  *FileName = L'\0';
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Resolve a symlink file on an UDF volume.
+
+  @param[in]   BlockIo        BlockIo interface.
+  @param[in]   DiskIo         DiskIo interface.
+  @param[in]   Volume         UDF volume information structure.
+  @param[in]   Parent         Parent file.
+  @param[in]   FileEntryData  FE/EFE structure pointer.
+  @param[out]  File           Resolved file.
+
+  @retval EFI_SUCCESS          Symlink file resolved.
+  @retval EFI_UNSUPPORTED      Extended Allocation Descriptors not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The symlink file was not resolved due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+ResolveSymlink (
+  IN   EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL   *DiskIo,
+  IN   UDF_VOLUME_INFO        *Volume,
+  IN   UDF_FILE_INFO          *Parent,
+  IN   VOID                   *FileEntryData,
+  OUT  UDF_FILE_INFO          *File
+  )
+{
+  EFI_STATUS          Status;
+  UDF_READ_FILE_INFO  ReadFileInfo;
+  UINT8               *Data;
+  UINT64              Length;
+  UINT8               *EndData;
+  UDF_PATH_COMPONENT  *PathComp;
+  UINT8               PathCompLength;
+  CHAR16              FileName[UDF_FILENAME_LENGTH];
+  CHAR16              *C;
+  UINTN               Index;
+  UINT8               CompressionId;
+  UDF_FILE_INFO       PreviousFile;
+
+  //
+  // Symlink files on UDF volumes do not contain so much data other than
+  // Path Components which resolves to real filenames, so it's OK to read in
+  // all its data here -- usually the data will be inline with the FE/EFE for
+  // lower filenames.
+  //
+  ReadFileInfo.Flags = READ_FILE_ALLOCATE_AND_READ;
+
+  Status = ReadFile (
+    BlockIo,
+    DiskIo,
+    Volume,
+    &Parent->FileIdentifierDesc->Icb,
+    FileEntryData,
+    &ReadFileInfo
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  Length = ReadFileInfo.ReadLength;
+
+  Data = (UINT8 *)ReadFileInfo.FileData;
+  EndData = Data + Length;
+
+  CopyMem ((VOID *)&PreviousFile, (VOID *)Parent, sizeof (UDF_FILE_INFO));
+
+  for (;;) {
+    PathComp = (UDF_PATH_COMPONENT *)Data;
+
+    PathCompLength = PathComp->LengthOfComponentIdentifier;
+
+    switch (PathComp->ComponentType) {
+    case 1:
+      //
+      // This Path Component specifies the root directory hierarchy subject to
+      // agreement between the originator and recipient of the medium. Skip it.
+      //
+      // Fall through.
+      //
+    case 2:
+      //
+      // "\\." of the current directory. Read next Path Component.
+      //
+      goto Next_Path_Component;
+    case 3:
+      //
+      // ".." (parent directory). Go to it.
+      //
+      CopyMem ((VOID *)FileName, L"..", 6);
+      break;
+    case 4:
+      //
+      // "." (current file). Duplicate both FE/EFE and FID of this file.
+      //
+      DuplicateFe (BlockIo, Volume, PreviousFile.FileEntry, &File->FileEntry);
+      DuplicateFid (PreviousFile.FileIdentifierDesc,
+                    &File->FileIdentifierDesc);
+      goto Next_Path_Component;
+    case 5:
+      //
+      // This Path Component identifies an object, either a file or a
+      // directory or an alias.
+      //
+      // Decode it from the compressed data in ComponentIdentifier and find
+      // respective path.
+      //
+      CompressionId = PathComp->ComponentIdentifier[0];
+      if (!IS_VALID_COMPRESSION_ID (CompressionId)) {
+        return EFI_VOLUME_CORRUPTED;
+      }
+
+      C = FileName;
+      for (Index = 1; Index < PathCompLength; Index++) {
+        if (CompressionId == 16) {
+          *C = *(UINT8 *)((UINT8 *)PathComp->ComponentIdentifier +
+                          Index) << 8;
+          Index++;
+        } else {
+          *C = 0;
+        }
+
+        if (Index < Length) {
+          *C |= *(UINT8 *)((UINT8 *)PathComp->ComponentIdentifier + Index);
+        }
+
+        C++;
+      }
+
+      *C = L'\0';
+      break;
+    }
+
+    //
+    // Find file from the read filename in symlink's file data.
+    //
+    Status = InternalFindFile (
+      BlockIo,
+      DiskIo,
+      Volume,
+      FileName,
+      &PreviousFile,
+      NULL,
+      File
+      );
+    if (EFI_ERROR (Status)) {
+      goto Error_Find_File;
+    }
+
+  Next_Path_Component:
+    Data += sizeof (UDF_PATH_COMPONENT) + PathCompLength;
+    if (Data >= EndData) {
+      break;
+    }
+
+    if (CompareMem ((VOID *)&PreviousFile, (VOID *)Parent,
+                    sizeof (UDF_FILE_INFO)) != 0) {
+      CleanupFileInformation (&PreviousFile);
+    }
+
+    CopyMem ((VOID *)&PreviousFile, (VOID *)File, sizeof (UDF_FILE_INFO));
+  }
+
+  //
+  // Unmap the symlink file.
+  //
+  FreePool (ReadFileInfo.FileData);
+
+  return EFI_SUCCESS;
+
+Error_Find_File:
+  if (CompareMem ((VOID *)&PreviousFile, (VOID *)Parent,
+                  sizeof (UDF_FILE_INFO)) != 0) {
+    CleanupFileInformation (&PreviousFile);
+  }
+
+  FreePool (ReadFileInfo.FileData);
+
+  return Status;
+}
+
+/**
+  Clean up in-memory UDF volume information.
+
+  @param[in] Volume Volume information pointer.
+
+**/
+VOID
+CleanupVolumeInformation (
+  IN UDF_VOLUME_INFO *Volume
+  )
+{
+  UINTN Index;
+
+  if (Volume->LogicalVolDescs != NULL) {
+    for (Index = 0; Index < Volume->LogicalVolDescsNo; Index++) {
+      FreePool ((VOID *)Volume->LogicalVolDescs[Index]);
+    }
+
+    FreePool ((VOID *)Volume->LogicalVolDescs);
+  }
+
+  if (Volume->PartitionDescs != NULL) {
+    for (Index = 0; Index < Volume->PartitionDescsNo; Index++) {
+      FreePool ((VOID *)Volume->PartitionDescs[Index]);
+    }
+
+    FreePool ((VOID *)Volume->PartitionDescs);
+  }
+
+  if (Volume->FileSetDescs != NULL) {
+    for (Index = 0; Index < Volume->FileSetDescsNo; Index++) {
+      FreePool ((VOID *)Volume->FileSetDescs[Index]);
+    }
+
+    FreePool ((VOID *)Volume->FileSetDescs);
+  }
+
+  ZeroMem ((VOID *)Volume, sizeof (UDF_VOLUME_INFO));
+}
+
+/**
+  Clean up in-memory UDF file information.
+
+  @param[in] File File information pointer.
+
+**/
+VOID
+CleanupFileInformation (
+  IN UDF_FILE_INFO *File
+  )
+{
+  if (File->FileEntry != NULL) {
+    FreePool (File->FileEntry);
+  }
+
+  if (File->FileIdentifierDesc != NULL) {
+    FreePool ((VOID *)File->FileIdentifierDesc);
+  }
+
+  ZeroMem ((VOID *)File, sizeof (UDF_FILE_INFO));
+}
+
+/**
+  Find a file from its absolute path on an UDF volume.
+
+  @param[in]   BlockIo  BlockIo interface.
+  @param[in]   DiskIo   DiskIo interface.
+  @param[in]   Volume   UDF volume information structure.
+  @param[in]   File     File information structure.
+  @param[out]  Size     Size of the file.
+
+  @retval EFI_SUCCESS          File size calculated and set in @p Size.
+  @retval EFI_UNSUPPORTED      Extended Allocation Descriptors not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The file size was not calculated due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+GetFileSize (
+  IN   EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL   *DiskIo,
+  IN   UDF_VOLUME_INFO        *Volume,
+  IN   UDF_FILE_INFO          *File,
+  OUT  UINT64                 *Size
+  )
+{
+  EFI_STATUS          Status;
+  UDF_READ_FILE_INFO  ReadFileInfo;
+
+  ReadFileInfo.Flags = READ_FILE_GET_FILESIZE;
+
+  Status = ReadFile (
+    BlockIo,
+    DiskIo,
+    Volume,
+    &File->FileIdentifierDesc->Icb,
+    File->FileEntry,
+    &ReadFileInfo
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  *Size = ReadFileInfo.ReadLength;
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Set information about a file on an UDF volume.
+
+  @param[in]      File        File pointer.
+  @param[in]      FileSize    Size of the file.
+  @param[in]      FileName    Filename of the file.
+  @param[in out]  BufferSize  Size of the returned file infomation.
+  @param[out]     Buffer      Data of the returned file information.
+
+  @retval EFI_SUCCESS          File information set.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The file information was not set due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+SetFileInfo (
+  IN      UDF_FILE_INFO  *File,
+  IN      UINT64         FileSize,
+  IN      CHAR16         *FileName,
+  IN OUT  UINTN          *BufferSize,
+  OUT     VOID           *Buffer
+  )
+{
+  UINTN                    FileInfoLength;
+  EFI_FILE_INFO            *FileInfo;
+  UDF_FILE_ENTRY           *FileEntry;
+  UDF_EXTENDED_FILE_ENTRY  *ExtendedFileEntry;
+
+  //
+  // Calculate the needed size for the EFI_FILE_INFO structure.
+  //
+  FileInfoLength = sizeof (EFI_FILE_INFO) + (FileName ?
+                                             StrSize (FileName) :
+                                             sizeof (CHAR16)
+    );
+  if (*BufferSize < FileInfoLength) {
+    //
+    // The given Buffer has no size enough for EFI_FILE_INFO structure.
+    //
+    *BufferSize = FileInfoLength;
+    return EFI_BUFFER_TOO_SMALL;
+  }
+
+  //
+  // Buffer now contains room enough to store EFI_FILE_INFO structure.
+  // Now, fill it in with all necessary information about the file.
+  //
+  FileInfo = (EFI_FILE_INFO *)Buffer;
+  FileInfo->Size         = FileInfoLength;
+  FileInfo->Attribute    &= ~EFI_FILE_VALID_ATTR;
+  FileInfo->Attribute    |= EFI_FILE_READ_ONLY;
+
+  if (IS_FID_DIRECTORY_FILE (File->FileIdentifierDesc)) {
+    FileInfo->Attribute |= EFI_FILE_DIRECTORY;
+  } else if (IS_FID_NORMAL_FILE (File->FileIdentifierDesc)) {
+    FileInfo->Attribute |= EFI_FILE_ARCHIVE;
+  }
+
+  if (IS_FID_HIDDEN_FILE (File->FileIdentifierDesc)) {
+    FileInfo->Attribute |= EFI_FILE_HIDDEN;
+  }
+
+  if (IS_FE (File->FileEntry)) {
+    FileEntry = (UDF_FILE_ENTRY *)File->FileEntry;
+
+    //
+    // Check if FE has the system attribute set.
+    //
+    if (FileEntry->IcbTag.Flags & (1 << 10)) {
+      FileInfo->Attribute |= EFI_FILE_SYSTEM;
+    }
+
+    FileInfo->FileSize      = FileSize;
+    FileInfo->PhysicalSize  = FileSize;
+
+    FileInfo->CreateTime.Year        = FileEntry->AccessTime.Year;
+    FileInfo->CreateTime.Month       = FileEntry->AccessTime.Month;
+    FileInfo->CreateTime.Day         = FileEntry->AccessTime.Day;
+    FileInfo->CreateTime.Hour        = FileEntry->AccessTime.Hour;
+    FileInfo->CreateTime.Minute      = FileEntry->AccessTime.Second;
+    FileInfo->CreateTime.Second      = FileEntry->AccessTime.Second;
+    FileInfo->CreateTime.Nanosecond  =
+                                   FileEntry->AccessTime.HundredsOfMicroseconds;
+
+    FileInfo->LastAccessTime.Year        =
+                                   FileEntry->AccessTime.Year;
+    FileInfo->LastAccessTime.Month       =
+                                   FileEntry->AccessTime.Month;
+    FileInfo->LastAccessTime.Day         =
+                                   FileEntry->AccessTime.Day;
+    FileInfo->LastAccessTime.Hour        =
+                                   FileEntry->AccessTime.Hour;
+    FileInfo->LastAccessTime.Minute      =
+                                   FileEntry->AccessTime.Minute;
+    FileInfo->LastAccessTime.Second      =
+                                   FileEntry->AccessTime.Second;
+    FileInfo->LastAccessTime.Nanosecond  =
+                                   FileEntry->AccessTime.HundredsOfMicroseconds;
+  } else if (IS_EFE (File->FileEntry)) {
+    ExtendedFileEntry = (UDF_EXTENDED_FILE_ENTRY *)File->FileEntry;
+
+    //
+    // Check if EFE has the system attribute set.
+    //
+    if (ExtendedFileEntry->IcbTag.Flags & (1 << 10)) {
+      FileInfo->Attribute |= EFI_FILE_SYSTEM;
+    }
+
+    FileInfo->FileSize      = FileSize;
+    FileInfo->PhysicalSize  = FileSize;
+
+    FileInfo->CreateTime.Year        = ExtendedFileEntry->CreationTime.Year;
+    FileInfo->CreateTime.Month       = ExtendedFileEntry->CreationTime.Month;
+    FileInfo->CreateTime.Day         = ExtendedFileEntry->CreationTime.Day;
+    FileInfo->CreateTime.Hour        = ExtendedFileEntry->CreationTime.Hour;
+    FileInfo->CreateTime.Minute      = ExtendedFileEntry->CreationTime.Second;
+    FileInfo->CreateTime.Second      = ExtendedFileEntry->CreationTime.Second;
+    FileInfo->CreateTime.Nanosecond  =
+                           ExtendedFileEntry->AccessTime.HundredsOfMicroseconds;
+
+    FileInfo->LastAccessTime.Year        =
+                           ExtendedFileEntry->AccessTime.Year;
+    FileInfo->LastAccessTime.Month       =
+                           ExtendedFileEntry->AccessTime.Month;
+    FileInfo->LastAccessTime.Day         =
+                           ExtendedFileEntry->AccessTime.Day;
+    FileInfo->LastAccessTime.Hour        =
+                           ExtendedFileEntry->AccessTime.Hour;
+    FileInfo->LastAccessTime.Minute      =
+                           ExtendedFileEntry->AccessTime.Minute;
+    FileInfo->LastAccessTime.Second      =
+                           ExtendedFileEntry->AccessTime.Second;
+    FileInfo->LastAccessTime.Nanosecond  =
+                           ExtendedFileEntry->AccessTime.HundredsOfMicroseconds;
+  }
+
+  FileInfo->CreateTime.TimeZone      = EFI_UNSPECIFIED_TIMEZONE;
+  FileInfo->CreateTime.Daylight      = EFI_TIME_ADJUST_DAYLIGHT;
+  FileInfo->LastAccessTime.TimeZone  = EFI_UNSPECIFIED_TIMEZONE;
+  FileInfo->LastAccessTime.Daylight  = EFI_TIME_ADJUST_DAYLIGHT;
+
+  CopyMem ((VOID *)&FileInfo->ModificationTime,
+           (VOID *)&FileInfo->LastAccessTime,
+           sizeof (EFI_TIME));
+
+  if (FileName != NULL) {
+    StrCpyS (FileInfo->FileName, StrLen (FileName) + 1, FileName);
+  } else {
+    FileInfo->FileName[0] = '\0';
+  }
+
+  *BufferSize = FileInfoLength;
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Get volume and free space size information of an UDF volume.
+
+  @param[in]   BlockIo        BlockIo interface.
+  @param[in]   DiskIo         DiskIo interface.
+  @param[in]   Volume         UDF volume information structure.
+  @param[out]  VolumeSize     Volume size.
+  @param[out]  FreeSpaceSize  Free space size.
+
+  @retval EFI_SUCCESS          Volume and free space size calculated.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The volume and free space size were not
+                               calculated due to lack of resources.
+
+**/
+EFI_STATUS
+GetVolumeSize (
+  IN   EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL   *DiskIo,
+  IN   UDF_VOLUME_INFO        *Volume,
+  OUT  UINT64                 *VolumeSize,
+  OUT  UINT64                 *FreeSpaceSize
+  )
+{
+  UDF_EXTENT_AD                 ExtentAd;
+  UINT32                        LogicalBlockSize;
+  UINT64                        Lsn;
+  EFI_STATUS                    Status;
+  UDF_LOGICAL_VOLUME_INTEGRITY  *LogicalVolInt;
+  UINTN                         Index;
+  UINTN                         Length;
+  UINT32                        LsnsNo;
+
+  *VolumeSize     = 0;
+  *FreeSpaceSize  = 0;
+
+  for (Index = 0; Index < Volume->LogicalVolDescsNo; Index++) {
+    CopyMem ((VOID *)&ExtentAd,
+             (VOID *)&Volume->LogicalVolDescs[Index]->IntegritySequenceExtent,
+             sizeof (UDF_EXTENT_AD));
+    if (ExtentAd.ExtentLength == 0) {
+      continue;
+    }
+
+    LogicalBlockSize = LV_BLOCK_SIZE (Volume, Index);
+
+  Read_Next_Sequence:
+    LogicalVolInt = (UDF_LOGICAL_VOLUME_INTEGRITY *)
+      AllocatePool (ExtentAd.ExtentLength);
+    if (LogicalVolInt == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+
+    Lsn = (UINT64)ExtentAd.ExtentLocation;
+
+    Status = DiskIo->ReadDisk (
+      DiskIo,
+      BlockIo->Media->MediaId,
+      MultU64x32 (Lsn, LogicalBlockSize),
+      ExtentAd.ExtentLength,
+      (VOID *)LogicalVolInt
+      );
+    if (EFI_ERROR (Status)) {
+      FreePool ((VOID *)LogicalVolInt);
+      return Status;
+    }
+
+    if (!IS_LVID (LogicalVolInt)) {
+      FreePool ((VOID *)LogicalVolInt);
+      return EFI_VOLUME_CORRUPTED;
+    }
+
+    Length = LogicalVolInt->NumberOfPartitions;
+    for (Index = 0; Index < Length; Index += sizeof (UINT32)) {
+      LsnsNo = *(UINT32 *)((UINT8 *)&LogicalVolInt->Data[0] + Index);
+      if (LsnsNo == 0xFFFFFFFFUL) {
+        //
+        // Size not specified.
+        //
+        continue;
+      }
+
+      *FreeSpaceSize += MultU64x32 ((UINT64)LsnsNo, LogicalBlockSize);
+    }
+
+    Length = (LogicalVolInt->NumberOfPartitions * sizeof (UINT32)) << 1;
+    for (; Index < Length; Index += sizeof (UINT32)) {
+      LsnsNo = *(UINT32 *)((UINT8 *)&LogicalVolInt->Data[0] + Index);
+      if (LsnsNo == 0xFFFFFFFFUL) {
+        //
+        // Size not specified.
+        //
+        continue;
+      }
+
+      *VolumeSize += MultU64x32 ((UINT64)LsnsNo, LogicalBlockSize);
+    }
+
+    CopyMem ((VOID *)&ExtentAd,(VOID *)&LogicalVolInt->NextIntegrityExtent,
+             sizeof (UDF_EXTENT_AD));
+    if (ExtentAd.ExtentLength > 0) {
+      FreePool ((VOID *)LogicalVolInt);
+      goto Read_Next_Sequence;
+    }
+
+    FreePool ((VOID *)LogicalVolInt);
+  }
+
+  return EFI_SUCCESS;
+}
diff --git a/MdeModulePkg/Universal/Disk/UdfDxe/Udf.c b/MdeModulePkg/Universal/Disk/UdfDxe/Udf.c
new file mode 100644
index 0000000000..1b912fb3a3
--- /dev/null
+++ b/MdeModulePkg/Universal/Disk/UdfDxe/Udf.c
@@ -0,0 +1,407 @@
+/** @file
+  UDF/ECMA-167 file system driver.
+
+  Copyright (C) 2014-2017 Paulo Alcantara <pcacjr@zytor.com>
+
+  This program and the accompanying materials are licensed and made available
+  under the terms and conditions of the BSD License which accompanies this
+  distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
+  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+**/
+
+#include "Udf.h"
+
+//
+// UDF filesystem driver's Global Variables.
+//
+EFI_DRIVER_BINDING_PROTOCOL gUdfDriverBinding = {
+  UdfDriverBindingSupported,
+  UdfDriverBindingStart,
+  UdfDriverBindingStop,
+  0x0000000BUL,
+  NULL,
+  NULL
+};
+
+typedef struct {
+  VENDOR_DEVICE_PATH        DevicePath;
+  EFI_DEVICE_PATH_PROTOCOL  End;
+} UDF_DEVICE_PATH;
+
+//
+// C5BD4D42-1A76-4996-8956-73CDA326CD0A
+//
+#define EFI_UDF_DEVICE_PATH_GUID \
+  { 0xC5BD4D42, 0x1A76, 0x4996, \
+    { 0x89, 0x56, 0x73, 0xCD, 0xA3, 0x26, 0xCD, 0x0A } \
+  }
+
+UDF_DEVICE_PATH gUdfDevicePath = {
+  { { MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP,
+      { sizeof (VENDOR_DEVICE_PATH), 0 } },
+    EFI_UDF_DEVICE_PATH_GUID
+  },
+  { END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE,
+    { sizeof (EFI_DEVICE_PATH_PROTOCOL), 0 }
+  }
+};
+
+EFI_SIMPLE_FILE_SYSTEM_PROTOCOL gUdfSimpleFsOps = {
+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION,
+  UdfOpenVolume
+};
+
+/**
+  Test to see if this driver supports ControllerHandle. Any ControllerHandle
+  than contains a BlockIo and DiskIo protocol or a BlockIo2 protocol can be
+  supported.
+
+  @param[in]  This                Protocol instance pointer.
+  @param[in]  ControllerHandle    Handle of device to test.
+  @param[in]  RemainingDevicePath Optional parameter use to pick a specific
+                                  child device to start.
+
+  @retval EFI_SUCCESS         This driver supports this device.
+  @retval EFI_ALREADY_STARTED This driver is already running on this device.
+  @retval other               This driver does not support this device.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfDriverBindingSupported (
+  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN EFI_HANDLE                   ControllerHandle,
+  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
+  )
+{
+  EFI_STATUS                       Status;
+  EFI_DISK_IO_PROTOCOL             *DiskIo;
+  EFI_BLOCK_IO_PROTOCOL            *BlockIo;
+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *SimpleFs;
+
+  Status = gBS->OpenProtocol (
+    ControllerHandle,
+    &gEfiDiskIoProtocolGuid,
+    (VOID **)&DiskIo,
+    This->DriverBindingHandle,
+    ControllerHandle,
+    EFI_OPEN_PROTOCOL_GET_PROTOCOL
+    );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  Status = gBS->OpenProtocol (
+    ControllerHandle,
+    &gEfiBlockIoProtocolGuid,
+    (VOID **)&BlockIo,
+    This->DriverBindingHandle,
+    ControllerHandle,
+    EFI_OPEN_PROTOCOL_GET_PROTOCOL
+    );
+  if (EFI_ERROR (Status)) {
+    goto Error_Open_BlockIo;
+  }
+
+  Status = SupportUdfFileSystem (BlockIo, DiskIo);
+  if (EFI_ERROR (Status)) {
+    goto Error_No_Udf_Volume;
+  }
+
+  Status = gBS->OpenProtocol (
+    ControllerHandle,
+    &gEfiSimpleFileSystemProtocolGuid,
+    (VOID **)&SimpleFs,
+    This->DriverBindingHandle,
+    ControllerHandle,
+    EFI_OPEN_PROTOCOL_GET_PROTOCOL
+    );
+  if (!EFI_ERROR (Status)) {
+    gBS->CloseProtocol (
+      ControllerHandle,
+      &gEfiSimpleFileSystemProtocolGuid,
+      This->DriverBindingHandle,
+      ControllerHandle
+      );
+    Status = EFI_ALREADY_STARTED;
+  } else {
+    Status = EFI_SUCCESS;
+  }
+
+  if (EFI_ERROR (Status)) {
+Error_No_Udf_Volume:
+Error_Open_BlockIo:
+    gBS->CloseProtocol (
+      ControllerHandle,
+      &gEfiDiskIoProtocolGuid,
+      This->DriverBindingHandle,
+      ControllerHandle
+      );
+    gBS->CloseProtocol (
+      ControllerHandle,
+      &gEfiBlockIoProtocolGuid,
+      This->DriverBindingHandle,
+      ControllerHandle
+      );
+  }
+
+  return Status;
+}
+
+/**
+  Start this driver on ControllerHandle by opening a Block IO or a Block IO2
+  or both, and Disk IO protocol, reading Device Path, and creating a child
+  handle with a Disk IO and device path protocol.
+
+  @param[in]  This                 Protocol instance pointer.
+  @param[in]  ControllerHandle     Handle of device to bind driver to
+  @param[in]  RemainingDevicePath  Optional parameter use to pick a specific
+                                   child device to start.
+
+  @retval EFI_SUCCESS          This driver is added to ControllerHandle.
+  @retval EFI_ALREADY_STARTED  This driver is already running on
+                               ControllerHandle.
+  @retval other                This driver does not support this device.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfDriverBindingStart (
+  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN EFI_HANDLE                   ControllerHandle,
+  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
+  )
+{
+  EFI_TPL                     OldTpl;
+  EFI_STATUS                  Status;
+  EFI_BLOCK_IO_PROTOCOL       *BlockIo;
+  EFI_DISK_IO_PROTOCOL        *DiskIo;
+  PRIVATE_UDF_SIMPLE_FS_DATA  *PrivFsData;
+
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+
+  Status = gBS->OpenProtocol (
+    ControllerHandle,
+    &gEfiBlockIoProtocolGuid,
+    (VOID **)&BlockIo,
+    This->DriverBindingHandle,
+    ControllerHandle,
+    EFI_OPEN_PROTOCOL_GET_PROTOCOL
+    );
+  if (EFI_ERROR (Status)) {
+    goto Exit;
+  }
+
+  Status = gBS->OpenProtocol (
+    ControllerHandle,
+    &gEfiDiskIoProtocolGuid,
+    (VOID **)&DiskIo,
+    This->DriverBindingHandle,
+    ControllerHandle,
+    EFI_OPEN_PROTOCOL_GET_PROTOCOL
+    );
+  if (EFI_ERROR (Status)) {
+    goto Exit;
+  }
+
+  //
+  // Check if media contains a valid UDF volume.
+  //
+  Status = SupportUdfFileSystem (BlockIo, DiskIo);
+  if (EFI_ERROR (Status)) {
+    goto Exit;
+  }
+
+  PrivFsData =
+    (PRIVATE_UDF_SIMPLE_FS_DATA *)
+    AllocateZeroPool (sizeof (PRIVATE_UDF_SIMPLE_FS_DATA));
+  if (PrivFsData == NULL) {
+    Status = EFI_OUT_OF_RESOURCES;
+    goto Exit;
+  }
+
+  //
+  // Create new child handle
+  //
+  PrivFsData->Signature = PRIVATE_UDF_SIMPLE_FS_DATA_SIGNATURE;
+  PrivFsData->BlockIo   = BlockIo;
+  PrivFsData->DiskIo    = DiskIo;
+
+  CopyMem ((VOID *)&PrivFsData->SimpleFs, (VOID *)&gUdfSimpleFsOps,
+           sizeof (EFI_SIMPLE_FILE_SYSTEM_PROTOCOL));
+
+  PrivFsData->DevicePath =
+    DuplicateDevicePath ((EFI_DEVICE_PATH_PROTOCOL *)&gUdfDevicePath);
+
+  //
+  // Install new child handle
+  //
+  Status = gBS->InstallMultipleProtocolInterfaces (
+    &PrivFsData->Handle,
+    &gEfiSimpleFileSystemProtocolGuid,
+    &PrivFsData->SimpleFs,
+    &gEfiDevicePathProtocolGuid,
+    PrivFsData->DevicePath,
+    NULL,
+    NULL
+    );
+
+Exit:
+  gBS->RestoreTPL (OldTpl);
+
+  return Status;
+}
+
+/**
+  Stop this driver on ControllerHandle. Support stopping any child handles
+  created by this driver.
+
+  @param  This              Protocol instance pointer.
+  @param  ControllerHandle  Handle of device to stop driver on
+  @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
+                            children is zero stop the entire bus driver.
+  @param  ChildHandleBuffer List of Child Handles to Stop.
+
+  @retval EFI_SUCCESS       This driver is removed ControllerHandle
+  @retval other             This driver was not removed from this device
+
+**/
+EFI_STATUS
+EFIAPI
+UdfDriverBindingStop (
+  IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
+  IN  EFI_HANDLE                    ControllerHandle,
+  IN  UINTN                         NumberOfChildren,
+  IN  EFI_HANDLE                    *ChildHandleBuffer
+  )
+{
+  UINTN Index;
+  PRIVATE_UDF_SIMPLE_FS_DATA        *PrivFsData;
+  EFI_STATUS                        Status;
+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL   *SimpleFs;
+  EFI_DISK_IO_PROTOCOL              *DiskIo;
+  EFI_BLOCK_IO_PROTOCOL              *BlockIo;
+  BOOLEAN                           Done;
+
+  Status = EFI_SUCCESS;
+
+  if (NumberOfChildren == 0) {
+    gBS->CloseProtocol (
+      ControllerHandle,
+      &gEfiDiskIoProtocolGuid,
+      This->DriverBindingHandle,
+      ControllerHandle
+      );
+    goto Exit;
+  }
+
+  Done = TRUE;
+
+  for (Index = 0; Index < NumberOfChildren; Index++) {
+    gBS->OpenProtocol (
+      ChildHandleBuffer[Index],
+      &gEfiSimpleFileSystemProtocolGuid,
+      (VOID **)&SimpleFs,
+      This->DriverBindingHandle,
+      ControllerHandle,
+      EFI_OPEN_PROTOCOL_GET_PROTOCOL
+      );
+
+    PrivFsData = PRIVATE_UDF_SIMPLE_FS_DATA_FROM_THIS (This);
+
+    gBS->CloseProtocol (
+      ControllerHandle,
+      &gEfiDiskIoProtocolGuid,
+      This->DriverBindingHandle,
+      ControllerHandle
+      );
+    gBS->CloseProtocol (
+      ControllerHandle,
+      &gEfiBlockIoProtocolGuid,
+      This->DriverBindingHandle,
+      ControllerHandle
+      );
+
+    Status = gBS->UninstallMultipleProtocolInterfaces (
+      ChildHandleBuffer[Index],
+      &gEfiSimpleFileSystemProtocolGuid,
+      &PrivFsData->SimpleFs,
+      &gEfiDevicePathProtocolGuid,
+      PrivFsData->DevicePath,
+      NULL
+      );
+    if (EFI_ERROR (Status)) {
+      gBS->OpenProtocol (
+        ControllerHandle,
+        &gEfiDiskIoProtocolGuid,
+        (VOID **)&DiskIo,
+        This->DriverBindingHandle,
+        ChildHandleBuffer[Index],
+        EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
+        );
+      gBS->OpenProtocol (
+        ControllerHandle,
+        &gEfiBlockIoProtocolGuid,
+        (VOID **)&BlockIo,
+        This->DriverBindingHandle,
+        ChildHandleBuffer[Index],
+        EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
+        );
+    } else {
+      FreePool ((VOID *)PrivFsData->DevicePath);
+
+      if (PrivFsData->OpenFiles) {
+        CleanupVolumeInformation (&PrivFsData->Volume);
+      }
+
+      FreePool ((VOID *)PrivFsData);
+    }
+
+    if (EFI_ERROR (Status)) {
+      Done = FALSE;
+    }
+  }
+
+  if (!Done) {
+    Status = EFI_DEVICE_ERROR;
+  }
+
+Exit:
+  return Status;
+}
+
+/**
+  The user Entry Point for UDF file system driver. The user code starts with
+  this function.
+
+  @param[in] ImageHandle    The firmware allocated handle for the EFI image.
+  @param[in] SystemTable    A pointer to the EFI System Table.
+
+  @retval EFI_SUCCESS       The entry point is executed successfully.
+  @retval other             Some error occurs when executing this entry point.
+
+**/
+EFI_STATUS
+EFIAPI
+InitializeUdf (
+  IN EFI_HANDLE           ImageHandle,
+  IN EFI_SYSTEM_TABLE     *SystemTable
+  )
+{
+  EFI_STATUS              Status;
+
+  Status = EfiLibInstallDriverBindingComponentName2 (
+    ImageHandle,
+    SystemTable,
+    &gUdfDriverBinding,
+    ImageHandle,
+    &gUdfComponentName,
+    &gUdfComponentName2
+    );
+  ASSERT_EFI_ERROR (Status);
+
+  return Status;
+}
diff --git a/MdeModulePkg/Universal/Disk/UdfDxe/Udf.h b/MdeModulePkg/Universal/Disk/UdfDxe/Udf.h
new file mode 100644
index 0000000000..37d7c613e1
--- /dev/null
+++ b/MdeModulePkg/Universal/Disk/UdfDxe/Udf.h
@@ -0,0 +1,1243 @@
+/** @file
+  UDF/ECMA-167 file system driver.
+
+  Copyright (C) 2014-2017 Paulo Alcantara <pcacjr@zytor.com>
+
+  This program and the accompanying materials are licensed and made available
+  under the terms and conditions of the BSD License which accompanies this
+  distribution.  The full text of the license may be found at
+  http://opensource.org/licenses/bsd-license.php
+
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT
+  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+**/
+
+#ifndef _UDF_H_
+#define _UDF_H_
+
+#include <Uefi.h>
+
+#include <Protocol/BlockIo.h>
+#include <Protocol/ComponentName.h>
+#include <Protocol/DevicePath.h>
+#include <Protocol/DriverBinding.h>
+#include <Protocol/DiskIo.h>
+#include <Protocol/SimpleFileSystem.h>
+
+#include <Guid/FileInfo.h>
+#include <Guid/FileSystemInfo.h>
+#include <Guid/FileSystemVolumeLabelInfo.h>
+
+#include <Library/DebugLib.h>
+#include <Library/UefiDriverEntryPoint.h>
+#include <Library/BaseLib.h>
+#include <Library/UefiLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/DevicePathLib.h>
+
+#define UDF_LOGICAL_SECTOR_SHIFT        11
+#define UDF_LOGICAL_SECTOR_SIZE         ((UINT64)(1 << UDF_LOGICAL_SECTOR_SHIFT))
+#define UDF_VRS_START_OFFSET            ((UINT64)(16 << UDF_LOGICAL_SECTOR_SHIFT))
+#define UDF_STANDARD_IDENTIFIER_LENGTH  5
+#define UDF_CDROM_VOLUME_IDENTIFIER     "CD001"
+
+#define UDF_DEFAULT_LV_NUM              0
+
+#define _GET_TAG_ID(_Pointer) \
+  (((UDF_DESCRIPTOR_TAG *)(_Pointer))->TagIdentifier)
+
+#define IS_PVD(_Pointer) \
+  ((BOOLEAN)(_GET_TAG_ID (_Pointer) == 1))
+#define IS_AVDP(_Pointer) \
+  ((BOOLEAN)(_GET_TAG_ID (_Pointer) == 2))
+#define IS_PD(_Pointer) \
+  ((BOOLEAN)(_GET_TAG_ID (_Pointer) == 5))
+#define IS_LVD(_Pointer) \
+  ((BOOLEAN)(_GET_TAG_ID (_Pointer) == 6))
+#define IS_TD(_Pointer) \
+  ((BOOLEAN)(_GET_TAG_ID (_Pointer) == 8))
+#define IS_FSD(_Pointer) \
+  ((BOOLEAN)(_GET_TAG_ID (_Pointer) == 256))
+#define IS_FE(_Pointer) \
+  ((BOOLEAN)(_GET_TAG_ID (_Pointer) == 261))
+#define IS_EFE(_Pointer) \
+  ((BOOLEAN)(_GET_TAG_ID (_Pointer) == 266))
+#define IS_FID(_Pointer) \
+  ((BOOLEAN)(_GET_TAG_ID (_Pointer) == 257))
+#define IS_AED(_Pointer) \
+  ((BOOLEAN)(_GET_TAG_ID (_Pointer) == 258))
+#define IS_LVID(_Pointer) \
+  ((BOOLEAN)(_GET_TAG_ID (_Pointer) == 9))
+
+#define _GET_FILETYPE(_Pointer) \
+  (IS_FE (_Pointer) ? \
+   (((UDF_FILE_ENTRY *)(_Pointer))->IcbTag.FileType) \
+   : \
+   (((UDF_EXTENDED_FILE_ENTRY *)(_Pointer))->IcbTag.FileType))
+
+#define IS_FE_DIRECTORY(_Pointer) \
+  ((BOOLEAN)(_GET_FILETYPE (_Pointer) == 4))
+#define IS_FE_STANDARD_FILE(_Pointer) \
+  ((BOOLEAN)(_GET_FILETYPE (_Pointer) == 5))
+#define IS_FE_SYMLINK(_Pointer) \
+  ((BOOLEAN)(_GET_FILETYPE (_Pointer) == 12))
+
+#define HIDDEN_FILE     (1 << 0)
+#define DIRECTORY_FILE  (1 << 1)
+#define DELETED_FILE    (1 << 2)
+#define PARENT_FILE     (1 << 3)
+
+#define _GET_FILE_CHARS(_Pointer) \
+  (((UDF_FILE_IDENTIFIER_DESCRIPTOR *)(_Pointer))->FileCharacteristics)
+
+#define IS_FID_HIDDEN_FILE(_Pointer) \
+  ((BOOLEAN)(_GET_FILE_CHARS (_Pointer) & HIDDEN_FILE))
+#define IS_FID_DIRECTORY_FILE(_Pointer) \
+  ((BOOLEAN)(_GET_FILE_CHARS (_Pointer) & DIRECTORY_FILE))
+#define IS_FID_DELETED_FILE(_Pointer) \
+  ((BOOLEAN)(_GET_FILE_CHARS (_Pointer) & DELETED_FILE))
+#define IS_FID_PARENT_FILE(_Pointer) \
+  ((BOOLEAN)(_GET_FILE_CHARS (_Pointer) & PARENT_FILE))
+#define IS_FID_NORMAL_FILE(_Pointer) \
+  ((BOOLEAN)(!IS_FID_DIRECTORY_FILE (_Pointer) && \
+	     !IS_FID_PARENT_FILE (_Pointer)))
+
+typedef enum {
+  SHORT_ADS_SEQUENCE,
+  LONG_ADS_SEQUENCE,
+  EXTENDED_ADS_SEQUENCE,
+  INLINE_DATA
+} UDF_FE_RECORDING_FLAGS;
+
+#define GET_FE_RECORDING_FLAGS(_Fe) \
+  ((UDF_FE_RECORDING_FLAGS)((UDF_ICB_TAG *)( \
+			      (UINT8 *)(_Fe) + \
+			      sizeof (UDF_DESCRIPTOR_TAG)))->Flags & 0x07)
+
+typedef enum {
+  EXTENT_RECORDED_AND_ALLOCATED,
+  EXTENT_NOT_RECORDED_BUT_ALLOCATED,
+  EXTENT_NOT_RECORDED_NOT_ALLOCATED,
+  EXTENT_IS_NEXT_EXTENT,
+} UDF_EXTENT_FLAGS;
+
+#define AD_LENGTH(_RecFlags) \
+  ((_RecFlags) == SHORT_ADS_SEQUENCE ? \
+   ((UINT64)(sizeof (UDF_SHORT_ALLOCATION_DESCRIPTOR))) : \
+   ((UINT64)(sizeof (UDF_LONG_ALLOCATION_DESCRIPTOR))))
+
+#define GET_EXTENT_FLAGS(_RecFlags, _Ad) \
+  ((_RecFlags) == SHORT_ADS_SEQUENCE ? \
+   ((UDF_EXTENT_FLAGS)((((UDF_SHORT_ALLOCATION_DESCRIPTOR *)(_Ad))->ExtentLength >> \
+			30) & 0x3)) : \
+   ((UDF_EXTENT_FLAGS)((((UDF_LONG_ALLOCATION_DESCRIPTOR *)(_Ad))->ExtentLength >> \
+			30) & 0x3)))
+
+#define GET_EXTENT_LENGTH(_RecFlags, _Ad) \
+  ((_RecFlags) == SHORT_ADS_SEQUENCE ? \
+   ((UINT32)((((UDF_SHORT_ALLOCATION_DESCRIPTOR *)(_Ad))->ExtentLength & \
+	      ~0xC0000000UL))) : \
+   ((UINT32)((((UDF_LONG_ALLOCATION_DESCRIPTOR *)(_Ad))->ExtentLength & \
+	      ~0xC0000000UL))))
+
+#define UDF_FILENAME_LENGTH  128
+#define UDF_PATH_LENGTH      512
+
+#define GET_FID_FROM_ADS(_Data, _Offs) \
+  ((UDF_FILE_IDENTIFIER_DESCRIPTOR *)((UINT8 *)(_Data) + (_Offs)))
+
+#define IS_VALID_COMPRESSION_ID(_CompId) \
+  ((BOOLEAN)((_CompId) == 8 || (_CompId) == 16))
+
+#define LV_BLOCK_SIZE(_Vol, _LvNum) \
+  (_Vol)->LogicalVolDescs[(_LvNum)]->LogicalBlockSize
+
+#define UDF_STANDARD_IDENTIFIER_LENGTH   5
+
+#pragma pack(1)
+
+typedef struct {
+  UINT8 StandardIdentifier[UDF_STANDARD_IDENTIFIER_LENGTH];
+} UDF_STANDARD_IDENTIFIER;
+
+#pragma pack()
+
+enum {
+  BEA_IDENTIFIER,
+  VSD_IDENTIFIER,
+  TEA_IDENTIFIER,
+  NR_STANDARD_IDENTIFIERS,
+};
+
+typedef enum {
+  READ_FILE_GET_FILESIZE,
+  READ_FILE_ALLOCATE_AND_READ,
+  READ_FILE_SEEK_AND_READ,
+} UDF_READ_FILE_FLAGS;
+
+typedef struct {
+  VOID                 *FileData;
+  UDF_READ_FILE_FLAGS  Flags;
+  UINT64               FileDataSize;
+  UINT64               FilePosition;
+  UINT64               FileSize;
+  UINT64               ReadLength;
+} UDF_READ_FILE_INFO;
+
+#pragma pack(1)
+
+typedef struct {
+  UINT16               TagIdentifier;
+  UINT16               DescriptorVersion;
+  UINT8                TagChecksum;
+  UINT8                Reserved;
+  UINT16               TagSerialNumber;
+  UINT16               DescriptorCRC;
+  UINT16               DescriptorCRCLength;
+  UINT32               TagLocation;
+} UDF_DESCRIPTOR_TAG;
+
+typedef struct {
+  UINT8           CharacterSetType;
+  UINT8           CharacterSetInfo[63];
+} UDF_CHAR_SPEC;
+
+typedef struct {
+  UINT8           Flags;
+  UINT8           Identifier[23];
+  UINT8           IdentifierSuffix[8];
+} UDF_ENTITY_ID;
+
+typedef struct {
+  UINT16          TypeAndTimezone;
+  INT16           Year;
+  UINT8           Month;
+  UINT8           Day;
+  UINT8           Hour;
+  UINT8           Minute;
+  UINT8           Second;
+  UINT8           Centiseconds;
+  UINT8           HundredsOfMicroseconds;
+  UINT8           Microseconds;
+} UDF_TIMESTAMP;
+
+typedef struct {
+  UINT32          ExtentLength;
+  UINT32          ExtentLocation;
+} UDF_EXTENT_AD;
+
+typedef struct {
+  UINT32        LogicalBlockNumber;
+  UINT16        PartitionReferenceNumber;
+} UDF_LB_ADDR;
+
+typedef struct {
+  UINT32                           ExtentLength;
+  UDF_LB_ADDR                      ExtentLocation;
+  UINT8                            ImplementationUse[6];
+} UDF_LONG_ALLOCATION_DESCRIPTOR;
+
+typedef struct {
+  UDF_DESCRIPTOR_TAG                 DescriptorTag;
+  UINT32                             PrevAllocationExtentDescriptor;
+  UINT32                             LengthOfAllocationDescriptors;
+} UDF_ALLOCATION_EXTENT_DESCRIPTOR;
+
+typedef struct {
+  UINT8                   StructureType;
+  UINT8                   StandardIdentifier[UDF_STANDARD_IDENTIFIER_LENGTH];
+  UINT8                   StructureVersion;
+  UINT8                   Reserved;
+  UINT8                   StructureData[2040];
+} UDF_VOLUME_DESCRIPTOR;
+
+typedef struct {
+  UDF_DESCRIPTOR_TAG                     DescriptorTag;
+  UDF_EXTENT_AD                          MainVolumeDescriptorSequenceExtent;
+  UDF_EXTENT_AD                          ReserveVolumeDescriptorSequenceExtent;
+  UINT8                                  Reserved[480];
+} UDF_ANCHOR_VOLUME_DESCRIPTOR_POINTER;
+
+typedef struct {
+  UDF_DESCRIPTOR_TAG         DescriptorTag;
+  UINT32                     VolumeDescriptorSequenceNumber;
+  UINT16                     PartitionFlags;
+  UINT16                     PartitionNumber;
+  UDF_ENTITY_ID              PartitionContents;
+  UINT8                      PartitionContentsUse[128];
+  UINT32                     AccessType;
+  UINT32                     PartitionStartingLocation;
+  UINT32                     PartitionLength;
+  UDF_ENTITY_ID              ImplementationIdentifier;
+  UINT8                      ImplementationUse[128];
+  UINT8                      Reserved[156];
+} UDF_PARTITION_DESCRIPTOR;
+
+typedef struct {
+  UDF_DESCRIPTOR_TAG              DescriptorTag;
+  UINT32                          VolumeDescriptorSequenceNumber;
+  UDF_CHAR_SPEC                   DescriptorCharacterSet;
+  UINT8                           LogicalVolumeIdentifier[128];
+  UINT32                          LogicalBlockSize;
+  UDF_ENTITY_ID                   DomainIdentifier;
+  UDF_LONG_ALLOCATION_DESCRIPTOR  LogicalVolumeContentsUse;
+  UINT32                          MapTableLength;
+  UINT32                          NumberOfPartitionMaps;
+  UDF_ENTITY_ID                   ImplementationIdentifier;
+  UINT8                           ImplementationUse[128];
+  UDF_EXTENT_AD                   IntegritySequenceExtent;
+  UINT8                           PartitionMaps[6];
+} UDF_LOGICAL_VOLUME_DESCRIPTOR;
+
+typedef struct {
+  UDF_DESCRIPTOR_TAG             DescriptorTag;
+  UDF_TIMESTAMP                  RecordingDateTime;
+  UINT32                         IntegrityType;
+  UDF_EXTENT_AD                  NextIntegrityExtent;
+  UINT8                          LogicalVolumeContentsUse[32];
+  UINT32                         NumberOfPartitions;
+  UINT32                         LengthOfImplementationUse;
+  UINT8                          Data[0];
+} UDF_LOGICAL_VOLUME_INTEGRITY;
+
+typedef struct {
+  UDF_DESCRIPTOR_TAG              DescriptorTag;
+  UDF_TIMESTAMP                   RecordingDateAndTime;
+  UINT16                          InterchangeLevel;
+  UINT16                          MaximumInterchangeLevel;
+  UINT32                          CharacterSetList;
+  UINT32                          MaximumCharacterSetList;
+  UINT32                          FileSetNumber;
+  UINT32                          FileSetDescriptorNumber;
+  UDF_CHAR_SPEC                   LogicalVolumeIdentifierCharacterSet;
+  UINT8                           LogicalVolumeIdentifier[128];
+  UDF_CHAR_SPEC                   FileSetCharacterSet;
+  UINT8                           FileSetIdentifier[32];
+  UINT8                           CopyrightFileIdentifier[32];
+  UINT8                           AbstractFileIdentifier[32];
+  UDF_LONG_ALLOCATION_DESCRIPTOR  RootDirectoryIcb;
+  UDF_ENTITY_ID                   DomainIdentifier;
+  UDF_LONG_ALLOCATION_DESCRIPTOR  NextExtent;
+  UDF_LONG_ALLOCATION_DESCRIPTOR  SystemStreamDirectoryIcb;
+  UINT8                           Reserved[32];
+} UDF_FILE_SET_DESCRIPTOR;
+
+typedef struct {
+  UINT32                            ExtentLength;
+  UINT32                            ExtentPosition;
+} UDF_SHORT_ALLOCATION_DESCRIPTOR;
+
+typedef struct {
+  UDF_DESCRIPTOR_TAG               DescriptorTag;
+  UINT16                           FileVersionNumber;
+  UINT8                            FileCharacteristics;
+  UINT8                            LengthOfFileIdentifier;
+  UDF_LONG_ALLOCATION_DESCRIPTOR   Icb;
+  UINT16                           LengthOfImplementationUse;
+  UINT8                            Data[0];
+} UDF_FILE_IDENTIFIER_DESCRIPTOR;
+
+typedef struct {
+  UINT32        PriorRecordNumberOfDirectEntries;
+  UINT16        StrategyType;
+  UINT16        StrategyParameter;
+  UINT16        MaximumNumberOfEntries;
+  UINT8         Reserved;
+  UINT8         FileType;
+  UDF_LB_ADDR   ParentIcbLocation;
+  UINT16        Flags;
+} UDF_ICB_TAG;
+
+typedef struct {
+  UDF_DESCRIPTOR_TAG              DescriptorTag;
+  UDF_ICB_TAG                     IcbTag;
+  UINT32                          Uid;
+  UINT32                          Gid;
+  UINT32                          Permissions;
+  UINT16                          FileLinkCount;
+  UINT8                           RecordFormat;
+  UINT8                           RecordDisplayAttributes;
+  UINT32                          RecordLength;
+  UINT64                          InformationLength;
+  UINT64                          LogicalBlocksRecorded;
+  UDF_TIMESTAMP                   AccessTime;
+  UDF_TIMESTAMP                   ModificationTime;
+  UDF_TIMESTAMP                   AttributeTime;
+  UINT32                          CheckPoint;
+  UDF_LONG_ALLOCATION_DESCRIPTOR  ExtendedAttributeIcb;
+  UDF_ENTITY_ID                   ImplementationIdentifier;
+  UINT64                          UniqueId;
+  UINT32                          LengthOfExtendedAttributes;
+  UINT32                          LengthOfAllocationDescriptors;
+  UINT8                           Data[0]; // L_EA + L_AD
+} UDF_FILE_ENTRY;
+
+typedef struct {
+  UDF_DESCRIPTOR_TAG              DescriptorTag;
+  UDF_ICB_TAG                     IcbTag;
+  UINT32                          Uid;
+  UINT32                          Gid;
+  UINT32                          Permissions;
+  UINT16                          FileLinkCount;
+  UINT8                           RecordFormat;
+  UINT8                           RecordDisplayAttributes;
+  UINT32                          RecordLength;
+  UINT64                          InformationLength;
+  UINT64                          ObjectSize;
+  UINT64                          LogicalBlocksRecorded;
+  UDF_TIMESTAMP                   AccessTime;
+  UDF_TIMESTAMP                   ModificationTime;
+  UDF_TIMESTAMP                   CreationTime;
+  UDF_TIMESTAMP                   AttributeTime;
+  UINT32                          CheckPoint;
+  UINT32                          Reserved;
+  UDF_LONG_ALLOCATION_DESCRIPTOR  ExtendedAttributeIcb;
+  UDF_LONG_ALLOCATION_DESCRIPTOR  StreamDirectoryIcb;
+  UDF_ENTITY_ID                   ImplementationIdentifier;
+  UINT64                          UniqueId;
+  UINT32                          LengthOfExtendedAttributes;
+  UINT32                          LengthOfAllocationDescriptors;
+  UINT8                           Data[0]; // L_EA + L_AD
+} UDF_EXTENDED_FILE_ENTRY;
+
+typedef struct {
+  UINT8                ComponentType;
+  UINT8                LengthOfComponentIdentifier;
+  UINT16               ComponentFileVersionNumber;
+  UINT8                ComponentIdentifier[0];
+} UDF_PATH_COMPONENT;
+
+#pragma pack()
+
+//
+// UDF filesystem driver's private data
+//
+typedef struct {
+  UDF_LOGICAL_VOLUME_DESCRIPTOR  **LogicalVolDescs;
+  UINTN                          LogicalVolDescsNo;
+  UDF_PARTITION_DESCRIPTOR       **PartitionDescs;
+  UINTN                          PartitionDescsNo;
+  UDF_FILE_SET_DESCRIPTOR        **FileSetDescs;
+  UINTN                          FileSetDescsNo;
+  UINTN                          FileEntrySize;
+} UDF_VOLUME_INFO;
+
+typedef struct {
+  VOID                            *FileEntry;
+  UDF_FILE_IDENTIFIER_DESCRIPTOR  *FileIdentifierDesc;
+} UDF_FILE_INFO;
+
+typedef struct {
+  VOID                      *DirectoryData;
+  UINT64                    DirectoryLength;
+  UINT64                    FidOffset;
+} UDF_READ_DIRECTORY_INFO;
+
+#define PRIVATE_UDF_FILE_DATA_SIGNATURE SIGNATURE_32 ('U', 'd', 'f', 'f')
+
+#define PRIVATE_UDF_FILE_DATA_FROM_THIS(a) \
+  CR ( \
+      a, \
+      PRIVATE_UDF_FILE_DATA, \
+      FileIo, \
+      PRIVATE_UDF_FILE_DATA_SIGNATURE \
+      )
+
+typedef struct {
+  UINTN                            Signature;
+  BOOLEAN                          IsRootDirectory;
+  UDF_FILE_INFO                    *Root;
+  UDF_FILE_INFO                    File;
+  UDF_READ_DIRECTORY_INFO          ReadDirInfo;
+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *SimpleFs;
+  EFI_FILE_PROTOCOL                FileIo;
+  CHAR16                           AbsoluteFileName[UDF_PATH_LENGTH];
+  CHAR16                           FileName[UDF_FILENAME_LENGTH];
+  UINT64                           FileSize;
+  UINT64                           FilePosition;
+} PRIVATE_UDF_FILE_DATA;
+
+#define PRIVATE_UDF_SIMPLE_FS_DATA_SIGNATURE SIGNATURE_32 ('U', 'd', 'f', 's')
+
+#define PRIVATE_UDF_SIMPLE_FS_DATA_FROM_THIS(a) \
+  CR ( \
+      a, \
+      PRIVATE_UDF_SIMPLE_FS_DATA, \
+      SimpleFs, \
+      PRIVATE_UDF_SIMPLE_FS_DATA_SIGNATURE \
+      )
+
+typedef struct {
+  UINTN                            Signature;
+  EFI_BLOCK_IO_PROTOCOL            *BlockIo;
+  EFI_DISK_IO_PROTOCOL             *DiskIo;
+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  SimpleFs;
+  EFI_DEVICE_PATH_PROTOCOL         *DevicePath;
+  UDF_VOLUME_INFO                  Volume;
+  UDF_FILE_INFO                    Root;
+  UINTN                            OpenFiles;
+  EFI_HANDLE                       Handle;
+} PRIVATE_UDF_SIMPLE_FS_DATA;
+
+//
+// Global Variables
+//
+extern EFI_DRIVER_BINDING_PROTOCOL   gUdfDriverBinding;
+extern EFI_COMPONENT_NAME_PROTOCOL   gUdfComponentName;
+extern EFI_COMPONENT_NAME2_PROTOCOL  gUdfComponentName2;
+
+//
+// Function Prototypes
+//
+
+/**
+  Open the root directory on a volume.
+
+  @param  This Protocol instance pointer.
+  @param  Root Returns an Open file handle for the root directory
+
+  @retval EFI_SUCCESS          The device was opened.
+  @retval EFI_UNSUPPORTED      This volume does not support the file system.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_ACCESS_DENIED    The service denied access to the file.
+  @retval EFI_OUT_OF_RESOURCES The volume was not opened due to lack of resources.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfOpenVolume (
+  IN   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *This,
+  OUT  EFI_FILE_PROTOCOL                **Root
+  );
+
+/**
+  Opens a new file relative to the source file's location.
+
+  @param  This       The protocol instance pointer.
+  @param  NewHandle  Returns File Handle for FileName.
+  @param  FileName   Null terminated string. "\", ".", and ".." are supported.
+  @param  OpenMode   Open mode for file.
+  @param  Attributes Only used for EFI_FILE_MODE_CREATE.
+
+  @retval EFI_SUCCESS          The device was opened.
+  @retval EFI_NOT_FOUND        The specified file could not be found on the device.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_MEDIA_CHANGED    The media has changed.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_ACCESS_DENIED    The service denied access to the file.
+  @retval EFI_OUT_OF_RESOURCES The volume was not opened due to lack of resources.
+  @retval EFI_VOLUME_FULL      The volume is full.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfOpen (
+  IN   EFI_FILE_PROTOCOL  *This,
+  OUT  EFI_FILE_PROTOCOL  **NewHandle,
+  IN   CHAR16             *FileName,
+  IN   UINT64             OpenMode,
+  IN   UINT64             Attributes
+  );
+
+/**
+  Read data from the file.
+
+  @param  This       Protocol instance pointer.
+  @param  BufferSize On input size of buffer, on output amount of data in buffer.
+  @param  Buffer     The buffer in which data is read.
+
+  @retval EFI_SUCCESS          Data was read.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_BUFFER_TO_SMALL  BufferSize is too small. BufferSize contains required size.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfRead (
+  IN      EFI_FILE_PROTOCOL  *This,
+  IN OUT  UINTN              *BufferSize,
+  OUT     VOID               *Buffer
+  );
+
+/**
+  Close the file handle.
+
+  @param  This Protocol instance pointer.
+
+  @retval EFI_SUCCESS The file was closed.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfClose (
+  IN EFI_FILE_PROTOCOL *This
+  );
+
+/**
+  Close and delete the file handle.
+
+  @param  This Protocol instance pointer.
+
+  @retval EFI_SUCCESS              The file was closed and deleted.
+  @retval EFI_WARN_DELETE_FAILURE  The handle was closed but the file was not
+                                   deleted.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfDelete (
+  IN EFI_FILE_PROTOCOL  *This
+  );
+
+/**
+  Write data to a file.
+
+  @param  This       Protocol instance pointer.
+  @param  BufferSize On input size of buffer, on output amount of data in buffer.
+  @param  Buffer     The buffer in which data to write.
+
+  @retval EFI_SUCCESS          Data was written.
+  @retval EFI_UNSUPPORTED      Writes to Open directory are not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_DEVICE_ERROR     An attempt was made to write to a deleted file.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The device is write protected.
+  @retval EFI_ACCESS_DENIED    The file was open for read only.
+  @retval EFI_VOLUME_FULL      The volume is full.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfWrite (
+  IN      EFI_FILE_PROTOCOL  *This,
+  IN OUT  UINTN              *BufferSize,
+  IN      VOID               *Buffer
+  );
+
+/**
+  Get file's current position.
+
+  @param  This      Protocol instance pointer.
+  @param  Position  Byte position from the start of the file.
+
+  @retval EFI_SUCCESS     Position was updated.
+  @retval EFI_UNSUPPORTED Seek request for directories is not valid.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfGetPosition (
+  IN   EFI_FILE_PROTOCOL  *This,
+  OUT  UINT64             *Position
+  );
+
+/**
+  Set file's current position.
+
+  @param  This      Protocol instance pointer.
+  @param  Position  Byte position from the start of the file.
+
+  @retval EFI_SUCCESS      Position was updated.
+  @retval EFI_UNSUPPORTED  Seek request for non-zero is not valid on open.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfSetPosition (
+  IN EFI_FILE_PROTOCOL  *This,
+  IN UINT64             Position
+  );
+
+/**
+  Get information about a file.
+
+  @param  This            Protocol instance pointer.
+  @param  InformationType Type of information to return in Buffer.
+  @param  BufferSize      On input size of buffer, on output amount of data in buffer.
+  @param  Buffer          The buffer to return data.
+
+  @retval EFI_SUCCESS          Data was returned.
+  @retval EFI_UNSUPPORTED      InformationType is not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The device is write protected.
+  @retval EFI_ACCESS_DENIED    The file was open for read only.
+  @retval EFI_BUFFER_TOO_SMALL Buffer was too small; required size returned in BufferSize.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfGetInfo (
+  IN      EFI_FILE_PROTOCOL  *This,
+  IN      EFI_GUID           *InformationType,
+  IN OUT  UINTN              *BufferSize,
+  OUT     VOID               *Buffer
+  );
+
+/**
+  Set information about a file.
+
+  @param  File            Protocol instance pointer.
+  @param  InformationType Type of information in Buffer.
+  @param  BufferSize      Size of buffer.
+  @param  Buffer          The data to write.
+
+  @retval EFI_SUCCESS          Data was set.
+  @retval EFI_UNSUPPORTED      InformationType is not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The device is write protected.
+  @retval EFI_ACCESS_DENIED    The file was open for read only.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfSetInfo (
+  IN EFI_FILE_PROTOCOL  *This,
+  IN EFI_GUID           *InformationType,
+  IN UINTN              BufferSize,
+  IN VOID               *Buffer
+  );
+
+/**
+  Flush data back for the file handle.
+
+  @param  This Protocol instance pointer.
+
+  @retval EFI_SUCCESS          Data was flushed.
+  @retval EFI_UNSUPPORTED      Writes to Open directory are not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED  The device is write protected.
+  @retval EFI_ACCESS_DENIED    The file was open for read only.
+  @retval EFI_VOLUME_FULL      The volume is full.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfFlush (
+  IN EFI_FILE_PROTOCOL *This
+  );
+
+/**
+  Check if medium contains an UDF file system.
+
+  @param[in]   BlockIo  BlockIo interface.
+  @param[in]   DiskIo   DiskIo interface.
+
+  @retval EFI_SUCCESS          UDF file system found.
+  @retval EFI_UNSUPPORTED      UDF file system not found.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The scan was not successful due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+SupportUdfFileSystem (
+  IN  EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN  EFI_DISK_IO_PROTOCOL   *DiskIo
+  );
+
+/**
+  Read volume information on a medium which contains a valid UDF file system.
+
+  @param[in]   BlockIo  BlockIo interface.
+  @param[in]   DiskIo   DiskIo interface.
+  @param[out]  Volume   UDF volume information structure.
+
+  @retval EFI_SUCCESS          Volume information read.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The volume was not read due to lack of resources.
+
+**/
+EFI_STATUS
+ReadUdfVolumeInformation (
+  IN   EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL   *DiskIo,
+  OUT  UDF_VOLUME_INFO        *Volume
+  );
+
+/**
+  Find the root directory on an UDF volume.
+
+  @param[in]   BlockIo  BlockIo interface.
+  @param[in]   DiskIo   DiskIo interface.
+  @param[in]   Volume   UDF volume information structure.
+  @param[out]  File     Root directory file.
+
+  @retval EFI_SUCCESS          Root directory found.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The root directory was not found due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+FindRootDirectory (
+  IN   EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL   *DiskIo,
+  IN   UDF_VOLUME_INFO        *Volume,
+  OUT  UDF_FILE_INFO          *File
+  );
+
+/**
+  Find either a File Entry or a Extended File Entry from a given ICB.
+
+  @param[in]   BlockIo    BlockIo interface.
+  @param[in]   DiskIo     DiskIo interface.
+  @param[in]   Volume     UDF volume information structure.
+  @param[in]   Icb        ICB of the FID.
+  @param[out]  FileEntry  File Entry or Extended File Entry.
+
+  @retval EFI_SUCCESS          File Entry or Extended File Entry found.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The FE/EFE entry was not found due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+FindFileEntry (
+  IN   EFI_BLOCK_IO_PROTOCOL           *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL            *DiskIo,
+  IN   UDF_VOLUME_INFO                 *Volume,
+  IN   UDF_LONG_ALLOCATION_DESCRIPTOR  *Icb,
+  OUT  VOID                            **FileEntry
+  );
+
+/**
+  Find a file given its absolute path on an UDF volume.
+
+  @param[in]   BlockIo   BlockIo interface.
+  @param[in]   DiskIo    DiskIo interface.
+  @param[in]   Volume    UDF volume information structure.
+  @param[in]   FilePath  File's absolute path.
+  @param[in]   Root      Root directory file.
+  @param[in]   Parent    Parent directory file.
+  @param[out]  File      Found file.
+
+  @retval EFI_SUCCESS          @p FilePath was found.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The @p FilePath file was not found due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+FindFile (
+  IN   EFI_BLOCK_IO_PROTOCOL           *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL            *DiskIo,
+  IN   UDF_VOLUME_INFO                 *Volume,
+  IN   CHAR16                          *FilePath,
+  IN   UDF_FILE_INFO                   *Root,
+  IN   UDF_FILE_INFO                   *Parent,
+  IN   UDF_LONG_ALLOCATION_DESCRIPTOR  *Icb,
+  OUT  UDF_FILE_INFO                   *File
+  );
+
+/**
+  Read a directory entry at a time on an UDF volume.
+
+  @param[in]      BlockIo        BlockIo interface.
+  @param[in]      DiskIo         DiskIo interface.
+  @param[in]      Volume         UDF volume information structure.
+  @param[in]      ParentIcb      ICB of the parent file.
+  @param[in]      FileEntryData  FE/EFE of the parent file.
+  @param[in out]  ReadDirInfo    Next read directory listing structure
+                                 information.
+  @param[out]     FoundFid       File Identifier Descriptor pointer.
+
+  @retval EFI_SUCCESS          Directory entry read.
+  @retval EFI_UNSUPPORTED      Extended Allocation Descriptors not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The directory entry was not read due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+ReadDirectoryEntry (
+  IN      EFI_BLOCK_IO_PROTOCOL           *BlockIo,
+  IN      EFI_DISK_IO_PROTOCOL            *DiskIo,
+  IN      UDF_VOLUME_INFO                 *Volume,
+  IN      UDF_LONG_ALLOCATION_DESCRIPTOR  *ParentIcb,
+  IN      VOID                            *FileEntryData,
+  IN OUT  UDF_READ_DIRECTORY_INFO         *ReadDirInfo,
+  OUT     UDF_FILE_IDENTIFIER_DESCRIPTOR  **FoundFid
+  );
+
+/**
+  Get a filename (encoded in OSTA-compressed format) from a File Identifier
+  Descriptor on an UDF volume.
+
+  @param[in]   FileIdentifierDesc  File Identifier Descriptor pointer.
+  @param[out]  FileName            Decoded filename.
+
+  @retval EFI_SUCCESS           Filename decoded and read.
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.
+**/
+EFI_STATUS
+GetFileNameFromFid (
+  IN   UDF_FILE_IDENTIFIER_DESCRIPTOR  *FileIdentifierDesc,
+  OUT  CHAR16                          *FileName
+  );
+
+/**
+  Resolve a symlink file on an UDF volume.
+
+  @param[in]   BlockIo        BlockIo interface.
+  @param[in]   DiskIo         DiskIo interface.
+  @param[in]   Volume         UDF volume information structure.
+  @param[in]   Parent         Parent file.
+  @param[in]   FileEntryData  FE/EFE structure pointer.
+  @param[out]  File           Resolved file.
+
+  @retval EFI_SUCCESS          Symlink file resolved.
+  @retval EFI_UNSUPPORTED      Extended Allocation Descriptors not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The symlink file was not resolved due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+ResolveSymlink (
+  IN   EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL   *DiskIo,
+  IN   UDF_VOLUME_INFO        *Volume,
+  IN   UDF_FILE_INFO          *Parent,
+  IN   VOID                   *FileEntryData,
+  OUT  UDF_FILE_INFO          *File
+  );
+
+/**
+  Clean up in-memory UDF volume information.
+
+  @param[in] Volume Volume information pointer.
+
+**/
+VOID
+CleanupVolumeInformation (
+  IN UDF_VOLUME_INFO *Volume
+  );
+
+/**
+  Clean up in-memory UDF file information.
+
+  @param[in] File File information pointer.
+
+**/
+VOID
+CleanupFileInformation (
+  IN UDF_FILE_INFO *File
+  );
+
+/**
+  Find a file from its absolute path on an UDF volume.
+
+  @param[in]   BlockIo  BlockIo interface.
+  @param[in]   DiskIo   DiskIo interface.
+  @param[in]   Volume   UDF volume information structure.
+  @param[in]   File     File information structure.
+  @param[out]  Size     Size of the file.
+
+  @retval EFI_SUCCESS          File size calculated and set in @p Size.
+  @retval EFI_UNSUPPORTED      Extended Allocation Descriptors not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The file size was not calculated due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+GetFileSize (
+  IN   EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL   *DiskIo,
+  IN   UDF_VOLUME_INFO        *Volume,
+  IN   UDF_FILE_INFO          *File,
+  OUT  UINT64                 *Size
+  );
+
+/**
+  Set information about a file on an UDF volume.
+
+  @param[in]      File        File pointer.
+  @param[in]      FileSize    Size of the file.
+  @param[in]      FileName    Filename of the file.
+  @param[in out]  BufferSize  Size of the returned file infomation.
+  @param[out]     Buffer      Data of the returned file information.
+
+  @retval EFI_SUCCESS          File information set.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The file information was not set due to lack of
+                               resources.
+
+**/
+EFI_STATUS
+SetFileInfo (
+  IN      UDF_FILE_INFO  *File,
+  IN      UINT64         FileSize,
+  IN      CHAR16         *FileName,
+  IN OUT  UINTN          *BufferSize,
+  OUT     VOID           *Buffer
+  );
+
+/**
+  Get volume and free space size information of an UDF volume.
+
+  @param[in]   BlockIo        BlockIo interface.
+  @param[in]   DiskIo         DiskIo interface.
+  @param[in]   Volume         UDF volume information structure.
+  @param[out]  VolumeSize     Volume size.
+  @param[out]  FreeSpaceSize  Free space size.
+
+  @retval EFI_SUCCESS          Volume and free space size calculated.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The volume and free space size were not
+                               calculated due to lack of resources.
+
+**/
+EFI_STATUS
+GetVolumeSize (
+  IN   EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN   EFI_DISK_IO_PROTOCOL   *DiskIo,
+  IN   UDF_VOLUME_INFO        *Volume,
+  OUT  UINT64                 *VolumeSize,
+  OUT  UINT64                 *FreeSpaceSize
+  );
+
+/**
+  Mangle a filename by cutting off trailing whitespaces, "\\", "." and "..".
+
+  @param[in] FileName Filename.
+
+  @retval @p FileName Filename mangled.
+
+**/
+CHAR16 *
+MangleFileName (
+  IN CHAR16        *FileName
+  );
+
+/**
+  Test to see if this driver supports ControllerHandle. Any ControllerHandle
+  than contains a BlockIo and DiskIo protocol can be supported.
+
+  @param  This                Protocol instance pointer.
+  @param  ControllerHandle    Handle of device to test
+  @param  RemainingDevicePath Optional parameter use to pick a specific child
+                              device to start.
+
+  @retval EFI_SUCCESS         This driver supports this device
+  @retval EFI_ALREADY_STARTED This driver is already running on this device
+  @retval other               This driver does not support this device
+
+**/
+EFI_STATUS
+EFIAPI
+UdfDriverBindingSupported (
+  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN EFI_HANDLE                   ControllerHandle,
+  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
+  );
+
+/**
+  Start this driver on ControllerHandle by opening a Block IO and Disk IO
+  protocol, reading Device Path, and creating a child handle with a
+  Disk IO and device path protocol.
+
+  @param  This                 Protocol instance pointer.
+  @param  ControllerHandle     Handle of device to bind driver to
+  @param  RemainingDevicePath  Optional parameter use to pick a specific child
+                               device to start.
+
+  @retval EFI_SUCCESS          This driver is added to ControllerHandle
+  @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle
+  @retval other                This driver does not support this device
+
+**/
+EFI_STATUS
+EFIAPI
+UdfDriverBindingStart (
+  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN EFI_HANDLE                   ControllerHandle,
+  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
+  );
+
+/**
+  Stop this driver on ControllerHandle. Support stopping any child handles
+  created by this driver.
+
+  @param  This              Protocol instance pointer.
+  @param  ControllerHandle  Handle of device to stop driver on
+  @param  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
+                            children is zero stop the entire bus driver.
+  @param  ChildHandleBuffer List of Child Handles to Stop.
+
+  @retval EFI_SUCCESS       This driver is removed ControllerHandle
+  @retval other             This driver was not removed from this device
+
+**/
+EFI_STATUS
+EFIAPI
+UdfDriverBindingStop (
+  IN  EFI_DRIVER_BINDING_PROTOCOL   *This,
+  IN  EFI_HANDLE                    ControllerHandle,
+  IN  UINTN                         NumberOfChildren,
+  IN  EFI_HANDLE                    *ChildHandleBuffer
+  );
+
+//
+// EFI Component Name Functions
+//
+/**
+  Retrieves a Unicode string that is the user readable name of the driver.
+
+  This function retrieves the user readable name of a driver in the form of a
+  Unicode string. If the driver specified by This has a user readable name in
+  the language specified by Language, then a pointer to the driver name is
+  returned in DriverName, and EFI_SUCCESS is returned. If the driver specified
+  by This does not support the language specified by Language,
+  then EFI_UNSUPPORTED is returned.
+
+  @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
+                                EFI_COMPONENT_NAME_PROTOCOL instance.
+
+  @param  Language[in]          A pointer to a Null-terminated ASCII string
+                                array indicating the language. This is the
+                                language of the driver name that the caller is
+                                requesting, and it must match one of the
+                                languages specified in SupportedLanguages. The
+                                number of languages supported by a driver is up
+                                to the driver writer. Language is specified
+                                in RFC 4646 or ISO 639-2 language code format.
+
+  @param  DriverName[out]       A pointer to the Unicode string to return.
+                                This Unicode string is the name of the
+                                driver specified by This in the language
+                                specified by Language.
+
+  @retval EFI_SUCCESS           The Unicode string for the Driver specified by
+                                This and the language specified by Language was
+                                returned in DriverName.
+
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+
+  @retval EFI_INVALID_PARAMETER DriverName is NULL.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support
+                                the language specified by Language.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfComponentNameGetDriverName (
+  IN  EFI_COMPONENT_NAME_PROTOCOL  *This,
+  IN  CHAR8                        *Language,
+  OUT CHAR16                       **DriverName
+  );
+
+/**
+  Retrieves a Unicode string that is the user readable name of the controller
+  that is being managed by a driver.
+
+  This function retrieves the user readable name of the controller specified by
+  ControllerHandle and ChildHandle in the form of a Unicode string. If the
+  driver specified by This has a user readable name in the language specified by
+  Language, then a pointer to the controller name is returned in ControllerName,
+  and EFI_SUCCESS is returned.  If the driver specified by This is not currently
+  managing the controller specified by ControllerHandle and ChildHandle,
+  then EFI_UNSUPPORTED is returned.  If the driver specified by This does not
+  support the language specified by Language, then EFI_UNSUPPORTED is returned.
+
+  @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
+                                EFI_COMPONENT_NAME_PROTOCOL instance.
+
+  @param  ControllerHandle[in]  The handle of a controller that the driver
+                                specified by This is managing.  This handle
+                                specifies the controller whose name is to be
+                                returned.
+
+  @param  ChildHandle[in]       The handle of the child controller to retrieve
+                                the name of.  This is an optional parameter that
+                                may be NULL.  It will be NULL for device
+                                drivers.  It will also be NULL for a bus drivers
+                                that wish to retrieve the name of the bus
+                                controller.  It will not be NULL for a bus
+                                driver that wishes to retrieve the name of a
+                                child controller.
+
+  @param  Language[in]          A pointer to a Null-terminated ASCII string
+                                array indicating the language.  This is the
+                                language of the driver name that the caller is
+                                requesting, and it must match one of the
+                                languages specified in SupportedLanguages. The
+                                number of languages supported by a driver is up
+                                to the driver writer. Language is specified in
+                                RFC 4646 or ISO 639-2 language code format.
+
+  @param  ControllerName[out]   A pointer to the Unicode string to return.
+                                This Unicode string is the name of the
+                                controller specified by ControllerHandle and
+                                ChildHandle in the language specified by
+                                Language from the point of view of the driver
+                                specified by This.
+
+  @retval EFI_SUCCESS           The Unicode string for the user readable name in
+                                the language specified by Language for the
+                                driver specified by This was returned in
+                                DriverName.
+
+  @retval EFI_INVALID_PARAMETER ControllerHandle is not a valid EFI_HANDLE.
+
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
+                                EFI_HANDLE.
+
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+
+  @retval EFI_INVALID_PARAMETER ControllerName is NULL.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This is not currently
+                                managing the controller specified by
+                                ControllerHandle and ChildHandle.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support
+                                the language specified by Language.
+
+**/
+EFI_STATUS
+EFIAPI
+UdfComponentNameGetControllerName (
+  IN   EFI_COMPONENT_NAME_PROTOCOL  *This,
+  IN   EFI_HANDLE                   ControllerHandle,
+  IN   EFI_HANDLE                   ChildHandle OPTIONAL,
+  IN   CHAR8                        *Language,
+  OUT  CHAR16                       **ControllerName
+  );
+
+#endif // _UDF_H_
diff --git a/MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf b/MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
new file mode 100644
index 0000000000..5be2959bdc
--- /dev/null
+++ b/MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
@@ -0,0 +1,66 @@
+## @file
+#  UDF/ECMA-167 file system driver.
+#
+#  Copyright (C) 2014-2017 Paulo Alcantara <pcacjr@zytor.com>
+#
+#  This program and the accompanying materials
+#  are licensed and made available under the terms and conditions of the BSD License
+#  which accompanies this distribution.  The full text of the license may be found at
+#  http://opensource.org/licenses/bsd-license.php
+#
+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+##
+
+[Defines]
+  INF_VERSION                    = 0x00010005
+  BASE_NAME                      = UdfDxe
+  FILE_GUID                      = 905f13b0-8f91-4b0a-bd76-e1e78f9422e4
+  MODULE_TYPE                    = UEFI_DRIVER
+  VERSION_STRING                 = 1.0
+  ENTRY_POINT                    = InitializeUdf
+
+#
+# The following information is for reference only and not required by the build tools.
+#
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC
+#
+#  DRIVER_BINDING                = gUdfDriverBinding
+#  COMPONENT_NAME                = gUdfComponentName
+#  COMPONENT_NAME2               = gUdfComponentName2
+#
+
+[Sources]
+  ComponentName.c
+  FileSystemOperations.c
+  FileName.c
+  File.c
+  Udf.c
+  Udf.h
+
+
+[Packages]
+  MdePkg/MdePkg.dec
+
+
+[LibraryClasses]
+  DevicePathLib
+  UefiBootServicesTableLib
+  MemoryAllocationLib
+  BaseMemoryLib
+  UefiLib
+  BaseLib
+  UefiDriverEntryPoint
+  DebugLib
+
+
+[Guids]
+  gEfiFileInfoGuid                              ## SOMETIMES_CONSUMES ## Protocol
+  gEfiFileSystemInfoGuid                        ## SOMETIMES_CONSUMES ## Protocol
+
+
+[Protocols]
+  gEfiSimpleFileSystemProtocolGuid              ## BY_START
+  gEfiDevicePathProtocolGuid                    ## BY_START
+  gEfiBlockIoProtocolGuid                       ## TO_START
+  gEfiDiskIoProtocolGuid                        ## TO_START
-- 
2.11.0



^ permalink raw reply related	[flat|nested] 17+ messages in thread

* [PATCH 3/4] MdeModulePkg/UdfDxe: Add seek, read and listing support on files
  2017-08-08 19:31 [PATCH 0/4] read-only UDF file system support Paulo Alcantara
  2017-08-08 19:31 ` [PATCH 1/4] MdeModulePkg/PartitionDxe: Add UDF/ECMA-167 " Paulo Alcantara
  2017-08-08 19:31 ` [PATCH 2/4] MdeModulePkg: Initial " Paulo Alcantara
@ 2017-08-08 19:31 ` Paulo Alcantara
  2017-08-08 19:31 ` [PATCH 4/4] OvmfPkg: Introduce UDF_ENABLE build flag Paulo Alcantara
  2017-08-09  1:17 ` [PATCH 0/4] read-only UDF file system support Zeng, Star
  4 siblings, 0 replies; 17+ messages in thread
From: Paulo Alcantara @ 2017-08-08 19:31 UTC (permalink / raw)
  To: edk2-devel; +Cc: Paulo Alcantara, Star Zeng, Eric Dong, Laszlo Ersek

This patch implements UdfRead(), UdfGetPosition() and UdfSetPosition()
functions.

Cc: Star Zeng <star.zeng@intel.com>
Cc: Eric Dong <eric.dong@intel.com>
Cc: Laszlo Ersek <lersek@redhat.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Paulo Alcantara <pcacjr@zytor.com>
---
 MdeModulePkg/Universal/Disk/UdfDxe/File.c          | 264 ++++++++++++++++++++-
 .../Universal/Disk/UdfDxe/FileSystemOperations.c   | 102 ++++++--
 MdeModulePkg/Universal/Disk/UdfDxe/Udf.h           |  33 +++
 3 files changed, 371 insertions(+), 28 deletions(-)

diff --git a/MdeModulePkg/Universal/Disk/UdfDxe/File.c b/MdeModulePkg/Universal/Disk/UdfDxe/File.c
index dcb9ff2cf5..3b93beb3f8 100644
--- a/MdeModulePkg/Universal/Disk/UdfDxe/File.c
+++ b/MdeModulePkg/Universal/Disk/UdfDxe/File.c
@@ -198,7 +198,7 @@ UdfOpen (
   //
   // Build full path
   //
-  if (FileName[0] == L'\\') {
+  if (*FileName == L'\\') {
     StrCpyS (FilePath, UDF_PATH_LENGTH, FileName);
   } else {
     StrCpyS (FilePath, UDF_PATH_LENGTH, PrivFileData->AbsoluteFileName);
@@ -247,6 +247,7 @@ UdfOpen (
   }
 
   StrCpyS (NewPrivFileData->FileName, UDF_PATH_LENGTH, FileName);
+
   Status = GetFileSize (
     PrivFsData->BlockIo,
     PrivFsData->DiskIo,
@@ -308,7 +309,197 @@ UdfRead (
   OUT     VOID               *Buffer
   )
 {
-  return EFI_VOLUME_CORRUPTED;
+  EFI_TPL                         OldTpl;
+  EFI_STATUS                      Status;
+  PRIVATE_UDF_FILE_DATA           *PrivFileData;
+  PRIVATE_UDF_SIMPLE_FS_DATA      *PrivFsData;
+  UDF_VOLUME_INFO                 *Volume;
+  UDF_FILE_INFO                   *Parent;
+  UDF_READ_DIRECTORY_INFO         *ReadDirInfo;
+  EFI_BLOCK_IO_PROTOCOL           *BlockIo;
+  EFI_DISK_IO_PROTOCOL            *DiskIo;
+  UDF_FILE_INFO                   FoundFile;
+  UDF_FILE_IDENTIFIER_DESCRIPTOR  *NewFileIdentifierDesc;
+  VOID                            *NewFileEntryData;
+  CHAR16                          FileName[UDF_FILENAME_LENGTH] = { 0 };
+  UINT64                          FileSize;
+
+  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
+
+  if (This == NULL || BufferSize == NULL || (*BufferSize != 0 &&
+                                             Buffer == NULL)) {
+    Status = EFI_INVALID_PARAMETER;
+    goto Error_Invalid_Params;
+  }
+
+  PrivFileData = PRIVATE_UDF_FILE_DATA_FROM_THIS (This);
+
+  PrivFsData = PRIVATE_UDF_SIMPLE_FS_DATA_FROM_THIS (PrivFileData->SimpleFs);
+
+  BlockIo                = PrivFsData->BlockIo;
+  DiskIo                 = PrivFsData->DiskIo;
+  Volume                 = &PrivFsData->Volume;
+  ReadDirInfo            = &PrivFileData->ReadDirInfo;
+  NewFileIdentifierDesc  = NULL;
+  NewFileEntryData       = NULL;
+
+  Parent = _PARENT_FILE (PrivFileData);
+
+  Status = EFI_VOLUME_CORRUPTED;
+
+  if (IS_FID_NORMAL_FILE (Parent->FileIdentifierDesc)) {
+    if (PrivFileData->FilePosition > PrivFileData->FileSize) {
+      //
+      // File's position is beyond the EOF
+      //
+      Status = EFI_DEVICE_ERROR;
+      goto Error_File_Beyond_The_Eof;
+    }
+
+    if (PrivFileData->FilePosition == PrivFileData->FileSize) {
+      *BufferSize = 0;
+      Status = EFI_SUCCESS;
+      goto Done;
+    }
+
+    Status = ReadFileData (
+                       BlockIo,
+                       DiskIo,
+                       Volume,
+                       Parent,
+                       PrivFileData->FileSize,
+                       &PrivFileData->FilePosition,
+                       Buffer,
+                       BufferSize
+                       );
+  } else if (IS_FID_DIRECTORY_FILE (Parent->FileIdentifierDesc)) {
+    if (ReadDirInfo->FidOffset == 0 && PrivFileData->FilePosition > 0) {
+      Status = EFI_DEVICE_ERROR;
+      *BufferSize = 0;
+      goto Done;
+    }
+
+    for (;;) {
+      Status = ReadDirectoryEntry (
+			       BlockIo,
+			       DiskIo,
+			       Volume,
+			       &Parent->FileIdentifierDesc->Icb,
+			       Parent->FileEntry,
+			       ReadDirInfo,
+			       &NewFileIdentifierDesc
+			       );
+      if (EFI_ERROR (Status)) {
+        if (Status == EFI_DEVICE_ERROR) {
+          FreePool (ReadDirInfo->DirectoryData);
+          ZeroMem ((VOID *)ReadDirInfo, sizeof (UDF_READ_DIRECTORY_INFO));
+
+          *BufferSize = 0;
+          Status = EFI_SUCCESS;
+        }
+
+        goto Done;
+      }
+
+      if (!IS_FID_PARENT_FILE (NewFileIdentifierDesc)) {
+        break;
+      }
+
+      FreePool ((VOID *)NewFileIdentifierDesc);
+    }
+
+    Status = FindFileEntry (
+                        BlockIo,
+                        DiskIo,
+                        Volume,
+                        &NewFileIdentifierDesc->Icb,
+                        &NewFileEntryData
+                        );
+    if (EFI_ERROR (Status)) {
+      goto Error_Find_Fe;
+    }
+
+    if (IS_FE_SYMLINK (NewFileEntryData)) {
+      Status = ResolveSymlink (
+                           BlockIo,
+                           DiskIo,
+                           Volume,
+                           Parent,
+                           NewFileEntryData,
+                           &FoundFile
+                           );
+      if (EFI_ERROR (Status)) {
+        goto Error_Resolve_Symlink;
+      }
+
+      FreePool ((VOID *)NewFileEntryData);
+      NewFileEntryData = FoundFile.FileEntry;
+
+      Status = GetFileNameFromFid (NewFileIdentifierDesc, FileName);
+      if (EFI_ERROR (Status)) {
+        FreePool ((VOID *)FoundFile.FileIdentifierDesc);
+        goto Error_Get_FileName;
+      }
+
+      FreePool ((VOID *)NewFileIdentifierDesc);
+      NewFileIdentifierDesc = FoundFile.FileIdentifierDesc;
+    } else {
+      FoundFile.FileIdentifierDesc  = NewFileIdentifierDesc;
+      FoundFile.FileEntry           = NewFileEntryData;
+
+      Status = GetFileNameFromFid (FoundFile.FileIdentifierDesc, FileName);
+      if (EFI_ERROR (Status)) {
+        goto Error_Get_FileName;
+      }
+    }
+
+    Status = GetFileSize (
+                      BlockIo,
+                      DiskIo,
+                      Volume,
+                      &FoundFile,
+                      &FileSize
+                      );
+    if (EFI_ERROR (Status)) {
+      goto Error_Get_File_Size;
+    }
+
+    Status = SetFileInfo (
+                    &FoundFile,
+                    FileSize,
+                    FileName,
+                    BufferSize,
+                    Buffer
+                    );
+    if (EFI_ERROR (Status)) {
+      goto Error_Set_File_Info;
+    }
+
+    PrivFileData->FilePosition++;
+    Status = EFI_SUCCESS;
+  } else if (IS_FID_DELETED_FILE (Parent->FileIdentifierDesc)) {
+    Status = EFI_DEVICE_ERROR;
+  }
+
+Error_Set_File_Info:
+Error_Get_File_Size:
+Error_Get_FileName:
+Error_Resolve_Symlink:
+  if (NewFileEntryData != NULL) {
+    FreePool (NewFileEntryData);
+  }
+
+Error_Find_Fe:
+  if (NewFileIdentifierDesc != NULL) {
+    FreePool ((VOID *)NewFileIdentifierDesc);
+  }
+
+Done:
+Error_File_Beyond_The_Eof:
+Error_Invalid_Params:
+  gBS->RestoreTPL (OldTpl);
+
+  return Status;
 }
 
 /**
@@ -346,7 +537,7 @@ UdfClose (
   if (!PrivFileData->IsRootDirectory) {
     CleanupFileInformation (&PrivFileData->File);
 
-    if (PrivFileData->ReadDirInfo.DirectoryData) {
+    if (PrivFileData->ReadDirInfo.DirectoryData != NULL) {
       FreePool (PrivFileData->ReadDirInfo.DirectoryData);
     }
   }
@@ -439,7 +630,28 @@ UdfGetPosition (
   OUT  UINT64             *Position
   )
 {
-  return EFI_UNSUPPORTED;
+  PRIVATE_UDF_FILE_DATA *PrivFileData;
+
+  if (This == NULL || Position == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  PrivFileData = PRIVATE_UDF_FILE_DATA_FROM_THIS (This);
+
+  //
+  // As per UEFI spec, if the file handle is a directory, then the current file
+  // position has no meaning and the operation is not supported.
+  //
+  if (IS_FID_DIRECTORY_FILE (&PrivFileData->File.FileIdentifierDesc)) {
+    return  EFI_UNSUPPORTED;
+  }
+
+  //
+  // The file is not a directory. So, return its position.
+  //
+  *Position = PrivFileData->FilePosition;
+
+  return EFI_SUCCESS;
 }
 
 /**
@@ -459,7 +671,45 @@ UdfSetPosition (
   IN UINT64             Position
   )
 {
-  return EFI_UNSUPPORTED;
+  EFI_STATUS                      Status;
+  PRIVATE_UDF_FILE_DATA           *PrivFileData;
+  UDF_FILE_IDENTIFIER_DESCRIPTOR  *FileIdentifierDesc;
+
+  if (This == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  Status = EFI_UNSUPPORTED;
+
+  PrivFileData = PRIVATE_UDF_FILE_DATA_FROM_THIS (This);
+
+  FileIdentifierDesc = PrivFileData->File.FileIdentifierDesc;
+  if (IS_FID_DIRECTORY_FILE (FileIdentifierDesc)) {
+    //
+    // If the file handle is a directory, the _only_ position that may be set is
+    // zero. This has no effect of starting the read proccess of the directory
+    // entries over.
+    //
+    if (Position == 0) {
+      PrivFileData->FilePosition = Position;
+      PrivFileData->ReadDirInfo.FidOffset = 0;
+      Status = EFI_SUCCESS;
+    }
+  } else if (IS_FID_NORMAL_FILE (FileIdentifierDesc)) {
+    //
+    // Seeking to position 0xFFFFFFFFFFFFFFFF causes the current position to be
+    // set to the EOF.
+    //
+    if (Position == 0xFFFFFFFFFFFFFFFF) {
+      PrivFileData->FilePosition = PrivFileData->FileSize - 1;
+    } else {
+      PrivFileData->FilePosition = Position;
+    }
+
+    Status = EFI_SUCCESS;
+  }
+
+  return Status;
 }
 
 /**
@@ -505,7 +755,7 @@ UdfGetInfo (
   UINT64                      FreeSpaceSize;
   CHAR16                      VolumeLabel[64];
 
-  if (This == NULL || InformationType == NULL || BufferSize == 0 ||
+  if (This == NULL || InformationType == NULL || BufferSize == NULL ||
       (*BufferSize != 0 && Buffer == NULL)) {
     return EFI_INVALID_PARAMETER;
   }
@@ -553,7 +803,7 @@ UdfGetInfo (
       // NULL-terminated OSTA compressed format, so we must check for the NULL
       // character.
       //
-      if (!*String) {
+      if (*String == L'\0') {
         break;
       }
 
diff --git a/MdeModulePkg/Universal/Disk/UdfDxe/FileSystemOperations.c b/MdeModulePkg/Universal/Disk/UdfDxe/FileSystemOperations.c
index 2f7f945479..65cf8dc057 100644
--- a/MdeModulePkg/Universal/Disk/UdfDxe/FileSystemOperations.c
+++ b/MdeModulePkg/Universal/Disk/UdfDxe/FileSystemOperations.c
@@ -384,7 +384,7 @@ GetFileSetDescriptors (
 
   for (Index = 0; Index < Volume->LogicalVolDescsNo; Index++) {
     FileSetDesc = AllocateZeroPool (sizeof (UDF_FILE_SET_DESCRIPTOR));
-    if (!FileSetDesc) {
+    if (FileSetDesc == NULL) {
       Status = EFI_OUT_OF_RESOURCES;
       goto Error_Alloc_Fsd;
     }
@@ -533,13 +533,13 @@ GetFileEntryData (
     ExtendedFileEntry = (UDF_EXTENDED_FILE_ENTRY *)FileEntryData;
 
     *Length  = ExtendedFileEntry->InformationLength;
-    *Data    = (VOID *)((UINT8 *)&ExtendedFileEntry->Data[0] +
+    *Data    = (VOID *)((UINT8 *)ExtendedFileEntry->Data +
                         ExtendedFileEntry->LengthOfExtendedAttributes);
   } else if (IS_FE (FileEntryData)) {
     FileEntry = (UDF_FILE_ENTRY *)FileEntryData;
 
     *Length  = FileEntry->InformationLength;
-    *Data    = (VOID *)((UINT8 *)&FileEntry->Data[0] +
+    *Data    = (VOID *)((UINT8 *)FileEntry->Data +
                         FileEntry->LengthOfExtendedAttributes);
   }
 }
@@ -561,13 +561,13 @@ GetAdsInformation (
     ExtendedFileEntry = (UDF_EXTENDED_FILE_ENTRY *)FileEntryData;
 
     *Length = ExtendedFileEntry->LengthOfAllocationDescriptors;
-    *AdsData = (VOID *)((UINT8 *)&ExtendedFileEntry->Data[0] +
+    *AdsData = (VOID *)((UINT8 *)ExtendedFileEntry->Data +
                         ExtendedFileEntry->LengthOfExtendedAttributes);
   } else if (IS_FE (FileEntryData)) {
     FileEntry = (UDF_FILE_ENTRY *)FileEntryData;
 
     *Length = FileEntry->LengthOfAllocationDescriptors;
-    *AdsData = (VOID *)((UINT8 *)&FileEntry->Data[0] +
+    *AdsData = (VOID *)((UINT8 *)FileEntry->Data +
                         FileEntry->LengthOfExtendedAttributes);
   }
 }
@@ -955,7 +955,7 @@ ReadFile (
       // Allocate buffer for starting read data.
       //
       ReadFileInfo->FileData = AllocatePool (Length);
-      if (!ReadFileInfo->FileData) {
+      if (ReadFileInfo->FileData == NULL) {
         return EFI_OUT_OF_RESOURCES;
       }
 
@@ -1135,7 +1135,7 @@ ReadFile (
 	    ReadFileInfo->FilePosition += DataLength;
 
 	    BytesLeft -= DataLength;
-	    if (!BytesLeft) {
+	    if (BytesLeft == 0) {
 	      //
 	      // There is no more file data to read.
 	      //
@@ -1155,7 +1155,8 @@ ReadFile (
 
     break;
   case EXTENDED_ADS_SEQUENCE:
-    // Not supported. Haven't got a volume with that yet.
+     // FIXME: Not supported. Got no volume with it, yet.
+    ASSERT (FALSE);
     Status = EFI_UNSUPPORTED;
     break;
   }
@@ -1214,7 +1215,7 @@ InternalFindFile (
   // If FileName is current file or working directory, just duplicate Parent's
   // FE/EFE and FID descriptors.
   //
-  if (!StrCmp (FileName, L".")) {
+  if (StrCmp (FileName, L".") == 0) {
     DuplicateFe (BlockIo, Volume, Parent->FileEntry, &File->FileEntry);
     DuplicateFid (Parent->FileIdentifierDesc, &File->FileIdentifierDesc);
 
@@ -1254,7 +1255,7 @@ InternalFindFile (
       // directory (Parent), and if FileName is either ".." or "\\", then it's
       // the expected FID.
       //
-      if (!StrCmp (FileName, L"..") || !StrCmp (FileName, L"\\")) {
+      if (StrCmp (FileName, L"..") == 0 || StrCmp (FileName, L"\\") == 0) {
         Found = TRUE;
         break;
       }
@@ -1268,14 +1269,14 @@ InternalFindFile (
       }
 
       //
-      // OK - their filename lengths match. Now, compare if their filenames.
+      // OK - their filename lengths match. Now, compare their characters.
       //
       Status = GetFileNameFromFid (FileIdentifierDesc, FoundFileName);
       if (EFI_ERROR (Status)) {
         break;
       }
 
-      if (!StrCmp (FileName, FoundFileName)) {
+      if (StrCmp (FileName, FoundFileName) == 0) {
         //
         // FID has been found. Prepare to find its respective FE/EFE.
         //
@@ -1288,7 +1289,7 @@ InternalFindFile (
     FreePool ((VOID *)FileIdentifierDesc);
   }
 
-  if (ReadDirInfo.DirectoryData) {
+  if (ReadDirInfo.DirectoryData != NULL) {
     //
     // Free all allocated resources for the directory listing.
     //
@@ -1306,7 +1307,7 @@ InternalFindFile (
     //
     // Otherwise, find FE/EFE from the respective FID.
     //
-    if (StrCmp (FileName, L"\\")) {
+    if (StrCmp (FileName, L"\\") != 0) {
       Status = FindFileEntry (
         BlockIo,
         DiskIo,
@@ -1685,7 +1686,7 @@ FindFile (
       //
       // Open root directory.
       //
-      if (!Root) {
+      if (Root == NULL) {
         //
         // There is no file found for the root directory yet. So, find only its
         // FID by now.
@@ -1798,7 +1799,7 @@ ReadDirectoryEntry (
   UDF_READ_FILE_INFO              ReadFileInfo;
   UDF_FILE_IDENTIFIER_DESCRIPTOR  *FileIdentifierDesc;
 
-  if (!ReadDirInfo->DirectoryData) {
+  if (ReadDirInfo->DirectoryData == NULL) {
     //
     // The directory's recorded data has not been read yet. So let's cache it
     // into memory and the next calls won't need to read it again.
@@ -1873,7 +1874,7 @@ GetFileNameFromFid (
 
   OstaCompressed =
     (UINT8 *)(
-      (UINT8 *)&FileIdentifierDesc->Data[0] +
+      (UINT8 *)FileIdentifierDesc->Data +
       FileIdentifierDesc->LengthOfImplementationUse
       );
 
@@ -2235,8 +2236,7 @@ SetFileInfo (
   //
   FileInfoLength = sizeof (EFI_FILE_INFO) + (FileName ?
                                              StrSize (FileName) :
-                                             sizeof (CHAR16)
-    );
+                                             sizeof (CHAR16));
   if (*BufferSize < FileInfoLength) {
     //
     // The given Buffer has no size enough for EFI_FILE_INFO structure.
@@ -2434,7 +2434,7 @@ GetVolumeSize (
 
     Length = LogicalVolInt->NumberOfPartitions;
     for (Index = 0; Index < Length; Index += sizeof (UINT32)) {
-      LsnsNo = *(UINT32 *)((UINT8 *)&LogicalVolInt->Data[0] + Index);
+      LsnsNo = *(UINT32 *)((UINT8 *)LogicalVolInt->Data + Index);
       if (LsnsNo == 0xFFFFFFFFUL) {
         //
         // Size not specified.
@@ -2447,7 +2447,7 @@ GetVolumeSize (
 
     Length = (LogicalVolInt->NumberOfPartitions * sizeof (UINT32)) << 1;
     for (; Index < Length; Index += sizeof (UINT32)) {
-      LsnsNo = *(UINT32 *)((UINT8 *)&LogicalVolInt->Data[0] + Index);
+      LsnsNo = *(UINT32 *)((UINT8 *)LogicalVolInt->Data + Index);
       if (LsnsNo == 0xFFFFFFFFUL) {
         //
         // Size not specified.
@@ -2470,3 +2470,63 @@ GetVolumeSize (
 
   return EFI_SUCCESS;
 }
+
+/**
+  Seek a file and read its data into memory on an UDF volume.
+
+  @param[in]      BlockIo       BlockIo interface.
+  @param[in]      DiskIo        DiskIo interface.
+  @param[in]      Volume        UDF volume information structure.
+  @param[in]      File          File information structure.
+  @param[in]      FileSize      Size of the file.
+  @param[in out]  FilePosition  File position.
+  @param[in out]  Buffer        File data.
+  @param[in out]  BufferSize    Read size.
+
+  @retval EFI_SUCCESS          File seeked and read.
+  @retval EFI_UNSUPPORTED      Extended Allocation Descriptors not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The file's recorded data was not read due to lack
+                               of resources.
+
+**/
+EFI_STATUS
+ReadFileData (
+  IN      EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN      EFI_DISK_IO_PROTOCOL   *DiskIo,
+  IN      UDF_VOLUME_INFO        *Volume,
+  IN      UDF_FILE_INFO          *File,
+  IN      UINT64                 FileSize,
+  IN OUT  UINT64                 *FilePosition,
+  IN OUT  VOID                   *Buffer,
+  IN OUT  UINT64                 *BufferSize
+  )
+{
+  EFI_STATUS          Status;
+  UDF_READ_FILE_INFO  ReadFileInfo;
+
+  ReadFileInfo.Flags         = READ_FILE_SEEK_AND_READ;
+  ReadFileInfo.FilePosition  = *FilePosition;
+  ReadFileInfo.FileData      = Buffer;
+  ReadFileInfo.FileDataSize  = *BufferSize;
+  ReadFileInfo.FileSize      = FileSize;
+
+  Status = ReadFile (
+                 BlockIo,
+                 DiskIo,
+                 Volume,
+                 &File->FileIdentifierDesc->Icb,
+                 File->FileEntry,
+                 &ReadFileInfo
+                 );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  *BufferSize    = ReadFileInfo.FileDataSize;
+  *FilePosition  = ReadFileInfo.FilePosition;
+
+  return EFI_SUCCESS;
+}
diff --git a/MdeModulePkg/Universal/Disk/UdfDxe/Udf.h b/MdeModulePkg/Universal/Disk/UdfDxe/Udf.h
index 37d7c613e1..ccea385e22 100644
--- a/MdeModulePkg/Universal/Disk/UdfDxe/Udf.h
+++ b/MdeModulePkg/Universal/Disk/UdfDxe/Udf.h
@@ -1032,6 +1032,39 @@ GetVolumeSize (
   );
 
 /**
+  Seek a file and read its data into memory on an UDF volume.
+
+  @param[in]      BlockIo       BlockIo interface.
+  @param[in]      DiskIo        DiskIo interface.
+  @param[in]      Volume        UDF volume information structure.
+  @param[in]      File          File information structure.
+  @param[in]      FileSize      Size of the file.
+  @param[in out]  FilePosition  File position.
+  @param[in out]  Buffer        File data.
+  @param[in out]  BufferSize    Read size.
+
+  @retval EFI_SUCCESS          File seeked and read.
+  @retval EFI_UNSUPPORTED      Extended Allocation Descriptors not supported.
+  @retval EFI_NO_MEDIA         The device has no media.
+  @retval EFI_DEVICE_ERROR     The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.
+  @retval EFI_OUT_OF_RESOURCES The file's recorded data was not read due to lack
+                               of resources.
+
+**/
+EFI_STATUS
+ReadFileData (
+  IN      EFI_BLOCK_IO_PROTOCOL  *BlockIo,
+  IN      EFI_DISK_IO_PROTOCOL   *DiskIo,
+  IN      UDF_VOLUME_INFO        *Volume,
+  IN      UDF_FILE_INFO          *File,
+  IN      UINT64                 FileSize,
+  IN OUT  UINT64                 *FilePosition,
+  IN OUT  VOID                   *Buffer,
+  IN OUT  UINT64                 *BufferSize
+  );
+
+/**
   Mangle a filename by cutting off trailing whitespaces, "\\", "." and "..".
 
   @param[in] FileName Filename.
-- 
2.11.0



^ permalink raw reply related	[flat|nested] 17+ messages in thread

* [PATCH 4/4] OvmfPkg: Introduce UDF_ENABLE build flag
  2017-08-08 19:31 [PATCH 0/4] read-only UDF file system support Paulo Alcantara
                   ` (2 preceding siblings ...)
  2017-08-08 19:31 ` [PATCH 3/4] MdeModulePkg/UdfDxe: Add seek, read and listing support on files Paulo Alcantara
@ 2017-08-08 19:31 ` Paulo Alcantara
  2017-08-09  9:44   ` Laszlo Ersek
  2017-08-09  1:17 ` [PATCH 0/4] read-only UDF file system support Zeng, Star
  4 siblings, 1 reply; 17+ messages in thread
From: Paulo Alcantara @ 2017-08-08 19:31 UTC (permalink / raw)
  To: edk2-devel; +Cc: Paulo Alcantara, Jordan Justen, Laszlo Ersek

By defining this build flag, OVMF will support booting from UDF file
systems.

Cc: Jordan Justen <jordan.l.justen@intel.com>
Cc: Laszlo Ersek <lersek@redhat.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Paulo Alcantara <pcacjr@zytor.com>
---
 OvmfPkg/OvmfPkgIa32.dsc    | 7 +++++++
 OvmfPkg/OvmfPkgIa32.fdf    | 3 +++
 OvmfPkg/OvmfPkgIa32X64.dsc | 7 +++++++
 OvmfPkg/OvmfPkgIa32X64.fdf | 3 +++
 OvmfPkg/OvmfPkgX64.dsc     | 7 +++++++
 OvmfPkg/OvmfPkgX64.fdf     | 3 +++
 6 files changed, 30 insertions(+)

diff --git a/OvmfPkg/OvmfPkgIa32.dsc b/OvmfPkg/OvmfPkgIa32.dsc
index 5a14325f73..c71c332efd 100644
--- a/OvmfPkg/OvmfPkgIa32.dsc
+++ b/OvmfPkg/OvmfPkgIa32.dsc
@@ -39,6 +39,7 @@
   DEFINE HTTP_BOOT_ENABLE        = FALSE
   DEFINE SMM_REQUIRE             = FALSE
   DEFINE TLS_ENABLE              = FALSE
+  DEFINE UDF_ENABLE              = FALSE
 
   #
   # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
@@ -409,6 +410,9 @@
   gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
   gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
 !endif
+!if $(UDF_ENABLE) == TRUE
+  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
+!endif
 
 [PcdsFixedAtBuild]
   gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
@@ -685,6 +689,9 @@
   MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
   MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
   FatPkg/EnhancedFatDxe/Fat.inf
+!if $(UDF_ENABLE) == TRUE
+  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
+!endif
   MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
   MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
   OvmfPkg/SataControllerDxe/SataControllerDxe.inf
diff --git a/OvmfPkg/OvmfPkgIa32.fdf b/OvmfPkg/OvmfPkgIa32.fdf
index 5e5ade2a1f..2da1fcbe1f 100644
--- a/OvmfPkg/OvmfPkgIa32.fdf
+++ b/OvmfPkg/OvmfPkgIa32.fdf
@@ -282,6 +282,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
 INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
 
 INF  FatPkg/EnhancedFatDxe/Fat.inf
+!if $(UDF_ENABLE) == TRUE
+INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
+!endif
 
 !ifndef $(USE_OLD_SHELL)
 INF  ShellPkg/Application/Shell/Shell.inf
diff --git a/OvmfPkg/OvmfPkgIa32X64.dsc b/OvmfPkg/OvmfPkgIa32X64.dsc
index 2f17a70db8..d0785cca13 100644
--- a/OvmfPkg/OvmfPkgIa32X64.dsc
+++ b/OvmfPkg/OvmfPkgIa32X64.dsc
@@ -39,6 +39,7 @@
   DEFINE HTTP_BOOT_ENABLE        = FALSE
   DEFINE SMM_REQUIRE             = FALSE
   DEFINE TLS_ENABLE              = FALSE
+  DEFINE UDF_ENABLE              = FALSE
 
   #
   # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
@@ -414,6 +415,9 @@
   gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
   gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
 !endif
+!if $(UDF_ENABLE) == TRUE
+  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
+!endif
 
 [PcdsFixedAtBuild]
   gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
@@ -694,6 +698,9 @@
   MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
   MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
   FatPkg/EnhancedFatDxe/Fat.inf
+!if $(UDF_ENABLE) == TRUE
+  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
+!endif
   MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
   MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
   OvmfPkg/SataControllerDxe/SataControllerDxe.inf
diff --git a/OvmfPkg/OvmfPkgIa32X64.fdf b/OvmfPkg/OvmfPkgIa32X64.fdf
index aa0d8c69f3..0fdd359051 100644
--- a/OvmfPkg/OvmfPkgIa32X64.fdf
+++ b/OvmfPkg/OvmfPkgIa32X64.fdf
@@ -283,6 +283,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
 INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
 
 INF  FatPkg/EnhancedFatDxe/Fat.inf
+!if $(UDF_ENABLE) == TRUE
+INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
+!endif
 
 !ifndef $(USE_OLD_SHELL)
 INF  ShellPkg/Application/Shell/Shell.inf
diff --git a/OvmfPkg/OvmfPkgX64.dsc b/OvmfPkg/OvmfPkgX64.dsc
index c0bd5d0ea6..a25d8b1e99 100644
--- a/OvmfPkg/OvmfPkgX64.dsc
+++ b/OvmfPkg/OvmfPkgX64.dsc
@@ -39,6 +39,7 @@
   DEFINE HTTP_BOOT_ENABLE        = FALSE
   DEFINE SMM_REQUIRE             = FALSE
   DEFINE TLS_ENABLE              = FALSE
+  DEFINE UDF_ENABLE              = FALSE
 
   #
   # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
@@ -414,6 +415,9 @@
   gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
   gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
 !endif
+!if $(UDF_ENABLE) == TRUE
+  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
+!endif
 
 [PcdsFixedAtBuild]
   gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
@@ -692,6 +696,9 @@
   MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
   MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
   FatPkg/EnhancedFatDxe/Fat.inf
+!if $(UDF_ENABLE) == TRUE
+  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
+!endif
   MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
   MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
   OvmfPkg/SataControllerDxe/SataControllerDxe.inf
diff --git a/OvmfPkg/OvmfPkgX64.fdf b/OvmfPkg/OvmfPkgX64.fdf
index 98a0cf17da..8ae591c1f5 100644
--- a/OvmfPkg/OvmfPkgX64.fdf
+++ b/OvmfPkg/OvmfPkgX64.fdf
@@ -283,6 +283,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
 INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
 
 INF  FatPkg/EnhancedFatDxe/Fat.inf
+!if $(UDF_ENABLE) == TRUE
+INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
+!endif
 
 !ifndef $(USE_OLD_SHELL)
 INF  ShellPkg/Application/Shell/Shell.inf
-- 
2.11.0



^ permalink raw reply related	[flat|nested] 17+ messages in thread

* Re: [PATCH 0/4] read-only UDF file system support
  2017-08-08 19:31 [PATCH 0/4] read-only UDF file system support Paulo Alcantara
                   ` (3 preceding siblings ...)
  2017-08-08 19:31 ` [PATCH 4/4] OvmfPkg: Introduce UDF_ENABLE build flag Paulo Alcantara
@ 2017-08-09  1:17 ` Zeng, Star
  2017-08-09  6:05   ` Ni, Ruiyu
  4 siblings, 1 reply; 17+ messages in thread
From: Zeng, Star @ 2017-08-09  1:17 UTC (permalink / raw)
  To: Paulo Alcantara, edk2-devel@lists.01.org
  Cc: Laszlo Ersek, Justen, Jordan L, Andrew Fish, Kinney, Michael D,
	Gao, Liming, Dong, Eric, Doran, Mark, Ni, Ruiyu, Wu, Hao A

Cc Ray and Hao.

-----Original Message-----
From: Paulo Alcantara [mailto:pcacjr@zytor.com] 
Sent: Wednesday, August 9, 2017 3:32 AM
To: edk2-devel@lists.01.org
Cc: Paulo Alcantara <pcacjr@zytor.com>; Laszlo Ersek <lersek@redhat.com>; Justen, Jordan L <jordan.l.justen@intel.com>; Andrew Fish <afish@apple.com>; Kinney, Michael D <michael.d.kinney@intel.com>; Gao, Liming <liming.gao@intel.com>; Zeng, Star <star.zeng@intel.com>; Dong, Eric <eric.dong@intel.com>; Doran, Mark <mark.doran@intel.com>
Subject: [PATCH 0/4] read-only UDF file system support

Hi,

I'm posting this series again after ~3 years that introduces UDF file system support in UEFI. Why? Because Laszlo (or Red Hat) seemed to be interested in such support.

I started working on this driver just as an excuse to learn UEFI development at that time. This work isn't based on any previous one and it's BSD licensed. I also *never* intended to replace it with the default FAT file system. On the contrary, I was looking to give people an opportunity to use file system features that current FAT file system lacks.

This series was never reviewed or fully tested. I basically used Linux and mkudffs[1] to test different UDF disks, as well as booting a Linux (EFI stub) rootfs from UDF file systems. Please, I'd really appreciate if some of one could help reviewing or testing it.

Note that UDF file system support was *only* added to OVMF platform and it's disabled by default through UDF_ENABLE build option. There's also a feature PCD flag that turns on or off parsing of UDF volumes during partition discovery in PartitionDxe driver.

Branch: https://github.com/pcacjr/edk2/tree/udf-fs

Cc: Laszlo Ersek <lersek@redhat.com>
Cc: Jordan Justen <jordan.l.justen@intel.com>
Cc: Andrew Fish <afish@apple.com>
Cc: Michael D Kinney <michael.d.kinney@intel.com>
Cc: Liming Gao <liming.gao@intel.com>
Cc: Star Zeng <star.zeng@intel.com>
Cc: Eric Dong <eric.dong@intel.com>
Cc: Mark Doran <mark.doran@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Paulo Alcantara <pcacjr@zytor.com>
---

Paulo Alcantara (4):
  MdeModulePkg/PartitionDxe: Add UDF/ECMA-167 file system support
  MdeModulePkg: Initial UDF/ECMA-167 file system support
  MdeModulePkg/UdfDxe: Add seek, read and listing support on files
  OvmfPkg: Introduce UDF_ENABLE build flag

 MdeModulePkg/MdeModulePkg.dec                      |    6 +
 .../Universal/Disk/PartitionDxe/Partition.c        |    3 +-
 .../Universal/Disk/PartitionDxe/Partition.h        |   41 +-
 .../Universal/Disk/PartitionDxe/PartitionDxe.inf   |   10 +-
 MdeModulePkg/Universal/Disk/PartitionDxe/Udf.c     |  335 +++
 MdeModulePkg/Universal/Disk/UdfDxe/ComponentName.c |  185 ++
 MdeModulePkg/Universal/Disk/UdfDxe/File.c          |  901 +++++++
 MdeModulePkg/Universal/Disk/UdfDxe/FileName.c      |  195 ++
 .../Universal/Disk/UdfDxe/FileSystemOperations.c   | 2532 ++++++++++++++++++++
 MdeModulePkg/Universal/Disk/UdfDxe/Udf.c           |  407 ++++
 MdeModulePkg/Universal/Disk/UdfDxe/Udf.h           | 1276 ++++++++++
 MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf      |   66 +
 MdePkg/Include/IndustryStandard/Udf.h              |   78 +
 OvmfPkg/OvmfPkgIa32.dsc                            |    7 +
 OvmfPkg/OvmfPkgIa32.fdf                            |    3 +
 OvmfPkg/OvmfPkgIa32X64.dsc                         |    7 +
 OvmfPkg/OvmfPkgIa32X64.fdf                         |    3 +
 OvmfPkg/OvmfPkgX64.dsc                             |    7 +
 OvmfPkg/OvmfPkgX64.fdf                             |    3 +
 19 files changed, 6057 insertions(+), 8 deletions(-)  create mode 100644 MdeModulePkg/Universal/Disk/PartitionDxe/Udf.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/ComponentName.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/File.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/FileName.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/FileSystemOperations.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/Udf.c
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/Udf.h
 create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
 create mode 100644 MdePkg/Include/IndustryStandard/Udf.h

--
2.11.0



^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 0/4] read-only UDF file system support
  2017-08-09  1:17 ` [PATCH 0/4] read-only UDF file system support Zeng, Star
@ 2017-08-09  6:05   ` Ni, Ruiyu
  2017-08-09 13:26     ` Paulo Alcantara
  0 siblings, 1 reply; 17+ messages in thread
From: Ni, Ruiyu @ 2017-08-09  6:05 UTC (permalink / raw)
  To: Zeng, Star, Paulo Alcantara, edk2-devel@lists.01.org
  Cc: Laszlo Ersek, Justen, Jordan L, Andrew Fish, Kinney, Michael D,
	Gao, Liming, Dong, Eric, Doran, Mark, Wu, Hao A

Paulo,
Thanks for enabling the UDF support into EDKII.
Below are several comments:
1. Could you please separate the patch to modify MdePkg and MdeModulePkg?

2. UDF_CDROM_VOLUME_IDENTIFIER is also defined in Eltorito.h as CDVOL_ID.
     Maybe we could redefine CDVOL_ID to UDF_CDROM_VOLUME_IDENTIFIER?

2. Why do you need a PCD to control the UDF support? I prefer no. More choices
     is not always good😊

3.  Is gUdfVolumeSignatureGuid only used in Partition driver to produce the device
      path? Can we just use HARDDRIVE_DEVICE_PATH? Or at least gUdfVolumeSignatureGuid
      can be removed, the GUID macro is enough?

4.  Have you verified on a CDROM which contains both ElTorito and CDFS?

Thanks/Ray

> -----Original Message-----
> From: Zeng, Star
> Sent: Wednesday, August 9, 2017 9:18 AM
> To: Paulo Alcantara <pcacjr@zytor.com>; edk2-devel@lists.01.org
> Cc: Laszlo Ersek <lersek@redhat.com>; Justen, Jordan L
> <jordan.l.justen@intel.com>; Andrew Fish <afish@apple.com>; Kinney,
> Michael D <michael.d.kinney@intel.com>; Gao, Liming
> <liming.gao@intel.com>; Dong, Eric <eric.dong@intel.com>; Doran, Mark
> <mark.doran@intel.com>; Ni, Ruiyu <ruiyu.ni@intel.com>; Wu, Hao A
> <hao.a.wu@intel.com>
> Subject: RE: [PATCH 0/4] read-only UDF file system support
> 
> Cc Ray and Hao.
> 
> -----Original Message-----
> From: Paulo Alcantara [mailto:pcacjr@zytor.com]
> Sent: Wednesday, August 9, 2017 3:32 AM
> To: edk2-devel@lists.01.org
> Cc: Paulo Alcantara <pcacjr@zytor.com>; Laszlo Ersek <lersek@redhat.com>;
> Justen, Jordan L <jordan.l.justen@intel.com>; Andrew Fish
> <afish@apple.com>; Kinney, Michael D <michael.d.kinney@intel.com>; Gao,
> Liming <liming.gao@intel.com>; Zeng, Star <star.zeng@intel.com>; Dong, Eric
> <eric.dong@intel.com>; Doran, Mark <mark.doran@intel.com>
> Subject: [PATCH 0/4] read-only UDF file system support
> 
> Hi,
> 
> I'm posting this series again after ~3 years that introduces UDF file system
> support in UEFI. Why? Because Laszlo (or Red Hat) seemed to be interested
> in such support.
> 
> I started working on this driver just as an excuse to learn UEFI development
> at that time. This work isn't based on any previous one and it's BSD licensed. I
> also *never* intended to replace it with the default FAT file system. On the
> contrary, I was looking to give people an opportunity to use file system
> features that current FAT file system lacks.
> 
> This series was never reviewed or fully tested. I basically used Linux and
> mkudffs[1] to test different UDF disks, as well as booting a Linux (EFI stub)
> rootfs from UDF file systems. Please, I'd really appreciate if some of one
> could help reviewing or testing it.
> 
> Note that UDF file system support was *only* added to OVMF platform and
> it's disabled by default through UDF_ENABLE build option. There's also a
> feature PCD flag that turns on or off parsing of UDF volumes during partition
> discovery in PartitionDxe driver.
> 
> Branch: https://github.com/pcacjr/edk2/tree/udf-fs
> 
> Cc: Laszlo Ersek <lersek@redhat.com>
> Cc: Jordan Justen <jordan.l.justen@intel.com>
> Cc: Andrew Fish <afish@apple.com>
> Cc: Michael D Kinney <michael.d.kinney@intel.com>
> Cc: Liming Gao <liming.gao@intel.com>
> Cc: Star Zeng <star.zeng@intel.com>
> Cc: Eric Dong <eric.dong@intel.com>
> Cc: Mark Doran <mark.doran@intel.com>
> Contributed-under: TianoCore Contribution Agreement 1.1
> Signed-off-by: Paulo Alcantara <pcacjr@zytor.com>
> ---
> 
> Paulo Alcantara (4):
>   MdeModulePkg/PartitionDxe: Add UDF/ECMA-167 file system support
>   MdeModulePkg: Initial UDF/ECMA-167 file system support
>   MdeModulePkg/UdfDxe: Add seek, read and listing support on files
>   OvmfPkg: Introduce UDF_ENABLE build flag
> 
>  MdeModulePkg/MdeModulePkg.dec                      |    6 +
>  .../Universal/Disk/PartitionDxe/Partition.c        |    3 +-
>  .../Universal/Disk/PartitionDxe/Partition.h        |   41 +-
>  .../Universal/Disk/PartitionDxe/PartitionDxe.inf   |   10 +-
>  MdeModulePkg/Universal/Disk/PartitionDxe/Udf.c     |  335 +++
>  MdeModulePkg/Universal/Disk/UdfDxe/ComponentName.c |  185 ++
>  MdeModulePkg/Universal/Disk/UdfDxe/File.c          |  901 +++++++
>  MdeModulePkg/Universal/Disk/UdfDxe/FileName.c      |  195 ++
>  .../Universal/Disk/UdfDxe/FileSystemOperations.c   | 2532
> ++++++++++++++++++++
>  MdeModulePkg/Universal/Disk/UdfDxe/Udf.c           |  407 ++++
>  MdeModulePkg/Universal/Disk/UdfDxe/Udf.h           | 1276 ++++++++++
>  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf      |   66 +
>  MdePkg/Include/IndustryStandard/Udf.h              |   78 +
>  OvmfPkg/OvmfPkgIa32.dsc                            |    7 +
>  OvmfPkg/OvmfPkgIa32.fdf                            |    3 +
>  OvmfPkg/OvmfPkgIa32X64.dsc                         |    7 +
>  OvmfPkg/OvmfPkgIa32X64.fdf                         |    3 +
>  OvmfPkg/OvmfPkgX64.dsc                             |    7 +
>  OvmfPkg/OvmfPkgX64.fdf                             |    3 +
>  19 files changed, 6057 insertions(+), 8 deletions(-)  create mode 100644
> MdeModulePkg/Universal/Disk/PartitionDxe/Udf.c
>  create mode 100644
> MdeModulePkg/Universal/Disk/UdfDxe/ComponentName.c
>  create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/File.c
>  create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/FileName.c
>  create mode 100644
> MdeModulePkg/Universal/Disk/UdfDxe/FileSystemOperations.c
>  create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/Udf.c
>  create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/Udf.h
>  create mode 100644 MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>  create mode 100644 MdePkg/Include/IndustryStandard/Udf.h
> 
> --
> 2.11.0


^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 4/4] OvmfPkg: Introduce UDF_ENABLE build flag
  2017-08-08 19:31 ` [PATCH 4/4] OvmfPkg: Introduce UDF_ENABLE build flag Paulo Alcantara
@ 2017-08-09  9:44   ` Laszlo Ersek
  2017-08-09 13:38     ` Paulo Alcantara
  2017-08-09 15:45     ` Andrew Fish
  0 siblings, 2 replies; 17+ messages in thread
From: Laszlo Ersek @ 2017-08-09  9:44 UTC (permalink / raw)
  To: Paulo Alcantara; +Cc: edk2-devel, Jordan Justen, Ard Biesheuvel, Andrew Fish

CC Ard and Andrew

On 08/08/17 21:31, Paulo Alcantara wrote:
> By defining this build flag, OVMF will support booting from UDF file
> systems.
> 
> Cc: Jordan Justen <jordan.l.justen@intel.com>
> Cc: Laszlo Ersek <lersek@redhat.com>
> Contributed-under: TianoCore Contribution Agreement 1.1
> Signed-off-by: Paulo Alcantara <pcacjr@zytor.com>
> ---
>  OvmfPkg/OvmfPkgIa32.dsc    | 7 +++++++
>  OvmfPkg/OvmfPkgIa32.fdf    | 3 +++
>  OvmfPkg/OvmfPkgIa32X64.dsc | 7 +++++++
>  OvmfPkg/OvmfPkgIa32X64.fdf | 3 +++
>  OvmfPkg/OvmfPkgX64.dsc     | 7 +++++++
>  OvmfPkg/OvmfPkgX64.fdf     | 3 +++
>  6 files changed, 30 insertions(+)

Ray already mentioned that PcdUdfFileSystemSupport is not needed. I
agree. Similarly, I think UDF_ENABLE is also not needed, the new driver
should be added to the DSC and FDF files right after "Fat.inf" (like you
are doing it now, just unconditionally).

Furthermore, can you please do the same in the ArmVirtPkg DSC and FDF
files? (Just grep the tree for "Fat.inf".) EmulatorPkg and Nt32Pkg are
further emulation platforms that might want to include this.

My reason for suggesting the unconditional inclusion is the following
sentence from the UEFI 2.7 spec:

  13 Protocols — Media Access
  13.3 File System Format
  13.3.2 Partition Discovery
  13.3.2.1 ISO-9660 and El Torito

  [...] DVD-ROM images formatted as required by the UDF 2.0
  specification (OSTA Universal Disk Format Specification, Revision 2.0)
  can be booted by EFI. [...]

It does not say "may be bootable", it says "can be booted".

It would be interesting to see the Mantis ticket (if any) that got this
language into the spec, without the edk2 reference implementation
providing a UDF driver.
- Using the Mantis simple search function, "UDF" brings up nothing.
- From some googling, this sentence appears to go back to EFI 1.10 at
  the least.

Andrew, do you remember the history of the quoted sentence?

Paulo, I'll check if I can test your driver with some 3rd party media
(i.e., a DVD image that I don't prepare myself).

Thank you!
Laszlo

> 
> diff --git a/OvmfPkg/OvmfPkgIa32.dsc b/OvmfPkg/OvmfPkgIa32.dsc
> index 5a14325f73..c71c332efd 100644
> --- a/OvmfPkg/OvmfPkgIa32.dsc
> +++ b/OvmfPkg/OvmfPkgIa32.dsc
> @@ -39,6 +39,7 @@
>    DEFINE HTTP_BOOT_ENABLE        = FALSE
>    DEFINE SMM_REQUIRE             = FALSE
>    DEFINE TLS_ENABLE              = FALSE
> +  DEFINE UDF_ENABLE              = FALSE
>  
>    #
>    # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
> @@ -409,6 +410,9 @@
>    gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>    gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>  !endif
> +!if $(UDF_ENABLE) == TRUE
> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
> +!endif
>  
>  [PcdsFixedAtBuild]
>    gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
> @@ -685,6 +689,9 @@
>    MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>    MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>    FatPkg/EnhancedFatDxe/Fat.inf
> +!if $(UDF_ENABLE) == TRUE
> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
> +!endif
>    MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>    MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>    OvmfPkg/SataControllerDxe/SataControllerDxe.inf
> diff --git a/OvmfPkg/OvmfPkgIa32.fdf b/OvmfPkg/OvmfPkgIa32.fdf
> index 5e5ade2a1f..2da1fcbe1f 100644
> --- a/OvmfPkg/OvmfPkgIa32.fdf
> +++ b/OvmfPkg/OvmfPkgIa32.fdf
> @@ -282,6 +282,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>  INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>  
>  INF  FatPkg/EnhancedFatDxe/Fat.inf
> +!if $(UDF_ENABLE) == TRUE
> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
> +!endif
>  
>  !ifndef $(USE_OLD_SHELL)
>  INF  ShellPkg/Application/Shell/Shell.inf
> diff --git a/OvmfPkg/OvmfPkgIa32X64.dsc b/OvmfPkg/OvmfPkgIa32X64.dsc
> index 2f17a70db8..d0785cca13 100644
> --- a/OvmfPkg/OvmfPkgIa32X64.dsc
> +++ b/OvmfPkg/OvmfPkgIa32X64.dsc
> @@ -39,6 +39,7 @@
>    DEFINE HTTP_BOOT_ENABLE        = FALSE
>    DEFINE SMM_REQUIRE             = FALSE
>    DEFINE TLS_ENABLE              = FALSE
> +  DEFINE UDF_ENABLE              = FALSE
>  
>    #
>    # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
> @@ -414,6 +415,9 @@
>    gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>    gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>  !endif
> +!if $(UDF_ENABLE) == TRUE
> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
> +!endif
>  
>  [PcdsFixedAtBuild]
>    gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
> @@ -694,6 +698,9 @@
>    MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>    MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>    FatPkg/EnhancedFatDxe/Fat.inf
> +!if $(UDF_ENABLE) == TRUE
> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
> +!endif
>    MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>    MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>    OvmfPkg/SataControllerDxe/SataControllerDxe.inf
> diff --git a/OvmfPkg/OvmfPkgIa32X64.fdf b/OvmfPkg/OvmfPkgIa32X64.fdf
> index aa0d8c69f3..0fdd359051 100644
> --- a/OvmfPkg/OvmfPkgIa32X64.fdf
> +++ b/OvmfPkg/OvmfPkgIa32X64.fdf
> @@ -283,6 +283,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>  INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>  
>  INF  FatPkg/EnhancedFatDxe/Fat.inf
> +!if $(UDF_ENABLE) == TRUE
> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
> +!endif
>  
>  !ifndef $(USE_OLD_SHELL)
>  INF  ShellPkg/Application/Shell/Shell.inf
> diff --git a/OvmfPkg/OvmfPkgX64.dsc b/OvmfPkg/OvmfPkgX64.dsc
> index c0bd5d0ea6..a25d8b1e99 100644
> --- a/OvmfPkg/OvmfPkgX64.dsc
> +++ b/OvmfPkg/OvmfPkgX64.dsc
> @@ -39,6 +39,7 @@
>    DEFINE HTTP_BOOT_ENABLE        = FALSE
>    DEFINE SMM_REQUIRE             = FALSE
>    DEFINE TLS_ENABLE              = FALSE
> +  DEFINE UDF_ENABLE              = FALSE
>  
>    #
>    # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
> @@ -414,6 +415,9 @@
>    gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>    gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>  !endif
> +!if $(UDF_ENABLE) == TRUE
> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
> +!endif
>  
>  [PcdsFixedAtBuild]
>    gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
> @@ -692,6 +696,9 @@
>    MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>    MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>    FatPkg/EnhancedFatDxe/Fat.inf
> +!if $(UDF_ENABLE) == TRUE
> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
> +!endif
>    MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>    MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>    OvmfPkg/SataControllerDxe/SataControllerDxe.inf
> diff --git a/OvmfPkg/OvmfPkgX64.fdf b/OvmfPkg/OvmfPkgX64.fdf
> index 98a0cf17da..8ae591c1f5 100644
> --- a/OvmfPkg/OvmfPkgX64.fdf
> +++ b/OvmfPkg/OvmfPkgX64.fdf
> @@ -283,6 +283,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>  INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>  
>  INF  FatPkg/EnhancedFatDxe/Fat.inf
> +!if $(UDF_ENABLE) == TRUE
> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
> +!endif
>  
>  !ifndef $(USE_OLD_SHELL)
>  INF  ShellPkg/Application/Shell/Shell.inf
> 



^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 0/4] read-only UDF file system support
  2017-08-09  6:05   ` Ni, Ruiyu
@ 2017-08-09 13:26     ` Paulo Alcantara
  2017-08-09 14:01       ` Paulo Alcantara
  0 siblings, 1 reply; 17+ messages in thread
From: Paulo Alcantara @ 2017-08-09 13:26 UTC (permalink / raw)
  To: Ni, Ruiyu, Zeng, Star, edk2-devel@lists.01.org
  Cc: Laszlo Ersek, Justen, Jordan L, Andrew Fish, Kinney, Michael D,
	Gao, Liming, Dong, Eric, Doran, Mark, Wu, Hao A

Hi Ray,

Thanks for the review. My comments below.

On 8/9/2017 3:05 AM, Ni, Ruiyu wrote:
> Paulo,
> Thanks for enabling the UDF support into EDKII.
> Below are several comments:
> 1. Could you please separate the patch to modify MdePkg and MdeModulePkg?

Sure.

> 2. UDF_CDROM_VOLUME_IDENTIFIER is also defined in Eltorito.h as CDVOL_ID.
>       Maybe we could redefine CDVOL_ID to UDF_CDROM_VOLUME_IDENTIFIER?

The Volume Identifier structure is defined in ECMA-167 specification 
(not UDF specific), so perhaps it would be better if we create a 
separate header file (e.g., Ecma-167.h) and define 
ECMA167_VOLUME_IDENTIFIER structure. That would be used in both ElTorito 
and UDF codes. What do you think?

> 
> 2. Why do you need a PCD to control the UDF support? I prefer no. More choices
>       is not always good😊

The original idea of including this PCD was to avoid adding unnecessary 
overhead in PartitionDxe driver to something (UDF) that wasn't actually 
defined in UEFI specification -- leaving it as an optional feature.

But yes, I agree with you that just complicates things and would be 
better to remove it.

> 
> 3.  Is gUdfVolumeSignatureGuid only used in Partition driver to produce the device
>        path? Can we just use HARDDRIVE_DEVICE_PATH? Or at least gUdfVolumeSignatureGuid
>        can be removed, the GUID macro is enough?
> 
> 4.  Have you verified on a CDROM which contains both ElTorito and CDFS?

In the past I tested it with some Windows 8 and 10 ISO images I grabbed 
somewhere (both had ISO9660 & ElTorito's boot catalogs) but I haven't 
verified if it *still* works with them, yet. I'll do it when I get a chance.

Thanks,
Paulo


^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 4/4] OvmfPkg: Introduce UDF_ENABLE build flag
  2017-08-09  9:44   ` Laszlo Ersek
@ 2017-08-09 13:38     ` Paulo Alcantara
  2017-08-09 15:45     ` Andrew Fish
  1 sibling, 0 replies; 17+ messages in thread
From: Paulo Alcantara @ 2017-08-09 13:38 UTC (permalink / raw)
  To: Laszlo Ersek; +Cc: edk2-devel, Jordan Justen, Ard Biesheuvel, Andrew Fish

Hi,

On 8/9/2017 6:44 AM, Laszlo Ersek wrote:
> CC Ard and Andrew
> 
> On 08/08/17 21:31, Paulo Alcantara wrote:
>> By defining this build flag, OVMF will support booting from UDF file
>> systems.
>>
>> Cc: Jordan Justen <jordan.l.justen@intel.com>
>> Cc: Laszlo Ersek <lersek@redhat.com>
>> Contributed-under: TianoCore Contribution Agreement 1.1
>> Signed-off-by: Paulo Alcantara <pcacjr@zytor.com>
>> ---
>>   OvmfPkg/OvmfPkgIa32.dsc    | 7 +++++++
>>   OvmfPkg/OvmfPkgIa32.fdf    | 3 +++
>>   OvmfPkg/OvmfPkgIa32X64.dsc | 7 +++++++
>>   OvmfPkg/OvmfPkgIa32X64.fdf | 3 +++
>>   OvmfPkg/OvmfPkgX64.dsc     | 7 +++++++
>>   OvmfPkg/OvmfPkgX64.fdf     | 3 +++
>>   6 files changed, 30 insertions(+)
> 
> Ray already mentioned that PcdUdfFileSystemSupport is not needed. I
> agree. Similarly, I think UDF_ENABLE is also not needed, the new driver
> should be added to the DSC and FDF files right after "Fat.inf" (like you
> are doing it now, just unconditionally).

OK - I'll send a v2 as soon as I can with its removal.

> 
> Furthermore, can you please do the same in the ArmVirtPkg DSC and FDF
> files? (Just grep the tree for "Fat.inf".) EmulatorPkg and Nt32Pkg are
> further emulation platforms that might want to include this.

Sure. That'd be great if someone could help me testing on those 
platforms. I'll try to set up an environment and then test it on them.

> Paulo, I'll check if I can test your driver with some 3rd party media
> (i.e., a DVD image that I don't prepare myself).

Thanks!

Paulo


^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 0/4] read-only UDF file system support
  2017-08-09 13:26     ` Paulo Alcantara
@ 2017-08-09 14:01       ` Paulo Alcantara
  2017-08-10  1:11         ` Ni, Ruiyu
  0 siblings, 1 reply; 17+ messages in thread
From: Paulo Alcantara @ 2017-08-09 14:01 UTC (permalink / raw)
  To: Ni, Ruiyu, Zeng, Star, edk2-devel@lists.01.org
  Cc: Dong, Eric, Wu, Hao A, Justen, Jordan L, Andrew Fish, Gao, Liming,
	Kinney, Michael D, Laszlo Ersek

(heh - forgot to answer your question about the GUID :-) )

On 8/9/2017 10:26 AM, Paulo Alcantara wrote:
> Hi Ray,
> 
> Thanks for the review. My comments below.
> 
> On 8/9/2017 3:05 AM, Ni, Ruiyu wrote:
>> Paulo,
>> Thanks for enabling the UDF support into EDKII.
>> Below are several comments:
>> 1. Could you please separate the patch to modify MdePkg and MdeModulePkg?
> 
> Sure.
> 
>> 2. UDF_CDROM_VOLUME_IDENTIFIER is also defined in Eltorito.h as CDVOL_ID.
>>       Maybe we could redefine CDVOL_ID to UDF_CDROM_VOLUME_IDENTIFIER?
> 
> The Volume Identifier structure is defined in ECMA-167 specification 
> (not UDF specific), so perhaps it would be better if we create a 
> separate header file (e.g., Ecma-167.h) and define 
> ECMA167_VOLUME_IDENTIFIER structure. That would be used in both ElTorito 
> and UDF codes. What do you think?
> 
>>
>> 2. Why do you need a PCD to control the UDF support? I prefer no. More 
>> choices
>>       is not always good😊
> 
> The original idea of including this PCD was to avoid adding unnecessary 
> overhead in PartitionDxe driver to something (UDF) that wasn't actually 
> defined in UEFI specification -- leaving it as an optional feature.
> 
> But yes, I agree with you that just complicates things and would be 
> better to remove it.
> 
>>
>> 3.  Is gUdfVolumeSignatureGuid only used in Partition driver to 
>> produce the device
>>        path? Can we just use HARDDRIVE_DEVICE_PATH? Or at least 
>> gUdfVolumeSignatureGuid
>>        can be removed, the GUID macro is enough?

The GUID is used in both Partition and UdfDxe drivers. Do you mean that 
we should use HARDDRIVE_DEVICE_PATH and then appending the UDF-specific 
GUID to it?

Thanks,
Paulo


^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 4/4] OvmfPkg: Introduce UDF_ENABLE build flag
  2017-08-09  9:44   ` Laszlo Ersek
  2017-08-09 13:38     ` Paulo Alcantara
@ 2017-08-09 15:45     ` Andrew Fish
  2017-08-09 17:33       ` Laszlo Ersek
  1 sibling, 1 reply; 17+ messages in thread
From: Andrew Fish @ 2017-08-09 15:45 UTC (permalink / raw)
  To: Laszlo Ersek; +Cc: Paulo Alcantara, Jordan Justen, edk2-devel, Ard Biesheuvel


> On Aug 9, 2017, at 2:44 AM, Laszlo Ersek <lersek@redhat.com> wrote:
> 
> CC Ard and Andrew
> 
> On 08/08/17 21:31, Paulo Alcantara wrote:
>> By defining this build flag, OVMF will support booting from UDF file
>> systems.
>> 
>> Cc: Jordan Justen <jordan.l.justen@intel.com>
>> Cc: Laszlo Ersek <lersek@redhat.com>
>> Contributed-under: TianoCore Contribution Agreement 1.1
>> Signed-off-by: Paulo Alcantara <pcacjr@zytor.com>
>> ---
>> OvmfPkg/OvmfPkgIa32.dsc    | 7 +++++++
>> OvmfPkg/OvmfPkgIa32.fdf    | 3 +++
>> OvmfPkg/OvmfPkgIa32X64.dsc | 7 +++++++
>> OvmfPkg/OvmfPkgIa32X64.fdf | 3 +++
>> OvmfPkg/OvmfPkgX64.dsc     | 7 +++++++
>> OvmfPkg/OvmfPkgX64.fdf     | 3 +++
>> 6 files changed, 30 insertions(+)
> 
> Ray already mentioned that PcdUdfFileSystemSupport is not needed. I
> agree. Similarly, I think UDF_ENABLE is also not needed, the new driver
> should be added to the DSC and FDF files right after "Fat.inf" (like you
> are doing it now, just unconditionally).
> 
> Furthermore, can you please do the same in the ArmVirtPkg DSC and FDF
> files? (Just grep the tree for "Fat.inf".) EmulatorPkg and Nt32Pkg are
> further emulation platforms that might want to include this.
> 
> My reason for suggesting the unconditional inclusion is the following
> sentence from the UEFI 2.7 spec:
> 
>  13 Protocols — Media Access
>  13.3 File System Format
>  13.3.2 Partition Discovery
>  13.3.2.1 ISO-9660 and El Torito
> 
>  [...] DVD-ROM images formatted as required by the UDF 2.0
>  specification (OSTA Universal Disk Format Specification, Revision 2.0)
>  can be booted by EFI. [...]
> 
> It does not say "may be bootable", it says "can be booted".
> 
> It would be interesting to see the Mantis ticket (if any) that got this
> language into the spec, without the edk2 reference implementation
> providing a UDF driver.
> - Using the Mantis simple search function, "UDF" brings up nothing.
> - From some googling, this sentence appears to go back to EFI 1.10 at
>  the least.
> 
> Andrew, do you remember the history of the quoted sentence?
> 

UDF defines a "UDF Bridge" disk that is "El Torito" compatible. So UDF punted on boot ability by allowing compatibility with CD-ROMs. 

 EFI supports booting from an ISO-9660 file system that conforms to the “El Torito” Bootable CD-ROM Format Specification on a DVD- ROM. A DVD-ROM that contains an ISO-9660 file system is defined as a “UDF Bridge” disk. Booting from CD-ROM and DVD-ROM is accomplished using the same methods.

I'm fine with adding a UDF file system driver, but it is not required from a UEFI Spec conformance point of view. 

Thanks,

Andrew Fish

PS "El Torito" was the restaurant that Curtis and Stan wrote out the proposal on a napkin. Luckily device paths are not called "House of Teriyaki", or even worse the nickname "rats and rice".  

> Paulo, I'll check if I can test your driver with some 3rd party media
> (i.e., a DVD image that I don't prepare myself).
> 
> Thank you!
> Laszlo
> 
>> 
>> diff --git a/OvmfPkg/OvmfPkgIa32.dsc b/OvmfPkg/OvmfPkgIa32.dsc
>> index 5a14325f73..c71c332efd 100644
>> --- a/OvmfPkg/OvmfPkgIa32.dsc
>> +++ b/OvmfPkg/OvmfPkgIa32.dsc
>> @@ -39,6 +39,7 @@
>>   DEFINE HTTP_BOOT_ENABLE        = FALSE
>>   DEFINE SMM_REQUIRE             = FALSE
>>   DEFINE TLS_ENABLE              = FALSE
>> +  DEFINE UDF_ENABLE              = FALSE
>> 
>>   #
>>   # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
>> @@ -409,6 +410,9 @@
>>   gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>>   gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>> !endif
>> +!if $(UDF_ENABLE) == TRUE
>> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
>> +!endif
>> 
>> [PcdsFixedAtBuild]
>>   gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
>> @@ -685,6 +689,9 @@
>>   MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>>   MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>>   FatPkg/EnhancedFatDxe/Fat.inf
>> +!if $(UDF_ENABLE) == TRUE
>> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>> +!endif
>>   MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>>   MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>>   OvmfPkg/SataControllerDxe/SataControllerDxe.inf
>> diff --git a/OvmfPkg/OvmfPkgIa32.fdf b/OvmfPkg/OvmfPkgIa32.fdf
>> index 5e5ade2a1f..2da1fcbe1f 100644
>> --- a/OvmfPkg/OvmfPkgIa32.fdf
>> +++ b/OvmfPkg/OvmfPkgIa32.fdf
>> @@ -282,6 +282,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>> INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>> 
>> INF  FatPkg/EnhancedFatDxe/Fat.inf
>> +!if $(UDF_ENABLE) == TRUE
>> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>> +!endif
>> 
>> !ifndef $(USE_OLD_SHELL)
>> INF  ShellPkg/Application/Shell/Shell.inf
>> diff --git a/OvmfPkg/OvmfPkgIa32X64.dsc b/OvmfPkg/OvmfPkgIa32X64.dsc
>> index 2f17a70db8..d0785cca13 100644
>> --- a/OvmfPkg/OvmfPkgIa32X64.dsc
>> +++ b/OvmfPkg/OvmfPkgIa32X64.dsc
>> @@ -39,6 +39,7 @@
>>   DEFINE HTTP_BOOT_ENABLE        = FALSE
>>   DEFINE SMM_REQUIRE             = FALSE
>>   DEFINE TLS_ENABLE              = FALSE
>> +  DEFINE UDF_ENABLE              = FALSE
>> 
>>   #
>>   # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
>> @@ -414,6 +415,9 @@
>>   gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>>   gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>> !endif
>> +!if $(UDF_ENABLE) == TRUE
>> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
>> +!endif
>> 
>> [PcdsFixedAtBuild]
>>   gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
>> @@ -694,6 +698,9 @@
>>   MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>>   MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>>   FatPkg/EnhancedFatDxe/Fat.inf
>> +!if $(UDF_ENABLE) == TRUE
>> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>> +!endif
>>   MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>>   MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>>   OvmfPkg/SataControllerDxe/SataControllerDxe.inf
>> diff --git a/OvmfPkg/OvmfPkgIa32X64.fdf b/OvmfPkg/OvmfPkgIa32X64.fdf
>> index aa0d8c69f3..0fdd359051 100644
>> --- a/OvmfPkg/OvmfPkgIa32X64.fdf
>> +++ b/OvmfPkg/OvmfPkgIa32X64.fdf
>> @@ -283,6 +283,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>> INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>> 
>> INF  FatPkg/EnhancedFatDxe/Fat.inf
>> +!if $(UDF_ENABLE) == TRUE
>> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>> +!endif
>> 
>> !ifndef $(USE_OLD_SHELL)
>> INF  ShellPkg/Application/Shell/Shell.inf
>> diff --git a/OvmfPkg/OvmfPkgX64.dsc b/OvmfPkg/OvmfPkgX64.dsc
>> index c0bd5d0ea6..a25d8b1e99 100644
>> --- a/OvmfPkg/OvmfPkgX64.dsc
>> +++ b/OvmfPkg/OvmfPkgX64.dsc
>> @@ -39,6 +39,7 @@
>>   DEFINE HTTP_BOOT_ENABLE        = FALSE
>>   DEFINE SMM_REQUIRE             = FALSE
>>   DEFINE TLS_ENABLE              = FALSE
>> +  DEFINE UDF_ENABLE              = FALSE
>> 
>>   #
>>   # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
>> @@ -414,6 +415,9 @@
>>   gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>>   gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>> !endif
>> +!if $(UDF_ENABLE) == TRUE
>> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
>> +!endif
>> 
>> [PcdsFixedAtBuild]
>>   gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
>> @@ -692,6 +696,9 @@
>>   MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>>   MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>>   FatPkg/EnhancedFatDxe/Fat.inf
>> +!if $(UDF_ENABLE) == TRUE
>> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>> +!endif
>>   MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>>   MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>>   OvmfPkg/SataControllerDxe/SataControllerDxe.inf
>> diff --git a/OvmfPkg/OvmfPkgX64.fdf b/OvmfPkg/OvmfPkgX64.fdf
>> index 98a0cf17da..8ae591c1f5 100644
>> --- a/OvmfPkg/OvmfPkgX64.fdf
>> +++ b/OvmfPkg/OvmfPkgX64.fdf
>> @@ -283,6 +283,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>> INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>> 
>> INF  FatPkg/EnhancedFatDxe/Fat.inf
>> +!if $(UDF_ENABLE) == TRUE
>> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>> +!endif
>> 
>> !ifndef $(USE_OLD_SHELL)
>> INF  ShellPkg/Application/Shell/Shell.inf
>> 
> 
> _______________________________________________
> edk2-devel mailing list
> edk2-devel@lists.01.org
> https://lists.01.org/mailman/listinfo/edk2-devel



^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 4/4] OvmfPkg: Introduce UDF_ENABLE build flag
  2017-08-09 15:45     ` Andrew Fish
@ 2017-08-09 17:33       ` Laszlo Ersek
  2017-08-09 17:51         ` Andrew Fish
  0 siblings, 1 reply; 17+ messages in thread
From: Laszlo Ersek @ 2017-08-09 17:33 UTC (permalink / raw)
  To: Andrew Fish; +Cc: Paulo Alcantara, Jordan Justen, edk2-devel, Ard Biesheuvel

On 08/09/17 17:45, Andrew Fish wrote:
> 
>> On Aug 9, 2017, at 2:44 AM, Laszlo Ersek <lersek@redhat.com> wrote:
>>
>> CC Ard and Andrew
>>
>> On 08/08/17 21:31, Paulo Alcantara wrote:
>>> By defining this build flag, OVMF will support booting from UDF file
>>> systems.
>>>
>>> Cc: Jordan Justen <jordan.l.justen@intel.com>
>>> Cc: Laszlo Ersek <lersek@redhat.com>
>>> Contributed-under: TianoCore Contribution Agreement 1.1
>>> Signed-off-by: Paulo Alcantara <pcacjr@zytor.com>
>>> ---
>>> OvmfPkg/OvmfPkgIa32.dsc    | 7 +++++++
>>> OvmfPkg/OvmfPkgIa32.fdf    | 3 +++
>>> OvmfPkg/OvmfPkgIa32X64.dsc | 7 +++++++
>>> OvmfPkg/OvmfPkgIa32X64.fdf | 3 +++
>>> OvmfPkg/OvmfPkgX64.dsc     | 7 +++++++
>>> OvmfPkg/OvmfPkgX64.fdf     | 3 +++
>>> 6 files changed, 30 insertions(+)
>>
>> Ray already mentioned that PcdUdfFileSystemSupport is not needed. I
>> agree. Similarly, I think UDF_ENABLE is also not needed, the new driver
>> should be added to the DSC and FDF files right after "Fat.inf" (like you
>> are doing it now, just unconditionally).
>>
>> Furthermore, can you please do the same in the ArmVirtPkg DSC and FDF
>> files? (Just grep the tree for "Fat.inf".) EmulatorPkg and Nt32Pkg are
>> further emulation platforms that might want to include this.
>>
>> My reason for suggesting the unconditional inclusion is the following
>> sentence from the UEFI 2.7 spec:
>>
>>  13 Protocols — Media Access
>>  13.3 File System Format
>>  13.3.2 Partition Discovery
>>  13.3.2.1 ISO-9660 and El Torito
>>
>>  [...] DVD-ROM images formatted as required by the UDF 2.0
>>  specification (OSTA Universal Disk Format Specification, Revision 2.0)
>>  can be booted by EFI. [...]
>>
>> It does not say "may be bootable", it says "can be booted".
>>
>> It would be interesting to see the Mantis ticket (if any) that got this
>> language into the spec, without the edk2 reference implementation
>> providing a UDF driver.
>> - Using the Mantis simple search function, "UDF" brings up nothing.
>> - From some googling, this sentence appears to go back to EFI 1.10 at
>>  the least.
>>
>> Andrew, do you remember the history of the quoted sentence?
>>
> 
> UDF defines a "UDF Bridge" disk that is "El Torito" compatible. So UDF punted on boot ability by allowing compatibility with CD-ROMs. 
> 
>  EFI supports booting from an ISO-9660 file system that conforms to the “El Torito” Bootable CD-ROM Format Specification on a DVD- ROM. A DVD-ROM that contains an ISO-9660 file system is defined as a “UDF Bridge” disk. Booting from CD-ROM and DVD-ROM is accomplished using the same methods.
> 
> I'm fine with adding a UDF file system driver, but it is not required from a UEFI Spec conformance point of view.

But the one sentence that I quoted above (from the spec) gives rise to
this exact impression:

  [...] DVD-ROM images formatted as required by the UDF 2.0
  specification (OSTA Universal Disk Format Specification, Revision 2.0)
  can be booted by EFI. [...]

Yes, it goes on to talk about "UDF Bridge", but this sentence per se
seems to require booting UDF optical media. The next sentence ("EFI
supports booting from an ISO-9660 file system...") does not start with
"Namely,".

So is this a spec bug?

I'd like to clarify this, because the intent of the above phrase
determines whether:
- edk2, as-is, conforms or does not conform to that passage of the spec,
- optical media that is formatted with UDF (and no ISO9660/ElTorito
  compat) qualifies as EFI-compatible (that edk2 currently cannot boot).

Could you recommend improved wording for the spec? I'd be happy to file
a Mantis item on your behalf.

Thanks,
Laszlo

> 
> Thanks,
> 
> Andrew Fish
> 
> PS "El Torito" was the restaurant that Curtis and Stan wrote out the proposal on a napkin. Luckily device paths are not called "House of Teriyaki", or even worse the nickname "rats and rice".  
> 
>> Paulo, I'll check if I can test your driver with some 3rd party media
>> (i.e., a DVD image that I don't prepare myself).
>>
>> Thank you!
>> Laszlo
>>
>>>
>>> diff --git a/OvmfPkg/OvmfPkgIa32.dsc b/OvmfPkg/OvmfPkgIa32.dsc
>>> index 5a14325f73..c71c332efd 100644
>>> --- a/OvmfPkg/OvmfPkgIa32.dsc
>>> +++ b/OvmfPkg/OvmfPkgIa32.dsc
>>> @@ -39,6 +39,7 @@
>>>   DEFINE HTTP_BOOT_ENABLE        = FALSE
>>>   DEFINE SMM_REQUIRE             = FALSE
>>>   DEFINE TLS_ENABLE              = FALSE
>>> +  DEFINE UDF_ENABLE              = FALSE
>>>
>>>   #
>>>   # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
>>> @@ -409,6 +410,9 @@
>>>   gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>>>   gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>>> !endif
>>> +!if $(UDF_ENABLE) == TRUE
>>> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
>>> +!endif
>>>
>>> [PcdsFixedAtBuild]
>>>   gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
>>> @@ -685,6 +689,9 @@
>>>   MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>>>   MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>>>   FatPkg/EnhancedFatDxe/Fat.inf
>>> +!if $(UDF_ENABLE) == TRUE
>>> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>> +!endif
>>>   MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>>>   MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>>>   OvmfPkg/SataControllerDxe/SataControllerDxe.inf
>>> diff --git a/OvmfPkg/OvmfPkgIa32.fdf b/OvmfPkg/OvmfPkgIa32.fdf
>>> index 5e5ade2a1f..2da1fcbe1f 100644
>>> --- a/OvmfPkg/OvmfPkgIa32.fdf
>>> +++ b/OvmfPkg/OvmfPkgIa32.fdf
>>> @@ -282,6 +282,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>>> INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>>>
>>> INF  FatPkg/EnhancedFatDxe/Fat.inf
>>> +!if $(UDF_ENABLE) == TRUE
>>> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>> +!endif
>>>
>>> !ifndef $(USE_OLD_SHELL)
>>> INF  ShellPkg/Application/Shell/Shell.inf
>>> diff --git a/OvmfPkg/OvmfPkgIa32X64.dsc b/OvmfPkg/OvmfPkgIa32X64.dsc
>>> index 2f17a70db8..d0785cca13 100644
>>> --- a/OvmfPkg/OvmfPkgIa32X64.dsc
>>> +++ b/OvmfPkg/OvmfPkgIa32X64.dsc
>>> @@ -39,6 +39,7 @@
>>>   DEFINE HTTP_BOOT_ENABLE        = FALSE
>>>   DEFINE SMM_REQUIRE             = FALSE
>>>   DEFINE TLS_ENABLE              = FALSE
>>> +  DEFINE UDF_ENABLE              = FALSE
>>>
>>>   #
>>>   # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
>>> @@ -414,6 +415,9 @@
>>>   gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>>>   gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>>> !endif
>>> +!if $(UDF_ENABLE) == TRUE
>>> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
>>> +!endif
>>>
>>> [PcdsFixedAtBuild]
>>>   gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
>>> @@ -694,6 +698,9 @@
>>>   MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>>>   MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>>>   FatPkg/EnhancedFatDxe/Fat.inf
>>> +!if $(UDF_ENABLE) == TRUE
>>> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>> +!endif
>>>   MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>>>   MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>>>   OvmfPkg/SataControllerDxe/SataControllerDxe.inf
>>> diff --git a/OvmfPkg/OvmfPkgIa32X64.fdf b/OvmfPkg/OvmfPkgIa32X64.fdf
>>> index aa0d8c69f3..0fdd359051 100644
>>> --- a/OvmfPkg/OvmfPkgIa32X64.fdf
>>> +++ b/OvmfPkg/OvmfPkgIa32X64.fdf
>>> @@ -283,6 +283,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>>> INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>>>
>>> INF  FatPkg/EnhancedFatDxe/Fat.inf
>>> +!if $(UDF_ENABLE) == TRUE
>>> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>> +!endif
>>>
>>> !ifndef $(USE_OLD_SHELL)
>>> INF  ShellPkg/Application/Shell/Shell.inf
>>> diff --git a/OvmfPkg/OvmfPkgX64.dsc b/OvmfPkg/OvmfPkgX64.dsc
>>> index c0bd5d0ea6..a25d8b1e99 100644
>>> --- a/OvmfPkg/OvmfPkgX64.dsc
>>> +++ b/OvmfPkg/OvmfPkgX64.dsc
>>> @@ -39,6 +39,7 @@
>>>   DEFINE HTTP_BOOT_ENABLE        = FALSE
>>>   DEFINE SMM_REQUIRE             = FALSE
>>>   DEFINE TLS_ENABLE              = FALSE
>>> +  DEFINE UDF_ENABLE              = FALSE
>>>
>>>   #
>>>   # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
>>> @@ -414,6 +415,9 @@
>>>   gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>>>   gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>>> !endif
>>> +!if $(UDF_ENABLE) == TRUE
>>> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
>>> +!endif
>>>
>>> [PcdsFixedAtBuild]
>>>   gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
>>> @@ -692,6 +696,9 @@
>>>   MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>>>   MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>>>   FatPkg/EnhancedFatDxe/Fat.inf
>>> +!if $(UDF_ENABLE) == TRUE
>>> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>> +!endif
>>>   MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>>>   MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>>>   OvmfPkg/SataControllerDxe/SataControllerDxe.inf
>>> diff --git a/OvmfPkg/OvmfPkgX64.fdf b/OvmfPkg/OvmfPkgX64.fdf
>>> index 98a0cf17da..8ae591c1f5 100644
>>> --- a/OvmfPkg/OvmfPkgX64.fdf
>>> +++ b/OvmfPkg/OvmfPkgX64.fdf
>>> @@ -283,6 +283,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>>> INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>>>
>>> INF  FatPkg/EnhancedFatDxe/Fat.inf
>>> +!if $(UDF_ENABLE) == TRUE
>>> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>> +!endif
>>>
>>> !ifndef $(USE_OLD_SHELL)
>>> INF  ShellPkg/Application/Shell/Shell.inf
>>>
>>
>> _______________________________________________
>> edk2-devel mailing list
>> edk2-devel@lists.01.org
>> https://lists.01.org/mailman/listinfo/edk2-devel
> 
> 



^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 4/4] OvmfPkg: Introduce UDF_ENABLE build flag
  2017-08-09 17:33       ` Laszlo Ersek
@ 2017-08-09 17:51         ` Andrew Fish
  2017-08-10  9:28           ` Laszlo Ersek
  0 siblings, 1 reply; 17+ messages in thread
From: Andrew Fish @ 2017-08-09 17:51 UTC (permalink / raw)
  To: Laszlo Ersek; +Cc: Paulo Alcantara, Jordan Justen, edk2-devel, Ard Biesheuvel


> On Aug 9, 2017, at 10:33 AM, Laszlo Ersek <lersek@redhat.com> wrote:
> 
> On 08/09/17 17:45, Andrew Fish wrote:
>> 
>>> On Aug 9, 2017, at 2:44 AM, Laszlo Ersek <lersek@redhat.com> wrote:
>>> 
>>> CC Ard and Andrew
>>> 
>>> On 08/08/17 21:31, Paulo Alcantara wrote:
>>>> By defining this build flag, OVMF will support booting from UDF file
>>>> systems.
>>>> 
>>>> Cc: Jordan Justen <jordan.l.justen@intel.com>
>>>> Cc: Laszlo Ersek <lersek@redhat.com>
>>>> Contributed-under: TianoCore Contribution Agreement 1.1
>>>> Signed-off-by: Paulo Alcantara <pcacjr@zytor.com>
>>>> ---
>>>> OvmfPkg/OvmfPkgIa32.dsc    | 7 +++++++
>>>> OvmfPkg/OvmfPkgIa32.fdf    | 3 +++
>>>> OvmfPkg/OvmfPkgIa32X64.dsc | 7 +++++++
>>>> OvmfPkg/OvmfPkgIa32X64.fdf | 3 +++
>>>> OvmfPkg/OvmfPkgX64.dsc     | 7 +++++++
>>>> OvmfPkg/OvmfPkgX64.fdf     | 3 +++
>>>> 6 files changed, 30 insertions(+)
>>> 
>>> Ray already mentioned that PcdUdfFileSystemSupport is not needed. I
>>> agree. Similarly, I think UDF_ENABLE is also not needed, the new driver
>>> should be added to the DSC and FDF files right after "Fat.inf" (like you
>>> are doing it now, just unconditionally).
>>> 
>>> Furthermore, can you please do the same in the ArmVirtPkg DSC and FDF
>>> files? (Just grep the tree for "Fat.inf".) EmulatorPkg and Nt32Pkg are
>>> further emulation platforms that might want to include this.
>>> 
>>> My reason for suggesting the unconditional inclusion is the following
>>> sentence from the UEFI 2.7 spec:
>>> 
>>> 13 Protocols — Media Access
>>> 13.3 File System Format
>>> 13.3.2 Partition Discovery
>>> 13.3.2.1 ISO-9660 and El Torito
>>> 
>>> [...] DVD-ROM images formatted as required by the UDF 2.0
>>> specification (OSTA Universal Disk Format Specification, Revision 2.0)
>>> can be booted by EFI. [...]
>>> 
>>> It does not say "may be bootable", it says "can be booted".
>>> 
>>> It would be interesting to see the Mantis ticket (if any) that got this
>>> language into the spec, without the edk2 reference implementation
>>> providing a UDF driver.
>>> - Using the Mantis simple search function, "UDF" brings up nothing.
>>> - From some googling, this sentence appears to go back to EFI 1.10 at
>>> the least.
>>> 
>>> Andrew, do you remember the history of the quoted sentence?
>>> 
>> 
>> UDF defines a "UDF Bridge" disk that is "El Torito" compatible. So UDF punted on boot ability by allowing compatibility with CD-ROMs. 
>> 
>> EFI supports booting from an ISO-9660 file system that conforms to the “El Torito” Bootable CD-ROM Format Specification on a DVD- ROM. A DVD-ROM that contains an ISO-9660 file system is defined as a “UDF Bridge” disk. Booting from CD-ROM and DVD-ROM is accomplished using the same methods.
>> 
>> I'm fine with adding a UDF file system driver, but it is not required from a UEFI Spec conformance point of view.
> 
> But the one sentence that I quoted above (from the spec) gives rise to
> this exact impression:
> 
>  [...] DVD-ROM images formatted as required by the UDF 2.0
>  specification (OSTA Universal Disk Format Specification, Revision 2.0)
>  can be booted by EFI. [...]
> 
> Yes, it goes on to talk about "UDF Bridge", but this sentence per se
> seems to require booting UDF optical media. The next sentence ("EFI
> supports booting from an ISO-9660 file system...") does not start with
> "Namely,".
> 
> So is this a spec bug?
> 
> I'd like to clarify this, because the intent of the above phrase
> determines whether:
> - edk2, as-is, conforms or does not conform to that passage of the spec,
> - optical media that is formatted with UDF (and no ISO9660/ElTorito
>  compat) qualifies as EFI-compatible (that edk2 currently cannot boot).
> 
> Could you recommend improved wording for the spec? I'd be happy to file
> a Mantis item on your behalf.
> 

Sure feel free to file a mantis. I think the missing chunk of info is that the only definition of booting in the UDF spec is the "UDF Bridge" format to be compatible with El-Torito. Thus the statement is factual. I think the UDF spec basically states to be bootable it must be a UEF Bridge disk and thus be compatible with El-Torito. 

Maybe turning things around a bit helps. 

The UDF 2.0 specification (..) requires a bootable DVD-ROM be formatted as a "UDF Bridge" disk to be bootable...

Anyway feel free to start a thread on the spec mailing list.

Thanks,

Andrew Fish

> Thanks,
> Laszlo
> 
>> 
>> Thanks,
>> 
>> Andrew Fish
>> 
>> PS "El Torito" was the restaurant that Curtis and Stan wrote out the proposal on a napkin. Luckily device paths are not called "House of Teriyaki", or even worse the nickname "rats and rice".  
>> 
>>> Paulo, I'll check if I can test your driver with some 3rd party media
>>> (i.e., a DVD image that I don't prepare myself).
>>> 
>>> Thank you!
>>> Laszlo
>>> 
>>>> 
>>>> diff --git a/OvmfPkg/OvmfPkgIa32.dsc b/OvmfPkg/OvmfPkgIa32.dsc
>>>> index 5a14325f73..c71c332efd 100644
>>>> --- a/OvmfPkg/OvmfPkgIa32.dsc
>>>> +++ b/OvmfPkg/OvmfPkgIa32.dsc
>>>> @@ -39,6 +39,7 @@
>>>>  DEFINE HTTP_BOOT_ENABLE        = FALSE
>>>>  DEFINE SMM_REQUIRE             = FALSE
>>>>  DEFINE TLS_ENABLE              = FALSE
>>>> +  DEFINE UDF_ENABLE              = FALSE
>>>> 
>>>>  #
>>>>  # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
>>>> @@ -409,6 +410,9 @@
>>>>  gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>>>>  gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>>>> !endif
>>>> +!if $(UDF_ENABLE) == TRUE
>>>> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
>>>> +!endif
>>>> 
>>>> [PcdsFixedAtBuild]
>>>>  gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
>>>> @@ -685,6 +689,9 @@
>>>>  MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>>>>  MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>>>>  FatPkg/EnhancedFatDxe/Fat.inf
>>>> +!if $(UDF_ENABLE) == TRUE
>>>> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>>> +!endif
>>>>  MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>>>>  MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>>>>  OvmfPkg/SataControllerDxe/SataControllerDxe.inf
>>>> diff --git a/OvmfPkg/OvmfPkgIa32.fdf b/OvmfPkg/OvmfPkgIa32.fdf
>>>> index 5e5ade2a1f..2da1fcbe1f 100644
>>>> --- a/OvmfPkg/OvmfPkgIa32.fdf
>>>> +++ b/OvmfPkg/OvmfPkgIa32.fdf
>>>> @@ -282,6 +282,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>>>> INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>>>> 
>>>> INF  FatPkg/EnhancedFatDxe/Fat.inf
>>>> +!if $(UDF_ENABLE) == TRUE
>>>> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>>> +!endif
>>>> 
>>>> !ifndef $(USE_OLD_SHELL)
>>>> INF  ShellPkg/Application/Shell/Shell.inf
>>>> diff --git a/OvmfPkg/OvmfPkgIa32X64.dsc b/OvmfPkg/OvmfPkgIa32X64.dsc
>>>> index 2f17a70db8..d0785cca13 100644
>>>> --- a/OvmfPkg/OvmfPkgIa32X64.dsc
>>>> +++ b/OvmfPkg/OvmfPkgIa32X64.dsc
>>>> @@ -39,6 +39,7 @@
>>>>  DEFINE HTTP_BOOT_ENABLE        = FALSE
>>>>  DEFINE SMM_REQUIRE             = FALSE
>>>>  DEFINE TLS_ENABLE              = FALSE
>>>> +  DEFINE UDF_ENABLE              = FALSE
>>>> 
>>>>  #
>>>>  # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
>>>> @@ -414,6 +415,9 @@
>>>>  gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>>>>  gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>>>> !endif
>>>> +!if $(UDF_ENABLE) == TRUE
>>>> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
>>>> +!endif
>>>> 
>>>> [PcdsFixedAtBuild]
>>>>  gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
>>>> @@ -694,6 +698,9 @@
>>>>  MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>>>>  MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>>>>  FatPkg/EnhancedFatDxe/Fat.inf
>>>> +!if $(UDF_ENABLE) == TRUE
>>>> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>>> +!endif
>>>>  MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>>>>  MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>>>>  OvmfPkg/SataControllerDxe/SataControllerDxe.inf
>>>> diff --git a/OvmfPkg/OvmfPkgIa32X64.fdf b/OvmfPkg/OvmfPkgIa32X64.fdf
>>>> index aa0d8c69f3..0fdd359051 100644
>>>> --- a/OvmfPkg/OvmfPkgIa32X64.fdf
>>>> +++ b/OvmfPkg/OvmfPkgIa32X64.fdf
>>>> @@ -283,6 +283,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>>>> INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>>>> 
>>>> INF  FatPkg/EnhancedFatDxe/Fat.inf
>>>> +!if $(UDF_ENABLE) == TRUE
>>>> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>>> +!endif
>>>> 
>>>> !ifndef $(USE_OLD_SHELL)
>>>> INF  ShellPkg/Application/Shell/Shell.inf
>>>> diff --git a/OvmfPkg/OvmfPkgX64.dsc b/OvmfPkg/OvmfPkgX64.dsc
>>>> index c0bd5d0ea6..a25d8b1e99 100644
>>>> --- a/OvmfPkg/OvmfPkgX64.dsc
>>>> +++ b/OvmfPkg/OvmfPkgX64.dsc
>>>> @@ -39,6 +39,7 @@
>>>>  DEFINE HTTP_BOOT_ENABLE        = FALSE
>>>>  DEFINE SMM_REQUIRE             = FALSE
>>>>  DEFINE TLS_ENABLE              = FALSE
>>>> +  DEFINE UDF_ENABLE              = FALSE
>>>> 
>>>>  #
>>>>  # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
>>>> @@ -414,6 +415,9 @@
>>>>  gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>>>>  gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>>>> !endif
>>>> +!if $(UDF_ENABLE) == TRUE
>>>> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
>>>> +!endif
>>>> 
>>>> [PcdsFixedAtBuild]
>>>>  gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
>>>> @@ -692,6 +696,9 @@
>>>>  MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>>>>  MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>>>>  FatPkg/EnhancedFatDxe/Fat.inf
>>>> +!if $(UDF_ENABLE) == TRUE
>>>> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>>> +!endif
>>>>  MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>>>>  MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>>>>  OvmfPkg/SataControllerDxe/SataControllerDxe.inf
>>>> diff --git a/OvmfPkg/OvmfPkgX64.fdf b/OvmfPkg/OvmfPkgX64.fdf
>>>> index 98a0cf17da..8ae591c1f5 100644
>>>> --- a/OvmfPkg/OvmfPkgX64.fdf
>>>> +++ b/OvmfPkg/OvmfPkgX64.fdf
>>>> @@ -283,6 +283,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>>>> INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>>>> 
>>>> INF  FatPkg/EnhancedFatDxe/Fat.inf
>>>> +!if $(UDF_ENABLE) == TRUE
>>>> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>>> +!endif
>>>> 
>>>> !ifndef $(USE_OLD_SHELL)
>>>> INF  ShellPkg/Application/Shell/Shell.inf
>>>> 
>>> 
>>> _______________________________________________
>>> edk2-devel mailing list
>>> edk2-devel@lists.01.org
>>> https://lists.01.org/mailman/listinfo/edk2-devel



^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 0/4] read-only UDF file system support
  2017-08-09 14:01       ` Paulo Alcantara
@ 2017-08-10  1:11         ` Ni, Ruiyu
  2017-08-10 23:30           ` Paulo Alcantara
  0 siblings, 1 reply; 17+ messages in thread
From: Ni, Ruiyu @ 2017-08-10  1:11 UTC (permalink / raw)
  To: Paulo Alcantara, Zeng, Star, edk2-devel@lists.01.org
  Cc: Dong, Eric, Wu, Hao A, Justen, Jordan L, Andrew Fish, Gao, Liming,
	Kinney, Michael D, Laszlo Ersek



Regards,
Ray

>-----Original Message-----
>From: Paulo Alcantara [mailto:pcacjr@zytor.com]
>Sent: Wednesday, August 9, 2017 10:01 PM
>To: Ni, Ruiyu <ruiyu.ni@intel.com>; Zeng, Star <star.zeng@intel.com>; edk2-devel@lists.01.org
>Cc: Dong, Eric <eric.dong@intel.com>; Wu, Hao A <hao.a.wu@intel.com>; Justen, Jordan L <jordan.l.justen@intel.com>;
>Andrew Fish <afish@apple.com>; Gao, Liming <liming.gao@intel.com>; Kinney, Michael D <michael.d.kinney@intel.com>;
>Laszlo Ersek <lersek@redhat.com>
>Subject: Re: [edk2] [PATCH 0/4] read-only UDF file system support
>
>(heh - forgot to answer your question about the GUID :-) )
>
>On 8/9/2017 10:26 AM, Paulo Alcantara wrote:
>> Hi Ray,
>>
>> Thanks for the review. My comments below.
>>
>> On 8/9/2017 3:05 AM, Ni, Ruiyu wrote:
>>> Paulo,
>>> Thanks for enabling the UDF support into EDKII.
>>> Below are several comments:
>>> 1. Could you please separate the patch to modify MdePkg and MdeModulePkg?
>>
>> Sure.
>>
>>> 2. UDF_CDROM_VOLUME_IDENTIFIER is also defined in Eltorito.h as CDVOL_ID.
>>>       Maybe we could redefine CDVOL_ID to UDF_CDROM_VOLUME_IDENTIFIER?
>>
>> The Volume Identifier structure is defined in ECMA-167 specification
>> (not UDF specific), so perhaps it would be better if we create a
>> separate header file (e.g., Ecma-167.h) and define
>> ECMA167_VOLUME_IDENTIFIER structure. That would be used in both ElTorito
>> and UDF codes. What do you think?
>>
>>>
>>> 2. Why do you need a PCD to control the UDF support? I prefer no. More
>>> choices
>>>       is not always good😊
>>
>> The original idea of including this PCD was to avoid adding unnecessary
>> overhead in PartitionDxe driver to something (UDF) that wasn't actually
>> defined in UEFI specification -- leaving it as an optional feature.
>>
>> But yes, I agree with you that just complicates things and would be
>> better to remove it.
>>
>>>
>>> 3.  Is gUdfVolumeSignatureGuid only used in Partition driver to
>>> produce the device
>>>        path? Can we just use HARDDRIVE_DEVICE_PATH? Or at least
>>> gUdfVolumeSignatureGuid
>>>        can be removed, the GUID macro is enough?
>
>The GUID is used in both Partition and UdfDxe drivers. Do you mean that
>we should use HARDDRIVE_DEVICE_PATH and then appending the UDF-specific
>GUID to it?

I originally thought UdfDxe driver needs to use this GUID to know it's a UDF partition.
But later I found UdfDxe contains a function SupportUdfFileSystem() to parse the
partition content to decide whether to manage that partition.
I wasn't able to find the reference of this GUID.

I just tried again, still didn't find it. But I did find some improper implementation of
driver-model logic.
I saw UdfDxe uses OPEN_PROTOCOL_GET to open the BlockIo and DiskIo.
It should use OPEN_PROTOCOL_BY_DRIVER.
In details, it should firstly try OPEN_BY_DRIVER to open the BlockIo and DiskIo in
Supported(), when either one fails, the Supported() returns failure. But please
keep in mind to close the successfully-opened BlockIo/DiskIo. Supported() is a
test function called by DxeCore, and it should not alter the system state.
Start() should then repeat the same open logic as that in Supported(), but it's
find to use ASSERT_EFI_ERROR() to assert the return status of OPEN_BY_DRIVER
is EFI_SUCCESS because per UEFI spec, Start() should only be called when Supported()
returns EFI_SUCCESS. Start() will then install the SimpleFileSystem instance on the
same Handle that have BlockIo/DiskIo installed. (I noticed that your driver creates
a new handle for SimpleFileSystem, which is unnecessary and may break the driver
model chain.)

The OPEN_BY_DRIVER open is necessary because DxeCore driver model core logic
records the special open operation. and when BlockIo or DiskIo is uninstalled,
the Stop() function whose corresponding Start() is opening the same BlockIo/DiskIo
OPEN_BY_DRIVER will get called. So you can treat OPEN_BY_DRIVER is a mechanism
to notify the upper layer driver to destroy the newly created service(SimpleFileSystem)
when lower layer services (BlockIo/DiskIo) it layers on is destroyed (Uninstalled).

Not sure if I explained well. You could refer to
https://github.com/tianocore/tianocore.github.io/wiki/UEFI-Driver-Writer's-Guide
written by Kinney Michael for detailed instructions.


>
>Thanks,
>Paulo

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 4/4] OvmfPkg: Introduce UDF_ENABLE build flag
  2017-08-09 17:51         ` Andrew Fish
@ 2017-08-10  9:28           ` Laszlo Ersek
  0 siblings, 0 replies; 17+ messages in thread
From: Laszlo Ersek @ 2017-08-10  9:28 UTC (permalink / raw)
  To: Andrew Fish; +Cc: Jordan Justen, edk2-devel, Ard Biesheuvel

On 08/09/17 19:51, Andrew Fish wrote:
> 
>> On Aug 9, 2017, at 10:33 AM, Laszlo Ersek <lersek@redhat.com> wrote:
>>
>> On 08/09/17 17:45, Andrew Fish wrote:
>>>
>>>> On Aug 9, 2017, at 2:44 AM, Laszlo Ersek <lersek@redhat.com> wrote:
>>>>
>>>> CC Ard and Andrew
>>>>
>>>> On 08/08/17 21:31, Paulo Alcantara wrote:
>>>>> By defining this build flag, OVMF will support booting from UDF file
>>>>> systems.
>>>>>
>>>>> Cc: Jordan Justen <jordan.l.justen@intel.com>
>>>>> Cc: Laszlo Ersek <lersek@redhat.com>
>>>>> Contributed-under: TianoCore Contribution Agreement 1.1
>>>>> Signed-off-by: Paulo Alcantara <pcacjr@zytor.com>
>>>>> ---
>>>>> OvmfPkg/OvmfPkgIa32.dsc    | 7 +++++++
>>>>> OvmfPkg/OvmfPkgIa32.fdf    | 3 +++
>>>>> OvmfPkg/OvmfPkgIa32X64.dsc | 7 +++++++
>>>>> OvmfPkg/OvmfPkgIa32X64.fdf | 3 +++
>>>>> OvmfPkg/OvmfPkgX64.dsc     | 7 +++++++
>>>>> OvmfPkg/OvmfPkgX64.fdf     | 3 +++
>>>>> 6 files changed, 30 insertions(+)
>>>>
>>>> Ray already mentioned that PcdUdfFileSystemSupport is not needed. I
>>>> agree. Similarly, I think UDF_ENABLE is also not needed, the new driver
>>>> should be added to the DSC and FDF files right after "Fat.inf" (like you
>>>> are doing it now, just unconditionally).
>>>>
>>>> Furthermore, can you please do the same in the ArmVirtPkg DSC and FDF
>>>> files? (Just grep the tree for "Fat.inf".) EmulatorPkg and Nt32Pkg are
>>>> further emulation platforms that might want to include this.
>>>>
>>>> My reason for suggesting the unconditional inclusion is the following
>>>> sentence from the UEFI 2.7 spec:
>>>>
>>>> 13 Protocols — Media Access
>>>> 13.3 File System Format
>>>> 13.3.2 Partition Discovery
>>>> 13.3.2.1 ISO-9660 and El Torito
>>>>
>>>> [...] DVD-ROM images formatted as required by the UDF 2.0
>>>> specification (OSTA Universal Disk Format Specification, Revision 2.0)
>>>> can be booted by EFI. [...]
>>>>
>>>> It does not say "may be bootable", it says "can be booted".
>>>>
>>>> It would be interesting to see the Mantis ticket (if any) that got this
>>>> language into the spec, without the edk2 reference implementation
>>>> providing a UDF driver.
>>>> - Using the Mantis simple search function, "UDF" brings up nothing.
>>>> - From some googling, this sentence appears to go back to EFI 1.10 at
>>>> the least.
>>>>
>>>> Andrew, do you remember the history of the quoted sentence?
>>>>
>>>
>>> UDF defines a "UDF Bridge" disk that is "El Torito" compatible. So UDF punted on boot ability by allowing compatibility with CD-ROMs. 
>>>
>>> EFI supports booting from an ISO-9660 file system that conforms to the “El Torito” Bootable CD-ROM Format Specification on a DVD- ROM. A DVD-ROM that contains an ISO-9660 file system is defined as a “UDF Bridge” disk. Booting from CD-ROM and DVD-ROM is accomplished using the same methods.
>>>
>>> I'm fine with adding a UDF file system driver, but it is not required from a UEFI Spec conformance point of view.
>>
>> But the one sentence that I quoted above (from the spec) gives rise to
>> this exact impression:
>>
>>  [...] DVD-ROM images formatted as required by the UDF 2.0
>>  specification (OSTA Universal Disk Format Specification, Revision 2.0)
>>  can be booted by EFI. [...]
>>
>> Yes, it goes on to talk about "UDF Bridge", but this sentence per se
>> seems to require booting UDF optical media. The next sentence ("EFI
>> supports booting from an ISO-9660 file system...") does not start with
>> "Namely,".
>>
>> So is this a spec bug?
>>
>> I'd like to clarify this, because the intent of the above phrase
>> determines whether:
>> - edk2, as-is, conforms or does not conform to that passage of the spec,
>> - optical media that is formatted with UDF (and no ISO9660/ElTorito
>>  compat) qualifies as EFI-compatible (that edk2 currently cannot boot).
>>
>> Could you recommend improved wording for the spec? I'd be happy to file
>> a Mantis item on your behalf.
>>
> 
> Sure feel free to file a mantis. I think the missing chunk of info is that the only definition of booting in the UDF spec is the "UDF Bridge" format to be compatible with El-Torito. Thus the statement is factual. I think the UDF spec basically states to be bootable it must be a UEF Bridge disk and thus be compatible with El-Torito. 
> 
> Maybe turning things around a bit helps. 
> 
> The UDF 2.0 specification (..) requires a bootable DVD-ROM be formatted as a "UDF Bridge" disk to be bootable...
> 
> Anyway feel free to start a thread on the spec mailing list.

I've filed

  https://mantis.uefi.org/mantis/view.php?id=1835

Thank you for your help!
Laszlo



>>> PS "El Torito" was the restaurant that Curtis and Stan wrote out the proposal on a napkin. Luckily device paths are not called "House of Teriyaki", or even worse the nickname "rats and rice".  
>>>
>>>> Paulo, I'll check if I can test your driver with some 3rd party media
>>>> (i.e., a DVD image that I don't prepare myself).
>>>>
>>>> Thank you!
>>>> Laszlo
>>>>
>>>>>
>>>>> diff --git a/OvmfPkg/OvmfPkgIa32.dsc b/OvmfPkg/OvmfPkgIa32.dsc
>>>>> index 5a14325f73..c71c332efd 100644
>>>>> --- a/OvmfPkg/OvmfPkgIa32.dsc
>>>>> +++ b/OvmfPkg/OvmfPkgIa32.dsc
>>>>> @@ -39,6 +39,7 @@
>>>>>  DEFINE HTTP_BOOT_ENABLE        = FALSE
>>>>>  DEFINE SMM_REQUIRE             = FALSE
>>>>>  DEFINE TLS_ENABLE              = FALSE
>>>>> +  DEFINE UDF_ENABLE              = FALSE
>>>>>
>>>>>  #
>>>>>  # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
>>>>> @@ -409,6 +410,9 @@
>>>>>  gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>>>>>  gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>>>>> !endif
>>>>> +!if $(UDF_ENABLE) == TRUE
>>>>> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
>>>>> +!endif
>>>>>
>>>>> [PcdsFixedAtBuild]
>>>>>  gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
>>>>> @@ -685,6 +689,9 @@
>>>>>  MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>>>>>  MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>>>>>  FatPkg/EnhancedFatDxe/Fat.inf
>>>>> +!if $(UDF_ENABLE) == TRUE
>>>>> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>>>> +!endif
>>>>>  MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>>>>>  MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>>>>>  OvmfPkg/SataControllerDxe/SataControllerDxe.inf
>>>>> diff --git a/OvmfPkg/OvmfPkgIa32.fdf b/OvmfPkg/OvmfPkgIa32.fdf
>>>>> index 5e5ade2a1f..2da1fcbe1f 100644
>>>>> --- a/OvmfPkg/OvmfPkgIa32.fdf
>>>>> +++ b/OvmfPkg/OvmfPkgIa32.fdf
>>>>> @@ -282,6 +282,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>>>>> INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>>>>>
>>>>> INF  FatPkg/EnhancedFatDxe/Fat.inf
>>>>> +!if $(UDF_ENABLE) == TRUE
>>>>> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>>>> +!endif
>>>>>
>>>>> !ifndef $(USE_OLD_SHELL)
>>>>> INF  ShellPkg/Application/Shell/Shell.inf
>>>>> diff --git a/OvmfPkg/OvmfPkgIa32X64.dsc b/OvmfPkg/OvmfPkgIa32X64.dsc
>>>>> index 2f17a70db8..d0785cca13 100644
>>>>> --- a/OvmfPkg/OvmfPkgIa32X64.dsc
>>>>> +++ b/OvmfPkg/OvmfPkgIa32X64.dsc
>>>>> @@ -39,6 +39,7 @@
>>>>>  DEFINE HTTP_BOOT_ENABLE        = FALSE
>>>>>  DEFINE SMM_REQUIRE             = FALSE
>>>>>  DEFINE TLS_ENABLE              = FALSE
>>>>> +  DEFINE UDF_ENABLE              = FALSE
>>>>>
>>>>>  #
>>>>>  # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
>>>>> @@ -414,6 +415,9 @@
>>>>>  gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>>>>>  gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>>>>> !endif
>>>>> +!if $(UDF_ENABLE) == TRUE
>>>>> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
>>>>> +!endif
>>>>>
>>>>> [PcdsFixedAtBuild]
>>>>>  gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
>>>>> @@ -694,6 +698,9 @@
>>>>>  MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>>>>>  MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>>>>>  FatPkg/EnhancedFatDxe/Fat.inf
>>>>> +!if $(UDF_ENABLE) == TRUE
>>>>> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>>>> +!endif
>>>>>  MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>>>>>  MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>>>>>  OvmfPkg/SataControllerDxe/SataControllerDxe.inf
>>>>> diff --git a/OvmfPkg/OvmfPkgIa32X64.fdf b/OvmfPkg/OvmfPkgIa32X64.fdf
>>>>> index aa0d8c69f3..0fdd359051 100644
>>>>> --- a/OvmfPkg/OvmfPkgIa32X64.fdf
>>>>> +++ b/OvmfPkg/OvmfPkgIa32X64.fdf
>>>>> @@ -283,6 +283,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>>>>> INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>>>>>
>>>>> INF  FatPkg/EnhancedFatDxe/Fat.inf
>>>>> +!if $(UDF_ENABLE) == TRUE
>>>>> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>>>> +!endif
>>>>>
>>>>> !ifndef $(USE_OLD_SHELL)
>>>>> INF  ShellPkg/Application/Shell/Shell.inf
>>>>> diff --git a/OvmfPkg/OvmfPkgX64.dsc b/OvmfPkg/OvmfPkgX64.dsc
>>>>> index c0bd5d0ea6..a25d8b1e99 100644
>>>>> --- a/OvmfPkg/OvmfPkgX64.dsc
>>>>> +++ b/OvmfPkg/OvmfPkgX64.dsc
>>>>> @@ -39,6 +39,7 @@
>>>>>  DEFINE HTTP_BOOT_ENABLE        = FALSE
>>>>>  DEFINE SMM_REQUIRE             = FALSE
>>>>>  DEFINE TLS_ENABLE              = FALSE
>>>>> +  DEFINE UDF_ENABLE              = FALSE
>>>>>
>>>>>  #
>>>>>  # Flash size selection. Setting FD_SIZE_IN_KB on the command line directly to
>>>>> @@ -414,6 +415,9 @@
>>>>>  gUefiOvmfPkgTokenSpaceGuid.PcdSmmSmramRequire|TRUE
>>>>>  gUefiCpuPkgTokenSpaceGuid.PcdCpuSmmEnableBspElection|FALSE
>>>>> !endif
>>>>> +!if $(UDF_ENABLE) == TRUE
>>>>> +  gEfiMdeModulePkgTokenSpaceGuid.PcdUdfFileSystemSupport|TRUE
>>>>> +!endif
>>>>>
>>>>> [PcdsFixedAtBuild]
>>>>>  gEfiMdeModulePkgTokenSpaceGuid.PcdStatusCodeMemorySize|1
>>>>> @@ -692,6 +696,9 @@
>>>>>  MdeModulePkg/Universal/Disk/RamDiskDxe/RamDiskDxe.inf
>>>>>  MdeModulePkg/Universal/Disk/UnicodeCollation/EnglishDxe/EnglishDxe.inf
>>>>>  FatPkg/EnhancedFatDxe/Fat.inf
>>>>> +!if $(UDF_ENABLE) == TRUE
>>>>> +  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>>>> +!endif
>>>>>  MdeModulePkg/Bus/Scsi/ScsiBusDxe/ScsiBusDxe.inf
>>>>>  MdeModulePkg/Bus/Scsi/ScsiDiskDxe/ScsiDiskDxe.inf
>>>>>  OvmfPkg/SataControllerDxe/SataControllerDxe.inf
>>>>> diff --git a/OvmfPkg/OvmfPkgX64.fdf b/OvmfPkg/OvmfPkgX64.fdf
>>>>> index 98a0cf17da..8ae591c1f5 100644
>>>>> --- a/OvmfPkg/OvmfPkgX64.fdf
>>>>> +++ b/OvmfPkg/OvmfPkgX64.fdf
>>>>> @@ -283,6 +283,9 @@ INF  MdeModulePkg/Universal/Acpi/BootScriptExecutorDxe/BootScriptExecutorDxe.inf
>>>>> INF  MdeModulePkg/Universal/Acpi/BootGraphicsResourceTableDxe/BootGraphicsResourceTableDxe.inf
>>>>>
>>>>> INF  FatPkg/EnhancedFatDxe/Fat.inf
>>>>> +!if $(UDF_ENABLE) == TRUE
>>>>> +INF  MdeModulePkg/Universal/Disk/UdfDxe/UdfDxe.inf
>>>>> +!endif
>>>>>
>>>>> !ifndef $(USE_OLD_SHELL)
>>>>> INF  ShellPkg/Application/Shell/Shell.inf
>>>>>
>>>>
>>>> _______________________________________________
>>>> edk2-devel mailing list
>>>> edk2-devel@lists.01.org
>>>> https://lists.01.org/mailman/listinfo/edk2-devel
> 
> _______________________________________________
> edk2-devel mailing list
> edk2-devel@lists.01.org
> https://lists.01.org/mailman/listinfo/edk2-devel
> 



^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH 0/4] read-only UDF file system support
  2017-08-10  1:11         ` Ni, Ruiyu
@ 2017-08-10 23:30           ` Paulo Alcantara
  0 siblings, 0 replies; 17+ messages in thread
From: Paulo Alcantara @ 2017-08-10 23:30 UTC (permalink / raw)
  To: Ni, Ruiyu, Zeng, Star, edk2-devel@lists.01.org
  Cc: Dong, Eric, Wu, Hao A, Justen, Jordan L, Andrew Fish, Gao, Liming,
	Kinney, Michael D, Laszlo Ersek

Hi,

(sorry for the late reply)

On 09/08/2017 22:11, Ni, Ruiyu wrote:
> 
> 
> Regards,
> Ray
> 
>> -----Original Message-----
>> From: Paulo Alcantara [mailto:pcacjr@zytor.com]
>> Sent: Wednesday, August 9, 2017 10:01 PM
>> To: Ni, Ruiyu <ruiyu.ni@intel.com>; Zeng, Star <star.zeng@intel.com>; edk2-devel@lists.01.org
>> Cc: Dong, Eric <eric.dong@intel.com>; Wu, Hao A <hao.a.wu@intel.com>; Justen, Jordan L <jordan.l.justen@intel.com>;
>> Andrew Fish <afish@apple.com>; Gao, Liming <liming.gao@intel.com>; Kinney, Michael D <michael.d.kinney@intel.com>;
>> Laszlo Ersek <lersek@redhat.com>
>> Subject: Re: [edk2] [PATCH 0/4] read-only UDF file system support
>>
>> (heh - forgot to answer your question about the GUID :-) )
>>
>> On 8/9/2017 10:26 AM, Paulo Alcantara wrote:
>>> Hi Ray,
>>>
>>> Thanks for the review. My comments below.
>>>
>>> On 8/9/2017 3:05 AM, Ni, Ruiyu wrote:
>>>> Paulo,
>>>> Thanks for enabling the UDF support into EDKII.
>>>> Below are several comments:
>>>> 1. Could you please separate the patch to modify MdePkg and MdeModulePkg?
>>>
>>> Sure.
>>>
>>>> 2. UDF_CDROM_VOLUME_IDENTIFIER is also defined in Eltorito.h as CDVOL_ID.
>>>>        Maybe we could redefine CDVOL_ID to UDF_CDROM_VOLUME_IDENTIFIER?
>>>
>>> The Volume Identifier structure is defined in ECMA-167 specification
>>> (not UDF specific), so perhaps it would be better if we create a
>>> separate header file (e.g., Ecma-167.h) and define
>>> ECMA167_VOLUME_IDENTIFIER structure. That would be used in both ElTorito
>>> and UDF codes. What do you think?
>>>
>>>>
>>>> 2. Why do you need a PCD to control the UDF support? I prefer no. More
>>>> choices
>>>>        is not always good😊
>>>
>>> The original idea of including this PCD was to avoid adding unnecessary
>>> overhead in PartitionDxe driver to something (UDF) that wasn't actually
>>> defined in UEFI specification -- leaving it as an optional feature.
>>>
>>> But yes, I agree with you that just complicates things and would be
>>> better to remove it.
>>>
>>>>
>>>> 3.  Is gUdfVolumeSignatureGuid only used in Partition driver to
>>>> produce the device
>>>>         path? Can we just use HARDDRIVE_DEVICE_PATH? Or at least
>>>> gUdfVolumeSignatureGuid
>>>>         can be removed, the GUID macro is enough?
>>
>> The GUID is used in both Partition and UdfDxe drivers. Do you mean that
>> we should use HARDDRIVE_DEVICE_PATH and then appending the UDF-specific
>> GUID to it?
> 
> I originally thought UdfDxe driver needs to use this GUID to know it's a UDF partition.
> But later I found UdfDxe contains a function SupportUdfFileSystem() to parse the
> partition content to decide whether to manage that partition.
> I wasn't able to find the reference of this GUID.

Yes - you're right. I think it should just check for the installed GUID, 
indeed. So we don't have to parse and look for UDF file systems twice.

> 
> I just tried again, still didn't find it. But I did find some improper implementation of
> driver-model logic.
> I saw UdfDxe uses OPEN_PROTOCOL_GET to open the BlockIo and DiskIo.
> It should use OPEN_PROTOCOL_BY_DRIVER.
> In details, it should firstly try OPEN_BY_DRIVER to open the BlockIo and DiskIo in
> Supported(), when either one fails, the Supported() returns failure. But please
> keep in mind to close the successfully-opened BlockIo/DiskIo. Supported() is a
> test function called by DxeCore, and it should not alter the system state.
> Start() should then repeat the same open logic as that in Supported(), but it's
> find to use ASSERT_EFI_ERROR() to assert the return status of OPEN_BY_DRIVER
> is EFI_SUCCESS because per UEFI spec, Start() should only be called when Supported()
> returns EFI_SUCCESS. Start() will then install the SimpleFileSystem instance on the
> same Handle that have BlockIo/DiskIo installed. (I noticed that your driver creates
> a new handle for SimpleFileSystem, which is unnecessary and may break the driver
> model chain.)
> 
> The OPEN_BY_DRIVER open is necessary because DxeCore driver model core logic
> records the special open operation. and when BlockIo or DiskIo is uninstalled,
> the Stop() function whose corresponding Start() is opening the same BlockIo/DiskIo
> OPEN_BY_DRIVER will get called. So you can treat OPEN_BY_DRIVER is a mechanism
> to notify the upper layer driver to destroy the newly created service(SimpleFileSystem)
> when lower layer services (BlockIo/DiskIo) it layers on is destroyed (Uninstalled).
> 
> Not sure if I explained well. You could refer to
> https://github.com/tianocore/tianocore.github.io/wiki/UEFI-Driver-Writer's-Guide
> written by Kinney Michael for detailed instructions.

Good catch! You explained it very well. I'll fix that up in the next series.

Thanks!
Paulo


^ permalink raw reply	[flat|nested] 17+ messages in thread

end of thread, other threads:[~2017-08-10 23:30 UTC | newest]

Thread overview: 17+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2017-08-08 19:31 [PATCH 0/4] read-only UDF file system support Paulo Alcantara
2017-08-08 19:31 ` [PATCH 1/4] MdeModulePkg/PartitionDxe: Add UDF/ECMA-167 " Paulo Alcantara
2017-08-08 19:31 ` [PATCH 2/4] MdeModulePkg: Initial " Paulo Alcantara
2017-08-08 19:31 ` [PATCH 3/4] MdeModulePkg/UdfDxe: Add seek, read and listing support on files Paulo Alcantara
2017-08-08 19:31 ` [PATCH 4/4] OvmfPkg: Introduce UDF_ENABLE build flag Paulo Alcantara
2017-08-09  9:44   ` Laszlo Ersek
2017-08-09 13:38     ` Paulo Alcantara
2017-08-09 15:45     ` Andrew Fish
2017-08-09 17:33       ` Laszlo Ersek
2017-08-09 17:51         ` Andrew Fish
2017-08-10  9:28           ` Laszlo Ersek
2017-08-09  1:17 ` [PATCH 0/4] read-only UDF file system support Zeng, Star
2017-08-09  6:05   ` Ni, Ruiyu
2017-08-09 13:26     ` Paulo Alcantara
2017-08-09 14:01       ` Paulo Alcantara
2017-08-10  1:11         ` Ni, Ruiyu
2017-08-10 23:30           ` Paulo Alcantara

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox