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