2019-06-30 20:39:13 +02:00
|
|
|
#include <sys/mount.h>
|
2020-04-01 13:39:28 +02:00
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/un.h>
|
2019-06-30 20:39:13 +02:00
|
|
|
#include <unistd.h>
|
2019-05-27 09:29:43 +02:00
|
|
|
#include <stdlib.h>
|
2019-11-19 06:16:20 +01:00
|
|
|
#include <vector>
|
2019-05-27 09:29:43 +02:00
|
|
|
|
2020-06-17 10:17:28 +02:00
|
|
|
#include <utils.hpp>
|
2019-12-13 12:05:12 +01:00
|
|
|
|
2020-10-27 04:46:15 +01:00
|
|
|
#include "raw_data.hpp"
|
|
|
|
|
2019-05-27 09:29:43 +02:00
|
|
|
struct cmdline {
|
2019-12-06 18:02:34 +01:00
|
|
|
bool skip_initramfs;
|
Logical Resizable Android Partitions support
The way how logical partition, or "Logical Resizable Android Partitions"
as they say in AOSP source code, is setup makes it impossible to early
mount the partitions from the shared super partition with just
a few lines of code; in fact, AOSP has a whole "fs_mgr" folder which
consist of multiple complex libraries, with 15K lines of code just
to deal with the device mapper shenanigans.
In order to keep the already overly complicated MagiskInit more
managable, I chose NOT to go the route of including fs_mgr directly
into MagiskInit. Luckily, starting from Android Q, Google decided to
split init startup into 3 stages, with the first stage doing _only_
early mount. This is great news, because we can simply let the stock
init do its own thing for us, and we intercept the bootup sequence.
So the workflow can be visualized roughly below:
Magisk First Stage --> First Stage Mount --> Magisk Second Stage --+
(MagiskInit) (Original Init) (MagiskInit) +
+
+
...Rest of the boot... <-- Second Stage <-- Selinux Setup <--+
(__________________ Original Init ____________________)
The catch here is that after doing all the first stage mounting, /init
will pivot /system as root directory (/), leaving us impossible to
regain control after we hand it over. So the solution here is to patch
fstab in /first_stage_ramdisk on-the-fly to redirect /system to
/system_root, making the original init do all the hard work for
us and mount required early mount partitions, but skips the step of
switching root directory. It will also conveniently hand over execution
back to MagiskInit, which we will reuse the routine for patching
root directory in normal system-as-root situations.
2019-06-29 09:47:29 +02:00
|
|
|
bool force_normal_boot;
|
2019-05-27 09:29:43 +02:00
|
|
|
char slot[3];
|
2020-05-04 07:49:54 +02:00
|
|
|
char dt_dir[64];
|
2020-10-08 12:04:12 +02:00
|
|
|
char fstab_suffix[32];
|
2020-05-04 07:49:54 +02:00
|
|
|
char hardware[32];
|
|
|
|
char hardware_plat[32];
|
2019-05-27 09:29:43 +02:00
|
|
|
};
|
|
|
|
|
2020-05-04 07:49:54 +02:00
|
|
|
struct fstab_entry {
|
|
|
|
std::string dev;
|
|
|
|
std::string mnt_point;
|
|
|
|
std::string type;
|
|
|
|
std::string mnt_flags;
|
|
|
|
std::string fsmgr_flags;
|
|
|
|
|
|
|
|
fstab_entry() = default;
|
2020-09-02 11:49:32 +02:00
|
|
|
fstab_entry(const fstab_entry &) = delete;
|
2020-10-27 04:46:15 +01:00
|
|
|
fstab_entry(fstab_entry &&) = default;
|
Force init to load fstab from file in 2SI
Patching DTBs is proven to be difficult and problematic as there are
tons of different formats out there. Adding support for all the formats
in magiskboot has been quite an headache in the past year, and it still
definitely does not cover all possible cases of them out there.
There is another issue: fake dt fstabs. Some super old devices do not
have device trees in their boot images, so some custom ROM developers
had came up with a "genius" solution: hardcode fstab entries directly
in the kernel source code and create fake device tree nodes even if
Android 10+ init can graciously take fstab files instead (-_-) 。。。
And there is YET another issue: DTBs are not always in boot images!
Google is crazy enough to litter DTBs all over the place, it is like
they cannot make up their minds (duh). This means the dt fstabs can be
either concatnated after the kernel (1), in the DTB partition (2), in
the DTBO partition (3), in the recovery_dtbo section in boot images (4),
or in the dtb section in boot images (5). FIVE f**king places, how can
anyone keep up with that!
With Android 10+ that uses 2 stage inits, it is crutual for Magisk to
be able to modify fstab mount points in order to let the original init
mount partitions for us, but NOT switch root and continue booting. For
devices using dt for early mount fstab, we used to patch the DTB at
install time with magiskboot. However these changes are permanent and
cannot be restored back at reinstallation.
With this commit, Magisk will read dt fstabs and write them to ramdisk
at boot time. And in that case, the init binary will also be patched
to force it to NEVER use fstabs in device-tree. By doing so, we can
unify ramdisk based 2SI fstab patching as basically we are just patching
fstab files. This also means we can manipulate fstab whatever Magisk
needs in the future without the need to going through the headache that
is patching DTBs at installation.
2020-05-04 11:21:51 +02:00
|
|
|
void to_file(FILE *fp);
|
2020-05-04 07:49:54 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
#define INIT_SOCKET "MAGISKINIT"
|
|
|
|
#define DEFAULT_DT_DIR "/proc/device-tree/firmware/android"
|
|
|
|
|
|
|
|
void load_kernel_info(cmdline *cmd);
|
2020-09-03 06:20:00 +02:00
|
|
|
bool check_two_stage();
|
2020-05-04 07:49:54 +02:00
|
|
|
int dump_magisk(const char *path, mode_t mode);
|
|
|
|
void setup_klog();
|
|
|
|
|
2020-04-19 13:56:56 +02:00
|
|
|
/***************
|
Logical Resizable Android Partitions support
The way how logical partition, or "Logical Resizable Android Partitions"
as they say in AOSP source code, is setup makes it impossible to early
mount the partitions from the shared super partition with just
a few lines of code; in fact, AOSP has a whole "fs_mgr" folder which
consist of multiple complex libraries, with 15K lines of code just
to deal with the device mapper shenanigans.
In order to keep the already overly complicated MagiskInit more
managable, I chose NOT to go the route of including fs_mgr directly
into MagiskInit. Luckily, starting from Android Q, Google decided to
split init startup into 3 stages, with the first stage doing _only_
early mount. This is great news, because we can simply let the stock
init do its own thing for us, and we intercept the bootup sequence.
So the workflow can be visualized roughly below:
Magisk First Stage --> First Stage Mount --> Magisk Second Stage --+
(MagiskInit) (Original Init) (MagiskInit) +
+
+
...Rest of the boot... <-- Second Stage <-- Selinux Setup <--+
(__________________ Original Init ____________________)
The catch here is that after doing all the first stage mounting, /init
will pivot /system as root directory (/), leaving us impossible to
regain control after we hand it over. So the solution here is to patch
fstab in /first_stage_ramdisk on-the-fly to redirect /system to
/system_root, making the original init do all the hard work for
us and mount required early mount partitions, but skips the step of
switching root directory. It will also conveniently hand over execution
back to MagiskInit, which we will reuse the routine for patching
root directory in normal system-as-root situations.
2019-06-29 09:47:29 +02:00
|
|
|
* Base classes
|
2020-04-19 13:56:56 +02:00
|
|
|
***************/
|
Logical Resizable Android Partitions support
The way how logical partition, or "Logical Resizable Android Partitions"
as they say in AOSP source code, is setup makes it impossible to early
mount the partitions from the shared super partition with just
a few lines of code; in fact, AOSP has a whole "fs_mgr" folder which
consist of multiple complex libraries, with 15K lines of code just
to deal with the device mapper shenanigans.
In order to keep the already overly complicated MagiskInit more
managable, I chose NOT to go the route of including fs_mgr directly
into MagiskInit. Luckily, starting from Android Q, Google decided to
split init startup into 3 stages, with the first stage doing _only_
early mount. This is great news, because we can simply let the stock
init do its own thing for us, and we intercept the bootup sequence.
So the workflow can be visualized roughly below:
Magisk First Stage --> First Stage Mount --> Magisk Second Stage --+
(MagiskInit) (Original Init) (MagiskInit) +
+
+
...Rest of the boot... <-- Second Stage <-- Selinux Setup <--+
(__________________ Original Init ____________________)
The catch here is that after doing all the first stage mounting, /init
will pivot /system as root directory (/), leaving us impossible to
regain control after we hand it over. So the solution here is to patch
fstab in /first_stage_ramdisk on-the-fly to redirect /system to
/system_root, making the original init do all the hard work for
us and mount required early mount partitions, but skips the step of
switching root directory. It will also conveniently hand over execution
back to MagiskInit, which we will reuse the routine for patching
root directory in normal system-as-root situations.
2019-06-29 09:47:29 +02:00
|
|
|
|
2019-06-16 21:45:32 +02:00
|
|
|
class BaseInit {
|
|
|
|
protected:
|
2019-06-16 07:25:09 +02:00
|
|
|
cmdline *cmd;
|
2019-05-27 09:29:43 +02:00
|
|
|
char **argv;
|
2019-11-19 06:16:20 +01:00
|
|
|
std::vector<std::string> mount_list;
|
Logical Resizable Android Partitions support
The way how logical partition, or "Logical Resizable Android Partitions"
as they say in AOSP source code, is setup makes it impossible to early
mount the partitions from the shared super partition with just
a few lines of code; in fact, AOSP has a whole "fs_mgr" folder which
consist of multiple complex libraries, with 15K lines of code just
to deal with the device mapper shenanigans.
In order to keep the already overly complicated MagiskInit more
managable, I chose NOT to go the route of including fs_mgr directly
into MagiskInit. Luckily, starting from Android Q, Google decided to
split init startup into 3 stages, with the first stage doing _only_
early mount. This is great news, because we can simply let the stock
init do its own thing for us, and we intercept the bootup sequence.
So the workflow can be visualized roughly below:
Magisk First Stage --> First Stage Mount --> Magisk Second Stage --+
(MagiskInit) (Original Init) (MagiskInit) +
+
+
...Rest of the boot... <-- Second Stage <-- Selinux Setup <--+
(__________________ Original Init ____________________)
The catch here is that after doing all the first stage mounting, /init
will pivot /system as root directory (/), leaving us impossible to
regain control after we hand it over. So the solution here is to patch
fstab in /first_stage_ramdisk on-the-fly to redirect /system to
/system_root, making the original init do all the hard work for
us and mount required early mount partitions, but skips the step of
switching root directory. It will also conveniently hand over execution
back to MagiskInit, which we will reuse the routine for patching
root directory in normal system-as-root situations.
2019-06-29 09:47:29 +02:00
|
|
|
|
2020-04-19 13:56:56 +02:00
|
|
|
void exec_init() {
|
2019-06-30 20:39:13 +02:00
|
|
|
cleanup();
|
2020-04-19 13:56:56 +02:00
|
|
|
execv("/init", argv);
|
2019-06-30 20:39:13 +02:00
|
|
|
exit(1);
|
|
|
|
}
|
2019-11-19 06:16:20 +01:00
|
|
|
virtual void cleanup();
|
2020-10-27 04:46:15 +01:00
|
|
|
void read_dt_fstab(std::vector<fstab_entry> &fstab);
|
2019-06-22 12:14:33 +02:00
|
|
|
public:
|
2019-11-19 06:16:20 +01:00
|
|
|
BaseInit(char *argv[], cmdline *cmd) :
|
2019-12-13 12:05:12 +01:00
|
|
|
cmd(cmd), argv(argv), mount_list{"/sys", "/proc"} {}
|
2019-06-22 12:14:33 +02:00
|
|
|
virtual ~BaseInit() = default;
|
|
|
|
virtual void start() = 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
class MagiskInit : public BaseInit {
|
|
|
|
protected:
|
2020-09-02 11:49:32 +02:00
|
|
|
auto_data<HEAP> self;
|
2020-10-27 04:46:15 +01:00
|
|
|
auto_data<HEAP> config;
|
2020-04-12 14:34:56 +02:00
|
|
|
std::string persist_dir;
|
2019-05-27 09:29:43 +02:00
|
|
|
|
2020-10-27 04:46:15 +01:00
|
|
|
void mount_with_dt();
|
2020-04-19 13:56:56 +02:00
|
|
|
bool patch_sepolicy(const char *file);
|
2020-10-27 04:46:15 +01:00
|
|
|
void setup_tmp(const char *path);
|
2019-05-27 09:29:43 +02:00
|
|
|
public:
|
2020-04-12 14:34:56 +02:00
|
|
|
MagiskInit(char *argv[], cmdline *cmd) : BaseInit(argv, cmd) {}
|
2019-06-24 00:14:47 +02:00
|
|
|
};
|
|
|
|
|
2019-09-22 11:20:51 +02:00
|
|
|
class SARBase : public MagiskInit {
|
2019-06-24 00:14:47 +02:00
|
|
|
protected:
|
2020-04-01 13:39:28 +02:00
|
|
|
std::vector<raw_file> overlays;
|
2019-06-24 10:21:33 +02:00
|
|
|
|
2020-10-27 04:46:15 +01:00
|
|
|
virtual void early_mount() = 0;
|
2020-04-01 13:39:28 +02:00
|
|
|
void backup_files();
|
2019-06-24 10:21:33 +02:00
|
|
|
void patch_rootdir();
|
2020-04-01 13:39:28 +02:00
|
|
|
void mount_system_root();
|
2019-06-24 00:14:47 +02:00
|
|
|
public:
|
2020-04-12 14:34:56 +02:00
|
|
|
SARBase(char *argv[], cmdline *cmd) : MagiskInit(argv, cmd) {}
|
2019-06-30 20:39:13 +02:00
|
|
|
void start() override {
|
|
|
|
early_mount();
|
|
|
|
patch_rootdir();
|
|
|
|
exec_init();
|
|
|
|
}
|
2019-06-24 00:14:47 +02:00
|
|
|
};
|
|
|
|
|
2020-04-19 13:56:56 +02:00
|
|
|
/***************
|
2019-09-22 11:15:31 +02:00
|
|
|
* 2 Stage Init
|
2020-04-19 13:56:56 +02:00
|
|
|
***************/
|
2019-06-16 21:45:32 +02:00
|
|
|
|
2020-04-01 13:39:28 +02:00
|
|
|
class FirstStageInit : public BaseInit {
|
2019-12-12 09:25:48 +01:00
|
|
|
private:
|
2019-09-22 11:15:31 +02:00
|
|
|
void prepare();
|
|
|
|
public:
|
2020-04-12 14:34:56 +02:00
|
|
|
FirstStageInit(char *argv[], cmdline *cmd) : BaseInit(argv, cmd) {
|
|
|
|
LOGD("%s\n", __FUNCTION__);
|
|
|
|
};
|
2019-09-22 11:15:31 +02:00
|
|
|
void start() override {
|
|
|
|
prepare();
|
|
|
|
exec_init();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-09-22 11:20:51 +02:00
|
|
|
class SecondStageInit : public SARBase {
|
Logical Resizable Android Partitions support
The way how logical partition, or "Logical Resizable Android Partitions"
as they say in AOSP source code, is setup makes it impossible to early
mount the partitions from the shared super partition with just
a few lines of code; in fact, AOSP has a whole "fs_mgr" folder which
consist of multiple complex libraries, with 15K lines of code just
to deal with the device mapper shenanigans.
In order to keep the already overly complicated MagiskInit more
managable, I chose NOT to go the route of including fs_mgr directly
into MagiskInit. Luckily, starting from Android Q, Google decided to
split init startup into 3 stages, with the first stage doing _only_
early mount. This is great news, because we can simply let the stock
init do its own thing for us, and we intercept the bootup sequence.
So the workflow can be visualized roughly below:
Magisk First Stage --> First Stage Mount --> Magisk Second Stage --+
(MagiskInit) (Original Init) (MagiskInit) +
+
+
...Rest of the boot... <-- Second Stage <-- Selinux Setup <--+
(__________________ Original Init ____________________)
The catch here is that after doing all the first stage mounting, /init
will pivot /system as root directory (/), leaving us impossible to
regain control after we hand it over. So the solution here is to patch
fstab in /first_stage_ramdisk on-the-fly to redirect /system to
/system_root, making the original init do all the hard work for
us and mount required early mount partitions, but skips the step of
switching root directory. It will also conveniently hand over execution
back to MagiskInit, which we will reuse the routine for patching
root directory in normal system-as-root situations.
2019-06-29 09:47:29 +02:00
|
|
|
protected:
|
|
|
|
void early_mount() override;
|
|
|
|
void cleanup() override { /* Do not do any cleanup */ }
|
|
|
|
public:
|
2020-04-12 14:34:56 +02:00
|
|
|
SecondStageInit(char *argv[]) : SARBase(argv, nullptr) {
|
|
|
|
LOGD("%s\n", __FUNCTION__);
|
|
|
|
};
|
Logical Resizable Android Partitions support
The way how logical partition, or "Logical Resizable Android Partitions"
as they say in AOSP source code, is setup makes it impossible to early
mount the partitions from the shared super partition with just
a few lines of code; in fact, AOSP has a whole "fs_mgr" folder which
consist of multiple complex libraries, with 15K lines of code just
to deal with the device mapper shenanigans.
In order to keep the already overly complicated MagiskInit more
managable, I chose NOT to go the route of including fs_mgr directly
into MagiskInit. Luckily, starting from Android Q, Google decided to
split init startup into 3 stages, with the first stage doing _only_
early mount. This is great news, because we can simply let the stock
init do its own thing for us, and we intercept the bootup sequence.
So the workflow can be visualized roughly below:
Magisk First Stage --> First Stage Mount --> Magisk Second Stage --+
(MagiskInit) (Original Init) (MagiskInit) +
+
+
...Rest of the boot... <-- Second Stage <-- Selinux Setup <--+
(__________________ Original Init ____________________)
The catch here is that after doing all the first stage mounting, /init
will pivot /system as root directory (/), leaving us impossible to
regain control after we hand it over. So the solution here is to patch
fstab in /first_stage_ramdisk on-the-fly to redirect /system to
/system_root, making the original init do all the hard work for
us and mount required early mount partitions, but skips the step of
switching root directory. It will also conveniently hand over execution
back to MagiskInit, which we will reuse the routine for patching
root directory in normal system-as-root situations.
2019-06-29 09:47:29 +02:00
|
|
|
};
|
|
|
|
|
2020-04-19 13:56:56 +02:00
|
|
|
/*************
|
2019-09-22 11:15:31 +02:00
|
|
|
* Legacy SAR
|
2020-04-19 13:56:56 +02:00
|
|
|
*************/
|
Logical Resizable Android Partitions support
The way how logical partition, or "Logical Resizable Android Partitions"
as they say in AOSP source code, is setup makes it impossible to early
mount the partitions from the shared super partition with just
a few lines of code; in fact, AOSP has a whole "fs_mgr" folder which
consist of multiple complex libraries, with 15K lines of code just
to deal with the device mapper shenanigans.
In order to keep the already overly complicated MagiskInit more
managable, I chose NOT to go the route of including fs_mgr directly
into MagiskInit. Luckily, starting from Android Q, Google decided to
split init startup into 3 stages, with the first stage doing _only_
early mount. This is great news, because we can simply let the stock
init do its own thing for us, and we intercept the bootup sequence.
So the workflow can be visualized roughly below:
Magisk First Stage --> First Stage Mount --> Magisk Second Stage --+
(MagiskInit) (Original Init) (MagiskInit) +
+
+
...Rest of the boot... <-- Second Stage <-- Selinux Setup <--+
(__________________ Original Init ____________________)
The catch here is that after doing all the first stage mounting, /init
will pivot /system as root directory (/), leaving us impossible to
regain control after we hand it over. So the solution here is to patch
fstab in /first_stage_ramdisk on-the-fly to redirect /system to
/system_root, making the original init do all the hard work for
us and mount required early mount partitions, but skips the step of
switching root directory. It will also conveniently hand over execution
back to MagiskInit, which we will reuse the routine for patching
root directory in normal system-as-root situations.
2019-06-29 09:47:29 +02:00
|
|
|
|
2019-09-22 11:20:51 +02:00
|
|
|
class SARInit : public SARBase {
|
Logical Resizable Android Partitions support
The way how logical partition, or "Logical Resizable Android Partitions"
as they say in AOSP source code, is setup makes it impossible to early
mount the partitions from the shared super partition with just
a few lines of code; in fact, AOSP has a whole "fs_mgr" folder which
consist of multiple complex libraries, with 15K lines of code just
to deal with the device mapper shenanigans.
In order to keep the already overly complicated MagiskInit more
managable, I chose NOT to go the route of including fs_mgr directly
into MagiskInit. Luckily, starting from Android Q, Google decided to
split init startup into 3 stages, with the first stage doing _only_
early mount. This is great news, because we can simply let the stock
init do its own thing for us, and we intercept the bootup sequence.
So the workflow can be visualized roughly below:
Magisk First Stage --> First Stage Mount --> Magisk Second Stage --+
(MagiskInit) (Original Init) (MagiskInit) +
+
+
...Rest of the boot... <-- Second Stage <-- Selinux Setup <--+
(__________________ Original Init ____________________)
The catch here is that after doing all the first stage mounting, /init
will pivot /system as root directory (/), leaving us impossible to
regain control after we hand it over. So the solution here is to patch
fstab in /first_stage_ramdisk on-the-fly to redirect /system to
/system_root, making the original init do all the hard work for
us and mount required early mount partitions, but skips the step of
switching root directory. It will also conveniently hand over execution
back to MagiskInit, which we will reuse the routine for patching
root directory in normal system-as-root situations.
2019-06-29 09:47:29 +02:00
|
|
|
protected:
|
|
|
|
void early_mount() override;
|
|
|
|
public:
|
2020-04-12 14:34:56 +02:00
|
|
|
SARInit(char *argv[], cmdline *cmd) : SARBase(argv, cmd) {
|
|
|
|
LOGD("%s\n", __FUNCTION__);
|
|
|
|
};
|
Logical Resizable Android Partitions support
The way how logical partition, or "Logical Resizable Android Partitions"
as they say in AOSP source code, is setup makes it impossible to early
mount the partitions from the shared super partition with just
a few lines of code; in fact, AOSP has a whole "fs_mgr" folder which
consist of multiple complex libraries, with 15K lines of code just
to deal with the device mapper shenanigans.
In order to keep the already overly complicated MagiskInit more
managable, I chose NOT to go the route of including fs_mgr directly
into MagiskInit. Luckily, starting from Android Q, Google decided to
split init startup into 3 stages, with the first stage doing _only_
early mount. This is great news, because we can simply let the stock
init do its own thing for us, and we intercept the bootup sequence.
So the workflow can be visualized roughly below:
Magisk First Stage --> First Stage Mount --> Magisk Second Stage --+
(MagiskInit) (Original Init) (MagiskInit) +
+
+
...Rest of the boot... <-- Second Stage <-- Selinux Setup <--+
(__________________ Original Init ____________________)
The catch here is that after doing all the first stage mounting, /init
will pivot /system as root directory (/), leaving us impossible to
regain control after we hand it over. So the solution here is to patch
fstab in /first_stage_ramdisk on-the-fly to redirect /system to
/system_root, making the original init do all the hard work for
us and mount required early mount partitions, but skips the step of
switching root directory. It will also conveniently hand over execution
back to MagiskInit, which we will reuse the routine for patching
root directory in normal system-as-root situations.
2019-06-29 09:47:29 +02:00
|
|
|
};
|
|
|
|
|
2020-10-27 04:46:15 +01:00
|
|
|
// Special case for legacy SAR on Android 10+
|
|
|
|
// Should be followed by normal 2SI SecondStageInit
|
|
|
|
class SARFirstStageInit : public SARBase {
|
|
|
|
private:
|
|
|
|
void prepare();
|
|
|
|
protected:
|
|
|
|
void early_mount() override;
|
|
|
|
public:
|
|
|
|
SARFirstStageInit(char *argv[], cmdline *cmd) : SARBase(argv, cmd) {
|
|
|
|
LOGD("%s\n", __FUNCTION__);
|
|
|
|
};
|
|
|
|
void start() override {
|
|
|
|
early_mount();
|
|
|
|
prepare();
|
|
|
|
exec_init();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-04-19 13:56:56 +02:00
|
|
|
/************
|
Logical Resizable Android Partitions support
The way how logical partition, or "Logical Resizable Android Partitions"
as they say in AOSP source code, is setup makes it impossible to early
mount the partitions from the shared super partition with just
a few lines of code; in fact, AOSP has a whole "fs_mgr" folder which
consist of multiple complex libraries, with 15K lines of code just
to deal with the device mapper shenanigans.
In order to keep the already overly complicated MagiskInit more
managable, I chose NOT to go the route of including fs_mgr directly
into MagiskInit. Luckily, starting from Android Q, Google decided to
split init startup into 3 stages, with the first stage doing _only_
early mount. This is great news, because we can simply let the stock
init do its own thing for us, and we intercept the bootup sequence.
So the workflow can be visualized roughly below:
Magisk First Stage --> First Stage Mount --> Magisk Second Stage --+
(MagiskInit) (Original Init) (MagiskInit) +
+
+
...Rest of the boot... <-- Second Stage <-- Selinux Setup <--+
(__________________ Original Init ____________________)
The catch here is that after doing all the first stage mounting, /init
will pivot /system as root directory (/), leaving us impossible to
regain control after we hand it over. So the solution here is to patch
fstab in /first_stage_ramdisk on-the-fly to redirect /system to
/system_root, making the original init do all the hard work for
us and mount required early mount partitions, but skips the step of
switching root directory. It will also conveniently hand over execution
back to MagiskInit, which we will reuse the routine for patching
root directory in normal system-as-root situations.
2019-06-29 09:47:29 +02:00
|
|
|
* Initramfs
|
2020-04-19 13:56:56 +02:00
|
|
|
************/
|
Logical Resizable Android Partitions support
The way how logical partition, or "Logical Resizable Android Partitions"
as they say in AOSP source code, is setup makes it impossible to early
mount the partitions from the shared super partition with just
a few lines of code; in fact, AOSP has a whole "fs_mgr" folder which
consist of multiple complex libraries, with 15K lines of code just
to deal with the device mapper shenanigans.
In order to keep the already overly complicated MagiskInit more
managable, I chose NOT to go the route of including fs_mgr directly
into MagiskInit. Luckily, starting from Android Q, Google decided to
split init startup into 3 stages, with the first stage doing _only_
early mount. This is great news, because we can simply let the stock
init do its own thing for us, and we intercept the bootup sequence.
So the workflow can be visualized roughly below:
Magisk First Stage --> First Stage Mount --> Magisk Second Stage --+
(MagiskInit) (Original Init) (MagiskInit) +
+
+
...Rest of the boot... <-- Second Stage <-- Selinux Setup <--+
(__________________ Original Init ____________________)
The catch here is that after doing all the first stage mounting, /init
will pivot /system as root directory (/), leaving us impossible to
regain control after we hand it over. So the solution here is to patch
fstab in /first_stage_ramdisk on-the-fly to redirect /system to
/system_root, making the original init do all the hard work for
us and mount required early mount partitions, but skips the step of
switching root directory. It will also conveniently hand over execution
back to MagiskInit, which we will reuse the routine for patching
root directory in normal system-as-root situations.
2019-06-29 09:47:29 +02:00
|
|
|
|
2019-12-12 09:25:48 +01:00
|
|
|
class RootFSInit : public MagiskInit {
|
|
|
|
private:
|
|
|
|
void setup_rootfs();
|
2020-10-27 04:46:15 +01:00
|
|
|
void early_mount();
|
2019-06-16 21:45:32 +02:00
|
|
|
public:
|
2019-12-13 12:05:12 +01:00
|
|
|
RootFSInit(char *argv[], cmdline *cmd) : MagiskInit(argv, cmd) {
|
2020-04-12 14:34:56 +02:00
|
|
|
LOGD("%s\n", __FUNCTION__);
|
2019-12-13 12:05:12 +01:00
|
|
|
}
|
2019-06-16 21:45:32 +02:00
|
|
|
|
2019-12-12 09:25:48 +01:00
|
|
|
void start() override {
|
|
|
|
early_mount();
|
|
|
|
setup_rootfs();
|
|
|
|
exec_init();
|
|
|
|
}
|
2019-05-27 09:29:43 +02:00
|
|
|
};
|
2020-10-27 04:46:15 +01:00
|
|
|
|
|
|
|
class MagiskProxy : public MagiskInit {
|
|
|
|
public:
|
|
|
|
explicit MagiskProxy(char *argv[]) : MagiskInit(argv, nullptr) {
|
|
|
|
LOGD("%s\n", __FUNCTION__);
|
|
|
|
}
|
|
|
|
void start() override;
|
|
|
|
};
|