fs/ufs/quota.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */


#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
 * Code pertaining to management of the in-core data structures.
 */
#include <sys/types.h>
#include <sys/t_lock.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/signal.h>
#include <sys/errno.h>
#include <sys/user.h>
#include <sys/proc.h>
#include <sys/vfs.h>
#include <sys/vnode.h>
#include <sys/uio.h>
#include <sys/buf.h>
#include <sys/fs/ufs_fs.h>
#include <sys/fs/ufs_inode.h>
#include <sys/fs/ufs_quota.h>
#include <sys/cmn_err.h>
#include <sys/kmem.h>
#include <sys/debug.h>
#include <sys/file.h>
#include <sys/fs/ufs_panic.h>
#include <sys/var.h>


/*
 * Dquot in core hash chain headers
 */
struct	dqhead	dqhead[NDQHASH];

static kmutex_t dq_cachelock;
static kmutex_t dq_freelock;

krwlock_t dq_rwlock;

/*
 * Dquot free list.
 */
struct dquot dqfreelist;

#define	dqinsheadfree(DQP) { \
	mutex_enter(&dq_freelock); \
	(DQP)->dq_freef = dqfreelist.dq_freef; \
	(DQP)->dq_freeb = &dqfreelist; \
	dqfreelist.dq_freef->dq_freeb = (DQP); \
	dqfreelist.dq_freef = (DQP); \
	mutex_exit(&dq_freelock); \
}

#define	dqinstailfree(DQP) { \
	mutex_enter(&dq_freelock); \
	(DQP)->dq_freeb = dqfreelist.dq_freeb; \
	(DQP)->dq_freef = &dqfreelist; \
	dqfreelist.dq_freeb->dq_freef = (DQP); \
	dqfreelist.dq_freeb = (DQP); \
	mutex_exit(&dq_freelock); \
}

/* (clear pointers to make sure we don't use them; catch problems early) */
#define	dqremfree(DQP) { \
	(DQP)->dq_freeb->dq_freef = (DQP)->dq_freef; \
	(DQP)->dq_freef->dq_freeb = (DQP)->dq_freeb; \
	(DQP)->dq_freef = (DQP)->dq_freeb = NULL; \
}

typedef	struct dquot *DQptr;

/*
 * Initialize quota sub-system init lock.
 */
void
qtinit()
{
	rw_init(&dq_rwlock, NULL, RW_DEFAULT, NULL);
}

/*
 * qtinit2 allocated space for the quota structures.  Only do this if
 * if quotas are going to be used so that we can save the space if quotas
 * aren't used.
 */
void
qtinit2(void)
{
	register struct dqhead *dhp;
	register struct dquot *dqp;

	ASSERT(RW_WRITE_HELD(&dq_rwlock));

	if (ndquot == 0)
		ndquot = ((maxusers * NMOUNT) / 4) + v.v_proc;

	dquot = kmem_zalloc(ndquot * sizeof (struct dquot), KM_SLEEP);
	dquotNDQUOT = dquot + ndquot;

	/*
	 * Initialize the cache between the in-core structures
	 * and the per-file system quota files on disk.
	 */
	for (dhp = &dqhead[0]; dhp < &dqhead[NDQHASH]; dhp++) {
		dhp->dqh_forw = dhp->dqh_back = (DQptr)dhp;
	}
	dqfreelist.dq_freef = dqfreelist.dq_freeb = (DQptr)&dqfreelist;
	for (dqp = dquot; dqp < dquotNDQUOT; dqp++) {
		mutex_init(&dqp->dq_lock, NULL, MUTEX_DEFAULT, NULL);
		dqp->dq_forw = dqp->dq_back = dqp;
		dqinsheadfree(dqp);
	}
}

/*
 * Obtain the user's on-disk quota limit for file system specified.
 * dqpp is returned locked.
 */
int
getdiskquota(
	uid_t uid,
	struct ufsvfs *ufsvfsp,
	int force,			/* don't do enable checks */
	struct dquot **dqpp)		/* resulting dquot ptr */
{
	struct dquot *dqp;
	struct dqhead *dhp;
	struct inode *qip;
	int error;
	extern struct cred *kcred;
	daddr_t	bn;
	int contig;
	int err;

	ASSERT(RW_LOCK_HELD(&ufsvfsp->vfs_dqrwlock));

	dhp = &dqhead[DQHASH(uid, ufsvfsp)];
loop:
	/*
	 * Check for quotas enabled.
	 */
	if ((ufsvfsp->vfs_qflags & MQ_ENABLED) == 0 && !force)
		return (ESRCH);
	qip = ufsvfsp->vfs_qinod;
	if (!qip)
		return (ufs_fault(ufsvfsp->vfs_root, "getdiskquota: NULL qip"));
	/*
	 * Check the cache first.
	 */
	mutex_enter(&dq_cachelock);
	for (dqp = dhp->dqh_forw; dqp != (DQptr)dhp; dqp = dqp->dq_forw) {
		if (dqp->dq_uid != uid || dqp->dq_ufsvfsp != ufsvfsp)
			continue;
		mutex_exit(&dq_cachelock);
		mutex_enter(&dqp->dq_lock);
		/*
		 * I may have slept in the mutex_enter.  Make sure this is
		 * still the one I want.
		 */
		if (dqp->dq_uid != uid || dqp->dq_ufsvfsp != ufsvfsp) {
			mutex_exit(&dqp->dq_lock);
			goto loop;
		}
		if (dqp->dq_flags & DQ_ERROR) {
			mutex_exit(&dqp->dq_lock);
			return (EINVAL);
		}
		/*
		 * Cache hit with no references.
		 * Take the structure off the free list.
		 */
		if (dqp->dq_cnt == 0) {
			mutex_enter(&dq_freelock);
			dqremfree(dqp);
			mutex_exit(&dq_freelock);
		}
		dqp->dq_cnt++;
		mutex_exit(&dqp->dq_lock);
		*dqpp = dqp;
		return (0);
	}
	/*
	 * Not in cache.
	 * Get dquot at head of free list.
	 */
	mutex_enter(&dq_freelock);
	if ((dqp = dqfreelist.dq_freef) == &dqfreelist) {
		mutex_exit(&dq_freelock);
		mutex_exit(&dq_cachelock);
		cmn_err(CE_WARN, "dquot table full");
		return (EUSERS);
	}

	if (dqp->dq_cnt != 0 || dqp->dq_flags != 0) {
		panic("getdiskquota: dqp->dq_cnt: "
		    "%ld != 0 || dqp->dq_flags: 0x%x != 0 (%s)",
		    dqp->dq_cnt, dqp->dq_flags, qip->i_fs->fs_fsmnt);
		/*NOTREACHED*/
	}
	/*
	 * Take it off the free list, and off the hash chain it was on.
	 * Then put it on the new hash chain.
	 */
	dqremfree(dqp);
	mutex_exit(&dq_freelock);
	remque(dqp);
	dqp->dq_cnt = 1;
	dqp->dq_uid = uid;
	dqp->dq_ufsvfsp = ufsvfsp;
	dqp->dq_mof = UFS_HOLE;
	mutex_enter(&dqp->dq_lock);
	insque(dqp, dhp);
	mutex_exit(&dq_cachelock);
	/*
	 * Check the uid in case it's too large to fit into the 2Gbyte
	 * 'quotas' file (higher than 67 million or so).
	 */

	/*
	 * Large Files: i_size need to be accessed atomically now.
	 */
	rw_enter(&qip->i_contents, RW_READER);
	if (uid >= 0 && dqoff(uid) >= 0 && dqoff(uid) < qip->i_size) {
		/*
		 * This could almost be a static comparison with UID_MAX,
		 * but we keep the ASSERT here to document the restriction
		 * inherent in this simplistic database.
		 */
		ASSERT((u_offset_t)uid <
		    UFS_MAXOFFSET_T / sizeof (struct dqblk));

		/*
		 * Read quota info off disk.
		 */
		error = ufs_rdwri(UIO_READ, FREAD, qip, (caddr_t)&dqp->dq_dqb,
		    sizeof (struct dqblk), dqoff(uid), UIO_SYSSPACE,
		    (int *)NULL, kcred);
		/*
		 * We must set the dq_mof even if not we are not logging in case
		 * we are later remount to logging.
		 */
		err = bmap_read(qip, dqoff(uid), &bn, &contig);
		rw_exit(&qip->i_contents);
		if ((bn != UFS_HOLE) && !err) {
			dqp->dq_mof = ldbtob(bn) +
			(offset_t)(dqoff(uid) & (DEV_BSIZE - 1));
		} else {
			dqp->dq_mof = UFS_HOLE;
		}
		if (error) {
			/*
			 * I/O error in reading quota file.
			 * Put dquot on a private, unfindable hash list,
			 * put dquot at the head of the free list and
			 * reflect the problem to caller.
			 */
			dqp->dq_flags = DQ_ERROR;
			/*
			 * I must exit the dq_lock so that I can acquire the
			 * dq_cachelock.  If another thread finds dqp before
			 * I remove it from the cache it will see the
			 * DQ_ERROR and just return EIO.
			 */
			mutex_exit(&dqp->dq_lock);
			mutex_enter(&dq_cachelock);
			mutex_enter(&dqp->dq_lock);
			remque(dqp);
			mutex_exit(&dqp->dq_lock);
			mutex_exit(&dq_cachelock);
			/*
			 * Don't bother reacquiring dq_lock because the dq is
			 * not on the freelist or in the cache so only I have
			 * access to it.
			 */
			dqp->dq_cnt = 0;
			dqp->dq_ufsvfsp = NULL;
			dqp->dq_forw = dqp;
			dqp->dq_back = dqp;
			dqp->dq_mof = UFS_HOLE;
			dqp->dq_flags = 0;
			dqinsheadfree(dqp);
			return (EIO);
		}
	} else {
		rw_exit(&qip->i_contents);	/* done with i_size */
		bzero(&dqp->dq_dqb, sizeof (struct dqblk));
		dqp->dq_mof = UFS_HOLE;
	}
	mutex_exit(&dqp->dq_lock);
	*dqpp = dqp;
	return (0);
}

/*
 * Release dquot.
 */
void
dqput(dqp)
	register struct dquot *dqp;
{

	ASSERT(dqp->dq_ufsvfsp == NULL ||
		RW_LOCK_HELD(&dqp->dq_ufsvfsp->vfs_dqrwlock));
	ASSERT(MUTEX_HELD(&dqp->dq_lock));
	if (dqp->dq_cnt == 0) {
		(void) ufs_fault(
			dqp->dq_ufsvfsp && dqp->dq_ufsvfsp->vfs_root?
			dqp->dq_ufsvfsp->vfs_root: NULL,
						    "dqput: dqp->dq_cnt == 0");
		return;
	}
	if (--dqp->dq_cnt == 0) {
		if (dqp->dq_flags & DQ_MOD)
			dqupdate(dqp);
		/*
		 * DQ_MOD was cleared by dqupdate().
		 * DQ_ERROR shouldn't be set if this dquot was being used.
		 * DQ_FILES/DQ_BLKS don't matter at this point.
		 */
		dqp->dq_flags = 0;
		if (dqp->dq_ufsvfsp == NULL ||
		    dqp->dq_ufsvfsp->vfs_qflags == 0) {
			/* quotas are disabled, discard this dquot struct */
			dqinval(dqp);
		} else
			dqinstailfree(dqp);
	}
}

/*
 * Update on disk quota info.
 */
void
dqupdate(dqp)
	register struct dquot *dqp;
{
	register struct inode *qip;
	extern struct cred *kcred;
	struct ufsvfs	*ufsvfsp;
	int		newtrans	= 0;
	struct vnode	*vfs_root;

	ASSERT(MUTEX_HELD(&dqp->dq_lock));

	if (!dqp->dq_ufsvfsp) {
		(void) ufs_fault(NULL, "dqupdate: NULL dq_ufsvfsp");
		return;
	}
	vfs_root = dqp->dq_ufsvfsp->vfs_root;
	if (!vfs_root) {
		(void) ufs_fault(NULL, "dqupdate: NULL vfs_root");
		return;
	}
	/*
	 * I don't need to hold dq_rwlock when looking at vfs_qinod here
	 * because vfs_qinod is only cleared by closedq after it has called
	 * dqput on all dq's.  Since I am holding dq_lock on this dq, closedq
	 * will have to wait until I am done before it can call dqput on
	 * this dq so vfs_qinod will not change value until after I return.
	 */
	qip = dqp->dq_ufsvfsp->vfs_qinod;
	if (!qip) {
		(void) ufs_fault(vfs_root, "dqupdate: NULL vfs_qinod");
		return;
	}
	ufsvfsp = qip->i_ufsvfs;
	if (!ufsvfsp) {
		(void) ufs_fault(vfs_root,
				    "dqupdate: NULL vfs_qinod->i_ufsvfs");
		return;
	}
	if (ufsvfsp != dqp->dq_ufsvfsp) {
		(void) ufs_fault(vfs_root,
			    "dqupdate: vfs_qinod->i_ufsvfs != dqp->dq_ufsvfsp");
		return;
	}
	if (!(dqp->dq_flags & DQ_MOD)) {
		(void) ufs_fault(vfs_root,
				    "dqupdate: !(dqp->dq_flags & DQ_MOD)");
		return;
	}

	if (!(curthread->t_flag & T_DONTBLOCK)) {
		newtrans++;
		curthread->t_flag |= T_DONTBLOCK;
		TRANS_BEGIN_ASYNC(ufsvfsp, TOP_QUOTA, TOP_QUOTA_SIZE);
	}
	if (TRANS_ISTRANS(ufsvfsp)) {
		TRANS_DELTA(ufsvfsp, dqp->dq_mof, sizeof (struct dqblk),
		    DT_QR, 0, 0);
		TRANS_LOG(ufsvfsp, (caddr_t)&dqp->dq_dqb, dqp->dq_mof,
		    (int)(sizeof (struct dqblk)), NULL, 0);
	} else {
		/*
		 * Locknest gets very confused when I lock the quota inode.
		 * It thinks that qip and ip (the inode that caused the
		 * quota routines to get called) are the same inode.
		 */
		rw_enter(&qip->i_contents, RW_WRITER);
		/*
		 * refuse to push if offset would be illegal
		 */
		if (dqoff(dqp->dq_uid) >= 0) {
			(void) ufs_rdwri(UIO_WRITE, FWRITE, qip,
					(caddr_t)&dqp->dq_dqb,
					sizeof (struct dqblk),
					dqoff(dqp->dq_uid), UIO_SYSSPACE,
					(int *)NULL, kcred);
		}
		rw_exit(&qip->i_contents);
	}

	dqp->dq_flags &= ~DQ_MOD;
	if (newtrans) {
		TRANS_END_ASYNC(ufsvfsp, TOP_QUOTA, TOP_QUOTA_SIZE);
		curthread->t_flag &= ~T_DONTBLOCK;
	}
}

/*
 * Invalidate a dquot.  This function is called when quotas are disabled
 * for a specific file system via closedq() or when we unmount the file
 * system and invalidate the quota cache via invalidatedq().
 *
 * Take the dquot off its hash list and put it on a private, unfindable
 * hash list (refers to itself). Also, put it at the head of the free list.
 * Note that even though dq_cnt is zero, this dquot is NOT yet on the
 * freelist.
 */
void
dqinval(dqp)
	register struct dquot *dqp;
{
	ASSERT(MUTEX_HELD(&dqp->dq_lock));
	ASSERT(dqp->dq_cnt == 0);
	ASSERT(dqp->dq_flags == 0);
	ASSERT(dqp->dq_freef == NULL && dqp->dq_freeb == NULL);
	ASSERT(dqp->dq_ufsvfsp &&
		(dqp->dq_ufsvfsp->vfs_qflags & MQ_ENABLED) == 0);

	/*
	 * To preserve lock order, we have to drop dq_lock in order to
	 * grab dq_cachelock.  To prevent someone from grabbing this
	 * dquot from the quota cache via getdiskquota() while we are
	 * "unsafe", we clear dq_ufsvfsp so it won't match anything.
	 */
	dqp->dq_ufsvfsp = NULL;
	mutex_exit(&dqp->dq_lock);
	mutex_enter(&dq_cachelock);
	mutex_enter(&dqp->dq_lock);

	/*
	 * The following paranoia is to make sure that getdiskquota()
	 * has not been broken:
	 */
	ASSERT(dqp->dq_cnt == 0);
	ASSERT(dqp->dq_flags == 0);
	ASSERT(dqp->dq_freef == NULL && dqp->dq_freeb == NULL);
	ASSERT(dqp->dq_ufsvfsp == NULL);

	/*
	 * Now we have the locks in the right order so we can do the
	 * rest of the work.
	 */
	remque(dqp);
	mutex_exit(&dq_cachelock);
	dqp->dq_forw = dqp;
	dqp->dq_back = dqp;
	dqinsheadfree(dqp);
}

/*
 * Invalidate all quota information records for the specified file system.
 */
void
invalidatedq(ufsvfsp)
	register struct ufsvfs *ufsvfsp;
{
	register struct dquot *dqp;


	/*
	 * If quotas are not initialized, then there is nothing to do.
	 */
	rw_enter(&dq_rwlock, RW_READER);
	if (!quotas_initialized) {
		rw_exit(&dq_rwlock);
		return;
	}
	rw_exit(&dq_rwlock);


	rw_enter(&ufsvfsp->vfs_dqrwlock, RW_WRITER);

	ASSERT((ufsvfsp->vfs_qflags & MQ_ENABLED) == 0);

	/*
	 * Invalidate all the quota info records for this file system
	 * that are in the quota cache:
	 */
	for (dqp = dquot; dqp < dquotNDQUOT; dqp++) {
		/*
		 * If someone else has it, then ignore it. For the target
		 * file system, this is okay for three reasons:
		 *
		 * 1) This routine is called after closedq() so the quota
		 *    sub-system is disabled for this file system.
		 * 2) We have made the quota sub-system quiescent for
		 *    this file system.
		 * 3) We are in the process of unmounting this file
		 *    system so the quota sub-system can't be enabled
		 *    for it.
		 */
		if (!mutex_tryenter(&dqp->dq_lock)) {
			continue;
		}


		/*
		 * At this point, any quota info records that are
		 * associated with the target file system, should have a
		 * reference count of zero and be on the free list.
		 * Why? Because these quota info records went to a zero
		 * dq_cnt (via dqput()) before the file system was
		 * unmounted and are waiting to be found in the quota
		 * cache and reused (via getdiskquota()). The exception
		 * is when a quota transaction is sitting in the deltamap,
		 * indicated by DQ_TRANS being set in dq_flags.
		 * This causes a reference to be held on the quota
		 * information record and it will only be cleared once
		 * the transaction has reached the log. If we find
		 * any of these - we ignore them and let logging do
		 * the right thing.
		 */
		if (dqp->dq_ufsvfsp == ufsvfsp) {
			ASSERT(dqp->dq_cnt == 0 || (dqp->dq_cnt == 1 &&
			    (dqp->dq_flags & DQ_TRANS)));

			/* Cope with those orphaned dquots. */
			if (dqp->dq_cnt == 1 && (dqp->dq_flags & DQ_TRANS)) {
				mutex_exit(&dqp->dq_lock);
				continue;
			}

			ASSERT(dqp->dq_cnt == 0);
			ASSERT(dqp->dq_freef && dqp->dq_freeb);

			/*
			 * Take the quota info record off the free list
			 * so dqinval() can do its job (and put it on the
			 * front of the free list).
			 */
			mutex_enter(&dq_freelock);
			dqremfree(dqp);
			mutex_exit(&dq_freelock);
			dqinval(dqp);
		}

		mutex_exit(&dqp->dq_lock);
	}
	rw_exit(&ufsvfsp->vfs_dqrwlock);
}