efifs

by pbatard

pbatard / efifs

EFI FileSystem drivers

242 Stars 37 Forks Last release: Not found GNU General Public License v3.0 154 Commits 15 Releases

Available items

No Items, yet!

The developer of this repository has not created any items for sale yet. Need a bug fixed? Help with integration? A different license? Create a request here:

EfiFs - EFI File System Drivers

This is a GPLv3+ implementation of standalone EFI File System drivers, based on the GRUB 2.0 read-only drivers.

For additional info as well as precompiled drivers, see https://efi.akeo.ie

Requirements

  • Visual Studio 2019 (Windows) MinGW (Windows), gcc (Linux) or EDK2.
  • A git client able to initialize/update submodules
  • QEMU v2.7 or later if debugging with Visual Studio (NB: You can find QEMU Windows binaries here)

Compilation

Common

  • Fetch the git submodules with
    git submodule init
    and
    git submodule update
    .
    NOTE This only works if you cloned the directory using
    git
    .
  • Apply
    0001-GRUB-fixes.patch
    to the
    grub\
    subdirectory. This applies the changes that are required for successful compilation of GRUB.

Visual Studio (non EDK2)

  • Open the solution file and hit
    F5
    to compile and debug the default driver.

gcc (non EDK2)

  • Run
    make
    in the top directory. If needed you can also issue something like
    make ARCH= CROSS_COMPILE=
    where
     is one of 
    ia32
    ,
    x64
    ,
    arm
    or
    aa64
    (the official UEFI abbreviations for an arch, as used in
    /efi/boot/boot[ARCH].efi
    ) and
     is the one for your cross-
    compiler, such as 
    arm-linux-gnueabihf-
    . e.g.
    make ARCH=aa64 CROSS_COMPILE=aarch64-linux-gnu-

EDK2

  • Open an elevated command prompt and create a symbolic link called
    EfiFsPkg
    , inside your EDK2 directory, to the EfiFs source. On Windows, from an elevated prompt, you could run something like
    mklink /D EfiFsPkg C:\efifs
    , and on Linux
    ln -s ../efifs EfiFsPkg
    .
  • From a command prompt, set Grub to target the platform you are compiling for by invoking:
    • (Windows)
      set_grub_cpu.cmd 
    • (Linux)
      ./set_grub_cpu.sh 

      Where
       is one of 
      ia32
      ,
      x64
      ,
      arm
      or
      aarch64
      .
      Note that you MUST invoke the
      set_grub_cpu
      script every time you switch target.
  • After having invoked
    edksetup.bat
    (Windows) or
    edksetup.sh
    (Linux) run something like:
    build -a X64 -b RELEASE -t  -p EfiFsPkg/EfiFsPkg.dsc
    

    where
     is something like 
    VS2015
    (Windows) or
    GCC5
    (Linux).
    NB: To build an individual driver, such as NTFS, you can also use something like:
    build -a X64 -b RELEASE -t  -p EfiFsPkg/EfiFsPkg.dsc -m EfiFsPkg/EfiFsPkg/Ntfs.inf
    
  • Note that, provided that you cloned a recent EDK2 from git, you should be able to use
    VS2019
    as your EDK2 toolchain, including for buidling the ARM or ARM64 drivers, with something like:
    build -a AARCH64 -b RELEASE -t VS2019 -p EfiFsPkg/EfiFsPkg.dsc
    
  • A Windows script to build the drivers, using EDK2 with VS2019 is also provided as
    edk2_build_drivers.cmd
    .

Testing

If QEMU is installed, the Visual Studio solution will set up and test the drivers using QEMU (by also downloading a sample image for each target file system). Note however that VS debugging expects a 64-bit version of QEMU to be installed in

C:\Program Files\qemu\
(which you can download here). If that is not the case, you should edit
.msvc\debug.vbs
accordingly.

For testing outside of Visual Studio, make sure you have at least one disk with a target partition using the target filesystem, that is not being handled by other EFI filesystem drivers. Then boot into the EFI shell and run the following: *

load fs0:\_.efi
or wherever your driver was copied *
map -r
this should make a new
fs#
available, eg
fs2:
* You should now be able to navigate and access content (in read-only mode) * For logging output, set the
FS_LOGGING
shell variable to 1 or more * To unload use the
drivers
command, then
unload
with the driver ID

Visual Studio 2019 and ARM/ARM64 support

Please be mindful that, to enable ARM/ARM64 compilation support in Visual Studio 2019, you MUST go to the Individual components screen in the setup application and select the ARM compilers and libraries there, as they do NOT appear in the default Workloads screen:

VS2019 Individual Components

Additional Notes

This is a pure GPLv3+ implementation of EFI drivers. Great care was taken not to use any code from non GPLv3 compatible sources, such as rEFInd's

fsw_efi
(GPLv2 only) or Intel's FAT driver (requires an extra copyright notice).

Bonus: Commands to compile EfiFs using EDK2 on a vanilla Debian GNU/Linux 10.x

As root:

apt-get install nasm uuid-dev gcc-multilib gcc-aarch64-linux-gnu gcc-arm-linux-gnueabihf
cd /usr/src
git clone https://github.com/tianocore/edk2.git
git clone https://github.com/pbatard/efifs.git
cd efifs
git submodule update --init
cd grub
patch -Np1 -i ../0001-GRUB-fixes.patch
cd ../../edk2
git submodule update --init
ln -s ../efifs EfiFsPkg
make -C BaseTools
export GCC5_ARM_PREFIX=arm-linux-gnueabihf-
export GCC5_AARCH64_PREFIX=aarch64-linux-gnu-
source edksetup.sh --reconfig
./EfiFsPkg/set_grub_cpu.sh X64
build -a X64 -b RELEASE -t GCC5 -p EfiFsPkg/EfiFsPkg.dsc
./EfiFsPkg/set_grub_cpu.sh IA32
build -a IA32 -b RELEASE -t GCC5 -p EfiFsPkg/EfiFsPkg.dsc
./EfiFsPkg/set_grub_cpu.sh AARCH64
build -a AARCH64 -b RELEASE -t GCC5 -p EfiFsPkg/EfiFsPkg.dsc
./EfiFsPkg/set_grub_cpu.sh ARM
build -a ARM -b RELEASE -t GCC5 -p EfiFsPkg/EfiFsPkg.dsc

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.