fs/xfs/xfs_dquot.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_DQUOT_H__
   7 #define __XFS_DQUOT_H__
   8
   9 /*
  10  * Dquots are structures that hold quota information about a user or a group,
  11  * much like inodes are for files. In fact, dquots share many characteristics
  12  * with inodes. However, dquots can also be a centralized resource, relative
  13  * to a collection of inodes. In this respect, dquots share some characteristics
  14  * of the superblock.
  15  * XFS dquots exploit both those in its algorithms. They make every attempt
  16  * to not be a bottleneck when quotas are on and have minimal impact, if any,
  17  * when quotas are off.
  18  */
  19
  20 struct xfs_mount;
  21 struct xfs_trans;
  22
  23 enum {
  24         XFS_QLOWSP_1_PCNT = 0,
  25         XFS_QLOWSP_3_PCNT,
  26         XFS_QLOWSP_5_PCNT,
  27         XFS_QLOWSP_MAX
  28 };
  29
  30 struct xfs_dquot_res {
  31         /* Total resources allocated and reserved. */
  32         xfs_qcnt_t              reserved;
  33
  34         /* Total resources allocated. */
  35         xfs_qcnt_t              count;
  36
  37         /* Absolute and preferred limits. */
  38         xfs_qcnt_t              hardlimit;
  39         xfs_qcnt_t              softlimit;
  40
  41         /*
  42          * For root dquots, this is the default grace period, in seconds.
  43          * Otherwise, this is when the quota grace period expires,
  44          * in seconds since the Unix epoch.
  45          */
  46         time64_t                timer;
  47 };
  48
  49 static inline bool
  50 xfs_dquot_res_over_limits(
  51         const struct xfs_dquot_res      *qres)
  52 {
  53         if ((qres->softlimit && qres->softlimit < qres->reserved) ||
  54             (qres->hardlimit && qres->hardlimit < qres->reserved))
  55                 return true;
  56         return false;
  57 }
  58
  59 struct xfs_dquot_pre {
  60         xfs_qcnt_t              q_prealloc_lo_wmark;
  61         xfs_qcnt_t              q_prealloc_hi_wmark;
  62         int64_t                 q_low_space[XFS_QLOWSP_MAX];
  63 };
  64
  65 /*
  66  * The incore dquot structure
  67  */
  68 struct xfs_dquot {
  69         struct list_head        q_lru;
  70         struct xfs_mount        *q_mount;
  71         xfs_dqtype_t            q_type;
  72         uint16_t                q_flags;
  73         xfs_dqid_t              q_id;
  74         uint                    q_nrefs;
  75         int                     q_bufoffset;
  76         xfs_daddr_t             q_blkno;
  77         xfs_fileoff_t           q_fileoffset;
  78
  79         struct xfs_dquot_res    q_blk;  /* regular blocks */
  80         struct xfs_dquot_res    q_ino;  /* inodes */
  81         struct xfs_dquot_res    q_rtb;  /* realtime blocks */
  82
  83         struct xfs_dq_logitem   q_logitem;
  84
  85         struct xfs_dquot_pre    q_blk_prealloc;
  86         struct xfs_dquot_pre    q_rtb_prealloc;
  87
  88         struct mutex            q_qlock;
  89         struct completion       q_flush;
  90         atomic_t                q_pincount;
  91         struct wait_queue_head  q_pinwait;
  92 };
  93
  94 /*
  95  * Lock hierarchy for q_qlock:
  96  *      XFS_QLOCK_NORMAL is the implicit default,
  97  *      XFS_QLOCK_NESTED is the dquot with the higher id in xfs_dqlock2
  98  */
  99 enum {
 100         XFS_QLOCK_NORMAL = 0,
 101         XFS_QLOCK_NESTED,
 102 };
 103
 104 /*
 105  * Manage the q_flush completion queue embedded in the dquot. This completion
 106  * queue synchronizes processes attempting to flush the in-core dquot back to
 107  * disk.
 108  */
 109 static inline void xfs_dqflock(struct xfs_dquot *dqp)
 110 {
 111         wait_for_completion(&dqp->q_flush);
 112 }
 113
 114 static inline bool xfs_dqflock_nowait(struct xfs_dquot *dqp)
 115 {
 116         return try_wait_for_completion(&dqp->q_flush);
 117 }
 118
 119 static inline void xfs_dqfunlock(struct xfs_dquot *dqp)
 120 {
 121         complete(&dqp->q_flush);
 122 }
 123
 124 static inline int xfs_dqlock_nowait(struct xfs_dquot *dqp)
 125 {
 126         return mutex_trylock(&dqp->q_qlock);
 127 }
 128
 129 static inline void xfs_dqlock(struct xfs_dquot *dqp)
 130 {
 131         mutex_lock(&dqp->q_qlock);
 132 }
 133
 134 static inline void xfs_dqunlock(struct xfs_dquot *dqp)
 135 {
 136         mutex_unlock(&dqp->q_qlock);
 137 }
 138
 139 static inline int
 140 xfs_dquot_type(const struct xfs_dquot *dqp)
 141 {
 142         return dqp->q_type & XFS_DQTYPE_REC_MASK;
 143 }
 144
 145 static inline int xfs_this_quota_on(struct xfs_mount *mp, xfs_dqtype_t type)
 146 {
 147         switch (type) {
 148         case XFS_DQTYPE_USER:
 149                 return XFS_IS_UQUOTA_ON(mp);
 150         case XFS_DQTYPE_GROUP:
 151                 return XFS_IS_GQUOTA_ON(mp);
 152         case XFS_DQTYPE_PROJ:
 153                 return XFS_IS_PQUOTA_ON(mp);
 154         default:
 155                 return 0;
 156         }
 157 }
 158
 159 static inline struct xfs_dquot *xfs_inode_dquot(
 160         struct xfs_inode        *ip,
 161         xfs_dqtype_t            type)
 162 {
 163         switch (type) {
 164         case XFS_DQTYPE_USER:
 165                 return ip->i_udquot;
 166         case XFS_DQTYPE_GROUP:
 167                 return ip->i_gdquot;
 168         case XFS_DQTYPE_PROJ:
 169                 return ip->i_pdquot;
 170         default:
 171                 return NULL;
 172         }
 173 }
 174
 175 /* Decide if the dquot's limits are actually being enforced. */
 176 static inline bool
 177 xfs_dquot_is_enforced(
 178         const struct xfs_dquot  *dqp)
 179 {
 180         switch (xfs_dquot_type(dqp)) {
 181         case XFS_DQTYPE_USER:
 182                 return XFS_IS_UQUOTA_ENFORCED(dqp->q_mount);
 183         case XFS_DQTYPE_GROUP:
 184                 return XFS_IS_GQUOTA_ENFORCED(dqp->q_mount);
 185         case XFS_DQTYPE_PROJ:
 186                 return XFS_IS_PQUOTA_ENFORCED(dqp->q_mount);
 187         }
 188         ASSERT(0);
 189         return false;
 190 }
 191
 192 /*
 193  * Check whether a dquot is under low free space conditions. We assume the quota
 194  * is enabled and enforced.
 195  */
 196 static inline bool xfs_dquot_lowsp(struct xfs_dquot *dqp)
 197 {
 198         int64_t freesp;
 199
 200         freesp = dqp->q_blk.hardlimit - dqp->q_blk.reserved;
 201         if (freesp < dqp->q_blk_prealloc.q_low_space[XFS_QLOWSP_1_PCNT])
 202                 return true;
 203
 204         freesp = dqp->q_rtb.hardlimit - dqp->q_rtb.reserved;
 205         if (freesp < dqp->q_rtb_prealloc.q_low_space[XFS_QLOWSP_1_PCNT])
 206                 return true;
 207
 208         return false;
 209 }
 210
 211 void xfs_dquot_to_disk(struct xfs_disk_dquot *ddqp, struct xfs_dquot *dqp);
 212
 213 #define XFS_DQ_IS_LOCKED(dqp)   (mutex_is_locked(&((dqp)->q_qlock)))
 214 #define XFS_DQ_IS_DIRTY(dqp)    ((dqp)->q_flags & XFS_DQFLAG_DIRTY)
 215
 216 void            xfs_qm_dqdestroy(struct xfs_dquot *dqp);
 217 int             xfs_qm_dqflush(struct xfs_dquot *dqp, struct xfs_buf **bpp);
 218 void            xfs_qm_dqunpin_wait(struct xfs_dquot *dqp);
 219 void            xfs_qm_adjust_dqtimers(struct xfs_dquot *d);
 220 void            xfs_qm_adjust_dqlimits(struct xfs_dquot *d);
 221 xfs_dqid_t      xfs_qm_id_for_quotatype(struct xfs_inode *ip,
 222                                 xfs_dqtype_t type);
 223 int             xfs_qm_dqget(struct xfs_mount *mp, xfs_dqid_t id,
 224                                 xfs_dqtype_t type, bool can_alloc,
 225                                 struct xfs_dquot **dqpp);
 226 int             xfs_qm_dqget_inode(struct xfs_inode *ip, xfs_dqtype_t type,
 227                                 bool can_alloc, struct xfs_dquot **dqpp);
 228 int             xfs_qm_dqget_next(struct xfs_mount *mp, xfs_dqid_t id,
 229                                 xfs_dqtype_t type, struct xfs_dquot **dqpp);
 230 int             xfs_qm_dqget_uncached(struct xfs_mount *mp,
 231                                 xfs_dqid_t id, xfs_dqtype_t type,
 232                                 struct xfs_dquot **dqpp);
 233 void            xfs_qm_dqput(struct xfs_dquot *dqp);
 234
 235 void            xfs_dqlock2(struct xfs_dquot *, struct xfs_dquot *);
 236 void            xfs_dqlockn(struct xfs_dqtrx *q);
 237
 238 void            xfs_dquot_set_prealloc_limits(struct xfs_dquot *);
 239
 240 static inline struct xfs_dquot *xfs_qm_dqhold(struct xfs_dquot *dqp)
 241 {
 242         xfs_dqlock(dqp);
 243         dqp->q_nrefs++;
 244         xfs_dqunlock(dqp);
 245         return dqp;
 246 }
 247
 248 time64_t xfs_dquot_set_timeout(struct xfs_mount *mp, time64_t timeout);
 249 time64_t xfs_dquot_set_grace_period(time64_t grace);
 250
 251 void xfs_qm_init_dquot_blk(struct xfs_trans *tp, xfs_dqid_t id, xfs_dqtype_t
 252                 type, struct xfs_buf *bp);
 253
 254 #endif /* __XFS_DQUOT_H__ */