pbatard/ efifs

(v1.8) 3 months ago

arm

driver

Shell

x64

qemu

aarch64

gcc

uefi

grub

efi

grub2

View on GitHub

Need help with efifs?

Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

pbatard

315 Stars

49 Forks

GNU General Public License v3.0

175 Commits

2 Opened issues

Description

EFI FileSystem drivers

Services available

Need anything else?

Contributors list

Pete Batard pbatard

# 421

Windows

sed

sha256

167 commits

Andy Vandijck andyvand

# 409,578

Shell

grub2

3 commits

Rod Smith srs5694

# 423,390

Shell

grub2

1 commit

M1cha M1cha

# 87,033

Shell

PHP

rpc-fra...

1 commit

Readme

EfiFs - EFI File System Drivers

Name: efifs
Brand: efifs
SKU: //pbatard/efifs
Rating: 2.5375 (315 reviews)

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
```
,
```
aa64
```
or
```
riscv64
```
(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-gnueabi-
```
or
```
aarch64-linux-gnu-
```
. 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
```
  ,
```
aarch64
```
  or
```
riscv64
```
  .
  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
```
VS2019
```
(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
```
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:

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).

Note however that some files (the non

grub_####

sources under

./src/

) are licensed under GPLv2+ rather than GPLv3+ and that, just like the GPLv3+ sources, we took great care of ensuring that we are fully compliant with any licensing or relicensing matters, so that they can legally be reused into GPLv2+ works.

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

sudo apt install nasm uuid-dev gcc-multilib gcc-aarch64-linux-gnu gcc-arm-linux-gnueabi gcc-riscv64-linux-gnu
git clone --recurse-submodules https://github.com/tianocore/edk2.git
cd edk2
make -C BaseTools
git clone --recurse-submodules https://github.com/pbatard/efifs.git EfiFsPkg
cd EfiFsPkg/grub
git apply ../0001-GRUB-fixes.patch
cd -
export GCC5_ARM_PREFIX=arm-linux-gnueabi-
export GCC5_AARCH64_PREFIX=aarch64-linux-gnu-
export GCC5_RISCV64_PREFIX=riscv64-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
./EfiFsPkg/set_grub_cpu.sh RISCV64
build -a RISCV64 -b RELEASE -t GCC5 -p EfiFsPkg/EfiFsPkg.dsc