blob: adfe2e403bcfb3a1ac1f1a123f7bdb93e7287e13 [file] [log] [blame]
Brad Bishopc342db32019-05-15 21:57:59 -04001#
2# SPDX-License-Identifier: GPL-2.0-only
3#
Patrick Williamsc124f4f2015-09-15 14:41:29 -05004import bb.siggen
Andrew Geisslerd25ed322020-06-27 00:28:28 -05005import bb.runqueue
Brad Bishop316dfdd2018-06-25 12:45:53 -04006import oe
Patrick Williamsc124f4f2015-09-15 14:41:29 -05007
Andrew Geisslerd25ed322020-06-27 00:28:28 -05008def sstate_rundepfilter(siggen, fn, recipename, task, dep, depname, dataCaches):
Patrick Williamsc124f4f2015-09-15 14:41:29 -05009 # Return True if we should keep the dependency, False to drop it
10 def isNative(x):
11 return x.endswith("-native")
12 def isCross(x):
13 return "-cross-" in x
14 def isNativeSDK(x):
15 return x.startswith("nativesdk-")
Andrew Geisslerd25ed322020-06-27 00:28:28 -050016 def isKernel(mc, fn):
17 inherits = " ".join(dataCaches[mc].inherits[fn])
Patrick Williamsc124f4f2015-09-15 14:41:29 -050018 return inherits.find("/module-base.bbclass") != -1 or inherits.find("/linux-kernel-base.bbclass") != -1
Andrew Geisslerd25ed322020-06-27 00:28:28 -050019 def isPackageGroup(mc, fn):
20 inherits = " ".join(dataCaches[mc].inherits[fn])
Patrick Williamsc124f4f2015-09-15 14:41:29 -050021 return "/packagegroup.bbclass" in inherits
Andrew Geisslerd25ed322020-06-27 00:28:28 -050022 def isAllArch(mc, fn):
23 inherits = " ".join(dataCaches[mc].inherits[fn])
Patrick Williamsc124f4f2015-09-15 14:41:29 -050024 return "/allarch.bbclass" in inherits
Andrew Geisslerd25ed322020-06-27 00:28:28 -050025 def isImage(mc, fn):
26 return "/image.bbclass" in " ".join(dataCaches[mc].inherits[fn])
Patrick Williamsc124f4f2015-09-15 14:41:29 -050027
Andrew Geisslerd25ed322020-06-27 00:28:28 -050028 depmc, _, deptaskname, depmcfn = bb.runqueue.split_tid_mcfn(dep)
29 mc, _ = bb.runqueue.split_mc(fn)
30
31 # (Almost) always include our own inter-task dependencies (unless it comes
32 # from a mcdepends). The exception is the special
33 # do_kernel_configme->do_unpack_and_patch dependency from archiver.bbclass.
34 if recipename == depname and depmc == mc:
35 if task == "do_kernel_configme" and deptaskname == "do_unpack_and_patch":
Brad Bishop6e60e8b2018-02-01 10:27:11 -050036 return False
Patrick Williamsc124f4f2015-09-15 14:41:29 -050037 return True
38
Patrick Williamsc124f4f2015-09-15 14:41:29 -050039 # Exclude well defined recipe->dependency
40 if "%s->%s" % (recipename, depname) in siggen.saferecipedeps:
41 return False
42
Brad Bishop316dfdd2018-06-25 12:45:53 -040043 # Check for special wildcard
44 if "*->%s" % depname in siggen.saferecipedeps and recipename != depname:
45 return False
46
Patrick Williamsc124f4f2015-09-15 14:41:29 -050047 # Don't change native/cross/nativesdk recipe dependencies any further
48 if isNative(recipename) or isCross(recipename) or isNativeSDK(recipename):
49 return True
50
51 # Only target packages beyond here
52
53 # allarch packagegroups are assumed to have well behaved names which don't change between architecures/tunes
Andrew Geisslerd25ed322020-06-27 00:28:28 -050054 if isPackageGroup(mc, fn) and isAllArch(mc, fn) and not isNative(depname):
Brad Bishop1a4b7ee2018-12-16 17:11:34 -080055 return False
Patrick Williamsc124f4f2015-09-15 14:41:29 -050056
57 # Exclude well defined machine specific configurations which don't change ABI
Andrew Geisslerd25ed322020-06-27 00:28:28 -050058 if depname in siggen.abisaferecipes and not isImage(mc, fn):
Patrick Williamsc124f4f2015-09-15 14:41:29 -050059 return False
60
61 # Kernel modules are well namespaced. We don't want to depend on the kernel's checksum
62 # if we're just doing an RRECOMMENDS_xxx = "kernel-module-*", not least because the checksum
63 # is machine specific.
64 # Therefore if we're not a kernel or a module recipe (inheriting the kernel classes)
65 # and we reccomend a kernel-module, we exclude the dependency.
Andrew Geisslerd25ed322020-06-27 00:28:28 -050066 if dataCaches and isKernel(depmc, depmcfn) and not isKernel(mc, fn):
67 for pkg in dataCaches[mc].runrecs[fn]:
68 if " ".join(dataCaches[mc].runrecs[fn][pkg]).find("kernel-module-") != -1:
Patrick Williamsc124f4f2015-09-15 14:41:29 -050069 return False
70
71 # Default to keep dependencies
72 return True
73
74def sstate_lockedsigs(d):
75 sigs = {}
Brad Bishop6e60e8b2018-02-01 10:27:11 -050076 types = (d.getVar("SIGGEN_LOCKEDSIGS_TYPES") or "").split()
Patrick Williamsc124f4f2015-09-15 14:41:29 -050077 for t in types:
Patrick Williamsd8c66bc2016-06-20 12:57:21 -050078 siggen_lockedsigs_var = "SIGGEN_LOCKEDSIGS_%s" % t
Brad Bishop6e60e8b2018-02-01 10:27:11 -050079 lockedsigs = (d.getVar(siggen_lockedsigs_var) or "").split()
Patrick Williamsc124f4f2015-09-15 14:41:29 -050080 for ls in lockedsigs:
81 pn, task, h = ls.split(":", 2)
82 if pn not in sigs:
83 sigs[pn] = {}
Patrick Williamsd8c66bc2016-06-20 12:57:21 -050084 sigs[pn][task] = [h, siggen_lockedsigs_var]
Patrick Williamsc124f4f2015-09-15 14:41:29 -050085 return sigs
86
87class SignatureGeneratorOEBasic(bb.siggen.SignatureGeneratorBasic):
88 name = "OEBasic"
89 def init_rundepcheck(self, data):
Brad Bishop6e60e8b2018-02-01 10:27:11 -050090 self.abisaferecipes = (data.getVar("SIGGEN_EXCLUDERECIPES_ABISAFE") or "").split()
91 self.saferecipedeps = (data.getVar("SIGGEN_EXCLUDE_SAFE_RECIPE_DEPS") or "").split()
Patrick Williamsc124f4f2015-09-15 14:41:29 -050092 pass
Andrew Geisslerd25ed322020-06-27 00:28:28 -050093 def rundep_check(self, fn, recipename, task, dep, depname, dataCaches = None):
94 return sstate_rundepfilter(self, fn, recipename, task, dep, depname, dataCaches)
Patrick Williamsc124f4f2015-09-15 14:41:29 -050095
Brad Bishop00e122a2019-10-05 11:10:57 -040096class SignatureGeneratorOEBasicHashMixIn(object):
Andrew Geisslerd25ed322020-06-27 00:28:28 -050097 supports_multiconfig_datacaches = True
98
Patrick Williamsc124f4f2015-09-15 14:41:29 -050099 def init_rundepcheck(self, data):
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500100 self.abisaferecipes = (data.getVar("SIGGEN_EXCLUDERECIPES_ABISAFE") or "").split()
101 self.saferecipedeps = (data.getVar("SIGGEN_EXCLUDE_SAFE_RECIPE_DEPS") or "").split()
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500102 self.lockedsigs = sstate_lockedsigs(data)
103 self.lockedhashes = {}
104 self.lockedpnmap = {}
105 self.lockedhashfn = {}
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500106 self.machine = data.getVar("MACHINE")
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500107 self.mismatch_msgs = []
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500108 self.unlockedrecipes = (data.getVar("SIGGEN_UNLOCKED_RECIPES") or
Patrick Williamsd8c66bc2016-06-20 12:57:21 -0500109 "").split()
110 self.unlockedrecipes = { k: "" for k in self.unlockedrecipes }
Andrew Geissler82c905d2020-04-13 13:39:40 -0500111 self.buildarch = data.getVar('BUILD_ARCH')
112 self._internal = False
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500113 pass
Patrick Williamsf1e5d692016-03-30 15:21:19 -0500114
115 def tasks_resolved(self, virtmap, virtpnmap, dataCache):
116 # Translate virtual/xxx entries to PN values
117 newabisafe = []
118 for a in self.abisaferecipes:
119 if a in virtpnmap:
120 newabisafe.append(virtpnmap[a])
121 else:
122 newabisafe.append(a)
123 self.abisaferecipes = newabisafe
124 newsafedeps = []
125 for a in self.saferecipedeps:
126 a1, a2 = a.split("->")
127 if a1 in virtpnmap:
128 a1 = virtpnmap[a1]
129 if a2 in virtpnmap:
130 a2 = virtpnmap[a2]
131 newsafedeps.append(a1 + "->" + a2)
132 self.saferecipedeps = newsafedeps
133
Andrew Geisslerd25ed322020-06-27 00:28:28 -0500134 def rundep_check(self, fn, recipename, task, dep, depname, dataCaches = None):
135 return sstate_rundepfilter(self, fn, recipename, task, dep, depname, dataCaches)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500136
137 def get_taskdata(self):
Brad Bishop00e122a2019-10-05 11:10:57 -0400138 return (self.lockedpnmap, self.lockedhashfn, self.lockedhashes) + super().get_taskdata()
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500139
140 def set_taskdata(self, data):
Brad Bishop00e122a2019-10-05 11:10:57 -0400141 self.lockedpnmap, self.lockedhashfn, self.lockedhashes = data[:3]
142 super().set_taskdata(data[3:])
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500143
144 def dump_sigs(self, dataCache, options):
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600145 sigfile = os.getcwd() + "/locked-sigs.inc"
146 bb.plain("Writing locked sigs to %s" % sigfile)
147 self.dump_lockedsigs(sigfile)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500148 return super(bb.siggen.SignatureGeneratorBasicHash, self).dump_sigs(dataCache, options)
149
Andrew Geisslerd25ed322020-06-27 00:28:28 -0500150 def prep_taskhash(self, tid, deps, dataCaches):
151 super().prep_taskhash(tid, deps, dataCaches)
Andrew Geissler82c905d2020-04-13 13:39:40 -0500152 if hasattr(self, "extramethod"):
Andrew Geisslerd25ed322020-06-27 00:28:28 -0500153 (mc, _, _, fn) = bb.runqueue.split_tid_mcfn(tid)
154 inherits = " ".join(dataCaches[mc].inherits[fn])
Andrew Geissler82c905d2020-04-13 13:39:40 -0500155 if inherits.find("/native.bbclass") != -1 or inherits.find("/cross.bbclass") != -1:
156 self.extramethod[tid] = ":" + self.buildarch
157
Andrew Geisslerd25ed322020-06-27 00:28:28 -0500158 def get_taskhash(self, tid, deps, dataCaches):
Andrew Geissler82c905d2020-04-13 13:39:40 -0500159 if tid in self.lockedhashes:
160 if self.lockedhashes[tid]:
161 return self.lockedhashes[tid]
162 else:
Andrew Geisslerd25ed322020-06-27 00:28:28 -0500163 return super().get_taskhash(tid, deps, dataCaches)
Andrew Geissler82c905d2020-04-13 13:39:40 -0500164
Andrew Geisslerd25ed322020-06-27 00:28:28 -0500165 h = super().get_taskhash(tid, deps, dataCaches)
Brad Bishop08902b02019-08-20 09:16:51 -0400166
167 (mc, _, task, fn) = bb.runqueue.split_tid_mcfn(tid)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500168
Andrew Geisslerd25ed322020-06-27 00:28:28 -0500169 recipename = dataCaches[mc].pkg_fn[fn]
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500170 self.lockedpnmap[fn] = recipename
Andrew Geisslerd25ed322020-06-27 00:28:28 -0500171 self.lockedhashfn[fn] = dataCaches[mc].hashfn[fn]
Patrick Williamsd8c66bc2016-06-20 12:57:21 -0500172
173 unlocked = False
174 if recipename in self.unlockedrecipes:
175 unlocked = True
176 else:
177 def recipename_from_dep(dep):
Andrew Geisslerd25ed322020-06-27 00:28:28 -0500178 (depmc, _, _, depfn) = bb.runqueue.split_tid_mcfn(dep)
179 return dataCaches[depmc].pkg_fn[depfn]
Patrick Williamsd8c66bc2016-06-20 12:57:21 -0500180
181 # If any unlocked recipe is in the direct dependencies then the
182 # current recipe should be unlocked as well.
Brad Bishop08902b02019-08-20 09:16:51 -0400183 depnames = [ recipename_from_dep(x) for x in deps if mc == bb.runqueue.mc_from_tid(x)]
Patrick Williamsd8c66bc2016-06-20 12:57:21 -0500184 if any(x in y for y in depnames for x in self.unlockedrecipes):
185 self.unlockedrecipes[recipename] = ''
186 unlocked = True
187
188 if not unlocked and recipename in self.lockedsigs:
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500189 if task in self.lockedsigs[recipename]:
Patrick Williamsd8c66bc2016-06-20 12:57:21 -0500190 h_locked = self.lockedsigs[recipename][task][0]
191 var = self.lockedsigs[recipename][task][1]
Brad Bishop08902b02019-08-20 09:16:51 -0400192 self.lockedhashes[tid] = h_locked
Andrew Geissler82c905d2020-04-13 13:39:40 -0500193 self._internal = True
194 unihash = self.get_unihash(tid)
195 self._internal = False
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500196 #bb.warn("Using %s %s %s" % (recipename, task, h))
197
Brad Bishop00e122a2019-10-05 11:10:57 -0400198 if h != h_locked and h_locked != unihash:
Patrick Williamsd8c66bc2016-06-20 12:57:21 -0500199 self.mismatch_msgs.append('The %s:%s sig is computed to be %s, but the sig is locked to %s in %s'
200 % (recipename, task, h, h_locked, var))
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500201
202 return h_locked
Andrew Geissler82c905d2020-04-13 13:39:40 -0500203
204 self.lockedhashes[tid] = False
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500205 #bb.warn("%s %s %s" % (recipename, task, h))
206 return h
207
Andrew Geissler82c905d2020-04-13 13:39:40 -0500208 def get_stampfile_hash(self, tid):
209 if tid in self.lockedhashes and self.lockedhashes[tid]:
210 return self.lockedhashes[tid]
211 return super().get_stampfile_hash(tid)
212
Brad Bishop00e122a2019-10-05 11:10:57 -0400213 def get_unihash(self, tid):
Andrew Geissler82c905d2020-04-13 13:39:40 -0500214 if tid in self.lockedhashes and self.lockedhashes[tid] and not self._internal:
Brad Bishop00e122a2019-10-05 11:10:57 -0400215 return self.lockedhashes[tid]
216 return super().get_unihash(tid)
217
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500218 def dump_sigtask(self, fn, task, stampbase, runtime):
Brad Bishop08902b02019-08-20 09:16:51 -0400219 tid = fn + ":" + task
Andrew Geissler82c905d2020-04-13 13:39:40 -0500220 if tid in self.lockedhashes and self.lockedhashes[tid]:
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500221 return
222 super(bb.siggen.SignatureGeneratorBasicHash, self).dump_sigtask(fn, task, stampbase, runtime)
223
Patrick Williamsc0f7c042017-02-23 20:41:17 -0600224 def dump_lockedsigs(self, sigfile, taskfilter=None):
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500225 types = {}
Brad Bishop08902b02019-08-20 09:16:51 -0400226 for tid in self.runtaskdeps:
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500227 if taskfilter:
Brad Bishop08902b02019-08-20 09:16:51 -0400228 if not tid in taskfilter:
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500229 continue
Brad Bishop08902b02019-08-20 09:16:51 -0400230 fn = bb.runqueue.fn_from_tid(tid)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500231 t = self.lockedhashfn[fn].split(" ")[1].split(":")[5]
232 t = 't-' + t.replace('_', '-')
233 if t not in types:
234 types[t] = []
Brad Bishop08902b02019-08-20 09:16:51 -0400235 types[t].append(tid)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500236
237 with open(sigfile, "w") as f:
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500238 l = sorted(types)
239 for t in l:
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500240 f.write('SIGGEN_LOCKEDSIGS_%s = "\\\n' % t)
241 types[t].sort()
Brad Bishop08902b02019-08-20 09:16:51 -0400242 sortedtid = sorted(types[t], key=lambda tid: self.lockedpnmap[bb.runqueue.fn_from_tid(tid)])
243 for tid in sortedtid:
244 (_, _, task, fn) = bb.runqueue.split_tid_mcfn(tid)
245 if tid not in self.taskhash:
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500246 continue
Brad Bishop00e122a2019-10-05 11:10:57 -0400247 f.write(" " + self.lockedpnmap[fn] + ":" + task + ":" + self.get_unihash(tid) + " \\\n")
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500248 f.write(' "\n')
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500249 f.write('SIGGEN_LOCKEDSIGS_TYPES_%s = "%s"' % (self.machine, " ".join(l)))
250
251 def dump_siglist(self, sigfile):
252 with open(sigfile, "w") as f:
253 tasks = []
254 for taskitem in self.taskhash:
Brad Bishop08902b02019-08-20 09:16:51 -0400255 (fn, task) = taskitem.rsplit(":", 1)
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500256 pn = self.lockedpnmap[fn]
257 tasks.append((pn, task, fn, self.taskhash[taskitem]))
258 for (pn, task, fn, taskhash) in sorted(tasks):
Brad Bishop08902b02019-08-20 09:16:51 -0400259 f.write('%s:%s %s %s\n' % (pn, task, fn, taskhash))
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500260
Brad Bishop08902b02019-08-20 09:16:51 -0400261 def checkhashes(self, sq_data, missed, found, d):
Patrick Williamsd8c66bc2016-06-20 12:57:21 -0500262 warn_msgs = []
263 error_msgs = []
264 sstate_missing_msgs = []
265
Brad Bishop08902b02019-08-20 09:16:51 -0400266 for tid in sq_data['hash']:
267 if tid not in found:
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500268 for pn in self.lockedsigs:
Brad Bishop08902b02019-08-20 09:16:51 -0400269 taskname = bb.runqueue.taskname_from_tid(tid)
270 if sq_data['hash'][tid] in iter(self.lockedsigs[pn].values()):
271 if taskname == 'do_shared_workdir':
Patrick Williamsd8c66bc2016-06-20 12:57:21 -0500272 continue
273 sstate_missing_msgs.append("Locked sig is set for %s:%s (%s) yet not in sstate cache?"
Brad Bishop08902b02019-08-20 09:16:51 -0400274 % (pn, taskname, sq_data['hash'][tid]))
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500275
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500276 checklevel = d.getVar("SIGGEN_LOCKEDSIGS_TASKSIG_CHECK")
Patrick Williamsd8c66bc2016-06-20 12:57:21 -0500277 if checklevel == 'warn':
278 warn_msgs += self.mismatch_msgs
279 elif checklevel == 'error':
280 error_msgs += self.mismatch_msgs
281
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500282 checklevel = d.getVar("SIGGEN_LOCKEDSIGS_SSTATE_EXISTS_CHECK")
Patrick Williamsd8c66bc2016-06-20 12:57:21 -0500283 if checklevel == 'warn':
284 warn_msgs += sstate_missing_msgs
285 elif checklevel == 'error':
286 error_msgs += sstate_missing_msgs
287
288 if warn_msgs:
289 bb.warn("\n".join(warn_msgs))
290 if error_msgs:
291 bb.fatal("\n".join(error_msgs))
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500292
Brad Bishop00e122a2019-10-05 11:10:57 -0400293class SignatureGeneratorOEBasicHash(SignatureGeneratorOEBasicHashMixIn, bb.siggen.SignatureGeneratorBasicHash):
294 name = "OEBasicHash"
295
296class SignatureGeneratorOEEquivHash(SignatureGeneratorOEBasicHashMixIn, bb.siggen.SignatureGeneratorUniHashMixIn, bb.siggen.SignatureGeneratorBasicHash):
Brad Bishop19323692019-04-05 15:28:33 -0400297 name = "OEEquivHash"
298
299 def init_rundepcheck(self, data):
300 super().init_rundepcheck(data)
Brad Bishopa34c0302019-09-23 22:34:48 -0400301 self.server = data.getVar('BB_HASHSERVE')
Brad Bishop08902b02019-08-20 09:16:51 -0400302 if not self.server:
Brad Bishopa34c0302019-09-23 22:34:48 -0400303 bb.fatal("OEEquivHash requires BB_HASHSERVE to be set")
Brad Bishop19323692019-04-05 15:28:33 -0400304 self.method = data.getVar('SSTATE_HASHEQUIV_METHOD')
Brad Bishop08902b02019-08-20 09:16:51 -0400305 if not self.method:
306 bb.fatal("OEEquivHash requires SSTATE_HASHEQUIV_METHOD to be set")
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500307
308# Insert these classes into siggen's namespace so it can see and select them
309bb.siggen.SignatureGeneratorOEBasic = SignatureGeneratorOEBasic
310bb.siggen.SignatureGeneratorOEBasicHash = SignatureGeneratorOEBasicHash
Brad Bishop19323692019-04-05 15:28:33 -0400311bb.siggen.SignatureGeneratorOEEquivHash = SignatureGeneratorOEEquivHash
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500312
313
314def find_siginfo(pn, taskname, taskhashlist, d):
315 """ Find signature data files for comparison purposes """
316
317 import fnmatch
318 import glob
319
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500320 if not taskname:
321 # We have to derive pn and taskname
322 key = pn
Brad Bishop08902b02019-08-20 09:16:51 -0400323 splitit = key.split('.bb:')
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500324 taskname = splitit[1]
325 pn = os.path.basename(splitit[0]).split('_')[0]
326 if key.startswith('virtual:native:'):
327 pn = pn + '-native'
328
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500329 hashfiles = {}
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500330 filedates = {}
331
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500332 def get_hashval(siginfo):
333 if siginfo.endswith('.siginfo'):
334 return siginfo.rpartition(':')[2].partition('_')[0]
335 else:
336 return siginfo.rpartition('.')[2]
337
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500338 # First search in stamps dir
339 localdata = d.createCopy()
340 localdata.setVar('MULTIMACH_TARGET_SYS', '*')
341 localdata.setVar('PN', pn)
342 localdata.setVar('PV', '*')
343 localdata.setVar('PR', '*')
344 localdata.setVar('EXTENDPE', '')
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500345 stamp = localdata.getVar('STAMP')
Patrick Williamsd8c66bc2016-06-20 12:57:21 -0500346 if pn.startswith("gcc-source"):
347 # gcc-source shared workdir is a special case :(
348 stamp = localdata.expand("${STAMPS_DIR}/work-shared/gcc-${PV}-${PR}")
349
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500350 filespec = '%s.%s.sigdata.*' % (stamp, taskname)
351 foundall = False
352 import glob
353 for fullpath in glob.glob(filespec):
354 match = False
355 if taskhashlist:
356 for taskhash in taskhashlist:
357 if fullpath.endswith('.%s' % taskhash):
358 hashfiles[taskhash] = fullpath
359 if len(hashfiles) == len(taskhashlist):
360 foundall = True
361 break
362 else:
363 try:
364 filedates[fullpath] = os.stat(fullpath).st_mtime
365 except OSError:
366 continue
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500367 hashval = get_hashval(fullpath)
368 hashfiles[hashval] = fullpath
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500369
370 if not taskhashlist or (len(filedates) < 2 and not foundall):
371 # That didn't work, look in sstate-cache
Brad Bishop19323692019-04-05 15:28:33 -0400372 hashes = taskhashlist or ['?' * 64]
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500373 localdata = bb.data.createCopy(d)
374 for hashval in hashes:
375 localdata.setVar('PACKAGE_ARCH', '*')
376 localdata.setVar('TARGET_VENDOR', '*')
377 localdata.setVar('TARGET_OS', '*')
378 localdata.setVar('PN', pn)
379 localdata.setVar('PV', '*')
380 localdata.setVar('PR', '*')
381 localdata.setVar('BB_TASKHASH', hashval)
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500382 swspec = localdata.getVar('SSTATE_SWSPEC')
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500383 if taskname in ['do_fetch', 'do_unpack', 'do_patch', 'do_populate_lic', 'do_preconfigure'] and swspec:
384 localdata.setVar('SSTATE_PKGSPEC', '${SSTATE_SWSPEC}')
385 elif pn.endswith('-native') or "-cross-" in pn or "-crosssdk-" in pn:
386 localdata.setVar('SSTATE_EXTRAPATH', "${NATIVELSBSTRING}/")
387 sstatename = taskname[3:]
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500388 filespec = '%s_%s.*.siginfo' % (localdata.getVar('SSTATE_PKG'), sstatename)
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500389
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500390 matchedfiles = glob.glob(filespec)
391 for fullpath in matchedfiles:
392 actual_hashval = get_hashval(fullpath)
393 if actual_hashval in hashfiles:
394 continue
395 hashfiles[hashval] = fullpath
396 if not taskhashlist:
397 try:
398 filedates[fullpath] = os.stat(fullpath).st_mtime
399 except:
400 continue
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500401
402 if taskhashlist:
403 return hashfiles
404 else:
405 return filedates
406
407bb.siggen.find_siginfo = find_siginfo
408
409
410def sstate_get_manifest_filename(task, d):
411 """
412 Return the sstate manifest file path for a particular task.
413 Also returns the datastore that can be used to query related variables.
414 """
415 d2 = d.createCopy()
Brad Bishop6e60e8b2018-02-01 10:27:11 -0500416 extrainf = d.getVarFlag("do_" + task, 'stamp-extra-info')
Patrick Williamsc124f4f2015-09-15 14:41:29 -0500417 if extrainf:
418 d2.setVar("SSTATE_MANMACH", extrainf)
419 return (d2.expand("${SSTATE_MANFILEPREFIX}.%s" % task), d2)
Brad Bishop316dfdd2018-06-25 12:45:53 -0400420
421def find_sstate_manifest(taskdata, taskdata2, taskname, d, multilibcache):
422 d2 = d
423 variant = ''
Brad Bishop1a4b7ee2018-12-16 17:11:34 -0800424 curr_variant = ''
425 if d.getVar("BBEXTENDCURR") == "multilib":
426 curr_variant = d.getVar("BBEXTENDVARIANT")
427 if "virtclass-multilib" not in d.getVar("OVERRIDES"):
428 curr_variant = "invalid"
Brad Bishop316dfdd2018-06-25 12:45:53 -0400429 if taskdata2.startswith("virtual:multilib"):
430 variant = taskdata2.split(":")[2]
Brad Bishop1a4b7ee2018-12-16 17:11:34 -0800431 if curr_variant != variant:
Brad Bishop316dfdd2018-06-25 12:45:53 -0400432 if variant not in multilibcache:
433 multilibcache[variant] = oe.utils.get_multilib_datastore(variant, d)
434 d2 = multilibcache[variant]
435
436 if taskdata.endswith("-native"):
Andrew Geissler6ce62a22020-11-30 19:58:47 -0600437 pkgarchs = ["${BUILD_ARCH}", "${BUILD_ARCH}_${ORIGNATIVELSBSTRING}"]
Brad Bishop316dfdd2018-06-25 12:45:53 -0400438 elif taskdata.startswith("nativesdk-"):
439 pkgarchs = ["${SDK_ARCH}_${SDK_OS}", "allarch"]
440 elif "-cross-canadian" in taskdata:
441 pkgarchs = ["${SDK_ARCH}_${SDK_ARCH}-${SDKPKGSUFFIX}"]
442 elif "-cross-" in taskdata:
443 pkgarchs = ["${BUILD_ARCH}_${TARGET_ARCH}"]
444 elif "-crosssdk" in taskdata:
445 pkgarchs = ["${BUILD_ARCH}_${SDK_ARCH}_${SDK_OS}"]
446 else:
447 pkgarchs = ['${MACHINE_ARCH}']
448 pkgarchs = pkgarchs + list(reversed(d2.getVar("PACKAGE_EXTRA_ARCHS").split()))
449 pkgarchs.append('allarch')
450 pkgarchs.append('${SDK_ARCH}_${SDK_ARCH}-${SDKPKGSUFFIX}')
451
452 for pkgarch in pkgarchs:
453 manifest = d2.expand("${SSTATE_MANIFESTS}/manifest-%s-%s.%s" % (pkgarch, taskdata, taskname))
454 if os.path.exists(manifest):
455 return manifest, d2
456 bb.warn("Manifest %s not found in %s (variant '%s')?" % (manifest, d2.expand(" ".join(pkgarchs)), variant))
457 return None, d2
458
Brad Bishop19323692019-04-05 15:28:33 -0400459def OEOuthashBasic(path, sigfile, task, d):
460 """
461 Basic output hash function
462
463 Calculates the output hash of a task by hashing all output file metadata,
464 and file contents.
465 """
466 import hashlib
467 import stat
468 import pwd
469 import grp
470
471 def update_hash(s):
472 s = s.encode('utf-8')
473 h.update(s)
474 if sigfile:
475 sigfile.write(s)
476
477 h = hashlib.sha256()
478 prev_dir = os.getcwd()
479 include_owners = os.environ.get('PSEUDO_DISABLED') == '0'
Andrew Geisslerf0343792020-11-18 10:42:21 -0600480 if "package_write_" in task or task == "package_qa":
481 include_owners = False
Andrew Geissler6ce62a22020-11-30 19:58:47 -0600482 include_timestamps = False
483 if task == "package":
484 include_timestamps = d.getVar('BUILD_REPRODUCIBLE_BINARIES') == '1'
Andrew Geissler82c905d2020-04-13 13:39:40 -0500485 extra_content = d.getVar('HASHEQUIV_HASH_VERSION')
Brad Bishop19323692019-04-05 15:28:33 -0400486
487 try:
488 os.chdir(path)
489
490 update_hash("OEOuthashBasic\n")
Andrew Geissler82c905d2020-04-13 13:39:40 -0500491 if extra_content:
492 update_hash(extra_content + "\n")
Brad Bishop19323692019-04-05 15:28:33 -0400493
494 # It is only currently useful to get equivalent hashes for things that
495 # can be restored from sstate. Since the sstate object is named using
496 # SSTATE_PKGSPEC and the task name, those should be included in the
497 # output hash calculation.
498 update_hash("SSTATE_PKGSPEC=%s\n" % d.getVar('SSTATE_PKGSPEC'))
499 update_hash("task=%s\n" % task)
500
501 for root, dirs, files in os.walk('.', topdown=True):
502 # Sort directories to ensure consistent ordering when recursing
503 dirs.sort()
504 files.sort()
505
506 def process(path):
507 s = os.lstat(path)
508
509 if stat.S_ISDIR(s.st_mode):
510 update_hash('d')
511 elif stat.S_ISCHR(s.st_mode):
512 update_hash('c')
513 elif stat.S_ISBLK(s.st_mode):
514 update_hash('b')
515 elif stat.S_ISSOCK(s.st_mode):
516 update_hash('s')
517 elif stat.S_ISLNK(s.st_mode):
518 update_hash('l')
519 elif stat.S_ISFIFO(s.st_mode):
520 update_hash('p')
521 else:
522 update_hash('-')
523
524 def add_perm(mask, on, off='-'):
525 if mask & s.st_mode:
526 update_hash(on)
527 else:
528 update_hash(off)
529
530 add_perm(stat.S_IRUSR, 'r')
531 add_perm(stat.S_IWUSR, 'w')
532 if stat.S_ISUID & s.st_mode:
533 add_perm(stat.S_IXUSR, 's', 'S')
534 else:
535 add_perm(stat.S_IXUSR, 'x')
536
537 add_perm(stat.S_IRGRP, 'r')
538 add_perm(stat.S_IWGRP, 'w')
539 if stat.S_ISGID & s.st_mode:
540 add_perm(stat.S_IXGRP, 's', 'S')
541 else:
542 add_perm(stat.S_IXGRP, 'x')
543
544 add_perm(stat.S_IROTH, 'r')
545 add_perm(stat.S_IWOTH, 'w')
546 if stat.S_ISVTX & s.st_mode:
547 update_hash('t')
548 else:
549 add_perm(stat.S_IXOTH, 'x')
550
551 if include_owners:
Andrew Geissler82c905d2020-04-13 13:39:40 -0500552 try:
553 update_hash(" %10s" % pwd.getpwuid(s.st_uid).pw_name)
554 update_hash(" %10s" % grp.getgrgid(s.st_gid).gr_name)
555 except KeyError:
556 bb.warn("KeyError in %s" % path)
557 raise
Brad Bishop19323692019-04-05 15:28:33 -0400558
Andrew Geissler6ce62a22020-11-30 19:58:47 -0600559 if include_timestamps:
560 update_hash(" %10d" % s.st_mtime)
561
Brad Bishop19323692019-04-05 15:28:33 -0400562 update_hash(" ")
563 if stat.S_ISBLK(s.st_mode) or stat.S_ISCHR(s.st_mode):
564 update_hash("%9s" % ("%d.%d" % (os.major(s.st_rdev), os.minor(s.st_rdev))))
565 else:
566 update_hash(" " * 9)
567
568 update_hash(" ")
569 if stat.S_ISREG(s.st_mode):
570 update_hash("%10d" % s.st_size)
571 else:
572 update_hash(" " * 10)
573
574 update_hash(" ")
575 fh = hashlib.sha256()
576 if stat.S_ISREG(s.st_mode):
577 # Hash file contents
578 with open(path, 'rb') as d:
579 for chunk in iter(lambda: d.read(4096), b""):
580 fh.update(chunk)
581 update_hash(fh.hexdigest())
582 else:
583 update_hash(" " * len(fh.hexdigest()))
584
585 update_hash(" %s" % path)
586
587 if stat.S_ISLNK(s.st_mode):
588 update_hash(" -> %s" % os.readlink(path))
589
590 update_hash("\n")
591
592 # Process this directory and all its child files
593 process(root)
594 for f in files:
595 if f == 'fixmepath':
596 continue
597 process(os.path.join(root, f))
598 finally:
599 os.chdir(prev_dir)
600
601 return h.hexdigest()
602
Brad Bishop316dfdd2018-06-25 12:45:53 -0400603