home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d0xx / d079 / monproc.lha / MonProc / monproc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-06-04  |  9.9 KB  |  376 lines
  1. /*
  2.  *  MONPROC.C    - Monitor AmigaDOS process packet activity.
  3.  *
  4.  *        Phillip Lindsay (c) 1987 Commodore-Amiga, Inc.
  5.  *  You may use this source as long as this copywrite notice is left intact.
  6.  *
  7.  *  re-organized and slightly re-worked by Davide P. Cervone, 4/25/87.
  8.  */
  9.  
  10. #include <exec/types.h>
  11. #include <exec/ports.h>
  12. #include <exec/semaphores.h>
  13. #include <libraries/dos.h>
  14. #include <libraries/dosextens.h>
  15. #include <stdio.h>
  16.  
  17. #ifdef MANX
  18. #include <functions.h>
  19. #endif
  20.  
  21. #define ONE         1L
  22.  
  23. /*
  24.  * AmigaDOS uses task signal bit 8 for message signaling
  25.  */
  26.  
  27. #define DOS_SIGNAL   8
  28. #define DOS_MASK     (ONE<<DOS_SIGNAL)
  29.  
  30. #define PTR(x,p)     ((struct x *)(p))
  31.  
  32. extern void GetProcList(),FreeProcList(),PrintPkt();
  33. extern LONG AllocSignal(), Wait();
  34. extern struct Message *PacketWait(), *GetMsg();
  35. extern struct Process *FindTask();
  36. extern struct DosLibrary *DOSBase;
  37. extern int Dump_OK, Lock_OK;
  38.  
  39.  
  40. struct MsgPort         *thePort;        /* the port we will be monitoring */
  41. struct Process         *myProcess;      /* pointer to our own process */
  42. ULONG                  WaitMask;        /* the task signal mask */
  43. struct SignalSemaphore CanReturn = {0}; /* coordinates PacketWait */
  44. struct Message         *theMessage;     /* the message we received */
  45. APTR                   OldPktWait;      /* the old pr_PktWait routine */
  46.  
  47.  
  48. #ifdef MANX
  49.    LONG PWait();        /* this is the ASM stub that calls PacketWait() */
  50. #else
  51.    #define PWait   PacketWait
  52. #endif
  53.  
  54. #ifndef MANX
  55.    Ctrl_C()             /* Control-C Trap routine for Lattice */
  56.    {
  57.       return(0);
  58.    }
  59. #endif
  60.  
  61.  
  62. /*
  63.  *  PacketWait()
  64.  *
  65.  *  This is the routine placed in the pr_PktWait field of the monitored
  66.  *  precess.  It is run asynchronously by the monitored process, and is
  67.  *  called whenever AmigaDOS does a taskwait().  PacketWait() waits for
  68.  *  a message to come in and then signals the monitoring task that one has
  69.  *  arrived.  It then attempts to obtain the semaphore, which will not be
  70.  *  released by the monitoring process until it is finished printing the 
  71.  *  contents of the packet.
  72.  */
  73.  
  74. struct Message *PacketWait()
  75. {
  76. #ifdef MANX
  77.    /*
  78.     *  if MANX, make sure we can see our data
  79.     */
  80.    geta4();
  81. #endif
  82.  
  83.    SetSignal(FALSE,DOS_MASK);
  84.  
  85.    while(!(theMessage = GetMsg(thePort)))  Wait(DOS_MASK);
  86.  
  87.    Signal(myProcess,WaitMask);
  88.    ObtainSemaphore(&CanReturn);
  89.    ReleaseSemaphore(&CanReturn);
  90.  
  91.    return(theMessage);
  92. } 
  93.  
  94.  
  95. /*
  96.  *  DoArguments()
  97.  *
  98.  *  Parses the command line to make sure it contains only valid arguments,
  99.  *  and sets the flag variables to their proper values (they are initialized
  100.  *  in printpkt.c).  The legal options are:
  101.  *
  102.  *      [NO]DUMP        To control hex dumps of long buffers
  103.  *      [NO]LOCK        To control the display of LOCK parameters
  104.  *                      (you should use NOLOCK if you are monitoring a
  105.  *                      file system process).
  106.  */
  107.  
  108. void DoArguments(argc,argv)
  109. int argc;
  110. char **argv;
  111. {
  112.    while (--argc)
  113.    {
  114.       argv++;
  115.       if (stricmp(*argv,"NODUMP") == 0)      Dump_OK = FALSE;
  116.       else if (stricmp(*argv,"DUMP") == 0)   Dump_OK = TRUE;
  117.       else if (stricmp(*argv,"NOLOCK") == 0) Lock_OK = FALSE;
  118.       else if (stricmp(*argv,"LOCK") == 0)   Lock_OK = TRUE;
  119.       else
  120.       {
  121.          printf("Bad Argument:  '%s'\n",*argv);
  122.          printf("Usage:  MONPROC [NO]DUMP [NO]LOCK\n");
  123.          exit(5);
  124.       }
  125.    }
  126. }
  127.  
  128.  
  129. /*
  130.  *  GetProcToMonitor()
  131.  *
  132.  *  Lists the processes currently running and lets the user choose one.
  133.  *  Returns a pointer the the chosen process.
  134.  */
  135.  
  136. struct Process *GetProcToMonitor()
  137. {
  138.    struct List           ProcList;
  139.    struct Node           *theProc;
  140.    struct Process        *ChosenProcess = NULL;
  141.    ULONG                 count,choice;
  142.    char                  s[80];
  143.  
  144. /*
  145.  *  Set up ProcList and a list header and read the process list into it
  146.  *  (we assume the process list won't change).
  147.  */
  148.    NewList(&ProcList);
  149.    GetProcList(&ProcList);
  150.  
  151. /*
  152.  *  If there are any processes, list them and let the user chose one by 
  153.  *  number.  If he choses a legal number, find the process in the list
  154.  *  and return a pointer to the process structure for that process.
  155.  *  Finally, free the process list.
  156.  */
  157.    if (ProcList.lh_TailPred == PTR(Node,&ProcList))
  158.    {
  159.       printf("No Processes.\n");
  160.    } else {
  161.       do
  162.       {
  163.          printf("\nEnter NUMBER for process to monitor:\n"); 
  164.          printf("Pick# Process  MsgPort  Name\n");    
  165.          for (count=1,theProc=ProcList.lh_Head;    /* start at the list head */
  166.               theProc->ln_Succ;                    /* while there are more */
  167.               theProc=theProc->ln_Succ,count++)    /* go on to the next */
  168.          {
  169.             printf("%4ld. %08lX %08lX %s\n",count,
  170.                theProc->ln_Name,
  171.                &(PTR(Process,theProc->ln_Name)->pr_MsgPort),
  172.                PTR(Process,theProc->ln_Name)->pr_Task.tc_Node.ln_Name);
  173.          }
  174.          printf("\nNUMBER: ");
  175.          gets(s);
  176.       } while (sscanf(s,"%ld",&choice) != 1);
  177.   
  178.       if (choice < 1 || choice >= count)
  179.       {
  180.          printf("Operation Aborted.\n");
  181.       } else {
  182.          for (count=1,theProc=ProcList.lh_Head;
  183.               count < choice;
  184.               theProc=theProc->ln_Succ,count++);
  185.          ChosenProcess = PTR(Process,theProc->ln_Name);
  186.       }
  187.       FreeProcList(&ProcList);
  188.    }
  189.    return(ChosenProcess);
  190. }
  191.  
  192.  
  193. /*
  194.  *  SetupSignal()
  195.  *
  196.  *  Allocate a signal to use for our inter-task communication, and
  197.  *  set up the mask for using it.
  198.  */
  199.  
  200. void SetupSignal(theSignal)
  201. LONG *theSignal;
  202. {
  203.    *theSignal = AllocSignal(-ONE);
  204.    if (*theSignal == -ONE)
  205.    {
  206.       printf("Can't Allocate a Task Signal.");
  207.       exit(10);
  208.    }
  209.    WaitMask = (ONE << (*theSignal));
  210. }
  211.  
  212.  
  213. /*
  214.  *  SetupProcess()
  215.  *
  216.  *  Copy the process name, and gets it Message port.  Set our priority
  217.  *  higher than the monitored process so we will be able to react to its
  218.  *  signals.  Then set the pr_PktWait field so that we begin monitoring 
  219.  *  the other task.  Save the old one so we can put it back.
  220.  */
  221.  
  222. void SetupProcess(theProcess,name)
  223. struct Process *theProcess;
  224. char *name;
  225. {
  226.    strcpy(name,theProcess->pr_Task.tc_Node.ln_Name);
  227.    thePort = &theProcess->pr_MsgPort;
  228.  
  229.    Forbid();
  230.    SetTaskPri(myProcess,(ULONG)(theProcess->pr_Task.tc_Node.ln_Pri + 1)); 
  231.    OldPktWait = theProcess->pr_PktWait;
  232.    theProcess->pr_PktWait = (APTR) PWait;
  233.    Permit();
  234. }
  235.  
  236.  
  237. /*
  238.  *  MonitorProcess()
  239.  *
  240.  *  Wait for the monitored process to receive a message (our PacketWait()
  241.  *  function signals us via theSignal when it has received a message), then
  242.  *  print out the contents of the message.  A semaphore is used to coordinate
  243.  *  this routine with the PacketWait() routine (which is run asynchonously
  244.  *  by the monitored process).  Phillip Lindsay says "there are probably a
  245.  *  hundred better was of doing this.  I just went with the first one [that]
  246.  *  came to mind."  I couldn't think of a better one, so I still use it.
  247.  *  Since our process is running at a higher priority than the monitored one,
  248.  *  we should obtain the semaphore first.  The other process wil block until
  249.  *  we release it (when we are done printing the contents).
  250.  */
  251.  
  252. void MonitorProcess(name,theSignal)
  253. char *name;
  254. ULONG theSignal;
  255. {
  256.    ULONG                signals;
  257.    struct DosPacket     *thePacket;
  258.  
  259.    do 
  260.    {
  261.       signals = Wait(SIGBREAKF_CTRL_C | WaitMask); 
  262.       ObtainSemaphore(&CanReturn); 
  263.       if (signals & WaitMask)
  264.       {
  265.          /*
  266.           *  PacketWait() signalled us so print the message it put in
  267.           *  theMessage.
  268.           */
  269.          thePacket = PTR(DosPacket,theMessage->mn_Node.ln_Name);
  270.          printf("\n%s: ",name);     
  271.          PrintPkt(thePacket);
  272.       }
  273.       ReleaseSemaphore(&CanReturn);
  274.    } while(!(signals & SIGBREAKF_CTRL_C)); 
  275. }
  276.  
  277.  
  278. /*
  279.  *  ClenUpProcess()
  280.  *
  281.  *  Put everything back the way we found it, except that the monitored process
  282.  *  is still running our code...
  283.  */
  284.  
  285. void CleanUpProcess(theProcess)
  286. struct Process *theProcess;
  287. {
  288.    Forbid();
  289.    theProcess->pr_PktWait = OldPktWait;
  290.    Permit();
  291.    SetTaskPri(myProcess,0L);
  292. }
  293.  
  294.  
  295. /*
  296.  *  WaitForLastPacket()
  297.  *
  298.  *  Since the monitored process is still running our PacketWait() code, we
  299.  *  can't quit yet.  Since we already put back the old pr_PktWait pointer,
  300.  *  our code will not be called after the next packet is received, so we have
  301.  *  to wait for one more packet before we can quit.  Note that PacketWait()
  302.  *  will still signal us, so we know when it will be safe to remove the code.
  303.  *  Just in case we goof, let CTRL-E cancel, too.
  304.  */
  305.  
  306. void WaitForLastPacket(theSignal)
  307. ULONG theSignal;
  308. {
  309.    ULONG signals;
  310.  
  311.    printf("\nThe process must receive another message before we can safely\n");
  312.    printf("remove the packet wait code.  We will wait for one more packet.\n");
  313.    printf("Press CTRL-E if you want to quit early, but that will likely\n");
  314.    printf("crash the monitored process!\n");
  315.  
  316.    signals = Wait(SIGBREAKF_CTRL_E | WaitMask);
  317.    if (signals & WaitMask)
  318.    {
  319.       ObtainSemaphore(&CanReturn);
  320.       ReleaseSemaphore(&CanReturn);
  321.    }
  322. }
  323.  
  324. void main(argc,argv)
  325. int argc;
  326. char **argv;
  327. {
  328.    struct Process    *ChosenProcess;
  329.    LONG              TaskSignal;
  330.    UBYTE             ProcessName[81];
  331.    
  332.    if (argc > 1) DoArguments(argc,argv);
  333.  
  334.    printf("\n%s - monitor AmigaDOS process packet activity.\n",*argv);
  335.  
  336.    myProcess = FindTask(NULL);
  337.    ChosenProcess = GetProcToMonitor();
  338.    if (ChosenProcess != NULL)
  339.    {
  340.       #ifndef MANX
  341.          onbreak(&Ctrl_C);    /* Turn off CTRL-C for Lattice:  we do our own */
  342.       #endif
  343.  
  344.       SetupSignal(&TaskSignal);
  345.       InitSemaphore(&CanReturn);
  346.       SetupProcess(ChosenProcess,ProcessName);
  347.       printf("Monitor Installed, press CTRL-C to quit monitoring\n"); 
  348.    
  349.       MonitorProcess(ProcessName,TaskSignal);
  350.       
  351.       CleanUpProcess(ChosenProcess);
  352.       WaitForLastPacket(TaskSignal);
  353.       FreeSignal(TaskSignal);
  354.  
  355.       printf("\nAll done.\n");
  356.    }
  357. }
  358.  
  359.  
  360. /*
  361.  *  This code stub has been known to save lives... 
  362.  */
  363.  
  364. #if MANX        
  365. #asm
  366.         XREF _PacketWait
  367.  
  368.         XDEF _PWait
  369. _PWait:
  370.         movem.l a2/a3/a4,-(sp)
  371.         jsr _PacketWait
  372.         movem.l (sp)+,a2/a3/a4
  373.         rts
  374. #endasm
  375. #endif
  376.