Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Copyright (c) 2000-2004 Silicon Graphics, Inc. All Rights Reserved. | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify it | |
5 | * under the terms of version 2 of the GNU General Public License as | |
6 | * published by the Free Software Foundation. | |
7 | * | |
8 | * This program is distributed in the hope that it would be useful, but | |
9 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
11 | * | |
12 | * Further, this software is distributed without any warranty that it is | |
13 | * free of the rightful claim of any third person regarding infringement | |
14 | * or the like. Any license provided herein, whether implied or | |
15 | * otherwise, applies only to this software file. Patent licenses, if | |
16 | * any, provided herein do not apply to combinations of this program with | |
17 | * other software, or any other product whatsoever. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License along | |
20 | * with this program; if not, write the Free Software Foundation, Inc., 59 | |
21 | * Temple Place - Suite 330, Boston MA 02111-1307, USA. | |
22 | * | |
23 | * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy, | |
24 | * Mountain View, CA 94043, or: | |
25 | * | |
26 | * http://www.sgi.com | |
27 | * | |
28 | * For further information regarding this notice, see: | |
29 | * | |
30 | * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/ | |
31 | */ | |
32 | ||
33 | #include "xfs.h" | |
34 | #include "xfs_fs.h" | |
35 | #include "xfs_inum.h" | |
36 | #include "xfs_log.h" | |
37 | #include "xfs_clnt.h" | |
38 | #include "xfs_trans.h" | |
39 | #include "xfs_sb.h" | |
40 | #include "xfs_dir.h" | |
41 | #include "xfs_dir2.h" | |
42 | #include "xfs_alloc.h" | |
43 | #include "xfs_dmapi.h" | |
44 | #include "xfs_quota.h" | |
45 | #include "xfs_mount.h" | |
46 | #include "xfs_alloc_btree.h" | |
47 | #include "xfs_bmap_btree.h" | |
48 | #include "xfs_ialloc_btree.h" | |
49 | #include "xfs_btree.h" | |
50 | #include "xfs_ialloc.h" | |
51 | #include "xfs_attr_sf.h" | |
52 | #include "xfs_dir_sf.h" | |
53 | #include "xfs_dir2_sf.h" | |
54 | #include "xfs_dinode.h" | |
55 | #include "xfs_inode.h" | |
56 | #include "xfs_bmap.h" | |
57 | #include "xfs_bit.h" | |
58 | #include "xfs_rtalloc.h" | |
59 | #include "xfs_error.h" | |
60 | #include "xfs_itable.h" | |
61 | #include "xfs_rw.h" | |
62 | #include "xfs_acl.h" | |
63 | #include "xfs_cap.h" | |
64 | #include "xfs_mac.h" | |
65 | #include "xfs_attr.h" | |
66 | #include "xfs_buf_item.h" | |
67 | ||
68 | #include "xfs_qm.h" | |
69 | ||
70 | #define MNTOPT_QUOTA "quota" /* disk quotas (user) */ | |
71 | #define MNTOPT_NOQUOTA "noquota" /* no quotas */ | |
72 | #define MNTOPT_USRQUOTA "usrquota" /* user quota enabled */ | |
73 | #define MNTOPT_GRPQUOTA "grpquota" /* group quota enabled */ | |
74 | #define MNTOPT_UQUOTA "uquota" /* user quota (IRIX variant) */ | |
75 | #define MNTOPT_GQUOTA "gquota" /* group quota (IRIX variant) */ | |
76 | #define MNTOPT_UQUOTANOENF "uqnoenforce"/* user quota limit enforcement */ | |
77 | #define MNTOPT_GQUOTANOENF "gqnoenforce"/* group quota limit enforcement */ | |
78 | #define MNTOPT_QUOTANOENF "qnoenforce" /* same as uqnoenforce */ | |
79 | ||
80 | STATIC int | |
81 | xfs_qm_parseargs( | |
82 | struct bhv_desc *bhv, | |
83 | char *options, | |
84 | struct xfs_mount_args *args, | |
85 | int update) | |
86 | { | |
87 | size_t length; | |
88 | char *local_options = options; | |
89 | char *this_char; | |
90 | int error; | |
91 | int referenced = update; | |
92 | ||
93 | while ((this_char = strsep(&local_options, ",")) != NULL) { | |
94 | length = strlen(this_char); | |
95 | if (local_options) | |
96 | length++; | |
97 | ||
98 | if (!strcmp(this_char, MNTOPT_NOQUOTA)) { | |
99 | args->flags &= ~(XFSMNT_UQUOTAENF|XFSMNT_UQUOTA); | |
100 | args->flags &= ~(XFSMNT_GQUOTAENF|XFSMNT_GQUOTA); | |
101 | referenced = update; | |
102 | } else if (!strcmp(this_char, MNTOPT_QUOTA) || | |
103 | !strcmp(this_char, MNTOPT_UQUOTA) || | |
104 | !strcmp(this_char, MNTOPT_USRQUOTA)) { | |
105 | args->flags |= XFSMNT_UQUOTA | XFSMNT_UQUOTAENF; | |
106 | referenced = 1; | |
107 | } else if (!strcmp(this_char, MNTOPT_QUOTANOENF) || | |
108 | !strcmp(this_char, MNTOPT_UQUOTANOENF)) { | |
109 | args->flags |= XFSMNT_UQUOTA; | |
110 | args->flags &= ~XFSMNT_UQUOTAENF; | |
111 | referenced = 1; | |
112 | } else if (!strcmp(this_char, MNTOPT_GQUOTA) || | |
113 | !strcmp(this_char, MNTOPT_GRPQUOTA)) { | |
114 | args->flags |= XFSMNT_GQUOTA | XFSMNT_GQUOTAENF; | |
115 | referenced = 1; | |
116 | } else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) { | |
117 | args->flags |= XFSMNT_GQUOTA; | |
118 | args->flags &= ~XFSMNT_GQUOTAENF; | |
119 | referenced = 1; | |
120 | } else { | |
121 | if (local_options) | |
122 | *(local_options-1) = ','; | |
123 | continue; | |
124 | } | |
125 | ||
126 | while (length--) | |
127 | *this_char++ = ','; | |
128 | } | |
129 | ||
130 | PVFS_PARSEARGS(BHV_NEXT(bhv), options, args, update, error); | |
131 | if (!error && !referenced) | |
132 | bhv_remove_vfsops(bhvtovfs(bhv), VFS_POSITION_QM); | |
133 | return error; | |
134 | } | |
135 | ||
136 | STATIC int | |
137 | xfs_qm_showargs( | |
138 | struct bhv_desc *bhv, | |
139 | struct seq_file *m) | |
140 | { | |
141 | struct vfs *vfsp = bhvtovfs(bhv); | |
142 | struct xfs_mount *mp = XFS_VFSTOM(vfsp); | |
143 | int error; | |
144 | ||
145 | if (mp->m_qflags & XFS_UQUOTA_ACCT) { | |
146 | (mp->m_qflags & XFS_UQUOTA_ENFD) ? | |
147 | seq_puts(m, "," MNTOPT_USRQUOTA) : | |
148 | seq_puts(m, "," MNTOPT_UQUOTANOENF); | |
149 | } | |
150 | ||
151 | if (mp->m_qflags & XFS_GQUOTA_ACCT) { | |
152 | (mp->m_qflags & XFS_GQUOTA_ENFD) ? | |
153 | seq_puts(m, "," MNTOPT_GRPQUOTA) : | |
154 | seq_puts(m, "," MNTOPT_GQUOTANOENF); | |
155 | } | |
156 | ||
157 | if (!(mp->m_qflags & (XFS_UQUOTA_ACCT|XFS_GQUOTA_ACCT))) | |
158 | seq_puts(m, "," MNTOPT_NOQUOTA); | |
159 | ||
160 | PVFS_SHOWARGS(BHV_NEXT(bhv), m, error); | |
161 | return error; | |
162 | } | |
163 | ||
164 | STATIC int | |
165 | xfs_qm_mount( | |
166 | struct bhv_desc *bhv, | |
167 | struct xfs_mount_args *args, | |
168 | struct cred *cr) | |
169 | { | |
170 | struct vfs *vfsp = bhvtovfs(bhv); | |
171 | struct xfs_mount *mp = XFS_VFSTOM(vfsp); | |
172 | int error; | |
173 | ||
174 | if (args->flags & (XFSMNT_UQUOTA | XFSMNT_GQUOTA)) | |
175 | xfs_qm_mount_quotainit(mp, args->flags); | |
176 | PVFS_MOUNT(BHV_NEXT(bhv), args, cr, error); | |
177 | return error; | |
178 | } | |
179 | ||
180 | STATIC int | |
181 | xfs_qm_syncall( | |
182 | struct bhv_desc *bhv, | |
183 | int flags, | |
184 | cred_t *credp) | |
185 | { | |
186 | struct vfs *vfsp = bhvtovfs(bhv); | |
187 | struct xfs_mount *mp = XFS_VFSTOM(vfsp); | |
188 | int error; | |
189 | ||
190 | /* | |
191 | * Get the Quota Manager to flush the dquots. | |
192 | */ | |
193 | if (XFS_IS_QUOTA_ON(mp)) { | |
194 | if ((error = xfs_qm_sync(mp, flags))) { | |
195 | /* | |
196 | * If we got an IO error, we will be shutting down. | |
197 | * So, there's nothing more for us to do here. | |
198 | */ | |
199 | ASSERT(error != EIO || XFS_FORCED_SHUTDOWN(mp)); | |
200 | if (XFS_FORCED_SHUTDOWN(mp)) { | |
201 | return XFS_ERROR(error); | |
202 | } | |
203 | } | |
204 | } | |
205 | PVFS_SYNC(BHV_NEXT(bhv), flags, credp, error); | |
206 | return error; | |
207 | } | |
208 | ||
209 | /* | |
210 | * Clear the quotaflags in memory and in the superblock. | |
211 | */ | |
212 | void | |
213 | xfs_mount_reset_sbqflags( | |
214 | xfs_mount_t *mp) | |
215 | { | |
216 | xfs_trans_t *tp; | |
217 | unsigned long s; | |
218 | ||
219 | mp->m_qflags = 0; | |
220 | /* | |
221 | * It is OK to look at sb_qflags here in mount path, | |
222 | * without SB_LOCK. | |
223 | */ | |
224 | if (mp->m_sb.sb_qflags == 0) | |
225 | return; | |
226 | s = XFS_SB_LOCK(mp); | |
227 | mp->m_sb.sb_qflags = 0; | |
228 | XFS_SB_UNLOCK(mp, s); | |
229 | ||
230 | /* | |
231 | * if the fs is readonly, let the incore superblock run | |
232 | * with quotas off but don't flush the update out to disk | |
233 | */ | |
234 | if (XFS_MTOVFS(mp)->vfs_flag & VFS_RDONLY) | |
235 | return; | |
236 | #ifdef QUOTADEBUG | |
237 | xfs_fs_cmn_err(CE_NOTE, mp, "Writing superblock quota changes"); | |
238 | #endif | |
239 | tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE); | |
240 | if (xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0, | |
241 | XFS_DEFAULT_LOG_COUNT)) { | |
242 | xfs_trans_cancel(tp, 0); | |
243 | xfs_fs_cmn_err(CE_ALERT, mp, | |
244 | "xfs_mount_reset_sbqflags: Superblock update failed!"); | |
245 | return; | |
246 | } | |
247 | xfs_mod_sb(tp, XFS_SB_QFLAGS); | |
248 | xfs_trans_commit(tp, 0, NULL); | |
249 | } | |
250 | ||
251 | STATIC int | |
252 | xfs_qm_newmount( | |
253 | xfs_mount_t *mp, | |
254 | uint *needquotamount, | |
255 | uint *quotaflags) | |
256 | { | |
257 | uint quotaondisk; | |
258 | uint uquotaondisk = 0, gquotaondisk = 0; | |
259 | ||
260 | *quotaflags = 0; | |
261 | *needquotamount = B_FALSE; | |
262 | ||
263 | quotaondisk = XFS_SB_VERSION_HASQUOTA(&mp->m_sb) && | |
264 | mp->m_sb.sb_qflags & (XFS_UQUOTA_ACCT|XFS_GQUOTA_ACCT); | |
265 | ||
266 | if (quotaondisk) { | |
267 | uquotaondisk = mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT; | |
268 | gquotaondisk = mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT; | |
269 | } | |
270 | ||
271 | /* | |
272 | * If the device itself is read-only, we can't allow | |
273 | * the user to change the state of quota on the mount - | |
274 | * this would generate a transaction on the ro device, | |
275 | * which would lead to an I/O error and shutdown | |
276 | */ | |
277 | ||
278 | if (((uquotaondisk && !XFS_IS_UQUOTA_ON(mp)) || | |
279 | (!uquotaondisk && XFS_IS_UQUOTA_ON(mp)) || | |
280 | (gquotaondisk && !XFS_IS_GQUOTA_ON(mp)) || | |
281 | (!gquotaondisk && XFS_IS_GQUOTA_ON(mp))) && | |
282 | xfs_dev_is_read_only(mp, "changing quota state")) { | |
283 | cmn_err(CE_WARN, | |
284 | "XFS: please mount with%s%s%s.", | |
285 | (!quotaondisk ? "out quota" : ""), | |
286 | (uquotaondisk ? " usrquota" : ""), | |
287 | (gquotaondisk ? " grpquota" : "")); | |
288 | return XFS_ERROR(EPERM); | |
289 | } | |
290 | ||
291 | if (XFS_IS_QUOTA_ON(mp) || quotaondisk) { | |
292 | /* | |
293 | * Call mount_quotas at this point only if we won't have to do | |
294 | * a quotacheck. | |
295 | */ | |
296 | if (quotaondisk && !XFS_QM_NEED_QUOTACHECK(mp)) { | |
297 | /* | |
298 | * If an error occured, qm_mount_quotas code | |
299 | * has already disabled quotas. So, just finish | |
300 | * mounting, and get on with the boring life | |
301 | * without disk quotas. | |
302 | */ | |
303 | xfs_qm_mount_quotas(mp, 0); | |
304 | } else { | |
305 | /* | |
306 | * Clear the quota flags, but remember them. This | |
307 | * is so that the quota code doesn't get invoked | |
308 | * before we're ready. This can happen when an | |
309 | * inode goes inactive and wants to free blocks, | |
310 | * or via xfs_log_mount_finish. | |
311 | */ | |
312 | *needquotamount = B_TRUE; | |
313 | *quotaflags = mp->m_qflags; | |
314 | mp->m_qflags = 0; | |
315 | } | |
316 | } | |
317 | ||
318 | return 0; | |
319 | } | |
320 | ||
321 | STATIC int | |
322 | xfs_qm_endmount( | |
323 | xfs_mount_t *mp, | |
324 | uint needquotamount, | |
325 | uint quotaflags, | |
326 | int mfsi_flags) | |
327 | { | |
328 | if (needquotamount) { | |
329 | ASSERT(mp->m_qflags == 0); | |
330 | mp->m_qflags = quotaflags; | |
331 | xfs_qm_mount_quotas(mp, mfsi_flags); | |
332 | } | |
333 | ||
334 | #if defined(DEBUG) && defined(XFS_LOUD_RECOVERY) | |
335 | if (! (XFS_IS_QUOTA_ON(mp))) | |
336 | xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas not turned on"); | |
337 | else | |
338 | xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas turned on"); | |
339 | #endif | |
340 | ||
341 | #ifdef QUOTADEBUG | |
342 | if (XFS_IS_QUOTA_ON(mp) && xfs_qm_internalqcheck(mp)) | |
343 | cmn_err(CE_WARN, "XFS: mount internalqcheck failed"); | |
344 | #endif | |
345 | ||
346 | return 0; | |
347 | } | |
348 | ||
349 | STATIC void | |
350 | xfs_qm_dqrele_null( | |
351 | xfs_dquot_t *dq) | |
352 | { | |
353 | /* | |
354 | * Called from XFS, where we always check first for a NULL dquot. | |
355 | */ | |
356 | if (!dq) | |
357 | return; | |
358 | xfs_qm_dqrele(dq); | |
359 | } | |
360 | ||
361 | ||
ba0f32d4 | 362 | STATIC struct xfs_qmops xfs_qmcore_xfs = { |
1da177e4 LT |
363 | .xfs_qminit = xfs_qm_newmount, |
364 | .xfs_qmdone = xfs_qm_unmount_quotadestroy, | |
365 | .xfs_qmmount = xfs_qm_endmount, | |
366 | .xfs_qmunmount = xfs_qm_unmount_quotas, | |
367 | .xfs_dqrele = xfs_qm_dqrele_null, | |
368 | .xfs_dqattach = xfs_qm_dqattach, | |
369 | .xfs_dqdetach = xfs_qm_dqdetach, | |
370 | .xfs_dqpurgeall = xfs_qm_dqpurge_all, | |
371 | .xfs_dqvopalloc = xfs_qm_vop_dqalloc, | |
372 | .xfs_dqvopcreate = xfs_qm_vop_dqattach_and_dqmod_newinode, | |
373 | .xfs_dqvoprename = xfs_qm_vop_rename_dqattach, | |
374 | .xfs_dqvopchown = xfs_qm_vop_chown, | |
375 | .xfs_dqvopchownresv = xfs_qm_vop_chown_reserve, | |
376 | .xfs_dqtrxops = &xfs_trans_dquot_ops, | |
377 | }; | |
378 | ||
379 | struct bhv_vfsops xfs_qmops = { { | |
380 | BHV_IDENTITY_INIT(VFS_BHV_QM, VFS_POSITION_QM), | |
381 | .vfs_parseargs = xfs_qm_parseargs, | |
382 | .vfs_showargs = xfs_qm_showargs, | |
383 | .vfs_mount = xfs_qm_mount, | |
384 | .vfs_sync = xfs_qm_syncall, | |
385 | .vfs_quotactl = xfs_qm_quotactl, }, | |
386 | }; | |
387 | ||
388 | ||
389 | void __init | |
390 | xfs_qm_init(void) | |
391 | { | |
392 | static char message[] __initdata = | |
393 | KERN_INFO "SGI XFS Quota Management subsystem\n"; | |
394 | ||
395 | printk(message); | |
396 | mutex_init(&xfs_Gqm_lock, MUTEX_DEFAULT, "xfs_qmlock"); | |
397 | vfs_bhv_set_custom(&xfs_qmops, &xfs_qmcore_xfs); | |
398 | xfs_qm_init_procfs(); | |
399 | } | |
400 | ||
401 | void __exit | |
402 | xfs_qm_exit(void) | |
403 | { | |
404 | vfs_bhv_clr_custom(&xfs_qmops); | |
405 | xfs_qm_cleanup_procfs(); | |
406 | if (qm_dqzone) | |
407 | kmem_cache_destroy(qm_dqzone); | |
408 | if (qm_dqtrxzone) | |
409 | kmem_cache_destroy(qm_dqtrxzone); | |
410 | } |