short a_stat
, a_uid
, a_pid
, a_nice
;
/* F S UID PID PPID CP PRI NICE ADDR SZ RSS WCHAN TTY TIME */
/* USER PID %%CPU NICE SZ RSS TTY TIME */
/* F PID TT TIME TIM SL MINFLT MAJFLT SIZE RSS SRS TSIZ TRS PF*/
u_int v_minflt
, v_majflt
;
size_t v_swrss
, v_tsiz
, v_txtrss
, v_txtswrss
;
char upages
[UPAGES
][NBPG
];
#define clear(x) ((int)x & 0x7fffffff)
int aflg
, cflg
, gflg
, kflg
, lflg
, sflg
, uflg
, vflg
, xflg
;
char *gettty(), *getcmd(), *getname(), *savestr(), *alloc();
struct pte
*Usrptma
, *usrpt
;
} devl
[256], *cand
[16], *cons
;
struct savcom savcom
[NPROC
];
char *kmemf
, *memf
, *swapf
, *nlistf
;
while (*ap
) switch (*ap
++) {
procp
= nl
[X_PROC
].n_value
;
for (i
=0; i
<NPROC
; i
++) {
lseek(kmem
, (char *)procp
, 0);
if (read(kmem
, (char *)&mproc
, sizeof mproc
) != sizeof mproc
)
cantread("proc table", kmemf
);
if (mproc
.p_stat
== 0 || mproc
.p_pgrp
== 0 && xflg
== 0)
if (tptr
== 0 && gflg
== 0 && xflg
== 0 &&
mproc
.p_ppid
== 1 && (mproc
.p_flag
&SDETACH
) == 0)
if (uid
!= mproc
.p_uid
&& aflg
==0 ||
chkpid
!= 0 && chkpid
!= mproc
.p_pid
)
if (vflg
&& gflg
== 0 && xflg
== 0) {
if (mproc
.p_stat
== SZOMB
)
if (mproc
.p_slptime
> MAXSLP
&&
(mproc
.p_stat
== SSLEEP
|| mproc
.p_stat
== SSTOP
))
qsort(savcom
, npr
, sizeof(savcom
[0]), pscomp
);
register struct savcom
*sp
= &savcom
[i
];
else if (sp
->ap
->a_pid
== 2)
printf(" %.*s", twidth
- cmdstart
- 2, sp
->ap
->a_cmdp
);
kmemf
= argc
> 1 ? argv
[1] : "/vmcore";
swapf
= argc
>2 ? argv
[2]: "/dev/drum";
register struct nlist
*nlp
;
nlistf
= argc
> 3 ? argv
[3] : "/vmunix";
fprintf(stderr
, "%s: No namelist\n", nlistf
);
for (nlp
= nl
; nlp
< &nl
[sizeof (nl
)/sizeof (nl
[0])]; nlp
++)
nlp
->n_value
= clear(nlp
->n_value
);
Usrptma
= (struct pte
*)nl
[X_USRPTMA
].n_value
;
usrpt
= (struct pte
*)nl
[X_USRPT
].n_value
;
lseek(kmem
, (long)nl
[X_NSWAP
].n_value
, 0);
if (read(kmem
, &nswap
, sizeof (nswap
)) != sizeof (nswap
)) {
/*###287 [lint] read arg. 2 used inconsistently ps.c(41) :: ps.c(287)%%%*/
cantread("nswap", kmemf
);
/*###288 [lint] cantread arg. 1 used inconsistently ps.c(322) :: ps.c(288)%%%*/
/*###288 [lint] cantread arg. 2 used inconsistently ps.c(322) :: ps.c(288)%%%*/
text
= (struct text
*)alloc(NTEXT
* sizeof (struct text
));
fprintf(stderr
, "no room for text table\n");
lseek(kmem
, (long)nl
[X_TEXT
].n_value
, 0);
if (read(kmem
, text
, sizeof (text
)) != sizeof (text
)) {
/*###298 [lint] read arg. 2 used inconsistently ps.c(41) :: ps.c(298)%%%*/
cantread("text table", kmemf
);
/*###299 [lint] cantread arg. 1 used inconsistently ps.c(322) :: ps.c(299)%%%*/
/*###299 [lint] cantread arg. 2 used inconsistently ps.c(322) :: ps.c(299)%%%*/
if (sflg
+lflg
+vflg
+uflg
> 1) {
fprintf(stderr
, "ps: specify only one of s,l,v and u\n");
hdr
= lflg
? lhdr
: (vflg
? vhdr
: (uflg
? uhdr
: shdr
));
if (lflg
+vflg
+uflg
+sflg
== 0)
printf("%s COMMAND\n", hdr
);
fprintf(stderr
, "ps: error reading %s from %s", what
, fromwhat
);
if ((df
= fopen("/dev", "r")) == NULL
) {
fprintf(stderr
, "Can't open /dev\n");
while (fread((char *)&dbuf
, sizeof(dbuf
), 1, df
) == 1) {
if (stat(dbuf
.d_name
, &sbuf
) < 0)
if ((sbuf
.st_mode
&S_IFMT
) != S_IFCHR
)
strcpy(devl
[ndev
].dname
, dbuf
.d_name
);
devl
[ndev
].dev
= sbuf
.st_rdev
;
register struct savcom
*sp
;
register struct asav
*ap
;
if (mproc
.p_stat
!= SZOMB
&& getu() == 0)
if (tptr
&& strcmpn(tptr
, ttyp
, 2))
sp
->ap
= ap
= (struct asav
*)alloc(sizeof (struct asav
));
#define e(a,b) ap->a = mproc.b
e(a_flag
, p_flag
); e(a_stat
, p_stat
); e(a_nice
, p_nice
);
e(a_uid
, p_uid
); e(a_pid
, p_pid
); e(a_rss
, p_rssize
);
ap
->a_size
= mproc
.p_dsize
+ mproc
.p_ssize
;
ap
->a_tty
[1] = ttyp
[1] ? ttyp
[1] : ' ';
ap
->a_time
= u
.u_vm
.vm_utime
+ u
.u_vm
.vm_stime
;
register struct lsav
*lp
;
sp
->sun
.lp
= lp
= (struct lsav
*)alloc(sizeof (struct lsav
));
#define e(a,b) lp->a = mproc.b
e(l_ppid
, p_ppid
); e(l_cpu
, p_cpu
);
e(l_pri
, p_pri
); e(l_wchan
, p_wchan
);
register struct vsav
*vp
;
register struct text
*xp
;
sp
->sun
.vp
= vp
= (struct vsav
*)alloc(sizeof (struct vsav
));
#define e(a,b) vp->a = mproc.b
e(v_slptime
, p_slptime
); e(v_pri
, p_pri
);
e(v_swrss
, p_swrss
); e(v_aveflt
, p_aveflt
);
vp
->v_minflt
= u
.u_vm
.vm_minflt
;
vp
->v_majflt
= u
.u_vm
.vm_majflt
;
xp
= &text
[mproc
.p_textp
-
(struct text
*)nl
[X_TEXT
].n_value
];
vp
->v_txtrss
= xp
->x_rssize
;
vp
->v_txtswrss
= xp
->x_swrss
;
vp
->v_xccount
= xp
->x_ccount
;
for (cp
= (char *)u
.u_stack
;
cp
< (char *)&u
+ ctob(UPAGES
); )
sp
->sun
.s_ssiz
= (int) ((char *)&u
+ ctob(UPAGES
) - cp
);
struct pte
*pteaddr
, apte
, arguutl
[UPAGES
+CLSIZE
];
size
= sflg
? ctob(UPAGES
) : sizeof (struct user
);
if ((mproc
.p_flag
& SLOAD
) == 0) {
lseek(swap
, ctob(mproc
.p_swaddr
), 0);
if (read(swap
, (char *)&u
, size
) != size
) {
fprintf(stderr
, "ps: cant read u for pid %d from %s\n",
pteaddr
= &Usrptma
[btokmx(mproc
.p_p0br
) + mproc
.p_szpt
- 1];
lseek(kmem
, kflg
? clear(pteaddr
) : (int)pteaddr
, 0);
if (read(kmem
, (char *)&apte
, sizeof(apte
)) != sizeof(apte
)) {
printf("ps: cant read indir pte to get u for pid %d from %s\n",
ctob(apte
.pg_pfnum
+1) - (UPAGES
+CLSIZE
) * sizeof (struct pte
), 0);
if (read(mem
, (char *)arguutl
, sizeof(arguutl
)) != sizeof(arguutl
)) {
printf("ps: cant read page table for u of pid %d from %s\n",
if (arguutl
[0].pg_fod
== 0 && arguutl
[0].pg_pfnum
)
argaddr
= ctob(arguutl
[0].pg_pfnum
);
pcbpf
= arguutl
[CLSIZE
].pg_pfnum
;
ncl
= (size
+ NBPG
*CLSIZE
- 1) / (NBPG
*CLSIZE
);
lseek(mem
, ctob(arguutl
[CLSIZE
+i
].pg_pfnum
), 0);
if (read(mem
, user
.upages
[CLSIZE
+i
], CLSIZE
*NBPG
)
printf("ps: cant read page %d of u of pid %d from %s\n",
arguutl
[CLSIZE
+i
].pg_pfnum
, mproc
.p_pid
, memf
);
int argi
[CLSIZE
*NBPG
/sizeof (int)];
if (mproc
.p_stat
== SZOMB
)
if ((mproc
.p_flag
& SLOAD
) == 0 || argaddr
== 0) {
vstodb(0, CLSIZE
, &u
.u_smap
, &db
, 1);
lseek(swap
, ctob(db
.db_base
), 0);
if (read(swap
, (char *)&argspac
, sizeof(argspac
))
if (read(mem
, (char *)&argspac
, sizeof (argspac
))
ip
= &argspac
.argi
[CLSIZE
*NBPG
/sizeof (int)];
for (cp
= (char *)ip
; cp
< &argspac
.argc
[CLSIZE
*NBPG
]; cp
++) {
else if (c
< ' ' || c
> 0176) {
strncpy(cmdbuf
, cp
, &argspac
.argc
[CLSIZE
*NBPG
] - cp
);
if (cp
[0] == '-' || cp
[0] == '?' || cp
[0] <= ' ') {
strncat(cp
, u
.u_comm
, sizeof(u
.u_comm
));
if (xflg
== 0 && gflg
== 0 && tptr
== 0 && cp
[0] == '-')
return (savestr(cmdbuf
));
fprintf(stderr
, "ps: error locating command name for pid %d\n",
strncpy(cmdbuf
, u
.u_comm
, sizeof (u
.u_comm
));
return (savestr(cmdbuf
));
" F S UID PID PPID CP PRI NICE ADDR SZ RSS WCHAN TTY TIME";
register struct asav
*ap
= sp
->ap
;
register struct lsav
*lp
= sp
->sun
.lp
;
printf("%5x %c %4d%5u%6u%3d%4d%4d%6x%4d%5d",
ap
->a_flag
, "0SWRIZT"[ap
->a_stat
], ap
->a_uid
,
ap
->a_pid
, lp
->l_ppid
, lp
->l_cpu
&0377, lp
->l_pri
-PZERO
,
ap
->a_nice
-NZERO
, lp
->l_addr
, ap
->a_size
, ap
->a_rss
);
printf(lp
->l_wchan
? "%6x" : " ", lp
->l_wchan
);
printf("%3ld:%02ld", ap
->a_time
/ HZ
, ap
->a_time
% HZ
);
"USER PID %%CPU NICE SZ RSS TTY TIME";
register struct asav
*ap
= sp
->ap
;
printf("%-8.8s%5u%5.1f%4d%4d%5d",
getname(ap
->a_uid
), ap
->a_pid
, sp
->sun
.u_pctcpu
, ap
->a_nice
,
"F PID TT TIME TIM SL MINFLT MAJFLT SIZE RSS SRS TSIZ TRS PF";
register struct vsav
*vp
= sp
->sun
.vp
;
register struct asav
*ap
= sp
->ap
;
if ((ap
->a_flag
& SLOAD
) == 0)
else if (vp
->v_pri
>= PZERO
)
else if (ap
->a_flag
& SPAGE
)
stat
= ap
->a_flag
& SLOAD
? 'R' : 'W';
nice
= ap
->a_nice
> NZERO
? 'N' : ' ';
anom
= ap
->a_flag
& (SANOM
|SUANOM
) ? 'A' : ' ';
printf("%c%c%c%5u", stat
, nice
, anom
, ap
->a_pid
);
printf("%3d%3d%8d%8d%5d%5d%5d%5d%4d%3d",
ap
->a_time
, vp
->v_slptime
, vp
->v_majflt
, vp
->v_minflt
,
ap
->a_size
, ap
->a_rss
, vp
->v_swrss
, vp
->v_tsiz
, vp
->v_txtrss
,
register struct asav
*ap
= sp
->ap
;
printf("%5d", sp
->sun
.s_ssiz
);
printf(" %5u", ap
->a_pid
);
if (devl
[i
].dev
== u
.u_ttyd
) {
if (p
[0]=='t' && p
[1]=='t' && p
[2]=='y')
* Given a base/size pair in virtual swap area,
* return a physical base/size pair which is the
* (largest) initial, physically contiguous block.
vstodb(vsbase
, vssize
, dmp
, dbp
, rev
)
register struct dblock
*dbp
;
register int blk
= DMMIN
;
register swblk_t
*ip
= dmp
->dm_map
;
if (vsbase
< 0 || vsbase
+ vssize
> dmp
->dm_size
)
if (*ip
<= 0 || *ip
+ blk
> nswap
)
dbp
->db_size
= min(vssize
, blk
- vsbase
);
dbp
->db_base
= *ip
+ (rev
? blk
- (vsbase
+ dbp
->db_size
) : vsbase
);
return (vsize(s2
) - vsize(s1
));
i
= s1
->ap
->a_ttyd
- s2
->ap
->a_ttyd
;
i
= s1
->ap
->a_pid
- s2
->ap
->a_pid
;
register struct asav
*ap
= sp
->ap
;
register struct vsav
*vp
= sp
->sun
.vp
;
vp
->v_txtrss
/ (vp
->v_xccount
? vp
->v_xccount
: 1));
return (vp
->v_swrss
+ (vp
->v_xccount
? 0 : vp
->v_txtswrss
));
char names
[NUID
][NMAX
+1];
register struct passwd
*pw
;
struct passwd
*getpwent();
while (pw
= getpwent()) {
if (names
[pw
->pw_uid
][0])
strncpy(names
[pw
->pw_uid
], pw
->pw_name
, NMAX
);
freebase
= (char *)sbrk(size
> 2048 ? size
: 2048);
fprintf(stderr
, "ps: ran out of memory\n");
for (i
= size
; --i
>= 0; )
dp
= (char *)alloc(len
+1);