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