1/*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2005-2009 Stanislav Sedov <stas@FreeBSD.org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 *
28 */
29#include <sys/cdefs.h>
30#include <sys/queue.h>
31#include <sys/stat.h>
32#include <sys/sysctl.h>
33#include <sys/user.h>
34
35#include <assert.h>
36#include <ctype.h>
37#include <err.h>
38#include <fcntl.h>
39#include <libprocstat.h>
40#include <limits.h>
41#include <paths.h>
42#include <pwd.h>
43#include <signal.h>
44#include <stdio.h>
45#include <stdlib.h>
46#include <string.h>
47#include <sysexits.h>
48#include <unistd.h>
49
50#include "functions.h"
51
52/*
53 * File access mode flags table.
54 */
55static const struct {
56	int	flag;
57	char	ch;
58} fflags[] = {
59	{PS_FST_FFLAG_WRITE,	'w'},
60	{PS_FST_FFLAG_APPEND,	'a'},
61	{PS_FST_FFLAG_DIRECT,	'd'},
62	{PS_FST_FFLAG_SHLOCK,	's'},
63	{PS_FST_FFLAG_EXLOCK,	'e'}
64};
65#define	NFFLAGS	(sizeof(fflags) / sizeof(*fflags))
66
67/*
68 * Usage flags translation table.
69 */
70static const struct {
71	int	flag;
72	char	ch;
73} uflags[] = {
74	{PS_FST_UFLAG_RDIR,	'r'},
75	{PS_FST_UFLAG_CDIR,	'c'},
76	{PS_FST_UFLAG_JAIL,	'j'},
77	{PS_FST_UFLAG_TRACE,	't'},
78	{PS_FST_UFLAG_TEXT,	'x'},
79	{PS_FST_UFLAG_MMAP,	'm'},
80	{PS_FST_UFLAG_CTTY,	'y'}
81};
82#define	NUFLAGS	(sizeof(uflags) / sizeof(*uflags))
83
84struct consumer {
85	pid_t	pid;
86	uid_t	uid;
87	int	fd;
88	int	flags;
89	int	uflags;
90	STAILQ_ENTRY(consumer)	next;
91};
92struct reqfile {
93	dev_t		fsid;
94	ino_t		fileid;
95	const char	*name;
96	STAILQ_HEAD(, consumer) consumers;
97};
98
99/*
100 * Option flags.
101 */
102#define	UFLAG	0x01	/* -u flag: show users				*/
103#define	FFLAG	0x02	/* -f flag: specified files only		*/
104#define	CFLAG	0x04	/* -c flag: treat as mpoints			*/
105#define	MFLAG	0x10	/* -m flag: mmapped files too			*/
106#define	KFLAG	0x20	/* -k flag: send signal (SIGKILL by default)	*/
107
108static int flags = 0;	/* Option flags. */
109
110static void	printflags(struct consumer *consumer);
111static int	str2sig(const char *str);
112static void	usage(void) __dead2;
113static int	addfile(const char *path, struct reqfile *reqfile);
114static void	dofiles(struct procstat *procstat, struct kinfo_proc *kp,
115    struct reqfile *reqfiles, size_t nfiles);
116
117static void
118usage(void)
119{
120
121	fprintf(stderr,
122"usage: fuser [-cfhkmu] [-M core] [-N system] [-s signal] file ...\n");
123	exit(EX_USAGE);
124}
125
126static void
127printflags(struct consumer *cons)
128{
129	unsigned int i;
130
131	assert(cons);
132	for (i = 0; i < NUFLAGS; i++)
133		if ((cons->uflags & uflags[i].flag) != 0)
134			fputc(uflags[i].ch, stderr);
135	for (i = 0; i < NFFLAGS; i++)
136		if ((cons->flags & fflags[i].flag) != 0)
137			fputc(fflags[i].ch, stderr);
138}
139
140/*
141 * Add file to the list.
142 */
143static int
144addfile(const char *path, struct reqfile *reqfile)
145{
146	struct stat sb;
147
148	assert(path);
149	if (stat(path, &sb) != 0) {
150		warn("%s", path);
151		return (1);
152	}
153	reqfile->fileid = sb.st_ino;
154	reqfile->fsid = sb.st_dev;
155	reqfile->name = path;
156	STAILQ_INIT(&reqfile->consumers);
157	return (0);
158}
159
160int
161do_fuser(int argc, char *argv[])
162{
163	struct consumer *consumer;
164	struct kinfo_proc *procs;
165	struct procstat *procstat;
166	struct reqfile *reqfiles;
167	char *ep, *nlistf, *memf;
168	int ch, sig;
169	unsigned int i, cnt, nfiles;
170
171	sig = SIGKILL;	/* Default to kill. */
172	nlistf = NULL;
173	memf = NULL;
174	while ((ch = getopt(argc, argv, "M:N:cfhkms:u")) != -1)
175		switch(ch) {
176		case 'f':
177			if ((flags & CFLAG) != 0)
178				usage();
179			flags |= FFLAG;
180			break;
181		case 'c':
182			if ((flags & FFLAG) != 0)
183				usage();
184			flags |= CFLAG;
185			break;
186		case 'N':
187			nlistf = optarg;
188			break;
189		case 'M':
190			memf = optarg;
191			break;
192		case 'u':
193			flags |= UFLAG;
194			break;
195		case 'm':
196			flags |= MFLAG;
197			break;
198		case 'k':
199			flags |= KFLAG;
200			break;
201		case 's':
202			if (isdigit(*optarg)) {
203				sig = strtol(optarg, &ep, 10);
204				if (*ep != '\0' || sig < 0 || sig >= sys_nsig)
205					errx(EX_USAGE, "illegal signal number" ": %s",
206					    optarg);
207			} else {
208				sig = str2sig(optarg);
209				if (sig < 0)
210					errx(EX_USAGE, "illegal signal name: "
211					    "%s", optarg);
212			}
213			break;
214		case 'h':
215			/* PASSTHROUGH */
216		default:
217			usage();
218			/* NORETURN */
219		}
220	argv += optind;
221	argc -= optind;
222
223	assert(argc >= 0);
224	if (argc == 0)
225		usage();
226		/* NORETURN */
227
228	/*
229	 * Process named files.
230	 */
231	reqfiles = malloc(argc * sizeof(struct reqfile));
232	if (reqfiles == NULL)
233		err(EX_OSERR, "malloc()");
234	nfiles = 0;
235	while (argc--)
236		if (!addfile(*(argv++), &reqfiles[nfiles]))
237			nfiles++;
238	if (nfiles == 0)
239		errx(EX_IOERR, "files not accessible");
240
241	if (memf != NULL)
242		procstat = procstat_open_kvm(nlistf, memf);
243	else
244		procstat = procstat_open_sysctl();
245	if (procstat == NULL)
246		errx(1, "procstat_open()");
247	procs = procstat_getprocs(procstat, KERN_PROC_PROC, 0, &cnt);
248	if (procs == NULL)
249		 errx(1, "procstat_getprocs()");
250
251	/*
252	 * Walk through process table and look for matching files.
253	 */
254	for (i = 0; i < cnt; i++)
255		if (procs[i].ki_stat != SZOMB)
256			dofiles(procstat, &procs[i], reqfiles, nfiles);
257
258	for (i = 0; i < nfiles; i++) {
259		fprintf(stderr, "%s:", reqfiles[i].name);
260		fflush(stderr);
261		STAILQ_FOREACH(consumer, &reqfiles[i].consumers, next) {
262			if (consumer->flags != 0) {
263				fprintf(stdout, "%6d", consumer->pid);
264				fflush(stdout);
265				printflags(consumer);
266				if ((flags & UFLAG) != 0)
267					fprintf(stderr, "(%s)",
268					    user_from_uid(consumer->uid, 0));
269				if ((flags & KFLAG) != 0)
270					kill(consumer->pid, sig);
271				fflush(stderr);
272			}
273		}
274		(void)fprintf(stderr, "\n");
275	}
276	procstat_freeprocs(procstat, procs);
277	procstat_close(procstat);
278	free(reqfiles);
279	return (0);
280}
281
282static void
283dofiles(struct procstat *procstat, struct kinfo_proc *kp,
284    struct reqfile *reqfiles, size_t nfiles)
285{
286	struct vnstat vn;
287	struct consumer *cons;
288	struct filestat *fst;
289	struct filestat_list *head;
290	int error, match;
291	unsigned int i;
292	char errbuf[_POSIX2_LINE_MAX];
293
294	head = procstat_getfiles(procstat, kp, flags & MFLAG);
295	if (head == NULL)
296		return;
297	STAILQ_FOREACH(fst, head, next) {
298		if (fst->fs_type != PS_FST_TYPE_VNODE)
299			continue;
300		error = procstat_get_vnode_info(procstat, fst, &vn, errbuf);
301		if (error != 0)
302			continue;
303		for (i = 0; i < nfiles; i++) {
304			if (flags & CFLAG && reqfiles[i].fsid == vn.vn_fsid) {
305				break;
306			}
307			else if (reqfiles[i].fsid == vn.vn_fsid &&
308			    reqfiles[i].fileid == vn.vn_fileid) {
309				break;
310			}
311			else if (!(flags & FFLAG) &&
312			    (vn.vn_type == PS_FST_VTYPE_VCHR ||
313			    vn.vn_type == PS_FST_VTYPE_VBLK) &&
314			    vn.vn_fsid == reqfiles[i].fileid) {
315				break;
316			}
317		}
318		if (i == nfiles)
319			continue;	/* No match. */
320
321		/*
322		 * Look for existing entries.
323		 */
324		match = 0;
325		STAILQ_FOREACH(cons, &reqfiles[i].consumers, next)
326			if (cons->pid == kp->ki_pid) {
327				match = 1;
328				break;
329			}
330		if (match == 1) {	/* Use old entry. */
331			cons->flags |= fst->fs_fflags;
332			cons->uflags |= fst->fs_uflags;
333		} else {
334			/*
335			 * Create new entry in the consumer chain.
336			 */
337			cons = calloc(1, sizeof(struct consumer));
338			if (cons == NULL) {
339				warn("malloc()");
340				continue;
341			}
342			cons->uid = kp->ki_uid;
343			cons->pid = kp->ki_pid;
344			cons->uflags = fst->fs_uflags;
345			cons->flags = fst->fs_fflags;
346			STAILQ_INSERT_TAIL(&reqfiles[i].consumers, cons, next);
347		}
348	}
349	procstat_freefiles(procstat, head);
350}
351
352/*
353 * Returns signal number for it's string representation.
354 */
355static int
356str2sig(const char *str)
357{
358	int i;
359
360	if (!strncasecmp(str, "SIG", 3))
361		str += 3;
362	for (i = 1; i < sys_nsig; i++) {
363                if (!strcasecmp(sys_signame[i], str))
364                        return (i);
365        }
366        return (-1);
367}
368