blob: dc3c37a1e1585702eeb814da992b216b57f4c96d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 */
Nathan Scottc8ad20f2005-06-21 15:38:48 +100074#define MNTOPT_PRJQUOTA "prjquota" /* project quota enabled */
Linus Torvalds1da177e2005-04-16 15:20:36 -070075#define MNTOPT_UQUOTA "uquota" /* user quota (IRIX variant) */
76#define MNTOPT_GQUOTA "gquota" /* group quota (IRIX variant) */
Nathan Scottc8ad20f2005-06-21 15:38:48 +100077#define MNTOPT_PQUOTA "pquota" /* project quota (IRIX variant) */
Linus Torvalds1da177e2005-04-16 15:20:36 -070078#define MNTOPT_UQUOTANOENF "uqnoenforce"/* user quota limit enforcement */
79#define MNTOPT_GQUOTANOENF "gqnoenforce"/* group quota limit enforcement */
Nathan Scottc8ad20f2005-06-21 15:38:48 +100080#define MNTOPT_PQUOTANOENF "pqnoenforce"/* project quota limit enforcement */
Linus Torvalds1da177e2005-04-16 15:20:36 -070081#define MNTOPT_QUOTANOENF "qnoenforce" /* same as uqnoenforce */
82
83STATIC int
84xfs_qm_parseargs(
85 struct bhv_desc *bhv,
86 char *options,
87 struct xfs_mount_args *args,
88 int update)
89{
90 size_t length;
91 char *local_options = options;
92 char *this_char;
93 int error;
94 int referenced = update;
95
96 while ((this_char = strsep(&local_options, ",")) != NULL) {
97 length = strlen(this_char);
98 if (local_options)
99 length++;
100
101 if (!strcmp(this_char, MNTOPT_NOQUOTA)) {
102 args->flags &= ~(XFSMNT_UQUOTAENF|XFSMNT_UQUOTA);
103 args->flags &= ~(XFSMNT_GQUOTAENF|XFSMNT_GQUOTA);
104 referenced = update;
105 } else if (!strcmp(this_char, MNTOPT_QUOTA) ||
106 !strcmp(this_char, MNTOPT_UQUOTA) ||
107 !strcmp(this_char, MNTOPT_USRQUOTA)) {
108 args->flags |= XFSMNT_UQUOTA | XFSMNT_UQUOTAENF;
109 referenced = 1;
110 } else if (!strcmp(this_char, MNTOPT_QUOTANOENF) ||
111 !strcmp(this_char, MNTOPT_UQUOTANOENF)) {
112 args->flags |= XFSMNT_UQUOTA;
113 args->flags &= ~XFSMNT_UQUOTAENF;
114 referenced = 1;
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000115 } else if (!strcmp(this_char, MNTOPT_PQUOTA) ||
116 !strcmp(this_char, MNTOPT_PRJQUOTA)) {
117 args->flags |= XFSMNT_PQUOTA | XFSMNT_PQUOTAENF;
118 referenced = 1;
119 } else if (!strcmp(this_char, MNTOPT_PQUOTANOENF)) {
120 args->flags |= XFSMNT_PQUOTA;
121 args->flags &= ~XFSMNT_PQUOTAENF;
122 referenced = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 } else if (!strcmp(this_char, MNTOPT_GQUOTA) ||
124 !strcmp(this_char, MNTOPT_GRPQUOTA)) {
125 args->flags |= XFSMNT_GQUOTA | XFSMNT_GQUOTAENF;
126 referenced = 1;
127 } else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
128 args->flags |= XFSMNT_GQUOTA;
129 args->flags &= ~XFSMNT_GQUOTAENF;
130 referenced = 1;
131 } else {
132 if (local_options)
133 *(local_options-1) = ',';
134 continue;
135 }
136
137 while (length--)
138 *this_char++ = ',';
139 }
140
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000141 if ((args->flags & XFSMNT_GQUOTA) && (args->flags & XFSMNT_PQUOTA)) {
142 cmn_err(CE_WARN,
143 "XFS: cannot mount with both project and group quota");
144 return XFS_ERROR(EINVAL);
145 }
146
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 PVFS_PARSEARGS(BHV_NEXT(bhv), options, args, update, error);
148 if (!error && !referenced)
149 bhv_remove_vfsops(bhvtovfs(bhv), VFS_POSITION_QM);
150 return error;
151}
152
153STATIC int
154xfs_qm_showargs(
155 struct bhv_desc *bhv,
156 struct seq_file *m)
157{
158 struct vfs *vfsp = bhvtovfs(bhv);
159 struct xfs_mount *mp = XFS_VFSTOM(vfsp);
160 int error;
161
162 if (mp->m_qflags & XFS_UQUOTA_ACCT) {
163 (mp->m_qflags & XFS_UQUOTA_ENFD) ?
164 seq_puts(m, "," MNTOPT_USRQUOTA) :
165 seq_puts(m, "," MNTOPT_UQUOTANOENF);
166 }
167
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000168 if (mp->m_qflags & XFS_PQUOTA_ACCT) {
169 (mp->m_qflags & XFS_OQUOTA_ENFD) ?
170 seq_puts(m, "," MNTOPT_PRJQUOTA) :
171 seq_puts(m, "," MNTOPT_PQUOTANOENF);
172 }
173
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 if (mp->m_qflags & XFS_GQUOTA_ACCT) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000175 (mp->m_qflags & XFS_OQUOTA_ENFD) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 seq_puts(m, "," MNTOPT_GRPQUOTA) :
177 seq_puts(m, "," MNTOPT_GQUOTANOENF);
178 }
179
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000180 if (!(mp->m_qflags & XFS_ALL_QUOTA_ACCT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 seq_puts(m, "," MNTOPT_NOQUOTA);
182
183 PVFS_SHOWARGS(BHV_NEXT(bhv), m, error);
184 return error;
185}
186
187STATIC int
188xfs_qm_mount(
189 struct bhv_desc *bhv,
190 struct xfs_mount_args *args,
191 struct cred *cr)
192{
193 struct vfs *vfsp = bhvtovfs(bhv);
194 struct xfs_mount *mp = XFS_VFSTOM(vfsp);
195 int error;
196
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000197 if (args->flags & (XFSMNT_UQUOTA | XFSMNT_GQUOTA | XFSMNT_PQUOTA))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 xfs_qm_mount_quotainit(mp, args->flags);
199 PVFS_MOUNT(BHV_NEXT(bhv), args, cr, error);
200 return error;
201}
202
203STATIC int
204xfs_qm_syncall(
205 struct bhv_desc *bhv,
206 int flags,
207 cred_t *credp)
208{
209 struct vfs *vfsp = bhvtovfs(bhv);
210 struct xfs_mount *mp = XFS_VFSTOM(vfsp);
211 int error;
212
213 /*
214 * Get the Quota Manager to flush the dquots.
215 */
216 if (XFS_IS_QUOTA_ON(mp)) {
217 if ((error = xfs_qm_sync(mp, flags))) {
218 /*
219 * If we got an IO error, we will be shutting down.
220 * So, there's nothing more for us to do here.
221 */
222 ASSERT(error != EIO || XFS_FORCED_SHUTDOWN(mp));
223 if (XFS_FORCED_SHUTDOWN(mp)) {
224 return XFS_ERROR(error);
225 }
226 }
227 }
228 PVFS_SYNC(BHV_NEXT(bhv), flags, credp, error);
229 return error;
230}
231
232/*
233 * Clear the quotaflags in memory and in the superblock.
234 */
235void
236xfs_mount_reset_sbqflags(
237 xfs_mount_t *mp)
238{
239 xfs_trans_t *tp;
240 unsigned long s;
241
242 mp->m_qflags = 0;
243 /*
244 * It is OK to look at sb_qflags here in mount path,
245 * without SB_LOCK.
246 */
247 if (mp->m_sb.sb_qflags == 0)
248 return;
249 s = XFS_SB_LOCK(mp);
250 mp->m_sb.sb_qflags = 0;
251 XFS_SB_UNLOCK(mp, s);
252
253 /*
254 * if the fs is readonly, let the incore superblock run
255 * with quotas off but don't flush the update out to disk
256 */
257 if (XFS_MTOVFS(mp)->vfs_flag & VFS_RDONLY)
258 return;
259#ifdef QUOTADEBUG
260 xfs_fs_cmn_err(CE_NOTE, mp, "Writing superblock quota changes");
261#endif
262 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
263 if (xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
264 XFS_DEFAULT_LOG_COUNT)) {
265 xfs_trans_cancel(tp, 0);
266 xfs_fs_cmn_err(CE_ALERT, mp,
267 "xfs_mount_reset_sbqflags: Superblock update failed!");
268 return;
269 }
270 xfs_mod_sb(tp, XFS_SB_QFLAGS);
271 xfs_trans_commit(tp, 0, NULL);
272}
273
274STATIC int
275xfs_qm_newmount(
276 xfs_mount_t *mp,
277 uint *needquotamount,
278 uint *quotaflags)
279{
280 uint quotaondisk;
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000281 uint uquotaondisk = 0, gquotaondisk = 0, pquotaondisk = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282
283 *quotaflags = 0;
284 *needquotamount = B_FALSE;
285
286 quotaondisk = XFS_SB_VERSION_HASQUOTA(&mp->m_sb) &&
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000287 (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288
289 if (quotaondisk) {
290 uquotaondisk = mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT;
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000291 pquotaondisk = mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 gquotaondisk = mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT;
293 }
294
295 /*
296 * If the device itself is read-only, we can't allow
297 * the user to change the state of quota on the mount -
298 * this would generate a transaction on the ro device,
299 * which would lead to an I/O error and shutdown
300 */
301
302 if (((uquotaondisk && !XFS_IS_UQUOTA_ON(mp)) ||
303 (!uquotaondisk && XFS_IS_UQUOTA_ON(mp)) ||
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000304 (pquotaondisk && !XFS_IS_PQUOTA_ON(mp)) ||
305 (!pquotaondisk && XFS_IS_PQUOTA_ON(mp)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 (gquotaondisk && !XFS_IS_GQUOTA_ON(mp)) ||
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000307 (!gquotaondisk && XFS_IS_OQUOTA_ON(mp))) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 xfs_dev_is_read_only(mp, "changing quota state")) {
309 cmn_err(CE_WARN,
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000310 "XFS: please mount with%s%s%s%s.",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 (!quotaondisk ? "out quota" : ""),
312 (uquotaondisk ? " usrquota" : ""),
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000313 (pquotaondisk ? " prjquota" : ""),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 (gquotaondisk ? " grpquota" : ""));
315 return XFS_ERROR(EPERM);
316 }
317
318 if (XFS_IS_QUOTA_ON(mp) || quotaondisk) {
319 /*
320 * Call mount_quotas at this point only if we won't have to do
321 * a quotacheck.
322 */
323 if (quotaondisk && !XFS_QM_NEED_QUOTACHECK(mp)) {
324 /*
325 * If an error occured, qm_mount_quotas code
326 * has already disabled quotas. So, just finish
327 * mounting, and get on with the boring life
328 * without disk quotas.
329 */
330 xfs_qm_mount_quotas(mp, 0);
331 } else {
332 /*
333 * Clear the quota flags, but remember them. This
334 * is so that the quota code doesn't get invoked
335 * before we're ready. This can happen when an
336 * inode goes inactive and wants to free blocks,
337 * or via xfs_log_mount_finish.
338 */
339 *needquotamount = B_TRUE;
340 *quotaflags = mp->m_qflags;
341 mp->m_qflags = 0;
342 }
343 }
344
345 return 0;
346}
347
348STATIC int
349xfs_qm_endmount(
350 xfs_mount_t *mp,
351 uint needquotamount,
352 uint quotaflags,
353 int mfsi_flags)
354{
355 if (needquotamount) {
356 ASSERT(mp->m_qflags == 0);
357 mp->m_qflags = quotaflags;
358 xfs_qm_mount_quotas(mp, mfsi_flags);
359 }
360
361#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
362 if (! (XFS_IS_QUOTA_ON(mp)))
363 xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas not turned on");
364 else
365 xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas turned on");
366#endif
367
368#ifdef QUOTADEBUG
369 if (XFS_IS_QUOTA_ON(mp) && xfs_qm_internalqcheck(mp))
370 cmn_err(CE_WARN, "XFS: mount internalqcheck failed");
371#endif
372
373 return 0;
374}
375
376STATIC void
377xfs_qm_dqrele_null(
378 xfs_dquot_t *dq)
379{
380 /*
381 * Called from XFS, where we always check first for a NULL dquot.
382 */
383 if (!dq)
384 return;
385 xfs_qm_dqrele(dq);
386}
387
388
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000389STATIC struct xfs_qmops xfs_qmcore_xfs = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 .xfs_qminit = xfs_qm_newmount,
391 .xfs_qmdone = xfs_qm_unmount_quotadestroy,
392 .xfs_qmmount = xfs_qm_endmount,
393 .xfs_qmunmount = xfs_qm_unmount_quotas,
394 .xfs_dqrele = xfs_qm_dqrele_null,
395 .xfs_dqattach = xfs_qm_dqattach,
396 .xfs_dqdetach = xfs_qm_dqdetach,
397 .xfs_dqpurgeall = xfs_qm_dqpurge_all,
398 .xfs_dqvopalloc = xfs_qm_vop_dqalloc,
399 .xfs_dqvopcreate = xfs_qm_vop_dqattach_and_dqmod_newinode,
400 .xfs_dqvoprename = xfs_qm_vop_rename_dqattach,
401 .xfs_dqvopchown = xfs_qm_vop_chown,
402 .xfs_dqvopchownresv = xfs_qm_vop_chown_reserve,
403 .xfs_dqtrxops = &xfs_trans_dquot_ops,
404};
405
406struct bhv_vfsops xfs_qmops = { {
407 BHV_IDENTITY_INIT(VFS_BHV_QM, VFS_POSITION_QM),
408 .vfs_parseargs = xfs_qm_parseargs,
409 .vfs_showargs = xfs_qm_showargs,
410 .vfs_mount = xfs_qm_mount,
411 .vfs_sync = xfs_qm_syncall,
412 .vfs_quotactl = xfs_qm_quotactl, },
413};
414
415
416void __init
417xfs_qm_init(void)
418{
419 static char message[] __initdata =
420 KERN_INFO "SGI XFS Quota Management subsystem\n";
421
422 printk(message);
423 mutex_init(&xfs_Gqm_lock, MUTEX_DEFAULT, "xfs_qmlock");
424 vfs_bhv_set_custom(&xfs_qmops, &xfs_qmcore_xfs);
425 xfs_qm_init_procfs();
426}
427
428void __exit
429xfs_qm_exit(void)
430{
431 vfs_bhv_clr_custom(&xfs_qmops);
432 xfs_qm_cleanup_procfs();
433 if (qm_dqzone)
434 kmem_cache_destroy(qm_dqzone);
435 if (qm_dqtrxzone)
436 kmem_cache_destroy(qm_dqtrxzone);
437}