openkylin
/
platform_build
mirror of https://gitee.com/openkylin/platform_build.git
9
0
Fork 1
Code Issues Projects Releases Wiki Activity

applypatch changes for patching recovery image 

Make some changes needed to applypatch in order to store the recovery
image in the system partition as a binary patch relative to the boot
image:

  - make applypatch use shared libraries, so it's smaller.  It will
    need to be on the main system so it can install the recovery
    image.  Make an applypatch_static binary for use in recovery
    packages (still needed for updating cupcake devices to donut).

  - output the results of patching to an in-memory buffer and write
    that to the partition; there's no convenient /tmp for us to us.
    (This should be basically a no-op in recovery, since /tmp is a
    ramdisk anyway.)
This commit is contained in:
Doug Zongker 2009-07-22 18:27:31 -07:00
parent 289d80eee4
commit 6c770467fb
7 changed files with 101 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
core/Makefile
View File

@ -788,6 +788,7 @@ endef
built_ota_tools := \
$(call intermediates-dir-for,EXECUTABLES,applypatch)/applypatch \
$(call intermediates-dir-for,EXECUTABLES,applypatch_static)/applypatch_static \
$(call intermediates-dir-for,EXECUTABLES,check_prereq)/check_prereq \
$(call intermediates-dir-for,EXECUTABLES,updater)/updater
$(BUILT_TARGET_FILES_PACKAGE): PRIVATE_OTA_TOOLS := $(built_ota_tools)

14
tools/applypatch/Android.mk
View File

@ -29,11 +29,19 @@ include $(CLEAR_VARS)
LOCAL_SRC_FILES := main.c
LOCAL_MODULE := applypatch
LOCAL_STATIC_LIBRARIES += libapplypatch libmtdutils libmincrypt libbz
LOCAL_SHARED_LIBRARIES += libz libcutils libstdc++ libc
include $(BUILD_EXECUTABLE)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := main.c
LOCAL_MODULE := applypatch_static
LOCAL_FORCE_STATIC_EXECUTABLE := true
LOCAL_MODULE_TAGS := eng
LOCAL_STATIC_LIBRARIES += libapplypatch
LOCAL_STATIC_LIBRARIES += libmtdutils libmincrypt libbz libz
LOCAL_STATIC_LIBRARIES += libcutils libstdc++ libc
LOCAL_STATIC_LIBRARIES += libapplypatch libmtdutils libmincrypt libbz
LOCAL_STATIC_LIBRARIES += libz libcutils libstdc++ libc
include $(BUILD_EXECUTABLE)

103
tools/applypatch/applypatch.c
View File

@ -282,9 +282,10 @@ int SaveFileContents(const char* filename, FileContents file) {
return 0;
}
// Copy the contents of source_file to target_mtd partition, a string
// of the form "MTD:<partition>[:...]". Return 0 on success.
int CopyToMTDPartition(const char* source_file, const char* target_mtd) {
// Write a memory buffer to target_mtd partition, a string of the form
// "MTD:<partition>[:...]". Return 0 on success.
int WriteToMTDPartition(unsigned char* data, size_t len,
const char* target_mtd) {
char* partition = strchr(target_mtd, ':');
if (partition == NULL) {
fprintf(stderr, "bad MTD target name \"%s\"\n", target_mtd);
@ -298,13 +299,6 @@ int CopyToMTDPartition(const char* source_file, const char* target_mtd) {
if (end != NULL)
*end = '\0';
FILE* f = fopen(source_file, "rb");
if (f == NULL) {
fprintf(stderr, "failed to open %s for reading: %s\n",
source_file, strerror(errno));
return -1;
}
if (!mtd_partitions_scanned) {
mtd_scan_partitions();
mtd_partitions_scanned = 1;
@ -323,20 +317,14 @@ int CopyToMTDPartition(const char* source_file, const char* target_mtd) {
return -1;
}
const int buffer_size = 4096;
char buffer[buffer_size];
size_t read;
while ((read = fread(buffer, 1, buffer_size, f)) > 0) {
size_t written = mtd_write_data(ctx, buffer, read);
if (written != read) {
fprintf(stderr, "only wrote %d of %d bytes to MTD %s\n",
written, read, partition);
mtd_write_close(ctx);
return -1;
}
size_t written = mtd_write_data(ctx, (char*)data, len);
if (written != len) {
fprintf(stderr, "only wrote %d of %d bytes to MTD %s\n",
written, len, partition);
mtd_write_close(ctx);
return -1;
}
fclose(f);
if (mtd_erase_blocks(ctx, -1) < 0) {
fprintf(stderr, "error finishing mtd write of %s\n", partition);
mtd_write_close(ctx);
@ -476,6 +464,26 @@ int ShowLicenses() {
return 0;
}
size_t FileSink(unsigned char* data, size_t len, void* token) {
return fwrite(data, 1, len, (FILE*)token);
}
typedef struct {
unsigned char* buffer;
size_t size;
size_t pos;
} MemorySinkInfo;
size_t MemorySink(unsigned char* data, size_t len, void* token) {
MemorySinkInfo* msi = (MemorySinkInfo*)token;
if (msi->size - msi->pos < len) {
return -1;
}
memcpy(msi->buffer + msi->pos, data, len);
msi->pos += len;
return len;
}
// Return the amount of free space (in bytes) on the filesystem
// containing filename. filename must exist. Return -1 on error.
size_t FreeSpaceForFile(const char* filename) {
@ -720,19 +728,36 @@ int applypatch(int argc, char** argv) {
}
char* outname = NULL;
FILE* output = NULL;
MemorySinkInfo msi;
SinkFn sink = NULL;
void* token = NULL;
if (strncmp(target_filename, "MTD:", 4) == 0) {
outname = MTD_TARGET_TEMP_FILE;
// We store the decoded output in memory.
msi.buffer = malloc(target_size);
if (msi.buffer == NULL) {
fprintf(stderr, "failed to alloc %ld bytes for output\n",
(long)target_size);
return 1;
}
msi.pos = 0;
msi.size = target_size;
sink = MemorySink;
token = &msi;
} else {
// We write the decoded output to "<tgt-file>.patch".
outname = (char*)malloc(strlen(target_filename) + 10);
strcpy(outname, target_filename);
strcat(outname, ".patch");
}
FILE* output = fopen(outname, "wb");
if (output == NULL) {
fprintf(stderr, "failed to open output file %s: %s\n",
outname, strerror(errno));
return 1;
output = fopen(outname, "wb");
if (output == NULL) {
fprintf(stderr, "failed to open output file %s: %s\n",
outname, strerror(errno));
return 1;
}
sink = FileSink;
token = output;
}
#define MAX_HEADER_LENGTH 8
@ -759,7 +784,7 @@ int applypatch(int argc, char** argv) {
} else if (header_bytes_read >= 8 &&
memcmp(header, "BSDIFF40", 8) == 0) {
int result = ApplyBSDiffPatch(source_to_use->data, source_to_use->size,
patch_filename, 0, output, &ctx);
patch_filename, 0, sink, token, &ctx);
if (result != 0) {
fprintf(stderr, "ApplyBSDiffPatch failed\n");
return result;
@ -768,7 +793,7 @@ int applypatch(int argc, char** argv) {
memcmp(header, "IMGDIFF", 7) == 0 &&
(header[7] == '1' || header[7] == '2')) {
int result = ApplyImagePatch(source_to_use->data, source_to_use->size,
patch_filename, output, &ctx);
patch_filename, sink, token, &ctx);
if (result != 0) {
fprintf(stderr, "ApplyImagePatch failed\n");
return result;
@ -778,9 +803,11 @@ int applypatch(int argc, char** argv) {
return 1;
}
fflush(output);
fsync(fileno(output));
fclose(output);
if (output != NULL) {
fflush(output);
fsync(fileno(output));
fclose(output);
}
const uint8_t* current_target_sha1 = SHA_final(&ctx);
if (memcmp(current_target_sha1, target_sha1, SHA_DIGEST_SIZE) != 0) {
@ -788,13 +815,13 @@ int applypatch(int argc, char** argv) {
return 1;
}
if (strcmp(outname, MTD_TARGET_TEMP_FILE) == 0) {
if (output == NULL) {
// Copy the temp file to the MTD partition.
if (CopyToMTDPartition(outname, target_filename) != 0) {
fprintf(stderr, "copy of %s to %s failed\n", outname, target_filename);
if (WriteToMTDPartition(msi.buffer, msi.pos, target_filename) != 0) {
fprintf(stderr, "write of patched data to %s failed\n", target_filename);
return 1;
}
unlink(outname);
free(msi.buffer);
} else {
// Give the .patch file the same owner, group, and mode of the
// original source file.

11
tools/applypatch/applypatch.h
View File

@ -39,10 +39,7 @@ typedef struct _FileContents {
// and use it as the source instead.
#define CACHE_TEMP_SOURCE "/cache/saved.file"
// When writing to an MTD partition, we first put the output in this
// temp file, then copy it to the partition once the patching is
// finished (and the target sha1 verified).
#define MTD_TARGET_TEMP_FILE "/tmp/mtd-temp"
typedef size_t (*SinkFn)(unsigned char*, size_t, void*);
// applypatch.c
size_t FreeSpaceForFile(const char* filename);
@ -52,15 +49,15 @@ int applypatch(int argc, char** argv);
void ShowBSDiffLicense();
int ApplyBSDiffPatch(const unsigned char* old_data, ssize_t old_size,
const char* patch_filename, ssize_t offset,
FILE* output, SHA_CTX* ctx);
SinkFn sink, void* token, SHA_CTX* ctx);
int ApplyBSDiffPatchMem(const unsigned char* old_data, ssize_t old_size,
const char* patch_filename, ssize_t patch_offset,
unsigned char** new_data, ssize_t* new_size);
// imgpatch.c
int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size,
const char* patch_filename,
FILE* output, SHA_CTX* ctx);
const char* patch_filename,
SinkFn sink, void* token, SHA_CTX* ctx);
// freecache.c
int MakeFreeSpaceOnCache(size_t bytes_needed);

4
tools/applypatch/bsdiff.c
View File

@ -84,7 +84,7 @@ static off_t offtin(u_char *buf)
int ApplyBSDiffPatch(const unsigned char* old_data, ssize_t old_size,
const char* patch_filename, ssize_t patch_offset,
FILE* output, SHA_CTX* ctx) {
SinkFn sink, void* token, SHA_CTX* ctx) {
unsigned char* new_data;
ssize_t new_size;
@ -93,7 +93,7 @@ int ApplyBSDiffPatch(const unsigned char* old_data, ssize_t old_size,
return -1;
}
if (fwrite(new_data, 1, new_size, output) < new_size) {
if (sink(new_data, new_size, token) < new_size) {
fprintf(stderr, "short write of output: %d (%s)\n", errno, strerror(errno));
return 1;
}

14
tools/applypatch/imgpatch.c
View File

@ -37,7 +37,7 @@
*/
int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size,
const char* patch_filename,
FILE* output, SHA_CTX* ctx) {
SinkFn sink, void* token, SHA_CTX* ctx) {
FILE* f;
if ((f = fopen(patch_filename, "rb")) == NULL) {
fprintf(stderr, "failed to open patch file\n");
@ -86,7 +86,7 @@ int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size,
ApplyBSDiffPatch(old_data + src_start, src_len,
patch_filename, patch_offset,
output, ctx);
sink, token, ctx);
} else if (type == CHUNK_GZIP) {
// This branch is basically a duplicate of the CHUNK_DEFLATE
// branch, with a bit of extra processing for the gzip header
@ -178,7 +178,7 @@ int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size,
// Now compress the target data and append it to the output.
// start with the gzip header.
fwrite(gzip+64, 1, gzip_header_len, output);
sink(gzip+64, gzip_header_len, token);
SHA_update(ctx, gzip+64, gzip_header_len);
// we're done with the expanded_source data buffer, so we'll
@ -207,7 +207,7 @@ int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size,
ret = deflate(&strm, Z_FINISH);
size_t have = temp_size - strm.avail_out;
if (fwrite(temp_data, 1, have, output) != have) {
if (sink(temp_data, have, token) != have) {
fprintf(stderr, "failed to write %d compressed bytes to output\n",
have);
return -1;
@ -217,7 +217,7 @@ int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size,
deflateEnd(&strm);
// lastly, the gzip footer.
fwrite(gzip+64+gzip_header_len, 1, 8, output);
sink(gzip+64+gzip_header_len, 8, token);
SHA_update(ctx, gzip+64+gzip_header_len, 8);
free(temp_data);
@ -240,7 +240,7 @@ int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size,
return -1;
}
SHA_update(ctx, temp, data_len);
if (fwrite(temp, 1, data_len, output) != data_len) {
if (sink(temp, data_len, token) != data_len) {
fprintf(stderr, "failed to write chunk %d raw data\n", i);
return -1;
}
@ -343,7 +343,7 @@ int ApplyImagePatch(const unsigned char* old_data, ssize_t old_size,
ret = deflate(&strm, Z_FINISH);
size_t have = temp_size - strm.avail_out;
if (fwrite(temp_data, 1, have, output) != have) {
if (sink(temp_data, have, token) != have) {
fprintf(stderr, "failed to write %d compressed bytes to output\n",
have);
return -1;

17
tools/releasetools/amend_generator.py
View File

@ -94,13 +94,13 @@ class AmendGenerator(object):
for i in sha1:
out.append(" " + i)
self.script.append("".join(out))
self.included_files.add("applypatch")
self.included_files.add(("applypatch_static", "applypatch"))
def CacheFreeSpaceCheck(self, amount):
"""Check that there's at least 'amount' space that can be made
available on /cache."""
self.script.append("run_program PACKAGE:applypatch -s %d" % (amount,))
self.included_files.add("applypatch")
self.included_files.add(("applypatch_static", "applypatch"))
def Mount(self, kind, what, path):
# no-op; amend uses it's 'roots' system to automatically mount
@ -155,7 +155,7 @@ class AmendGenerator(object):
(srcfile, tgtfile, tgtsha1, tgtsize)) +
" ".join(["%s:%s" % patchpairs[i:i+2]
for i in range(0, len(patchpairs), 2)]))
self.included_files.add("applypatch")
self.included_files.add(("applypatch_static", "applypatch"))
def WriteFirmwareImage(self, kind, fn):
"""Arrange to update the given firmware image (kind must be
@ -195,11 +195,16 @@ class AmendGenerator(object):
common.ZipWriteStr(output_zip, "META-INF/com/google/android/update-script",
"\n".join(self.script) + "\n")
for i in self.included_files:
if isinstance(i, tuple):
sourcefn, targetfn = i
else:
sourcefn = i
targetfn = i
try:
if input_path is None:
data = input_zip.read(os.path.join("OTA/bin", i))
data = input_zip.read(os.path.join("OTA/bin", sourcefn))
else:
data = open(os.path.join(input_path, i)).read()
common.ZipWriteStr(output_zip, i, data, perms=0755)
data = open(os.path.join(input_path, sourcefn)).read()
common.ZipWriteStr(output_zip, targetfn, data, perms=0755)
except (IOError, KeyError), e:
raise ExternalError("unable to include binary %s: %s" % (i, e))