1884d179dSJan Kara /* 2884d179dSJan Kara * Quota code necessary even when VFS quota support is not compiled 3884d179dSJan Kara * into the kernel. The interesting stuff is over in dquot.c, here 4884d179dSJan Kara * we have symbols for initial quotactl(2) handling, the sysctl(2) 5884d179dSJan Kara * variables, etc - things needed even when quota support disabled. 6884d179dSJan Kara */ 7884d179dSJan Kara 8884d179dSJan Kara #include <linux/fs.h> 9884d179dSJan Kara #include <linux/namei.h> 10884d179dSJan Kara #include <linux/slab.h> 11884d179dSJan Kara #include <asm/current.h> 12f3da9310SJeff Liu #include <linux/uaccess.h> 13884d179dSJan Kara #include <linux/kernel.h> 14884d179dSJan Kara #include <linux/security.h> 15884d179dSJan Kara #include <linux/syscalls.h> 16884d179dSJan Kara #include <linux/capability.h> 17884d179dSJan Kara #include <linux/quotaops.h> 18884d179dSJan Kara #include <linux/types.h> 198c4e4acdSChristoph Hellwig #include <linux/writeback.h> 20884d179dSJan Kara 21c988afb5SChristoph Hellwig static int check_quotactl_permission(struct super_block *sb, int type, int cmd, 22268157baSJan Kara qid_t id) 23884d179dSJan Kara { 24c988afb5SChristoph Hellwig switch (cmd) { 25c988afb5SChristoph Hellwig /* these commands do not require any special privilegues */ 26c988afb5SChristoph Hellwig case Q_GETFMT: 27c988afb5SChristoph Hellwig case Q_SYNC: 28c988afb5SChristoph Hellwig case Q_GETINFO: 29c988afb5SChristoph Hellwig case Q_XGETQSTAT: 30af30cb44SChandra Seetharaman case Q_XGETQSTATV: 31c988afb5SChristoph Hellwig case Q_XQUOTASYNC: 32c988afb5SChristoph Hellwig break; 33c988afb5SChristoph Hellwig /* allow to query information for dquots we "own" */ 34c988afb5SChristoph Hellwig case Q_GETQUOTA: 35c988afb5SChristoph Hellwig case Q_XGETQUOTA: 3674a8a103SEric W. Biederman if ((type == USRQUOTA && uid_eq(current_euid(), make_kuid(current_user_ns(), id))) || 3774a8a103SEric W. Biederman (type == GRPQUOTA && in_egroup_p(make_kgid(current_user_ns(), id)))) 38c988afb5SChristoph Hellwig break; 39c988afb5SChristoph Hellwig /*FALLTHROUGH*/ 40c988afb5SChristoph Hellwig default: 41884d179dSJan Kara if (!capable(CAP_SYS_ADMIN)) 42884d179dSJan Kara return -EPERM; 43884d179dSJan Kara } 44884d179dSJan Kara 45c988afb5SChristoph Hellwig return security_quotactl(cmd, type, id, sb); 46884d179dSJan Kara } 47884d179dSJan Kara 4801a05b33SAl Viro static void quota_sync_one(struct super_block *sb, void *arg) 4901a05b33SAl Viro { 502c5f648aSJan Kara int type = *(int *)arg; 512c5f648aSJan Kara 522c5f648aSJan Kara if (sb->s_qcop && sb->s_qcop->quota_sync && 532c5f648aSJan Kara (sb->s_quota_types & (1 << type))) 542c5f648aSJan Kara sb->s_qcop->quota_sync(sb, type); 5501a05b33SAl Viro } 5601a05b33SAl Viro 576ae09575SChristoph Hellwig static int quota_sync_all(int type) 58884d179dSJan Kara { 596ae09575SChristoph Hellwig int ret; 606ae09575SChristoph Hellwig 616ae09575SChristoph Hellwig if (type >= MAXQUOTAS) 626ae09575SChristoph Hellwig return -EINVAL; 636ae09575SChristoph Hellwig ret = security_quotactl(Q_SYNC, type, 0, NULL); 6401a05b33SAl Viro if (!ret) 6501a05b33SAl Viro iterate_supers(quota_sync_one, &type); 666ae09575SChristoph Hellwig return ret; 67884d179dSJan Kara } 68884d179dSJan Kara 69d3b86324SJan Kara unsigned int qtype_enforce_flag(int type) 70d3b86324SJan Kara { 71d3b86324SJan Kara switch (type) { 72d3b86324SJan Kara case USRQUOTA: 73d3b86324SJan Kara return FS_QUOTA_UDQ_ENFD; 74d3b86324SJan Kara case GRPQUOTA: 75d3b86324SJan Kara return FS_QUOTA_GDQ_ENFD; 76d3b86324SJan Kara case PRJQUOTA: 77d3b86324SJan Kara return FS_QUOTA_PDQ_ENFD; 78d3b86324SJan Kara } 79d3b86324SJan Kara return 0; 80d3b86324SJan Kara } 81d3b86324SJan Kara 82c411e5f6SChristoph Hellwig static int quota_quotaon(struct super_block *sb, int type, int cmd, qid_t id, 83f00c9e44SJan Kara struct path *path) 84884d179dSJan Kara { 85aaa3daedSJan Kara if (!sb->s_qcop->quota_on && !sb->s_qcop->quota_enable) 86f00c9e44SJan Kara return -ENOSYS; 87d3b86324SJan Kara if (sb->s_qcop->quota_enable) 88d3b86324SJan Kara return sb->s_qcop->quota_enable(sb, qtype_enforce_flag(type)); 89f00c9e44SJan Kara if (IS_ERR(path)) 90f00c9e44SJan Kara return PTR_ERR(path); 91f00c9e44SJan Kara return sb->s_qcop->quota_on(sb, type, id, path); 92884d179dSJan Kara } 93884d179dSJan Kara 94d3b86324SJan Kara static int quota_quotaoff(struct super_block *sb, int type) 95d3b86324SJan Kara { 96d3b86324SJan Kara if (!sb->s_qcop->quota_off && !sb->s_qcop->quota_disable) 97d3b86324SJan Kara return -ENOSYS; 98d3b86324SJan Kara if (sb->s_qcop->quota_disable) 99d3b86324SJan Kara return sb->s_qcop->quota_disable(sb, qtype_enforce_flag(type)); 100d3b86324SJan Kara return sb->s_qcop->quota_off(sb, type); 101d3b86324SJan Kara } 102d3b86324SJan Kara 103c411e5f6SChristoph Hellwig static int quota_getfmt(struct super_block *sb, int type, void __user *addr) 104c411e5f6SChristoph Hellwig { 105884d179dSJan Kara __u32 fmt; 106884d179dSJan Kara 107606cdccaSNiu Yawei mutex_lock(&sb_dqopt(sb)->dqonoff_mutex); 108884d179dSJan Kara if (!sb_has_quota_active(sb, type)) { 109606cdccaSNiu Yawei mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 110884d179dSJan Kara return -ESRCH; 111884d179dSJan Kara } 112884d179dSJan Kara fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id; 113606cdccaSNiu Yawei mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex); 114884d179dSJan Kara if (copy_to_user(addr, &fmt, sizeof(fmt))) 115884d179dSJan Kara return -EFAULT; 116884d179dSJan Kara return 0; 117884d179dSJan Kara } 118c411e5f6SChristoph Hellwig 119c411e5f6SChristoph Hellwig static int quota_getinfo(struct super_block *sb, int type, void __user *addr) 120c411e5f6SChristoph Hellwig { 121*0a240339SJan Kara struct qc_state state; 122*0a240339SJan Kara struct qc_type_state *tstate; 123*0a240339SJan Kara struct if_dqinfo uinfo; 124c411e5f6SChristoph Hellwig int ret; 125884d179dSJan Kara 126*0a240339SJan Kara /* This checks whether qc_state has enough entries... */ 127*0a240339SJan Kara BUILD_BUG_ON(MAXQUOTAS > XQM_MAXQUOTAS); 128*0a240339SJan Kara if (!sb->s_qcop->get_state) 129f450d4feSChristoph Hellwig return -ENOSYS; 130*0a240339SJan Kara ret = sb->s_qcop->get_state(sb, &state); 131*0a240339SJan Kara if (ret) 132*0a240339SJan Kara return ret; 133*0a240339SJan Kara tstate = state.s_state + type; 134*0a240339SJan Kara if (!(tstate->flags & QCI_ACCT_ENABLED)) 135*0a240339SJan Kara return -ESRCH; 136*0a240339SJan Kara memset(&uinfo, 0, sizeof(uinfo)); 137*0a240339SJan Kara uinfo.dqi_bgrace = tstate->spc_timelimit; 138*0a240339SJan Kara uinfo.dqi_igrace = tstate->ino_timelimit; 139*0a240339SJan Kara if (tstate->flags & QCI_SYSFILE) 140*0a240339SJan Kara uinfo.dqi_flags |= DQF_SYS_FILE; 141*0a240339SJan Kara if (tstate->flags & QCI_ROOT_SQUASH) 142*0a240339SJan Kara uinfo.dqi_flags |= DQF_ROOT_SQUASH; 143*0a240339SJan Kara uinfo.dqi_valid = IIF_ALL; 144*0a240339SJan Kara if (!ret && copy_to_user(addr, &uinfo, sizeof(uinfo))) 145884d179dSJan Kara return -EFAULT; 146c411e5f6SChristoph Hellwig return ret; 147884d179dSJan Kara } 148c411e5f6SChristoph Hellwig 149c411e5f6SChristoph Hellwig static int quota_setinfo(struct super_block *sb, int type, void __user *addr) 150c411e5f6SChristoph Hellwig { 151884d179dSJan Kara struct if_dqinfo info; 152884d179dSJan Kara 153884d179dSJan Kara if (copy_from_user(&info, addr, sizeof(info))) 154884d179dSJan Kara return -EFAULT; 155f450d4feSChristoph Hellwig if (!sb->s_qcop->set_info) 156f450d4feSChristoph Hellwig return -ENOSYS; 157884d179dSJan Kara return sb->s_qcop->set_info(sb, type, &info); 158884d179dSJan Kara } 159c411e5f6SChristoph Hellwig 16014bf61ffSJan Kara static inline qsize_t qbtos(qsize_t blocks) 16114bf61ffSJan Kara { 16214bf61ffSJan Kara return blocks << QIF_DQBLKSIZE_BITS; 16314bf61ffSJan Kara } 16414bf61ffSJan Kara 16514bf61ffSJan Kara static inline qsize_t stoqb(qsize_t space) 16614bf61ffSJan Kara { 16714bf61ffSJan Kara return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS; 16814bf61ffSJan Kara } 16914bf61ffSJan Kara 17014bf61ffSJan Kara static void copy_to_if_dqblk(struct if_dqblk *dst, struct qc_dqblk *src) 171b9b2dd36SChristoph Hellwig { 17218da65e7SDan Carpenter memset(dst, 0, sizeof(*dst)); 17314bf61ffSJan Kara dst->dqb_bhardlimit = stoqb(src->d_spc_hardlimit); 17414bf61ffSJan Kara dst->dqb_bsoftlimit = stoqb(src->d_spc_softlimit); 17514bf61ffSJan Kara dst->dqb_curspace = src->d_space; 176b9b2dd36SChristoph Hellwig dst->dqb_ihardlimit = src->d_ino_hardlimit; 177b9b2dd36SChristoph Hellwig dst->dqb_isoftlimit = src->d_ino_softlimit; 17814bf61ffSJan Kara dst->dqb_curinodes = src->d_ino_count; 17914bf61ffSJan Kara dst->dqb_btime = src->d_spc_timer; 18014bf61ffSJan Kara dst->dqb_itime = src->d_ino_timer; 181b9b2dd36SChristoph Hellwig dst->dqb_valid = QIF_ALL; 182b9b2dd36SChristoph Hellwig } 183b9b2dd36SChristoph Hellwig 184c411e5f6SChristoph Hellwig static int quota_getquota(struct super_block *sb, int type, qid_t id, 185c411e5f6SChristoph Hellwig void __user *addr) 186c411e5f6SChristoph Hellwig { 18774a8a103SEric W. Biederman struct kqid qid; 18814bf61ffSJan Kara struct qc_dqblk fdq; 189884d179dSJan Kara struct if_dqblk idq; 190c411e5f6SChristoph Hellwig int ret; 191884d179dSJan Kara 192f450d4feSChristoph Hellwig if (!sb->s_qcop->get_dqblk) 193f450d4feSChristoph Hellwig return -ENOSYS; 19474a8a103SEric W. Biederman qid = make_kqid(current_user_ns(), type, id); 19574a8a103SEric W. Biederman if (!qid_valid(qid)) 19674a8a103SEric W. Biederman return -EINVAL; 19774a8a103SEric W. Biederman ret = sb->s_qcop->get_dqblk(sb, qid, &fdq); 198268157baSJan Kara if (ret) 199884d179dSJan Kara return ret; 200b9b2dd36SChristoph Hellwig copy_to_if_dqblk(&idq, &fdq); 201884d179dSJan Kara if (copy_to_user(addr, &idq, sizeof(idq))) 202884d179dSJan Kara return -EFAULT; 203884d179dSJan Kara return 0; 204884d179dSJan Kara } 205c411e5f6SChristoph Hellwig 20614bf61ffSJan Kara static void copy_from_if_dqblk(struct qc_dqblk *dst, struct if_dqblk *src) 207c472b432SChristoph Hellwig { 20814bf61ffSJan Kara dst->d_spc_hardlimit = qbtos(src->dqb_bhardlimit); 20914bf61ffSJan Kara dst->d_spc_softlimit = qbtos(src->dqb_bsoftlimit); 21014bf61ffSJan Kara dst->d_space = src->dqb_curspace; 211c472b432SChristoph Hellwig dst->d_ino_hardlimit = src->dqb_ihardlimit; 212c472b432SChristoph Hellwig dst->d_ino_softlimit = src->dqb_isoftlimit; 21314bf61ffSJan Kara dst->d_ino_count = src->dqb_curinodes; 21414bf61ffSJan Kara dst->d_spc_timer = src->dqb_btime; 21514bf61ffSJan Kara dst->d_ino_timer = src->dqb_itime; 216c472b432SChristoph Hellwig 217c472b432SChristoph Hellwig dst->d_fieldmask = 0; 218c472b432SChristoph Hellwig if (src->dqb_valid & QIF_BLIMITS) 21914bf61ffSJan Kara dst->d_fieldmask |= QC_SPC_SOFT | QC_SPC_HARD; 220c472b432SChristoph Hellwig if (src->dqb_valid & QIF_SPACE) 22114bf61ffSJan Kara dst->d_fieldmask |= QC_SPACE; 222c472b432SChristoph Hellwig if (src->dqb_valid & QIF_ILIMITS) 22314bf61ffSJan Kara dst->d_fieldmask |= QC_INO_SOFT | QC_INO_HARD; 224c472b432SChristoph Hellwig if (src->dqb_valid & QIF_INODES) 22514bf61ffSJan Kara dst->d_fieldmask |= QC_INO_COUNT; 226c472b432SChristoph Hellwig if (src->dqb_valid & QIF_BTIME) 22714bf61ffSJan Kara dst->d_fieldmask |= QC_SPC_TIMER; 228c472b432SChristoph Hellwig if (src->dqb_valid & QIF_ITIME) 22914bf61ffSJan Kara dst->d_fieldmask |= QC_INO_TIMER; 230c472b432SChristoph Hellwig } 231c472b432SChristoph Hellwig 232c411e5f6SChristoph Hellwig static int quota_setquota(struct super_block *sb, int type, qid_t id, 233c411e5f6SChristoph Hellwig void __user *addr) 234c411e5f6SChristoph Hellwig { 23514bf61ffSJan Kara struct qc_dqblk fdq; 236884d179dSJan Kara struct if_dqblk idq; 23774a8a103SEric W. Biederman struct kqid qid; 238884d179dSJan Kara 239884d179dSJan Kara if (copy_from_user(&idq, addr, sizeof(idq))) 240884d179dSJan Kara return -EFAULT; 241f450d4feSChristoph Hellwig if (!sb->s_qcop->set_dqblk) 242f450d4feSChristoph Hellwig return -ENOSYS; 24374a8a103SEric W. Biederman qid = make_kqid(current_user_ns(), type, id); 24474a8a103SEric W. Biederman if (!qid_valid(qid)) 24574a8a103SEric W. Biederman return -EINVAL; 246c472b432SChristoph Hellwig copy_from_if_dqblk(&fdq, &idq); 24774a8a103SEric W. Biederman return sb->s_qcop->set_dqblk(sb, qid, &fdq); 248884d179dSJan Kara } 249884d179dSJan Kara 25038e478c4SJan Kara static int quota_enable(struct super_block *sb, void __user *addr) 251c411e5f6SChristoph Hellwig { 252884d179dSJan Kara __u32 flags; 253884d179dSJan Kara 254884d179dSJan Kara if (copy_from_user(&flags, addr, sizeof(flags))) 255884d179dSJan Kara return -EFAULT; 25638e478c4SJan Kara if (!sb->s_qcop->quota_enable) 257f450d4feSChristoph Hellwig return -ENOSYS; 25838e478c4SJan Kara return sb->s_qcop->quota_enable(sb, flags); 25938e478c4SJan Kara } 26038e478c4SJan Kara 26138e478c4SJan Kara static int quota_disable(struct super_block *sb, void __user *addr) 26238e478c4SJan Kara { 26338e478c4SJan Kara __u32 flags; 26438e478c4SJan Kara 26538e478c4SJan Kara if (copy_from_user(&flags, addr, sizeof(flags))) 26638e478c4SJan Kara return -EFAULT; 26738e478c4SJan Kara if (!sb->s_qcop->quota_disable) 26838e478c4SJan Kara return -ENOSYS; 26938e478c4SJan Kara return sb->s_qcop->quota_disable(sb, flags); 270884d179dSJan Kara } 271884d179dSJan Kara 272c411e5f6SChristoph Hellwig static int quota_getxstate(struct super_block *sb, void __user *addr) 273c411e5f6SChristoph Hellwig { 274c411e5f6SChristoph Hellwig struct fs_quota_stat fqs; 275c411e5f6SChristoph Hellwig int ret; 276c411e5f6SChristoph Hellwig 277f450d4feSChristoph Hellwig if (!sb->s_qcop->get_xstate) 278f450d4feSChristoph Hellwig return -ENOSYS; 279c411e5f6SChristoph Hellwig ret = sb->s_qcop->get_xstate(sb, &fqs); 280c411e5f6SChristoph Hellwig if (!ret && copy_to_user(addr, &fqs, sizeof(fqs))) 281884d179dSJan Kara return -EFAULT; 282c411e5f6SChristoph Hellwig return ret; 283884d179dSJan Kara } 284c411e5f6SChristoph Hellwig 285af30cb44SChandra Seetharaman static int quota_getxstatev(struct super_block *sb, void __user *addr) 286af30cb44SChandra Seetharaman { 287af30cb44SChandra Seetharaman struct fs_quota_statv fqs; 288af30cb44SChandra Seetharaman int ret; 289af30cb44SChandra Seetharaman 290af30cb44SChandra Seetharaman if (!sb->s_qcop->get_xstatev) 291af30cb44SChandra Seetharaman return -ENOSYS; 292af30cb44SChandra Seetharaman 293af30cb44SChandra Seetharaman memset(&fqs, 0, sizeof(fqs)); 294af30cb44SChandra Seetharaman if (copy_from_user(&fqs, addr, 1)) /* Just read qs_version */ 295af30cb44SChandra Seetharaman return -EFAULT; 296af30cb44SChandra Seetharaman 297af30cb44SChandra Seetharaman /* If this kernel doesn't support user specified version, fail */ 298af30cb44SChandra Seetharaman switch (fqs.qs_version) { 299af30cb44SChandra Seetharaman case FS_QSTATV_VERSION1: 300af30cb44SChandra Seetharaman break; 301af30cb44SChandra Seetharaman default: 302af30cb44SChandra Seetharaman return -EINVAL; 303af30cb44SChandra Seetharaman } 304af30cb44SChandra Seetharaman ret = sb->s_qcop->get_xstatev(sb, &fqs); 305af30cb44SChandra Seetharaman if (!ret && copy_to_user(addr, &fqs, sizeof(fqs))) 306af30cb44SChandra Seetharaman return -EFAULT; 307af30cb44SChandra Seetharaman return ret; 308af30cb44SChandra Seetharaman } 309af30cb44SChandra Seetharaman 31014bf61ffSJan Kara /* 31114bf61ffSJan Kara * XFS defines BBTOB and BTOBB macros inside fs/xfs/ and we cannot move them 31214bf61ffSJan Kara * out of there as xfsprogs rely on definitions being in that header file. So 31314bf61ffSJan Kara * just define same functions here for quota purposes. 31414bf61ffSJan Kara */ 31514bf61ffSJan Kara #define XFS_BB_SHIFT 9 31614bf61ffSJan Kara 31714bf61ffSJan Kara static inline u64 quota_bbtob(u64 blocks) 31814bf61ffSJan Kara { 31914bf61ffSJan Kara return blocks << XFS_BB_SHIFT; 32014bf61ffSJan Kara } 32114bf61ffSJan Kara 32214bf61ffSJan Kara static inline u64 quota_btobb(u64 bytes) 32314bf61ffSJan Kara { 32414bf61ffSJan Kara return (bytes + (1 << XFS_BB_SHIFT) - 1) >> XFS_BB_SHIFT; 32514bf61ffSJan Kara } 32614bf61ffSJan Kara 32714bf61ffSJan Kara static void copy_from_xfs_dqblk(struct qc_dqblk *dst, struct fs_disk_quota *src) 32814bf61ffSJan Kara { 32914bf61ffSJan Kara dst->d_spc_hardlimit = quota_bbtob(src->d_blk_hardlimit); 33014bf61ffSJan Kara dst->d_spc_softlimit = quota_bbtob(src->d_blk_softlimit); 33114bf61ffSJan Kara dst->d_ino_hardlimit = src->d_ino_hardlimit; 33214bf61ffSJan Kara dst->d_ino_softlimit = src->d_ino_softlimit; 33314bf61ffSJan Kara dst->d_space = quota_bbtob(src->d_bcount); 33414bf61ffSJan Kara dst->d_ino_count = src->d_icount; 33514bf61ffSJan Kara dst->d_ino_timer = src->d_itimer; 33614bf61ffSJan Kara dst->d_spc_timer = src->d_btimer; 33714bf61ffSJan Kara dst->d_ino_warns = src->d_iwarns; 33814bf61ffSJan Kara dst->d_spc_warns = src->d_bwarns; 33914bf61ffSJan Kara dst->d_rt_spc_hardlimit = quota_bbtob(src->d_rtb_hardlimit); 34014bf61ffSJan Kara dst->d_rt_spc_softlimit = quota_bbtob(src->d_rtb_softlimit); 34114bf61ffSJan Kara dst->d_rt_space = quota_bbtob(src->d_rtbcount); 34214bf61ffSJan Kara dst->d_rt_spc_timer = src->d_rtbtimer; 34314bf61ffSJan Kara dst->d_rt_spc_warns = src->d_rtbwarns; 34414bf61ffSJan Kara dst->d_fieldmask = 0; 34514bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_ISOFT) 34614bf61ffSJan Kara dst->d_fieldmask |= QC_INO_SOFT; 34714bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_IHARD) 34814bf61ffSJan Kara dst->d_fieldmask |= QC_INO_HARD; 34914bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_BSOFT) 35014bf61ffSJan Kara dst->d_fieldmask |= QC_SPC_SOFT; 35114bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_BHARD) 35214bf61ffSJan Kara dst->d_fieldmask |= QC_SPC_HARD; 35314bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_RTBSOFT) 35414bf61ffSJan Kara dst->d_fieldmask |= QC_RT_SPC_SOFT; 35514bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_RTBHARD) 35614bf61ffSJan Kara dst->d_fieldmask |= QC_RT_SPC_HARD; 35714bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_BTIMER) 35814bf61ffSJan Kara dst->d_fieldmask |= QC_SPC_TIMER; 35914bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_ITIMER) 36014bf61ffSJan Kara dst->d_fieldmask |= QC_INO_TIMER; 36114bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_RTBTIMER) 36214bf61ffSJan Kara dst->d_fieldmask |= QC_RT_SPC_TIMER; 36314bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_BWARNS) 36414bf61ffSJan Kara dst->d_fieldmask |= QC_SPC_WARNS; 36514bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_IWARNS) 36614bf61ffSJan Kara dst->d_fieldmask |= QC_INO_WARNS; 36714bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_RTBWARNS) 36814bf61ffSJan Kara dst->d_fieldmask |= QC_RT_SPC_WARNS; 36914bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_BCOUNT) 37014bf61ffSJan Kara dst->d_fieldmask |= QC_SPACE; 37114bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_ICOUNT) 37214bf61ffSJan Kara dst->d_fieldmask |= QC_INO_COUNT; 37314bf61ffSJan Kara if (src->d_fieldmask & FS_DQ_RTBCOUNT) 37414bf61ffSJan Kara dst->d_fieldmask |= QC_RT_SPACE; 37514bf61ffSJan Kara } 37614bf61ffSJan Kara 377c411e5f6SChristoph Hellwig static int quota_setxquota(struct super_block *sb, int type, qid_t id, 378c411e5f6SChristoph Hellwig void __user *addr) 379c411e5f6SChristoph Hellwig { 380884d179dSJan Kara struct fs_disk_quota fdq; 38114bf61ffSJan Kara struct qc_dqblk qdq; 38274a8a103SEric W. Biederman struct kqid qid; 383884d179dSJan Kara 384884d179dSJan Kara if (copy_from_user(&fdq, addr, sizeof(fdq))) 385884d179dSJan Kara return -EFAULT; 386c472b432SChristoph Hellwig if (!sb->s_qcop->set_dqblk) 387f450d4feSChristoph Hellwig return -ENOSYS; 38874a8a103SEric W. Biederman qid = make_kqid(current_user_ns(), type, id); 38974a8a103SEric W. Biederman if (!qid_valid(qid)) 39074a8a103SEric W. Biederman return -EINVAL; 39114bf61ffSJan Kara copy_from_xfs_dqblk(&qdq, &fdq); 39214bf61ffSJan Kara return sb->s_qcop->set_dqblk(sb, qid, &qdq); 39314bf61ffSJan Kara } 39414bf61ffSJan Kara 39514bf61ffSJan Kara static void copy_to_xfs_dqblk(struct fs_disk_quota *dst, struct qc_dqblk *src, 39614bf61ffSJan Kara int type, qid_t id) 39714bf61ffSJan Kara { 39814bf61ffSJan Kara memset(dst, 0, sizeof(*dst)); 39914bf61ffSJan Kara dst->d_version = FS_DQUOT_VERSION; 40014bf61ffSJan Kara dst->d_id = id; 40114bf61ffSJan Kara if (type == USRQUOTA) 40214bf61ffSJan Kara dst->d_flags = FS_USER_QUOTA; 40314bf61ffSJan Kara else if (type == PRJQUOTA) 40414bf61ffSJan Kara dst->d_flags = FS_PROJ_QUOTA; 40514bf61ffSJan Kara else 40614bf61ffSJan Kara dst->d_flags = FS_GROUP_QUOTA; 40714bf61ffSJan Kara dst->d_blk_hardlimit = quota_btobb(src->d_spc_hardlimit); 40814bf61ffSJan Kara dst->d_blk_softlimit = quota_btobb(src->d_spc_softlimit); 40914bf61ffSJan Kara dst->d_ino_hardlimit = src->d_ino_hardlimit; 41014bf61ffSJan Kara dst->d_ino_softlimit = src->d_ino_softlimit; 41114bf61ffSJan Kara dst->d_bcount = quota_btobb(src->d_space); 41214bf61ffSJan Kara dst->d_icount = src->d_ino_count; 41314bf61ffSJan Kara dst->d_itimer = src->d_ino_timer; 41414bf61ffSJan Kara dst->d_btimer = src->d_spc_timer; 41514bf61ffSJan Kara dst->d_iwarns = src->d_ino_warns; 41614bf61ffSJan Kara dst->d_bwarns = src->d_spc_warns; 41714bf61ffSJan Kara dst->d_rtb_hardlimit = quota_btobb(src->d_rt_spc_hardlimit); 41814bf61ffSJan Kara dst->d_rtb_softlimit = quota_btobb(src->d_rt_spc_softlimit); 41914bf61ffSJan Kara dst->d_rtbcount = quota_btobb(src->d_rt_space); 42014bf61ffSJan Kara dst->d_rtbtimer = src->d_rt_spc_timer; 42114bf61ffSJan Kara dst->d_rtbwarns = src->d_rt_spc_warns; 422884d179dSJan Kara } 423c411e5f6SChristoph Hellwig 424c411e5f6SChristoph Hellwig static int quota_getxquota(struct super_block *sb, int type, qid_t id, 425c411e5f6SChristoph Hellwig void __user *addr) 426c411e5f6SChristoph Hellwig { 427884d179dSJan Kara struct fs_disk_quota fdq; 42814bf61ffSJan Kara struct qc_dqblk qdq; 42974a8a103SEric W. Biederman struct kqid qid; 430c411e5f6SChristoph Hellwig int ret; 431884d179dSJan Kara 432b9b2dd36SChristoph Hellwig if (!sb->s_qcop->get_dqblk) 433f450d4feSChristoph Hellwig return -ENOSYS; 43474a8a103SEric W. Biederman qid = make_kqid(current_user_ns(), type, id); 43574a8a103SEric W. Biederman if (!qid_valid(qid)) 43674a8a103SEric W. Biederman return -EINVAL; 43714bf61ffSJan Kara ret = sb->s_qcop->get_dqblk(sb, qid, &qdq); 43814bf61ffSJan Kara if (ret) 43914bf61ffSJan Kara return ret; 44014bf61ffSJan Kara copy_to_xfs_dqblk(&fdq, &qdq, type, id); 44114bf61ffSJan Kara if (copy_to_user(addr, &fdq, sizeof(fdq))) 442884d179dSJan Kara return -EFAULT; 443c411e5f6SChristoph Hellwig return ret; 444884d179dSJan Kara } 445c411e5f6SChristoph Hellwig 4469da93f9bSEric Sandeen static int quota_rmxquota(struct super_block *sb, void __user *addr) 4479da93f9bSEric Sandeen { 4489da93f9bSEric Sandeen __u32 flags; 4499da93f9bSEric Sandeen 4509da93f9bSEric Sandeen if (copy_from_user(&flags, addr, sizeof(flags))) 4519da93f9bSEric Sandeen return -EFAULT; 4529da93f9bSEric Sandeen if (!sb->s_qcop->rm_xquota) 4539da93f9bSEric Sandeen return -ENOSYS; 4549da93f9bSEric Sandeen return sb->s_qcop->rm_xquota(sb, flags); 4559da93f9bSEric Sandeen } 4569da93f9bSEric Sandeen 457c411e5f6SChristoph Hellwig /* Copy parameters and call proper function */ 458c411e5f6SChristoph Hellwig static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, 459f00c9e44SJan Kara void __user *addr, struct path *path) 460c411e5f6SChristoph Hellwig { 461c988afb5SChristoph Hellwig int ret; 462c988afb5SChristoph Hellwig 463c988afb5SChristoph Hellwig if (type >= (XQM_COMMAND(cmd) ? XQM_MAXQUOTAS : MAXQUOTAS)) 464c988afb5SChristoph Hellwig return -EINVAL; 4652c5f648aSJan Kara /* 4662c5f648aSJan Kara * Quota not supported on this fs? Check this before s_quota_types 4672c5f648aSJan Kara * since they needn't be set if quota is not supported at all. 4682c5f648aSJan Kara */ 469c988afb5SChristoph Hellwig if (!sb->s_qcop) 470c988afb5SChristoph Hellwig return -ENOSYS; 4712c5f648aSJan Kara if (!(sb->s_quota_types & (1 << type))) 4722c5f648aSJan Kara return -EINVAL; 473c988afb5SChristoph Hellwig 474c988afb5SChristoph Hellwig ret = check_quotactl_permission(sb, type, cmd, id); 475c988afb5SChristoph Hellwig if (ret < 0) 476c988afb5SChristoph Hellwig return ret; 477c988afb5SChristoph Hellwig 478c411e5f6SChristoph Hellwig switch (cmd) { 479c411e5f6SChristoph Hellwig case Q_QUOTAON: 480f00c9e44SJan Kara return quota_quotaon(sb, type, cmd, id, path); 481c411e5f6SChristoph Hellwig case Q_QUOTAOFF: 482d3b86324SJan Kara return quota_quotaoff(sb, type); 483c411e5f6SChristoph Hellwig case Q_GETFMT: 484c411e5f6SChristoph Hellwig return quota_getfmt(sb, type, addr); 485c411e5f6SChristoph Hellwig case Q_GETINFO: 486c411e5f6SChristoph Hellwig return quota_getinfo(sb, type, addr); 487c411e5f6SChristoph Hellwig case Q_SETINFO: 488c411e5f6SChristoph Hellwig return quota_setinfo(sb, type, addr); 489c411e5f6SChristoph Hellwig case Q_GETQUOTA: 490c411e5f6SChristoph Hellwig return quota_getquota(sb, type, id, addr); 491c411e5f6SChristoph Hellwig case Q_SETQUOTA: 492c411e5f6SChristoph Hellwig return quota_setquota(sb, type, id, addr); 493c411e5f6SChristoph Hellwig case Q_SYNC: 494f450d4feSChristoph Hellwig if (!sb->s_qcop->quota_sync) 495f450d4feSChristoph Hellwig return -ENOSYS; 496ceed1723SJan Kara return sb->s_qcop->quota_sync(sb, type); 497c411e5f6SChristoph Hellwig case Q_XQUOTAON: 49838e478c4SJan Kara return quota_enable(sb, addr); 499c411e5f6SChristoph Hellwig case Q_XQUOTAOFF: 50038e478c4SJan Kara return quota_disable(sb, addr); 5019da93f9bSEric Sandeen case Q_XQUOTARM: 5029da93f9bSEric Sandeen return quota_rmxquota(sb, addr); 503c411e5f6SChristoph Hellwig case Q_XGETQSTAT: 504c411e5f6SChristoph Hellwig return quota_getxstate(sb, addr); 505af30cb44SChandra Seetharaman case Q_XGETQSTATV: 506af30cb44SChandra Seetharaman return quota_getxstatev(sb, addr); 507c411e5f6SChristoph Hellwig case Q_XSETQLIM: 508c411e5f6SChristoph Hellwig return quota_setxquota(sb, type, id, addr); 509c411e5f6SChristoph Hellwig case Q_XGETQUOTA: 510c411e5f6SChristoph Hellwig return quota_getxquota(sb, type, id, addr); 511884d179dSJan Kara case Q_XQUOTASYNC: 5128c4e4acdSChristoph Hellwig if (sb->s_flags & MS_RDONLY) 5138c4e4acdSChristoph Hellwig return -EROFS; 5144b217ed9SChristoph Hellwig /* XFS quotas are fully coherent now, making this call a noop */ 5158c4e4acdSChristoph Hellwig return 0; 516884d179dSJan Kara default: 517f450d4feSChristoph Hellwig return -EINVAL; 518884d179dSJan Kara } 519884d179dSJan Kara } 520884d179dSJan Kara 52156df1278SLee Jones #ifdef CONFIG_BLOCK 52256df1278SLee Jones 523dcdbed85SJan Kara /* Return 1 if 'cmd' will block on frozen filesystem */ 524dcdbed85SJan Kara static int quotactl_cmd_write(int cmd) 525dcdbed85SJan Kara { 526dcdbed85SJan Kara switch (cmd) { 527dcdbed85SJan Kara case Q_GETFMT: 528dcdbed85SJan Kara case Q_GETINFO: 529dcdbed85SJan Kara case Q_SYNC: 530dcdbed85SJan Kara case Q_XGETQSTAT: 531af30cb44SChandra Seetharaman case Q_XGETQSTATV: 532dcdbed85SJan Kara case Q_XGETQUOTA: 533dcdbed85SJan Kara case Q_XQUOTASYNC: 534dcdbed85SJan Kara return 0; 535dcdbed85SJan Kara } 536dcdbed85SJan Kara return 1; 537dcdbed85SJan Kara } 538dcdbed85SJan Kara 53956df1278SLee Jones #endif /* CONFIG_BLOCK */ 54056df1278SLee Jones 541884d179dSJan Kara /* 542884d179dSJan Kara * look up a superblock on which quota ops will be performed 543884d179dSJan Kara * - use the name of a block device to find the superblock thereon 544884d179dSJan Kara */ 545dcdbed85SJan Kara static struct super_block *quotactl_block(const char __user *special, int cmd) 546884d179dSJan Kara { 547884d179dSJan Kara #ifdef CONFIG_BLOCK 548884d179dSJan Kara struct block_device *bdev; 549884d179dSJan Kara struct super_block *sb; 55091a27b2aSJeff Layton struct filename *tmp = getname(special); 551884d179dSJan Kara 552884d179dSJan Kara if (IS_ERR(tmp)) 553884d179dSJan Kara return ERR_CAST(tmp); 55491a27b2aSJeff Layton bdev = lookup_bdev(tmp->name); 555884d179dSJan Kara putname(tmp); 556884d179dSJan Kara if (IS_ERR(bdev)) 557884d179dSJan Kara return ERR_CAST(bdev); 558dcdbed85SJan Kara if (quotactl_cmd_write(cmd)) 559dcdbed85SJan Kara sb = get_super_thawed(bdev); 560dcdbed85SJan Kara else 561884d179dSJan Kara sb = get_super(bdev); 562884d179dSJan Kara bdput(bdev); 563884d179dSJan Kara if (!sb) 564884d179dSJan Kara return ERR_PTR(-ENODEV); 565884d179dSJan Kara 566884d179dSJan Kara return sb; 567884d179dSJan Kara #else 568884d179dSJan Kara return ERR_PTR(-ENODEV); 569884d179dSJan Kara #endif 570884d179dSJan Kara } 571884d179dSJan Kara 572884d179dSJan Kara /* 573884d179dSJan Kara * This is the system call interface. This communicates with 574884d179dSJan Kara * the user-level programs. Currently this only supports diskquota 575884d179dSJan Kara * calls. Maybe we need to add the process quotas etc. in the future, 576884d179dSJan Kara * but we probably should use rlimits for that. 577884d179dSJan Kara */ 578884d179dSJan Kara SYSCALL_DEFINE4(quotactl, unsigned int, cmd, const char __user *, special, 579884d179dSJan Kara qid_t, id, void __user *, addr) 580884d179dSJan Kara { 581884d179dSJan Kara uint cmds, type; 582884d179dSJan Kara struct super_block *sb = NULL; 583f00c9e44SJan Kara struct path path, *pathp = NULL; 584884d179dSJan Kara int ret; 585884d179dSJan Kara 586884d179dSJan Kara cmds = cmd >> SUBCMDSHIFT; 587884d179dSJan Kara type = cmd & SUBCMDMASK; 588884d179dSJan Kara 5896ae09575SChristoph Hellwig /* 5906ae09575SChristoph Hellwig * As a special case Q_SYNC can be called without a specific device. 5916ae09575SChristoph Hellwig * It will iterate all superblocks that have quota enabled and call 5926ae09575SChristoph Hellwig * the sync action on each of them. 5936ae09575SChristoph Hellwig */ 5946ae09575SChristoph Hellwig if (!special) { 5956ae09575SChristoph Hellwig if (cmds == Q_SYNC) 5966ae09575SChristoph Hellwig return quota_sync_all(type); 5976ae09575SChristoph Hellwig return -ENODEV; 5986ae09575SChristoph Hellwig } 5996ae09575SChristoph Hellwig 600f00c9e44SJan Kara /* 601f00c9e44SJan Kara * Path for quotaon has to be resolved before grabbing superblock 602f00c9e44SJan Kara * because that gets s_umount sem which is also possibly needed by path 603f00c9e44SJan Kara * resolution (think about autofs) and thus deadlocks could arise. 604f00c9e44SJan Kara */ 605f00c9e44SJan Kara if (cmds == Q_QUOTAON) { 606815d405cSTrond Myklebust ret = user_path_at(AT_FDCWD, addr, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path); 607f00c9e44SJan Kara if (ret) 608f00c9e44SJan Kara pathp = ERR_PTR(ret); 609f00c9e44SJan Kara else 610f00c9e44SJan Kara pathp = &path; 611f00c9e44SJan Kara } 612f00c9e44SJan Kara 613dcdbed85SJan Kara sb = quotactl_block(special, cmds); 6140aaa6188SJan Kara if (IS_ERR(sb)) { 6150aaa6188SJan Kara ret = PTR_ERR(sb); 6160aaa6188SJan Kara goto out; 6170aaa6188SJan Kara } 618884d179dSJan Kara 619f00c9e44SJan Kara ret = do_quotactl(sb, type, cmds, id, addr, pathp); 620884d179dSJan Kara 6216ae09575SChristoph Hellwig drop_super(sb); 6220aaa6188SJan Kara out: 623f00c9e44SJan Kara if (pathp && !IS_ERR(pathp)) 624f00c9e44SJan Kara path_put(pathp); 625884d179dSJan Kara return ret; 626884d179dSJan Kara } 627