OSDev.org

Code: Select all

/* ArchImplement is a previous #define that marks a symbol as defined by arch-specific code
Note: In my kernel every function used by, and only by a macro internally is preceded by a '_'
*/
ArchImplement void _AtomicEnter();
ArchImplement void _AtomicExit();

/* Make a specific part of code completely atomic and thread-safe 
It's hackish (for supporting commas) I know, but it works well :)
The _NE version just doesn't exits the atomicity by itself. This is done
by the Atomic(...) extension if necessary.
*/
#define Atomic_NE(...) AtomicEnter(); __VA_ARGS__;
#define Atomic(...) Atomic_NE(__VA_ARGS__); _AtomicExit();

Code: Select all

/* Arch-independent context switch code. It must be able to change
all machine-specific stuff and process all hackish operations needed
to set user/kernel-space, virtual memory, registers and other things
specific as per process/thread.
volatile void PMContextSwitch(Bool autoSelect, PID pid)
{
	/* If autoselect == true, ignore pid and continue the chain. If false, switch to pid */
	Process *new = autoselect ? _runningProcess->next : PMGetProcess(pid);
	
	/* ContextSwitch() is an ArchImplement-ish function which (obviously) changes
	to another context. ContextSwitch() is responsible for disabling the atomicity as
	its final act before the actual far jump. If it fails, a Kernel Panic will ocurr. (An
	simple exception message here isn't enough to know how torepair the damage made).
	*/
	Atomic_NE(
		ContextSwitch(new);
	);
}

Code: Select all

#define Atomic_NE(res, ...) _AtomicEnter(res); __VA_ARGS__;
#define Atomic(res, ...) Atomic_NE(res, __VA_ARGS__); _AtomicExit(res);

Code: Select all

// In <lib/spinlock.h>

typedef struct
{
    PID pid;
    Size tid; // Thread ID
    volatile Bool lock; // "GCC, please don't think in single-threading when compiling me. Thanks!"
} Spinlock;

void spinlockacquire(Spinlock *lock);
void spinlockrelease(Spinlock *lock);

// ... In <lib/spinlock.c>

#include <proc/task.h>

// ...

volatile void spinlockacquire(Spinlock *lock)
{
    while(lock->lock && (lock->pid != _currentProcess->pid && lock->tid != _currentThread->tid)) PMYield(); // Yield timeslice
    lock->lock = true;
    lock->pid = _currentProcess->pid;
    lock->tid = _currentThread->tid;
}

volatile void spinlockrelease(Spinlock *lock)
{
    if(lock->pid != _currentProcess->pid || lock->tid != _currentThread->tid) return; // Silently fail
    lock->lock = false;
}

// ... In <lib/def.h>

#include <lib/spinlock.h>

// ...

#define Atomic_NE(res, ...) spinlockacquire(&res); __VA_ARGS__;
#define Atomic(res, ...) Atomic_NE(res, __VA_ARGS__); spinlockrelease(&res);

Code: Select all

    if( scheduler_disable_counter != 0) {
        task_switch_postponed_flag = true;
    } else {
        do_task_switch_like_normal();
   }

Code: Select all

    scheduler_disable_counter--;
    if(scheduler_disable_counter == 0) {
        if(task_switch_postponed_flag == true) {
            task_switch_postponed_flag = false;
            do_postponed_task_switch_now();
        }
    }

Code: Select all

// In <arch/x86/proc/atomic.c>

void spinlockacquire(volatile Spinlock *lock)
{
    while(lock->lock);
    
    // Atomical race condition (I think it is okay). How will win?
    INASM("cli");
    lock->tid = _currentProcess->pid;
    lock->tid = _currentThread->tid;
    lock->lock = true;
    INASM("sti");
}

void spinlockrelease(volatile Spinlock *lock)
{
    if(!lock->lock || lock->pid != _currentProcess->pid || lock->tid != _currentThread->tid) Panic(); // Pseudo-code
    
    INASM("cli");
    lock->lock = false;
    INASM("sti");
}

Code: Select all

    while(lock->lock);
   // NOTE: interrupt happens here
    INASM("cli");

Code: Select all

.retry:
     lock bts [myLock],0     ;Set bit 0 of "myLock", and return the previous value in the carry flag
     jc .retry               ;Retry if bit 0 was already set

Code: Select all

.retry:
     pause                   ;Don't waste CPU resources
     lock bts [myLock],0     ;Set bit 0 of "myLock", and return the previous value in the carry flag
     jc .retry               ;Retry if bit 0 was already set

Code: Select all

.retry:
     pause                   ;Don't waste CPU resources
     bt [myLock],0           ;Test if bit 0 of "myLock" is already set
     jc .retry               ;Retry (without doing the more expensive "lock bts [myLock],0") if bit 0 was set

     lock bts [myLock],0     ;Set bit 0 of "myLock", and return the previous value in the carry flag
     jc .retry               ;Retry if bit 0 was already set

Code: Select all

     lock bts [myLock],0     ;Optimistically set bit 0 of "myLock", and return the previous value in the carry flag
     jnc .acquired           ;Lock was acquired is bit 0 was previously clear

.retry:
     pause                   ;Don't waste CPU resources
     bt [myLock],0           ;Test if bit 0 of "myLock" is already set
     jc .retry               ;Retry (without doing the more expensive "lock bts [myLock],0") if bit 0 was set

     lock bts [myLock],0     ;Set bit 0 of "myLock", and return the previous value in the carry flag
     jc .retry               ;Retry if bit 0 was already set

.acquired:

Code: Select all

     cli                     ;Disable IRQs (in the hope that we do acquire the lock)
     lock bts [myLock],0     ;Optimistically set bit 0 of "myLock", and return the previous value in the carry flag
     jnc .acquired           ;Lock was acquired is bit 0 was previously clear

.retry:
     sti                     ;Enable IRQs (because we failed to acquire the lock)
     pause                   ;Don't waste CPU resources
     bt [myLock],0           ;Test if bit 0 of "myLock" is already set
     jc .retry               ;Retry (without doing the more expensive "lock bts [myLock],0") if bit 0 was set

     cli                     ;Disable IRQs (in the hope that we do acquire the lock)
     lock bts [myLock],0     ;Set bit 0 of "myLock", and return the previous value in the carry flag
     jc .retry               ;Retry if bit 0 was already set

.acquired:

Code: Select all

;we are in <arch/x86/proc/atomic.s
;PID/TID verifying is not included
.code32
.text
.global Spinlock
Spinlock:
push %ebp
movl %esp, %ebp
cli
lock bts $0, 8(%ebp)
jnc .acquired
.retry:
sti
pause
btl $0, 8(%ebp)
jc .retry
cli
lock bts $0, 8(%ebp)
jc .retry
.acquired:
movl %ebp, %esp
pop %ebp
ret