Line data    Source code

       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_cache        *xfs_dqtrx_cache;
      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_blk.hardlimit && \
      24             :         !dqp->q_blk.softlimit && \
      25             :         !dqp->q_rtb.hardlimit && \
      26             :         !dqp->q_rtb.softlimit && \
      27             :         !dqp->q_ino.hardlimit && \
      28             :         !dqp->q_ino.softlimit && \
      29             :         !dqp->q_blk.count && \
      30             :         !dqp->q_rtb.count && \
      31             :         !dqp->q_ino.count)
      32             : 
      33             : struct xfs_quota_limits {
      34             :         xfs_qcnt_t              hard;   /* default hard limit */
      35             :         xfs_qcnt_t              soft;   /* default soft limit */
      36             :         time64_t                time;   /* limit for timers */
      37             : };
      38             : 
      39             : /* Defaults for each quota type: time limits, warn limits, usage limits */
      40             : struct xfs_def_quota {
      41             :         struct xfs_quota_limits blk;
      42             :         struct xfs_quota_limits ino;
      43             :         struct xfs_quota_limits rtb;
      44             : };
      45             : 
      46             : /*
      47             :  * Various quota information for individual filesystems.
      48             :  * The mount structure keeps a pointer to this.
      49             :  */
      50             : struct xfs_quotainfo {
      51             :         struct radix_tree_root  qi_uquota_tree;
      52             :         struct radix_tree_root  qi_gquota_tree;
      53             :         struct radix_tree_root  qi_pquota_tree;
      54             :         struct mutex            qi_tree_lock;
      55             :         struct xfs_inode        *qi_uquotaip;   /* user quota inode */
      56             :         struct xfs_inode        *qi_gquotaip;   /* group quota inode */
      57             :         struct xfs_inode        *qi_pquotaip;   /* project quota inode */
      58             :         struct list_lru         qi_lru;
      59             :         int                     qi_dquots;
      60             :         struct mutex            qi_quotaofflock;/* to serialize quotaoff */
      61             :         xfs_filblks_t           qi_dqchunklen;  /* # BBs in a chunk of dqs */
      62             :         uint                    qi_dqperchunk;  /* # ondisk dq in above chunk */
      63             :         struct xfs_def_quota    qi_usr_default;
      64             :         struct xfs_def_quota    qi_grp_default;
      65             :         struct xfs_def_quota    qi_prj_default;
      66             :         struct shrinker         qi_shrinker;
      67             : 
      68             :         /* Minimum and maximum quota expiration timestamp values. */
      69             :         time64_t                qi_expiry_min;
      70             :         time64_t                qi_expiry_max;
      71             : };
      72             : 
      73             : static inline struct radix_tree_root *
      74    71171686 : xfs_dquot_tree(
      75             :         struct xfs_quotainfo    *qi,
      76             :         xfs_dqtype_t            type)
      77             : {
      78    71171686 :         switch (type) {
      79    27991572 :         case XFS_DQTYPE_USER:
      80    27991572 :                 return &qi->qi_uquota_tree;
      81    27381269 :         case XFS_DQTYPE_GROUP:
      82    27381269 :                 return &qi->qi_gquota_tree;
      83    15798845 :         case XFS_DQTYPE_PROJ:
      84    15798845 :                 return &qi->qi_pquota_tree;
      85           0 :         default:
      86           0 :                 ASSERT(0);
      87             :         }
      88           0 :         return NULL;
      89             : }
      90             : 
      91             : static inline struct xfs_inode *
      92    17746788 : xfs_quota_inode(struct xfs_mount *mp, xfs_dqtype_t type)
      93             : {
      94    17746788 :         switch (type) {
      95     8836167 :         case XFS_DQTYPE_USER:
      96     8836167 :                 return mp->m_quotainfo->qi_uquotaip;
      97     8213491 :         case XFS_DQTYPE_GROUP:
      98     8213491 :                 return mp->m_quotainfo->qi_gquotaip;
      99      697130 :         case XFS_DQTYPE_PROJ:
     100      697130 :                 return mp->m_quotainfo->qi_pquotaip;
     101           0 :         default:
     102           0 :                 ASSERT(0);
     103             :         }
     104           0 :         return NULL;
     105             : }
     106             : 
     107             : extern void     xfs_trans_mod_dquot(struct xfs_trans *tp, struct xfs_dquot *dqp,
     108             :                                     uint field, int64_t delta);
     109             : extern void     xfs_trans_dqjoin(struct xfs_trans *, struct xfs_dquot *);
     110             : extern void     xfs_trans_log_dquot(struct xfs_trans *, struct xfs_dquot *);
     111             : 
     112             : /*
     113             :  * We keep the usr, grp, and prj dquots separately so that locking will be
     114             :  * easier to do at commit time. All transactions that we know of at this point
     115             :  * affect no more than two dquots of one type. Hence, the TRANS_MAXDQS value.
     116             :  */
     117             : enum {
     118             :         XFS_QM_TRANS_USR = 0,
     119             :         XFS_QM_TRANS_GRP,
     120             :         XFS_QM_TRANS_PRJ,
     121             :         XFS_QM_TRANS_DQTYPES
     122             : };
     123             : #define XFS_QM_TRANS_MAXDQS             2
     124             : struct xfs_dquot_acct {
     125             :         struct xfs_dqtrx        dqs[XFS_QM_TRANS_DQTYPES][XFS_QM_TRANS_MAXDQS];
     126             : };
     127             : 
     128             : /*
     129             :  * Users are allowed to have a usage exceeding their softlimit for
     130             :  * a period this long.
     131             :  */
     132             : #define XFS_QM_BTIMELIMIT       (7 * 24*60*60)          /* 1 week */
     133             : #define XFS_QM_RTBTIMELIMIT     (7 * 24*60*60)          /* 1 week */
     134             : #define XFS_QM_ITIMELIMIT       (7 * 24*60*60)          /* 1 week */
     135             : 
     136             : extern void             xfs_qm_destroy_quotainfo(struct xfs_mount *);
     137             : 
     138             : /* quota ops */
     139             : extern int              xfs_qm_scall_trunc_qfiles(struct xfs_mount *, uint);
     140             : extern int              xfs_qm_scall_getquota(struct xfs_mount *mp,
     141             :                                         xfs_dqid_t id,
     142             :                                         xfs_dqtype_t type,
     143             :                                         struct qc_dqblk *dst);
     144             : extern int              xfs_qm_scall_getquota_next(struct xfs_mount *mp,
     145             :                                         xfs_dqid_t *id,
     146             :                                         xfs_dqtype_t type,
     147             :                                         struct qc_dqblk *dst);
     148             : extern int              xfs_qm_scall_setqlim(struct xfs_mount *mp,
     149             :                                         xfs_dqid_t id,
     150             :                                         xfs_dqtype_t type,
     151             :                                         struct qc_dqblk *newlim);
     152             : extern int              xfs_qm_scall_quotaon(struct xfs_mount *, uint);
     153             : extern int              xfs_qm_scall_quotaoff(struct xfs_mount *, uint);
     154             : 
     155             : static inline struct xfs_def_quota *
     156  2029060720 : xfs_get_defquota(struct xfs_quotainfo *qi, xfs_dqtype_t type)
     157             : {
     158  2029060720 :         switch (type) {
     159   703358695 :         case XFS_DQTYPE_USER:
     160   703358695 :                 return &qi->qi_usr_default;
     161   702609415 :         case XFS_DQTYPE_GROUP:
     162   702609415 :                 return &qi->qi_grp_default;
     163   623092610 :         case XFS_DQTYPE_PROJ:
     164   623092610 :                 return &qi->qi_prj_default;
     165           0 :         default:
     166           0 :                 ASSERT(0);
     167           0 :                 return NULL;
     168             :         }
     169             : }
     170             : 
     171             : #endif /* __XFS_QM_H__ */