void bless_procs(struct procsinfo64 *procs, int count)
{

	int index;
	char cmndline[ARG_MAX];
	char comm[ARG_MAX];
	char pctmem[PCT_LENGTH];
	char pctcpu[PCT_LENGTH];
	char state[STATE_LENGTH];
	char *c = NULL;
	struct procsinfo64 *curproc = NULL;
    struct procsinfo curproc_for_getargs;
	int zombie;
	int done;
	long utime, stime, cutime, cstime;

    /* initialize */
    Zero(&curproc_for_getargs, 1, struct procsinfo);

	for( index = 0, curproc = procs; index < count; index++, curproc = procs+index ) {

		/* reset char fields */
		memset(cmndline, 0, ARG_MAX);
		memset(comm, 0, ARG_MAX);
		memset(pctmem, 0, PCT_LENGTH);
		memset(pctcpu, 0, PCT_LENGTH);
		memset(state, 0, STATE_LENGTH);

		/* skip procs with a state of NONE */
		if( curproc->pi_state == SNONE ) {
			continue;
		}

		/* copy the format into something we can use */
		strcpy(format, Defaultformat);

		/* presume we are not a zombie */
		zombie = 0;

		/* set a descriptive name for the process state */
		switch( curproc->pi_state ) {

			case SSLEEP:
					strcpy(state, SLEEP);
					break;

			case SRUN:
					strcpy(state, RUN);
					break;

			case SIDL:
					strcpy(state, IDLE);
					break;

			case SZOMB:
					strcpy(state, ZOMBIE);
					zombie = 1;
					break;

			case SSTOP:
					strcpy(state, STOP);
					break;

			case SACTIVE:
					strcpy(state, ACTIVE);
					break;

			default:
					format[F_STAT] = 'S';
					break;

		}

		/* calc utime, stime, cutime, cstime */
		if( zombie ) {
			utime = curproc->pi_utime;
			stime = curproc->pi_stime;
		} else {
			utime = TVALN_TO_SEC(curproc->pi_ru.ru_utime);
			stime = TVALN_TO_SEC(curproc->pi_ru.ru_stime);
			cutime = TVALN_TO_SEC(curproc->pi_cru.ru_utime);
			cstime = TVALN_TO_SEC(curproc->pi_cru.ru_stime);
		}

		/* calc pctcpu */
		sprintf(pctcpu, "%3.2f", ((utime + stime) * 100 /
                                  ( now_time - curproc->pi_start )) / ncpus );

		/* calc pctmem */
		if( memory == 0 ) {
			format[F_PCTMEM] = 'S';
		} else {
			sprintf(pctmem, "%3.2f", (curproc->pi_drss + curproc->pi_trss) * pagesize * 100 / (float)memory);
		}

		/* determine comm & cmndline */
		if( (curproc->pi_flags & SKPROC) == SKPROC ) {
			if( curproc->pi_pid == 0 ) {
				snprintf(comm, ARG_MAX, "kproc (swapper)");
				snprintf(cmndline, ARG_MAX, "kproc (swapper)");
			} else {
				snprintf(comm, ARG_MAX, "kproc (%s)", curproc->pi_comm);
				snprintf(cmndline, ARG_MAX, "kproc (%s)", curproc->pi_comm);
			}
		} else {
			snprintf(comm, ARG_MAX, "%s", curproc->pi_comm);
            curproc_for_getargs.pi_pid = curproc->pi_pid;
			if( getargs(&curproc_for_getargs, sizeof(struct procsinfo), cmndline, ARG_MAX) < 0 ) {
				snprintf(cmndline, ARG_MAX, "%s", curproc->pi_comm);
			} else {
				/* replace NUL characters in command line with spaces */
				c = cmndline;
				done = 0;
				while( ! done ) {
					if( *c == '\0' ) {
						if( *(c+1) == '\0' ) {
							done = 1;
						} else {
							*c++ = ' ';
						}
					} else {
						c++;
					}
				}
			}
		}

		/* sanity check: bless_into_procs doesn't like negative ints */
		if( curproc->pi_cred.cr_uid == -1 ) {
			format[F_EUID] = 'I';
			curproc->pi_cred.cr_uid = 0;
		}
		if( curproc->pi_ttyd == -1 ) {
			format[F_TTYNUM] = 'I';
			curproc->pi_ttyd = 0;
		}
		if( curproc->pi_ttympx == -1 ) {
			format[F_TTYMPX] = 'I';
			curproc->pi_ttympx = 0;
		}
		
		/* give it to Perl */
		bless_into_proc(format, Fields,
			curproc->pi_pid,		/* pid */
			curproc->pi_ppid,		/* ppid */
			curproc->pi_sid,		/* sess */
			curproc->pi_pgrp,		/* pgrp */
			curproc->pi_uid,		/* uid */
			curproc->pi_suid,		/* suid */
			curproc->pi_cred.cr_luid,	/* luid */
			curproc->pi_cred.cr_uid,	/* euid */
			curproc->pi_cred.cr_rgid,	/* gid */
			curproc->pi_cred.cr_gid,	/* egid */
			curproc->pi_pri,		/* priority */
			curproc->pi_nice,		/* nice */
			curproc->pi_thcount,	/* thcount */
			state,
			curproc->pi_flags,		/* flags */
			curproc->pi_flags2,		/* flags2 */
			curproc->pi_adspace,	/* adspace */
			curproc->pi_majflt,		/* majflt */
			curproc->pi_minflt,		/* minflt */
			(long)(utime * 100),	/* utime */
			(long)(stime * 100),	/* stime */
			(long)(cutime * 100),	/* cutime */
			(long)(cstime * 100),	/* cstime */
			curproc->pi_start,		/* start */
			curproc->pi_size,		/* size */
			curproc->pi_tsize,		/* tsize */
			curproc->pi_ttyp,		/* ttyp */
			curproc->pi_ttyd,		/* ttynum */
			curproc->pi_ttympx,		/* ttympx */
			curproc->pi_drss,		/* drss */
			curproc->pi_trss,		/* trss */
			curproc->pi_dvm,		/* dvm */
			pctmem,					/* pctmem */
			pctcpu,					/* pctcpu */
			comm,					/* comm */
			cmndline				/* cmndline */
		);
	}

}
void OS_get_table() {
  int                  i, proc_nb;
  struct procinfo      pr_buff[MAX_PROCS];
  struct userinfo      uinfo;
  char                 format[F_FLAST + 1];
  char                 wchan[15], pctcpu[7], pctmem[7], state[10];
  char                 Args[MAXARGLN+1], Arglist[MAXARGLN+1], Comm[MAXARGLN+1];
  int                  argcount;
  struct timeval       now_tval;
  double               utime, stime, cutime, cstime, now;
  
  
  strcpy(format, Fullformat);
  
  proc_nb = getproc(pr_buff, MAX_PROCS, sizeof(struct procinfo));
  
  gettimeofday(&now_tval, (void *)NULL);
  now = (double)now_tval.tv_sec + (double) now_tval.tv_usec / 1000000.0;
  
  for(i=0; i<proc_nb; i++) {
    
    if ( pr_buff[i].pi_wchan != NULL ) {
      sprintf(wchan, "%p", pr_buff[i].pi_wchan);
    }
    
    if ( pr_buff[i].pi_stat == SNONE ) {
      continue;
    }
    
    
    switch (pr_buff[i].pi_stat){
    case SSLEEP :
      strcpy(state, SLEEP);
      break;
    case SRUN :
      strcpy(state, RUN);
      break;
    case SIDL :
      strcpy(state, IDLE);
      break;
    case SZOMB :
      strcpy(state, ZOMBIE);
      break;
    case SSTOP :
      strcpy(state, STOP);
      break;
    case SACTIVE :
      strcpy(state, ACTIVE);
      break;
    default:
      format[F_STAT] = 'S';
    }

    
    if ( state == ZOMBIE 
	 || getuser(&pr_buff[i], sizeof(struct procinfo),
		    &uinfo,      sizeof(struct userinfo) ) < 0 ) {
      
      bless_into_proc( Zombformat,
		       ZombFields,
		       pr_buff[i].pi_pid,
		       pr_buff[i].pi_ppid,
		       pr_buff[i].pi_sid,
		       pr_buff[i].pi_pgrp,
		       pr_buff[i].pi_uid,
		       pr_buff[i].pi_suid,
		       pr_buff[i].pi_pri,
		       pr_buff[i].pi_nice,
		       pr_buff[i].pi_cpu,
		       /* pr_buff[i].pi_stat, */
		       state,
		       pr_buff[i].pi_flag,
		       wchan,
		       pr_buff[i].pi_wtype,
		       pr_buff[i].pi_adspace,
		       pr_buff[i].pi_majflt,
		       pr_buff[i].pi_minflt,
		       pr_buff[i].pi_utime,
		       pr_buff[i].pi_stime,
		       pr_buff[i].pi_size * PageSize );
      
      continue;
    } 
    
    /*
     * Command line args processing
     * 
     */

    Args[0] = '\0';

    if ( pr_buff[i].pi_flag & SKPROC ) {
      if ( pr_buff[i].pi_pid == 0 ) {
	strcpy(Args, "kproc (swapper)");
	strcpy(Comm, "kproc (swapper)");
      }
      else {
	sprintf(Args, "kproc (%s)", uinfo.ui_comm);
	sprintf(Comm, "kproc (%s)", uinfo.ui_comm);
      }
    }
    else {
      strncpy(Comm, uinfo.ui_comm, MAXARGLN);
      Comm[MAXARGLN] = '\0';
      if (getargs(&pr_buff[i], sizeof(struct procinfo), Arglist, MAXARGLN) < 0) {
	sprintf(Args, "%s", uinfo.ui_comm);
      }
      else {
	/* Returns a succession of strings seperated by a null
           characters, 2 nulls for the end (see getargs info/man page) */
	argcount = -1;
	while (++argcount < MAXARGLN) {
	  /* Copy everything but replace the end of the arg with a
             space */
	  if (Arglist[argcount] != '\0') {
	    Args[argcount] = Arglist[argcount];
	  }
	  else {
	    /* Is this the last arg, then hop out of the loop */
	    if (Arglist[argcount+1] == '\0') {
	      /* Terminate the arguments */
	      Args[argcount] = '\0';
	      break;
	    }
	    /* Seperate arguments with a space */
	    Args[argcount] = ' ';
	  }
	}
      }
    }
    
    
    /*
     * Convert time values into seconds
     * 
     */

    
    utime = uinfo.ui_ru.ru_utime.tv_sec + 
            (double) uinfo.ui_ru.ru_utime.tv_usec / 1000000.0;
    
    stime = uinfo.ui_ru.ru_stime.tv_sec + 
            (double) uinfo.ui_ru.ru_stime.tv_usec / 1000000.0;

    cutime = uinfo.ui_cru.ru_utime.tv_sec + 
            (double) uinfo.ui_cru.ru_utime.tv_usec / 1000000.0;
    
    cstime = uinfo.ui_cru.ru_stime.tv_sec + 
            (double) uinfo.ui_cru.ru_stime.tv_usec / 1000000.0;

    /*
     * percentage calculation
     * 
     */
        
    pctcpu[0] = pctmem[0]= '\0';      
/* compute %CPU in SMP environment */    
    sprintf( pctcpu, 
	     "%3.2f",
	     ((utime + stime ) * 100 / ( now - uinfo.ui_start )) / ProcessNumber );
    
    if ( Sysmem == 0 ) {
      format[F_PRM] = 'S';
    }
    else {
      sprintf( pctmem,
	       "%3.2f",
	       (uinfo.ui_drss + uinfo.ui_trss) * PageSize * 100 / 
	       (float)Sysmem );
    }


    /*
     * Give it all to Perl
     * (we convert time values to hundredth of a second
     *  to keep in sync with the Linux version )
     */
    
    bless_into_proc( format,
		     FullFields,
		     pr_buff[i].pi_pid,
		     pr_buff[i].pi_ppid,
		     pr_buff[i].pi_sid,
		     pr_buff[i].pi_pgrp,
		     pr_buff[i].pi_uid,
		     pr_buff[i].pi_suid,
		     pr_buff[i].pi_pri,
		     pr_buff[i].pi_nice,
		     /* pr_buff[i].pi_cpu,  */
		     pctcpu,
		     /* pr_buff[i].pi_stat, */
		     state,
		     pr_buff[i].pi_flag,
		     wchan,
		     pr_buff[i].pi_wtype,
		     pr_buff[i].pi_adspace,
		     pr_buff[i].pi_majflt,
		     pr_buff[i].pi_minflt,
		     ((pr_buff[i].pi_size * PageSize) - uinfo.ui_tsize)/1024,
		     uinfo.ui_luid,
		     uinfo.ui_uid,
		     uinfo.ui_gid,
		     uinfo.ui_start,
		     (long) (utime  * 100),
		     (long) (stime  * 100),
		     (long) (cutime * 100),
		     (long) (cstime * 100),
		     uinfo.ui_tsize/1024,
		     uinfo.ui_ttyp,
		     uinfo.ui_ttyd,
		     uinfo.ui_ttympx,
		     ((uinfo.ui_drss + uinfo.ui_trss) * PageSize)/1024,
		     (uinfo.ui_trss * PageSize)/1024,
		     uinfo.ui_dvm,
		     /* uinfo.ui_prm,*/
		     pctmem,
		     Comm,
                     Args ); 
    
  } 
  
}
void OS_get_table()
{
    /* dir walker storage */
    DIR             *dir;
    struct dirent   *dir_ent, *dir_result;
    
    /* all our storage is going to be here */
    struct obstack  mem_pool;
    
    /* container for scaped process values */
    struct procstat *prs;

    /* string containing our local copy of format_str, elements will be
     * lower cased if we are able to figure them out */
    char            *format_str;

    /* initlize a small memory pool for this function */
    obstack_init(&mem_pool);

    /* put the dirent on the obstack, since it's rather large */
    dir_ent = obstack_alloc(&mem_pool, sizeof(struct dirent));

    if ((dir = opendir("/proc")) == NULL)
        return;

    /* Iterate through all the process entries (numeric) under /proc */
    while(readdir_r(dir, dir_ent, &dir_result) == 0 && dir_result) {

        /* Only look at this file if it's a proc id; that is, all numbers */
        if(!is_pid(dir_result->d_name))
            continue;

        /* allocate container for storing process values */
        prs = obstack_alloc(&mem_pool, sizeof(struct procstat));
        bzero(prs, sizeof(struct procstat));

        /* intilize the format string */
        obstack_printf(&mem_pool, get_string(STR_DEFAULT_FORMAT));
        obstack_1grow(&mem_pool, '\0');
        format_str = (char *) obstack_finish(&mem_pool);

        /* get process' uid/guid */
        get_user_info(dir_result->d_name, format_str, prs, &mem_pool);

        /* scrape /proc/${pid}/stat */
        if (get_proc_stat(dir_result->d_name, format_str, prs, &mem_pool) == false) {
            /* did the pid directory go away mid flight? */
            if (pid_exists(dir_result->d_name, &mem_pool) == false)
                continue;
        }

        /* correct values (times) found in /proc/${pid}/stat */
        fixup_stat_values(format_str, prs);

		/* get process' cmndline */
		get_proc_cmndline(dir_result->d_name, format_str, prs, &mem_pool);

        /* get process' cwd & exec values from the symblink */
        eval_link(dir_result->d_name, "cwd", F_CWD, &prs->cwd, format_str,
            &mem_pool);
        eval_link(dir_result->d_name, "exe", F_EXEC, &prs->exec, format_str,
            &mem_pool);

        /* scapre from /proc/{$pid}/status */
        get_proc_status(dir_result->d_name, format_str, prs, &mem_pool);

		/* calculate precent cpu & mem values */
		calc_prec(format_str, prs, &mem_pool);

        /* Go ahead and bless into a perl object */
        bless_into_proc(format_str, field_names,
            prs->uid,			
            prs->gid,			
            prs->pid,			
            prs->comm,			
            prs->ppid,			
            prs->pgrp,			
            prs->sid,			
            prs->tty,			
            prs->flags,			
            prs->minflt,		
            prs->cminflt,		
            prs->majflt,		
            prs->cmajflt,		
            prs->utime,			
            prs->stime,			
            prs->cutime,		
            prs->cstime,		
            prs->priority,		
            prs->start_time,	
            prs->vsize,			
            prs->rss,			
            prs->wchan,			
	    prs->time,			
	    prs->ctime,			
            prs->state,			
            prs->euid,
            prs->suid,
            prs->fuid,
            prs->egid,
            prs->sgid,
            prs->fgid,
            prs->pctcpu,
            prs->pctmem,
            prs->cmndline,
            prs->exec,
            prs->cwd
        );

        /* we want a new prs, for the next itteration */
        obstack_free(&mem_pool, prs);
    }
    
    closedir(dir);

    /* free all our tempoary memory */
    obstack_free(&mem_pool, NULL);
}
Exemple #4
0
void OS_get_table() {
  kvm_t *kd;
  char errbuf[_POSIX2_LINE_MAX];
  struct kinfo_proc *procs;          /* array of processes */
  int count;                         /* returns number of processes */
  int i, j;
  int seconds, minutes, secleft;     /* for time[20] */
  int milsec, shortmsec;             /* for miliseconds of time[20] */      
  int ttynum;
  long start;
  char *ttydev;
  static time_t now;                 /* for started[20] */
  struct tm *tp;                     /* for month/day/hour/min/AM/PM fields of started[20] */
  int SECSPERHOUR = 3600;
  int SECSPERDAY = 24 * 3600;
  pid_t sesid;
  int length;
  char cmndline[MAXARGLN+1];
  char ** argv;

  /* for bless_into_proc */
  static char format[F_LASTFIELD + 1];
  
  /* variables to hold some values for bless_into_proc */
  char state[20];
  char cputime[20];
  char started[20];
  char session[20];
  char shortsess[20];

  /* Open the kvm interface, get a descriptor */
  if ((kd = kvm_open(NULL, NULL, NULL, 0, errbuf)) == NULL) {
    /* fprintf(stderr, "kvm_open: %s\n", errbuf); */
    ppt_croak("kvm_open: ", errbuf);
  }  
 
  /* Get the list of processes. */
  if ((procs = kvm_getprocs(kd, KERN_PROC_ALL, 0, &count)) == NULL) {
	kvm_close(kd);
    /* fprintf(stderr, "kvm_getprocs: %s\n", kvm_geterr(kd)); */
    ppt_croak("kvm_getprocs: ", kvm_geterr(kd));
  }

  /* Iterate through the processes in kinfo_proc, sending proc info */
  /* to bless_into_proc for each proc */
  for (i=0; i < count; i++) {
    static struct pstats ps;
    static struct session seslead;
    strcpy(format, Defaultformat);
	
    /* get ttydev */
    ttynum=procs[i].kp_eproc.e_tdev;
    ttydev=devname(ttynum, S_IFCHR);
    if (ttydev == NULL) ttydev = "??";

    /* get the state of processes */
    switch (procs[i].kp_proc.p_stat) 
      {
      case SIDL:
        strcpy(state, IDLE);
        break;
      case SRUN:
        strcpy(state, RUN);
        break;
      case SSLEEP:
        strcpy(state, SLEEP);
        break;
      case SSTOP:
        strcpy(state, STOP);
        break;
      case SZOMB: 
        strcpy(state, ZOMBIE);
        break;
      default:
        strcpy(state, UNKNOWN);
        break;
      }

    /* get the cpu time of processes */
    seconds=procs[i].kp_proc.p_rtime.tv_sec;
    milsec=procs[i].kp_proc.p_rtime.tv_usec;
    shortmsec=roundit(milsec);  

    if (seconds < 60) {
      if (seconds < 10)
        sprintf(cputime, "0:0%d.%d", seconds, shortmsec);
      else
        sprintf(cputime, "0:%d.%d", seconds, shortmsec);
    }
    else {
      minutes=seconds/60;
      secleft=seconds-(minutes * 60);
      if (secleft < 10)
        sprintf(cputime, "%d:0%d.%d", minutes, secleft, shortmsec);
      else
        sprintf(cputime, "%d:%d.%d", minutes, secleft, shortmsec);
    }

    /* get the start time of process (when started) */
    /* fill the pstats struct using kvm_read */
    if (kvm_read(kd, (u_long)procs[i].kp_proc.p_stats, (char *)&ps, sizeof(ps)) == sizeof(ps)) {
      start=ps.p_start.tv_sec;
      tp=localtime(&start);
      if (!now)
        (void)time(&now);
      if (now - ps.p_start.tv_sec < 24 * SECSPERHOUR) {
        static char fmt[] = __CONCAT("%l:%", "M%p");
        (void)strftime(started, sizeof(started) - 1, fmt, tp);
      } 
      else if (now - ps.p_start.tv_sec < 7 * SECSPERDAY) {
        static char fmt[] = __CONCAT("%a%", "I%p");
        (void)strftime(started, sizeof(started) - 1, fmt, tp);
      } 
      else
        (void)strftime(started, sizeof(started) - 1, "%e%b%y", tp);
    }

    /* get the session ID (ie: session pointer ID) */
    sprintf(session, "%x", (u_long)procs[i].kp_eproc.e_sess);   
    length=strlen(session);
    for (j=0; j < length; j++) {
      if (session[1] == '1') 
        shortsess[j]=session[j+1];
      else
        shortsess[j]=session[j+2];
    } 
    
    /* fill the session leader and proc struct using kvm_read */
    if (kvm_read(kd, (u_long)procs[i].kp_eproc.e_sess, (char *)&seslead, sizeof(seslead)) == sizeof(seslead)) {
      static struct proc leader; 
      if (kvm_read(kd, (u_long)seslead.s_leader, (char *)&leader, sizeof(leader)) == sizeof(leader)) {
        sesid=leader.p_pid;     
      }
    }

	/* retrieve the arguments */
	cmndline[0] = '\0';
	argv = kvm_getargv(kd, (const struct kinfo_proc *) &(procs[i]) , 0);
	if (argv) {
	  int j = 0;
	  while (argv[j] && strlen(cmndline) <= MAXARGLN) {
		strcat(cmndline, argv[j]);
		strcat(cmndline, " ");
		j++;
	  }
	}

    /* access everything else directly from the kernel, send it */
    /* into bless_into_proc */
    bless_into_proc( format,
                     Fields,
                     procs[i].kp_eproc.e_pcred.p_ruid,
                     procs[i].kp_eproc.e_pcred.p_rgid,
                     procs[i].kp_proc.p_pid,
                     procs[i].kp_eproc.e_ppid,
                     procs[i].kp_eproc.e_pgid,
                     procs[i].kp_proc.p_priority - PZERO,
                     shortsess,
                     sesid,
                     cputime,
                     procs[i].kp_eproc.e_wmesg,
                     procs[i].kp_proc.p_comm,
                     state,
                     started,
                     ttydev,
                     ttynum,
					 cmndline
                     );
  }
  if (kd) {
	kvm_close(kd);
  }
}
void OS_get_table() {
	kvm_t *kd;
	char errbuf[_POSIX2_LINE_MAX];
	struct kinfo_proc *procs;
	int count;
	int i, argcount;
	int ttynum;
	long start;
	char *ttydev;
	char cmndline[ARG_MAX+1];
	char **pargv;

	/* for bless_into_proc */
	static char format[F_LASTFIELD + 2];
	char state[20];

	/* open the kvm interface */
	if ((kd = kvm_open(NULL, NULL, NULL, KVM_NO_FILES, errbuf)) == NULL) {
		ppt_croak("kvm_open: %s", errbuf);
	}

	/* get processes */
	if ((procs = kvm_getprocs(kd, KERN_PROC_ALL, 0, sizeof(*procs), &count)) == NULL) {
		kvm_close(kd);
		ppt_croak("kvm_getprocs: %s", kvm_geterr(kd));
	}

	/* bless_into_proc each process's information */
	for (i=0; i < count; i++) {
		STRLCPY(1,format,Defaultformat);

		/* get ttydev */
		ttynum=procs[i].p_tdev;
		ttydev=devname(ttynum, S_IFCHR);
		if (ttydev == NULL) ttydev = "??";

		/* process state */
		switch (procs[i].p_stat) {
			case SIDL:
				STRLCPY(2,state,"IDLE");
				break;
			case SRUN:
				STRLCPY(3,state,"RUN");
				break;
			case SSLEEP:
				STRLCPY(4,state,"SLEEP");
				break;
			case SSTOP:
				STRLCPY(5,state,"STOP");
				break;
			case SZOMB:
				STRLCPY(6,state,"ZOMBIE");
				break;
			default:
				STRLCPY(7,state,"UNKNOWN");
				break;
		}

		/* arguments */
		cmndline[0] = '\0';
		pargv = kvm_getargv(kd, (const struct kinfo_proc *) &(procs[i]), 0);
		if (pargv) {
			argcount = 0;
			while (pargv[argcount] && strlen(cmndline)+strlen(pargv[argcount])+1 <= ARG_MAX) {
				STRLCAT(1,cmndline,pargv[argcount]);
				if (pargv[argcount+1]) {
					STRLCAT(2,cmndline," ");
				}
				argcount++;
			}
		}

		/* everything else is straightforward, bless the lot */
		bless_into_proc( format,
			Fields,
			ttynum,
			procs[i].p_ruid,
			procs[i].p_rgid,
			procs[i].p_uid,
			procs[i].p_gid,
			procs[i].p_pid,
			procs[i].p_ppid,
			procs[i].p__pgid,
			procs[i].p_sid,
			procs[i].p_rtime_sec,
			procs[i].p_uutime_sec,
			procs[i].p_ustime_sec,
			procs[i].p_ustart_sec,
			procs[i].p_comm,
			state,
			ttydev,
			cmndline
		);
	}
	if (kd) {
		kvm_close(kd);
	}
}
void OS_get_table()
{
    struct pst_status pst[BURST];

    int i, count;
    int idx = 0;
    char buff[256]; /* used to format %cpu which is the only float. */

    while ((count = pstat_getproc(pst, sizeof(pst[0]), BURST, idx)) > 0)
    {
        for (i = 0; i < count; i++)
        {
            sprintf(buff, "%f", pst[i].pst_pctcpu * 100);
            bless_into_proc(Format, Fields,
                            (long) pst[i].pst_uid,
                            (long) pst[i].pst_pid,
                            (long) pst[i].pst_ppid,
                            (long) pst[i].pst_dsize,
                            (long) pst[i].pst_tsize,
                            (long) pst[i].pst_ssize,
                            (long) pst[i].pst_nice,
                            (long) makedev(pst[i].pst_term.psd_major, pst[i].pst_term.psd_minor),
                            (long) pst[i].pst_pgrp,
                            (long) pst[i].pst_pri,
                            (long) pst[i].pst_addr,
                            (long) pst[i].pst_cpu,
                            (long) pst[i].pst_utime,
                            (long) pst[i].pst_stime,
                            (long) pst[i].pst_start,
                            (long) pst[i].pst_flag,
                            States[pst[i].pst_stat],
                            (long) pst[i].pst_wchan,
                            (long) pst[i].pst_procnum,
                            pst[i].pst_cmd,
                            pst[i].pst_ucomm,
                            (long) pst[i].pst_cptickstotal/100,
                            (long) pst[i].pst_cpticks,
                            (long) pst[i].pst_cptickstotal,
                            (long) pst[i].pst_fss,
                            buff,
                            (long) pst[i].pst_rssize,
                            (long) pst[i].pst_suid,
                            pst[i].pst_ucomm,
                            (long) pst[i].pst_shmsize,
                            (long) pst[i].pst_mmsize,
                            (long) pst[i].pst_usize,
                            (long) pst[i].pst_iosize,
                            (long) pst[i].pst_vtsize,
                            (long) pst[i].pst_vdsize,
                            (long) pst[i].pst_vssize,
                            (long) pst[i].pst_vshmsize,
                            (long) pst[i].pst_vmmsize,
                            (long) pst[i].pst_vusize,
                            (long) pst[i].pst_viosize,
                            (long) pst[i].pst_minorfaults,
                            (long) pst[i].pst_majorfaults,
                            (long) pst[i].pst_nswap,
                            (long) pst[i].pst_nsignals,
                            (long) pst[i].pst_msgrcv,
                            (long) pst[i].pst_msgsnd,
                            (long) pst[i].pst_maxrss,
                            (long) pst[i].pst_sid,
                            (long) pst[i].pst_schedpolicy,
                            (long) pst[i].pst_ticksleft,
                            "",
                            "",
                            "",
                            (long) pst[i].pst_highestfd,
                            (long) pst[i].pst_euid,
                            (long) pst[i].pst_egid,
                            (long) pst[i].pst_ioch,
                            "",
                            "",
                            "",
                            (long) pst[i].pst_gid,
                            (long) pst[i].pst_lwpid);
        }
        idx = pst[count-1].pst_idx + 1;
    }
}