Changeset dda2602 in mainline for uspace/srv/sysman/job.c

Timestamp:

2019-08-03T09:41:07Z (5 years ago)

Author:

Matthieu Riolo <matthieu.riolo@…>

Children:

dd5c623

Parents:

c0e4fc50

git-author:

Michal Koutný <xm.koutny+hos@…> (2015-05-08 11:10:06)

git-committer:

Matthieu Riolo <matthieu.riolo@…> (2019-08-03 09:41:07)

Message:

sysman: Create units to start up to compositor

• add necessary units to support basic GUI (barber, vterm)
• lacking autostart is compensated with explicit dependencies
• IPC_FLAG_AUTOSTART in compositor and locsrv fix
• paths to v* binaries
• refactored job closure creation

Conflicts:

boot/Makefile.common
uspace/app/vlaunch/vlaunch.c
uspace/srv/hid/compositor/compositor.c
uspace/srv/locsrv/locsrv.c

File:

• uspace/srv/sysman/job.c (modified) (10 diffs)

uspace/srv/sysman/job.c

@@ -27 +27 @@
  */
 
-#include <adt/fifo.h>
+#include <adt/list.h>
 #include <assert.h>
 #include <errno.h>
-
+#include <stdlib.h>
+
+#include "configuration.h"
 #include "dep.h"
 #include "job.h"
@@ -42 +44 @@
  */
 
-static int job_add_blocked_job(job_t *job, job_t *blocked_job)
-{
-        int rc = dyn_array_append(&job->blocked_jobs, job_ptr_t, blocked_job);
+static int job_add_blocked_job(job_t *blocking_job, job_t *blocked_job)
+{
+        int rc = dyn_array_append(&blocking_job->blocked_jobs, job_ptr_t,
+            blocked_job);
         if (rc != EOK) {
                 return ENOMEM;
@@ -73 +76 @@
         assert(job);
         assert(u);
+        assert(u->job == NULL);
         memset(job, 0, sizeof(*job));
 
@@ -82 +86 @@
         job->unit = u;
 
-        dyn_array_initialize(&job->blocked_jobs, job_ptr_t, 0);
+        u->job = job;
+        job_add_ref(job);
+
+        (void)dyn_array_initialize(&job->blocked_jobs, job_ptr_t, 0);
         job->blocking_jobs = 0;
         job->blocking_job_failed = false;
@@ -225 +232 @@
 int job_create_closure(job_t *main_job, dyn_array_t *job_closure)
 {
-        // TODO replace hard-coded FIFO size with resizable FIFO
-        FIFO_INITIALIZE_DYNAMIC(jobs_fifo, job_ptr_t, 10);
-        void *fifo_data = fifo_create(jobs_fifo);
         int rc;
-        if (fifo_data == NULL) {
-                rc = ENOMEM;
-                goto finish;
-        }
-
-        /*
-         * Traverse dependency graph in BFS fashion and create jobs for every
-         * necessary unit.
-         * Closure keeps reference to each job. We've to add reference to the
-         * main job, other newly created jobs are pased to the closure.
-         */
-        fifo_push(jobs_fifo, main_job);
-        job_add_ref(main_job);
-        while (jobs_fifo.head != jobs_fifo.tail) {
-                job_t *job = fifo_pop(jobs_fifo);
+        list_t units_fifo;
+        list_initialize(&units_fifo);
+
+        /* Zero BFS tags before use */
+        list_foreach(units, units, unit_t, u) {
+                u->bfs_tag = false;
+        }
                 
+        unit_t *unit = main_job->unit;
+        list_append(&unit->bfs_link, &units_fifo);
+        unit->bfs_tag = true;
+        
+        while (!list_empty(&units_fifo)) {
+                unit = list_get_instance(list_first(&units_fifo), unit_t,
+                    bfs_link);
+                assert(unit->job);
+                list_remove(&unit->bfs_link);
+                job_t *job = unit->job;
+
+
                 // TODO more sophisticated check? (unit that is in transitional
                 //      state cannot have currently multiple jobs queued)
-                if (job->target_state == job->unit->state) {
+                if (job->target_state == unit->state) {
                         /*
                          * Job would do nothing, finish it on spot.
@@ -254 +262 @@
                         job->retval = JOB_OK;
                         job_finish(job);
-                        job_del_ref(&job);
                         continue;
-                } else {
-                        /* No refcount increase, pass it to the closure */
-                        dyn_array_append(job_closure, job_ptr_t, job);
                 }
 
-                /* Traverse dependencies edges */
-                unit_t *u = job->unit;
-                list_foreach(u->dependencies, dependencies, unit_dependency_t, dep) {
-                        // TODO prepare for reverse edge direction and
-                        //      non-identity state mapping
-                        job_t *new_job =
-                            job_create(dep->dependency, job->target_state);
-                        if (new_job == NULL) {
-                                rc = ENOMEM;
-                                goto finish;
+                job_add_ref(job);
+                dyn_array_append(job_closure, job_ptr_t, job);
+
+                /*
+                 * Traverse dependencies edges
+                 * Depending on dependency type and edge direction create
+                 * appropriate jobs.
+                 */
+                list_foreach(unit->dependencies, dependencies, unit_dependency_t, dep) {
+                        unit_t *u = dep->dependency;
+                        job_t *blocking_job;
+                        if (u->bfs_tag) {
+                                assert(u->job);
+                                blocking_job = u->job;
+                        } else {
+                                u->bfs_tag = true;
+                                blocking_job = job_create(u, job->target_state);
+                                if (blocking_job == NULL) {
+                                        rc = ENOMEM;
+                                        goto finish;
+                                }
+                                /* Reference to job is kept in unit */
+                                job_del_ref(&blocking_job);
+                                list_append(&u->bfs_link, &units_fifo);
                         }
-                        job_add_blocked_job(new_job, job);
-                        fifo_push(jobs_fifo, new_job);
+                        
+                        job_add_blocked_job(blocking_job, job);
                 }
         }
+        sysman_log(LVL_DEBUG2, "%s(%s):", __func__, unit_name(main_job->unit));
+        dyn_array_foreach(*job_closure, job_ptr_t, job_it) {
+                sysman_log(LVL_DEBUG2, "%s\t%s", __func__, unit_name((*job_it)->unit));
+        }
         rc = EOK;
 
 finish:
-        free(fifo_data);
-        /*
-         * Newly created jobs are already passed to the closure, thus not
-         * deleting reference to them here.
-         */
+        /* Any unprocessed jobs may be referenced by units */
+        list_foreach(units_fifo, bfs_link, unit_t, u) {
+                job_del_ref(&u->job);
+        }
         return rc;
 }
 
+/** Create job assigned to the unit
+ *
+ * @param[in]  unit          unit to be modified, its job must be empty
+ * @param[in]  target_state
+ *
+ * @return NULL or newly created job
+ *         There are two references to the job, one set in the unit and second
+ *         is the return value.
+ */
 job_t *job_create(unit_t *u, unit_state_t target_state)
 {
@@ -293 +323 @@
                 job_init(job, u, target_state);
 
-                /* Start with one reference for the creator */
+                /* Add one reference for the creator */
                 job_add_ref(job);
         }
@@ -354 +384 @@
         }
         if (rc != EOK) {
+                sysman_log(LVL_DEBUG, "%s(%p), %s -> %i, error: %i",
+                    __func__, job, unit_name(u), job->target_state, rc);
                 goto fail;
         }
@@ -378 +410 @@
         assert(job->state != JOB_FINISHED);
         assert(job->retval != JOB_UNDEFINED_);
+        assert(job->unit->job == job);
 
         sysman_log(LVL_DEBUG2, "%s(%p) %s -> %i",
@@ -390 +423 @@
         dyn_array_clear(&job->blocked_jobs);
 
-        /* Add reference for the event */
-        job_add_ref(job);
+        /*
+         * Remove job from unit and pass the reference from the unit to the
+         * event.
+         */
+        job->unit->job = NULL;
         sysman_raise_event(&sysman_event_job_finished, job);
 }