Changeset 5559712 in mainline for uspace/srv/sysman/units/unit_mnt.c

Timestamp:

2019-08-03T09:28:50Z (5 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/units/unit_mnt.c (modified) (5 diffs)

uspace/srv/sysman/units/unit_mnt.c

@@ -32 +32 @@
 #include <stdlib.h>
 #include <vfs/vfs.h>
+#include <str.h>
 
 #include "log.h"
+#include "sysman.h"
 #include "unit.h"
 
@@ -39 +41 @@
 
 static config_item_t unit_configuration[] = {
-        {"What",  &config_parse_string, offsetof(unit_mnt_t, device),     NULL},
-        {"Where", &config_parse_string, offsetof(unit_mnt_t, mountpoint), NULL},
-        {"Type",  &config_parse_string, offsetof(unit_mnt_t, type),       NULL},
+        {"What",      &config_parse_string, offsetof(unit_mnt_t, device),     NULL},
+        {"Where",     &config_parse_string, offsetof(unit_mnt_t, mountpoint), NULL},
+        {"Type",      &config_parse_string, offsetof(unit_mnt_t, type),       NULL},
+        {"Autostart", &config_parse_bool,   offsetof(unit_mnt_t, autostart),  "true"},
+        {"Blocking",  &config_parse_bool,   offsetof(unit_mnt_t, blocking),   "true"},
         CONFIGURATION_ITEM_SENTINEL
 };
 
+typedef struct {
+        char *type;
+        char *mountpoint;
+        char *device;
+        char *options;
+        unsigned int flags;
+        unsigned int instance;
+
+        unit_t *unit;
+        bool owner;
+} mount_data_t;
+
+static void mount_data_destroy(mount_data_t **mnt_data_ptr)
+{
+        assert(mnt_data_ptr);
+        if (*mnt_data_ptr == NULL) {
+                return;
+        }
+
+        mount_data_t *mnt_data = *mnt_data_ptr;
+        free(mnt_data->type);
+        free(mnt_data->mountpoint);
+        free(mnt_data->device);
+        free(mnt_data->options);
+
+        free(mnt_data);
+        *mnt_data_ptr = NULL;
+}
+
+static bool mount_data_copy(mount_data_t *src, mount_data_t **dst_ptr)
+{
+        mount_data_t *dst = malloc(sizeof(mount_data_t));
+        if (dst == NULL) {
+                goto fail;
+        }
+
+        dst->type = str_dup(src->type);
+        if (dst->type == NULL)
+                goto fail;
+
+        dst->mountpoint = str_dup(src->mountpoint);
+        if (dst->mountpoint == NULL)
+                goto fail;
+
+        dst->device = str_dup(src->device);
+        if (dst->device == NULL)
+                goto fail;
+
+        dst->options = src->options ? str_dup(src->options) : NULL;
+        if (src->options != NULL && dst->options == NULL)
+                goto fail;
+
+        dst->flags = src->flags;
+        dst->instance = src->instance;
+        dst->unit = src->unit;
+        dst->owner = true;
+
+        *dst_ptr = dst;
+        return true;
+
+fail:
+        mount_data_destroy(&dst);
+        return false;
+}
+
 static void unit_mnt_init(unit_t *unit)
 {
         unit_mnt_t *u_mnt = CAST_MNT(unit);
         assert(u_mnt);
-
-        u_mnt->type = NULL;
-        u_mnt->mountpoint = NULL;
-        u_mnt->device = NULL;
 }
 
@@ -60 +125 @@
         unit_mnt_t *u_mnt = CAST_MNT(unit);
 
-        sysman_log(LVL_DEBUG2, "%s, %p, %p, %p", __func__,
-            u_mnt->type, u_mnt->mountpoint, u_mnt->device);
         free(u_mnt->type);
         free(u_mnt->mountpoint);
@@ -85 +148 @@
 }
 
+static int mount_exec(void *arg)
+{
+        mount_data_t *mnt_data = arg;
+        /*sysman_log(LVL_DEBUG2, "%s(%p, %p, %p, %p, %x, %u)",
+            __func__,
+            mnt_data->type, mnt_data->mountpoint, mnt_data->device, mnt_data->options,
+            mnt_data->flags, mnt_data->instance);*/
+        int rc = mount(mnt_data->type, mnt_data->mountpoint, mnt_data->device,
+            mnt_data->options ? mnt_data->options : "",
+            mnt_data->flags, mnt_data->instance);
+
+        if (rc == EOK) {
+                sysman_log(LVL_DEBUG, "Mount ('%s') mounted",
+                    unit_name(mnt_data->unit));
+                /*
+                 * Emulate future VFS broker fibril that notifies about created
+                 * exposee.
+                 * Difference: It'll notify exposee name only, we'll have to
+                 * match it...
+                 */
+                sysman_raise_event(&sysman_event_unit_exposee_created,
+                    mnt_data->unit);
+        } else {
+                sysman_log(LVL_ERROR, "Mount ('%s') failed (%i)",
+                    unit_name(mnt_data->unit), rc);
+                /*
+                 * Think about analogy of this event, probably timeout or sthing
+                 */
+                sysman_raise_event(&sysman_event_unit_failed,
+                    mnt_data->unit);
+        }
+
+        if (mnt_data->owner) {
+                mount_data_destroy(&mnt_data);
+        }
+
+        return EOK;
+}
+
 static int unit_mnt_start(unit_t *unit)
 {
-        // TODO replace with non-blocking
-        const bool blocking = true;
         unit_mnt_t *u_mnt = CAST_MNT(unit);
         assert(u_mnt);
+        /* autostart implies blocking */
+        assert(!u_mnt->autostart || u_mnt->blocking);
 
         
@@ -96 +198 @@
         assert(unit->state == STATE_STOPPED);
 
-
-        // TODO use other mount parameters
-        int rc = mount(u_mnt->type, u_mnt->mountpoint, u_mnt->device, "",
-            blocking ? IPC_FLAG_BLOCKING : 0, 0);
-
-        if (blocking) {
-                if (rc == EOK) {
-                        sysman_log(LVL_DEBUG, "Mount ('%s') mounted", unit_name(unit));
-                        unit->state = STATE_STARTED;
-                } else {
-                        sysman_log(LVL_ERROR, "Mount ('%s') failed (%i)",
-                            unit_name(unit), rc);
-                        unit->state = STATE_FAILED;
+        mount_data_t mnt_data;
+        memset(&mnt_data, 0, sizeof(mnt_data));
+        mnt_data.type       = u_mnt->type;
+        mnt_data.mountpoint = u_mnt->mountpoint;
+        mnt_data.device     = u_mnt->device;
+        /* TODO use other mount parameters
+         * mnt_data.options    = u_mnt->options;
+         * mnt_data.instance   = u_mnt->instance;
+         */
+
+        mnt_data.flags |= u_mnt->blocking ? IPC_FLAG_BLOCKING : 0;
+        mnt_data.flags |= u_mnt->autostart ? IPC_FLAG_AUTOSTART : 0;
+        mnt_data.unit = unit;
+
+        if (u_mnt->blocking) {
+                mount_data_t *heap_mnt_data = NULL;
+                if (!mount_data_copy(&mnt_data, &heap_mnt_data)) {
+                        return ENOMEM;
                 }
+                fid_t fib = fibril_create(&mount_exec, heap_mnt_data);
+                unit->state = STATE_STARTING;
+                fibril_add_ready(fib);
         } else {
-                if (rc == EOK) {
-                        sysman_log(LVL_DEBUG, "Mount ('%s') requested", unit_name(unit));
-                        unit->state = STATE_STARTING;
-                } else {
-                        sysman_log(LVL_ERROR, "Mount ('%s') request failed (%i)",
-                            unit_name(unit), rc);
-                        unit->state = STATE_FAILED;
-                }
-        }
-
-        return rc;
-}
+                unit->state = STATE_STARTING;
+                mount_exec(&mnt_data);
+        }
+
+        return EOK;
+}
+
+static void unit_mnt_exposee_created(unit_t *unit)
+{
+        assert(CAST_MNT(unit));
+        assert(unit->state == STATE_STOPPED || unit->state == STATE_STARTING);
+
+        unit->state = STATE_STARTED;
+        unit_notify_state(unit);
+}
+
+static void unit_mnt_fail(unit_t *unit)
+{
+        assert(CAST_MNT(unit));
+        assert(unit->state == STATE_STARTING);
+
+        unit->state = STATE_FAILED;
+        unit_notify_state(unit);
+}
+
 
 DEFINE_UNIT_VMT(unit_mnt)