a simple portable CMake-based build system for magiskboot

magiskboot itself depends on the following libraries:

1. LZMA
2. LZ4
3. bzip2
4. zlib

for build-time dependencies:

1. pkg-config
2. Clang (maybe also others, but GCC doesn't work, see this part)
3. Rust (stable channel is OK... spoiler: RUSTC_BOOTSTRAP HACK is used)
4. CMake
5. Libc++ (optional, see this part)

please make sure you have installed the above softwares before building

here are examples for some supported popular operating systems/distributions:

export PATH=/path/to/your/ondk/toolchains/rust/bin:$PATH

apt update
apt upgrade  # upgrade all existing packages (optional)
apt install build-essential liblzma liblz4 libbz2 zlib pkg-config \
            clang rust cmake ninja

sudo apt update
sudo apt upgrade  # upgrade all existing packages (optional)

# replace clang-15, libc++-15-dev, libc++abi-15-dev with
# appropriate version according to your Ubuntu release
sudo apt install build-essential lzma-dev liblzma-dev liblz4-dev libbz2-dev \
                 zlib1g-dev pkg-config clang-15 libc++-15-dev libc++abi-15-dev cmake \
                 ninja-build rustc cargo

sudo apk update
sudo apk upgrade  # upgrade all existing packages (recommended)
sudo apk add build-base linux-headers xz-dev lz4-dev bzip2-dev \
             zlib-dev pkgconf clang libc++-dev cmake \
             samurai rust cargo

sudo pacman -S --needed base-devel xz lz4 bzip2 zlib pkgconf \
                        clang libc++ cmake ninja rust

brew update
brew upgrade  # upgrade all existing packages (optional)
brew install xz lz4 pkg-config cmake ninja rust

export PATH="$(brew --prefix)/opt/llvm/bin:$PATH" CC=clang CXX=clang++

pacman -Syu  # upgrade all existing packages (optional, you may need to do this for multiple times)
pacman -S --needed base-devel pactoys
pacboy -S --needed {xz,lz4,bzip2,zlib,pkgconf,clang,cmake,libc++,ninja,rust}:p

Please refer to Magisk documentation.

For prebuilt binaries, go check GitHub Releases for selected CI builds.

First get and extract the latest source tarball (called magiskboot_<COMMIT_ID>_<VERCODE>-src.tar.xz) from Github Releases.

Or clone this repository using Git, note that cloning with --recurse-submodules is not recommended, and you should run scripts/clone_submodules.sh after clone because it skips the submodules that is not necessary for building magiskboot.

CC=clang CXX=clang++ cmake -G Ninja -B build -DCMAKE_BUILD_TYPE=Release  # configure
cmake --build build -j $(nproc)  # build
./build/magiskboot  # running
# install to system (may need sudo, to specify different install dir, set the `DESTDIR' environment variable)
cmake --install build

To produce a statically linked binary (optional), pass -DPREFER_STATIC_LINKING=ON to CMake while configuring, make sure you have the static version of the depended libraries, otherwise you'll run into configure or link errors.

You can specify extra arguments passed to Cargo by setting CMake variable CARGO_FLAGS while configuring, you can also provide an initial value of environment RUSTFLAGS by setting the corresponding CMake variable.

Note: these variables are using CMake's list syntax, not string. that is, replace all your spaces with ;, e.g. -DCARGO_FLAGS="-Z;no-index-update" instead of -DCARGO_FLAGS="-Z no-index-update"

First get a cross-compiler and likely also a Clang from somewhere (usually your distribution's package manager). If you don't have Libc++ installed for your crossed target, you could probably also try to link against Libstdc++ instead, see this part.

Install Rust using rustup and add your cross target like this: rustup target add aarch64-unknown-linux-gnu (replace aarch64-unknown-linux-gnu with the Rust target of your target platform).

If the cross Rust target can't be installed using rustup, you can still compile if you build the Rust standard library (STD) from source, to do this, pass -DRUST_BUILD_STD=ON during configuration (Note this will require Nightly Rust and the STD source code to be installed on your system).

To cross-compile, you may need a CMake toolchain file describing your target specs (for example the sysroot location, and target triplet for using Clang), the location of the cross compiler toolchain and strategy for CMake to seek for the depended libraries.

You can install the depended libraries for your cross target by using vcpkg, for example:

vcpkg install --host-triplet=arm64-linux bzip2 lz4 zlib liblzma

arm64-linux is the triplet of your cross target, pass this value to CMake using the VCPKG_TARGET_TRIPLET variable during configuration.

Set variable Rust_CARGO_TARGET to the Rust target you wanted to cross compile for, e.g. aarch64-unknown-linux-gnu (You can find them in rustc documentation).

To integrate vcpkg with CMake, pass -DCMAKE_TOOLCHAIN_FILE=/path/to/your/vcpkg/scripts/buildsystems/vcpkg.cmake to CMake, to use your toolchain file with vcpkg, set the variable VCPKG_CHAINLOAD_TOOLCHAIN_FILE to the path of your actual toolchain file.

Set LDFLAGS to " -flto" before calling CMake.

If you want to perform LTO for the Rust part at final link time, pass -DFULL_RUST_LTO=ON to CMake during configuring. (And you will need to install LLD. Note: you may need to make sure your LLVM and LLD are sharing the same LLVM version with Rust.)

A very basic shell script is provided under the scripts directory, currently the following functions are automatically tested with Github CI:

• unpack* (currently not all header versions and variants are tested)
• repack* (same as above)
• verify
• sign
• extract
• hexpatch

• cpio* (currently not widely tested on all common ramdisks)

  • cpio exists
  • cpio ls
  • cpio rm
  • cpio mkdir
  • cpio ln
  • cpio mv
  • cpio add
  • cpio extract
  • cpio test
  • cpio patch
  • cpio backup
  • cpio restore

• dtb

  • dtb print
  • dtb test
  • dtb patch

• split
• sha1
• cleanup
• compress
• decompress

# configure for only packaging source
CC=true cmake -G Ninja -B build \
    -DCMAKE_C_COMPILER_WORKS=YES -DWITHOUT_BUILD=ON
cmake --build build -t package_source  # make a source package

Make sure to pass the above flags to CMake while configuring, which will allow creating source tarball without installing the build dependencies.

you should be able to find your source package under the build folder

Please use debug builds and paste your information (like crash or error logs) in a new Issue.

If you need to build with Libstdc++ instead of Libc++, pass -DWITH_LIBCXX=OFF to CMake during configuring, also apply this patch.

Make sure you are using Clang to build. GCC doesn't work because of: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=36566

Check the version status badges at the top of README.

This project is very similiar to android-tools which just maintains a set of patches on top of a specific upstream Magisk commit and require manual adaption for compiling with newer source.

Although I may update the version once in a while, Pull requests are welcome.

This project aims to be portable, it should be possible to port it to new platforms with some efforts, as long as your platform meets the the above requirements.

Feel free to add an Issue about support on your new platform.

To quickly discard the current build directory and dirty vendored submodule (src/) changes, please run make clean.

If you are building directly from the Git source tree, all the patches under the patches/ directory will be automatically applied on the first configure. After that a flag file called .mbb_patched is created under your build directory (i.e. build/).

Removing the flag file and re-configure will discard any dirty changes in vendored projects, and re-apply all the patches to them again.

To avoid applying any patch at configure time, create the flag file manually before calling CMake. Note that in this case this project might not build on anything other than Android.

Patches and stub codes created by this project (not borrowed from other places) are licensed under Apache 2.0 or GNU General Public License (GPL) v3 at your option,

All parts of the code borrowed from other projects are licensed under their corresponding license.

However, please note that when combining them are a whole and to distribute the magiskboot binary, all sources have to be licensed under GPL v3.

For more details about these licenses, please see LICENSE and LICENSE.magiskboot.

• android-tools developers for many code and inspiration of this repository
• Magisk developers for the magiskboot utility
• all other used projects' developers (mentioned in the Requirements section)