[linux-2.6-block.git] / fs / statfs.c

#include <linux/syscalls.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/mount.h>
#include <linux/namei.h>
#include <linux/statfs.h>
#include <linux/security.h>
#include <linux/uaccess.h>

static int flags_by_mnt(int mnt_flags)
{
	int flags = 0;

	if (mnt_flags & MNT_READONLY)
		flags |= ST_RDONLY;
	if (mnt_flags & MNT_NOSUID)
		flags |= ST_NOSUID;
	if (mnt_flags & MNT_NODEV)
		flags |= ST_NODEV;
	if (mnt_flags & MNT_NOEXEC)
		flags |= ST_NOEXEC;
	if (mnt_flags & MNT_NOATIME)
		flags |= ST_NOATIME;
	if (mnt_flags & MNT_NODIRATIME)
		flags |= ST_NODIRATIME;
	if (mnt_flags & MNT_RELATIME)
		flags |= ST_RELATIME;
	return flags;
}

static int flags_by_sb(int s_flags)
{
	int flags = 0;
	if (s_flags & MS_SYNCHRONOUS)
		flags |= ST_SYNCHRONOUS;
	if (s_flags & MS_MANDLOCK)
		flags |= ST_MANDLOCK;
	return flags;
}

static int calculate_f_flags(struct vfsmount *mnt)
{
	return ST_VALID | flags_by_mnt(mnt->mnt_flags) |
		flags_by_sb(mnt->mnt_sb->s_flags);
}

int statfs_by_dentry(struct dentry *dentry, struct kstatfs *buf)
{
	int retval;

	if (!dentry->d_sb->s_op->statfs)
		return -ENOSYS;

	memset(buf, 0, sizeof(*buf));
	retval = security_sb_statfs(dentry);
	if (retval)
		return retval;
	retval = dentry->d_sb->s_op->statfs(dentry, buf);
	if (retval == 0 && buf->f_frsize == 0)
		buf->f_frsize = buf->f_bsize;
	return retval;
}

int vfs_statfs(struct path *path, struct kstatfs *buf)
{
	int error;

	error = statfs_by_dentry(path->dentry, buf);
	if (!error)
		buf->f_flags = calculate_f_flags(path->mnt);
	return error;
}
EXPORT_SYMBOL(vfs_statfs);

int user_statfs(const char __user *pathname, struct kstatfs *st)
{
	struct path path;
	int error = user_path_at(AT_FDCWD, pathname, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path);
	if (!error) {
		error = vfs_statfs(&path, st);
		path_put(&path);
	}
	return error;
}

int fd_statfs(int fd, struct kstatfs *st)
{
	struct file *file = fget(fd);
	int error = -EBADF;
	if (file) {
		error = vfs_statfs(&file->f_path, st);
		fput(file);
	}
	return error;
}

static int do_statfs_native(struct kstatfs *st, struct statfs __user *p)
{
	struct statfs buf;

	if (sizeof(buf) == sizeof(*st))
		memcpy(&buf, st, sizeof(*st));
	else {
		if (sizeof buf.f_blocks == 4) {
			if ((st->f_blocks | st->f_bfree | st->f_bavail |
			     st->f_bsize | st->f_frsize) &
			    0xffffffff00000000ULL)
				return -EOVERFLOW;
			/*
			 * f_files and f_ffree may be -1; it's okay to stuff
			 * that into 32 bits
			 */
			if (st->f_files != -1 &&
			    (st->f_files & 0xffffffff00000000ULL))
				return -EOVERFLOW;
			if (st->f_ffree != -1 &&
			    (st->f_ffree & 0xffffffff00000000ULL))
				return -EOVERFLOW;
		}

		buf.f_type = st->f_type;
		buf.f_bsize = st->f_bsize;
		buf.f_blocks = st->f_blocks;
		buf.f_bfree = st->f_bfree;
		buf.f_bavail = st->f_bavail;
		buf.f_files = st->f_files;
		buf.f_ffree = st->f_ffree;
		buf.f_fsid = st->f_fsid;
		buf.f_namelen = st->f_namelen;
		buf.f_frsize = st->f_frsize;
		buf.f_flags = st->f_flags;
		memset(buf.f_spare, 0, sizeof(buf.f_spare));
	}
	if (copy_to_user(p, &buf, sizeof(buf)))
		return -EFAULT;
	return 0;
}

static int do_statfs64(struct kstatfs *st, struct statfs64 __user *p)
{
	struct statfs64 buf;
	if (sizeof(buf) == sizeof(*st))
		memcpy(&buf, st, sizeof(*st));
	else {
		buf.f_type = st->f_type;
		buf.f_bsize = st->f_bsize;
		buf.f_blocks = st->f_blocks;
		buf.f_bfree = st->f_bfree;
		buf.f_bavail = st->f_bavail;
		buf.f_files = st->f_files;
		buf.f_ffree = st->f_ffree;
		buf.f_fsid = st->f_fsid;
		buf.f_namelen = st->f_namelen;
		buf.f_frsize = st->f_frsize;
		buf.f_flags = st->f_flags;
		memset(buf.f_spare, 0, sizeof(buf.f_spare));
	}
	if (copy_to_user(p, &buf, sizeof(buf)))
		return -EFAULT;
	return 0;
}

SYSCALL_DEFINE2(statfs, const char __user *, pathname, struct statfs __user *, buf)
{
	struct kstatfs st;
	int error = user_statfs(pathname, &st);
	if (!error)
		error = do_statfs_native(&st, buf);
	return error;
}

SYSCALL_DEFINE3(statfs64, const char __user *, pathname, size_t, sz, struct statfs64 __user *, buf)
{
	struct kstatfs st;
	int error;
	if (sz != sizeof(*buf))
		return -EINVAL;
	error = user_statfs(pathname, &st);
	if (!error)
		error = do_statfs64(&st, buf);
	return error;
}

SYSCALL_DEFINE2(fstatfs, unsigned int, fd, struct statfs __user *, buf)
{
	struct kstatfs st;
	int error = fd_statfs(fd, &st);
	if (!error)
		error = do_statfs_native(&st, buf);
	return error;
}

SYSCALL_DEFINE3(fstatfs64, unsigned int, fd, size_t, sz, struct statfs64 __user *, buf)
{
	struct kstatfs st;
	int error;

	if (sz != sizeof(*buf))
		return -EINVAL;

	error = fd_statfs(fd, &st);
	if (!error)
		error = do_statfs64(&st, buf);
	return error;
}

SYSCALL_DEFINE2(ustat, unsigned, dev, struct ustat __user *, ubuf)
{
	struct super_block *s;
	struct ustat tmp;
	struct kstatfs sbuf;
	int err;

	s = user_get_super(new_decode_dev(dev));
	if (!s)
		return -EINVAL;

	err = statfs_by_dentry(s->s_root, &sbuf);
	drop_super(s);
	if (err)
		return err;

	memset(&tmp,0,sizeof(struct ustat));
	tmp.f_tfree = sbuf.f_bfree;
	tmp.f_tinode = sbuf.f_ffree;

	return copy_to_user(ubuf, &tmp, sizeof(struct ustat)) ? -EFAULT : 0;
}
Commit	Line	Data
7ed1ee61 AV	1	#include <linux/syscalls.h>
	2	#include <linux/module.h>
	3	#include <linux/fs.h>
	4	#include <linux/file.h>
365b1818	5	#include <linux/mount.h>
7ed1ee61 AV	6	#include <linux/namei.h>
	7	#include <linux/statfs.h>
	8	#include <linux/security.h>
	9	#include <linux/uaccess.h>
	10
365b1818 CH	11	static int flags_by_mnt(int mnt_flags)
	12	{
	13	int flags = 0;
	14
	15	if (mnt_flags & MNT_READONLY)
	16	flags \|= ST_RDONLY;
	17	if (mnt_flags & MNT_NOSUID)
	18	flags \|= ST_NOSUID;
	19	if (mnt_flags & MNT_NODEV)
	20	flags \|= ST_NODEV;
	21	if (mnt_flags & MNT_NOEXEC)
	22	flags \|= ST_NOEXEC;
	23	if (mnt_flags & MNT_NOATIME)
	24	flags \|= ST_NOATIME;
	25	if (mnt_flags & MNT_NODIRATIME)
	26	flags \|= ST_NODIRATIME;
	27	if (mnt_flags & MNT_RELATIME)
	28	flags \|= ST_RELATIME;
	29	return flags;
	30	}
	31
	32	static int flags_by_sb(int s_flags)
	33	{
	34	int flags = 0;
	35	if (s_flags & MS_SYNCHRONOUS)
	36	flags \|= ST_SYNCHRONOUS;
	37	if (s_flags & MS_MANDLOCK)
	38	flags \|= ST_MANDLOCK;
	39	return flags;
	40	}
	41
	42	static int calculate_f_flags(struct vfsmount *mnt)
	43	{
	44	return ST_VALID \| flags_by_mnt(mnt->mnt_flags) \|
	45	flags_by_sb(mnt->mnt_sb->s_flags);
	46	}
	47
ebabe9a9	48	int statfs_by_dentry(struct dentry dentry, struct kstatfs buf)
7ed1ee61	49	{
ebabe9a9 CH	50	int retval;
	51
	52	if (!dentry->d_sb->s_op->statfs)
	53	return -ENOSYS;
	54
	55	memset(buf, 0, sizeof(*buf));
	56	retval = security_sb_statfs(dentry);
	57	if (retval)
	58	return retval;
	59	retval = dentry->d_sb->s_op->statfs(dentry, buf);
	60	if (retval == 0 && buf->f_frsize == 0)
	61	buf->f_frsize = buf->f_bsize;
7ed1ee61 AV	62	return retval;
	63	}
	64
ebabe9a9 CH	65	int vfs_statfs(struct path path, struct kstatfs buf)
ebabe9a9 CH	66	{
365b1818 CH	67	int error;
	68
	69	error = statfs_by_dentry(path->dentry, buf);
	70	if (!error)
	71	buf->f_flags = calculate_f_flags(path->mnt);
	72	return error;
ebabe9a9	73	}
7ed1ee61 AV	74	EXPORT_SYMBOL(vfs_statfs);
7ed1ee61 AV	75
c8b91acc	76	int user_statfs(const char __user pathname, struct kstatfs st)
7ed1ee61	77	{
c8b91acc	78	struct path path;
5c8a0fbb	79	int error = user_path_at(AT_FDCWD, pathname, LOOKUP_FOLLOW\|LOOKUP_AUTOMOUNT, &path);
c8b91acc AV	80	if (!error) {
	81	error = vfs_statfs(&path, st);
	82	path_put(&path);
	83	}
	84	return error;
	85	}
7ed1ee61	86
c8b91acc AV	87	int fd_statfs(int fd, struct kstatfs *st)
	88	{
	89	struct file *file = fget(fd);
	90	int error = -EBADF;
	91	if (file) {
	92	error = vfs_statfs(&file->f_path, st);
	93	fput(file);
	94	}
	95	return error;
	96	}
7ed1ee61	97
c8b91acc AV	98	static int do_statfs_native(struct kstatfs st, struct statfs __user p)
	99	{
	100	struct statfs buf;
	101
	102	if (sizeof(buf) == sizeof(*st))
	103	memcpy(&buf, st, sizeof(*st));
7ed1ee61	104	else {
c8b91acc AV	105	if (sizeof buf.f_blocks == 4) {
	106	if ((st->f_blocks \| st->f_bfree \| st->f_bavail \|
	107	st->f_bsize \| st->f_frsize) &
7ed1ee61 AV	108	0xffffffff00000000ULL)
	109	return -EOVERFLOW;
	110	/*
	111	* f_files and f_ffree may be -1; it's okay to stuff
	112	* that into 32 bits
	113	*/
c8b91acc AV	114	if (st->f_files != -1 &&
c8b91acc AV	115	(st->f_files & 0xffffffff00000000ULL))
7ed1ee61	116	return -EOVERFLOW;
c8b91acc AV	117	if (st->f_ffree != -1 &&
c8b91acc AV	118	(st->f_ffree & 0xffffffff00000000ULL))
7ed1ee61 AV	119	return -EOVERFLOW;
	120	}
	121
c8b91acc AV	122	buf.f_type = st->f_type;
	123	buf.f_bsize = st->f_bsize;
	124	buf.f_blocks = st->f_blocks;
	125	buf.f_bfree = st->f_bfree;
	126	buf.f_bavail = st->f_bavail;
	127	buf.f_files = st->f_files;
	128	buf.f_ffree = st->f_ffree;
	129	buf.f_fsid = st->f_fsid;
	130	buf.f_namelen = st->f_namelen;
	131	buf.f_frsize = st->f_frsize;
	132	buf.f_flags = st->f_flags;
	133	memset(buf.f_spare, 0, sizeof(buf.f_spare));
7ed1ee61	134	}
c8b91acc AV	135	if (copy_to_user(p, &buf, sizeof(buf)))
c8b91acc AV	136	return -EFAULT;
7ed1ee61 AV	137	return 0;
	138	}
	139
c8b91acc	140	static int do_statfs64(struct kstatfs st, struct statfs64 __user p)
7ed1ee61	141	{
c8b91acc AV	142	struct statfs64 buf;
	143	if (sizeof(buf) == sizeof(*st))
	144	memcpy(&buf, st, sizeof(*st));
7ed1ee61	145	else {
c8b91acc AV	146	buf.f_type = st->f_type;
	147	buf.f_bsize = st->f_bsize;
	148	buf.f_blocks = st->f_blocks;
	149	buf.f_bfree = st->f_bfree;
	150	buf.f_bavail = st->f_bavail;
	151	buf.f_files = st->f_files;
	152	buf.f_ffree = st->f_ffree;
	153	buf.f_fsid = st->f_fsid;
	154	buf.f_namelen = st->f_namelen;
	155	buf.f_frsize = st->f_frsize;
	156	buf.f_flags = st->f_flags;
	157	memset(buf.f_spare, 0, sizeof(buf.f_spare));
7ed1ee61	158	}
c8b91acc AV	159	if (copy_to_user(p, &buf, sizeof(buf)))
c8b91acc AV	160	return -EFAULT;
7ed1ee61 AV	161	return 0;
	162	}
	163
	164	SYSCALL_DEFINE2(statfs, const char __user , pathname, struct statfs __user , buf)
	165	{
c8b91acc AV	166	struct kstatfs st;
	167	int error = user_statfs(pathname, &st);
	168	if (!error)
	169	error = do_statfs_native(&st, buf);
7ed1ee61 AV	170	return error;
	171	}
	172
	173	SYSCALL_DEFINE3(statfs64, const char __user , pathname, size_t, sz, struct statfs64 __user , buf)
	174	{
c8b91acc AV	175	struct kstatfs st;
c8b91acc AV	176	int error;
7ed1ee61 AV	177	if (sz != sizeof(*buf))
7ed1ee61 AV	178	return -EINVAL;
c8b91acc AV	179	error = user_statfs(pathname, &st);
	180	if (!error)
	181	error = do_statfs64(&st, buf);
7ed1ee61 AV	182	return error;
	183	}
	184
	185	SYSCALL_DEFINE2(fstatfs, unsigned int, fd, struct statfs __user *, buf)
	186	{
c8b91acc AV	187	struct kstatfs st;
	188	int error = fd_statfs(fd, &st);
	189	if (!error)
	190	error = do_statfs_native(&st, buf);
7ed1ee61 AV	191	return error;
	192	}
	193
	194	SYSCALL_DEFINE3(fstatfs64, unsigned int, fd, size_t, sz, struct statfs64 __user *, buf)
	195	{
c8b91acc	196	struct kstatfs st;
7ed1ee61 AV	197	int error;
	198
	199	if (sz != sizeof(*buf))
	200	return -EINVAL;
	201
c8b91acc AV	202	error = fd_statfs(fd, &st);
	203	if (!error)
	204	error = do_statfs64(&st, buf);
7ed1ee61 AV	205	return error;
	206	}
	207
	208	SYSCALL_DEFINE2(ustat, unsigned, dev, struct ustat __user *, ubuf)
	209	{
	210	struct super_block *s;
	211	struct ustat tmp;
	212	struct kstatfs sbuf;
	213	int err;
	214
	215	s = user_get_super(new_decode_dev(dev));
	216	if (!s)
	217	return -EINVAL;
	218
ebabe9a9	219	err = statfs_by_dentry(s->s_root, &sbuf);
7ed1ee61 AV	220	drop_super(s);
	221	if (err)
	222	return err;
	223
	224	memset(&tmp,0,sizeof(struct ustat));
	225	tmp.f_tfree = sbuf.f_bfree;
	226	tmp.f_tinode = sbuf.f_ffree;
	227
	228	return copy_to_user(ubuf, &tmp, sizeof(struct ustat)) ? -EFAULT : 0;
	229	}