andreacavalli/Magisk
1
0
Fork 0
forked from MarcoBuster/Magisk
Code Issues Pull Requests Projects Releases Wiki Activity

Refactor magiskboot

Browse Source
This commit is contained in:
topjohnwu 2021-02-28 12:56:23 -08:00
parent ac8372dd26
commit 0d42f937dd
3 changed files with 123 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

194
native/jni/magiskboot/bootimg.cpp
View File

@ -167,16 +167,17 @@ boot_img::boot_img(const char *image) {
switch (fmt) { switch (fmt) {
case CHROMEOS: case CHROMEOS:
// chromeos require external signing // chromeos require external signing
flags |= CHROMEOS_FLAG; flags[CHROMEOS_FLAG] = true;
addr += 65535; addr += 65535;
break; break;
case DHTB: case DHTB:
flags |= (DHTB_FLAG | SEANDROID_FLAG); flags[DHTB_FLAG] = true;
flags[SEANDROID_FLAG] = true;
fprintf(stderr, "DHTB_HDR\n"); fprintf(stderr, "DHTB_HDR\n");
addr += sizeof(dhtb_hdr) - 1; addr += sizeof(dhtb_hdr) - 1;
break; break;
case BLOB: case BLOB:
flags |= BLOB_FLAG; flags[BLOB_FLAG] = true;
fprintf(stderr, "TEGRA_BLOB\n"); fprintf(stderr, "TEGRA_BLOB\n");
addr += sizeof(blob_hdr) - 1; addr += sizeof(blob_hdr) - 1;
break; break;
@ -259,11 +260,11 @@ void boot_img::parse_image(uint8_t *addr, format_t type) {
memcmp(hp->cmdline, NOOKHD_GR_MAGIC, 14) == 0 || memcmp(hp->cmdline, NOOKHD_GR_MAGIC, 14) == 0 ||
memcmp(hp->cmdline, NOOKHD_EB_MAGIC, 26) == 0 || memcmp(hp->cmdline, NOOKHD_EB_MAGIC, 26) == 0 ||
memcmp(hp->cmdline, NOOKHD_ER_MAGIC, 30) == 0) { memcmp(hp->cmdline, NOOKHD_ER_MAGIC, 30) == 0) {
flags |= NOOKHD_FLAG; flags[NOOKHD_FLAG] = true;
fprintf(stderr, "NOOKHD_LOADER\n"); fprintf(stderr, "NOOKHD_LOADER\n");
addr += NOOKHD_PRE_HEADER_SZ; addr += NOOKHD_PRE_HEADER_SZ;
} else if (memcmp(hp->name, ACCLAIM_MAGIC, 10) == 0) { } else if (memcmp(hp->name, ACCLAIM_MAGIC, 10) == 0) {
flags |= ACCLAIM_FLAG; flags[ACCLAIM_FLAG] = true;
fprintf(stderr, "ACCLAIM_LOADER\n"); fprintf(stderr, "ACCLAIM_LOADER\n");
addr += ACCLAIM_PRE_HEADER_SZ; addr += ACCLAIM_PRE_HEADER_SZ;
} }
@ -287,7 +288,7 @@ void boot_img::parse_image(uint8_t *addr, format_t type) {
if (char *id = hdr->id()) { if (char *id = hdr->id()) {
for (int i = SHA_DIGEST_SIZE + 4; i < SHA256_DIGEST_SIZE; ++i) { for (int i = SHA_DIGEST_SIZE + 4; i < SHA256_DIGEST_SIZE; ++i) {
if (id[i]) { if (id[i]) {
flags |= SHA256_FLAG; flags[SHA256_FLAG] = true;
break; break;
} }
} }
@ -309,25 +310,25 @@ void boot_img::parse_image(uint8_t *addr, format_t type) {
tail_size = map_size - (tail - map_addr); tail_size = map_size - (tail - map_addr);
} }
// Check tail info, currently only for LG Bump and Samsung SEANDROIDENFORCE // Check tail info
if (tail_size >= 16 && memcmp(tail, SEANDROID_MAGIC, 16) == 0) { if (tail_size >= 16 && memcmp(tail, SEANDROID_MAGIC, 16) == 0) {
flags |= SEANDROID_FLAG; flags[SEANDROID_FLAG] = true;
} else if (tail_size >= 16 && memcmp(tail, LG_BUMP_MAGIC, 16) == 0) { } else if (tail_size >= 16 && memcmp(tail, LG_BUMP_MAGIC, 16) == 0) {
flags |= LG_BUMP_FLAG; flags[LG_BUMP_FLAG] = true;
} }
if (int dtb_off = find_dtb_offset(kernel, hdr->kernel_size()); dtb_off > 0) { if (int dtb_off = find_dtb_offset(kernel, hdr->kernel_size()); dtb_off > 0) {
kernel_dtb = kernel + dtb_off; kernel_dtb = kernel + dtb_off;
kernel_dt_size = hdr->kernel_size() - dtb_off; hdr->kernel_dt_size = hdr->kernel_size() - dtb_off;
hdr->kernel_size() = dtb_off; hdr->kernel_size() = dtb_off;
fprintf(stderr, "%-*s [%u]\n", PADDING, "KERNEL_DTB", kernel_dt_size); fprintf(stderr, "%-*s [%u]\n", PADDING, "KERNEL_DTB_SZ", hdr->kernel_dt_size);
} }
if (auto size = hdr->kernel_size()) { if (auto size = hdr->kernel_size()) {
k_fmt = check_fmt_lg(kernel, size); k_fmt = check_fmt_lg(kernel, size);
if (k_fmt == MTK) { if (k_fmt == MTK) {
fprintf(stderr, "MTK_KERNEL_HDR\n"); fprintf(stderr, "MTK_KERNEL_HDR\n");
flags |= MTK_KERNEL; flags[MTK_KERNEL] = true;
k_hdr = reinterpret_cast<mtk_hdr *>(kernel); k_hdr = reinterpret_cast<mtk_hdr *>(kernel);
fprintf(stderr, "%-*s [%u]\n", PADDING, "KERNEL", k_hdr->size); fprintf(stderr, "%-*s [%u]\n", PADDING, "KERNEL", k_hdr->size);
fprintf(stderr, "%-*s [%s]\n", PADDING, "NAME", k_hdr->name); fprintf(stderr, "%-*s [%s]\n", PADDING, "NAME", k_hdr->name);
@ -341,7 +342,7 @@ void boot_img::parse_image(uint8_t *addr, format_t type) {
r_fmt = check_fmt_lg(ramdisk, size); r_fmt = check_fmt_lg(ramdisk, size);
if (r_fmt == MTK) { if (r_fmt == MTK) {
fprintf(stderr, "MTK_RAMDISK_HDR\n"); fprintf(stderr, "MTK_RAMDISK_HDR\n");
flags |= MTK_RAMDISK; flags[MTK_RAMDISK] = true;
r_hdr = reinterpret_cast<mtk_hdr *>(ramdisk); r_hdr = reinterpret_cast<mtk_hdr *>(ramdisk);
fprintf(stderr, "%-*s [%u]\n", PADDING, "RAMDISK", r_hdr->size); fprintf(stderr, "%-*s [%u]\n", PADDING, "RAMDISK", r_hdr->size);
fprintf(stderr, "%-*s [%s]\n", PADDING, "NAME", r_hdr->name); fprintf(stderr, "%-*s [%s]\n", PADDING, "NAME", r_hdr->name);
@ -396,7 +397,7 @@ int unpack(const char *image, bool skip_decomp, bool hdr) {
} }
// Dump kernel_dtb // Dump kernel_dtb
dump(boot.kernel_dtb, boot.kernel_dt_size, KER_DTB_FILE); dump(boot.kernel_dtb, boot.hdr->kernel_dt_size, KER_DTB_FILE);
// Dump ramdisk // Dump ramdisk
if (!skip_decomp && COMPRESSED(boot.r_fmt)) { if (!skip_decomp && COMPRESSED(boot.r_fmt)) {
@ -425,16 +426,15 @@ int unpack(const char *image, bool skip_decomp, bool hdr) {
// Dump dtb // Dump dtb
dump(boot.dtb, boot.hdr->dtb_size(), DTB_FILE); dump(boot.dtb, boot.hdr->dtb_size(), DTB_FILE);
return (boot.flags & CHROMEOS_FLAG) ? 2 : 0; return boot.flags[CHROMEOS_FLAG] ? 2 : 0;
} }
#define file_align() \ #define file_align() \
write_zero(fd, align_off(lseek(fd, 0, SEEK_CUR) - off.header, boot.hdr->page_size())) write_zero(fd, align_off(lseek(fd, 0, SEEK_CUR) - off.header, boot.hdr->page_size()))
void repack(const char* src_img, const char* out_img, bool skip_comp) { void repack(const char *src_img, const char *out_img, bool skip_comp) {
boot_img boot(src_img); const boot_img boot(src_img);
fprintf(stderr, "Repack to boot image: [%s]\n", out_img);
auto is_flag = [&](unsigned flag) -> bool { return (boot.flags & flag); };
struct { struct {
uint32_t header; uint32_t header;
@ -444,45 +444,44 @@ void repack(const char* src_img, const char* out_img, bool skip_comp) {
uint32_t extra; uint32_t extra;
uint32_t dtb; uint32_t dtb;
uint32_t total; uint32_t total;
} off; } off{};
fprintf(stderr, "Repack to boot image: [%s]\n", out_img); // Create a new boot header and reset sizes
auto hdr = boot.hdr->clone();
// Reset sizes hdr->kernel_size() = 0;
boot.hdr->kernel_size() = 0; hdr->ramdisk_size() = 0;
boot.hdr->ramdisk_size() = 0; hdr->second_size() = 0;
boot.hdr->second_size() = 0; hdr->dtb_size() = 0;
boot.hdr->dtb_size() = 0; hdr->kernel_dt_size = 0;
boot.kernel_dt_size = 0;
if (access(HEADER_FILE, R_OK) == 0) if (access(HEADER_FILE, R_OK) == 0)
boot.hdr->load_hdr_file(); hdr->load_hdr_file();
/***************** /***************
* Writing blocks * Write blocks
*****************/ ***************/
// Create new image // Create new image
int fd = creat(out_img, 0644); int fd = creat(out_img, 0644);
if (is_flag(DHTB_FLAG)) { if (boot.flags[DHTB_FLAG]) {
// Skip DHTB header // Skip DHTB header
write_zero(fd, sizeof(dhtb_hdr)); write_zero(fd, sizeof(dhtb_hdr));
} else if (is_flag(BLOB_FLAG)) { } else if (boot.flags[BLOB_FLAG]) {
restore_buf(fd, boot.map_addr, sizeof(blob_hdr)); restore_buf(fd, boot.map_addr, sizeof(blob_hdr));
} else if (is_flag(NOOKHD_FLAG)) { } else if (boot.flags[NOOKHD_FLAG]) {
restore_buf(fd, boot.map_addr, NOOKHD_PRE_HEADER_SZ); restore_buf(fd, boot.map_addr, NOOKHD_PRE_HEADER_SZ);
} else if (is_flag(ACCLAIM_FLAG)) { } else if (boot.flags[ACCLAIM_FLAG]) {
restore_buf(fd, boot.map_addr, ACCLAIM_PRE_HEADER_SZ); restore_buf(fd, boot.map_addr, ACCLAIM_PRE_HEADER_SZ);
} }
// Copy header // Copy raw header
off.header = lseek(fd, 0, SEEK_CUR); off.header = lseek(fd, 0, SEEK_CUR);
restore_buf(fd, boot.hdr_addr, boot.hdr->hdr_space()); restore_buf(fd, boot.hdr_addr, hdr->hdr_space());
// kernel // kernel
off.kernel = lseek(fd, 0, SEEK_CUR); off.kernel = lseek(fd, 0, SEEK_CUR);
if (is_flag(MTK_KERNEL)) { if (boot.flags[MTK_KERNEL]) {
// Copy MTK headers // Copy MTK headers
restore_buf(fd, boot.k_hdr, sizeof(mtk_hdr)); restore_buf(fd, boot.k_hdr, sizeof(mtk_hdr));
} }
@ -491,21 +490,21 @@ void repack(const char* src_img, const char* out_img, bool skip_comp) {
void *raw_buf; void *raw_buf;
mmap_ro(KERNEL_FILE, raw_buf, raw_size); mmap_ro(KERNEL_FILE, raw_buf, raw_size);
if (!COMPRESSED_ANY(check_fmt(raw_buf, raw_size)) && COMPRESSED(boot.k_fmt)) { if (!COMPRESSED_ANY(check_fmt(raw_buf, raw_size)) && COMPRESSED(boot.k_fmt)) {
boot.hdr->kernel_size() = compress(boot.k_fmt, fd, raw_buf, raw_size); hdr->kernel_size() = compress(boot.k_fmt, fd, raw_buf, raw_size);
} else { } else {
boot.hdr->kernel_size() = xwrite(fd, raw_buf, raw_size); hdr->kernel_size() = xwrite(fd, raw_buf, raw_size);
} }
munmap(raw_buf, raw_size); munmap(raw_buf, raw_size);
} }
// kernel dtb // kernel dtb
if (access(KER_DTB_FILE, R_OK) == 0) if (access(KER_DTB_FILE, R_OK) == 0)
boot.hdr->kernel_size() += restore(fd, KER_DTB_FILE); hdr->kernel_size() += restore(fd, KER_DTB_FILE);
file_align(); file_align();
// ramdisk // ramdisk
off.ramdisk = lseek(fd, 0, SEEK_CUR); off.ramdisk = lseek(fd, 0, SEEK_CUR);
if (is_flag(MTK_RAMDISK)) { if (boot.flags[MTK_RAMDISK]) {
// Copy MTK headers // Copy MTK headers
restore_buf(fd, boot.r_hdr, sizeof(mtk_hdr)); restore_buf(fd, boot.r_hdr, sizeof(mtk_hdr));
} }
@ -514,9 +513,9 @@ void repack(const char* src_img, const char* out_img, bool skip_comp) {
void *raw_buf; void *raw_buf;
mmap_ro(RAMDISK_FILE, raw_buf, raw_size); mmap_ro(RAMDISK_FILE, raw_buf, raw_size);
if (!skip_comp && !COMPRESSED_ANY(check_fmt(raw_buf, raw_size)) && COMPRESSED(boot.r_fmt)) { if (!skip_comp && !COMPRESSED_ANY(check_fmt(raw_buf, raw_size)) && COMPRESSED(boot.r_fmt)) {
boot.hdr->ramdisk_size() = compress(boot.r_fmt, fd, raw_buf, raw_size); hdr->ramdisk_size() = compress(boot.r_fmt, fd, raw_buf, raw_size);
} else { } else {
boot.hdr->ramdisk_size() = xwrite(fd, raw_buf, raw_size); hdr->ramdisk_size() = xwrite(fd, raw_buf, raw_size);
} }
munmap(raw_buf, raw_size); munmap(raw_buf, raw_size);
file_align(); file_align();
@ -525,7 +524,7 @@ void repack(const char* src_img, const char* out_img, bool skip_comp) {
// second // second
off.second = lseek(fd, 0, SEEK_CUR); off.second = lseek(fd, 0, SEEK_CUR);
if (access(SECOND_FILE, R_OK) == 0) { if (access(SECOND_FILE, R_OK) == 0) {
boot.hdr->second_size() = restore(fd, SECOND_FILE); hdr->second_size() = restore(fd, SECOND_FILE);
file_align(); file_align();
} }
@ -536,9 +535,9 @@ void repack(const char* src_img, const char* out_img, bool skip_comp) {
void *raw_buf; void *raw_buf;
mmap_ro(EXTRA_FILE, raw_buf, raw_size); mmap_ro(EXTRA_FILE, raw_buf, raw_size);
if (!skip_comp && !COMPRESSED_ANY(check_fmt(raw_buf, raw_size)) && COMPRESSED(boot.e_fmt)) { if (!skip_comp && !COMPRESSED_ANY(check_fmt(raw_buf, raw_size)) && COMPRESSED(boot.e_fmt)) {
boot.hdr->extra_size() = compress(boot.e_fmt, fd, raw_buf, raw_size); hdr->extra_size() = compress(boot.e_fmt, fd, raw_buf, raw_size);
} else { } else {
boot.hdr->extra_size() = xwrite(fd, raw_buf, raw_size); hdr->extra_size() = xwrite(fd, raw_buf, raw_size);
} }
munmap(raw_buf, raw_size); munmap(raw_buf, raw_size);
file_align(); file_align();
@ -546,30 +545,30 @@ void repack(const char* src_img, const char* out_img, bool skip_comp) {
// recovery_dtbo // recovery_dtbo
if (access(RECV_DTBO_FILE, R_OK) == 0) { if (access(RECV_DTBO_FILE, R_OK) == 0) {
boot.hdr->recovery_dtbo_offset() = lseek(fd, 0, SEEK_CUR); hdr->recovery_dtbo_offset() = lseek(fd, 0, SEEK_CUR);
boot.hdr->recovery_dtbo_size() = restore(fd, RECV_DTBO_FILE); hdr->recovery_dtbo_size() = restore(fd, RECV_DTBO_FILE);
file_align(); file_align();
} }
// dtb // dtb
off.dtb = lseek(fd, 0, SEEK_CUR); off.dtb = lseek(fd, 0, SEEK_CUR);
if (access(DTB_FILE, R_OK) == 0) { if (access(DTB_FILE, R_OK) == 0) {
boot.hdr->dtb_size() = restore(fd, DTB_FILE); hdr->dtb_size() = restore(fd, DTB_FILE);
file_align(); file_align();
} }
// Append tail info // Append tail info
if (is_flag(SEANDROID_FLAG)) { if (boot.flags[SEANDROID_FLAG]) {
restore_buf(fd, SEANDROID_MAGIC "\xFF\xFF\xFF\xFF", 20); restore_buf(fd, SEANDROID_MAGIC "\xFF\xFF\xFF\xFF", 20);
} }
if (is_flag(LG_BUMP_FLAG)) { if (boot.flags[LG_BUMP_FLAG]) {
restore_buf(fd, LG_BUMP_MAGIC, 16); restore_buf(fd, LG_BUMP_MAGIC, 16);
} }
off.total = lseek(fd, 0, SEEK_CUR); off.total = lseek(fd, 0, SEEK_CUR);
// Pad image to at least original size if not chromeos (as it requires post processing) // Pad image to at least original size if not chromeos (as it requires post processing)
if (!is_flag(CHROMEOS_FLAG)) { if (!boot.flags[CHROMEOS_FLAG]) {
if (off.total < boot.map_size) { if (off.total < boot.map_size) {
int padding = boot.map_size - off.total; int padding = boot.map_size - off.total;
write_zero(fd, padding); write_zero(fd, padding);
@ -578,77 +577,80 @@ void repack(const char* src_img, const char* out_img, bool skip_comp) {
close(fd); close(fd);
/********************* /******************
* Patching the image * Patch the image
*********************/ ******************/
// Map output image as rw // Map output image as rw
munmap(boot.map_addr, boot.map_size); uint8_t *new_addr;
mmap_rw(out_img, boot.map_addr, boot.map_size); size_t new_size;
mmap_rw(out_img, new_addr, new_size);
// MTK headers // MTK headers
if (is_flag(MTK_KERNEL)) { if (boot.flags[MTK_KERNEL]) {
auto hdr = reinterpret_cast<mtk_hdr *>(boot.map_addr + off.kernel); auto m_hdr = reinterpret_cast<mtk_hdr *>(new_addr + off.kernel);
hdr->size = boot.hdr->kernel_size(); m_hdr->size = hdr->kernel_size();
boot.hdr->kernel_size() += sizeof(*hdr); hdr->kernel_size() += sizeof(mtk_hdr);
} }
if (is_flag(MTK_RAMDISK)) { if (boot.flags[MTK_RAMDISK]) {
auto hdr = reinterpret_cast<mtk_hdr *>(boot.map_addr + off.ramdisk); auto m_hdr = reinterpret_cast<mtk_hdr *>(new_addr + off.ramdisk);
hdr->size = boot.hdr->ramdisk_size(); m_hdr->size = hdr->ramdisk_size();
boot.hdr->ramdisk_size() += sizeof(*hdr); hdr->ramdisk_size() += sizeof(mtk_hdr);
} }
// Make sure header size matches // Make sure header size matches
boot.hdr->header_size() = boot.hdr->hdr_size(); hdr->header_size() = hdr->hdr_size();
// Update checksum // Update checksum
if (char *id = boot.hdr->id()) { if (char *id = hdr->id()) {
HASH_CTX ctx; HASH_CTX ctx;
is_flag(SHA256_FLAG) ? SHA256_init(&ctx) : SHA_init(&ctx); boot.flags[SHA256_FLAG] ? SHA256_init(&ctx) : SHA_init(&ctx);
uint32_t size = boot.hdr->kernel_size(); uint32_t size = hdr->kernel_size();
HASH_update(&ctx, boot.map_addr + off.kernel, size); HASH_update(&ctx, new_addr + off.kernel, size);
HASH_update(&ctx, &size, sizeof(size)); HASH_update(&ctx, &size, sizeof(size));
size = boot.hdr->ramdisk_size(); size = hdr->ramdisk_size();
HASH_update(&ctx, boot.map_addr + off.ramdisk, size); HASH_update(&ctx, new_addr + off.ramdisk, size);
HASH_update(&ctx, &size, sizeof(size)); HASH_update(&ctx, &size, sizeof(size));
size = boot.hdr->second_size(); size = hdr->second_size();
HASH_update(&ctx, boot.map_addr + off.second, size); HASH_update(&ctx, new_addr + off.second, size);
HASH_update(&ctx, &size, sizeof(size)); HASH_update(&ctx, &size, sizeof(size));
size = boot.hdr->extra_size(); size = hdr->extra_size();
if (size) { if (size) {
HASH_update(&ctx, boot.map_addr + off.extra, size); HASH_update(&ctx, new_addr + off.extra, size);
HASH_update(&ctx, &size, sizeof(size)); HASH_update(&ctx, &size, sizeof(size));
} }
uint32_t ver = boot.hdr->header_version(); uint32_t ver = hdr->header_version();
if (ver == 1 || ver == 2) { if (ver == 1 || ver == 2) {
size = boot.hdr->recovery_dtbo_size(); size = hdr->recovery_dtbo_size();
HASH_update(&ctx, boot.map_addr + boot.hdr->recovery_dtbo_offset(), size); HASH_update(&ctx, new_addr + hdr->recovery_dtbo_offset(), size);
HASH_update(&ctx, &size, sizeof(size)); HASH_update(&ctx, &size, sizeof(size));
} }
if (ver == 2) { if (ver == 2) {
size = boot.hdr->dtb_size(); size = hdr->dtb_size();
HASH_update(&ctx, boot.map_addr + off.dtb, size); HASH_update(&ctx, new_addr + off.dtb, size);
HASH_update(&ctx, &size, sizeof(size)); HASH_update(&ctx, &size, sizeof(size));
} }
memset(id, 0, BOOT_ID_SIZE); memset(id, 0, BOOT_ID_SIZE);
memcpy(id, HASH_final(&ctx), is_flag(SHA256_FLAG) ? SHA256_DIGEST_SIZE : SHA_DIGEST_SIZE); memcpy(id, HASH_final(&ctx), boot.flags[SHA256_FLAG] ? SHA256_DIGEST_SIZE : SHA_DIGEST_SIZE);
} }
// Print new image info // Print new header info
boot.hdr->print(); hdr->print();
// Main header // Copy main header
memcpy(boot.map_addr + off.header, boot.hdr->raw_hdr(), boot.hdr->hdr_size()); memcpy(new_addr + off.header, hdr->raw_hdr(), hdr->hdr_size());
if (is_flag(DHTB_FLAG)) { if (boot.flags[DHTB_FLAG]) {
// DHTB header // DHTB header
auto hdr = reinterpret_cast<dhtb_hdr *>(boot.map_addr); auto d_hdr = reinterpret_cast<dhtb_hdr *>(new_addr);
memcpy(hdr, DHTB_MAGIC, 8); memcpy(d_hdr, DHTB_MAGIC, 8);
hdr->size = off.total - sizeof(dhtb_hdr); d_hdr->size = off.total - sizeof(dhtb_hdr);
SHA256_hash(boot.map_addr + sizeof(dhtb_hdr), hdr->size, hdr->checksum); SHA256_hash(new_addr + sizeof(dhtb_hdr), d_hdr->size, d_hdr->checksum);
} else if (is_flag(BLOB_FLAG)) { } else if (boot.flags[BLOB_FLAG]) {
// Blob header // Blob header
auto hdr = reinterpret_cast<blob_hdr *>(boot.map_addr); auto b_hdr = reinterpret_cast<blob_hdr *>(new_addr);
hdr->size = off.total - sizeof(blob_hdr); b_hdr->size = off.total - sizeof(blob_hdr);
} }
munmap(new_addr, new_size);
} }

38
native/jni/magiskboot/bootimg.hpp
View File

@ -2,6 +2,7 @@
#include <stdint.h> #include <stdint.h>
#include <utility> #include <utility>
#include <bitset>
#include "format.hpp" #include "format.hpp"
/****************** /******************
@ -231,6 +232,7 @@ struct dyn_img_hdr {
decl_val(cmdline, char *) decl_val(cmdline, char *)
decl_val(id, char *) decl_val(id, char *)
decl_val(extra_cmdline, char *) decl_val(extra_cmdline, char *)
uint32_t kernel_dt_size = 0;
// v1/v2 specific // v1/v2 specific
decl_var(recovery_dtbo_size, 32) decl_var(recovery_dtbo_size, 32)
@ -244,6 +246,7 @@ struct dyn_img_hdr {
virtual size_t hdr_size() = 0; virtual size_t hdr_size() = 0;
virtual size_t hdr_space() { return page_size(); } virtual size_t hdr_space() { return page_size(); }
virtual dyn_img_hdr *clone() = 0;
const void *raw_hdr() const { return raw; } const void *raw_hdr() const { return raw; }
void print(); void print();
@ -276,7 +279,12 @@ name(void *ptr) { \
raw = xmalloc(sizeof(hdr)); \ raw = xmalloc(sizeof(hdr)); \
memcpy(raw, ptr, sizeof(hdr)); \ memcpy(raw, ptr, sizeof(hdr)); \
} \ } \
size_t hdr_size() override { return sizeof(hdr); } size_t hdr_size() override { return sizeof(hdr); } \
dyn_img_hdr *clone() override { \
auto p = new name(this->raw); \
p->kernel_dt_size = kernel_dt_size; \
return p; \
};
#define __impl_val(name, hdr_name) \ #define __impl_val(name, hdr_name) \
decltype(std::declval<dyn_img_hdr>().name()) name() override { return hdr_name->name; } decltype(std::declval<dyn_img_hdr>().name()) name() override { return hdr_name->name; }
@ -351,7 +359,7 @@ struct dyn_img_v3 : public dyn_img_hdr {
char *extra_cmdline() override { return &v3_hdr->cmdline[BOOT_ARGS_SIZE]; } char *extra_cmdline() override { return &v3_hdr->cmdline[BOOT_ARGS_SIZE]; }
private: private:
uint32_t page_sz; uint32_t page_sz = 4096;
}; };
#undef impl_val #undef impl_val
@ -383,16 +391,19 @@ struct dyn_img_vnd_v3 : public dyn_img_hdr {
* Full Boot Image * Full Boot Image
******************/ ******************/
#define MTK_KERNEL (1 << 0) enum {
#define MTK_RAMDISK (1 << 1) MTK_KERNEL,
#define CHROMEOS_FLAG (1 << 2) MTK_RAMDISK,
#define DHTB_FLAG (1 << 3) CHROMEOS_FLAG,
#define SEANDROID_FLAG (1 << 4) DHTB_FLAG,
#define LG_BUMP_FLAG (1 << 5) SEANDROID_FLAG,
#define SHA256_FLAG (1 << 6) LG_BUMP_FLAG,
#define BLOB_FLAG (1 << 7) SHA256_FLAG,
#define NOOKHD_FLAG (1 << 8) BLOB_FLAG,
#define ACCLAIM_FLAG (1 << 9) NOOKHD_FLAG,
ACCLAIM_FLAG,
BOOT_FLAGS_MAX
};
struct boot_img { struct boot_img {
// Memory map of the whole image // Memory map of the whole image
@ -403,7 +414,7 @@ struct boot_img {
dyn_img_hdr *hdr; dyn_img_hdr *hdr;
// Flags to indicate the state of current boot image // Flags to indicate the state of current boot image
uint16_t flags = 0; std::bitset<BOOT_FLAGS_MAX> flags;
// The format of kernel, ramdisk and extra // The format of kernel, ramdisk and extra
format_t k_fmt = UNKNOWN; format_t k_fmt = UNKNOWN;
@ -420,7 +431,6 @@ struct boot_img {
// Pointer to dtb that is embedded in kernel // Pointer to dtb that is embedded in kernel
uint8_t *kernel_dtb; uint8_t *kernel_dtb;
uint32_t kernel_dt_size = 0;
// Pointer to end of image // Pointer to end of image
uint8_t *tail; uint8_t *tail;

2
native/jni/magiskboot/magiskboot.hpp
View File

@ -13,7 +13,7 @@
#define NEW_BOOT "new-boot.img" #define NEW_BOOT "new-boot.img"
int unpack(const char *image, bool skip_decomp = false, bool hdr = false); int unpack(const char *image, bool skip_decomp = false, bool hdr = false);
void repack(const char* src_img, const char* out_img, bool skip_comp = false); void repack(const char *src_img, const char *out_img, bool skip_comp = false);
int split_image_dtb(const char *filename); int split_image_dtb(const char *filename);
int hexpatch(const char *image, const char *from, const char *to); int hexpatch(const char *image, const char *from, const char *to);
int cpio_commands(int argc, char *argv[]); int cpio_commands(int argc, char *argv[]);