fs/quota/quota.c

   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 }