Home | History | Annotate | Download | only in syscall
      1 /*
      2  * CDDL HEADER START
      3  *
      4  * The contents of this file are subject to the terms of the
      5  * Common Development and Distribution License (the "License").
      6  * You may not use this file except in compliance with the License.
      7  *
      8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
      9  * or http://www.opensolaris.org/os/licensing.
     10  * See the License for the specific language governing permissions
     11  * and limitations under the License.
     12  *
     13  * When distributing Covered Code, include this CDDL HEADER in each
     14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
     15  * If applicable, add the following below this CDDL HEADER, with the
     16  * fields enclosed by brackets "[]" replaced with your own identifying
     17  * information: Portions Copyright [yyyy] [name of copyright owner]
     18  *
     19  * CDDL HEADER END
     20  */
     21 /*
     22  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
     23  * Use is subject to license terms.
     24  */
     25 
     26 /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
     27 /*	  All Rights Reserved  	*/
     28 
     29 /*
     30  * Portions of this source code were derived from Berkeley 4.3 BSD
     31  * under license from the Regents of the University of California.
     32  */
     33 
     34 #pragma ident	"@(#)statvfs.c	1.19	06/05/17 SMI"
     35 
     36 /*
     37  * Get file system statistics (statvfs and fstatvfs).
     38  */
     39 
     40 #include <sys/types.h>
     41 #include <sys/inttypes.h>
     42 #include <sys/t_lock.h>
     43 #include <sys/param.h>
     44 #include <sys/errno.h>
     45 #include <sys/fstyp.h>
     46 #include <sys/systm.h>
     47 #include <sys/vfs.h>
     48 #include <sys/statvfs.h>
     49 #include <sys/vnode.h>
     50 #include <sys/file.h>
     51 #include <sys/cmn_err.h>
     52 #include <sys/debug.h>
     53 #include <sys/pathname.h>
     54 
     55 #include <vm/page.h>
     56 #include <fs/fs_subr.h>
     57 
     58 #define	STATVFSCOPY(dst, src)					\
     59 	(dst)->f_bsize	= (src)->f_bsize;			\
     60 	(dst)->f_frsize	= (src)->f_frsize;			\
     61 	(dst)->f_blocks	= (src)->f_blocks;			\
     62 	(dst)->f_bfree	= (src)->f_bfree;			\
     63 	(dst)->f_bavail	= (src)->f_bavail;			\
     64 	(dst)->f_files	= (src)->f_files;			\
     65 	(dst)->f_ffree	= (src)->f_ffree;			\
     66 	(dst)->f_favail	= (src)->f_favail;			\
     67 	(dst)->f_fsid	= (src)->f_fsid;			\
     68 	bcopy((src)->f_basetype, (dst)->f_basetype,		\
     69 		sizeof ((dst)->f_basetype));			\
     70 	(dst)->f_flag	= (src)->f_flag;			\
     71 	(dst)->f_namemax = (src)->f_namemax;			\
     72 	bcopy((src)->f_fstr, (dst)->f_fstr,			\
     73 		sizeof ((dst)->f_fstr))
     74 
     75 /*
     76  * Common routines for statvfs and fstatvfs.
     77  */
     78 
     79 static int
     80 cstatvfs32(struct vfs *vfsp, struct statvfs32 *ubp)
     81 {
     82 	struct statvfs64 ds64;
     83 	struct statvfs32 ds32;
     84 	int error;
     85 
     86 #if !defined(lint)
     87 	ASSERT32(sizeof (struct statvfs) == sizeof (struct statvfs32));
     88 	ASSERT32(sizeof (struct statvfs64) == sizeof (struct statvfs64_32));
     89 #endif
     90 
     91 	bzero(&ds64, sizeof (ds64));
     92 	if ((error = VFS_STATVFS(vfsp, &ds64)) != 0)
     93 		return (error);
     94 
     95 	/*
     96 	 * VFS_STATVFS can return data that is incompatible with the space
     97 	 * available the 32-bit statvfs structure.  Check here to see if
     98 	 * it will fit into the 32-bit structure, if not, return EOVERFLOW.
     99 	 *
    100 	 * The check for -1 is because some file systems return -1 in the
    101 	 * fields that are irrelevant or nonessential, and we do not want
    102 	 * to return EOVERFLOW for them.  For example: df is expected to
    103 	 * show -1 in the output for some of these fields on NFS mounted
    104 	 * filesystems.
    105 	 */
    106 	if (ds64.f_files == (fsfilcnt64_t)-1)
    107 		ds64.f_files = UINT32_MAX;
    108 	if (ds64.f_ffree == (fsfilcnt64_t)-1)
    109 		ds64.f_ffree = UINT32_MAX;
    110 	if (ds64.f_favail == (fsfilcnt64_t)-1)
    111 		ds64.f_favail = UINT32_MAX;
    112 	if (ds64.f_bavail == (fsblkcnt64_t)-1)
    113 		ds64.f_bavail = UINT32_MAX;
    114 	if (ds64.f_bfree == (fsblkcnt64_t)-1)
    115 		ds64.f_bfree = UINT32_MAX;
    116 
    117 	if (ds64.f_blocks > UINT32_MAX || ds64.f_bfree > UINT32_MAX ||
    118 	    ds64.f_bavail > UINT32_MAX || ds64.f_files > UINT32_MAX ||
    119 	    ds64.f_ffree > UINT32_MAX || ds64.f_favail > UINT32_MAX)
    120 		return (EOVERFLOW);
    121 #ifdef _LP64
    122 	/*
    123 	 * On the 64-bit kernel, even these fields grow to 64-bit
    124 	 * quantities in the statvfs64 structure.
    125 	 */
    126 	if (ds64.f_namemax == (ulong_t)-1l)
    127 		ds64.f_namemax = UINT32_MAX;
    128 
    129 	if (ds64.f_bsize > UINT32_MAX || ds64.f_frsize > UINT32_MAX ||
    130 	    ds64.f_fsid > UINT32_MAX || ds64.f_flag > UINT32_MAX ||
    131 	    ds64.f_namemax > UINT32_MAX)
    132 		return (EOVERFLOW);
    133 #endif
    134 
    135 	bzero(&ds32, sizeof (ds32));
    136 	STATVFSCOPY(&ds32, &ds64);
    137 	if (copyout(&ds32, ubp, sizeof (ds32)) != 0)
    138 		return (EFAULT);
    139 	return (0);
    140 }
    141 
    142 static int
    143 cstatvfs64(struct vfs *vfsp, struct statvfs64 *ubp)
    144 {
    145 	struct statvfs64 ds64;
    146 	int error;
    147 
    148 #if !defined(lint)
    149 	ASSERT64(sizeof (struct statvfs) == sizeof (struct statvfs64));
    150 #endif
    151 	bzero(&ds64, sizeof (ds64));
    152 	if ((error = VFS_STATVFS(vfsp, &ds64)) != 0)
    153 		return (error);
    154 	if (copyout(&ds64, ubp, sizeof (ds64)) != 0)
    155 		return (EFAULT);
    156 	return (0);
    157 }
    158 
    159 /*
    160  * Native system calls
    161  */
    162 int
    163 statvfs(char *fname, struct statvfs *sbp)
    164 {
    165 	vnode_t *vp;
    166 	int error;
    167 	int estale_retry = 0;
    168 
    169 lookup:
    170 	if (error = lookupname(fname, UIO_USERSPACE, FOLLOW, NULLVPP, &vp)) {
    171 		if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
    172 			goto lookup;
    173 		return (set_errno(error));
    174 	}
    175 #ifdef _LP64
    176 	error = cstatvfs64(vp->v_vfsp, (struct statvfs64 *)sbp);
    177 #else
    178 	error = cstatvfs32(vp->v_vfsp, (struct statvfs32 *)sbp);
    179 #endif
    180 	VN_RELE(vp);
    181 	if (error) {
    182 		if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
    183 			goto lookup;
    184 		return (set_errno(error));
    185 	}
    186 	return (0);
    187 }
    188 
    189 int
    190 fstatvfs(int fdes, struct statvfs *sbp)
    191 {
    192 	struct file *fp;
    193 	int error;
    194 
    195 	if ((fp = getf(fdes)) == NULL)
    196 		return (set_errno(EBADF));
    197 #ifdef _LP64
    198 	error = cstatvfs64(fp->f_vnode->v_vfsp, (struct statvfs64 *)sbp);
    199 #else
    200 	error = cstatvfs32(fp->f_vnode->v_vfsp, (struct statvfs32 *)sbp);
    201 #endif
    202 	releasef(fdes);
    203 	if (error)
    204 		return (set_errno(error));
    205 	return (0);
    206 }
    207 
    208 #if defined(_ILP32)
    209 
    210 /*
    211  * Large File system calls.
    212  *
    213  * (We deliberately don't have special "large file" system calls in the
    214  * 64-bit kernel -- we just use the native versions, since they're just
    215  * as functional.)
    216  */
    217 int
    218 statvfs64(char *fname, struct statvfs64 *sbp)
    219 {
    220 	vnode_t *vp;
    221 	int error;
    222 	int estale_retry = 0;
    223 
    224 lookup:
    225 	if (error = lookupname(fname, UIO_USERSPACE, FOLLOW, NULLVPP, &vp)) {
    226 		if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
    227 			goto lookup;
    228 		return (set_errno(error));
    229 	}
    230 	error = cstatvfs64(vp->v_vfsp, sbp);
    231 	VN_RELE(vp);
    232 	if (error) {
    233 		if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
    234 			goto lookup;
    235 		return (set_errno(error));
    236 	}
    237 	return (0);
    238 }
    239 
    240 int
    241 fstatvfs64(int fdes, struct statvfs64 *sbp)
    242 {
    243 	struct file *fp;
    244 	int error;
    245 
    246 	if ((fp = getf(fdes)) == NULL)
    247 		return (set_errno(EBADF));
    248 	error = cstatvfs64(fp->f_vnode->v_vfsp, sbp);
    249 	releasef(fdes);
    250 	if (error)
    251 		return (set_errno(error));
    252 	return (0);
    253 }
    254 
    255 #endif	/* _ILP32 */
    256 
    257 #ifdef _SYSCALL32_IMPL
    258 
    259 static int
    260 cstatvfs64_32(struct vfs *vfsp, struct statvfs64_32 *ubp)
    261 {
    262 	struct statvfs64 ds64;
    263 	struct statvfs64_32 ds64_32;
    264 	int error;
    265 
    266 	bzero(&ds64, sizeof (ds64));
    267 	if ((error = VFS_STATVFS(vfsp, &ds64)) != 0)
    268 		return (error);
    269 
    270 	/*
    271 	 * On the 64-bit kernel, even these fields grow to 64-bit
    272 	 * quantities in the statvfs64 structure.
    273 	 */
    274 	if (ds64.f_namemax == (ulong_t)-1l)
    275 		ds64.f_namemax = UINT32_MAX;
    276 
    277 	if (ds64.f_bsize > UINT32_MAX || ds64.f_frsize > UINT32_MAX ||
    278 	    ds64.f_fsid > UINT32_MAX || ds64.f_flag > UINT32_MAX ||
    279 	    ds64.f_namemax > UINT32_MAX)
    280 		return (EOVERFLOW);
    281 
    282 	STATVFSCOPY(&ds64_32, &ds64);
    283 	if (copyout(&ds64_32, ubp, sizeof (ds64_32)) != 0)
    284 		return (EFAULT);
    285 	return (0);
    286 }
    287 
    288 /*
    289  * ILP32 "small file" system calls on LP64 kernel
    290  */
    291 int
    292 statvfs32(char *fname, struct statvfs32 *sbp)
    293 {
    294 	vnode_t *vp;
    295 	int error;
    296 	int estale_retry = 0;
    297 
    298 lookup:
    299 	if (error = lookupname(fname, UIO_USERSPACE, FOLLOW, NULLVPP, &vp)) {
    300 		if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
    301 			goto lookup;
    302 		return (set_errno(error));
    303 	}
    304 	error = cstatvfs32(vp->v_vfsp, sbp);
    305 	VN_RELE(vp);
    306 	if (error) {
    307 		if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
    308 			goto lookup;
    309 		return (set_errno(error));
    310 	}
    311 	return (0);
    312 }
    313 
    314 int
    315 fstatvfs32(int fdes, struct statvfs32 *sbp)
    316 {
    317 	struct file *fp;
    318 	int error;
    319 
    320 	if ((fp = getf(fdes)) == NULL)
    321 		return (set_errno(EBADF));
    322 	error = cstatvfs32(fp->f_vnode->v_vfsp, sbp);
    323 	releasef(fdes);
    324 	if (error)
    325 		return (set_errno(error));
    326 	return (0);
    327 }
    328 
    329 /*
    330  * ILP32 Large File system calls on LP64 kernel
    331  */
    332 int
    333 statvfs64_32(char *fname, struct statvfs64_32 *sbp)
    334 {
    335 	vnode_t *vp;
    336 	int error;
    337 	int estale_retry = 0;
    338 
    339 lookup:
    340 	if (error = lookupname(fname, UIO_USERSPACE, FOLLOW, NULLVPP, &vp)) {
    341 		if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
    342 			goto lookup;
    343 		return (set_errno(error));
    344 	}
    345 	error = cstatvfs64_32(vp->v_vfsp, sbp);
    346 	VN_RELE(vp);
    347 	if (error) {
    348 		if ((error == ESTALE) && fs_need_estale_retry(estale_retry++))
    349 			goto lookup;
    350 		return (set_errno(error));
    351 	}
    352 	return (0);
    353 }
    354 
    355 int
    356 fstatvfs64_32(int fdes, struct statvfs64_32 *sbp)
    357 {
    358 	struct file *fp;
    359 	int error;
    360 
    361 	if ((fp = getf(fdes)) == NULL)
    362 		return (set_errno(EBADF));
    363 	error = cstatvfs64_32(fp->f_vnode->v_vfsp, sbp);
    364 	releasef(fdes);
    365 	if (error)
    366 		return (set_errno(error));
    367 	return (0);
    368 }
    369 
    370 #endif	/* _SYSCALL32_IMPL */
    371