Synchronization (#84)

In the current situation, only one thread runs at a time since only one
CPU is enabled. Furthermore, threading is fully cooperative since
interrupts are always disabled, so threads can never be preempted.

This PR starts laying the foundations for multiprocessing by creating
the necessary synchronization primitives (spinlock, atomic
increment/decrement, "block thread and unlock", etc.) and by ensuring
they are used where needed.

doc/syscalls/destroy.md

@@ -2,7 +2,7 @@
 
 ## Description
 
-Close a descriptor and destroy the kernel object to which it refers.
+Destroy the kernel object to which a descriptor refers.
 
 In order to use this function, the owner descriptor for the resource must be
 specified. The owner descriptor is the descriptor that was specified in the

include/jinue/shared/types.h

@@ -107,10 +107,10 @@ typedef struct {
 } jinue_mclone_args_t;
 
 typedef struct {
-    int process;
-    int fd;
-    int perms;
-    uintptr_t cookie;
+    int         process;
+    int         fd;
+    int         perms;
+    uintptr_t   cookie;
 } jinue_mint_args_t;
 
 #endif

include/kernel/application/syscalls.h

@@ -56,7 +56,7 @@ int get_user_memory(const jinue_buffer_t *buffer);
 
 int mclone(int src, int dest, const jinue_mclone_args_t *args);
 
-int mint(int owner, const jinue_mint_args_t *mint_args);
+int mint(int owner, const jinue_mint_args_t *args);
 
 int mmap(int process_fd, const jinue_mmap_args_t *args);
 

include/kernel/domain/entities/descriptor.h

@@ -38,39 +38,69 @@
 /* These flags are numbered downward starting at 31 to not conflict with PERM_... flags
  * which share the same flags field. */
 
-#define DESCRIPTOR_FLAG_NONE        0
+#define DESC_FLAG_NONE          0
 
-#define DESCRIPTOR_FLAG_IN_USE      (1<<31)
+#define DESC_FLAG_STATE1        (1<<31)
 
-#define DESCRIPTOR_FLAG_DESTROYED   (1<<30)
+#define DESC_FLAG_STATE0        (1<<30)
 
-#define DESCRIPTOR_FLAG_OWNER       (1<<29)
+#define DESC_FLAG_OWNER         (1<<29)
 
-static inline bool descriptor_is_in_use(descriptor_t *desc) {
-    return desc != NULL && (desc->flags & DESCRIPTOR_FLAG_IN_USE);
+#define DESC_FLAG_STATE         (DESC_FLAG_STATE1 | DESC_FLAG_STATE0)
+
+#define DESC_STATE_FREE         0
+
+#define DESC_STATE_RESERVED     DESC_FLAG_STATE0
+
+#define DESC_STATE_OPEN         DESC_FLAG_STATE1
+
+#define DESC_STATE_DESTROYED    (DESC_FLAG_STATE1 | DESC_FLAG_STATE0)
+
+
+static inline bool descriptor_is_free(const descriptor_t *desc) {
+    return (desc->flags & DESC_FLAG_STATE) == DESC_STATE_FREE;
+}
+
+static inline bool descriptor_is_reserved(const descriptor_t *desc) {
+    return (desc->flags & DESC_FLAG_STATE) == DESC_STATE_RESERVED;
+}
+
+static inline bool descriptor_is_open(const descriptor_t *desc) {
+    return (desc->flags & DESC_FLAG_STATE) == DESC_STATE_OPEN;
+}
+
+static inline bool descriptor_is_destroyed(const descriptor_t *desc) {
+    return (desc->flags & DESC_FLAG_STATE) == DESC_STATE_DESTROYED;
 }
 
-static inline bool descriptor_is_destroyed(descriptor_t *desc) {
-    return !!(desc->flags & DESCRIPTOR_FLAG_DESTROYED);
+static inline bool descriptor_is_closeable(const descriptor_t *desc) {
+    return descriptor_is_open(desc) || descriptor_is_destroyed(desc);
 }
 
-static inline bool descriptor_is_owner(descriptor_t *desc) {
-    return !!(desc->flags & DESCRIPTOR_FLAG_OWNER);
+static inline bool descriptor_is_owner(const descriptor_t *desc) {
+    return !!(desc->flags & DESC_FLAG_OWNER);
 }
 
 static inline bool descriptor_has_permissions(const descriptor_t *desc, int perms) {
     return (desc->flags & perms) == perms;
 }
 
+void clear_descriptor(descriptor_t *desc);
+
 int dereference_object_descriptor(
-        descriptor_t    **pdesc,
-        process_t        *process,
-        int               fd);
-
-int dereference_unused_descriptor(
-        descriptor_t    **pdesc,
-        process_t        *process,
-        int               fd);
+        descriptor_t    *pout,
+        process_t       *process,
+        int              fd);
+
+void unreference_descriptor_object(descriptor_t *desc);
+
+int reserve_free_descriptor(process_t *process, int fd);
+
+void free_reserved_descriptor(process_t *process, int fd);
+
+void open_descriptor(process_t *process, int fd, const descriptor_t *in);
+
+int close_descriptor(process_t *process, int fd);
 
 ipc_endpoint_t *get_endpoint_from_descriptor(descriptor_t *desc);
 

include/kernel/domain/entities/endpoint.h

@@ -36,6 +36,10 @@
 
 extern const object_type_t *object_type_ipc_endpoint;
 
+static inline object_header_t *endpoint_object(ipc_endpoint_t *endpoint) {
+    return &endpoint->header;
+}
+
 void initialize_endpoint_cache(void);
 
 ipc_endpoint_t *construct_endpoint(void);

include/kernel/domain/entities/object.h

@@ -40,11 +40,6 @@
 
 #define OBJECT_FLAG_DESTROYED       (1<<0)
 
-
-static inline void mark_object_destroyed(object_header_t *object) {
-    object->flags |= OBJECT_FLAG_DESTROYED;
-}
-
 static inline bool object_is_destroyed(object_header_t *object) {
     return !!(object->flags & OBJECT_FLAG_DESTROYED);
 }
@@ -55,10 +50,6 @@ static inline void init_object_header(object_header_t *object, const object_type
     object->flags       = OBJECT_FLAG_NONE;
 }
 
-static inline void add_ref_to_object(object_header_t *object) {
-    ++object->ref_count;
-}
-
 void init_object_cache(slab_cache_t *cache, const object_type_t *type);
 
 void open_object(object_header_t *object, const descriptor_t *desc);
@@ -67,6 +58,8 @@ void close_object(object_header_t *object, const descriptor_t *desc);
 
 void destroy_object(object_header_t *object);
 
+void add_ref_to_object(object_header_t *object);
+
 void sub_ref_to_object(object_header_t *object);
 
 #endif

include/kernel/domain/entities/process.h

@@ -36,6 +36,10 @@
 
 extern const object_type_t *object_type_process;
 
+static inline object_header_t *process_object(process_t *process) {
+    return &process->header;
+}
+
 void initialize_process_cache(void);
 
 process_t *construct_process(void);

include/kernel/domain/entities/thread.h

@@ -36,23 +36,29 @@
 
 extern const object_type_t *object_type_thread;
 
+static inline object_header_t *thread_object(thread_t *thread) {
+    return &thread->header;
+}
+
 thread_t *construct_thread(process_t *process);
 
 void prepare_thread(thread_t *thread, const thread_params_t *params);
-       
+
 void ready_thread(thread_t *thread);
 
-void switch_to_thread(thread_t *thread, bool blocked);
+void run_first_thread(thread_t *thread);
 
-void start_first_thread(thread_t *thread);
+void run_thread(thread_t *thread);
 
-void yield_current_thread(void);
+void terminate_current_thread(void);
 
-void block_current_thread(void);
+void switch_to(thread_t *to);
 
-void thread_is_starting(thread_t *thread);
+void switch_to_and_block(thread_t *to);
 
-void current_thread_is_exiting(void);
+void block_and_unlock(spinlock_t *lock);
+
+void yield_current_thread(void);
 
 void set_thread_local_storage(thread_t *thread, addr_t addr, size_t size);
 

include/kernel/infrastructure/i686/asm/eflags.h

@@ -32,6 +32,8 @@
 #ifndef JINUE_KERNEL_INFRASTRUCTURE_I686_ASM_EFLAGS_H
 #define JINUE_KERNEL_INFRASTRUCTURE_I686_ASM_EFLAGS_H
 
-#define CPU_EFLAGS_ID (1<<21)
+#define EFLAGS_ALWAYS_1 (1<<1)
+
+#define EFLAGS_ID       (1<<21)
 
 #endif

include/kernel/infrastructure/i686/exports.h

@@ -94,4 +94,6 @@ typedef struct {
     bool                 vga_enable;
 } machine_config_t;
 
+typedef struct { uint32_t lock; } spinlock_t;
+
 #endif

include/kernel/infrastructure/i686/percpu.h

@@ -43,7 +43,7 @@ static inline percpu_t *get_percpu_data(void) {
     return (percpu_t *)get_gs_ptr( (uint32_t *)&zero->self );
 }
 
-static inline tss_t *get_tss(void) {
+static inline tss_t *get_percpu_tss(void) {
     return &get_percpu_data()->tss;
 }
 

include/kernel/infrastructure/i686/pmap/private.h

@@ -74,7 +74,6 @@ void destroy_page_directory(void *page_directory, unsigned int last_index);
  *
  * @param pte page table or page directory entry
  * @return true if page is present in memory, false otherwise
- *
  */
 static inline bool pte_is_present(const pte_t *pte) {
     /* Micro-optimization: both flags we are interested in are in the lower four

include/kernel/infrastructure/i686/thread.h

@@ -35,9 +35,6 @@
 #include <kernel/machine/types.h>
 #include <stdbool.h>
 
-void switch_thread_stack(
-        machine_thread_t    *from_ctx,
-        machine_thread_t    *to_ctx,
-        bool                 destroy_from);
+void switch_thread_stack(machine_thread_t *from, machine_thread_t *to);
 
 #endif

include/kernel/infrastructure/i686/types.h

@@ -122,12 +122,4 @@ struct percpu_t {
 
 typedef struct percpu_t percpu_t;
 
-typedef struct {
-    uint32_t    edi;
-    uint32_t    esi;
-    uint32_t    ebx;
-    uint32_t    ebp;
-    uint32_t    eip;
-} kernel_context_t;
-
 #endif

include/kernel/machine/atomic.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2024 Philippe Aubertin.
+ * All rights reserved.
+
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * 3. Neither the name of the author nor the names of other contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef JINUE_KERNEL_MACHINE_ATOMIC_H
+#define JINUE_KERNEL_MACHINE_ATOMIC_H
+
+int add_atomic(int *value, int increment);
+
+int or_atomic(int *value, int mask);
+
+#endif

include/kernel/machine/pmap.h

@@ -55,6 +55,4 @@ bool machine_clone_userspace_mapping(
 
 kern_paddr_t machine_lookup_kernel_paddr(void *addr);
 
-void machine_switch_to_kernel_addr_space(void);
-
 #endif

include/kernel/machine/spinlock.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2024 Philippe Aubertin.
+ * All rights reserved.
+
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 
+ * 3. Neither the name of the author nor the names of other contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef JINUE_KERNEL_MACHINE_SPINLOCK_H
+#define JINUE_KERNEL_MACHINE_SPINLOCK_H
+
+#include <kernel/machine/types.h>
+
+#define SPINLOCK_STATIC { .lock = 0 }
+
+void init_spinlock(spinlock_t *lock);
+
+void spin_lock(spinlock_t *lock);
+
+void spin_unlock(spinlock_t *lock);
+
+#endif
+

include/kernel/machine/thread.h

@@ -42,6 +42,10 @@ thread_t *machine_alloc_thread(void);
 
 void machine_free_thread(thread_t *thread);
 
-void machine_switch_thread(thread_t *from, thread_t *to, bool destroy_from);
+void machine_switch_thread(thread_t *from, thread_t *to);
+
+void machine_switch_and_unref_thread(thread_t *from, thread_t *to);
+
+void machine_switch_thread_and_unlock(thread_t *from, thread_t *to, spinlock_t *lock);
 
 #endif

include/kernel/machine/tls.h

@@ -34,6 +34,6 @@
 
 #include <kernel/types.h>
 
-void machine_set_tls(const thread_t *thread);
+void machine_set_thread_local_storage(const thread_t *thread);
 
 #endif