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
xfs_qm_parseargs(struct bhv_desc * bhv,char * options,struct xfs_mount_args * args,int update)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
xfs_qm_showargs(struct bhv_desc * bhv,struct seq_file * m)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
xfs_qm_mount(struct bhv_desc * bhv,struct xfs_mount_args * args,struct cred * cr)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
xfs_qm_syncall(struct bhv_desc * bhv,int flags,cred_t * credp)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
xfs_mount_reset_sbqflags(xfs_mount_t * mp)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
xfs_qm_newmount(xfs_mount_t * mp,uint * needquotamount,uint * quotaflags)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
xfs_qm_endmount(xfs_mount_t * mp,uint needquotamount,uint quotaflags,int mfsi_flags)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
xfs_qm_dqrele_null(xfs_dquot_t * dq)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
362 struct xfs_qmops xfs_qmcore_xfs = {
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
xfs_qm_init(void)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
xfs_qm_exit(void)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 }
411