对Minix3中进程模型的简要分析

struct proc {
struct stackframe_s p_reg;　　　　　　　　　　　　/*process‘ registers saved in stack frame */
reg_t p_ldt_sel;　　　　　　　　　　　　　　　　　　/*selector in gdt with ldt base and limit */
struct segdesc_sp_ldt[2+NR_REMOTE_SEGS]; 　　　/* CS, DS and remote segments */
proc_n r_tp_nr;　　　　　　　　　　　　　　　　　　 /* numberof this process (for fast access) */
struct priv *p_priv;　　　　　　　　　　　　　　　 /*system privileges structure */
char p_rts_flags;　　　　　　　　　　　　　　　　　 /*SENDING, RECEIVING, etc. */
char p_priority;　　　　　　　　　　　　　　　　　　/*current scheduling priority */
char p_max_priority;　　　　　　　　　　　　　　　 /*maximum scheduling priority */
char p_ticks_left;　　　　　　　　　　　　　　　   /*number of scheduling ticks left */
char p_quantum_size;                          /*quantum size in ticks */
struct mem_mapp_memmap[NR_LOCAL_SEGS];        /* memory map (T, D, S) */
clock_t p_user_time;　　　　　　　　　　　　　　   /*user time in ticks */
clock_t p_sys_time;      　　　　　　　　　　　　 /*sys time in ticks */
struct proc *p_nextready;　　　　　　　　　　　　 /*pointer to next ready process */
struct proc *p_caller_q;　　　　　　　　　　　　  /*head of list of procs wishing to send */
struct proc *p_q_link;　　　　　　　　　　　　　　 /*link to next proc wishing to send */
message* p_messbuf;　　　　　　　　　　　　　　　　 /*pointer to passed message buffer */
proc_n r_tp_getfrom;　　　　　　　　　　　　　　　　/*from whom does process want to receive? */
proc_n r_tp_sendto;　　　　　　　　　　　　　　　　 /* towhom does process want to send? */
sigset_t p_pending;　　　　　　　　　　　　　　　　 /*bit map for pending kernel signals */
char p_name[P_NAME_LEN];　　　　　　　　　　　　　 /*name of the process, including \0 */
};

/* Scheduling priorities for p_priority. Values must start at zero (highest
 * priority) and increment.  Priorities of the processes in the boot image
 * can be set in table.c. IDLE must have a queue for itself, to prevent low
 * priority user processes to run round-robin with IDLE.
 */
#define NR_SCHED_QUEUES   16        /* MUST equal minimum priority + 1 */
#define TASK_Q             0        /* highest, used for kernel tasks */
#define MAX_USER_Q         0        /* highest priority for user processes */  
#define USER_Q             7        /* default (should correspond to nice 0) */  
#define MIN_USER_Q        14        /* minimum priority for user processes */
#define IDLE_Q            15        /* lowest, only IDLE process goes here */

EXTERN struct proc *rdy_head[NR_SCHED_QUEUES]; /* ptrs to ready list headers */
EXTERN struct proc *rdy_tail[NR_SCHED_QUEUES]; /* ptrs to ready list tails */ 

PRIVATE int clock_handler(hook)
irq_hook_t *hook;
{
/* This executes on each clock tick (i.e., every time the timer chip generates
 * an interrupt). It does a little bit of work so the clock task does not have
 * to be called on every tick.  The clock task is called when:
 *
 *        (1) the scheduling quantum of the running process has expired, or ......
 */
  ......
  /* Check if do_clocktick() must be called. Done for alarms and scheduling.
   ......
   */
  if (  ...... || (proc_ptr->p_ticks_left <= 0)) {
      prev_ptr = proc_ptr;                        /* store running process */
      lock_notify(HARDWARE, CLOCK);               /* send notification */
  }
  ......
}

PRIVATE int do_clocktick(m_ptr)
message *m_ptr;                                /* pointer to request message */
{
   ......
  /* A process used up a full quantum. The interrupt handler stored this
   * process in ‘prev_ptr‘.  First make sure that the process is not on the
   * scheduling queues.  Then announce the process ready again. Since it has
   * no more time left, it gets a new quantum and is inserted at the right
   * place in the queues.  As a side-effect a new process will be scheduled.
   */
  if (prev_ptr->p_ticks_left <= 0 && priv(prev_ptr)->s_flags & PREEMPTIBLE) {
      lock_dequeue(prev_ptr);                /* take it off the queues */
      lock_enqueue(prev_ptr);                /* and reinsert it again */
  }
  ......
}

PRIVATE void enqueue(rp)
register struct proc *rp; /* this process is now runnable */
{
/* Add ‘rp‘ to one of the queues of runnable processes.  This function is
 * responsible for inserting a process into one of the scheduling queues.
 * The mechanism is implemented here.   The actual scheduling policy is
 * defined in sched() and pick_proc().
 */
  int q;      /* scheduling queue to use */
  int front;     /* add to front or back */

  /* Determine where to insert to process. */
  sched(rp, &q, &front);

  /* Now add the process to the queue. */
  if (rdy_head[q] == NIL_PROC) {        /* add to empty queue */
      rdy_head[q] = rdy_tail[q] = rp;   /* create a new queue */
      rp->p_nextready = NIL_PROC;       /* mark new end */
  }
  else if (front) {   　　　　　　　　　　 /* add to head of queue */
      rp->p_nextready = rdy_head[q];    /* chain head of queue */
      rdy_head[q] = rp;                 /* set new queue head */
  }
  else {                                /* add to tail of queue */
      rdy_tail[q]->p_nextready = rp;    /* chain tail of queue */ 
      rdy_tail[q] = rp;                 /* set new queue tail */
      rp->p_nextready = NIL_PROC;       /* mark new end */
  }

  /* Now select the next process to run. */
  pick_proc();   

}