sys/src/forkcntrl.c

Go to the documentation of this file.

// _Id: forkcntrl.c,v 1.29 2009-05-10 21:24:29 roart Exp $
// _Locker:  $

// Author. Roar Thronæs.

#include<linux/linkage.h>
#include<system_data_cells.h>
#include<ucbdef.h>
#include<irpdef.h>
#include<fkbdef.h>
#include<ipldef.h>
#include<ipl.h>
#include<internals.h>
#include <linux/smp.h>
#include <asm/current.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <asm/hw_irq.h>
#include <queue.h>

asmlinkage void exe_forkdspth(int i);
void exe_fork(struct _irp * i, struct _ucb * u);
void exe_queue_fork(struct _irp * i, struct _ucb * u);

struct fork_lock_struct {
  struct _spl * spin;
  int ipl;
};

// call this smp_al_iplvec?
static struct fork_lock_struct forklock_table[7]={
  { &SPIN_IOLOCK8, IPL__IOLOCK8 },
  { 0, 0 },
  { &SPIN_IOLOCK8, IPL__IOLOCK8 },
  { &SPIN_IOLOCK9, IPL__IOLOCK9 },
  { &SPIN_IOLOCK10, IPL__IOLOCK10 },
  { &SPIN_IOLOCK11, IPL__IOLOCK11 },
  { &SPIN_MAILBOX, IPL__MAILBOX }
};

/**
   \brief forklock - see 5.2 8.3.7
   \details forklock with spinlock and setipl
   \details not 100% according to spec
   \param i lock type
   \param j new ipl
*/

int inline forklock(int i, signed int j) {
  if (i<6 || i == 7 || i > 12)
    panic("forklock\n");
  if (j==-2) j=forklock_table[i-6].ipl;
  return vmslock(forklock_table[i-6].spin, j);
}

/**
   \brief forkunlock - see 5.2 8.3.7
   \details forkunlock with spinunlock and setipl
   \details not 100% according to spec
   \param i lock type
   \param j new ipl
*/

void inline forkunlock(int i, signed int j) {
  if (i<6 || i == 7 || i > 12)
    panic("forkunlock\n");
  if (j==-2) j=forklock_table[i-6].ipl;
  vmsunlock(forklock_table[i-6].spin, j);
}

/**
   \brief fork soft int - see 5.2 22.3.4
*/

asmlinkage void exe_frkipl6dsp(void) {
  exe_forkdspth(6);
}

/**
   \brief fork soft int - see 5.2 22.3.4
*/

asmlinkage void exe_frkipl8dsp(void) {
  exe_forkdspth(8);
}

/**
   \brief fork soft int - see 5.2 22.3.4
*/

asmlinkage void exe_frkipl9dsp(void) {
  exe_forkdspth(9);
}

/**
   \brief fork soft int - see 5.2 22.3.4
*/

asmlinkage void exe_frkipl10dsp(void) {
  exe_forkdspth(10);
}

/**
   \brief fork soft int - see 5.2 22.3.4
*/

asmlinkage void exe_frkipl11dsp(void) {
  exe_forkdspth(11);
}

/**
   \brief requesting i/o completion processing - see 5.2 22.3.4
   \param i interrupt
*/

asmlinkage void exe_forkdspth(int i) {
  void (*func)(void *,void *, void *);
  struct _fkb * f, * dummy = 0, * fq;
#ifdef __x86_64__
  if (intr_blocked(i))
    return;
  regtrap(REG_INTR, i);
#endif
  setipl(i);
  //printk("forkdspth\n");
  /** remove one fork block at a time from the appropriate fork queue */
  fq=smp_gl_cpu_data[smp_processor_id()]->cpu$q_swiqfl[i-6]; /* so far */
  while (!aqempty(fq)) {
    f=remque(fq,dummy);
    //printk("forking entry %x\n",f);
    func=f->fkb_l_fpc;
    /** get forklock */
    int savipl = vmslock(forklock_table[i-6].spin, forklock_table[i-6].spin);
    /** call fork routine */
    func(f->fkb_l_fr3,f->fkb$l_fr4,f);
    /** unlock fork */
    vmsunlock(forklock_table[i-6].spin, savipl);
    /** next entry TODO redo maybe */
    fq=smp_gl_cpu_data[smp_processor_id()]->cpu$q_swiqfl[0]; /* so far */
  }
}

/**
   \brief servicing the device interrupt - see 5.2 22.3.3
   \param i irp
   \param u ucb
*/

void exe_iofork(struct _irp * i, struct _ucb * u) {
  /** clear tim bit */
  u->ucb_l_sts&=~UCB$M_TIM;
  /** call exe_fork */
  exe_fork(i,u);
}

/**
   \brief servicing the device interrupt - see 5.2 22.3.3
   \param i irp
   \param u ucb
*/

void exe_fork(struct _irp * i, struct _ucb * u) {
  u->ucb_l_fr3=i;
  /* should also popl fkb_l_fpc(r5) according to the book. */
  /** call queue_fork */
  exe_queue_fork(i,u);
}

/**
   \brief servicing the device interrupt - see 5.2 22.3.3
   \param i irp
   \param u ucb
*/

void exe_queue_fork(struct _irp * i, struct _ucb * u) {
  int curipl;
  int newipl;
  int isempty;
  struct _fkb * f=u;
  /* I think that the below is really an fkb */
  /* need caller and caller's caller address of return again */
  // u->ucb_l_fr4=current; // wrong?
  /** get fork ipl - TODO smp/up support? */
  newipl=f->fkb_b_flck;
  /** locate fork block queue and insert fork block */
  f=smp_gl_cpu_data[smp_processor_id()]->cpu$q_swiqfl[newipl-6];
  isempty=aqempty(f);
  insque(u,f->fkb_l_fqbl);
  /** if first element request softint for it */
  if (isempty) {
    /* do SOFTINTS */
    switch (newipl) {
    case IPL__IOLOCK11:
      SOFTINT_IOLOCK11_VECTOR;
      break;
    case IPL__IOLOCK10:
      SOFTINT_IOLOCK10_VECTOR;
      break;
    case IPL__IOLOCK9:
      SOFTINT_IOLOCK9_VECTOR;
      break;
    case IPL__IOLOCK8:
      SOFTINT_IOLOCK8_VECTOR;
      break;
    case IPL__QUEUEAST:
      SOFTINT_QUEUEAST_VECTOR;
      break;
    default:
      panic("in forkdspth\n");
    }
  }
}

void exe_std_queue_fork(struct _fkb * fkb) {
  exe_queue_fork(0,fkb);
}

// replaces exe_fork
void exe_std_primitive_fork(long fr3, long fr4, struct _fkb * fkb) {
  fkb->fkb_l_fr3=fr3;
  fkb->fkb_l_fr4=fr4;
  exe_std_queue_fork(fkb);
}

---