releasetools: Raise on image building errors.
The image building functions in build_image.py have been returning
(success, result) or special values to indicate the validity of the
result. The same logic can be better expressed by raising exceptions
instead, because
a) using a special value relies on caller to check for that magic
value;
b) exceptions can carry additional messages other than a boolean does,
e.g. the output from the failing command;
c) caller can have cleaner code flow without explicitly checking for
the validity of the result.
This CL changes such functions to raise on errors. The majority of these
functions are internal to build_image.py only, except for BuildImage()
that has a few callers in add_img_to_target_files.py (which all die upon
error anyway).
Test: `m dist`
Test: python -m unittest test_build_image
Test: python -m unittest test_add_img_to_target_files
Test: python -m unittest test_validate_target_files
Test: Inject an error to the depended binaries (e.g. avbtool), and check
that build_image.py exits with error messages.
Change-Id: Ibe4d51e267756bb1a00fa9238a213f9d55fd9b58
This commit is contained in:
Tao Bao
parent
943be51cf1
commit
c6bd70a5e6
4 changed files with 146 additions and 163 deletions
|
|
@ -308,9 +308,8 @@ def CreateImage(input_dir, info_dict, what, output_file, block_list=None):
|
|||
hash_seed = "hash_seed-" + uuid_seed
|
||||
image_props["hash_seed"] = str(uuid.uuid5(uuid.NAMESPACE_URL, hash_seed))
|
||||
|
||||
succ = build_image.BuildImage(os.path.join(input_dir, what.upper()),
|
||||
image_props, output_file.name)
|
||||
assert succ, "build " + what + ".img image failed"
|
||||
build_image.BuildImage(
|
||||
os.path.join(input_dir, what.upper()), image_props, output_file.name)
|
||||
|
||||
output_file.Write()
|
||||
if block_list:
|
||||
|
|
@ -361,8 +360,7 @@ def AddUserdata(output_zip):
|
|||
fstab = OPTIONS.info_dict["fstab"]
|
||||
if fstab:
|
||||
image_props["fs_type"] = fstab["/data"].fs_type
|
||||
succ = build_image.BuildImage(user_dir, image_props, img.name)
|
||||
assert succ, "build userdata.img image failed"
|
||||
build_image.BuildImage(user_dir, image_props, img.name)
|
||||
|
||||
common.CheckSize(img.name, "userdata.img", OPTIONS.info_dict)
|
||||
img.Write()
|
||||
|
|
@ -514,8 +512,7 @@ def AddCache(output_zip):
|
|||
fstab = OPTIONS.info_dict["fstab"]
|
||||
if fstab:
|
||||
image_props["fs_type"] = fstab["/cache"].fs_type
|
||||
succ = build_image.BuildImage(user_dir, image_props, img.name)
|
||||
assert succ, "build cache.img image failed"
|
||||
build_image.BuildImage(user_dir, image_props, img.name)
|
||||
|
||||
common.CheckSize(img.name, "cache.img", OPTIONS.info_dict)
|
||||
img.Write()
|
||||
|
|
|
|||
|
|
@ -45,6 +45,13 @@ BLOCK_SIZE = 4096
|
|||
BYTES_IN_MB = 1024 * 1024
|
||||
|
||||
|
||||
class BuildImageError(Exception):
|
||||
"""An Exception raised during image building."""
|
||||
|
||||
def __init__(self, message):
|
||||
Exception.__init__(self, message)
|
||||
|
||||
|
||||
def RunCommand(cmd, verbose=None, env=None):
|
||||
"""Echo and run the given command.
|
||||
|
||||
|
|
@ -76,58 +83,55 @@ def GetVerityFECSize(partition_size):
|
|||
cmd = ["fec", "-s", str(partition_size)]
|
||||
output, exit_code = RunCommand(cmd, False)
|
||||
if exit_code != 0:
|
||||
return False, 0
|
||||
return True, int(output)
|
||||
raise BuildImageError("Failed to GetVerityFECSize:\n{}".format(output))
|
||||
return int(output)
|
||||
|
||||
|
||||
def GetVerityTreeSize(partition_size):
|
||||
cmd = ["build_verity_tree", "-s", str(partition_size)]
|
||||
output, exit_code = RunCommand(cmd, False)
|
||||
if exit_code != 0:
|
||||
return False, 0
|
||||
return True, int(output)
|
||||
raise BuildImageError("Failed to GetVerityTreeSize:\n{}".format(output))
|
||||
return int(output)
|
||||
|
||||
|
||||
def GetVerityMetadataSize(partition_size):
|
||||
cmd = ["build_verity_metadata.py", "size", str(partition_size)]
|
||||
output, exit_code = RunCommand(cmd, False)
|
||||
if exit_code != 0:
|
||||
return False, 0
|
||||
return True, int(output)
|
||||
raise BuildImageError("Failed to GetVerityMetadataSize:\n{}".format(output))
|
||||
return int(output)
|
||||
|
||||
|
||||
def GetVeritySize(partition_size, fec_supported):
|
||||
success, verity_tree_size = GetVerityTreeSize(partition_size)
|
||||
if not success:
|
||||
return 0
|
||||
success, verity_metadata_size = GetVerityMetadataSize(partition_size)
|
||||
if not success:
|
||||
return 0
|
||||
verity_tree_size = GetVerityTreeSize(partition_size)
|
||||
verity_metadata_size = GetVerityMetadataSize(partition_size)
|
||||
verity_size = verity_tree_size + verity_metadata_size
|
||||
if fec_supported:
|
||||
success, fec_size = GetVerityFECSize(partition_size + verity_size)
|
||||
if not success:
|
||||
return 0
|
||||
fec_size = GetVerityFECSize(partition_size + verity_size)
|
||||
return verity_size + fec_size
|
||||
return verity_size
|
||||
|
||||
|
||||
def GetDiskUsage(path):
|
||||
"""Return number of bytes that "path" occupies on host.
|
||||
"""Returns the number of bytes that "path" occupies on host.
|
||||
|
||||
Args:
|
||||
path: The directory or file to calculate size on
|
||||
|
||||
Returns:
|
||||
True and the number of bytes if successful,
|
||||
False and 0 otherwise.
|
||||
The number of bytes.
|
||||
|
||||
Raises:
|
||||
BuildImageError: On error.
|
||||
"""
|
||||
env = {"POSIXLY_CORRECT": "1"}
|
||||
cmd = ["du", "-s", path]
|
||||
output, exit_code = RunCommand(cmd, verbose=False, env=env)
|
||||
if exit_code != 0:
|
||||
return False, 0
|
||||
raise BuildImageError("Failed to get disk usage:\n{}".format(output))
|
||||
# POSIX du returns number of blocks with block size 512
|
||||
return True, int(output.split()[0]) * 512
|
||||
return int(output.split()[0]) * 512
|
||||
|
||||
|
||||
def GetSimgSize(image_file):
|
||||
|
|
@ -153,17 +157,24 @@ def AVBCalcMaxImageSize(avbtool, footer_type, partition_size, additional_args):
|
|||
or "avbtool add_hashtree_footer".
|
||||
|
||||
Returns:
|
||||
The maximum image size or 0 if an error occurred.
|
||||
The maximum image size.
|
||||
|
||||
Raises:
|
||||
BuildImageError: On error or getting invalid image size.
|
||||
"""
|
||||
cmd = [avbtool, "add_%s_footer" % footer_type,
|
||||
"--partition_size", str(partition_size), "--calc_max_image_size"]
|
||||
cmd.extend(shlex.split(additional_args))
|
||||
|
||||
(output, exit_code) = RunCommand(cmd)
|
||||
output, exit_code = RunCommand(cmd)
|
||||
if exit_code != 0:
|
||||
return 0
|
||||
else:
|
||||
return int(output)
|
||||
raise BuildImageError(
|
||||
"Failed to calculate max image size:\n{}".format(output))
|
||||
image_size = int(output)
|
||||
if image_size <= 0:
|
||||
raise BuildImageError(
|
||||
"Invalid max image size: {}".format(output))
|
||||
return image_size
|
||||
|
||||
|
||||
def AVBCalcMinPartitionSize(image_size, size_calculator):
|
||||
|
|
@ -240,8 +251,8 @@ def AVBAddFooter(image_path, avbtool, footer_type, partition_size,
|
|||
additional_args: Additional arguments to pass to "avbtool add_hash_footer"
|
||||
or "avbtool add_hashtree_footer".
|
||||
|
||||
Returns:
|
||||
True if the operation succeeded.
|
||||
Raises:
|
||||
BuildImageError: On error.
|
||||
"""
|
||||
cmd = [avbtool, "add_%s_footer" % footer_type,
|
||||
"--partition_size", partition_size,
|
||||
|
|
@ -257,9 +268,8 @@ def AVBAddFooter(image_path, avbtool, footer_type, partition_size,
|
|||
|
||||
output, exit_code = RunCommand(cmd)
|
||||
if exit_code != 0:
|
||||
print("Failed to add AVB footer! Error: %s" % output)
|
||||
return False
|
||||
return True
|
||||
raise BuildImageError(
|
||||
"Failed to add AVB footer:\n{}".format(output))
|
||||
|
||||
|
||||
def AdjustPartitionSizeForVerity(partition_size, fec_supported):
|
||||
|
|
@ -316,9 +326,8 @@ def BuildVerityFEC(sparse_image_path, verity_path, verity_fec_path,
|
|||
verity_path, verity_fec_path]
|
||||
output, exit_code = RunCommand(cmd)
|
||||
if exit_code != 0:
|
||||
print("Could not build FEC data! Error: %s" % output)
|
||||
return False
|
||||
return True
|
||||
raise BuildImageError(
|
||||
"Failed to build FEC data:\n{}".format(output))
|
||||
|
||||
|
||||
def BuildVerityTree(sparse_image_path, verity_image_path, prop_dict):
|
||||
|
|
@ -326,12 +335,11 @@ def BuildVerityTree(sparse_image_path, verity_image_path, prop_dict):
|
|||
verity_image_path]
|
||||
output, exit_code = RunCommand(cmd)
|
||||
if exit_code != 0:
|
||||
print("Could not build verity tree! Error: %s" % output)
|
||||
return False
|
||||
raise BuildImageError(
|
||||
"Failed to build verity tree:\n{}".format(output))
|
||||
root, salt = output.split()
|
||||
prop_dict["verity_root_hash"] = root
|
||||
prop_dict["verity_salt"] = salt
|
||||
return True
|
||||
|
||||
|
||||
def BuildVerityMetadata(image_size, verity_metadata_path, root_hash, salt,
|
||||
|
|
@ -345,9 +353,8 @@ def BuildVerityMetadata(image_size, verity_metadata_path, root_hash, salt,
|
|||
cmd.append("--verity_disable")
|
||||
output, exit_code = RunCommand(cmd)
|
||||
if exit_code != 0:
|
||||
print("Could not build verity metadata! Error: %s" % output)
|
||||
return False
|
||||
return True
|
||||
raise BuildImageError(
|
||||
"Failed to build verity metadata:\n{}".format(output))
|
||||
|
||||
|
||||
def Append2Simg(sparse_image_path, unsparse_image_path, error_message):
|
||||
|
|
@ -356,49 +363,45 @@ def Append2Simg(sparse_image_path, unsparse_image_path, error_message):
|
|||
Args:
|
||||
sparse_image_path: the path to the (sparse) image
|
||||
unsparse_image_path: the path to the (unsparse) image
|
||||
Returns:
|
||||
True on success, False on failure.
|
||||
|
||||
Raises:
|
||||
BuildImageError: On error.
|
||||
"""
|
||||
cmd = ["append2simg", sparse_image_path, unsparse_image_path]
|
||||
output, exit_code = RunCommand(cmd)
|
||||
if exit_code != 0:
|
||||
print("%s: %s" % (error_message, output))
|
||||
return False
|
||||
return True
|
||||
raise BuildImageError("{}:\n{}".format(error_message, output))
|
||||
|
||||
|
||||
def Append(target, file_to_append, error_message):
|
||||
"""Appends file_to_append to target."""
|
||||
"""Appends file_to_append to target.
|
||||
|
||||
Raises:
|
||||
BuildImageError: On error.
|
||||
"""
|
||||
try:
|
||||
with open(target, "a") as out_file, open(file_to_append, "r") as input_file:
|
||||
for line in input_file:
|
||||
out_file.write(line)
|
||||
except IOError:
|
||||
print(error_message)
|
||||
return False
|
||||
return True
|
||||
raise BuildImageError(error_message)
|
||||
|
||||
|
||||
def BuildVerifiedImage(data_image_path, verity_image_path,
|
||||
verity_metadata_path, verity_fec_path,
|
||||
padding_size, fec_supported):
|
||||
if not Append(verity_image_path, verity_metadata_path,
|
||||
"Could not append verity metadata!"):
|
||||
return False
|
||||
Append(
|
||||
verity_image_path, verity_metadata_path,
|
||||
"Could not append verity metadata!")
|
||||
|
||||
if fec_supported:
|
||||
# build FEC for the entire partition, including metadata
|
||||
if not BuildVerityFEC(data_image_path, verity_image_path,
|
||||
verity_fec_path, padding_size):
|
||||
return False
|
||||
# Build FEC for the entire partition, including metadata.
|
||||
BuildVerityFEC(
|
||||
data_image_path, verity_image_path, verity_fec_path, padding_size)
|
||||
Append(verity_image_path, verity_fec_path, "Could not append FEC!")
|
||||
|
||||
if not Append(verity_image_path, verity_fec_path, "Could not append FEC!"):
|
||||
return False
|
||||
|
||||
if not Append2Simg(data_image_path, verity_image_path,
|
||||
"Could not append verity data!"):
|
||||
return False
|
||||
return True
|
||||
Append2Simg(
|
||||
data_image_path, verity_image_path, "Could not append verity data!")
|
||||
|
||||
|
||||
def UnsparseImage(sparse_image_path, replace=True):
|
||||
|
|
@ -409,15 +412,15 @@ def UnsparseImage(sparse_image_path, replace=True):
|
|||
if replace:
|
||||
os.unlink(unsparse_image_path)
|
||||
else:
|
||||
return True, unsparse_image_path
|
||||
return unsparse_image_path
|
||||
inflate_command = ["simg2img", sparse_image_path, unsparse_image_path]
|
||||
(inflate_output, exit_code) = RunCommand(inflate_command)
|
||||
inflate_output, exit_code = RunCommand(inflate_command)
|
||||
if exit_code != 0:
|
||||
print("Error: '%s' failed with exit code %d:\n%s" % (
|
||||
inflate_command, exit_code, inflate_output))
|
||||
os.remove(unsparse_image_path)
|
||||
return False, None
|
||||
return True, unsparse_image_path
|
||||
raise BuildImageError(
|
||||
"Error: '{}' failed with exit code {}:\n{}".format(
|
||||
inflate_command, exit_code, inflate_output))
|
||||
return unsparse_image_path
|
||||
|
||||
|
||||
def MakeVerityEnabledImage(out_file, fec_supported, prop_dict):
|
||||
|
|
@ -427,8 +430,10 @@ def MakeVerityEnabledImage(out_file, fec_supported, prop_dict):
|
|||
out_file: the location to write the verifiable image at
|
||||
prop_dict: a dictionary of properties required for image creation and
|
||||
verification
|
||||
Returns:
|
||||
True on success, False otherwise.
|
||||
|
||||
Raises:
|
||||
AssertionError: On invalid partition sizes.
|
||||
BuildImageError: On other errors.
|
||||
"""
|
||||
# get properties
|
||||
image_size = int(prop_dict["image_size"])
|
||||
|
|
@ -440,50 +445,44 @@ def MakeVerityEnabledImage(out_file, fec_supported, prop_dict):
|
|||
signer_path = prop_dict["verity_signer_cmd"]
|
||||
signer_args = OPTIONS.verity_signer_args
|
||||
|
||||
# make a tempdir
|
||||
tempdir_name = common.MakeTempDir(suffix="_verity_images")
|
||||
|
||||
# get partial image paths
|
||||
# Get partial image paths.
|
||||
verity_image_path = os.path.join(tempdir_name, "verity.img")
|
||||
verity_metadata_path = os.path.join(tempdir_name, "verity_metadata.img")
|
||||
verity_fec_path = os.path.join(tempdir_name, "verity_fec.img")
|
||||
|
||||
# build the verity tree and get the root hash and salt
|
||||
if not BuildVerityTree(out_file, verity_image_path, prop_dict):
|
||||
return False
|
||||
# Build the verity tree and get the root hash and salt.
|
||||
BuildVerityTree(out_file, verity_image_path, prop_dict)
|
||||
|
||||
# build the metadata blocks
|
||||
# Build the metadata blocks.
|
||||
root_hash = prop_dict["verity_root_hash"]
|
||||
salt = prop_dict["verity_salt"]
|
||||
verity_disable = "verity_disable" in prop_dict
|
||||
if not BuildVerityMetadata(image_size, verity_metadata_path, root_hash, salt,
|
||||
block_dev, signer_path, signer_key, signer_args,
|
||||
verity_disable):
|
||||
return False
|
||||
BuildVerityMetadata(
|
||||
image_size, verity_metadata_path, root_hash, salt, block_dev, signer_path,
|
||||
signer_key, signer_args, verity_disable)
|
||||
|
||||
# build the full verified image
|
||||
# Build the full verified image.
|
||||
partition_size = int(prop_dict["partition_size"])
|
||||
verity_size = int(prop_dict["verity_size"])
|
||||
|
||||
padding_size = partition_size - image_size - verity_size
|
||||
assert padding_size >= 0
|
||||
|
||||
if not BuildVerifiedImage(out_file,
|
||||
verity_image_path,
|
||||
verity_metadata_path,
|
||||
verity_fec_path,
|
||||
padding_size,
|
||||
fec_supported):
|
||||
return False
|
||||
|
||||
return True
|
||||
BuildVerifiedImage(
|
||||
out_file, verity_image_path, verity_metadata_path, verity_fec_path,
|
||||
padding_size, fec_supported)
|
||||
|
||||
|
||||
def ConvertBlockMapToBaseFs(block_map_file):
|
||||
base_fs_file = common.MakeTempFile(prefix="script_gen_", suffix=".base_fs")
|
||||
convert_command = ["blk_alloc_to_base_fs", block_map_file, base_fs_file]
|
||||
(_, exit_code) = RunCommand(convert_command)
|
||||
return base_fs_file if exit_code == 0 else None
|
||||
output, exit_code = RunCommand(convert_command)
|
||||
if exit_code != 0:
|
||||
raise BuildImageError(
|
||||
"Failed to call blk_alloc_to_base_fs:\n{}".format(output))
|
||||
return base_fs_file
|
||||
|
||||
|
||||
def SetUpInDirAndFsConfig(origin_in, prop_dict):
|
||||
|
|
@ -547,11 +546,9 @@ def CheckHeadroom(ext4fs_output, prop_dict):
|
|||
ext4fs_output: The output string from mke2fs command.
|
||||
prop_dict: The property dict.
|
||||
|
||||
Returns:
|
||||
The check result.
|
||||
|
||||
Raises:
|
||||
AssertionError: On invalid input.
|
||||
BuildImageError: On check failure.
|
||||
"""
|
||||
assert ext4fs_output is not None
|
||||
assert prop_dict.get('fs_type', '').startswith('ext4')
|
||||
|
|
@ -569,12 +566,11 @@ def CheckHeadroom(ext4fs_output, prop_dict):
|
|||
adjusted_blocks = total_blocks - headroom_blocks
|
||||
if used_blocks > adjusted_blocks:
|
||||
mount_point = prop_dict["mount_point"]
|
||||
print("Error: Not enough room on %s (total: %d blocks, used: %d blocks, "
|
||||
"headroom: %d blocks, available: %d blocks)" % (
|
||||
mount_point, total_blocks, used_blocks, headroom_blocks,
|
||||
adjusted_blocks))
|
||||
return False
|
||||
return True
|
||||
raise BuildImageError(
|
||||
"Error: Not enough room on {} (total: {} blocks, used: {} blocks, "
|
||||
"headroom: {} blocks, available: {} blocks)".format(
|
||||
mount_point, total_blocks, used_blocks, headroom_blocks,
|
||||
adjusted_blocks))
|
||||
|
||||
|
||||
def BuildImage(in_dir, prop_dict, out_file, target_out=None):
|
||||
|
|
@ -590,8 +586,8 @@ def BuildImage(in_dir, prop_dict, out_file, target_out=None):
|
|||
under system/core/libcutils) reads device specific FS config files from
|
||||
there.
|
||||
|
||||
Returns:
|
||||
True iff the image is built successfully.
|
||||
Raises:
|
||||
BuildImageError: On build image failures.
|
||||
"""
|
||||
in_dir, fs_config = SetUpInDirAndFsConfig(in_dir, prop_dict)
|
||||
|
||||
|
|
@ -620,10 +616,8 @@ def BuildImage(in_dir, prop_dict, out_file, target_out=None):
|
|||
|
||||
if (prop_dict.get("use_dynamic_partition_size") == "true" and
|
||||
"partition_size" not in prop_dict):
|
||||
# if partition_size is not defined, use output of `du' + reserved_size
|
||||
success, size = GetDiskUsage(in_dir)
|
||||
if not success:
|
||||
return False
|
||||
# If partition_size is not defined, use output of `du' + reserved_size.
|
||||
size = GetDiskUsage(in_dir)
|
||||
if OPTIONS.verbose:
|
||||
print("The tree size of %s is %d MB." % (in_dir, size // BYTES_IN_MB))
|
||||
size += int(prop_dict.get("partition_reserved_size", 0))
|
||||
|
|
@ -647,8 +641,6 @@ def BuildImage(in_dir, prop_dict, out_file, target_out=None):
|
|||
partition_size = int(prop_dict.get("partition_size"))
|
||||
image_size, verity_size = AdjustPartitionSizeForVerity(
|
||||
partition_size, verity_fec_supported)
|
||||
if not image_size:
|
||||
return False
|
||||
prop_dict["image_size"] = str(image_size)
|
||||
prop_dict["verity_size"] = str(verity_size)
|
||||
|
||||
|
|
@ -656,11 +648,8 @@ def BuildImage(in_dir, prop_dict, out_file, target_out=None):
|
|||
if avb_footer_type:
|
||||
partition_size = prop_dict["partition_size"]
|
||||
# avb_add_hash_footer_args or avb_add_hashtree_footer_args.
|
||||
max_image_size = AVBCalcMaxImageSize(avbtool, avb_footer_type,
|
||||
partition_size, avb_signing_args)
|
||||
if max_image_size <= 0:
|
||||
print("AVBCalcMaxImageSize is <= 0: %d" % max_image_size)
|
||||
return False
|
||||
max_image_size = AVBCalcMaxImageSize(
|
||||
avbtool, avb_footer_type, partition_size, avb_signing_args)
|
||||
prop_dict["image_size"] = str(max_image_size)
|
||||
|
||||
if fs_type.startswith("ext"):
|
||||
|
|
@ -683,8 +672,6 @@ def BuildImage(in_dir, prop_dict, out_file, target_out=None):
|
|||
build_command.extend(["-B", prop_dict["block_list"]])
|
||||
if "base_fs_file" in prop_dict:
|
||||
base_fs_file = ConvertBlockMapToBaseFs(prop_dict["base_fs_file"])
|
||||
if base_fs_file is None:
|
||||
return False
|
||||
build_command.extend(["-d", base_fs_file])
|
||||
build_command.extend(["-L", prop_dict["mount_point"]])
|
||||
if "extfs_inode_count" in prop_dict:
|
||||
|
|
@ -742,16 +729,17 @@ def BuildImage(in_dir, prop_dict, out_file, target_out=None):
|
|||
build_command.extend(["-T", str(prop_dict["timestamp"])])
|
||||
build_command.extend(["-L", prop_dict["mount_point"]])
|
||||
else:
|
||||
print("Error: unknown filesystem type '%s'" % (fs_type))
|
||||
return False
|
||||
raise BuildImageError(
|
||||
"Error: unknown filesystem type: {}".format(fs_type))
|
||||
|
||||
(mkfs_output, exit_code) = RunCommand(build_command)
|
||||
mkfs_output, exit_code = RunCommand(build_command)
|
||||
if exit_code != 0:
|
||||
print("Error: '%s' failed with exit code %d:\n%s" % (
|
||||
build_command, exit_code, mkfs_output))
|
||||
success, du = GetDiskUsage(in_dir)
|
||||
du_str = ("%d bytes (%d MB)" % (du, du // BYTES_IN_MB)
|
||||
) if success else "unknown"
|
||||
try:
|
||||
du = GetDiskUsage(in_dir)
|
||||
du_str = "{} bytes ({} MB)".format(du, du // BYTES_IN_MB)
|
||||
except BuildImageError as e:
|
||||
print(e, file=sys.stderr)
|
||||
du_str = "unknown"
|
||||
print(
|
||||
"Out of space? The tree size of {} is {}, with reserved space of {} "
|
||||
"bytes ({} MB).".format(
|
||||
|
|
@ -765,28 +753,29 @@ def BuildImage(in_dir, prop_dict, out_file, target_out=None):
|
|||
int(prop_dict["image_size"]) // BYTES_IN_MB,
|
||||
int(prop_dict["partition_size"]),
|
||||
int(prop_dict["partition_size"]) // BYTES_IN_MB))
|
||||
return False
|
||||
|
||||
raise BuildImageError(
|
||||
"Error: '{}' failed with exit code {}:\n{}".format(
|
||||
build_command, exit_code, mkfs_output))
|
||||
|
||||
# Check if there's enough headroom space available for ext4 image.
|
||||
if "partition_headroom" in prop_dict and fs_type.startswith("ext4"):
|
||||
if not CheckHeadroom(mkfs_output, prop_dict):
|
||||
return False
|
||||
CheckHeadroom(mkfs_output, prop_dict)
|
||||
|
||||
if not fs_spans_partition:
|
||||
mount_point = prop_dict.get("mount_point")
|
||||
image_size = int(prop_dict["image_size"])
|
||||
sparse_image_size = GetSimgSize(out_file)
|
||||
if sparse_image_size > image_size:
|
||||
print("Error: %s image size of %d is larger than partition size of "
|
||||
"%d" % (mount_point, sparse_image_size, image_size))
|
||||
return False
|
||||
raise BuildImageError(
|
||||
"Error: {} image size of {} is larger than partition size of "
|
||||
"{}".format(mount_point, sparse_image_size, image_size))
|
||||
if verity_supported and is_verity_partition:
|
||||
ZeroPadSimg(out_file, image_size - sparse_image_size)
|
||||
|
||||
# Create the verified image if this is to be verified.
|
||||
if verity_supported and is_verity_partition:
|
||||
if not MakeVerityEnabledImage(out_file, verity_fec_supported, prop_dict):
|
||||
return False
|
||||
MakeVerityEnabledImage(out_file, verity_fec_supported, prop_dict)
|
||||
|
||||
# Add AVB HASH or HASHTREE footer (metadata).
|
||||
if avb_footer_type:
|
||||
|
|
@ -796,30 +785,25 @@ def BuildImage(in_dir, prop_dict, out_file, target_out=None):
|
|||
key_path = prop_dict.get("avb_key_path")
|
||||
algorithm = prop_dict.get("avb_algorithm")
|
||||
salt = prop_dict.get("avb_salt")
|
||||
if not AVBAddFooter(out_file, avbtool, avb_footer_type,
|
||||
partition_size, partition_name, key_path,
|
||||
algorithm, salt, avb_signing_args):
|
||||
return False
|
||||
AVBAddFooter(
|
||||
out_file, avbtool, avb_footer_type, partition_size, partition_name,
|
||||
key_path, algorithm, salt, avb_signing_args)
|
||||
|
||||
if run_e2fsck and prop_dict.get("skip_fsck") != "true":
|
||||
success, unsparse_image = UnsparseImage(out_file, replace=False)
|
||||
if not success:
|
||||
return False
|
||||
unsparse_image = UnsparseImage(out_file, replace=False)
|
||||
|
||||
# Run e2fsck on the inflated image file
|
||||
e2fsck_command = ["e2fsck", "-f", "-n", unsparse_image]
|
||||
# TODO(b/112062612): work around e2fsck failure with SANITIZE_HOST=address
|
||||
env4e2fsck = {"ASAN_OPTIONS": "detect_odr_violation=0"}
|
||||
(e2fsck_output, exit_code) = RunCommand(e2fsck_command, env=env4e2fsck)
|
||||
e2fsck_output, exit_code = RunCommand(e2fsck_command, env=env4e2fsck)
|
||||
|
||||
os.remove(unsparse_image)
|
||||
|
||||
if exit_code != 0:
|
||||
print("Error: '%s' failed with exit code %d:\n%s" % (
|
||||
e2fsck_command, exit_code, e2fsck_output))
|
||||
return False
|
||||
|
||||
return True
|
||||
raise BuildImageError(
|
||||
"Error: '{}' failed with exit code {}:\n{}".format(
|
||||
e2fsck_command, exit_code, e2fsck_output))
|
||||
|
||||
|
||||
def ImagePropFromGlobalDict(glob_dict, mount_point):
|
||||
|
|
@ -1110,10 +1094,12 @@ def main(argv):
|
|||
|
||||
image_properties = ImagePropFromGlobalDict(glob_dict, mount_point)
|
||||
|
||||
if not BuildImage(in_dir, image_properties, out_file, target_out):
|
||||
print("error: failed to build %s from %s" % (out_file, in_dir),
|
||||
try:
|
||||
BuildImage(in_dir, image_properties, out_file, target_out)
|
||||
except:
|
||||
print("Error: Failed to build {} from {}".format(out_file, in_dir),
|
||||
file=sys.stderr)
|
||||
sys.exit(1)
|
||||
raise
|
||||
|
||||
if prop_file_out:
|
||||
glob_dict_out = GlobalDictFromImageProp(image_properties, mount_point)
|
||||
|
|
|
|||
|
|
@ -22,8 +22,8 @@ import unittest
|
|||
|
||||
import common
|
||||
from build_image import (
|
||||
AVBCalcMinPartitionSize, BLOCK_SIZE,
|
||||
CheckHeadroom, RunCommand, SetUpInDirAndFsConfig)
|
||||
AVBCalcMinPartitionSize, BLOCK_SIZE, BuildImageError, CheckHeadroom,
|
||||
RunCommand, SetUpInDirAndFsConfig)
|
||||
|
||||
|
||||
class BuildImageTest(unittest.TestCase):
|
||||
|
|
@ -49,7 +49,7 @@ class BuildImageTest(unittest.TestCase):
|
|||
'partition_headroom' : '4096000',
|
||||
'mount_point' : 'system',
|
||||
}
|
||||
self.assertTrue(CheckHeadroom(self.EXT4FS_OUTPUT, prop_dict))
|
||||
CheckHeadroom(self.EXT4FS_OUTPUT, prop_dict)
|
||||
|
||||
def test_CheckHeadroom_InsufficientHeadroom(self):
|
||||
# Required headroom: 1001 blocks.
|
||||
|
|
@ -58,7 +58,8 @@ class BuildImageTest(unittest.TestCase):
|
|||
'partition_headroom' : '4100096',
|
||||
'mount_point' : 'system',
|
||||
}
|
||||
self.assertFalse(CheckHeadroom(self.EXT4FS_OUTPUT, prop_dict))
|
||||
self.assertRaises(
|
||||
BuildImageError, CheckHeadroom, self.EXT4FS_OUTPUT, prop_dict)
|
||||
|
||||
def test_CheckHeadroom_WrongFsType(self):
|
||||
prop_dict = {
|
||||
|
|
@ -98,14 +99,14 @@ class BuildImageTest(unittest.TestCase):
|
|||
'partition_headroom' : '40960',
|
||||
'mount_point' : 'system',
|
||||
}
|
||||
self.assertTrue(CheckHeadroom(ext4fs_output, prop_dict))
|
||||
CheckHeadroom(ext4fs_output, prop_dict)
|
||||
|
||||
prop_dict = {
|
||||
'fs_type' : 'ext4',
|
||||
'partition_headroom' : '413696',
|
||||
'mount_point' : 'system',
|
||||
}
|
||||
self.assertFalse(CheckHeadroom(ext4fs_output, prop_dict))
|
||||
self.assertRaises(BuildImageError, CheckHeadroom, ext4fs_output, prop_dict)
|
||||
|
||||
def test_SetUpInDirAndFsConfig_SystemRootImageTrue_NonSystem(self):
|
||||
prop_dict = {
|
||||
|
|
|
|||
|
|
@ -139,8 +139,7 @@ class ValidateTargetFilesTest(unittest.TestCase):
|
|||
'verity_signer_cmd' : 'verity_signer',
|
||||
'verity_size' : str(verity_size),
|
||||
}
|
||||
self.assertTrue(
|
||||
build_image.MakeVerityEnabledImage(output_file, verity_fec, prop_dict))
|
||||
build_image.MakeVerityEnabledImage(output_file, verity_fec, prop_dict)
|
||||
|
||||
def test_ValidateVerifiedBootImages_systemImage(self):
|
||||
input_tmp = common.MakeTempDir()
|
||||
|
|
|
|||
Loading…
Reference in a new issue