1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Quota code necessary even when VFS quota support is not compiled 4 * into the kernel. The interesting stuff is over in dquot.c, here 5 * we have symbols for initial quotactl(2) handling, the sysctl(2) 6 * variables, etc - things needed even when quota support disabled. 7 */ 8 9 #include <linux/fs.h> 10 #include <linux/namei.h> 11 #include <linux/slab.h> 12 #include <asm/current.h> 13 #include <linux/uaccess.h> 14 #include <linux/kernel.h> 15 #include <linux/security.h> 16 #include <linux/syscalls.h> 17 #include <linux/capability.h> 18 #include <linux/quotaops.h> 19 #include <linux/types.h> 20 #include <linux/writeback.h> 21 22 static int check_quotactl_permission(struct super_block *sb, int type, int cmd, 23 qid_t id) 24 { 25 switch (cmd) { 26 /* these commands do not require any special privilegues */ 27 case Q_GETFMT: 28 case Q_SYNC: 29 case Q_GETINFO: 30 case Q_XGETQSTAT: 31 case Q_XGETQSTATV: 32 case Q_XQUOTASYNC: 33 break; 34 /* allow to query information for dquots we "own" */ 35 case Q_GETQUOTA: 36 case Q_XGETQUOTA: 37 if ((type == USRQUOTA && uid_eq(current_euid(), make_kuid(current_user_ns(), id))) || 38 (type == GRPQUOTA && in_egroup_p(make_kgid(current_user_ns(), id)))) 39 break; 40 /*FALLTHROUGH*/ 41 default: 42 if (!capable(CAP_SYS_ADMIN)) 43 return -EPERM; 44 } 45 46 return security_quotactl(cmd, type, id, sb); 47 } 48 49 static void quota_sync_one(struct super_block *sb, void *arg) 50 { 51 int type = *(int *)arg; 52 53 if (sb->s_qcop && sb->s_qcop->quota_sync && 54 (sb->s_quota_types & (1 << type))) 55 sb->s_qcop->quota_sync(sb, type); 56 } 57 58 static int quota_sync_all(int type) 59 { 60 int ret; 61 62 if (type >= MAXQUOTAS) 63 return -EINVAL; 64 ret = security_quotactl(Q_SYNC, type, 0, NULL); 65 if (!ret) 66 iterate_supers(quota_sync_one, &type); 67 return ret; 68 } 69 70 unsigned int qtype_enforce_flag(int type) 71 { 72 switch (type) { 73 case USRQUOTA: 74 return FS_QUOTA_UDQ_ENFD; 75 case GRPQUOTA: 76 return FS_QUOTA_GDQ_ENFD; 77 case PRJQUOTA: 78 return FS_QUOTA_PDQ_ENFD; 79 } 80 return 0; 81 } 82 83 static int quota_quotaon(struct super_block *sb, int type, qid_t id, 84 const struct path *path) 85 { 86 if (!sb->s_qcop->quota_on && !sb->s_qcop->quota_enable) 87 return -ENOSYS; 88 if (sb->s_qcop->quota_enable) 89 return sb->s_qcop->quota_enable(sb, qtype_enforce_flag(type)); 90 if (IS_ERR(path)) 91 return PTR_ERR(path); 92 return sb->s_qcop->quota_on(sb, type, id, path); 93 } 94 95 static int quota_quotaoff(struct super_block *sb, int type) 96 { 97 if (!sb->s_qcop->quota_off && !sb->s_qcop->quota_disable) 98 return -ENOSYS; 99 if (sb->s_qcop->quota_disable) 100 return sb->s_qcop->quota_disable(sb, qtype_enforce_flag(type)); 101 return sb->s_qcop->quota_off(sb, type); 102 } 103 104 static int quota_getfmt(struct super_block *sb, int type, void __user *addr) 105 { 106 __u32 fmt; 107 108 if (!sb_has_quota_active(sb, type)) 109 return -ESRCH; 110 fmt = sb_dqopt(sb)->info[type].dqi_format->qf_fmt_id; 111 if (copy_to_user(addr, &fmt, sizeof(fmt))) 112 return -EFAULT; 113 return 0; 114 } 115 116 static int quota_getinfo(struct super_block *sb, int type, void __user *addr) 117 { 118 struct qc_state state; 119 struct qc_type_state *tstate; 120 struct if_dqinfo uinfo; 121 int ret; 122 123 /* This checks whether qc_state has enough entries... */ 124 BUILD_BUG_ON(MAXQUOTAS > XQM_MAXQUOTAS); 125 if (!sb->s_qcop->get_state) 126 return -ENOSYS; 127 ret = sb->s_qcop->get_state(sb, &state); 128 if (ret) 129 return ret; 130 tstate = state.s_state + type; 131 if (!(tstate->flags & QCI_ACCT_ENABLED)) 132 return -ESRCH; 133 memset(&uinfo, 0, sizeof(uinfo)); 134 uinfo.dqi_bgrace = tstate->spc_timelimit; 135 uinfo.dqi_igrace = tstate->ino_timelimit; 136 if (tstate->flags & QCI_SYSFILE) 137 uinfo.dqi_flags |= DQF_SYS_FILE; 138 if (tstate->flags & QCI_ROOT_SQUASH) 139 uinfo.dqi_flags |= DQF_ROOT_SQUASH; 140 uinfo.dqi_valid = IIF_ALL; 141 if (copy_to_user(addr, &uinfo, sizeof(uinfo))) 142 return -EFAULT; 143 return 0; 144 } 145 146 static int quota_setinfo(struct super_block *sb, int type, void __user *addr) 147 { 148 struct if_dqinfo info; 149 struct qc_info qinfo; 150 151 if (copy_from_user(&info, addr, sizeof(info))) 152 return -EFAULT; 153 if (!sb->s_qcop->set_info) 154 return -ENOSYS; 155 if (info.dqi_valid & ~(IIF_FLAGS | IIF_BGRACE | IIF_IGRACE)) 156 return -EINVAL; 157 memset(&qinfo, 0, sizeof(qinfo)); 158 if (info.dqi_valid & IIF_FLAGS) { 159 if (info.dqi_flags & ~DQF_SETINFO_MASK) 160 return -EINVAL; 161 if (info.dqi_flags & DQF_ROOT_SQUASH) 162 qinfo.i_flags |= QCI_ROOT_SQUASH; 163 qinfo.i_fieldmask |= QC_FLAGS; 164 } 165 if (info.dqi_valid & IIF_BGRACE) { 166 qinfo.i_spc_timelimit = info.dqi_bgrace; 167 qinfo.i_fieldmask |= QC_SPC_TIMER; 168 } 169 if (info.dqi_valid & IIF_IGRACE) { 170 qinfo.i_ino_timelimit = info.dqi_igrace; 171 qinfo.i_fieldmask |= QC_INO_TIMER; 172 } 173 return sb->s_qcop->set_info(sb, type, &qinfo); 174 } 175 176 static inline qsize_t qbtos(qsize_t blocks) 177 { 178 return blocks << QIF_DQBLKSIZE_BITS; 179 } 180 181 static inline qsize_t stoqb(qsize_t space) 182 { 183 return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS; 184 } 185 186 static void copy_to_if_dqblk(struct if_dqblk *dst, struct qc_dqblk *src) 187 { 188 memset(dst, 0, sizeof(*dst)); 189 dst->dqb_bhardlimit = stoqb(src->d_spc_hardlimit); 190 dst->dqb_bsoftlimit = stoqb(src->d_spc_softlimit); 191 dst->dqb_curspace = src->d_space; 192 dst->dqb_ihardlimit = src->d_ino_hardlimit; 193 dst->dqb_isoftlimit = src->d_ino_softlimit; 194 dst->dqb_curinodes = src->d_ino_count; 195 dst->dqb_btime = src->d_spc_timer; 196 dst->dqb_itime = src->d_ino_timer; 197 dst->dqb_valid = QIF_ALL; 198 } 199 200 static int quota_getquota(struct super_block *sb, int type, qid_t id, 201 void __user *addr) 202 { 203 struct kqid qid; 204 struct qc_dqblk fdq; 205 struct if_dqblk idq; 206 int ret; 207 208 if (!sb->s_qcop->get_dqblk) 209 return -ENOSYS; 210 qid = make_kqid(current_user_ns(), type, id); 211 if (!qid_has_mapping(sb->s_user_ns, qid)) 212 return -EINVAL; 213 ret = sb->s_qcop->get_dqblk(sb, qid, &fdq); 214 if (ret) 215 return ret; 216 copy_to_if_dqblk(&idq, &fdq); 217 if (copy_to_user(addr, &idq, sizeof(idq))) 218 return -EFAULT; 219 return 0; 220 } 221 222 /* 223 * Return quota for next active quota >= this id, if any exists, 224 * otherwise return -ENOENT via ->get_nextdqblk 225 */ 226 static int quota_getnextquota(struct super_block *sb, int type, qid_t id, 227 void __user *addr) 228 { 229 struct kqid qid; 230 struct qc_dqblk fdq; 231 struct if_nextdqblk idq; 232 int ret; 233 234 if (!sb->s_qcop->get_nextdqblk) 235 return -ENOSYS; 236 qid = make_kqid(current_user_ns(), type, id); 237 if (!qid_has_mapping(sb->s_user_ns, qid)) 238 return -EINVAL; 239 ret = sb->s_qcop->get_nextdqblk(sb, &qid, &fdq); 240 if (ret) 241 return ret; 242 /* struct if_nextdqblk is a superset of struct if_dqblk */ 243 copy_to_if_dqblk((struct if_dqblk *)&idq, &fdq); 244 idq.dqb_id = from_kqid(current_user_ns(), qid); 245 if (copy_to_user(addr, &idq, sizeof(idq))) 246 return -EFAULT; 247 return 0; 248 } 249 250 static void copy_from_if_dqblk(struct qc_dqblk *dst, struct if_dqblk *src) 251 { 252 dst->d_spc_hardlimit = qbtos(src->dqb_bhardlimit); 253 dst->d_spc_softlimit = qbtos(src->dqb_bsoftlimit); 254 dst->d_space = src->dqb_curspace; 255 dst->d_ino_hardlimit = src->dqb_ihardlimit; 256 dst->d_ino_softlimit = src->dqb_isoftlimit; 257 dst->d_ino_count = src->dqb_curinodes; 258 dst->d_spc_timer = src->dqb_btime; 259 dst->d_ino_timer = src->dqb_itime; 260 261 dst->d_fieldmask = 0; 262 if (src->dqb_valid & QIF_BLIMITS) 263 dst->d_fieldmask |= QC_SPC_SOFT | QC_SPC_HARD; 264 if (src->dqb_valid & QIF_SPACE) 265 dst->d_fieldmask |= QC_SPACE; 266 if (src->dqb_valid & QIF_ILIMITS) 267 dst->d_fieldmask |= QC_INO_SOFT | QC_INO_HARD; 268 if (src->dqb_valid & QIF_INODES) 269 dst->d_fieldmask |= QC_INO_COUNT; 270 if (src->dqb_valid & QIF_BTIME) 271 dst->d_fieldmask |= QC_SPC_TIMER; 272 if (src->dqb_valid & QIF_ITIME) 273 dst->d_fieldmask |= QC_INO_TIMER; 274 } 275 276 static int quota_setquota(struct super_block *sb, int type, qid_t id, 277 void __user *addr) 278 { 279 struct qc_dqblk fdq; 280 struct if_dqblk idq; 281 struct kqid qid; 282 283 if (copy_from_user(&idq, addr, sizeof(idq))) 284 return -EFAULT; 285 if (!sb->s_qcop->set_dqblk) 286 return -ENOSYS; 287 qid = make_kqid(current_user_ns(), type, id); 288 if (!qid_has_mapping(sb->s_user_ns, qid)) 289 return -EINVAL; 290 copy_from_if_dqblk(&fdq, &idq); 291 return sb->s_qcop->set_dqblk(sb, qid, &fdq); 292 } 293 294 static int quota_enable(struct super_block *sb, void __user *addr) 295 { 296 __u32 flags; 297 298 if (copy_from_user(&flags, addr, sizeof(flags))) 299 return -EFAULT; 300 if (!sb->s_qcop->quota_enable) 301 return -ENOSYS; 302 return sb->s_qcop->quota_enable(sb, flags); 303 } 304 305 static int quota_disable(struct super_block *sb, void __user *addr) 306 { 307 __u32 flags; 308 309 if (copy_from_user(&flags, addr, sizeof(flags))) 310 return -EFAULT; 311 if (!sb->s_qcop->quota_disable) 312 return -ENOSYS; 313 return sb->s_qcop->quota_disable(sb, flags); 314 } 315 316 static int quota_state_to_flags(struct qc_state *state) 317 { 318 int flags = 0; 319 320 if (state->s_state[USRQUOTA].flags & QCI_ACCT_ENABLED) 321 flags |= FS_QUOTA_UDQ_ACCT; 322 if (state->s_state[USRQUOTA].flags & QCI_LIMITS_ENFORCED) 323 flags |= FS_QUOTA_UDQ_ENFD; 324 if (state->s_state[GRPQUOTA].flags & QCI_ACCT_ENABLED) 325 flags |= FS_QUOTA_GDQ_ACCT; 326 if (state->s_state[GRPQUOTA].flags & QCI_LIMITS_ENFORCED) 327 flags |= FS_QUOTA_GDQ_ENFD; 328 if (state->s_state[PRJQUOTA].flags & QCI_ACCT_ENABLED) 329 flags |= FS_QUOTA_PDQ_ACCT; 330 if (state->s_state[PRJQUOTA].flags & QCI_LIMITS_ENFORCED) 331 flags |= FS_QUOTA_PDQ_ENFD; 332 return flags; 333 } 334 335 static int quota_getstate(struct super_block *sb, struct fs_quota_stat *fqs) 336 { 337 int type; 338 struct qc_state state; 339 int ret; 340 341 memset(&state, 0, sizeof (struct qc_state)); 342 ret = sb->s_qcop->get_state(sb, &state); 343 if (ret < 0) 344 return ret; 345 346 memset(fqs, 0, sizeof(*fqs)); 347 fqs->qs_version = FS_QSTAT_VERSION; 348 fqs->qs_flags = quota_state_to_flags(&state); 349 /* No quota enabled? */ 350 if (!fqs->qs_flags) 351 return -ENOSYS; 352 fqs->qs_incoredqs = state.s_incoredqs; 353 /* 354 * GETXSTATE quotactl has space for just one set of time limits so 355 * report them for the first enabled quota type 356 */ 357 for (type = 0; type < XQM_MAXQUOTAS; type++) 358 if (state.s_state[type].flags & QCI_ACCT_ENABLED) 359 break; 360 BUG_ON(type == XQM_MAXQUOTAS); 361 fqs->qs_btimelimit = state.s_state[type].spc_timelimit; 362 fqs->qs_itimelimit = state.s_state[type].ino_timelimit; 363 fqs->qs_rtbtimelimit = state.s_state[type].rt_spc_timelimit; 364 fqs->qs_bwarnlimit = state.s_state[type].spc_warnlimit; 365 fqs->qs_iwarnlimit = state.s_state[type].ino_warnlimit; 366 367 /* Inodes may be allocated even if inactive; copy out if present */ 368 if (state.s_state[USRQUOTA].ino) { 369 fqs->qs_uquota.qfs_ino = state.s_state[USRQUOTA].ino; 370 fqs->qs_uquota.qfs_nblks = state.s_state[USRQUOTA].blocks; 371 fqs->qs_uquota.qfs_nextents = state.s_state[USRQUOTA].nextents; 372 } 373 if (state.s_state[GRPQUOTA].ino) { 374 fqs->qs_gquota.qfs_ino = state.s_state[GRPQUOTA].ino; 375 fqs->qs_gquota.qfs_nblks = state.s_state[GRPQUOTA].blocks; 376 fqs->qs_gquota.qfs_nextents = state.s_state[GRPQUOTA].nextents; 377 } 378 if (state.s_state[PRJQUOTA].ino) { 379 /* 380 * Q_XGETQSTAT doesn't have room for both group and project 381 * quotas. So, allow the project quota values to be copied out 382 * only if there is no group quota information available. 383 */ 384 if (!(state.s_state[GRPQUOTA].flags & QCI_ACCT_ENABLED)) { 385 fqs->qs_gquota.qfs_ino = state.s_state[PRJQUOTA].ino; 386 fqs->qs_gquota.qfs_nblks = 387 state.s_state[PRJQUOTA].blocks; 388 fqs->qs_gquota.qfs_nextents = 389 state.s_state[PRJQUOTA].nextents; 390 } 391 } 392 return 0; 393 } 394 395 static int quota_getxstate(struct super_block *sb, void __user *addr) 396 { 397 struct fs_quota_stat fqs; 398 int ret; 399 400 if (!sb->s_qcop->get_state) 401 return -ENOSYS; 402 ret = quota_getstate(sb, &fqs); 403 if (!ret && copy_to_user(addr, &fqs, sizeof(fqs))) 404 return -EFAULT; 405 return ret; 406 } 407 408 static int quota_getstatev(struct super_block *sb, struct fs_quota_statv *fqs) 409 { 410 int type; 411 struct qc_state state; 412 int ret; 413 414 memset(&state, 0, sizeof (struct qc_state)); 415 ret = sb->s_qcop->get_state(sb, &state); 416 if (ret < 0) 417 return ret; 418 419 memset(fqs, 0, sizeof(*fqs)); 420 fqs->qs_version = FS_QSTAT_VERSION; 421 fqs->qs_flags = quota_state_to_flags(&state); 422 /* No quota enabled? */ 423 if (!fqs->qs_flags) 424 return -ENOSYS; 425 fqs->qs_incoredqs = state.s_incoredqs; 426 /* 427 * GETXSTATV quotactl has space for just one set of time limits so 428 * report them for the first enabled quota type 429 */ 430 for (type = 0; type < XQM_MAXQUOTAS; type++) 431 if (state.s_state[type].flags & QCI_ACCT_ENABLED) 432 break; 433 BUG_ON(type == XQM_MAXQUOTAS); 434 fqs->qs_btimelimit = state.s_state[type].spc_timelimit; 435 fqs->qs_itimelimit = state.s_state[type].ino_timelimit; 436 fqs->qs_rtbtimelimit = state.s_state[type].rt_spc_timelimit; 437 fqs->qs_bwarnlimit = state.s_state[type].spc_warnlimit; 438 fqs->qs_iwarnlimit = state.s_state[type].ino_warnlimit; 439 440 /* Inodes may be allocated even if inactive; copy out if present */ 441 if (state.s_state[USRQUOTA].ino) { 442 fqs->qs_uquota.qfs_ino = state.s_state[USRQUOTA].ino; 443 fqs->qs_uquota.qfs_nblks = state.s_state[USRQUOTA].blocks; 444 fqs->qs_uquota.qfs_nextents = state.s_state[USRQUOTA].nextents; 445 } 446 if (state.s_state[GRPQUOTA].ino) { 447 fqs->qs_gquota.qfs_ino = state.s_state[GRPQUOTA].ino; 448 fqs->qs_gquota.qfs_nblks = state.s_state[GRPQUOTA].blocks; 449 fqs->qs_gquota.qfs_nextents = state.s_state[GRPQUOTA].nextents; 450 } 451 if (state.s_state[PRJQUOTA].ino) { 452 fqs->qs_pquota.qfs_ino = state.s_state[PRJQUOTA].ino; 453 fqs->qs_pquota.qfs_nblks = state.s_state[PRJQUOTA].blocks; 454 fqs->qs_pquota.qfs_nextents = state.s_state[PRJQUOTA].nextents; 455 } 456 return 0; 457 } 458 459 static int quota_getxstatev(struct super_block *sb, void __user *addr) 460 { 461 struct fs_quota_statv fqs; 462 int ret; 463 464 if (!sb->s_qcop->get_state) 465 return -ENOSYS; 466 467 memset(&fqs, 0, sizeof(fqs)); 468 if (copy_from_user(&fqs, addr, 1)) /* Just read qs_version */ 469 return -EFAULT; 470 471 /* If this kernel doesn't support user specified version, fail */ 472 switch (fqs.qs_version) { 473 case FS_QSTATV_VERSION1: 474 break; 475 default: 476 return -EINVAL; 477 } 478 ret = quota_getstatev(sb, &fqs); 479 if (!ret && copy_to_user(addr, &fqs, sizeof(fqs))) 480 return -EFAULT; 481 return ret; 482 } 483 484 /* 485 * XFS defines BBTOB and BTOBB macros inside fs/xfs/ and we cannot move them 486 * out of there as xfsprogs rely on definitions being in that header file. So 487 * just define same functions here for quota purposes. 488 */ 489 #define XFS_BB_SHIFT 9 490 491 static inline u64 quota_bbtob(u64 blocks) 492 { 493 return blocks << XFS_BB_SHIFT; 494 } 495 496 static inline u64 quota_btobb(u64 bytes) 497 { 498 return (bytes + (1 << XFS_BB_SHIFT) - 1) >> XFS_BB_SHIFT; 499 } 500 501 static void copy_from_xfs_dqblk(struct qc_dqblk *dst, struct fs_disk_quota *src) 502 { 503 dst->d_spc_hardlimit = quota_bbtob(src->d_blk_hardlimit); 504 dst->d_spc_softlimit = quota_bbtob(src->d_blk_softlimit); 505 dst->d_ino_hardlimit = src->d_ino_hardlimit; 506 dst->d_ino_softlimit = src->d_ino_softlimit; 507 dst->d_space = quota_bbtob(src->d_bcount); 508 dst->d_ino_count = src->d_icount; 509 dst->d_ino_timer = src->d_itimer; 510 dst->d_spc_timer = src->d_btimer; 511 dst->d_ino_warns = src->d_iwarns; 512 dst->d_spc_warns = src->d_bwarns; 513 dst->d_rt_spc_hardlimit = quota_bbtob(src->d_rtb_hardlimit); 514 dst->d_rt_spc_softlimit = quota_bbtob(src->d_rtb_softlimit); 515 dst->d_rt_space = quota_bbtob(src->d_rtbcount); 516 dst->d_rt_spc_timer = src->d_rtbtimer; 517 dst->d_rt_spc_warns = src->d_rtbwarns; 518 dst->d_fieldmask = 0; 519 if (src->d_fieldmask & FS_DQ_ISOFT) 520 dst->d_fieldmask |= QC_INO_SOFT; 521 if (src->d_fieldmask & FS_DQ_IHARD) 522 dst->d_fieldmask |= QC_INO_HARD; 523 if (src->d_fieldmask & FS_DQ_BSOFT) 524 dst->d_fieldmask |= QC_SPC_SOFT; 525 if (src->d_fieldmask & FS_DQ_BHARD) 526 dst->d_fieldmask |= QC_SPC_HARD; 527 if (src->d_fieldmask & FS_DQ_RTBSOFT) 528 dst->d_fieldmask |= QC_RT_SPC_SOFT; 529 if (src->d_fieldmask & FS_DQ_RTBHARD) 530 dst->d_fieldmask |= QC_RT_SPC_HARD; 531 if (src->d_fieldmask & FS_DQ_BTIMER) 532 dst->d_fieldmask |= QC_SPC_TIMER; 533 if (src->d_fieldmask & FS_DQ_ITIMER) 534 dst->d_fieldmask |= QC_INO_TIMER; 535 if (src->d_fieldmask & FS_DQ_RTBTIMER) 536 dst->d_fieldmask |= QC_RT_SPC_TIMER; 537 if (src->d_fieldmask & FS_DQ_BWARNS) 538 dst->d_fieldmask |= QC_SPC_WARNS; 539 if (src->d_fieldmask & FS_DQ_IWARNS) 540 dst->d_fieldmask |= QC_INO_WARNS; 541 if (src->d_fieldmask & FS_DQ_RTBWARNS) 542 dst->d_fieldmask |= QC_RT_SPC_WARNS; 543 if (src->d_fieldmask & FS_DQ_BCOUNT) 544 dst->d_fieldmask |= QC_SPACE; 545 if (src->d_fieldmask & FS_DQ_ICOUNT) 546 dst->d_fieldmask |= QC_INO_COUNT; 547 if (src->d_fieldmask & FS_DQ_RTBCOUNT) 548 dst->d_fieldmask |= QC_RT_SPACE; 549 } 550 551 static void copy_qcinfo_from_xfs_dqblk(struct qc_info *dst, 552 struct fs_disk_quota *src) 553 { 554 memset(dst, 0, sizeof(*dst)); 555 dst->i_spc_timelimit = src->d_btimer; 556 dst->i_ino_timelimit = src->d_itimer; 557 dst->i_rt_spc_timelimit = src->d_rtbtimer; 558 dst->i_ino_warnlimit = src->d_iwarns; 559 dst->i_spc_warnlimit = src->d_bwarns; 560 dst->i_rt_spc_warnlimit = src->d_rtbwarns; 561 if (src->d_fieldmask & FS_DQ_BWARNS) 562 dst->i_fieldmask |= QC_SPC_WARNS; 563 if (src->d_fieldmask & FS_DQ_IWARNS) 564 dst->i_fieldmask |= QC_INO_WARNS; 565 if (src->d_fieldmask & FS_DQ_RTBWARNS) 566 dst->i_fieldmask |= QC_RT_SPC_WARNS; 567 if (src->d_fieldmask & FS_DQ_BTIMER) 568 dst->i_fieldmask |= QC_SPC_TIMER; 569 if (src->d_fieldmask & FS_DQ_ITIMER) 570 dst->i_fieldmask |= QC_INO_TIMER; 571 if (src->d_fieldmask & FS_DQ_RTBTIMER) 572 dst->i_fieldmask |= QC_RT_SPC_TIMER; 573 } 574 575 static int quota_setxquota(struct super_block *sb, int type, qid_t id, 576 void __user *addr) 577 { 578 struct fs_disk_quota fdq; 579 struct qc_dqblk qdq; 580 struct kqid qid; 581 582 if (copy_from_user(&fdq, addr, sizeof(fdq))) 583 return -EFAULT; 584 if (!sb->s_qcop->set_dqblk) 585 return -ENOSYS; 586 qid = make_kqid(current_user_ns(), type, id); 587 if (!qid_has_mapping(sb->s_user_ns, qid)) 588 return -EINVAL; 589 /* Are we actually setting timer / warning limits for all users? */ 590 if (from_kqid(sb->s_user_ns, qid) == 0 && 591 fdq.d_fieldmask & (FS_DQ_WARNS_MASK | FS_DQ_TIMER_MASK)) { 592 struct qc_info qinfo; 593 int ret; 594 595 if (!sb->s_qcop->set_info) 596 return -EINVAL; 597 copy_qcinfo_from_xfs_dqblk(&qinfo, &fdq); 598 ret = sb->s_qcop->set_info(sb, type, &qinfo); 599 if (ret) 600 return ret; 601 /* These are already done */ 602 fdq.d_fieldmask &= ~(FS_DQ_WARNS_MASK | FS_DQ_TIMER_MASK); 603 } 604 copy_from_xfs_dqblk(&qdq, &fdq); 605 return sb->s_qcop->set_dqblk(sb, qid, &qdq); 606 } 607 608 static void copy_to_xfs_dqblk(struct fs_disk_quota *dst, struct qc_dqblk *src, 609 int type, qid_t id) 610 { 611 memset(dst, 0, sizeof(*dst)); 612 dst->d_version = FS_DQUOT_VERSION; 613 dst->d_id = id; 614 if (type == USRQUOTA) 615 dst->d_flags = FS_USER_QUOTA; 616 else if (type == PRJQUOTA) 617 dst->d_flags = FS_PROJ_QUOTA; 618 else 619 dst->d_flags = FS_GROUP_QUOTA; 620 dst->d_blk_hardlimit = quota_btobb(src->d_spc_hardlimit); 621 dst->d_blk_softlimit = quota_btobb(src->d_spc_softlimit); 622 dst->d_ino_hardlimit = src->d_ino_hardlimit; 623 dst->d_ino_softlimit = src->d_ino_softlimit; 624 dst->d_bcount = quota_btobb(src->d_space); 625 dst->d_icount = src->d_ino_count; 626 dst->d_itimer = src->d_ino_timer; 627 dst->d_btimer = src->d_spc_timer; 628 dst->d_iwarns = src->d_ino_warns; 629 dst->d_bwarns = src->d_spc_warns; 630 dst->d_rtb_hardlimit = quota_btobb(src->d_rt_spc_hardlimit); 631 dst->d_rtb_softlimit = quota_btobb(src->d_rt_spc_softlimit); 632 dst->d_rtbcount = quota_btobb(src->d_rt_space); 633 dst->d_rtbtimer = src->d_rt_spc_timer; 634 dst->d_rtbwarns = src->d_rt_spc_warns; 635 } 636 637 static int quota_getxquota(struct super_block *sb, int type, qid_t id, 638 void __user *addr) 639 { 640 struct fs_disk_quota fdq; 641 struct qc_dqblk qdq; 642 struct kqid qid; 643 int ret; 644 645 if (!sb->s_qcop->get_dqblk) 646 return -ENOSYS; 647 qid = make_kqid(current_user_ns(), type, id); 648 if (!qid_has_mapping(sb->s_user_ns, qid)) 649 return -EINVAL; 650 ret = sb->s_qcop->get_dqblk(sb, qid, &qdq); 651 if (ret) 652 return ret; 653 copy_to_xfs_dqblk(&fdq, &qdq, type, id); 654 if (copy_to_user(addr, &fdq, sizeof(fdq))) 655 return -EFAULT; 656 return ret; 657 } 658 659 /* 660 * Return quota for next active quota >= this id, if any exists, 661 * otherwise return -ENOENT via ->get_nextdqblk. 662 */ 663 static int quota_getnextxquota(struct super_block *sb, int type, qid_t id, 664 void __user *addr) 665 { 666 struct fs_disk_quota fdq; 667 struct qc_dqblk qdq; 668 struct kqid qid; 669 qid_t id_out; 670 int ret; 671 672 if (!sb->s_qcop->get_nextdqblk) 673 return -ENOSYS; 674 qid = make_kqid(current_user_ns(), type, id); 675 if (!qid_has_mapping(sb->s_user_ns, qid)) 676 return -EINVAL; 677 ret = sb->s_qcop->get_nextdqblk(sb, &qid, &qdq); 678 if (ret) 679 return ret; 680 id_out = from_kqid(current_user_ns(), qid); 681 copy_to_xfs_dqblk(&fdq, &qdq, type, id_out); 682 if (copy_to_user(addr, &fdq, sizeof(fdq))) 683 return -EFAULT; 684 return ret; 685 } 686 687 static int quota_rmxquota(struct super_block *sb, void __user *addr) 688 { 689 __u32 flags; 690 691 if (copy_from_user(&flags, addr, sizeof(flags))) 692 return -EFAULT; 693 if (!sb->s_qcop->rm_xquota) 694 return -ENOSYS; 695 return sb->s_qcop->rm_xquota(sb, flags); 696 } 697 698 /* Copy parameters and call proper function */ 699 static int do_quotactl(struct super_block *sb, int type, int cmd, qid_t id, 700 void __user *addr, const struct path *path) 701 { 702 int ret; 703 704 if (type >= (XQM_COMMAND(cmd) ? XQM_MAXQUOTAS : MAXQUOTAS)) 705 return -EINVAL; 706 /* 707 * Quota not supported on this fs? Check this before s_quota_types 708 * since they needn't be set if quota is not supported at all. 709 */ 710 if (!sb->s_qcop) 711 return -ENOSYS; 712 if (!(sb->s_quota_types & (1 << type))) 713 return -EINVAL; 714 715 ret = check_quotactl_permission(sb, type, cmd, id); 716 if (ret < 0) 717 return ret; 718 719 switch (cmd) { 720 case Q_QUOTAON: 721 return quota_quotaon(sb, type, id, path); 722 case Q_QUOTAOFF: 723 return quota_quotaoff(sb, type); 724 case Q_GETFMT: 725 return quota_getfmt(sb, type, addr); 726 case Q_GETINFO: 727 return quota_getinfo(sb, type, addr); 728 case Q_SETINFO: 729 return quota_setinfo(sb, type, addr); 730 case Q_GETQUOTA: 731 return quota_getquota(sb, type, id, addr); 732 case Q_GETNEXTQUOTA: 733 return quota_getnextquota(sb, type, id, addr); 734 case Q_SETQUOTA: 735 return quota_setquota(sb, type, id, addr); 736 case Q_SYNC: 737 if (!sb->s_qcop->quota_sync) 738 return -ENOSYS; 739 return sb->s_qcop->quota_sync(sb, type); 740 case Q_XQUOTAON: 741 return quota_enable(sb, addr); 742 case Q_XQUOTAOFF: 743 return quota_disable(sb, addr); 744 case Q_XQUOTARM: 745 return quota_rmxquota(sb, addr); 746 case Q_XGETQSTAT: 747 return quota_getxstate(sb, addr); 748 case Q_XGETQSTATV: 749 return quota_getxstatev(sb, addr); 750 case Q_XSETQLIM: 751 return quota_setxquota(sb, type, id, addr); 752 case Q_XGETQUOTA: 753 return quota_getxquota(sb, type, id, addr); 754 case Q_XGETNEXTQUOTA: 755 return quota_getnextxquota(sb, type, id, addr); 756 case Q_XQUOTASYNC: 757 if (sb_rdonly(sb)) 758 return -EROFS; 759 /* XFS quotas are fully coherent now, making this call a noop */ 760 return 0; 761 default: 762 return -EINVAL; 763 } 764 } 765 766 #ifdef CONFIG_BLOCK 767 768 /* Return 1 if 'cmd' will block on frozen filesystem */ 769 static int quotactl_cmd_write(int cmd) 770 { 771 /* 772 * We cannot allow Q_GETQUOTA and Q_GETNEXTQUOTA without write access 773 * as dquot_acquire() may allocate space for new structure and OCFS2 774 * needs to increment on-disk use count. 775 */ 776 switch (cmd) { 777 case Q_GETFMT: 778 case Q_GETINFO: 779 case Q_SYNC: 780 case Q_XGETQSTAT: 781 case Q_XGETQSTATV: 782 case Q_XGETQUOTA: 783 case Q_XGETNEXTQUOTA: 784 case Q_XQUOTASYNC: 785 return 0; 786 } 787 return 1; 788 } 789 #endif /* CONFIG_BLOCK */ 790 791 /* Return true if quotactl command is manipulating quota on/off state */ 792 static bool quotactl_cmd_onoff(int cmd) 793 { 794 return (cmd == Q_QUOTAON) || (cmd == Q_QUOTAOFF); 795 } 796 797 /* 798 * look up a superblock on which quota ops will be performed 799 * - use the name of a block device to find the superblock thereon 800 */ 801 static struct super_block *quotactl_block(const char __user *special, int cmd) 802 { 803 #ifdef CONFIG_BLOCK 804 struct block_device *bdev; 805 struct super_block *sb; 806 struct filename *tmp = getname(special); 807 808 if (IS_ERR(tmp)) 809 return ERR_CAST(tmp); 810 bdev = lookup_bdev(tmp->name); 811 putname(tmp); 812 if (IS_ERR(bdev)) 813 return ERR_CAST(bdev); 814 if (quotactl_cmd_onoff(cmd)) 815 sb = get_super_exclusive_thawed(bdev); 816 else if (quotactl_cmd_write(cmd)) 817 sb = get_super_thawed(bdev); 818 else 819 sb = get_super(bdev); 820 bdput(bdev); 821 if (!sb) 822 return ERR_PTR(-ENODEV); 823 824 return sb; 825 #else 826 return ERR_PTR(-ENODEV); 827 #endif 828 } 829 830 /* 831 * This is the system call interface. This communicates with 832 * the user-level programs. Currently this only supports diskquota 833 * calls. Maybe we need to add the process quotas etc. in the future, 834 * but we probably should use rlimits for that. 835 */ 836 SYSCALL_DEFINE4(quotactl, unsigned int, cmd, const char __user *, special, 837 qid_t, id, void __user *, addr) 838 { 839 uint cmds, type; 840 struct super_block *sb = NULL; 841 struct path path, *pathp = NULL; 842 int ret; 843 844 cmds = cmd >> SUBCMDSHIFT; 845 type = cmd & SUBCMDMASK; 846 847 /* 848 * As a special case Q_SYNC can be called without a specific device. 849 * It will iterate all superblocks that have quota enabled and call 850 * the sync action on each of them. 851 */ 852 if (!special) { 853 if (cmds == Q_SYNC) 854 return quota_sync_all(type); 855 return -ENODEV; 856 } 857 858 /* 859 * Path for quotaon has to be resolved before grabbing superblock 860 * because that gets s_umount sem which is also possibly needed by path 861 * resolution (think about autofs) and thus deadlocks could arise. 862 */ 863 if (cmds == Q_QUOTAON) { 864 ret = user_path_at(AT_FDCWD, addr, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path); 865 if (ret) 866 pathp = ERR_PTR(ret); 867 else 868 pathp = &path; 869 } 870 871 sb = quotactl_block(special, cmds); 872 if (IS_ERR(sb)) { 873 ret = PTR_ERR(sb); 874 goto out; 875 } 876 877 ret = do_quotactl(sb, type, cmds, id, addr, pathp); 878 879 if (!quotactl_cmd_onoff(cmds)) 880 drop_super(sb); 881 else 882 drop_super_exclusive(sb); 883 out: 884 if (pathp && !IS_ERR(pathp)) 885 path_put(pathp); 886 return ret; 887 } 888