Changeset b55f62a in mainline

Timestamp:

2019-08-07T09:29:33Z (5 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

Files:

• Makefile (modified) (1 diff)
• app/sysctl/Makefile (added)
• app/sysctl/main.c (added)
• lib/c/include/ipc/sysman.h (modified) (2 diffs)
• lib/sysman/include/sysman/ctl.h (modified) (1 diff)
• lib/sysman/src/ctl.c (modified) (2 diffs)
• srv/sysman/configuration.c (modified) (5 diffs)
• srv/sysman/configuration.h (modified) (2 diffs)
• srv/sysman/connection_ctl.c (modified) (5 diffs)
• srv/sysman/sm_task.c (modified) (1 diff)
• srv/sysman/unit.h (modified) (3 diffs)

uspace/Makefile

@@ -72 +72 @@
         app/sportdmp \
         app/stats \
+        app/sysctl \
         app/taskdump \
         app/tester \

uspace/lib/c/include/ipc/sysman.h

@@ -44 +44 @@
         SYSMAN_BROKER_EXP_ADDED,
         SYSMAN_BROKER_EXP_REMOVED,
-        SYSMAN_CTL_UNIT_START
+        SYSMAN_CTL_UNIT_START,
+        SYSMAN_CTL_GET_UNITS,
+        SYSMAN_CTL_UNIT_GET_NAME,
+        SYSMAN_CTL_UNIT_GET_STATE
 } sysman_ipc_method_t;
 
@@ -53 +56 @@
 } sysman_interface_t;
 
+typedef sysarg_t unit_handle_t;
+
+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;
+
 #endif
 

uspace/lib/sysman/include/sysman/ctl.h

@@ -30 +30 @@
 #define _SYSMAN_CTL_H
 
+#include <ipc/sysman.h>
 #include <sysman/unit.h>
 
 int sysman_unit_start(const char *, int);
 
+int sysman_get_units(unit_handle_t **, size_t *);
+
+int sysman_unit_get_name(unit_handle_t, char *, size_t);
+int sysman_unit_get_state(unit_handle_t, unit_state_t *);
 #endif

uspace/lib/sysman/src/ctl.c

@@ -29 +29 @@
 #include <async.h>
 #include <errno.h>
+#include <stdlib.h>
 #include <str.h>
 #include <sysman/ctl.h>
@@ -57 +58 @@
         return rc;
 }
+
+static int sysman_get_units_once(sysarg_t *buf, size_t buf_size,
+    size_t *act_size)
+{
+        async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL);
+
+        ipc_call_t answer;
+        aid_t req = async_send_0(exch, SYSMAN_CTL_GET_UNITS, &answer);
+        int rc = async_data_read_start(exch, buf, buf_size);
+
+        sysman_exchange_end(exch);
+
+        if (rc != EOK) {
+                async_forget(req);
+                return rc;
+        }
+
+        sysarg_t retval;
+        async_wait_for(req, &retval);
+
+        if (retval != EOK) {
+                return retval;
+        }
+
+        *act_size = IPC_GET_ARG1(answer);
+        return EOK;
+}
+
+int sysman_get_units(unit_handle_t **units_ptr, size_t *cnt_ptr)
+{
+        *units_ptr = NULL;
+        *cnt_ptr = 0;
+
+        unit_handle_t *units = NULL;
+        size_t alloc_size = 0;
+        size_t act_size = 0;
+
+        while (true) {
+                int rc = sysman_get_units_once(units, alloc_size, &act_size);
+                if (rc != EOK) {
+                        return rc;
+                }
+
+                if (act_size <= alloc_size) {
+                        break;
+                }
+
+                alloc_size = act_size;
+                units = realloc(units, alloc_size);
+                if (units == NULL) {
+                        return ENOMEM;
+                }
+        }
+
+        *units_ptr = units;
+        *cnt_ptr = act_size / sizeof(unit_handle_t);
+        return EOK;
+}
+
+int sysman_unit_get_name(unit_handle_t handle, char *buf, size_t buf_size)
+{
+        async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL);
+
+        ipc_call_t answer;
+        aid_t req = async_send_1(exch, SYSMAN_CTL_UNIT_GET_NAME, handle, &answer);
+        int rc = async_data_read_start(exch, buf, buf_size);
+
+        sysman_exchange_end(exch);
+
+        if (rc != EOK) {
+                async_forget(req);
+                return rc;
+        }
+
+        sysarg_t retval;
+        async_wait_for(req, &retval);
+
+        if (retval != EOK) {
+                return retval;
+        }
+
+        return EOK;
+}
+
+int sysman_unit_get_state(unit_handle_t handle, unit_state_t *state)
+{
+        async_exch_t *exch = sysman_exchange_begin(SYSMAN_PORT_CTL);
+        int rc = async_req_1_1(exch, SYSMAN_CTL_UNIT_GET_STATE, handle, state);
+        sysman_exchange_end(exch);
+
+        return rc;
+}

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;