am 185e8204: am c7f64fdf: Merge "Keep multiple kernel logs"
* commit '185e8204c6e29e2177721a30c73928fb4e5382fa':
Keep multiple kernel logs
diff --git a/uncrypt/Android.mk b/uncrypt/Android.mk
index 878d275..d832d97 100644
--- a/uncrypt/Android.mk
+++ b/uncrypt/Android.mk
@@ -16,7 +16,7 @@
include $(CLEAR_VARS)
-LOCAL_SRC_FILES := uncrypt.c
+LOCAL_SRC_FILES := uncrypt.cpp
LOCAL_MODULE := uncrypt
diff --git a/uncrypt/uncrypt.c b/uncrypt/uncrypt.cpp
similarity index 78%
rename from uncrypt/uncrypt.c
rename to uncrypt/uncrypt.cpp
index da035df..11766f1 100644
--- a/uncrypt/uncrypt.c
+++ b/uncrypt/uncrypt.cpp
@@ -62,9 +62,7 @@
static struct fstab* fstab = NULL;
-static int write_at_offset(unsigned char* buffer, size_t size,
- int wfd, off64_t offset)
-{
+static int write_at_offset(unsigned char* buffer, size_t size, int wfd, off64_t offset) {
if (TEMP_FAILURE_RETRY(lseek64(wfd, offset, SEEK_SET)) == -1) {
ALOGE("error seeking to offset %lld: %s\n", offset, strerror(errno));
return -1;
@@ -81,8 +79,7 @@
return 0;
}
-void add_block_to_ranges(int** ranges, int* range_alloc, int* range_used, int new_block)
-{
+static void add_block_to_ranges(int** ranges, int* range_alloc, int* range_used, int new_block) {
// If the current block start is < 0, set the start to the new
// block. (This only happens for the very first block of the very
// first range.)
@@ -101,7 +98,7 @@
// If there isn't enough room in the array, we need to expand it.
if (*range_used >= *range_alloc) {
*range_alloc *= 2;
- *ranges = realloc(*ranges, *range_alloc * 2 * sizeof(int));
+ *ranges = reinterpret_cast<int*>(realloc(*ranges, *range_alloc * 2 * sizeof(int)));
}
++*range_used;
@@ -110,8 +107,7 @@
}
}
-static struct fstab* read_fstab()
-{
+static struct fstab* read_fstab() {
fstab = NULL;
// The fstab path is always "/fstab.${ro.hardware}".
@@ -130,26 +126,26 @@
return fstab;
}
-const char* find_block_device(const char* path, int* encryptable, int* encrypted)
-{
+static const char* find_block_device(const char* path, bool* encryptable, bool* encrypted) {
// Look for a volume whose mount point is the prefix of path and
// return its block device. Set encrypted if it's currently
// encrypted.
- int i;
- for (i = 0; i < fstab->num_entries; ++i) {
+ for (int i = 0; i < fstab->num_entries; ++i) {
struct fstab_rec* v = &fstab->recs[i];
- if (!v->mount_point) continue;
+ if (!v->mount_point) {
+ continue;
+ }
int len = strlen(v->mount_point);
if (strncmp(path, v->mount_point, len) == 0 &&
(path[len] == '/' || path[len] == 0)) {
- *encrypted = 0;
- *encryptable = 0;
+ *encrypted = false;
+ *encryptable = false;
if (fs_mgr_is_encryptable(v)) {
- *encryptable = 1;
+ *encryptable = true;
char buffer[PROPERTY_VALUE_MAX+1];
if (property_get("ro.crypto.state", buffer, "") &&
strcmp(buffer, "encrypted") == 0) {
- *encrypted = 1;
+ *encrypted = true;
}
}
return v->blk_device;
@@ -159,12 +155,13 @@
return NULL;
}
-char* parse_recovery_command_file()
+// Parse the command file RECOVERY_COMMAND_FILE to find the update package
+// name. If it's on the /data partition, replace the package name with the
+// block map file name and store it temporarily in RECOVERY_COMMAND_FILE_TMP.
+// It will be renamed to RECOVERY_COMMAND_FILE if uncrypt finishes
+// successfully.
+static char* find_update_package()
{
- char* fn = NULL;
- int count = 0;
- char temp[1024];
-
FILE* f = fopen(RECOVERY_COMMAND_FILE, "r");
if (f == NULL) {
return NULL;
@@ -175,31 +172,40 @@
return NULL;
}
FILE* fo = fdopen(fd, "w");
-
- while (fgets(temp, sizeof(temp), f)) {
- printf("read: %s", temp);
- if (strncmp(temp, "--update_package=/data/", strlen("--update_package=/data/")) == 0) {
- fn = strdup(temp + strlen("--update_package="));
- strcpy(temp, "--update_package=@" CACHE_BLOCK_MAP "\n");
+ char* fn = NULL;
+ char* line = NULL;
+ size_t len = 0;
+ while (getline(&line, &len, f) != -1) {
+ if (strncmp(line, "--update_package=", strlen("--update_package=")) == 0) {
+ fn = strdup(line + strlen("--update_package="));
+ // Replace the package name with block map file if it's on /data partition.
+ if (strncmp(fn, "/data/", strlen("/data/")) == 0) {
+ fputs("--update_package=@" CACHE_BLOCK_MAP "\n", fo);
+ continue;
+ }
}
- fputs(temp, fo);
+ fputs(line, fo);
}
+ free(line);
fclose(f);
- fsync(fd);
+ if (fsync(fd) == -1) {
+ ALOGE("failed to fsync \"%s\": %s\n", RECOVERY_COMMAND_FILE_TMP, strerror(errno));
+ fclose(fo);
+ return NULL;
+ }
fclose(fo);
if (fn) {
char* newline = strchr(fn, '\n');
- if (newline) *newline = 0;
+ if (newline) {
+ *newline = 0;
+ }
}
return fn;
}
-int produce_block_map(const char* path, const char* map_file, const char* blk_dev,
- int encrypted)
-{
- struct stat sb;
- int ret;
+static int produce_block_map(const char* path, const char* map_file, const char* blk_dev,
+ bool encrypted) {
int mapfd = open(map_file, O_WRONLY | O_CREAT | O_SYNC, S_IRUSR | S_IWUSR);
if (mapfd < 0) {
@@ -208,7 +214,8 @@
}
FILE* mapf = fdopen(mapfd, "w");
- ret = stat(path, &sb);
+ struct stat sb;
+ int ret = stat(path, &sb);
if (ret != 0) {
ALOGE("failed to stat %s\n", path);
return -1;
@@ -219,20 +226,18 @@
int blocks = ((sb.st_size-1) / sb.st_blksize) + 1;
ALOGI(" file size: %lld bytes, %d blocks\n", (long long)sb.st_size, blocks);
- int* ranges;
int range_alloc = 1;
int range_used = 1;
- ranges = malloc(range_alloc * 2 * sizeof(int));
+ int* ranges = reinterpret_cast<int*>(malloc(range_alloc * 2 * sizeof(int)));
ranges[0] = -1;
ranges[1] = -1;
fprintf(mapf, "%s\n%lld %lu\n", blk_dev, (long long)sb.st_size, (unsigned long)sb.st_blksize);
unsigned char* buffers[WINDOW_SIZE];
- int i;
if (encrypted) {
- for (i = 0; i < WINDOW_SIZE; ++i) {
- buffers[i] = malloc(sb.st_blksize);
+ for (size_t i = 0; i < WINDOW_SIZE; ++i) {
+ buffers[i] = reinterpret_cast<unsigned char*>(malloc(sb.st_blksize));
}
}
int head_block = 0;
@@ -244,7 +249,6 @@
ALOGE("failed to open fd for reading: %s\n", strerror(errno));
return -1;
}
- fsync(fd);
int wfd = -1;
if (encrypted) {
@@ -266,7 +270,8 @@
}
add_block_to_ranges(&ranges, &range_alloc, &range_used, block);
if (encrypted) {
- if (write_at_offset(buffers[head], sb.st_blksize, wfd, (off64_t)sb.st_blksize * block) != 0) {
+ if (write_at_offset(buffers[head], sb.st_blksize, wfd,
+ (off64_t)sb.st_blksize * block) != 0) {
return -1;
}
}
@@ -306,7 +311,8 @@
}
add_block_to_ranges(&ranges, &range_alloc, &range_used, block);
if (encrypted) {
- if (write_at_offset(buffers[head], sb.st_blksize, wfd, (off64_t)sb.st_blksize * block) != 0) {
+ if (write_at_offset(buffers[head], sb.st_blksize, wfd,
+ (off64_t)sb.st_blksize * block) != 0) {
return -1;
}
}
@@ -315,25 +321,30 @@
}
fprintf(mapf, "%d\n", range_used);
- for (i = 0; i < range_used; ++i) {
+ for (int i = 0; i < range_used; ++i) {
fprintf(mapf, "%d %d\n", ranges[i*2], ranges[i*2+1]);
}
- fsync(mapfd);
+ if (fsync(mapfd) == -1) {
+ ALOGE("failed to fsync \"%s\": %s\n", map_file, strerror(errno));
+ return -1;
+ }
fclose(mapf);
close(fd);
if (encrypted) {
- fsync(wfd);
+ if (fsync(wfd) == -1) {
+ ALOGE("failed to fsync \"%s\": %s\n", blk_dev, strerror(errno));
+ return -1;
+ }
close(wfd);
}
return 0;
}
-void wipe_misc() {
+static void wipe_misc() {
ALOGI("removing old commands from misc");
- int i;
- for (i = 0; i < fstab->num_entries; ++i) {
+ for (int i = 0; i < fstab->num_entries; ++i) {
struct fstab_rec* v = &fstab->recs[i];
if (!v->mount_point) continue;
if (strcmp(v->mount_point, "/misc") == 0) {
@@ -352,13 +363,17 @@
written += w;
}
}
- fsync(fd);
+ if (fsync(fd) == -1) {
+ ALOGE("failed to fsync \"%s\": %s\n", v->blk_device, strerror(errno));
+ close(fd);
+ return;
+ }
close(fd);
}
}
}
-void reboot_to_recovery() {
+static void reboot_to_recovery() {
ALOGI("rebooting to recovery");
property_set("sys.powerctl", "reboot,recovery");
sleep(10);
@@ -369,7 +384,7 @@
{
const char* input_path;
const char* map_file;
- int do_reboot = 1;
+ bool do_reboot = true;
if (argc != 1 && argc != 3) {
fprintf(stderr, "usage: %s [<transform_path> <map_file>]\n", argv[0]);
@@ -381,9 +396,9 @@
// for debugging; don't reboot to recovery at the end.
input_path = argv[1];
map_file = argv[2];
- do_reboot = 0;
+ do_reboot = false;
} else {
- input_path = parse_recovery_command_file();
+ input_path = find_update_package();
if (input_path == NULL) {
// if we're rebooting to recovery without a package (say,
// to wipe data), then we don't need to do anything before
@@ -405,11 +420,12 @@
return 1;
}
- int encryptable;
- int encrypted;
if (read_fstab() == NULL) {
return 1;
}
+
+ bool encryptable;
+ bool encrypted;
const char* blk_dev = find_block_device(path, &encryptable, &encrypted);
if (blk_dev == NULL) {
ALOGE("failed to find block device for %s", path);
@@ -432,15 +448,18 @@
if (strncmp(path, "/data/", 6) != 0) {
// path does not start with "/data/"; leave it alone.
unlink(RECOVERY_COMMAND_FILE_TMP);
+ wipe_misc();
} else {
ALOGI("writing block map %s", map_file);
if (produce_block_map(path, map_file, blk_dev, encrypted) != 0) {
return 1;
}
+ wipe_misc();
+ rename(RECOVERY_COMMAND_FILE_TMP, RECOVERY_COMMAND_FILE);
}
- wipe_misc();
- rename(RECOVERY_COMMAND_FILE_TMP, RECOVERY_COMMAND_FILE);
- if (do_reboot) reboot_to_recovery();
+ if (do_reboot) {
+ reboot_to_recovery();
+ }
return 0;
}