process.h

Go to the documentation of this file.

#pragma once
 
#include <kernel/file.h>
#include <kernel/interrupts.h>
#include <kernel/types.h>
#include <kernel/vmm.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_KILLED,  
} thread_state_t;
 
struct process {
    char name[PROCESS_NAME_MAX_LEN]; 
    pid_t pid;                       
    struct address_space *as; 
    llist_t threads; 
    size_t refcount; 
    struct file *files[PROCESS_FD_COUNT];
    spinlock_t files_lock; 
    thread_state_t state;
    int exit_status; 
    spinlock_t lock;
};
 
typedef struct thread {
 
    thread_context_t context;
    thread_state_t state; 
    struct process *process; 
    node_t proc_this; 
    struct interrupt_frame frame;
 
    pid_t tid; 
    u32 flags; 
    node_t this; 
    union {
        struct {
            clock_t preempt;
        } running;
        struct {
            clock_t wakeup; 
        } sleep;
    };
 
} thread_t;
 
typedef enum thread_flags {
    THREAD_KERNEL = BIT(0), 
} 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_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;
}
 
extern struct process kernel_process;
extern struct thread kernel_process_initial_thread;
 
extern struct process *init_process;
 
void process_init_kernel_process(void);
 
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));
}
 
extern thread_t *current;
 
bool thread_switch(thread_t *);
 
thread_t *thread_spawn(struct process *, thread_entry_t, void *, void *, u32);
 
NO_RETURN void thread_jump_to_userland(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 *);