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

Timestamp:

2019-08-03T09:28:50Z (6 years ago)

Author:

Matthieu Riolo <matthieu.riolo@…>

Children:

c0e4fc50

Parents:

2dda1d4

git-author:

Michal Koutný <xm.koutny+hos@…> (2015-05-07 11:49:47)

git-committer:

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

Message:

sysman: Naive autostart instrumentation of locsrv

• Add IPC_FLAG_AUTOSTART flag.
• libsysman: sysman's broker and control API.
• Simple implementation of service unit, exposee verification is missing.
• Simple mapping of exposee to unit name in locsrv.
• Temporary debug prints in locsrv.

Conflicts:

boot/Makefile.common
boot/arch/amd64/Makefile.inc
uspace/lib/c/include/ipc/services.h
uspace/srv/locsrv/locsrv.c

File:

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

uspace/srv/sysman/job.c

@@ -73 +73 @@
         assert(job);
         assert(u);
+        memset(job, 0, sizeof(*job));
 
         link_initialize(&job->job_queue);
@@ -101 +102 @@
                 return false;
         }
-}
-
-static bool job_is_runnable(job_t *job)
-{
-        return job->state == JOB_QUEUED && job->blocking_jobs == 0;
 }
 
@@ -126 +122 @@
 }
 
-
-
-
 static void job_destroy(job_t **job_ptr)
 {
@@ -145 +138 @@
         free(job);
         *job_ptr = NULL;
+}
+
+static bool job_is_runnable(job_t *job)
+{
+        return job->state == JOB_QUEUED && job->blocking_jobs == 0;
+}
+
+/** Pop next runnable job
+ *
+ * @return runnable job or NULL when there's none
+ */
+static job_t *job_queue_pop_runnable(void)
+{
+        job_t *result = NULL;
+
+        /* Select first runnable job */
+        list_foreach(job_queue, job_queue, job_t, candidate) {
+                if (job_is_runnable(candidate)) {
+                        result = candidate;
+                        break;
+                }
+        }
+        if (result) {
+                /* Remove job from queue and pass reference to caller */
+                list_remove(&result->job_queue);
+                result->state = JOB_DEQUEUED;
+        }
+
+        return result;
 }
 
@@ -163 +185 @@
                         /*
                          * Currently we have strict strategy not permitting
-                         * multiple jobs for one unit in the queue.
+                         * multiple jobs for one unit in the queue at a time.
                          */
                         if ((*new_job_it)->unit == queued_job->unit) {
                                 sysman_log(LVL_ERROR,
-                                    "Cannot queue multiple jobs foor unit '%s'",
+                                    "Cannot queue multiple jobs for unit '%s'",
                                     unit_name((*new_job_it)->unit));
                                 return EEXIST;
@@ -184 +206 @@
 }
 
-/** Pop next runnable job
- *
- * @return runnable job or NULL when there's none
- */
-job_t *job_queue_pop_runnable(void)
-{
-        job_t *result = NULL;
-        link_t *first_link = list_first(&job_queue);
-        bool first_iteration = true;
-
-        list_foreach_safe(job_queue, cur_link, next_link) {
-                result = list_get_instance(cur_link, job_t, job_queue);
-                if (job_is_runnable(result)) {
-                        break;
-                } else if (!first_iteration && cur_link == first_link) {
-                        result = NULL;
-                        break;
-                } else {
-                        /*
-                         * We make no assuptions about ordering of jobs in the
-                         * queue, so just move the job to the end of the queue.
-                         * If there are exist topologic ordering, eventually
-                         * jobs will be reordered. Furthermore when if there
-                         * exists any runnable job, it's always found.
-                         */
-                        list_remove(cur_link);
-                        list_append(cur_link, &job_queue);
-                }
-                first_iteration = false;
-        }
-
-        if (result) {
-                /* Remove job from queue and pass refernce to caller */
-                list_remove(&result->job_queue);
-                result->state = JOB_DEQUEUED;
-        }
-
-        return result;
+/** Process all jobs that aren't transitively blocked
+ *
+ * Job can be blocked either by another job or by an incoming event, that will
+ * be queued after this job_queue_process call.
+ *
+ * TODO Write down rules from where this function can be called, to avoid stack
+ *      overflow.
+ */
+void job_queue_process(void)
+{
+        job_t *job;
+        while ((job = job_queue_pop_runnable())) {
+                job_run(job);
+                job_del_ref(&job);
+        }
 }
 
@@ -242 +241 @@
          */
         fifo_push(jobs_fifo, main_job);
-        job_t *job;
         job_add_ref(main_job);
-        while ((job = fifo_pop(jobs_fifo)) != NULL) {
-                /* No refcount increase, pass it to the closure */
-                dyn_array_append(job_closure, job_ptr_t, job);
+        while (jobs_fifo.head != jobs_fifo.tail) {
+                job_t *job = fifo_pop(jobs_fifo);
+                
+                // TODO more sophisticated check? (unit that is in transitional
+                //      state cannot have currently multiple jobs queued)
+                if (job->target_state == job->unit->state) {
+                        /*
+                         * Job would do nothing, finish it on spot.
+                         * No need to continue BFS search from it.
+                         */
+                        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 */
@@ -379 +392 @@
         /* Add reference for the event */
         job_add_ref(job);
-        sysman_raise_event(&sysman_event_job_changed, job);
-}
-
+        sysman_raise_event(&sysman_event_job_finished, job);
+}
+