blockimgdiff中方法分析01

https://blog.csdn.net/Android_2016/article/details/98947824

 

关于blockimgdiff文件,本篇文档将详细分析初步生成transfer对象和生成diff的字典,并对几个重要方法 进行解析.

一、传入blockimgdiff的参数分析

二、blockimgdiff中方法分析

 

一、传入blockimgdiff的参数分析

我们都知道生成差分包从ota_from_target_file.py 的WriteBlockIncrementalOTAPackage方法开始,有部分 流程我在之前的文档做包问题中提到过,有一部分我直接copy过来,核心代码部分

以上截图首先拿到system_src,system_tgt,通过getimage方法
system_src = GetImage("system", OPTIONS.source_tmp)
system_tgt = GetImage("system", OPTIONS.target_tmp)
而getimage的返回值为spare_img对象
return sparse_img.SparseImage(path, mappath, clobbered_blocks)

传入system_diff = common.BlockDifference("system", system_tgt, system_src,
check_first_block,
version=blockimgdiff_version,
disable_imgdiff=disable_imgdiff)

common.blockdifference,跳转到common.py class BlockDifference(object):中
主要做了两步
1.生成blockimgdiff对象,传入对应src,tgt参数,也就是之前获得的spare_img对象
b = blockimgdiff.BlockImageDiff(tgt, src, threads=OPTIONS.worker_threads,
version=self.version,
disable_imgdiff=self.disable_imgdiff)
2.调用blockimgdiff的Compute方法
b.Compute(self.path)

以上就是调用到blockimgdiff的大致流程,接下来进入我们的主要分析部分
二、blockimgdiff中方法分析

1.blockimgdiff init 其中有一些参数大概做下说明
def __init__(self, tgt, src=None, threads=None, version=4,
disable_imgdiff=False):
#声明两个空的字典,后面会用到
self.src_basenames = {}
self.src_numpatterns = {}
#声明了一个空的集合.重点关注,后面会使用到
self.transfers = []
# The range sets in each filemap should comprise a partition of
# the care map.
#src tgt 也就是传进来的sparse_img对象,那么这其中给到我们的有用的信息,caremap和filemap
#0-32766 32768-32769 32865-32866 .......360925-364543 这些数字就是caremap,也就是
system分区中文件占用的block块,为什么会有空的呢.因为sparse格式里面会存在头文件等
print(src.care_map)
#/system/bin/applypatch 打印出来可以看到file_map中的key值为system.map文件中的文件名
print(src.file_map.keys())
#<RangeSet("130771-130825")> values为该文件所占的block区间
print(src.file_map.values())
self.AssertPartition(src.care_map, src.file_map.values())
self.AssertPartition(tgt.care_map, tgt.file_map.values())

这里简单说明下,本身python 中只有range列表,上面出现的rangeset是Android为了装载所占用block的
区间导入的Rangelib例如上面的130771-130825

2.Compute(self, prefix): 接下来就是调用compute生成最终的差分包中transfer.list的形态

,本次我们先 介绍前三个方法

#名称转换,将基础版本中的文件名转换为

self.AbbreviateSourceNames()

#生成Transer对象

self.FindTransfers() #

Find the ordering dependencies among transfers (this is O(n^2) # in the number of transfers).

#生成gose_before,gose_after两个字典,相当于存放着基础版本文件和升级版本的差异和差异block的大小 self.GenerateDigraph()

第一个方法只是做了简单的替换,我们将着重分析后两个方法,基本上每个方法将生成对应的数据为下一步的 计算做准备

3.self.AbbreviateSourceNames()
for k in self.src.file_map.keys():
#self.src.file_map.keys() 我们之前说明了self.src.file_map.keys这个方法获得的就是system.map
中的文件名,当然也包含文件路径,os.path.basename方法的作用就是抹去文件路径,只保留文件名称
例如:k=/system/bin/applypatch,那么b=applypatch
b = os.path.basename(k)
#print("AbbreviateSourceNames" + "++++b" + b)
#以下代码的含义是python字典的写法,表示的是字典中key为b,values为k
self.src_basenames[b] = k
#sub为替换字符串的方法 [0-9]为正则表达式,表示如果b中有0-9的数字,会执行替换为#,重新赋值为b
b = re.sub("[0-9]+", "#", b)
#print("AbbreviateSourceNames" + "----b" + b)
#装载到src_numpatterns,key为b,values为k
self.src_numpatterns[b] = k
4.def FindTransfers(self):方法分析

print("Finding transfers...")

empty = RangeSet()
for tgt_fn, tgt_ranges in self.tgt.file_map.items():

if tgt_fn == "__ZERO":
print("tgt_fn == __ZERO"+ "++++tgt_fn=" + tgt_fn)
# the special "__ZERO" domain is all the blocks not contained
# in any file and that are filled with zeros. We have a
# special transfer style for zero blocks.
src_ranges = self.src.file_map.get("__ZERO", empty)
AddTransfer(tgt_fn, "__ZERO", tgt_ranges, src_ranges,
"zero", self.transfers)
continue

elif tgt_fn == "__COPY":
print("tgt_fn == __COPY" + "++++tgt_fn=" + tgt_fn)
# "__COPY" domain includes all the blocks not contained in any
# file and that need to be copied unconditionally to the target.
AddTransfer(tgt_fn, None, tgt_ranges, empty, "new", self.transfers)
continue

elif tgt_fn in self.src.file_map:
print("tgt_fn in self.src.file_map" + "++++tgt_fn=" + tgt_fn)
# Look for an exact pathname match in the source.
AddTransfer(tgt_fn, tgt_fn, tgt_ranges, self.src.file_map[tgt_fn],
"diff", self.transfers, True)
continue

b = os.path.basename(tgt_fn)
if b in self.src_basenames:
print("b in self.src_basenames" + "++++tgt_fn=" + tgt_fn + "self.transfers=" + self.transfers)
# Look for an exact basename match in the source.
src_fn = self.src_basenames[b]
AddTransfer(tgt_fn, src_fn, tgt_ranges, self.src.file_map[src_fn],
"diff", self.transfers, True)
continue

b = re.sub("[0-9]+", "#", b)
if b in self.src_numpatterns:
print("b in self.src_numpatterns" + "++++tgt_fn=" + tgt_fn)
# Look for a 'number pattern' match (a basename match after
# all runs of digits are replaced by "#"). (This is useful
# for .so files that contain version numbers in the filename
# that get bumped.)
src_fn = self.src_numpatterns[b]
AddTransfer(tgt_fn, src_fn, tgt_ranges, self.src.file_map[src_fn],
"diff", self.transfers, True)
continue

AddTransfer(tgt_fn, None, tgt_ranges, empty, "new", self.transfers)
在做包的log中可以看到,执行的打印finding transfer..
声明一个空的列表
empty = RangeSet()
开启for循环,
for tgt_fn, tgt_ranges in self.tgt.file_map.items():
遍历tgt_fn和tgt_ranges,这里面有很多的判断条件,大部分都
进入了
elif tgt_fn in self.src.file_map:
AddTransfer(tgt_fn, tgt_fn, tgt_ranges,
self.src.file_map[tgt_fn],"diff", self.transfers, True)
也就是当tgt文件名存在与src中时,这个时候会进入addTranster
方法,并将一些参数传入,"diff" 是指的存在差分,self.transfers=[]
如果前五个条件都走完了,如果有APK都不符合,那么就进入最后的
AddTransfer(tgt_fn, None, tgt_ranges, empty, "new", self.transfers)
传入的src_fn,src_ranges为空,也就是作为新增文件了

这里其他类似的方法我们先不做分析,先只分析主线diff流程
AddTransfer/AddSplitTransfers
这个方法作为一个过度,单独对odex化做了一些处理,进而将参数进一步传入了AddSplitTransfers
def AddTransfer(tgt_name, src_name, tgt_ranges, src_ranges, style, by_id,split=False):
......
# Add the transfer(s).
AddSplitTransfers(tgt_name, src_name, tgt_ranges, src_ranges, style, by_id)
这里面的参数style就是第一步传入的"diff" by_id=self.transfer=[],接下来我们分析下这个方法

def AddSplitTransfers(tgt_name, src_name, tgt_ranges, src_ranges,
#声明分割个数,首次为0
pieces = 0
#拿到cache的大小
cache_size = common.OPTIONS.cache_size
split_threshold = 0.125
#定义单个分割大小,以cache的8分之1除以定义的blockize4096
max_blocks_per_transfer = int(cache_size * split_threshold /
self.tgt.blocksize)
# Change nothing for small files.
#针对较小的文件,如果tgt和src区间大小都不够单个分割大小,则不做处理,直接生成Transfer对象
if (tgt_ranges.size() <= max_blocks_per_transfer and
src_ranges.size() <= max_blocks_per_transfer):
Transfer(tgt_name, src_name, tgt_ranges, src_ranges,
self.tgt.RangeSha1(tgt_ranges), self.src.RangeSha1(src_ranges),
style, by_id)
return

#如果tgt和src的区间大于分割比例,将进入一个while循环,
while (tgt_ranges.size() > max_blocks_per_transfer and src_ranges.size() > max_blocks_per_transfer):
#这里的语法是字段拼接的意思,最终生成的split_name为tgt_name-pieces,例如第一次进while循环是/system/app/a.apk-0
tgt_split_name = "%s-%d" % (tgt_name, pieces)
src_split_name = "%s-%d" % (src_name, pieces)
#取出区间中的分割所占的区间范围
tgt_first = tgt_ranges.first(max_blocks_per_transfer)
src_first = src_ranges.first(max_blocks_per_transfer)
#传入生成Transfer对象
Transfer(tgt_split_name, src_split_name, tgt_first, src_first,
self.tgt.RangeSha1(tgt_first), self.src.RangeSha1(src_first),
style, by_id)
#去除tgt_ranges tgt_first,剩余的继续在while中分割
tgt_ranges = tgt_ranges.subtract(tgt_first)
src_ranges = src_ranges.subtract(src_first)
#因为还在循环中,我们并不知道还会分割多少次,所以这里加1,之后生成的split_name就是/system/app/a.apk-1
pieces += 1
#这里代码的意思是,while循环走完后,剩余的部分需要处理,例如/system/app/a.apk-1
if tgt_ranges.size() or src_ranges.size():
# Must be both non-empty.
assert tgt_ranges.size() and src_ranges.size()
tgt_split_name = "%s-%d" % (tgt_name, pieces)
src_split_name = "%s-%d" % (src_name, pieces)
Transfer(tgt_split_name, src_split_name, tgt_ranges, src_ranges,
self.tgt.RangeSha1(tgt_ranges), self.src.RangeSha1(src_ranges),
style, by_id)
生成Transfer对象
走完FindTransfer后进入class Transfer(object):的inti程序
def __init__(self, tgt_name, src_name, tgt_ranges, src_ranges, tgt_sha1,
src_sha1, style, by_id):
#将我们传入的tgt_name,src_name,tgt_ranges,src_ranges,tgt_sha1,src_sha1
self.tgt_name = tgt_name
self.src_name = src_name
self.tgt_ranges = tgt_ranges
self.src_ranges = src_ranges
self.tgt_sha1 = tgt_sha1
self.src_sha1 = src_sha1
self.style = style
self.intact = (getattr(tgt_ranges, "monotonic", False) and
getattr(src_ranges, "monotonic", False))
#print(getattr(tgt_ranges, "monotonic", False))
# We use OrderedDict rather than dict so that the output is repeatable;
# otherwise it would depend on the hash values of the Transfer objects.
#声明两个字典,装载这两本字典将是下个方法做的事情
self.goes_before = OrderedDict()
self.goes_after = OrderedDict()
self.stash_before = []
self.use_stash = []
#这里的by_id其实就是之前的self.transfer,这里记录的id其实就是当前self.Transfer的长度
self.id = len(by_id)
#把当前的Transfer对象放入self.transfer列表中,其中他的位置其实就是他的id号,这个参数将用到下个方法中,用于取出diff
by_id.append(self)
5.GenerateDigraph(self):方法分析 这个方法中最主要的是包含了两个for循环,以下的流程中将引入一些例子
print("Generating digraph...")
#声明一个空的列表
source_ranges = []
#遍历self.transfer集合,取出所有的Transfer对象,b=0: <130771-130825 diff to 32629-32683> 如果直接打印Transer对象,会出现这样的字符串
因为在初始化Transer时添加了一个string方法,按这种格式进行输出
for b in self.transfers:
#遍历Transfer对象的src_range区间,这里拿到的s,e是区间的开头和结尾
for s, e in b.src_ranges:
#如果e大于source_range列表的长度,
if e > len(source_ranges):
#那么我们会将该长度追加到source_range,所以循环走完后,其实这个列表的长度就是e的长度,也就是system.map中最大的block值
source_ranges.extend([None] * (e-len(source_ranges)))
#遍历range(s,e),注意,这里已经变成了普通的range列表,这时候会取出列表中所有的元素range(130771,130825)
for i in range(s, e):
#如果source_ranges i位置上是空的
if source_ranges[i] is None:
#那么我们在i位置上放入一本字典,OrderedDict.fromkeys([b])是有序字典的写法,会生成一本字典key为含有b的列表,values为None
#那么这个时候source_ranges 130771-130824位置上放入的就是b这个Transfer对象
source_ranges[i] = OrderedDict.fromkeys([b])
else:
source_ranges[i][b] = None
其实这里第一步就是为了生成source_ranges这个列表,根据我们上面的例子,可以发现,列表的长度就是system.map最大的block值,而
每个位置上放入的其实是一本字典,而这个Transfer对象中,src_range的区间大小,就是该对象在source_ranges列表中的个数,注意,以上循环中使用的
是src_range.这样我们就按基本版本的block值,完完全全按顺序放在了列表中,
下面分析第二个for循环,取出小于基础版本最大区间目标版本中的Transfer对象
#遍历self.Transfer,取出Transer对象
for a in self.transfers:
#声明一个新的有序字典,intersections
intersections = OrderedDict()
#遍历tgt_ranges,注意使用的是tgt_ranges,上个循环使用的是src_ranges
for s, e in a.tgt_ranges:
#用tgt_ranges的区间生成一个新的range列表
for i in range(s, e):
#如果i的值大于我们之前的source_ranges,将中断整个循环,为什么会这样呢,因为如果i>source_range,那说明操过了src_range的最大值.
#也就不再处理了
if i >= len(source_ranges): break
# Add all the Transfers in source_ranges[i] to the (ordered) set.
#如果source_ranger[i]不为空,也就是说该位置上有Transfer对象,
if source_ranges[i] is not None:
#这里要注意下,首先遍历的对象是source_ranges[i],也就是对应i位置上的元素,一个字典,我们遍历字典,其实j是取出的Transfer对象
for j in source_ranges[i]:
#这是字典的赋值方法,该字典key为j ,values为None,有序字典是有去重功能的,所以如果遍历ranges(s,e)存在相同的元素,这里只会出现一个
#如果是不同的,都会放进去
intersections[j] = None
最终生成gose_before,goes_after两个字典
#注意这个for循环是是在for a in self.transfers:中的,并且与for s, e in a.tgt_ranges:同一个缩进的,
#遍历intersections这个字典,实际打印发现有intersections=()的情况,那就说明tgt_range完全超出了src_range_max
print("intersections================")
print(intersections)
for b in intersections:
#如果a与b相同,那么中断当前的循环,继续等待下一个b的进入,进行对比
if a is b: continue
# If the blocks written by A are read by B, then B needs to go before A.
#如果a这个Transer对象与b不同,那么取出a对象的tgt_ranges和b对象的src_ranges的intersect,也就是交集
i = a.tgt_ranges.intersect(b.src_ranges)
if i:
if b.src_name == "__ZERO":
# the cost of removing source blocks for the __ZERO domain
# is (nearly) zero.
size = 0
else:
#取出交集的长度size,也就是基础版本和升级版本相交的block
size = i.size()
#装载b的gose_before对象,内容为{a,size}
b.goes_before[a] = size
#装载a的goes_after对象,内容为{a,size}
a.goes_after[b] = size
这里好像看起来很乱,字面意思仿佛就是是谁杀了我,而我又杀了谁,下面我们以一个简单的例子进行分析
关于生成gose_before,gose_after
a.Tansfer
src_name = a.apk
tgt_name = a.apk
src_range = 0-1000
tgt_range = 500-2000

b.Transfer
src_name = b.apk
tgt_name = b.apk
src_range = 1001-2000
tgt_range = 2001-3000

i = a.tgt_ranges.intersect(b.src_ranges)
这时候用a的tgt_ranges 与 b.src_ranges 取交集,很明显可以取到500-2000
那么b的gose_before中存储了与其src_range有交集的a的tgt_range
b.goes_before[a] = size
那么a的goes_after中存储了与其tgt_range有交集的b的src_range
a.goes_after[b] = size
那么可能也会有c和d,
b的goes_after中存储了与其tgt_range有交集的c的src_range
b.gose_after[c] = size
a的gose_before中存储了与其src_range有交集的d的tgt_range
a.goes_before[d] = size
这样我们相当于会取出与当前APK基础版本的交集和升级版本的交集区间diff,以用于下一步的操作,这一部分的代码参数很多,我也是打印了很多的log
才慢慢看出了生成文件的作用.下一步将去操作这两个字典中存储的diff.
————————————————
版权声明：本文为CSDN博主「李标标」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Android_2016/article/details/98947824