229 lines
8.7 KiB
Python
Executable File
229 lines
8.7 KiB
Python
Executable File
#!/usr/bin/env python
|
|
# Copyright (C) 2017 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.
|
|
|
|
import argparse
|
|
import logging
|
|
import sys
|
|
import traceback
|
|
import zipfile
|
|
|
|
from rangelib import RangeSet
|
|
|
|
class Stash(object):
|
|
"""Build a map to track stashed blocks during update simulation."""
|
|
|
|
def __init__(self):
|
|
self.blocks_stashed = 0
|
|
self.overlap_blocks_stashed = 0
|
|
self.max_stash_needed = 0
|
|
self.current_stash_size = 0
|
|
self.stash_map = {}
|
|
|
|
def StashBlocks(self, SHA1, blocks):
|
|
if SHA1 in self.stash_map:
|
|
logging.info("already stashed {}: {}".format(SHA1, blocks))
|
|
return
|
|
self.blocks_stashed += blocks.size()
|
|
self.current_stash_size += blocks.size()
|
|
self.max_stash_needed = max(self.current_stash_size, self.max_stash_needed)
|
|
self.stash_map[SHA1] = blocks
|
|
|
|
def FreeBlocks(self, SHA1):
|
|
assert self.stash_map.has_key(SHA1), "stash {} not found".format(SHA1)
|
|
self.current_stash_size -= self.stash_map[SHA1].size()
|
|
del self.stash_map[SHA1]
|
|
|
|
def HandleOverlapBlocks(self, SHA1, blocks):
|
|
self.StashBlocks(SHA1, blocks)
|
|
self.overlap_blocks_stashed += blocks.size()
|
|
self.FreeBlocks(SHA1)
|
|
|
|
|
|
class OtaPackageParser(object):
|
|
"""Parse a block-based OTA package."""
|
|
|
|
def __init__(self, package):
|
|
self.package = package
|
|
self.new_data_size = 0
|
|
self.patch_data_size = 0
|
|
self.block_written = 0
|
|
self.block_stashed = 0
|
|
|
|
@staticmethod
|
|
def GetSizeString(size):
|
|
assert size >= 0
|
|
base = 1024.0
|
|
if size <= base:
|
|
return "{} bytes".format(size)
|
|
for units in ['K', 'M', 'G']:
|
|
if size <= base * 1024 or units == 'G':
|
|
return "{:.1f}{}".format(size / base, units)
|
|
base *= 1024
|
|
|
|
def ParseTransferList(self, name):
|
|
"""Simulate the transfer commands and calculate the amout of I/O."""
|
|
|
|
logging.info("\nSimulating commands in '{}':".format(name))
|
|
lines = self.package.read(name).strip().splitlines()
|
|
assert len(lines) >= 4, "{} is too short; Transfer list expects at least" \
|
|
"4 lines, it has {}".format(name, len(lines))
|
|
assert int(lines[0]) >= 3
|
|
logging.info("(version: {})".format(lines[0]))
|
|
|
|
blocks_written = 0
|
|
my_stash = Stash()
|
|
for line in lines[4:]:
|
|
cmd_list = line.strip().split(" ")
|
|
cmd_name = cmd_list[0]
|
|
try:
|
|
if cmd_name == "new" or cmd_name == "zero":
|
|
assert len(cmd_list) == 2, "command format error: {}".format(line)
|
|
target_range = RangeSet.parse_raw(cmd_list[1])
|
|
blocks_written += target_range.size()
|
|
elif cmd_name == "move":
|
|
# Example: move <onehash> <tgt_range> <src_blk_count> <src_range>
|
|
# [<loc_range> <stashed_blocks>]
|
|
assert len(cmd_list) >= 5, "command format error: {}".format(line)
|
|
target_range = RangeSet.parse_raw(cmd_list[2])
|
|
blocks_written += target_range.size()
|
|
if cmd_list[4] == '-':
|
|
continue
|
|
SHA1 = cmd_list[1]
|
|
source_range = RangeSet.parse_raw(cmd_list[4])
|
|
if target_range.overlaps(source_range):
|
|
my_stash.HandleOverlapBlocks(SHA1, source_range)
|
|
elif cmd_name == "bsdiff" or cmd_name == "imgdiff":
|
|
# Example: bsdiff <offset> <len> <src_hash> <tgt_hash> <tgt_range>
|
|
# <src_blk_count> <src_range> [<loc_range> <stashed_blocks>]
|
|
assert len(cmd_list) >= 8, "command format error: {}".format(line)
|
|
target_range = RangeSet.parse_raw(cmd_list[5])
|
|
blocks_written += target_range.size()
|
|
if cmd_list[7] == '-':
|
|
continue
|
|
source_SHA1 = cmd_list[3]
|
|
source_range = RangeSet.parse_raw(cmd_list[7])
|
|
if target_range.overlaps(source_range):
|
|
my_stash.HandleOverlapBlocks(source_SHA1, source_range)
|
|
elif cmd_name == "stash":
|
|
assert len(cmd_list) == 3, "command format error: {}".format(line)
|
|
SHA1 = cmd_list[1]
|
|
source_range = RangeSet.parse_raw(cmd_list[2])
|
|
my_stash.StashBlocks(SHA1, source_range)
|
|
elif cmd_name == "free":
|
|
assert len(cmd_list) == 2, "command format error: {}".format(line)
|
|
SHA1 = cmd_list[1]
|
|
my_stash.FreeBlocks(SHA1)
|
|
except:
|
|
logging.error("failed to parse command in: " + line)
|
|
raise
|
|
|
|
self.block_written += blocks_written
|
|
self.block_stashed += my_stash.blocks_stashed
|
|
|
|
logging.info("blocks written: {} (expected: {})".format(
|
|
blocks_written, lines[1]))
|
|
logging.info("max blocks stashed simultaneously: {} (expected: {})".
|
|
format(my_stash.max_stash_needed, lines[3]))
|
|
logging.info("total blocks stashed: {}".format(my_stash.blocks_stashed))
|
|
logging.info("blocks stashed implicitly: {}".format(
|
|
my_stash.overlap_blocks_stashed))
|
|
|
|
def PrintDataInfo(self, partition):
|
|
logging.info("\nReading data info for {} partition:".format(partition))
|
|
new_data = self.package.getinfo(partition + ".new.dat")
|
|
patch_data = self.package.getinfo(partition + ".patch.dat")
|
|
logging.info("{:<40}{:<40}".format(new_data.filename, patch_data.filename))
|
|
logging.info("{:<40}{:<40}".format(
|
|
"compress_type: " + str(new_data.compress_type),
|
|
"compress_type: " + str(patch_data.compress_type)))
|
|
logging.info("{:<40}{:<40}".format(
|
|
"compressed_size: " + OtaPackageParser.GetSizeString(
|
|
new_data.compress_size),
|
|
"compressed_size: " + OtaPackageParser.GetSizeString(
|
|
patch_data.compress_size)))
|
|
logging.info("{:<40}{:<40}".format(
|
|
"file_size: " + OtaPackageParser.GetSizeString(new_data.file_size),
|
|
"file_size: " + OtaPackageParser.GetSizeString(patch_data.file_size)))
|
|
|
|
self.new_data_size += new_data.file_size
|
|
self.patch_data_size += patch_data.file_size
|
|
|
|
def AnalyzePartition(self, partition):
|
|
assert partition in ("system", "vendor")
|
|
assert partition + ".new.dat" in self.package.namelist()
|
|
assert partition + ".patch.dat" in self.package.namelist()
|
|
assert partition + ".transfer.list" in self.package.namelist()
|
|
|
|
self.PrintDataInfo(partition)
|
|
self.ParseTransferList(partition + ".transfer.list")
|
|
|
|
def PrintMetadata(self):
|
|
metadata_path = "META-INF/com/android/metadata"
|
|
logging.info("\nMetadata info:")
|
|
metadata_info = {}
|
|
for line in self.package.read(metadata_path).strip().splitlines():
|
|
index = line.find("=")
|
|
metadata_info[line[0 : index].strip()] = line[index + 1:].strip()
|
|
assert metadata_info.get("ota-type") == "BLOCK"
|
|
assert "pre-device" in metadata_info
|
|
logging.info("device: {}".format(metadata_info["pre-device"]))
|
|
if "pre-build" in metadata_info:
|
|
logging.info("pre-build: {}".format(metadata_info["pre-build"]))
|
|
assert "post-build" in metadata_info
|
|
logging.info("post-build: {}".format(metadata_info["post-build"]))
|
|
|
|
def Analyze(self):
|
|
logging.info("Analyzing ota package: " + self.package.filename)
|
|
self.PrintMetadata()
|
|
assert "system.new.dat" in self.package.namelist()
|
|
self.AnalyzePartition("system")
|
|
if "vendor.new.dat" in self.package.namelist():
|
|
self.AnalyzePartition("vendor")
|
|
|
|
#TODO Add analysis of other partitions(e.g. bootloader, boot, radio)
|
|
|
|
BLOCK_SIZE = 4096
|
|
logging.info("\nOTA package analyzed:")
|
|
logging.info("new data size (uncompressed): " +
|
|
OtaPackageParser.GetSizeString(self.new_data_size))
|
|
logging.info("patch data size (uncompressed): " +
|
|
OtaPackageParser.GetSizeString(self.patch_data_size))
|
|
logging.info("total data written: " +
|
|
OtaPackageParser.GetSizeString(self.block_written * BLOCK_SIZE))
|
|
logging.info("total data stashed: " +
|
|
OtaPackageParser.GetSizeString(self.block_stashed * BLOCK_SIZE))
|
|
|
|
|
|
def main(argv):
|
|
parser = argparse.ArgumentParser(description='Analyze an OTA package.')
|
|
parser.add_argument("ota_package", help='Path of the OTA package.')
|
|
args = parser.parse_args(argv)
|
|
|
|
logging_format = '%(message)s'
|
|
logging.basicConfig(level=logging.INFO, format=logging_format)
|
|
|
|
try:
|
|
with zipfile.ZipFile(args.ota_package, 'r') as package:
|
|
package_parser = OtaPackageParser(package)
|
|
package_parser.Analyze()
|
|
except:
|
|
logging.error("Failed to read " + args.ota_package)
|
|
traceback.print_exc()
|
|
sys.exit(1)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main(sys.argv[1:])
|