1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 2009 Stanislav Sedov <[email protected]>
5 * Copyright (c) 1988, 1993
6 * The Regents of the University of California. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the University nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33 #include <sys/cdefs.h>
34 #include <sys/param.h>
35 #include <sys/user.h>
36 #include <sys/stat.h>
37 #include <sys/socket.h>
38 #include <sys/socketvar.h>
39 #include <sys/sysctl.h>
40 #include <sys/queue.h>
41 #include <sys/un.h>
42
43 #include <netinet/in.h>
44
45 #include <arpa/inet.h>
46
47 #include <assert.h>
48 #include <ctype.h>
49 #include <err.h>
50 #include <libprocstat.h>
51 #include <limits.h>
52 #include <pwd.h>
53 #include <stdint.h>
54 #include <stdio.h>
55 #include <stdlib.h>
56 #include <stddef.h>
57 #include <string.h>
58 #include <unistd.h>
59 #include <netdb.h>
60
61 #include "functions.h"
62
63 static int fsflg, /* show files on same filesystem as file(s) argument */
64 pflg, /* show files open by a particular pid */
65 sflg, /* show socket details */
66 uflg; /* show files open by a particular (effective) user */
67 static int checkfile; /* restrict to particular files or filesystems */
68 static int nflg; /* (numerical) display f.s. and rdev as dev_t */
69 static int mflg; /* include memory-mapped files */
70 static int vflg; /* be verbose */
71
72 typedef struct devs {
73 struct devs *next;
74 uint64_t fsid;
75 uint64_t ino;
76 const char *name;
77 } DEVS;
78
79 static DEVS *devs;
80 static char *memf, *nlistf;
81
82 static int getfname(const char *filename);
83 static void dofiles(struct procstat *procstat, struct kinfo_proc *p);
84 static void print_access_flags(int flags);
85 static void print_file_info(struct procstat *procstat,
86 struct filestat *fst, const char *uname, const char *cmd, int pid);
87 static void print_pipe_info(struct procstat *procstat,
88 struct filestat *fst);
89 static void print_pts_info(struct procstat *procstat,
90 struct filestat *fst);
91 static void print_sem_info(struct procstat *procstat,
92 struct filestat *fst);
93 static void print_shm_info(struct procstat *procstat,
94 struct filestat *fst);
95 static void print_socket_info(struct procstat *procstat,
96 struct filestat *fst);
97 static void print_vnode_info(struct procstat *procstat,
98 struct filestat *fst);
99 static void usage(void) __dead2;
100
101 int
do_fstat(int argc,char ** argv)102 do_fstat(int argc, char **argv)
103 {
104 struct kinfo_proc *p;
105 struct passwd *passwd;
106 struct procstat *procstat;
107 int arg, ch, what;
108 int cnt, i;
109
110 arg = 0;
111 what = KERN_PROC_PROC;
112 nlistf = memf = NULL;
113 while ((ch = getopt(argc, argv, "fmnp:su:vN:M:")) != -1)
114 switch((char)ch) {
115 case 'f':
116 fsflg = 1;
117 break;
118 case 'M':
119 memf = optarg;
120 break;
121 case 'N':
122 nlistf = optarg;
123 break;
124 case 'm':
125 mflg = 1;
126 break;
127 case 'n':
128 nflg = 1;
129 break;
130 case 'p':
131 if (pflg++)
132 usage();
133 if (!isdigit(*optarg)) {
134 warnx("-p requires a process id");
135 usage();
136 }
137 what = KERN_PROC_PID;
138 arg = atoi(optarg);
139 break;
140 case 's':
141 sflg = 1;
142 break;
143 case 'u':
144 if (uflg++)
145 usage();
146 if (!(passwd = getpwnam(optarg)))
147 errx(1, "%s: unknown uid", optarg);
148 what = KERN_PROC_UID;
149 arg = passwd->pw_uid;
150 break;
151 case 'v':
152 vflg = 1;
153 break;
154 case '?':
155 default:
156 usage();
157 }
158
159 if (*(argv += optind)) {
160 for (; *argv; ++argv) {
161 if (getfname(*argv))
162 checkfile = 1;
163 }
164 if (!checkfile) /* file(s) specified, but none accessible */
165 exit(1);
166 }
167
168 if (fsflg && !checkfile) {
169 /* -f with no files means use wd */
170 if (getfname(".") == 0)
171 exit(1);
172 checkfile = 1;
173 }
174
175 if (memf != NULL)
176 procstat = procstat_open_kvm(nlistf, memf);
177 else
178 procstat = procstat_open_sysctl();
179 if (procstat == NULL)
180 errx(1, "procstat_open()");
181 p = procstat_getprocs(procstat, what, arg, &cnt);
182 if (p == NULL)
183 errx(1, "procstat_getprocs()");
184
185 /*
186 * Print header.
187 */
188 if (nflg)
189 printf("%s",
190 "USER CMD PID FD DEV INUM MODE SZ|DV R/W");
191 else
192 printf("%s",
193 "USER CMD PID FD MOUNT INUM MODE SZ|DV R/W");
194 if (checkfile && fsflg == 0)
195 printf(" NAME\n");
196 else
197 putchar('\n');
198
199 /*
200 * Go through the process list.
201 */
202 for (i = 0; i < cnt; i++) {
203 if (p[i].ki_stat == SZOMB)
204 continue;
205 dofiles(procstat, &p[i]);
206 }
207 procstat_freeprocs(procstat, p);
208 procstat_close(procstat);
209 return (0);
210 }
211
212 static void
dofiles(struct procstat * procstat,struct kinfo_proc * kp)213 dofiles(struct procstat *procstat, struct kinfo_proc *kp)
214 {
215 const char *cmd;
216 const char *uname;
217 struct filestat *fst;
218 struct filestat_list *head;
219 int pid;
220
221 uname = user_from_uid(kp->ki_uid, 0);
222 pid = kp->ki_pid;
223 cmd = kp->ki_comm;
224
225 head = procstat_getfiles(procstat, kp, mflg);
226 if (head == NULL)
227 return;
228 STAILQ_FOREACH(fst, head, next)
229 print_file_info(procstat, fst, uname, cmd, pid);
230 procstat_freefiles(procstat, head);
231 }
232
233
234 static void
print_file_info(struct procstat * procstat,struct filestat * fst,const char * uname,const char * cmd,int pid)235 print_file_info(struct procstat *procstat, struct filestat *fst,
236 const char *uname, const char *cmd, int pid)
237 {
238 struct vnstat vn;
239 DEVS *d;
240 const char *filename;
241 int error, fsmatch = 0;
242 char errbuf[_POSIX2_LINE_MAX];
243
244 filename = NULL;
245 if (checkfile != 0) {
246 if (fst->fs_type != PS_FST_TYPE_VNODE &&
247 fst->fs_type != PS_FST_TYPE_FIFO)
248 return;
249 error = procstat_get_vnode_info(procstat, fst, &vn, errbuf);
250 if (error != 0)
251 return;
252
253 for (d = devs; d != NULL; d = d->next)
254 if (d->fsid == vn.vn_fsid) {
255 fsmatch = 1;
256 if (d->ino == vn.vn_fileid) {
257 filename = d->name;
258 break;
259 }
260 }
261 if (fsmatch == 0 || (filename == NULL && fsflg == 0))
262 return;
263 }
264
265 /*
266 * Print entry prefix.
267 */
268 printf("%-8.8s %-10s %5d", uname, cmd, pid);
269 if (fst->fs_uflags & PS_FST_UFLAG_TEXT)
270 printf(" text");
271 else if (fst->fs_uflags & PS_FST_UFLAG_CDIR)
272 printf(" wd");
273 else if (fst->fs_uflags & PS_FST_UFLAG_RDIR)
274 printf(" root");
275 else if (fst->fs_uflags & PS_FST_UFLAG_TRACE)
276 printf(" tr");
277 else if (fst->fs_uflags & PS_FST_UFLAG_MMAP)
278 printf(" mmap");
279 else if (fst->fs_uflags & PS_FST_UFLAG_JAIL)
280 printf(" jail");
281 else if (fst->fs_uflags & PS_FST_UFLAG_CTTY)
282 printf(" ctty");
283 else
284 printf(" %4d", fst->fs_fd);
285
286 /*
287 * Print type-specific data.
288 */
289 switch (fst->fs_type) {
290 case PS_FST_TYPE_FIFO:
291 case PS_FST_TYPE_VNODE:
292 print_vnode_info(procstat, fst);
293 break;
294 case PS_FST_TYPE_SOCKET:
295 print_socket_info(procstat, fst);
296 break;
297 case PS_FST_TYPE_PIPE:
298 print_pipe_info(procstat, fst);
299 break;
300 case PS_FST_TYPE_PTS:
301 print_pts_info(procstat, fst);
302 break;
303 case PS_FST_TYPE_SHM:
304 print_shm_info(procstat, fst);
305 break;
306 case PS_FST_TYPE_SEM:
307 print_sem_info(procstat, fst);
308 break;
309 case PS_FST_TYPE_DEV:
310 break;
311 default:
312 if (vflg)
313 fprintf(stderr,
314 "unknown file type %d for file %d of pid %d\n",
315 fst->fs_type, fst->fs_fd, pid);
316 }
317 if (filename && !fsflg)
318 printf(" %s", filename);
319 putchar('\n');
320 }
321
322 static char *
addr_to_string(struct sockaddr_storage * ss,char * buffer,int buflen)323 addr_to_string(struct sockaddr_storage *ss, char *buffer, int buflen)
324 {
325 char buffer2[INET6_ADDRSTRLEN];
326 struct sockaddr_in6 *sin6;
327 struct sockaddr_in *sin;
328 struct sockaddr_un *sun;
329
330 switch (ss->ss_family) {
331 case AF_LOCAL:
332 sun = (struct sockaddr_un *)ss;
333 if (strlen(sun->sun_path) == 0)
334 strlcpy(buffer, "-", buflen);
335 else
336 strlcpy(buffer, sun->sun_path, buflen);
337 break;
338
339 case AF_INET:
340 sin = (struct sockaddr_in *)ss;
341 if (sin->sin_addr.s_addr == INADDR_ANY)
342 snprintf(buffer, buflen, "%s:%d", "*",
343 ntohs(sin->sin_port));
344 else if (inet_ntop(AF_INET, &sin->sin_addr, buffer2,
345 sizeof(buffer2)) != NULL)
346 snprintf(buffer, buflen, "%s:%d", buffer2,
347 ntohs(sin->sin_port));
348 break;
349
350 case AF_INET6:
351 sin6 = (struct sockaddr_in6 *)ss;
352 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr))
353 snprintf(buffer, buflen, "%s.%d", "*",
354 ntohs(sin6->sin6_port));
355 else if (inet_ntop(AF_INET6, &sin6->sin6_addr, buffer2,
356 sizeof(buffer2)) != NULL)
357 snprintf(buffer, buflen, "%s.%d", buffer2,
358 ntohs(sin6->sin6_port));
359 else
360 strlcpy(buffer, "-", buflen);
361 break;
362
363 default:
364 strlcpy(buffer, "", buflen);
365 break;
366 }
367 return buffer;
368 }
369
370
371 static void
print_socket_info(struct procstat * procstat,struct filestat * fst)372 print_socket_info(struct procstat *procstat, struct filestat *fst)
373 {
374 static const char *stypename[] = {
375 "unused", /* 0 */
376 "stream", /* 1 */
377 "dgram", /* 2 */
378 "raw", /* 3 */
379 "rdm", /* 4 */
380 "seqpak" /* 5 */
381 };
382 #define STYPEMAX 5
383 struct sockstat sock;
384 struct protoent *pe;
385 char errbuf[_POSIX2_LINE_MAX];
386 char src_addr[PATH_MAX], dst_addr[PATH_MAX];
387 struct sockaddr_un *sun;
388 int error;
389 static int isopen;
390
391 error = procstat_get_socket_info(procstat, fst, &sock, errbuf);
392 if (error != 0) {
393 printf("* error");
394 return;
395 }
396 if (sock.type > STYPEMAX)
397 printf("* %s ?%d", sock.dname, sock.type);
398 else
399 printf("* %s %s", sock.dname, stypename[sock.type]);
400
401 /*
402 * protocol specific formatting
403 *
404 * Try to find interesting things to print. For tcp, the interesting
405 * thing is the address of the tcpcb, for udp and others, just the
406 * inpcb (socket pcb). For unix domain, its the address of the socket
407 * pcb and the address of the connected pcb (if connected). Otherwise
408 * just print the protocol number and address of the socket itself.
409 * The idea is not to duplicate netstat, but to make available enough
410 * information for further analysis.
411 */
412 switch (sock.dom_family) {
413 case AF_INET:
414 case AF_INET6:
415 if (!isopen)
416 setprotoent(++isopen);
417 if ((pe = getprotobynumber(sock.proto)) != NULL)
418 printf(" %s", pe->p_name);
419 else
420 printf(" %d", sock.proto);
421 if (sock.proto == IPPROTO_TCP ) {
422 if (sock.inp_ppcb != 0)
423 printf(" %lx", (u_long)sock.inp_ppcb);
424 }
425 else if (sock.so_pcb != 0)
426 printf(" %lx", (u_long)sock.so_pcb);
427 if (!sflg)
428 break;
429 printf(" %s <-> %s",
430 addr_to_string(&sock.sa_local, src_addr, sizeof(src_addr)),
431 addr_to_string(&sock.sa_peer, dst_addr, sizeof(dst_addr)));
432 break;
433 case AF_UNIX:
434 /* print address of pcb and connected pcb */
435 if (sock.so_pcb != 0) {
436 printf(" %lx", (u_long)sock.so_pcb);
437 if (sock.unp_conn) {
438 char shoconn[4], *cp;
439
440 cp = shoconn;
441 if (!(sock.so_rcv_sb_state & SBS_CANTRCVMORE))
442 *cp++ = '<';
443 *cp++ = '-';
444 if (!(sock.so_snd_sb_state & SBS_CANTSENDMORE))
445 *cp++ = '>';
446 *cp = '\0';
447 printf(" %s %lx", shoconn,
448 (u_long)sock.unp_conn);
449 }
450 }
451 if (!sflg)
452 break;
453 sun = (struct sockaddr_un *)&sock.sa_local;
454 /*
455 * While generally we like to print two addresses,
456 * local and peer, for sockets, it turns out to be
457 * more useful to print the first non-null address for
458 * local sockets, as typically they aren't bound and
459 * connected, and the path strings can get long.
460 */
461 if (sun->sun_path[0] != 0)
462 addr_to_string(&sock.sa_local,
463 src_addr, sizeof(src_addr));
464 else
465 addr_to_string(&sock.sa_peer,
466 src_addr, sizeof(src_addr));
467 printf(" %s", src_addr);
468 break;
469 default:
470 /* print protocol number and socket address */
471 printf(" %d %lx", sock.proto, (u_long)sock.so_addr);
472 }
473 }
474
475 static void
print_pipe_info(struct procstat * procstat,struct filestat * fst)476 print_pipe_info(struct procstat *procstat, struct filestat *fst)
477 {
478 struct pipestat ps;
479 char errbuf[_POSIX2_LINE_MAX];
480 int error;
481
482 error = procstat_get_pipe_info(procstat, fst, &ps, errbuf);
483 if (error != 0) {
484 printf("* error");
485 return;
486 }
487 printf("* pipe %8lx <-> %8lx", (u_long)ps.addr, (u_long)ps.peer);
488 printf(" %6zd", ps.buffer_cnt);
489 print_access_flags(fst->fs_fflags);
490 }
491
492 static void
print_pts_info(struct procstat * procstat,struct filestat * fst)493 print_pts_info(struct procstat *procstat, struct filestat *fst)
494 {
495 struct ptsstat pts;
496 char errbuf[_POSIX2_LINE_MAX];
497 int error;
498
499 error = procstat_get_pts_info(procstat, fst, &pts, errbuf);
500 if (error != 0) {
501 printf("* error");
502 return;
503 }
504 printf("* pseudo-terminal master ");
505 if (nflg || !*pts.devname) {
506 printf("%#10jx", (uintmax_t)pts.dev);
507 } else {
508 printf("%10s", pts.devname);
509 }
510 print_access_flags(fst->fs_fflags);
511 }
512
513 static void
print_sem_info(struct procstat * procstat,struct filestat * fst)514 print_sem_info(struct procstat *procstat, struct filestat *fst)
515 {
516 struct semstat sem;
517 char errbuf[_POSIX2_LINE_MAX];
518 char mode[15];
519 int error;
520
521 error = procstat_get_sem_info(procstat, fst, &sem, errbuf);
522 if (error != 0) {
523 printf("* error");
524 return;
525 }
526 if (nflg) {
527 printf(" ");
528 (void)snprintf(mode, sizeof(mode), "%o", sem.mode);
529 } else {
530 printf(" %-15s", fst->fs_path != NULL ? fst->fs_path : "-");
531 strmode(sem.mode, mode);
532 }
533 printf(" %10s %6u", mode, sem.value);
534 print_access_flags(fst->fs_fflags);
535 }
536
537 static void
print_shm_info(struct procstat * procstat,struct filestat * fst)538 print_shm_info(struct procstat *procstat, struct filestat *fst)
539 {
540 struct shmstat shm;
541 char errbuf[_POSIX2_LINE_MAX];
542 char mode[15];
543 int error;
544
545 error = procstat_get_shm_info(procstat, fst, &shm, errbuf);
546 if (error != 0) {
547 printf("* error");
548 return;
549 }
550 if (nflg) {
551 printf(" ");
552 (void)snprintf(mode, sizeof(mode), "%o", shm.mode);
553 } else {
554 printf(" %-15s", fst->fs_path != NULL ? fst->fs_path : "-");
555 strmode(shm.mode, mode);
556 }
557 printf(" %10s %6ju", mode, shm.size);
558 print_access_flags(fst->fs_fflags);
559 }
560
561 static void
print_vnode_info(struct procstat * procstat,struct filestat * fst)562 print_vnode_info(struct procstat *procstat, struct filestat *fst)
563 {
564 struct vnstat vn;
565 char errbuf[_POSIX2_LINE_MAX];
566 char mode[15];
567 const char *badtype;
568 int error;
569
570 badtype = NULL;
571 error = procstat_get_vnode_info(procstat, fst, &vn, errbuf);
572 if (error != 0)
573 badtype = errbuf;
574 else if (vn.vn_type == PS_FST_VTYPE_VBAD)
575 badtype = "bad";
576 else if (vn.vn_type == PS_FST_VTYPE_VNON)
577 badtype = "none";
578 if (badtype != NULL) {
579 printf(" - - %10s -", badtype);
580 return;
581 }
582
583 if (nflg)
584 printf(" %#5jx", (uintmax_t)vn.vn_fsid);
585 else if (vn.vn_mntdir != NULL)
586 (void)printf(" %-8s", vn.vn_mntdir);
587
588 /*
589 * Print access mode.
590 */
591 if (nflg)
592 (void)snprintf(mode, sizeof(mode), "%o", vn.vn_mode);
593 else {
594 strmode(vn.vn_mode, mode);
595 }
596 (void)printf(" %6jd %10s", (intmax_t)vn.vn_fileid, mode);
597
598 if (vn.vn_type == PS_FST_VTYPE_VBLK || vn.vn_type == PS_FST_VTYPE_VCHR) {
599 if (nflg || !*vn.vn_devname)
600 printf(" %#6jx", (uintmax_t)vn.vn_dev);
601 else {
602 printf(" %6s", vn.vn_devname);
603 }
604 } else
605 printf(" %6ju", (uintmax_t)vn.vn_size);
606 print_access_flags(fst->fs_fflags);
607 }
608
609 static void
print_access_flags(int flags)610 print_access_flags(int flags)
611 {
612 char rw[3];
613
614 rw[0] = '\0';
615 if (flags & PS_FST_FFLAG_READ)
616 strcat(rw, "r");
617 if (flags & PS_FST_FFLAG_WRITE)
618 strcat(rw, "w");
619 printf(" %2s", rw);
620 }
621
622 int
getfname(const char * filename)623 getfname(const char *filename)
624 {
625 struct stat statbuf;
626 DEVS *cur;
627
628 if (stat(filename, &statbuf)) {
629 warn("%s", filename);
630 return (0);
631 }
632 if ((cur = malloc(sizeof(DEVS))) == NULL)
633 err(1, NULL);
634 cur->next = devs;
635 devs = cur;
636
637 cur->ino = statbuf.st_ino;
638 cur->fsid = statbuf.st_dev;
639 cur->name = filename;
640 return (1);
641 }
642
643 static void
usage(void)644 usage(void)
645 {
646 (void)fprintf(stderr,
647 "usage: fstat [-fmnv] [-M core] [-N system] [-p pid] [-u user] [file ...]\n");
648 exit(1);
649 }
650