2005-01-10 08:39:26 +00:00
|
|
|
/*-
|
1994-05-26 06:18:55 +00:00
|
|
|
* Copyright (c) 1980, 1990, 1993, 1994
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
* (c) UNIX System Laboratories, Inc.
|
|
|
|
* All or some portions of this file are derived from material licensed
|
|
|
|
* to the University of California by American Telephone and Telegraph
|
|
|
|
* Co. or Unix System Laboratories, Inc. and are reproduced herein with
|
|
|
|
* the permission of UNIX System Laboratories, Inc.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2003-05-01 16:58:57 +00:00
|
|
|
#if 0
|
1994-05-26 06:18:55 +00:00
|
|
|
#ifndef lint
|
1997-08-07 21:31:00 +00:00
|
|
|
static const char copyright[] =
|
1994-05-26 06:18:55 +00:00
|
|
|
"@(#) Copyright (c) 1980, 1990, 1993, 1994\n\
|
|
|
|
The Regents of the University of California. All rights reserved.\n";
|
|
|
|
#endif /* not lint */
|
|
|
|
|
|
|
|
#ifndef lint
|
1997-08-07 21:31:00 +00:00
|
|
|
static char sccsid[] = "@(#)df.c 8.9 (Berkeley) 5/8/95";
|
1994-05-26 06:18:55 +00:00
|
|
|
#endif /* not lint */
|
2003-05-01 16:58:57 +00:00
|
|
|
#endif
|
2002-06-30 05:13:54 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
1994-05-26 06:18:55 +00:00
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/mount.h>
|
2001-06-04 23:07:15 +00:00
|
|
|
#include <sys/sysctl.h>
|
1997-03-13 17:41:37 +00:00
|
|
|
#include <ufs/ufs/ufsmount.h>
|
1994-05-26 06:18:55 +00:00
|
|
|
#include <err.h>
|
2004-05-24 22:22:29 +00:00
|
|
|
#include <libutil.h>
|
2012-11-15 03:39:21 +00:00
|
|
|
#include <locale.h>
|
2004-02-08 23:42:09 +00:00
|
|
|
#include <stdint.h>
|
1994-05-26 06:18:55 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
1999-12-15 03:44:09 +00:00
|
|
|
#include <sysexits.h>
|
1994-05-26 06:18:55 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
|
2002-05-12 19:24:09 +00:00
|
|
|
#include "extern.h"
|
|
|
|
|
2004-05-24 22:22:29 +00:00
|
|
|
#define UNITS_SI 1
|
|
|
|
#define UNITS_2 2
|
1999-12-15 03:44:09 +00:00
|
|
|
|
2002-03-26 20:32:37 +00:00
|
|
|
/* Maximum widths of various fields. */
|
|
|
|
struct maxwidths {
|
2004-02-08 23:42:09 +00:00
|
|
|
int mntfrom;
|
2008-11-23 13:03:44 +00:00
|
|
|
int fstype;
|
2004-02-08 23:42:09 +00:00
|
|
|
int total;
|
|
|
|
int used;
|
|
|
|
int avail;
|
|
|
|
int iused;
|
|
|
|
int ifree;
|
2002-03-26 20:32:37 +00:00
|
|
|
};
|
|
|
|
|
2004-04-22 17:05:08 +00:00
|
|
|
static void addstat(struct statfs *, struct statfs *);
|
2003-05-03 10:21:26 +00:00
|
|
|
static char *getmntpt(const char *);
|
2004-02-08 23:42:09 +00:00
|
|
|
static int int64width(int64_t);
|
2002-05-12 19:24:09 +00:00
|
|
|
static char *makenetvfslist(void);
|
2003-11-12 08:01:40 +00:00
|
|
|
static void prthuman(const struct statfs *, int64_t);
|
2004-05-24 22:22:29 +00:00
|
|
|
static void prthumanval(int64_t);
|
2004-06-04 09:30:51 +00:00
|
|
|
static intmax_t fsbtoblk(int64_t, uint64_t, u_long);
|
2002-05-12 19:24:09 +00:00
|
|
|
static void prtstat(struct statfs *, struct maxwidths *);
|
2003-09-13 20:46:58 +00:00
|
|
|
static size_t regetmntinfo(struct statfs **, long, const char **);
|
2003-05-03 10:21:26 +00:00
|
|
|
static void update_maxwidths(struct maxwidths *, const struct statfs *);
|
2002-05-12 19:24:09 +00:00
|
|
|
static void usage(void);
|
|
|
|
|
2004-02-08 23:42:09 +00:00
|
|
|
static __inline int
|
|
|
|
imax(int a, int b)
|
2002-03-26 20:32:37 +00:00
|
|
|
{
|
2003-05-03 10:21:26 +00:00
|
|
|
return (a > b ? a : b);
|
2002-03-26 20:32:37 +00:00
|
|
|
}
|
|
|
|
|
2008-11-23 13:03:44 +00:00
|
|
|
static int aflag = 0, cflag, hflag, iflag, kflag, lflag = 0, nflag, Tflag;
|
2012-11-15 03:39:21 +00:00
|
|
|
static int thousands;
|
2002-05-12 19:24:09 +00:00
|
|
|
static struct ufs_args mdev;
|
|
|
|
|
1994-05-26 06:18:55 +00:00
|
|
|
int
|
2002-02-02 06:24:13 +00:00
|
|
|
main(int argc, char *argv[])
|
1994-05-26 06:18:55 +00:00
|
|
|
{
|
|
|
|
struct stat stbuf;
|
2004-04-22 17:05:08 +00:00
|
|
|
struct statfs statfsbuf, totalbuf;
|
2002-03-26 20:32:37 +00:00
|
|
|
struct maxwidths maxwidths;
|
2004-04-22 17:05:08 +00:00
|
|
|
struct statfs *mntbuf;
|
2001-05-20 04:12:30 +00:00
|
|
|
const char *fstype;
|
2002-05-12 19:24:09 +00:00
|
|
|
char *mntpath, *mntpt;
|
|
|
|
const char **vfslist;
|
Simplify df(1) by factoring out most of the common code:
- In the argc == 0 case, just populate the mount list as before, but
do not calculate widths, update totals or print anything.
- In the argv > 0 case, collect information about the requested file
systems and store it in the mount list, but do not calculate
widths, update totals or print anything.
- In either case, once all the information has been collected,
iterate once through the mount list to calculate widths and totals,
then once more to print everything.
This also fixes two bugs: firstly, column widths were not calculated
correctly if more than one file system was specified on the command
line; and secondly, file systems with MNT_IGNORE were included in the
totals even if -a was not specified.
Noticed by: Paul Schenkeveld
MFC after: 3 weeks
2011-10-18 08:18:26 +00:00
|
|
|
int i, mntsize;
|
2003-09-13 20:46:58 +00:00
|
|
|
int ch, rv;
|
2001-05-09 08:44:15 +00:00
|
|
|
|
|
|
|
fstype = "ufs";
|
2012-11-15 03:39:21 +00:00
|
|
|
(void)setlocale(LC_ALL, "");
|
2004-04-22 17:05:08 +00:00
|
|
|
memset(&totalbuf, 0, sizeof(totalbuf));
|
2004-04-18 20:56:31 +00:00
|
|
|
totalbuf.f_bsize = DEV_BSIZE;
|
2006-08-20 06:32:40 +00:00
|
|
|
strlcpy(totalbuf.f_mntfromname, "total", MNAMELEN);
|
1997-03-13 17:41:37 +00:00
|
|
|
vfslist = NULL;
|
2012-11-15 03:39:21 +00:00
|
|
|
while ((ch = getopt(argc, argv, "abcgHhiklmnPt:T,")) != -1)
|
1994-05-26 06:18:55 +00:00
|
|
|
switch (ch) {
|
1999-11-01 04:57:43 +00:00
|
|
|
case 'a':
|
|
|
|
aflag = 1;
|
|
|
|
break;
|
1999-12-15 03:44:09 +00:00
|
|
|
case 'b':
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
case 'P':
|
2006-09-20 20:55:02 +00:00
|
|
|
/*
|
2011-02-21 09:01:34 +00:00
|
|
|
* POSIX specifically discusses the behavior of
|
2006-09-20 20:55:02 +00:00
|
|
|
* both -k and -P. It states that the blocksize should
|
|
|
|
* be set to 1024. Thus, if this occurs, simply break
|
|
|
|
* rather than clobbering the old blocksize.
|
|
|
|
*/
|
|
|
|
if (kflag)
|
|
|
|
break;
|
2007-07-04 00:00:41 +00:00
|
|
|
setenv("BLOCKSIZE", "512", 1);
|
1999-12-15 03:44:09 +00:00
|
|
|
hflag = 0;
|
|
|
|
break;
|
2004-04-22 17:05:08 +00:00
|
|
|
case 'c':
|
|
|
|
cflag = 1;
|
|
|
|
break;
|
2000-06-03 20:17:39 +00:00
|
|
|
case 'g':
|
2007-07-04 00:00:41 +00:00
|
|
|
setenv("BLOCKSIZE", "1g", 1);
|
2000-06-03 20:17:39 +00:00
|
|
|
hflag = 0;
|
|
|
|
break;
|
1999-12-15 03:44:09 +00:00
|
|
|
case 'H':
|
|
|
|
hflag = UNITS_SI;
|
|
|
|
break;
|
|
|
|
case 'h':
|
|
|
|
hflag = UNITS_2;
|
|
|
|
break;
|
1994-05-26 06:18:55 +00:00
|
|
|
case 'i':
|
|
|
|
iflag = 1;
|
|
|
|
break;
|
1994-08-10 19:21:07 +00:00
|
|
|
case 'k':
|
2006-09-20 20:55:02 +00:00
|
|
|
kflag++;
|
2007-07-04 00:00:41 +00:00
|
|
|
setenv("BLOCKSIZE", "1024", 1);
|
1999-12-15 03:44:09 +00:00
|
|
|
hflag = 0;
|
|
|
|
break;
|
2001-06-04 23:07:15 +00:00
|
|
|
case 'l':
|
|
|
|
if (vfslist != NULL)
|
|
|
|
errx(1, "-l and -t are mutually exclusive.");
|
|
|
|
vfslist = makevfslist(makenetvfslist());
|
2007-03-08 06:10:17 +00:00
|
|
|
lflag = 1;
|
2001-06-04 23:07:15 +00:00
|
|
|
break;
|
1999-12-15 03:44:09 +00:00
|
|
|
case 'm':
|
2007-07-04 00:00:41 +00:00
|
|
|
setenv("BLOCKSIZE", "1m", 1);
|
1999-12-15 03:44:09 +00:00
|
|
|
hflag = 0;
|
1994-08-10 19:21:07 +00:00
|
|
|
break;
|
1994-05-26 06:18:55 +00:00
|
|
|
case 'n':
|
|
|
|
nflag = 1;
|
|
|
|
break;
|
|
|
|
case 't':
|
2007-03-08 06:10:17 +00:00
|
|
|
if (lflag)
|
|
|
|
errx(1, "-l and -t are mutually exclusive.");
|
1997-03-13 17:41:37 +00:00
|
|
|
if (vfslist != NULL)
|
2001-12-11 18:22:01 +00:00
|
|
|
errx(1, "only one -t option may be specified");
|
2001-08-01 02:09:09 +00:00
|
|
|
fstype = optarg;
|
1997-03-13 17:41:37 +00:00
|
|
|
vfslist = makevfslist(optarg);
|
1994-05-26 06:18:55 +00:00
|
|
|
break;
|
2008-11-23 13:03:44 +00:00
|
|
|
case 'T':
|
|
|
|
Tflag = 1;
|
|
|
|
break;
|
2012-11-15 03:39:21 +00:00
|
|
|
case ',':
|
|
|
|
thousands = 1;
|
|
|
|
break;
|
1994-05-26 06:18:55 +00:00
|
|
|
case '?':
|
|
|
|
default:
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
argc -= optind;
|
|
|
|
argv += optind;
|
|
|
|
|
1997-10-12 13:55:43 +00:00
|
|
|
rv = 0;
|
1994-05-26 06:18:55 +00:00
|
|
|
if (!*argv) {
|
Simplify df(1) by factoring out most of the common code:
- In the argc == 0 case, just populate the mount list as before, but
do not calculate widths, update totals or print anything.
- In the argv > 0 case, collect information about the requested file
systems and store it in the mount list, but do not calculate
widths, update totals or print anything.
- In either case, once all the information has been collected,
iterate once through the mount list to calculate widths and totals,
then once more to print everything.
This also fixes two bugs: firstly, column widths were not calculated
correctly if more than one file system was specified on the command
line; and secondly, file systems with MNT_IGNORE were included in the
totals even if -a was not specified.
Noticed by: Paul Schenkeveld
MFC after: 3 weeks
2011-10-18 08:18:26 +00:00
|
|
|
/* everything (modulo -t) */
|
|
|
|
mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
|
1997-03-13 17:41:37 +00:00
|
|
|
mntsize = regetmntinfo(&mntbuf, mntsize, vfslist);
|
Simplify df(1) by factoring out most of the common code:
- In the argc == 0 case, just populate the mount list as before, but
do not calculate widths, update totals or print anything.
- In the argv > 0 case, collect information about the requested file
systems and store it in the mount list, but do not calculate
widths, update totals or print anything.
- In either case, once all the information has been collected,
iterate once through the mount list to calculate widths and totals,
then once more to print everything.
This also fixes two bugs: firstly, column widths were not calculated
correctly if more than one file system was specified on the command
line; and secondly, file systems with MNT_IGNORE were included in the
totals even if -a was not specified.
Noticed by: Paul Schenkeveld
MFC after: 3 weeks
2011-10-18 08:18:26 +00:00
|
|
|
} else {
|
|
|
|
/* just the filesystems specified on the command line */
|
|
|
|
mntbuf = malloc(argc * sizeof(*mntbuf));
|
|
|
|
if (mntbuf == 0)
|
|
|
|
err(1, "malloc()");
|
|
|
|
mntsize = 0;
|
|
|
|
/* continued in for loop below */
|
1994-05-26 06:18:55 +00:00
|
|
|
}
|
|
|
|
|
Simplify df(1) by factoring out most of the common code:
- In the argc == 0 case, just populate the mount list as before, but
do not calculate widths, update totals or print anything.
- In the argv > 0 case, collect information about the requested file
systems and store it in the mount list, but do not calculate
widths, update totals or print anything.
- In either case, once all the information has been collected,
iterate once through the mount list to calculate widths and totals,
then once more to print everything.
This also fixes two bugs: firstly, column widths were not calculated
correctly if more than one file system was specified on the command
line; and secondly, file systems with MNT_IGNORE were included in the
totals even if -a was not specified.
Noticed by: Paul Schenkeveld
MFC after: 3 weeks
2011-10-18 08:18:26 +00:00
|
|
|
/* iterate through specified filesystems */
|
1994-05-26 06:18:55 +00:00
|
|
|
for (; *argv; argv++) {
|
|
|
|
if (stat(*argv, &stbuf) < 0) {
|
|
|
|
if ((mntpt = getmntpt(*argv)) == 0) {
|
|
|
|
warn("%s", *argv);
|
1997-10-12 13:55:43 +00:00
|
|
|
rv = 1;
|
1994-05-26 06:18:55 +00:00
|
|
|
continue;
|
|
|
|
}
|
2001-05-09 08:44:15 +00:00
|
|
|
} else if (S_ISCHR(stbuf.st_mode)) {
|
|
|
|
if ((mntpt = getmntpt(*argv)) == 0) {
|
|
|
|
mdev.fspec = *argv;
|
|
|
|
mntpath = strdup("/tmp/df.XXXXXX");
|
|
|
|
if (mntpath == NULL) {
|
|
|
|
warn("strdup failed");
|
|
|
|
rv = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
mntpt = mkdtemp(mntpath);
|
|
|
|
if (mntpt == NULL) {
|
|
|
|
warn("mkdtemp(\"%s\") failed", mntpath);
|
|
|
|
rv = 1;
|
|
|
|
free(mntpath);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (mount(fstype, mntpt, MNT_RDONLY,
|
|
|
|
&mdev) != 0) {
|
2002-05-12 19:24:09 +00:00
|
|
|
warn("%s", *argv);
|
|
|
|
rv = 1;
|
2001-05-09 08:44:15 +00:00
|
|
|
(void)rmdir(mntpt);
|
|
|
|
free(mntpath);
|
|
|
|
continue;
|
|
|
|
} else if (statfs(mntpt, &statfsbuf) == 0) {
|
|
|
|
statfsbuf.f_mntonname[0] = '\0';
|
2002-03-26 20:32:37 +00:00
|
|
|
prtstat(&statfsbuf, &maxwidths);
|
2004-04-18 20:56:31 +00:00
|
|
|
if (cflag)
|
|
|
|
addstat(&totalbuf, &statfsbuf);
|
2001-05-09 08:44:15 +00:00
|
|
|
} else {
|
|
|
|
warn("%s", *argv);
|
|
|
|
rv = 1;
|
|
|
|
}
|
|
|
|
(void)unmount(mntpt, 0);
|
|
|
|
(void)rmdir(mntpt);
|
|
|
|
free(mntpath);
|
|
|
|
continue;
|
|
|
|
}
|
1994-05-26 06:18:55 +00:00
|
|
|
} else
|
|
|
|
mntpt = *argv;
|
2003-06-03 11:54:42 +00:00
|
|
|
|
1994-05-26 06:18:55 +00:00
|
|
|
/*
|
|
|
|
* Statfs does not take a `wait' flag, so we cannot
|
|
|
|
* implement nflag here.
|
|
|
|
*/
|
|
|
|
if (statfs(mntpt, &statfsbuf) < 0) {
|
|
|
|
warn("%s", mntpt);
|
1997-10-12 13:55:43 +00:00
|
|
|
rv = 1;
|
1994-05-26 06:18:55 +00:00
|
|
|
continue;
|
|
|
|
}
|
2003-06-03 11:54:42 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check to make sure the arguments we've been given are
|
|
|
|
* satisfied. Return an error if we have been asked to
|
|
|
|
* list a mount point that does not match the other args
|
|
|
|
* we've been given (-l, -t, etc.).
|
2003-06-02 22:33:12 +00:00
|
|
|
*/
|
|
|
|
if (checkvfsname(statfsbuf.f_fstypename, vfslist)) {
|
2003-06-03 11:54:42 +00:00
|
|
|
rv = 1;
|
2003-06-02 22:33:12 +00:00
|
|
|
continue;
|
|
|
|
}
|
2003-06-03 11:54:42 +00:00
|
|
|
|
Simplify df(1) by factoring out most of the common code:
- In the argc == 0 case, just populate the mount list as before, but
do not calculate widths, update totals or print anything.
- In the argv > 0 case, collect information about the requested file
systems and store it in the mount list, but do not calculate
widths, update totals or print anything.
- In either case, once all the information has been collected,
iterate once through the mount list to calculate widths and totals,
then once more to print everything.
This also fixes two bugs: firstly, column widths were not calculated
correctly if more than one file system was specified on the command
line; and secondly, file systems with MNT_IGNORE were included in the
totals even if -a was not specified.
Noticed by: Paul Schenkeveld
MFC after: 3 weeks
2011-10-18 08:18:26 +00:00
|
|
|
/* the user asked for it, so ignore the ignore flag */
|
|
|
|
statfsbuf.f_flags &= ~MNT_IGNORE;
|
|
|
|
|
|
|
|
/* add to list */
|
|
|
|
mntbuf[mntsize++] = statfsbuf;
|
|
|
|
}
|
|
|
|
|
|
|
|
bzero(&maxwidths, sizeof(maxwidths));
|
|
|
|
for (i = 0; i < mntsize; i++) {
|
|
|
|
if (aflag || (mntbuf[i].f_flags & MNT_IGNORE) == 0) {
|
|
|
|
update_maxwidths(&maxwidths, &mntbuf[i]);
|
|
|
|
if (cflag)
|
|
|
|
addstat(&totalbuf, &mntbuf[i]);
|
2002-03-26 20:32:37 +00:00
|
|
|
}
|
1994-05-26 06:18:55 +00:00
|
|
|
}
|
Simplify df(1) by factoring out most of the common code:
- In the argc == 0 case, just populate the mount list as before, but
do not calculate widths, update totals or print anything.
- In the argv > 0 case, collect information about the requested file
systems and store it in the mount list, but do not calculate
widths, update totals or print anything.
- In either case, once all the information has been collected,
iterate once through the mount list to calculate widths and totals,
then once more to print everything.
This also fixes two bugs: firstly, column widths were not calculated
correctly if more than one file system was specified on the command
line; and secondly, file systems with MNT_IGNORE were included in the
totals even if -a was not specified.
Noticed by: Paul Schenkeveld
MFC after: 3 weeks
2011-10-18 08:18:26 +00:00
|
|
|
for (i = 0; i < mntsize; i++)
|
|
|
|
if (aflag || (mntbuf[i].f_flags & MNT_IGNORE) == 0)
|
|
|
|
prtstat(&mntbuf[i], &maxwidths);
|
2004-04-18 20:56:31 +00:00
|
|
|
if (cflag)
|
|
|
|
prtstat(&totalbuf, &maxwidths);
|
1997-10-12 13:55:43 +00:00
|
|
|
return (rv);
|
1994-05-26 06:18:55 +00:00
|
|
|
}
|
|
|
|
|
2002-05-12 19:24:09 +00:00
|
|
|
static char *
|
2003-05-03 10:21:26 +00:00
|
|
|
getmntpt(const char *name)
|
1994-05-26 06:18:55 +00:00
|
|
|
{
|
2003-09-13 20:46:58 +00:00
|
|
|
size_t mntsize, i;
|
1994-05-26 06:18:55 +00:00
|
|
|
struct statfs *mntbuf;
|
|
|
|
|
|
|
|
mntsize = getmntinfo(&mntbuf, MNT_NOWAIT);
|
|
|
|
for (i = 0; i < mntsize; i++) {
|
|
|
|
if (!strcmp(mntbuf[i].f_mntfromname, name))
|
|
|
|
return (mntbuf[i].f_mntonname);
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2002-08-21 17:32:44 +00:00
|
|
|
* Make a pass over the file system info in ``mntbuf'' filtering out
|
|
|
|
* file system types not in vfslist and possibly re-stating to get
|
1994-05-26 06:18:55 +00:00
|
|
|
* current (not cached) info. Returns the new count of valid statfs bufs.
|
|
|
|
*/
|
2003-09-13 20:46:58 +00:00
|
|
|
static size_t
|
2002-05-12 19:24:09 +00:00
|
|
|
regetmntinfo(struct statfs **mntbufp, long mntsize, const char **vfslist)
|
1994-05-26 06:18:55 +00:00
|
|
|
{
|
2004-07-20 18:24:47 +00:00
|
|
|
int error, i, j;
|
1994-05-26 06:18:55 +00:00
|
|
|
struct statfs *mntbuf;
|
|
|
|
|
1997-03-13 17:41:37 +00:00
|
|
|
if (vfslist == NULL)
|
1994-05-26 06:18:55 +00:00
|
|
|
return (nflag ? mntsize : getmntinfo(mntbufp, MNT_WAIT));
|
|
|
|
|
|
|
|
mntbuf = *mntbufp;
|
1997-03-13 17:41:37 +00:00
|
|
|
for (j = 0, i = 0; i < mntsize; i++) {
|
|
|
|
if (checkvfsname(mntbuf[i].f_fstypename, vfslist))
|
|
|
|
continue;
|
2004-07-20 18:24:47 +00:00
|
|
|
/*
|
|
|
|
* XXX statfs(2) can fail for various reasons. It may be
|
|
|
|
* possible that the user does not have access to the
|
|
|
|
* pathname, if this happens, we will fall back on
|
|
|
|
* "stale" filesystem statistics.
|
|
|
|
*/
|
|
|
|
error = statfs(mntbuf[i].f_mntonname, &mntbuf[j]);
|
|
|
|
if (nflag || error < 0)
|
|
|
|
if (i != j) {
|
|
|
|
if (error < 0)
|
|
|
|
warnx("%s stats possibly stale",
|
|
|
|
mntbuf[i].f_mntonname);
|
|
|
|
mntbuf[j] = mntbuf[i];
|
|
|
|
}
|
1997-03-13 17:41:37 +00:00
|
|
|
j++;
|
1994-05-26 06:18:55 +00:00
|
|
|
}
|
|
|
|
return (j);
|
|
|
|
}
|
|
|
|
|
2002-05-12 19:24:09 +00:00
|
|
|
static void
|
2003-11-12 08:01:40 +00:00
|
|
|
prthuman(const struct statfs *sfsp, int64_t used)
|
1999-12-15 03:44:09 +00:00
|
|
|
{
|
|
|
|
|
2004-05-24 22:22:29 +00:00
|
|
|
prthumanval(sfsp->f_blocks * sfsp->f_bsize);
|
|
|
|
prthumanval(used * sfsp->f_bsize);
|
|
|
|
prthumanval(sfsp->f_bavail * sfsp->f_bsize);
|
1999-12-15 03:44:09 +00:00
|
|
|
}
|
|
|
|
|
2002-05-12 19:24:09 +00:00
|
|
|
static void
|
2004-05-24 22:22:29 +00:00
|
|
|
prthumanval(int64_t bytes)
|
1999-12-15 03:44:09 +00:00
|
|
|
{
|
2004-05-24 22:22:29 +00:00
|
|
|
char buf[6];
|
|
|
|
int flags;
|
|
|
|
|
|
|
|
flags = HN_B | HN_NOSPACE | HN_DECIMAL;
|
|
|
|
if (hflag == UNITS_SI)
|
|
|
|
flags |= HN_DIVISOR_1000;
|
1999-12-15 03:44:09 +00:00
|
|
|
|
2004-05-24 22:22:29 +00:00
|
|
|
humanize_number(buf, sizeof(buf) - (bytes < 0 ? 0 : 1),
|
|
|
|
bytes, "", HN_AUTOSCALE, flags);
|
1999-12-15 03:44:09 +00:00
|
|
|
|
2004-05-24 22:22:29 +00:00
|
|
|
(void)printf(" %6s", buf);
|
1999-12-15 03:44:09 +00:00
|
|
|
}
|
|
|
|
|
2009-06-07 09:06:21 +00:00
|
|
|
/*
|
|
|
|
* Print an inode count in "human-readable" format.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
prthumanvalinode(int64_t bytes)
|
|
|
|
{
|
|
|
|
char buf[6];
|
|
|
|
int flags;
|
|
|
|
|
|
|
|
flags = HN_NOSPACE | HN_DECIMAL | HN_DIVISOR_1000;
|
|
|
|
|
|
|
|
humanize_number(buf, sizeof(buf) - (bytes < 0 ? 0 : 1),
|
|
|
|
bytes, "", HN_AUTOSCALE, flags);
|
|
|
|
|
|
|
|
(void)printf(" %5s", buf);
|
|
|
|
}
|
|
|
|
|
1994-05-26 06:18:55 +00:00
|
|
|
/*
|
2002-08-21 17:32:44 +00:00
|
|
|
* Convert statfs returned file system size into BLOCKSIZE units.
|
1994-05-26 06:18:55 +00:00
|
|
|
*/
|
2004-06-04 09:30:51 +00:00
|
|
|
static intmax_t
|
|
|
|
fsbtoblk(int64_t num, uint64_t fsbs, u_long bs)
|
|
|
|
{
|
2012-11-16 03:33:34 +00:00
|
|
|
return (num * (intmax_t) fsbs / bs);
|
2004-06-04 09:30:51 +00:00
|
|
|
}
|
1994-05-26 06:18:55 +00:00
|
|
|
|
|
|
|
/*
|
2002-08-21 17:32:44 +00:00
|
|
|
* Print out status about a file system.
|
1994-05-26 06:18:55 +00:00
|
|
|
*/
|
2002-05-12 19:24:09 +00:00
|
|
|
static void
|
2002-03-26 20:32:37 +00:00
|
|
|
prtstat(struct statfs *sfsp, struct maxwidths *mwp)
|
1994-05-26 06:18:55 +00:00
|
|
|
{
|
2007-04-06 15:36:43 +00:00
|
|
|
static long blocksize;
|
2003-05-03 10:21:26 +00:00
|
|
|
static int headerlen, timesthrough = 0;
|
2001-05-20 04:12:30 +00:00
|
|
|
static const char *header;
|
2003-11-12 08:01:40 +00:00
|
|
|
int64_t used, availblks, inodes;
|
2012-11-15 03:39:21 +00:00
|
|
|
const char *format;
|
1994-05-26 06:18:55 +00:00
|
|
|
|
|
|
|
if (++timesthrough == 1) {
|
2004-02-08 23:42:09 +00:00
|
|
|
mwp->mntfrom = imax(mwp->mntfrom, (int)strlen("Filesystem"));
|
2008-11-23 13:03:44 +00:00
|
|
|
mwp->fstype = imax(mwp->fstype, (int)strlen("Type"));
|
2012-11-15 03:39:21 +00:00
|
|
|
if (thousands) { /* make space for commas */
|
|
|
|
mwp->total += (mwp->total - 1) / 3;
|
|
|
|
mwp->used += (mwp->used - 1) / 3;
|
|
|
|
mwp->avail += (mwp->avail - 1) / 3;
|
|
|
|
mwp->iused += (mwp->iused - 1) / 3;
|
|
|
|
mwp->ifree += (mwp->ifree - 1) / 3;
|
|
|
|
}
|
1999-12-15 03:44:09 +00:00
|
|
|
if (hflag) {
|
2004-04-22 16:26:05 +00:00
|
|
|
header = " Size";
|
2004-02-08 23:42:09 +00:00
|
|
|
mwp->total = mwp->used = mwp->avail =
|
|
|
|
(int)strlen(header);
|
1999-12-15 03:44:09 +00:00
|
|
|
} else {
|
|
|
|
header = getbsize(&headerlen, &blocksize);
|
2004-02-08 23:42:09 +00:00
|
|
|
mwp->total = imax(mwp->total, headerlen);
|
2002-03-26 20:32:37 +00:00
|
|
|
}
|
2004-02-08 23:42:09 +00:00
|
|
|
mwp->used = imax(mwp->used, (int)strlen("Used"));
|
|
|
|
mwp->avail = imax(mwp->avail, (int)strlen("Avail"));
|
2002-03-26 20:32:37 +00:00
|
|
|
|
2008-11-23 13:03:44 +00:00
|
|
|
(void)printf("%-*s", mwp->mntfrom, "Filesystem");
|
|
|
|
if (Tflag)
|
|
|
|
(void)printf(" %-*s", mwp->fstype, "Type");
|
2012-11-15 03:39:21 +00:00
|
|
|
(void)printf(" %*s %*s %*s Capacity", mwp->total, header,
|
2004-02-08 23:42:09 +00:00
|
|
|
mwp->used, "Used", mwp->avail, "Avail");
|
2002-03-26 20:32:37 +00:00
|
|
|
if (iflag) {
|
2009-06-07 09:06:21 +00:00
|
|
|
mwp->iused = imax(hflag ? 0 : mwp->iused,
|
|
|
|
(int)strlen(" iused"));
|
|
|
|
mwp->ifree = imax(hflag ? 0 : mwp->ifree,
|
|
|
|
(int)strlen("ifree"));
|
2003-05-03 16:02:52 +00:00
|
|
|
(void)printf(" %*s %*s %%iused",
|
2004-02-08 23:42:09 +00:00
|
|
|
mwp->iused - 2, "iused", mwp->ifree, "ifree");
|
1999-12-15 03:44:09 +00:00
|
|
|
}
|
1994-05-26 06:18:55 +00:00
|
|
|
(void)printf(" Mounted on\n");
|
|
|
|
}
|
2012-11-16 03:33:34 +00:00
|
|
|
/* Check for 0 block size. Can this happen? */
|
|
|
|
if (sfsp->f_bsize == 0) {
|
|
|
|
warnx ("File system %s does not have a block size, assuming 512.",
|
|
|
|
sfsp->f_mntonname);
|
|
|
|
sfsp->f_bsize = 512;
|
|
|
|
}
|
2004-02-08 23:42:09 +00:00
|
|
|
(void)printf("%-*s", mwp->mntfrom, sfsp->f_mntfromname);
|
2008-11-23 13:03:44 +00:00
|
|
|
if (Tflag)
|
|
|
|
(void)printf(" %-*s", mwp->fstype, sfsp->f_fstypename);
|
1994-05-26 06:18:55 +00:00
|
|
|
used = sfsp->f_blocks - sfsp->f_bfree;
|
|
|
|
availblks = sfsp->f_bavail + used;
|
1999-12-15 03:44:09 +00:00
|
|
|
if (hflag) {
|
|
|
|
prthuman(sfsp, used);
|
|
|
|
} else {
|
2012-11-15 03:39:21 +00:00
|
|
|
if (thousands)
|
|
|
|
format = " %*j'd %*j'd %*j'd";
|
|
|
|
else
|
|
|
|
format = " %*jd %*jd %*jd";
|
|
|
|
(void)printf(format,
|
2004-06-04 09:30:51 +00:00
|
|
|
mwp->total, fsbtoblk(sfsp->f_blocks,
|
2004-02-08 23:42:09 +00:00
|
|
|
sfsp->f_bsize, blocksize),
|
2004-06-04 09:30:51 +00:00
|
|
|
mwp->used, fsbtoblk(used, sfsp->f_bsize, blocksize),
|
|
|
|
mwp->avail, fsbtoblk(sfsp->f_bavail,
|
2004-02-08 23:42:09 +00:00
|
|
|
sfsp->f_bsize, blocksize));
|
1999-12-15 03:44:09 +00:00
|
|
|
}
|
1994-05-26 06:18:55 +00:00
|
|
|
(void)printf(" %5.0f%%",
|
|
|
|
availblks == 0 ? 100.0 : (double)used / (double)availblks * 100.0);
|
|
|
|
if (iflag) {
|
|
|
|
inodes = sfsp->f_files;
|
|
|
|
used = inodes - sfsp->f_ffree;
|
2009-06-07 09:06:21 +00:00
|
|
|
if (hflag) {
|
|
|
|
(void)printf(" ");
|
|
|
|
prthumanvalinode(used);
|
|
|
|
prthumanvalinode(sfsp->f_ffree);
|
|
|
|
} else {
|
2012-11-15 03:39:21 +00:00
|
|
|
if (thousands)
|
|
|
|
format = " %*j'd %*j'd";
|
|
|
|
else
|
|
|
|
format = " %*jd %*jd";
|
|
|
|
(void)printf(format, mwp->iused, (intmax_t)used,
|
2009-06-07 09:06:21 +00:00
|
|
|
mwp->ifree, (intmax_t)sfsp->f_ffree);
|
|
|
|
}
|
|
|
|
(void)printf(" %4.0f%% ", inodes == 0 ? 100.0 :
|
2004-02-08 23:42:09 +00:00
|
|
|
(double)used / (double)inodes * 100.0);
|
2004-04-22 16:26:05 +00:00
|
|
|
} else
|
|
|
|
(void)printf(" ");
|
2004-04-22 17:05:08 +00:00
|
|
|
if (strncmp(sfsp->f_mntfromname, "total", MNAMELEN) != 0)
|
2004-04-18 20:56:31 +00:00
|
|
|
(void)printf(" %s", sfsp->f_mntonname);
|
|
|
|
(void)printf("\n");
|
|
|
|
}
|
|
|
|
|
2009-06-23 23:30:56 +00:00
|
|
|
static void
|
2004-04-18 20:56:31 +00:00
|
|
|
addstat(struct statfs *totalfsp, struct statfs *statfsp)
|
|
|
|
{
|
2004-04-22 17:05:08 +00:00
|
|
|
uint64_t bsize;
|
2004-04-18 20:56:31 +00:00
|
|
|
|
2004-04-22 17:05:08 +00:00
|
|
|
bsize = statfsp->f_bsize / totalfsp->f_bsize;
|
2004-04-18 20:56:31 +00:00
|
|
|
totalfsp->f_blocks += statfsp->f_blocks * bsize;
|
|
|
|
totalfsp->f_bfree += statfsp->f_bfree * bsize;
|
|
|
|
totalfsp->f_bavail += statfsp->f_bavail * bsize;
|
|
|
|
totalfsp->f_files += statfsp->f_files;
|
|
|
|
totalfsp->f_ffree += statfsp->f_ffree;
|
1994-05-26 06:18:55 +00:00
|
|
|
}
|
|
|
|
|
2002-03-26 20:32:37 +00:00
|
|
|
/*
|
|
|
|
* Update the maximum field-width information in `mwp' based on
|
2002-08-21 17:32:44 +00:00
|
|
|
* the file system specified by `sfsp'.
|
2002-03-26 20:32:37 +00:00
|
|
|
*/
|
2002-05-12 19:24:09 +00:00
|
|
|
static void
|
2003-05-03 10:21:26 +00:00
|
|
|
update_maxwidths(struct maxwidths *mwp, const struct statfs *sfsp)
|
2002-03-26 20:32:37 +00:00
|
|
|
{
|
2007-04-06 15:36:43 +00:00
|
|
|
static long blocksize = 0;
|
2002-12-30 18:10:37 +00:00
|
|
|
int dummy;
|
2002-03-26 20:32:37 +00:00
|
|
|
|
|
|
|
if (blocksize == 0)
|
|
|
|
getbsize(&dummy, &blocksize);
|
|
|
|
|
2004-02-08 23:42:09 +00:00
|
|
|
mwp->mntfrom = imax(mwp->mntfrom, (int)strlen(sfsp->f_mntfromname));
|
2008-11-23 13:03:44 +00:00
|
|
|
mwp->fstype = imax(mwp->fstype, (int)strlen(sfsp->f_fstypename));
|
2004-02-08 23:42:09 +00:00
|
|
|
mwp->total = imax(mwp->total, int64width(
|
2003-11-12 08:01:40 +00:00
|
|
|
fsbtoblk((int64_t)sfsp->f_blocks, sfsp->f_bsize, blocksize)));
|
2004-02-08 23:42:09 +00:00
|
|
|
mwp->used = imax(mwp->used,
|
|
|
|
int64width(fsbtoblk((int64_t)sfsp->f_blocks -
|
2003-11-12 08:01:40 +00:00
|
|
|
(int64_t)sfsp->f_bfree, sfsp->f_bsize, blocksize)));
|
2004-02-08 23:42:09 +00:00
|
|
|
mwp->avail = imax(mwp->avail, int64width(fsbtoblk(sfsp->f_bavail,
|
2002-03-26 20:32:37 +00:00
|
|
|
sfsp->f_bsize, blocksize)));
|
2004-02-08 23:42:09 +00:00
|
|
|
mwp->iused = imax(mwp->iused, int64width((int64_t)sfsp->f_files -
|
2002-03-26 20:32:37 +00:00
|
|
|
sfsp->f_ffree));
|
2004-02-08 23:42:09 +00:00
|
|
|
mwp->ifree = imax(mwp->ifree, int64width(sfsp->f_ffree));
|
2002-03-26 20:32:37 +00:00
|
|
|
}
|
|
|
|
|
2004-02-08 23:42:09 +00:00
|
|
|
/* Return the width in characters of the specified value. */
|
|
|
|
static int
|
2003-11-12 08:01:40 +00:00
|
|
|
int64width(int64_t val)
|
2002-03-26 20:32:37 +00:00
|
|
|
{
|
2004-02-08 23:42:09 +00:00
|
|
|
int len;
|
2002-03-26 20:32:37 +00:00
|
|
|
|
|
|
|
len = 0;
|
|
|
|
/* Negative or zero values require one extra digit. */
|
|
|
|
if (val <= 0) {
|
|
|
|
val = -val;
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
while (val > 0) {
|
|
|
|
len++;
|
|
|
|
val /= 10;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (len);
|
|
|
|
}
|
|
|
|
|
2002-05-12 19:24:09 +00:00
|
|
|
static void
|
2002-02-02 06:24:13 +00:00
|
|
|
usage(void)
|
1994-05-26 06:18:55 +00:00
|
|
|
{
|
1999-12-15 03:44:09 +00:00
|
|
|
|
1997-03-13 17:41:37 +00:00
|
|
|
(void)fprintf(stderr,
|
2012-11-15 03:39:21 +00:00
|
|
|
"usage: df [-b | -g | -H | -h | -k | -m | -P] [-acilnT] [-t type] [-,] [file | filesystem ...]\n");
|
1999-12-15 03:44:09 +00:00
|
|
|
exit(EX_USAGE);
|
1994-05-26 06:18:55 +00:00
|
|
|
}
|
2001-06-04 23:07:15 +00:00
|
|
|
|
2002-05-12 19:24:09 +00:00
|
|
|
static char *
|
2002-02-02 06:24:13 +00:00
|
|
|
makenetvfslist(void)
|
2001-06-04 23:07:15 +00:00
|
|
|
{
|
|
|
|
char *str, *strptr, **listptr;
|
2003-05-03 10:21:26 +00:00
|
|
|
struct xvfsconf *xvfsp, *keep_xvfsp;
|
- Introduce a new struct xvfsconf, the userland version of struct vfsconf.
- Make getvfsbyname() take a struct xvfsconf *.
- Convert several consumers of getvfsbyname() to use struct xvfsconf.
- Correct the getvfsbyname.3 manpage.
- Create a new vfs.conflist sysctl to dump all the struct xvfsconf in the
kernel, and rewrite getvfsbyname() to use this instead of the weird
existing API.
- Convert some {set,get,end}vfsent() consumers to use the new vfs.conflist
sysctl.
- Convert a vfsload() call in nfsiod.c to kldload() and remove the useless
vfsisloadable() and endvfsent() calls.
- Add a warning printf() in vfs_sysctl() to tell people they are using
an old userland.
After these changes, it's possible to modify struct vfsconf without
breaking the binary compatibility. Please note that these changes don't
break this compatibility either.
When bp will have updated mount_smbfs(8) with the patch I sent him, there
will be no more consumers of the {set,get,end}vfsent(), vfsisloadable()
and vfsload() API, and I will promptly delete it.
2002-08-10 20:19:04 +00:00
|
|
|
size_t buflen;
|
|
|
|
int cnt, i, maxvfsconf;
|
|
|
|
|
|
|
|
if (sysctlbyname("vfs.conflist", NULL, &buflen, NULL, 0) < 0) {
|
|
|
|
warn("sysctl(vfs.conflist)");
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
xvfsp = malloc(buflen);
|
|
|
|
if (xvfsp == NULL) {
|
|
|
|
warnx("malloc failed");
|
2001-06-04 23:07:15 +00:00
|
|
|
return (NULL);
|
|
|
|
}
|
2003-05-03 10:21:26 +00:00
|
|
|
keep_xvfsp = xvfsp;
|
- Introduce a new struct xvfsconf, the userland version of struct vfsconf.
- Make getvfsbyname() take a struct xvfsconf *.
- Convert several consumers of getvfsbyname() to use struct xvfsconf.
- Correct the getvfsbyname.3 manpage.
- Create a new vfs.conflist sysctl to dump all the struct xvfsconf in the
kernel, and rewrite getvfsbyname() to use this instead of the weird
existing API.
- Convert some {set,get,end}vfsent() consumers to use the new vfs.conflist
sysctl.
- Convert a vfsload() call in nfsiod.c to kldload() and remove the useless
vfsisloadable() and endvfsent() calls.
- Add a warning printf() in vfs_sysctl() to tell people they are using
an old userland.
After these changes, it's possible to modify struct vfsconf without
breaking the binary compatibility. Please note that these changes don't
break this compatibility either.
When bp will have updated mount_smbfs(8) with the patch I sent him, there
will be no more consumers of the {set,get,end}vfsent(), vfsisloadable()
and vfsload() API, and I will promptly delete it.
2002-08-10 20:19:04 +00:00
|
|
|
if (sysctlbyname("vfs.conflist", xvfsp, &buflen, NULL, 0) < 0) {
|
|
|
|
warn("sysctl(vfs.conflist)");
|
2003-05-03 10:21:26 +00:00
|
|
|
free(keep_xvfsp);
|
- Introduce a new struct xvfsconf, the userland version of struct vfsconf.
- Make getvfsbyname() take a struct xvfsconf *.
- Convert several consumers of getvfsbyname() to use struct xvfsconf.
- Correct the getvfsbyname.3 manpage.
- Create a new vfs.conflist sysctl to dump all the struct xvfsconf in the
kernel, and rewrite getvfsbyname() to use this instead of the weird
existing API.
- Convert some {set,get,end}vfsent() consumers to use the new vfs.conflist
sysctl.
- Convert a vfsload() call in nfsiod.c to kldload() and remove the useless
vfsisloadable() and endvfsent() calls.
- Add a warning printf() in vfs_sysctl() to tell people they are using
an old userland.
After these changes, it's possible to modify struct vfsconf without
breaking the binary compatibility. Please note that these changes don't
break this compatibility either.
When bp will have updated mount_smbfs(8) with the patch I sent him, there
will be no more consumers of the {set,get,end}vfsent(), vfsisloadable()
and vfsload() API, and I will promptly delete it.
2002-08-10 20:19:04 +00:00
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
maxvfsconf = buflen / sizeof(struct xvfsconf);
|
2001-06-04 23:07:15 +00:00
|
|
|
|
2001-07-16 15:49:58 +00:00
|
|
|
if ((listptr = malloc(sizeof(char*) * maxvfsconf)) == NULL) {
|
2001-06-04 23:07:15 +00:00
|
|
|
warnx("malloc failed");
|
2003-05-03 10:21:26 +00:00
|
|
|
free(keep_xvfsp);
|
2001-06-04 23:07:15 +00:00
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
- Introduce a new struct xvfsconf, the userland version of struct vfsconf.
- Make getvfsbyname() take a struct xvfsconf *.
- Convert several consumers of getvfsbyname() to use struct xvfsconf.
- Correct the getvfsbyname.3 manpage.
- Create a new vfs.conflist sysctl to dump all the struct xvfsconf in the
kernel, and rewrite getvfsbyname() to use this instead of the weird
existing API.
- Convert some {set,get,end}vfsent() consumers to use the new vfs.conflist
sysctl.
- Convert a vfsload() call in nfsiod.c to kldload() and remove the useless
vfsisloadable() and endvfsent() calls.
- Add a warning printf() in vfs_sysctl() to tell people they are using
an old userland.
After these changes, it's possible to modify struct vfsconf without
breaking the binary compatibility. Please note that these changes don't
break this compatibility either.
When bp will have updated mount_smbfs(8) with the patch I sent him, there
will be no more consumers of the {set,get,end}vfsent(), vfsisloadable()
and vfsload() API, and I will promptly delete it.
2002-08-10 20:19:04 +00:00
|
|
|
for (cnt = 0, i = 0; i < maxvfsconf; i++) {
|
|
|
|
if (xvfsp->vfc_flags & VFCF_NETWORK) {
|
|
|
|
listptr[cnt++] = strdup(xvfsp->vfc_name);
|
2001-07-16 15:49:58 +00:00
|
|
|
if (listptr[cnt-1] == NULL) {
|
2001-06-04 23:07:15 +00:00
|
|
|
warnx("malloc failed");
|
2003-05-03 10:21:26 +00:00
|
|
|
free(listptr);
|
|
|
|
free(keep_xvfsp);
|
2001-06-04 23:07:15 +00:00
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
}
|
- Introduce a new struct xvfsconf, the userland version of struct vfsconf.
- Make getvfsbyname() take a struct xvfsconf *.
- Convert several consumers of getvfsbyname() to use struct xvfsconf.
- Correct the getvfsbyname.3 manpage.
- Create a new vfs.conflist sysctl to dump all the struct xvfsconf in the
kernel, and rewrite getvfsbyname() to use this instead of the weird
existing API.
- Convert some {set,get,end}vfsent() consumers to use the new vfs.conflist
sysctl.
- Convert a vfsload() call in nfsiod.c to kldload() and remove the useless
vfsisloadable() and endvfsent() calls.
- Add a warning printf() in vfs_sysctl() to tell people they are using
an old userland.
After these changes, it's possible to modify struct vfsconf without
breaking the binary compatibility. Please note that these changes don't
break this compatibility either.
When bp will have updated mount_smbfs(8) with the patch I sent him, there
will be no more consumers of the {set,get,end}vfsent(), vfsisloadable()
and vfsload() API, and I will promptly delete it.
2002-08-10 20:19:04 +00:00
|
|
|
xvfsp++;
|
|
|
|
}
|
2001-06-04 23:07:15 +00:00
|
|
|
|
2001-12-19 08:38:02 +00:00
|
|
|
if (cnt == 0 ||
|
|
|
|
(str = malloc(sizeof(char) * (32 * cnt + cnt + 2))) == NULL) {
|
|
|
|
if (cnt > 0)
|
|
|
|
warnx("malloc failed");
|
2001-06-04 23:07:15 +00:00
|
|
|
free(listptr);
|
2003-05-03 10:21:26 +00:00
|
|
|
free(keep_xvfsp);
|
2001-06-04 23:07:15 +00:00
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
2001-07-16 15:49:58 +00:00
|
|
|
*str = 'n'; *(str + 1) = 'o';
|
|
|
|
for (i = 0, strptr = str + 2; i < cnt; i++, strptr++) {
|
2006-08-20 06:32:40 +00:00
|
|
|
strlcpy(strptr, listptr[i], 32);
|
2001-07-16 15:49:58 +00:00
|
|
|
strptr += strlen(listptr[i]);
|
|
|
|
*strptr = ',';
|
2001-06-04 23:07:15 +00:00
|
|
|
free(listptr[i]);
|
|
|
|
}
|
2004-03-05 08:10:19 +00:00
|
|
|
*(--strptr) = '\0';
|
2001-06-04 23:07:15 +00:00
|
|
|
|
2003-05-03 10:21:26 +00:00
|
|
|
free(keep_xvfsp);
|
2001-06-04 23:07:15 +00:00
|
|
|
free(listptr);
|
|
|
|
return (str);
|
|
|
|
}
|