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