Changeset ed5367b in mainline for uspace/srv/sysman/units

Timestamp:

2019-08-07T10:01:13Z (7 years ago)

Author:

Matthieu Riolo <matthieu.riolo@…>

Children:

a097c50

Parents:

68ae40a

git-author:

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

git-committer:

Matthieu Riolo <matthieu.riolo@…> (2019-08-07 10:01:13)

Message:

sysman: Implement stopping units

Currently fails service monitoring because of taskman flawed event flags.
However, job closure works well.

Location:

uspace/srv/sysman/units

Files:

• unit_cfg.c (modified) (1 diff)
• unit_mnt.c (modified) (1 diff)
• unit_svc.c (modified) (1 diff)
• unit_tgt.c (modified) (1 diff)

uspace/srv/sysman/units/unit_cfg.c

@@ -240 +240 @@
 }
 
+static int unit_cfg_stop(unit_t *unit)
+{
+        unit_cfg_t *u_cfg = CAST_CFG(unit);
+        assert(u_cfg);
+
+        /*
+         * It makes no sense to stop configuration (i.e. unload it), however,
+         * lets virtually stop it not to make obstructions for potential
+         * restart = reload of configuration.
+         */
+        unit->state = STATE_STOPPED;
+        return EOK;
+}
+
 static void unit_cfg_exposee_created(unit_t *unit)
 {

uspace/srv/sysman/units/unit_mnt.c

@@ -229 +229 @@
 }
 
+static int unit_mnt_stop(unit_t *unit)
+{
+        unit_mnt_t *u_mnt = CAST_MNT(unit);
+        assert(u_mnt);
+        /* autostart implies blocking */
+        assert(!u_mnt->autostart || u_mnt->blocking);
+
+        
+        // TODO think about unit's lifecycle (is STOPPED only acceptable?)
+        // note: we should never hit STATE_STARTING, since it'd mean there are
+        //       two jobs running at once (unless job cancellation is implemented)
+        assert(unit->state == STATE_STARTED);
+
+        /*
+         * We don't expect unmount to be blocking, since if some files are
+         * being used, it'd return EBUSY immediately. That's why we call
+         * unmount synchronously in the event loop fibril.
+         */
+        int rc = unmount(u_mnt->mountpoint);
+
+        if (rc == EOK) {
+                unit->state = STATE_STOPPED;
+                return EOK;
+        } else if (rc == EBUSY) {
+                assert(unit->state == STATE_STARTED);
+                return EBUSY;
+        } else {
+                /*
+                 * Mount may be still usable, but be conservative and mark unit
+                 * as failed.
+                 */
+                unit->state = STATE_FAILED;
+                return rc;
+        }
+}
+
 static void unit_mnt_exposee_created(unit_t *unit)
 {

uspace/srv/sysman/units/unit_svc.c

@@ -112 +112 @@
 }
 
+static int unit_svc_stop(unit_t *unit)
+{
+        unit_svc_t *u_svc = CAST_SVC(unit);
+        assert(u_svc);
+
+        
+        // TODO think about unit's lifecycle (is STOPPED only acceptable?)
+        // note: May change when job cancellation is possible.
+        assert(unit->state == STATE_STARTED);
+
+        int rc = task_kill(u_svc->main_task_id);
+
+        if (rc != EOK) {
+                /* Task may still be running, but be conservative about unit's
+                 * state. */
+                unit->state = STATE_FAILED;
+                return rc;
+        }
+
+        unit->state = STATE_STOPPING;
+
+        return EOK;
+}
+
+
 static void unit_svc_exposee_created(unit_t *unit)
 {

uspace/srv/sysman/units/unit_tgt.c

@@ -63 +63 @@
 }
 
+static int unit_tgt_stop(unit_t *unit)
+{
+        unit_tgt_t *u_tgt = CAST_TGT(unit);
+        assert(u_tgt);
+
+        unit->state = STATE_STOPPED;
+        return EOK;
+}
+
 static void unit_tgt_exposee_created(unit_t *unit)
 {