taskshot.c

VRTX操作系统

char *state;
{
int i, concat=0;

  for (i=0; i<STATES; i++) {
    if (s & (1<<i)) {
      if (concat)
        strcat(state,"+");
      concat++;
      strcat(state, (char *) vmc_states[i]);
    }
  }
}

/*---------------------------------------------------------------------*/
int  TaskSnapshot(void)
{

int     i;
struct  tentry   *sptr;
char tstate[11];

  vmc_printf("\n\n------------------- %s ------------------\n\n","Tasks");
  vmc_printf("id     state          prio\tfgrp\tmask\topt\tmbox\tqueue\n");
  for ( i=0; i<vmc_ntsk; i++) {
    sptr = &vmc_tasktab[i];
    tstate[0] = '\0';
    STATE(sptr->tstate, tstate);
    vmc_printf("%-7d %-11s    %d\t", i, tstate, sptr->tprio);
    if(sptr->tstate & TBSFLAG)
      vmc_printf("%d\t%lx\t%d\t",
            sptr->object.event.tfevgroup,
            sptr->object.event.tfmask,
            sptr->object.event.tfopt);
    else
      vmc_printf("-1\t0\t0\t");

    if(sptr->tstate & TBSMBOX)
      vmc_printf("%x\t", (int) sptr->object.mbox.mboxp);
    else
      vmc_printf("-1\t");

    if(sptr->tstate & TBSQUEUE)
      vmc_printf("%d", sptr->object.queue.qid);
    else
      vmc_printf("-1");

    vmc_printf("\n");
  }
  return 0;
}

/*---------------------------------------------------------------------*/
void ListSnapshot(i,qnam)
int     i;
int     qnam;
{
int     ni, pi=NO_TID;

  if (qnam == RDY)
    vmc_printf("\n\n---------------- %s ----------------\n\n","Ready List");
  else
    vmc_printf("\n\n------------- %s --------------\n\n","Task Delta List");
  for ( ni=i; ni != NO_TID; pi=ni, ni=next(ni,qnam) ) {
    vmc_printf("%3s: tid=%02d", qnam ? "DLY" : "RDY", ni);
    if (isbadtid(ni) && ni != 0) {
      vmc_printf(" ?queue index corrupted!\n");
      break;
    }
    vmc_printf(" key=%u", (unsigned int) key(ni,qnam));
    if ( prev(ni,qnam) != pi)
      vmc_printf(" ?invalid qprev index (%d)", prev(ni,qnam));
    vmc_printf("\n");
  }
}

/*---------------------------------------------------------------------*/
void	EventSnapshot(void)
{
int	    i;
struct  fentry  *fptr;
unsigned char next;

  vmc_printf("\n\n---------------- %s ---------------\n\n","Event Flags");
  fptr = &vmc_eventgroup[0];
  vmc_printf("flag\tevent\tPending Tasks\n");
  for (i=0 ; i < vmc_nflag ; i++) {
    vmc_printf("%d\t%lx\t", i, fptr->fevent);		
    next = fptr->list;
    while (next != NO_TID) {
      vmc_printf("%d ", next);
      next = vmc_tasktab[next].prio_next;
    }
    vmc_printf("\n");
    fptr++;
  }
}

/*---------------------------------------------------------------------*/
void TimerQueue(void)
{
unsigned char next=vmc_timer_head;

  vmc_printf("\n\n------------- %s -------------\n\n","Timer Delta List");
  if (next != NO_TIMER) {
    vmc_printf("Timer Delta List:\n\nTimer\tCount\n\n");
    while (next != NO_TIMER) {
      vmc_printf("%d\t%lu\n", next, vmc_timers[next].count);
      next = vmc_timers[next].next;
    }
  }
}

/*---------------------------------------------------------------------*/
void MboxSnapshot(void)
{
unsigned char next=vmc_mboxhead;

  vmc_printf("\n\n----------------- %s ----------------\n\n","Mailboxes");
  if (next != NO_TID) {
    vmc_printf("Mbox\tTask\n\n");
    while (next != NO_TID) {
      vmc_printf("%x\t%d\n", (int) vmc_tasktab[next].object.mbox.mboxp, (int) next);
      next = vmc_tasktab[next].prio_next;
    }
  }
}

/*---------------------------------------------------------------------*/
void	TimerSnapshot(void)
{
int i, err;
unsigned long sc_vtinquiry(int, int *);

  vmc_printf("\n\n------------------- %s -------------------\n\n","Time");
  vmc_printf("systime=%ld timeslice=%d\n", vmc_systime, vmc_timeslice);
  if (vmc_ntimers) {
    vmc_printf("\nVirtual Timers:\n\nID\tstarted\tcount\tfunc\targ\n");
    for (i=0; i<vmc_ntimers; i++) {
      vmc_printf("%d\t%d\t%ld\t%x\t%x\n", i, vmc_timers[i].started,
                 sc_vtinquiry(i, &err), (int) vmc_timers[i].handler,
                 (int) vmc_timers[i].arg);
    }
  }
}

/*---------------------------------------------------------------------*/
void QueueSnapshot(void)
{
int i;
struct qentry *queue;

  vmc_printf("\n\n-------------- %s --------------\n\n","Message Queues");
  if (vmc_nqueue) {
    vmc_printf("Queue   Size   Count   Tid\n");
    for (i=0; i<vmc_nqueue; i++) {
      queue = &vmc_qcb[i];
      vmc_printf("%3d %7d %6d %6d\n", i, queue->maxcount-1,
            queue->count, (queue->tid != NO_TID) ? queue->tid : -1);
    }
  }
}

/*---------------------------------------------------------------------*/
void PartitionSnapshot(void)
{
int n, r;
unsigned long i[3];
void sc_pinquiry(unsigned long *, int, int *);
 
  vmc_printf("\n\n---------------- %s ----------------\n\n","Partitions");
  if (vmc_npart) {
    vmc_printf("Partitions:\n\nID\talloc\tfree\tbsize\n");
    for (n = 0; n < vmc_npart; n++) {
      sc_pinquiry(i, n, &r);
      vmc_printf("%d\t%ld\t%ld\t%ld\n", n, i[0], i[1], i[2]);
    }
  }
}

/*---------------------------------------------------------------------*/
void vmc_snapshot()
{
    cpu_interrupt_t     ps;

    disable(ps);

    vmc_printf("------------- VRTXmc Snapshot -------------\n\n");

    TaskSnapshot();

    ListSnapshot(vmc_readyhead,RDY);

    ListSnapshot(vmc_delayhead,DLY);

    TimerQueue();

    EventSnapshot();

    MboxSnapshot();

    TimerSnapshot();

    QueueSnapshot();

    PartitionSnapshot();

    vmc_printf("-------------------------------------------------------------\n\n");
    restore(ps);
}

/*---------------------------------------------------------------------*/