src/ipc/sem.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       sem.cpp, version 1.0                               *
************************************************************
*                                                          *
*Semaphores                                                *
*                                                          *
*30'07'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/heap.hpp"
#include "src/memory/align.hpp"
#include "src/memory/heap.hpp"
#include "src/thread/thread.hpp"
#include "src/thread/scheduler.hpp"
#include "src/ipc/lock.hpp"
#include "src/ipc/sem.hpp"

// namespace IPC {
// namespace Sem {


// init an unnamed sem, with value
int sem_init(sem_t *sem, unsigned int value, const char *name)
 { _Pf("sem_init");
        memset(sem,0,sizeof(struct sem_t));
        sem->wait_queue.init(name, &Memory::Heap::heap0);
        sem->lock_sem.init((char*)name);
        sem->name=name;
        sem->val= value;
        sem->flags=SF_OPEN;

        preturn(ESUCCESS);
 }

//destroy an unnamed semaphore. it is unsafe to destroy a semaphore upon which threads are blocking
int sem_destroy(sem_t *sem)
 { _Pf("sem_destroy");
        if ((sem->flags&SF_OPEN)==0)
                preturn(EFAIL);
        sem->wait_queue.done();
        memset(sem,0,sizeof(struct sem_t));
        preturn(ESUCCESS);
 }

// returns val
int sem_getvalue(sem_t *sem, int *sval)
 { _Pf("sem_getvalue");
        if ((sem->flags&SF_OPEN)==0)
                preturn(EFAIL);

        sem->lock_sem.lock();
        *sval= sem->val;
        sem->lock_sem.ulock();
        preturn(ESUCCESS);
 }

// blocking wait
int sem_wait(sem_t *sem)
 { _Pf("sem_wait");
        if ((sem->flags&SF_OPEN)==0)
                preturn(EFAIL);

int r;
        sem->lock_sem.lock();
uint32 fl;
        asm volatile("pushf\npopl %0\ncli":"=g"(fl));
        r= --sem->val;
        if (r<0)
                sem->wait_queue.ptr((void*)current_thread,NULL);
        sem->lock_sem.ulock();

        if (r<0) {
        if (Thread::Scheduler::multitasking_running)
                Thread::sem_sleep(sem, 0); else
                sysfail("semaphore locked with multithreading off");
   }

        asm volatile("pushl %0\npopf"::"g"(fl));

        preturn(ESUCCESS);      //uncompliant to posix. posix returns 0 instead of -1
 }

// non blocking wait
int sem_trywait(sem_t *sem)
 { _Pf("sem_trywait");
        if ((sem->flags&SF_OPEN)==0)
                preturn(EFAIL);

int r;
        sem->lock_sem.lock();
        r= sem->val;
        if (r>0) sem->val--;

        sem->lock_sem.ulock();
        if (r>0)
                preturn(ESUCCESS);

        preturn(EFAIL);
 }

//unlock semaphore
int sem_post(sem_t *sem)
 { _Pf("sem_post");
        if ((sem->flags&SF_OPEN)==0)
                preturn(EFAIL);
int r;
        sem->lock_sem.lock();
        r= ++sem->val;
        if (r<=0) {
                Thread::sem_awake(bli_dt(sem->wait_queue.head,struct Thread::thread_t*));
                sem->wait_queue.del(sem->wait_queue.head);
                }
        sem->lock_sem.ulock();
        preturn(ESUCCESS);
 }

//   }; /*namespace Sem*/
//  };  /*naemespace IPC*/



/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---