sys/src/mutex.c

Go to the documentation of this file.

// _Id: mutex.c,v 1.11 2009-05-10 21:15:31 roart Exp $
// _Locker:  $

// Author. Roar Thronæs.
/**
   \file mutex.c
   \brief mutexes
   \author Roar Thronæs
*/

#include<system_data_cells.h>
#include<ipl.h>
#include<internals.h>
#include<pridef.h>
#include<wqhdef.h>
#include<linux/sched.h>
#include<ipldef.h>
#include <sch_routines.h>
#include <linux/spinlock.h>
#include <mtxdef.h>
#include <asm/bitops.h>
#include <statedef.h>
#include <queue.h>
#include <sch_routines.h>

#define ioc_gq_mutex ioc_spin
static struct _mtx ioc_spin = { 65535 /* mtx_w_sts : 1, mtx$w_owncnt : -1 */ };

// definitely needs reimplementation. this implemantion, or the bad old one? */

/**
   \brief stall process when waiting for mutex - see 5.2 8.5.3
   \param p pcb
   \param m mutex
*/

void mutexwait(struct _pcb * p, struct _mtx * m) {
  /** store mutex address in efwm */
  p->pcb_l_efwm = m; // check. 32 bit problem
  /** new pcb state MWAIT */
  p->pcb_w_state = SCH$C_MWAIT;
  /** insert into MWAIT scheduling queue */
  insque(p,sch_aq_wqhdr[SCH$C_MWAIT].wqh$l_wqfl);
  int ipl=getipl();
  /** put on wait */
  sch_waitl(p, &sch$aq_wqhdr[SCH$C_MWAIT]);
  setipl(ipl);
}  

/**
   \brief mutex for writing - see 5.2 8.5.2
   \param m mutex
*/

void sch_lockw(struct _mtx * m) {
  struct _pcb * p = ctl_gl_pcb;
 again:
  {}
  /** spinlock sched */
  int ipl = vmslock(&SPIN_SCHED, IPL__SCHED);
  /** test and set mutex write flag */
  if (test_and_set_bit(16, m)) {
    /** if set, no further readers or writers allowed, stall process */
    mutexwait(p, m);
    goto again;
  } else {
    /** if no other owners */
    if (m->mtx_w_owncnt==65535 /* not yet: -1 */ ) {
      /** own it is done by incrementing owncnt and mtxcnt */
      m->mtx_w_owncnt++;
      p->pcb_w_mtxcnt++;
      /** if it is the first to be locked */
      if (p->pcb_w_mtxcnt==1) {
        /** then record current priorities in pcb */
        /** TODO check if saved right with regard to realtime */
        p->pcb_b_prisav = p->pcb$b_pri;
        p->pcb_b_pribsav = p->pcb$b_prib;
        /** if not realtime process, boost priority */
        if (16>=p->pcb_b_pri) { 
          p->pcb_b_prib = 15;
          sch_change_cur_priority(p, 15);
        }
      }
    } else {
      /** if other owners, stall */
      mutexwait(p, m);
      goto again;
    }
  }
  /** release spinlock */
  ipl = IPL__ASTDEL;
  vmsunlock(&SPIN_SCHED, ipl);
}

/**
   \brief mutex for reading - see 5.2 8.5.1
   \param m mutex
*/

void sch_lockr(struct _mtx * m) {
  struct _pcb * p = ctl_gl_pcb;
 again:
  {}
  /** spinlock sched */
  int ipl = vmslock(&SPIN_SCHED, IPL__SCHED);
  /** test mutex write flag */
  if (test_bit(16, m)) {
    /** if set, stall process until available */
    mutexwait(p, m);
    goto again;
  } else {
    /** if not set, grant readership */
    /** TODO check owncnt use here. copied from lockw? */
    if (m->mtx_w_owncnt==65535 /* not yet: -1 */ ) {
      /** own it is done by incrementing owncnt and mtxcnt */
      m->mtx_w_owncnt++;
      p->pcb_w_mtxcnt++;
      /** if it is the first to be locked */
      if (p->pcb_w_mtxcnt==1) {
        /** then record current priorities in pcb */
        /** TODO check if saved right with regard to realtime */
        p->pcb_b_prisav = p->pcb$b_pri;
        p->pcb_b_pribsav = p->pcb$b_prib;
        /** if not realtime process, boost priority */
        if (16>=p->pcb_b_pri) { 
          p->pcb_b_prib = 15;
          sch_change_cur_priority(p, 15);
        }
      }
    } else {
      mutexwait(p, m);
      goto again;
    }
  }
  /** release spinlock */
  ipl = IPL__ASTDEL;
  vmsunlock(&SPIN_SCHED, ipl);
}

void sch_iolockw(void) {
  // probably wrong?
  sch_lockw(&ioc$gq_mutex);
}

/**
   \brief unlocking a mutex - see 5.2 8.5.4
   \param m mutex
*/

void sch_unlock(struct _mtx * m) {
  struct _pcb * p = ctl_gl_pcb;
  /** spinlock sched */
  int ipl = vmslock(&SPIN_SCHED, IPL__SCHED);
  /** decrement mtxcnt */
  p->pcb_w_mtxcnt--;
  /** if process does not own anymore, restore pris and change pri */
  /** TODO check if all saved are restore, and TODO check realtime */
  if (p->pcb_w_mtxcnt==0) {
    p->pcb_b_prib = p->pcb$b_pribsav;
    sch_change_cur_priority(p, p->pcb$b_pri);
  }
  /** decrement owncnt */
  m->mtx_w_owncnt--;
  if (m->mtx_w_owncnt==65535 /* not yet: -1 */ ) {
    /** if no other owners */
    /** bbcci, test and clear write bit */
    if (test_and_clear_bit(16, m)) {
      /** if a writer had it */
      int rsn = m; // check 32 bit
      // pasted from ravail
      struct _wqh * wq=sch_gq_mwait;
      struct _pcb * p=wq->wqh_l_wqfl;
      struct _pcb * next;
      /** scan misc wait queue */
      for (; p!=wq; p=next) {
        next = p->pcb_l_sqfl;
        /** search for those waiting for the now unlocked mutex */
        if (p->pcb_l_efwm==rsn) {
          /** when found */
          /** decrease wqueue count */
          wq->wqh_l_wqcnt--;
          /** schedule that process */
          sch_chse(p,PRI$_RESAVL);
        }
      }
    }
  }

 out:
  /** release spinlock */
  vmsunlock(&SPIN_SCHED, ipl);
}

void sch_unlockw(struct _mtx * m) {
  sch_unlock(m);
}

void sch_iounlockw(void) {
  // probably wrong?
  sch_unlockw(&ioc$gq_mutex);
}

void sch_iounlock(void) {
  // probably wrong?
  sch_unlockw(&ioc$gq_mutex);
}

/**
   \brief resource available
*/

void sch_std_ravail(int rsn) { // check. still 32 bit prob
  int retval=test_and_clear_bit(rsn,&sch_gl_resmask);
  if (retval==0)
    return;
  int savipl=vmslock(&SPIN_SCHED,IPL__MAILBOX);
  struct _wqh * wq=sch_gq_mwait;
  struct _pcb * p=wq->wqh_l_wqfl;
  for (;p!=wq;p=p->pcb_l_sqfl) {
    if (p->pcb_l_efwm==rsn) {
      wq->wqh_l_wqcnt--;
      sch_chse(p,PRI$_RESAVL);
    }
  }
  vmsunlock(&SPIN_SCHED,savipl);
}

void sch_rwait(int rsn) {
  test_and_set_bit(rsn,&sch_gl_resmask);
  return mutexwait(ctl_gl_pcb, rsn);
}

---