Changeset be07995 in mainline

Timestamp:

2019-08-17T13:54:09Z (5 years ago)

Author:

Matthieu Riolo <matthieu.riolo@…>

Children:

8d74fdd

Parents:

015b147

git-author:

Michal Koutný <xm.koutny+hos@…> (2016-01-10 23:36:33)

git-committer:

Matthieu Riolo <matthieu.riolo@…> (2019-08-17 13:54:09)

Message:

sysman: Add support for closure creation with CLOSURE_ISOLATE flag

Now can create closures, that contain start jobs for all transitively dependent
jobs and stop for all others. (Next step: enqueue and execute.)

Location:

uspace/srv/sysman

Files:

• job_closure.c (modified) (6 diffs)
• job_closure.h (modified) (1 diff)
• repo.c (modified) (2 diffs)
• sysman.c (modified) (1 diff)
• test/job_closure.c (modified) (7 diffs)
• test/mock_unit.h (modified) (1 diff)

uspace/srv/sysman/job_closure.c

@@ -82 +82 @@
 /** During visit creates job and appends it to closure
  *
- * @note Assumes BFS start unit's job is already present in closure!
+ * @note Assumes BFS origin unit's job is already present in the closure on the
+ *       last position!
  *
  * @return EOK on success
@@ -94 +95 @@
 
         if (e == NULL) {
-                assert(u->bfs_data == NULL);
+                if (u->bfs_data != NULL) {
+                        goto finish;
+                }
                 job_t *first_job = dyn_array_last(closure, job_t *);
 
@@ -133 +136 @@
                 job_del_ref(&created_job);
         }
+        return rc;
+}
+
+static int visit_isolate(unit_t *u, unit_edge_t *e, bfs_ops_t *ops, void *arg)
+{
+        int rc = EOK;
+        job_t *created_job = NULL;
+        job_closure_t *closure = arg;
+
+        sysman_log(LVL_DEBUG2, "%s(%s)", __func__, unit_name(u));
+        /*
+         * Unit can have starting job from original request or from isolation
+         * BFS with different origin.
+         *
+         * Don't check u->state == STATE_STOPPED, closure is created stateless
+         * and its upon merging procedure to correctly resolve conflicting
+         * jobs.
+         *
+         * If we're at the origin (no BFS incoming edge), create a stop job,
+         * put it to the closure and let propagate as if called the propagate
+         * visitor.
+         */
+        if (e == NULL && u->bfs_data == NULL) {
+                created_job = job_create(u, STATE_STOPPED);
+                if (created_job == NULL) {
+                        rc = ENOMEM;
+                        goto finish;
+                }
+
+                /* Pass job reference to closure and add one for unit */
+                rc = dyn_array_append(closure, job_t *, created_job);
+                if (rc != EOK) {
+                        goto finish;
+                }
+        }
+        rc = visit_propagate_job(u, e, ops, closure);
+
+finish:
+        if (rc != EOK) {
+                job_del_ref(&created_job);
+        }
+        sysman_log(LVL_DEBUG2, "%s(%s) -> %i", __func__, unit_name(u), rc);
         return rc;
 }
@@ -217 +262 @@
 }
 
-// TODO bfs_traverse_all
-
+static int bfs_traverse_all(bfs_ops_t *ops, void *arg)
+{
+        /* Check invariant */
+        repo_foreach(u) {
+                assert(u->bfs_tag == false);
+        }
+        int rc = EOK;
+
+        repo_foreach(origin) {
+                sysman_log(LVL_DEBUG2, "%s: %p, %i", __func__, origin, origin->bfs_tag);
+                if (origin->bfs_tag == true) {
+                        continue;
+                }
+                rc = bfs_traverse_component_internal(origin, ops, arg);
+                if (rc != EOK) {
+                        goto finish;
+                }
+        }
+
+finish:
+        /* Clean after ourselves (BFS tag jobs) */
+        repo_foreach(u) {
+                u->bfs_tag = false;
+        }
+        return rc;
+}
 
 /*
@@ -230 +299 @@
  * @return EOK on success otherwise propagated error
  */
-int job_create_closure(job_t *main_job, job_closure_t *job_closure)
+int job_create_closure(job_t *main_job, job_closure_t *job_closure, int flags)
 {
         sysman_log(LVL_DEBUG2, "%s(%s)", __func__, unit_name(main_job->unit));
 
-        static bfs_ops_t ops = {
+        if ((flags & CLOSURE_ISOLATE) && main_job->target_state != STATE_STARTED) {
+                // TODO EINVAL?
+                return ENOTSUP;
+        }
+
+        int rc = dyn_array_append(job_closure, job_t *, main_job);
+        if (rc != EOK) {
+                return rc;
+        }
+        job_add_ref(main_job); /* Add one for the closure */
+
+        /* Propagate main_job to other (dependent) units */
+        static bfs_ops_t propagate_ops = {
                 .clean = traverse_clean,
                 .visit = visit_propagate_job
         };
-
         switch (main_job->target_state) {
         case STATE_STARTED:
-                ops.direction = BFS_FORWARD;
+                propagate_ops.direction = BFS_FORWARD;
                 break;
         case STATE_STOPPED:
-                ops.direction = BFS_BACKWARD;
+                propagate_ops.direction = BFS_BACKWARD;
                 break;
         default:
@@ -250 +330 @@
         }
 
-        int rc = dyn_array_append(job_closure, job_t *, main_job);
-        if (rc != EOK) {
-                return rc;
-        }
-        job_add_ref(main_job); /* Add one for the closure */
-
-        rc = bfs_traverse_component(main_job->unit, &ops, job_closure);
+        rc = bfs_traverse_component(main_job->unit, &propagate_ops, job_closure);
+
+        sysman_log(LVL_DEBUG2, "%s: %i&%i", __func__, flags, CLOSURE_ISOLATE);
+        if (flags & CLOSURE_ISOLATE) {
+                static bfs_ops_t isolate_ops = {
+                        .direction = BFS_BACKWARD,
+                        .clean = traverse_clean,
+                        .visit = visit_isolate
+                };
+                rc = bfs_traverse_all(&isolate_ops, job_closure);
+        }
 
         if (rc == EOK) {
-                sysman_log(LVL_DEBUG2, "%s(%s):", __func__, unit_name(main_job->unit));
                 dyn_array_foreach(*job_closure, job_t *, job_it) {
                         sysman_log(LVL_DEBUG2, "%s\t%s, refs: %u", __func__,

uspace/srv/sysman/job_closure.h

@@ -33 +33 @@
 
 #include "job.h"
-#include "unit.h"
+
+#define CLOSURE_ISOLATE 0x1
 
 typedef dyn_array_t job_closure_t;
 
-extern int job_create_closure(job_t *, job_closure_t *);
+extern int job_create_closure(job_t *, job_closure_t *, int);
 
 #endif

uspace/srv/sysman/repo.c

@@ -176 +176 @@
 }
 
-void repo_begin_update_(void) {
+void repo_begin_update(void) {
         sysman_log(LVL_DEBUG2, "%s", __func__);
         fibril_rwlock_write_lock(&repo_lock);
@@ -293 +293 @@
  * The function can be safely called from non-event loop fibrils
  */
-unit_t *repo_find_unit_by_name_(const char *name)
+unit_t *repo_find_unit_by_name(const char *name)
 {
         return repo_find_unit_by_name_internal(name, true);

uspace/srv/sysman/sysman.c

@@ -373 +373 @@
         free(job_args);
 
-        int rc = job_create_closure(job, &job_closure);
+        int rc = job_create_closure(job, &job_closure, 0);
         if (rc != EOK) {
                 sysman_log(LVL_ERROR, "Cannot create closure for job %p (%i)",

uspace/srv/sysman/test/job_closure.c

@@ -32 +32 @@
 
 #include "../job_closure.h"
+#include "../repo.h"
 
 #include "mock_unit.h"
@@ -50 +51 @@
 {
         if (expected->size != actual->size) {
-                printf("%s: |expected| - |actual| = %u\n",
-                    __func__, expected->size - actual->size);
+                printf("%s: |expected|, |actual| = %u, %u\n",
+                    __func__, expected->size, actual->size);
                 return false;
         }
@@ -119 +120 @@
         rc = dyn_array_reserve(&act_closure, MAX_TYPES * MAX_UNITS);
         assert(rc == EOK);
+
+        repo_init();
 }
 
@@ -148 +151 @@
         assert(main_job);
 
-        int rc = job_create_closure(main_job, &act_closure);
+        int rc = job_create_closure(main_job, &act_closure, 0);
         PCUT_ASSERT_INT_EQUALS(EOK, rc);
 
@@ -179 +182 @@
         assert(main_job);
 
-        int rc = job_create_closure(main_job, &act_closure);
+        int rc = job_create_closure(main_job, &act_closure, 0);
         PCUT_ASSERT_INT_EQUALS(EOK, rc);
 
@@ -212 +215 @@
         assert(main_job);
 
-        int rc = job_create_closure(main_job, &act_closure);
+        int rc = job_create_closure(main_job, &act_closure, 0);
         PCUT_ASSERT_INT_EQUALS(EOK, rc);
 
@@ -227 +230 @@
 }
 
+PCUT_TEST(job_closure_isolate_linears) {
+        unit_t *u0 = mock_units[UNIT_SERVICE][0];
+        unit_t *u1 = mock_units[UNIT_SERVICE][1];
+        unit_t *u2 = mock_units[UNIT_SERVICE][2];
+        unit_t *u3 = mock_units[UNIT_SERVICE][3];
+        unit_t *u4 = mock_units[UNIT_SERVICE][4];
+        unit_t *u5 = mock_units[UNIT_SERVICE][5];
+        unit_t *u6 = mock_units[UNIT_SERVICE][6];
+        repo_begin_update();
+        for (int i = 0; i < 7; ++i) {
+                repo_add_unit(mock_units[UNIT_SERVICE][i]);
+        }
+        repo_commit();
+
+        /*
+         *
+         * u0 -> u1 -> u2
+         *
+         * u3 -> u4 -> u5
+         *
+         * u6
+         */
+        mock_add_edge(u0, u1);
+        mock_add_edge(u1, u2);
+
+        mock_add_edge(u3, u4);
+        mock_add_edge(u4, u5);
+
+        job_t *main_job = job_create(u1, STATE_STARTED);
+        assert(main_job);
+
+        int rc = job_create_closure(main_job, &act_closure, CLOSURE_ISOLATE);
+        PCUT_ASSERT_INT_EQUALS(EOK, rc);
+
+        dyn_array_append(&exp_closure, job_t *, dummy_job(u0, STATE_STOPPED));
+        dyn_array_append(&exp_closure, job_t *, dummy_job(u1, STATE_STARTED));
+        dyn_array_append(&exp_closure, job_t *, dummy_job(u2, STATE_STARTED));
+        dyn_array_append(&exp_closure, job_t *, dummy_job(u3, STATE_STOPPED));
+        dyn_array_append(&exp_closure, job_t *, dummy_job(u4, STATE_STOPPED));
+        dyn_array_append(&exp_closure, job_t *, dummy_job(u5, STATE_STOPPED));
+        dyn_array_append(&exp_closure, job_t *, dummy_job(u6, STATE_STOPPED));
+
+        dummy_add_closure(&act_closure);
+
+        PCUT_ASSERT_TRUE(same_jobs(&exp_closure, &act_closure));
+        PCUT_ASSERT_TRUE(job_blocked(u1->job, u2->job));
+
+        PCUT_ASSERT_TRUE(job_blocked(u5->job, u4->job));
+        PCUT_ASSERT_TRUE(job_blocked(u4->job, u3->job));
+
+        PCUT_ASSERT_INT_EQUALS(0, u6->job->blocking_jobs);
+        PCUT_ASSERT_INT_EQUALS(0, u0->job->blocking_jobs);
+}
 
 PCUT_EXPORT(job_closure);

uspace/srv/sysman/test/mock_unit.h

@@ -36 +36 @@
 #include "../unit.h"
 
-#define MAX_UNITS 5
+#define MAX_UNITS 7
 #define MAX_TYPES 4