src/ipc/lock.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                             *
************************************************************
*       lock.cpp, version 1.0                              *
************************************************************
*                                                          *
*locks. we use these to mark resources as free/used. only  *
*one thread/process may hold a lock over a resource which  *
*is necessary to work with shared data.                    *
*                                                          *
*23'04'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/common/string.hpp"
#include "src/memory/memset.hpp"
#include "src/thread/thread.hpp"
#include "src/thread/scheduler.hpp"
#include "src/arch/x86/rtc.hpp"
#include "src/ipc/lock.hpp"

IPC::Lock::lock_t lock_system("system");        // when a critical section should not be interrupted

#define LOCK_SLEEP_STEP 70
#define LOCK_SPIN_STEP 70
//#define LOCK_RETRIES 0x10000

#define LOCK_RETRIES 0x1000
#define LOCK_RETRIES_WHEN_SLEEP 10

#define LOCKS_BY_CRITICAL_SECTION 1

namespace IPC {
namespace Lock {

volatile bool disable_all_locks=false;

/*this clears the state variable*/
lock_t::lock_t(const char *nam)
 {
        memset(name, 0, LOCK_NAME);
        memmove(name, const_cast<char*>(nam), ( lgth(const_cast<char*>(nam))<LOCK_NAME-1 ) ? lgth(const_cast<char*>(nam)) : LOCK_NAME-1 );
        state=FALSE;
 }

lock_t::lock_t() {
        state=false;
 }

void lock_t::init(const char *nam)
 {
        memset(&name, 0, LOCK_NAME);
        memmove(&name, nam, ( lgth(nam)<LOCK_NAME-1 ) ? lgth(nam) : LOCK_NAME-1 );
        state=FALSE;
 }

//returns state
bool lock_t::locked() {
   if (disable_all_locks) return false;
        return state;
 }

/*lock the resource*/
void lock_t::lock(bool slp)
 {
   if (disable_all_locks)
      return ;
bool ret;
uint64 retries=0;
uint32 fl;
#if 0
   ENTER_CRITICAL(eflags);
   if (Arch::x86::Interr::isInInterruptHandler())
   if (name[0]!='t' || name[1]!='t'||name[2]!='y'||name[3]!='\0')
   {
      TTYDisableLock=true;
      cout(name);
      cout("\t");
      TTYDisableLock=false;
   }
   LEAVE_CRITICAL(eflags);
#endif
//      asm volatile("pushf\npopl %0":"=g"(fl));
ENTER_CRITICAL(eflags);
/*lock with atomic operations*/
bool flag=false;
        do {
                asm volatile ("lock\nxchg (%%edx),%%ebx" :"=b"(ret) :"b"(true), "d"(&state));

                if (Thread::Scheduler::multitasking_running == true)
                        if (ret == TRUE) {
                                asm volatile("sti");
                                if (slp)
               Thread::sleep(LOCK_SLEEP_STEP);
            else {
               uint64 t= Arch::x86::RTC::up_time+(DEF_SECOND/1024)*LOCK_SPIN_STEP;
               while (Arch::x86::RTC::up_time < t) ;
            }
            
            asm volatile("cli");
                        }

                if (retries++ == (slp ? LOCK_RETRIES_WHEN_SLEEP : LOCK_RETRIES))
                 {
                        asm volatile ("pushf\npopl %0\ncli":"=g"(fl));
                        TTYDisableLock=true;
         alert(" lock ");
         bool state = disable_all_locks;
         //disable_all_locks=true;
         debug_dump_call_trace(eipebp.eip,eipebp.ebp);
                        debug_dump_call_trace();
         flag=true;
                        cout("caution: locked on ");
                        cout( (char*)&name );
                        cout("\n");
                        TTYDisableLock=false;
         disable_all_locks=state;
                        asm volatile("pushl %0\npopf"::"g"(fl));
                 }
         } while (ret == TRUE) ;
   save_eip_ebp(eipebp);

   if (flag==true) { cout("relocked on "); cout( (char*)&name); cout("\n"); }

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

#if LOCKS_BY_CRITICAL_SECTION
#else
   LEAVE_CRITICAL(eflags);
#endif

#ifdef LOCKS_BY_CRITICAL_SECTION
//   ENTER_CRITICAL(eflags);
#endif
 }

//get the lock, not spinning, sleeping
void lock_t::lock2() {
        lock(true);
 }

//get the lock
void lock_t::lock() {
        lock(false);
 }

/*release the lock*/
void lock_t::ulock()
 {
        state=FALSE;
#ifdef LOCKS_BY_CRITICAL_SECTION
   LEAVE_CRITICAL(eflags);
#endif
 }


  };    /*namespace Lock*/
 };     /*namespace IPC*/

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

---