2 * Copyright (c) 2000-2003 Silicon Graphics, Inc. All Rights Reserved.
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.
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.
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.
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.
23 * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24 * Mountain View, CA 94043, or:
28 * For further information regarding this notice, see:
30 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
38 #include "xfs_trans.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"
58 #include "xfs_rtalloc.h"
59 #include "xfs_error.h"
60 #include "xfs_itable.h"
66 #include "xfs_buf_item.h"
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 */
84 struct xfs_mount_args *args,
88 char *local_options = options;
91 int referenced = update;
93 while ((this_char = strsep(&local_options, ",")) != NULL) {
94 length = strlen(this_char);
98 if (!strcmp(this_char, MNTOPT_NOQUOTA)) {
99 args->flags &= ~(XFSMNT_UQUOTAENF|XFSMNT_UQUOTA);
100 args->flags &= ~(XFSMNT_GQUOTAENF|XFSMNT_GQUOTA);
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;
107 } else if (!strcmp(this_char, MNTOPT_QUOTANOENF) ||
108 !strcmp(this_char, MNTOPT_UQUOTANOENF)) {
109 args->flags |= XFSMNT_UQUOTA;
110 args->flags &= ~XFSMNT_UQUOTAENF;
112 } else if (!strcmp(this_char, MNTOPT_GQUOTA) ||
113 !strcmp(this_char, MNTOPT_GRPQUOTA)) {
114 args->flags |= XFSMNT_GQUOTA | XFSMNT_GQUOTAENF;
116 } else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
117 args->flags |= XFSMNT_GQUOTA;
118 args->flags &= ~XFSMNT_GQUOTAENF;
122 *(local_options-1) = ',';
130 PVFS_PARSEARGS(BHV_NEXT(bhv), options, args, update, error);
131 if (!error && !referenced)
132 bhv_remove_vfsops(bhvtovfs(bhv), VFS_POSITION_QM);
138 struct bhv_desc *bhv,
141 struct vfs *vfsp = bhvtovfs(bhv);
142 struct xfs_mount *mp = XFS_VFSTOM(vfsp);
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);
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);
157 if (!(mp->m_qflags & (XFS_UQUOTA_ACCT|XFS_GQUOTA_ACCT)))
158 seq_puts(m, "," MNTOPT_NOQUOTA);
160 PVFS_SHOWARGS(BHV_NEXT(bhv), m, error);
166 struct bhv_desc *bhv,
167 struct xfs_mount_args *args,
170 struct vfs *vfsp = bhvtovfs(bhv);
171 struct xfs_mount *mp = XFS_VFSTOM(vfsp);
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);
182 struct bhv_desc *bhv,
186 struct vfs *vfsp = bhvtovfs(bhv);
187 struct xfs_mount *mp = XFS_VFSTOM(vfsp);
191 * Get the Quota Manager to flush the dquots.
193 if (XFS_IS_QUOTA_ON(mp)) {
194 if ((error = xfs_qm_sync(mp, flags))) {
196 * If we got an IO error, we will be shutting down.
197 * So, there's nothing more for us to do here.
199 ASSERT(error != EIO || XFS_FORCED_SHUTDOWN(mp));
200 if (XFS_FORCED_SHUTDOWN(mp)) {
201 return XFS_ERROR(error);
205 PVFS_SYNC(BHV_NEXT(bhv), flags, credp, error);
210 * When xfsquotas isn't installed and the superblock had quotas, we need to
211 * clear the quotaflags from superblock.
214 xfs_mount_reset_sbqflags(
222 * It is OK to look at sb_qflags here in mount path,
225 if (mp->m_sb.sb_qflags == 0)
228 mp->m_sb.sb_qflags = 0;
229 XFS_SB_UNLOCK(mp, s);
232 * if the fs is readonly, let the incore superblock run
233 * with quotas off but don't flush the update out to disk
235 if (XFS_MTOVFS(mp)->vfs_flag & VFS_RDONLY)
238 xfs_fs_cmn_err(CE_NOTE, mp, "Writing superblock quota changes");
240 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
241 if (xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
242 XFS_DEFAULT_LOG_COUNT)) {
243 xfs_trans_cancel(tp, 0);
246 xfs_mod_sb(tp, XFS_SB_QFLAGS);
247 xfs_trans_commit(tp, 0, NULL);
253 uint *needquotamount,
257 uint uquotaondisk = 0, gquotaondisk = 0;
260 *needquotamount = B_FALSE;
262 quotaondisk = XFS_SB_VERSION_HASQUOTA(&mp->m_sb) &&
263 mp->m_sb.sb_qflags & (XFS_UQUOTA_ACCT|XFS_GQUOTA_ACCT);
266 uquotaondisk = mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT;
267 gquotaondisk = mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT;
271 * If the device itself is read-only, we can't allow
272 * the user to change the state of quota on the mount -
273 * this would generate a transaction on the ro device,
274 * which would lead to an I/O error and shutdown
277 if (((uquotaondisk && !XFS_IS_UQUOTA_ON(mp)) ||
278 (!uquotaondisk && XFS_IS_UQUOTA_ON(mp)) ||
279 (gquotaondisk && !XFS_IS_GQUOTA_ON(mp)) ||
280 (!gquotaondisk && XFS_IS_GQUOTA_ON(mp))) &&
281 xfs_dev_is_read_only(mp, "changing quota state")) {
283 "XFS: please mount with%s%s%s.",
284 (!quotaondisk ? "out quota" : ""),
285 (uquotaondisk ? " usrquota" : ""),
286 (gquotaondisk ? " grpquota" : ""));
287 return XFS_ERROR(EPERM);
290 if (XFS_IS_QUOTA_ON(mp) || quotaondisk) {
292 * Call mount_quotas at this point only if we won't have to do
295 if (quotaondisk && !XFS_QM_NEED_QUOTACHECK(mp)) {
297 * If the xfs quota code isn't installed,
298 * we have to reset the quotachk'd bit.
299 * If an error occured, qm_mount_quotas code
300 * has already disabled quotas. So, just finish
301 * mounting, and get on with the boring life
302 * without disk quotas.
304 if (xfs_qm_mount_quotas(mp))
305 xfs_mount_reset_sbqflags(mp);
308 * Clear the quota flags, but remember them. This
309 * is so that the quota code doesn't get invoked
310 * before we're ready. This can happen when an
311 * inode goes inactive and wants to free blocks,
312 * or via xfs_log_mount_finish.
314 *needquotamount = B_TRUE;
315 *quotaflags = mp->m_qflags;
329 if (needquotamount) {
330 ASSERT(mp->m_qflags == 0);
331 mp->m_qflags = quotaflags;
332 if (xfs_qm_mount_quotas(mp))
333 xfs_mount_reset_sbqflags(mp);
336 #if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
337 if (! (XFS_IS_QUOTA_ON(mp)))
338 xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas not turned on");
340 xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas turned on");
344 if (XFS_IS_QUOTA_ON(mp) && xfs_qm_internalqcheck(mp))
345 cmn_err(CE_WARN, "XFS: mount internalqcheck failed");
356 * Called from XFS, where we always check first for a NULL dquot.
364 struct xfs_qmops xfs_qmcore_xfs = {
365 .xfs_qminit = xfs_qm_newmount,
366 .xfs_qmdone = xfs_qm_unmount_quotadestroy,
367 .xfs_qmmount = xfs_qm_endmount,
368 .xfs_qmunmount = xfs_qm_unmount_quotas,
369 .xfs_dqrele = xfs_qm_dqrele_null,
370 .xfs_dqattach = xfs_qm_dqattach,
371 .xfs_dqdetach = xfs_qm_dqdetach,
372 .xfs_dqpurgeall = xfs_qm_dqpurge_all,
373 .xfs_dqvopalloc = xfs_qm_vop_dqalloc,
374 .xfs_dqvopcreate = xfs_qm_vop_dqattach_and_dqmod_newinode,
375 .xfs_dqvoprename = xfs_qm_vop_rename_dqattach,
376 .xfs_dqvopchown = xfs_qm_vop_chown,
377 .xfs_dqvopchownresv = xfs_qm_vop_chown_reserve,
378 .xfs_dqtrxops = &xfs_trans_dquot_ops,
381 struct bhv_vfsops xfs_qmops = { {
382 BHV_IDENTITY_INIT(VFS_BHV_QM, VFS_POSITION_QM),
383 .vfs_parseargs = xfs_qm_parseargs,
384 .vfs_showargs = xfs_qm_showargs,
385 .vfs_mount = xfs_qm_mount,
386 .vfs_sync = xfs_qm_syncall,
387 .vfs_quotactl = xfs_qm_quotactl, },
394 static char message[] __initdata =
395 KERN_INFO "SGI XFS Quota Management subsystem\n";
398 mutex_init(&xfs_Gqm_lock, MUTEX_DEFAULT, "xfs_qmlock");
399 vfs_bhv_set_custom(&xfs_qmops, &xfs_qmcore_xfs);
400 xfs_qm_init_procfs();
406 vfs_bhv_clr_custom(&xfs_qmops);
407 xfs_qm_cleanup_procfs();
409 kmem_cache_destroy(qm_dqzone);
411 kmem_cache_destroy(qm_dqtrxzone);