![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kmem.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ps|
Return to kmem.c CVS log | Up to [Research Unix] / researchv10no / cmd / ps |
1.1 root 1: #include <stdio.h>
2: #include "ps.h"
3: #include <nlist.h>
4:
5: struct nlist nl[] = {
6: { "_proc" },
7: #define X_PROC 0
8: { "_proccnt" },
9: #define X_NPROC 1
10: { "_physspt" },
11: #define X_PHYSSPT 2
12: { 0 },
13: };
14:
15: struct proc *kproc;
16: static int nproc, lastproc;
17: long physspt;
18:
19: long vtophys();
20:
21: initk()
22: {
23:
24: if (memf == NULL)
25: memf = "/dev/mem";
26: else {
27: if (drumf == NULL) /* and memf was specified */
28: drumf = "/dev/null";
29: }
30: if (drumf == NULL)
31: drumf = "/dev/drum";
32: if (nlistf == NULL)
33: nlistf = "/unix";
34: if ((drum = open(drumf, 0)) < 0) {
35: perror(drumf);
36: exit(1);
37: }
38: if ((memory = open(memf, 0)) < 0) {
39: perror(memf);
40: exit(1);
41: }
42: nlist(nlistf, nl);
43: if(nl[0].n_type == 0) {
44: fprintf(stderr, "%s: No namelist\n", nlistf);
45: exit(1);
46: }
47: if (memrd(memory, (char *)&physspt, sizeof(physspt),
48: (long)nl[X_PHYSSPT].n_value-KSTART) != sizeof(physspt)) {
49: fprintf(stderr, "can't read physspt\n");
50: exit(1);
51: }
52: }
53:
54: setkproc()
55: {
56: if (memrd(memory, (char *)&nproc, sizeof(nproc),
57: vtophys(nl[X_NPROC].n_value)) != sizeof(nproc)) {
58: fprintf(stderr, "can't read nproc\n");
59: exit(1);
60: }
61: if((kproc = (struct proc *)malloc(nproc*sizeof(struct proc))) == 0) {
62: fprintf(stderr, "no memory for proc table\n");
63: exit(1);
64: }
65: if (memrd(memory, (char *)kproc, nproc*sizeof(struct proc),
66: vtophys(nl[X_PROC].n_value)) != nproc*sizeof(struct proc)) {
67: fprintf(stderr, "can't read proc table\n");
68: exit(1);
69: }
70: lastproc = nproc-1;
71: }
72:
73: getprock(s, pp)
74: char *s;
75: struct proc *pp;
76: {
77: register int pid, x;
78:
79: if (nproc == 0)
80: setkproc();
81: pid = atoi(s);
82: for(x = lastproc+1; x != lastproc; x++) {
83: if(x >= nproc)
84: x = 0;
85: if (kproc[x].p_stat == 0)
86: continue;
87: if(kproc[x].p_pid == pid) {
88: *pp = kproc[x];
89: lastproc = x;
90: return 0;
91: }
92: }
93: return -1;
94: }
95:
96: char *
97: getuareak(fd, pp, up)
98: register struct proc *pp;
99: register struct user *up;
100: {
101: struct pte upte[UPAGES];
102: register int i;
103:
104: if (pp->p_stat == SZOMB) {
105: memset((char *)up, 0, sizeof(*up));
106: return (0);
107: }
108: if (pp->p_flag & SLOAD) {
109: if (memrd(memory, (char *)upte, sizeof(upte), vtophys((long)pp->p_addr)) != sizeof(upte))
110: return ("can't read user ptes");
111: for (i = 0; i < UPAGES; i++)
112: if (memrd(memory, ((char *)up)+i*NBPG, NBPG,
113: ctob(upte[i].pg_pfnum)) != NBPG)
114: return ("can't read user");
115: return (0);
116: } else {
117: if (memrd(drum, (char *)up, sizeof(*up), ctob(pp->p_swaddr)) != sizeof(*up))
118: return ("can't read user block");
119: return (0);
120: }
121: }
122:
123: getstackk(f, pp, up, stack)
124: register struct proc *pp;
125: register struct user *up;
126: char *stack;
127: {
128: register int i;
129: int nstack, nspte;
130: int szpt; /* swapped pt size */
131: struct pte pte[NPTEPG];
132:
133: nstack = ctob(up->u_ssize);
134: if (nstack <= 0)
135: return (0);
136: if (nstack > NSTACK)
137: nstack = NSTACK;
138: nspte = btoc(nstack);
139: szpt = clrnd(ctopt(UPAGES+pp->p_tsize+pp->p_dsize+pp->p_ssize));
140: if (pp->p_flag & SLOAD) {
141: if (memrd(memory, (char *)pte, sizeof(pte),
142: vtophys((long)pp->p_addr+UPAGES*sizeof(struct pte)-NBPG)) != sizeof(pte))
143: return (0);
144: } else {
145: if (memrd(drum, (char *)pte, sizeof(pte),
146: ctob(pp->p_swaddr+UPAGES+szpt-1)) != sizeof(pte))
147: return (0);
148: }
149: for (i = nspte-1; i >= 0; stack += NBPG, --i)
150: rdpage(up, i, &pte[NPTEPG-UPAGES-1-i], stack);
151: return (nstack);
152: }
153:
154: List *
155: getprlistk()
156: {
157: register List *lp;
158: register Entry *ep;
159: register int x;
160:
161: if (nproc == 0)
162: setkproc();
163: if((lp = Malloc(List, 1)) == 0)
164: return 0;
165: lp->next = 0;
166: lp->begin = 0;
167: lp->nentry = 0;
168: for(x = 0; x < nproc; x++) {
169: if(kproc[x].p_stat == 0)
170: continue;
171: if((ep = Malloc(Entry, 1)) == 0)
172: break;
173: ep->next = lp->begin;
174: lp->begin = ep;
175: lp->nentry++;
176: ep->e_val = kproc[x].p_pid;
177: sprintf(ep->e_name, "%d", kproc[x].p_pid);
178: }
179: return lp;
180: }
181:
182: long
183: vtophys(loc)
184: long loc;
185: {
186: struct pte pte;
187: register long nloc;
188:
189: nloc = loc - KSTART;
190: if (nloc < 0) {
191: fprintf(stderr, "bad kernel address %x\n", loc);
192: return (0);
193: }
194: if (memrd(memory, (char *)&pte, sizeof(pte),
195: physspt + (nloc/NBPG)*sizeof(struct pte)) != sizeof(pte)) {
196: fprintf(stderr, "can't get spt for %x\n", loc);
197: return (0);
198: }
199: if (pte.pg_v == 0) {
200: fprintf(stderr, "invalid spt for %x\n", loc);
201: return (0);
202: }
203: return (pte.pg_pfnum * NBPG + (nloc & PGOFSET));
204: }
205:
206: kreadk(addr, buf, size)
207: long addr;
208: char *buf;
209: int size;
210: {
211:
212: return (memrd(memory, buf, size, vtophys(addr)) == size);
213: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.