2 * Copyright (c) 1988, 1993
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the University nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * @(#) Copyright (c) 1988, 1993 The Regents of the University of California. All rights reserved.
30 * @(#)fstat.c 8.3 (Berkeley) 5/2/95
31 * $FreeBSD: src/usr.bin/fstat/fstat.c,v 1.21.2.7 2001/11/21 10:49:37 dwmalone Exp $
35 #include <sys/param.h>
38 #include <sys/vnode.h>
39 #include <sys/socket.h>
40 #include <sys/socketvar.h>
41 #include <sys/domain.h>
42 #include <sys/protosw.h>
44 #include <sys/unpcb.h>
45 #include <sys/sysctl.h>
46 #include <sys/filedesc.h>
47 #include <sys/queue.h>
51 #include <sys/ktrace.h>
52 #include <vfs/ufs/quota.h>
53 #include <vfs/ufs/inode.h>
54 #include <sys/mount.h>
55 #include <sys/namecache.h>
56 #include <vfs/nfs/nfsproto.h>
57 #include <vfs/nfs/rpcv2.h>
58 #include <vfs/nfs/nfs.h>
59 #include <vfs/nfs/nfsnode.h>
60 #include <sys/devfs.h>
63 #include <vm/vm_map.h>
64 #include <vm/vm_object.h>
66 #include <net/route.h>
67 #include <netinet/in.h>
68 #include <netinet/in_systm.h>
69 #include <netinet/ip.h>
70 #include <netinet/in_pcb.h>
96 static void make_printable(char *buf
, int len
);
104 int fsflg
, /* show files on same filesystem as file(s) argument */
105 pflg
, /* show files open by a particular pid */
106 uflg
; /* show files open by a particular (effective) user */
107 int checkfile
; /* true if restricting to particular files or filesystems */
108 int nflg
; /* (numerical) display f.s. and rdev as dev_t */
109 int vflg
; /* display errors in locating kernel data objects etc... */
110 int mflg
; /* include memory-mapped files */
120 struct fdnode
*ofiles
; /* buffer of pointers to file structures */
123 #define ALLOC_OFILES(d) \
124 if ((d) > maxfiles) { \
126 ofiles = malloc((d) * sizeof(struct fdnode)); \
127 if (ofiles == NULL) { \
135 static void dofiles(struct kinfo_proc
*, struct proc
*);
136 static void dommap(struct proc
*);
137 static void vtrans_reset(void);
138 static void vtrans(struct vnode
*, struct nchandle
*, int, int, off_t
);
139 static int ufs_filestat(struct vnode
*, struct filestat
*);
140 static int nfs_filestat(struct vnode
*, struct filestat
*);
141 static int devfs_filestat(struct vnode
*, struct filestat
*);
142 static char *getmnton(struct mount
*, struct namecache_list
*, struct nchandle
*);
143 static void pipetrans(struct pipe
*, int, int);
144 static void socktrans(struct socket
*, int);
145 static void getinetproto(int);
146 static int getfname(const char *);
147 static void usage(void) __dead2
;
151 main(int argc
, char **argv
)
153 struct passwd
*passwd
;
154 struct kinfo_proc
*p
, *plast
;
158 char buf
[_POSIX2_LINE_MAX
];
162 what
= KERN_PROC_ALL
;
163 nlistf
= memf
= NULL
;
164 while ((ch
= getopt(argc
, argv
, "fmnp:u:vwN:M:")) != -1)
184 if (!isdigit(*optarg
)) {
185 warnx("-p requires a process id");
188 what
= KERN_PROC_PID
;
194 if (!(passwd
= getpwnam(optarg
)))
195 errx(1, "%s: unknown uid", optarg
);
196 what
= KERN_PROC_UID
;
197 arg
= passwd
->pw_uid
;
211 if (*(argv
+= optind
)) {
212 for (; *argv
; ++argv
) {
216 if (!checkfile
) /* file(s) specified, but none accessable */
220 ALLOC_OFILES(256); /* reserve space for file pointers */
222 if (fsflg
&& !checkfile
) {
223 /* -f with no files means use wd */
224 if (getfname(".") == 0)
230 * Discard setgid privileges if not the running kernel so that bad
231 * guys can't print interesting stuff from kernel memory.
233 if (nlistf
!= NULL
|| memf
!= NULL
)
236 if ((kd
= kvm_openfiles(nlistf
, memf
, NULL
, O_RDONLY
, buf
)) == NULL
)
239 if (kvm_nlist(kd
, nl
) != 0)
240 errx(1, "no namelist: %s", kvm_geterr(kd
));
242 if ((p
= kvm_getprocs(kd
, what
, arg
, &cnt
)) == NULL
)
243 errx(1, "%s", kvm_geterr(kd
));
245 printf("USER %-*.*s %*.*s FD DEV %*.*s MODE SZ|DV R/W",
246 wflg_cmd
, wflg_cmd
, "CMD",
247 pid_width
, pid_width
, "PID",
248 ino_width
, ino_width
, "INUM");
250 printf("USER %-*.*s %*.*s FD %-*.*s %*.*s MODE SZ|DV R/W",
251 wflg_cmd
, wflg_cmd
, "CMD",
252 pid_width
, pid_width
, "PID",
253 wflg_mnt
, wflg_mnt
, "PATH",
254 ino_width
, ino_width
, "INUM");
255 if (checkfile
&& fsflg
== 0)
260 for (plast
= &p
[cnt
]; p
< plast
; ++p
) {
261 if (p
->kp_stat
== SZOMB
)
263 if (!kread((void *)p
->kp_paddr
, &proc
, sizeof(proc
))) {
264 dprintf(stderr
, "can't read proc at %p for pid %d\n",
265 (void *)p
->kp_paddr
, Pid
);
276 printf("%-8.8s %-*s %*d", Uname, wflg_cmd, Comm, pid_width, Pid); \
299 * print open files attributed to this process
302 dofiles(struct kinfo_proc
*kp
, struct proc
*p
)
306 struct filedesc filed
;
307 struct ktrace_node ktrace_node
;
309 Uname
= user_from_uid(kp
->kp_uid
, 0);
312 make_printable(Comm
, strlen(Comm
));
316 if (!kread(p
->p_fd
, &filed
, sizeof (filed
))) {
317 dprintf(stderr
, "can't read filedesc at %p for pid %d\n",
318 (void *)p
->p_fd
, Pid
);
325 * root directory vnode, if one
328 vtrans(filed
.fd_rdir
, &filed
.fd_nrdir
, RDIR
, FREAD
, 0);
330 * current working directory vnode
332 vtrans(filed
.fd_cdir
, &filed
.fd_ncdir
, CDIR
, FREAD
, 0);
334 * ktrace vnode, if one
336 if (p
->p_tracenode
) {
337 if (kread(p
->p_tracenode
, &ktrace_node
, sizeof (ktrace_node
)))
338 vtrans(ktrace_node
.kn_vp
, NULL
, TRACE
, FREAD
|FWRITE
, 0);
344 vtrans(p
->p_textvp
, NULL
, TEXT
, FREAD
, 0);
348 ALLOC_OFILES(filed
.fd_lastfile
+1);
349 if (!kread(filed
.fd_files
, ofiles
,
350 (filed
.fd_lastfile
+1) * sizeof(struct fdnode
))) {
352 "can't read file structures at %p for pid %d\n",
353 (void *)filed
.fd_files
, Pid
);
356 for (i
= 0; i
<= filed
.fd_lastfile
; i
++) {
357 if (ofiles
[i
].fp
== NULL
)
359 if (!kread(ofiles
[i
].fp
, &file
, sizeof (struct file
))) {
360 dprintf(stderr
, "can't read file %d at %p for pid %d\n",
361 i
, (void *)ofiles
[i
].fp
, Pid
);
364 if (file
.f_type
== DTYPE_VNODE
) {
365 vtrans((struct vnode
*)file
.f_data
, &file
.f_nchandle
,
366 i
, file
.f_flag
, file
.f_offset
);
367 } else if (file
.f_type
== DTYPE_SOCKET
) {
369 socktrans((struct socket
*)file
.f_data
, i
);
372 else if (file
.f_type
== DTYPE_PIPE
) {
374 pipetrans((struct pipe
*)file
.f_data
, i
,
379 else if (file
.f_type
== DTYPE_FIFO
) {
381 vtrans((struct vnode
*)file
.f_data
,
383 i
, file
.f_flag
, file
.f_offset
);
388 "unknown file type %d for file %d of pid %d\n",
389 file
.f_type
, i
, Pid
);
395 dommap(struct proc
*p
)
397 struct vmspace vmspace
;
399 struct vm_map_entry entry
;
401 struct vm_object object
;
402 struct vm_map_backing ba
;
406 if (!kread(p
->p_vmspace
, &vmspace
, sizeof(vmspace
))) {
407 dprintf(stderr
, "can't read vmspace at %p for pid %d\n",
408 (void *)p
->p_vmspace
, Pid
);
412 map
= &vmspace
.vm_map
;
413 for (ken
= kvm_vm_map_entry_first(kd
, map
, &entry
);
414 ken
; ken
= kvm_vm_map_entry_next(kd
, ken
, &entry
)) {
415 if (entry
.maptype
== VM_MAPTYPE_SUBMAP
)
418 if (entry
.ba
.object
== NULL
)
422 if ((objp
= entry
.ba
.object
) != NULL
) {
423 if (!kread(objp
, &object
, sizeof(object
))) {
425 "can't read vm_object at %p "
431 if (ba
.backing_ba
== NULL
)
433 if (!kread(ba
.backing_ba
, &ba
, sizeof(ba
))) {
435 "can't read map_backing at %p "
437 (void *)ba
.backing_ba
, Pid
);
442 prot
= entry
.protection
;
443 fflags
= (prot
& VM_PROT_READ
? FREAD
: 0) |
444 (prot
& VM_PROT_WRITE
? FWRITE
: 0);
446 switch (object
.type
) {
448 vtrans((struct vnode
*)object
.handle
, NULL
,
457 static int last_name_width
;
466 vtrans(struct vnode
*vp
, struct nchandle
*ncr
, int i
, int flag
, off_t off
)
470 char rw
[3], mode
[15];
471 const char *badtype
= NULL
, *filename
;
477 filename
= badtype
= NULL
;
478 if (!kread(vp
, &vn
, sizeof (struct vnode
))) {
479 dprintf(stderr
, "can't read vnode at %p for pid %d\n",
483 if (vn
.v_type
== VNON
|| vn
.v_tag
== VT_NON
) {
485 } else if (vn
.v_type
== VBAD
) {
490 if (!hammer_filestat(&vn
, &fst
))
494 if (!hammer2_filestat(&vn
, &fst
))
498 if (!tmpfs_filestat(&vn
, &fst
))
502 if (!ufs_filestat(&vn
, &fst
))
506 if (!ufs_filestat(&vn
, &fst
))
510 if (!nfs_filestat(&vn
, &fst
))
514 if (!ntfs_filestat(&vn
, &fst
))
518 if (!ext2fs_filestat(&vn
, &fst
))
523 if (!msdosfs_filestat(&vn
, &fst
))
528 if (!isofs_filestat(&vn
, &fst
))
533 if (!devfs_filestat(&vn
, &fst
))
539 static char unknown
[10];
541 sprintf(unknown
, "?(%x)", vn
.v_tag
);
553 for (d
= devs
; d
!= NULL
; d
= d
->next
)
554 if (d
->fsid
== fst
.fsid
) {
556 if (d
->ino
== (ino_t
)fst
.fileid
) {
561 if (fsmatch
== 0 || (filename
== NULL
&& fsflg
== 0))
567 * Retrieve variable-length file path and try to make
568 * indentation human-readable.
571 asprintf(&name
, "%s",
572 getmnton(vn
.v_mount
, &vn
.v_namecache
, ncr
));
574 asprintf(&name
, "%3u,%-9u",
575 major(fst
.fsid
), minor(fst
.fsid
));
577 asprintf(&name
, "%s",
578 getmnton(vn
.v_mount
, &vn
.v_namecache
, ncr
));
580 len
= (int)strlen(name
);
583 * Nominal extra-space indented in multiples of 4
585 extra_space
= wflg_mnt
- len
;
587 extra_space
= 4 - -extra_space
% 4;
589 if (len
+ extra_space
< last_name_width
)
590 extra_space
= last_name_width
- len
;
591 last_name_width
= len
+ extra_space
;
593 printf(" %s%*.*s ", name
, extra_space
, extra_space
, "");
601 printf("%10s %8s:%jd\n",
602 badtype
, "offset", (intmax_t)off
);
607 sprintf(mode
, "%06o", fst
.mode
);
608 printf("%*ld %s", ino_width
, fst
.fileid
, mode
);
610 strmode(fst
.mode
, mode
);
611 printf("%*ld %10s", ino_width
, fst
.fileid
, mode
);
618 ((name
= devname(fst
.rdev
, vn
.v_type
== VCHR
?
619 S_IFCHR
: S_IFBLK
)) == NULL
)) {
620 printf(" %3u,%-4u", major(fst
.rdev
), minor(fst
.rdev
));
622 printf(" %8s", name
);
624 printf(":%jd", (intmax_t)fst
.offset
);
627 printf(" %8s:%ju", "offset", (intmax_t)fst
.offset
);
630 printf(" %8s:%ju", "offset", (uintmax_t)fst
.size
);
638 if (filename
&& !fsflg
)
639 printf(" %s", filename
);
644 ufs_filestat(struct vnode
*vp
, struct filestat
*fsp
)
648 if (!kread(VTOI(vp
), &inode
, sizeof (inode
))) {
649 dprintf(stderr
, "can't read inode at %p for pid %d\n",
650 (void *)VTOI(vp
), Pid
);
654 * The st_dev from stat(2) is a dev_t. These kernel structures
655 * contain cdev_t structures. We need to convert to udev to make
658 fsp
->fsid
= fstat_dev2udev(inode
.i_dev
);
659 fsp
->fileid
= (long)inode
.i_number
;
660 fsp
->mode
= (mode_t
)inode
.i_mode
;
661 fsp
->size
= inode
.i_size
;
662 fsp
->rdev
= inode
.i_rdev
;
668 nfs_filestat(struct vnode
*vp
, struct filestat
*fsp
)
670 struct nfsnode nfsnode
;
672 if (!kread(VTONFS(vp
), &nfsnode
, sizeof (nfsnode
))) {
673 dprintf(stderr
, "can't read nfsnode at %p for pid %d\n",
674 (void *)VTONFS(vp
), Pid
);
677 fsp
->fsid
= nfsnode
.n_vattr
.va_fsid
;
678 fsp
->fileid
= nfsnode
.n_vattr
.va_fileid
;
679 fsp
->size
= nfsnode
.n_size
;
680 fsp
->rdev
= makeudev(nfsnode
.n_vattr
.va_rmajor
,
681 nfsnode
.n_vattr
.va_rminor
);
682 fsp
->mode
= nfsnode
.n_vattr
.va_mode
| mtrans(vp
->v_type
);
688 devfs_filestat(struct vnode
*vp
, struct filestat
*fsp
)
690 struct devfs_node devfs_node
;
692 if (!kread(vp
->v_data
, &devfs_node
, sizeof (devfs_node
))) {
693 dprintf(stderr
, "can't read devfs_node at %p for pid %d\n",
694 (void *)vp
->v_data
, Pid
);
697 fsp
->fsid
= fsp
->rdev
= fstat_dev2udev(vp
->v_rdev
);
698 fsp
->fileid
= devfs_node
.d_dir
.d_ino
;
699 fsp
->mode
= (devfs_node
.mode
& ~S_IFMT
) | S_IFCHR
;
706 getmnton(struct mount
*m
, struct namecache_list
*ncplist
, struct nchandle
*ncr
)
708 static struct mount mount_l
;
712 char mntonname
[MNAMELEN
];
715 struct namecache
*ncp
;
716 struct namecache ncp_copy
;
717 static char path
[1024];
721 * If no ncp is passed try to find one via ncplist. Make sure
722 * we are using the correct mount pointer or the matching code
723 * will not know how to transition mount points properly.
725 if (ncr
== NULL
|| ncr
->ncp
== NULL
) {
726 ncp
= ncplist
->tqh_first
;
734 * If we have an ncp, traceback the path. This is a kvm pointer.
737 if (!kread(m
, &mount_l
, sizeof(struct mount
))) {
738 warnx("can't read mount table at %p", (void *)m
);
741 i
= sizeof(path
) - 1;
745 * If this is the root of the mount then traverse
746 * to the parent mount.
748 if (ncp
== mount_l
.mnt_ncmountpt
.ncp
) {
749 ncp
= mount_l
.mnt_ncmounton
.ncp
;
752 m
= mount_l
.mnt_ncmounton
.mount
;
753 if (!kread(m
, &mount_l
, sizeof(struct mount
))) {
754 warnx("can't read mount table at %p", (void *)m
);
760 * Ok, pull out the ncp and extract the name
762 if (!kread(ncp
, &ncp_copy
, sizeof(ncp_copy
))) {
763 warnx("can't read ncp at %p", ncp
);
766 if (i
<= ncp_copy
.nc_nlen
)
768 i
-= ncp_copy
.nc_nlen
;
769 if (!kread(ncp_copy
.nc_name
, path
+ i
, ncp_copy
.nc_nlen
)) {
770 warnx("can't read ncp %p path component at %p", ncp
, ncp_copy
.nc_name
);
773 make_printable(path
+ i
, ncp_copy
.nc_nlen
);
775 ncp
= ncp_copy
.nc_parent
;
777 if (i
== sizeof(path
) - 1)
783 * If all else fails print out the mount point path
785 for (mt
= mhead
; mt
!= NULL
; mt
= mt
->next
) {
787 return (mt
->mntonname
);
789 if (!kread(m
, &mount_l
, sizeof(struct mount
))) {
790 warnx("can't read mount table at %p", (void *)m
);
793 if ((mt
= malloc(sizeof (struct mtab
))) == NULL
)
796 bcopy(&mount_l
.mnt_stat
.f_mntonname
[0], &mt
->mntonname
[0], MNAMELEN
);
799 return (mt
->mntonname
);
803 pipetrans(struct pipe
*pi
, int i
, int flag
)
813 if ((intptr_t)pi
& 1) {
824 pi
= (void *)((intptr_t)pi
& ~(intptr_t)1);
827 if (!kread(pi
, &pip
, sizeof(struct pipe
))) {
828 dprintf(stderr
, "can't read pipe at %p\n", (void *)pi
);
832 printf("* pipe %8lx (%c<->%c)", (u_long
)pi
, side1
, side2
);
833 printf(" ravail %-zu wavail %-zu",
834 b1
->windex
- b1
->rindex
,
835 b2
->windex
- b2
->rindex
);
850 socktrans(struct socket
*sock
, int i
)
852 static const char *stypename
[] = {
862 struct protosw proto
;
872 if (!kread(sock
, &so
, sizeof(struct socket
))) {
873 dprintf(stderr
, "can't read sock at %p\n", (void *)sock
);
877 /* fill in protosw entry */
878 if (!kread(so
.so_proto
, &proto
, sizeof(struct protosw
))) {
879 dprintf(stderr
, "can't read protosw at %p",
880 (void *)so
.so_proto
);
885 if (!kread(proto
.pr_domain
, &dom
, sizeof(struct domain
))) {
886 dprintf(stderr
, "can't read domain at %p\n",
887 (const void *)proto
.pr_domain
);
891 if ((len
= kvm_read(kd
, (u_long
)dom
.dom_name
, dname
,
892 sizeof(dname
) - 1)) < 0) {
893 dprintf(stderr
, "can't read domain name at %p\n",
894 (void *)dom
.dom_name
);
900 if ((u_short
)so
.so_type
> STYPEMAX
)
901 printf("* %-9s ?%d", dname
, so
.so_type
);
903 printf("* %-9s %s", dname
, stypename
[so
.so_type
]);
906 * protocol specific formatting
908 * Try to find interesting things to print. For tcp, the interesting
909 * thing is the address of the tcpcb, for udp and others, just the
910 * inpcb (socket pcb). For unix domain, its the address of the socket
911 * pcb and the address of the connected pcb (if connected). Otherwise
912 * just print the protocol number and address of the socket itself.
913 * The idea is not to duplicate netstat, but to make available enough
914 * information for further analysis.
916 switch(dom
.dom_family
) {
919 getinetproto(proto
.pr_protocol
);
920 if (proto
.pr_protocol
== IPPROTO_TCP
) {
922 if (kvm_read(kd
, (u_long
)so
.so_pcb
,
923 (char *)&inpcb
, sizeof(struct inpcb
))
924 != sizeof(struct inpcb
)) {
926 "can't read inpcb at %p\n",
930 printf(" %lx", (u_long
)inpcb
.inp_ppcb
);
934 printf(" %lx", (u_long
)so
.so_pcb
);
937 /* print address of pcb and connected pcb */
939 printf(" %lx", (u_long
)so
.so_pcb
);
940 if (kvm_read(kd
, (u_long
)so
.so_pcb
, (char *)&unpcb
,
941 sizeof(struct unpcb
)) != sizeof(struct unpcb
)){
942 dprintf(stderr
, "can't read unpcb at %p\n",
946 if (unpcb
.unp_conn
) {
947 char shoconn
[4], *cp
;
950 if (!(so
.so_state
& SS_CANTRCVMORE
))
953 if (!(so
.so_state
& SS_CANTSENDMORE
))
956 printf(" %s %lx", shoconn
,
957 (u_long
)unpcb
.unp_conn
);
962 /* print protocol number and socket address */
963 printf(" %d %lx", proto
.pr_protocol
, (u_long
)sock
);
973 * Read the cdev structure in the kernel (as pointed to by a cdev_t)
974 * in order to work out the associated dev_t
977 fstat_dev2udev(cdev_t dev
)
981 if (kread(dev
, &si
, sizeof si
)) {
982 if ((si
.si_umajor
& 0xffffff00) ||
983 (si
.si_uminor
& 0x0000ff00)) {
986 return((si
.si_umajor
<< 8) | si
.si_uminor
);
988 dprintf(stderr
, "can't convert cdev_t %p to a dev_t\n", dev
);
994 makeudev(int x
, int y
)
996 if ((x
& 0xffffff00) || (y
& 0x0000ff00))
998 return ((x
<< 8) | y
);
1003 * print name of protocol number
1006 getinetproto(int number
)
1009 struct protoent
*pe
;
1012 setprotoent(++isopen
);
1013 if ((pe
= getprotobynumber(number
)) != NULL
)
1014 printf(" %s", pe
->p_name
);
1016 printf(" %d", number
);
1020 getfname(const char *filename
)
1022 struct stat statbuf
;
1025 if (stat(filename
, &statbuf
)) {
1026 warn("%s", filename
);
1029 if ((cur
= malloc(sizeof(DEVS
))) == NULL
)
1034 cur
->ino
= statbuf
.st_ino
;
1035 cur
->fsid
= statbuf
.st_dev
;
1036 cur
->name
= filename
;
1043 (void)fprintf(stderr
,
1044 "usage: fstat [-fmnv] [-p pid] [-u user] [-N system] [-M core] [file ...]\n");
1050 make_printable(char *buf
, int len
)
1061 kread(const void *kaddr
, void *uaddr
, size_t nbytes
)
1063 if (nbytes
> 0x10000000)
1066 if (kvm_read(kd
, (u_long
)kaddr
, (char *)uaddr
, nbytes
) == (ssize_t
)nbytes
)