Make releasetools pylint clean. (8b72aefb) · Commits · e / os / android_build

tools/releasetools/add_img_to_target_files.py

+26 −26

Original line number	Original line	Diff line number	Diff line
	@@ -60,9 +60,9 @@ def AddSystem(output_zip, prefix="IMAGES/", recovery_img=None, boot_img=None):
	ofile.close()		ofile.close()

	if OPTIONS.rebuild_recovery:		if OPTIONS.rebuild_recovery:
	print("Building new recovery patch")		print "Building new recovery patch"
	common.MakeRecoveryPatch(OPTIONS.input_tmp, output_sink, recovery_img, boot_img,		common.MakeRecoveryPatch(OPTIONS.input_tmp, output_sink, recovery_img,
	info_dict=OPTIONS.info_dict)		boot_img, info_dict=OPTIONS.info_dict)

	block_list = common.MakeTempFile(prefix="system-blocklist-", suffix=".map")		block_list = common.MakeTempFile(prefix="system-blocklist-", suffix=".map")
	imgname = BuildSystem(OPTIONS.input_tmp, OPTIONS.info_dict,		imgname = BuildSystem(OPTIONS.input_tmp, OPTIONS.info_dict,
	@@ -110,12 +110,12 @@ def CreateImage(input_dir, info_dict, what, block_list=None):
	try:		try:
	os.symlink(os.path.join(input_dir, what.upper()),		os.symlink(os.path.join(input_dir, what.upper()),
	os.path.join(input_dir, what))		os.path.join(input_dir, what))
	except OSError, e:		except OSError as e:
	# bogus error on my mac version?		# bogus error on my mac version?
	# File "./build/tools/releasetools/img_from_target_files", line 86, in AddSystem		# File "./build/tools/releasetools/img_from_target_files"
	# os.path.join(OPTIONS.input_tmp, "system"))		# os.path.join(OPTIONS.input_tmp, "system"))
	# OSError: [Errno 17] File exists		# OSError: [Errno 17] File exists
	if (e.errno == errno.EEXIST):		if e.errno == errno.EEXIST:
	pass		pass

	image_props = build_image.ImagePropFromGlobalDict(info_dict, what)		image_props = build_image.ImagePropFromGlobalDict(info_dict, what)
	@@ -130,10 +130,12 @@ def CreateImage(input_dir, info_dict, what, block_list=None):

	fs_config = os.path.join(		fs_config = os.path.join(
	input_dir, "META/" + fs_config_prefix + "filesystem_config.txt")		input_dir, "META/" + fs_config_prefix + "filesystem_config.txt")
	if not os.path.exists(fs_config): fs_config = None		if not os.path.exists(fs_config):
			fs_config = None

	fc_config = os.path.join(input_dir, "BOOT/RAMDISK/file_contexts")		fc_config = os.path.join(input_dir, "BOOT/RAMDISK/file_contexts")
	if not os.path.exists(fc_config): fc_config = None		if not os.path.exists(fc_config):
			fc_config = None

	succ = build_image.BuildImage(os.path.join(input_dir, what),		succ = build_image.BuildImage(os.path.join(input_dir, what),
	image_props, img,		image_props, img,
	@@ -289,7 +291,7 @@ def AddImagesToTargetFiles(filename):
	output_zip.close()		output_zip.close()

	def main(argv):		def main(argv):
	def option_handler(o, a):		def option_handler(o, _):
	if o in ("-a", "--add_missing"):		if o in ("-a", "--add_missing"):
	OPTIONS.add_missing = True		OPTIONS.add_missing = True
	elif o in ("-r", "--rebuild_recovery",):		elif o in ("-r", "--rebuild_recovery",):
	@@ -298,11 +300,9 @@ def main(argv):
	return False		return False
	return True		return True

	args = common.ParseOptions(argv, __doc__,		args = common.ParseOptions(
	extra_opts="ar",		argv, __doc__, extra_opts="ar",
	extra_long_opts=["add_missing",		extra_long_opts=["add_missing", "rebuild_recovery"],
	"rebuild_recovery",
	],
	extra_option_handler=option_handler)		extra_option_handler=option_handler)


	@@ -317,7 +317,7 @@ if __name__ == '__main__':
	try:		try:
	common.CloseInheritedPipes()		common.CloseInheritedPipes()
	main(sys.argv[1:])		main(sys.argv[1:])
	except common.ExternalError, e:		except common.ExternalError as e:
	print		print
	print " ERROR: %s" % (e,)		print " ERROR: %s" % (e,)
	print		print

tools/releasetools/blockimgdiff.py

+52 −41

Original line number	Original line	Diff line number	Diff line
	@@ -20,17 +20,17 @@ import heapq
	import itertools		import itertools
	import multiprocessing		import multiprocessing
	import os		import os
	import pprint
	import re		import re
	import subprocess		import subprocess
	import sys
	import threading		import threading
	import tempfile		import tempfile

	from rangelib import *		from rangelib import RangeSet


	__all__ = ["EmptyImage", "DataImage", "BlockImageDiff"]		__all__ = ["EmptyImage", "DataImage", "BlockImageDiff"]


	def compute_patch(src, tgt, imgdiff=False):		def compute_patch(src, tgt, imgdiff=False):
	srcfd, srcfile = tempfile.mkstemp(prefix="src-")		srcfd, srcfile = tempfile.mkstemp(prefix="src-")
	tgtfd, tgtfile = tempfile.mkstemp(prefix="tgt-")		tgtfd, tgtfile = tempfile.mkstemp(prefix="tgt-")
	@@ -69,7 +69,16 @@ def compute_patch(src, tgt, imgdiff=False):
	except OSError:		except OSError:
	pass		pass

	class EmptyImage(object):
			class Image(object):
			def ReadRangeSet(self, ranges):
			raise NotImplementedError

			def TotalSha1(self):
			raise NotImplementedError


			class EmptyImage(Image):
	"""A zero-length image."""		"""A zero-length image."""
	blocksize = 4096		blocksize = 4096
	care_map = RangeSet()		care_map = RangeSet()
	@@ -81,7 +90,7 @@ class EmptyImage(object):
	return sha1().hexdigest()		return sha1().hexdigest()


	class DataImage(object):		class DataImage(Image):
	"""An image wrapped around a single string of data."""		"""An image wrapped around a single string of data."""

	def __init__(self, data, trim=False, pad=False):		def __init__(self, data, trim=False, pad=False):
	@@ -126,9 +135,7 @@ class DataImage(object):
	return [self.data[sself.blocksize:eself.blocksize] for (s, e) in ranges]		return [self.data[sself.blocksize:eself.blocksize] for (s, e) in ranges]

	def TotalSha1(self):		def TotalSha1(self):
	if not hasattr(self, "sha1"):		return sha1(self.data).hexdigest()
	self.sha1 = sha1(self.data).hexdigest()
	return self.sha1


	class Transfer(object):		class Transfer(object):
	@@ -196,9 +203,13 @@ class BlockImageDiff(object):
	def __init__(self, tgt, src=None, threads=None, version=3):		def __init__(self, tgt, src=None, threads=None, version=3):
	if threads is None:		if threads is None:
	threads = multiprocessing.cpu_count() // 2		threads = multiprocessing.cpu_count() // 2
	if threads == 0: threads = 1		if threads == 0:
			threads = 1
	self.threads = threads		self.threads = threads
	self.version = version		self.version = version
			self.transfers = []
			self.src_basenames = {}
			self.src_numpatterns = {}

	assert version in (1, 2, 3)		assert version in (1, 2, 3)

	@@ -247,7 +258,7 @@ class BlockImageDiff(object):
	self.ComputePatches(prefix)		self.ComputePatches(prefix)
	self.WriteTransfers(prefix)		self.WriteTransfers(prefix)

	def HashBlocks(self, source, ranges):		def HashBlocks(self, source, ranges): # pylint: disable=no-self-use
	data = source.ReadRangeSet(ranges)		data = source.ReadRangeSet(ranges)
	ctx = sha1()		ctx = sha1()

	@@ -300,7 +311,7 @@ class BlockImageDiff(object):
	free_string = []		free_string = []

	if self.version == 1:		if self.version == 1:
	src_string = xf.src_ranges.to_string_raw()		src_str = xf.src_ranges.to_string_raw()
	elif self.version >= 2:		elif self.version >= 2:

	# <# blocks> <src ranges>		# <# blocks> <src ranges>
	@@ -310,7 +321,7 @@ class BlockImageDiff(object):
	# <# blocks> - <stash refs...>		# <# blocks> - <stash refs...>

	size = xf.src_ranges.size()		size = xf.src_ranges.size()
	src_string = [str(size)]		src_str = [str(size)]

	unstashed_src_ranges = xf.src_ranges		unstashed_src_ranges = xf.src_ranges
	mapped_stashes = []		mapped_stashes = []
	@@ -322,10 +333,10 @@ class BlockImageDiff(object):
	sr = xf.src_ranges.map_within(sr)		sr = xf.src_ranges.map_within(sr)
	mapped_stashes.append(sr)		mapped_stashes.append(sr)
	if self.version == 2:		if self.version == 2:
	src_string.append("%d:%s" % (sid, sr.to_string_raw()))		src_str.append("%d:%s" % (sid, sr.to_string_raw()))
	else:		else:
	assert sh in stashes		assert sh in stashes
	src_string.append("%s:%s" % (sh, sr.to_string_raw()))		src_str.append("%s:%s" % (sh, sr.to_string_raw()))
	stashes[sh] -= 1		stashes[sh] -= 1
	if stashes[sh] == 0:		if stashes[sh] == 0:
	free_string.append("free %s\n" % (sh))		free_string.append("free %s\n" % (sh))
	@@ -333,17 +344,17 @@ class BlockImageDiff(object):
	heapq.heappush(free_stash_ids, sid)		heapq.heappush(free_stash_ids, sid)

	if unstashed_src_ranges:		if unstashed_src_ranges:
	src_string.insert(1, unstashed_src_ranges.to_string_raw())		src_str.insert(1, unstashed_src_ranges.to_string_raw())
	if xf.use_stash:		if xf.use_stash:
	mapped_unstashed = xf.src_ranges.map_within(unstashed_src_ranges)		mapped_unstashed = xf.src_ranges.map_within(unstashed_src_ranges)
	src_string.insert(2, mapped_unstashed.to_string_raw())		src_str.insert(2, mapped_unstashed.to_string_raw())
	mapped_stashes.append(mapped_unstashed)		mapped_stashes.append(mapped_unstashed)
	self.AssertPartition(RangeSet(data=(0, size)), mapped_stashes)		self.AssertPartition(RangeSet(data=(0, size)), mapped_stashes)
	else:		else:
	src_string.insert(1, "-")		src_str.insert(1, "-")
	self.AssertPartition(RangeSet(data=(0, size)), mapped_stashes)		self.AssertPartition(RangeSet(data=(0, size)), mapped_stashes)

	src_string = " ".join(src_string)		src_str = " ".join(src_str)

	# all versions:		# all versions:
	# zero <rangeset>		# zero <rangeset>
	@@ -356,14 +367,14 @@ class BlockImageDiff(object):
	# move <src rangeset> <tgt rangeset>		# move <src rangeset> <tgt rangeset>
	#		#
	# version 2:		# version 2:
	# bsdiff patchstart patchlen <tgt rangeset> <src_string>		# bsdiff patchstart patchlen <tgt rangeset> <src_str>
	# imgdiff patchstart patchlen <tgt rangeset> <src_string>		# imgdiff patchstart patchlen <tgt rangeset> <src_str>
	# move <tgt rangeset> <src_string>		# move <tgt rangeset> <src_str>
	#		#
	# version 3:		# version 3:
	# bsdiff patchstart patchlen srchash tgthash <tgt rangeset> <src_string>		# bsdiff patchstart patchlen srchash tgthash <tgt rangeset> <src_str>
	# imgdiff patchstart patchlen srchash tgthash <tgt rangeset> <src_string>		# imgdiff patchstart patchlen srchash tgthash <tgt rangeset> <src_str>
	# move hash <tgt rangeset> <src_string>		# move hash <tgt rangeset> <src_str>

	tgt_size = xf.tgt_ranges.size()		tgt_size = xf.tgt_ranges.size()

	@@ -383,12 +394,12 @@ class BlockImageDiff(object):
	elif self.version == 2:		elif self.version == 2:
	out.append("%s %s %s\n" % (		out.append("%s %s %s\n" % (
	xf.style,		xf.style,
	xf.tgt_ranges.to_string_raw(), src_string))		xf.tgt_ranges.to_string_raw(), src_str))
	elif self.version >= 3:		elif self.version >= 3:
	out.append("%s %s %s %s\n" % (		out.append("%s %s %s %s\n" % (
	xf.style,		xf.style,
	self.HashBlocks(self.tgt, xf.tgt_ranges),		self.HashBlocks(self.tgt, xf.tgt_ranges),
	xf.tgt_ranges.to_string_raw(), src_string))		xf.tgt_ranges.to_string_raw(), src_str))
	total += tgt_size		total += tgt_size
	elif xf.style in ("bsdiff", "imgdiff"):		elif xf.style in ("bsdiff", "imgdiff"):
	performs_read = True		performs_read = True
	@@ -401,14 +412,14 @@ class BlockImageDiff(object):
	elif self.version == 2:		elif self.version == 2:
	out.append("%s %d %d %s %s\n" % (		out.append("%s %d %d %s %s\n" % (
	xf.style, xf.patch_start, xf.patch_len,		xf.style, xf.patch_start, xf.patch_len,
	xf.tgt_ranges.to_string_raw(), src_string))		xf.tgt_ranges.to_string_raw(), src_str))
	elif self.version >= 3:		elif self.version >= 3:
	out.append("%s %d %d %s %s %s %s\n" % (		out.append("%s %d %d %s %s %s %s\n" % (
	xf.style,		xf.style,
	xf.patch_start, xf.patch_len,		xf.patch_start, xf.patch_len,
	self.HashBlocks(self.src, xf.src_ranges),		self.HashBlocks(self.src, xf.src_ranges),
	self.HashBlocks(self.tgt, xf.tgt_ranges),		self.HashBlocks(self.tgt, xf.tgt_ranges),
	xf.tgt_ranges.to_string_raw(), src_string))		xf.tgt_ranges.to_string_raw(), src_str))
	total += tgt_size		total += tgt_size
	elif xf.style == "zero":		elif xf.style == "zero":
	assert xf.tgt_ranges		assert xf.tgt_ranges
	@@ -417,7 +428,7 @@ class BlockImageDiff(object):
	out.append("%s %s\n" % (xf.style, to_zero.to_string_raw()))		out.append("%s %s\n" % (xf.style, to_zero.to_string_raw()))
	total += to_zero.size()		total += to_zero.size()
	else:		else:
	raise ValueError, "unknown transfer style '%s'\n" % (xf.style,)		raise ValueError("unknown transfer style '%s'\n" % xf.style)

	if free_string:		if free_string:
	out.append("".join(free_string))		out.append("".join(free_string))
	@@ -527,11 +538,13 @@ class BlockImageDiff(object):

	patches = [None] * patch_num		patches = [None] * patch_num

			# TODO: Rewrite with multiprocessing.ThreadPool?
	lock = threading.Lock()		lock = threading.Lock()
	def diff_worker():		def diff_worker():
	while True:		while True:
	with lock:		with lock:
	if not diff_q: return		if not diff_q:
			return
	tgt_size, src, tgt, xf, patchnum = diff_q.pop()		tgt_size, src, tgt, xf, patchnum = diff_q.pop()
	patch = compute_patch(src, tgt, imgdiff=(xf.style == "imgdiff"))		patch = compute_patch(src, tgt, imgdiff=(xf.style == "imgdiff"))
	size = len(patch)		size = len(patch)
	@@ -543,7 +556,7 @@ class BlockImageDiff(object):
	xf.tgt_name + " (from " + xf.src_name + ")")))		xf.tgt_name + " (from " + xf.src_name + ")")))

	threads = [threading.Thread(target=diff_worker)		threads = [threading.Thread(target=diff_worker)
	for i in range(self.threads)]		for _ in range(self.threads)]
	for th in threads:		for th in threads:
	th.start()		th.start()
	while threads:		while threads:
	@@ -670,8 +683,6 @@ class BlockImageDiff(object):
	stash_size = 0		stash_size = 0

	for xf in self.transfers:		for xf in self.transfers:
	lost = 0
	size = xf.src_ranges.size()
	for u in xf.goes_before.copy():		for u in xf.goes_before.copy():
	# xf should go before u		# xf should go before u
	if xf.order < u.order:		if xf.order < u.order:
	@@ -737,7 +748,8 @@ class BlockImageDiff(object):
	# Put all sinks at the end of the sequence.		# Put all sinks at the end of the sequence.
	while True:		while True:
	sinks = [u for u in G if not u.outgoing]		sinks = [u for u in G if not u.outgoing]
	if not sinks: break		if not sinks:
			break
	for u in sinks:		for u in sinks:
	s2.appendleft(u)		s2.appendleft(u)
	del G[u]		del G[u]
	@@ -747,14 +759,16 @@ class BlockImageDiff(object):
	# Put all the sources at the beginning of the sequence.		# Put all the sources at the beginning of the sequence.
	while True:		while True:
	sources = [u for u in G if not u.incoming]		sources = [u for u in G if not u.incoming]
	if not sources: break		if not sources:
			break
	for u in sources:		for u in sources:
	s1.append(u)		s1.append(u)
	del G[u]		del G[u]
	for iu in u.outgoing:		for iu in u.outgoing:
	del iu.incoming[u]		del iu.incoming[u]

	if not G: break		if not G:
			break

	# Find the "best" vertex to put next. "Best" is the one that		# Find the "best" vertex to put next. "Best" is the one that
	# maximizes the net difference in source blocks saved we get by		# maximizes the net difference in source blocks saved we get by
	@@ -792,7 +806,8 @@ class BlockImageDiff(object):
	print("Generating digraph...")		print("Generating digraph...")
	for a in self.transfers:		for a in self.transfers:
	for b in self.transfers:		for b in self.transfers:
	if a is b: continue		if a is b:
			continue

	# If the blocks written by A are read by B, then B needs to go before A.		# If the blocks written by A are read by B, then B needs to go before A.
	i = a.tgt_ranges.intersect(b.src_ranges)		i = a.tgt_ranges.intersect(b.src_ranges)
	@@ -807,7 +822,6 @@ class BlockImageDiff(object):
	a.goes_after[b] = size		a.goes_after[b] = size

	def FindTransfers(self):		def FindTransfers(self):
	self.transfers = []
	empty = RangeSet()		empty = RangeSet()
	for tgt_fn, tgt_ranges in self.tgt.file_map.items():		for tgt_fn, tgt_ranges in self.tgt.file_map.items():
	if tgt_fn == "__ZERO":		if tgt_fn == "__ZERO":
	@@ -847,9 +861,6 @@ class BlockImageDiff(object):
	Transfer(tgt_fn, None, tgt_ranges, empty, "new", self.transfers)		Transfer(tgt_fn, None, tgt_ranges, empty, "new", self.transfers)

	def AbbreviateSourceNames(self):		def AbbreviateSourceNames(self):
	self.src_basenames = {}
	self.src_numpatterns = {}

	for k in self.src.file_map.keys():		for k in self.src.file_map.keys():
	b = os.path.basename(k)		b = os.path.basename(k)
	self.src_basenames[b] = k		self.src_basenames[b] = k

tools/releasetools/build_image.py

+23 −24

Original line number	Original line	Diff line number	Diff line
	@@ -72,14 +72,15 @@ def AdjustPartitionSizeForVerity(partition_size):
	"""		"""
	success, verity_tree_size = GetVerityTreeSize(partition_size)		success, verity_tree_size = GetVerityTreeSize(partition_size)
	if not success:		if not success:
	return 0;		return 0
	success, verity_metadata_size = GetVerityMetadataSize(partition_size)		success, verity_metadata_size = GetVerityMetadataSize(partition_size)
	if not success:		if not success:
	return 0		return 0
	return partition_size - verity_tree_size - verity_metadata_size		return partition_size - verity_tree_size - verity_metadata_size

	def BuildVerityTree(sparse_image_path, verity_image_path, prop_dict):		def BuildVerityTree(sparse_image_path, verity_image_path, prop_dict):
	cmd = ("build_verity_tree -A %s %s %s" % (FIXED_SALT, sparse_image_path, verity_image_path))		cmd = "build_verity_tree -A %s %s %s" % (
			FIXED_SALT, sparse_image_path, verity_image_path)
	print cmd		print cmd
	status, output = commands.getstatusoutput(cmd)		status, output = commands.getstatusoutput(cmd)
	if status:		if status:
	@@ -92,14 +93,10 @@ def BuildVerityTree(sparse_image_path, verity_image_path, prop_dict):

	def BuildVerityMetadata(image_size, verity_metadata_path, root_hash, salt,		def BuildVerityMetadata(image_size, verity_metadata_path, root_hash, salt,
	block_device, signer_path, key):		block_device, signer_path, key):
	cmd = ("system/extras/verity/build_verity_metadata.py %s %s %s %s %s %s %s" %		cmd_template = (
	(image_size,		"system/extras/verity/build_verity_metadata.py %s %s %s %s %s %s %s")
	verity_metadata_path,		cmd = cmd_template % (image_size, verity_metadata_path, root_hash, salt,
	root_hash,		block_device, signer_path, key)
	salt,
	block_device,
	signer_path,
	key))
	print cmd		print cmd
	status, output = commands.getstatusoutput(cmd)		status, output = commands.getstatusoutput(cmd)
	if status:		if status:
	@@ -125,10 +122,13 @@ def Append2Simg(sparse_image_path, unsparse_image_path, error_message):
	return False		return False
	return True		return True

	def BuildVerifiedImage(data_image_path, verity_image_path, verity_metadata_path):		def BuildVerifiedImage(data_image_path, verity_image_path,
	if not Append2Simg(data_image_path, verity_metadata_path, "Could not append verity metadata!"):		verity_metadata_path):
			if not Append2Simg(data_image_path, verity_metadata_path,
			"Could not append verity metadata!"):
	return False		return False
	if not Append2Simg(data_image_path, verity_image_path, "Could not append verity tree!"):		if not Append2Simg(data_image_path, verity_image_path,
			"Could not append verity tree!"):
	return False		return False
	return True		return True

	@@ -153,7 +153,8 @@ def MakeVerityEnabledImage(out_file, prop_dict):

	Args:		Args:
	out_file: the location to write the verifiable image at		out_file: the location to write the verifiable image at
	prop_dict: a dictionary of properties required for image creation and verification		prop_dict: a dictionary of properties required for image creation and
			verification
	Returns:		Returns:
	True on success, False otherwise.		True on success, False otherwise.
	"""		"""
	@@ -178,13 +179,8 @@ def MakeVerityEnabledImage(out_file, prop_dict):
	# build the metadata blocks		# build the metadata blocks
	root_hash = prop_dict["verity_root_hash"]		root_hash = prop_dict["verity_root_hash"]
	salt = prop_dict["verity_salt"]		salt = prop_dict["verity_salt"]
	if not BuildVerityMetadata(image_size,		if not BuildVerityMetadata(image_size, verity_metadata_path, root_hash, salt,
	verity_metadata_path,		block_dev, signer_path, signer_key):
	root_hash,
	salt,
	block_dev,
	signer_path,
	signer_key):
	shutil.rmtree(tempdir_name, ignore_errors=True)		shutil.rmtree(tempdir_name, ignore_errors=True)
	return False		return False

	@@ -223,7 +219,8 @@ def BuildImage(in_dir, prop_dict, out_file,

	is_verity_partition = "verity_block_device" in prop_dict		is_verity_partition = "verity_block_device" in prop_dict
	verity_supported = prop_dict.get("verity") == "true"		verity_supported = prop_dict.get("verity") == "true"
	# adjust the partition size to make room for the hashes if this is to be verified		# adjust the partition size to make room for the hashes if this is to be
			# verified
	if verity_supported and is_verity_partition:		if verity_supported and is_verity_partition:
	partition_size = int(prop_dict.get("partition_size"))		partition_size = int(prop_dict.get("partition_size"))
	adjusted_size = AdjustPartitionSizeForVerity(partition_size)		adjusted_size = AdjustPartitionSizeForVerity(partition_size)
	@@ -329,7 +326,8 @@ def ImagePropFromGlobalDict(glob_dict, mount_point):
	d["mount_point"] = mount_point		d["mount_point"] = mount_point
	if mount_point == "system":		if mount_point == "system":
	copy_prop("fs_type", "fs_type")		copy_prop("fs_type", "fs_type")
	# Copy the generic sysetem fs type first, override with specific one if available.		# Copy the generic sysetem fs type first, override with specific one if
			# available.
	copy_prop("system_fs_type", "fs_type")		copy_prop("system_fs_type", "fs_type")
	copy_prop("system_size", "partition_size")		copy_prop("system_size", "partition_size")
	copy_prop("system_journal_size", "journal_size")		copy_prop("system_journal_size", "journal_size")
	@@ -397,7 +395,8 @@ def main(argv):

	image_properties = ImagePropFromGlobalDict(glob_dict, mount_point)		image_properties = ImagePropFromGlobalDict(glob_dict, mount_point)
	if not BuildImage(in_dir, image_properties, out_file):		if not BuildImage(in_dir, image_properties, out_file):
	print >> sys.stderr, "error: failed to build %s from %s" % (out_file, in_dir)		print >> sys.stderr, "error: failed to build %s from %s" % (out_file,
			in_dir)
	exit(1)		exit(1)