Changeset b55f62a in mainline for uspace/srv/sysman/connection_ctl.c

Timestamp:

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

File:

• uspace/srv/sysman/connection_ctl.c (modified) (5 diffs)

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);