fs/xfs/xfs_qm.h

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6 #ifndef __XFS_QM_H__
   7 #define __XFS_QM_H__
   8
   9 #include "xfs_dquot_item.h"
  10 #include "xfs_dquot.h"
  11
  12 struct xfs_inode;
  13
  14 extern struct kmem_zone *xfs_qm_dqtrxzone;
  15
  16 /*
  17  * Number of bmaps that we ask from bmapi when doing a quotacheck.
  18  * We make this restriction to keep the memory usage to a minimum.
  19  */
  20 #define XFS_DQITER_MAP_SIZE     10
  21
  22 #define XFS_IS_DQUOT_UNINITIALIZED(dqp) ( \
  23         !dqp->q_core.d_blk_hardlimit && \
  24         !dqp->q_core.d_blk_softlimit && \
  25         !dqp->q_core.d_rtb_hardlimit && \
  26         !dqp->q_core.d_rtb_softlimit && \
  27         !dqp->q_core.d_ino_hardlimit && \
  28         !dqp->q_core.d_ino_softlimit && \
  29         !dqp->q_core.d_bcount && \
  30         !dqp->q_core.d_rtbcount && \
  31         !dqp->q_core.d_icount)
  32
  33 /*
  34  * This defines the unit of allocation of dquots.
  35  * Currently, it is just one file system block, and a 4K blk contains 30
  36  * (136 * 30 = 4080) dquots. It's probably not worth trying to make
  37  * this more dynamic.
  38  * XXXsup However, if this number is changed, we have to make sure that we don't
  39  * implicitly assume that we do allocations in chunks of a single filesystem
  40  * block in the dquot/xqm code.
  41  */
  42 #define XFS_DQUOT_CLUSTER_SIZE_FSB      (xfs_filblks_t)1
  43
  44 /* Defaults for each quota type: time limits, warn limits, usage limits */
  45 struct xfs_def_quota {
  46         time64_t        btimelimit;     /* limit for blks timer */
  47         time64_t        itimelimit;     /* limit for inodes timer */
  48         time64_t        rtbtimelimit;   /* limit for rt blks timer */
  49         xfs_qwarncnt_t  bwarnlimit;     /* limit for blks warnings */
  50         xfs_qwarncnt_t  iwarnlimit;     /* limit for inodes warnings */
  51         xfs_qwarncnt_t  rtbwarnlimit;   /* limit for rt blks warnings */
  52         xfs_qcnt_t      bhardlimit;     /* default data blk hard limit */
  53         xfs_qcnt_t      bsoftlimit;     /* default data blk soft limit */
  54         xfs_qcnt_t      ihardlimit;     /* default inode count hard limit */
  55         xfs_qcnt_t      isoftlimit;     /* default inode count soft limit */
  56         xfs_qcnt_t      rtbhardlimit;   /* default realtime blk hard limit */
  57         xfs_qcnt_t      rtbsoftlimit;   /* default realtime blk soft limit */
  58 };
  59
  60 /*
  61  * Various quota information for individual filesystems.
  62  * The mount structure keeps a pointer to this.
  63  */
  64 struct xfs_quotainfo {
  65         struct radix_tree_root  qi_uquota_tree;
  66         struct radix_tree_root  qi_gquota_tree;
  67         struct radix_tree_root  qi_pquota_tree;
  68         struct mutex            qi_tree_lock;
  69         struct xfs_inode        *qi_uquotaip;   /* user quota inode */
  70         struct xfs_inode        *qi_gquotaip;   /* group quota inode */
  71         struct xfs_inode        *qi_pquotaip;   /* project quota inode */
  72         struct list_lru         qi_lru;
  73         int                     qi_dquots;
  74         struct mutex            qi_quotaofflock;/* to serialize quotaoff */
  75         xfs_filblks_t           qi_dqchunklen;  /* # BBs in a chunk of dqs */
  76         uint                    qi_dqperchunk;  /* # ondisk dq in above chunk */
  77         struct xfs_def_quota    qi_usr_default;
  78         struct xfs_def_quota    qi_grp_default;
  79         struct xfs_def_quota    qi_prj_default;
  80         struct shrinker         qi_shrinker;
  81 };
  82
  83 static inline struct radix_tree_root *
  84 xfs_dquot_tree(
  85         struct xfs_quotainfo    *qi,
  86         int                     type)
  87 {
  88         switch (type) {
  89         case XFS_DQ_USER:
  90                 return &qi->qi_uquota_tree;
  91         case XFS_DQ_GROUP:
  92                 return &qi->qi_gquota_tree;
  93         case XFS_DQ_PROJ:
  94                 return &qi->qi_pquota_tree;
  95         default:
  96                 ASSERT(0);
  97         }
  98         return NULL;
  99 }
 100
 101 static inline struct xfs_inode *
 102 xfs_quota_inode(xfs_mount_t *mp, uint dq_flags)
 103 {
 104         switch (dq_flags & XFS_DQ_ALLTYPES) {
 105         case XFS_DQ_USER:
 106                 return mp->m_quotainfo->qi_uquotaip;
 107         case XFS_DQ_GROUP:
 108                 return mp->m_quotainfo->qi_gquotaip;
 109         case XFS_DQ_PROJ:
 110                 return mp->m_quotainfo->qi_pquotaip;
 111         default:
 112                 ASSERT(0);
 113         }
 114         return NULL;
 115 }
 116
 117 static inline int
 118 xfs_dquot_type(struct xfs_dquot *dqp)
 119 {
 120         if (XFS_QM_ISUDQ(dqp))
 121                 return XFS_DQ_USER;
 122         if (XFS_QM_ISGDQ(dqp))
 123                 return XFS_DQ_GROUP;
 124         ASSERT(XFS_QM_ISPDQ(dqp));
 125         return XFS_DQ_PROJ;
 126 }
 127
 128 extern void     xfs_trans_mod_dquot(struct xfs_trans *tp, struct xfs_dquot *dqp,
 129                                     uint field, int64_t delta);
 130 extern void     xfs_trans_dqjoin(struct xfs_trans *, struct xfs_dquot *);
 131 extern void     xfs_trans_log_dquot(struct xfs_trans *, struct xfs_dquot *);
 132
 133 /*
 134  * We keep the usr, grp, and prj dquots separately so that locking will be
 135  * easier to do at commit time. All transactions that we know of at this point
 136  * affect no more than two dquots of one type. Hence, the TRANS_MAXDQS value.
 137  */
 138 enum {
 139         XFS_QM_TRANS_USR = 0,
 140         XFS_QM_TRANS_GRP,
 141         XFS_QM_TRANS_PRJ,
 142         XFS_QM_TRANS_DQTYPES
 143 };
 144 #define XFS_QM_TRANS_MAXDQS             2
 145 struct xfs_dquot_acct {
 146         struct xfs_dqtrx        dqs[XFS_QM_TRANS_DQTYPES][XFS_QM_TRANS_MAXDQS];
 147 };
 148
 149 /*
 150  * Users are allowed to have a usage exceeding their softlimit for
 151  * a period this long.
 152  */
 153 #define XFS_QM_BTIMELIMIT       (7 * 24*60*60)          /* 1 week */
 154 #define XFS_QM_RTBTIMELIMIT     (7 * 24*60*60)          /* 1 week */
 155 #define XFS_QM_ITIMELIMIT       (7 * 24*60*60)          /* 1 week */
 156
 157 #define XFS_QM_BWARNLIMIT       5
 158 #define XFS_QM_IWARNLIMIT       5
 159 #define XFS_QM_RTBWARNLIMIT     5
 160
 161 extern void             xfs_qm_destroy_quotainfo(struct xfs_mount *);
 162
 163 /* dquot stuff */
 164 extern void             xfs_qm_dqpurge_all(struct xfs_mount *, uint);
 165 extern void             xfs_qm_dqrele_all_inodes(struct xfs_mount *, uint);
 166
 167 /* quota ops */
 168 extern int              xfs_qm_scall_trunc_qfiles(struct xfs_mount *, uint);
 169 extern int              xfs_qm_scall_getquota(struct xfs_mount *, xfs_dqid_t,
 170                                         uint, struct qc_dqblk *);
 171 extern int              xfs_qm_scall_getquota_next(struct xfs_mount *,
 172                                         xfs_dqid_t *, uint, struct qc_dqblk *);
 173 extern int              xfs_qm_scall_setqlim(struct xfs_mount *, xfs_dqid_t, uint,
 174                                         struct qc_dqblk *);
 175 extern int              xfs_qm_scall_quotaon(struct xfs_mount *, uint);
 176 extern int              xfs_qm_scall_quotaoff(struct xfs_mount *, uint);
 177
 178 static inline struct xfs_def_quota *
 179 xfs_get_defquota(struct xfs_quotainfo *qi, int type)
 180 {
 181         switch (type) {
 182         case XFS_DQ_USER:
 183                 return &qi->qi_usr_default;
 184         case XFS_DQ_GROUP:
 185                 return &qi->qi_grp_default;
 186         case XFS_DQ_PROJ:
 187                 return &qi->qi_prj_default;
 188         default:
 189                 ASSERT(0);
 190                 return NULL;
 191         }
 192 }
 193
 194 #endif /* __XFS_QM_H__ */