[bitbake-devel,23/26] runqueue: Alter setscenewhitelist handling

Submitted by Richard Purdie on July 10, 2019, 11:54 p.m. | Patch ID: 162972

Details

Message ID 20190710235420.23825-23-richard.purdie@linuxfoundation.org
State Master Next
Commit eb3b22757203ac06ff4b6aa9a9326bff5df0a624
Headers show

Commit Message

Richard Purdie July 10, 2019, 11:54 p.m.
Since there is now parallel execution of setscene and normal tasks, the way
setscenewhitelist handling worked can't function the way it did. Paul and I
never liked its error output anyway.

This code tries a different approach, checking the task at execution time
but printing the uncovered task list.

This code may need improvement after real world usage but can
work with the new task flows.

Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
---
 lib/bb/runqueue.py | 78 +++++++++++++++++-----------------------------
 1 file changed, 29 insertions(+), 49 deletions(-)

Patch hide | download patch | download mbox

diff --git a/lib/bb/runqueue.py b/lib/bb/runqueue.py
index e4994f6c52..e7ba610723 100644
--- a/lib/bb/runqueue.py
+++ b/lib/bb/runqueue.py
@@ -1681,49 +1681,6 @@  class RunQueue:
                 output = bb.siggen.compare_sigfiles(latestmatch, match, recursecb)
                 bb.plain("\nTask %s:%s couldn't be used from the cache because:\n  We need hash %s, closest matching task was %s\n  " % (pn, taskname, h, prevh) + '\n  '.join(output))
 
-def process_setscene_whitelist(rq, rqdata, stampcache, sched, rqex):
-    # Check tasks that are going to run against the whitelist
-    def check_norun_task(tid, showerror=False):
-        (mc, fn, taskname, taskfn) = split_tid_mcfn(tid)
-        # Ignore covered tasks
-        if tid in rqex.tasks_covered:
-            return False
-        # Ignore stamped tasks
-        if rq.check_stamp_task(tid, taskname, cache=stampcache):
-            return False
-        # Ignore noexec tasks
-        taskdep = rqdata.dataCaches[mc].task_deps[taskfn]
-        if 'noexec' in taskdep and taskname in taskdep['noexec']:
-            return False
-
-        pn = rqdata.dataCaches[mc].pkg_fn[taskfn]
-        if not check_setscene_enforce_whitelist(pn, taskname, rqdata.setscenewhitelist):
-            if showerror:
-                if tid in rqdata.runq_setscene_tids:
-                    logger.error('Task %s.%s attempted to execute unexpectedly and should have been setscened' % (pn, taskname))
-                else:
-                    logger.error('Task %s.%s attempted to execute unexpectedly' % (pn, taskname))
-            return True
-        return False
-    # Look to see if any tasks that we think shouldn't run are going to
-    unexpected = False
-    for tid in rqdata.runtaskentries:
-        if check_norun_task(tid):
-            unexpected = True
-            break
-    if unexpected:
-        # Run through the tasks in the rough order they'd have executed and print errors
-        # (since the order can be useful - usually missing sstate for the last few tasks
-        # is the cause of the problem)
-        task = sched.next()
-        while task is not None:
-            check_norun_task(task, showerror=True)
-            rqex.task_skip(task, 'Setscene enforcement check')
-            task = sched.next()
-
-        rq.state = runQueueCleanUp
-        return True
-
 
 class RunQueueExecute:
 
@@ -1944,12 +1901,6 @@  class RunQueueExecute:
         Run the tasks in a queue prepared by rqdata.prepare()
         """
 
-        if self.rqdata.setscenewhitelist is not None and not self.rqdata.setscenewhitelist_checked:
-            self.rqdata.setscenewhitelist_checked = True
-
-            if process_setscenewhitelist(self.rq, self.rqdata, self.stampcache, self.sched, self):
-                return True
-
         if self.cooker.configuration.setsceneonly:
             return True
 
@@ -1963,6 +1914,11 @@  class RunQueueExecute:
         if task is not None:
             (mc, fn, taskname, taskfn) = split_tid_mcfn(task)
 
+            if self.rqdata.setscenewhitelist is not None:
+                if self.check_setscenewhitelist(task):
+                    self.task_fail(task, "setscene whitelist")
+                    return True
+
             if task in self.tasks_covered:
                 logger.debug(2, "Setscene covered task %s", task)
                 self.task_skip(task, "covered")
@@ -2357,6 +2313,30 @@  class RunQueueExecute:
         #bb.note("Task %s: " % task + str(taskdepdata).replace("], ", "],\n"))
         return taskdepdata
 
+    def check_setscenewhitelist(self, tid):
+        # Check task that is going to run against the whitelist
+        (mc, fn, taskname, taskfn) = split_tid_mcfn(tid)
+        # Ignore covered tasks
+        if tid in self.tasks_covered:
+            return False
+        # Ignore stamped tasks
+        if self.rq.check_stamp_task(tid, taskname, cache=self.stampcache):
+            return False
+        # Ignore noexec tasks
+        taskdep = self.rqdata.dataCaches[mc].task_deps[taskfn]
+        if 'noexec' in taskdep and taskname in taskdep['noexec']:
+            return False
+
+        pn = self.rqdata.dataCaches[mc].pkg_fn[taskfn]
+        if not check_setscene_enforce_whitelist(pn, taskname, self.rqdata.setscenewhitelist):
+            if tid in self.rqdata.runq_setscene_tids:
+                msg = 'Task %s.%s attempted to execute unexpectedly and should have been setscened' % (pn, taskname)
+            else:
+                msg = 'Task %s.%s attempted to execute unexpectedly' % (pn, taskname)
+            logger.error(msg + '\nThis is usually due to missing setscene tasks. Those missing in this build were: %s' % pprint.pformat(self.scenequeue_notcovered))
+            return True
+        return False
+
 class SQData(object):
     def __init__(self):
         self.sq_harddeps = {}