Changeset b55f62a in mainline for uspace/srv

Timestamp:

2019-08-07T09:29:33Z (7 years ago)

Author:

Matthieu Riolo <matthieu.riolo@…>

Children:

918ac9b

Parents:

2df7d824

git-author:

Michal Koutný <xm.koutny+hos@…> (2015-11-02 00:50:02)

git-committer:

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

Message:

sysman: Create control utility sysctl

• can list units and their states (starts to feel like systemctl
• helluva boilerplate to get some IPC between sysctl and sysman :-/

Conflicts:

boot/Makefile.common
uspace/Makefile

Location:

uspace/srv/sysman

Files:

• configuration.c (modified) (5 diffs)
• configuration.h (modified) (2 diffs)
• connection_ctl.c (modified) (5 diffs)
• sm_task.c (modified) (1 diff)
• unit.h (modified) (3 diffs)

uspace/srv/sysman/configuration.c

@@ -43 +43 @@
 
 static hash_table_t units_by_name;
+static hash_table_t units_by_handle;
 
 /* Hash table functions */
+static size_t units_by_handle_ht_hash(const ht_link_t *item)
+{
+        unit_t *unit =
+            hash_table_get_inst(item, unit_t, units_by_handle);
+        return unit->handle;
+}
+
+static size_t units_by_handle_ht_key_hash(void *key)
+{
+        return *(unit_handle_t *)key;
+}
+
+static bool units_by_handle_ht_equal(const ht_link_t *item1, const ht_link_t *item2)
+{
+        return
+            hash_table_get_inst(item1, unit_t, units_by_handle) ==
+            hash_table_get_inst(item2, unit_t, units_by_handle);
+}
+
+static bool units_by_handle_ht_key_equal(void *key, const ht_link_t *item)
+{
+        return *(unit_handle_t *)key ==
+            hash_table_get_inst(item, unit_t, units_by_handle)->handle;
+}
+
+static hash_table_ops_t units_by_handle_ht_ops = {
+        .hash            = &units_by_handle_ht_hash,
+        .key_hash        = &units_by_handle_ht_key_hash,
+        .equal           = &units_by_handle_ht_equal,
+        .key_equal       = &units_by_handle_ht_key_equal,
+        .remove_callback = NULL // TODO realy unneeded?
+};
+
 static size_t units_by_name_ht_hash(const ht_link_t *item)
 {
@@ -59 +93 @@
 static bool units_by_name_ht_equal(const ht_link_t *item1, const ht_link_t *item2)
 {
-        return str_cmp(
-            hash_table_get_inst(item1, unit_t, units_by_name)->name,
-            hash_table_get_inst(item2, unit_t, units_by_name)->name) == 0;
+        return
+            hash_table_get_inst(item1, unit_t, units_by_handle) ==
+            hash_table_get_inst(item2, unit_t, units_by_handle);
 }
 
@@ -84 +118 @@
 {
         hash_table_create(&units_by_name, 0, 0, &units_by_name_ht_ops);
+        hash_table_create(&units_by_handle, 0, 0, &units_by_handle_ht_ops);
 }
 
@@ -90 +125 @@
         assert(unit);
         assert(unit->state == STATE_EMBRYO);
+        assert(unit->handle == 0);
         assert(unit->name != NULL);
         sysman_log(LVL_DEBUG2, "%s('%s')", __func__, unit_name(unit));
 
         if (hash_table_insert_unique(&units_by_name, &unit->units_by_name)) {
+                /* Pointers are same size as unit_handle_t both on 32b and 64b */
+                unit->handle = (unit_handle_t)unit;
+
+                hash_table_insert(&units_by_handle, &unit->units_by_handle);
                 list_append(&unit->units, &units);
                 return EOK;
@@ -218 +258 @@
 }
 
+unit_t *configuration_find_unit_by_handle(unit_handle_t handle)
+{
+        ht_link_t *ht_link = hash_table_find(&units_by_handle, &handle);
+        if (ht_link != NULL) {
+                return hash_table_get_inst(ht_link, unit_t, units_by_handle);
+        } else {
+                return NULL;
+        }
+}
+

uspace/srv/sysman/configuration.h

@@ -31 +31 @@
 
 #include <adt/list.h>
+#include <ipc/sysman.h>
 
 #include "unit.h"
@@ -49 +50 @@
 
 extern unit_t *configuration_find_unit_by_name(const char *);
+extern unit_t *configuration_find_unit_by_handle(unit_handle_t);
 
 

uspace/srv/sysman/connection_ctl.c

@@ -29 +29 @@
 #include <errno.h>
 #include <ipc/sysman.h>
+#include <macros.h>
 #include <stdlib.h>
+#include <str.h>
 
 #include "configuration.h"
@@ -61 +63 @@
         job_del_ref(&job);
 }
-
 static void sysman_unit_start(ipc_callid_t iid, ipc_call_t *icall)
 {
@@ -77 +78 @@
         sysman_log(LVL_DEBUG2, "%s(%s, %x)", __func__, unit_name, flags);
 
+        // TODO this is connection fibril, UNSYNCHRONIZED access to units!
         unit_t *unit = configuration_find_unit_by_name(unit_name);
         if (unit == NULL) {
@@ -109 +111 @@
 }
 
+static int fill_handles_buffer(unit_handle_t *buffer, size_t size,
+    size_t *act_size)
+{
+        if (size % sizeof(unit_handle_t) != 0) {
+                return EINVAL;
+        }
+
+        size_t filled = 0;
+        size_t to_fill = size / sizeof(unit_handle_t);
+        size_t total = 0;
+        list_foreach(units, units, unit_t, u) {
+                if (filled < to_fill) {
+                        buffer[filled++] = u->handle;
+                }
+                ++total;
+        }
+        *act_size = total * sizeof(unit_handle_t);
+        return EOK;
+}
+
+static void sysman_get_units(ipc_callid_t iid, ipc_call_t *icall)
+{
+        ipc_callid_t callid;
+        size_t size;
+        size_t act_size;
+        int rc;
+        
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        
+        unit_handle_t *handles = malloc(size);
+        if (handles == NULL && size > 0) {
+                async_answer_0(callid, ENOMEM);
+                async_answer_0(iid, ENOMEM);
+                return;
+        }
+        
+        
+        // TODO UNSYNCHRONIZED access to units!
+        rc = fill_handles_buffer(handles, size, &act_size);
+        if (rc != EOK) {
+                async_answer_0(callid, rc);
+                async_answer_0(iid, rc);
+                return;
+        }
+        
+        size_t real_size = min(act_size, size);
+        sysarg_t retval = async_data_read_finalize(callid, handles, real_size);
+        free(handles);
+        
+        async_answer_1(iid, retval, act_size);
+}
+
+static void sysman_unit_get_name(ipc_callid_t iid, ipc_call_t *icall)
+{
+        ipc_callid_t callid;
+        size_t size;
+        
+        if (!async_data_read_receive(&callid, &size)) {
+                async_answer_0(callid, EREFUSED);
+                async_answer_0(iid, EREFUSED);
+                return;
+        }
+        
+        // TODO UNSYNCHRONIZED access to units!
+        unit_t *u = configuration_find_unit_by_handle(IPC_GET_ARG1(*icall));
+        if (u == NULL) {
+                async_answer_0(callid, ENOENT);
+                async_answer_0(iid, ENOENT);
+                return;
+        }
+        
+        size_t real_size = min(str_size(u->name) + 1, size);
+        sysarg_t retval = async_data_read_finalize(callid, u->name, real_size);
+        
+        async_answer_0(iid, retval);
+}
+
+static void sysman_unit_get_state(ipc_callid_t iid, ipc_call_t *icall)
+{
+        // TODO UNSYNCHRONIZED access to units!
+        unit_t *u = configuration_find_unit_by_handle(IPC_GET_ARG1(*icall));
+        if (u == NULL) {
+                async_answer_0(iid, ENOENT);
+        } else {
+                async_answer_1(iid, EOK, u->state);
+        }
+}
+
 void sysman_connection_ctl(ipc_callid_t iid, ipc_call_t *icall)
 {
@@ -128 +223 @@
                         sysman_unit_start(callid, &call);
                         break;
+                case SYSMAN_CTL_GET_UNITS:
+                        sysman_get_units(callid, &call);
+                        break;
+                case SYSMAN_CTL_UNIT_GET_NAME:
+                        sysman_unit_get_name(callid, &call);
+                        break;
+                case SYSMAN_CTL_UNIT_GET_STATE:
+                        sysman_unit_get_state(callid, &call);
+                        break;
                 default:
                         async_answer_0(callid, ENOENT);

uspace/srv/sysman/sm_task.c

@@ -89 +89 @@
         sm_task_event_t *tev = data;
 
+        sysman_log(LVL_DEBUG2, "%s, %" PRIu64 " %i",
+            __func__, tev->task_id, tev->flags);
         unit_svc_t *u_svc = sm_task_find_service(tev->task_id);
         if (u_svc == NULL) {

uspace/srv/sysman/unit.h

@@ -39 +39 @@
 #include <conf/text_parse.h>
 #include <fibril_synch.h>
-
-typedef enum {
-        UNIT_TYPE_INVALID = -1,
-        UNIT_CONFIGURATION = 0,
-        UNIT_MOUNT,
-        UNIT_SERVICE,
-        UNIT_TARGET
-} unit_type_t;
-
-typedef enum {
-        STATE_EMBRYO = 0,
-        STATE_STARTING,
-        STATE_STARTED,
-        STATE_STOPPED,
-        STATE_FAILED
-} unit_state_t;
+#include <ipc/sysman.h>
 
 /* Forward declarations */
@@ -66 +51 @@
         /** Link to name-to-unit hash table */
         ht_link_t units_by_name;
+
+        /** Link to handle-to-unit hash table */
+        ht_link_t units_by_handle;
 
         /** Link to list of all units */
@@ -80 +68 @@
         job_t *job;
 
+        unit_handle_t handle;
         unit_type_t type;
         char *name;