LXR linux/fs/xfs/xfs_qm

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   4 * All Rights Reserved.
   5 */
   6#include "xfs.h"
   7#include "xfs_fs.h"
   8#include "xfs_format.h"
   9#include "xfs_log_format.h"
  10#include "xfs_trans_resv.h"
  11#include "xfs_quota.h"
  12#include "xfs_mount.h"
  13#include "xfs_inode.h"
  14#include "xfs_error.h"
  15#include "xfs_trans.h"
  16#include "xfs_qm.h"
  17
  18
  19STATIC void
  20xfs_fill_statvfs_from_dquot(
  21        struct kstatfs          *statp,
  22        struct xfs_dquot        *dqp)
  23{
  24        uint64_t                limit;
  25
  26        limit = dqp->q_core.d_blk_softlimit ?
  27                be64_to_cpu(dqp->q_core.d_blk_softlimit) :
  28                be64_to_cpu(dqp->q_core.d_blk_hardlimit);
  29        if (limit && statp->f_blocks > limit) {
  30                statp->f_blocks = limit;
  31                statp->f_bfree = statp->f_bavail =
  32                        (statp->f_blocks > dqp->q_res_bcount) ?
  33                         (statp->f_blocks - dqp->q_res_bcount) : 0;
  34        }
  35
  36        limit = dqp->q_core.d_ino_softlimit ?
  37                be64_to_cpu(dqp->q_core.d_ino_softlimit) :
  38                be64_to_cpu(dqp->q_core.d_ino_hardlimit);
  39        if (limit && statp->f_files > limit) {
  40                statp->f_files = limit;
  41                statp->f_ffree =
  42                        (statp->f_files > dqp->q_res_icount) ?
  43                         (statp->f_ffree - dqp->q_res_icount) : 0;
  44        }
  45}
  46
  47
  48/*
  49 * Directory tree accounting is implemented using project quotas, where
  50 * the project identifier is inherited from parent directories.
  51 * A statvfs (df, etc.) of a directory that is using project quota should
  52 * return a statvfs of the project, not the entire filesystem.
  53 * This makes such trees appear as if they are filesystems in themselves.
  54 */
  55void
  56xfs_qm_statvfs(
  57        xfs_inode_t             *ip,
  58        struct kstatfs          *statp)
  59{
  60        xfs_mount_t             *mp = ip->i_mount;
  61        xfs_dquot_t             *dqp;
  62
  63        if (!xfs_qm_dqget(mp, xfs_get_projid(ip), XFS_DQ_PROJ, false, &dqp)) {
  64                xfs_fill_statvfs_from_dquot(statp, dqp);
  65                xfs_qm_dqput(dqp);
  66        }
  67}
  68
  69int
  70xfs_qm_newmount(
  71        xfs_mount_t     *mp,
  72        uint            *needquotamount,
  73        uint            *quotaflags)
  74{
  75        uint            quotaondisk;
  76        uint            uquotaondisk = 0, gquotaondisk = 0, pquotaondisk = 0;
  77
  78        quotaondisk = xfs_sb_version_hasquota(&mp->m_sb) &&
  79                                (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT);
  80
  81        if (quotaondisk) {
  82                uquotaondisk = mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT;
  83                pquotaondisk = mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT;
  84                gquotaondisk = mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT;
  85        }
  86
  87        /*
  88         * If the device itself is read-only, we can't allow
  89         * the user to change the state of quota on the mount -
  90         * this would generate a transaction on the ro device,
  91         * which would lead to an I/O error and shutdown
  92         */
  93
  94        if (((uquotaondisk && !XFS_IS_UQUOTA_ON(mp)) ||
  95            (!uquotaondisk &&  XFS_IS_UQUOTA_ON(mp)) ||
  96             (gquotaondisk && !XFS_IS_GQUOTA_ON(mp)) ||
  97            (!gquotaondisk &&  XFS_IS_GQUOTA_ON(mp)) ||
  98             (pquotaondisk && !XFS_IS_PQUOTA_ON(mp)) ||
  99            (!pquotaondisk &&  XFS_IS_PQUOTA_ON(mp)))  &&
 100            xfs_dev_is_read_only(mp, "changing quota state")) {
 101                xfs_warn(mp, "please mount with%s%s%s%s.",
 102                        (!quotaondisk ? "out quota" : ""),
 103                        (uquotaondisk ? " usrquota" : ""),
 104                        (gquotaondisk ? " grpquota" : ""),
 105                        (pquotaondisk ? " prjquota" : ""));
 106                return -EPERM;
 107        }
 108
 109        if (XFS_IS_QUOTA_ON(mp) || quotaondisk) {
 110                /*
 111                 * Call mount_quotas at this point only if we won't have to do
 112                 * a quotacheck.
 113                 */
 114                if (quotaondisk && !XFS_QM_NEED_QUOTACHECK(mp)) {
 115                        /*
 116                         * If an error occurred, qm_mount_quotas code
 117                         * has already disabled quotas. So, just finish
 118                         * mounting, and get on with the boring life
 119                         * without disk quotas.
 120                         */
 121                        xfs_qm_mount_quotas(mp);
 122                } else {
 123                        /*
 124                         * Clear the quota flags, but remember them. This
 125                         * is so that the quota code doesn't get invoked
 126                         * before we're ready. This can happen when an
 127                         * inode goes inactive and wants to free blocks,
 128                         * or via xfs_log_mount_finish.
 129                         */
 130                        *needquotamount = true;
 131                        *quotaflags = mp->m_qflags;
 132                        mp->m_qflags = 0;
 133                }
 134        }
 135
 136        return 0;
 137}
 138