SHM: adding sys_shm_get_infos() syscall (#41)

When sharing a shared memory with another, it would be highly easier to
be able to get back the SHM infos withtout requiring DTS forge with
ninja.

The global problematic is defined in #39, which is fixed by this PR.

This PR also fixes an invalid glue addition of DMA-related entries at
UAPI level versus gate LUT, which were not synchronize in term of
syscall identifiers, making autotest failing for the new SHM syscall.
Note: all new syscalls are append to avoid any ABI violation.

Closes #39

Author: pthierry-ledger

.github/workflows/gnulinux.yml

@@ -18,7 +18,7 @@ concurrency:
 
 jobs:
   forge_matrix:
-    runs-on: ${{ vars.DEFAULT_RUNNER_NAME }}
+    runs-on: ubuntu-latest
     container:
       image: python:3.9.14-alpine3.16
     steps:
@@ -58,7 +58,7 @@ jobs:
     defaults:
       run:
         shell: bash
-    runs-on: ${{ vars.DEFAULT_RUNNER_NAME }}
+    runs-on: ubuntu-latest
     container:
       image: ${{ matrix.operating_system }}
     steps:
@@ -130,7 +130,7 @@ jobs:
     defaults:
       run:
         shell: bash
-    runs-on: ${{ vars.DEFAULT_RUNNER_NAME }}
+    runs-on: ubuntu-latest
     container:
       image: 'mesonbuild/ubuntu-rolling'
     steps:
@@ -194,7 +194,7 @@ jobs:
     defaults:
       run:
         shell: bash
-    runs-on: ${{ vars.DEFAULT_RUNNER_NAME }}
+    runs-on: ubuntu-latest
     container:
       image: 'mesonbuild/ubuntu-rolling'
     steps:

.github/workflows/proof.yml

@@ -19,7 +19,7 @@ jobs:
     defaults:
       run:
         shell: bash
-    runs-on: ${{ vars.DEFAULT_RUNNER_NAME }}
+    runs-on: ubuntu-latest
     container: 'pthierry38/framac-runner:29'
     timeout-minutes: 60
     steps:

autotest/src/tests/test_shm.c

@@ -66,6 +66,26 @@ void test_shm_invalidmap(void) {
     TEST_END();
 }
 
+void test_shm_infos(void) {
+    Status res;
+    shmh_t shm;
+    shm_infos_t infos;
+    TEST_START();
+    res = sys_get_shm_handle(shms[0].id);
+    copy_to_user((uint8_t*)&shm, sizeof(shmh_t));
+    ASSERT_EQ(res, STATUS_OK);
+    res = sys_shm_get_infos(shm);
+    copy_to_user((uint8_t*)&infos, sizeof(shm_infos_t));
+
+    ASSERT_EQ(res, STATUS_OK);
+    ASSERT_EQ(infos.label, shms[0].id);
+    ASSERT_EQ(infos.handle, shm);
+    ASSERT_EQ((uint32_t)infos.base, (uint32_t)shms[0].baseaddr);
+    ASSERT_EQ((uint32_t)infos.len, (uint32_t)shms[0].size);
+
+    TEST_END();
+}
+
 void test_shm_creds_on_mapped(void) {
     Status res;
     shmh_t shm;
@@ -185,6 +205,7 @@ void test_shm(void) {
     test_shm_mapunmap();
     test_shm_map_unmappable();
     test_shm_creds_on_mapped();
+    test_shm_infos();
     test_shm_allows_idle();
     TEST_SUITE_END("sys_map_shm");
 }

doc/concepts/uapi/syscalls.rst

@@ -139,6 +139,11 @@ Syscall definition
   single: sys_shm_set_credential; usage
 .. include:: syscalls/shm_set_credential.rst
 
+.. index::
+  single: sys_shm_get_infos; definition
+  single: sys_shm_get_infos; usage
+.. include:: syscalls/shm_get_infos.rst
+
 .. index::
   single: sys_wait_for_event; definition
   single: sys_wait_for_event; usage

doc/concepts/uapi/syscalls/meson.build

@@ -22,6 +22,7 @@ syscalls_src = files(
   'shm_map.rst',
   'shm_unmap.rst',
   'shm_set_credential.rst',
+  'shm_get_infos.rst',
   'send_ipc.rst',
   'waitforevent.rst',
 )

doc/concepts/uapi/syscalls/shm_get_infos.rst

@@ -0,0 +1,81 @@
+sys_shm_get_infos
+"""""""""""""""""
+.. _uapi_shm_get_infos:
+
+**API definition**
+
+   .. code-block:: rust
+      :caption: Rust UAPI for shm_get_infos syscall
+
+      mod uapi {
+         fn shm_get_infos(shm: shm_t) -> Status
+      }
+
+   .. code-block:: c
+      :caption: C UAPI for shm_get_infos syscall
+
+      enum Status sys_shm_get_infos(shmh_t shm);
+
+**Usage**
+
+   In Sentry, as explained in :ref:`SHM model definition chapter <shm_principles>`, a shared memory
+   holds credential for its owner and user task. It also hold some memory-related shm_get_infos
+   such as base address and size.
+
+   These information set is useful to get back in user-space without requiring any DTS forge at application level.
+
+   These informations can be received through this syscall, by fulfilling the shm_infos_t structure
+   declared by the UAPI in the SVC Exchange area. The `shm_infos_t` is defined in the
+   UAPI `<types.h>` header in C or through the uapi.systypes Rust mod.
+
+   .. code-block:: C
+      :linenos:
+      :caption: shm_infos_t structure definition
+
+      /* SHM informations data structure */
+      typedef struct shm_infos {
+        shmh_t   handle;  /*< SHM handle */
+        uint32_t label;   /*< SHM label */
+        size_t   base;    /*< SHM base address */
+        size_t   len;     /*< SHM length in bytes */
+        uint32_t perms;   /*< SHM permissions (mask of SHMPermission) */
+      } shm_infos_t;
+
+
+
+   The only input required for this syscall is the SHM handle, as given by the
+   `sys_get_shmhandle()` syscall.
+
+   When a given SHM credentials set for the current job is updated, the `sys_shm_get_infos()`
+   returns an up-to-date content synchronously.
+
+   .. code-block:: C
+      :linenos:
+      :caption: sample bare usage of sys_shm_get_infos
+
+      uint32_t my_shm_label=0xf00UL;
+      taskh_t myself;
+      shm_infos_t infos;
+      if (sys_get_task_handle(myself_label) != STATUS_OK) {
+         // [...]
+      }
+      copy_to_user(&myself, sizeof(taskh_t));
+      if (sys_get_shm_handle(my_shm_label) != STATUS_OK) {
+         // [...]
+      }
+      copy_to_user(&my_shm_handle, sizeof(shmh_t));
+
+      if (sys_shm_get_infos(my_shm_handle)) {
+        // [...]
+      }
+      copy_to_user(&infos, sizeof(shm_infos_t));
+      printf("SHM base address is %lx\n", infos.base);
+
+**Required capability**
+
+   None.
+
+**Return values**
+
+   * STATUS_INVALID if the SHM do not exist, target do not exist or is not owned or used by the calling task
+   * STATUS_OK

kernel/include/sentry/managers/memory.h

@@ -111,6 +111,12 @@ kstatus_t mgr_mm_shm_is_shared(shmh_t shm, secure_bool_t * result);
 
 kstatus_t mgr_mm_shm_get_handle(uint32_t shm_id, shmh_t *handle);
 
+kstatus_t mgr_mm_shm_get_baseaddr(shmh_t shm, size_t *base);
+
+kstatus_t mgr_mm_shm_get_size(shmh_t shm, size_t *size);
+
+kstatus_t mgr_mm_shm_get_label(shmh_t shm, uint32_t *label);
+
 /* per user/owner properties requests */
 
 kstatus_t mgr_mm_shm_is_mapped_by(shmh_t shm, shm_user_t accessor, secure_bool_t * result);

kernel/include/sentry/syscalls.h

@@ -69,4 +69,6 @@ stack_frame_t *gate_log(stack_frame_t *frame, __MAYBE_UNUSED uint32_t log_len);
 
 stack_frame_t *gate_get_dmahandle(stack_frame_t *frame, uint32_t streamlabel);
 
+stack_frame_t *gate_shm_get_infos(stack_frame_t *frame, shmh_t shm);
+
 #endif/*!SYSCALLS_H*/

kernel/src/arch/asm-generic/handler-svc-lut.c

@@ -178,6 +178,16 @@ static stack_frame_t *lut_notsup(stack_frame_t *f) {
     return f;
 }
 
+static stack_frame_t *lut_shm_get_infos(stack_frame_t *frame) {
+    shmh_t shm = frame->r0;
+    return gate_shm_get_infos(frame, shm);
+}
+
+/* for not yet supported syscalls */
+static stack_frame_t *lut_unsuported(stack_frame_t *frame) {
+    mgr_task_set_sysreturn(sched_get_current(), STATUS_NO_ENTITY);
+    return frame;
+}
 
 static const lut_svc_handler svc_lut[] = {
     lut_exit,
@@ -210,6 +220,10 @@ static const lut_svc_handler svc_lut[] = {
     lut_int_disable,
     lut_get_shmhandle,
     lut_get_dmahandle,
+    lut_unsuported, /* DMA Start Stream */
+    lut_unsuported, /* DMA Stop Stream */
+    lut_unsuported, /* DMA Get Stream Status */
+    lut_shm_get_infos,
 };
 
 #define SYSCALL_NUM ARRAY_SIZE(svc_lut)

kernel/src/managers/memory/memory_shm.c

@@ -143,6 +143,111 @@ kstatus_t mgr_mm_shm_declare_user(shmh_t shm, taskh_t task)
     return status;
 }
 
+/**
+ * @fn get base address of the given SHM
+ *
+ * @param[in] shm: Shared memory handle that identify the SHM
+ * @param[out] base: base address of the SHM returned when found
+ */
+kstatus_t mgr_mm_shm_get_baseaddr(shmh_t shm, size_t *base)
+{
+    kstatus_t status = K_ERROR_INVPARAM;
+    kshmh_t const *kshm = shmh_to_kshmh(&shm);
+
+    /*@ assert \valid_read(kshm); */
+
+    if (unlikely(mgr_mm_configured() == SECURE_FALSE)) {
+        status = K_ERROR_BADSTATE;
+        goto end;
+    }
+    if (unlikely(base == NULL)) {
+        goto end;
+    }
+    /*@ assert \valid(base); */
+    /* check that id exsits */
+    if (unlikely(kshm->id >= SHM_LIST_SIZE)) {
+        goto end;
+    }
+    /* check that handle matches */
+    if (unlikely(shm_table[kshm->id].handle != shm)) {
+        goto end;
+    }
+    *base = shm_table[kshm->id].meta->baseaddr;
+    status = K_STATUS_OKAY;
+end:
+    return status;
+}
+
+/**
+ * @fn get size in bytes of the given SHM
+ *
+ * @param[in] shm: Shared memory handle that identify the SHM
+ * @param[out] size:  length in bytes of the SHM returned when found
+ */
+kstatus_t mgr_mm_shm_get_size(shmh_t shm, size_t *size)
+{
+    kstatus_t status = K_ERROR_INVPARAM;
+    kshmh_t const *kshm = shmh_to_kshmh(&shm);
+
+    /*@ assert \valid_read(kshm); */
+
+    if (unlikely(mgr_mm_configured() == SECURE_FALSE)) {
+        status = K_ERROR_BADSTATE;
+        goto end;
+    }
+    if (unlikely(size == NULL)) {
+        goto end;
+    }
+    /*@ assert \valid(size); */
+    /* check that id exsits */
+    if (unlikely(kshm->id >= SHM_LIST_SIZE)) {
+        goto end;
+    }
+    /* check that handle matches */
+    if (unlikely(shm_table[kshm->id].handle != shm)) {
+        goto end;
+    }
+    *size = shm_table[kshm->id].meta->size;
+    status = K_STATUS_OKAY;
+end:
+    return status;
+}
+
+/**
+ * @fn get label defined in DTS for the given SHM
+ *
+ * @param[in] shm: Shared memory handle that identify the SHM
+ * @param[out] label: identifier of the SHM as declared in the DTS, returned when found
+ */
+kstatus_t mgr_mm_shm_get_label(shmh_t shm, uint32_t *label)
+{
+    kstatus_t status = K_ERROR_INVPARAM;
+    kshmh_t const *kshm = shmh_to_kshmh(&shm);
+
+    /*@ assert \valid_read(kshm); */
+
+    if (unlikely(mgr_mm_configured() == SECURE_FALSE)) {
+        status = K_ERROR_BADSTATE;
+        goto end;
+    }
+    if (unlikely(label == NULL)) {
+        goto end;
+    }
+    /*@ assert \valid(label); */
+    /* check that id exsits */
+    if (unlikely(kshm->id >= SHM_LIST_SIZE)) {
+        goto end;
+    }
+    /* check that handle matches */
+    if (unlikely(shm_table[kshm->id].handle != shm)) {
+        goto end;
+    }
+    *label = shm_table[kshm->id].meta->shm_label;
+    status = K_STATUS_OKAY;
+end:
+    return status;
+}
+
 /**
  * @brief specify if the given SHM can be mapped by owner or user
  *