![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kvm.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / lib / libutil|
Return to kvm.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / lib / libutil |
1.1 ! root 1: /*- ! 2: * Copyright (c) 1989 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms are permitted provided ! 6: * that: (1) source distributions retain this entire copyright notice and ! 7: * comment, and (2) distributions including binaries display the following ! 8: * acknowledgement: ``This product includes software developed by the ! 9: * University of California, Berkeley and its contributors'' in the ! 10: * documentation or other materials provided with the distribution and in ! 11: * all advertising materials mentioning features or use of this software. ! 12: * Neither the name of the University nor the names of its contributors may ! 13: * be used to endorse or promote products derived from this software without ! 14: * specific prior written permission. ! 15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 18: */ ! 19: ! 20: #if defined(LIBC_SCCS) && !defined(lint) ! 21: static char sccsid[] = "@(#)kvm.c 5.9 (Berkeley) 6/27/90"; ! 22: #endif /* LIBC_SCCS and not lint */ ! 23: ! 24: #include <machine/pte.h> ! 25: #include <machine/vmparam.h> ! 26: #include <sys/param.h> ! 27: #include <sys/user.h> ! 28: #include <sys/proc.h> ! 29: #include <sys/file.h> ! 30: #include <sys/text.h> ! 31: #include <sys/stat.h> ! 32: #include <sys/time.h> ! 33: #include <sys/vmmac.h> ! 34: #include <sys/ioctl.h> ! 35: #include <sys/tty.h> ! 36: #include <kvm.h> ! 37: #include <ctype.h> ! 38: #include <vis.h> ! 39: #include <nlist.h> ! 40: #include <pwd.h> ! 41: #include <string.h> ! 42: #include <ndbm.h> ! 43: #include <limits.h> ! 44: #include <paths.h> ! 45: #include <stdio.h> ! 46: ! 47: /* ! 48: * files ! 49: */ ! 50: static char *unixf, *memf, *kmemf, *swapf; ! 51: static int unixx, mem, kmem, swap; ! 52: static DBM *db; ! 53: /* ! 54: * flags ! 55: */ ! 56: static int deadkernel; ! 57: static int kvminit = 0; ! 58: static int kvmfilesopen = 0; ! 59: /* ! 60: * state ! 61: */ ! 62: static struct kinfo_proc *kvmprocbase, *kvmprocptr; ! 63: static int kvmnprocs; ! 64: /* ! 65: * u. buffer ! 66: */ ! 67: static union { ! 68: struct user user; ! 69: char upages[UPAGES][NBPG]; ! 70: } user; ! 71: /* ! 72: * random other stuff ! 73: */ ! 74: static struct pte *Usrptmap, *usrpt; ! 75: static int dmmin, dmmax; ! 76: static struct pte *Sysmap; ! 77: static int Syssize; ! 78: static int pcbpf; ! 79: static int argaddr0; /* XXX */ ! 80: static int argaddr1; ! 81: static int nswap; ! 82: static char *tmp; ! 83: #if defined(hp300) ! 84: static int lowram; ! 85: #endif ! 86: ! 87: #define basename(cp) ((tmp=rindex((cp), '/')) ? tmp+1 : (cp)) ! 88: #define MAXSYMSIZE 256 ! 89: ! 90: #if defined(hp300) ! 91: #define pftoc(f) ((f) - lowram) ! 92: #define iskva(v) (1) ! 93: #endif ! 94: ! 95: #ifndef pftoc ! 96: #define pftoc(f) (f) ! 97: #endif ! 98: #ifndef iskva ! 99: #define iskva(v) ((v) & KERNBASE) ! 100: #endif ! 101: ! 102: static struct nlist nl[] = { ! 103: { "_Usrptmap" }, ! 104: #define X_USRPTMAP 0 ! 105: { "_usrpt" }, ! 106: #define X_USRPT 1 ! 107: { "_nswap" }, ! 108: #define X_NSWAP 2 ! 109: { "_dmmin" }, ! 110: #define X_DMMIN 3 ! 111: { "_dmmax" }, ! 112: #define X_DMMAX 4 ! 113: /* ! 114: * everything here and down, only if a dead kernel ! 115: */ ! 116: { "_Sysmap" }, ! 117: #define X_SYSMAP 5 ! 118: #define X_DEADKERNEL X_SYSMAP ! 119: { "_Syssize" }, ! 120: #define X_SYSSIZE 6 ! 121: { "_allproc" }, ! 122: #define X_ALLPROC 7 ! 123: { "_zombproc" }, ! 124: #define X_ZOMBPROC 8 ! 125: { "_nproc" }, ! 126: #define X_NPROC 9 ! 127: #define X_LAST 9 ! 128: #if defined(hp300) ! 129: { "_lowram" }, ! 130: #define X_LOWRAM (X_LAST+1) ! 131: #endif ! 132: { "" }, ! 133: }; ! 134: ! 135: /* ! 136: * returns 0 if files were opened now, ! 137: * 1 if files were already opened, ! 138: * -1 if files could not be opened. ! 139: */ ! 140: kvm_openfiles(uf, mf, sf) ! 141: char *uf, *mf, *sf; ! 142: { ! 143: if (kvmfilesopen) ! 144: return (1); ! 145: unixx = mem = kmem = swap = -1; ! 146: unixf = (uf == NULL) ? _PATH_UNIX : uf; ! 147: memf = (mf == NULL) ? _PATH_MEM : mf; ! 148: ! 149: if ((unixx = open(unixf, O_RDONLY, 0)) == -1) { ! 150: setsyserr("can't open %s", unixf); ! 151: goto failed; ! 152: } ! 153: if ((mem = open(memf, O_RDONLY, 0)) == -1) { ! 154: setsyserr("can't open %s", memf); ! 155: goto failed; ! 156: } ! 157: if (sf != NULL) ! 158: swapf = sf; ! 159: if (mf != NULL) { ! 160: deadkernel++; ! 161: kmemf = mf; ! 162: kmem = mem; ! 163: swap = -1; ! 164: } else { ! 165: kmemf = _PATH_KMEM; ! 166: if ((kmem = open(kmemf, O_RDONLY, 0)) == -1) { ! 167: setsyserr("can't open %s", kmemf); ! 168: goto failed; ! 169: } ! 170: swapf = (sf == NULL) ? _PATH_DRUM : sf; ! 171: /* ! 172: * live kernel - avoid looking up nlist entries ! 173: * past X_DEADKERNEL. ! 174: */ ! 175: nl[X_DEADKERNEL].n_name = ""; ! 176: } ! 177: if (swapf != NULL && ((swap = open(swapf, O_RDONLY, 0)) == -1)) { ! 178: seterr("can't open %s", swapf); ! 179: goto failed; ! 180: } ! 181: kvmfilesopen++; ! 182: if (kvminit == 0 && kvm_init(NULL, NULL, NULL, 0) == -1) /*XXX*/ ! 183: return (-1); ! 184: return (0); ! 185: failed: ! 186: kvm_close(); ! 187: return (-1); ! 188: } ! 189: ! 190: static ! 191: kvm_init(uf, mf, sf) ! 192: char *uf, *mf, *sf; ! 193: { ! 194: if (kvmfilesopen == 0 && kvm_openfiles(NULL, NULL, NULL) == -1) ! 195: return (-1); ! 196: if (getkvars() == -1) ! 197: return (-1); ! 198: kvminit = 1; ! 199: ! 200: return (0); ! 201: } ! 202: ! 203: kvm_close() ! 204: { ! 205: if (unixx != -1) { ! 206: close(unixx); ! 207: unixx = -1; ! 208: } ! 209: if (kmem != -1) { ! 210: if (kmem != mem) ! 211: close(kmem); ! 212: /* otherwise kmem is a copy of mem, and will be closed below */ ! 213: kmem = -1; ! 214: } ! 215: if (mem != -1) { ! 216: close(mem); ! 217: mem = -1; ! 218: } ! 219: if (swap != -1) { ! 220: close(swap); ! 221: swap = -1; ! 222: } ! 223: if (db != NULL) { ! 224: dbm_close(db); ! 225: db = NULL; ! 226: } ! 227: kvminit = 0; ! 228: kvmfilesopen = 0; ! 229: deadkernel = 0; ! 230: if (Sysmap) { ! 231: free(Sysmap); ! 232: Sysmap = NULL; ! 233: } ! 234: } ! 235: ! 236: kvm_nlist(nl) ! 237: struct nlist *nl; ! 238: { ! 239: datum key, data; ! 240: char dbname[MAXPATHLEN]; ! 241: char dbversion[_BSD_LINE_MAX]; ! 242: char kversion[_BSD_LINE_MAX]; ! 243: int dbversionlen; ! 244: char symbuf[MAXSYMSIZE+1]; ! 245: struct nlist nbuf, *n; ! 246: int num, did; ! 247: ! 248: if (kvmfilesopen == 0 && kvm_openfiles(NULL, NULL, NULL) == -1) ! 249: return (-1); ! 250: if (deadkernel) ! 251: goto hard2; ! 252: /* ! 253: * initialize key datum ! 254: */ ! 255: key.dptr = symbuf; ! 256: symbuf[0] = KVMDB_NLIST; ! 257: ! 258: if (db != NULL) ! 259: goto win; /* off to the races */ ! 260: /* ! 261: * open database ! 262: */ ! 263: sprintf(dbname, "%s/kvm_%s", KVMDBDIR, basename(unixf)); ! 264: if ((db = dbm_open(dbname, O_RDONLY, 0)) == NULL) ! 265: goto hard2; ! 266: /* ! 267: * read version out of database ! 268: */ ! 269: bcopy("VERSION", symbuf+1, sizeof ("VERSION")-1); ! 270: key.dsize = (sizeof ("VERSION") - 1) + 1; ! 271: data = dbm_fetch(db, key); ! 272: if (data.dptr == NULL) ! 273: goto hard1; ! 274: bcopy(data.dptr, dbversion, data.dsize); ! 275: dbversionlen = data.dsize; ! 276: /* ! 277: * read version string from kernel memory ! 278: */ ! 279: bcopy("_version", symbuf+1, sizeof ("_version")-1); ! 280: key.dsize = (sizeof ("_version")-1) + 1; ! 281: data = dbm_fetch(db, key); ! 282: if (data.dptr == NULL) ! 283: goto hard1; ! 284: if (data.dsize != sizeof (struct nlist)) ! 285: goto hard1; ! 286: bcopy(data.dptr, &nbuf, sizeof (struct nlist)); ! 287: lseek(kmem, nbuf.n_value, 0); ! 288: if (read(kmem, kversion, dbversionlen) != dbversionlen) ! 289: goto hard1; ! 290: /* ! 291: * if they match, we win - otherwise do it the hard way ! 292: */ ! 293: if (bcmp(dbversion, kversion, dbversionlen) != 0) ! 294: goto hard1; ! 295: /* ! 296: * getem from the database. ! 297: */ ! 298: win: ! 299: num = did = 0; ! 300: for (n = nl; n->n_name && n->n_name[0]; n++, num++) { ! 301: int len; ! 302: /* ! 303: * clear out fields from users buffer ! 304: */ ! 305: n->n_type = 0; ! 306: n->n_other = 0; ! 307: n->n_desc = 0; ! 308: n->n_value = 0; ! 309: /* ! 310: * query db ! 311: */ ! 312: if ((len = strlen(n->n_name)) > MAXSYMSIZE) { ! 313: seterr("kvm_nlist: symbol too large"); ! 314: return (-1); ! 315: } ! 316: strcpy(symbuf+1, n->n_name); ! 317: key.dsize = len + 1; ! 318: data = dbm_fetch(db, key); ! 319: if (data.dptr == NULL || data.dsize != sizeof (struct nlist)) ! 320: continue; ! 321: bcopy(data.dptr, &nbuf, sizeof (struct nlist)); ! 322: n->n_value = nbuf.n_value; ! 323: n->n_type = nbuf.n_type; ! 324: n->n_desc = nbuf.n_desc; ! 325: n->n_other = nbuf.n_other; ! 326: did++; ! 327: } ! 328: return (num - did); ! 329: hard1: ! 330: dbm_close(db); ! 331: db = NULL; ! 332: hard2: ! 333: return (nlist(unixf, nl)); /* XXX seterr if -1 */ ! 334: } ! 335: ! 336: kvm_getprocs(what, arg) ! 337: { ! 338: if (kvminit == 0 && kvm_init(NULL, NULL, NULL, 0) == -1) ! 339: return (NULL); ! 340: if (!deadkernel) { ! 341: int ret, copysize; ! 342: ! 343: if ((ret = getkerninfo(what, NULL, NULL, arg)) == -1) { ! 344: setsyserr("can't get estimate for kerninfo"); ! 345: return (-1); ! 346: } ! 347: copysize = ret; ! 348: if ((kvmprocbase = (struct kinfo_proc *)malloc(copysize)) ! 349: == NULL) { ! 350: seterr("out of memory"); ! 351: return (-1); ! 352: } ! 353: if ((ret = getkerninfo(what, kvmprocbase, ©size, ! 354: arg)) == -1) { ! 355: setsyserr("can't get proc list"); ! 356: return (-1); ! 357: } ! 358: if (copysize % sizeof (struct kinfo_proc)) { ! 359: seterr("proc size mismatch (kinfo_proc: %d)", ! 360: sizeof (struct kinfo_proc)); ! 361: return (-1); ! 362: } ! 363: kvmnprocs = copysize / sizeof (struct kinfo_proc); ! 364: } else { ! 365: int nproc; ! 366: ! 367: if (kvm_read(nl[X_NPROC].n_value, &nproc, sizeof (int)) != ! 368: sizeof (int)) { ! 369: seterr("can't read nproc"); ! 370: return (-1); ! 371: } ! 372: if ((kvmprocbase = (struct kinfo_proc *) ! 373: malloc(nproc * sizeof (struct kinfo_proc))) == NULL) { ! 374: seterr("out of memory (addr: %x nproc = %d)", ! 375: nl[X_NPROC].n_value, nproc); ! 376: return (-1); ! 377: } ! 378: kvmnprocs = kvm_doprocs(what, arg, kvmprocbase); ! 379: realloc(kvmprocbase, kvmnprocs * sizeof (struct kinfo_proc)); ! 380: } ! 381: kvmprocptr = kvmprocbase; ! 382: ! 383: return (kvmnprocs); ! 384: } ! 385: ! 386: /* ! 387: * XXX - should NOT give up so easily - especially since the kernel ! 388: * may be corrupt (it died). Should gather as much information as possible. ! 389: * Follows proc ptrs instead of reading table since table may go ! 390: * away soon. ! 391: */ ! 392: static ! 393: kvm_doprocs(what, arg, buff) ! 394: int what, arg; ! 395: char *buff; ! 396: { ! 397: struct proc *p, proc; ! 398: register char *bp = buff; ! 399: int i = 0; ! 400: int doingzomb = 0; ! 401: struct eproc eproc; ! 402: struct pgrp pgrp; ! 403: struct session sess; ! 404: struct tty tty; ! 405: struct text text; ! 406: ! 407: /* allproc */ ! 408: if (kvm_read(nl[X_ALLPROC].n_value, &p, ! 409: sizeof (struct proc *)) != sizeof (struct proc *)) { ! 410: seterr("can't read allproc"); ! 411: return (-1); ! 412: } ! 413: ! 414: again: ! 415: for (; p; p = proc.p_nxt) { ! 416: if (kvm_read(p, &proc, sizeof (struct proc)) != ! 417: sizeof (struct proc)) { ! 418: seterr("can't read proc at %x", p); ! 419: return (-1); ! 420: } ! 421: switch(ki_op(what)) { ! 422: ! 423: case KINFO_PROC_PID: ! 424: if (proc.p_pid != (pid_t)arg) ! 425: continue; ! 426: break; ! 427: ! 428: ! 429: case KINFO_PROC_UID: ! 430: if (proc.p_uid != (uid_t)arg) ! 431: continue; ! 432: break; ! 433: ! 434: case KINFO_PROC_RUID: ! 435: if (proc.p_ruid != (uid_t)arg) ! 436: continue; ! 437: break; ! 438: } ! 439: /* ! 440: * gather eproc ! 441: */ ! 442: eproc.e_paddr = p; ! 443: if (kvm_read(proc.p_pgrp, &pgrp, sizeof (struct pgrp)) != ! 444: sizeof (struct pgrp)) { ! 445: seterr("can't read pgrp at %x", proc.p_pgrp); ! 446: return (-1); ! 447: } ! 448: eproc.e_sess = pgrp.pg_session; ! 449: eproc.e_pgid = pgrp.pg_id; ! 450: eproc.e_jobc = pgrp.pg_jobc; ! 451: if (kvm_read(pgrp.pg_session, &sess, sizeof (struct session)) ! 452: != sizeof (struct session)) { ! 453: seterr("can't read session at %x", pgrp.pg_session); ! 454: return (-1); ! 455: } ! 456: if ((proc.p_flag&SCTTY) && sess.s_ttyp != NULL) { ! 457: if (kvm_read(sess.s_ttyp, &tty, sizeof (struct tty)) ! 458: != sizeof (struct tty)) { ! 459: seterr("can't read tty at %x", sess.s_ttyp); ! 460: return (-1); ! 461: } ! 462: eproc.e_tdev = tty.t_dev; ! 463: eproc.e_tsess = tty.t_session; ! 464: if (tty.t_pgrp != NULL) { ! 465: if (kvm_read(tty.t_pgrp, &pgrp, sizeof (struct ! 466: pgrp)) != sizeof (struct pgrp)) { ! 467: seterr("can't read tpgrp at &x", ! 468: tty.t_pgrp); ! 469: return (-1); ! 470: } ! 471: eproc.e_tpgid = pgrp.pg_id; ! 472: } else ! 473: eproc.e_tpgid = -1; ! 474: } else ! 475: eproc.e_tdev = NODEV; ! 476: if (proc.p_wmesg) ! 477: kvm_read(proc.p_wmesg, eproc.e_wmesg, WMESGLEN); ! 478: if (proc.p_textp) { ! 479: kvm_read(proc.p_textp, &text, sizeof (text)); ! 480: eproc.e_xsize = text.x_size; ! 481: eproc.e_xrssize = text.x_rssize; ! 482: eproc.e_xccount = text.x_ccount; ! 483: eproc.e_xswrss = text.x_swrss; ! 484: } else { ! 485: eproc.e_xsize = eproc.e_xrssize = ! 486: eproc.e_xccount = eproc.e_xswrss = 0; ! 487: } ! 488: ! 489: switch(ki_op(what)) { ! 490: ! 491: case KINFO_PROC_PGRP: ! 492: if (eproc.e_pgid != (pid_t)arg) ! 493: continue; ! 494: break; ! 495: ! 496: case KINFO_PROC_TTY: ! 497: if ((proc.p_flag&SCTTY) == 0 || ! 498: eproc.e_tdev != (dev_t)arg) ! 499: continue; ! 500: break; ! 501: } ! 502: ! 503: i++; ! 504: bcopy(&proc, bp, sizeof (struct proc)); ! 505: bp += sizeof (struct proc); ! 506: bcopy(&eproc, bp, sizeof (struct eproc)); ! 507: bp+= sizeof (struct eproc); ! 508: } ! 509: if (!doingzomb) { ! 510: /* zombproc */ ! 511: if (kvm_read(nl[X_ZOMBPROC].n_value, &p, ! 512: sizeof (struct proc *)) != sizeof (struct proc *)) { ! 513: seterr("can't read zombproc"); ! 514: return (-1); ! 515: } ! 516: doingzomb = 1; ! 517: goto again; ! 518: } ! 519: ! 520: return (i); ! 521: } ! 522: ! 523: struct proc * ! 524: kvm_nextproc() ! 525: { ! 526: ! 527: if (!kvmprocbase && kvm_getprocs(0, 0) == -1) ! 528: return (NULL); ! 529: if (kvmprocptr >= (kvmprocbase + kvmnprocs)) { ! 530: seterr("end of proc list"); ! 531: return (NULL); ! 532: } ! 533: return((struct proc *)(kvmprocptr++)); ! 534: } ! 535: ! 536: struct eproc * ! 537: kvm_geteproc(p) ! 538: struct proc *p; ! 539: { ! 540: return ((struct eproc *)(((char *)p) + sizeof (struct proc))); ! 541: } ! 542: ! 543: kvm_setproc() ! 544: { ! 545: ! 546: kvmprocptr = kvmprocbase; ! 547: } ! 548: ! 549: kvm_freeprocs() ! 550: { ! 551: ! 552: if (kvmprocbase) { ! 553: free(kvmprocbase); ! 554: kvmprocbase = NULL; ! 555: } ! 556: } ! 557: ! 558: struct user * ! 559: kvm_getu(p) ! 560: struct proc *p; ! 561: { ! 562: struct pte *pteaddr, apte; ! 563: struct pte arguutl[HIGHPAGES+(CLSIZE*2)]; ! 564: register int i; ! 565: int ncl; ! 566: ! 567: if (kvminit == 0 && kvm_init(NULL, NULL, NULL, 0) == -1) ! 568: return (NULL); ! 569: if (p->p_stat == SZOMB) { ! 570: seterr("zombie process"); ! 571: return (NULL); ! 572: } ! 573: if ((p->p_flag & SLOAD) == 0) { ! 574: if (swap < 0) { ! 575: seterr("no swap"); ! 576: return (NULL); ! 577: } ! 578: (void) lseek(swap, (long)dtob(p->p_swaddr), 0); ! 579: if (read(swap, (char *)&user.user, sizeof (struct user)) != ! 580: sizeof (struct user)) { ! 581: seterr("can't read u for pid %d from %s\n", ! 582: p->p_pid, swapf); ! 583: return (NULL); ! 584: } ! 585: pcbpf = 0; ! 586: argaddr0 = 0; ! 587: argaddr1 = 0; ! 588: return (&user.user); ! 589: } ! 590: pteaddr = &Usrptmap[btokmx(p->p_p0br) + p->p_szpt - 1]; ! 591: klseek(kmem, (long)pteaddr, 0); ! 592: if (read(kmem, (char *)&apte, sizeof(apte)) != sizeof(apte)) { ! 593: seterr("can't read indir pte to get u for pid %d from %s", ! 594: p->p_pid, kmemf); ! 595: return (NULL); ! 596: } ! 597: lseek(mem, (long)ctob(pftoc(apte.pg_pfnum+1)) - sizeof(arguutl), 0); ! 598: if (read(mem, (char *)arguutl, sizeof(arguutl)) != sizeof(arguutl)) { ! 599: seterr("can't read page table for u of pid %d from %s", ! 600: p->p_pid, memf); ! 601: return (NULL); ! 602: } ! 603: if (arguutl[0].pg_fod == 0 && arguutl[0].pg_pfnum) ! 604: argaddr0 = ctob(pftoc(arguutl[0].pg_pfnum)); ! 605: else ! 606: argaddr0 = 0; ! 607: if (arguutl[CLSIZE*1].pg_fod == 0 && arguutl[CLSIZE*1].pg_pfnum) ! 608: argaddr1 = ctob(pftoc(arguutl[CLSIZE*1].pg_pfnum)); ! 609: else ! 610: argaddr1 = 0; ! 611: pcbpf = arguutl[CLSIZE*2].pg_pfnum; ! 612: ncl = (sizeof (struct user) + CLBYTES - 1) / CLBYTES; ! 613: while (--ncl >= 0) { ! 614: i = ncl * CLSIZE; ! 615: lseek(mem, ! 616: (long)ctob(pftoc(arguutl[(CLSIZE*2)+i].pg_pfnum)), 0); ! 617: if (read(mem, user.upages[i], CLBYTES) != CLBYTES) { ! 618: seterr("can't read page %d of u of pid %d from %s", ! 619: arguutl[(CLSIZE*2)+i].pg_pfnum, p->p_pid, memf); ! 620: return(NULL); ! 621: } ! 622: } ! 623: return (&user.user); ! 624: } ! 625: ! 626: char * ! 627: kvm_getargs(p, up) ! 628: struct proc *p; ! 629: struct user *up; ! 630: { ! 631: char cmdbuf[CLBYTES*2]; ! 632: union { ! 633: char argc[CLBYTES*2]; ! 634: int argi[CLBYTES*2/sizeof (int)]; ! 635: } argspac; ! 636: register char *cp; ! 637: register int *ip; ! 638: char c; ! 639: int nbad; ! 640: struct dblock db; ! 641: char *file; ! 642: ! 643: if (up == NULL || p->p_pid == 0 || p->p_pid == 2) ! 644: goto retucomm; ! 645: if ((p->p_flag & SLOAD) == 0 || argaddr1 == 0) { ! 646: if (swap < 0 || p->p_ssize == 0) ! 647: goto retucomm; ! 648: vstodb(0, CLSIZE, &up->u_smap, &db, 1); ! 649: (void) lseek(swap, (long)dtob(db.db_base), 0); ! 650: if (read(swap, (char *)&argspac.argc[CLBYTES], CLBYTES) ! 651: != CLBYTES) ! 652: goto bad; ! 653: vstodb(1, CLSIZE, &up->u_smap, &db, 1); ! 654: (void) lseek(swap, (long)dtob(db.db_base), 0); ! 655: if (read(swap, (char *)&argspac.argc[0], CLBYTES) != CLBYTES) ! 656: goto bad; ! 657: file = swapf; ! 658: } else { ! 659: if (argaddr0) { ! 660: lseek(mem, (long)argaddr0, 0); ! 661: if (read(mem, (char *)&argspac, CLBYTES) != CLBYTES) ! 662: goto bad; ! 663: } else ! 664: bzero(&argspac, CLBYTES); ! 665: lseek(mem, (long)argaddr1, 0); ! 666: if (read(mem, &argspac.argc[CLBYTES], CLBYTES) != CLBYTES) ! 667: goto bad; ! 668: file = memf; ! 669: } ! 670: ip = &argspac.argi[CLBYTES*2/sizeof (int)]; ! 671: ip -= 2; /* last arg word and .long 0 */ ! 672: while (*--ip) { ! 673: if (ip == argspac.argi) ! 674: goto retucomm; ! 675: } ! 676: *(char *)ip = ' '; ! 677: ip++; ! 678: nbad = 0; ! 679: for (cp = (char *)ip; cp < &argspac.argc[CLBYTES*2]; cp++) { ! 680: c = *cp & 0177; ! 681: if (c == 0) ! 682: *cp = ' '; ! 683: else if (c < ' ' || c > 0176) { ! 684: if (++nbad >= 5*(0+1)) { /* eflg -> 0 XXX */ ! 685: *cp++ = ' '; ! 686: break; ! 687: } ! 688: *cp = '?'; ! 689: } else if (0 == 0 && c == '=') { /* eflg -> 0 XXX */ ! 690: while (*--cp != ' ') ! 691: if (cp <= (char *)ip) ! 692: break; ! 693: break; ! 694: } ! 695: } ! 696: *cp = 0; ! 697: while (*--cp == ' ') ! 698: *cp = 0; ! 699: cp = (char *)ip; ! 700: (void) strncpy(cmdbuf, cp, &argspac.argc[CLBYTES*2] - cp); ! 701: if (cp[0] == '-' || cp[0] == '?' || cp[0] <= ' ') { ! 702: (void) strcat(cmdbuf, " ("); ! 703: (void) strncat(cmdbuf, p->p_comm, sizeof(p->p_comm)); ! 704: (void) strcat(cmdbuf, ")"); ! 705: } ! 706: return (cmdbuf); ! 707: ! 708: bad: ! 709: seterr("error locating command name for pid %d from %s\n", ! 710: p->p_pid, file); ! 711: retucomm: ! 712: (void) strcpy(cmdbuf, " ("); ! 713: (void) strncat(cmdbuf, p->p_comm, sizeof (p->p_comm)); ! 714: (void) strcat(cmdbuf, ")"); ! 715: return (cmdbuf); ! 716: } ! 717: ! 718: ! 719: static ! 720: getkvars() ! 721: { ! 722: ! 723: if (kvm_nlist(nl) == -1) ! 724: return (-1); ! 725: if (deadkernel) { ! 726: /* We must do the sys map first because klseek uses it */ ! 727: long addr; ! 728: ! 729: Syssize = nl[X_SYSSIZE].n_value; ! 730: Sysmap = (struct pte *) ! 731: calloc((unsigned) Syssize, sizeof (struct pte)); ! 732: if (Sysmap == NULL) { ! 733: seterr("out of space for Sysmap"); ! 734: return (-1); ! 735: } ! 736: addr = (long) nl[X_SYSMAP].n_value; ! 737: addr &= ~KERNBASE; ! 738: (void) lseek(kmem, addr, 0); ! 739: if (read(kmem, (char *) Sysmap, Syssize * sizeof (struct pte)) ! 740: != Syssize * sizeof (struct pte)) { ! 741: seterr("can't read Sysmap"); ! 742: return (-1); ! 743: } ! 744: #if defined(hp300) ! 745: addr = (long) nl[X_LOWRAM].n_value; ! 746: (void) lseek(kmem, addr, 0); ! 747: if (read(kmem, (char *) &lowram, sizeof (lowram)) ! 748: != sizeof (lowram)) { ! 749: seterr("can't read lowram"); ! 750: return (-1); ! 751: } ! 752: lowram = btop(lowram); ! 753: #endif ! 754: } ! 755: usrpt = (struct pte *)nl[X_USRPT].n_value; ! 756: Usrptmap = (struct pte *)nl[X_USRPTMAP].n_value; ! 757: if (kvm_read((long)nl[X_NSWAP].n_value, &nswap, sizeof (long)) != ! 758: sizeof (long)) { ! 759: seterr("can't read nswap"); ! 760: return (-1); ! 761: } ! 762: if (kvm_read((long)nl[X_DMMIN].n_value, &dmmin, sizeof (long)) != ! 763: sizeof (long)) { ! 764: seterr("can't read dmmin"); ! 765: return (-1); ! 766: } ! 767: if (kvm_read((long)nl[X_DMMAX].n_value, &dmmax, sizeof (long)) != ! 768: sizeof (long)) { ! 769: seterr("can't read dmmax"); ! 770: return (-1); ! 771: } ! 772: return (0); ! 773: } ! 774: ! 775: kvm_read(loc, buf, len) ! 776: unsigned long loc; ! 777: char *buf; ! 778: { ! 779: if (kvmfilesopen == 0 && kvm_openfiles(NULL, NULL, NULL) == -1) ! 780: return (-1); ! 781: if (iskva(loc)) { ! 782: klseek(kmem, loc, 0); ! 783: if (read(kmem, buf, len) != len) { ! 784: seterr("error reading kmem at %x\n", loc); ! 785: return (-1); ! 786: } ! 787: } else { ! 788: lseek(mem, loc, 0); ! 789: if (read(mem, buf, len) != len) { ! 790: seterr("error reading mem at %x\n", loc); ! 791: return (-1); ! 792: } ! 793: } ! 794: return (len); ! 795: } ! 796: ! 797: static ! 798: klseek(fd, loc, off) ! 799: int fd; ! 800: off_t loc; ! 801: int off; ! 802: { ! 803: ! 804: if (deadkernel) { ! 805: off_t vtophys(); ! 806: ! 807: if ((loc = vtophys(loc)) == -1) ! 808: return; ! 809: } ! 810: (void) lseek(fd, (off_t)loc, off); ! 811: } ! 812: ! 813: /* ! 814: * Given a base/size pair in virtual swap area, ! 815: * return a physical base/size pair which is the ! 816: * (largest) initial, physically contiguous block. ! 817: */ ! 818: static ! 819: vstodb(vsbase, vssize, dmp, dbp, rev) ! 820: register int vsbase; ! 821: int vssize; ! 822: struct dmap *dmp; ! 823: register struct dblock *dbp; ! 824: { ! 825: register int blk = dmmin; ! 826: register swblk_t *ip = dmp->dm_map; ! 827: ! 828: vsbase = ctod(vsbase); ! 829: vssize = ctod(vssize); ! 830: if (vsbase < 0 || vsbase + vssize > dmp->dm_size) ! 831: /*panic("vstodb")*/; ! 832: while (vsbase >= blk) { ! 833: vsbase -= blk; ! 834: if (blk < dmmax) ! 835: blk *= 2; ! 836: ip++; ! 837: } ! 838: if (*ip <= 0 || *ip + blk > nswap) ! 839: /*panic("vstodb")*/; ! 840: dbp->db_size = MIN(vssize, blk - vsbase); ! 841: dbp->db_base = *ip + (rev ? blk - (vsbase + dbp->db_size) : vsbase); ! 842: } ! 843: ! 844: static off_t ! 845: vtophys(loc) ! 846: long loc; ! 847: { ! 848: int p; ! 849: off_t newloc; ! 850: register struct pte *pte; ! 851: ! 852: newloc = loc & ~KERNBASE; ! 853: p = btop(newloc); ! 854: #if defined(vax) || defined(tahoe) ! 855: if ((loc & KERNBASE) == 0) { ! 856: seterr("vtophys: translating non-kernel address"); ! 857: return((off_t) -1); ! 858: } ! 859: #endif ! 860: if (p >= Syssize) { ! 861: seterr("vtophys: page out of bound (%d>=%d)", p, Syssize); ! 862: return((off_t) -1); ! 863: } ! 864: pte = &Sysmap[p]; ! 865: if (pte->pg_v == 0 && (pte->pg_fod || pte->pg_pfnum == 0)) { ! 866: seterr("vtophys: page not valid"); ! 867: return((off_t) -1); ! 868: } ! 869: #if defined(hp300) ! 870: if (pte->pg_pfnum < lowram) { ! 871: seterr("vtophys: non-RAM page (%d<%d)", pte->pg_pfnum, lowram); ! 872: return((off_t) -1); ! 873: } ! 874: #endif ! 875: loc = (long) (ptob(pftoc(pte->pg_pfnum)) + (loc & PGOFSET)); ! 876: return(loc); ! 877: } ! 878: ! 879: #include <varargs.h> ! 880: static char errbuf[_BSD_LINE_MAX]; ! 881: ! 882: static ! 883: seterr(va_alist) ! 884: va_dcl ! 885: { ! 886: char *fmt; ! 887: va_list ap; ! 888: ! 889: va_start(ap); ! 890: fmt = va_arg(ap, char *); ! 891: (void) vsprintf(errbuf, fmt, ap); ! 892: va_end(ap); ! 893: } ! 894: ! 895: static ! 896: setsyserr(va_alist) ! 897: va_dcl ! 898: { ! 899: char *fmt, *cp; ! 900: va_list ap; ! 901: extern int errno; ! 902: ! 903: va_start(ap); ! 904: fmt = va_arg(ap, char *); ! 905: (void) vsprintf(errbuf, fmt, ap); ! 906: for (cp=errbuf; *cp; cp++) ! 907: ; ! 908: sprintf(cp, ": %s", strerror(errno)); ! 909: va_end(ap); ! 910: } ! 911: ! 912: char * ! 913: kvm_geterr() ! 914: { ! 915: return (errbuf); ! 916: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.