From 503f176e001ddf15e6e32bc912cf10b5764bc23b Mon Sep 17 00:00:00 2001 From: Alex Auvolat Date: Wed, 4 Mar 2015 11:51:30 +0100 Subject: Process exiting & thread termination. IMPORTANT NOTE FOLLOWS. Threads may now communicate via wait_on(void* ressource) and resume_on (void* ressource). Previous pause() is replaced by wait_on(current_thread) and resume(thread) by resume_on(thread). wait_on(x) may return false, indicating that the reason for returning is NOT that resume_on(x) was called but something else happenned. Typically false indicates that the curent thread is being killed and must terminate its kernel-land processing as soon as possible. --- src/kernel/include/process.h | 18 ++++++++++++------ src/kernel/include/thread.h | 11 ++++++++--- 2 files changed, 20 insertions(+), 9 deletions(-) (limited to 'src/kernel/include') diff --git a/src/kernel/include/process.h b/src/kernel/include/process.h index 1b4012f..def3397 100644 --- a/src/kernel/include/process.h +++ b/src/kernel/include/process.h @@ -56,23 +56,29 @@ typedef struct process { struct process *parent; struct process *next_child; struct process *children; + + mutex_t lock; } process_t; typedef void* proc_entry_t; // ---- Process creation, deletion, waiting, etc. -// Simple semantics : when a process exits, all its ressources are freed immediately -// except for the process_t that remains attached to the parent process until it does -// a wait() and acknowleges the process' ending -// When a process exits, all the children are orphaned and nobody can wait on them anymore, -// which is a bad thing : a user process must always wait for all its children ! +// Simple semantics : +// - When a process exits, all its ressources are freed immediately +// except for the process_t that remains attached to the parent process until it does +// a wait() and acknowleges the process' ending +// - When a process exits, if it has living children then they are terminated too. (a process +// is seen as a "virtual machine", and spawning sub-process is seen as "sharing some ressources +// it was allocated to create a new VM", therefore removing the ressource allocated to the +// parent implies removing the ressource from its children too) process_t *current_process(); process_t *new_process(process_t *parent); bool start_process(process_t *p, proc_entry_t entry); // maps a region for user stack -void process_exit(process_t *p, int status, int exit_code); // exit current process +void process_exit(process_t *p, int status, int exit_code); // exit specified process (must not be current process) +void current_process_exit(int status, int exit_code); bool process_new_thread(process_t *p, proc_entry_t entry, void* sp); void process_thread_deleted(thread_t *t); // called by threading code when a thread exits diff --git a/src/kernel/include/thread.h b/src/kernel/include/thread.h index 163045d..2d385ea 100644 --- a/src/kernel/include/thread.h +++ b/src/kernel/include/thread.h @@ -5,6 +5,7 @@ #include #include +#define T_STATE_LOADING 0 #define T_STATE_RUNNING 1 #define T_STATE_PAUSED 2 #define T_STATE_FINISHED 3 @@ -34,21 +35,25 @@ typedef struct thread { struct thread *next_in_queue; struct thread *next_in_proc; + + void* waiting_on; + bool must_exit; } thread_t; typedef void (*entry_t)(void*); void threading_setup(entry_t cont, void* data); // never returns -thread_t *new_thread(entry_t entry, void* data); // thread is PAUSED, and must be resume_thread'ed +thread_t *new_thread(entry_t entry, void* data); // thread is PAUSED, and must be started with start_thread +void start_thread(thread_t *t); extern thread_t *current_thread; void yield(); -void pause(); void exit(); void usleep(int usecs); +bool wait_on(void* x); // true : resumed normally, false : resumed because thread was killed, or someone else already waiting -bool resume_thread(thread_t *thread); +bool resume_on(void* x); void kill_thread(thread_t *thread); // cannot be called for current thread // Kernel critical sections -- cgit v1.2.3