""" This module implements the block map (bmap) creation functionality and provides the corresponding API in form of the 'BmapCreate' class. The idea is that while images files may generally be very large (e.g., 4GiB), they may nevertheless contain only little real data, e.g., 512MiB. This data are files, directories, file-system meta-data, partition table, etc. When copying the image to the target device, you do not have to copy all the 4GiB of data, you can copy only 512MiB of it, which is 4 times less, so copying should presumably be 4 times faster. The block map file is an XML file which contains a list of blocks which have to be copied to the target device. The other blocks are not used and there is no need to copy them. The XML file also contains some additional information like block size, image size, count of mapped blocks, etc. There are also many commentaries, so it is human-readable. The image has to be a sparse file. Generally, this means that when you generate this image file, you should start with a huge sparse file which contains a single hole spanning the entire file. Then you should partition it, write all the data (probably by means of loop-back mounting the image or parts of it), etc. The end result should be a sparse file where mapped areas represent useful parts of the image and holes represent useless parts of the image, which do not have to be copied when copying the image to the target device. This module uses the FIBMAP ioctl to detect holes. """ # Disable the following pylint recommendations: # * Too many instance attributes - R0902 # * Too few public methods - R0903 # pylint: disable=R0902,R0903 import hashlib from mic.utils.misc import human_size from mic.utils import Fiemap # The bmap format version we generate SUPPORTED_BMAP_VERSION = "1.3" _BMAP_START_TEMPLATE = \ """<?xml version="1.0" ?> <!-- This file contains the block map for an image file, which is basically a list of useful (mapped) block numbers in the image file. In other words, it lists only those blocks which contain data (boot sector, partition table, file-system metadata, files, directories, extents, etc). These blocks have to be copied to the target device. The other blocks do not contain any useful data and do not have to be copied to the target device. The block map an optimization which allows to copy or flash the image to the image quicker than copying of flashing the entire image. This is because with bmap less data is copied: <MappedBlocksCount> blocks instead of <BlocksCount> blocks. Besides the machine-readable data, this file contains useful commentaries which contain human-readable information like image size, percentage of mapped data, etc. The 'version' attribute is the block map file format version in the 'major.minor' format. The version major number is increased whenever an incompatible block map format change is made. The minor number changes in case of minor backward-compatible changes. --> <bmap version="%s"> <!-- Image size in bytes: %s --> <ImageSize> %u </ImageSize> <!-- Size of a block in bytes --> <BlockSize> %u </BlockSize> <!-- Count of blocks in the image file --> <BlocksCount> %u </BlocksCount> """ class Error(Exception): """ A class for exceptions generated by this module. We currently support only one type of exceptions, and we basically throw human-readable problem description in case of errors. """ pass class BmapCreate: """ This class implements the bmap creation functionality. To generate a bmap for an image (which is supposedly a sparse file), you should first create an instance of 'BmapCreate' and provide: * full path or a file-like object of the image to create bmap for * full path or a file object to use for writing the results to Then you should invoke the 'generate()' method of this class. It will use the FIEMAP ioctl to generate the bmap. """ def _open_image_file(self): """ Open the image file. """ try: self._f_image = open(self._image_path, 'rb') except IOError as err: raise Error("cannot open image file '%s': %s" \ % (self._image_path, err)) self._f_image_needs_close = True def _open_bmap_file(self): """ Open the bmap file. """ try: self._f_bmap = open(self._bmap_path, 'w+') except IOError as err: raise Error("cannot open bmap file '%s': %s" \ % (self._bmap_path, err)) self._f_bmap_needs_close = True def __init__(self, image, bmap): """ Initialize a class instance: * image - full path or a file-like object of the image to create bmap for * bmap - full path or a file object to use for writing the resulting bmap to """ self.image_size = None self.image_size_human = None self.block_size = None self.blocks_cnt = None self.mapped_cnt = None self.mapped_size = None self.mapped_size_human = None self.mapped_percent = None self._mapped_count_pos1 = None self._mapped_count_pos2 = None self._sha1_pos = None self._f_image_needs_close = False self._f_bmap_needs_close = False if hasattr(image, "read"): self._f_image = image self._image_path = image.name else: self._image_path = image self._open_image_file() if hasattr(bmap, "read"): self._f_bmap = bmap self._bmap_path = bmap.name else: self._bmap_path = bmap self._open_bmap_file() self.fiemap = Fiemap.Fiemap(self._f_image) self.image_size = self.fiemap.image_size self.image_size_human = human_size(self.image_size) if self.image_size == 0: raise Error("cannot generate bmap for zero-sized image file '%s'" \ % self._image_path) self.block_size = self.fiemap.block_size self.blocks_cnt = self.fiemap.blocks_cnt def _bmap_file_start(self): """ A helper function which generates the starting contents of the block map file: the header comment, image size, block size, etc. """ # We do not know the amount of mapped blocks at the moment, so just put # whitespaces instead of real numbers. Assume the longest possible # numbers. mapped_count = ' ' * len(str(self.image_size)) mapped_size_human = ' ' * len(self.image_size_human) xml = _BMAP_START_TEMPLATE \ % (SUPPORTED_BMAP_VERSION, self.image_size_human, self.image_size, self.block_size, self.blocks_cnt) xml += " <!-- Count of mapped blocks: " self._f_bmap.write(xml) self._mapped_count_pos1 = self._f_bmap.tell() # Just put white-spaces instead of real information about mapped blocks xml = "%s or %.1f -->\n" % (mapped_size_human, 100.0) xml += " <MappedBlocksCount> " self._f_bmap.write(xml) self._mapped_count_pos2 = self._f_bmap.tell() xml = "%s </MappedBlocksCount>\n\n" % mapped_count # pylint: disable=C0301 xml += " <!-- The checksum of this bmap file. When it is calculated, the value of\n" xml += " the SHA1 checksum has be zeoro (40 ASCII \"0\" symbols). -->\n" xml += " <BmapFileSHA1> " self._f_bmap.write(xml) self._sha1_pos = self._f_bmap.tell() xml = "0" * 40 + " </BmapFileSHA1>\n\n" xml += " <!-- The block map which consists of elements which may either be a\n" xml += " range of blocks or a single block. The 'sha1' attribute (if present)\n" xml += " is the SHA1 checksum of this blocks range. -->\n" xml += " <BlockMap>\n" # pylint: enable=C0301 self._f_bmap.write(xml) def _bmap_file_end(self): """ A helper function which generates the final parts of the block map file: the ending tags and the information about the amount of mapped blocks. """ xml = " </BlockMap>\n" xml += "</bmap>\n" self._f_bmap.write(xml) self._f_bmap.seek(self._mapped_count_pos1) self._f_bmap.write("%s or %.1f%%" % \ (self.mapped_size_human, self.mapped_percent)) self._f_bmap.seek(self._mapped_count_pos2) self._f_bmap.write("%u" % self.mapped_cnt) self._f_bmap.seek(0) sha1 = hashlib.sha1(self._f_bmap.read()).hexdigest() self._f_bmap.seek(self._sha1_pos) self._f_bmap.write("%s" % sha1) def _calculate_sha1(self, first, last): """ A helper function which calculates SHA1 checksum for the range of blocks of the image file: from block 'first' to block 'last'. """ start = first * self.block_size end = (last + 1) * self.block_size self._f_image.seek(start) hash_obj = hashlib.new("sha1") chunk_size = 1024*1024 to_read = end - start read = 0 while read < to_read: if read + chunk_size > to_read: chunk_size = to_read - read chunk = self._f_image.read(chunk_size) hash_obj.update(chunk) read += chunk_size return hash_obj.hexdigest() def generate(self, include_checksums = True): """ Generate bmap for the image file. If 'include_checksums' is 'True', also generate SHA1 checksums for block ranges. """ # Save image file position in order to restore it at the end image_pos = self._f_image.tell() self._bmap_file_start() # Generate the block map and write it to the XML block map # file as we go. self.mapped_cnt = 0 for first, last in self.fiemap.get_mapped_ranges(0, self.blocks_cnt): self.mapped_cnt += last - first + 1 if include_checksums: sha1 = self._calculate_sha1(first, last) sha1 = " sha1=\"%s\"" % sha1 else: sha1 = "" if first != last: self._f_bmap.write(" <Range%s> %s-%s </Range>\n" \ % (sha1, first, last)) else: self._f_bmap.write(" <Range%s> %s </Range>\n" \ % (sha1, first)) self.mapped_size = self.mapped_cnt * self.block_size self.mapped_size_human = human_size(self.mapped_size) self.mapped_percent = (self.mapped_cnt * 100.0) / self.blocks_cnt self._bmap_file_end() try: self._f_bmap.flush() except IOError as err: raise Error("cannot flush the bmap file '%s': %s" \ % (self._bmap_path, err)) self._f_image.seek(image_pos) def __del__(self): """ The class destructor which closes the opened files. """ if self._f_image_needs_close: self._f_image.close() if self._f_bmap_needs_close: self._f_bmap.close()