1 /* 2 * Copyright (c) 1980, 1990, 1993, 1994 3 * The Regents of the University of California. All rights reserved. 4 * (c) UNIX System Laboratories, Inc. 5 * All or some portions of this file are derived from material licensed 6 * to the University of California by American Telephone and Telegraph 7 * Co. or Unix System Laboratories, Inc. and are reproduced herein with 8 * the permission of UNIX System Laboratories, Inc. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the University of 21 * California, Berkeley and its contributors. 22 * 4. Neither the name of the University nor the names of its contributors 23 * may be used to endorse or promote products derived from this software 24 * without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 27 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 30 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 31 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 32 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 33 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 35 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 36 * SUCH DAMAGE. 37 */ 38 39 #ifndef lint 40 static const char copyright[] = 41 "@(#) Copyright (c) 1980, 1990, 1993, 1994\n\ 42 The Regents of the University of California. All rights reserved.\n"; 43 #endif /* not lint */ 44 45 #ifndef lint 46 #if 0 47 static char sccsid[] = "@(#)df.c 8.9 (Berkeley) 5/8/95"; 48 #else 49 static const char rcsid[] = 50 "$FreeBSD$"; 51 #endif 52 #endif /* not lint */ 53 54 #include <sys/param.h> 55 #include <sys/stat.h> 56 #include <sys/mount.h> 57 #include <ufs/ufs/ufsmount.h> 58 59 #include <err.h> 60 #include <errno.h> 61 #include <fcntl.h> 62 #include <stdio.h> 63 #include <stdlib.h> 64 #include <string.h> 65 #include <unistd.h> 66 67 int checkvfsname __P((const char *, char **)); 68 char **makevfslist __P((char *)); 69 long regetmntinfo __P((struct statfs **, long, char **)); 70 int bread __P((off_t, void *, int)); 71 char *getmntpt __P((char *)); 72 void prtstat __P((struct statfs *, int)); 73 int ufs_df __P((char *, int)); 74 void usage __P((void)); 75 76 int aflag = 0, iflag, nflag; 77 struct ufs_args mdev; 78 79 int 80 main(argc, argv) 81 int argc; 82 char *argv[]; 83 { 84 struct stat stbuf; 85 struct statfs statfsbuf, *mntbuf; 86 long mntsize; 87 int ch, err, i, maxwidth, rv, width; 88 char *mntpt, *mntpath, **vfslist; 89 90 vfslist = NULL; 91 while ((ch = getopt(argc, argv, "aiknt:")) != -1) 92 switch (ch) { 93 case 'a': 94 aflag = 1; 95 break; 96 case 'i': 97 iflag = 1; 98 break; 99 case 'k': 100 putenv("BLOCKSIZE=1k"); 101 break; 102 case 'n': 103 nflag = 1; 104 break; 105 case 't': 106 if (vfslist != NULL) 107 errx(1, "only one -t option may be specified."); 108 vfslist = makevfslist(optarg); 109 break; 110 case '?': 111 default: 112 usage(); 113 } 114 argc -= optind; 115 argv += optind; 116 117 mntsize = getmntinfo(&mntbuf, MNT_NOWAIT); 118 maxwidth = 0; 119 for (i = 0; i < mntsize; i++) { 120 width = strlen(mntbuf[i].f_mntfromname); 121 if (width > maxwidth) 122 maxwidth = width; 123 } 124 125 rv = 0; 126 if (!*argv) { 127 mntsize = regetmntinfo(&mntbuf, mntsize, vfslist); 128 if (vfslist != NULL) { 129 maxwidth = 0; 130 for (i = 0; i < mntsize; i++) { 131 width = strlen(mntbuf[i].f_mntfromname); 132 if (width > maxwidth) 133 maxwidth = width; 134 } 135 } 136 for (i = 0; i < mntsize; i++) { 137 if (aflag || (mntbuf[i].f_flags & MNT_IGNORE) == 0) 138 prtstat(&mntbuf[i], maxwidth); 139 } 140 exit(rv); 141 } 142 143 for (; *argv; argv++) { 144 if (stat(*argv, &stbuf) < 0) { 145 err = errno; 146 if ((mntpt = getmntpt(*argv)) == 0) { 147 warn("%s", *argv); 148 rv = 1; 149 continue; 150 } 151 } else if ((stbuf.st_mode & S_IFMT) == S_IFCHR) { 152 rv = ufs_df(*argv, maxwidth) || rv; 153 continue; 154 } else if ((stbuf.st_mode & S_IFMT) == S_IFBLK) { 155 if ((mntpt = getmntpt(*argv)) == 0) { 156 mdev.fspec = *argv; 157 mntpath = strdup("/tmp/df.XXXXXX"); 158 if (mntpath == NULL) { 159 warn("strdup failed"); 160 rv = 1; 161 continue; 162 } 163 mntpt = mkdtemp(mntpath); 164 if (mntpt == NULL) { 165 warn("mkdtemp(\"%s\") failed", mntpath); 166 rv = 1; 167 free(mntpath); 168 continue; 169 } 170 if (mount("ufs", mntpt, MNT_RDONLY, 171 &mdev) != 0) { 172 rv = ufs_df(*argv, maxwidth) || rv; 173 (void)rmdir(mntpt); 174 free(mntpath); 175 continue; 176 } else if (statfs(mntpt, &statfsbuf) == 0) { 177 statfsbuf.f_mntonname[0] = '\0'; 178 prtstat(&statfsbuf, maxwidth); 179 } else { 180 warn("%s", *argv); 181 rv = 1; 182 } 183 (void)unmount(mntpt, 0); 184 (void)rmdir(mntpt); 185 free(mntpath); 186 continue; 187 } 188 } else 189 mntpt = *argv; 190 /* 191 * Statfs does not take a `wait' flag, so we cannot 192 * implement nflag here. 193 */ 194 if (statfs(mntpt, &statfsbuf) < 0) { 195 warn("%s", mntpt); 196 rv = 1; 197 continue; 198 } 199 if (argc == 1) 200 maxwidth = strlen(statfsbuf.f_mntfromname) + 1; 201 prtstat(&statfsbuf, maxwidth); 202 } 203 return (rv); 204 } 205 206 char * 207 getmntpt(name) 208 char *name; 209 { 210 long mntsize, i; 211 struct statfs *mntbuf; 212 213 mntsize = getmntinfo(&mntbuf, MNT_NOWAIT); 214 for (i = 0; i < mntsize; i++) { 215 if (!strcmp(mntbuf[i].f_mntfromname, name)) 216 return (mntbuf[i].f_mntonname); 217 } 218 return (0); 219 } 220 221 /* 222 * Make a pass over the filesystem info in ``mntbuf'' filtering out 223 * filesystem types not in vfslist and possibly re-stating to get 224 * current (not cached) info. Returns the new count of valid statfs bufs. 225 */ 226 long 227 regetmntinfo(mntbufp, mntsize, vfslist) 228 struct statfs **mntbufp; 229 long mntsize; 230 char **vfslist; 231 { 232 int i, j; 233 struct statfs *mntbuf; 234 235 if (vfslist == NULL) 236 return (nflag ? mntsize : getmntinfo(mntbufp, MNT_WAIT)); 237 238 mntbuf = *mntbufp; 239 for (j = 0, i = 0; i < mntsize; i++) { 240 if (checkvfsname(mntbuf[i].f_fstypename, vfslist)) 241 continue; 242 if (!nflag) 243 (void)statfs(mntbuf[i].f_mntonname,&mntbuf[j]); 244 else if (i != j) 245 mntbuf[j] = mntbuf[i]; 246 j++; 247 } 248 return (j); 249 } 250 251 /* 252 * Convert statfs returned filesystem size into BLOCKSIZE units. 253 * Attempts to avoid overflow for large filesystems. 254 */ 255 #define fsbtoblk(num, fsbs, bs) \ 256 (((fsbs) != 0 && (fsbs) < (bs)) ? \ 257 (num) / ((bs) / (fsbs)) : (num) * ((fsbs) / (bs))) 258 259 /* 260 * Print out status about a filesystem. 261 */ 262 void 263 prtstat(sfsp, maxwidth) 264 struct statfs *sfsp; 265 int maxwidth; 266 { 267 static long blocksize; 268 static int headerlen, timesthrough; 269 static char *header; 270 long used, availblks, inodes; 271 272 if (maxwidth < 11) 273 maxwidth = 11; 274 if (++timesthrough == 1) { 275 header = getbsize(&headerlen, &blocksize); 276 (void)printf("%-*.*s %s Used Avail Capacity", 277 maxwidth, maxwidth, "Filesystem", header); 278 if (iflag) 279 (void)printf(" iused ifree %%iused"); 280 (void)printf(" Mounted on\n"); 281 } 282 (void)printf("%-*.*s", maxwidth, maxwidth, sfsp->f_mntfromname); 283 used = sfsp->f_blocks - sfsp->f_bfree; 284 availblks = sfsp->f_bavail + used; 285 (void)printf(" %*ld %8ld %8ld", headerlen, 286 fsbtoblk(sfsp->f_blocks, sfsp->f_bsize, blocksize), 287 fsbtoblk(used, sfsp->f_bsize, blocksize), 288 fsbtoblk(sfsp->f_bavail, sfsp->f_bsize, blocksize)); 289 (void)printf(" %5.0f%%", 290 availblks == 0 ? 100.0 : (double)used / (double)availblks * 100.0); 291 if (iflag) { 292 inodes = sfsp->f_files; 293 used = inodes - sfsp->f_ffree; 294 (void)printf(" %7ld %7ld %5.0f%% ", used, sfsp->f_ffree, 295 inodes == 0 ? 100.0 : (double)used / (double)inodes * 100.0); 296 } else 297 (void)printf(" "); 298 (void)printf(" %s\n", sfsp->f_mntonname); 299 } 300 301 /* 302 * This code constitutes the pre-system call Berkeley df code for extracting 303 * information from filesystem superblocks. 304 */ 305 #include <ufs/ufs/dinode.h> 306 #include <ufs/ffs/fs.h> 307 #include <errno.h> 308 #include <fstab.h> 309 310 union { 311 struct fs iu_fs; 312 char dummy[SBSIZE]; 313 } sb; 314 #define sblock sb.iu_fs 315 316 int rfd; 317 318 int 319 ufs_df(file, maxwidth) 320 char *file; 321 int maxwidth; 322 { 323 struct statfs statfsbuf; 324 struct statfs *sfsp; 325 char *mntpt; 326 static int synced; 327 328 if (synced++ == 0) 329 sync(); 330 331 if ((rfd = open(file, O_RDONLY)) < 0) { 332 warn("%s", file); 333 return (1); 334 } 335 if (bread((off_t)SBOFF, &sblock, SBSIZE) == 0) { 336 (void)close(rfd); 337 return (1); 338 } 339 sfsp = &statfsbuf; 340 sfsp->f_type = 1; 341 strcpy(sfsp->f_fstypename, "ufs"); 342 sfsp->f_flags = 0; 343 sfsp->f_bsize = sblock.fs_fsize; 344 sfsp->f_iosize = sblock.fs_bsize; 345 sfsp->f_blocks = sblock.fs_dsize; 346 sfsp->f_bfree = sblock.fs_cstotal.cs_nbfree * sblock.fs_frag + 347 sblock.fs_cstotal.cs_nffree; 348 sfsp->f_bavail = freespace(&sblock, sblock.fs_minfree); 349 sfsp->f_files = sblock.fs_ncg * sblock.fs_ipg; 350 sfsp->f_ffree = sblock.fs_cstotal.cs_nifree; 351 sfsp->f_fsid.val[0] = 0; 352 sfsp->f_fsid.val[1] = 0; 353 if ((mntpt = getmntpt(file)) == 0) 354 mntpt = ""; 355 memmove(&sfsp->f_mntonname[0], mntpt, MNAMELEN); 356 memmove(&sfsp->f_mntfromname[0], file, MNAMELEN); 357 prtstat(sfsp, maxwidth); 358 (void)close(rfd); 359 return (0); 360 } 361 362 int 363 bread(off, buf, cnt) 364 off_t off; 365 void *buf; 366 int cnt; 367 { 368 int nr; 369 370 (void)lseek(rfd, off, SEEK_SET); 371 if ((nr = read(rfd, buf, cnt)) != cnt) { 372 /* Probably a dismounted disk if errno == EIO. */ 373 if (errno != EIO) 374 (void)fprintf(stderr, "\ndf: %qd: %s\n", 375 off, strerror(nr > 0 ? EIO : errno)); 376 return (0); 377 } 378 return (1); 379 } 380 381 void 382 usage() 383 { 384 (void)fprintf(stderr, 385 "usage: df [-aikn] [-t type] [file | filesystem ...]\n"); 386 exit(1); 387 } 388