Commit | Line | Data |
---|---|---|
fcafb71b CH |
1 | /* |
2 | * Copyright (c) 2008, Christoph Hellwig | |
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 | #include "xfs.h" | |
6ca1c906 | 19 | #include "xfs_format.h" |
239880ef | 20 | #include "xfs_log_format.h" |
7fd36c44 | 21 | #include "xfs_trans_resv.h" |
fcafb71b | 22 | #include "xfs_mount.h" |
a4fbe6ab | 23 | #include "xfs_inode.h" |
fcafb71b | 24 | #include "xfs_quota.h" |
fcafb71b | 25 | #include "xfs_trans.h" |
5d3684c2 JK |
26 | #include "xfs_trace.h" |
27 | #include "xfs_icache.h" | |
06f8e2d6 | 28 | #include "xfs_qm.h" |
fcafb71b CH |
29 | #include <linux/quota.h> |
30 | ||
31 | ||
5d3684c2 JK |
32 | static void |
33 | xfs_qm_fill_state( | |
34 | struct qc_type_state *tstate, | |
35 | struct xfs_mount *mp, | |
36 | struct xfs_inode *ip, | |
37 | xfs_ino_t ino) | |
fcafb71b | 38 | { |
5d3684c2 JK |
39 | struct xfs_quotainfo *q = mp->m_quotainfo; |
40 | bool tempqip = false; | |
41 | ||
42 | tstate->ino = ino; | |
43 | if (!ip && ino == NULLFSINO) | |
44 | return; | |
45 | if (!ip) { | |
46 | if (xfs_iget(mp, NULL, ino, 0, 0, &ip)) | |
47 | return; | |
48 | tempqip = true; | |
fcafb71b | 49 | } |
5d3684c2 JK |
50 | tstate->flags |= QCI_SYSFILE; |
51 | tstate->blocks = ip->i_d.di_nblocks; | |
52 | tstate->nextents = ip->i_d.di_nextents; | |
53 | tstate->spc_timelimit = q->qi_btimelimit; | |
54 | tstate->ino_timelimit = q->qi_itimelimit; | |
55 | tstate->rt_spc_timelimit = q->qi_rtbtimelimit; | |
56 | tstate->spc_warnlimit = q->qi_bwarnlimit; | |
57 | tstate->ino_warnlimit = q->qi_iwarnlimit; | |
58 | tstate->rt_spc_warnlimit = q->qi_rtbwarnlimit; | |
59 | if (tempqip) | |
60 | IRELE(ip); | |
fcafb71b CH |
61 | } |
62 | ||
5d3684c2 JK |
63 | /* |
64 | * Return quota status information, such as enforcements, quota file inode | |
65 | * numbers etc. | |
66 | */ | |
67 | static int | |
68 | xfs_fs_get_quota_state( | |
fcafb71b | 69 | struct super_block *sb, |
5d3684c2 | 70 | struct qc_state *state) |
fcafb71b | 71 | { |
5d3684c2 JK |
72 | struct xfs_mount *mp = XFS_M(sb); |
73 | struct xfs_quotainfo *q = mp->m_quotainfo; | |
fcafb71b | 74 | |
5d3684c2 | 75 | memset(state, 0, sizeof(*state)); |
fcafb71b | 76 | if (!XFS_IS_QUOTA_RUNNING(mp)) |
5d3684c2 JK |
77 | return 0; |
78 | state->s_incoredqs = q->qi_dquots; | |
79 | if (XFS_IS_UQUOTA_RUNNING(mp)) | |
80 | state->s_state[USRQUOTA].flags |= QCI_ACCT_ENABLED; | |
81 | if (XFS_IS_UQUOTA_ENFORCED(mp)) | |
82 | state->s_state[USRQUOTA].flags |= QCI_LIMITS_ENFORCED; | |
83 | if (XFS_IS_GQUOTA_RUNNING(mp)) | |
84 | state->s_state[GRPQUOTA].flags |= QCI_ACCT_ENABLED; | |
85 | if (XFS_IS_GQUOTA_ENFORCED(mp)) | |
86 | state->s_state[GRPQUOTA].flags |= QCI_LIMITS_ENFORCED; | |
87 | if (XFS_IS_PQUOTA_RUNNING(mp)) | |
88 | state->s_state[PRJQUOTA].flags |= QCI_ACCT_ENABLED; | |
89 | if (XFS_IS_PQUOTA_ENFORCED(mp)) | |
90 | state->s_state[PRJQUOTA].flags |= QCI_LIMITS_ENFORCED; | |
91 | ||
92 | xfs_qm_fill_state(&state->s_state[USRQUOTA], mp, q->qi_uquotaip, | |
93 | mp->m_sb.sb_uquotino); | |
94 | xfs_qm_fill_state(&state->s_state[GRPQUOTA], mp, q->qi_gquotaip, | |
95 | mp->m_sb.sb_gquotino); | |
96 | xfs_qm_fill_state(&state->s_state[PRJQUOTA], mp, q->qi_pquotaip, | |
97 | mp->m_sb.sb_pquotino); | |
98 | return 0; | |
fcafb71b CH |
99 | } |
100 | ||
5d5e3d57 | 101 | STATIC int |
5d3684c2 | 102 | xfs_quota_type(int type) |
5d5e3d57 | 103 | { |
5d3684c2 JK |
104 | switch (type) { |
105 | case USRQUOTA: | |
106 | return XFS_DQ_USER; | |
107 | case GRPQUOTA: | |
108 | return XFS_DQ_GROUP; | |
109 | default: | |
110 | return XFS_DQ_PROJ; | |
111 | } | |
5d5e3d57 CS |
112 | } |
113 | ||
c14cad9e JK |
114 | #define XFS_QC_SETINFO_MASK (QC_TIMER_MASK | QC_WARNS_MASK) |
115 | ||
116 | /* | |
117 | * Adjust quota timers & warnings | |
118 | */ | |
119 | static int | |
120 | xfs_fs_set_info( | |
121 | struct super_block *sb, | |
122 | int type, | |
123 | struct qc_info *info) | |
124 | { | |
125 | struct xfs_mount *mp = XFS_M(sb); | |
126 | struct qc_dqblk newlim; | |
127 | ||
128 | if (sb->s_flags & MS_RDONLY) | |
129 | return -EROFS; | |
130 | if (!XFS_IS_QUOTA_RUNNING(mp)) | |
131 | return -ENOSYS; | |
132 | if (!XFS_IS_QUOTA_ON(mp)) | |
133 | return -ESRCH; | |
134 | if (info->i_fieldmask & ~XFS_QC_SETINFO_MASK) | |
135 | return -EINVAL; | |
136 | if ((info->i_fieldmask & XFS_QC_SETINFO_MASK) == 0) | |
137 | return 0; | |
138 | ||
139 | newlim.d_fieldmask = info->i_fieldmask; | |
140 | newlim.d_spc_timer = info->i_spc_timelimit; | |
141 | newlim.d_ino_timer = info->i_ino_timelimit; | |
142 | newlim.d_rt_spc_timer = info->i_rt_spc_timelimit; | |
143 | newlim.d_ino_warns = info->i_ino_warnlimit; | |
144 | newlim.d_spc_warns = info->i_spc_warnlimit; | |
145 | newlim.d_rt_spc_warns = info->i_rt_spc_warnlimit; | |
146 | ||
147 | return xfs_qm_scall_setqlim(mp, 0, xfs_quota_type(type), &newlim); | |
148 | } | |
149 | ||
38e478c4 JK |
150 | static unsigned int |
151 | xfs_quota_flags(unsigned int uflags) | |
fcafb71b | 152 | { |
38e478c4 | 153 | unsigned int flags = 0; |
fcafb71b | 154 | |
ade7ce31 | 155 | if (uflags & FS_QUOTA_UDQ_ACCT) |
fcafb71b | 156 | flags |= XFS_UQUOTA_ACCT; |
ade7ce31 | 157 | if (uflags & FS_QUOTA_PDQ_ACCT) |
fcafb71b | 158 | flags |= XFS_PQUOTA_ACCT; |
ade7ce31 | 159 | if (uflags & FS_QUOTA_GDQ_ACCT) |
fcafb71b | 160 | flags |= XFS_GQUOTA_ACCT; |
ade7ce31 | 161 | if (uflags & FS_QUOTA_UDQ_ENFD) |
fcafb71b | 162 | flags |= XFS_UQUOTA_ENFD; |
83e782e1 CS |
163 | if (uflags & FS_QUOTA_GDQ_ENFD) |
164 | flags |= XFS_GQUOTA_ENFD; | |
165 | if (uflags & FS_QUOTA_PDQ_ENFD) | |
166 | flags |= XFS_PQUOTA_ENFD; | |
fcafb71b | 167 | |
38e478c4 JK |
168 | return flags; |
169 | } | |
170 | ||
171 | STATIC int | |
172 | xfs_quota_enable( | |
173 | struct super_block *sb, | |
174 | unsigned int uflags) | |
175 | { | |
176 | struct xfs_mount *mp = XFS_M(sb); | |
177 | ||
178 | if (sb->s_flags & MS_RDONLY) | |
179 | return -EROFS; | |
180 | if (!XFS_IS_QUOTA_RUNNING(mp)) | |
181 | return -ENOSYS; | |
182 | ||
183 | return xfs_qm_scall_quotaon(mp, xfs_quota_flags(uflags)); | |
184 | } | |
185 | ||
186 | STATIC int | |
187 | xfs_quota_disable( | |
188 | struct super_block *sb, | |
189 | unsigned int uflags) | |
190 | { | |
191 | struct xfs_mount *mp = XFS_M(sb); | |
192 | ||
193 | if (sb->s_flags & MS_RDONLY) | |
194 | return -EROFS; | |
195 | if (!XFS_IS_QUOTA_RUNNING(mp)) | |
196 | return -ENOSYS; | |
197 | if (!XFS_IS_QUOTA_ON(mp)) | |
198 | return -EINVAL; | |
fcafb71b | 199 | |
38e478c4 | 200 | return xfs_qm_scall_quotaoff(mp, xfs_quota_flags(uflags)); |
fcafb71b CH |
201 | } |
202 | ||
9da93f9b ES |
203 | STATIC int |
204 | xfs_fs_rm_xquota( | |
205 | struct super_block *sb, | |
206 | unsigned int uflags) | |
207 | { | |
208 | struct xfs_mount *mp = XFS_M(sb); | |
209 | unsigned int flags = 0; | |
2451337d | 210 | |
9da93f9b ES |
211 | if (sb->s_flags & MS_RDONLY) |
212 | return -EROFS; | |
213 | ||
214 | if (XFS_IS_QUOTA_ON(mp)) | |
215 | return -EINVAL; | |
216 | ||
217 | if (uflags & FS_USER_QUOTA) | |
218 | flags |= XFS_DQ_USER; | |
219 | if (uflags & FS_GROUP_QUOTA) | |
220 | flags |= XFS_DQ_GROUP; | |
74dc93a9 | 221 | if (uflags & FS_PROJ_QUOTA) |
9da93f9b ES |
222 | flags |= XFS_DQ_PROJ; |
223 | ||
2451337d DC |
224 | return xfs_qm_scall_trunc_qfiles(mp, flags); |
225 | } | |
9da93f9b | 226 | |
fcafb71b | 227 | STATIC int |
b9b2dd36 | 228 | xfs_fs_get_dqblk( |
fcafb71b | 229 | struct super_block *sb, |
74a8a103 | 230 | struct kqid qid, |
14bf61ff | 231 | struct qc_dqblk *qdq) |
fcafb71b CH |
232 | { |
233 | struct xfs_mount *mp = XFS_M(sb); | |
296c24e2 | 234 | xfs_dqid_t id; |
fcafb71b CH |
235 | |
236 | if (!XFS_IS_QUOTA_RUNNING(mp)) | |
237 | return -ENOSYS; | |
238 | if (!XFS_IS_QUOTA_ON(mp)) | |
239 | return -ESRCH; | |
240 | ||
296c24e2 ES |
241 | id = from_kqid(&init_user_ns, qid); |
242 | return xfs_qm_scall_getquota(mp, &id, | |
243 | xfs_quota_type(qid.type), qdq, 0); | |
244 | } | |
245 | ||
246 | /* Return quota info for active quota >= this qid */ | |
247 | STATIC int | |
248 | xfs_fs_get_nextdqblk( | |
249 | struct super_block *sb, | |
250 | struct kqid *qid, | |
251 | struct qc_dqblk *qdq) | |
252 | { | |
253 | int ret; | |
254 | struct xfs_mount *mp = XFS_M(sb); | |
255 | xfs_dqid_t id; | |
256 | ||
257 | if (!XFS_IS_QUOTA_RUNNING(mp)) | |
258 | return -ENOSYS; | |
259 | if (!XFS_IS_QUOTA_ON(mp)) | |
260 | return -ESRCH; | |
261 | ||
262 | id = from_kqid(&init_user_ns, *qid); | |
263 | ret = xfs_qm_scall_getquota(mp, &id, | |
264 | xfs_quota_type(qid->type), qdq, | |
265 | XFS_QMOPT_DQNEXT); | |
266 | if (ret) | |
267 | return ret; | |
268 | ||
269 | /* ID may be different, so convert back what we got */ | |
270 | *qid = make_kqid(current_user_ns(), qid->type, id); | |
271 | return 0; | |
272 | ||
fcafb71b CH |
273 | } |
274 | ||
275 | STATIC int | |
c472b432 | 276 | xfs_fs_set_dqblk( |
fcafb71b | 277 | struct super_block *sb, |
74a8a103 | 278 | struct kqid qid, |
14bf61ff | 279 | struct qc_dqblk *qdq) |
fcafb71b CH |
280 | { |
281 | struct xfs_mount *mp = XFS_M(sb); | |
282 | ||
283 | if (sb->s_flags & MS_RDONLY) | |
284 | return -EROFS; | |
285 | if (!XFS_IS_QUOTA_RUNNING(mp)) | |
286 | return -ENOSYS; | |
287 | if (!XFS_IS_QUOTA_ON(mp)) | |
288 | return -ESRCH; | |
fcafb71b | 289 | |
2451337d | 290 | return xfs_qm_scall_setqlim(mp, from_kqid(&init_user_ns, qid), |
14bf61ff | 291 | xfs_quota_type(qid.type), qdq); |
fcafb71b CH |
292 | } |
293 | ||
0d54b217 | 294 | const struct quotactl_ops xfs_quotactl_operations = { |
5d3684c2 | 295 | .get_state = xfs_fs_get_quota_state, |
c14cad9e | 296 | .set_info = xfs_fs_set_info, |
38e478c4 JK |
297 | .quota_enable = xfs_quota_enable, |
298 | .quota_disable = xfs_quota_disable, | |
9da93f9b | 299 | .rm_xquota = xfs_fs_rm_xquota, |
b9b2dd36 | 300 | .get_dqblk = xfs_fs_get_dqblk, |
296c24e2 | 301 | .get_nextdqblk = xfs_fs_get_nextdqblk, |
c472b432 | 302 | .set_dqblk = xfs_fs_set_dqblk, |
fcafb71b | 303 | }; |