src/lib/libkvm/kvm_proc.c - diff

Return to kvm_proc.c CVS log

Up to [cvs.NetBSD.org] / src / lib / libkvm

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/lib/libkvm/kvm_proc.c between version 1.27 and 1.28

version 1.27, 1998/09/09 00:31:25

version 1.28, 1998/09/27 18:16:00

Line 119 __RCSID("$NetBSD$");

#include "kvm_private.h"

#define KREAD(kd, addr, obj) \

(kvm_read(kd, addr, (char *)(obj), sizeof(*obj)) != sizeof(*obj))

(kvm_read(kd, addr, (void *)(obj), sizeof(*obj)) != sizeof(*obj))

char *_kvm_uread __P((kvm_t *, const struct proc *, u_long, u_long *));

#if !defined(UVM)

Line 149 _kvm_uread(kd, p, va, cnt)

u_long va;

u_long *cnt;

{

int true = 1;

u_long addr, head;

u_long offset;

struct vm_map_entry vme;

Line 156 _kvm_uread(kd, p, va, cnt)

Line 157 _kvm_uread(kd, p, va, cnt)

struct vm_amap amap;

struct vm_anon *anonp, anon;

struct vm_page pg;

int slot;

u_long slot;

#else

struct vm_object vmo;

int rv;

#endif

if (kd->swapspc == 0) {

kd->swapspc = (char *)_kvm_malloc(kd, kd->nbpg);

kd->swapspc = (char *)_kvm_malloc(kd, (size_t)kd->nbpg);

if (kd->swapspc == 0)

return (0);

}

Line 175 _kvm_uread(kd, p, va, cnt)

Line 176 _kvm_uread(kd, p, va, cnt)

head = (u_long)&p->p_vmspace->vm_map.header;

addr = head;

while (1) {

while (true) {

if (KREAD(kd, addr, &vme))

return (0);

Line 226 _kvm_uread(kd, p, va, cnt)

Line 227 _kvm_uread(kd, p, va, cnt)

if (KREAD(kd, addr, &pg))

return NULL;

if (pread(kd->pmfd, kd->swapspc, kd->nbpg,

if (pread(kd->pmfd, (void *)kd->swapspc, (size_t)kd->nbpg,

(off_t)pg.phys_addr) != kd->nbpg)

return NULL;

}

else {

if (pread(kd->swfd, kd->swapspc, kd->nbpg,

if (pread(kd->swfd, (void *)kd->swapspc, (size_t)kd->nbpg,

(off_t)(anon.an_swslot * kd->nbpg)) != kd->nbpg)

return NULL;

}

Line 269 _kvm_uread(kd, p, va, cnt)

Line 270 _kvm_uread(kd, p, va, cnt)

/* Found the page. */

offset %= kd->nbpg;

*cnt = kd->nbpg - offset;

return (&kd->swapspc[offset]);

return (&kd->swapspc[(size_t)offset]);

}

#if !defined(UVM)

Line 443 kvm_proclist(kd, what, arg, p, bp, maxcn

Line 444 kvm_proclist(kd, what, arg, p, bp, maxcn

return (-1);

}

if (KREAD(kd, (u_long)proc.p_cred, &eproc.e_pcred) == 0)

(void)KREAD(kd, (u_long)eproc.e_pcred.pc_ucred,

if (KREAD(kd, (u_long)eproc.e_pcred.pc_ucred,

&eproc.e_ucred);

&eproc.e_ucred)) {

_kvm_err(kd, kd->program,

"can't read proc credentials at %x", p);

return -1;

}

switch(what) {

Line 517 kvm_proclist(kd, what, arg, p, bp, maxcn

Line 522 kvm_proclist(kd, what, arg, p, bp, maxcn

eproc.e_wmesg, WMESGLEN);

(void)kvm_read(kd, (u_long)proc.p_vmspace,

(char *)&eproc.e_vm, sizeof(eproc.e_vm));

(void *)&eproc.e_vm, sizeof(eproc.e_vm));

eproc.e_xsize = eproc.e_xrssize = 0;

eproc.e_xccount = eproc.e_xswrss = 0;

Line 710 kvm_argv(kd, p, addr, narg, maxcnt)

Line 715 kvm_argv(kd, p, addr, narg, maxcnt)

int maxcnt;

{

char *np, *cp, *ep, *ap;

u_long oaddr = -1;

u_long oaddr = (u_long)~0L;

int len, cc;

u_long len;

size_t cc;

char **argv;

Line 738 kvm_argv(kd, p, addr, narg, maxcnt)

Line 744 kvm_argv(kd, p, addr, narg, maxcnt)

return (0);

}

if (kd->argspc == 0) {

kd->argspc = (char *)_kvm_malloc(kd, kd->nbpg);

kd->argspc = (char *)_kvm_malloc(kd, (size_t)kd->nbpg);

if (kd->argspc == 0)

return (0);

kd->arglen = kd->nbpg;

}

if (kd->argbuf == 0) {

kd->argbuf = (char *)_kvm_malloc(kd, kd->nbpg);

kd->argbuf = (char *)_kvm_malloc(kd, (size_t)kd->nbpg);

if (kd->argbuf == 0)

return (0);

}

cc = sizeof(char *) * narg;

if (kvm_uread(kd, p, addr, (char *)kd->argv, cc) != cc)

if (kvm_uread(kd, p, addr, (void *)kd->argv, cc) != cc)

return (0);

ap = np = kd->argspc;

argv = kd->argv;

Line 760 kvm_argv(kd, p, addr, narg, maxcnt)

Line 766 kvm_argv(kd, p, addr, narg, maxcnt)

while (argv < kd->argv + narg && *argv != 0) {

addr = (u_long)*argv & ~(kd->nbpg - 1);

if (addr != oaddr) {

if (kvm_uread(kd, p, addr, kd->argbuf, kd->nbpg) !=

if (kvm_uread(kd, p, addr, kd->argbuf,

kd->nbpg)

(size_t)kd->nbpg) != kd->nbpg)

return (0);

oaddr = addr;

}

addr = (u_long)*argv & (kd->nbpg - 1);

cp = kd->argbuf + addr;

cp = kd->argbuf + (size_t)addr;

cc = kd->nbpg - addr;

cc = kd->nbpg - (size_t)addr;

if (maxcnt > 0 && cc > maxcnt - len)

if (maxcnt > 0 && cc > (size_t)(maxcnt - len))

cc = maxcnt - len;;

cc = (size_t)(maxcnt - len);

ep = memchr(cp, '\0', cc);

if (ep != 0)

cc = ep - cp + 1;

Line 780 kvm_argv(kd, p, addr, narg, maxcnt)

Line 786 kvm_argv(kd, p, addr, narg, maxcnt)

kd->arglen *= 2;

kd->argspc = (char *)_kvm_realloc(kd, kd->argspc,

kd->arglen);

(size_t)kd->arglen);

if (kd->argspc == 0)

return (0);

Line 855 proc_verify(kd, kernp, p)

Line 861 proc_verify(kd, kernp, p)

* Just read in the whole proc. It's not that big relative

* to the cost of the read system call.

if (kvm_read(kd, kernp, (char *)&kernproc, sizeof(kernproc)) !=

if (kvm_read(kd, kernp, (void *)&kernproc, sizeof(kernproc)) !=

sizeof(kernproc))

return (0);

return (p->p_pid == kernproc.p_pid &&

Line 881 kvm_doargv(kd, kp, nchr, info)

Line 887 kvm_doargv(kd, kp, nchr, info)

if (p->p_stat == SZOMB)

return (0);

cnt = kvm_uread(kd, p, kd->usrstack - sizeof(arginfo),

(char *)&arginfo, sizeof(arginfo));

(void *)&arginfo, sizeof(arginfo));

if (cnt != sizeof(arginfo))

return (0);

Line 934 kvm_uread(kd, p, uva, buf, len)

Line 940 kvm_uread(kd, p, uva, buf, len)

cp = buf;

while (len > 0) {

int cc;

size_t cc;

char *dp;

u_long cnt;

Line 943 kvm_uread(kd, p, uva, buf, len)

Line 949 kvm_uread(kd, p, uva, buf, len)

_kvm_err(kd, 0, "invalid address (%x)", uva);

return (0);

}

cc = MIN(cnt, len);

cc = (size_t)MIN(cnt, len);

memcpy(cp, dp, cc);

cp += cc;

uva += cc;

len -= cc;

CVSweb <webmaster@jp.NetBSD.org>