Changeset 0116f21 in mainline

Timestamp:

2019-07-18T15:30:31Z (5 years ago)

Author:

Matthieu Riolo <matthieu.riolo@…>

Children:

bb580548

Parents:

40043e8

git-author:

Matthieu Riolo <matthieu.riolo@…> (2019-07-18 15:26:49)

git-committer:

Matthieu Riolo <matthieu.riolo@…> (2019-07-18 15:30:31)

Message:

Implementing systemcall for shotdown

This commit implements a systemcall for shutdown the system.
It provides the necessary systemcall which creates a new thread
for the kernel task. The thread will then call halt(), reboot()
or cancel the pending shutdown process. The systemcall takes
three parameters: a modus (cancel, halt, reboot), a delay and
a boolean for changing into the kernel console

Files:

• abi/include/abi/shutdown.h (added)
• abi/include/abi/syscall.h (modified) (1 diff)
• kernel/generic/include/proc/thread.h (modified) (1 diff)
• kernel/generic/include/shutdown.h (modified) (1 diff)
• kernel/generic/src/main/shutdown.c (modified) (3 diffs)
• kernel/generic/src/syscall/syscall.c (modified) (1 diff)

abi/include/abi/syscall.h

@@ -102 +102 @@
         SYS_DEBUG_CONSOLE,
 
+        SYS_SHUTDOWN,
+
         SYS_KLOG,
 

kernel/generic/include/proc/thread.h

@@ -49 +49 @@
 #include <abi/proc/thread.h>
 #include <abi/sysinfo.h>
-#include <arch.h>
 
 #define THREAD              CURRENT->thread

kernel/generic/include/shutdown.h

@@ -37 +37 @@
 
 #include <atomic.h>
+#include <typedefs.h>
+
+typedef struct thread thread_t;
 
 extern atomic_t haltstate;
+extern thread_t *shutdown_thread;
 
 extern void halt(void) __attribute__((noreturn));
 extern void reboot(void);
 extern void arch_reboot(void);
+extern sys_errno_t sys_shutdown(sysarg_t mode, sysarg_t delay, sysarg_t kconsole);
 
 #endif

kernel/generic/src/main/shutdown.c

@@ -37 +37 @@
  */
 
+#include <abi/shutdown.h>
 #include <shutdown.h>
 #include <log.h>
 #include <cpu.h>
-#include <arch/asm.h>
-#include <arch.h>
 #include <console/kconsole.h>
-#include <proc/task.h>
+#include <console/console.h>
+#include <proc/thread.h>
+#include <stdlib.h>
+
+/* pointer to the thread for the shutdown process */
+thread_t *shutdown_thread = NULL;
 
 /** Halt flag */
@@ -81 +85 @@
 }
 
+/* Reboots the kernel */
 void reboot(void)
 {
@@ -93 +98 @@
 }
 
+/* argument structure for the shutdown thread */
+typedef struct {
+        sysarg_t mode;
+        sysarg_t delay;
+} sys_shutdown_arg_t;
+
+/* function for the shutdown thread */
+static void sys_shutdown_function(void *arguments)
+{
+        sys_shutdown_arg_t *arg = (sys_shutdown_arg_t *)arguments;
+
+        if (arg->delay != 0) {
+                thread_sleep(arg->delay);
+        }
+
+        if (thread_interrupted(THREAD)) {
+                free(arguments);
+                return;
+        }
+
+        if (arg->mode == SHUTDOWN_REBOOT) {
+                reboot();
+        } else {
+                halt();
+        }
+}
+
+/* system call handler for shutdown */
+sys_errno_t sys_shutdown(sysarg_t mode, sysarg_t delay, sysarg_t kconsole)
+{
+
+#if (defined(CONFIG_DEBUG)) && (defined(CONFIG_KCONSOLE))
+        if (kconsole) {
+                grab_console();
+        }
+#endif
+
+        irq_spinlock_lock(&threads_lock, true);
+        thread_t *thread = atomic_load(&shutdown_thread);
+        if (thread != NULL) {
+                thread_interrupt(thread);
+                atomic_store(&shutdown_thread, NULL);
+        }
+        irq_spinlock_unlock(&threads_lock, true);
+
+        /* `cancel` or default has been called */
+        if (mode != SHUTDOWN_HALT && mode != SHUTDOWN_REBOOT) {
+                return EOK;
+        }
+
+        sys_shutdown_arg_t *arg = malloc(sizeof(sys_shutdown_arg_t));
+        if (arg == NULL) {
+                return ENOMEM;
+        }
+
+        //TODO: find a better way for accessing the kernel task
+        irq_spinlock_lock(&tasks_lock, true);
+        task_t *kernel_task = task_find_by_id(1);
+        irq_spinlock_unlock(&tasks_lock, true);
+
+        if (kernel_task == NULL) {
+                goto error;
+        }
+
+        arg->mode = mode;
+        arg->delay = delay;
+
+        thread = thread_create(sys_shutdown_function, arg, kernel_task, THREAD_FLAG_NONE, "shutdown");
+
+        if (thread == NULL) {
+                goto error;
+        }
+
+        thread_ready(thread);
+        atomic_store(&shutdown_thread, thread);
+        return EOK;
+
+error:
+        free(arg);
+        return ENOENT;
+}
+
 /** @}
  */

kernel/generic/src/syscall/syscall.c

@@ -192 +192 @@
         [SYS_SYSINFO_GET_DATA] = (syshandler_t) sys_sysinfo_get_data,
 
+        [SYS_SHUTDOWN] = (syshandler_t) sys_shutdown,
+
         /* Kernel console syscalls. */
         [SYS_DEBUG_CONSOLE] = (syshandler_t) sys_debug_console,