xfs_qm_syscalls.c 20.6 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
2 3
 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
 * All Rights Reserved.
Linus Torvalds's avatar
Linus Torvalds committed
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
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
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
Linus Torvalds's avatar
Linus Torvalds committed
17
 */
18 19 20

#include <linux/capability.h>

Linus Torvalds's avatar
Linus Torvalds committed
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"
Linus Torvalds's avatar
Linus Torvalds committed
28 29 30
#include "xfs_sb.h"
#include "xfs_mount.h"
#include "xfs_inode.h"
31
#include "xfs_trans.h"
Linus Torvalds's avatar
Linus Torvalds committed
32
#include "xfs_error.h"
33
#include "xfs_quota.h"
Linus Torvalds's avatar
Linus Torvalds committed
34
#include "xfs_qm.h"
35
#include "xfs_trace.h"
36
#include "xfs_icache.h"
Linus Torvalds's avatar
Linus Torvalds committed
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
Linus Torvalds's avatar
Linus Torvalds committed
51 52
xfs_qm_scall_quotaoff(
	xfs_mount_t		*mp,
53
	uint			flags)
Linus Torvalds's avatar
Linus Torvalds committed
54
{
55
	struct xfs_quotainfo	*q = mp->m_quotainfo;
Linus Torvalds's avatar
Linus Torvalds committed
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_
64
	 * errno == -EEXIST here.
Linus Torvalds's avatar
Linus Torvalds committed
65 66
	 */
	if ((mp->m_qflags & flags) == 0)
67
		return -EEXIST;
Linus Torvalds's avatar
Linus Torvalds committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
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);

Eric Sandeen's avatar
Eric Sandeen committed
87
		spin_lock(&mp->m_sb_lock);
Linus Torvalds's avatar
Linus Torvalds committed
88
		mp->m_sb.sb_qflags = mp->m_qflags;
Eric Sandeen's avatar
Eric Sandeen committed
89
		spin_unlock(&mp->m_sb_lock);
90
		mutex_unlock(&q->qi_quotaofflock);
Linus Torvalds's avatar
Linus Torvalds committed
91 92

		/* XXX what to do if error ? Revert back to old vals incore ? */
93
		return xfs_sync_sb(mp, false);
Linus Torvalds's avatar
Linus Torvalds committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
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;
Linus Torvalds's avatar
Linus Torvalds committed
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.
Linus Torvalds's avatar
Linus Torvalds committed
130
	 */
131 132
	error = xfs_qm_log_quotaoff(mp, &qoffstart, flags);
	if (error)
133
		goto out_unlock;
Linus Torvalds's avatar
Linus Torvalds committed
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
163
	 * don't want to take a mrlock every time we depend on quotas being on.
Linus Torvalds's avatar
Linus Torvalds committed
164
	 */
165
	mp->m_qflags &= ~flags;
Linus Torvalds's avatar
Linus Torvalds committed
166 167 168

	/*
	 * Go through all the dquots of this file system and purge them,
169
	 * according to what was turned off.
Linus Torvalds's avatar
Linus Torvalds committed
170
	 */
171
	xfs_qm_dqpurge_all(mp, dqtype);
Linus Torvalds's avatar
Linus Torvalds committed
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
	}
Linus Torvalds's avatar
Linus Torvalds committed
190 191

	/*
192
	 * If all quotas are completely turned off, close shop.
Linus Torvalds's avatar
Linus Torvalds committed
193
	 */
194
	if (mp->m_qflags == 0) {
195
		mutex_unlock(&q->qi_quotaofflock);
Linus Torvalds's avatar
Linus Torvalds committed
196
		xfs_qm_destroy_quotainfo(mp);
197
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
198 199 200
	}

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

216 217 218
out_unlock:
	mutex_unlock(&q->qi_quotaofflock);
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
219 220
}

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

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

	xfs_ilock(ip, XFS_ILOCK_EXCL);
246
	xfs_trans_ijoin(tp, ip, 0);
247

248 249 250 251
	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);
252
	if (error) {
253
		xfs_trans_cancel(tp);
254 255 256
		goto out_unlock;
	}

257 258
	ASSERT(ip->i_d.di_nextents == 0);

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

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

269
int
Linus Torvalds's avatar
Linus Torvalds committed
270 271 272 273
xfs_qm_scall_trunc_qfiles(
	xfs_mount_t	*mp,
	uint		flags)
{
274
	int		error = -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
275

276 277
	if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0 ||
	    (flags & ~XFS_DQ_ALLTYPES)) {
278
		xfs_debug(mp, "%s: flags=%x m_qflags=%x",
279
			__func__, flags, mp->m_qflags);
280
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
281 282
	}

283
	if (flags & XFS_DQ_USER) {
284
		error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_uquotino);
285 286 287 288 289 290 291 292
		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;
	}
293
	if (flags & XFS_DQ_PROJ)
294
		error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_pquotino);
Linus Torvalds's avatar
Linus Torvalds committed
295

296
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
297 298 299 300 301 302 303
}

/*
 * Switch on (a given) quota enforcement for a filesystem.  This takes
 * effect immediately.
 * (Switching on quota accounting must be done at mount time.)
 */
304
int
Linus Torvalds's avatar
Linus Torvalds committed
305 306 307 308 309 310 311 312 313 314 315 316 317 318
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) {
319
		xfs_debug(mp, "%s: zero flags, m_qflags=%x",
320
			__func__, mp->m_qflags);
321
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
322 323 324 325 326 327 328
	}

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

	/*
	 * Change sb_qflags on disk but not incore mp->qflags
	 * if this is the root filesystem.
	 */
Eric Sandeen's avatar
Eric Sandeen committed
350
	spin_lock(&mp->m_sb_lock);
Linus Torvalds's avatar
Linus Torvalds committed
351 352
	qf = mp->m_sb.sb_qflags;
	mp->m_sb.sb_qflags = qf | flags;
Eric Sandeen's avatar
Eric Sandeen committed
353
	spin_unlock(&mp->m_sb_lock);
Linus Torvalds's avatar
Linus Torvalds committed
354 355 356 357

	/*
	 * There's nothing to change if it's the same.
	 */
358
	if ((qf & flags) == flags)
359
		return -EEXIST;
Linus Torvalds's avatar
Linus Torvalds committed
360

361 362
	error = xfs_sync_sb(mp, false);
	if (error)
363
		return error;
Linus Torvalds's avatar
Linus Torvalds committed
364 365 366 367 368
	/*
	 * 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)) ||
369 370 371
	     ((mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) !=
	     (mp->m_qflags & XFS_PQUOTA_ACCT)) ||
	     ((mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) !=
372
	     (mp->m_qflags & XFS_GQUOTA_ACCT)))
373
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
374 375

	if (! XFS_IS_QUOTA_RUNNING(mp))
376
		return -ESRCH;
Linus Torvalds's avatar
Linus Torvalds committed
377 378 379 380

	/*
	 * Switch on quota enforcement in core.
	 */
381
	mutex_lock(&mp->m_quotainfo->qi_quotaofflock);
Linus Torvalds's avatar
Linus Torvalds committed
382
	mp->m_qflags |= (flags & XFS_ALL_QUOTA_ENFD);
383
	mutex_unlock(&mp->m_quotainfo->qi_quotaofflock);
Linus Torvalds's avatar
Linus Torvalds committed
384

385
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
386 387
}

388 389
#define XFS_QC_MASK \
	(QC_LIMIT_MASK | QC_TIMER_MASK | QC_WARNS_MASK)
390

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

409
	if (newlim->d_fieldmask & ~XFS_QC_MASK)
410
		return -EINVAL;
411
	if ((newlim->d_fieldmask & XFS_QC_MASK) == 0)
412
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
413 414 415

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

	/*
422 423 424 425 426
	 * 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.
Linus Torvalds's avatar
Linus Torvalds committed
427
	 */
428 429
	error = xfs_qm_dqget(mp, NULL, id, type, XFS_QMOPT_DQALLOC, &dqp);
	if (error) {
430
		ASSERT(error != -ENOENT);
431
		goto out_unlock;
Linus Torvalds's avatar
Linus Torvalds committed
432
	}
433 434

	defq = xfs_get_defquota(dqp, q);
435 436
	xfs_dqunlock(dqp);

437 438
	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_qm_setqlim, 0, 0, 0, &tp);
	if (error)
439 440 441
		goto out_rele;

	xfs_dqlock(dqp);
Linus Torvalds's avatar
Linus Torvalds committed
442 443 444 445 446 447
	xfs_trans_dqjoin(tp, dqp);
	ddq = &dqp->q_core;

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

482
	hard = (newlim->d_fieldmask & QC_INO_HARD) ?
Linus Torvalds's avatar
Linus Torvalds committed
483
		(xfs_qcnt_t) newlim->d_ino_hardlimit :
484
			be64_to_cpu(ddq->d_ino_hardlimit);
485
	soft = (newlim->d_fieldmask & QC_INO_SOFT) ?
Linus Torvalds's avatar
Linus Torvalds committed
486
		(xfs_qcnt_t) newlim->d_ino_softlimit :
487
			be64_to_cpu(ddq->d_ino_softlimit);
Linus Torvalds's avatar
Linus Torvalds committed
488
	if (hard == 0 || hard >= soft) {
489 490
		ddq->d_ino_hardlimit = cpu_to_be64(hard);
		ddq->d_ino_softlimit = cpu_to_be64(soft);
Linus Torvalds's avatar
Linus Torvalds committed
491
		if (id == 0) {
492 493
			defq->ihardlimit = hard;
			defq->isoftlimit = soft;
Linus Torvalds's avatar
Linus Torvalds committed
494 495
		}
	} else {
496
		xfs_debug(mp, "ihard %Ld < isoft %Ld", hard, soft);
Linus Torvalds's avatar
Linus Torvalds committed
497 498
	}

499 500 501
	/*
	 * Update warnings counter(s) if requested
	 */
502 503 504 505 506 507
	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);
508

Linus Torvalds's avatar
Linus Torvalds committed
509 510 511 512 513
	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
514 515
		 * soft and hard limit values (already done, above), and
		 * for warnings.
Linus Torvalds's avatar
Linus Torvalds committed
516
		 */
517 518 519
		if (newlim->d_fieldmask & QC_SPC_TIMER) {
			q->qi_btimelimit = newlim->d_spc_timer;
			ddq->d_btimer = cpu_to_be32(newlim->d_spc_timer);
Linus Torvalds's avatar
Linus Torvalds committed
520
		}
521 522 523
		if (newlim->d_fieldmask & QC_INO_TIMER) {
			q->qi_itimelimit = newlim->d_ino_timer;
			ddq->d_itimer = cpu_to_be32(newlim->d_ino_timer);
Linus Torvalds's avatar
Linus Torvalds committed
524
		}
525 526 527
		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);
Linus Torvalds's avatar
Linus Torvalds committed
528
		}
529 530 531 532 533 534
		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;
535
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
536 537 538 539 540 541 542 543 544 545 546 547
		/*
		 * 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);

548
	error = xfs_trans_commit(tp);
Linus Torvalds's avatar
Linus Torvalds committed
549

550 551 552
out_rele:
	xfs_qm_dqrele(dqp);
out_unlock:
553
	mutex_unlock(&q->qi_quotaofflock);
554
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
555 556 557 558 559 560 561 562
}

STATIC int
xfs_qm_log_quotaoff_end(
	xfs_mount_t		*mp,
	xfs_qoff_logitem_t	*startqoff,
	uint			flags)
{
563
	xfs_trans_t		*tp;
Linus Torvalds's avatar
Linus Torvalds committed
564
	int			error;
565
	xfs_qoff_logitem_t	*qoffi;
Linus Torvalds's avatar
Linus Torvalds committed
566

567 568
	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_qm_equotaoff, 0, 0, 0, &tp);
	if (error)
569
		return error;
Linus Torvalds's avatar
Linus Torvalds committed
570 571 572 573 574 575 576 577 578 579 580

	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);
581
	return xfs_trans_commit(tp);
Linus Torvalds's avatar
Linus Torvalds committed
582 583 584 585 586 587 588 589 590 591 592
}


STATIC int
xfs_qm_log_quotaoff(
	xfs_mount_t	       *mp,
	xfs_qoff_logitem_t     **qoffstartp,
	uint		       flags)
{
	xfs_trans_t	       *tp;
	int			error;
593 594 595
	xfs_qoff_logitem_t     *qoffi;

	*qoffstartp = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
596

597 598
	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_qm_quotaoff, 0, 0, 0, &tp);
	if (error)
599
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
600 601 602 603

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

Eric Sandeen's avatar
Eric Sandeen committed
604
	spin_lock(&mp->m_sb_lock);
Linus Torvalds's avatar
Linus Torvalds committed
605
	mp->m_sb.sb_qflags = (mp->m_qflags & ~(flags)) & XFS_MOUNT_QUOTA_ALL;
Eric Sandeen's avatar
Eric Sandeen committed
606
	spin_unlock(&mp->m_sb_lock);
Linus Torvalds's avatar
Linus Torvalds committed
607

608
	xfs_log_sb(tp);
Linus Torvalds's avatar
Linus Torvalds committed
609 610 611 612 613 614 615

	/*
	 * 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);
616
	error = xfs_trans_commit(tp);
617 618
	if (error)
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
619 620

	*qoffstartp = qoffi;
621
out:
622
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
623 624 625
}


626 627 628
int
xfs_qm_scall_getquota(
	struct xfs_mount	*mp,
629
	xfs_dqid_t		*id,
630
	uint			type,
631 632
	struct qc_dqblk		*dst,
	uint			dqget_flags)
Linus Torvalds's avatar
Linus Torvalds committed
633
{
634 635 636 637 638 639 640 641
	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.
	 */
642
	error = xfs_qm_dqget(mp, NULL, *id, type, dqget_flags, &dqp);
643 644 645 646 647 648 649 650
	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)) {
651
		error = -ENOENT;
652 653 654
		goto out_put;
	}

655 656 657
	/* Fill in the ID we actually read from disk */
	*id = be32_to_cpu(dqp->q_core.d_id);

Linus Torvalds's avatar
Linus Torvalds committed
658
	memset(dst, 0, sizeof(*dst));
659 660 661 662
	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));
663 664
	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);
665 666 667 668 669 670 671 672 673 674 675 676 677
	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);
Linus Torvalds's avatar
Linus Torvalds committed
678 679 680

	/*
	 * Internally, we don't reset all the timers when quota enforcement
681
	 * gets turned off. No need to confuse the user level code,
Linus Torvalds's avatar
Linus Torvalds committed
682 683
	 * so return zeroes in that case.
	 */
684 685 686 687 688 689
	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)) {
690 691 692
		dst->d_spc_timer = 0;
		dst->d_ino_timer = 0;
		dst->d_rt_spc_timer = 0;
Linus Torvalds's avatar
Linus Torvalds committed
693 694 695
	}

#ifdef DEBUG
696 697 698
	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)) &&
699
	    *id != 0) {
700 701 702
		if ((dst->d_space > dst->d_spc_softlimit) &&
		    (dst->d_spc_softlimit > 0)) {
			ASSERT(dst->d_spc_timer != 0);
Linus Torvalds's avatar
Linus Torvalds committed
703
		}
704
		if ((dst->d_ino_count > dst->d_ino_softlimit) &&
Linus Torvalds's avatar
Linus Torvalds committed
705
		    (dst->d_ino_softlimit > 0)) {
706
			ASSERT(dst->d_ino_timer != 0);
Linus Torvalds's avatar
Linus Torvalds committed
707 708 709
		}
	}
#endif
710 711 712
out_put:
	xfs_qm_dqput(dqp);
	return error;
Linus Torvalds's avatar
Linus Torvalds committed
713 714 715
}


716 717 718
STATIC int
xfs_dqrele_inode(
	struct xfs_inode	*ip,
719 720
	int			flags,
	void			*args)
Linus Torvalds's avatar
Linus Torvalds committed
721
{
722
	/* skip quota inodes */
723
	if (ip == ip->i_mount->m_quotainfo->qi_uquotaip ||
724 725
	    ip == ip->i_mount->m_quotainfo->qi_gquotaip ||
	    ip == ip->i_mount->m_quotainfo->qi_pquotaip) {
726 727
		ASSERT(ip->i_udquot == NULL);
		ASSERT(ip->i_gdquot == NULL);
728
		ASSERT(ip->i_pdquot == NULL);
729 730
		return 0;
	}
731

732 733 734 735 736
	xfs_ilock(ip, XFS_ILOCK_EXCL);
	if ((flags & XFS_UQUOTA_ACCT) && ip->i_udquot) {
		xfs_qm_dqrele(ip->i_udquot);
		ip->i_udquot = NULL;
	}
737
	if ((flags & XFS_GQUOTA_ACCT) && ip->i_gdquot) {
738 739 740
		xfs_qm_dqrele(ip->i_gdquot);
		ip->i_gdquot = NULL;
	}
741 742 743 744
	if ((flags & XFS_PQUOTA_ACCT) && ip->i_pdquot) {
		xfs_qm_dqrele(ip->i_pdquot);
		ip->i_pdquot = NULL;
	}
Christoph Hellwig's avatar
Christoph Hellwig committed
745
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
746
	return 0;
747 748
}

749

750 751
/*
 * Go thru all the inodes in the file system, releasing their dquots.
752
 *
753
 * Note that the mount structure gets modified to indicate that quotas are off
754
 * AFTER this, in the case of quotaoff.
755 756 757 758 759 760 761
 */
void
xfs_qm_dqrele_all_inodes(
	struct xfs_mount *mp,
	uint		 flags)
{
	ASSERT(mp->m_quotainfo);
762 763
	xfs_inode_ag_iterator_flags(mp, xfs_dqrele_inode, flags, NULL,
				    XFS_AGITER_INEW_WAIT);
Linus Torvalds's avatar
Linus Torvalds committed
764
}