ufs/df/df.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */


/*
 * df
 */
#include <stdio.h>
#include <fcntl.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/mntent.h>
#include <sys/fs/ufs_fs.h>
#include <sys/stat.h>
#include <sys/vfs.h>
#include <sys/file.h>
#include <sys/statvfs.h>
#include <sys/mnttab.h>
#include <sys/mkdev.h>
#include <locale.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <libintl.h>

extern char	*getenv();
extern char	*getcwd();
extern char	*realpath();
extern off_t	lseek();

/*
 * Raw name to block device name translation function.
 * This comes from libadm.
 */
extern char 	*getfullblkname();

static  void		usage(), pheader();
static  char		*mpath(char *);
static  char		*zap_chroot(char *);
static  char		*pathsuffix(char *, char *);
static  char		*xmalloc(unsigned int);
static  int		chroot_stat(char *, int (*)(), char *, char **);
static  int		bread(char *, int, daddr_t, char *, int);
static  int		subpath(char *, char *);
static	int		abspath(char *, char *, char *);
static  void		show_inode_usage();
static  void		dfreedev(char *);
static  void		dfreemnt(char *, struct mnttab *);
static  void		print_totals();
static  void		print_itotals();
static  void		print_statvfs(struct statvfs64 *);
static  int 		mdev(char *, struct mnttab **);
static struct mntlist	*mkmntlist();
static struct mnttab	*mntdup(struct mnttab *mnt);
static struct mntlist	*findmntent(char *, struct stat64 *, struct mntlist *);

#define	bcopy(f, t, n)	memcpy(t, f, n)
#define	bzero(s, n)	memset(s, 0, n)
#define	bcmp(s, d, n)	memcmp(s, d, n)

#define	index(s, r)	strchr(s, r)
#define	rindex(s, r)	strrchr(s, r)

#define	dbtok(x, b) \
	((b) < (fsblkcnt64_t)1024 ? \
	(x) / ((fsblkcnt64_t)1024 / (b)) : (x) * ((b) / (fsblkcnt64_t)1024))

int	aflag = 0;		/* even the uninteresting ones */
int	bflag = 0;		/* print only number of kilobytes free */
int	eflag = 0;		/* print only number of file entries free */
int	gflag = 0;		/* print entire statvfs structure */
int	hflag = 0;		/* don't print header */
int	iflag = 0;		/* information for inodes */
int	nflag = 0;		/* print VFStype name */
int	tflag = 0;		/* print totals */
int	errflag = 0;
int 	errcode = 0;
char	*typestr = "ufs";
fsblkcnt64_t	t_totalblks, t_avail, t_free, t_used, t_reserved;
int	t_inodes, t_iused, t_ifree;

/*
 * cached information recording previous chroot history.
 */
static	char	*chrootpath;

extern	int	optind;
extern	char	*optarg;

union {
	struct fs iu_fs;
	char dummy[SBSIZE];
} sb;
#define	sblock	sb.iu_fs

/*
 * This structure is used to chain mntent structures into a list
 * and to cache stat information for each member of the list.
 */
struct mntlist {
	struct mnttab	*mntl_mnt;
	struct mntlist	*mntl_next;
	dev_t		mntl_dev;
	int		mntl_devvalid;
};

char *subopts [] = {
#define	A_FLAG		0
	"a",
#define	I_FLAG		1
	"i",
	NULL
};

int
main(int argc, char *argv[])
{
	struct mnttab 		mnt;
	int			opt;
	char			*suboptions, *value;

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)	/* Should be defined by cc -D */
#define	TEXT_DOMAIN	"SYS_TEST"	/* Use this only if it weren't */
#endif
	(void) textdomain(TEXT_DOMAIN);

	while ((opt = getopt(argc, argv, "beghkno:t")) != EOF) {
		switch (opt) {

		case 'b':	/* print only number of kilobytes free */
			bflag++;
			break;

		case 'e':
			eflag++; /* print only number of file entries free */
			iflag++;
			break;

		case 'g':
			gflag++;
			break;

		case 'n':
			nflag++;
			break;

		case 'k':
			break;

		case 'h':
			hflag++;
			break;

		case 'o':
			/*
			 * ufs specific options.
			 */
			suboptions = optarg;
			while (*suboptions != '\0') {
				switch (getsubopt(&suboptions,
				    subopts, &value)) {

				case I_FLAG:	/* information for inodes */
					iflag++;
					break;

				default:
					usage();
				}
			}
			break;

		case 't':		/* print totals */
			tflag++;
			break;

		case 'V':		/* Print command line */
			{
				char			*opt_text;
				int			opt_count;

				(void) fprintf(stdout, "df -F ufs ");
				for (opt_count = 1; opt_count < argc;
				    opt_count++) {
					opt_text = argv[opt_count];
					if (opt_text)
						(void) fprintf(stdout, " %s ",
						    opt_text);
				}
				(void) fprintf(stdout, "\n");
			}
			break;

		case '?':
			errflag++;
		}
	}
	if (errflag)
		usage();
	if (gflag && iflag) {
		printf(gettext("df: '-g' and '-o i' are mutually exclusive\n"));
		exit(1);
	}
	if (bflag || eflag)
		tflag = 0;

	/*
	 * Cache CHROOT information for later use; assume that $CHROOT matches
	 * the cumulative arguments given to chroot calls.
	 */
	chrootpath = getenv("CHROOT");
	if (chrootpath != NULL && strcmp(chrootpath, "/") == 0)
		chrootpath = NULL;

	if (argc <= optind) {
		/*
		 * Take this path when "/usr/lib/fs/ufs/df" is specified, and
		 * there are no mountpoints specified.
		 * E.g., these command lines take us down this path
		 * 	/usr/lib/fs/ufs/df -o i
		 *	/usr/lib/fs/ufs/df
		 */
		FILE *mtabp;

		if ((mtabp = fopen(MNTTAB, "r")) == NULL) {
			(void) fprintf(stderr, "df: ");
			perror(MNTTAB);
			exit(1);
		}
		pheader();
		while (getmntent(mtabp, &mnt) == 0) {
			if (strcmp(typestr, mnt.mnt_fstype) != 0) {
				continue;
			}
			dfreemnt(mnt.mnt_mountp, &mnt);
		}
		if (tflag)
			if (iflag)
				print_itotals();
			else
				print_totals();
		(void) fclose(mtabp);
	} else {
		int i;
		struct mntlist *mntl;
		struct stat64    *argstat;
		char **devnames;
		char *cp;

		/* Arguments are processed till optind, adjust the pointers */
		argv += optind;
		argc -= optind;

		/*
		 * Obtain stat64 information for each argument before
		 * constructing the list of mounted file systems.  This
		 * ordering forces the automounter to establish any
		 * mounts required to access the arguments, so that the
		 * corresponding mount table entries will exist when
		 * we look for them.
		 */
		argstat = (struct stat64 *)xmalloc(argc * sizeof (*argstat));
		devnames = (char **)xmalloc(argc * sizeof (char *));
		for (i = 0; i < argc; i++) {

			/*
			 * Given a raw device name, get the block device name
			 */
			cp = getfullblkname(argv[i]);
			if (cp == NULL || *cp == '\0') {
				if (cp != NULL)
					free(cp);
				cp = strdup(argv[i]);

				if (cp == NULL) {
					int j;

					fprintf(stderr, gettext(
					"df: memory allocation failure\n"));

					for (j = 0; j < i; j++)
						free(devnames[j]);
					free(devnames);
					free(argstat);
					exit(1);
				}
			}
			if (stat64(cp, &argstat[i]) < 0) {
				errcode = errno;
				/*
				 * Mark as no longer interesting.
				 */
				argv[i] = NULL;
				devnames[i] = NULL;
				free(cp);
			} else {
				devnames[i] = cp;
			}
		}

		pheader();
		aflag++;
		/*
		 * Construct the list of mounted file systems.
		 */
		mntl = mkmntlist();

		/*
		 * Iterate through the argument list, reporting on each one.
		 */
		for (i = 0; i < argc; i++) {
			struct mntlist *mlp;
			int isblk;

			/*
			 * Skip if we've already determined that we can't
			 * process it.
			 */
			if (argv[i] == NULL)
				continue;

			/*
			 * If the argument names a device, report on the file
			 * system associated with the device rather than on
			 * the one containing the device's directory entry
			 */
			cp = devnames[i];
			if ((isblk = (argstat[i].st_mode&S_IFMT) == S_IFBLK) ||
			    (argstat[i].st_mode & S_IFMT) == S_IFCHR) {
				if (isblk && strcmp(mpath(cp), "") != 0) {
					struct mnttab *mp;
					if (mdev(cp, &mp))
						return (1);
					dfreemnt(mp->mnt_mountp, mp);
				} else {
					dfreedev(cp);
				}
				free(cp);
				devnames[i] = NULL;
				continue;
			}

			/*
			 * Get this argument's corresponding mount table
			 * entry.
			 */
			mlp = findmntent(cp, &argstat[i], mntl);
			free(cp);
			devnames[i] = NULL;

			if (mlp == NULL) {
				(void) fprintf(stderr,
				gettext("Could not find mount point for %s\n"),
				    argv[i]);
				continue;
			}

			dfreemnt(mlp->mntl_mnt->mnt_mountp, mlp->mntl_mnt);
		}
		free(devnames);
		free(argstat);
	}
	return (0);
}

void
pheader()
{
	if (hflag)
		return;
	if (nflag)
		(void) printf(gettext("VFStype name - ufs\n"));
	if (iflag) {
		if (eflag)
			/*
			 * TRANSLATION_NOTE
			 * Following string is used as a table header.
			 * Translated items should start at the same
			 * columns as the original items.
			 */
			(void) printf(gettext(
"Filesystem             ifree\n"));
		else {
			/*
			 * TRANSLATION_NOTE
			 * Following string is used as a table header.
			 * Translated items should start at the same
			 * columns as the original items.
			 */
			(void) printf(gettext(
"Filesystem             iused   ifree  %%iused  Mounted on\n"));
		}
	} else {
		if (gflag)
			/*
			 * TRANSLATION_NOTE
			 * Following string is used as a table header.
			 * Translated items should start at the same
			 * columns as the original items.
			 */
			(void) printf(gettext(
"Filesystem        f_type f_fsize f_bfree f_bavail f_files f_ffree "
"f_fsid f_flag f_fstr\n"));
		else
			if (bflag)
				/*
				 * TRANSLATION_NOTE
				 * Following string is used as a table header.
				 * Translated items should start at the same
				 * columns as the original items.
				 */
				(void) printf(gettext(
"Filesystem             avail\n"));
			else {
				/*
				 * TRANSLATION_NOTE
				 * Following string is used as a table header.
				 * Translated items should start at the same
				 * columns as the original items.
				 */
				(void) printf(gettext(
"Filesystem            kbytes    used   avail capacity  Mounted on\n"));
			}
		}
}

/*
 * Report on a block or character special device. Assumed not to be
 * mounted.  N.B. checks for a valid UFS superblock.
 */
void
dfreedev(char *file)
{
	fsblkcnt64_t totalblks, availblks, avail, free, used;
	int fi;

	fi = open64(file, 0);
	if (fi < 0) {
		(void) fprintf(stderr, "df: ");
		perror(file);
		return;
	}
	if (bread(file, fi, SBLOCK, (char *)&sblock, SBSIZE) == 0) {
		(void) close(fi);
		return;
	}
	if ((sblock.fs_magic != FS_MAGIC) &&
	    (sblock.fs_magic != MTB_UFS_MAGIC)) {
		(void) fprintf(stderr, gettext(
"df: %s: not a ufs file system\n"),
		    file);
		(void) close(fi);
		return;
	}
	if (sblock.fs_magic == FS_MAGIC &&
	    (sblock.fs_version != UFS_EFISTYLE4NONEFI_VERSION_2 &&
	    sblock.fs_version != UFS_VERSION_MIN)) {
		(void) fprintf(stderr, gettext(
"df: %s: unrecognized version of UFS: %d\n"),
		    file, sblock.fs_version);
		(void) close(fi);
		return;
	}
	if (sblock.fs_magic == MTB_UFS_MAGIC &&
	    (sblock.fs_version > MTB_UFS_VERSION_1 ||
	    sblock.fs_version < MTB_UFS_VERSION_MIN)) {
		(void) fprintf(stderr, gettext(
"df: %s: unrecognized version of UFS: %d\n"),
		    file, sblock.fs_version);
		(void) close(fi);
		return;
	}
	(void) printf("%-20.20s", file);
	if (iflag) {
		if (eflag) {
			(void) printf("%8ld", sblock.fs_cstotal.cs_nifree);
		} else {
			show_inode_usage(
			    (fsfilcnt64_t)sblock.fs_ncg *
			    (fsfilcnt64_t)sblock.fs_ipg,
			    (fsfilcnt64_t)sblock.fs_cstotal.cs_nifree);
		}
	} else {
		totalblks = (fsblkcnt64_t)sblock.fs_dsize;
		free =
		    (fsblkcnt64_t)sblock.fs_cstotal.cs_nbfree *
		    (fsblkcnt64_t)sblock.fs_frag +
		    (fsblkcnt64_t)sblock.fs_cstotal.cs_nffree;
		used = totalblks - free;
		availblks = totalblks / (fsblkcnt64_t)100 *
		    ((fsblkcnt64_t)100 - (fsblkcnt64_t)sblock.fs_minfree);
		avail = availblks > used ? availblks - used : (fsblkcnt64_t)0;
		if (bflag) {
			(void) printf("%8lld\n", dbtok(avail,
			    (fsblkcnt64_t)sblock.fs_fsize));
		} else {
			(void) printf(" %7lld %7lld %7lld",
			    dbtok(totalblks, (fsblkcnt64_t)sblock.fs_fsize),
			    dbtok(used, (fsblkcnt64_t)sblock.fs_fsize),
			    dbtok(avail, (fsblkcnt64_t)sblock.fs_fsize));
			(void) printf("%6.0f%%",
			    availblks == 0 ? 0.0 :
			    (double)used / (double)availblks * 100.0);
			(void) printf("  ");
		}
		if (tflag) {
			t_totalblks += dbtok(totalblks,
			    (fsblkcnt64_t)sblock.fs_fsize);
			t_used += dbtok(used, (fsblkcnt64_t)sblock.fs_fsize);
			t_avail += dbtok(avail, (fsblkcnt64_t)sblock.fs_fsize);
			t_free += free;
		}
	}
	if ((!bflag) && (!eflag))
		(void) printf("  %s\n", mpath(file));
	else if (eflag)
		(void) printf("\n");
	(void) close(fi);
}

void
dfreemnt(char *file, struct mnttab *mnt)
{
	struct statvfs64 fs;

	if (statvfs64(file, &fs) < 0 &&
	    chroot_stat(file, statvfs64, (char *)&fs, &file) < 0) {
		(void) fprintf(stderr, "df: ");
		perror(file);
		return;
	}

	if (!aflag && fs.f_blocks == 0) {
		return;
	}
	if (!isatty(fileno(stdout))) {
		(void) printf("%s", mnt->mnt_special);
	} else {
		if (strlen(mnt->mnt_special) > (size_t)20) {
			(void) printf("%s\n", mnt->mnt_special);
			(void) printf("                    ");
		} else {
			(void) printf("%-20.20s", mnt->mnt_special);
		}
	}
	if (iflag) {
		if (eflag) {
			(void) printf("%8lld", fs.f_ffree);
		} else {
			show_inode_usage(fs.f_files, fs.f_ffree);
		}
	} else {
		if (gflag) {
			print_statvfs(&fs);
		} else {
			fsblkcnt64_t totalblks, avail, free, used, reserved;

			totalblks = fs.f_blocks;
			free = fs.f_bfree;
			used = totalblks - free;
			avail = fs.f_bavail;
			reserved = free - avail;
			if ((long long)avail < 0)
				avail = 0;
			if (bflag) {
				(void) printf("%8lld\n", dbtok(avail,
				    (fsblkcnt64_t)fs.f_frsize));
			} else {
				(void) printf(" %7lld %7lld %7lld",
				    dbtok(totalblks,
				    (fsblkcnt64_t)fs.f_frsize),
				    dbtok(used, (fsblkcnt64_t)fs.f_frsize),
				    dbtok(avail, (fsblkcnt64_t)fs.f_frsize));
				totalblks -= reserved;
				(void) printf("%6.0f%%",
				    totalblks == 0 ? 0.0 :
				    (double)used / (double)totalblks * 100.0);
				(void) printf("  ");
				if (tflag) {
				t_totalblks += dbtok(totalblks + reserved,
				    (fsblkcnt64_t)fs.f_bsize);
				t_reserved += reserved;
				t_used += dbtok(used,
				    (fsblkcnt64_t)fs.f_frsize);
				t_avail += dbtok(avail,
				    (fsblkcnt64_t)fs.f_frsize);
				t_free += free;
				}
			}
		}
	}
	if ((!bflag) && (!eflag) && (!gflag))
		(void) printf("  %s\n", mnt->mnt_mountp);
	else if (eflag)
		(void) printf("\n");
}

static void
show_inode_usage(fsfilcnt64_t total, fsfilcnt64_t free)
{
	fsfilcnt64_t used = total - free;
	int missing_info = ((long long)total == (long long)-1 ||
	    (long long)free == (long long)-1);

	if (missing_info)
		(void) printf("%8s", "*");
	else
		(void) printf("%8lld", used);
	if ((long long)free == (long long)-1)
		(void) printf("%8s", "*");
	else
		(void) printf(" %7lld", free);
	if (missing_info)
		(void) printf("%6s  ", "*");
	else
		(void) printf("%6.0f%% ", (double)used / (double)total * 100.0);
}

/*
 * Return the suffix of path obtained by stripping off the prefix
 * that is the value of the CHROOT environment variable.  If this
 * value isn't obtainable or if it's not a prefix of path, return NULL.
 */
static char *
zap_chroot(char *path)
{
	return (pathsuffix(path, chrootpath));
}

/*
 * Stat/statfs a file after stripping off leading directory to which we are
 * chroot'd.  Used to find the TFS mount that applies to the current
 * activated NSE environment.
 */
static int
chroot_stat(char *dir, int (*statfunc)(), char *statp, char **dirp)
{
	if ((dir = zap_chroot(dir)) == NULL)
		return (-1);
	if (dirp)
		*dirp = dir;
	return (*statfunc)(dir, statp);
}

/*
 * Given a name like /dev/dsk/c1d0s2, returns the mounted path, like /usr.
 */
char *
mpath(char *file)
{
	struct mnttab mnt;
	FILE *mnttab;
	struct stat64 device_stat, mount_stat;
	char *mname;

	mnttab = fopen(MNTTAB, "r");
	if (mnttab == NULL) {
		return ("");
	}
	mname = "";
	while ((getmntent(mnttab, &mnt)) == 0) {
		if (strcmp(mnt.mnt_fstype, MNTTYPE_UFS) != 0) {
			continue;
		}
		if (strcmp(file, mnt.mnt_special) == 0) {
			if (stat64(mnt.mnt_mountp, &mount_stat) != 0)
				continue;
			if (stat64(mnt.mnt_special, &device_stat) != 0)
				continue;

			if (device_stat.st_rdev == mount_stat.st_dev) {
				mname = mnt.mnt_mountp;
				break;
			}
		}
	}
	fclose(mnttab);
	return (mname);
}

/*
 * Given a special device, return mnttab entry
 * Returns 0 on success
 */

int
mdev(char *spec, struct mnttab **mntbp)
{
	FILE *mntp;
	struct mnttab mnt;

	if ((mntp = fopen(MNTTAB, "r")) == 0) {
		(void) fprintf(stderr, "df: ");
		perror(MNTTAB);
		return (1);
	}

	while (getmntent(mntp, &mnt) == 0) {
		if (strcmp(spec, mnt.mnt_special) == 0) {
			(void) fclose(mntp);
			*mntbp =  mntdup(&mnt);
			return (0);
		}
	}
	(void) fclose(mntp);
	(void) fprintf(stderr, "df : couldn't find mnttab entry for %s", spec);
	return (1);
}

/*
 * Find the entry in mlist that corresponds to the file named by path
 * (i.e., that names a mount table entry for the file system in which
 * path lies).  The pstat argument must point to stat information for
 * path.
 *
 * Return the entry or NULL if there's no match.
 *
 * As it becomes necessary to obtain stat information about previously
 * unexamined mlist entries, gather the information and cache it with the
 * entries.
 *
 * The routine's strategy is to convert path into its canonical, symlink-free
 * representation canon (which will require accessing the file systems on the
 * branch from the root to path and thus may cause the routine to hang if any
 * of them are inaccessible) and to use it to search for a mount point whose
 * name is a substring of canon and whose corresponding device matches that of
 * canon.  This technique avoids accessing unnecessary file system resources
 * and thus prevents the program from hanging on inaccessible resources unless
 * those resources are necessary for accessing path.
 */
static struct mntlist *
findmntent(char *path, struct stat64 *pstat, struct mntlist *mlist)
{
	static char		cwd[MAXPATHLEN];
	char			canon[MAXPATHLEN];
	char			scratch[MAXPATHLEN];
	struct mntlist *mlp;

	/*
	 * If path is relative and we haven't already determined the current
	 * working directory, do so now.  Calculating the working directory
	 * here lets us do the work once, instead of (potentially) repeatedly
	 * in realpath().
	 */
	if (*path != '/' && cwd[0] == '\0') {
		if (getcwd(cwd, MAXPATHLEN) == NULL) {
			cwd[0] = '\0';
			return (NULL);
		}
	}

	/*
	 * Find an absolute pathname in the native file system name space that
	 * corresponds to path, stuffing it into canon.
	 *
	 * If CHROOT is set in the environment, assume that chroot($CHROOT)
	 * (or an equivalent series of calls) was executed and convert the
	 * path to the equivalent name in the native file system's name space.
	 * Doing so allows direct comparison with the names in mtab entires,
	 * which are assumed to be recorded relative to the native name space.
	 */
	if (abspath(cwd, path, scratch) < 0)
		return (NULL);
	if (strcmp(scratch, "/") == 0 && chrootpath != NULL) {
		/*
		 * Force canon to be in canonical form; if the result from
		 * abspath was "/" and chrootpath isn't the null string, we
		 * must strip off a trailing slash.
		 */
		scratch[0] = '\0';
	}
	(void) sprintf(canon, "%s%s", chrootpath ? chrootpath : "", scratch);

again:
	for (mlp = mlist; mlp; mlp = mlp->mntl_next) {
		struct mnttab *mnt = mlp->mntl_mnt;

		/*
		 * Ignore uninteresting mounts.
		 */
		if (strcmp(mnt->mnt_fstype, typestr) != 0)
			continue;

		/*
		 * The mount entry covers some prefix of the file.
		 * See whether it's the entry for the file system
		 * containing the file by comparing device ids.
		 */
		if (mlp->mntl_dev == NODEV) {
			struct stat64 fs_sb;

			if (stat64(mnt->mnt_mountp, &fs_sb) < 0 &&
			    chroot_stat(mnt->mnt_mountp, stat64, (char *)&fs_sb,
			    (char **)NULL) < 0) {
				continue;
			}
			mlp->mntl_dev = fs_sb.st_dev;
		}

		if (pstat->st_dev == mlp->mntl_dev)
			return (mlp);
	}

	return (NULL);
}

/*
 * Convert the path given in raw to canonical, absolute, symlink-free
 * form, storing the result in the buffer named by canon, which must be
 * at least MAXPATHLEN bytes long.  "wd" contains the current working
 * directory; accepting this value as an argument lets our caller cache
 * the value, so that realpath (called from this routine) doesn't have
 * to recalculate it each time it's given a relative pathname.
 *
 * Return 0 on success, -1 on failure.
 */
static int
abspath(char *wd, char *raw, char *canon)
{
	char		absbuf[MAXPATHLEN];

	/*
	 * Preliminary sanity check.
	 */
	if (wd == NULL || raw == NULL || canon == NULL)
		return (-1);

	/*
	 * If the path is relative, convert it to absolute form,
	 * using wd if it's been supplied.
	 */
	if (raw[0] != '/') {
		char	*limit = absbuf + sizeof (absbuf);
		char	*d;

		/* Fill in working directory. */
		if (strlcpy(absbuf, wd, sizeof (absbuf)) >= sizeof (absbuf))
			return (-1);

		/* Add separating slash. */
		d = absbuf + strlen(absbuf);
		if (d < limit)
			*d++ = '/';

		/* Glue on the relative part of the path. */
		while (d < limit && (*d++ = *raw++))
			continue;

		raw = absbuf;
	}

	/*
	 * Call realpath to canonicalize and resolve symlinks.
	 */
	return (realpath(raw, canon) == NULL ? -1 : 0);
}

/*
 * Return a pointer to the trailing suffix of full that follows the prefix
 * given by pref.  If pref isn't a prefix of full, return NULL.  Apply
 * pathname semantics to the prefix test, so that pref must match at a
 * component boundary.
 */
static char *
pathsuffix(char *full, char *pref)
{
	int preflen;

	if (full == NULL || pref == NULL)
		return (NULL);

	preflen = strlen(pref);
	if (strncmp(pref, full, preflen) != 0)
		return (NULL);

	/*
	 * pref is a substring of full.  To be a subpath, it cannot cover a
	 * partial component of full.  The last clause of the test handles the
	 * special case of the root.
	 */
	if (full[preflen] != '\0' && full[preflen] != '/' && preflen > 1)
		return (NULL);

	if (preflen == 1 && full[0] == '/')
		return (full);
	else
		return (full + preflen);
}

/*
 * Return zero iff the path named by sub is a leading subpath
 * of the path named by full.
 *
 * Treat null paths as matching nothing.
 */
static int
subpath(char *full, char *sub)
{
	return (pathsuffix(full, sub) == NULL);
}

offset_t llseek();

int
bread(char *file, int fi, daddr_t bno, char *buf, int cnt)
{
	int n;

	(void) llseek(fi, (offset_t)bno * DEV_BSIZE, 0);
	if ((n = read(fi, buf, cnt)) < 0) {
		/* probably a dismounted disk if errno == EIO */
		if (errno != EIO) {
			(void) fprintf(stderr, gettext("df: read error on "));
			perror(file);
			(void) fprintf(stderr, "bno = %ld\n", bno);
		} else {
			(void) fprintf(stderr, gettext(
"df: premature EOF on %s\n"), file);
			(void) fprintf(stderr,
			"bno = %ld expected = %d count = %d\n", bno, cnt, n);
		}
		return (0);
	}
	return (1);
}

char *
xmalloc(unsigned int size)
{
	char *ret;
	char *malloc();

	if ((ret = (char *)malloc(size)) == NULL) {
		(void) fprintf(stderr, gettext("umount: ran out of memory!\n"));
		exit(1);
	}
	return (ret);
}

struct mnttab *
mntdup(struct mnttab *mnt)
{
	struct mnttab *new;

	new = (struct mnttab *)xmalloc(sizeof (*new));

	new->mnt_special =
	    (char *)xmalloc((unsigned)(strlen(mnt->mnt_special) + 1));
	(void) strcpy(new->mnt_special, mnt->mnt_special);

	new->mnt_mountp =
	    (char *)xmalloc((unsigned)(strlen(mnt->mnt_mountp) + 1));
	(void) strcpy(new->mnt_mountp, mnt->mnt_mountp);

	new->mnt_fstype =
	    (char *)xmalloc((unsigned)(strlen(mnt->mnt_fstype) + 1));
	(void) strcpy(new->mnt_fstype, mnt->mnt_fstype);

	if (mnt->mnt_mntopts != NULL) {
		new->mnt_mntopts =
		    (char *)xmalloc((unsigned)(strlen(mnt->mnt_mntopts) + 1));
		(void) strcpy(new->mnt_mntopts, mnt->mnt_mntopts);
	} else {
		new->mnt_mntopts = NULL;
	}

#ifdef never
	new->mnt_freq = mnt->mnt_freq;
	new->mnt_passno = mnt->mnt_passno;
#endif /* never */

	return (new);
}

void
usage()
{

	(void) fprintf(stderr, gettext(
"ufs usage: df [generic options] [-o i] [directory | special]\n"));
	exit(1);
}

struct mntlist *
mkmntlist()
{
	FILE *mounted;
	struct mntlist *mntl;
	struct mntlist *mntst = NULL;
	struct extmnttab mnt;

	if ((mounted = fopen(MNTTAB, "r")) == NULL) {
		(void) fprintf(stderr, "df : ");
		perror(MNTTAB);
		exit(1);
	}
	resetmnttab(mounted);
	while (getextmntent(mounted, &mnt, sizeof (struct extmnttab)) == NULL) {
		mntl = (struct mntlist *)xmalloc(sizeof (*mntl));
		mntl->mntl_mnt = mntdup((struct mnttab *)(&mnt));
		mntl->mntl_next = mntst;
		mntl->mntl_devvalid = 1;
		mntl->mntl_dev = makedev(mnt.mnt_major, mnt.mnt_minor);
		mntst = mntl;
	}
	(void) fclose(mounted);
	return (mntst);
}

void
print_statvfs(struct statvfs64 *fs)
{
	int	i;

	for (i = 0; i < FSTYPSZ; i++)
		(void) printf("%c", fs->f_basetype[i]);
	(void) printf(" %7d %7lld %7lld",
	    fs->f_frsize,
	    fs->f_blocks,
	    fs->f_bavail);
	(void) printf(" %7lld %7lld %7d",
	    fs->f_files,
	    fs->f_ffree,
	    fs->f_fsid);
	(void) printf(" 0x%x ",
	    fs->f_flag);
	for (i = 0; i < 14; i++)
		(void) printf("%c",
		    (fs->f_fstr[i] == '\0') ? ' ' : fs->f_fstr[i]);
	printf("\n");
}

void
print_totals()
{
	/*
	 * TRANSLATION_NOTE
	 * Following string is used as a table header.
	 * Translated items should start at the same
	 * columns as the original items.
	 */
	(void) printf(gettext("Totals              %8lld %7lld %7lld"),
	    t_totalblks, t_used, t_avail);
	(void) printf("%6.0f%%\n",
	    (t_totalblks - t_reserved) == (fsblkcnt64_t)0 ?
	    0.0 :
	    (double)t_used / (double)(t_totalblks - t_reserved) * 100.0);
}

void
print_itotals()
{
	/*
	 * TRANSLATION_NOTE
	 * Following string is used as a table header.
	 * Translated items should start at the same
	 * columns as the original items.
	 */
	(void) printf(gettext("Totals              %8d %7d%6.0f%%\n"),
	    t_iused,
	    t_ifree,
	    t_inodes == 0 ? 0.0 : (double)t_iused / (double)t_inodes * 100.0);
}