wait.h

Go to the documentation of this file.

#pragma once
 
#include <kernel/cpu/regs.h>
#include <kernel/sync/lock.h>
 
#include <errno.h>
#include <sys/list.h>
#include <sys/proc.h>
 
typedef struct thread thread_t;
typedef struct cpu cpu_t;
 
#define WAIT_ALL UINT64_MAX
 
#define WAIT_BLOCK(waitQueue, condition) \
    ({ \
        assert(rflags_read() & RFLAGS_INTERRUPT_ENABLE); \
        uint64_t result = 0; \
        while (!(condition) && result == 0) \
        { \
            wait_queue_t* temp = waitQueue; \
            if (wait_block_setup(&temp, 1, CLOCKS_NEVER) == ERR) \
            { \
                result = ERR; \
                break; \
            } \
            result = wait_block_commit(); \
        } \
        result; \
    })
 
#define WAIT_BLOCK_TIMEOUT(waitQueue, condition, timeout) \
    ({ \
        assert(rflags_read() & RFLAGS_INTERRUPT_ENABLE); \
        uint64_t result = 0; \
        clock_t uptime = timer_uptime(); \
        clock_t deadline = (timeout) == CLOCKS_NEVER ? CLOCKS_NEVER : (timeout) + uptime; \
        while (!(condition) && result == 0) \
        { \
            if (deadline <= uptime) \
            { \
                errno = ETIMEDOUT; \
                result = ERR; \
                break; \
            } \
            clock_t remaining = deadline == CLOCKS_NEVER ? CLOCKS_NEVER : (deadline > uptime ? deadline - uptime : 0); \
            wait_queue_t* temp = waitQueue; \
            if (wait_block_setup(&temp, 1, remaining) == ERR) \
            { \
                result = ERR; \
                break; \
            } \
            result = wait_block_commit(); \
            uptime = timer_uptime(); \
        } \
        result; \
    })
 
#define WAIT_BLOCK_LOCK(waitQueue, lock, condition) \
    ({ \
        assert(!(rflags_read() & RFLAGS_INTERRUPT_ENABLE)); \
        uint64_t result = 0; \
        while (!(condition) && result == 0) \
        { \
            wait_queue_t* temp = waitQueue; \
            if (wait_block_setup(&temp, 1, CLOCKS_NEVER) == ERR) \
            { \
                result = ERR; \
                break; \
            } \
            lock_release(lock); \
            result = wait_block_commit(); \
            assert(rflags_read() & RFLAGS_INTERRUPT_ENABLE); \
            lock_acquire(lock); \
        } \
        result; \
    })
 
#define WAIT_BLOCK_LOCK_TIMEOUT(waitQueue, lock, condition, timeout) \
    ({ \
        uint64_t result = 0; \
        clock_t uptime = timer_uptime(); \
        clock_t deadline = (timeout) == CLOCKS_NEVER ? CLOCKS_NEVER : (timeout) + uptime; \
        while (!(condition) && result == ERR) \
        { \
            if (deadline <= uptime) \
            { \
                errno = ETIMEDOUT; \
                result = ERR; \
                break; \
            } \
            clock_t remaining = deadline == CLOCKS_NEVER ? CLOCKS_NEVER : (deadline > uptime ? deadline - uptime : 0); \
            wait_queue_t* temp = waitQueue; \
            if (wait_block_setup(&temp, 1, remaining) == ERR) \
            { \
                result = ERR; \
                break; \
            } \
            lock_release(lock); \
            result = wait_block_commit(); \
            assert(rflags_read() & RFLAGS_INTERRUPT_ENABLE); \
            lock_acquire(lock); \
            uptime = timer_uptime(); \
        } \
        result; \
    })
 
typedef struct wait_queue
{
    lock_t lock;
    list_t entries; 
} wait_queue_t;
 
typedef struct wait_entry
{
    list_entry_t queueEntry;  
    list_entry_t threadEntry; 
    thread_t* thread;         
    wait_queue_t* waitQueue;  
} wait_entry_t;
 
typedef struct
{
    list_t blockedThreads; 
    cpu_t* cpu;            
    lock_t lock;
} wait_cpu_ctx_t;
 
typedef struct
{
    list_t entries;      
    errno_t err;         
    clock_t deadline;    
    wait_cpu_ctx_t* cpu; 
} wait_thread_ctx_t;
 
#define WAIT_QUEUE_CREATE(name) {.lock = LOCK_CREATE, .entries = LIST_CREATE(name.entries)}
 
void wait_queue_init(wait_queue_t* waitQueue);
 
void wait_queue_deinit(wait_queue_t* waitQueue);
 
void wait_thread_ctx_init(wait_thread_ctx_t* wait);
 
void wait_cpu_ctx_init(wait_cpu_ctx_t* wait, cpu_t* self);
 
bool wait_block_finalize(interrupt_frame_t* frame, cpu_t* self, thread_t* thread, clock_t uptime);
 
void wait_unblock_thread(thread_t* thread, errno_t err);
 
uint64_t wait_unblock(wait_queue_t* waitQueue, uint64_t amount, errno_t err);
 
uint64_t wait_block_setup(wait_queue_t** waitQueues, uint64_t amount, clock_t timeout);
 
void wait_block_cancel(void);
 
uint64_t wait_block_commit(void);