xfs_qm_syscalls.c 20.8 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2 3
 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
 * All Rights Reserved.
L
Linus Torvalds 已提交
4
 *
5 6
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
L
Linus Torvalds 已提交
7 8
 * published by the Free Software Foundation.
 *
9 10 11 12
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
L
Linus Torvalds 已提交
13
 *
14 15 16
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
L
Linus Torvalds 已提交
17
 */
18 19 20

#include <linux/capability.h>

L
Linus Torvalds 已提交
21 22
#include "xfs.h"
#include "xfs_fs.h"
23
#include "xfs_shared.h"
24 25 26
#include "xfs_format.h"
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
27
#include "xfs_bit.h"
L
Linus Torvalds 已提交
28 29 30
#include "xfs_sb.h"
#include "xfs_mount.h"
#include "xfs_inode.h"
31
#include "xfs_trans.h"
L
Linus Torvalds 已提交
32
#include "xfs_error.h"
33
#include "xfs_quota.h"
L
Linus Torvalds 已提交
34
#include "xfs_qm.h"
C
Christoph Hellwig 已提交
35
#include "xfs_trace.h"
36
#include "xfs_icache.h"
L
Linus Torvalds 已提交
37 38 39 40 41 42 43 44 45 46 47 48 49

STATIC int	xfs_qm_log_quotaoff(xfs_mount_t *, xfs_qoff_logitem_t **, uint);
STATIC int	xfs_qm_log_quotaoff_end(xfs_mount_t *, xfs_qoff_logitem_t *,
					uint);

/*
 * Turn off quota accounting and/or enforcement for all udquots and/or
 * gdquots. Called only at unmount time.
 *
 * This assumes that there are no dquots of this file system cached
 * incore, and modifies the ondisk dquot directly. Therefore, for example,
 * it is an error to call this twice, without purging the cache.
 */
50
int
L
Linus Torvalds 已提交
51 52
xfs_qm_scall_quotaoff(
	xfs_mount_t		*mp,
53
	uint			flags)
L
Linus Torvalds 已提交
54
{
55
	struct xfs_quotainfo	*q = mp->m_quotainfo;
L
Linus Torvalds 已提交
56 57 58 59 60 61 62 63
	uint			dqtype;
	int			error;
	uint			inactivate_flags;
	xfs_qoff_logitem_t	*qoffstart;

	/*
	 * No file system can have quotas enabled on disk but not in core.
	 * Note that quota utilities (like quotaoff) _expect_
D
Dave Chinner 已提交
64
	 * errno == -EEXIST here.
L
Linus Torvalds 已提交
65 66
	 */
	if ((mp->m_qflags & flags) == 0)
D
Dave Chinner 已提交
67
		return -EEXIST;
L
Linus Torvalds 已提交
68 69 70 71 72 73 74 75 76 77
	error = 0;

	flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD);

	/*
	 * We don't want to deal with two quotaoffs messing up each other,
	 * so we're going to serialize it. quotaoff isn't exactly a performance
	 * critical thing.
	 * If quotaoff, then we must be dealing with the root filesystem.
	 */
78 79
	ASSERT(q);
	mutex_lock(&q->qi_quotaofflock);
L
Linus Torvalds 已提交
80 81 82 83 84 85 86

	/*
	 * If we're just turning off quota enforcement, change mp and go.
	 */
	if ((flags & XFS_ALL_QUOTA_ACCT) == 0) {
		mp->m_qflags &= ~(flags);

E
Eric Sandeen 已提交
87
		spin_lock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
88
		mp->m_sb.sb_qflags = mp->m_qflags;
E
Eric Sandeen 已提交
89
		spin_unlock(&mp->m_sb_lock);
90
		mutex_unlock(&q->qi_quotaofflock);
L
Linus Torvalds 已提交
91 92

		/* XXX what to do if error ? Revert back to old vals incore ? */
93
		return xfs_sync_sb(mp, false);
L
Linus Torvalds 已提交
94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
	}

	dqtype = 0;
	inactivate_flags = 0;
	/*
	 * If accounting is off, we must turn enforcement off, clear the
	 * quota 'CHKD' certificate to make it known that we have to
	 * do a quotacheck the next time this quota is turned on.
	 */
	if (flags & XFS_UQUOTA_ACCT) {
		dqtype |= XFS_QMOPT_UQUOTA;
		flags |= (XFS_UQUOTA_CHKD | XFS_UQUOTA_ENFD);
		inactivate_flags |= XFS_UQUOTA_ACTIVE;
	}
	if (flags & XFS_GQUOTA_ACCT) {
		dqtype |= XFS_QMOPT_GQUOTA;
110
		flags |= (XFS_GQUOTA_CHKD | XFS_GQUOTA_ENFD);
L
Linus Torvalds 已提交
111
		inactivate_flags |= XFS_GQUOTA_ACTIVE;
112 113
	}
	if (flags & XFS_PQUOTA_ACCT) {
114
		dqtype |= XFS_QMOPT_PQUOTA;
115
		flags |= (XFS_PQUOTA_CHKD | XFS_PQUOTA_ENFD);
116
		inactivate_flags |= XFS_PQUOTA_ACTIVE;
L
Linus Torvalds 已提交
117 118 119 120 121 122
	}

	/*
	 * Nothing to do?  Don't complain. This happens when we're just
	 * turning off quota enforcement.
	 */
123 124
	if ((mp->m_qflags & flags) == 0)
		goto out_unlock;
L
Linus Torvalds 已提交
125 126 127

	/*
	 * Write the LI_QUOTAOFF log record, and do SB changes atomically,
128 129
	 * and synchronously. If we fail to write, we should abort the
	 * operation as it cannot be recovered safely if we crash.
L
Linus Torvalds 已提交
130
	 */
131 132
	error = xfs_qm_log_quotaoff(mp, &qoffstart, flags);
	if (error)
133
		goto out_unlock;
L
Linus Torvalds 已提交
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162

	/*
	 * Next we clear the XFS_MOUNT_*DQ_ACTIVE bit(s) in the mount struct
	 * to take care of the race between dqget and quotaoff. We don't take
	 * any special locks to reset these bits. All processes need to check
	 * these bits *after* taking inode lock(s) to see if the particular
	 * quota type is in the process of being turned off. If *ACTIVE, it is
	 * guaranteed that all dquot structures and all quotainode ptrs will all
	 * stay valid as long as that inode is kept locked.
	 *
	 * There is no turning back after this.
	 */
	mp->m_qflags &= ~inactivate_flags;

	/*
	 * Give back all the dquot reference(s) held by inodes.
	 * Here we go thru every single incore inode in this file system, and
	 * do a dqrele on the i_udquot/i_gdquot that it may have.
	 * Essentially, as long as somebody has an inode locked, this guarantees
	 * that quotas will not be turned off. This is handy because in a
	 * transaction once we lock the inode(s) and check for quotaon, we can
	 * depend on the quota inodes (and other things) being valid as long as
	 * we keep the lock(s).
	 */
	xfs_qm_dqrele_all_inodes(mp, flags);

	/*
	 * Next we make the changes in the quota flag in the mount struct.
	 * This isn't protected by a particular lock directly, because we
L
Lucas De Marchi 已提交
163
	 * don't want to take a mrlock every time we depend on quotas being on.
L
Linus Torvalds 已提交
164
	 */
165
	mp->m_qflags &= ~flags;
L
Linus Torvalds 已提交
166 167 168

	/*
	 * Go through all the dquots of this file system and purge them,
169
	 * according to what was turned off.
L
Linus Torvalds 已提交
170
	 */
171
	xfs_qm_dqpurge_all(mp, dqtype);
L
Linus Torvalds 已提交
172 173 174 175 176 177 178 179 180 181 182 183

	/*
	 * Transactions that had started before ACTIVE state bit was cleared
	 * could have logged many dquots, so they'd have higher LSNs than
	 * the first QUOTAOFF log record does. If we happen to crash when
	 * the tail of the log has gone past the QUOTAOFF record, but
	 * before the last dquot modification, those dquots __will__
	 * recover, and that's not good.
	 *
	 * So, we have QUOTAOFF start and end logitems; the start
	 * logitem won't get overwritten until the end logitem appears...
	 */
184 185 186 187
	error = xfs_qm_log_quotaoff_end(mp, qoffstart, flags);
	if (error) {
		/* We're screwed now. Shutdown is the only option. */
		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
188
		goto out_unlock;
189
	}
L
Linus Torvalds 已提交
190 191

	/*
192
	 * If all quotas are completely turned off, close shop.
L
Linus Torvalds 已提交
193
	 */
194
	if (mp->m_qflags == 0) {
195
		mutex_unlock(&q->qi_quotaofflock);
L
Linus Torvalds 已提交
196
		xfs_qm_destroy_quotainfo(mp);
E
Eric Sandeen 已提交
197
		return 0;
L
Linus Torvalds 已提交
198 199 200
	}

	/*
201
	 * Release our quotainode references if we don't need them anymore.
L
Linus Torvalds 已提交
202
	 */
203 204 205
	if ((dqtype & XFS_QMOPT_UQUOTA) && q->qi_uquotaip) {
		IRELE(q->qi_uquotaip);
		q->qi_uquotaip = NULL;
L
Linus Torvalds 已提交
206
	}
207
	if ((dqtype & XFS_QMOPT_GQUOTA) && q->qi_gquotaip) {
208 209
		IRELE(q->qi_gquotaip);
		q->qi_gquotaip = NULL;
L
Linus Torvalds 已提交
210
	}
211 212 213 214
	if ((dqtype & XFS_QMOPT_PQUOTA) && q->qi_pquotaip) {
		IRELE(q->qi_pquotaip);
		q->qi_pquotaip = NULL;
	}
L
Linus Torvalds 已提交
215

216 217 218
out_unlock:
	mutex_unlock(&q->qi_quotaofflock);
	return error;
L
Linus Torvalds 已提交
219 220
}

221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
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);

	tp = xfs_trans_alloc(mp, XFS_TRANS_TRUNCATE_FILE);
240
	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
241
	if (error) {
242
		xfs_trans_cancel(tp);
243 244 245 246 247
		xfs_iunlock(ip, XFS_IOLOCK_EXCL);
		goto out_put;
	}

	xfs_ilock(ip, XFS_ILOCK_EXCL);
248
	xfs_trans_ijoin(tp, ip, 0);
249

250 251 252 253
	ip->i_d.di_size = 0;
	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);

	error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
254
	if (error) {
255
		xfs_trans_cancel(tp);
256 257 258
		goto out_unlock;
	}

259 260
	ASSERT(ip->i_d.di_nextents == 0);

261
	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
262
	error = xfs_trans_commit(tp);
263 264 265 266 267 268 269 270

out_unlock:
	xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
out_put:
	IRELE(ip);
	return error;
}

271
int
L
Linus Torvalds 已提交
272 273 274 275
xfs_qm_scall_trunc_qfiles(
	xfs_mount_t	*mp,
	uint		flags)
{
D
Dave Chinner 已提交
276
	int		error = -EINVAL;
L
Linus Torvalds 已提交
277

278 279
	if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0 ||
	    (flags & ~XFS_DQ_ALLTYPES)) {
280
		xfs_debug(mp, "%s: flags=%x m_qflags=%x",
281
			__func__, flags, mp->m_qflags);
D
Dave Chinner 已提交
282
		return -EINVAL;
L
Linus Torvalds 已提交
283 284
	}

285
	if (flags & XFS_DQ_USER) {
286
		error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_uquotino);
287 288 289 290 291 292 293 294
		if (error)
			return error;
	}
	if (flags & XFS_DQ_GROUP) {
		error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_gquotino);
		if (error)
			return error;
	}
295
	if (flags & XFS_DQ_PROJ)
296
		error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_pquotino);
L
Linus Torvalds 已提交
297

298
	return error;
L
Linus Torvalds 已提交
299 300 301 302 303 304 305
}

/*
 * Switch on (a given) quota enforcement for a filesystem.  This takes
 * effect immediately.
 * (Switching on quota accounting must be done at mount time.)
 */
306
int
L
Linus Torvalds 已提交
307 308 309 310 311 312 313 314 315 316 317 318 319 320
xfs_qm_scall_quotaon(
	xfs_mount_t	*mp,
	uint		flags)
{
	int		error;
	uint		qf;

	flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD);
	/*
	 * Switching on quota accounting must be done at mount time.
	 */
	flags &= ~(XFS_ALL_QUOTA_ACCT);

	if (flags == 0) {
321
		xfs_debug(mp, "%s: zero flags, m_qflags=%x",
322
			__func__, mp->m_qflags);
D
Dave Chinner 已提交
323
		return -EINVAL;
L
Linus Torvalds 已提交
324 325 326 327 328 329 330
	}

	/*
	 * 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.
	 */
J
Jan Kara 已提交
331
	if (((mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) == 0 &&
332
	     (flags & XFS_UQUOTA_ENFD)) ||
J
Jan Kara 已提交
333
	    ((mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) == 0 &&
334
	     (flags & XFS_GQUOTA_ENFD)) ||
J
Jan Kara 已提交
335
	    ((mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) == 0 &&
336
	     (flags & XFS_PQUOTA_ENFD))) {
337
		xfs_debug(mp,
338
			"%s: Can't enforce without acct, flags=%x sbflags=%x",
339
			__func__, flags, mp->m_sb.sb_qflags);
D
Dave Chinner 已提交
340
		return -EINVAL;
L
Linus Torvalds 已提交
341 342
	}
	/*
L
Lucas De Marchi 已提交
343
	 * If everything's up to-date incore, then don't waste time.
L
Linus Torvalds 已提交
344 345
	 */
	if ((mp->m_qflags & flags) == flags)
D
Dave Chinner 已提交
346
		return -EEXIST;
L
Linus Torvalds 已提交
347 348 349 350 351

	/*
	 * Change sb_qflags on disk but not incore mp->qflags
	 * if this is the root filesystem.
	 */
E
Eric Sandeen 已提交
352
	spin_lock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
353 354
	qf = mp->m_sb.sb_qflags;
	mp->m_sb.sb_qflags = qf | flags;
E
Eric Sandeen 已提交
355
	spin_unlock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
356 357 358 359

	/*
	 * There's nothing to change if it's the same.
	 */
360
	if ((qf & flags) == flags)
D
Dave Chinner 已提交
361
		return -EEXIST;
L
Linus Torvalds 已提交
362

363 364
	error = xfs_sync_sb(mp, false);
	if (error)
E
Eric Sandeen 已提交
365
		return error;
L
Linus Torvalds 已提交
366 367 368 369 370
	/*
	 * 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)) ||
371 372 373
	     ((mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) !=
	     (mp->m_qflags & XFS_PQUOTA_ACCT)) ||
	     ((mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) !=
J
Jan Kara 已提交
374
	     (mp->m_qflags & XFS_GQUOTA_ACCT)))
E
Eric Sandeen 已提交
375
		return 0;
L
Linus Torvalds 已提交
376 377

	if (! XFS_IS_QUOTA_RUNNING(mp))
D
Dave Chinner 已提交
378
		return -ESRCH;
L
Linus Torvalds 已提交
379 380 381 382

	/*
	 * Switch on quota enforcement in core.
	 */
383
	mutex_lock(&mp->m_quotainfo->qi_quotaofflock);
L
Linus Torvalds 已提交
384
	mp->m_qflags |= (flags & XFS_ALL_QUOTA_ENFD);
385
	mutex_unlock(&mp->m_quotainfo->qi_quotaofflock);
L
Linus Torvalds 已提交
386

E
Eric Sandeen 已提交
387
	return 0;
L
Linus Torvalds 已提交
388 389
}

390 391
#define XFS_QC_MASK \
	(QC_LIMIT_MASK | QC_TIMER_MASK | QC_WARNS_MASK)
C
Christoph Hellwig 已提交
392

L
Linus Torvalds 已提交
393 394 395
/*
 * Adjust quota limits, and start/stop timers accordingly.
 */
396
int
L
Linus Torvalds 已提交
397
xfs_qm_scall_setqlim(
398
	struct xfs_mount	*mp,
L
Linus Torvalds 已提交
399 400
	xfs_dqid_t		id,
	uint			type,
401
	struct qc_dqblk		*newlim)
L
Linus Torvalds 已提交
402
{
403
	struct xfs_quotainfo	*q = mp->m_quotainfo;
404 405 406
	struct xfs_disk_dquot	*ddq;
	struct xfs_dquot	*dqp;
	struct xfs_trans	*tp;
407
	struct xfs_def_quota	*defq;
L
Linus Torvalds 已提交
408 409 410
	int			error;
	xfs_qcnt_t		hard, soft;

411
	if (newlim->d_fieldmask & ~XFS_QC_MASK)
D
Dave Chinner 已提交
412
		return -EINVAL;
413
	if ((newlim->d_fieldmask & XFS_QC_MASK) == 0)
C
Christoph Hellwig 已提交
414
		return 0;
L
Linus Torvalds 已提交
415 416 417

	/*
	 * We don't want to race with a quotaoff so take the quotaoff lock.
418 419
	 * We don't hold an inode lock, so there's nothing else to stop
	 * a quotaoff from happening.
L
Linus Torvalds 已提交
420
	 */
421
	mutex_lock(&q->qi_quotaofflock);
L
Linus Torvalds 已提交
422 423

	/*
424 425 426 427 428
	 * 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.
L
Linus Torvalds 已提交
429
	 */
430 431
	error = xfs_qm_dqget(mp, NULL, id, type, XFS_QMOPT_DQALLOC, &dqp);
	if (error) {
D
Dave Chinner 已提交
432
		ASSERT(error != -ENOENT);
433
		goto out_unlock;
L
Linus Torvalds 已提交
434
	}
435 436

	defq = xfs_get_defquota(dqp, q);
437 438 439
	xfs_dqunlock(dqp);

	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SETQLIM);
440
	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_setqlim, 0, 0);
441
	if (error) {
442
		xfs_trans_cancel(tp);
443 444 445 446
		goto out_rele;
	}

	xfs_dqlock(dqp);
L
Linus Torvalds 已提交
447 448 449 450 451 452
	xfs_trans_dqjoin(tp, dqp);
	ddq = &dqp->q_core;

	/*
	 * Make sure that hardlimits are >= soft limits before changing.
	 */
453 454
	hard = (newlim->d_fieldmask & QC_SPC_HARD) ?
		(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_spc_hardlimit) :
455
			be64_to_cpu(ddq->d_blk_hardlimit);
456 457
	soft = (newlim->d_fieldmask & QC_SPC_SOFT) ?
		(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_spc_softlimit) :
458
			be64_to_cpu(ddq->d_blk_softlimit);
L
Linus Torvalds 已提交
459
	if (hard == 0 || hard >= soft) {
460 461
		ddq->d_blk_hardlimit = cpu_to_be64(hard);
		ddq->d_blk_softlimit = cpu_to_be64(soft);
462
		xfs_dquot_set_prealloc_limits(dqp);
L
Linus Torvalds 已提交
463
		if (id == 0) {
464 465
			defq->bhardlimit = hard;
			defq->bsoftlimit = soft;
L
Linus Torvalds 已提交
466 467
		}
	} else {
468
		xfs_debug(mp, "blkhard %Ld < blksoft %Ld", hard, soft);
L
Linus Torvalds 已提交
469
	}
470 471
	hard = (newlim->d_fieldmask & QC_RT_SPC_HARD) ?
		(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_rt_spc_hardlimit) :
472
			be64_to_cpu(ddq->d_rtb_hardlimit);
473 474
	soft = (newlim->d_fieldmask & QC_RT_SPC_SOFT) ?
		(xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_rt_spc_softlimit) :
475
			be64_to_cpu(ddq->d_rtb_softlimit);
L
Linus Torvalds 已提交
476
	if (hard == 0 || hard >= soft) {
477 478
		ddq->d_rtb_hardlimit = cpu_to_be64(hard);
		ddq->d_rtb_softlimit = cpu_to_be64(soft);
L
Linus Torvalds 已提交
479
		if (id == 0) {
480 481
			defq->rtbhardlimit = hard;
			defq->rtbsoftlimit = soft;
L
Linus Torvalds 已提交
482 483
		}
	} else {
484
		xfs_debug(mp, "rtbhard %Ld < rtbsoft %Ld", hard, soft);
L
Linus Torvalds 已提交
485 486
	}

487
	hard = (newlim->d_fieldmask & QC_INO_HARD) ?
L
Linus Torvalds 已提交
488
		(xfs_qcnt_t) newlim->d_ino_hardlimit :
489
			be64_to_cpu(ddq->d_ino_hardlimit);
490
	soft = (newlim->d_fieldmask & QC_INO_SOFT) ?
L
Linus Torvalds 已提交
491
		(xfs_qcnt_t) newlim->d_ino_softlimit :
492
			be64_to_cpu(ddq->d_ino_softlimit);
L
Linus Torvalds 已提交
493
	if (hard == 0 || hard >= soft) {
494 495
		ddq->d_ino_hardlimit = cpu_to_be64(hard);
		ddq->d_ino_softlimit = cpu_to_be64(soft);
L
Linus Torvalds 已提交
496
		if (id == 0) {
497 498
			defq->ihardlimit = hard;
			defq->isoftlimit = soft;
L
Linus Torvalds 已提交
499 500
		}
	} else {
501
		xfs_debug(mp, "ihard %Ld < isoft %Ld", hard, soft);
L
Linus Torvalds 已提交
502 503
	}

504 505 506
	/*
	 * Update warnings counter(s) if requested
	 */
507 508 509 510 511 512
	if (newlim->d_fieldmask & QC_SPC_WARNS)
		ddq->d_bwarns = cpu_to_be16(newlim->d_spc_warns);
	if (newlim->d_fieldmask & QC_INO_WARNS)
		ddq->d_iwarns = cpu_to_be16(newlim->d_ino_warns);
	if (newlim->d_fieldmask & QC_RT_SPC_WARNS)
		ddq->d_rtbwarns = cpu_to_be16(newlim->d_rt_spc_warns);
513

L
Linus Torvalds 已提交
514 515 516 517 518
	if (id == 0) {
		/*
		 * 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
519 520
		 * soft and hard limit values (already done, above), and
		 * for warnings.
L
Linus Torvalds 已提交
521
		 */
522 523 524
		if (newlim->d_fieldmask & QC_SPC_TIMER) {
			q->qi_btimelimit = newlim->d_spc_timer;
			ddq->d_btimer = cpu_to_be32(newlim->d_spc_timer);
L
Linus Torvalds 已提交
525
		}
526 527 528
		if (newlim->d_fieldmask & QC_INO_TIMER) {
			q->qi_itimelimit = newlim->d_ino_timer;
			ddq->d_itimer = cpu_to_be32(newlim->d_ino_timer);
L
Linus Torvalds 已提交
529
		}
530 531 532
		if (newlim->d_fieldmask & QC_RT_SPC_TIMER) {
			q->qi_rtbtimelimit = newlim->d_rt_spc_timer;
			ddq->d_rtbtimer = cpu_to_be32(newlim->d_rt_spc_timer);
L
Linus Torvalds 已提交
533
		}
534 535 536 537 538 539
		if (newlim->d_fieldmask & QC_SPC_WARNS)
			q->qi_bwarnlimit = newlim->d_spc_warns;
		if (newlim->d_fieldmask & QC_INO_WARNS)
			q->qi_iwarnlimit = newlim->d_ino_warns;
		if (newlim->d_fieldmask & QC_RT_SPC_WARNS)
			q->qi_rtbwarnlimit = newlim->d_rt_spc_warns;
540
	} else {
L
Linus Torvalds 已提交
541 542 543 544 545 546 547 548 549 550 551 552
		/*
		 * 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.
		 */
		xfs_qm_adjust_dqtimers(mp, ddq);
	}
	dqp->dq_flags |= XFS_DQ_DIRTY;
	xfs_trans_log_dquot(tp, dqp);

553
	error = xfs_trans_commit(tp);
L
Linus Torvalds 已提交
554

555 556 557
out_rele:
	xfs_qm_dqrele(dqp);
out_unlock:
558
	mutex_unlock(&q->qi_quotaofflock);
559
	return error;
L
Linus Torvalds 已提交
560 561 562 563 564 565 566 567
}

STATIC int
xfs_qm_log_quotaoff_end(
	xfs_mount_t		*mp,
	xfs_qoff_logitem_t	*startqoff,
	uint			flags)
{
568
	xfs_trans_t		*tp;
L
Linus Torvalds 已提交
569
	int			error;
570
	xfs_qoff_logitem_t	*qoffi;
L
Linus Torvalds 已提交
571 572 573

	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QUOTAOFF_END);

574
	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_equotaoff, 0, 0);
575
	if (error) {
576
		xfs_trans_cancel(tp);
E
Eric Sandeen 已提交
577
		return error;
L
Linus Torvalds 已提交
578 579 580 581 582 583 584 585 586 587 588 589
	}

	qoffi = xfs_trans_get_qoff_item(tp, startqoff,
					flags & XFS_ALL_QUOTA_ACCT);
	xfs_trans_log_quotaoff_item(tp, qoffi);

	/*
	 * We have to make sure that the transaction is secure on disk before we
	 * return and actually stop quota accounting. So, make it synchronous.
	 * We don't care about quotoff's performance.
	 */
	xfs_trans_set_sync(tp);
590
	return xfs_trans_commit(tp);
L
Linus Torvalds 已提交
591 592 593 594 595 596 597 598 599 600 601
}


STATIC int
xfs_qm_log_quotaoff(
	xfs_mount_t	       *mp,
	xfs_qoff_logitem_t     **qoffstartp,
	uint		       flags)
{
	xfs_trans_t	       *tp;
	int			error;
602 603 604
	xfs_qoff_logitem_t     *qoffi;

	*qoffstartp = NULL;
L
Linus Torvalds 已提交
605 606

	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QUOTAOFF);
607
	error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_quotaoff, 0, 0);
608
	if (error) {
609
		xfs_trans_cancel(tp);
610 611
		goto out;
	}
L
Linus Torvalds 已提交
612 613 614 615

	qoffi = xfs_trans_get_qoff_item(tp, NULL, flags & XFS_ALL_QUOTA_ACCT);
	xfs_trans_log_quotaoff_item(tp, qoffi);

E
Eric Sandeen 已提交
616
	spin_lock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
617
	mp->m_sb.sb_qflags = (mp->m_qflags & ~(flags)) & XFS_MOUNT_QUOTA_ALL;
E
Eric Sandeen 已提交
618
	spin_unlock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
619

620
	xfs_log_sb(tp);
L
Linus Torvalds 已提交
621 622 623 624 625 626 627

	/*
	 * We have to make sure that the transaction is secure on disk before we
	 * return and actually stop quota accounting. So, make it synchronous.
	 * We don't care about quotoff's performance.
	 */
	xfs_trans_set_sync(tp);
628
	error = xfs_trans_commit(tp);
629 630
	if (error)
		goto out;
L
Linus Torvalds 已提交
631 632

	*qoffstartp = qoffi;
633
out:
E
Eric Sandeen 已提交
634
	return error;
L
Linus Torvalds 已提交
635 636 637
}


638 639 640
int
xfs_qm_scall_getquota(
	struct xfs_mount	*mp,
641
	xfs_dqid_t		*id,
642
	uint			type,
643 644
	struct qc_dqblk		*dst,
	uint			dqget_flags)
L
Linus Torvalds 已提交
645
{
646 647 648 649 650 651 652 653
	struct xfs_dquot	*dqp;
	int			error;

	/*
	 * Try to get the dquot. We don't want it allocated on disk, so
	 * we aren't passing the XFS_QMOPT_DOALLOC flag. If it doesn't
	 * exist, we'll get ENOENT back.
	 */
654
	error = xfs_qm_dqget(mp, NULL, *id, type, dqget_flags, &dqp);
655 656 657 658 659 660 661 662
	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)) {
D
Dave Chinner 已提交
663
		error = -ENOENT;
664 665 666
		goto out_put;
	}

667 668 669
	/* Fill in the ID we actually read from disk */
	*id = be32_to_cpu(dqp->q_core.d_id);

L
Linus Torvalds 已提交
670
	memset(dst, 0, sizeof(*dst));
671 672 673 674
	dst->d_spc_hardlimit =
		XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_blk_hardlimit));
	dst->d_spc_softlimit =
		XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_blk_softlimit));
675 676
	dst->d_ino_hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit);
	dst->d_ino_softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit);
677 678 679 680 681 682 683 684 685 686 687 688 689
	dst->d_space = XFS_FSB_TO_B(mp, dqp->q_res_bcount);
	dst->d_ino_count = dqp->q_res_icount;
	dst->d_spc_timer = be32_to_cpu(dqp->q_core.d_btimer);
	dst->d_ino_timer = be32_to_cpu(dqp->q_core.d_itimer);
	dst->d_ino_warns = be16_to_cpu(dqp->q_core.d_iwarns);
	dst->d_spc_warns = be16_to_cpu(dqp->q_core.d_bwarns);
	dst->d_rt_spc_hardlimit =
		XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_rtb_hardlimit));
	dst->d_rt_spc_softlimit =
		XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_rtb_softlimit));
	dst->d_rt_space = XFS_FSB_TO_B(mp, dqp->q_res_rtbcount);
	dst->d_rt_spc_timer = be32_to_cpu(dqp->q_core.d_rtbtimer);
	dst->d_rt_spc_warns = be16_to_cpu(dqp->q_core.d_rtbwarns);
L
Linus Torvalds 已提交
690 691 692

	/*
	 * Internally, we don't reset all the timers when quota enforcement
693
	 * gets turned off. No need to confuse the user level code,
L
Linus Torvalds 已提交
694 695
	 * so return zeroes in that case.
	 */
696 697 698 699 700 701
	if ((!XFS_IS_UQUOTA_ENFORCED(mp) &&
	     dqp->q_core.d_flags == XFS_DQ_USER) ||
	    (!XFS_IS_GQUOTA_ENFORCED(mp) &&
	     dqp->q_core.d_flags == XFS_DQ_GROUP) ||
	    (!XFS_IS_PQUOTA_ENFORCED(mp) &&
	     dqp->q_core.d_flags == XFS_DQ_PROJ)) {
702 703 704
		dst->d_spc_timer = 0;
		dst->d_ino_timer = 0;
		dst->d_rt_spc_timer = 0;
L
Linus Torvalds 已提交
705 706 707
	}

#ifdef DEBUG
708 709 710
	if (((XFS_IS_UQUOTA_ENFORCED(mp) && type == XFS_DQ_USER) ||
	     (XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQ_GROUP) ||
	     (XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQ_PROJ)) &&
711
	    *id != 0) {
712 713 714
		if ((dst->d_space > dst->d_spc_softlimit) &&
		    (dst->d_spc_softlimit > 0)) {
			ASSERT(dst->d_spc_timer != 0);
L
Linus Torvalds 已提交
715
		}
716
		if ((dst->d_ino_count > dst->d_ino_softlimit) &&
L
Linus Torvalds 已提交
717
		    (dst->d_ino_softlimit > 0)) {
718
			ASSERT(dst->d_ino_timer != 0);
L
Linus Torvalds 已提交
719 720 721
		}
	}
#endif
722 723 724
out_put:
	xfs_qm_dqput(dqp);
	return error;
L
Linus Torvalds 已提交
725 726 727
}


728 729 730
STATIC int
xfs_dqrele_inode(
	struct xfs_inode	*ip,
731 732
	int			flags,
	void			*args)
L
Linus Torvalds 已提交
733
{
734
	/* skip quota inodes */
735
	if (ip == ip->i_mount->m_quotainfo->qi_uquotaip ||
736 737
	    ip == ip->i_mount->m_quotainfo->qi_gquotaip ||
	    ip == ip->i_mount->m_quotainfo->qi_pquotaip) {
738 739
		ASSERT(ip->i_udquot == NULL);
		ASSERT(ip->i_gdquot == NULL);
740
		ASSERT(ip->i_pdquot == NULL);
741 742
		return 0;
	}
743

744 745 746 747 748
	xfs_ilock(ip, XFS_ILOCK_EXCL);
	if ((flags & XFS_UQUOTA_ACCT) && ip->i_udquot) {
		xfs_qm_dqrele(ip->i_udquot);
		ip->i_udquot = NULL;
	}
749
	if ((flags & XFS_GQUOTA_ACCT) && ip->i_gdquot) {
750 751 752
		xfs_qm_dqrele(ip->i_gdquot);
		ip->i_gdquot = NULL;
	}
753 754 755 756
	if ((flags & XFS_PQUOTA_ACCT) && ip->i_pdquot) {
		xfs_qm_dqrele(ip->i_pdquot);
		ip->i_pdquot = NULL;
	}
C
Christoph Hellwig 已提交
757
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
758
	return 0;
759 760
}

761

762 763
/*
 * Go thru all the inodes in the file system, releasing their dquots.
764
 *
765
 * Note that the mount structure gets modified to indicate that quotas are off
766
 * AFTER this, in the case of quotaoff.
767 768 769 770 771 772 773
 */
void
xfs_qm_dqrele_all_inodes(
	struct xfs_mount *mp,
	uint		 flags)
{
	ASSERT(mp->m_quotainfo);
774
	xfs_inode_ag_iterator(mp, xfs_dqrele_inode, flags, NULL);
L
Linus Torvalds 已提交
775
}