[mirror_ubuntu-zesty-kernel.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 <linux/uaccess.h>
#include <linux/kernel.h>
#include <linux/security.h>
#include <linux/syscalls.h>
#include <linux/capability.h>
#include <linux/quotaops.h>
#include <linux/types.h>
#include <linux/writeback.h>

static int check_quotactl_permission(struct super_block *sb, int type, int cmd,
				     qid_t id)
{
	switch (cmd) {
	/* these commands do not require any special privilegues */
	case Q_GETFMT:
	case Q_SYNC:
	case Q_GETINFO:
	case Q_XGETQSTAT:
	case Q_XGETQSTATV:
	case Q_XQUOTASYNC:
		break;
	/* allow to query information for dquots we "own" */
	case Q_GETQUOTA:
	case Q_XGETQUOTA:
		if ((type == USRQUOTA && uid_eq(current_euid(), make_kuid(current_user_ns(), id))) ||
		    (type == GRPQUOTA && in_egroup_p(make_kgid(current_user_ns(), id))))
			break;
		/*FALLTHROUGH*/
	default:
		if (!capable(CAP_SYS_ADMIN))
			return -EPERM;
	}

	return security_quotactl(cmd, type, id, sb);
}

static void quota_sync_one(struct super_block *sb, void *arg)
{
	int type = *(int *)arg;

	if (sb->s_qcop && sb->s_qcop->quota_sync &&
	    (sb->s_quota_types & (1 << type)))
		sb->s_qcop->quota_sync(sb, type);
}

static int quota_sync_all(int type)
{
	int ret;

	if (type >= MAXQUOTAS)
		return -EINVAL;
	ret = security_quotactl(Q_SYNC, type, 0, NULL);
	if (!ret)
		iterate_supers(quota_sync_one, &type);
	return ret;
}

unsigned int qtype_enforce_flag(int type)
{
	switch (type) {
	case USRQUOTA:
		return FS_QUOTA_UDQ_ENFD;
	case GRPQUOTA:
		return FS_QUOTA_GDQ_ENFD;
	case PRJQUOTA:
		return FS_QUOTA_PDQ_ENFD;
	}
	return 0;
}

static int quota_quotaon(struct super_block *sb, int type, int cmd, qid_t id,
		         struct path *path)
{
	if (!sb->s_qcop->quota_on && !sb->s_qcop->quota_enable)
		return -ENOSYS;
	if (sb->s_qcop->quota_enable)
		return sb->s_qcop->quota_enable(sb, qtype_enforce_flag(type));
	if (IS_ERR(path))
		return PTR_ERR(path);
	return sb->s_qcop->quota_on(sb, type, id, path);
}

static int quota_quotaoff(struct super_block *sb, int type)
{
	if (!sb->s_qcop->quota_off && !sb->s_qcop->quota_disable)
		return -ENOSYS;
	if (sb->s_qcop->quota_disable)
		return sb->s_qcop->quota_disable(sb, qtype_enforce_flag(type));
	return sb->s_qcop->quota_off(sb, type);
}

static int quota_getfmt(struct super_block *sb, int type, void __user *addr)
{
	__u32 fmt;

	mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
	if (!sb_has_quota_active(sb, type)) {
		mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
		return -ESRCH;
	}
	fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id;
	mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
	if (copy_to_user(addr, &fmt, sizeof(fmt)))
		return -EFAULT;
	return 0;
}

static int quota_getinfo(struct super_block *sb, int type, void __user *addr)
{
	struct qc_state state;
	struct qc_type_state *tstate;
	struct if_dqinfo uinfo;
	int ret;

	/* This checks whether qc_state has enough entries... */
	BUILD_BUG_ON(MAXQUOTAS > XQM_MAXQUOTAS);
	if (!sb->s_qcop->get_state)
		return -ENOSYS;
	ret = sb->s_qcop->get_state(sb, &state);
	if (ret)
		return ret;
	tstate = state.s_state + type;
	if (!(tstate->flags & QCI_ACCT_ENABLED))
		return -ESRCH;
	memset(&uinfo, 0, sizeof(uinfo));
	uinfo.dqi_bgrace = tstate->spc_timelimit;
	uinfo.dqi_igrace = tstate->ino_timelimit;
	if (tstate->flags & QCI_SYSFILE)
		uinfo.dqi_flags |= DQF_SYS_FILE;
	if (tstate->flags & QCI_ROOT_SQUASH)
		uinfo.dqi_flags |= DQF_ROOT_SQUASH;
	uinfo.dqi_valid = IIF_ALL;
	if (!ret && copy_to_user(addr, &uinfo, sizeof(uinfo)))
		return -EFAULT;
	return ret;
}

static int quota_setinfo(struct super_block *sb, int type, void __user *addr)
{
	struct if_dqinfo info;

	if (copy_from_user(&info, addr, sizeof(info)))
		return -EFAULT;
	if (!sb->s_qcop->set_info)
		return -ENOSYS;
	return sb->s_qcop->set_info(sb, type, &info);
}

static inline qsize_t qbtos(qsize_t blocks)
{
	return blocks << QIF_DQBLKSIZE_BITS;
}

static inline qsize_t stoqb(qsize_t space)
{
	return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS;
}

static void copy_to_if_dqblk(struct if_dqblk *dst, struct qc_dqblk *src)
{
	memset(dst, 0, sizeof(*dst));
	dst->dqb_bhardlimit = stoqb(src->d_spc_hardlimit);
	dst->dqb_bsoftlimit = stoqb(src->d_spc_softlimit);
	dst->dqb_curspace = src->d_space;
	dst->dqb_ihardlimit = src->d_ino_hardlimit;
	dst->dqb_isoftlimit = src->d_ino_softlimit;
	dst->dqb_curinodes = src->d_ino_count;
	dst->dqb_btime = src->d_spc_timer;
	dst->dqb_itime = src->d_ino_timer;
	dst->dqb_valid = QIF_ALL;
}

static int quota_getquota(struct super_block *sb, int type, qid_t id,
			  void __user *addr)
{
	struct kqid qid;
	struct qc_dqblk fdq;
	struct if_dqblk idq;
	int ret;

	if (!sb->s_qcop->get_dqblk)
		return -ENOSYS;
	qid = make_kqid(current_user_ns(), type, id);
	if (!qid_valid(qid))
		return -EINVAL;
	ret = sb->s_qcop->get_dqblk(sb, qid, &fdq);
	if (ret)
		return ret;
	copy_to_if_dqblk(&idq, &fdq);
	if (copy_to_user(addr, &idq, sizeof(idq)))
		return -EFAULT;
	return 0;
}

static void copy_from_if_dqblk(struct qc_dqblk *dst, struct if_dqblk *src)
{
	dst->d_spc_hardlimit = qbtos(src->dqb_bhardlimit);
	dst->d_spc_softlimit = qbtos(src->dqb_bsoftlimit);
	dst->d_space = src->dqb_curspace;
	dst->d_ino_hardlimit = src->dqb_ihardlimit;
	dst->d_ino_softlimit = src->dqb_isoftlimit;
	dst->d_ino_count = src->dqb_curinodes;
	dst->d_spc_timer = src->dqb_btime;
	dst->d_ino_timer = src->dqb_itime;

	dst->d_fieldmask = 0;
	if (src->dqb_valid & QIF_BLIMITS)
		dst->d_fieldmask |= QC_SPC_SOFT | QC_SPC_HARD;
	if (src->dqb_valid & QIF_SPACE)
		dst->d_fieldmask |= QC_SPACE;
	if (src->dqb_valid & QIF_ILIMITS)
		dst->d_fieldmask |= QC_INO_SOFT | QC_INO_HARD;
	if (src->dqb_valid & QIF_INODES)
		dst->d_fieldmask |= QC_INO_COUNT;
	if (src->dqb_valid & QIF_BTIME)
		dst->d_fieldmask |= QC_SPC_TIMER;
	if (src->dqb_valid & QIF_ITIME)
		dst->d_fieldmask |= QC_INO_TIMER;
}

static int quota_setquota(struct super_block *sb, int type, qid_t id,
			  void __user *addr)
{
	struct qc_dqblk fdq;
	struct if_dqblk idq;
	struct kqid qid;

	if (copy_from_user(&idq, addr, sizeof(idq)))
		return -EFAULT;
	if (!sb->s_qcop->set_dqblk)
		return -ENOSYS;
	qid = make_kqid(current_user_ns(), type, id);
	if (!qid_valid(qid))
		return -EINVAL;
	copy_from_if_dqblk(&fdq, &idq);
	return sb->s_qcop->set_dqblk(sb, qid, &fdq);
}

static int quota_enable(struct super_block *sb, void __user *addr)
{
	__u32 flags;

	if (copy_from_user(&flags, addr, sizeof(flags)))
		return -EFAULT;
	if (!sb->s_qcop->quota_enable)
		return -ENOSYS;
	return sb->s_qcop->quota_enable(sb, flags);
}

static int quota_disable(struct super_block *sb, void __user *addr)
{
	__u32 flags;

	if (copy_from_user(&flags, addr, sizeof(flags)))
		return -EFAULT;
	if (!sb->s_qcop->quota_disable)
		return -ENOSYS;
	return sb->s_qcop->quota_disable(sb, flags);
}

static int quota_getxstate(struct super_block *sb, void __user *addr)
{
	struct fs_quota_stat fqs;
	int ret;

	if (!sb->s_qcop->get_xstate)
		return -ENOSYS;
	ret = sb->s_qcop->get_xstate(sb, &fqs);
	if (!ret && copy_to_user(addr, &fqs, sizeof(fqs)))
		return -EFAULT;
	return ret;
}

static int quota_getxstatev(struct super_block *sb, void __user *addr)
{
	struct fs_quota_statv fqs;
	int ret;

	if (!sb->s_qcop->get_xstatev)
		return -ENOSYS;

	memset(&fqs, 0, sizeof(fqs));
	if (copy_from_user(&fqs, addr, 1)) /* Just read qs_version */
		return -EFAULT;

	/* If this kernel doesn't support user specified version, fail */
	switch (fqs.qs_version) {
	case FS_QSTATV_VERSION1:
		break;
	default:
		return -EINVAL;
	}
	ret = sb->s_qcop->get_xstatev(sb, &fqs);
	if (!ret && copy_to_user(addr, &fqs, sizeof(fqs)))
		return -EFAULT;
	return ret;
}

/*
 * XFS defines BBTOB and BTOBB macros inside fs/xfs/ and we cannot move them
 * out of there as xfsprogs rely on definitions being in that header file. So
 * just define same functions here for quota purposes.
 */
#define XFS_BB_SHIFT 9

static inline u64 quota_bbtob(u64 blocks)
{
	return blocks << XFS_BB_SHIFT;
}

static inline u64 quota_btobb(u64 bytes)
{
	return (bytes + (1 << XFS_BB_SHIFT) - 1) >> XFS_BB_SHIFT;
}

static void copy_from_xfs_dqblk(struct qc_dqblk *dst, struct fs_disk_quota *src)
{
	dst->d_spc_hardlimit = quota_bbtob(src->d_blk_hardlimit);
	dst->d_spc_softlimit = quota_bbtob(src->d_blk_softlimit);
	dst->d_ino_hardlimit = src->d_ino_hardlimit;
	dst->d_ino_softlimit = src->d_ino_softlimit;
	dst->d_space = quota_bbtob(src->d_bcount);
	dst->d_ino_count = src->d_icount;
	dst->d_ino_timer = src->d_itimer;
	dst->d_spc_timer = src->d_btimer;
	dst->d_ino_warns = src->d_iwarns;
	dst->d_spc_warns = src->d_bwarns;
	dst->d_rt_spc_hardlimit = quota_bbtob(src->d_rtb_hardlimit);
	dst->d_rt_spc_softlimit = quota_bbtob(src->d_rtb_softlimit);
	dst->d_rt_space = quota_bbtob(src->d_rtbcount);
	dst->d_rt_spc_timer = src->d_rtbtimer;
	dst->d_rt_spc_warns = src->d_rtbwarns;
	dst->d_fieldmask = 0;
	if (src->d_fieldmask & FS_DQ_ISOFT)
		dst->d_fieldmask |= QC_INO_SOFT;
	if (src->d_fieldmask & FS_DQ_IHARD)
		dst->d_fieldmask |= QC_INO_HARD;
	if (src->d_fieldmask & FS_DQ_BSOFT)
		dst->d_fieldmask |= QC_SPC_SOFT;
	if (src->d_fieldmask & FS_DQ_BHARD)
		dst->d_fieldmask |= QC_SPC_HARD;
	if (src->d_fieldmask & FS_DQ_RTBSOFT)
		dst->d_fieldmask |= QC_RT_SPC_SOFT;
	if (src->d_fieldmask & FS_DQ_RTBHARD)
		dst->d_fieldmask |= QC_RT_SPC_HARD;
	if (src->d_fieldmask & FS_DQ_BTIMER)
		dst->d_fieldmask |= QC_SPC_TIMER;
	if (src->d_fieldmask & FS_DQ_ITIMER)
		dst->d_fieldmask |= QC_INO_TIMER;
	if (src->d_fieldmask & FS_DQ_RTBTIMER)
		dst->d_fieldmask |= QC_RT_SPC_TIMER;
	if (src->d_fieldmask & FS_DQ_BWARNS)
		dst->d_fieldmask |= QC_SPC_WARNS;
	if (src->d_fieldmask & FS_DQ_IWARNS)
		dst->d_fieldmask |= QC_INO_WARNS;
	if (src->d_fieldmask & FS_DQ_RTBWARNS)
		dst->d_fieldmask |= QC_RT_SPC_WARNS;
	if (src->d_fieldmask & FS_DQ_BCOUNT)
		dst->d_fieldmask |= QC_SPACE;
	if (src->d_fieldmask & FS_DQ_ICOUNT)
		dst->d_fieldmask |= QC_INO_COUNT;
	if (src->d_fieldmask & FS_DQ_RTBCOUNT)
		dst->d_fieldmask |= QC_RT_SPACE;
}

static int quota_setxquota(struct super_block *sb, int type, qid_t id,
			   void __user *addr)
{
	struct fs_disk_quota fdq;
	struct qc_dqblk qdq;
	struct kqid qid;

	if (copy_from_user(&fdq, addr, sizeof(fdq)))
		return -EFAULT;
	if (!sb->s_qcop->set_dqblk)
		return -ENOSYS;
	qid = make_kqid(current_user_ns(), type, id);
	if (!qid_valid(qid))
		return -EINVAL;
	copy_from_xfs_dqblk(&qdq, &fdq);
	return sb->s_qcop->set_dqblk(sb, qid, &qdq);
}

static void copy_to_xfs_dqblk(struct fs_disk_quota *dst, struct qc_dqblk *src,
			      int type, qid_t id)
{
	memset(dst, 0, sizeof(*dst));
	dst->d_version = FS_DQUOT_VERSION;
	dst->d_id = id;
	if (type == USRQUOTA)
		dst->d_flags = FS_USER_QUOTA;
	else if (type == PRJQUOTA)
		dst->d_flags = FS_PROJ_QUOTA;
	else
		dst->d_flags = FS_GROUP_QUOTA;
	dst->d_blk_hardlimit = quota_btobb(src->d_spc_hardlimit);
	dst->d_blk_softlimit = quota_btobb(src->d_spc_softlimit);
	dst->d_ino_hardlimit = src->d_ino_hardlimit;
	dst->d_ino_softlimit = src->d_ino_softlimit;
	dst->d_bcount = quota_btobb(src->d_space);
	dst->d_icount = src->d_ino_count;
	dst->d_itimer = src->d_ino_timer;
	dst->d_btimer = src->d_spc_timer;
	dst->d_iwarns = src->d_ino_warns;
	dst->d_bwarns = src->d_spc_warns;
	dst->d_rtb_hardlimit = quota_btobb(src->d_rt_spc_hardlimit);
	dst->d_rtb_softlimit = quota_btobb(src->d_rt_spc_softlimit);
	dst->d_rtbcount = quota_btobb(src->d_rt_space);
	dst->d_rtbtimer = src->d_rt_spc_timer;
	dst->d_rtbwarns = src->d_rt_spc_warns;
}

static int quota_getxquota(struct super_block *sb, int type, qid_t id,
			   void __user *addr)
{
	struct fs_disk_quota fdq;
	struct qc_dqblk qdq;
	struct kqid qid;
	int ret;

	if (!sb->s_qcop->get_dqblk)
		return -ENOSYS;
	qid = make_kqid(current_user_ns(), type, id);
	if (!qid_valid(qid))
		return -EINVAL;
	ret = sb->s_qcop->get_dqblk(sb, qid, &qdq);
	if (ret)
		return ret;
	copy_to_xfs_dqblk(&fdq, &qdq, type, id);
	if (copy_to_user(addr, &fdq, sizeof(fdq)))
		return -EFAULT;
	return ret;
}

static int quota_rmxquota(struct super_block *sb, void __user *addr)
{
	__u32 flags;

	if (copy_from_user(&flags, addr, sizeof(flags)))
		return -EFAULT;
	if (!sb->s_qcop->rm_xquota)
		return -ENOSYS;
	return sb->s_qcop->rm_xquota(sb, flags);
}

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

	if (type >= (XQM_COMMAND(cmd) ? XQM_MAXQUOTAS : MAXQUOTAS))
		return -EINVAL;
	/*
	 * Quota not supported on this fs? Check this before s_quota_types
	 * since they needn't be set if quota is not supported at all.
	 */
	if (!sb->s_qcop)
		return -ENOSYS;
	if (!(sb->s_quota_types & (1 << type)))
		return -EINVAL;

	ret = check_quotactl_permission(sb, type, cmd, id);
	if (ret < 0)
		return ret;

	switch (cmd) {
	case Q_QUOTAON:
		return quota_quotaon(sb, type, cmd, id, path);
	case Q_QUOTAOFF:
		return quota_quotaoff(sb, type);
	case Q_GETFMT:
		return quota_getfmt(sb, type, addr);
	case Q_GETINFO:
		return quota_getinfo(sb, type, addr);
	case Q_SETINFO:
		return quota_setinfo(sb, type, addr);
	case Q_GETQUOTA:
		return quota_getquota(sb, type, id, addr);
	case Q_SETQUOTA:
		return quota_setquota(sb, type, id, addr);
	case Q_SYNC:
		if (!sb->s_qcop->quota_sync)
			return -ENOSYS;
		return sb->s_qcop->quota_sync(sb, type);
	case Q_XQUOTAON:
		return quota_enable(sb, addr);
	case Q_XQUOTAOFF:
		return quota_disable(sb, addr);
	case Q_XQUOTARM:
		return quota_rmxquota(sb, addr);
	case Q_XGETQSTAT:
		return quota_getxstate(sb, addr);
	case Q_XGETQSTATV:
		return quota_getxstatev(sb, addr);
	case Q_XSETQLIM:
		return quota_setxquota(sb, type, id, addr);
	case Q_XGETQUOTA:
		return quota_getxquota(sb, type, id, addr);
	case Q_XQUOTASYNC:
		if (sb->s_flags & MS_RDONLY)
			return -EROFS;
		/* XFS quotas are fully coherent now, making this call a noop */
		return 0;
	default:
		return -EINVAL;
	}
}

#ifdef CONFIG_BLOCK

/* Return 1 if 'cmd' will block on frozen filesystem */
static int quotactl_cmd_write(int cmd)
{
	switch (cmd) {
	case Q_GETFMT:
	case Q_GETINFO:
	case Q_SYNC:
	case Q_XGETQSTAT:
	case Q_XGETQSTATV:
	case Q_XGETQUOTA:
	case Q_XQUOTASYNC:
		return 0;
	}
	return 1;
}

#endif /* CONFIG_BLOCK */

/*
 * 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, int cmd)
{
#ifdef CONFIG_BLOCK
	struct block_device *bdev;
	struct super_block *sb;
	struct filename *tmp = getname(special);

	if (IS_ERR(tmp))
		return ERR_CAST(tmp);
	bdev = lookup_bdev(tmp->name);
	putname(tmp);
	if (IS_ERR(bdev))
		return ERR_CAST(bdev);
	if (quotactl_cmd_write(cmd))
		sb = get_super_thawed(bdev);
	else
		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;
	struct path path, *pathp = NULL;
	int ret;

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

	/*
	 * As a special case Q_SYNC can be called without a specific device.
	 * It will iterate all superblocks that have quota enabled and call
	 * the sync action on each of them.
	 */
	if (!special) {
		if (cmds == Q_SYNC)
			return quota_sync_all(type);
		return -ENODEV;
	}

	/*
	 * Path for quotaon has to be resolved before grabbing superblock
	 * because that gets s_umount sem which is also possibly needed by path
	 * resolution (think about autofs) and thus deadlocks could arise.
	 */
	if (cmds == Q_QUOTAON) {
		ret = user_path_at(AT_FDCWD, addr, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path);
		if (ret)
			pathp = ERR_PTR(ret);
		else
			pathp = &path;
	}

	sb = quotactl_block(special, cmds);
	if (IS_ERR(sb)) {
		ret = PTR_ERR(sb);
		goto out;
	}

	ret = do_quotactl(sb, type, cmds, id, addr, pathp);

	drop_super(sb);
out:
	if (pathp && !IS_ERR(pathp))
		path_put(pathp);
	return ret;
}
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>
f3da9310	12	#include <linux/uaccess.h>
1da177e4	13	#include <linux/kernel.h>
1da177e4 LT	14	#include <linux/security.h>
1da177e4 LT	15	#include <linux/syscalls.h>
16f7e0fe	16	#include <linux/capability.h>
be586bab	17	#include <linux/quotaops.h>
b716395e	18	#include <linux/types.h>
8c4e4acd	19	#include <linux/writeback.h>
1da177e4	20
c988afb5 CH	21	static int check_quotactl_permission(struct super_block *sb, int type, int cmd,
c988afb5 CH	22	qid_t id)
1da177e4	23	{
c988afb5 CH	24	switch (cmd) {
	25	/* these commands do not require any special privilegues */
	26	case Q_GETFMT:
	27	case Q_SYNC:
	28	case Q_GETINFO:
	29	case Q_XGETQSTAT:
af30cb44	30	case Q_XGETQSTATV:
c988afb5 CH	31	case Q_XQUOTASYNC:
	32	break;
	33	/* allow to query information for dquots we "own" */
	34	case Q_GETQUOTA:
	35	case Q_XGETQUOTA:
74a8a103 EB	36	if ((type == USRQUOTA && uid_eq(current_euid(), make_kuid(current_user_ns(), id))) \|\|
74a8a103 EB	37	(type == GRPQUOTA && in_egroup_p(make_kgid(current_user_ns(), id))))
c988afb5 CH	38	break;
	39	/FALLTHROUGH/
	40	default:
1da177e4 LT	41	if (!capable(CAP_SYS_ADMIN))
	42	return -EPERM;
	43	}
	44
c988afb5	45	return security_quotactl(cmd, type, id, sb);
1da177e4 LT	46	}
1da177e4 LT	47
01a05b33 AV	48	static void quota_sync_one(struct super_block sb, void arg)
01a05b33 AV	49	{
2c5f648a JK	50	int type = (int )arg;
	51
	52	if (sb->s_qcop && sb->s_qcop->quota_sync &&
	53	(sb->s_quota_types & (1 << type)))
	54	sb->s_qcop->quota_sync(sb, type);
01a05b33 AV	55	}
01a05b33 AV	56
6ae09575	57	static int quota_sync_all(int type)
1da177e4	58	{
6ae09575 CH	59	int ret;
	60
	61	if (type >= MAXQUOTAS)
	62	return -EINVAL;
	63	ret = security_quotactl(Q_SYNC, type, 0, NULL);
01a05b33 AV	64	if (!ret)
	65	iterate_supers(quota_sync_one, &type);
	66	return ret;
1da177e4 LT	67	}
1da177e4 LT	68
d3b86324 JK	69	unsigned int qtype_enforce_flag(int type)
	70	{
	71	switch (type) {
	72	case USRQUOTA:
	73	return FS_QUOTA_UDQ_ENFD;
	74	case GRPQUOTA:
	75	return FS_QUOTA_GDQ_ENFD;
	76	case PRJQUOTA:
	77	return FS_QUOTA_PDQ_ENFD;
	78	}
	79	return 0;
	80	}
	81
c411e5f6	82	static int quota_quotaon(struct super_block *sb, int type, int cmd, qid_t id,
f00c9e44	83	struct path *path)
1da177e4	84	{
aaa3daed	85	if (!sb->s_qcop->quota_on && !sb->s_qcop->quota_enable)
f00c9e44	86	return -ENOSYS;
d3b86324 JK	87	if (sb->s_qcop->quota_enable)
d3b86324 JK	88	return sb->s_qcop->quota_enable(sb, qtype_enforce_flag(type));
f00c9e44 JK	89	if (IS_ERR(path))
	90	return PTR_ERR(path);
	91	return sb->s_qcop->quota_on(sb, type, id, path);
c411e5f6	92	}
1da177e4	93
d3b86324 JK	94	static int quota_quotaoff(struct super_block *sb, int type)
	95	{
	96	if (!sb->s_qcop->quota_off && !sb->s_qcop->quota_disable)
	97	return -ENOSYS;
	98	if (sb->s_qcop->quota_disable)
	99	return sb->s_qcop->quota_disable(sb, qtype_enforce_flag(type));
	100	return sb->s_qcop->quota_off(sb, type);
	101	}
	102
c411e5f6 CH	103	static int quota_getfmt(struct super_block sb, int type, void __user addr)
	104	{
	105	__u32 fmt;
1da177e4	106
606cdcca	107	mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
c411e5f6	108	if (!sb_has_quota_active(sb, type)) {
606cdcca	109	mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
c411e5f6 CH	110	return -ESRCH;
	111	}
	112	fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id;
606cdcca	113	mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
c411e5f6 CH	114	if (copy_to_user(addr, &fmt, sizeof(fmt)))
	115	return -EFAULT;
	116	return 0;
	117	}
1da177e4	118
c411e5f6 CH	119	static int quota_getinfo(struct super_block sb, int type, void __user addr)
c411e5f6 CH	120	{
0a240339 JK	121	struct qc_state state;
	122	struct qc_type_state *tstate;
	123	struct if_dqinfo uinfo;
c411e5f6	124	int ret;
1da177e4	125
0a240339 JK	126	/* This checks whether qc_state has enough entries... */
	127	BUILD_BUG_ON(MAXQUOTAS > XQM_MAXQUOTAS);
	128	if (!sb->s_qcop->get_state)
f450d4fe	129	return -ENOSYS;
0a240339 JK	130	ret = sb->s_qcop->get_state(sb, &state);
	131	if (ret)
	132	return ret;
	133	tstate = state.s_state + type;
	134	if (!(tstate->flags & QCI_ACCT_ENABLED))
	135	return -ESRCH;
	136	memset(&uinfo, 0, sizeof(uinfo));
	137	uinfo.dqi_bgrace = tstate->spc_timelimit;
	138	uinfo.dqi_igrace = tstate->ino_timelimit;
	139	if (tstate->flags & QCI_SYSFILE)
	140	uinfo.dqi_flags \|= DQF_SYS_FILE;
	141	if (tstate->flags & QCI_ROOT_SQUASH)
	142	uinfo.dqi_flags \|= DQF_ROOT_SQUASH;
	143	uinfo.dqi_valid = IIF_ALL;
	144	if (!ret && copy_to_user(addr, &uinfo, sizeof(uinfo)))
c411e5f6 CH	145	return -EFAULT;
	146	return ret;
	147	}
1da177e4	148
c411e5f6 CH	149	static int quota_setinfo(struct super_block sb, int type, void __user addr)
	150	{
	151	struct if_dqinfo info;
1da177e4	152
c411e5f6 CH	153	if (copy_from_user(&info, addr, sizeof(info)))
c411e5f6 CH	154	return -EFAULT;
f450d4fe CH	155	if (!sb->s_qcop->set_info)
f450d4fe CH	156	return -ENOSYS;
c411e5f6 CH	157	return sb->s_qcop->set_info(sb, type, &info);
	158	}
	159
14bf61ff JK	160	static inline qsize_t qbtos(qsize_t blocks)
	161	{
	162	return blocks << QIF_DQBLKSIZE_BITS;
	163	}
	164
	165	static inline qsize_t stoqb(qsize_t space)
	166	{
	167	return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS;
	168	}
	169
	170	static void copy_to_if_dqblk(struct if_dqblk dst, struct qc_dqblk src)
b9b2dd36	171	{
18da65e7	172	memset(dst, 0, sizeof(*dst));
14bf61ff JK	173	dst->dqb_bhardlimit = stoqb(src->d_spc_hardlimit);
	174	dst->dqb_bsoftlimit = stoqb(src->d_spc_softlimit);
	175	dst->dqb_curspace = src->d_space;
b9b2dd36 CH	176	dst->dqb_ihardlimit = src->d_ino_hardlimit;
b9b2dd36 CH	177	dst->dqb_isoftlimit = src->d_ino_softlimit;
14bf61ff JK	178	dst->dqb_curinodes = src->d_ino_count;
	179	dst->dqb_btime = src->d_spc_timer;
	180	dst->dqb_itime = src->d_ino_timer;
b9b2dd36 CH	181	dst->dqb_valid = QIF_ALL;
	182	}
	183
c411e5f6 CH	184	static int quota_getquota(struct super_block *sb, int type, qid_t id,
	185	void __user *addr)
	186	{
74a8a103	187	struct kqid qid;
14bf61ff	188	struct qc_dqblk fdq;
c411e5f6 CH	189	struct if_dqblk idq;
	190	int ret;
	191
f450d4fe CH	192	if (!sb->s_qcop->get_dqblk)
f450d4fe CH	193	return -ENOSYS;
74a8a103 EB	194	qid = make_kqid(current_user_ns(), type, id);
	195	if (!qid_valid(qid))
	196	return -EINVAL;
	197	ret = sb->s_qcop->get_dqblk(sb, qid, &fdq);
c411e5f6 CH	198	if (ret)
c411e5f6 CH	199	return ret;
b9b2dd36	200	copy_to_if_dqblk(&idq, &fdq);
c411e5f6 CH	201	if (copy_to_user(addr, &idq, sizeof(idq)))
	202	return -EFAULT;
	203	return 0;
	204	}
	205
14bf61ff	206	static void copy_from_if_dqblk(struct qc_dqblk dst, struct if_dqblk src)
c472b432	207	{
14bf61ff JK	208	dst->d_spc_hardlimit = qbtos(src->dqb_bhardlimit);
	209	dst->d_spc_softlimit = qbtos(src->dqb_bsoftlimit);
	210	dst->d_space = src->dqb_curspace;
c472b432 CH	211	dst->d_ino_hardlimit = src->dqb_ihardlimit;
c472b432 CH	212	dst->d_ino_softlimit = src->dqb_isoftlimit;
14bf61ff JK	213	dst->d_ino_count = src->dqb_curinodes;
	214	dst->d_spc_timer = src->dqb_btime;
	215	dst->d_ino_timer = src->dqb_itime;
c472b432 CH	216
	217	dst->d_fieldmask = 0;
	218	if (src->dqb_valid & QIF_BLIMITS)
14bf61ff	219	dst->d_fieldmask \|= QC_SPC_SOFT \| QC_SPC_HARD;
c472b432	220	if (src->dqb_valid & QIF_SPACE)
14bf61ff	221	dst->d_fieldmask \|= QC_SPACE;
c472b432	222	if (src->dqb_valid & QIF_ILIMITS)
14bf61ff	223	dst->d_fieldmask \|= QC_INO_SOFT \| QC_INO_HARD;
c472b432	224	if (src->dqb_valid & QIF_INODES)
14bf61ff	225	dst->d_fieldmask \|= QC_INO_COUNT;
c472b432	226	if (src->dqb_valid & QIF_BTIME)
14bf61ff	227	dst->d_fieldmask \|= QC_SPC_TIMER;
c472b432	228	if (src->dqb_valid & QIF_ITIME)
14bf61ff	229	dst->d_fieldmask \|= QC_INO_TIMER;
c472b432 CH	230	}
c472b432 CH	231
c411e5f6 CH	232	static int quota_setquota(struct super_block *sb, int type, qid_t id,
	233	void __user *addr)
	234	{
14bf61ff	235	struct qc_dqblk fdq;
c411e5f6	236	struct if_dqblk idq;
74a8a103	237	struct kqid qid;
c411e5f6 CH	238
	239	if (copy_from_user(&idq, addr, sizeof(idq)))
	240	return -EFAULT;
f450d4fe CH	241	if (!sb->s_qcop->set_dqblk)
f450d4fe CH	242	return -ENOSYS;
74a8a103 EB	243	qid = make_kqid(current_user_ns(), type, id);
	244	if (!qid_valid(qid))
	245	return -EINVAL;
c472b432	246	copy_from_if_dqblk(&fdq, &idq);
74a8a103	247	return sb->s_qcop->set_dqblk(sb, qid, &fdq);
c411e5f6 CH	248	}
c411e5f6 CH	249
38e478c4	250	static int quota_enable(struct super_block sb, void __user addr)
c411e5f6 CH	251	{
	252	__u32 flags;
	253
	254	if (copy_from_user(&flags, addr, sizeof(flags)))
	255	return -EFAULT;
38e478c4	256	if (!sb->s_qcop->quota_enable)
f450d4fe	257	return -ENOSYS;
38e478c4 JK	258	return sb->s_qcop->quota_enable(sb, flags);
	259	}
	260
	261	static int quota_disable(struct super_block sb, void __user addr)
	262	{
	263	__u32 flags;
	264
	265	if (copy_from_user(&flags, addr, sizeof(flags)))
	266	return -EFAULT;
	267	if (!sb->s_qcop->quota_disable)
	268	return -ENOSYS;
	269	return sb->s_qcop->quota_disable(sb, flags);
c411e5f6 CH	270	}
	271
	272	static int quota_getxstate(struct super_block sb, void __user addr)
	273	{
	274	struct fs_quota_stat fqs;
	275	int ret;
f450d4fe CH	276
	277	if (!sb->s_qcop->get_xstate)
	278	return -ENOSYS;
c411e5f6 CH	279	ret = sb->s_qcop->get_xstate(sb, &fqs);
	280	if (!ret && copy_to_user(addr, &fqs, sizeof(fqs)))
	281	return -EFAULT;
	282	return ret;
	283	}
1da177e4	284
af30cb44 CS	285	static int quota_getxstatev(struct super_block sb, void __user addr)
	286	{
	287	struct fs_quota_statv fqs;
	288	int ret;
	289
	290	if (!sb->s_qcop->get_xstatev)
	291	return -ENOSYS;
	292
	293	memset(&fqs, 0, sizeof(fqs));
	294	if (copy_from_user(&fqs, addr, 1)) /* Just read qs_version */
	295	return -EFAULT;
	296
	297	/* If this kernel doesn't support user specified version, fail */
	298	switch (fqs.qs_version) {
	299	case FS_QSTATV_VERSION1:
	300	break;
	301	default:
	302	return -EINVAL;
	303	}
	304	ret = sb->s_qcop->get_xstatev(sb, &fqs);
	305	if (!ret && copy_to_user(addr, &fqs, sizeof(fqs)))
	306	return -EFAULT;
	307	return ret;
	308	}
	309
14bf61ff JK	310	/*
	311	* XFS defines BBTOB and BTOBB macros inside fs/xfs/ and we cannot move them
	312	* out of there as xfsprogs rely on definitions being in that header file. So
	313	* just define same functions here for quota purposes.
	314	*/
	315	#define XFS_BB_SHIFT 9
	316
	317	static inline u64 quota_bbtob(u64 blocks)
	318	{
	319	return blocks << XFS_BB_SHIFT;
	320	}
	321
	322	static inline u64 quota_btobb(u64 bytes)
	323	{
	324	return (bytes + (1 << XFS_BB_SHIFT) - 1) >> XFS_BB_SHIFT;
	325	}
	326
	327	static void copy_from_xfs_dqblk(struct qc_dqblk dst, struct fs_disk_quota src)
	328	{
	329	dst->d_spc_hardlimit = quota_bbtob(src->d_blk_hardlimit);
	330	dst->d_spc_softlimit = quota_bbtob(src->d_blk_softlimit);
	331	dst->d_ino_hardlimit = src->d_ino_hardlimit;
	332	dst->d_ino_softlimit = src->d_ino_softlimit;
	333	dst->d_space = quota_bbtob(src->d_bcount);
	334	dst->d_ino_count = src->d_icount;
	335	dst->d_ino_timer = src->d_itimer;
	336	dst->d_spc_timer = src->d_btimer;
	337	dst->d_ino_warns = src->d_iwarns;
	338	dst->d_spc_warns = src->d_bwarns;
	339	dst->d_rt_spc_hardlimit = quota_bbtob(src->d_rtb_hardlimit);
	340	dst->d_rt_spc_softlimit = quota_bbtob(src->d_rtb_softlimit);
	341	dst->d_rt_space = quota_bbtob(src->d_rtbcount);
	342	dst->d_rt_spc_timer = src->d_rtbtimer;
	343	dst->d_rt_spc_warns = src->d_rtbwarns;
	344	dst->d_fieldmask = 0;
	345	if (src->d_fieldmask & FS_DQ_ISOFT)
	346	dst->d_fieldmask \|= QC_INO_SOFT;
	347	if (src->d_fieldmask & FS_DQ_IHARD)
	348	dst->d_fieldmask \|= QC_INO_HARD;
	349	if (src->d_fieldmask & FS_DQ_BSOFT)
	350	dst->d_fieldmask \|= QC_SPC_SOFT;
	351	if (src->d_fieldmask & FS_DQ_BHARD)
	352	dst->d_fieldmask \|= QC_SPC_HARD;
	353	if (src->d_fieldmask & FS_DQ_RTBSOFT)
	354	dst->d_fieldmask \|= QC_RT_SPC_SOFT;
	355	if (src->d_fieldmask & FS_DQ_RTBHARD)
	356	dst->d_fieldmask \|= QC_RT_SPC_HARD;
	357	if (src->d_fieldmask & FS_DQ_BTIMER)
	358	dst->d_fieldmask \|= QC_SPC_TIMER;
	359	if (src->d_fieldmask & FS_DQ_ITIMER)
	360	dst->d_fieldmask \|= QC_INO_TIMER;
	361	if (src->d_fieldmask & FS_DQ_RTBTIMER)
	362	dst->d_fieldmask \|= QC_RT_SPC_TIMER;
	363	if (src->d_fieldmask & FS_DQ_BWARNS)
	364	dst->d_fieldmask \|= QC_SPC_WARNS;
	365	if (src->d_fieldmask & FS_DQ_IWARNS)
	366	dst->d_fieldmask \|= QC_INO_WARNS;
	367	if (src->d_fieldmask & FS_DQ_RTBWARNS)
	368	dst->d_fieldmask \|= QC_RT_SPC_WARNS;
	369	if (src->d_fieldmask & FS_DQ_BCOUNT)
	370	dst->d_fieldmask \|= QC_SPACE;
	371	if (src->d_fieldmask & FS_DQ_ICOUNT)
	372	dst->d_fieldmask \|= QC_INO_COUNT;
	373	if (src->d_fieldmask & FS_DQ_RTBCOUNT)
374	dst->d_fieldmask \|= QC_RT_SPACE;
375	}
376
c411e5f6 CH	377	static int quota_setxquota(struct super_block *sb, int type, qid_t id,
	378	void __user *addr)
	379	{
	380	struct fs_disk_quota fdq;
14bf61ff	381	struct qc_dqblk qdq;
74a8a103	382	struct kqid qid;
c411e5f6 CH	383
	384	if (copy_from_user(&fdq, addr, sizeof(fdq)))
	385	return -EFAULT;
c472b432	386	if (!sb->s_qcop->set_dqblk)
f450d4fe	387	return -ENOSYS;
74a8a103 EB	388	qid = make_kqid(current_user_ns(), type, id);
	389	if (!qid_valid(qid))
	390	return -EINVAL;
14bf61ff JK	391	copy_from_xfs_dqblk(&qdq, &fdq);
	392	return sb->s_qcop->set_dqblk(sb, qid, &qdq);
	393	}
	394
	395	static void copy_to_xfs_dqblk(struct fs_disk_quota dst, struct qc_dqblk src,
	396	int type, qid_t id)
	397	{
	398	memset(dst, 0, sizeof(*dst));
	399	dst->d_version = FS_DQUOT_VERSION;
	400	dst->d_id = id;
	401	if (type == USRQUOTA)
	402	dst->d_flags = FS_USER_QUOTA;
	403	else if (type == PRJQUOTA)
	404	dst->d_flags = FS_PROJ_QUOTA;
	405	else
	406	dst->d_flags = FS_GROUP_QUOTA;
	407	dst->d_blk_hardlimit = quota_btobb(src->d_spc_hardlimit);
	408	dst->d_blk_softlimit = quota_btobb(src->d_spc_softlimit);
	409	dst->d_ino_hardlimit = src->d_ino_hardlimit;
	410	dst->d_ino_softlimit = src->d_ino_softlimit;
	411	dst->d_bcount = quota_btobb(src->d_space);
	412	dst->d_icount = src->d_ino_count;
	413	dst->d_itimer = src->d_ino_timer;
	414	dst->d_btimer = src->d_spc_timer;
	415	dst->d_iwarns = src->d_ino_warns;
	416	dst->d_bwarns = src->d_spc_warns;
	417	dst->d_rtb_hardlimit = quota_btobb(src->d_rt_spc_hardlimit);
	418	dst->d_rtb_softlimit = quota_btobb(src->d_rt_spc_softlimit);
	419	dst->d_rtbcount = quota_btobb(src->d_rt_space);
	420	dst->d_rtbtimer = src->d_rt_spc_timer;
	421	dst->d_rtbwarns = src->d_rt_spc_warns;
c411e5f6 CH	422	}
	423
	424	static int quota_getxquota(struct super_block *sb, int type, qid_t id,
	425	void __user *addr)
	426	{
	427	struct fs_disk_quota fdq;
14bf61ff	428	struct qc_dqblk qdq;
74a8a103	429	struct kqid qid;
c411e5f6 CH	430	int ret;
c411e5f6 CH	431
b9b2dd36	432	if (!sb->s_qcop->get_dqblk)
f450d4fe	433	return -ENOSYS;
74a8a103 EB	434	qid = make_kqid(current_user_ns(), type, id);
	435	if (!qid_valid(qid))
	436	return -EINVAL;
14bf61ff JK	437	ret = sb->s_qcop->get_dqblk(sb, qid, &qdq);
	438	if (ret)
	439	return ret;
	440	copy_to_xfs_dqblk(&fdq, &qdq, type, id);
	441	if (copy_to_user(addr, &fdq, sizeof(fdq)))
c411e5f6 CH	442	return -EFAULT;
	443	return ret;
	444	}
	445
9da93f9b ES	446	static int quota_rmxquota(struct super_block sb, void __user addr)
	447	{
	448	__u32 flags;
	449
	450	if (copy_from_user(&flags, addr, sizeof(flags)))
	451	return -EFAULT;
	452	if (!sb->s_qcop->rm_xquota)
	453	return -ENOSYS;
	454	return sb->s_qcop->rm_xquota(sb, flags);
	455	}
	456
c411e5f6 CH	457	/* Copy parameters and call proper function */
c411e5f6 CH	458	static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id,
f00c9e44	459	void __user addr, struct path path)
c411e5f6	460	{
c988afb5 CH	461	int ret;
	462
	463	if (type >= (XQM_COMMAND(cmd) ? XQM_MAXQUOTAS : MAXQUOTAS))
	464	return -EINVAL;
2c5f648a JK	465	/*
	466	* Quota not supported on this fs? Check this before s_quota_types
	467	* since they needn't be set if quota is not supported at all.
	468	*/
c988afb5 CH	469	if (!sb->s_qcop)
c988afb5 CH	470	return -ENOSYS;
2c5f648a JK	471	if (!(sb->s_quota_types & (1 << type)))
2c5f648a JK	472	return -EINVAL;
c988afb5 CH	473
	474	ret = check_quotactl_permission(sb, type, cmd, id);
	475	if (ret < 0)
	476	return ret;
	477
c411e5f6 CH	478	switch (cmd) {
c411e5f6 CH	479	case Q_QUOTAON:
f00c9e44	480	return quota_quotaon(sb, type, cmd, id, path);
c411e5f6	481	case Q_QUOTAOFF:
d3b86324	482	return quota_quotaoff(sb, type);
c411e5f6 CH	483	case Q_GETFMT:
	484	return quota_getfmt(sb, type, addr);
	485	case Q_GETINFO:
	486	return quota_getinfo(sb, type, addr);
	487	case Q_SETINFO:
	488	return quota_setinfo(sb, type, addr);
	489	case Q_GETQUOTA:
	490	return quota_getquota(sb, type, id, addr);
	491	case Q_SETQUOTA:
	492	return quota_setquota(sb, type, id, addr);
	493	case Q_SYNC:
6ae09575 CH	494	if (!sb->s_qcop->quota_sync)
6ae09575 CH	495	return -ENOSYS;
ceed1723	496	return sb->s_qcop->quota_sync(sb, type);
c411e5f6	497	case Q_XQUOTAON:
38e478c4	498	return quota_enable(sb, addr);
c411e5f6	499	case Q_XQUOTAOFF:
38e478c4	500	return quota_disable(sb, addr);
9da93f9b ES	501	case Q_XQUOTARM:
9da93f9b ES	502	return quota_rmxquota(sb, addr);
c411e5f6 CH	503	case Q_XGETQSTAT:
c411e5f6 CH	504	return quota_getxstate(sb, addr);
af30cb44 CS	505	case Q_XGETQSTATV:
af30cb44 CS	506	return quota_getxstatev(sb, addr);
c411e5f6 CH	507	case Q_XSETQLIM:
	508	return quota_setxquota(sb, type, id, addr);
	509	case Q_XGETQUOTA:
	510	return quota_getxquota(sb, type, id, addr);
	511	case Q_XQUOTASYNC:
8c4e4acd CH	512	if (sb->s_flags & MS_RDONLY)
8c4e4acd CH	513	return -EROFS;
4b217ed9	514	/* XFS quotas are fully coherent now, making this call a noop */
8c4e4acd	515	return 0;
c411e5f6	516	default:
f450d4fe	517	return -EINVAL;
1da177e4	518	}
1da177e4 LT	519	}
1da177e4 LT	520
56df1278 LJ	521	#ifdef CONFIG_BLOCK
56df1278 LJ	522
dcdbed85 JK	523	/* Return 1 if 'cmd' will block on frozen filesystem */
	524	static int quotactl_cmd_write(int cmd)
	525	{
	526	switch (cmd) {
	527	case Q_GETFMT:
	528	case Q_GETINFO:
	529	case Q_SYNC:
	530	case Q_XGETQSTAT:
af30cb44	531	case Q_XGETQSTATV:
dcdbed85 JK	532	case Q_XGETQUOTA:
	533	case Q_XQUOTASYNC:
	534	return 0;
	535	}
	536	return 1;
	537	}
	538
56df1278 LJ	539	#endif /* CONFIG_BLOCK */
56df1278 LJ	540
9361401e DH	541	/*
	542	* look up a superblock on which quota ops will be performed
	543	* - use the name of a block device to find the superblock thereon
	544	*/
dcdbed85	545	static struct super_block quotactl_block(const char __user special, int cmd)
9361401e DH	546	{
	547	#ifdef CONFIG_BLOCK
	548	struct block_device *bdev;
	549	struct super_block *sb;
91a27b2a	550	struct filename *tmp = getname(special);
9361401e DH	551
9361401e DH	552	if (IS_ERR(tmp))
e231c2ee	553	return ERR_CAST(tmp);
91a27b2a	554	bdev = lookup_bdev(tmp->name);
9361401e DH	555	putname(tmp);
9361401e DH	556	if (IS_ERR(bdev))
e231c2ee	557	return ERR_CAST(bdev);
dcdbed85 JK	558	if (quotactl_cmd_write(cmd))
	559	sb = get_super_thawed(bdev);
	560	else
	561	sb = get_super(bdev);
9361401e DH	562	bdput(bdev);
	563	if (!sb)
	564	return ERR_PTR(-ENODEV);
	565
	566	return sb;
	567	#else
	568	return ERR_PTR(-ENODEV);
	569	#endif
	570	}
	571
1da177e4 LT	572	/*
	573	* This is the system call interface. This communicates with
	574	* the user-level programs. Currently this only supports diskquota
	575	* calls. Maybe we need to add the process quotas etc. in the future,
	576	* but we probably should use rlimits for that.
	577	*/
3cdad428 HC	578	SYSCALL_DEFINE4(quotactl, unsigned int, cmd, const char __user *, special,
3cdad428 HC	579	qid_t, id, void __user *, addr)
1da177e4 LT	580	{
	581	uint cmds, type;
	582	struct super_block *sb = NULL;
f00c9e44	583	struct path path, *pathp = NULL;
1da177e4 LT	584	int ret;
	585
	586	cmds = cmd >> SUBCMDSHIFT;
	587	type = cmd & SUBCMDMASK;
	588
6ae09575 CH	589	/*
	590	* As a special case Q_SYNC can be called without a specific device.
	591	* It will iterate all superblocks that have quota enabled and call
	592	* the sync action on each of them.
	593	*/
	594	if (!special) {
	595	if (cmds == Q_SYNC)
	596	return quota_sync_all(type);
	597	return -ENODEV;
1da177e4 LT	598	}
1da177e4 LT	599
f00c9e44 JK	600	/*
	601	* Path for quotaon has to be resolved before grabbing superblock
	602	* because that gets s_umount sem which is also possibly needed by path
	603	* resolution (think about autofs) and thus deadlocks could arise.
	604	*/
	605	if (cmds == Q_QUOTAON) {
815d405c	606	ret = user_path_at(AT_FDCWD, addr, LOOKUP_FOLLOW\|LOOKUP_AUTOMOUNT, &path);
f00c9e44 JK	607	if (ret)
	608	pathp = ERR_PTR(ret);
	609	else
	610	pathp = &path;
	611	}
	612
dcdbed85	613	sb = quotactl_block(special, cmds);
0aaa6188 JK	614	if (IS_ERR(sb)) {
	615	ret = PTR_ERR(sb);
	616	goto out;
	617	}
6ae09575	618
f00c9e44	619	ret = do_quotactl(sb, type, cmds, id, addr, pathp);
1da177e4	620
6ae09575	621	drop_super(sb);
0aaa6188	622	out:
f00c9e44 JK	623	if (pathp && !IS_ERR(pathp))
f00c9e44 JK	624	path_put(pathp);
1da177e4 LT	625	return ret;
1da177e4 LT	626	}