2 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
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.
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.
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
19 #include <linux/capability.h>
23 #include "xfs_shared.h"
24 #include "xfs_format.h"
25 #include "xfs_log_format.h"
26 #include "xfs_trans_resv.h"
30 #include "xfs_mount.h"
31 #include "xfs_inode.h"
32 #include "xfs_trans.h"
33 #include "xfs_error.h"
34 #include "xfs_quota.h"
36 #include "xfs_trace.h"
37 #include "xfs_icache.h"
39 STATIC
int xfs_qm_log_quotaoff(xfs_mount_t
*, xfs_qoff_logitem_t
**, uint
);
40 STATIC
int xfs_qm_log_quotaoff_end(xfs_mount_t
*, xfs_qoff_logitem_t
*,
42 STATIC uint
xfs_qm_export_flags(uint
);
43 STATIC uint
xfs_qm_export_qtype_flags(uint
);
46 * Turn off quota accounting and/or enforcement for all udquots and/or
47 * gdquots. Called only at unmount time.
49 * This assumes that there are no dquots of this file system cached
50 * incore, and modifies the ondisk dquot directly. Therefore, for example,
51 * it is an error to call this twice, without purging the cache.
54 xfs_qm_scall_quotaoff(
58 struct xfs_quotainfo
*q
= mp
->m_quotainfo
;
61 uint inactivate_flags
;
62 xfs_qoff_logitem_t
*qoffstart
;
65 * No file system can have quotas enabled on disk but not in core.
66 * Note that quota utilities (like quotaoff) _expect_
67 * errno == EEXIST here.
69 if ((mp
->m_qflags
& flags
) == 0)
70 return XFS_ERROR(EEXIST
);
73 flags
&= (XFS_ALL_QUOTA_ACCT
| XFS_ALL_QUOTA_ENFD
);
76 * We don't want to deal with two quotaoffs messing up each other,
77 * so we're going to serialize it. quotaoff isn't exactly a performance
79 * If quotaoff, then we must be dealing with the root filesystem.
82 mutex_lock(&q
->qi_quotaofflock
);
85 * If we're just turning off quota enforcement, change mp and go.
87 if ((flags
& XFS_ALL_QUOTA_ACCT
) == 0) {
88 mp
->m_qflags
&= ~(flags
);
90 spin_lock(&mp
->m_sb_lock
);
91 mp
->m_sb
.sb_qflags
= mp
->m_qflags
;
92 spin_unlock(&mp
->m_sb_lock
);
93 mutex_unlock(&q
->qi_quotaofflock
);
95 /* XXX what to do if error ? Revert back to old vals incore ? */
96 error
= xfs_qm_write_sb_changes(mp
, XFS_SB_QFLAGS
);
101 inactivate_flags
= 0;
103 * If accounting is off, we must turn enforcement off, clear the
104 * quota 'CHKD' certificate to make it known that we have to
105 * do a quotacheck the next time this quota is turned on.
107 if (flags
& XFS_UQUOTA_ACCT
) {
108 dqtype
|= XFS_QMOPT_UQUOTA
;
109 flags
|= (XFS_UQUOTA_CHKD
| XFS_UQUOTA_ENFD
);
110 inactivate_flags
|= XFS_UQUOTA_ACTIVE
;
112 if (flags
& XFS_GQUOTA_ACCT
) {
113 dqtype
|= XFS_QMOPT_GQUOTA
;
114 flags
|= (XFS_GQUOTA_CHKD
| XFS_GQUOTA_ENFD
);
115 inactivate_flags
|= XFS_GQUOTA_ACTIVE
;
117 if (flags
& XFS_PQUOTA_ACCT
) {
118 dqtype
|= XFS_QMOPT_PQUOTA
;
119 flags
|= (XFS_PQUOTA_CHKD
| XFS_PQUOTA_ENFD
);
120 inactivate_flags
|= XFS_PQUOTA_ACTIVE
;
124 * Nothing to do? Don't complain. This happens when we're just
125 * turning off quota enforcement.
127 if ((mp
->m_qflags
& flags
) == 0)
131 * Write the LI_QUOTAOFF log record, and do SB changes atomically,
132 * and synchronously. If we fail to write, we should abort the
133 * operation as it cannot be recovered safely if we crash.
135 error
= xfs_qm_log_quotaoff(mp
, &qoffstart
, flags
);
140 * Next we clear the XFS_MOUNT_*DQ_ACTIVE bit(s) in the mount struct
141 * to take care of the race between dqget and quotaoff. We don't take
142 * any special locks to reset these bits. All processes need to check
143 * these bits *after* taking inode lock(s) to see if the particular
144 * quota type is in the process of being turned off. If *ACTIVE, it is
145 * guaranteed that all dquot structures and all quotainode ptrs will all
146 * stay valid as long as that inode is kept locked.
148 * There is no turning back after this.
150 mp
->m_qflags
&= ~inactivate_flags
;
153 * Give back all the dquot reference(s) held by inodes.
154 * Here we go thru every single incore inode in this file system, and
155 * do a dqrele on the i_udquot/i_gdquot that it may have.
156 * Essentially, as long as somebody has an inode locked, this guarantees
157 * that quotas will not be turned off. This is handy because in a
158 * transaction once we lock the inode(s) and check for quotaon, we can
159 * depend on the quota inodes (and other things) being valid as long as
160 * we keep the lock(s).
162 xfs_qm_dqrele_all_inodes(mp
, flags
);
165 * Next we make the changes in the quota flag in the mount struct.
166 * This isn't protected by a particular lock directly, because we
167 * don't want to take a mrlock every time we depend on quotas being on.
169 mp
->m_qflags
&= ~flags
;
172 * Go through all the dquots of this file system and purge them,
173 * according to what was turned off.
175 xfs_qm_dqpurge_all(mp
, dqtype
);
178 * Transactions that had started before ACTIVE state bit was cleared
179 * could have logged many dquots, so they'd have higher LSNs than
180 * the first QUOTAOFF log record does. If we happen to crash when
181 * the tail of the log has gone past the QUOTAOFF record, but
182 * before the last dquot modification, those dquots __will__
183 * recover, and that's not good.
185 * So, we have QUOTAOFF start and end logitems; the start
186 * logitem won't get overwritten until the end logitem appears...
188 error
= xfs_qm_log_quotaoff_end(mp
, qoffstart
, flags
);
190 /* We're screwed now. Shutdown is the only option. */
191 xfs_force_shutdown(mp
, SHUTDOWN_CORRUPT_INCORE
);
196 * If all quotas are completely turned off, close shop.
198 if (mp
->m_qflags
== 0) {
199 mutex_unlock(&q
->qi_quotaofflock
);
200 xfs_qm_destroy_quotainfo(mp
);
205 * Release our quotainode references if we don't need them anymore.
207 if ((dqtype
& XFS_QMOPT_UQUOTA
) && q
->qi_uquotaip
) {
208 IRELE(q
->qi_uquotaip
);
209 q
->qi_uquotaip
= NULL
;
211 if ((dqtype
& XFS_QMOPT_GQUOTA
) && q
->qi_gquotaip
) {
212 IRELE(q
->qi_gquotaip
);
213 q
->qi_gquotaip
= NULL
;
215 if ((dqtype
& XFS_QMOPT_PQUOTA
) && q
->qi_pquotaip
) {
216 IRELE(q
->qi_pquotaip
);
217 q
->qi_pquotaip
= NULL
;
221 mutex_unlock(&q
->qi_quotaofflock
);
226 xfs_qm_scall_trunc_qfile(
227 struct xfs_mount
*mp
,
230 struct xfs_inode
*ip
;
231 struct xfs_trans
*tp
;
234 if (ino
== NULLFSINO
)
237 error
= xfs_iget(mp
, NULL
, ino
, 0, 0, &ip
);
241 xfs_ilock(ip
, XFS_IOLOCK_EXCL
);
243 tp
= xfs_trans_alloc(mp
, XFS_TRANS_TRUNCATE_FILE
);
244 error
= xfs_trans_reserve(tp
, &M_RES(mp
)->tr_itruncate
, 0, 0);
246 xfs_trans_cancel(tp
, 0);
247 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
251 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
252 xfs_trans_ijoin(tp
, ip
, 0);
255 xfs_trans_log_inode(tp
, ip
, XFS_ILOG_CORE
);
257 error
= xfs_itruncate_extents(&tp
, ip
, XFS_DATA_FORK
, 0);
259 xfs_trans_cancel(tp
, XFS_TRANS_RELEASE_LOG_RES
|
264 ASSERT(ip
->i_d
.di_nextents
== 0);
266 xfs_trans_ichgtime(tp
, ip
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
267 error
= xfs_trans_commit(tp
, XFS_TRANS_RELEASE_LOG_RES
);
270 xfs_iunlock(ip
, XFS_ILOCK_EXCL
| XFS_IOLOCK_EXCL
);
277 xfs_qm_scall_trunc_qfiles(
281 int error
= 0, error2
= 0;
283 if (!xfs_sb_version_hasquota(&mp
->m_sb
) || flags
== 0) {
284 xfs_debug(mp
, "%s: flags=%x m_qflags=%x",
285 __func__
, flags
, mp
->m_qflags
);
286 return XFS_ERROR(EINVAL
);
289 if (flags
& XFS_DQ_USER
)
290 error
= xfs_qm_scall_trunc_qfile(mp
, mp
->m_sb
.sb_uquotino
);
291 if (flags
& XFS_DQ_GROUP
)
292 error2
= xfs_qm_scall_trunc_qfile(mp
, mp
->m_sb
.sb_gquotino
);
293 if (flags
& XFS_DQ_PROJ
)
294 error2
= xfs_qm_scall_trunc_qfile(mp
, mp
->m_sb
.sb_pquotino
);
296 return error
? error
: error2
;
300 * Switch on (a given) quota enforcement for a filesystem. This takes
301 * effect immediately.
302 * (Switching on quota accounting must be done at mount time.)
305 xfs_qm_scall_quotaon(
313 flags
&= (XFS_ALL_QUOTA_ACCT
| XFS_ALL_QUOTA_ENFD
);
315 * Switching on quota accounting must be done at mount time.
317 flags
&= ~(XFS_ALL_QUOTA_ACCT
);
322 xfs_debug(mp
, "%s: zero flags, m_qflags=%x",
323 __func__
, mp
->m_qflags
);
324 return XFS_ERROR(EINVAL
);
327 /* No fs can turn on quotas with a delayed effect */
328 ASSERT((flags
& XFS_ALL_QUOTA_ACCT
) == 0);
331 * Can't enforce without accounting. We check the superblock
332 * qflags here instead of m_qflags because rootfs can have
333 * quota acct on ondisk without m_qflags' knowing.
335 if (((flags
& XFS_UQUOTA_ACCT
) == 0 &&
336 (mp
->m_sb
.sb_qflags
& XFS_UQUOTA_ACCT
) == 0 &&
337 (flags
& XFS_UQUOTA_ENFD
)) ||
338 ((flags
& XFS_GQUOTA_ACCT
) == 0 &&
339 (mp
->m_sb
.sb_qflags
& XFS_GQUOTA_ACCT
) == 0 &&
340 (flags
& XFS_GQUOTA_ENFD
)) ||
341 ((flags
& XFS_PQUOTA_ACCT
) == 0 &&
342 (mp
->m_sb
.sb_qflags
& XFS_PQUOTA_ACCT
) == 0 &&
343 (flags
& XFS_PQUOTA_ENFD
))) {
345 "%s: Can't enforce without acct, flags=%x sbflags=%x",
346 __func__
, flags
, mp
->m_sb
.sb_qflags
);
347 return XFS_ERROR(EINVAL
);
350 * If everything's up to-date incore, then don't waste time.
352 if ((mp
->m_qflags
& flags
) == flags
)
353 return XFS_ERROR(EEXIST
);
356 * Change sb_qflags on disk but not incore mp->qflags
357 * if this is the root filesystem.
359 spin_lock(&mp
->m_sb_lock
);
360 qf
= mp
->m_sb
.sb_qflags
;
361 mp
->m_sb
.sb_qflags
= qf
| flags
;
362 spin_unlock(&mp
->m_sb_lock
);
365 * There's nothing to change if it's the same.
367 if ((qf
& flags
) == flags
&& sbflags
== 0)
368 return XFS_ERROR(EEXIST
);
369 sbflags
|= XFS_SB_QFLAGS
;
371 if ((error
= xfs_qm_write_sb_changes(mp
, sbflags
)))
374 * If we aren't trying to switch on quota enforcement, we are done.
376 if (((mp
->m_sb
.sb_qflags
& XFS_UQUOTA_ACCT
) !=
377 (mp
->m_qflags
& XFS_UQUOTA_ACCT
)) ||
378 ((mp
->m_sb
.sb_qflags
& XFS_PQUOTA_ACCT
) !=
379 (mp
->m_qflags
& XFS_PQUOTA_ACCT
)) ||
380 ((mp
->m_sb
.sb_qflags
& XFS_GQUOTA_ACCT
) !=
381 (mp
->m_qflags
& XFS_GQUOTA_ACCT
)) ||
382 (flags
& XFS_ALL_QUOTA_ENFD
) == 0)
385 if (! XFS_IS_QUOTA_RUNNING(mp
))
386 return XFS_ERROR(ESRCH
);
389 * Switch on quota enforcement in core.
391 mutex_lock(&mp
->m_quotainfo
->qi_quotaofflock
);
392 mp
->m_qflags
|= (flags
& XFS_ALL_QUOTA_ENFD
);
393 mutex_unlock(&mp
->m_quotainfo
->qi_quotaofflock
);
400 * Return quota status information, such as uquota-off, enforcements, etc.
401 * for Q_XGETQSTAT command.
404 xfs_qm_scall_getqstat(
405 struct xfs_mount
*mp
,
406 struct fs_quota_stat
*out
)
408 struct xfs_quotainfo
*q
= mp
->m_quotainfo
;
409 struct xfs_inode
*uip
= NULL
;
410 struct xfs_inode
*gip
= NULL
;
411 struct xfs_inode
*pip
= NULL
;
412 bool tempuqip
= false;
413 bool tempgqip
= false;
414 bool temppqip
= false;
416 memset(out
, 0, sizeof(fs_quota_stat_t
));
418 out
->qs_version
= FS_QSTAT_VERSION
;
419 if (!xfs_sb_version_hasquota(&mp
->m_sb
)) {
420 out
->qs_uquota
.qfs_ino
= NULLFSINO
;
421 out
->qs_gquota
.qfs_ino
= NULLFSINO
;
425 out
->qs_flags
= (__uint16_t
) xfs_qm_export_flags(mp
->m_qflags
&
427 XFS_ALL_QUOTA_ENFD
));
429 uip
= q
->qi_uquotaip
;
430 gip
= q
->qi_gquotaip
;
431 pip
= q
->qi_pquotaip
;
433 if (!uip
&& mp
->m_sb
.sb_uquotino
!= NULLFSINO
) {
434 if (xfs_iget(mp
, NULL
, mp
->m_sb
.sb_uquotino
,
438 if (!gip
&& mp
->m_sb
.sb_gquotino
!= NULLFSINO
) {
439 if (xfs_iget(mp
, NULL
, mp
->m_sb
.sb_gquotino
,
444 * Q_XGETQSTAT doesn't have room for both group and project quotas.
445 * So, allow the project quota values to be copied out only if
446 * there is no group quota information available.
449 if (!pip
&& mp
->m_sb
.sb_pquotino
!= NULLFSINO
) {
450 if (xfs_iget(mp
, NULL
, mp
->m_sb
.sb_pquotino
,
457 out
->qs_uquota
.qfs_ino
= mp
->m_sb
.sb_uquotino
;
458 out
->qs_uquota
.qfs_nblks
= uip
->i_d
.di_nblocks
;
459 out
->qs_uquota
.qfs_nextents
= uip
->i_d
.di_nextents
;
465 out
->qs_gquota
.qfs_ino
= mp
->m_sb
.sb_gquotino
;
466 out
->qs_gquota
.qfs_nblks
= gip
->i_d
.di_nblocks
;
467 out
->qs_gquota
.qfs_nextents
= gip
->i_d
.di_nextents
;
472 out
->qs_gquota
.qfs_ino
= mp
->m_sb
.sb_gquotino
;
473 out
->qs_gquota
.qfs_nblks
= pip
->i_d
.di_nblocks
;
474 out
->qs_gquota
.qfs_nextents
= pip
->i_d
.di_nextents
;
479 out
->qs_incoredqs
= q
->qi_dquots
;
480 out
->qs_btimelimit
= q
->qi_btimelimit
;
481 out
->qs_itimelimit
= q
->qi_itimelimit
;
482 out
->qs_rtbtimelimit
= q
->qi_rtbtimelimit
;
483 out
->qs_bwarnlimit
= q
->qi_bwarnlimit
;
484 out
->qs_iwarnlimit
= q
->qi_iwarnlimit
;
490 * Return quota status information, such as uquota-off, enforcements, etc.
491 * for Q_XGETQSTATV command, to support separate project quota field.
494 xfs_qm_scall_getqstatv(
495 struct xfs_mount
*mp
,
496 struct fs_quota_statv
*out
)
498 struct xfs_quotainfo
*q
= mp
->m_quotainfo
;
499 struct xfs_inode
*uip
= NULL
;
500 struct xfs_inode
*gip
= NULL
;
501 struct xfs_inode
*pip
= NULL
;
502 bool tempuqip
= false;
503 bool tempgqip
= false;
504 bool temppqip
= false;
506 if (!xfs_sb_version_hasquota(&mp
->m_sb
)) {
507 out
->qs_uquota
.qfs_ino
= NULLFSINO
;
508 out
->qs_gquota
.qfs_ino
= NULLFSINO
;
509 out
->qs_pquota
.qfs_ino
= NULLFSINO
;
513 out
->qs_flags
= (__uint16_t
) xfs_qm_export_flags(mp
->m_qflags
&
515 XFS_ALL_QUOTA_ENFD
));
516 out
->qs_uquota
.qfs_ino
= mp
->m_sb
.sb_uquotino
;
517 out
->qs_gquota
.qfs_ino
= mp
->m_sb
.sb_gquotino
;
518 out
->qs_pquota
.qfs_ino
= mp
->m_sb
.sb_pquotino
;
521 uip
= q
->qi_uquotaip
;
522 gip
= q
->qi_gquotaip
;
523 pip
= q
->qi_pquotaip
;
525 if (!uip
&& mp
->m_sb
.sb_uquotino
!= NULLFSINO
) {
526 if (xfs_iget(mp
, NULL
, mp
->m_sb
.sb_uquotino
,
530 if (!gip
&& mp
->m_sb
.sb_gquotino
!= NULLFSINO
) {
531 if (xfs_iget(mp
, NULL
, mp
->m_sb
.sb_gquotino
,
535 if (!pip
&& mp
->m_sb
.sb_pquotino
!= NULLFSINO
) {
536 if (xfs_iget(mp
, NULL
, mp
->m_sb
.sb_pquotino
,
541 out
->qs_uquota
.qfs_nblks
= uip
->i_d
.di_nblocks
;
542 out
->qs_uquota
.qfs_nextents
= uip
->i_d
.di_nextents
;
548 out
->qs_gquota
.qfs_nblks
= gip
->i_d
.di_nblocks
;
549 out
->qs_gquota
.qfs_nextents
= gip
->i_d
.di_nextents
;
554 out
->qs_pquota
.qfs_nblks
= pip
->i_d
.di_nblocks
;
555 out
->qs_pquota
.qfs_nextents
= pip
->i_d
.di_nextents
;
560 out
->qs_incoredqs
= q
->qi_dquots
;
561 out
->qs_btimelimit
= q
->qi_btimelimit
;
562 out
->qs_itimelimit
= q
->qi_itimelimit
;
563 out
->qs_rtbtimelimit
= q
->qi_rtbtimelimit
;
564 out
->qs_bwarnlimit
= q
->qi_bwarnlimit
;
565 out
->qs_iwarnlimit
= q
->qi_iwarnlimit
;
570 #define XFS_DQ_MASK \
571 (FS_DQ_LIMIT_MASK | FS_DQ_TIMER_MASK | FS_DQ_WARNS_MASK)
574 * Adjust quota limits, and start/stop timers accordingly.
577 xfs_qm_scall_setqlim(
578 struct xfs_mount
*mp
,
581 fs_disk_quota_t
*newlim
)
583 struct xfs_quotainfo
*q
= mp
->m_quotainfo
;
584 struct xfs_disk_dquot
*ddq
;
585 struct xfs_dquot
*dqp
;
586 struct xfs_trans
*tp
;
588 xfs_qcnt_t hard
, soft
;
590 if (newlim
->d_fieldmask
& ~XFS_DQ_MASK
)
592 if ((newlim
->d_fieldmask
& XFS_DQ_MASK
) == 0)
596 * We don't want to race with a quotaoff so take the quotaoff lock.
597 * We don't hold an inode lock, so there's nothing else to stop
598 * a quotaoff from happening.
600 mutex_lock(&q
->qi_quotaofflock
);
603 * Get the dquot (locked) before we start, as we need to do a
604 * transaction to allocate it if it doesn't exist. Once we have the
605 * dquot, unlock it so we can start the next transaction safely. We hold
606 * a reference to the dquot, so it's safe to do this unlock/lock without
607 * it being reclaimed in the mean time.
609 error
= xfs_qm_dqget(mp
, NULL
, id
, type
, XFS_QMOPT_DQALLOC
, &dqp
);
611 ASSERT(error
!= ENOENT
);
616 tp
= xfs_trans_alloc(mp
, XFS_TRANS_QM_SETQLIM
);
617 error
= xfs_trans_reserve(tp
, &M_RES(mp
)->tr_qm_setqlim
, 0, 0);
619 xfs_trans_cancel(tp
, 0);
624 xfs_trans_dqjoin(tp
, dqp
);
628 * Make sure that hardlimits are >= soft limits before changing.
630 hard
= (newlim
->d_fieldmask
& FS_DQ_BHARD
) ?
631 (xfs_qcnt_t
) XFS_BB_TO_FSB(mp
, newlim
->d_blk_hardlimit
) :
632 be64_to_cpu(ddq
->d_blk_hardlimit
);
633 soft
= (newlim
->d_fieldmask
& FS_DQ_BSOFT
) ?
634 (xfs_qcnt_t
) XFS_BB_TO_FSB(mp
, newlim
->d_blk_softlimit
) :
635 be64_to_cpu(ddq
->d_blk_softlimit
);
636 if (hard
== 0 || hard
>= soft
) {
637 ddq
->d_blk_hardlimit
= cpu_to_be64(hard
);
638 ddq
->d_blk_softlimit
= cpu_to_be64(soft
);
639 xfs_dquot_set_prealloc_limits(dqp
);
641 q
->qi_bhardlimit
= hard
;
642 q
->qi_bsoftlimit
= soft
;
645 xfs_debug(mp
, "blkhard %Ld < blksoft %Ld", hard
, soft
);
647 hard
= (newlim
->d_fieldmask
& FS_DQ_RTBHARD
) ?
648 (xfs_qcnt_t
) XFS_BB_TO_FSB(mp
, newlim
->d_rtb_hardlimit
) :
649 be64_to_cpu(ddq
->d_rtb_hardlimit
);
650 soft
= (newlim
->d_fieldmask
& FS_DQ_RTBSOFT
) ?
651 (xfs_qcnt_t
) XFS_BB_TO_FSB(mp
, newlim
->d_rtb_softlimit
) :
652 be64_to_cpu(ddq
->d_rtb_softlimit
);
653 if (hard
== 0 || hard
>= soft
) {
654 ddq
->d_rtb_hardlimit
= cpu_to_be64(hard
);
655 ddq
->d_rtb_softlimit
= cpu_to_be64(soft
);
657 q
->qi_rtbhardlimit
= hard
;
658 q
->qi_rtbsoftlimit
= soft
;
661 xfs_debug(mp
, "rtbhard %Ld < rtbsoft %Ld", hard
, soft
);
664 hard
= (newlim
->d_fieldmask
& FS_DQ_IHARD
) ?
665 (xfs_qcnt_t
) newlim
->d_ino_hardlimit
:
666 be64_to_cpu(ddq
->d_ino_hardlimit
);
667 soft
= (newlim
->d_fieldmask
& FS_DQ_ISOFT
) ?
668 (xfs_qcnt_t
) newlim
->d_ino_softlimit
:
669 be64_to_cpu(ddq
->d_ino_softlimit
);
670 if (hard
== 0 || hard
>= soft
) {
671 ddq
->d_ino_hardlimit
= cpu_to_be64(hard
);
672 ddq
->d_ino_softlimit
= cpu_to_be64(soft
);
674 q
->qi_ihardlimit
= hard
;
675 q
->qi_isoftlimit
= soft
;
678 xfs_debug(mp
, "ihard %Ld < isoft %Ld", hard
, soft
);
682 * Update warnings counter(s) if requested
684 if (newlim
->d_fieldmask
& FS_DQ_BWARNS
)
685 ddq
->d_bwarns
= cpu_to_be16(newlim
->d_bwarns
);
686 if (newlim
->d_fieldmask
& FS_DQ_IWARNS
)
687 ddq
->d_iwarns
= cpu_to_be16(newlim
->d_iwarns
);
688 if (newlim
->d_fieldmask
& FS_DQ_RTBWARNS
)
689 ddq
->d_rtbwarns
= cpu_to_be16(newlim
->d_rtbwarns
);
693 * Timelimits for the super user set the relative time
694 * the other users can be over quota for this file system.
695 * If it is zero a default is used. Ditto for the default
696 * soft and hard limit values (already done, above), and
699 if (newlim
->d_fieldmask
& FS_DQ_BTIMER
) {
700 q
->qi_btimelimit
= newlim
->d_btimer
;
701 ddq
->d_btimer
= cpu_to_be32(newlim
->d_btimer
);
703 if (newlim
->d_fieldmask
& FS_DQ_ITIMER
) {
704 q
->qi_itimelimit
= newlim
->d_itimer
;
705 ddq
->d_itimer
= cpu_to_be32(newlim
->d_itimer
);
707 if (newlim
->d_fieldmask
& FS_DQ_RTBTIMER
) {
708 q
->qi_rtbtimelimit
= newlim
->d_rtbtimer
;
709 ddq
->d_rtbtimer
= cpu_to_be32(newlim
->d_rtbtimer
);
711 if (newlim
->d_fieldmask
& FS_DQ_BWARNS
)
712 q
->qi_bwarnlimit
= newlim
->d_bwarns
;
713 if (newlim
->d_fieldmask
& FS_DQ_IWARNS
)
714 q
->qi_iwarnlimit
= newlim
->d_iwarns
;
715 if (newlim
->d_fieldmask
& FS_DQ_RTBWARNS
)
716 q
->qi_rtbwarnlimit
= newlim
->d_rtbwarns
;
719 * If the user is now over quota, start the timelimit.
720 * The user will not be 'warned'.
721 * Note that we keep the timers ticking, whether enforcement
722 * is on or off. We don't really want to bother with iterating
723 * over all ondisk dquots and turning the timers on/off.
725 xfs_qm_adjust_dqtimers(mp
, ddq
);
727 dqp
->dq_flags
|= XFS_DQ_DIRTY
;
728 xfs_trans_log_dquot(tp
, dqp
);
730 error
= xfs_trans_commit(tp
, 0);
735 mutex_unlock(&q
->qi_quotaofflock
);
740 xfs_qm_log_quotaoff_end(
742 xfs_qoff_logitem_t
*startqoff
,
747 xfs_qoff_logitem_t
*qoffi
;
749 tp
= xfs_trans_alloc(mp
, XFS_TRANS_QM_QUOTAOFF_END
);
751 error
= xfs_trans_reserve(tp
, &M_RES(mp
)->tr_qm_equotaoff
, 0, 0);
753 xfs_trans_cancel(tp
, 0);
757 qoffi
= xfs_trans_get_qoff_item(tp
, startqoff
,
758 flags
& XFS_ALL_QUOTA_ACCT
);
759 xfs_trans_log_quotaoff_item(tp
, qoffi
);
762 * We have to make sure that the transaction is secure on disk before we
763 * return and actually stop quota accounting. So, make it synchronous.
764 * We don't care about quotoff's performance.
766 xfs_trans_set_sync(tp
);
767 error
= xfs_trans_commit(tp
, 0);
775 xfs_qoff_logitem_t
**qoffstartp
,
780 xfs_qoff_logitem_t
*qoffi
=NULL
;
783 tp
= xfs_trans_alloc(mp
, XFS_TRANS_QM_QUOTAOFF
);
784 error
= xfs_trans_reserve(tp
, &M_RES(mp
)->tr_qm_quotaoff
, 0, 0);
788 qoffi
= xfs_trans_get_qoff_item(tp
, NULL
, flags
& XFS_ALL_QUOTA_ACCT
);
789 xfs_trans_log_quotaoff_item(tp
, qoffi
);
791 spin_lock(&mp
->m_sb_lock
);
792 oldsbqflag
= mp
->m_sb
.sb_qflags
;
793 mp
->m_sb
.sb_qflags
= (mp
->m_qflags
& ~(flags
)) & XFS_MOUNT_QUOTA_ALL
;
794 spin_unlock(&mp
->m_sb_lock
);
796 xfs_mod_sb(tp
, XFS_SB_QFLAGS
);
799 * We have to make sure that the transaction is secure on disk before we
800 * return and actually stop quota accounting. So, make it synchronous.
801 * We don't care about quotoff's performance.
803 xfs_trans_set_sync(tp
);
804 error
= xfs_trans_commit(tp
, 0);
808 xfs_trans_cancel(tp
, 0);
810 * No one else is modifying sb_qflags, so this is OK.
811 * We still hold the quotaofflock.
813 spin_lock(&mp
->m_sb_lock
);
814 mp
->m_sb
.sb_qflags
= oldsbqflag
;
815 spin_unlock(&mp
->m_sb_lock
);
823 xfs_qm_scall_getquota(
824 struct xfs_mount
*mp
,
827 struct fs_disk_quota
*dst
)
829 struct xfs_dquot
*dqp
;
833 * Try to get the dquot. We don't want it allocated on disk, so
834 * we aren't passing the XFS_QMOPT_DOALLOC flag. If it doesn't
835 * exist, we'll get ENOENT back.
837 error
= xfs_qm_dqget(mp
, NULL
, id
, type
, 0, &dqp
);
842 * If everything's NULL, this dquot doesn't quite exist as far as
843 * our utility programs are concerned.
845 if (XFS_IS_DQUOT_UNINITIALIZED(dqp
)) {
846 error
= XFS_ERROR(ENOENT
);
850 memset(dst
, 0, sizeof(*dst
));
851 dst
->d_version
= FS_DQUOT_VERSION
;
852 dst
->d_flags
= xfs_qm_export_qtype_flags(dqp
->q_core
.d_flags
);
853 dst
->d_id
= be32_to_cpu(dqp
->q_core
.d_id
);
854 dst
->d_blk_hardlimit
=
855 XFS_FSB_TO_BB(mp
, be64_to_cpu(dqp
->q_core
.d_blk_hardlimit
));
856 dst
->d_blk_softlimit
=
857 XFS_FSB_TO_BB(mp
, be64_to_cpu(dqp
->q_core
.d_blk_softlimit
));
858 dst
->d_ino_hardlimit
= be64_to_cpu(dqp
->q_core
.d_ino_hardlimit
);
859 dst
->d_ino_softlimit
= be64_to_cpu(dqp
->q_core
.d_ino_softlimit
);
860 dst
->d_bcount
= XFS_FSB_TO_BB(mp
, dqp
->q_res_bcount
);
861 dst
->d_icount
= dqp
->q_res_icount
;
862 dst
->d_btimer
= be32_to_cpu(dqp
->q_core
.d_btimer
);
863 dst
->d_itimer
= be32_to_cpu(dqp
->q_core
.d_itimer
);
864 dst
->d_iwarns
= be16_to_cpu(dqp
->q_core
.d_iwarns
);
865 dst
->d_bwarns
= be16_to_cpu(dqp
->q_core
.d_bwarns
);
866 dst
->d_rtb_hardlimit
=
867 XFS_FSB_TO_BB(mp
, be64_to_cpu(dqp
->q_core
.d_rtb_hardlimit
));
868 dst
->d_rtb_softlimit
=
869 XFS_FSB_TO_BB(mp
, be64_to_cpu(dqp
->q_core
.d_rtb_softlimit
));
870 dst
->d_rtbcount
= XFS_FSB_TO_BB(mp
, dqp
->q_res_rtbcount
);
871 dst
->d_rtbtimer
= be32_to_cpu(dqp
->q_core
.d_rtbtimer
);
872 dst
->d_rtbwarns
= be16_to_cpu(dqp
->q_core
.d_rtbwarns
);
875 * Internally, we don't reset all the timers when quota enforcement
876 * gets turned off. No need to confuse the user level code,
877 * so return zeroes in that case.
879 if ((!XFS_IS_UQUOTA_ENFORCED(mp
) &&
880 dqp
->q_core
.d_flags
== XFS_DQ_USER
) ||
881 (!XFS_IS_GQUOTA_ENFORCED(mp
) &&
882 dqp
->q_core
.d_flags
== XFS_DQ_GROUP
) ||
883 (!XFS_IS_PQUOTA_ENFORCED(mp
) &&
884 dqp
->q_core
.d_flags
== XFS_DQ_PROJ
)) {
891 if (((XFS_IS_UQUOTA_ENFORCED(mp
) && dst
->d_flags
== FS_USER_QUOTA
) ||
892 (XFS_IS_GQUOTA_ENFORCED(mp
) && dst
->d_flags
== FS_GROUP_QUOTA
) ||
893 (XFS_IS_PQUOTA_ENFORCED(mp
) && dst
->d_flags
== FS_PROJ_QUOTA
)) &&
895 if ((dst
->d_bcount
> dst
->d_blk_softlimit
) &&
896 (dst
->d_blk_softlimit
> 0)) {
897 ASSERT(dst
->d_btimer
!= 0);
899 if ((dst
->d_icount
> dst
->d_ino_softlimit
) &&
900 (dst
->d_ino_softlimit
> 0)) {
901 ASSERT(dst
->d_itimer
!= 0);
911 xfs_qm_export_qtype_flags(
915 * Can't be more than one, or none.
917 ASSERT((flags
& (FS_PROJ_QUOTA
| FS_USER_QUOTA
)) !=
918 (FS_PROJ_QUOTA
| FS_USER_QUOTA
));
919 ASSERT((flags
& (FS_PROJ_QUOTA
| FS_GROUP_QUOTA
)) !=
920 (FS_PROJ_QUOTA
| FS_GROUP_QUOTA
));
921 ASSERT((flags
& (FS_USER_QUOTA
| FS_GROUP_QUOTA
)) !=
922 (FS_USER_QUOTA
| FS_GROUP_QUOTA
));
923 ASSERT((flags
& (FS_PROJ_QUOTA
|FS_USER_QUOTA
|FS_GROUP_QUOTA
)) != 0);
925 return (flags
& XFS_DQ_USER
) ?
926 FS_USER_QUOTA
: (flags
& XFS_DQ_PROJ
) ?
927 FS_PROJ_QUOTA
: FS_GROUP_QUOTA
;
937 if (flags
& XFS_UQUOTA_ACCT
)
938 uflags
|= FS_QUOTA_UDQ_ACCT
;
939 if (flags
& XFS_GQUOTA_ACCT
)
940 uflags
|= FS_QUOTA_GDQ_ACCT
;
941 if (flags
& XFS_PQUOTA_ACCT
)
942 uflags
|= FS_QUOTA_PDQ_ACCT
;
943 if (flags
& XFS_UQUOTA_ENFD
)
944 uflags
|= FS_QUOTA_UDQ_ENFD
;
945 if (flags
& XFS_GQUOTA_ENFD
)
946 uflags
|= FS_QUOTA_GDQ_ENFD
;
947 if (flags
& XFS_PQUOTA_ENFD
)
948 uflags
|= FS_QUOTA_PDQ_ENFD
;
955 struct xfs_inode
*ip
,
956 struct xfs_perag
*pag
,
960 /* skip quota inodes */
961 if (ip
== ip
->i_mount
->m_quotainfo
->qi_uquotaip
||
962 ip
== ip
->i_mount
->m_quotainfo
->qi_gquotaip
||
963 ip
== ip
->i_mount
->m_quotainfo
->qi_pquotaip
) {
964 ASSERT(ip
->i_udquot
== NULL
);
965 ASSERT(ip
->i_gdquot
== NULL
);
966 ASSERT(ip
->i_pdquot
== NULL
);
970 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
971 if ((flags
& XFS_UQUOTA_ACCT
) && ip
->i_udquot
) {
972 xfs_qm_dqrele(ip
->i_udquot
);
975 if ((flags
& XFS_GQUOTA_ACCT
) && ip
->i_gdquot
) {
976 xfs_qm_dqrele(ip
->i_gdquot
);
979 if ((flags
& XFS_PQUOTA_ACCT
) && ip
->i_pdquot
) {
980 xfs_qm_dqrele(ip
->i_pdquot
);
983 xfs_iunlock(ip
, XFS_ILOCK_EXCL
);
989 * Go thru all the inodes in the file system, releasing their dquots.
991 * Note that the mount structure gets modified to indicate that quotas are off
992 * AFTER this, in the case of quotaoff.
995 xfs_qm_dqrele_all_inodes(
996 struct xfs_mount
*mp
,
999 ASSERT(mp
->m_quotainfo
);
1000 xfs_inode_ag_iterator(mp
, xfs_dqrele_inode
, flags
, NULL
);