home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / C / CTASK11.ZIP / TSKSNAP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1988-07-01  |  5.2 KB  |  165 lines
  1. /*
  2.    TSKSNAP.C - CTask State Snaphot
  3.  
  4.    Public Domain Software written by
  5.       Thomas Wagner
  6.       Patschkauer Weg 31
  7.       D-1000 Berlin 33
  8.       West Germany
  9.  
  10.    This file is new with Version 1.1
  11. */
  12.  
  13. #include "tsk.h"
  14. #include "tsklocal.h"
  15.  
  16. #if (TSK_NAMED)
  17.  
  18. local char *sn_state [] = { "*???*", "Stop", "Delay", "Wait", "Elig", "Run" };
  19. local char *sn_kind [] = { "*Undef*", "Task", "Flag", "Resource", "Counter",
  20.                            "Mailbox", "Pipe", "Wpipe", "Buffer" };
  21.  
  22. local int sn_wlist (FILE *f, char *str, tqueptr list, int col)
  23. {
  24.    tcbptr curr;
  25.  
  26.    if ((curr = *list) == NULL)
  27.       return col;
  28.    if (col)
  29.       fprintf (f, "\n%51c", ' ');
  30.    col = 52;
  31.    fprintf (f, "%6s(%Fp):  ", str, list);
  32.    while (curr != NULL)
  33.       {
  34.       if (col >= 60)
  35.          {
  36.          fprintf (f, "\n51c", ' ');
  37.          col = 52;
  38.          }
  39.       fprintf (f, "%-8s(%Fp) ", curr->name.name, curr);
  40.       col += 20;
  41.       curr = curr->next;
  42.       }
  43.    return col;
  44. }
  45.  
  46. local void dump_events (FILE *f)
  47. {
  48.    nameptr curr;
  49.    int col;
  50.    flagptr fl;
  51.    counterptr ct;
  52.    resourceptr rs;
  53.    mailboxptr mb;
  54.    pipeptr pp;
  55.    wpipeptr wp;
  56.    bufferptr bp;
  57.  
  58.    fprintf (f, "List of Events:\n");
  59.    /*           1234567890123456789012345678901234567890123456789012345
  60.                 12345678   12345678  12345678  123456(123456789):        */
  61.    fprintf (f, "Name       Type         State     Waitfor(Queue)   Tasks\n");
  62.  
  63.    for (curr = tsk_name_list.follow; curr->nkind; curr = curr->follow)
  64.       if (curr->nkind != TYP_TCB)
  65.          {
  66.          fprintf (f, "%-8s   %-8s  ", curr->name, sn_kind [curr->nkind]);
  67.          switch (curr->nkind)
  68.             {
  69.             case TYP_FLAG: fl = (flagptr) curr->strucp;
  70.                            fprintf (f, "%8s  ", (fl->state) ? "Set" : "Clear");
  71.                            col = sn_wlist (f, "Set", &fl->wait_set, 0);
  72.                            sn_wlist (f, "Clear", &fl->wait_clear, col);
  73.                            break;
  74.  
  75.             case TYP_COUNTER: ct = (counterptr) curr->strucp;
  76.                            fprintf (f, "%8ld  ", ct->state);
  77.                            col = sn_wlist (f, "Set", &ct->wait_set, 0);
  78.                            sn_wlist (f, "Clear", &ct->wait_clear, col);
  79.                            break;
  80.  
  81.             case TYP_RESOURCE: rs = (resourceptr) curr->strucp;
  82.                            fprintf (f, "%8s  ", (rs->state) ? "Free" : "Busy");
  83.                            col = sn_wlist (f, "Owner", &rs->owner, 0);
  84.                            sn_wlist (f, "Wait", &rs->waiting, col);
  85.                            break;
  86.  
  87.             case TYP_MAILBOX: mb = (mailboxptr) curr->strucp;
  88.                            fprintf (f, "%8s  ", (mb->mail_first == NULL)
  89.                                     ? "Empty" : "Mail");
  90.                            sn_wlist (f, "Mail", &mb->waiting, 0);
  91.                            break;
  92.  
  93.             case TYP_PIPE: pp = (pipeptr) curr->strucp;
  94.                            fprintf (f, "%8u  ", pp->filled);
  95.                            col = sn_wlist (f, "Read", &pp->wait_read, 0);
  96.                            col = sn_wlist (f, "Write", &pp->wait_write, col);
  97.                            sn_wlist (f, "Clear", &pp->wait_clear, col);
  98.                            break;
  99.  
  100.             case TYP_WPIPE: wp = (wpipeptr) curr->strucp;
  101.                            fprintf (f, "%8u  ", wp->filled);
  102.                            col = sn_wlist (f, "Read", &wp->wait_read, 0);
  103.                            col = sn_wlist (f, "Write", &wp->wait_write, col);
  104.                            sn_wlist (f, "Clear", &wp->wait_clear, col);
  105.                            break;
  106.  
  107.             case TYP_BUFFER: bp = (bufferptr) curr->strucp;
  108.                            fprintf (f, "%8u  ", bp->msgcnt);
  109.                            col = sn_wlist (f, "Read", &bp->buf_read.waiting, 0);
  110.                            sn_wlist (f, "Write", &bp->buf_write.waiting, col);
  111.                            break;
  112.  
  113.             default:       fprintf (f, "*Invalid Type %02x", curr->nkind);
  114.                            break;
  115.             }
  116.          fprintf (f, "\n");
  117.          }
  118.    fprintf (f, "\n");
  119. }
  120.  
  121.  
  122. local void dump_tasks (FILE *f)
  123. {
  124.    nameptr curr;
  125.    tcbptr task;
  126.    fprintf (f, "\nTask List:\n");
  127.    fprintf (f, "Name     State Queue      Timeout TCB-addr  Stackptr  Stackbot  Instrptr  Prior\n");
  128.  
  129.    for (curr = tsk_name_list.follow; curr->nkind; curr = curr->follow)
  130.       if (curr->nkind == TYP_TCB)
  131.          {
  132.          task = (tcbptr) curr->strucp;
  133.  
  134.          fprintf (f, "%-8s %-5s %Fp %8ld %Fp %Fp %Fp %Fp %5u\n",
  135.                  curr->name, 
  136.                  sn_state [(task->state <= 5) 
  137.                            ? task->state : 0],
  138.                  task->queue,
  139.                  task->timerq.timeout, 
  140.                  task, 
  141.                  task->stack, 
  142.                  task->stkbot,
  143.                  ((struct task_stack *)task->stack)->retn, 
  144.                  task->prior);
  145.          }
  146.    fprintf (f, "\n");
  147. }
  148.  
  149.  
  150. void snapshot (FILE *f)
  151. {
  152.    word oldpri;
  153.  
  154.    oldpri = get_priority (tsk_current);
  155.    set_priority (tsk_current, 0xffff);
  156.  
  157.    dump_tasks (f);
  158.    dump_events (f);
  159.  
  160.    set_priority (tsk_current, oldpri);
  161. }
  162.  
  163. #endif
  164.  
  165.