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