2018-06-06 02:42:14 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
2005-11-02 03:59:41 +00:00
|
|
|
* Copyright (c) 2000-2005 Silicon Graphics, Inc.
|
|
|
|
* All Rights Reserved.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2006-01-11 20:17:46 +00:00
|
|
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs.h"
|
|
|
|
#include "xfs_fs.h"
|
2013-10-22 23:36:05 +00:00
|
|
|
#include "xfs_shared.h"
|
2013-10-22 23:50:10 +00:00
|
|
|
#include "xfs_format.h"
|
|
|
|
#include "xfs_log_format.h"
|
|
|
|
#include "xfs_trans_resv.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs_sb.h"
|
|
|
|
#include "xfs_mount.h"
|
|
|
|
#include "xfs_inode.h"
|
2013-10-22 23:50:10 +00:00
|
|
|
#include "xfs_trans.h"
|
2013-10-22 23:51:50 +00:00
|
|
|
#include "xfs_quota.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "xfs_qm.h"
|
2012-10-08 10:56:09 +00:00
|
|
|
#include "xfs_icache.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2009-02-09 07:47:34 +00:00
|
|
|
int
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_qm_scall_quotaoff(
|
|
|
|
xfs_mount_t *mp,
|
2009-02-09 07:47:34 +00:00
|
|
|
uint flags)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* No file system can have quotas enabled on disk but not in core.
|
|
|
|
* Note that quota utilities (like quotaoff) _expect_
|
2014-06-25 04:58:08 +00:00
|
|
|
* errno == -EEXIST here.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
if ((mp->m_qflags & flags) == 0)
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EEXIST;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2021-08-06 18:05:36 +00:00
|
|
|
* We do not support actually turning off quota accounting any more.
|
|
|
|
* Just log a warning and ignore the accounting related flags.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2021-08-06 18:05:36 +00:00
|
|
|
if (flags & XFS_ALL_QUOTA_ACCT)
|
|
|
|
xfs_info(mp, "disabling of quota accounting not supported.");
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-08-06 18:05:36 +00:00
|
|
|
mutex_lock(&mp->m_quotainfo->qi_quotaofflock);
|
|
|
|
mp->m_qflags &= ~(flags & XFS_ALL_QUOTA_ENFD);
|
|
|
|
spin_lock(&mp->m_sb_lock);
|
|
|
|
mp->m_sb.sb_qflags = mp->m_qflags;
|
|
|
|
spin_unlock(&mp->m_sb_lock);
|
|
|
|
mutex_unlock(&mp->m_quotainfo->qi_quotaofflock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2021-08-06 18:05:36 +00:00
|
|
|
/* XXX what to do if error ? Revert back to old vals incore ? */
|
|
|
|
return xfs_sync_sb(mp, false);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2010-07-20 07:51:31 +00:00
|
|
|
STATIC int
|
|
|
|
xfs_qm_scall_trunc_qfile(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
xfs_ino_t ino)
|
|
|
|
{
|
|
|
|
struct xfs_inode *ip;
|
|
|
|
struct xfs_trans *tp;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (ino == NULLFSINO)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error = xfs_iget(mp, NULL, ino, 0, 0, &ip);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
xfs_ilock(ip, XFS_IOLOCK_EXCL);
|
|
|
|
|
2016-04-05 23:19:55 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
|
2010-07-20 07:51:31 +00:00
|
|
|
if (error) {
|
|
|
|
xfs_iunlock(ip, XFS_IOLOCK_EXCL);
|
|
|
|
goto out_put;
|
|
|
|
}
|
|
|
|
|
|
|
|
xfs_ilock(ip, XFS_ILOCK_EXCL);
|
2011-09-19 15:00:54 +00:00
|
|
|
xfs_trans_ijoin(tp, ip, 0);
|
2010-07-20 07:51:31 +00:00
|
|
|
|
2021-03-29 18:11:40 +00:00
|
|
|
ip->i_disk_size = 0;
|
2011-12-18 20:00:04 +00:00
|
|
|
xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
|
|
|
|
|
|
|
|
error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
|
2010-07-20 07:51:31 +00:00
|
|
|
if (error) {
|
2015-06-04 03:47:56 +00:00
|
|
|
xfs_trans_cancel(tp);
|
2010-07-20 07:51:31 +00:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
2020-05-18 17:27:22 +00:00
|
|
|
ASSERT(ip->i_df.if_nextents == 0);
|
2011-12-18 20:00:04 +00:00
|
|
|
|
2010-09-28 02:27:25 +00:00
|
|
|
xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
|
2015-06-04 03:48:08 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
2010-07-20 07:51:31 +00:00
|
|
|
|
|
|
|
out_unlock:
|
|
|
|
xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
|
|
|
|
out_put:
|
2018-07-25 19:52:32 +00:00
|
|
|
xfs_irele(ip);
|
2010-07-20 07:51:31 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2009-02-09 07:47:34 +00:00
|
|
|
int
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_qm_scall_trunc_qfiles(
|
|
|
|
xfs_mount_t *mp,
|
|
|
|
uint flags)
|
|
|
|
{
|
2014-06-25 04:58:08 +00:00
|
|
|
int error = -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-05-05 07:27:06 +00:00
|
|
|
if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0 ||
|
2020-07-14 17:36:09 +00:00
|
|
|
(flags & ~XFS_QMOPT_QUOTALL)) {
|
2013-10-12 01:59:05 +00:00
|
|
|
xfs_debug(mp, "%s: flags=%x m_qflags=%x",
|
2011-03-06 23:07:35 +00:00
|
|
|
__func__, flags, mp->m_qflags);
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2020-07-14 17:36:09 +00:00
|
|
|
if (flags & XFS_QMOPT_UQUOTA) {
|
2010-07-20 07:51:31 +00:00
|
|
|
error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_uquotino);
|
2013-11-22 06:04:00 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
2020-07-14 17:36:09 +00:00
|
|
|
if (flags & XFS_QMOPT_GQUOTA) {
|
2013-11-22 06:04:00 +00:00
|
|
|
error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_gquotino);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
}
|
2020-07-14 17:36:09 +00:00
|
|
|
if (flags & XFS_QMOPT_PQUOTA)
|
2013-11-22 06:04:00 +00:00
|
|
|
error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_pquotino);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-11-22 06:04:00 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Switch on (a given) quota enforcement for a filesystem. This takes
|
|
|
|
* effect immediately.
|
|
|
|
* (Switching on quota accounting must be done at mount time.)
|
|
|
|
*/
|
2009-02-09 07:47:34 +00:00
|
|
|
int
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_qm_scall_quotaon(
|
|
|
|
xfs_mount_t *mp,
|
|
|
|
uint flags)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
uint qf;
|
|
|
|
|
|
|
|
/*
|
2020-04-23 04:54:30 +00:00
|
|
|
* Switching on quota accounting must be done at mount time,
|
|
|
|
* only consider quota enforcement stuff here.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2020-04-23 04:54:30 +00:00
|
|
|
flags &= XFS_ALL_QUOTA_ENFD;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (flags == 0) {
|
2013-10-12 01:59:05 +00:00
|
|
|
xfs_debug(mp, "%s: zero flags, m_qflags=%x",
|
2011-03-06 23:07:35 +00:00
|
|
|
__func__, mp->m_qflags);
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Can't enforce without accounting. We check the superblock
|
|
|
|
* qflags here instead of m_qflags because rootfs can have
|
|
|
|
* quota acct on ondisk without m_qflags' knowing.
|
|
|
|
*/
|
2014-10-08 09:52:52 +00:00
|
|
|
if (((mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) == 0 &&
|
2013-06-27 22:25:10 +00:00
|
|
|
(flags & XFS_UQUOTA_ENFD)) ||
|
2014-10-08 09:52:52 +00:00
|
|
|
((mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) == 0 &&
|
2013-06-27 22:25:10 +00:00
|
|
|
(flags & XFS_GQUOTA_ENFD)) ||
|
2014-10-08 09:52:52 +00:00
|
|
|
((mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) == 0 &&
|
2013-06-27 22:25:10 +00:00
|
|
|
(flags & XFS_PQUOTA_ENFD))) {
|
2011-03-06 23:07:35 +00:00
|
|
|
xfs_debug(mp,
|
2013-10-12 01:59:05 +00:00
|
|
|
"%s: Can't enforce without acct, flags=%x sbflags=%x",
|
2011-03-06 23:07:35 +00:00
|
|
|
__func__, flags, mp->m_sb.sb_qflags);
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
/*
|
2011-03-31 01:57:33 +00:00
|
|
|
* If everything's up to-date incore, then don't waste time.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
if ((mp->m_qflags & flags) == flags)
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EEXIST;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Change sb_qflags on disk but not incore mp->qflags
|
|
|
|
* if this is the root filesystem.
|
|
|
|
*/
|
2007-10-11 07:42:32 +00:00
|
|
|
spin_lock(&mp->m_sb_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
qf = mp->m_sb.sb_qflags;
|
|
|
|
mp->m_sb.sb_qflags = qf | flags;
|
2007-10-11 07:42:32 +00:00
|
|
|
spin_unlock(&mp->m_sb_lock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* There's nothing to change if it's the same.
|
|
|
|
*/
|
xfs: remove bitfield based superblock updates
When we log changes to the superblock, we first have to write them
to the on-disk buffer, and then log that. Right now we have a
complex bitfield based arrangement to only write the modified field
to the buffer before we log it.
This used to be necessary as a performance optimisation because we
logged the superblock buffer in every extent or inode allocation or
freeing, and so performance was extremely important. We haven't done
this for years, however, ever since the lazy superblock counters
pulled the superblock logging out of the transaction commit
fast path.
Hence we have a bunch of complexity that is not necessary that makes
writing the in-core superblock to disk much more complex than it
needs to be. We only need to log the superblock now during
management operations (e.g. during mount, unmount or quota control
operations) so it is not a performance critical path anymore.
As such, remove the complex field based logging mechanism and
replace it with a simple conversion function similar to what we use
for all other on-disk structures.
This means we always log the entirity of the superblock, but again
because we rarely modify the superblock this is not an issue for log
bandwidth or CPU time. Indeed, if we do log the superblock
frequently, delayed logging will minimise the impact of this
overhead.
[Fixed gquota/pquota inode sharing regression noticed by bfoster.]
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Brian Foster <bfoster@redhat.com>
Signed-off-by: Dave Chinner <david@fromorbit.com>
2015-01-21 22:10:26 +00:00
|
|
|
if ((qf & flags) == flags)
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EEXIST;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-01-21 22:10:31 +00:00
|
|
|
error = xfs_sync_sb(mp, false);
|
|
|
|
if (error)
|
2014-06-22 05:03:54 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* If we aren't trying to switch on quota enforcement, we are done.
|
|
|
|
*/
|
|
|
|
if (((mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) !=
|
|
|
|
(mp->m_qflags & XFS_UQUOTA_ACCT)) ||
|
2005-06-21 05:38:48 +00:00
|
|
|
((mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) !=
|
|
|
|
(mp->m_qflags & XFS_PQUOTA_ACCT)) ||
|
|
|
|
((mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) !=
|
2014-10-08 09:52:52 +00:00
|
|
|
(mp->m_qflags & XFS_GQUOTA_ACCT)))
|
2014-06-22 05:03:54 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (! XFS_IS_QUOTA_RUNNING(mp))
|
2014-06-25 04:58:08 +00:00
|
|
|
return -ESRCH;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Switch on quota enforcement in core.
|
|
|
|
*/
|
2010-04-20 07:01:30 +00:00
|
|
|
mutex_lock(&mp->m_quotainfo->qi_quotaofflock);
|
2005-04-16 22:20:36 +00:00
|
|
|
mp->m_qflags |= (flags & XFS_ALL_QUOTA_ENFD);
|
2010-04-20 07:01:30 +00:00
|
|
|
mutex_unlock(&mp->m_quotainfo->qi_quotaofflock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-06-22 05:03:54 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2014-10-09 14:03:13 +00:00
|
|
|
#define XFS_QC_MASK \
|
|
|
|
(QC_LIMIT_MASK | QC_TIMER_MASK | QC_WARNS_MASK)
|
2010-05-06 21:05:17 +00:00
|
|
|
|
2020-07-14 17:37:33 +00:00
|
|
|
/*
|
|
|
|
* Adjust limits of this quota, and the defaults if passed in. Returns true
|
|
|
|
* if the new limits made sense and were applied, false otherwise.
|
|
|
|
*/
|
|
|
|
static inline bool
|
|
|
|
xfs_setqlim_limits(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
struct xfs_dquot_res *res,
|
|
|
|
struct xfs_quota_limits *qlim,
|
|
|
|
xfs_qcnt_t hard,
|
|
|
|
xfs_qcnt_t soft,
|
|
|
|
const char *tag)
|
|
|
|
{
|
|
|
|
/* The hard limit can't be less than the soft limit. */
|
|
|
|
if (hard != 0 && hard < soft) {
|
|
|
|
xfs_debug(mp, "%shard %lld < %ssoft %lld", tag, hard, tag,
|
|
|
|
soft);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
res->hardlimit = hard;
|
|
|
|
res->softlimit = soft;
|
|
|
|
if (qlim) {
|
|
|
|
qlim->hard = hard;
|
|
|
|
qlim->soft = soft;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
xfs_setqlim_warns(
|
|
|
|
struct xfs_dquot_res *res,
|
|
|
|
struct xfs_quota_limits *qlim,
|
|
|
|
int warns)
|
|
|
|
{
|
|
|
|
res->warnings = warns;
|
|
|
|
if (qlim)
|
|
|
|
qlim->warn = warns;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
xfs_setqlim_timer(
|
2020-08-17 16:58:36 +00:00
|
|
|
struct xfs_mount *mp,
|
2020-07-14 17:37:33 +00:00
|
|
|
struct xfs_dquot_res *res,
|
|
|
|
struct xfs_quota_limits *qlim,
|
|
|
|
s64 timer)
|
|
|
|
{
|
2020-08-17 16:58:36 +00:00
|
|
|
if (qlim) {
|
|
|
|
/* Set the length of the default grace period. */
|
2020-08-17 16:58:42 +00:00
|
|
|
res->timer = xfs_dquot_set_grace_period(timer);
|
|
|
|
qlim->time = res->timer;
|
2020-08-17 16:58:36 +00:00
|
|
|
} else {
|
|
|
|
/* Set the grace period expiration on a quota. */
|
|
|
|
res->timer = xfs_dquot_set_timeout(mp, timer);
|
|
|
|
}
|
2020-07-14 17:37:33 +00:00
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Adjust quota limits, and start/stop timers accordingly.
|
|
|
|
*/
|
2009-02-09 07:47:34 +00:00
|
|
|
int
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_qm_scall_setqlim(
|
2013-03-18 14:51:46 +00:00
|
|
|
struct xfs_mount *mp,
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_dqid_t id,
|
2020-07-16 00:53:43 +00:00
|
|
|
xfs_dqtype_t type,
|
2014-10-09 14:03:13 +00:00
|
|
|
struct qc_dqblk *newlim)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-04-20 07:01:30 +00:00
|
|
|
struct xfs_quotainfo *q = mp->m_quotainfo;
|
2013-03-18 14:51:46 +00:00
|
|
|
struct xfs_dquot *dqp;
|
|
|
|
struct xfs_trans *tp;
|
2016-02-08 00:27:55 +00:00
|
|
|
struct xfs_def_quota *defq;
|
2020-07-14 17:37:33 +00:00
|
|
|
struct xfs_dquot_res *res;
|
|
|
|
struct xfs_quota_limits *qlim;
|
2005-04-16 22:20:36 +00:00
|
|
|
int error;
|
|
|
|
xfs_qcnt_t hard, soft;
|
|
|
|
|
2014-10-09 14:03:13 +00:00
|
|
|
if (newlim->d_fieldmask & ~XFS_QC_MASK)
|
2014-06-25 04:58:08 +00:00
|
|
|
return -EINVAL;
|
2014-10-09 14:03:13 +00:00
|
|
|
if ((newlim->d_fieldmask & XFS_QC_MASK) == 0)
|
2010-05-06 21:05:17 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't want to race with a quotaoff so take the quotaoff lock.
|
2013-05-21 08:02:00 +00:00
|
|
|
* We don't hold an inode lock, so there's nothing else to stop
|
|
|
|
* a quotaoff from happening.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2010-04-20 07:01:30 +00:00
|
|
|
mutex_lock(&q->qi_quotaofflock);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
2013-05-21 08:02:00 +00:00
|
|
|
* Get the dquot (locked) before we start, as we need to do a
|
|
|
|
* transaction to allocate it if it doesn't exist. Once we have the
|
|
|
|
* dquot, unlock it so we can start the next transaction safely. We hold
|
|
|
|
* a reference to the dquot, so it's safe to do this unlock/lock without
|
|
|
|
* it being reclaimed in the mean time.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2018-05-04 22:30:24 +00:00
|
|
|
error = xfs_qm_dqget(mp, id, type, true, &dqp);
|
2013-05-21 08:02:00 +00:00
|
|
|
if (error) {
|
2014-06-25 04:58:08 +00:00
|
|
|
ASSERT(error != -ENOENT);
|
2010-04-20 07:01:30 +00:00
|
|
|
goto out_unlock;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2016-02-08 00:27:55 +00:00
|
|
|
|
2020-05-21 20:07:00 +00:00
|
|
|
defq = xfs_get_defquota(q, xfs_dquot_type(dqp));
|
2013-05-21 08:02:00 +00:00
|
|
|
xfs_dqunlock(dqp);
|
|
|
|
|
2016-04-05 23:19:55 +00:00
|
|
|
error = xfs_trans_alloc(mp, &M_RES(mp)->tr_qm_setqlim, 0, 0, 0, &tp);
|
|
|
|
if (error)
|
2013-05-21 08:02:00 +00:00
|
|
|
goto out_rele;
|
|
|
|
|
|
|
|
xfs_dqlock(dqp);
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_trans_dqjoin(tp, dqp);
|
|
|
|
|
|
|
|
/*
|
2020-07-14 17:37:33 +00:00
|
|
|
* Update quota limits, warnings, and timers, and the defaults
|
|
|
|
* if we're touching id == 0.
|
|
|
|
*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Make sure that hardlimits are >= soft limits before changing.
|
2020-07-14 17:37:33 +00:00
|
|
|
*
|
|
|
|
* Update warnings counter(s) if requested.
|
|
|
|
*
|
|
|
|
* Timelimits for the super user set the relative time the other users
|
|
|
|
* can be over quota for this file system. If it is zero a default is
|
|
|
|
* used. Ditto for the default soft and hard limit values (already
|
|
|
|
* done, above), and for warnings.
|
|
|
|
*
|
|
|
|
* For other IDs, userspace can bump out the grace period if over
|
|
|
|
* the soft limit.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2020-07-14 17:37:33 +00:00
|
|
|
|
|
|
|
/* Blocks on the data device. */
|
2014-10-09 14:03:13 +00:00
|
|
|
hard = (newlim->d_fieldmask & QC_SPC_HARD) ?
|
|
|
|
(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_spc_hardlimit) :
|
2020-07-14 17:37:31 +00:00
|
|
|
dqp->q_blk.hardlimit;
|
2014-10-09 14:03:13 +00:00
|
|
|
soft = (newlim->d_fieldmask & QC_SPC_SOFT) ?
|
|
|
|
(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_spc_softlimit) :
|
2020-07-14 17:37:31 +00:00
|
|
|
dqp->q_blk.softlimit;
|
2020-07-14 17:37:33 +00:00
|
|
|
res = &dqp->q_blk;
|
|
|
|
qlim = id == 0 ? &defq->blk : NULL;
|
|
|
|
|
|
|
|
if (xfs_setqlim_limits(mp, res, qlim, hard, soft, "blk"))
|
2013-03-18 14:51:46 +00:00
|
|
|
xfs_dquot_set_prealloc_limits(dqp);
|
2020-07-14 17:37:33 +00:00
|
|
|
if (newlim->d_fieldmask & QC_SPC_WARNS)
|
|
|
|
xfs_setqlim_warns(res, qlim, newlim->d_spc_warns);
|
|
|
|
if (newlim->d_fieldmask & QC_SPC_TIMER)
|
2020-08-17 16:58:36 +00:00
|
|
|
xfs_setqlim_timer(mp, res, qlim, newlim->d_spc_timer);
|
2020-07-14 17:37:33 +00:00
|
|
|
|
|
|
|
/* Blocks on the realtime device. */
|
2014-10-09 14:03:13 +00:00
|
|
|
hard = (newlim->d_fieldmask & QC_RT_SPC_HARD) ?
|
|
|
|
(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_rt_spc_hardlimit) :
|
2020-07-14 17:37:31 +00:00
|
|
|
dqp->q_rtb.hardlimit;
|
2014-10-09 14:03:13 +00:00
|
|
|
soft = (newlim->d_fieldmask & QC_RT_SPC_SOFT) ?
|
|
|
|
(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_rt_spc_softlimit) :
|
2020-07-14 17:37:31 +00:00
|
|
|
dqp->q_rtb.softlimit;
|
2020-07-14 17:37:33 +00:00
|
|
|
res = &dqp->q_rtb;
|
|
|
|
qlim = id == 0 ? &defq->rtb : NULL;
|
|
|
|
|
|
|
|
xfs_setqlim_limits(mp, res, qlim, hard, soft, "rtb");
|
|
|
|
if (newlim->d_fieldmask & QC_RT_SPC_WARNS)
|
|
|
|
xfs_setqlim_warns(res, qlim, newlim->d_rt_spc_warns);
|
|
|
|
if (newlim->d_fieldmask & QC_RT_SPC_TIMER)
|
2020-08-17 16:58:36 +00:00
|
|
|
xfs_setqlim_timer(mp, res, qlim, newlim->d_rt_spc_timer);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2020-07-14 17:37:33 +00:00
|
|
|
/* Inodes */
|
2014-10-09 14:03:13 +00:00
|
|
|
hard = (newlim->d_fieldmask & QC_INO_HARD) ?
|
2005-04-16 22:20:36 +00:00
|
|
|
(xfs_qcnt_t) newlim->d_ino_hardlimit :
|
2020-07-14 17:37:31 +00:00
|
|
|
dqp->q_ino.hardlimit;
|
2014-10-09 14:03:13 +00:00
|
|
|
soft = (newlim->d_fieldmask & QC_INO_SOFT) ?
|
2005-04-16 22:20:36 +00:00
|
|
|
(xfs_qcnt_t) newlim->d_ino_softlimit :
|
2020-07-14 17:37:31 +00:00
|
|
|
dqp->q_ino.softlimit;
|
2020-07-14 17:37:33 +00:00
|
|
|
res = &dqp->q_ino;
|
|
|
|
qlim = id == 0 ? &defq->ino : NULL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2020-07-14 17:37:33 +00:00
|
|
|
xfs_setqlim_limits(mp, res, qlim, hard, soft, "ino");
|
2014-10-09 14:03:13 +00:00
|
|
|
if (newlim->d_fieldmask & QC_INO_WARNS)
|
2020-07-14 17:37:33 +00:00
|
|
|
xfs_setqlim_warns(res, qlim, newlim->d_ino_warns);
|
2020-05-21 20:07:01 +00:00
|
|
|
if (newlim->d_fieldmask & QC_INO_TIMER)
|
2020-08-17 16:58:36 +00:00
|
|
|
xfs_setqlim_timer(mp, res, qlim, newlim->d_ino_timer);
|
2020-05-21 20:07:01 +00:00
|
|
|
|
|
|
|
if (id != 0) {
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* If the user is now over quota, start the timelimit.
|
|
|
|
* The user will not be 'warned'.
|
|
|
|
* Note that we keep the timers ticking, whether enforcement
|
|
|
|
* is on or off. We don't really want to bother with iterating
|
|
|
|
* over all ondisk dquots and turning the timers on/off.
|
|
|
|
*/
|
2020-07-14 17:37:33 +00:00
|
|
|
xfs_qm_adjust_dqtimers(dqp);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2020-07-14 17:37:13 +00:00
|
|
|
dqp->q_flags |= XFS_DQFLAG_DIRTY;
|
2005-04-16 22:20:36 +00:00
|
|
|
xfs_trans_log_dquot(tp, dqp);
|
|
|
|
|
2015-06-04 03:48:08 +00:00
|
|
|
error = xfs_trans_commit(tp);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-05-21 08:02:00 +00:00
|
|
|
out_rele:
|
|
|
|
xfs_qm_dqrele(dqp);
|
|
|
|
out_unlock:
|
2010-04-20 07:01:30 +00:00
|
|
|
mutex_unlock(&q->qi_quotaofflock);
|
2008-04-10 02:21:18 +00:00
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2018-05-04 22:30:20 +00:00
|
|
|
/* Fill out the quota context. */
|
|
|
|
static void
|
|
|
|
xfs_qm_scall_getquota_fill_qc(
|
2012-02-20 02:28:16 +00:00
|
|
|
struct xfs_mount *mp,
|
2020-07-16 00:53:43 +00:00
|
|
|
xfs_dqtype_t type,
|
2018-05-04 22:30:20 +00:00
|
|
|
const struct xfs_dquot *dqp,
|
|
|
|
struct qc_dqblk *dst)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
memset(dst, 0, sizeof(*dst));
|
2020-07-14 17:37:31 +00:00
|
|
|
dst->d_spc_hardlimit = XFS_FSB_TO_B(mp, dqp->q_blk.hardlimit);
|
|
|
|
dst->d_spc_softlimit = XFS_FSB_TO_B(mp, dqp->q_blk.softlimit);
|
2020-07-14 17:37:32 +00:00
|
|
|
dst->d_ino_hardlimit = dqp->q_ino.hardlimit;
|
|
|
|
dst->d_ino_softlimit = dqp->q_ino.softlimit;
|
2020-07-14 17:37:30 +00:00
|
|
|
dst->d_space = XFS_FSB_TO_B(mp, dqp->q_blk.reserved);
|
|
|
|
dst->d_ino_count = dqp->q_ino.reserved;
|
2020-07-14 17:37:32 +00:00
|
|
|
dst->d_spc_timer = dqp->q_blk.timer;
|
|
|
|
dst->d_ino_timer = dqp->q_ino.timer;
|
2020-07-14 17:37:31 +00:00
|
|
|
dst->d_ino_warns = dqp->q_ino.warnings;
|
|
|
|
dst->d_spc_warns = dqp->q_blk.warnings;
|
2020-07-14 17:37:31 +00:00
|
|
|
dst->d_rt_spc_hardlimit = XFS_FSB_TO_B(mp, dqp->q_rtb.hardlimit);
|
|
|
|
dst->d_rt_spc_softlimit = XFS_FSB_TO_B(mp, dqp->q_rtb.softlimit);
|
2020-07-14 17:37:30 +00:00
|
|
|
dst->d_rt_space = XFS_FSB_TO_B(mp, dqp->q_rtb.reserved);
|
2020-07-14 17:37:32 +00:00
|
|
|
dst->d_rt_spc_timer = dqp->q_rtb.timer;
|
2020-07-14 17:37:31 +00:00
|
|
|
dst->d_rt_spc_warns = dqp->q_rtb.warnings;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Internally, we don't reset all the timers when quota enforcement
|
2006-03-28 22:55:14 +00:00
|
|
|
* gets turned off. No need to confuse the user level code,
|
2005-04-16 22:20:36 +00:00
|
|
|
* so return zeroes in that case.
|
|
|
|
*/
|
2020-07-16 00:48:31 +00:00
|
|
|
if (!xfs_dquot_is_enforced(dqp)) {
|
2014-10-09 14:03:13 +00:00
|
|
|
dst->d_spc_timer = 0;
|
|
|
|
dst->d_ino_timer = 0;
|
|
|
|
dst->d_rt_spc_timer = 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
2020-07-16 00:48:31 +00:00
|
|
|
if (xfs_dquot_is_enforced(dqp) && dqp->q_id != 0) {
|
2014-10-09 14:03:13 +00:00
|
|
|
if ((dst->d_space > dst->d_spc_softlimit) &&
|
|
|
|
(dst->d_spc_softlimit > 0)) {
|
|
|
|
ASSERT(dst->d_spc_timer != 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2020-07-14 17:37:31 +00:00
|
|
|
if ((dst->d_ino_count > dqp->q_ino.softlimit) &&
|
|
|
|
(dqp->q_ino.softlimit > 0)) {
|
2014-10-09 14:03:13 +00:00
|
|
|
ASSERT(dst->d_ino_timer != 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2018-05-04 22:30:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Return the quota information for the dquot matching id. */
|
|
|
|
int
|
|
|
|
xfs_qm_scall_getquota(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
xfs_dqid_t id,
|
2020-07-16 00:53:43 +00:00
|
|
|
xfs_dqtype_t type,
|
2018-05-04 22:30:20 +00:00
|
|
|
struct qc_dqblk *dst)
|
|
|
|
{
|
|
|
|
struct xfs_dquot *dqp;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/*
|
2018-05-04 22:30:24 +00:00
|
|
|
* Try to get the dquot. We don't want it allocated on disk, so don't
|
|
|
|
* set doalloc. If it doesn't exist, we'll get ENOENT back.
|
2018-05-04 22:30:20 +00:00
|
|
|
*/
|
2018-05-04 22:30:24 +00:00
|
|
|
error = xfs_qm_dqget(mp, id, type, false, &dqp);
|
2018-05-04 22:30:20 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If everything's NULL, this dquot doesn't quite exist as far as
|
|
|
|
* our utility programs are concerned.
|
|
|
|
*/
|
|
|
|
if (XFS_IS_DQUOT_UNINITIALIZED(dqp)) {
|
|
|
|
error = -ENOENT;
|
|
|
|
goto out_put;
|
|
|
|
}
|
|
|
|
|
|
|
|
xfs_qm_scall_getquota_fill_qc(mp, type, dqp, dst);
|
|
|
|
|
2012-02-20 02:28:16 +00:00
|
|
|
out_put:
|
|
|
|
xfs_qm_dqput(dqp);
|
|
|
|
return error;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2018-05-04 22:30:20 +00:00
|
|
|
/*
|
|
|
|
* Return the quota information for the first initialized dquot whose id
|
|
|
|
* is at least as high as id.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
xfs_qm_scall_getquota_next(
|
|
|
|
struct xfs_mount *mp,
|
|
|
|
xfs_dqid_t *id,
|
2020-07-16 00:53:43 +00:00
|
|
|
xfs_dqtype_t type,
|
2018-05-04 22:30:20 +00:00
|
|
|
struct qc_dqblk *dst)
|
|
|
|
{
|
|
|
|
struct xfs_dquot *dqp;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = xfs_qm_dqget_next(mp, *id, type, &dqp);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
/* Fill in the ID we actually read from disk */
|
2020-07-14 17:37:30 +00:00
|
|
|
*id = dqp->q_id;
|
2018-05-04 22:30:20 +00:00
|
|
|
|
|
|
|
xfs_qm_scall_getquota_fill_qc(mp, type, dqp, dst);
|
|
|
|
|
|
|
|
xfs_qm_dqput(dqp);
|
|
|
|
return error;
|
|
|
|
}
|