process.h

Go to the documentation of this file.

#pragma once
 
#include <kernel/file.h>
#include <kernel/types.h>
#include <kernel/user.h>
#include <kernel/vmm.h>
#include <kernel/signal.h>
 
#include <libalgo/linked_list.h>
#include <utils/compiler.h>
 
#include <string.h>
 
#if ARCH == i686
#include <kernel/arch/i686/process.h>
#else
#error Unsupported arcihtecture
#endif
 
#define PROCESS_NAME_MAX_LEN 32U
 
#define PROCESS_FD_COUNT 32
 
struct address_space;
 
typedef void (*thread_entry_t)(void *data);
 
typedef enum thread_state {
    SCHED_RUNNING, 
    SCHED_WAITING, 
    SCHED_ZOMBIE,  
    SCHED_KILLED,  
} thread_state_t;
 
struct process {
    char name[PROCESS_NAME_MAX_LEN]; 
    pid_t pid;                       
    unsigned int flags;
 
    struct address_space *as; 
    struct process *parent;
    llist_t threads;        
    llist_t children;       
    node_t  this;           
    node_t  this_global;    
    size_t refcount; 
    struct file *files[PROCESS_FD_COUNT];
    spinlock_t files_lock; 
    /*
     * Signal handling.
     */
    struct signal_set  *sig_set;     /* Registered signal handlers. */
    struct signal_queue sig_pending;
    sig_sa_sigaction_t  sig_handler; /* stub handler set by sigsethandler(). */
 
    thread_state_t state;
    uint16_t exit_status; 
    struct user_creds *creds; 
    spinlock_t lock;
};
 
/*
 * Possible values for (struct process)->flags.
 */
enum process_flags {
    PROC_SA_NOCLDWAIT = BIT(0), /* Do not generate SIGCHLD when children stop */
};
 
/* Union of all the flags that should be inherited when forking. */
#define PROC_FLAGS_INHERITED (PROC_SA_NOCLDWAIT)
 
typedef struct thread {
 
    thread_context_t context;
    thread_state_t state; 
    pid_t tid; 
    u32 flags; 
    struct process *process; 
    node_t this_proc;   
    node_t this_sched;  
    node_t this_global; 
    union {
        struct {
            clock_t wakeup; 
        } sleep;
    };
 
    /*
     * Signal handling.
     */
    struct signal_queue sig_pending;
    sigset_t            sig_blocked; /* mask of currently blocked signals. */
 
} thread_t;
 
/*
 * List of all processes and threads currently alive.
 *
 * These list only contain live threads/processes so that lookups
 * do not return objects that have already been killed.
 */
extern llist_t processes_list;
extern spinlock_t processes_list_lock;
extern llist_t threads_list;
extern spinlock_t threads_list_lock;
 
typedef enum thread_flags {
    THREAD_KERNEL           = BIT(0), 
    THREAD_RESCHED          = BIT(1), 
} process_flags_t;
 
/***/
static ALWAYS_INLINE bool thread_is_kernel(thread_t *thread)
{
    return thread->flags & THREAD_KERNEL;
}
 
static ALWAYS_INLINE bool thread_is_initial(thread_t *thread)
{
    return thread->tid == thread->process->pid;
}
 
static inline void thread_set_stack_pointer(struct thread *thread, void *stack)
{
    arch_thread_set_stack_pointer(&thread->context, stack);
}
 
static inline void *thread_get_stack_pointer(struct thread *thread)
{
    return arch_thread_get_stack_pointer(&thread->context);
}
 
static inline void thread_set_base_pointer(struct thread *thread, void *ptr)
{
    arch_thread_set_base_pointer(&thread->context, ptr);
}
 
static inline void *thread_get_base_pointer(struct thread *thread)
{
    return arch_thread_get_base_pointer(&thread->context);
}
 
static inline void
thread_set_interrupt_frame(thread_t *thread,
                           const struct interrupt_frame *frame)
{
    arch_thread_set_interrupt_frame(&thread->context, frame);
}
 
static inline struct interrupt_frame *
thread_get_interrupt_frame(struct thread *thread)
{
    return arch_thread_get_interrupt_frame(&thread->context);
}
 
static inline void thread_set_kernel_stack(struct thread *thread, void *stack)
{
    arch_thread_set_kernel_stack_top(&thread->context,
                                     stack + KERNEL_STACK_SIZE);
}
 
static inline void *thread_get_kernel_stack_top(const struct thread *thread)
{
    return arch_thread_get_kernel_stack_top(&thread->context);
}
 
static inline void *thread_get_kernel_stack(const struct thread *thread)
{
    void *top = thread_get_kernel_stack_top(thread);
    if (!top)
        return NULL;
 
    return top - KERNEL_STACK_SIZE;
}
 
static inline void thread_set_user_stack(struct thread *thread, void *stack)
{
    arch_thread_set_user_stack_top(&thread->context, stack + USER_STACK_SIZE);
}
 
static inline void *thread_get_user_stack_top(const struct thread *thread)
{
    return arch_thread_get_user_stack_top(&thread->context);
}
 
static inline void *thread_get_user_stack(const struct thread *thread)
{
    void *top = thread_get_user_stack_top(thread);
    if (!top)
        return NULL;
 
    return top - USER_STACK_SIZE;
}
 
static inline void *
thread_get_interrupt_return_address(const struct thread *thread)
{
    return arch_thread_get_interrupt_return_address(&thread->context);
}
 
extern struct process kernel_process;
extern struct thread kernel_process_initial_thread;
 
extern struct process *init_process;
 
void process_init_kernel_process(void);
 
void process_kill(struct process *process, uint16_t status);
 
int process_register_file(struct process *, struct file *);
 
error_t process_unregister_file(struct process *, int fd);
 
struct file *process_file_get(struct process *, int fd);
 
static inline void process_file_put(struct process *process, struct file *file)
{
    UNUSED(process);
    file_put(file);
}
 
struct thread *process_execute_in_userland(const char *exec_path);
 
/***/
static inline void process_set_name(struct process *process, const char *name,
                                    size_t size)
{
    strlcpy(process->name, name, MIN(size + 1, PROCESS_NAME_MAX_LEN));
}
 
struct process *process_find_by_pid(pid_t pid);
 
extern thread_t *current;
 
bool thread_switch(thread_t *);
 
thread_t *thread_spawn(struct process *, thread_entry_t, void *data,
                       void *esp, void *ebp, u32 flags);
 
NO_RETURN void thread_jump_to_userland(void *stack_pointer, void *base_pointer,
                                       thread_entry_t, void *);
 
void thread_set_mmu(struct thread *thread, paddr_t mmu);
 
void thread_kill(thread_t *);
 
struct thread *thread_fork(struct thread *, thread_entry_t, void *);
 
void thread_deliver_pending_signal(struct thread *thread);
 
struct thread *thread_find_by_tid(pid_t tid);