xref: /freebsd/usr.bin/fstat/fstat.c (revision 780fb4a2) 
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 2009 Stanislav Sedov <stas@FreeBSD.org>
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 __FBSDID("$FreeBSD$");
35 
36 #include <sys/param.h>
37 #include <sys/user.h>
38 #include <sys/stat.h>
39 #include <sys/socket.h>
40 #include <sys/socketvar.h>
41 #include <sys/sysctl.h>
42 #include <sys/queue.h>
43 
44 #include <netinet/in.h>
45 
46 #include <assert.h>
47 #include <ctype.h>
48 #include <err.h>
49 #include <libprocstat.h>
50 #include <limits.h>
51 #include <pwd.h>
52 #include <stdint.h>
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include <stddef.h>
56 #include <string.h>
57 #include <unistd.h>
58 #include <netdb.h>
59 
60 #include "functions.h"
61 
62 static int 	fsflg,	/* show files on same filesystem as file(s) argument */
63 		pflg,	/* show files open by a particular pid */
64 		uflg;	/* show files open by a particular (effective) user */
65 static int 	checkfile; /* restrict to particular files or filesystems */
66 static int	nflg;	/* (numerical) display f.s. and rdev as dev_t */
67 static int	mflg;	/* include memory-mapped files */
68 static int	vflg;	/* be verbose */
69 
70 typedef struct devs {
71 	struct devs	*next;
72 	uint64_t	fsid;
73 	uint64_t	ino;
74 	const char	*name;
75 } DEVS;
76 
77 static DEVS *devs;
78 static char *memf, *nlistf;
79 
80 static int	getfname(const char *filename);
81 static void	dofiles(struct procstat *procstat, struct kinfo_proc *p);
82 static void	print_access_flags(int flags);
83 static void	print_file_info(struct procstat *procstat,
84     struct filestat *fst, const char *uname, const char *cmd, int pid);
85 static void	print_pipe_info(struct procstat *procstat,
86     struct filestat *fst);
87 static void	print_pts_info(struct procstat *procstat,
88     struct filestat *fst);
89 static void	print_sem_info(struct procstat *procstat,
90     struct filestat *fst);
91 static void	print_shm_info(struct procstat *procstat,
92     struct filestat *fst);
93 static void	print_socket_info(struct procstat *procstat,
94     struct filestat *fst);
95 static void	print_vnode_info(struct procstat *procstat,
96     struct filestat *fst);
97 static void	usage(void) __dead2;
98 
99 int
100 do_fstat(int argc, char **argv)
101 {
102 	struct kinfo_proc *p;
103 	struct passwd *passwd;
104 	struct procstat *procstat;
105 	int arg, ch, what;
106 	int cnt, i;
107 
108 	arg = 0;
109 	what = KERN_PROC_PROC;
110 	nlistf = memf = NULL;
111 	while ((ch = getopt(argc, argv, "fmnp:u:vN:M:")) != -1)
112 		switch((char)ch) {
113 		case 'f':
114 			fsflg = 1;
115 			break;
116 		case 'M':
117 			memf = optarg;
118 			break;
119 		case 'N':
120 			nlistf = optarg;
121 			break;
122 		case 'm':
123 			mflg = 1;
124 			break;
125 		case 'n':
126 			nflg = 1;
127 			break;
128 		case 'p':
129 			if (pflg++)
130 				usage();
131 			if (!isdigit(*optarg)) {
132 				warnx("-p requires a process id");
133 				usage();
134 			}
135 			what = KERN_PROC_PID;
136 			arg = atoi(optarg);
137 			break;
138 		case 'u':
139 			if (uflg++)
140 				usage();
141 			if (!(passwd = getpwnam(optarg)))
142 				errx(1, "%s: unknown uid", optarg);
143 			what = KERN_PROC_UID;
144 			arg = passwd->pw_uid;
145 			break;
146 		case 'v':
147 			vflg = 1;
148 			break;
149 		case '?':
150 		default:
151 			usage();
152 		}
153 
154 	if (*(argv += optind)) {
155 		for (; *argv; ++argv) {
156 			if (getfname(*argv))
157 				checkfile = 1;
158 		}
159 		if (!checkfile)	/* file(s) specified, but none accessible */
160 			exit(1);
161 	}
162 
163 	if (fsflg && !checkfile) {
164 		/* -f with no files means use wd */
165 		if (getfname(".") == 0)
166 			exit(1);
167 		checkfile = 1;
168 	}
169 
170 	if (memf != NULL)
171 		procstat = procstat_open_kvm(nlistf, memf);
172 	else
173 		procstat = procstat_open_sysctl();
174 	if (procstat == NULL)
175 		errx(1, "procstat_open()");
176 	p = procstat_getprocs(procstat, what, arg, &cnt);
177 	if (p == NULL)
178 		errx(1, "procstat_getprocs()");
179 
180 	/*
181 	 * Print header.
182 	 */
183 	if (nflg)
184 		printf("%s",
185 "USER     CMD          PID   FD  DEV    INUM       MODE SZ|DV R/W");
186 	else
187 		printf("%s",
188 "USER     CMD          PID   FD MOUNT      INUM MODE         SZ|DV R/W");
189 	if (checkfile && fsflg == 0)
190 		printf(" NAME\n");
191 	else
192 		putchar('\n');
193 
194 	/*
195 	 * Go through the process list.
196 	 */
197 	for (i = 0; i < cnt; i++) {
198 		if (p[i].ki_stat == SZOMB)
199 			continue;
200 		dofiles(procstat, &p[i]);
201 	}
202 	procstat_freeprocs(procstat, p);
203 	procstat_close(procstat);
204 	return (0);
205 }
206 
207 static void
208 dofiles(struct procstat *procstat, struct kinfo_proc *kp)
209 {
210 	const char *cmd;
211 	const char *uname;
212 	struct filestat *fst;
213 	struct filestat_list *head;
214 	int pid;
215 
216 	uname = user_from_uid(kp->ki_uid, 0);
217 	pid = kp->ki_pid;
218 	cmd = kp->ki_comm;
219 
220 	head = procstat_getfiles(procstat, kp, mflg);
221 	if (head == NULL)
222 		return;
223 	STAILQ_FOREACH(fst, head, next)
224 		print_file_info(procstat, fst, uname, cmd, pid);
225 	procstat_freefiles(procstat, head);
226 }
227 
228 
229 static void
230 print_file_info(struct procstat *procstat, struct filestat *fst,
231     const char *uname, const char *cmd, int pid)
232 {
233 	struct vnstat vn;
234 	DEVS *d;
235 	const char *filename;
236 	int error, fsmatch = 0;
237 	char errbuf[_POSIX2_LINE_MAX];
238 
239 	filename = NULL;
240 	if (checkfile != 0) {
241 		if (fst->fs_type != PS_FST_TYPE_VNODE &&
242 		    fst->fs_type != PS_FST_TYPE_FIFO)
243 			return;
244 		error = procstat_get_vnode_info(procstat, fst, &vn, errbuf);
245 		if (error != 0)
246 			return;
247 
248 		for (d = devs; d != NULL; d = d->next)
249 			if (d->fsid == vn.vn_fsid) {
250 				fsmatch = 1;
251 				if (d->ino == vn.vn_fileid) {
252 					filename = d->name;
253 					break;
254 				}
255 			}
256 		if (fsmatch == 0 || (filename == NULL && fsflg == 0))
257 			return;
258 	}
259 
260 	/*
261 	 * Print entry prefix.
262 	 */
263 	printf("%-8.8s %-10s %5d", uname, cmd, pid);
264 	if (fst->fs_uflags & PS_FST_UFLAG_TEXT)
265 		printf(" text");
266 	else if (fst->fs_uflags & PS_FST_UFLAG_CDIR)
267 		printf("   wd");
268 	else if (fst->fs_uflags & PS_FST_UFLAG_RDIR)
269 		printf(" root");
270 	else if (fst->fs_uflags & PS_FST_UFLAG_TRACE)
271 		printf("   tr");
272 	else if (fst->fs_uflags & PS_FST_UFLAG_MMAP)
273 		printf(" mmap");
274 	else if (fst->fs_uflags & PS_FST_UFLAG_JAIL)
275 		printf(" jail");
276 	else if (fst->fs_uflags & PS_FST_UFLAG_CTTY)
277 		printf(" ctty");
278 	else
279 		printf(" %4d", fst->fs_fd);
280 
281 	/*
282 	 * Print type-specific data.
283 	 */
284 	switch (fst->fs_type) {
285 	case PS_FST_TYPE_FIFO:
286 	case PS_FST_TYPE_VNODE:
287 		print_vnode_info(procstat, fst);
288 		break;
289 	case PS_FST_TYPE_SOCKET:
290 		print_socket_info(procstat, fst);
291 		break;
292 	case PS_FST_TYPE_PIPE:
293 		print_pipe_info(procstat, fst);
294 		break;
295 	case PS_FST_TYPE_PTS:
296 		print_pts_info(procstat, fst);
297 		break;
298 	case PS_FST_TYPE_SHM:
299 		print_shm_info(procstat, fst);
300 		break;
301 	case PS_FST_TYPE_SEM:
302 		print_sem_info(procstat, fst);
303 		break;
304 	default:
305 		if (vflg)
306 			fprintf(stderr,
307 			    "unknown file type %d for file %d of pid %d\n",
308 			    fst->fs_type, fst->fs_fd, pid);
309 	}
310 	if (filename && !fsflg)
311 		printf("  %s", filename);
312 	putchar('\n');
313 }
314 
315 static void
316 print_socket_info(struct procstat *procstat, struct filestat *fst)
317 {
318 	static const char *stypename[] = {
319 		"unused",	/* 0 */
320 		"stream",	/* 1 */
321 		"dgram",	/* 2 */
322 		"raw",		/* 3 */
323 		"rdm",		/* 4 */
324 		"seqpak"	/* 5 */
325 	};
326 #define STYPEMAX 5
327 	struct sockstat sock;
328 	struct protoent *pe;
329 	char errbuf[_POSIX2_LINE_MAX];
330 	int error;
331 	static int isopen;
332 
333 	error = procstat_get_socket_info(procstat, fst, &sock, errbuf);
334 	if (error != 0) {
335 		printf("* error");
336 		return;
337 	}
338 	if (sock.type > STYPEMAX)
339 		printf("* %s ?%d", sock.dname, sock.type);
340 	else
341 		printf("* %s %s", sock.dname, stypename[sock.type]);
342 
343 	/*
344 	 * protocol specific formatting
345 	 *
346 	 * Try to find interesting things to print.  For tcp, the interesting
347 	 * thing is the address of the tcpcb, for udp and others, just the
348 	 * inpcb (socket pcb).  For unix domain, its the address of the socket
349 	 * pcb and the address of the connected pcb (if connected).  Otherwise
350 	 * just print the protocol number and address of the socket itself.
351 	 * The idea is not to duplicate netstat, but to make available enough
352 	 * information for further analysis.
353 	 */
354 	switch (sock.dom_family) {
355 	case AF_INET:
356 	case AF_INET6:
357 		if (!isopen)
358 			setprotoent(++isopen);
359 		if ((pe = getprotobynumber(sock.proto)) != NULL)
360 			printf(" %s", pe->p_name);
361 		else
362 			printf(" %d", sock.proto);
363 		if (sock.proto == IPPROTO_TCP ) {
364 			if (sock.inp_ppcb != 0)
365 				printf(" %lx", (u_long)sock.inp_ppcb);
366 		}
367 		else if (sock.so_pcb != 0)
368 			printf(" %lx", (u_long)sock.so_pcb);
369 		break;
370 	case AF_UNIX:
371 		/* print address of pcb and connected pcb */
372 		if (sock.so_pcb != 0) {
373 			printf(" %lx", (u_long)sock.so_pcb);
374 			if (sock.unp_conn) {
375 				char shoconn[4], *cp;
376 
377 				cp = shoconn;
378 				if (!(sock.so_rcv_sb_state & SBS_CANTRCVMORE))
379 					*cp++ = '<';
380 				*cp++ = '-';
381 				if (!(sock.so_snd_sb_state & SBS_CANTSENDMORE))
382 					*cp++ = '>';
383 				*cp = '\0';
384 				printf(" %s %lx", shoconn,
385 				    (u_long)sock.unp_conn);
386                         }
387 		}
388 		break;
389 	default:
390 		/* print protocol number and socket address */
391 		printf(" %d %lx", sock.proto, (u_long)sock.so_addr);
392 	}
393 }
394 
395 static void
396 print_pipe_info(struct procstat *procstat, struct filestat *fst)
397 {
398 	struct pipestat ps;
399 	char errbuf[_POSIX2_LINE_MAX];
400 	int error;
401 
402 	error = procstat_get_pipe_info(procstat, fst, &ps, errbuf);
403 	if (error != 0) {
404 		printf("* error");
405 		return;
406 	}
407 	printf("* pipe %8lx <-> %8lx", (u_long)ps.addr, (u_long)ps.peer);
408 	printf(" %6zd", ps.buffer_cnt);
409 	print_access_flags(fst->fs_fflags);
410 }
411 
412 static void
413 print_pts_info(struct procstat *procstat, struct filestat *fst)
414 {
415 	struct ptsstat pts;
416 	char errbuf[_POSIX2_LINE_MAX];
417 	int error;
418 
419 	error = procstat_get_pts_info(procstat, fst, &pts, errbuf);
420 	if (error != 0) {
421 		printf("* error");
422 		return;
423 	}
424 	printf("* pseudo-terminal master ");
425 	if (nflg || !*pts.devname) {
426 		printf("%#10jx", (uintmax_t)pts.dev);
427 	} else {
428 		printf("%10s", pts.devname);
429 	}
430 	print_access_flags(fst->fs_fflags);
431 }
432 
433 static void
434 print_sem_info(struct procstat *procstat, struct filestat *fst)
435 {
436 	struct semstat sem;
437 	char errbuf[_POSIX2_LINE_MAX];
438 	char mode[15];
439 	int error;
440 
441 	error = procstat_get_sem_info(procstat, fst, &sem, errbuf);
442 	if (error != 0) {
443 		printf("* error");
444 		return;
445 	}
446 	if (nflg) {
447 		printf("             ");
448 		(void)snprintf(mode, sizeof(mode), "%o", sem.mode);
449 	} else {
450 		printf(" %-15s", fst->fs_path != NULL ? fst->fs_path : "-");
451 		strmode(sem.mode, mode);
452 	}
453 	printf(" %10s %6u", mode, sem.value);
454 	print_access_flags(fst->fs_fflags);
455 }
456 
457 static void
458 print_shm_info(struct procstat *procstat, struct filestat *fst)
459 {
460 	struct shmstat shm;
461 	char errbuf[_POSIX2_LINE_MAX];
462 	char mode[15];
463 	int error;
464 
465 	error = procstat_get_shm_info(procstat, fst, &shm, errbuf);
466 	if (error != 0) {
467 		printf("* error");
468 		return;
469 	}
470 	if (nflg) {
471 		printf("             ");
472 		(void)snprintf(mode, sizeof(mode), "%o", shm.mode);
473 	} else {
474 		printf(" %-15s", fst->fs_path != NULL ? fst->fs_path : "-");
475 		strmode(shm.mode, mode);
476 	}
477 	printf(" %10s %6ju", mode, shm.size);
478 	print_access_flags(fst->fs_fflags);
479 }
480 
481 static void
482 print_vnode_info(struct procstat *procstat, struct filestat *fst)
483 {
484 	struct vnstat vn;
485 	char errbuf[_POSIX2_LINE_MAX];
486 	char mode[15];
487 	const char *badtype;
488 	int error;
489 
490 	badtype = NULL;
491 	error = procstat_get_vnode_info(procstat, fst, &vn, errbuf);
492 	if (error != 0)
493 		badtype = errbuf;
494 	else if (vn.vn_type == PS_FST_VTYPE_VBAD)
495 		badtype = "bad";
496 	else if (vn.vn_type == PS_FST_VTYPE_VNON)
497 		badtype = "none";
498 	if (badtype != NULL) {
499 		printf(" -         -  %10s    -", badtype);
500 		return;
501 	}
502 
503 	if (nflg)
504 		printf(" %#5jx", (uintmax_t)vn.vn_fsid);
505 	else if (vn.vn_mntdir != NULL)
506 		(void)printf(" %-8s", vn.vn_mntdir);
507 
508 	/*
509 	 * Print access mode.
510 	 */
511 	if (nflg)
512 		(void)snprintf(mode, sizeof(mode), "%o", vn.vn_mode);
513 	else {
514 		strmode(vn.vn_mode, mode);
515 	}
516 	(void)printf(" %6jd %10s", (intmax_t)vn.vn_fileid, mode);
517 
518 	if (vn.vn_type == PS_FST_VTYPE_VBLK || vn.vn_type == PS_FST_VTYPE_VCHR) {
519 		if (nflg || !*vn.vn_devname)
520 			printf(" %#6jx", (uintmax_t)vn.vn_dev);
521 		else {
522 			printf(" %6s", vn.vn_devname);
523 		}
524 	} else
525 		printf(" %6ju", (uintmax_t)vn.vn_size);
526 	print_access_flags(fst->fs_fflags);
527 }
528 
529 static void
530 print_access_flags(int flags)
531 {
532 	char rw[3];
533 
534 	rw[0] = '\0';
535 	if (flags & PS_FST_FFLAG_READ)
536 		strcat(rw, "r");
537 	if (flags & PS_FST_FFLAG_WRITE)
538 		strcat(rw, "w");
539 	printf(" %2s", rw);
540 }
541 
542 int
543 getfname(const char *filename)
544 {
545 	struct stat statbuf;
546 	DEVS *cur;
547 
548 	if (stat(filename, &statbuf)) {
549 		warn("%s", filename);
550 		return (0);
551 	}
552 	if ((cur = malloc(sizeof(DEVS))) == NULL)
553 		err(1, NULL);
554 	cur->next = devs;
555 	devs = cur;
556 
557 	cur->ino = statbuf.st_ino;
558 	cur->fsid = statbuf.st_dev;
559 	cur->name = filename;
560 	return (1);
561 }
562 
563 static void
564 usage(void)
565 {
566 	(void)fprintf(stderr,
567  "usage: fstat [-fmnv] [-M core] [-N system] [-p pid] [-u user] [file ...]\n");
568 	exit(1);
569 }
570