]>
git.ipfire.org Git - people/ms/linux.git/blob - fs/xfs/xfs_qm_syscalls.c
1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
10 #include "xfs_shared.h"
11 #include "xfs_format.h"
12 #include "xfs_log_format.h"
13 #include "xfs_trans_resv.h"
15 #include "xfs_mount.h"
16 #include "xfs_inode.h"
17 #include "xfs_trans.h"
18 #include "xfs_quota.h"
20 #include "xfs_icache.h"
23 xfs_qm_scall_quotaoff(
28 * No file system can have quotas enabled on disk but not in core.
29 * Note that quota utilities (like quotaoff) _expect_
30 * errno == -EEXIST here.
32 if ((mp
->m_qflags
& flags
) == 0)
36 * We do not support actually turning off quota accounting any more.
37 * Just log a warning and ignore the accounting related flags.
39 if (flags
& XFS_ALL_QUOTA_ACCT
)
40 xfs_info(mp
, "disabling of quota accounting not supported.");
42 mutex_lock(&mp
->m_quotainfo
->qi_quotaofflock
);
43 mp
->m_qflags
&= ~(flags
& XFS_ALL_QUOTA_ENFD
);
44 spin_lock(&mp
->m_sb_lock
);
45 mp
->m_sb
.sb_qflags
= mp
->m_qflags
;
46 spin_unlock(&mp
->m_sb_lock
);
47 mutex_unlock(&mp
->m_quotainfo
->qi_quotaofflock
);
49 /* XXX what to do if error ? Revert back to old vals incore ? */
50 return xfs_sync_sb(mp
, false);
54 xfs_qm_scall_trunc_qfile(
65 error
= xfs_iget(mp
, NULL
, ino
, 0, 0, &ip
);
69 xfs_ilock(ip
, XFS_IOLOCK_EXCL
);
71 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_itruncate
, 0, 0, 0, &tp
);
73 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
77 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
78 xfs_trans_ijoin(tp
, ip
, 0);
81 xfs_trans_log_inode(tp
, ip
, XFS_ILOG_CORE
);
83 error
= xfs_itruncate_extents(&tp
, ip
, XFS_DATA_FORK
, 0);
89 ASSERT(ip
->i_df
.if_nextents
== 0);
91 xfs_trans_ichgtime(tp
, ip
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
92 error
= xfs_trans_commit(tp
);
95 xfs_iunlock(ip
, XFS_ILOCK_EXCL
| XFS_IOLOCK_EXCL
);
102 xfs_qm_scall_trunc_qfiles(
108 if (!xfs_has_quota(mp
) || flags
== 0 ||
109 (flags
& ~XFS_QMOPT_QUOTALL
)) {
110 xfs_debug(mp
, "%s: flags=%x m_qflags=%x",
111 __func__
, flags
, mp
->m_qflags
);
115 if (flags
& XFS_QMOPT_UQUOTA
) {
116 error
= xfs_qm_scall_trunc_qfile(mp
, mp
->m_sb
.sb_uquotino
);
120 if (flags
& XFS_QMOPT_GQUOTA
) {
121 error
= xfs_qm_scall_trunc_qfile(mp
, mp
->m_sb
.sb_gquotino
);
125 if (flags
& XFS_QMOPT_PQUOTA
)
126 error
= xfs_qm_scall_trunc_qfile(mp
, mp
->m_sb
.sb_pquotino
);
132 * Switch on (a given) quota enforcement for a filesystem. This takes
133 * effect immediately.
134 * (Switching on quota accounting must be done at mount time.)
137 xfs_qm_scall_quotaon(
145 * Switching on quota accounting must be done at mount time,
146 * only consider quota enforcement stuff here.
148 flags
&= XFS_ALL_QUOTA_ENFD
;
151 xfs_debug(mp
, "%s: zero flags, m_qflags=%x",
152 __func__
, mp
->m_qflags
);
157 * Can't enforce without accounting. We check the superblock
158 * qflags here instead of m_qflags because rootfs can have
159 * quota acct on ondisk without m_qflags' knowing.
161 if (((mp
->m_sb
.sb_qflags
& XFS_UQUOTA_ACCT
) == 0 &&
162 (flags
& XFS_UQUOTA_ENFD
)) ||
163 ((mp
->m_sb
.sb_qflags
& XFS_GQUOTA_ACCT
) == 0 &&
164 (flags
& XFS_GQUOTA_ENFD
)) ||
165 ((mp
->m_sb
.sb_qflags
& XFS_PQUOTA_ACCT
) == 0 &&
166 (flags
& XFS_PQUOTA_ENFD
))) {
168 "%s: Can't enforce without acct, flags=%x sbflags=%x",
169 __func__
, flags
, mp
->m_sb
.sb_qflags
);
173 * If everything's up to-date incore, then don't waste time.
175 if ((mp
->m_qflags
& flags
) == flags
)
179 * Change sb_qflags on disk but not incore mp->qflags
180 * if this is the root filesystem.
182 spin_lock(&mp
->m_sb_lock
);
183 qf
= mp
->m_sb
.sb_qflags
;
184 mp
->m_sb
.sb_qflags
= qf
| flags
;
185 spin_unlock(&mp
->m_sb_lock
);
188 * There's nothing to change if it's the same.
190 if ((qf
& flags
) == flags
)
193 error
= xfs_sync_sb(mp
, false);
197 * If we aren't trying to switch on quota enforcement, we are done.
199 if (((mp
->m_sb
.sb_qflags
& XFS_UQUOTA_ACCT
) !=
200 (mp
->m_qflags
& XFS_UQUOTA_ACCT
)) ||
201 ((mp
->m_sb
.sb_qflags
& XFS_PQUOTA_ACCT
) !=
202 (mp
->m_qflags
& XFS_PQUOTA_ACCT
)) ||
203 ((mp
->m_sb
.sb_qflags
& XFS_GQUOTA_ACCT
) !=
204 (mp
->m_qflags
& XFS_GQUOTA_ACCT
)))
207 if (!XFS_IS_QUOTA_ON(mp
))
211 * Switch on quota enforcement in core.
213 mutex_lock(&mp
->m_quotainfo
->qi_quotaofflock
);
214 mp
->m_qflags
|= (flags
& XFS_ALL_QUOTA_ENFD
);
215 mutex_unlock(&mp
->m_quotainfo
->qi_quotaofflock
);
220 #define XFS_QC_MASK (QC_LIMIT_MASK | QC_TIMER_MASK)
223 * Adjust limits of this quota, and the defaults if passed in. Returns true
224 * if the new limits made sense and were applied, false otherwise.
228 struct xfs_mount
*mp
,
229 struct xfs_dquot_res
*res
,
230 struct xfs_quota_limits
*qlim
,
235 /* The hard limit can't be less than the soft limit. */
236 if (hard
!= 0 && hard
< soft
) {
237 xfs_debug(mp
, "%shard %lld < %ssoft %lld", tag
, hard
, tag
,
242 res
->hardlimit
= hard
;
243 res
->softlimit
= soft
;
254 struct xfs_mount
*mp
,
255 struct xfs_dquot_res
*res
,
256 struct xfs_quota_limits
*qlim
,
260 /* Set the length of the default grace period. */
261 res
->timer
= xfs_dquot_set_grace_period(timer
);
262 qlim
->time
= res
->timer
;
264 /* Set the grace period expiration on a quota. */
265 res
->timer
= xfs_dquot_set_timeout(mp
, timer
);
270 * Adjust quota limits, and start/stop timers accordingly.
273 xfs_qm_scall_setqlim(
274 struct xfs_mount
*mp
,
277 struct qc_dqblk
*newlim
)
279 struct xfs_quotainfo
*q
= mp
->m_quotainfo
;
280 struct xfs_dquot
*dqp
;
281 struct xfs_trans
*tp
;
282 struct xfs_def_quota
*defq
;
283 struct xfs_dquot_res
*res
;
284 struct xfs_quota_limits
*qlim
;
286 xfs_qcnt_t hard
, soft
;
288 if (newlim
->d_fieldmask
& ~XFS_QC_MASK
)
290 if ((newlim
->d_fieldmask
& XFS_QC_MASK
) == 0)
294 * Get the dquot (locked) before we start, as we need to do a
295 * transaction to allocate it if it doesn't exist. Once we have the
296 * dquot, unlock it so we can start the next transaction safely. We hold
297 * a reference to the dquot, so it's safe to do this unlock/lock without
298 * it being reclaimed in the mean time.
300 error
= xfs_qm_dqget(mp
, id
, type
, true, &dqp
);
302 ASSERT(error
!= -ENOENT
);
306 defq
= xfs_get_defquota(q
, xfs_dquot_type(dqp
));
309 error
= xfs_trans_alloc(mp
, &M_RES(mp
)->tr_qm_setqlim
, 0, 0, 0, &tp
);
314 xfs_trans_dqjoin(tp
, dqp
);
317 * Update quota limits, warnings, and timers, and the defaults
318 * if we're touching id == 0.
320 * Make sure that hardlimits are >= soft limits before changing.
322 * Update warnings counter(s) if requested.
324 * Timelimits for the super user set the relative time the other users
325 * can be over quota for this file system. If it is zero a default is
326 * used. Ditto for the default soft and hard limit values (already
327 * done, above), and for warnings.
329 * For other IDs, userspace can bump out the grace period if over
333 /* Blocks on the data device. */
334 hard
= (newlim
->d_fieldmask
& QC_SPC_HARD
) ?
335 (xfs_qcnt_t
) XFS_B_TO_FSB(mp
, newlim
->d_spc_hardlimit
) :
336 dqp
->q_blk
.hardlimit
;
337 soft
= (newlim
->d_fieldmask
& QC_SPC_SOFT
) ?
338 (xfs_qcnt_t
) XFS_B_TO_FSB(mp
, newlim
->d_spc_softlimit
) :
339 dqp
->q_blk
.softlimit
;
341 qlim
= id
== 0 ? &defq
->blk
: NULL
;
343 if (xfs_setqlim_limits(mp
, res
, qlim
, hard
, soft
, "blk"))
344 xfs_dquot_set_prealloc_limits(dqp
);
345 if (newlim
->d_fieldmask
& QC_SPC_TIMER
)
346 xfs_setqlim_timer(mp
, res
, qlim
, newlim
->d_spc_timer
);
348 /* Blocks on the realtime device. */
349 hard
= (newlim
->d_fieldmask
& QC_RT_SPC_HARD
) ?
350 (xfs_qcnt_t
) XFS_B_TO_FSB(mp
, newlim
->d_rt_spc_hardlimit
) :
351 dqp
->q_rtb
.hardlimit
;
352 soft
= (newlim
->d_fieldmask
& QC_RT_SPC_SOFT
) ?
353 (xfs_qcnt_t
) XFS_B_TO_FSB(mp
, newlim
->d_rt_spc_softlimit
) :
354 dqp
->q_rtb
.softlimit
;
356 qlim
= id
== 0 ? &defq
->rtb
: NULL
;
358 xfs_setqlim_limits(mp
, res
, qlim
, hard
, soft
, "rtb");
359 if (newlim
->d_fieldmask
& QC_RT_SPC_TIMER
)
360 xfs_setqlim_timer(mp
, res
, qlim
, newlim
->d_rt_spc_timer
);
363 hard
= (newlim
->d_fieldmask
& QC_INO_HARD
) ?
364 (xfs_qcnt_t
) newlim
->d_ino_hardlimit
:
365 dqp
->q_ino
.hardlimit
;
366 soft
= (newlim
->d_fieldmask
& QC_INO_SOFT
) ?
367 (xfs_qcnt_t
) newlim
->d_ino_softlimit
:
368 dqp
->q_ino
.softlimit
;
370 qlim
= id
== 0 ? &defq
->ino
: NULL
;
372 xfs_setqlim_limits(mp
, res
, qlim
, hard
, soft
, "ino");
373 if (newlim
->d_fieldmask
& QC_INO_TIMER
)
374 xfs_setqlim_timer(mp
, res
, qlim
, newlim
->d_ino_timer
);
378 * If the user is now over quota, start the timelimit.
379 * The user will not be 'warned'.
380 * Note that we keep the timers ticking, whether enforcement
381 * is on or off. We don't really want to bother with iterating
382 * over all ondisk dquots and turning the timers on/off.
384 xfs_qm_adjust_dqtimers(dqp
);
386 dqp
->q_flags
|= XFS_DQFLAG_DIRTY
;
387 xfs_trans_log_dquot(tp
, dqp
);
389 error
= xfs_trans_commit(tp
);
396 /* Fill out the quota context. */
398 xfs_qm_scall_getquota_fill_qc(
399 struct xfs_mount
*mp
,
401 const struct xfs_dquot
*dqp
,
402 struct qc_dqblk
*dst
)
404 memset(dst
, 0, sizeof(*dst
));
405 dst
->d_spc_hardlimit
= XFS_FSB_TO_B(mp
, dqp
->q_blk
.hardlimit
);
406 dst
->d_spc_softlimit
= XFS_FSB_TO_B(mp
, dqp
->q_blk
.softlimit
);
407 dst
->d_ino_hardlimit
= dqp
->q_ino
.hardlimit
;
408 dst
->d_ino_softlimit
= dqp
->q_ino
.softlimit
;
409 dst
->d_space
= XFS_FSB_TO_B(mp
, dqp
->q_blk
.reserved
);
410 dst
->d_ino_count
= dqp
->q_ino
.reserved
;
411 dst
->d_spc_timer
= dqp
->q_blk
.timer
;
412 dst
->d_ino_timer
= dqp
->q_ino
.timer
;
413 dst
->d_ino_warns
= 0;
414 dst
->d_spc_warns
= 0;
415 dst
->d_rt_spc_hardlimit
= XFS_FSB_TO_B(mp
, dqp
->q_rtb
.hardlimit
);
416 dst
->d_rt_spc_softlimit
= XFS_FSB_TO_B(mp
, dqp
->q_rtb
.softlimit
);
417 dst
->d_rt_space
= XFS_FSB_TO_B(mp
, dqp
->q_rtb
.reserved
);
418 dst
->d_rt_spc_timer
= dqp
->q_rtb
.timer
;
419 dst
->d_rt_spc_warns
= 0;
422 * Internally, we don't reset all the timers when quota enforcement
423 * gets turned off. No need to confuse the user level code,
424 * so return zeroes in that case.
426 if (!xfs_dquot_is_enforced(dqp
)) {
427 dst
->d_spc_timer
= 0;
428 dst
->d_ino_timer
= 0;
429 dst
->d_rt_spc_timer
= 0;
433 if (xfs_dquot_is_enforced(dqp
) && dqp
->q_id
!= 0) {
434 if ((dst
->d_space
> dst
->d_spc_softlimit
) &&
435 (dst
->d_spc_softlimit
> 0)) {
436 ASSERT(dst
->d_spc_timer
!= 0);
438 if ((dst
->d_ino_count
> dqp
->q_ino
.softlimit
) &&
439 (dqp
->q_ino
.softlimit
> 0)) {
440 ASSERT(dst
->d_ino_timer
!= 0);
446 /* Return the quota information for the dquot matching id. */
448 xfs_qm_scall_getquota(
449 struct xfs_mount
*mp
,
452 struct qc_dqblk
*dst
)
454 struct xfs_dquot
*dqp
;
458 * Expedite pending inodegc work at the start of a quota reporting
459 * scan but don't block waiting for it to complete.
462 xfs_inodegc_push(mp
);
465 * Try to get the dquot. We don't want it allocated on disk, so don't
466 * set doalloc. If it doesn't exist, we'll get ENOENT back.
468 error
= xfs_qm_dqget(mp
, id
, type
, false, &dqp
);
473 * If everything's NULL, this dquot doesn't quite exist as far as
474 * our utility programs are concerned.
476 if (XFS_IS_DQUOT_UNINITIALIZED(dqp
)) {
481 xfs_qm_scall_getquota_fill_qc(mp
, type
, dqp
, dst
);
489 * Return the quota information for the first initialized dquot whose id
490 * is at least as high as id.
493 xfs_qm_scall_getquota_next(
494 struct xfs_mount
*mp
,
497 struct qc_dqblk
*dst
)
499 struct xfs_dquot
*dqp
;
502 /* Flush inodegc work at the start of a quota reporting scan. */
504 xfs_inodegc_push(mp
);
506 error
= xfs_qm_dqget_next(mp
, *id
, type
, &dqp
);
510 /* Fill in the ID we actually read from disk */
513 xfs_qm_scall_getquota_fill_qc(mp
, type
, dqp
, dst
);