]>
Commit | Line | Data |
---|---|---|
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__ */ |