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

/*
 * Quota code necessary even when VFS quota support is not compiled
 * into the kernel.  The interesting stuff is over in dquot.c, here
 * we have symbols for initial quotactl(2) handling, the sysctl(2)
 * variables, etc - things needed even when quota support disabled.
 */

#include <linux/fs.h>
#include <linux/namei.h>
#include <linux/slab.h>
#include <asm/current.h>
#include <asm/uaccess.h>
#include <linux/compat.h>
#include <linux/kernel.h>
#include <linux/security.h>
#include <linux/syscalls.h>
#include <linux/buffer_head.h>
#include <linux/capability.h>
#include <linux/quotaops.h>
#include <linux/types.h>
#include <net/netlink.h>
#include <net/genetlink.h>

/* Check validity of generic quotactl commands */
static int generic_quotactl_valid(struct super_block *sb, int type, int cmd,
				  qid_t id)
{
	if (type >= MAXQUOTAS)
		return -EINVAL;
	if (!sb && cmd != Q_SYNC)
		return -ENODEV;
	/* Is operation supported? */
	if (sb && !sb->s_qcop)
		return -ENOSYS;

	switch (cmd) {
		case Q_GETFMT:
			break;
		case Q_QUOTAON:
			if (!sb->s_qcop->quota_on)
				return -ENOSYS;
			break;
		case Q_QUOTAOFF:
			if (!sb->s_qcop->quota_off)
				return -ENOSYS;
			break;
		case Q_SETINFO:
			if (!sb->s_qcop->set_info)
				return -ENOSYS;
			break;
		case Q_GETINFO:
			if (!sb->s_qcop->get_info)
				return -ENOSYS;
			break;
		case Q_SETQUOTA:
			if (!sb->s_qcop->set_dqblk)
				return -ENOSYS;
			break;
		case Q_GETQUOTA:
			if (!sb->s_qcop->get_dqblk)
				return -ENOSYS;
			break;
		case Q_SYNC:
			if (sb && !sb->s_qcop->quota_sync)
				return -ENOSYS;
			break;
		default:
			return -EINVAL;
	}

	/* Is quota turned on for commands which need it? */
	switch (cmd) {
		case Q_GETFMT:
		case Q_GETINFO:
		case Q_SETINFO:
		case Q_SETQUOTA:
		case Q_GETQUOTA:
			/* This is just an informative test so we are satisfied
			 * without the lock */
			if (!sb_has_quota_active(sb, type))
				return -ESRCH;
	}

	/* Check privileges */
	if (cmd == Q_GETQUOTA) {
		if (((type == USRQUOTA && current_euid() != id) ||
		     (type == GRPQUOTA && !in_egroup_p(id))) &&
		    !capable(CAP_SYS_ADMIN))
			return -EPERM;
	}
	else if (cmd != Q_GETFMT && cmd != Q_SYNC && cmd != Q_GETINFO)
		if (!capable(CAP_SYS_ADMIN))
			return -EPERM;

	return 0;
}

/* Check validity of XFS Quota Manager commands */
static int xqm_quotactl_valid(struct super_block *sb, int type, int cmd,
			      qid_t id)
{
	if (type >= XQM_MAXQUOTAS)
		return -EINVAL;
	if (!sb)
		return -ENODEV;
	if (!sb->s_qcop)
		return -ENOSYS;

	switch (cmd) {
		case Q_XQUOTAON:
		case Q_XQUOTAOFF:
		case Q_XQUOTARM:
			if (!sb->s_qcop->set_xstate)
				return -ENOSYS;
			break;
		case Q_XGETQSTAT:
			if (!sb->s_qcop->get_xstate)
				return -ENOSYS;
			break;
		case Q_XSETQLIM:
			if (!sb->s_qcop->set_xquota)
				return -ENOSYS;
			break;
		case Q_XGETQUOTA:
			if (!sb->s_qcop->get_xquota)
				return -ENOSYS;
			break;
		case Q_XQUOTASYNC:
			if (!sb->s_qcop->quota_sync)
				return -ENOSYS;
			break;
		default:
			return -EINVAL;
	}

	/* Check privileges */
	if (cmd == Q_XGETQUOTA) {
		if (((type == XQM_USRQUOTA && current_euid() != id) ||
		     (type == XQM_GRPQUOTA && !in_egroup_p(id))) &&
		     !capable(CAP_SYS_ADMIN))
			return -EPERM;
	} else if (cmd != Q_XGETQSTAT && cmd != Q_XQUOTASYNC) {
		if (!capable(CAP_SYS_ADMIN))
			return -EPERM;
	}

	return 0;
}

static int check_quotactl_valid(struct super_block *sb, int type, int cmd,
				qid_t id)
{
	int error;

	if (XQM_COMMAND(cmd))
		error = xqm_quotactl_valid(sb, type, cmd, id);
	else
		error = generic_quotactl_valid(sb, type, cmd, id);
	if (!error)
		error = security_quotactl(cmd, type, id, sb);
	return error;
}

#ifdef CONFIG_QUOTA
void sync_quota_sb(struct super_block *sb, int type)
{
	int cnt;

	if (!sb->s_qcop->quota_sync)
		return;

	sb->s_qcop->quota_sync(sb, type);

	if (sb_dqopt(sb)->flags & DQUOT_QUOTA_SYS_FILE)
		return;
	/* This is not very clever (and fast) but currently I don't know about
	 * any other simple way of getting quota data to disk and we must get
	 * them there for userspace to be visible... */
	if (sb->s_op->sync_fs)
		sb->s_op->sync_fs(sb, 1);
	sync_blockdev(sb->s_bdev);

	/*
	 * Now when everything is written we can discard the pagecache so
	 * that userspace sees the changes.
	 */
	mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (type != -1 && cnt != type)
			continue;
		if (!sb_has_quota_active(sb, cnt))
			continue;
		mutex_lock_nested(&sb_dqopt(sb)->files[cnt]->i_mutex,
				  I_MUTEX_QUOTA);
		truncate_inode_pages(&sb_dqopt(sb)->files[cnt]->i_data, 0);
		mutex_unlock(&sb_dqopt(sb)->files[cnt]->i_mutex);
	}
	mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
}
#endif

static void sync_dquots(int type)
{
	struct super_block *sb;
	int cnt;

	spin_lock(&sb_lock);
restart:
	list_for_each_entry(sb, &super_blocks, s_list) {
		/* This test just improves performance so it needn't be
		 * reliable... */
		for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
			if (type != -1 && type != cnt)
				continue;
			if (!sb_has_quota_active(sb, cnt))
				continue;
			if (!info_dirty(&sb_dqopt(sb)->info[cnt]) &&
			   list_empty(&sb_dqopt(sb)->info[cnt].dqi_dirty_list))
				continue;
			break;
		}
		if (cnt == MAXQUOTAS)
			continue;
		sb->s_count++;
		spin_unlock(&sb_lock);
		down_read(&sb->s_umount);
		if (sb->s_root)
			sync_quota_sb(sb, type);
		up_read(&sb->s_umount);
		spin_lock(&sb_lock);
		if (__put_super_and_need_restart(sb))
			goto restart;
	}
	spin_unlock(&sb_lock);
}

/* Copy parameters and call proper function */
static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id,
		       void __user *addr)
{
	int ret;

	switch (cmd) {
		case Q_QUOTAON: {
			char *pathname;

			pathname = getname(addr);
			if (IS_ERR(pathname))
				return PTR_ERR(pathname);
			ret = sb->s_qcop->quota_on(sb, type, id, pathname, 0);
			putname(pathname);
			return ret;
		}
		case Q_QUOTAOFF:
			return sb->s_qcop->quota_off(sb, type, 0);

		case Q_GETFMT: {
			__u32 fmt;

			down_read(&sb_dqopt(sb)->dqptr_sem);
			if (!sb_has_quota_active(sb, type)) {
				up_read(&sb_dqopt(sb)->dqptr_sem);
				return -ESRCH;
			}
			fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id;
			up_read(&sb_dqopt(sb)->dqptr_sem);
			if (copy_to_user(addr, &fmt, sizeof(fmt)))
				return -EFAULT;
			return 0;
		}
		case Q_GETINFO: {
			struct if_dqinfo info;

			ret = sb->s_qcop->get_info(sb, type, &info);
			if (ret)
				return ret;
			if (copy_to_user(addr, &info, sizeof(info)))
				return -EFAULT;
			return 0;
		}
		case Q_SETINFO: {
			struct if_dqinfo info;

			if (copy_from_user(&info, addr, sizeof(info)))
				return -EFAULT;
			return sb->s_qcop->set_info(sb, type, &info);
		}
		case Q_GETQUOTA: {
			struct if_dqblk idq;

			ret = sb->s_qcop->get_dqblk(sb, type, id, &idq);
			if (ret)
				return ret;
			if (copy_to_user(addr, &idq, sizeof(idq)))
				return -EFAULT;
			return 0;
		}
		case Q_SETQUOTA: {
			struct if_dqblk idq;

			if (copy_from_user(&idq, addr, sizeof(idq)))
				return -EFAULT;
			return sb->s_qcop->set_dqblk(sb, type, id, &idq);
		}
		case Q_SYNC:
			if (sb)
				sync_quota_sb(sb, type);
			else
				sync_dquots(type);
			return 0;

		case Q_XQUOTAON:
		case Q_XQUOTAOFF:
		case Q_XQUOTARM: {
			__u32 flags;

			if (copy_from_user(&flags, addr, sizeof(flags)))
				return -EFAULT;
			return sb->s_qcop->set_xstate(sb, flags, cmd);
		}
		case Q_XGETQSTAT: {
			struct fs_quota_stat fqs;
		
			if ((ret = sb->s_qcop->get_xstate(sb, &fqs)))
				return ret;
			if (copy_to_user(addr, &fqs, sizeof(fqs)))
				return -EFAULT;
			return 0;
		}
		case Q_XSETQLIM: {
			struct fs_disk_quota fdq;

			if (copy_from_user(&fdq, addr, sizeof(fdq)))
				return -EFAULT;
		       return sb->s_qcop->set_xquota(sb, type, id, &fdq);
		}
		case Q_XGETQUOTA: {
			struct fs_disk_quota fdq;

			ret = sb->s_qcop->get_xquota(sb, type, id, &fdq);
			if (ret)
				return ret;
			if (copy_to_user(addr, &fdq, sizeof(fdq)))
				return -EFAULT;
			return 0;
		}
		case Q_XQUOTASYNC:
			return sb->s_qcop->quota_sync(sb, type);
		/* We never reach here unless validity check is broken */
		default:
			BUG();
	}
	return 0;
}

/*
 * look up a superblock on which quota ops will be performed
 * - use the name of a block device to find the superblock thereon
 */
static struct super_block *quotactl_block(const char __user *special)
{
#ifdef CONFIG_BLOCK
	struct block_device *bdev;
	struct super_block *sb;
	char *tmp = getname(special);

	if (IS_ERR(tmp))
		return ERR_CAST(tmp);
	bdev = lookup_bdev(tmp);
	putname(tmp);
	if (IS_ERR(bdev))
		return ERR_CAST(bdev);
	sb = get_super(bdev);
	bdput(bdev);
	if (!sb)
		return ERR_PTR(-ENODEV);

	return sb;
#else
	return ERR_PTR(-ENODEV);
#endif
}

/*
 * This is the system call interface. This communicates with
 * the user-level programs. Currently this only supports diskquota
 * calls. Maybe we need to add the process quotas etc. in the future,
 * but we probably should use rlimits for that.
 */
SYSCALL_DEFINE4(quotactl, unsigned int, cmd, const char __user *, special,
		qid_t, id, void __user *, addr)
{
	uint cmds, type;
	struct super_block *sb = NULL;
	int ret;

	cmds = cmd >> SUBCMDSHIFT;
	type = cmd & SUBCMDMASK;

	if (cmds != Q_SYNC || special) {
		sb = quotactl_block(special);
		if (IS_ERR(sb))
			return PTR_ERR(sb);
	}

	ret = check_quotactl_valid(sb, type, cmds, id);
	if (ret >= 0)
		ret = do_quotactl(sb, type, cmds, id, addr);
	if (sb)
		drop_super(sb);

	return ret;
}

#if defined(CONFIG_COMPAT_FOR_U64_ALIGNMENT)
/*
 * This code works only for 32 bit quota tools over 64 bit OS (x86_64, ia64)
 * and is necessary due to alignment problems.
 */
struct compat_if_dqblk {
	compat_u64 dqb_bhardlimit;
	compat_u64 dqb_bsoftlimit;
	compat_u64 dqb_curspace;
	compat_u64 dqb_ihardlimit;
	compat_u64 dqb_isoftlimit;
	compat_u64 dqb_curinodes;
	compat_u64 dqb_btime;
	compat_u64 dqb_itime;
	compat_uint_t dqb_valid;
};

/* XFS structures */
struct compat_fs_qfilestat {
	compat_u64 dqb_bhardlimit;
	compat_u64 qfs_nblks;
	compat_uint_t qfs_nextents;
};

struct compat_fs_quota_stat {
	__s8		qs_version;
	__u16		qs_flags;
	__s8		qs_pad;
	struct compat_fs_qfilestat	qs_uquota;
	struct compat_fs_qfilestat	qs_gquota;
	compat_uint_t	qs_incoredqs;
	compat_int_t	qs_btimelimit;
	compat_int_t	qs_itimelimit;
	compat_int_t	qs_rtbtimelimit;
	__u16		qs_bwarnlimit;
	__u16		qs_iwarnlimit;
};

asmlinkage long sys32_quotactl(unsigned int cmd, const char __user *special,
						qid_t id, void __user *addr)
{
	unsigned int cmds;
	struct if_dqblk __user *dqblk;
	struct compat_if_dqblk __user *compat_dqblk;
	struct fs_quota_stat __user *fsqstat;
	struct compat_fs_quota_stat __user *compat_fsqstat;
	compat_uint_t data;
	u16 xdata;
	long ret;

	cmds = cmd >> SUBCMDSHIFT;

	switch (cmds) {
	case Q_GETQUOTA:
		dqblk = compat_alloc_user_space(sizeof(struct if_dqblk));
		compat_dqblk = addr;
		ret = sys_quotactl(cmd, special, id, dqblk);
		if (ret)
			break;
		if (copy_in_user(compat_dqblk, dqblk, sizeof(*compat_dqblk)) ||
			get_user(data, &dqblk->dqb_valid) ||
			put_user(data, &compat_dqblk->dqb_valid))
			ret = -EFAULT;
		break;
	case Q_SETQUOTA:
		dqblk = compat_alloc_user_space(sizeof(struct if_dqblk));
		compat_dqblk = addr;
		ret = -EFAULT;
		if (copy_in_user(dqblk, compat_dqblk, sizeof(*compat_dqblk)) ||
			get_user(data, &compat_dqblk->dqb_valid) ||
			put_user(data, &dqblk->dqb_valid))
			break;
		ret = sys_quotactl(cmd, special, id, dqblk);
		break;
	case Q_XGETQSTAT:
		fsqstat = compat_alloc_user_space(sizeof(struct fs_quota_stat));
		compat_fsqstat = addr;
		ret = sys_quotactl(cmd, special, id, fsqstat);
		if (ret)
			break;
		ret = -EFAULT;
		/* Copying qs_version, qs_flags, qs_pad */
		if (copy_in_user(compat_fsqstat, fsqstat,
			offsetof(struct compat_fs_quota_stat, qs_uquota)))
			break;
		/* Copying qs_uquota */
		if (copy_in_user(&compat_fsqstat->qs_uquota,
			&fsqstat->qs_uquota,
			sizeof(compat_fsqstat->qs_uquota)) ||
			get_user(data, &fsqstat->qs_uquota.qfs_nextents) ||
			put_user(data, &compat_fsqstat->qs_uquota.qfs_nextents))
			break;
		/* Copying qs_gquota */
		if (copy_in_user(&compat_fsqstat->qs_gquota,
			&fsqstat->qs_gquota,
			sizeof(compat_fsqstat->qs_gquota)) ||
			get_user(data, &fsqstat->qs_gquota.qfs_nextents) ||
			put_user(data, &compat_fsqstat->qs_gquota.qfs_nextents))
			break;
		/* Copying the rest */
		if (copy_in_user(&compat_fsqstat->qs_incoredqs,
			&fsqstat->qs_incoredqs,
			sizeof(struct compat_fs_quota_stat) -
			offsetof(struct compat_fs_quota_stat, qs_incoredqs)) ||
			get_user(xdata, &fsqstat->qs_iwarnlimit) ||
			put_user(xdata, &compat_fsqstat->qs_iwarnlimit))
			break;
		ret = 0;
		break;
	default:
		ret = sys_quotactl(cmd, special, id, addr);
	}
	return ret;
}
#endif


#ifdef CONFIG_QUOTA_NETLINK_INTERFACE

/* Netlink family structure for quota */
static struct genl_family quota_genl_family = {
	.id = GENL_ID_GENERATE,
	.hdrsize = 0,
	.name = "VFS_DQUOT",
	.version = 1,
	.maxattr = QUOTA_NL_A_MAX,
};

/**
 * quota_send_warning - Send warning to userspace about exceeded quota
 * @type: The quota type: USRQQUOTA, GRPQUOTA,...
 * @id: The user or group id of the quota that was exceeded
 * @dev: The device on which the fs is mounted (sb->s_dev)
 * @warntype: The type of the warning: QUOTA_NL_...
 *
 * This can be used by filesystems (including those which don't use
 * dquot) to send a message to userspace relating to quota limits.
 *
 */

void quota_send_warning(short type, unsigned int id, dev_t dev,
			const char warntype)
{
	static atomic_t seq;
	struct sk_buff *skb;
	void *msg_head;
	int ret;
	int msg_size = 4 * nla_total_size(sizeof(u32)) +
		       2 * nla_total_size(sizeof(u64));

	/* We have to allocate using GFP_NOFS as we are called from a
	 * filesystem performing write and thus further recursion into
	 * the fs to free some data could cause deadlocks. */
	skb = genlmsg_new(msg_size, GFP_NOFS);
	if (!skb) {
		printk(KERN_ERR
		  "VFS: Not enough memory to send quota warning.\n");
		return;
	}
	msg_head = genlmsg_put(skb, 0, atomic_add_return(1, &seq),
			&quota_genl_family, 0, QUOTA_NL_C_WARNING);
	if (!msg_head) {
		printk(KERN_ERR
		  "VFS: Cannot store netlink header in quota warning.\n");
		goto err_out;
	}
	ret = nla_put_u32(skb, QUOTA_NL_A_QTYPE, type);
	if (ret)
		goto attr_err_out;
	ret = nla_put_u64(skb, QUOTA_NL_A_EXCESS_ID, id);
	if (ret)
		goto attr_err_out;
	ret = nla_put_u32(skb, QUOTA_NL_A_WARNING, warntype);
	if (ret)
		goto attr_err_out;
	ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MAJOR, MAJOR(dev));
	if (ret)
		goto attr_err_out;
	ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MINOR, MINOR(dev));
	if (ret)
		goto attr_err_out;
	ret = nla_put_u64(skb, QUOTA_NL_A_CAUSED_ID, current_uid());
	if (ret)
		goto attr_err_out;
	genlmsg_end(skb, msg_head);

	genlmsg_multicast(skb, 0, quota_genl_family.id, GFP_NOFS);
	return;
attr_err_out:
	printk(KERN_ERR "VFS: Not enough space to compose quota message!\n");
err_out:
	kfree_skb(skb);
}
EXPORT_SYMBOL(quota_send_warning);

static int __init quota_init(void)
{
	if (genl_register_family(&quota_genl_family) != 0)
		printk(KERN_ERR
		       "VFS: Failed to create quota netlink interface.\n");
	return 0;
};

module_init(quota_init);
#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Quota code necessary even when VFS quota support is not compiled
	3	* into the kernel. The interesting stuff is over in dquot.c, here
	4	* we have symbols for initial quotactl(2) handling, the sysctl(2)
	5	* variables, etc - things needed even when quota support disabled.
	6	*/
	7
	8	#include <linux/fs.h>
	9	#include <linux/namei.h>
	10	#include <linux/slab.h>
	11	#include <asm/current.h>
	12	#include <asm/uaccess.h>
b716395e	13	#include <linux/compat.h>
1da177e4	14	#include <linux/kernel.h>
1da177e4 LT	15	#include <linux/security.h>
	16	#include <linux/syscalls.h>
	17	#include <linux/buffer_head.h>
16f7e0fe	18	#include <linux/capability.h>
be586bab	19	#include <linux/quotaops.h>
b716395e	20	#include <linux/types.h>
86e931a3 SW	21	#include <net/netlink.h>
86e931a3 SW	22	#include <net/genetlink.h>
1da177e4 LT	23
1da177e4 LT	24	/* Check validity of generic quotactl commands */
268157ba JK	25	static int generic_quotactl_valid(struct super_block *sb, int type, int cmd,
268157ba JK	26	qid_t id)
1da177e4 LT	27	{
	28	if (type >= MAXQUOTAS)
	29	return -EINVAL;
	30	if (!sb && cmd != Q_SYNC)
	31	return -ENODEV;
	32	/* Is operation supported? */
	33	if (sb && !sb->s_qcop)
	34	return -ENOSYS;
	35
	36	switch (cmd) {
	37	case Q_GETFMT:
	38	break;
	39	case Q_QUOTAON:
	40	if (!sb->s_qcop->quota_on)
	41	return -ENOSYS;
	42	break;
	43	case Q_QUOTAOFF:
	44	if (!sb->s_qcop->quota_off)
	45	return -ENOSYS;
	46	break;
	47	case Q_SETINFO:
	48	if (!sb->s_qcop->set_info)
	49	return -ENOSYS;
	50	break;
	51	case Q_GETINFO:
	52	if (!sb->s_qcop->get_info)
	53	return -ENOSYS;
	54	break;
	55	case Q_SETQUOTA:
	56	if (!sb->s_qcop->set_dqblk)
	57	return -ENOSYS;
	58	break;
	59	case Q_GETQUOTA:
	60	if (!sb->s_qcop->get_dqblk)
	61	return -ENOSYS;
	62	break;
	63	case Q_SYNC:
	64	if (sb && !sb->s_qcop->quota_sync)
	65	return -ENOSYS;
	66	break;
	67	default:
	68	return -EINVAL;
	69	}
	70
	71	/* Is quota turned on for commands which need it? */
	72	switch (cmd) {
	73	case Q_GETFMT:
	74	case Q_GETINFO:
1da177e4 LT	75	case Q_SETINFO:
	76	case Q_SETQUOTA:
	77	case Q_GETQUOTA:
268157ba JK	78	/* This is just an informative test so we are satisfied
268157ba JK	79	* without the lock */
f55abc0f	80	if (!sb_has_quota_active(sb, type))
1da177e4 LT	81	return -ESRCH;
	82	}
	83
	84	/* Check privileges */
	85	if (cmd == Q_GETQUOTA) {
da9592ed	86	if (((type == USRQUOTA && current_euid() != id) \|\|
1da177e4 LT	87	(type == GRPQUOTA && !in_egroup_p(id))) &&
	88	!capable(CAP_SYS_ADMIN))
	89	return -EPERM;
	90	}
	91	else if (cmd != Q_GETFMT && cmd != Q_SYNC && cmd != Q_GETINFO)
	92	if (!capable(CAP_SYS_ADMIN))
	93	return -EPERM;
	94
	95	return 0;
	96	}
	97
	98	/* Check validity of XFS Quota Manager commands */
268157ba JK	99	static int xqm_quotactl_valid(struct super_block *sb, int type, int cmd,
268157ba JK	100	qid_t id)
1da177e4 LT	101	{
	102	if (type >= XQM_MAXQUOTAS)
	103	return -EINVAL;
	104	if (!sb)
	105	return -ENODEV;
	106	if (!sb->s_qcop)
	107	return -ENOSYS;
	108
	109	switch (cmd) {
	110	case Q_XQUOTAON:
	111	case Q_XQUOTAOFF:
	112	case Q_XQUOTARM:
	113	if (!sb->s_qcop->set_xstate)
	114	return -ENOSYS;
	115	break;
	116	case Q_XGETQSTAT:
	117	if (!sb->s_qcop->get_xstate)
	118	return -ENOSYS;
	119	break;
	120	case Q_XSETQLIM:
	121	if (!sb->s_qcop->set_xquota)
	122	return -ENOSYS;
	123	break;
	124	case Q_XGETQUOTA:
	125	if (!sb->s_qcop->get_xquota)
	126	return -ENOSYS;
	127	break;
de69e5f4 NS	128	case Q_XQUOTASYNC:
	129	if (!sb->s_qcop->quota_sync)
	130	return -ENOSYS;
	131	break;
1da177e4 LT	132	default:
	133	return -EINVAL;
	134	}
	135
	136	/* Check privileges */
	137	if (cmd == Q_XGETQUOTA) {
da9592ed	138	if (((type == XQM_USRQUOTA && current_euid() != id) \|\|
1da177e4 LT	139	(type == XQM_GRPQUOTA && !in_egroup_p(id))) &&
	140	!capable(CAP_SYS_ADMIN))
	141	return -EPERM;
de69e5f4	142	} else if (cmd != Q_XGETQSTAT && cmd != Q_XQUOTASYNC) {
1da177e4 LT	143	if (!capable(CAP_SYS_ADMIN))
	144	return -EPERM;
	145	}
	146
	147	return 0;
	148	}
	149
268157ba JK	150	static int check_quotactl_valid(struct super_block *sb, int type, int cmd,
268157ba JK	151	qid_t id)
1da177e4 LT	152	{
	153	int error;
	154
	155	if (XQM_COMMAND(cmd))
	156	error = xqm_quotactl_valid(sb, type, cmd, id);
	157	else
	158	error = generic_quotactl_valid(sb, type, cmd, id);
	159	if (!error)
	160	error = security_quotactl(cmd, type, id, sb);
	161	return error;
	162	}
	163
850b201b CH	164	#ifdef CONFIG_QUOTA
850b201b CH	165	void sync_quota_sb(struct super_block *sb, int type)
1da177e4 LT	166	{
1da177e4 LT	167	int cnt;
1da177e4	168
850b201b CH	169	if (!sb->s_qcop->quota_sync)
	170	return;
	171
1da177e4	172	sb->s_qcop->quota_sync(sb, type);
ca785ec6 JK	173
	174	if (sb_dqopt(sb)->flags & DQUOT_QUOTA_SYS_FILE)
	175	return;
1da177e4 LT	176	/* This is not very clever (and fast) but currently I don't know about
	177	* any other simple way of getting quota data to disk and we must get
	178	* them there for userspace to be visible... */
	179	if (sb->s_op->sync_fs)
	180	sb->s_op->sync_fs(sb, 1);
	181	sync_blockdev(sb->s_bdev);
	182
7925409e JK	183	/*
	184	* Now when everything is written we can discard the pagecache so
	185	* that userspace sees the changes.
	186	*/
d3be915f	187	mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
1da177e4	188	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1da177e4 LT	189	if (type != -1 && cnt != type)
1da177e4 LT	190	continue;
f55abc0f	191	if (!sb_has_quota_active(sb, cnt))
1da177e4	192	continue;
268157ba JK	193	mutex_lock_nested(&sb_dqopt(sb)->files[cnt]->i_mutex,
268157ba JK	194	I_MUTEX_QUOTA);
7925409e JK	195	truncate_inode_pages(&sb_dqopt(sb)->files[cnt]->i_data, 0);
7925409e JK	196	mutex_unlock(&sb_dqopt(sb)->files[cnt]->i_mutex);
1da177e4	197	}
d3be915f	198	mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
1da177e4	199	}
850b201b	200	#endif
1da177e4	201
850b201b	202	static void sync_dquots(int type)
1da177e4	203	{
850b201b	204	struct super_block *sb;
02a55ca8	205	int cnt;
618f0636	206
618f0636 KK	207	spin_lock(&sb_lock);
	208	restart:
	209	list_for_each_entry(sb, &super_blocks, s_list) {
268157ba JK	210	/* This test just improves performance so it needn't be
268157ba JK	211	* reliable... */
02a55ca8 JK	212	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
	213	if (type != -1 && type != cnt)
	214	continue;
f55abc0f	215	if (!sb_has_quota_active(sb, cnt))
02a55ca8 JK	216	continue;
02a55ca8 JK	217	if (!info_dirty(&sb_dqopt(sb)->info[cnt]) &&
268157ba	218	list_empty(&sb_dqopt(sb)->info[cnt].dqi_dirty_list))
02a55ca8 JK	219	continue;
	220	break;
	221	}
	222	if (cnt == MAXQUOTAS)
618f0636 KK	223	continue;
	224	sb->s_count++;
	225	spin_unlock(&sb_lock);
	226	down_read(&sb->s_umount);
850b201b CH	227	if (sb->s_root)
850b201b CH	228	sync_quota_sb(sb, type);
618f0636 KK	229	up_read(&sb->s_umount);
	230	spin_lock(&sb_lock);
	231	if (__put_super_and_need_restart(sb))
	232	goto restart;
1da177e4	233	}
618f0636	234	spin_unlock(&sb_lock);
1da177e4 LT	235	}
	236
	237	/* Copy parameters and call proper function */
268157ba JK	238	static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id,
268157ba JK	239	void __user *addr)
1da177e4 LT	240	{
	241	int ret;
	242
	243	switch (cmd) {
	244	case Q_QUOTAON: {
	245	char *pathname;
	246
268157ba JK	247	pathname = getname(addr);
268157ba JK	248	if (IS_ERR(pathname))
1da177e4	249	return PTR_ERR(pathname);
0ff5af83	250	ret = sb->s_qcop->quota_on(sb, type, id, pathname, 0);
1da177e4 LT	251	putname(pathname);
	252	return ret;
	253	}
	254	case Q_QUOTAOFF:
0ff5af83	255	return sb->s_qcop->quota_off(sb, type, 0);
1da177e4 LT	256
	257	case Q_GETFMT: {
	258	__u32 fmt;
	259
	260	down_read(&sb_dqopt(sb)->dqptr_sem);
f55abc0f	261	if (!sb_has_quota_active(sb, type)) {
1da177e4 LT	262	up_read(&sb_dqopt(sb)->dqptr_sem);
	263	return -ESRCH;
	264	}
	265	fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id;
	266	up_read(&sb_dqopt(sb)->dqptr_sem);
	267	if (copy_to_user(addr, &fmt, sizeof(fmt)))
	268	return -EFAULT;
	269	return 0;
	270	}
	271	case Q_GETINFO: {
	272	struct if_dqinfo info;
	273
268157ba JK	274	ret = sb->s_qcop->get_info(sb, type, &info);
268157ba JK	275	if (ret)
1da177e4 LT	276	return ret;
	277	if (copy_to_user(addr, &info, sizeof(info)))
	278	return -EFAULT;
	279	return 0;
	280	}
	281	case Q_SETINFO: {
	282	struct if_dqinfo info;
	283
	284	if (copy_from_user(&info, addr, sizeof(info)))
	285	return -EFAULT;
	286	return sb->s_qcop->set_info(sb, type, &info);
	287	}
	288	case Q_GETQUOTA: {
	289	struct if_dqblk idq;
	290
268157ba JK	291	ret = sb->s_qcop->get_dqblk(sb, type, id, &idq);
268157ba JK	292	if (ret)
1da177e4 LT	293	return ret;
	294	if (copy_to_user(addr, &idq, sizeof(idq)))
	295	return -EFAULT;
	296	return 0;
	297	}
	298	case Q_SETQUOTA: {
	299	struct if_dqblk idq;
	300
	301	if (copy_from_user(&idq, addr, sizeof(idq)))
	302	return -EFAULT;
	303	return sb->s_qcop->set_dqblk(sb, type, id, &idq);
	304	}
	305	case Q_SYNC:
850b201b CH	306	if (sb)
	307	sync_quota_sb(sb, type);
	308	else
	309	sync_dquots(type);
1da177e4 LT	310	return 0;
	311
	312	case Q_XQUOTAON:
	313	case Q_XQUOTAOFF:
	314	case Q_XQUOTARM: {
	315	__u32 flags;
	316
	317	if (copy_from_user(&flags, addr, sizeof(flags)))
	318	return -EFAULT;
	319	return sb->s_qcop->set_xstate(sb, flags, cmd);
	320	}
	321	case Q_XGETQSTAT: {
	322	struct fs_quota_stat fqs;
	323
	324	if ((ret = sb->s_qcop->get_xstate(sb, &fqs)))
	325	return ret;
	326	if (copy_to_user(addr, &fqs, sizeof(fqs)))
	327	return -EFAULT;
	328	return 0;
	329	}
	330	case Q_XSETQLIM: {
	331	struct fs_disk_quota fdq;
	332
	333	if (copy_from_user(&fdq, addr, sizeof(fdq)))
	334	return -EFAULT;
	335	return sb->s_qcop->set_xquota(sb, type, id, &fdq);
	336	}
	337	case Q_XGETQUOTA: {
	338	struct fs_disk_quota fdq;
	339
268157ba JK	340	ret = sb->s_qcop->get_xquota(sb, type, id, &fdq);
268157ba JK	341	if (ret)
1da177e4 LT	342	return ret;
	343	if (copy_to_user(addr, &fdq, sizeof(fdq)))
	344	return -EFAULT;
	345	return 0;
	346	}
de69e5f4 NS	347	case Q_XQUOTASYNC:
de69e5f4 NS	348	return sb->s_qcop->quota_sync(sb, type);
1da177e4 LT	349	/* We never reach here unless validity check is broken */
	350	default:
	351	BUG();
	352	}
	353	return 0;
	354	}
	355
9361401e DH	356	/*
	357	* look up a superblock on which quota ops will be performed
	358	* - use the name of a block device to find the superblock thereon
	359	*/
7a2435d8	360	static struct super_block quotactl_block(const char __user special)
9361401e DH	361	{
	362	#ifdef CONFIG_BLOCK
	363	struct block_device *bdev;
	364	struct super_block *sb;
	365	char *tmp = getname(special);
	366
	367	if (IS_ERR(tmp))
e231c2ee	368	return ERR_CAST(tmp);
9361401e DH	369	bdev = lookup_bdev(tmp);
	370	putname(tmp);
	371	if (IS_ERR(bdev))
e231c2ee	372	return ERR_CAST(bdev);
9361401e DH	373	sb = get_super(bdev);
	374	bdput(bdev);
	375	if (!sb)
	376	return ERR_PTR(-ENODEV);
	377
	378	return sb;
	379	#else
	380	return ERR_PTR(-ENODEV);
	381	#endif
	382	}
	383
1da177e4 LT	384	/*
	385	* This is the system call interface. This communicates with
	386	* the user-level programs. Currently this only supports diskquota
	387	* calls. Maybe we need to add the process quotas etc. in the future,
	388	* but we probably should use rlimits for that.
	389	*/
3cdad428 HC	390	SYSCALL_DEFINE4(quotactl, unsigned int, cmd, const char __user *, special,
3cdad428 HC	391	qid_t, id, void __user *, addr)
1da177e4 LT	392	{
	393	uint cmds, type;
	394	struct super_block *sb = NULL;
1da177e4 LT	395	int ret;
	396
	397	cmds = cmd >> SUBCMDSHIFT;
	398	type = cmd & SUBCMDMASK;
	399
	400	if (cmds != Q_SYNC \|\| special) {
9361401e DH	401	sb = quotactl_block(special);
	402	if (IS_ERR(sb))
	403	return PTR_ERR(sb);
1da177e4 LT	404	}
	405
	406	ret = check_quotactl_valid(sb, type, cmds, id);
	407	if (ret >= 0)
	408	ret = do_quotactl(sb, type, cmds, id, addr);
	409	if (sb)
	410	drop_super(sb);
	411
	412	return ret;
	413	}
b716395e	414
7a6c8135	415	#if defined(CONFIG_COMPAT_FOR_U64_ALIGNMENT)
b716395e VT	416	/*
	417	* This code works only for 32 bit quota tools over 64 bit OS (x86_64, ia64)
	418	* and is necessary due to alignment problems.
	419	*/
	420	struct compat_if_dqblk {
	421	compat_u64 dqb_bhardlimit;
	422	compat_u64 dqb_bsoftlimit;
	423	compat_u64 dqb_curspace;
	424	compat_u64 dqb_ihardlimit;
	425	compat_u64 dqb_isoftlimit;
	426	compat_u64 dqb_curinodes;
	427	compat_u64 dqb_btime;
	428	compat_u64 dqb_itime;
	429	compat_uint_t dqb_valid;
	430	};
	431
	432	/* XFS structures */
	433	struct compat_fs_qfilestat {
	434	compat_u64 dqb_bhardlimit;
	435	compat_u64 qfs_nblks;
	436	compat_uint_t qfs_nextents;
	437	};
	438
	439	struct compat_fs_quota_stat {
	440	__s8 qs_version;
	441	__u16 qs_flags;
	442	__s8 qs_pad;
	443	struct compat_fs_qfilestat qs_uquota;
	444	struct compat_fs_qfilestat qs_gquota;
	445	compat_uint_t qs_incoredqs;
	446	compat_int_t qs_btimelimit;
	447	compat_int_t qs_itimelimit;
	448	compat_int_t qs_rtbtimelimit;
	449	__u16 qs_bwarnlimit;
	450	__u16 qs_iwarnlimit;
	451	};
	452
	453	asmlinkage long sys32_quotactl(unsigned int cmd, const char __user *special,
	454	qid_t id, void __user *addr)
	455	{
	456	unsigned int cmds;
	457	struct if_dqblk __user *dqblk;
	458	struct compat_if_dqblk __user *compat_dqblk;
	459	struct fs_quota_stat __user *fsqstat;
	460	struct compat_fs_quota_stat __user *compat_fsqstat;
	461	compat_uint_t data;
	462	u16 xdata;
	463	long ret;
	464
	465	cmds = cmd >> SUBCMDSHIFT;
	466
	467	switch (cmds) {
	468	case Q_GETQUOTA:
	469	dqblk = compat_alloc_user_space(sizeof(struct if_dqblk));
	470	compat_dqblk = addr;
	471	ret = sys_quotactl(cmd, special, id, dqblk);
	472	if (ret)
	473	break;
	474	if (copy_in_user(compat_dqblk, dqblk, sizeof(*compat_dqblk)) \|\|
	475	get_user(data, &dqblk->dqb_valid) \|\|
	476	put_user(data, &compat_dqblk->dqb_valid))
	477	ret = -EFAULT;
	478	break;
	479	case Q_SETQUOTA:
480	dqblk = compat_alloc_user_space(sizeof(struct if_dqblk));
481	compat_dqblk = addr;
482	ret = -EFAULT;
483	if (copy_in_user(dqblk, compat_dqblk, sizeof(*compat_dqblk)) \|\|
484	get_user(data, &compat_dqblk->dqb_valid) \|\|
485	put_user(data, &dqblk->dqb_valid))
486	break;
487	ret = sys_quotactl(cmd, special, id, dqblk);
488	break;
489	case Q_XGETQSTAT:
490	fsqstat = compat_alloc_user_space(sizeof(struct fs_quota_stat));
491	compat_fsqstat = addr;
492	ret = sys_quotactl(cmd, special, id, fsqstat);
493	if (ret)
494	break;
495	ret = -EFAULT;
496	/* Copying qs_version, qs_flags, qs_pad */
497	if (copy_in_user(compat_fsqstat, fsqstat,
498	offsetof(struct compat_fs_quota_stat, qs_uquota)))
499	break;
500	/* Copying qs_uquota */
501	if (copy_in_user(&compat_fsqstat->qs_uquota,
502	&fsqstat->qs_uquota,
503	sizeof(compat_fsqstat->qs_uquota)) \|\|
504	get_user(data, &fsqstat->qs_uquota.qfs_nextents) \|\|
505	put_user(data, &compat_fsqstat->qs_uquota.qfs_nextents))
506	break;
507	/* Copying qs_gquota */
508	if (copy_in_user(&compat_fsqstat->qs_gquota,
509	&fsqstat->qs_gquota,
510	sizeof(compat_fsqstat->qs_gquota)) \|\|
511	get_user(data, &fsqstat->qs_gquota.qfs_nextents) \|\|
512	put_user(data, &compat_fsqstat->qs_gquota.qfs_nextents))
513	break;
514	/* Copying the rest */
515	if (copy_in_user(&compat_fsqstat->qs_incoredqs,
516	&fsqstat->qs_incoredqs,
517	sizeof(struct compat_fs_quota_stat) -
518	offsetof(struct compat_fs_quota_stat, qs_incoredqs)) \|\|
519	get_user(xdata, &fsqstat->qs_iwarnlimit) \|\|
520	put_user(xdata, &compat_fsqstat->qs_iwarnlimit))
521	break;
522	ret = 0;
523	break;
524	default:
525	ret = sys_quotactl(cmd, special, id, addr);
526	}
527	return ret;
528	}
529	#endif
86e931a3 SW	530
	531
	532	#ifdef CONFIG_QUOTA_NETLINK_INTERFACE
	533
	534	/* Netlink family structure for quota */
	535	static struct genl_family quota_genl_family = {
	536	.id = GENL_ID_GENERATE,
	537	.hdrsize = 0,
	538	.name = "VFS_DQUOT",
	539	.version = 1,
	540	.maxattr = QUOTA_NL_A_MAX,
	541	};
	542
	543	/**
	544	* quota_send_warning - Send warning to userspace about exceeded quota
	545	* @type: The quota type: USRQQUOTA, GRPQUOTA,...
	546	* @id: The user or group id of the quota that was exceeded
	547	* @dev: The device on which the fs is mounted (sb->s_dev)
	548	* @warntype: The type of the warning: QUOTA_NL_...
	549	*
	550	* This can be used by filesystems (including those which don't use
	551	* dquot) to send a message to userspace relating to quota limits.
	552	*
	553	*/
	554
	555	void quota_send_warning(short type, unsigned int id, dev_t dev,
	556	const char warntype)
	557	{
	558	static atomic_t seq;
	559	struct sk_buff *skb;
	560	void *msg_head;
	561	int ret;
	562	int msg_size = 4 * nla_total_size(sizeof(u32)) +
	563	2 * nla_total_size(sizeof(u64));
	564
	565	/* We have to allocate using GFP_NOFS as we are called from a
	566	* filesystem performing write and thus further recursion into
	567	* the fs to free some data could cause deadlocks. */
	568	skb = genlmsg_new(msg_size, GFP_NOFS);
	569	if (!skb) {
	570	printk(KERN_ERR
	571	"VFS: Not enough memory to send quota warning.\n");
	572	return;
	573	}
	574	msg_head = genlmsg_put(skb, 0, atomic_add_return(1, &seq),
	575	&quota_genl_family, 0, QUOTA_NL_C_WARNING);
	576	if (!msg_head) {
	577	printk(KERN_ERR
	578	"VFS: Cannot store netlink header in quota warning.\n");
	579	goto err_out;
	580	}
	581	ret = nla_put_u32(skb, QUOTA_NL_A_QTYPE, type);
	582	if (ret)
	583	goto attr_err_out;
	584	ret = nla_put_u64(skb, QUOTA_NL_A_EXCESS_ID, id);
	585	if (ret)
	586	goto attr_err_out;
	587	ret = nla_put_u32(skb, QUOTA_NL_A_WARNING, warntype);
	588	if (ret)
	589	goto attr_err_out;
	590	ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MAJOR, MAJOR(dev));
	591	if (ret)
	592	goto attr_err_out;
	593	ret = nla_put_u32(skb, QUOTA_NL_A_DEV_MINOR, MINOR(dev));
594	if (ret)
595	goto attr_err_out;
596	ret = nla_put_u64(skb, QUOTA_NL_A_CAUSED_ID, current_uid());
597	if (ret)
598	goto attr_err_out;
599	genlmsg_end(skb, msg_head);
600
601	genlmsg_multicast(skb, 0, quota_genl_family.id, GFP_NOFS);
602	return;
603	attr_err_out:
604	printk(KERN_ERR "VFS: Not enough space to compose quota message!\n");
605	err_out:
606	kfree_skb(skb);
607	}
608	EXPORT_SYMBOL(quota_send_warning);
609
610	static int __init quota_init(void)
611	{
612	if (genl_register_family(&quota_genl_family) != 0)
613	printk(KERN_ERR
614	"VFS: Failed to create quota netlink interface.\n");
615	return 0;
616	};
617
618	module_init(quota_init);
619	#endif
620