tequilaOS/platform_bootable_recovery
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Create bootloader_message static library.

Browse source 
bootloader_messages merges bootloader_message_writer
and bootloader.cpp, so we can use the same library to
manage bootloader_message in normal boot and recovery mode.

Bug: 29582118

Change-Id: I9efdf776ef8f02b53911ff43a518e035e0c29618
This commit is contained in:
Yabin Cui 2016-06-24 18:22:02 -07:00
parent 6074099cb9
commit 2f272c0551
10 changed files with 227 additions and 381 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
Android.mk
View file

@ -31,7 +31,6 @@ include $(CLEAR_VARS)
LOCAL_SRC_FILES := \ LOCAL_SRC_FILES := \
adb_install.cpp \ adb_install.cpp \
asn1_decoder.cpp \ asn1_decoder.cpp \
bootloader.cpp \
device.cpp \ device.cpp \
fuse_sdcard_provider.cpp \ fuse_sdcard_provider.cpp \
install.cpp \ install.cpp \
@ -66,6 +65,7 @@ LOCAL_C_INCLUDES += \
LOCAL_STATIC_LIBRARIES := \ LOCAL_STATIC_LIBRARIES := \
libbatterymonitor \ libbatterymonitor \
libbootloader_message \
libext4_utils_static \ libext4_utils_static \
libsparse_static \ libsparse_static \
libminzip \ libminzip \
@ -143,15 +143,17 @@ LOCAL_SRC_FILES := \
LOCAL_STATIC_LIBRARIES := libcrypto_static LOCAL_STATIC_LIBRARIES := libcrypto_static
include $(BUILD_STATIC_LIBRARY) include $(BUILD_STATIC_LIBRARY)
include $(LOCAL_PATH)/minui/Android.mk \ include \
$(LOCAL_PATH)/applypatch/Android.mk \
$(LOCAL_PATH)/bootloader_message/Android.mk \
$(LOCAL_PATH)/edify/Android.mk \
$(LOCAL_PATH)/minui/Android.mk \
$(LOCAL_PATH)/minzip/Android.mk \ $(LOCAL_PATH)/minzip/Android.mk \
$(LOCAL_PATH)/minadbd/Android.mk \ $(LOCAL_PATH)/minadbd/Android.mk \
$(LOCAL_PATH)/mtdutils/Android.mk \ $(LOCAL_PATH)/mtdutils/Android.mk \
$(LOCAL_PATH)/otafault/Android.mk \
$(LOCAL_PATH)/tests/Android.mk \ $(LOCAL_PATH)/tests/Android.mk \
$(LOCAL_PATH)/tools/Android.mk \ $(LOCAL_PATH)/tools/Android.mk \
$(LOCAL_PATH)/edify/Android.mk \
$(LOCAL_PATH)/uncrypt/Android.mk \ $(LOCAL_PATH)/uncrypt/Android.mk \
$(LOCAL_PATH)/otafault/Android.mk \
$(LOCAL_PATH)/updater/Android.mk \ $(LOCAL_PATH)/updater/Android.mk \
$(LOCAL_PATH)/update_verifier/Android.mk \ $(LOCAL_PATH)/update_verifier/Android.mk \
$(LOCAL_PATH)/applypatch/Android.mk

235
bootloader.cpp
View file

@ -1,235 +0,0 @@
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fs_mgr.h>
#include <android-base/file.h>
#include "bootloader.h"
#include "common.h"
#include "mtdutils/mtdutils.h"
#include "roots.h"
#include "unique_fd.h"
static int get_bootloader_message_mtd(bootloader_message* out, const Volume* v);
static int set_bootloader_message_mtd(const bootloader_message* in, const Volume* v);
static bool read_misc_partition(const Volume* v, size_t offset, size_t size, std::string* out);
static bool write_misc_partition(const Volume* v, size_t offset, const std::string& in);
int get_bootloader_message(bootloader_message* out) {
Volume* v = volume_for_path("/misc");
if (v == nullptr) {
LOGE("Cannot load volume /misc!\n");
return -1;
}
if (strcmp(v->fs_type, "mtd") == 0) {
return get_bootloader_message_mtd(out, v);
} else if (strcmp(v->fs_type, "emmc") == 0) {
std::string s;
if (!read_misc_partition(v, BOOTLOADER_MESSAGE_OFFSET_IN_MISC, sizeof(bootloader_message),
&s)) {
return -1;
}
memcpy(out, s.data(), s.size());
return 0;
}
LOGE("Unknown misc partition fs_type \"%s\"\n", v->fs_type);
return -1;
}
bool read_wipe_package(size_t size, std::string* out) {
Volume* v = volume_for_path("/misc");
if (v == nullptr) {
LOGE("Cannot load volume /misc!\n");
return false;
}
if (strcmp(v->fs_type, "mtd") == 0) {
LOGE("Read wipe package on mtd is not supported.\n");
return false;
} else if (strcmp(v->fs_type, "emmc") == 0) {
return read_misc_partition(v, WIPE_PACKAGE_OFFSET_IN_MISC, size, out);
}
LOGE("Unknown misc partition fs_type \"%s\"\n", v->fs_type);
return false;
}
int set_bootloader_message(const bootloader_message* in) {
Volume* v = volume_for_path("/misc");
if (v == nullptr) {
LOGE("Cannot load volume /misc!\n");
return -1;
}
if (strcmp(v->fs_type, "mtd") == 0) {
return set_bootloader_message_mtd(in, v);
} else if (strcmp(v->fs_type, "emmc") == 0) {
std::string s(reinterpret_cast<const char*>(in), sizeof(*in));
bool success = write_misc_partition(v, BOOTLOADER_MESSAGE_OFFSET_IN_MISC, s);
return success ? 0 : -1;
}
LOGE("Unknown misc partition fs_type \"%s\"\n", v->fs_type);
return -1;
}
// ------------------------------
// for misc partitions on MTD
// ------------------------------
static const int MISC_PAGES = 3; // number of pages to save
static const int MISC_COMMAND_PAGE = 1; // bootloader command is this page
static int get_bootloader_message_mtd(bootloader_message* out,
const Volume* v) {
size_t write_size;
mtd_scan_partitions();
const MtdPartition* part = mtd_find_partition_by_name(v->blk_device);
if (part == nullptr || mtd_partition_info(part, nullptr, nullptr, &write_size)) {
LOGE("failed to find \"%s\"\n", v->blk_device);
return -1;
}
MtdReadContext* read = mtd_read_partition(part);
if (read == nullptr) {
LOGE("failed to open \"%s\": %s\n", v->blk_device, strerror(errno));
return -1;
}
const ssize_t size = write_size * MISC_PAGES;
char data[size];
ssize_t r = mtd_read_data(read, data, size);
if (r != size) LOGE("failed to read \"%s\": %s\n", v->blk_device, strerror(errno));
mtd_read_close(read);
if (r != size) return -1;
memcpy(out, &data[write_size * MISC_COMMAND_PAGE], sizeof(*out));
return 0;
}
static int set_bootloader_message_mtd(const bootloader_message* in,
const Volume* v) {
size_t write_size;
mtd_scan_partitions();
const MtdPartition* part = mtd_find_partition_by_name(v->blk_device);
if (part == nullptr || mtd_partition_info(part, nullptr, nullptr, &write_size)) {
LOGE("failed to find \"%s\"\n", v->blk_device);
return -1;
}
MtdReadContext* read = mtd_read_partition(part);
if (read == nullptr) {
LOGE("failed to open \"%s\": %s\n", v->blk_device, strerror(errno));
return -1;
}
ssize_t size = write_size * MISC_PAGES;
char data[size];
ssize_t r = mtd_read_data(read, data, size);
if (r != size) LOGE("failed to read \"%s\": %s\n", v->blk_device, strerror(errno));
mtd_read_close(read);
if (r != size) return -1;
memcpy(&data[write_size * MISC_COMMAND_PAGE], in, sizeof(*in));
MtdWriteContext* write = mtd_write_partition(part);
if (write == nullptr) {
LOGE("failed to open \"%s\": %s\n", v->blk_device, strerror(errno));
return -1;
}
if (mtd_write_data(write, data, size) != size) {
LOGE("failed to write \"%s\": %s\n", v->blk_device, strerror(errno));
mtd_write_close(write);
return -1;
}
if (mtd_write_close(write)) {
LOGE("failed to finish \"%s\": %s\n", v->blk_device, strerror(errno));
return -1;
}
LOGI("Set boot command \"%s\"\n", in->command[0] != 255 ? in->command : "");
return 0;
}
// ------------------------------------
// for misc partitions on block devices
// ------------------------------------
static void wait_for_device(const char* fn) {
int tries = 0;
int ret;
do {
++tries;
struct stat buf;
ret = stat(fn, &buf);
if (ret == -1) {
printf("failed to stat \"%s\" try %d: %s\n", fn, tries, strerror(errno));
sleep(1);
}
} while (ret && tries < 10);
if (ret) {
printf("failed to stat \"%s\"\n", fn);
}
}
static bool read_misc_partition(const Volume* v, size_t offset, size_t size, std::string* out) {
wait_for_device(v->blk_device);
unique_fd fd(open(v->blk_device, O_RDONLY));
if (fd.get() == -1) {
LOGE("Failed to open \"%s\": %s\n", v->blk_device, strerror(errno));
return false;
}
if (lseek(fd.get(), static_cast<off_t>(offset), SEEK_SET) != static_cast<off_t>(offset)) {
LOGE("Failed to lseek \"%s\": %s\n", v->blk_device, strerror(errno));
return false;
}
out->resize(size);
if (!android::base::ReadFully(fd.get(), &(*out)[0], size)) {
LOGE("Failed to read \"%s\": %s\n", v->blk_device, strerror(errno));
return false;
}
return true;
}
static bool write_misc_partition(const Volume* v, size_t offset, const std::string& in) {
wait_for_device(v->blk_device);
unique_fd fd(open(v->blk_device, O_WRONLY | O_SYNC));
if (fd.get() == -1) {
LOGE("Failed to open \"%s\": %s\n", v->blk_device, strerror(errno));
return false;
}
if (lseek(fd.get(), static_cast<off_t>(offset), SEEK_SET) != static_cast<off_t>(offset)) {
LOGE("Failed to lseek \"%s\": %s\n", v->blk_device, strerror(errno));
return false;
}
if (!android::base::WriteFully(fd.get(), in.data(), in.size())) {
LOGE("Failed to write \"%s\": %s\n", v->blk_device, strerror(errno));
return false;
}
if (fsync(fd.get()) == -1) {
LOGE("Failed to fsync \"%s\": %s\n", v->blk_device, strerror(errno));
return false;
}
return true;
}

75
bootloader.h
View file

@ -14,76 +14,5 @@
* limitations under the License. * limitations under the License.
*/ */
#ifndef _RECOVERY_BOOTLOADER_H // TODO: Remove this file once we remove all places that include this file.
#define _RECOVERY_BOOTLOADER_H #include "bootloader_message/include/bootloader_message/bootloader_message.h"
#include <stddef.h>
// Spaces used by misc partition are as below:
// 0 - 2K Bootloader Message
// 2K - 16K Used by Vendor's bootloader
// 16K - 64K Used by uncrypt and recovery to store wipe_package for A/B devices
// Note that these offsets are admitted by bootloader,recovery and uncrypt, so they
// are not configurable without changing all of them.
static const size_t BOOTLOADER_MESSAGE_OFFSET_IN_MISC = 0;
static const size_t WIPE_PACKAGE_OFFSET_IN_MISC = 16 * 1024;
/* Bootloader Message
*
* This structure describes the content of a block in flash
* that is used for recovery and the bootloader to talk to
* each other.
*
* The command field is updated by linux when it wants to
* reboot into recovery or to update radio or bootloader firmware.
* It is also updated by the bootloader when firmware update
* is complete (to boot into recovery for any final cleanup)
*
* The status field is written by the bootloader after the
* completion of an "update-radio" or "update-hboot" command.
*
* The recovery field is only written by linux and used
* for the system to send a message to recovery or the
* other way around.
*
* The stage field is written by packages which restart themselves
* multiple times, so that the UI can reflect which invocation of the
* package it is. If the value is of the format "#/#" (eg, "1/3"),
* the UI will add a simple indicator of that status.
*
* The slot_suffix field is used for A/B implementations where the
* bootloader does not set the androidboot.ro.boot.slot_suffix kernel
* commandline parameter. This is used by fs_mgr to mount /system and
* other partitions with the slotselect flag set in fstab. A/B
* implementations are free to use all 32 bytes and may store private
* data past the first NUL-byte in this field.
*/
struct bootloader_message {
char command[32];
char status[32];
char recovery[768];
// The 'recovery' field used to be 1024 bytes. It has only ever
// been used to store the recovery command line, so 768 bytes
// should be plenty. We carve off the last 256 bytes to store the
// stage string (for multistage packages) and possible future
// expansion.
char stage[32];
char slot_suffix[32];
char reserved[192];
};
/* Read and write the bootloader command from the "misc" partition.
* These return zero on success.
*/
int get_bootloader_message(struct bootloader_message *out);
int set_bootloader_message(const struct bootloader_message *in);
#ifdef __cplusplus
#include <string>
bool read_wipe_package(size_t size, std::string* out);
#endif
#endif

24
bootloader_message/Android.mk Normal file
View file

@ -0,0 +1,24 @@
# Copyright (C) 2016 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_CLANG := true
LOCAL_SRC_FILES := bootloader_message.cpp
LOCAL_MODULE := libbootloader_message
LOCAL_STATIC_LIBRARIES := libbase libfs_mgr
LOCAL_C_INCLUDES := $(LOCAL_PATH)/include
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
include $(BUILD_STATIC_LIBRARY)

70
uncrypt/bootloader_message_writer.cpp → bootloader_message/bootloader_message.cpp
View file

@ -14,6 +14,8 @@
* limitations under the License. * limitations under the License.
*/ */
#include <bootloader_message/bootloader_message.h>
#include <errno.h> #include <errno.h>
#include <fcntl.h> #include <fcntl.h>
#include <string.h> #include <string.h>
@ -27,8 +29,6 @@
#include <android-base/unique_fd.h> #include <android-base/unique_fd.h>
#include <fs_mgr.h> #include <fs_mgr.h>
#include "bootloader.h"
static struct fstab* read_fstab(std::string* err) { static struct fstab* read_fstab(std::string* err) {
// The fstab path is always "/fstab.${ro.hardware}". // The fstab path is always "/fstab.${ro.hardware}".
std::string fstab_path = "/fstab."; std::string fstab_path = "/fstab.";
@ -58,7 +58,57 @@ static std::string get_misc_blk_device(std::string* err) {
return record->blk_device; return record->blk_device;
} }
static bool write_misc_partition(const void* p, size_t size, size_t misc_offset, std::string* err) { // In recovery mode, recovery can get started and try to access the misc
// device before the kernel has actually created it.
static bool wait_for_device(const std::string& blk_device, std::string* err) {
int tries = 0;
int ret;
err->clear();
do {
++tries;
struct stat buf;
ret = stat(blk_device.c_str(), &buf);
if (ret == -1) {
*err += android::base::StringPrintf("failed to stat %s try %d: %s\n",
blk_device.c_str(), tries, strerror(errno));
sleep(1);
}
} while (ret && tries < 10);
if (ret) {
*err += android::base::StringPrintf("failed to stat %s\n", blk_device.c_str());
}
return ret == 0;
}
static bool read_misc_partition(void* p, size_t size, size_t offset, std::string* err) {
std::string misc_blk_device = get_misc_blk_device(err);
if (misc_blk_device.empty()) {
return false;
}
if (!wait_for_device(misc_blk_device, err)) {
return false;
}
android::base::unique_fd fd(open(misc_blk_device.c_str(), O_WRONLY | O_SYNC));
if (fd.get() == -1) {
*err = android::base::StringPrintf("failed to open %s: %s", misc_blk_device.c_str(),
strerror(errno));
return false;
}
if (lseek(fd.get(), static_cast<off_t>(offset), SEEK_SET) != static_cast<off_t>(offset)) {
*err = android::base::StringPrintf("failed to lseek %s: %s", misc_blk_device.c_str(),
strerror(errno));
return false;
}
if (!android::base::ReadFully(fd.get(), p, size)) {
*err = android::base::StringPrintf("failed to read %s: %s", misc_blk_device.c_str(),
strerror(errno));
return false;
}
return true;
}
static bool write_misc_partition(const void* p, size_t size, size_t offset, std::string* err) {
std::string misc_blk_device = get_misc_blk_device(err); std::string misc_blk_device = get_misc_blk_device(err);
if (misc_blk_device.empty()) { if (misc_blk_device.empty()) {
return false; return false;
@ -69,8 +119,7 @@ static bool write_misc_partition(const void* p, size_t size, size_t misc_offset,
strerror(errno)); strerror(errno));
return false; return false;
} }
if (lseek(fd.get(), static_cast<off_t>(misc_offset), SEEK_SET) != if (lseek(fd.get(), static_cast<off_t>(offset), SEEK_SET) != static_cast<off_t>(offset)) {
static_cast<off_t>(misc_offset)) {
*err = android::base::StringPrintf("failed to lseek %s: %s", misc_blk_device.c_str(), *err = android::base::StringPrintf("failed to lseek %s: %s", misc_blk_device.c_str(),
strerror(errno)); strerror(errno));
return false; return false;
@ -90,7 +139,11 @@ static bool write_misc_partition(const void* p, size_t size, size_t misc_offset,
return true; return true;
} }
static bool write_bootloader_message(const bootloader_message& boot, std::string* err) { bool read_bootloader_message(bootloader_message* boot, std::string* err) {
return read_misc_partition(boot, sizeof(*boot), BOOTLOADER_MESSAGE_OFFSET_IN_MISC, err);
}
bool write_bootloader_message(const bootloader_message& boot, std::string* err) {
return write_misc_partition(&boot, sizeof(boot), BOOTLOADER_MESSAGE_OFFSET_IN_MISC, err); return write_misc_partition(&boot, sizeof(boot), BOOTLOADER_MESSAGE_OFFSET_IN_MISC, err);
} }
@ -112,6 +165,11 @@ bool write_bootloader_message(const std::vector<std::string>& options, std::stri
return write_bootloader_message(boot, err); return write_bootloader_message(boot, err);
} }
bool read_wipe_package(std::string* package_data, size_t size, std::string* err) {
package_data->resize(size);
return read_misc_partition(&(*package_data)[0], size, WIPE_PACKAGE_OFFSET_IN_MISC, err);
}
bool write_wipe_package(const std::string& package_data, std::string* err) { bool write_wipe_package(const std::string& package_data, std::string* err) {
return write_misc_partition(package_data.data(), package_data.size(), return write_misc_partition(package_data.data(), package_data.size(),
WIPE_PACKAGE_OFFSET_IN_MISC, err); WIPE_PACKAGE_OFFSET_IN_MISC, err);

99
bootloader_message/include/bootloader_message/bootloader_message.h Normal file
View file

@ -0,0 +1,99 @@
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef _BOOTLOADER_MESSAGE_H
#define _BOOTLOADER_MESSAGE_H
#include <stddef.h>
// Spaces used by misc partition are as below:
// 0 - 2K Bootloader Message
// 2K - 16K Used by Vendor's bootloader
// 16K - 64K Used by uncrypt and recovery to store wipe_package for A/B devices
// Note that these offsets are admitted by bootloader,recovery and uncrypt, so they
// are not configurable without changing all of them.
static const size_t BOOTLOADER_MESSAGE_OFFSET_IN_MISC = 0;
static const size_t WIPE_PACKAGE_OFFSET_IN_MISC = 16 * 1024;
/* Bootloader Message
*
* This structure describes the content of a block in flash
* that is used for recovery and the bootloader to talk to
* each other.
*
* The command field is updated by linux when it wants to
* reboot into recovery or to update radio or bootloader firmware.
* It is also updated by the bootloader when firmware update
* is complete (to boot into recovery for any final cleanup)
*
* The status field is written by the bootloader after the
* completion of an "update-radio" or "update-hboot" command.
*
* The recovery field is only written by linux and used
* for the system to send a message to recovery or the
* other way around.
*
* The stage field is written by packages which restart themselves
* multiple times, so that the UI can reflect which invocation of the
* package it is. If the value is of the format "#/#" (eg, "1/3"),
* the UI will add a simple indicator of that status.
*
* The slot_suffix field is used for A/B implementations where the
* bootloader does not set the androidboot.ro.boot.slot_suffix kernel
* commandline parameter. This is used by fs_mgr to mount /system and
* other partitions with the slotselect flag set in fstab. A/B
* implementations are free to use all 32 bytes and may store private
* data past the first NUL-byte in this field.
*/
struct bootloader_message {
char command[32];
char status[32];
char recovery[768];
// The 'recovery' field used to be 1024 bytes. It has only ever
// been used to store the recovery command line, so 768 bytes
// should be plenty. We carve off the last 256 bytes to store the
// stage string (for multistage packages) and possible future
// expansion.
char stage[32];
char slot_suffix[32];
char reserved[192];
};
#ifdef __cplusplus
#include <string>
#include <vector>
bool read_bootloader_message(bootloader_message* boot, std::string* err);
bool write_bootloader_message(const bootloader_message& boot, std::string* err);
bool write_bootloader_message(const std::vector<std::string>& options, std::string* err);
bool clear_bootloader_message(std::string* err);
bool read_wipe_package(std::string* package_data, size_t size, std::string* err);
bool write_wipe_package(const std::string& package_data, std::string* err);
#else
#include <stdbool.h>
// C Interface.
bool write_bootloader_message(const char* options);
#endif // ifdef __cplusplus
#endif // _BOOTLOADER_MESSAGE_H

44
recovery.cpp
View file

@ -44,6 +44,7 @@
#include <android-base/parseint.h> #include <android-base/parseint.h>
#include <android-base/stringprintf.h> #include <android-base/stringprintf.h>
#include <android-base/strings.h> #include <android-base/strings.h>
#include <bootloader_message/bootloader_message.h>
#include <cutils/android_reboot.h> #include <cutils/android_reboot.h>
#include <cutils/properties.h> #include <cutils/properties.h>
#include <log/logger.h> /* Android Log packet format */ #include <log/logger.h> /* Android Log packet format */
@ -52,7 +53,6 @@
#include <healthd/BatteryMonitor.h> #include <healthd/BatteryMonitor.h>
#include "adb_install.h" #include "adb_install.h"
#include "bootloader.h"
#include "common.h" #include "common.h"
#include "device.h" #include "device.h"
#include "error_code.h" #include "error_code.h"
@ -303,9 +303,13 @@ static void redirect_stdio(const char* filename) {
// - the contents of COMMAND_FILE (one per line) // - the contents of COMMAND_FILE (one per line)
static void static void
get_args(int *argc, char ***argv) { get_args(int *argc, char ***argv) {
struct bootloader_message boot; bootloader_message boot = {};
memset(&boot, 0, sizeof(boot)); std::string err;
get_bootloader_message(&boot); // this may fail, leaving a zeroed structure if (!read_bootloader_message(&boot, &err)) {
LOGE("%s\n", err.c_str());
// If fails, leave a zeroed bootloader_message.
memset(&boot, 0, sizeof(boot));
}
stage = strndup(boot.stage, sizeof(boot.stage)); stage = strndup(boot.stage, sizeof(boot.stage));
if (boot.command[0] != 0 && boot.command[0] != 255) { if (boot.command[0] != 0 && boot.command[0] != 255) {
@ -367,16 +371,20 @@ get_args(int *argc, char ***argv) {
strlcat(boot.recovery, (*argv)[i], sizeof(boot.recovery)); strlcat(boot.recovery, (*argv)[i], sizeof(boot.recovery));
strlcat(boot.recovery, "\n", sizeof(boot.recovery)); strlcat(boot.recovery, "\n", sizeof(boot.recovery));
} }
set_bootloader_message(&boot); if (!write_bootloader_message(boot, &err)) {
LOGE("%s\n", err.c_str());
}
} }
static void static void
set_sdcard_update_bootloader_message() { set_sdcard_update_bootloader_message() {
struct bootloader_message boot; bootloader_message boot = {};
memset(&boot, 0, sizeof(boot));
strlcpy(boot.command, "boot-recovery", sizeof(boot.command)); strlcpy(boot.command, "boot-recovery", sizeof(boot.command));
strlcpy(boot.recovery, "recovery\n", sizeof(boot.recovery)); strlcpy(boot.recovery, "recovery\n", sizeof(boot.recovery));
set_bootloader_message(&boot); std::string err;
if (!write_bootloader_message(boot, &err)) {
LOGE("%s\n", err.c_str());
}
} }
// Read from kernel log into buffer and write out to file. // Read from kernel log into buffer and write out to file.
@ -537,9 +545,11 @@ finish_recovery(const char *send_intent) {
copy_logs(); copy_logs();
// Reset to normal system boot so recovery won't cycle indefinitely. // Reset to normal system boot so recovery won't cycle indefinitely.
struct bootloader_message boot; bootloader_message boot = {};
memset(&boot, 0, sizeof(boot)); std::string err;
set_bootloader_message(&boot); if (!write_bootloader_message(boot, &err)) {
LOGE("%s\n", err.c_str());
}
// Remove the command file, so recovery won't repeat indefinitely. // Remove the command file, so recovery won't repeat indefinitely.
if (has_cache) { if (has_cache) {
@ -916,8 +926,9 @@ static bool check_wipe_package(size_t wipe_package_size) {
return false; return false;
} }
std::string wipe_package; std::string wipe_package;
if (!read_wipe_package(wipe_package_size, &wipe_package)) { std::string err_str;
LOGE("Failed to read wipe package.\n"); if (!read_wipe_package(&wipe_package, wipe_package_size, &err_str)) {
LOGE("Failed to read wipe package: %s\n", err_str.c_str());
return false; return false;
} }
if (!verify_package(reinterpret_cast<const unsigned char*>(wipe_package.data()), if (!verify_package(reinterpret_cast<const unsigned char*>(wipe_package.data()),
@ -1369,7 +1380,7 @@ static bool is_battery_ok() {
} }
static void set_retry_bootloader_message(int retry_count, int argc, char** argv) { static void set_retry_bootloader_message(int retry_count, int argc, char** argv) {
struct bootloader_message boot {}; bootloader_message boot = {};
strlcpy(boot.command, "boot-recovery", sizeof(boot.command)); strlcpy(boot.command, "boot-recovery", sizeof(boot.command));
strlcpy(boot.recovery, "recovery\n", sizeof(boot.recovery)); strlcpy(boot.recovery, "recovery\n", sizeof(boot.recovery));
@ -1388,7 +1399,10 @@ static void set_retry_bootloader_message(int retry_count, int argc, char** argv)
snprintf(buffer, sizeof(buffer), "--retry_count=%d\n", retry_count+1); snprintf(buffer, sizeof(buffer), "--retry_count=%d\n", retry_count+1);
strlcat(boot.recovery, buffer, sizeof(boot.recovery)); strlcat(boot.recovery, buffer, sizeof(boot.recovery));
} }
set_bootloader_message(&boot); std::string err;
if (!write_bootloader_message(boot, &err)) {
LOGE("%s\n", err.c_str());
}
} }
static ssize_t logbasename( static ssize_t logbasename(

11
uncrypt/Android.mk
View file

@ -14,15 +14,6 @@
LOCAL_PATH := $(call my-dir) LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
LOCAL_CLANG := true
LOCAL_SRC_FILES := bootloader_message_writer.cpp
LOCAL_MODULE := libbootloader_message_writer
LOCAL_STATIC_LIBRARIES := libbase libfs_mgr
LOCAL_C_INCLUDES := $(LOCAL_PATH)/..
LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
include $(BUILD_STATIC_LIBRARY)
include $(CLEAR_VARS) include $(CLEAR_VARS)
LOCAL_CLANG := true LOCAL_CLANG := true
@ -33,7 +24,7 @@ LOCAL_C_INCLUDES := $(LOCAL_PATH)/..
LOCAL_MODULE := uncrypt LOCAL_MODULE := uncrypt
LOCAL_STATIC_LIBRARIES := libbootloader_message_writer libbase \ LOCAL_STATIC_LIBRARIES := libbootloader_message libbase \
liblog libfs_mgr libcutils \ liblog libfs_mgr libcutils \
LOCAL_INIT_RC := uncrypt.rc LOCAL_INIT_RC := uncrypt.rc

36
uncrypt/include/bootloader_message_writer.h
View file

@ -1,36 +0,0 @@
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef BOOTLOADER_MESSAGE_WRITER_H
#define BOOTLOADER_MESSAGE_WRITER_H
#ifdef __cplusplus
#include <string>
#include <vector>
bool clear_bootloader_message(std::string* err);
bool write_bootloader_message(const std::vector<std::string>& options, std::string* err);
bool write_wipe_package(const std::string& package_data, std::string* err);
#else
#include <stdbool.h>
// C Interface.
bool write_bootloader_message(const char* options);
#endif
#endif // BOOTLOADER_MESSAGE_WRITER_H

2
uncrypt/uncrypt.cpp
View file

@ -109,7 +109,7 @@
#include <android-base/logging.h> #include <android-base/logging.h>
#include <android-base/stringprintf.h> #include <android-base/stringprintf.h>
#include <android-base/strings.h> #include <android-base/strings.h>
#include <bootloader_message_writer.h> #include <bootloader_message/bootloader_message.h>
#include <cutils/android_reboot.h> #include <cutils/android_reboot.h>
#include <cutils/properties.h> #include <cutils/properties.h>
#include <cutils/sockets.h> #include <cutils/sockets.h>