fs/xfs/xfs_qm_bhv.c

   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_shared.h"
   9 #include "xfs_format.h"
  10 #include "xfs_log_format.h"
  11 #include "xfs_trans_resv.h"
  12 #include "xfs_quota.h"
  13 #include "xfs_mount.h"
  14 #include "xfs_inode.h"
  15 #include "xfs_trans.h"
  16 #include "xfs_qm.h"
  17
  18
  19 STATIC void
  20 xfs_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_files - 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  */
  55 void
  56 xfs_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
  69 int
  70 xfs_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 }