?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
m68k: Atari SCSI revival
[linux/fpc-iii.git] / fs / xfs / quota / xfs_qm_syscalls.c
blob716f562aa8b2f036c46c7dd1951b0185ae04d5d0
1 /*
2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
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
19 #include <linux/capability.h>
20
21 #include "xfs.h"
22 #include "xfs_fs.h"
23 #include "xfs_bit.h"
24 #include "xfs_log.h"
25 #include "xfs_inum.h"
26 #include "xfs_trans.h"
27 #include "xfs_sb.h"
28 #include "xfs_ag.h"
29 #include "xfs_dir2.h"
30 #include "xfs_alloc.h"
31 #include "xfs_dmapi.h"
32 #include "xfs_quota.h"
33 #include "xfs_mount.h"
34 #include "xfs_bmap_btree.h"
35 #include "xfs_alloc_btree.h"
36 #include "xfs_ialloc_btree.h"
37 #include "xfs_dir2_sf.h"
38 #include "xfs_attr_sf.h"
39 #include "xfs_dinode.h"
40 #include "xfs_inode.h"
41 #include "xfs_ialloc.h"
42 #include "xfs_itable.h"
43 #include "xfs_bmap.h"
44 #include "xfs_btree.h"
45 #include "xfs_rtalloc.h"
46 #include "xfs_error.h"
47 #include "xfs_rw.h"
48 #include "xfs_acl.h"
49 #include "xfs_attr.h"
50 #include "xfs_buf_item.h"
51 #include "xfs_utils.h"
52 #include "xfs_qm.h"
53
54 #ifdef DEBUG
55 # define qdprintk(s, args...) cmn_err(CE_DEBUG, s, ## args)
56 #else
57 # define qdprintk(s, args...) do { } while (0)
58 #endif
59
60 STATIC int xfs_qm_scall_trunc_qfiles(xfs_mount_t *, uint);
61 STATIC int xfs_qm_scall_getquota(xfs_mount_t *, xfs_dqid_t, uint,
62 fs_disk_quota_t *);
63 STATIC int xfs_qm_scall_getqstat(xfs_mount_t *, fs_quota_stat_t *);
64 STATIC int xfs_qm_scall_setqlim(xfs_mount_t *, xfs_dqid_t, uint,
65 fs_disk_quota_t *);
66 STATIC int xfs_qm_scall_quotaon(xfs_mount_t *, uint);
67 STATIC int xfs_qm_scall_quotaoff(xfs_mount_t *, uint, boolean_t);
68 STATIC int xfs_qm_log_quotaoff(xfs_mount_t *, xfs_qoff_logitem_t **, uint);
69 STATIC int xfs_qm_log_quotaoff_end(xfs_mount_t *, xfs_qoff_logitem_t *,
70 uint);
71 STATIC uint xfs_qm_import_flags(uint);
72 STATIC uint xfs_qm_export_flags(uint);
73 STATIC uint xfs_qm_import_qtype_flags(uint);
74 STATIC uint xfs_qm_export_qtype_flags(uint);
75 STATIC void xfs_qm_export_dquot(xfs_mount_t *, xfs_disk_dquot_t *,
76 fs_disk_quota_t *);
77
78
79 /*
80 * The main distribution switch of all XFS quotactl system calls.
81 */
82 int
83 xfs_qm_quotactl(
84 struct bhv_desc *bdp,
85 int cmd,
86 int id,
87 xfs_caddr_t addr)
88 {
89 xfs_mount_t *mp;
90 bhv_vfs_t *vfsp;
91 int error;
92
93 vfsp = bhvtovfs(bdp);
94 mp = XFS_VFSTOM(vfsp);
95
96 ASSERT(addr != NULL || cmd == Q_XQUOTASYNC);
97
98 /*
99 * The following commands are valid even when quotaoff.
100 */
101 switch (cmd) {
102 case Q_XQUOTARM:
103 /*
104 * Truncate quota files. quota must be off.
105 */
106 if (XFS_IS_QUOTA_ON(mp))
107 return XFS_ERROR(EINVAL);
108 if (vfsp->vfs_flag & VFS_RDONLY)
109 return XFS_ERROR(EROFS);
110 return (xfs_qm_scall_trunc_qfiles(mp,
111 xfs_qm_import_qtype_flags(*(uint *)addr)));
112
113 case Q_XGETQSTAT:
114 /*
115 * Get quota status information.
116 */
117 return (xfs_qm_scall_getqstat(mp, (fs_quota_stat_t *)addr));
118
119 case Q_XQUOTAON:
120 /*
121 * QUOTAON - enabling quota enforcement.
122 * Quota accounting must be turned on at mount time.
123 */
124 if (vfsp->vfs_flag & VFS_RDONLY)
125 return XFS_ERROR(EROFS);
126 return (xfs_qm_scall_quotaon(mp,
127 xfs_qm_import_flags(*(uint *)addr)));
128
129 case Q_XQUOTAOFF:
130 if (vfsp->vfs_flag & VFS_RDONLY)
131 return XFS_ERROR(EROFS);
132 break;
133
134 case Q_XQUOTASYNC:
135 return (xfs_sync_inodes(mp, SYNC_DELWRI, NULL));
136
137 default:
138 break;
139 }
140
141 if (! XFS_IS_QUOTA_ON(mp))
142 return XFS_ERROR(ESRCH);
143
144 switch (cmd) {
145 case Q_XQUOTAOFF:
146 if (vfsp->vfs_flag & VFS_RDONLY)
147 return XFS_ERROR(EROFS);
148 error = xfs_qm_scall_quotaoff(mp,
149 xfs_qm_import_flags(*(uint *)addr),
150 B_FALSE);
151 break;
152
153 case Q_XGETQUOTA:
154 error = xfs_qm_scall_getquota(mp, (xfs_dqid_t)id, XFS_DQ_USER,
155 (fs_disk_quota_t *)addr);
156 break;
157 case Q_XGETGQUOTA:
158 error = xfs_qm_scall_getquota(mp, (xfs_dqid_t)id, XFS_DQ_GROUP,
159 (fs_disk_quota_t *)addr);
160 break;
161 case Q_XGETPQUOTA:
162 error = xfs_qm_scall_getquota(mp, (xfs_dqid_t)id, XFS_DQ_PROJ,
163 (fs_disk_quota_t *)addr);
164 break;
165
166 case Q_XSETQLIM:
167 if (vfsp->vfs_flag & VFS_RDONLY)
168 return XFS_ERROR(EROFS);
169 error = xfs_qm_scall_setqlim(mp, (xfs_dqid_t)id, XFS_DQ_USER,
170 (fs_disk_quota_t *)addr);
171 break;
172 case Q_XSETGQLIM:
173 if (vfsp->vfs_flag & VFS_RDONLY)
174 return XFS_ERROR(EROFS);
175 error = xfs_qm_scall_setqlim(mp, (xfs_dqid_t)id, XFS_DQ_GROUP,
176 (fs_disk_quota_t *)addr);
177 break;
178 case Q_XSETPQLIM:
179 if (vfsp->vfs_flag & VFS_RDONLY)
180 return XFS_ERROR(EROFS);
181 error = xfs_qm_scall_setqlim(mp, (xfs_dqid_t)id, XFS_DQ_PROJ,
182 (fs_disk_quota_t *)addr);
183 break;
184
185 default:
186 error = XFS_ERROR(EINVAL);
187 break;
188 }
189
190 return (error);
191 }
192
193 /*
194 * Turn off quota accounting and/or enforcement for all udquots and/or
195 * gdquots. Called only at unmount time.
196 *
197 * This assumes that there are no dquots of this file system cached
198 * incore, and modifies the ondisk dquot directly. Therefore, for example,
199 * it is an error to call this twice, without purging the cache.
200 */
201 STATIC int
202 xfs_qm_scall_quotaoff(
203 xfs_mount_t *mp,
204 uint flags,
205 boolean_t force)
206 {
207 uint dqtype;
208 unsigned long s;
209 int error;
210 uint inactivate_flags;
211 xfs_qoff_logitem_t *qoffstart;
212 int nculprits;
213
214 if (!force && !capable(CAP_SYS_ADMIN))
215 return XFS_ERROR(EPERM);
216 /*
217 * No file system can have quotas enabled on disk but not in core.
218 * Note that quota utilities (like quotaoff) _expect_
219 * errno == EEXIST here.
220 */
221 if ((mp->m_qflags & flags) == 0)
222 return XFS_ERROR(EEXIST);
223 error = 0;
224
225 flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD);
226
227 /*
228 * We don't want to deal with two quotaoffs messing up each other,
229 * so we're going to serialize it. quotaoff isn't exactly a performance
230 * critical thing.
231 * If quotaoff, then we must be dealing with the root filesystem.
232 */
233 ASSERT(mp->m_quotainfo);
234 if (mp->m_quotainfo)
235 mutex_lock(&(XFS_QI_QOFFLOCK(mp)));
236
237 ASSERT(mp->m_quotainfo);
238
239 /*
240 * If we're just turning off quota enforcement, change mp and go.
241 */
242 if ((flags & XFS_ALL_QUOTA_ACCT) == 0) {
243 mp->m_qflags &= ~(flags);
244
245 s = XFS_SB_LOCK(mp);
246 mp->m_sb.sb_qflags = mp->m_qflags;
247 XFS_SB_UNLOCK(mp, s);
248 mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));
249
250 /* XXX what to do if error ? Revert back to old vals incore ? */
251 error = xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS);
252 return (error);
253 }
254
255 dqtype = 0;
256 inactivate_flags = 0;
257 /*
258 * If accounting is off, we must turn enforcement off, clear the
259 * quota 'CHKD' certificate to make it known that we have to
260 * do a quotacheck the next time this quota is turned on.
261 */
262 if (flags & XFS_UQUOTA_ACCT) {
263 dqtype |= XFS_QMOPT_UQUOTA;
264 flags |= (XFS_UQUOTA_CHKD | XFS_UQUOTA_ENFD);
265 inactivate_flags |= XFS_UQUOTA_ACTIVE;
266 }
267 if (flags & XFS_GQUOTA_ACCT) {
268 dqtype |= XFS_QMOPT_GQUOTA;
269 flags |= (XFS_OQUOTA_CHKD | XFS_OQUOTA_ENFD);
270 inactivate_flags |= XFS_GQUOTA_ACTIVE;
271 } else if (flags & XFS_PQUOTA_ACCT) {
272 dqtype |= XFS_QMOPT_PQUOTA;
273 flags |= (XFS_OQUOTA_CHKD | XFS_OQUOTA_ENFD);
274 inactivate_flags |= XFS_PQUOTA_ACTIVE;
275 }
276
277 /*
278 * Nothing to do? Don't complain. This happens when we're just
279 * turning off quota enforcement.
280 */
281 if ((mp->m_qflags & flags) == 0) {
282 mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));
283 return (0);
284 }
285
286 /*
287 * Write the LI_QUOTAOFF log record, and do SB changes atomically,
288 * and synchronously.
289 */
290 xfs_qm_log_quotaoff(mp, &qoffstart, flags);
291
292 /*
293 * Next we clear the XFS_MOUNT_*DQ_ACTIVE bit(s) in the mount struct
294 * to take care of the race between dqget and quotaoff. We don't take
295 * any special locks to reset these bits. All processes need to check
296 * these bits *after* taking inode lock(s) to see if the particular
297 * quota type is in the process of being turned off. If *ACTIVE, it is
298 * guaranteed that all dquot structures and all quotainode ptrs will all
299 * stay valid as long as that inode is kept locked.
300 *
301 * There is no turning back after this.
302 */
303 mp->m_qflags &= ~inactivate_flags;
304
305 /*
306 * Give back all the dquot reference(s) held by inodes.
307 * Here we go thru every single incore inode in this file system, and
308 * do a dqrele on the i_udquot/i_gdquot that it may have.
309 * Essentially, as long as somebody has an inode locked, this guarantees
310 * that quotas will not be turned off. This is handy because in a
311 * transaction once we lock the inode(s) and check for quotaon, we can
312 * depend on the quota inodes (and other things) being valid as long as
313 * we keep the lock(s).
314 */
315 xfs_qm_dqrele_all_inodes(mp, flags);
316
317 /*
318 * Next we make the changes in the quota flag in the mount struct.
319 * This isn't protected by a particular lock directly, because we
320 * don't want to take a mrlock everytime we depend on quotas being on.
321 */
322 mp->m_qflags &= ~(flags);
323
324 /*
325 * Go through all the dquots of this file system and purge them,
326 * according to what was turned off. We may not be able to get rid
327 * of all dquots, because dquots can have temporary references that
328 * are not attached to inodes. eg. xfs_setattr, xfs_create.
329 * So, if we couldn't purge all the dquots from the filesystem,
330 * we can't get rid of the incore data structures.
331 */
332 while ((nculprits = xfs_qm_dqpurge_all(mp, dqtype|XFS_QMOPT_QUOTAOFF)))
333 delay(10 * nculprits);
334
335 /*
336 * Transactions that had started before ACTIVE state bit was cleared
337 * could have logged many dquots, so they'd have higher LSNs than
338 * the first QUOTAOFF log record does. If we happen to crash when
339 * the tail of the log has gone past the QUOTAOFF record, but
340 * before the last dquot modification, those dquots __will__
341 * recover, and that's not good.
342 *
343 * So, we have QUOTAOFF start and end logitems; the start
344 * logitem won't get overwritten until the end logitem appears...
345 */
346 xfs_qm_log_quotaoff_end(mp, qoffstart, flags);
347
348 /*
349 * If quotas is completely disabled, close shop.
350 */
351 if (((flags & XFS_MOUNT_QUOTA_ALL) == XFS_MOUNT_QUOTA_SET1) ||
352 ((flags & XFS_MOUNT_QUOTA_ALL) == XFS_MOUNT_QUOTA_SET2)) {
353 mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));
354 xfs_qm_destroy_quotainfo(mp);
355 return (0);
356 }
357
358 /*
359 * Release our quotainode references, and vn_purge them,
360 * if we don't need them anymore.
361 */
362 if ((dqtype & XFS_QMOPT_UQUOTA) && XFS_QI_UQIP(mp)) {
363 XFS_PURGE_INODE(XFS_QI_UQIP(mp));
364 XFS_QI_UQIP(mp) = NULL;
365 }
366 if ((dqtype & (XFS_QMOPT_GQUOTA|XFS_QMOPT_PQUOTA)) && XFS_QI_GQIP(mp)) {
367 XFS_PURGE_INODE(XFS_QI_GQIP(mp));
368 XFS_QI_GQIP(mp) = NULL;
369 }
370 mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));
371
372 return (error);
373 }
374
375 STATIC int
376 xfs_qm_scall_trunc_qfiles(
377 xfs_mount_t *mp,
378 uint flags)
379 {
380 int error;
381 xfs_inode_t *qip;
382
383 if (!capable(CAP_SYS_ADMIN))
384 return XFS_ERROR(EPERM);
385 error = 0;
386 if (!XFS_SB_VERSION_HASQUOTA(&mp->m_sb) || flags == 0) {
387 qdprintk("qtrunc flags=%x m_qflags=%x\n", flags, mp->m_qflags);
388 return XFS_ERROR(EINVAL);
389 }
390
391 if ((flags & XFS_DQ_USER) && mp->m_sb.sb_uquotino != NULLFSINO) {
392 error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino, 0, 0, &qip, 0);
393 if (! error) {
394 (void) xfs_truncate_file(mp, qip);
395 VN_RELE(XFS_ITOV(qip));
396 }
397 }
398
399 if ((flags & (XFS_DQ_GROUP|XFS_DQ_PROJ)) &&
400 mp->m_sb.sb_gquotino != NULLFSINO) {
401 error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino, 0, 0, &qip, 0);
402 if (! error) {
403 (void) xfs_truncate_file(mp, qip);
404 VN_RELE(XFS_ITOV(qip));
405 }
406 }
407
408 return (error);
409 }
410
411
412 /*
413 * Switch on (a given) quota enforcement for a filesystem. This takes
414 * effect immediately.
415 * (Switching on quota accounting must be done at mount time.)
416 */
417 STATIC int
418 xfs_qm_scall_quotaon(
419 xfs_mount_t *mp,
420 uint flags)
421 {
422 int error;
423 unsigned long s;
424 uint qf;
425 uint accflags;
426 __int64_t sbflags;
427
428 if (!capable(CAP_SYS_ADMIN))
429 return XFS_ERROR(EPERM);
430
431 flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD);
432 /*
433 * Switching on quota accounting must be done at mount time.
434 */
435 accflags = flags & XFS_ALL_QUOTA_ACCT;
436 flags &= ~(XFS_ALL_QUOTA_ACCT);
437
438 sbflags = 0;
439
440 if (flags == 0) {
441 qdprintk("quotaon: zero flags, m_qflags=%x\n", mp->m_qflags);
442 return XFS_ERROR(EINVAL);
443 }
444
445 /* No fs can turn on quotas with a delayed effect */
446 ASSERT((flags & XFS_ALL_QUOTA_ACCT) == 0);
447
448 /*
449 * Can't enforce without accounting. We check the superblock
450 * qflags here instead of m_qflags because rootfs can have
451 * quota acct on ondisk without m_qflags' knowing.
452 */
453 if (((flags & XFS_UQUOTA_ACCT) == 0 &&
454 (mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) == 0 &&
455 (flags & XFS_UQUOTA_ENFD))
456 ||
457 ((flags & XFS_PQUOTA_ACCT) == 0 &&
458 (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) == 0 &&
459 (flags & XFS_OQUOTA_ENFD))
460 ||
461 ((flags & XFS_GQUOTA_ACCT) == 0 &&
462 (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) == 0 &&
463 (flags & XFS_OQUOTA_ENFD))) {
464 qdprintk("Can't enforce without acct, flags=%x sbflags=%x\n",
465 flags, mp->m_sb.sb_qflags);
466 return XFS_ERROR(EINVAL);
467 }
468 /*
469 * If everything's upto-date incore, then don't waste time.
470 */
471 if ((mp->m_qflags & flags) == flags)
472 return XFS_ERROR(EEXIST);
473
474 /*
475 * Change sb_qflags on disk but not incore mp->qflags
476 * if this is the root filesystem.
477 */
478 s = XFS_SB_LOCK(mp);
479 qf = mp->m_sb.sb_qflags;
480 mp->m_sb.sb_qflags = qf | flags;
481 XFS_SB_UNLOCK(mp, s);
482
483 /*
484 * There's nothing to change if it's the same.
485 */
486 if ((qf & flags) == flags && sbflags == 0)
487 return XFS_ERROR(EEXIST);
488 sbflags |= XFS_SB_QFLAGS;
489
490 if ((error = xfs_qm_write_sb_changes(mp, sbflags)))
491 return (error);
492 /*
493 * If we aren't trying to switch on quota enforcement, we are done.
494 */
495 if (((mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) !=
496 (mp->m_qflags & XFS_UQUOTA_ACCT)) ||
497 ((mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) !=
498 (mp->m_qflags & XFS_PQUOTA_ACCT)) ||
499 ((mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) !=
500 (mp->m_qflags & XFS_GQUOTA_ACCT)) ||
501 (flags & XFS_ALL_QUOTA_ENFD) == 0)
502 return (0);
503
504 if (! XFS_IS_QUOTA_RUNNING(mp))
505 return XFS_ERROR(ESRCH);
506
507 /*
508 * Switch on quota enforcement in core.
509 */
510 mutex_lock(&(XFS_QI_QOFFLOCK(mp)));
511 mp->m_qflags |= (flags & XFS_ALL_QUOTA_ENFD);
512 mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));
513
514 return (0);
515 }
516
517
518 /*
519 * Return quota status information, such as uquota-off, enforcements, etc.
520 */
521 STATIC int
522 xfs_qm_scall_getqstat(
523 xfs_mount_t *mp,
524 fs_quota_stat_t *out)
525 {
526 xfs_inode_t *uip, *gip;
527 boolean_t tempuqip, tempgqip;
528
529 uip = gip = NULL;
530 tempuqip = tempgqip = B_FALSE;
531 memset(out, 0, sizeof(fs_quota_stat_t));
532
533 out->qs_version = FS_QSTAT_VERSION;
534 if (! XFS_SB_VERSION_HASQUOTA(&mp->m_sb)) {
535 out->qs_uquota.qfs_ino = NULLFSINO;
536 out->qs_gquota.qfs_ino = NULLFSINO;
537 return (0);
538 }
539 out->qs_flags = (__uint16_t) xfs_qm_export_flags(mp->m_qflags &
540 (XFS_ALL_QUOTA_ACCT|
541 XFS_ALL_QUOTA_ENFD));
542 out->qs_pad = 0;
543 out->qs_uquota.qfs_ino = mp->m_sb.sb_uquotino;
544 out->qs_gquota.qfs_ino = mp->m_sb.sb_gquotino;
545
546 if (mp->m_quotainfo) {
547 uip = mp->m_quotainfo->qi_uquotaip;
548 gip = mp->m_quotainfo->qi_gquotaip;
549 }
550 if (!uip && mp->m_sb.sb_uquotino != NULLFSINO) {
551 if (xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
552 0, 0, &uip, 0) == 0)
553 tempuqip = B_TRUE;
554 }
555 if (!gip && mp->m_sb.sb_gquotino != NULLFSINO) {
556 if (xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
557 0, 0, &gip, 0) == 0)
558 tempgqip = B_TRUE;
559 }
560 if (uip) {
561 out->qs_uquota.qfs_nblks = uip->i_d.di_nblocks;
562 out->qs_uquota.qfs_nextents = uip->i_d.di_nextents;
563 if (tempuqip)
564 VN_RELE(XFS_ITOV(uip));
565 }
566 if (gip) {
567 out->qs_gquota.qfs_nblks = gip->i_d.di_nblocks;
568 out->qs_gquota.qfs_nextents = gip->i_d.di_nextents;
569 if (tempgqip)
570 VN_RELE(XFS_ITOV(gip));
571 }
572 if (mp->m_quotainfo) {
573 out->qs_incoredqs = XFS_QI_MPLNDQUOTS(mp);
574 out->qs_btimelimit = XFS_QI_BTIMELIMIT(mp);
575 out->qs_itimelimit = XFS_QI_ITIMELIMIT(mp);
576 out->qs_rtbtimelimit = XFS_QI_RTBTIMELIMIT(mp);
577 out->qs_bwarnlimit = XFS_QI_BWARNLIMIT(mp);
578 out->qs_iwarnlimit = XFS_QI_IWARNLIMIT(mp);
579 }
580 return (0);
581 }
582
583 /*
584 * Adjust quota limits, and start/stop timers accordingly.
585 */
586 STATIC int
587 xfs_qm_scall_setqlim(
588 xfs_mount_t *mp,
589 xfs_dqid_t id,
590 uint type,
591 fs_disk_quota_t *newlim)
592 {
593 xfs_disk_dquot_t *ddq;
594 xfs_dquot_t *dqp;
595 xfs_trans_t *tp;
596 int error;
597 xfs_qcnt_t hard, soft;
598
599 if (!capable(CAP_SYS_ADMIN))
600 return XFS_ERROR(EPERM);
601
602 if ((newlim->d_fieldmask &
603 (FS_DQ_LIMIT_MASK|FS_DQ_TIMER_MASK|FS_DQ_WARNS_MASK)) == 0)
604 return (0);
605
606 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SETQLIM);
607 if ((error = xfs_trans_reserve(tp, 0, sizeof(xfs_disk_dquot_t) + 128,
608 0, 0, XFS_DEFAULT_LOG_COUNT))) {
609 xfs_trans_cancel(tp, 0);
610 return (error);
611 }
612
613 /*
614 * We don't want to race with a quotaoff so take the quotaoff lock.
615 * (We don't hold an inode lock, so there's nothing else to stop
616 * a quotaoff from happening). (XXXThis doesn't currently happen
617 * because we take the vfslock before calling xfs_qm_sysent).
618 */
619 mutex_lock(&(XFS_QI_QOFFLOCK(mp)));
620
621 /*
622 * Get the dquot (locked), and join it to the transaction.
623 * Allocate the dquot if this doesn't exist.
624 */
625 if ((error = xfs_qm_dqget(mp, NULL, id, type, XFS_QMOPT_DQALLOC, &dqp))) {
626 xfs_trans_cancel(tp, XFS_TRANS_ABORT);
627 mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));
628 ASSERT(error != ENOENT);
629 return (error);
630 }
631 xfs_dqtrace_entry(dqp, "Q_SETQLIM: AFT DQGET");
632 xfs_trans_dqjoin(tp, dqp);
633 ddq = &dqp->q_core;
634
635 /*
636 * Make sure that hardlimits are >= soft limits before changing.
637 */
638 hard = (newlim->d_fieldmask & FS_DQ_BHARD) ?
639 (xfs_qcnt_t) XFS_BB_TO_FSB(mp, newlim->d_blk_hardlimit) :
640 be64_to_cpu(ddq->d_blk_hardlimit);
641 soft = (newlim->d_fieldmask & FS_DQ_BSOFT) ?
642 (xfs_qcnt_t) XFS_BB_TO_FSB(mp, newlim->d_blk_softlimit) :
643 be64_to_cpu(ddq->d_blk_softlimit);
644 if (hard == 0 || hard >= soft) {
645 ddq->d_blk_hardlimit = cpu_to_be64(hard);
646 ddq->d_blk_softlimit = cpu_to_be64(soft);
647 if (id == 0) {
648 mp->m_quotainfo->qi_bhardlimit = hard;
649 mp->m_quotainfo->qi_bsoftlimit = soft;
650 }
651 } else {
652 qdprintk("blkhard %Ld < blksoft %Ld\n", hard, soft);
653 }
654 hard = (newlim->d_fieldmask & FS_DQ_RTBHARD) ?
655 (xfs_qcnt_t) XFS_BB_TO_FSB(mp, newlim->d_rtb_hardlimit) :
656 be64_to_cpu(ddq->d_rtb_hardlimit);
657 soft = (newlim->d_fieldmask & FS_DQ_RTBSOFT) ?
658 (xfs_qcnt_t) XFS_BB_TO_FSB(mp, newlim->d_rtb_softlimit) :
659 be64_to_cpu(ddq->d_rtb_softlimit);
660 if (hard == 0 || hard >= soft) {
661 ddq->d_rtb_hardlimit = cpu_to_be64(hard);
662 ddq->d_rtb_softlimit = cpu_to_be64(soft);
663 if (id == 0) {
664 mp->m_quotainfo->qi_rtbhardlimit = hard;
665 mp->m_quotainfo->qi_rtbsoftlimit = soft;
666 }
667 } else {
668 qdprintk("rtbhard %Ld < rtbsoft %Ld\n", hard, soft);
669 }
670
671 hard = (newlim->d_fieldmask & FS_DQ_IHARD) ?
672 (xfs_qcnt_t) newlim->d_ino_hardlimit :
673 be64_to_cpu(ddq->d_ino_hardlimit);
674 soft = (newlim->d_fieldmask & FS_DQ_ISOFT) ?
675 (xfs_qcnt_t) newlim->d_ino_softlimit :
676 be64_to_cpu(ddq->d_ino_softlimit);
677 if (hard == 0 || hard >= soft) {
678 ddq->d_ino_hardlimit = cpu_to_be64(hard);
679 ddq->d_ino_softlimit = cpu_to_be64(soft);
680 if (id == 0) {
681 mp->m_quotainfo->qi_ihardlimit = hard;
682 mp->m_quotainfo->qi_isoftlimit = soft;
683 }
684 } else {
685 qdprintk("ihard %Ld < isoft %Ld\n", hard, soft);
686 }
687
688 /*
689 * Update warnings counter(s) if requested
690 */
691 if (newlim->d_fieldmask & FS_DQ_BWARNS)
692 ddq->d_bwarns = cpu_to_be16(newlim->d_bwarns);
693 if (newlim->d_fieldmask & FS_DQ_IWARNS)
694 ddq->d_iwarns = cpu_to_be16(newlim->d_iwarns);
695 if (newlim->d_fieldmask & FS_DQ_RTBWARNS)
696 ddq->d_rtbwarns = cpu_to_be16(newlim->d_rtbwarns);
697
698 if (id == 0) {
699 /*
700 * Timelimits for the super user set the relative time
701 * the other users can be over quota for this file system.
702 * If it is zero a default is used. Ditto for the default
703 * soft and hard limit values (already done, above), and
704 * for warnings.
705 */
706 if (newlim->d_fieldmask & FS_DQ_BTIMER) {
707 mp->m_quotainfo->qi_btimelimit = newlim->d_btimer;
708 ddq->d_btimer = cpu_to_be32(newlim->d_btimer);
709 }
710 if (newlim->d_fieldmask & FS_DQ_ITIMER) {
711 mp->m_quotainfo->qi_itimelimit = newlim->d_itimer;
712 ddq->d_itimer = cpu_to_be32(newlim->d_itimer);
713 }
714 if (newlim->d_fieldmask & FS_DQ_RTBTIMER) {
715 mp->m_quotainfo->qi_rtbtimelimit = newlim->d_rtbtimer;
716 ddq->d_rtbtimer = cpu_to_be32(newlim->d_rtbtimer);
717 }
718 if (newlim->d_fieldmask & FS_DQ_BWARNS)
719 mp->m_quotainfo->qi_bwarnlimit = newlim->d_bwarns;
720 if (newlim->d_fieldmask & FS_DQ_IWARNS)
721 mp->m_quotainfo->qi_iwarnlimit = newlim->d_iwarns;
722 if (newlim->d_fieldmask & FS_DQ_RTBWARNS)
723 mp->m_quotainfo->qi_rtbwarnlimit = newlim->d_rtbwarns;
724 } else {
725 /*
726 * If the user is now over quota, start the timelimit.
727 * The user will not be 'warned'.
728 * Note that we keep the timers ticking, whether enforcement
729 * is on or off. We don't really want to bother with iterating
730 * over all ondisk dquots and turning the timers on/off.
731 */
732 xfs_qm_adjust_dqtimers(mp, ddq);
733 }
734 dqp->dq_flags |= XFS_DQ_DIRTY;
735 xfs_trans_log_dquot(tp, dqp);
736
737 xfs_dqtrace_entry(dqp, "Q_SETQLIM: COMMIT");
738 xfs_trans_commit(tp, 0, NULL);
739 xfs_qm_dqprint(dqp);
740 xfs_qm_dqrele(dqp);
741 mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));
742
743 return (0);
744 }
745
746 STATIC int
747 xfs_qm_scall_getquota(
748 xfs_mount_t *mp,
749 xfs_dqid_t id,
750 uint type,
751 fs_disk_quota_t *out)
752 {
753 xfs_dquot_t *dqp;
754 int error;
755
756 /*
757 * Try to get the dquot. We don't want it allocated on disk, so
758 * we aren't passing the XFS_QMOPT_DOALLOC flag. If it doesn't
759 * exist, we'll get ENOENT back.
760 */
761 if ((error = xfs_qm_dqget(mp, NULL, id, type, 0, &dqp))) {
762 return (error);
763 }
764
765 xfs_dqtrace_entry(dqp, "Q_GETQUOTA SUCCESS");
766 /*
767 * If everything's NULL, this dquot doesn't quite exist as far as
768 * our utility programs are concerned.
769 */
770 if (XFS_IS_DQUOT_UNINITIALIZED(dqp)) {
771 xfs_qm_dqput(dqp);
772 return XFS_ERROR(ENOENT);
773 }
774 /* xfs_qm_dqprint(dqp); */
775 /*
776 * Convert the disk dquot to the exportable format
777 */
778 xfs_qm_export_dquot(mp, &dqp->q_core, out);
779 xfs_qm_dqput(dqp);
780 return (error ? XFS_ERROR(EFAULT) : 0);
781 }
782
783
784 STATIC int
785 xfs_qm_log_quotaoff_end(
786 xfs_mount_t *mp,
787 xfs_qoff_logitem_t *startqoff,
788 uint flags)
789 {
790 xfs_trans_t *tp;
791 int error;
792 xfs_qoff_logitem_t *qoffi;
793
794 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QUOTAOFF_END);
795
796 if ((error = xfs_trans_reserve(tp, 0, sizeof(xfs_qoff_logitem_t) * 2,
797 0, 0, XFS_DEFAULT_LOG_COUNT))) {
798 xfs_trans_cancel(tp, 0);
799 return (error);
800 }
801
802 qoffi = xfs_trans_get_qoff_item(tp, startqoff,
803 flags & XFS_ALL_QUOTA_ACCT);
804 xfs_trans_log_quotaoff_item(tp, qoffi);
805
806 /*
807 * We have to make sure that the transaction is secure on disk before we
808 * return and actually stop quota accounting. So, make it synchronous.
809 * We don't care about quotoff's performance.
810 */
811 xfs_trans_set_sync(tp);
812 error = xfs_trans_commit(tp, 0, NULL);
813 return (error);
814 }
815
816
817 STATIC int
818 xfs_qm_log_quotaoff(
819 xfs_mount_t *mp,
820 xfs_qoff_logitem_t **qoffstartp,
821 uint flags)
822 {
823 xfs_trans_t *tp;
824 int error;
825 unsigned long s;
826 xfs_qoff_logitem_t *qoffi=NULL;
827 uint oldsbqflag=0;
828
829 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QUOTAOFF);
830 if ((error = xfs_trans_reserve(tp, 0,
831 sizeof(xfs_qoff_logitem_t) * 2 +
832 mp->m_sb.sb_sectsize + 128,
833 0,
834 0,
835 XFS_DEFAULT_LOG_COUNT))) {
836 goto error0;
837 }
838
839 qoffi = xfs_trans_get_qoff_item(tp, NULL, flags & XFS_ALL_QUOTA_ACCT);
840 xfs_trans_log_quotaoff_item(tp, qoffi);
841
842 s = XFS_SB_LOCK(mp);
843 oldsbqflag = mp->m_sb.sb_qflags;
844 mp->m_sb.sb_qflags = (mp->m_qflags & ~(flags)) & XFS_MOUNT_QUOTA_ALL;
845 XFS_SB_UNLOCK(mp, s);
846
847 xfs_mod_sb(tp, XFS_SB_QFLAGS);
848
849 /*
850 * We have to make sure that the transaction is secure on disk before we
851 * return and actually stop quota accounting. So, make it synchronous.
852 * We don't care about quotoff's performance.
853 */
854 xfs_trans_set_sync(tp);
855 error = xfs_trans_commit(tp, 0, NULL);
856
857 error0:
858 if (error) {
859 xfs_trans_cancel(tp, 0);
860 /*
861 * No one else is modifying sb_qflags, so this is OK.
862 * We still hold the quotaofflock.
863 */
864 s = XFS_SB_LOCK(mp);
865 mp->m_sb.sb_qflags = oldsbqflag;
866 XFS_SB_UNLOCK(mp, s);
867 }
868 *qoffstartp = qoffi;
869 return (error);
870 }
871
872
873 /*
874 * Translate an internal style on-disk-dquot to the exportable format.
875 * The main differences are that the counters/limits are all in Basic
876 * Blocks (BBs) instead of the internal FSBs, and all on-disk data has
877 * to be converted to the native endianness.
878 */
879 STATIC void
880 xfs_qm_export_dquot(
881 xfs_mount_t *mp,
882 xfs_disk_dquot_t *src,
883 struct fs_disk_quota *dst)
884 {
885 memset(dst, 0, sizeof(*dst));
886 dst->d_version = FS_DQUOT_VERSION; /* different from src->d_version */
887 dst->d_flags = xfs_qm_export_qtype_flags(src->d_flags);
888 dst->d_id = be32_to_cpu(src->d_id);
889 dst->d_blk_hardlimit =
890 XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_blk_hardlimit));
891 dst->d_blk_softlimit =
892 XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_blk_softlimit));
893 dst->d_ino_hardlimit = be64_to_cpu(src->d_ino_hardlimit);
894 dst->d_ino_softlimit = be64_to_cpu(src->d_ino_softlimit);
895 dst->d_bcount = XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_bcount));
896 dst->d_icount = be64_to_cpu(src->d_icount);
897 dst->d_btimer = be32_to_cpu(src->d_btimer);
898 dst->d_itimer = be32_to_cpu(src->d_itimer);
899 dst->d_iwarns = be16_to_cpu(src->d_iwarns);
900 dst->d_bwarns = be16_to_cpu(src->d_bwarns);
901 dst->d_rtb_hardlimit =
902 XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_rtb_hardlimit));
903 dst->d_rtb_softlimit =
904 XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_rtb_softlimit));
905 dst->d_rtbcount = XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_rtbcount));
906 dst->d_rtbtimer = be32_to_cpu(src->d_rtbtimer);
907 dst->d_rtbwarns = be16_to_cpu(src->d_rtbwarns);
908
909 /*
910 * Internally, we don't reset all the timers when quota enforcement
911 * gets turned off. No need to confuse the user level code,
912 * so return zeroes in that case.
913 */
914 if (! XFS_IS_QUOTA_ENFORCED(mp)) {
915 dst->d_btimer = 0;
916 dst->d_itimer = 0;
917 dst->d_rtbtimer = 0;
918 }
919
920 #ifdef DEBUG
921 if (XFS_IS_QUOTA_ENFORCED(mp) && dst->d_id != 0) {
922 if (((int) dst->d_bcount >= (int) dst->d_blk_softlimit) &&
923 (dst->d_blk_softlimit > 0)) {
924 ASSERT(dst->d_btimer != 0);
925 }
926 if (((int) dst->d_icount >= (int) dst->d_ino_softlimit) &&
927 (dst->d_ino_softlimit > 0)) {
928 ASSERT(dst->d_itimer != 0);
929 }
930 }
931 #endif
932 }
933
934 STATIC uint
935 xfs_qm_import_qtype_flags(
936 uint uflags)
937 {
938 uint oflags = 0;
939
940 /*
941 * Can't be more than one, or none.
942 */
943 if (((uflags & (XFS_GROUP_QUOTA | XFS_USER_QUOTA)) ==
944 (XFS_GROUP_QUOTA | XFS_USER_QUOTA)) ||
945 ((uflags & (XFS_GROUP_QUOTA | XFS_PROJ_QUOTA)) ==
946 (XFS_GROUP_QUOTA | XFS_PROJ_QUOTA)) ||
947 ((uflags & (XFS_USER_QUOTA | XFS_PROJ_QUOTA)) ==
948 (XFS_USER_QUOTA | XFS_PROJ_QUOTA)) ||
949 ((uflags & (XFS_GROUP_QUOTA|XFS_USER_QUOTA|XFS_PROJ_QUOTA)) == 0))
950 return (0);
951
952 oflags |= (uflags & XFS_USER_QUOTA) ? XFS_DQ_USER : 0;
953 oflags |= (uflags & XFS_PROJ_QUOTA) ? XFS_DQ_PROJ : 0;
954 oflags |= (uflags & XFS_GROUP_QUOTA) ? XFS_DQ_GROUP: 0;
955 return oflags;
956 }
957
958 STATIC uint
959 xfs_qm_export_qtype_flags(
960 uint flags)
961 {
962 /*
963 * Can't be more than one, or none.
964 */
965 ASSERT((flags & (XFS_PROJ_QUOTA | XFS_USER_QUOTA)) !=
966 (XFS_PROJ_QUOTA | XFS_USER_QUOTA));
967 ASSERT((flags & (XFS_PROJ_QUOTA | XFS_GROUP_QUOTA)) !=
968 (XFS_PROJ_QUOTA | XFS_GROUP_QUOTA));
969 ASSERT((flags & (XFS_USER_QUOTA | XFS_GROUP_QUOTA)) !=
970 (XFS_USER_QUOTA | XFS_GROUP_QUOTA));
971 ASSERT((flags & (XFS_PROJ_QUOTA|XFS_USER_QUOTA|XFS_GROUP_QUOTA)) != 0);
972
973 return (flags & XFS_DQ_USER) ?
974 XFS_USER_QUOTA : (flags & XFS_DQ_PROJ) ?
975 XFS_PROJ_QUOTA : XFS_GROUP_QUOTA;
976 }
977
978 STATIC uint
979 xfs_qm_import_flags(
980 uint uflags)
981 {
982 uint flags = 0;
983
984 if (uflags & XFS_QUOTA_UDQ_ACCT)
985 flags |= XFS_UQUOTA_ACCT;
986 if (uflags & XFS_QUOTA_PDQ_ACCT)
987 flags |= XFS_PQUOTA_ACCT;
988 if (uflags & XFS_QUOTA_GDQ_ACCT)
989 flags |= XFS_GQUOTA_ACCT;
990 if (uflags & XFS_QUOTA_UDQ_ENFD)
991 flags |= XFS_UQUOTA_ENFD;
992 if (uflags & (XFS_QUOTA_PDQ_ENFD|XFS_QUOTA_GDQ_ENFD))
993 flags |= XFS_OQUOTA_ENFD;
994 return (flags);
995 }
996
997
998 STATIC uint
999 xfs_qm_export_flags(
1000 uint flags)
1001 {
1002 uint uflags;
1003
1004 uflags = 0;
1005 if (flags & XFS_UQUOTA_ACCT)
1006 uflags |= XFS_QUOTA_UDQ_ACCT;
1007 if (flags & XFS_PQUOTA_ACCT)
1008 uflags |= XFS_QUOTA_PDQ_ACCT;
1009 if (flags & XFS_GQUOTA_ACCT)
1010 uflags |= XFS_QUOTA_GDQ_ACCT;
1011 if (flags & XFS_UQUOTA_ENFD)
1012 uflags |= XFS_QUOTA_UDQ_ENFD;
1013 if (flags & (XFS_OQUOTA_ENFD)) {
1014 uflags |= (flags & XFS_GQUOTA_ACCT) ?
1015 XFS_QUOTA_GDQ_ENFD : XFS_QUOTA_PDQ_ENFD;
1016 }
1017 return (uflags);
1018 }
1019
1020
1021 /*
1022 * Go thru all the inodes in the file system, releasing their dquots.
1023 * Note that the mount structure gets modified to indicate that quotas are off
1024 * AFTER this, in the case of quotaoff. This also gets called from
1025 * xfs_rootumount.
1026 */
1027 void
1028 xfs_qm_dqrele_all_inodes(
1029 struct xfs_mount *mp,
1030 uint flags)
1031 {
1032 xfs_inode_t *ip, *topino;
1033 uint ireclaims;
1034 bhv_vnode_t *vp;
1035 boolean_t vnode_refd;
1036
1037 ASSERT(mp->m_quotainfo);
1038
1039 XFS_MOUNT_ILOCK(mp);
1040 again:
1041 ip = mp->m_inodes;
1042 if (ip == NULL) {
1043 XFS_MOUNT_IUNLOCK(mp);
1044 return;
1045 }
1046 do {
1047 /* Skip markers inserted by xfs_sync */
1048 if (ip->i_mount == NULL) {
1049 ip = ip->i_mnext;
1050 continue;
1051 }
1052 /* Root inode, rbmip and rsumip have associated blocks */
1053 if (ip == XFS_QI_UQIP(mp) || ip == XFS_QI_GQIP(mp)) {
1054 ASSERT(ip->i_udquot == NULL);
1055 ASSERT(ip->i_gdquot == NULL);
1056 ip = ip->i_mnext;
1057 continue;
1058 }
1059 vp = XFS_ITOV_NULL(ip);
1060 if (!vp) {
1061 ASSERT(ip->i_udquot == NULL);
1062 ASSERT(ip->i_gdquot == NULL);
1063 ip = ip->i_mnext;
1064 continue;
1065 }
1066 vnode_refd = B_FALSE;
1067 if (xfs_ilock_nowait(ip, XFS_ILOCK_EXCL) == 0) {
1068 ireclaims = mp->m_ireclaims;
1069 topino = mp->m_inodes;
1070 vp = vn_grab(vp);
1071 if (!vp)
1072 goto again;
1073
1074 XFS_MOUNT_IUNLOCK(mp);
1075 /* XXX restart limit ? */
1076 xfs_ilock(ip, XFS_ILOCK_EXCL);
1077 vnode_refd = B_TRUE;
1078 } else {
1079 ireclaims = mp->m_ireclaims;
1080 topino = mp->m_inodes;
1081 XFS_MOUNT_IUNLOCK(mp);
1082 }
1083
1084 /*
1085 * We don't keep the mountlock across the dqrele() call,
1086 * since it can take a while..
1087 */
1088 if ((flags & XFS_UQUOTA_ACCT) && ip->i_udquot) {
1089 xfs_qm_dqrele(ip->i_udquot);
1090 ip->i_udquot = NULL;
1091 }
1092 if (flags & (XFS_PQUOTA_ACCT|XFS_GQUOTA_ACCT) && ip->i_gdquot) {
1093 xfs_qm_dqrele(ip->i_gdquot);
1094 ip->i_gdquot = NULL;
1095 }
1096 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1097 /*
1098 * Wait until we've dropped the ilock and mountlock to
1099 * do the vn_rele. Or be condemned to an eternity in the
1100 * inactive code in hell.
1101 */
1102 if (vnode_refd)
1103 VN_RELE(vp);
1104 XFS_MOUNT_ILOCK(mp);
1105 /*
1106 * If an inode was inserted or removed, we gotta
1107 * start over again.
1108 */
1109 if (topino != mp->m_inodes || mp->m_ireclaims != ireclaims) {
1110 /* XXX use a sentinel */
1111 goto again;
1112 }
1113 ip = ip->i_mnext;
1114 } while (ip != mp->m_inodes);
1115
1116 XFS_MOUNT_IUNLOCK(mp);
1117 }
1118
1119 /*------------------------------------------------------------------------*/
1120 #ifdef DEBUG
1121 /*
1122 * This contains all the test functions for XFS disk quotas.
1123 * Currently it does a quota accounting check. ie. it walks through
1124 * all inodes in the file system, calculating the dquot accounting fields,
1125 * and prints out any inconsistencies.
1126 */
1127 xfs_dqhash_t *qmtest_udqtab;
1128 xfs_dqhash_t *qmtest_gdqtab;
1129 int qmtest_hashmask;
1130 int qmtest_nfails;
1131 mutex_t qcheck_lock;
1132
1133 #define DQTEST_HASHVAL(mp, id) (((__psunsigned_t)(mp) + \
1134 (__psunsigned_t)(id)) & \
1135 (qmtest_hashmask - 1))
1136
1137 #define DQTEST_HASH(mp, id, type) ((type & XFS_DQ_USER) ? \
1138 (qmtest_udqtab + \
1139 DQTEST_HASHVAL(mp, id)) : \
1140 (qmtest_gdqtab + \
1141 DQTEST_HASHVAL(mp, id)))
1142
1143 #define DQTEST_LIST_PRINT(l, NXT, title) \
1144 { \
1145 xfs_dqtest_t *dqp; int i = 0;\
1146 cmn_err(CE_DEBUG, "%s (#%d)", title, (int) (l)->qh_nelems); \
1147 for (dqp = (xfs_dqtest_t *)(l)->qh_next; dqp != NULL; \
1148 dqp = (xfs_dqtest_t *)dqp->NXT) { \
1149 cmn_err(CE_DEBUG, " %d. \"%d (%s)\" bcnt = %d, icnt = %d", \
1150 ++i, dqp->d_id, DQFLAGTO_TYPESTR(dqp), \
1151 dqp->d_bcount, dqp->d_icount); } \
1152 }
1153
1154 typedef struct dqtest {
1155 xfs_dqmarker_t q_lists;
1156 xfs_dqhash_t *q_hash; /* the hashchain header */
1157 xfs_mount_t *q_mount; /* filesystem this relates to */
1158 xfs_dqid_t d_id; /* user id or group id */
1159 xfs_qcnt_t d_bcount; /* # disk blocks owned by the user */
1160 xfs_qcnt_t d_icount; /* # inodes owned by the user */
1161 } xfs_dqtest_t;
1162
1163 STATIC void
1164 xfs_qm_hashinsert(xfs_dqhash_t *h, xfs_dqtest_t *dqp)
1165 {
1166 xfs_dquot_t *d;
1167 if (((d) = (h)->qh_next))
1168 (d)->HL_PREVP = &((dqp)->HL_NEXT);
1169 (dqp)->HL_NEXT = d;
1170 (dqp)->HL_PREVP = &((h)->qh_next);
1171 (h)->qh_next = (xfs_dquot_t *)dqp;
1172 (h)->qh_version++;
1173 (h)->qh_nelems++;
1174 }
1175 STATIC void
1176 xfs_qm_dqtest_print(
1177 xfs_dqtest_t *d)
1178 {
1179 cmn_err(CE_DEBUG, "-----------DQTEST DQUOT----------------");
1180 cmn_err(CE_DEBUG, "---- dquot ID = %d", d->d_id);
1181 cmn_err(CE_DEBUG, "---- fs = 0x%p", d->q_mount);
1182 cmn_err(CE_DEBUG, "---- bcount = %Lu (0x%x)",
1183 d->d_bcount, (int)d->d_bcount);
1184 cmn_err(CE_DEBUG, "---- icount = %Lu (0x%x)",
1185 d->d_icount, (int)d->d_icount);
1186 cmn_err(CE_DEBUG, "---------------------------");
1187 }
1188
1189 STATIC void
1190 xfs_qm_dqtest_failed(
1191 xfs_dqtest_t *d,
1192 xfs_dquot_t *dqp,
1193 char *reason,
1194 xfs_qcnt_t a,
1195 xfs_qcnt_t b,
1196 int error)
1197 {
1198 qmtest_nfails++;
1199 if (error)
1200 cmn_err(CE_DEBUG, "quotacheck failed id=%d, err=%d\nreason: %s",
1201 d->d_id, error, reason);
1202 else
1203 cmn_err(CE_DEBUG, "quotacheck failed id=%d (%s) [%d != %d]",
1204 d->d_id, reason, (int)a, (int)b);
1205 xfs_qm_dqtest_print(d);
1206 if (dqp)
1207 xfs_qm_dqprint(dqp);
1208 }
1209
1210 STATIC int
1211 xfs_dqtest_cmp2(
1212 xfs_dqtest_t *d,
1213 xfs_dquot_t *dqp)
1214 {
1215 int err = 0;
1216 if (be64_to_cpu(dqp->q_core.d_icount) != d->d_icount) {
1217 xfs_qm_dqtest_failed(d, dqp, "icount mismatch",
1218 be64_to_cpu(dqp->q_core.d_icount),
1219 d->d_icount, 0);
1220 err++;
1221 }
1222 if (be64_to_cpu(dqp->q_core.d_bcount) != d->d_bcount) {
1223 xfs_qm_dqtest_failed(d, dqp, "bcount mismatch",
1224 be64_to_cpu(dqp->q_core.d_bcount),
1225 d->d_bcount, 0);
1226 err++;
1227 }
1228 if (dqp->q_core.d_blk_softlimit &&
1229 be64_to_cpu(dqp->q_core.d_bcount) >=
1230 be64_to_cpu(dqp->q_core.d_blk_softlimit)) {
1231 if (!dqp->q_core.d_btimer && dqp->q_core.d_id) {
1232 cmn_err(CE_DEBUG,
1233 "%d [%s] [0x%p] BLK TIMER NOT STARTED",
1234 d->d_id, DQFLAGTO_TYPESTR(d), d->q_mount);
1235 err++;
1236 }
1237 }
1238 if (dqp->q_core.d_ino_softlimit &&
1239 be64_to_cpu(dqp->q_core.d_icount) >=
1240 be64_to_cpu(dqp->q_core.d_ino_softlimit)) {
1241 if (!dqp->q_core.d_itimer && dqp->q_core.d_id) {
1242 cmn_err(CE_DEBUG,
1243 "%d [%s] [0x%p] INO TIMER NOT STARTED",
1244 d->d_id, DQFLAGTO_TYPESTR(d), d->q_mount);
1245 err++;
1246 }
1247 }
1248 #ifdef QUOTADEBUG
1249 if (!err) {
1250 cmn_err(CE_DEBUG, "%d [%s] [0x%p] qchecked",
1251 d->d_id, DQFLAGTO_TYPESTR(d), d->q_mount);
1252 }
1253 #endif
1254 return (err);
1255 }
1256
1257 STATIC void
1258 xfs_dqtest_cmp(
1259 xfs_dqtest_t *d)
1260 {
1261 xfs_dquot_t *dqp;
1262 int error;
1263
1264 /* xfs_qm_dqtest_print(d); */
1265 if ((error = xfs_qm_dqget(d->q_mount, NULL, d->d_id, d->dq_flags, 0,
1266 &dqp))) {
1267 xfs_qm_dqtest_failed(d, NULL, "dqget failed", 0, 0, error);
1268 return;
1269 }
1270 xfs_dqtest_cmp2(d, dqp);
1271 xfs_qm_dqput(dqp);
1272 }
1273
1274 STATIC int
1275 xfs_qm_internalqcheck_dqget(
1276 xfs_mount_t *mp,
1277 xfs_dqid_t id,
1278 uint type,
1279 xfs_dqtest_t **O_dq)
1280 {
1281 xfs_dqtest_t *d;
1282 xfs_dqhash_t *h;
1283
1284 h = DQTEST_HASH(mp, id, type);
1285 for (d = (xfs_dqtest_t *) h->qh_next; d != NULL;
1286 d = (xfs_dqtest_t *) d->HL_NEXT) {
1287 /* DQTEST_LIST_PRINT(h, HL_NEXT, "@@@@@ dqtestlist @@@@@"); */
1288 if (d->d_id == id && mp == d->q_mount) {
1289 *O_dq = d;
1290 return (0);
1291 }
1292 }
1293 d = kmem_zalloc(sizeof(xfs_dqtest_t), KM_SLEEP);
1294 d->dq_flags = type;
1295 d->d_id = id;
1296 d->q_mount = mp;
1297 d->q_hash = h;
1298 xfs_qm_hashinsert(h, d);
1299 *O_dq = d;
1300 return (0);
1301 }
1302
1303 STATIC void
1304 xfs_qm_internalqcheck_get_dquots(
1305 xfs_mount_t *mp,
1306 xfs_dqid_t uid,
1307 xfs_dqid_t projid,
1308 xfs_dqid_t gid,
1309 xfs_dqtest_t **ud,
1310 xfs_dqtest_t **gd)
1311 {
1312 if (XFS_IS_UQUOTA_ON(mp))
1313 xfs_qm_internalqcheck_dqget(mp, uid, XFS_DQ_USER, ud);
1314 if (XFS_IS_GQUOTA_ON(mp))
1315 xfs_qm_internalqcheck_dqget(mp, gid, XFS_DQ_GROUP, gd);
1316 else if (XFS_IS_PQUOTA_ON(mp))
1317 xfs_qm_internalqcheck_dqget(mp, projid, XFS_DQ_PROJ, gd);
1318 }
1319
1320
1321 STATIC void
1322 xfs_qm_internalqcheck_dqadjust(
1323 xfs_inode_t *ip,
1324 xfs_dqtest_t *d)
1325 {
1326 d->d_icount++;
1327 d->d_bcount += (xfs_qcnt_t)ip->i_d.di_nblocks;
1328 }
1329
1330 STATIC int
1331 xfs_qm_internalqcheck_adjust(
1332 xfs_mount_t *mp, /* mount point for filesystem */
1333 xfs_ino_t ino, /* inode number to get data for */
1334 void __user *buffer, /* not used */
1335 int ubsize, /* not used */
1336 void *private_data, /* not used */
1337 xfs_daddr_t bno, /* starting block of inode cluster */
1338 int *ubused, /* not used */
1339 void *dip, /* not used */
1340 int *res) /* bulkstat result code */
1341 {
1342 xfs_inode_t *ip;
1343 xfs_dqtest_t *ud, *gd;
1344 uint lock_flags;
1345 boolean_t ipreleased;
1346 int error;
1347
1348 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1349
1350 if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
1351 *res = BULKSTAT_RV_NOTHING;
1352 qdprintk("internalqcheck: ino=%llu, uqino=%llu, gqino=%llu\n",
1353 (unsigned long long) ino,
1354 (unsigned long long) mp->m_sb.sb_uquotino,
1355 (unsigned long long) mp->m_sb.sb_gquotino);
1356 return XFS_ERROR(EINVAL);
1357 }
1358 ipreleased = B_FALSE;
1359 again:
1360 lock_flags = XFS_ILOCK_SHARED;
1361 if ((error = xfs_iget(mp, NULL, ino, 0, lock_flags, &ip, bno))) {
1362 *res = BULKSTAT_RV_NOTHING;
1363 return (error);
1364 }
1365
1366 if (ip->i_d.di_mode == 0) {
1367 xfs_iput_new(ip, lock_flags);
1368 *res = BULKSTAT_RV_NOTHING;
1369 return XFS_ERROR(ENOENT);
1370 }
1371
1372 /*
1373 * This inode can have blocks after eof which can get released
1374 * when we send it to inactive. Since we don't check the dquot
1375 * until the after all our calculations are done, we must get rid
1376 * of those now.
1377 */
1378 if (! ipreleased) {
1379 xfs_iput(ip, lock_flags);
1380 ipreleased = B_TRUE;
1381 goto again;
1382 }
1383 xfs_qm_internalqcheck_get_dquots(mp,
1384 (xfs_dqid_t) ip->i_d.di_uid,
1385 (xfs_dqid_t) ip->i_d.di_projid,
1386 (xfs_dqid_t) ip->i_d.di_gid,
1387 &ud, &gd);
1388 if (XFS_IS_UQUOTA_ON(mp)) {
1389 ASSERT(ud);
1390 xfs_qm_internalqcheck_dqadjust(ip, ud);
1391 }
1392 if (XFS_IS_OQUOTA_ON(mp)) {
1393 ASSERT(gd);
1394 xfs_qm_internalqcheck_dqadjust(ip, gd);
1395 }
1396 xfs_iput(ip, lock_flags);
1397 *res = BULKSTAT_RV_DIDONE;
1398 return (0);
1399 }
1400
1401
1402 /* PRIVATE, debugging */
1403 int
1404 xfs_qm_internalqcheck(
1405 xfs_mount_t *mp)
1406 {
1407 xfs_ino_t lastino;
1408 int done, count;
1409 int i;
1410 xfs_dqtest_t *d, *e;
1411 xfs_dqhash_t *h1;
1412 int error;
1413
1414 lastino = 0;
1415 qmtest_hashmask = 32;
1416 count = 5;
1417 done = 0;
1418 qmtest_nfails = 0;
1419
1420 if (! XFS_IS_QUOTA_ON(mp))
1421 return XFS_ERROR(ESRCH);
1422
1423 xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE | XFS_LOG_SYNC);
1424 XFS_bflush(mp->m_ddev_targp);
1425 xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE | XFS_LOG_SYNC);
1426 XFS_bflush(mp->m_ddev_targp);
1427
1428 mutex_lock(&qcheck_lock);
1429 /* There should be absolutely no quota activity while this
1430 is going on. */
1431 qmtest_udqtab = kmem_zalloc(qmtest_hashmask *
1432 sizeof(xfs_dqhash_t), KM_SLEEP);
1433 qmtest_gdqtab = kmem_zalloc(qmtest_hashmask *
1434 sizeof(xfs_dqhash_t), KM_SLEEP);
1435 do {
1436 /*
1437 * Iterate thru all the inodes in the file system,
1438 * adjusting the corresponding dquot counters
1439 */
1440 if ((error = xfs_bulkstat(mp, &lastino, &count,
1441 xfs_qm_internalqcheck_adjust, NULL,
1442 0, NULL, BULKSTAT_FG_IGET, &done))) {
1443 break;
1444 }
1445 } while (! done);
1446 if (error) {
1447 cmn_err(CE_DEBUG, "Bulkstat returned error 0x%x", error);
1448 }
1449 cmn_err(CE_DEBUG, "Checking results against system dquots");
1450 for (i = 0; i < qmtest_hashmask; i++) {
1451 h1 = &qmtest_udqtab[i];
1452 for (d = (xfs_dqtest_t *) h1->qh_next; d != NULL; ) {
1453 xfs_dqtest_cmp(d);
1454 e = (xfs_dqtest_t *) d->HL_NEXT;
1455 kmem_free(d, sizeof(xfs_dqtest_t));
1456 d = e;
1457 }
1458 h1 = &qmtest_gdqtab[i];
1459 for (d = (xfs_dqtest_t *) h1->qh_next; d != NULL; ) {
1460 xfs_dqtest_cmp(d);
1461 e = (xfs_dqtest_t *) d->HL_NEXT;
1462 kmem_free(d, sizeof(xfs_dqtest_t));
1463 d = e;
1464 }
1465 }
1466
1467 if (qmtest_nfails) {
1468 cmn_err(CE_DEBUG, "******** quotacheck failed ********");
1469 cmn_err(CE_DEBUG, "failures = %d", qmtest_nfails);
1470 } else {
1471 cmn_err(CE_DEBUG, "******** quotacheck successful! ********");
1472 }
1473 kmem_free(qmtest_udqtab, qmtest_hashmask * sizeof(xfs_dqhash_t));
1474 kmem_free(qmtest_gdqtab, qmtest_hashmask * sizeof(xfs_dqhash_t));
1475 mutex_unlock(&qcheck_lock);
1476 return (qmtest_nfails);
1477 }
1478
1479 #endif /* DEBUG */
Linux with added FPC-III support