GEMini Atari/GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso/files/mint/mntutl93/ps.c

C/C++ Source or Header | 1993-08-03 | 4.9 KB | 192 lines

/*

  ps.c: a program to print MiNT process statuses


  Coded: 3/24/1991 by Tony Reynolds, [e-mail]
  For use with: MiNT release 0.7
  Updated: 3/29/1991 by Eric Smith for MiNT version 0.8
  Updated again 8/9/1991 by ERS for MiNT 0.9.
  Updated some more 11/91 by AKP (shows process time in fractions of a sec).
*/

#include <stdio.h>
#include <osbind.h>
#include <errno.h>
#include <basepage.h>
#include <ioctl.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

#ifndef PCTXTSIZE
#define PCTXTSIZE (('P'<<8) | 3)
#endif

#define ulong unsigned long

struct status {   /* defines values for internal->external process states */
  int mint;       /* what MiNT knows */
  char desc[10];  /* a textual description for above */
} proc_stat[] = {
  0,    "Ready",
  0x01, "Ready",
  0x20, "Wait ",
  0x21, "Sleep",
  0x22, "Exit ",
  0x02, "TSR  ",
  0x24, "Stop ",
  -1,    "Unkn "
 };   /* initialized from data in procfs.c */

extern int __mint;

typedef struct _context {
    long    regs[15];    /* registers d0-d7, a0-a6 */
    long    usp;        /* user stack pointer (a7) */
    short    sr;        /* status register */
    long    pc;        /* program counter */
    long    ssp;        /* supervisor stack pointer */
    long    term_vec;    /* GEMDOS terminate vector (0x102) */

/* these fields were added in MiNT 0.9 */
    char    fstate[216];    /* FPU internal state */
    char    fregs[12*8];    /* registers fp0-fp7 */
    long    fctrl[3];        /* FPCR/FPSR/FPIAR */
    short    sfmt;            /* stack frame format identifier */
    long    iar;            /* instruction address */
    short    internal[4];    /* four words of internal info */
} CONTEXT;

struct pinfo {
    long    magic;
    char    *base;
    short    pid, ppid, pgrp;
    short    ruid, rgid;
    short    euid, egid;
    short    memflags;
    short    pri;
    short    wait_q;
    long    wait_cond;
    /* (all times are in milliseconds) */
    ulong    systime;        /* time spent in kernel        */
    ulong    usrtime;        /* time spent out of kernel    */
    ulong    chldstime;        /* children's kernel time     */
    ulong    chldutime;        /* children's user time        */

    ulong    maxmem;            /* max. amount of memory to use */
    ulong    maxdata;        /* max. data region for process */
    ulong    maxcore;        /* max. core memory for process */
    ulong    maxcpu;            /* max. cpu time to use     */

    short    domain;            /* process domain (TOS or MiNT)    */
    short    curpri;            /* current priority (nice)    */
};

/* open the process named "name" */
int
open_proc(name)
  char *name;
{
  static char pname[] = "u:\\proc\\xxxxxxxx.xxx";

  strcpy(pname+8, name);
  return open(pname, 0);
}

void
main(argc, argv)
  int argc;
  char **argv;
{

  _DTA mydta;
  int fd;
  int fserror=0;
  long place;
  short pid, ppid, pri, curpri;
  char *cmdline;
  struct status *statp;
  long ctxtsize;
  BASEPAGE bpage;        /* process basepage read in here if possible */
  struct pinfo proc;        /* process info read in here */
  long ptime;
  long hour, min, sec, frac;

  Fsetdta(&mydta);          /* give the OS my new DTA */

  fserror=Fsfirst("u:\\proc\\*.*", 0x27);
  if (fserror < 0) {
    fprintf(stderr, "ps: cannot list processes, MiNT may not be running\n");
    exit(1);
  }

  printf("PID  PPID PRI CURPRI STATUS   SIZE    TIME    COMMAND\n");

  /* okay, now run the Fsnext bit through the wringer */

  fserror = E_OK;       /* set up for the loop */

  while (fserror == E_OK ) {
    fd = open_proc(mydta.dta_name);

    for (cmdline = mydta.dta_name; *cmdline && *cmdline != '.'; cmdline++) ;
    *cmdline = 0;

    if (fd < 0) goto next;

    ioctl(fd, PPROCADDR, &place);
    if (ioctl(fd, PCTXTSIZE, &ctxtsize) < 0) {
    lseek(fd, place+4+2*sizeof(CONTEXT), 0);
    } else
        lseek(fd, place, 0);
    read(fd, &proc, sizeof(proc));
    if ((pid = proc.pid) < 0) pid = 0;
    if ((ppid = proc.ppid) < 0) ppid = 0;
    pri = proc.pri;
    curpri = proc.curpri;
    ptime = proc.systime + proc.usrtime;
    hour = (ptime/1000/60/60);
    min = (ptime/1000/60)%60;
    sec = (ptime/1000)%60;
    frac = (ptime%1000) / 10;    /* (never anything in .001 digit) */

    ioctl(fd, PBASEADDR, &place);
    lseek(fd, place, 0);
    read(fd, &bpage, sizeof(bpage));
    cmdline = bpage.p_cmdlin;
    if (*cmdline) *cmdline = ' ';
    close(fd);

    statp = proc_stat;      /* hunt down string referring to
                   process status */
    while (statp->mint != mydta.dta_attribute &&
       statp->mint >= 0) statp++;

/*        PID  PPID PRI CURPRI STATUS   SIZE     TIME   COMMAND */
    if (hour) {
    printf("%03d  %03d %3d   %3d  %s  %8ld %02ld:%02ld:%02ld  %s%s\n",
        pid, ppid, pri, curpri, statp->desc,
        mydta.dta_size,
        hour,
        min,
        sec,
        mydta.dta_name,
        cmdline);
    }
    else {
    printf("%03d  %03d %3d   %3d  %s  %8ld %02d:%02d.%02d  %s%s\n",
        pid, ppid, pri, curpri, statp->desc,
        mydta.dta_size,
        min,
        sec,
        frac,
        mydta.dta_name,
        cmdline);
    }
next:
    fserror = Fsnext();
  }
  exit(0);
}