1/*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1980, 1993
5 *	The Regents of the University of California.  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 * 3. Neither the name of the University nor the names of its contributors
16 *    may be used to endorse or promote products derived from this software
17 *    without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32#if 0
33#ifndef lint
34static const char copyright[] =
35"@(#) Copyright (c) 1980, 1993\n\
36	The Regents of the University of California.  All rights reserved.\n";
37#endif /* not lint */
38
39#ifndef lint
40static char sccsid[] = "@(#)swapon.c	8.1 (Berkeley) 6/5/93";
41#endif /* not lint */
42#endif
43#include <sys/cdefs.h>
44__FBSDID("$FreeBSD$");
45
46#include <sys/param.h>
47#include <sys/disk.h>
48#include <sys/disklabel.h>
49#include <sys/mdioctl.h>
50#include <sys/stat.h>
51#include <sys/sysctl.h>
52#include <sys/wait.h>
53#include <vm/vm_param.h>
54
55#include <err.h>
56#include <errno.h>
57#include <fcntl.h>
58#include <fnmatch.h>
59#include <fstab.h>
60#include <libgen.h>
61#include <libutil.h>
62#include <limits.h>
63#include <paths.h>
64#include <stdarg.h>
65#include <stdio.h>
66#include <stdlib.h>
67#include <string.h>
68#include <unistd.h>
69
70static void usage(void);
71static const char *swap_on_off(const char *, int, char *);
72static const char *swap_on_off_gbde(const char *, int);
73static const char *swap_on_off_geli(const char *, char *, int);
74static const char *swap_on_off_md(const char *, char *, int);
75static const char *swap_on_off_sfile(const char *, int);
76static void swaplist(int, int, int);
77static int run_cmd(int *, const char *, ...) __printflike(2, 3);
78
79static enum { SWAPON, SWAPOFF, SWAPCTL } orig_prog, which_prog = SWAPCTL;
80
81static int Eflag, qflag;
82
83int
84main(int argc, char **argv)
85{
86	struct fstab *fsp;
87	const char *swfile;
88	char *ptr;
89	int ret, ch, doall;
90	int sflag, lflag, late, hflag;
91	const char *etc_fstab;
92
93	sflag = lflag = late = hflag = 0;
94	if ((ptr = strrchr(argv[0], '/')) == NULL)
95		ptr = argv[0];
96	if (strstr(ptr, "swapon") != NULL)
97		which_prog = SWAPON;
98	else if (strstr(ptr, "swapoff") != NULL)
99		which_prog = SWAPOFF;
100	orig_prog = which_prog;
101
102	doall = 0;
103	etc_fstab = NULL;
104	while ((ch = getopt(argc, argv, "AadEghklLmqsUF:")) != -1) {
105		switch(ch) {
106		case 'A':
107			if (which_prog == SWAPCTL) {
108				doall = 1;
109				which_prog = SWAPON;
110			} else
111				usage();
112			break;
113		case 'a':
114			if (which_prog == SWAPON || which_prog == SWAPOFF)
115				doall = 1;
116			else
117				which_prog = SWAPON;
118			break;
119		case 'd':
120			if (which_prog == SWAPCTL)
121				which_prog = SWAPOFF;
122			else
123				usage();
124			break;
125		case 'E':
126			if (which_prog == SWAPON)
127				Eflag = 2;
128			else
129				usage();
130			break;
131		case 'g':
132			hflag = 'G';
133			break;
134		case 'h':
135			hflag = 'H';
136			break;
137		case 'k':
138			hflag = 'K';
139			break;
140		case 'l':
141			lflag = 1;
142			break;
143		case 'L':
144			late = 1;
145			break;
146		case 'm':
147			hflag = 'M';
148			break;
149		case 'q':
150			if (which_prog == SWAPON || which_prog == SWAPOFF)
151				qflag = 1;
152			break;
153		case 's':
154			sflag = 1;
155			break;
156		case 'U':
157			if (which_prog == SWAPCTL) {
158				doall = 1;
159				which_prog = SWAPOFF;
160			} else
161				usage();
162			break;
163		case 'F':
164			etc_fstab = optarg;
165			break;
166		case '?':
167		default:
168			usage();
169		}
170	}
171	argv += optind;
172
173	ret = 0;
174	swfile = NULL;
175	if (etc_fstab != NULL)
176		setfstab(etc_fstab);
177	if (which_prog == SWAPON || which_prog == SWAPOFF) {
178		if (doall) {
179			while ((fsp = getfsent()) != NULL) {
180				if (strcmp(fsp->fs_type, FSTAB_SW) != 0)
181					continue;
182				if (strstr(fsp->fs_mntops, "noauto") != NULL)
183					continue;
184				if (which_prog != SWAPOFF &&
185				    strstr(fsp->fs_mntops, "late") &&
186				    late == 0)
187					continue;
188				if (which_prog == SWAPOFF &&
189				    strstr(fsp->fs_mntops, "late") == NULL &&
190				    late != 0)
191					continue;
192				Eflag |= (strstr(fsp->fs_mntops, "trimonce") != NULL);
193				swfile = swap_on_off(fsp->fs_spec, 1,
194				    fsp->fs_mntops);
195				Eflag &= ~1;
196				if (swfile == NULL) {
197					ret = 1;
198					continue;
199				}
200				if (qflag == 0) {
201					printf("%s: %sing %s as swap device\n",
202					    getprogname(),
203					    (which_prog == SWAPOFF) ?
204					    "remov" : "add", swfile);
205				}
206			}
207		} else if (*argv == NULL)
208			usage();
209		for (; *argv; ++argv) {
210			swfile = swap_on_off(*argv, 0, NULL);
211			if (swfile == NULL) {
212				ret = 1;
213				continue;
214			}
215			if (orig_prog == SWAPCTL) {
216				printf("%s: %sing %s as swap device\n",
217				    getprogname(),
218				    (which_prog == SWAPOFF) ? "remov" : "add",
219				    swfile);
220			}
221		}
222	} else {
223		if (lflag || sflag)
224			swaplist(lflag, sflag, hflag);
225		else
226			usage();
227	}
228	exit(ret);
229}
230
231static const char *
232swap_on_off(const char *name, int doingall, char *mntops)
233{
234	char *base, *basebuf;
235
236	/* Swap on vnode-backed md(4) device. */
237	if (mntops != NULL &&
238	    (fnmatch(_PATH_DEV MD_NAME "[0-9]*", name, 0) == 0 ||
239	     fnmatch(MD_NAME "[0-9]*", name, 0) == 0 ||
240	     strncmp(_PATH_DEV MD_NAME, name,
241		sizeof(_PATH_DEV) + sizeof(MD_NAME)) == 0 ||
242	     strncmp(MD_NAME, name, sizeof(MD_NAME)) == 0))
243		return (swap_on_off_md(name, mntops, doingall));
244
245	basebuf = strdup(name);
246	base = basename(basebuf);
247
248	/* Swap on encrypted device by GEOM_BDE. */
249	if (fnmatch("*.bde", base, 0) == 0) {
250		free(basebuf);
251		return (swap_on_off_gbde(name, doingall));
252	}
253
254	/* Swap on encrypted device by GEOM_ELI. */
255	if (fnmatch("*.eli", base, 0) == 0) {
256		free(basebuf);
257		return (swap_on_off_geli(name, mntops, doingall));
258	}
259
260	/* Swap on special file. */
261	free(basebuf);
262	return (swap_on_off_sfile(name, doingall));
263}
264
265/* Strip off .bde or .eli suffix from swap device name */
266static char *
267swap_basename(const char *name)
268{
269	char *dname, *p;
270
271	dname = strdup(name);
272	p = strrchr(dname, '.');
273	/* assert(p != NULL); */
274	*p = '\0';
275
276	return (dname);
277}
278
279static const char *
280swap_on_off_gbde(const char *name, int doingall)
281{
282	const char *ret;
283	char pass[64 * 2 + 1];
284	unsigned char bpass[64];
285	char *dname;
286	int i, error;
287
288	dname = swap_basename(name);
289	if (dname == NULL)
290		return (NULL);
291
292	if (which_prog == SWAPON) {
293		arc4random_buf(bpass, sizeof(bpass));
294		for (i = 0; i < (int)sizeof(bpass); i++)
295			sprintf(&pass[2 * i], "%02x", bpass[i]);
296		pass[sizeof(pass) - 1] = '\0';
297
298		error = run_cmd(NULL, "%s init %s -P %s", _PATH_GBDE,
299		    dname, pass);
300		if (error) {
301			/* bde device found.  Ignore it. */
302			free(dname);
303			if (qflag == 0)
304				warnx("%s: Device already in use", name);
305			return (NULL);
306		}
307		error = run_cmd(NULL, "%s attach %s -p %s", _PATH_GBDE,
308		    dname, pass);
309		free(dname);
310		if (error) {
311			warnx("gbde (attach) error: %s", name);
312			return (NULL);
313		}
314	}
315
316	ret = swap_on_off_sfile(name, doingall);
317
318	if (which_prog == SWAPOFF) {
319		error = run_cmd(NULL, "%s detach %s", _PATH_GBDE, dname);
320		free(dname);
321		if (error) {
322			/* bde device not found.  Ignore it. */
323			if (qflag == 0)
324				warnx("%s: Device not found", name);
325			return (NULL);
326		}
327	}
328
329	return (ret);
330}
331
332/* Build geli(8) arguments from mntops */
333static char *
334swap_on_geli_args(const char *mntops)
335{
336	const char *aalgo, *ealgo, *keylen_str, *sectorsize_str;
337	const char *aflag, *eflag, *lflag, *Tflag, *sflag;
338	char *p, *args, *token, *string, *ops;
339	int pagesize;
340	size_t pagesize_len;
341	u_long ul;
342
343	/* Use built-in defaults for geli(8). */
344	aalgo = ealgo = keylen_str = "";
345	aflag = eflag = lflag = Tflag = "";
346
347	/* We will always specify sectorsize. */
348	sflag = " -s ";
349	sectorsize_str = NULL;
350
351	if (mntops != NULL) {
352		string = ops = strdup(mntops);
353
354		while ((token = strsep(&string, ",")) != NULL) {
355			if ((p = strstr(token, "aalgo=")) == token) {
356				aalgo = p + sizeof("aalgo=") - 1;
357				aflag = " -a ";
358			} else if ((p = strstr(token, "ealgo=")) == token) {
359				ealgo = p + sizeof("ealgo=") - 1;
360				eflag = " -e ";
361			} else if ((p = strstr(token, "keylen=")) == token) {
362				keylen_str = p + sizeof("keylen=") - 1;
363				errno = 0;
364				ul = strtoul(keylen_str, &p, 10);
365				if (errno == 0) {
366					if (*p != '\0' || ul > INT_MAX)
367						errno = EINVAL;
368				}
369				if (errno) {
370					warn("Invalid keylen: %s", keylen_str);
371					free(ops);
372					return (NULL);
373				}
374				lflag = " -l ";
375			} else if ((p = strstr(token, "sectorsize=")) == token) {
376				sectorsize_str = p + sizeof("sectorsize=") - 1;
377				errno = 0;
378				ul = strtoul(sectorsize_str, &p, 10);
379				if (errno == 0) {
380					if (*p != '\0' || ul > INT_MAX)
381						errno = EINVAL;
382				}
383				if (errno) {
384					warn("Invalid sectorsize: %s",
385					    sectorsize_str);
386					free(ops);
387					return (NULL);
388				}
389			} else if (strcmp(token, "notrim") == 0) {
390				if (Eflag) {
391					warn("Options \"notrim\" and "
392					    "\"trimonce\" conflict");
393					free(ops);
394					return (NULL);
395				}
396				Tflag = " -T ";
397			} else if (strcmp(token, "late") == 0) {
398				/* ignore known option */
399			} else if (strcmp(token, "noauto") == 0) {
400				/* ignore known option */
401			} else if (strcmp(token, "sw") == 0) {
402				/* ignore known option */
403			} else if (strcmp(token, "trimonce") == 0) {
404				/* ignore known option */
405			} else {
406				warnx("Invalid option: %s", token);
407				free(ops);
408				return (NULL);
409			}
410		}
411	} else
412		ops = NULL;
413
414	/*
415	 * If we do not have a sector size at this point, fill in
416	 * pagesize as sector size.
417	 */
418	if (sectorsize_str == NULL) {
419		/* Use pagesize as default sectorsize. */
420		pagesize = getpagesize();
421		pagesize_len = snprintf(NULL, 0, "%d", pagesize) + 1;
422		p = alloca(pagesize_len);
423		snprintf(p, pagesize_len, "%d", pagesize);
424		sectorsize_str = p;
425	}
426
427	(void)asprintf(&args, "%s%s%s%s%s%s%s%s%s -d",
428	    aflag, aalgo, eflag, ealgo, lflag, keylen_str, Tflag,
429	    sflag, sectorsize_str);
430
431	free(ops);
432	return (args);
433}
434
435static const char *
436swap_on_off_geli(const char *name, char *mntops, int doingall)
437{
438	struct stat sb;
439	char *dname, *args;
440	int error;
441
442	error = stat(name, &sb);
443
444	if (which_prog == SWAPON) do {
445		/* Skip if the .eli device already exists. */
446		if (error == 0)
447			break;
448
449		args = swap_on_geli_args(mntops);
450		if (args == NULL)
451			return (NULL);
452
453		dname = swap_basename(name);
454		if (dname == NULL) {
455			free(args);
456			return (NULL);
457		}
458
459		error = run_cmd(NULL, "%s onetime%s %s", _PATH_GELI, args,
460		    dname);
461
462		free(dname);
463		free(args);
464
465		if (error) {
466			/* error occurred during creation. */
467			if (qflag == 0)
468				warnx("%s: Invalid parameters", name);
469			return (NULL);
470		}
471	} while (0);
472
473	return (swap_on_off_sfile(name, doingall));
474}
475
476static const char *
477swap_on_off_md(const char *name, char *mntops, int doingall)
478{
479	FILE *sfd;
480	int fd, mdunit, error;
481	const char *ret;
482	static char mdpath[PATH_MAX], linebuf[PATH_MAX];
483	char *p, *vnodefile;
484	size_t linelen;
485	u_long ul;
486
487	fd = -1;
488	sfd = NULL;
489	if (strlen(name) == (sizeof(MD_NAME) - 1))
490		mdunit = -1;
491	else {
492		errno = 0;
493		ul = strtoul(name + 2, &p, 10);
494		if (errno == 0) {
495			if (*p != '\0' || ul > INT_MAX)
496				errno = EINVAL;
497		}
498		if (errno) {
499			warn("Bad device unit: %s", name);
500			return (NULL);
501		}
502		mdunit = (int)ul;
503	}
504
505	vnodefile = NULL;
506	if ((p = strstr(mntops, "file=")) != NULL) {
507		vnodefile = strdup(p + sizeof("file=") - 1);
508		p = strchr(vnodefile, ',');
509		if (p != NULL)
510			*p = '\0';
511	}
512	if (vnodefile == NULL) {
513		warnx("file option not found for %s", name);
514		return (NULL);
515	}
516
517	if (which_prog == SWAPON) {
518		if (mdunit == -1) {
519			error = run_cmd(&fd, "%s -l -n -f %s",
520			    _PATH_MDCONFIG, vnodefile);
521			if (error == 0) {
522				/* md device found.  Ignore it. */
523				close(fd);
524				if (!qflag)
525					warnx("%s: Device already in use",
526					    vnodefile);
527				free(vnodefile);
528				return (NULL);
529			}
530			error = run_cmd(&fd, "%s -a -t vnode -n -f %s",
531			    _PATH_MDCONFIG, vnodefile);
532			if (error) {
533				warnx("mdconfig (attach) error: file=%s",
534				    vnodefile);
535				free(vnodefile);
536				return (NULL);
537			}
538			sfd = fdopen(fd, "r");
539			if (sfd == NULL) {
540				warn("mdconfig (attach) fdopen error");
541				ret = NULL;
542				goto err;
543			}
544			p = fgetln(sfd, &linelen);
545			if (p == NULL ||
546			    (linelen < 2 || linelen > sizeof(linebuf))) {
547				warn("mdconfig (attach) unexpected output");
548				ret = NULL;
549				goto err;
550			}
551			strlcpy(linebuf, p, linelen);
552			errno = 0;
553			ul = strtoul(linebuf, &p, 10);
554			if (errno == 0) {
555				if (*p != '\0' || ul > INT_MAX)
556					errno = EINVAL;
557			}
558			if (errno) {
559				warn("mdconfig (attach) unexpected output: %s",
560				    linebuf);
561				ret = NULL;
562				goto err;
563			}
564			mdunit = (int)ul;
565		} else {
566			error = run_cmd(&fd, "%s -l -n -f %s -u %d",
567			    _PATH_MDCONFIG, vnodefile, mdunit);
568			if (error == 0) {
569				/* md device found.  Ignore it. */
570				close(fd);
571				if (qflag == 0)
572					warnx("md%d on %s: Device already "
573					    "in use", mdunit, vnodefile);
574				free(vnodefile);
575				return (NULL);
576			}
577			error = run_cmd(NULL, "%s -a -t vnode -u %d -f %s",
578			    _PATH_MDCONFIG, mdunit, vnodefile);
579			if (error) {
580				warnx("mdconfig (attach) error: "
581				    "md%d on file=%s", mdunit, vnodefile);
582				free(vnodefile);
583				return (NULL);
584			}
585		}
586	} else /* SWAPOFF */ {
587		if (mdunit == -1) {
588			error = run_cmd(&fd, "%s -l -n -f %s",
589			    _PATH_MDCONFIG, vnodefile);
590			if (error) {
591				/* md device not found.  Ignore it. */
592				close(fd);
593				if (!qflag)
594					warnx("md on %s: Device not found",
595					    vnodefile);
596				free(vnodefile);
597				return (NULL);
598			}
599			sfd = fdopen(fd, "r");
600			if (sfd == NULL) {
601				warn("mdconfig (list) fdopen error");
602				ret = NULL;
603				goto err;
604			}
605			p = fgetln(sfd, &linelen);
606			if (p == NULL ||
607			    (linelen < 2 || linelen > sizeof(linebuf))) {
608				warn("mdconfig (list) unexpected output");
609				ret = NULL;
610				goto err;
611			}
612			strlcpy(linebuf, p, linelen);
613			p = strchr(linebuf, ' ');
614			if (p != NULL)
615				*p = '\0';
616			errno = 0;
617			ul = strtoul(linebuf, &p, 10);
618			if (errno == 0) {
619				if (*p != '\0' || ul > INT_MAX)
620					errno = EINVAL;
621			}
622			if (errno) {
623				warn("mdconfig (list) unexpected output: %s",
624				    linebuf);
625				ret = NULL;
626				goto err;
627			}
628			mdunit = (int)ul;
629		} else {
630			error = run_cmd(&fd, "%s -l -n -f %s -u %d",
631			    _PATH_MDCONFIG, vnodefile, mdunit);
632			if (error) {
633				/* md device not found.  Ignore it. */
634				close(fd);
635				if (!qflag)
636					warnx("md%d on %s: Device not found",
637					    mdunit, vnodefile);
638				free(vnodefile);
639				return (NULL);
640			}
641		}
642	}
643	snprintf(mdpath, sizeof(mdpath), "%s%s%d", _PATH_DEV,
644	    MD_NAME, mdunit);
645	mdpath[sizeof(mdpath) - 1] = '\0';
646	ret = swap_on_off_sfile(mdpath, doingall);
647
648	if (which_prog == SWAPOFF) {
649		if (ret != NULL) {
650			error = run_cmd(NULL, "%s -d -u %d",
651			    _PATH_MDCONFIG, mdunit);
652			if (error)
653				warn("mdconfig (detach) detach failed: %s%s%d",
654				    _PATH_DEV, MD_NAME, mdunit);
655		}
656	}
657err:
658	if (sfd != NULL)
659		fclose(sfd);
660	if (fd != -1)
661		close(fd);
662	free(vnodefile);
663	return (ret);
664}
665
666static int
667run_cmd(int *ofd, const char *cmdline, ...)
668{
669	va_list ap;
670	char **argv, **argvp, *cmd, *p;
671	int argc, pid, status, rv;
672	int pfd[2], nfd, dup2dn;
673
674	va_start(ap, cmdline);
675	rv = vasprintf(&cmd, cmdline, ap);
676	if (rv == -1) {
677		warn("%s", __func__);
678		va_end(ap);
679		return (rv);
680	}
681	va_end(ap);
682
683	for (argc = 1, p = cmd; (p = strchr(p, ' ')) != NULL; p++)
684		argc++;
685	argv = (char **)malloc(sizeof(*argv) * (argc + 1));
686	for (p = cmd, argvp = argv; (*argvp = strsep(&p, " ")) != NULL;)
687		if (**argvp != '\0' && (++argvp > &argv[argc])) {
688			*argvp = NULL;
689			break;
690		}
691	/* The argv array ends up NULL-terminated here. */
692#if 0
693	{
694		int i;
695
696		fprintf(stderr, "DEBUG: running:");
697		/* Should be equivalent to 'cmd' (before strsep, of course). */
698		for (i = 0; argv[i] != NULL; i++)
699			fprintf(stderr, " %s", argv[i]);
700		fprintf(stderr, "\n");
701	}
702#endif
703	dup2dn = 1;
704	if (ofd != NULL) {
705		if (pipe(&pfd[0]) == -1) {
706			warn("%s: pipe", __func__);
707			return (-1);
708		}
709		*ofd = pfd[0];
710		dup2dn = 0;
711	}
712	pid = fork();
713	switch (pid) {
714	case 0:
715		/* Child process. */
716		if (ofd != NULL)
717			if (dup2(pfd[1], STDOUT_FILENO) < 0)
718				err(1, "dup2 in %s", __func__);
719		nfd = open(_PATH_DEVNULL, O_RDWR);
720		if (nfd == -1)
721			err(1, "%s: open %s", __func__, _PATH_DEVNULL);
722		if (dup2(nfd, STDIN_FILENO) < 0)
723			err(1, "%s: dup2", __func__);
724		if (dup2dn && dup2(nfd, STDOUT_FILENO) < 0)
725			err(1, "%s: dup2", __func__);
726		if (dup2(nfd, STDERR_FILENO) < 0)
727			err(1, "%s: dup2", __func__);
728		execv(argv[0], argv);
729		warn("exec: %s", argv[0]);
730		_exit(-1);
731	case -1:
732		err(1, "%s: fork", __func__);
733	}
734	free(cmd);
735	free(argv);
736	while (waitpid(pid, &status, 0) != pid)
737		;
738	return (WEXITSTATUS(status));
739}
740
741static int
742swapon_trim(const char *name)
743{
744	struct stat sb;
745	off_t ioarg[2], sz;
746	int error, fd;
747
748	/* Open a descriptor to create a consumer of the device. */
749	fd = open(name, O_WRONLY);
750	if (fd < 0)
751		errx(1, "Cannot open %s", name);
752	/* Find the device size. */
753	if (fstat(fd, &sb) < 0)
754		errx(1, "Cannot stat %s", name);
755	if (S_ISREG(sb.st_mode))
756		sz = sb.st_size;
757	else if (S_ISCHR(sb.st_mode)) {
758		if (ioctl(fd, DIOCGMEDIASIZE, &sz) != 0)
759			err(1, "ioctl(DIOCGMEDIASIZE)");
760	} else
761		errx(1, "%s has an invalid file type", name);
762	/* Trim the device. */
763	ioarg[0] = BBSIZE;
764	ioarg[1] = sz - BBSIZE;
765	if (ioctl(fd, DIOCGDELETE, ioarg) != 0)
766		warn("ioctl(DIOCGDELETE)");
767
768	/* Start using the device for swapping, creating a second consumer. */
769	error = swapon(name);
770
771	/*
772	 * Do not close the device until the swap pager has attempted to create
773	 * another consumer.  For GELI devices created with the 'detach -l'
774	 * option, removing the last consumer causes the device to be detached
775	 * - that is, to disappear.  This ordering ensures that the device will
776	 * not be detached until swapoff is called.
777	 */
778	close(fd);
779	return (error);
780}
781
782static const char *
783swap_on_off_sfile(const char *name, int doingall)
784{
785	int error;
786
787	if (which_prog == SWAPON)
788		error = Eflag ? swapon_trim(name) : swapon(name);
789	else /* SWAPOFF */
790		error = swapoff(name);
791
792	if (error == -1) {
793		switch (errno) {
794		case EBUSY:
795			if (doingall == 0)
796				warnx("%s: Device already in use", name);
797			break;
798		case EINVAL:
799			if (which_prog == SWAPON)
800				warnx("%s: NSWAPDEV limit reached", name);
801			else if (doingall == 0)
802				warn("%s", name);
803			break;
804		default:
805			warn("%s", name);
806			break;
807		}
808		return (NULL);
809	}
810	return (name);
811}
812
813static void
814usage(void)
815{
816
817	fprintf(stderr, "usage: %s ", getprogname());
818	switch(orig_prog) {
819	case SWAPON:
820	    fprintf(stderr, "[-F fstab] -aLq | [-E] file ...\n");
821	    break;
822	case SWAPOFF:
823	    fprintf(stderr, "[-F fstab] -aLq | file ...\n");
824	    break;
825	case SWAPCTL:
826	    fprintf(stderr, "[-AghklmsU] [-a file ... | -d file ...]\n");
827	    break;
828	}
829	exit(1);
830}
831
832static void
833sizetobuf(char *buf, size_t bufsize, int hflag, long long val, int hlen,
834    long blocksize)
835{
836	char tmp[16];
837
838	if (hflag == 'H') {
839		humanize_number(tmp, 5, (int64_t)val, "", HN_AUTOSCALE,
840		    HN_B | HN_NOSPACE | HN_DECIMAL);
841		snprintf(buf, bufsize, "%*s", hlen, tmp);
842	} else
843		snprintf(buf, bufsize, "%*lld", hlen, val / blocksize);
844}
845
846static void
847swaplist(int lflag, int sflag, int hflag)
848{
849	size_t mibsize, size;
850	struct xswdev xsw;
851	int hlen, mib[16], n, pagesize;
852	long blocksize;
853	long long total = 0;
854	long long used = 0;
855	long long tmp_total;
856	long long tmp_used;
857	char buf[32];
858
859	pagesize = getpagesize();
860	switch(hflag) {
861	case 'G':
862		blocksize = 1024 * 1024 * 1024;
863		strlcpy(buf, "1GB-blocks", sizeof(buf));
864		hlen = 10;
865		break;
866	case 'H':
867		blocksize = -1;
868		strlcpy(buf, "Bytes", sizeof(buf));
869		hlen = 10;
870		break;
871	case 'K':
872		blocksize = 1024;
873		strlcpy(buf, "1kB-blocks", sizeof(buf));
874		hlen = 10;
875		break;
876	case 'M':
877		blocksize = 1024 * 1024;
878		strlcpy(buf, "1MB-blocks", sizeof(buf));
879		hlen = 10;
880		break;
881	default:
882		getbsize(&hlen, &blocksize);
883		snprintf(buf, sizeof(buf), "%ld-blocks", blocksize);
884		break;
885	}
886
887	mibsize = nitems(mib);
888	if (sysctlnametomib("vm.swap_info", mib, &mibsize) == -1)
889		err(1, "sysctlnametomib()");
890
891	if (lflag) {
892		printf("%-13s %*s %*s\n",
893		    "Device:",
894		    hlen, buf,
895		    hlen, "Used:");
896	}
897
898	for (n = 0; ; ++n) {
899		mib[mibsize] = n;
900		size = sizeof xsw;
901		if (sysctl(mib, mibsize + 1, &xsw, &size, NULL, 0) == -1)
902			break;
903		if (xsw.xsw_version != XSWDEV_VERSION)
904			errx(1, "xswdev version mismatch");
905
906		tmp_total = (long long)xsw.xsw_nblks * pagesize;
907		tmp_used  = (long long)xsw.xsw_used * pagesize;
908		total += tmp_total;
909		used  += tmp_used;
910		if (lflag) {
911			sizetobuf(buf, sizeof(buf), hflag, tmp_total, hlen,
912			    blocksize);
913			printf("/dev/%-8s %s ", devname(xsw.xsw_dev, S_IFCHR),
914			    buf);
915			sizetobuf(buf, sizeof(buf), hflag, tmp_used, hlen,
916			    blocksize);
917			printf("%s\n", buf);
918		}
919	}
920	if (errno != ENOENT)
921		err(1, "sysctl()");
922
923	if (sflag) {
924		sizetobuf(buf, sizeof(buf), hflag, total, hlen, blocksize);
925		printf("Total:        %s ", buf);
926		sizetobuf(buf, sizeof(buf), hflag, used, hlen, blocksize);
927		printf("%s\n", buf);
928	}
929}
930
931