Home | History | Annotate | Line # | Download | only in lfs
ulfs_quota2.c revision 1.21
      1  1.21  dholland /*	$NetBSD: ulfs_quota2.c,v 1.21 2015/07/28 05:09:35 dholland Exp $	*/
      2   1.1  dholland /*  from NetBSD: ufs_quota2.c,v 1.35 2012/09/27 07:47:56 bouyer Exp  */
      3  1.10  dholland /*  from NetBSD: ffs_quota2.c,v 1.4 2011/06/12 03:36:00 rmind Exp  */
      4   1.1  dholland 
      5   1.1  dholland /*-
      6   1.1  dholland   * Copyright (c) 2010 Manuel Bouyer
      7   1.1  dholland   * All rights reserved.
      8   1.1  dholland   *
      9   1.1  dholland   * Redistribution and use in source and binary forms, with or without
     10   1.1  dholland   * modification, are permitted provided that the following conditions
     11   1.1  dholland   * are met:
     12   1.1  dholland   * 1. Redistributions of source code must retain the above copyright
     13   1.1  dholland   *    notice, this list of conditions and the following disclaimer.
     14   1.1  dholland   * 2. Redistributions in binary form must reproduce the above copyright
     15   1.1  dholland   *    notice, this list of conditions and the following disclaimer in the
     16   1.1  dholland   *    documentation and/or other materials provided with the distribution.
     17   1.1  dholland   *
     18   1.1  dholland   * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     19   1.1  dholland   * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     20   1.1  dholland   * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     21   1.1  dholland   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     22   1.1  dholland   * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     23   1.1  dholland   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     24   1.1  dholland   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     25   1.1  dholland   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     26   1.1  dholland   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     27   1.1  dholland   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     28   1.1  dholland   * POSSIBILITY OF SUCH DAMAGE.
     29   1.1  dholland   */
     30   1.1  dholland 
     31   1.1  dholland #include <sys/cdefs.h>
     32  1.21  dholland __KERNEL_RCSID(0, "$NetBSD: ulfs_quota2.c,v 1.21 2015/07/28 05:09:35 dholland Exp $");
     33   1.1  dholland 
     34   1.1  dholland #include <sys/buf.h>
     35   1.1  dholland #include <sys/param.h>
     36   1.1  dholland #include <sys/kernel.h>
     37   1.1  dholland #include <sys/systm.h>
     38   1.1  dholland #include <sys/namei.h>
     39   1.1  dholland #include <sys/file.h>
     40   1.1  dholland #include <sys/proc.h>
     41   1.1  dholland #include <sys/vnode.h>
     42   1.1  dholland #include <sys/mount.h>
     43   1.1  dholland #include <sys/fstrans.h>
     44   1.1  dholland #include <sys/kauth.h>
     45   1.1  dholland #include <sys/wapbl.h>
     46   1.1  dholland #include <sys/quota.h>
     47   1.1  dholland #include <sys/quotactl.h>
     48   1.1  dholland 
     49  1.21  dholland #include <ufs/lfs/lfs.h>
     50  1.21  dholland #include <ufs/lfs/lfs_accessors.h>
     51   1.7  dholland #include <ufs/lfs/lfs_extern.h>
     52   1.7  dholland 
     53   1.2  dholland #include <ufs/lfs/ulfs_quota2.h>
     54   1.2  dholland #include <ufs/lfs/ulfs_inode.h>
     55   1.2  dholland #include <ufs/lfs/ulfsmount.h>
     56   1.2  dholland #include <ufs/lfs/ulfs_bswap.h>
     57   1.2  dholland #include <ufs/lfs/ulfs_extern.h>
     58   1.2  dholland #include <ufs/lfs/ulfs_quota.h>
     59   1.1  dholland 
     60   1.1  dholland /*
     61   1.1  dholland  * LOCKING:
     62   1.1  dholland  * Data in the entries are protected by the associated struct dquot's
     63   1.1  dholland  * dq_interlock (this means we can't read or change a quota entry without
     64   1.1  dholland  * grabing a dquot for it).
     65   1.1  dholland  * The header and lists (including pointers in the data entries, and q2e_uid)
     66   1.1  dholland  * are protected by the global dqlock.
     67   1.1  dholland  * the locking order is dq_interlock -> dqlock
     68   1.1  dholland  */
     69   1.1  dholland 
     70   1.1  dholland static int quota2_bwrite(struct mount *, struct buf *);
     71   1.1  dholland static int getinoquota2(struct inode *, bool, bool, struct buf **,
     72   1.1  dholland     struct quota2_entry **);
     73   1.4  dholland static int getq2h(struct ulfsmount *, int, struct buf **,
     74   1.1  dholland     struct quota2_header **, int);
     75   1.4  dholland static int getq2e(struct ulfsmount *, int, daddr_t, int, struct buf **,
     76   1.1  dholland     struct quota2_entry **, int);
     77   1.4  dholland static int quota2_walk_list(struct ulfsmount *, struct buf *, int,
     78   1.1  dholland     uint64_t *, int, void *,
     79   1.4  dholland     int (*func)(struct ulfsmount *, uint64_t *, struct quota2_entry *,
     80   1.1  dholland       uint64_t, void *));
     81   1.1  dholland 
     82   1.1  dholland static const char *limnames[] = INITQLNAMES;
     83   1.1  dholland 
     84   1.1  dholland static void
     85   1.1  dholland quota2_dict_update_q2e_limits(int objtype, const struct quotaval *val,
     86   1.1  dholland     struct quota2_entry *q2e)
     87   1.1  dholland {
     88   1.1  dholland 	/* make sure we can index q2e_val[] by the fs-independent objtype */
     89   1.1  dholland 	CTASSERT(QUOTA_OBJTYPE_BLOCKS == QL_BLOCK);
     90   1.1  dholland 	CTASSERT(QUOTA_OBJTYPE_FILES == QL_FILE);
     91   1.1  dholland 
     92   1.1  dholland 	q2e->q2e_val[objtype].q2v_hardlimit = val->qv_hardlimit;
     93   1.1  dholland 	q2e->q2e_val[objtype].q2v_softlimit = val->qv_softlimit;
     94   1.1  dholland 	q2e->q2e_val[objtype].q2v_grace = val->qv_grace;
     95   1.1  dholland }
     96   1.1  dholland 
     97   1.1  dholland /*
     98   1.1  dholland  * Convert internal representation to FS-independent representation.
     99   1.1  dholland  * (Note that while the two types are currently identical, the
    100   1.1  dholland  * internal representation is an on-disk struct and the FS-independent
    101   1.1  dholland  * representation is not, and they might diverge in the future.)
    102   1.1  dholland  */
    103   1.1  dholland static void
    104   1.1  dholland q2val_to_quotaval(struct quota2_val *q2v, struct quotaval *qv)
    105   1.1  dholland {
    106   1.1  dholland 	qv->qv_softlimit = q2v->q2v_softlimit;
    107   1.1  dholland 	qv->qv_hardlimit = q2v->q2v_hardlimit;
    108   1.1  dholland 	qv->qv_usage = q2v->q2v_cur;
    109   1.1  dholland 	qv->qv_expiretime = q2v->q2v_time;
    110   1.1  dholland 	qv->qv_grace = q2v->q2v_grace;
    111   1.1  dholland }
    112   1.1  dholland 
    113   1.1  dholland /*
    114   1.1  dholland  * Convert a quota2entry and default-flag to the FS-independent
    115   1.1  dholland  * representation.
    116   1.1  dholland  */
    117   1.1  dholland static void
    118   1.1  dholland q2e_to_quotaval(struct quota2_entry *q2e, int def,
    119   1.1  dholland 	       id_t *id, int objtype, struct quotaval *ret)
    120   1.1  dholland {
    121   1.1  dholland 	if (def) {
    122   1.1  dholland 		*id = QUOTA_DEFAULTID;
    123   1.1  dholland 	} else {
    124   1.1  dholland 		*id = q2e->q2e_uid;
    125   1.1  dholland 	}
    126   1.1  dholland 
    127   1.1  dholland 	KASSERT(objtype >= 0 && objtype < N_QL);
    128   1.1  dholland 	q2val_to_quotaval(&q2e->q2e_val[objtype], ret);
    129   1.1  dholland }
    130   1.1  dholland 
    131   1.1  dholland 
    132   1.1  dholland static int
    133   1.1  dholland quota2_bwrite(struct mount *mp, struct buf *bp)
    134   1.1  dholland {
    135   1.1  dholland 	if (mp->mnt_flag & MNT_SYNCHRONOUS)
    136   1.1  dholland 		return bwrite(bp);
    137   1.1  dholland 	else {
    138   1.1  dholland 		bdwrite(bp);
    139   1.1  dholland 		return 0;
    140   1.1  dholland 	}
    141   1.1  dholland }
    142   1.1  dholland 
    143   1.1  dholland static int
    144   1.4  dholland getq2h(struct ulfsmount *ump, int type,
    145   1.1  dholland     struct buf **bpp, struct quota2_header **q2hp, int flags)
    146   1.1  dholland {
    147   1.9  dholland 	struct lfs *fs = ump->um_lfs;
    148   1.9  dholland 	const int needswap = ULFS_MPNEEDSWAP(fs);
    149   1.1  dholland 	int error;
    150   1.1  dholland 	struct buf *bp;
    151   1.1  dholland 	struct quota2_header *q2h;
    152   1.1  dholland 
    153   1.5  dholland 	KASSERT(mutex_owned(&lfs_dqlock));
    154  1.18      maxv 	error = bread(ump->um_quotas[type], 0, ump->umq2_bsize, flags, &bp);
    155   1.1  dholland 	if (error)
    156   1.1  dholland 		return error;
    157   1.1  dholland 	if (bp->b_resid != 0)
    158   1.5  dholland 		panic("dq2get: %s quota file truncated", lfs_quotatypes[type]);
    159   1.1  dholland 
    160   1.1  dholland 	q2h = (void *)bp->b_data;
    161   1.4  dholland 	if (ulfs_rw32(q2h->q2h_magic_number, needswap) != Q2_HEAD_MAGIC ||
    162   1.1  dholland 	    q2h->q2h_type != type)
    163   1.5  dholland 		panic("dq2get: corrupted %s quota header", lfs_quotatypes[type]);
    164   1.1  dholland 	*bpp = bp;
    165   1.1  dholland 	*q2hp = q2h;
    166   1.1  dholland 	return 0;
    167   1.1  dholland }
    168   1.1  dholland 
    169   1.1  dholland static int
    170   1.4  dholland getq2e(struct ulfsmount *ump, int type, daddr_t lblkno, int blkoffset,
    171   1.1  dholland     struct buf **bpp, struct quota2_entry **q2ep, int flags)
    172   1.1  dholland {
    173   1.1  dholland 	int error;
    174   1.1  dholland 	struct buf *bp;
    175   1.1  dholland 
    176   1.1  dholland 	if (blkoffset & (sizeof(uint64_t) - 1)) {
    177   1.1  dholland 		panic("dq2get: %s quota file corrupted",
    178   1.5  dholland 		    lfs_quotatypes[type]);
    179   1.1  dholland 	}
    180  1.18      maxv 	error = bread(ump->um_quotas[type], lblkno, ump->umq2_bsize, flags, &bp);
    181   1.1  dholland 	if (error)
    182   1.1  dholland 		return error;
    183   1.1  dholland 	if (bp->b_resid != 0) {
    184   1.1  dholland 		panic("dq2get: %s quota file corrupted",
    185   1.5  dholland 		    lfs_quotatypes[type]);
    186   1.1  dholland 	}
    187   1.1  dholland 	*q2ep = (void *)((char *)bp->b_data + blkoffset);
    188   1.1  dholland 	*bpp = bp;
    189   1.1  dholland 	return 0;
    190   1.1  dholland }
    191   1.1  dholland 
    192   1.1  dholland /* walk a quota entry list, calling the callback for each entry */
    193   1.1  dholland #define Q2WL_ABORT 0x10000000
    194   1.1  dholland 
    195   1.1  dholland static int
    196   1.4  dholland quota2_walk_list(struct ulfsmount *ump, struct buf *hbp, int type,
    197   1.1  dholland     uint64_t *offp, int flags, void *a,
    198   1.4  dholland     int (*func)(struct ulfsmount *, uint64_t *, struct quota2_entry *, uint64_t, void *))
    199   1.1  dholland {
    200   1.9  dholland 	struct lfs *fs = ump->um_lfs;
    201   1.9  dholland 	const int needswap = ULFS_MPNEEDSWAP(fs);
    202   1.4  dholland 	daddr_t off = ulfs_rw64(*offp, needswap);
    203   1.1  dholland 	struct buf *bp, *obp = hbp;
    204   1.1  dholland 	int ret = 0, ret2 = 0;
    205   1.1  dholland 	struct quota2_entry *q2e;
    206   1.1  dholland 	daddr_t lblkno, blkoff, olblkno = 0;
    207   1.1  dholland 
    208   1.5  dholland 	KASSERT(mutex_owner(&lfs_dqlock));
    209   1.1  dholland 
    210   1.1  dholland 	while (off != 0) {
    211   1.1  dholland 		lblkno = (off >> ump->um_mountp->mnt_fs_bshift);
    212   1.1  dholland 		blkoff = (off & ump->umq2_bmask);
    213   1.1  dholland 		if (lblkno == 0) {
    214   1.1  dholland 			/* in the header block */
    215   1.1  dholland 			bp = hbp;
    216   1.1  dholland 		} else if (lblkno == olblkno) {
    217   1.1  dholland 			/* still in the same buf */
    218   1.1  dholland 			bp = obp;
    219   1.1  dholland 		} else {
    220   1.1  dholland 			ret = bread(ump->um_quotas[type], lblkno,
    221  1.18      maxv 			    ump->umq2_bsize, flags, &bp);
    222   1.1  dholland 			if (ret)
    223   1.1  dholland 				return ret;
    224   1.1  dholland 			if (bp->b_resid != 0) {
    225   1.1  dholland 				panic("quota2_walk_list: %s quota file corrupted",
    226   1.5  dholland 				    lfs_quotatypes[type]);
    227   1.1  dholland 			}
    228   1.1  dholland 		}
    229   1.1  dholland 		q2e = (void *)((char *)(bp->b_data) + blkoff);
    230   1.1  dholland 		ret = (*func)(ump, offp, q2e, off, a);
    231   1.4  dholland 		if (off != ulfs_rw64(*offp, needswap)) {
    232   1.1  dholland 			/* callback changed parent's pointer, redo */
    233   1.4  dholland 			off = ulfs_rw64(*offp, needswap);
    234   1.1  dholland 			if (bp != hbp && bp != obp)
    235   1.1  dholland 				ret2 = bwrite(bp);
    236   1.1  dholland 		} else {
    237   1.1  dholland 			/* parent if now current */
    238   1.1  dholland 			if (obp != bp && obp != hbp) {
    239   1.1  dholland 				if (flags & B_MODIFY)
    240   1.1  dholland 					ret2 = bwrite(obp);
    241   1.1  dholland 				else
    242   1.1  dholland 					brelse(obp, 0);
    243   1.1  dholland 			}
    244   1.1  dholland 			obp = bp;
    245   1.1  dholland 			olblkno = lblkno;
    246   1.1  dholland 			offp = &(q2e->q2e_next);
    247   1.4  dholland 			off = ulfs_rw64(*offp, needswap);
    248   1.1  dholland 		}
    249   1.1  dholland 		if (ret)
    250   1.1  dholland 			break;
    251   1.1  dholland 		if (ret2) {
    252   1.1  dholland 			ret = ret2;
    253   1.1  dholland 			break;
    254   1.1  dholland 		}
    255   1.1  dholland 	}
    256   1.1  dholland 	if (obp != hbp) {
    257   1.1  dholland 		if (flags & B_MODIFY)
    258   1.1  dholland 			ret2 = bwrite(obp);
    259   1.1  dholland 		else
    260   1.1  dholland 			brelse(obp, 0);
    261   1.1  dholland 	}
    262   1.1  dholland 	if (ret & Q2WL_ABORT)
    263   1.1  dholland 		return 0;
    264   1.1  dholland 	if (ret == 0)
    265   1.1  dholland 		return ret2;
    266   1.1  dholland 	return ret;
    267   1.1  dholland }
    268   1.1  dholland 
    269   1.1  dholland int
    270   1.5  dholland lfsquota2_umount(struct mount *mp, int flags)
    271   1.1  dholland {
    272   1.1  dholland 	int i, error;
    273   1.4  dholland 	struct ulfsmount *ump = VFSTOULFS(mp);
    274   1.9  dholland 	struct lfs *fs = ump->um_lfs;
    275   1.1  dholland 
    276   1.9  dholland 	if ((fs->um_flags & ULFS_QUOTA2) == 0)
    277   1.1  dholland 		return 0;
    278   1.1  dholland 
    279   1.4  dholland 	for (i = 0; i < ULFS_MAXQUOTAS; i++) {
    280   1.1  dholland 		if (ump->um_quotas[i] != NULLVP) {
    281   1.1  dholland 			error = vn_close(ump->um_quotas[i], FREAD|FWRITE,
    282   1.1  dholland 			    ump->um_cred[i]);
    283   1.1  dholland 			if (error) {
    284   1.1  dholland 				printf("quota2_umount failed: close(%p) %d\n",
    285   1.1  dholland 				    ump->um_quotas[i], error);
    286   1.1  dholland 				return error;
    287   1.1  dholland 			}
    288   1.1  dholland 		}
    289   1.1  dholland 		ump->um_quotas[i] = NULLVP;
    290   1.1  dholland 	}
    291   1.1  dholland 	return 0;
    292   1.1  dholland }
    293   1.1  dholland 
    294   1.1  dholland static int
    295   1.4  dholland quota2_q2ealloc(struct ulfsmount *ump, int type, uid_t uid, struct dquot *dq)
    296   1.1  dholland {
    297   1.1  dholland 	int error, error2;
    298   1.1  dholland 	struct buf *hbp, *bp;
    299   1.1  dholland 	struct quota2_header *q2h;
    300   1.1  dholland 	struct quota2_entry *q2e;
    301   1.1  dholland 	daddr_t offset;
    302   1.1  dholland 	u_long hash_mask;
    303  1.12  dholland 	struct lfs *fs = ump->um_lfs;
    304   1.9  dholland 	const int needswap = ULFS_MPNEEDSWAP(fs);
    305   1.1  dholland 
    306   1.1  dholland 	KASSERT(mutex_owned(&dq->dq_interlock));
    307   1.5  dholland 	KASSERT(mutex_owned(&lfs_dqlock));
    308   1.1  dholland 	error = getq2h(ump, type, &hbp, &q2h, B_MODIFY);
    309   1.1  dholland 	if (error)
    310   1.1  dholland 		return error;
    311   1.4  dholland 	offset = ulfs_rw64(q2h->q2h_free, needswap);
    312   1.1  dholland 	if (offset == 0) {
    313   1.1  dholland 		struct vnode *vp = ump->um_quotas[type];
    314   1.1  dholland 		struct inode *ip = VTOI(vp);
    315   1.1  dholland 		uint64_t size = ip->i_size;
    316   1.1  dholland 		/* need to alocate a new disk block */
    317   1.8  dholland 		error = lfs_balloc(vp, size, ump->umq2_bsize,
    318   1.1  dholland 		    ump->um_cred[type], B_CLRBUF | B_SYNC, &bp);
    319   1.1  dholland 		if (error) {
    320   1.1  dholland 			brelse(hbp, 0);
    321   1.1  dholland 			return error;
    322   1.1  dholland 		}
    323   1.1  dholland 		KASSERT((ip->i_size % ump->umq2_bsize) == 0);
    324   1.1  dholland 		ip->i_size += ump->umq2_bsize;
    325   1.1  dholland 		DIP_ASSIGN(ip, size, ip->i_size);
    326   1.1  dholland 		ip->i_flag |= IN_CHANGE | IN_UPDATE;
    327   1.1  dholland 		uvm_vnp_setsize(vp, ip->i_size);
    328   1.5  dholland 		lfsquota2_addfreeq2e(q2h, bp->b_data, size, ump->umq2_bsize,
    329   1.1  dholland 		    needswap);
    330   1.1  dholland 		error = bwrite(bp);
    331   1.8  dholland 		error2 = lfs_update(vp, NULL, NULL, UPDATE_WAIT);
    332   1.1  dholland 		if (error || error2) {
    333   1.1  dholland 			brelse(hbp, 0);
    334   1.1  dholland 			if (error)
    335   1.1  dholland 				return error;
    336   1.1  dholland 			return error2;
    337   1.1  dholland 		}
    338   1.4  dholland 		offset = ulfs_rw64(q2h->q2h_free, needswap);
    339   1.1  dholland 		KASSERT(offset != 0);
    340   1.1  dholland 	}
    341   1.1  dholland 	dq->dq2_lblkno = (offset >> ump->um_mountp->mnt_fs_bshift);
    342   1.1  dholland 	dq->dq2_blkoff = (offset & ump->umq2_bmask);
    343   1.1  dholland 	if (dq->dq2_lblkno == 0) {
    344   1.1  dholland 		bp = hbp;
    345   1.1  dholland 		q2e = (void *)((char *)bp->b_data + dq->dq2_blkoff);
    346   1.1  dholland 	} else {
    347   1.1  dholland 		error = getq2e(ump, type, dq->dq2_lblkno,
    348   1.1  dholland 		    dq->dq2_blkoff, &bp, &q2e, B_MODIFY);
    349   1.1  dholland 		if (error) {
    350   1.1  dholland 			brelse(hbp, 0);
    351   1.1  dholland 			return error;
    352   1.1  dholland 		}
    353   1.1  dholland 	}
    354   1.1  dholland 	hash_mask = ((1 << q2h->q2h_hash_shift) - 1);
    355   1.1  dholland 	/* remove from free list */
    356   1.1  dholland 	q2h->q2h_free = q2e->q2e_next;
    357   1.1  dholland 
    358   1.1  dholland 	memcpy(q2e, &q2h->q2h_defentry, sizeof(*q2e));
    359   1.4  dholland 	q2e->q2e_uid = ulfs_rw32(uid, needswap);
    360   1.1  dholland 	/* insert in hash list */
    361   1.1  dholland 	q2e->q2e_next = q2h->q2h_entries[uid & hash_mask];
    362   1.4  dholland 	q2h->q2h_entries[uid & hash_mask] = ulfs_rw64(offset, needswap);
    363   1.1  dholland 	if (hbp != bp) {
    364   1.1  dholland 		bwrite(hbp);
    365   1.1  dholland 	}
    366   1.1  dholland 	bwrite(bp);
    367   1.1  dholland 	return 0;
    368   1.1  dholland }
    369   1.1  dholland 
    370   1.1  dholland static int
    371   1.1  dholland getinoquota2(struct inode *ip, bool alloc, bool modify, struct buf **bpp,
    372   1.1  dholland     struct quota2_entry **q2ep)
    373   1.1  dholland {
    374   1.1  dholland 	int error;
    375   1.1  dholland 	int i;
    376   1.1  dholland 	struct dquot *dq;
    377   1.4  dholland 	struct ulfsmount *ump = ip->i_ump;
    378   1.4  dholland 	u_int32_t ino_ids[ULFS_MAXQUOTAS];
    379   1.1  dholland 
    380   1.5  dholland 	error = lfs_getinoquota(ip);
    381   1.1  dholland 	if (error)
    382   1.1  dholland 		return error;
    383   1.1  dholland 
    384   1.4  dholland         ino_ids[ULFS_USRQUOTA] = ip->i_uid;
    385   1.4  dholland         ino_ids[ULFS_GRPQUOTA] = ip->i_gid;
    386   1.1  dholland 	/* first get the interlock for all dquot */
    387   1.4  dholland 	for (i = 0; i < ULFS_MAXQUOTAS; i++) {
    388   1.1  dholland 		dq = ip->i_dquot[i];
    389   1.1  dholland 		if (dq == NODQUOT)
    390   1.1  dholland 			continue;
    391   1.1  dholland 		mutex_enter(&dq->dq_interlock);
    392   1.1  dholland 	}
    393   1.1  dholland 	/* now get the corresponding quota entry */
    394   1.4  dholland 	for (i = 0; i < ULFS_MAXQUOTAS; i++) {
    395   1.1  dholland 		bpp[i] = NULL;
    396   1.1  dholland 		q2ep[i] = NULL;
    397   1.1  dholland 		dq = ip->i_dquot[i];
    398   1.1  dholland 		if (dq == NODQUOT)
    399   1.1  dholland 			continue;
    400   1.1  dholland 		if (__predict_false(ump->um_quotas[i] == NULL)) {
    401   1.1  dholland 			/*
    402   1.1  dholland 			 * quotas have been turned off. This can happen
    403   1.1  dholland 			 * at umount time.
    404   1.1  dholland 			 */
    405   1.1  dholland 			mutex_exit(&dq->dq_interlock);
    406   1.5  dholland 			lfs_dqrele(NULLVP, dq);
    407   1.1  dholland 			ip->i_dquot[i] = NULL;
    408   1.1  dholland 			continue;
    409   1.1  dholland 		}
    410   1.1  dholland 
    411   1.1  dholland 		if ((dq->dq2_lblkno | dq->dq2_blkoff) == 0) {
    412   1.1  dholland 			if (!alloc) {
    413   1.1  dholland 				continue;
    414   1.1  dholland 			}
    415   1.1  dholland 			/* need to alloc a new on-disk quot */
    416   1.5  dholland 			mutex_enter(&lfs_dqlock);
    417   1.1  dholland 			error = quota2_q2ealloc(ump, i, ino_ids[i], dq);
    418   1.5  dholland 			mutex_exit(&lfs_dqlock);
    419   1.1  dholland 			if (error)
    420   1.1  dholland 				return error;
    421   1.1  dholland 		}
    422   1.1  dholland 		KASSERT(dq->dq2_lblkno != 0 || dq->dq2_blkoff != 0);
    423   1.1  dholland 		error = getq2e(ump, i, dq->dq2_lblkno,
    424   1.1  dholland 		    dq->dq2_blkoff, &bpp[i], &q2ep[i],
    425   1.1  dholland 		    modify ? B_MODIFY : 0);
    426   1.1  dholland 		if (error)
    427   1.1  dholland 			return error;
    428   1.1  dholland 	}
    429   1.1  dholland 	return 0;
    430   1.1  dholland }
    431   1.1  dholland 
    432   1.1  dholland __inline static int __unused
    433   1.5  dholland lfsquota2_check_limit(struct quota2_val *q2v, uint64_t change, time_t now)
    434   1.1  dholland {
    435   1.5  dholland 	return lfsquota_check_limit(q2v->q2v_cur, change, q2v->q2v_softlimit,
    436   1.1  dholland 	    q2v->q2v_hardlimit, q2v->q2v_time, now);
    437   1.1  dholland }
    438   1.1  dholland 
    439   1.1  dholland static int
    440   1.1  dholland quota2_check(struct inode *ip, int vtype, int64_t change, kauth_cred_t cred,
    441   1.1  dholland     int flags)
    442   1.1  dholland {
    443   1.1  dholland 	int error;
    444   1.4  dholland 	struct buf *bp[ULFS_MAXQUOTAS];
    445   1.4  dholland 	struct quota2_entry *q2e[ULFS_MAXQUOTAS];
    446   1.1  dholland 	struct quota2_val *q2vp;
    447   1.1  dholland 	struct dquot *dq;
    448   1.1  dholland 	uint64_t ncurblks;
    449   1.4  dholland 	struct ulfsmount *ump = ip->i_ump;
    450  1.12  dholland 	struct lfs *fs = ip->i_lfs;
    451   1.1  dholland 	struct mount *mp = ump->um_mountp;
    452   1.9  dholland 	const int needswap = ULFS_MPNEEDSWAP(fs);
    453   1.1  dholland 	int i;
    454   1.1  dholland 
    455   1.1  dholland 	if ((error = getinoquota2(ip, change > 0, change != 0, bp, q2e)) != 0)
    456   1.1  dholland 		return error;
    457   1.1  dholland 	if (change == 0) {
    458   1.4  dholland 		for (i = 0; i < ULFS_MAXQUOTAS; i++) {
    459   1.1  dholland 			dq = ip->i_dquot[i];
    460   1.1  dholland 			if (dq == NODQUOT)
    461   1.1  dholland 				continue;
    462   1.1  dholland 			if (bp[i])
    463   1.1  dholland 				brelse(bp[i], 0);
    464   1.1  dholland 			mutex_exit(&dq->dq_interlock);
    465   1.1  dholland 		}
    466   1.1  dholland 		return 0;
    467   1.1  dholland 	}
    468   1.1  dholland 	if (change < 0) {
    469   1.4  dholland 		for (i = 0; i < ULFS_MAXQUOTAS; i++) {
    470   1.1  dholland 			dq = ip->i_dquot[i];
    471   1.1  dholland 			if (dq == NODQUOT)
    472   1.1  dholland 				continue;
    473   1.1  dholland 			if (q2e[i] == NULL) {
    474   1.1  dholland 				mutex_exit(&dq->dq_interlock);
    475   1.1  dholland 				continue;
    476   1.1  dholland 			}
    477   1.1  dholland 			q2vp = &q2e[i]->q2e_val[vtype];
    478   1.4  dholland 			ncurblks = ulfs_rw64(q2vp->q2v_cur, needswap);
    479   1.1  dholland 			if (ncurblks < -change)
    480   1.1  dholland 				ncurblks = 0;
    481   1.1  dholland 			else
    482   1.1  dholland 				ncurblks += change;
    483   1.4  dholland 			q2vp->q2v_cur = ulfs_rw64(ncurblks, needswap);
    484   1.1  dholland 			quota2_bwrite(mp, bp[i]);
    485   1.1  dholland 			mutex_exit(&dq->dq_interlock);
    486   1.1  dholland 		}
    487   1.1  dholland 		return 0;
    488   1.1  dholland 	}
    489   1.1  dholland 	/* see if the allocation is allowed */
    490   1.4  dholland 	for (i = 0; i < ULFS_MAXQUOTAS; i++) {
    491   1.1  dholland 		struct quota2_val q2v;
    492   1.1  dholland 		int ql_stat;
    493   1.1  dholland 		dq = ip->i_dquot[i];
    494   1.1  dholland 		if (dq == NODQUOT)
    495   1.1  dholland 			continue;
    496   1.1  dholland 		KASSERT(q2e[i] != NULL);
    497   1.5  dholland 		lfsquota2_ulfs_rwq2v(&q2e[i]->q2e_val[vtype], &q2v, needswap);
    498   1.5  dholland 		ql_stat = lfsquota2_check_limit(&q2v, change, time_second);
    499   1.1  dholland 
    500   1.1  dholland 		if ((flags & FORCE) == 0 &&
    501   1.1  dholland 		    kauth_authorize_system(cred, KAUTH_SYSTEM_FS_QUOTA,
    502   1.1  dholland 		    KAUTH_REQ_SYSTEM_FS_QUOTA_NOLIMIT,
    503   1.1  dholland 		    KAUTH_ARG(i), KAUTH_ARG(vtype), NULL) != 0) {
    504   1.1  dholland 			/* enforce this limit */
    505   1.1  dholland 			switch(QL_STATUS(ql_stat)) {
    506   1.1  dholland 			case QL_S_DENY_HARD:
    507   1.1  dholland 				if ((dq->dq_flags & DQ_WARN(vtype)) == 0) {
    508   1.1  dholland 					uprintf("\n%s: write failed, %s %s "
    509   1.1  dholland 					    "limit reached\n",
    510   1.1  dholland 					    mp->mnt_stat.f_mntonname,
    511   1.5  dholland 					    lfs_quotatypes[i], limnames[vtype]);
    512   1.1  dholland 					dq->dq_flags |= DQ_WARN(vtype);
    513   1.1  dholland 				}
    514   1.1  dholland 				error = EDQUOT;
    515   1.1  dholland 				break;
    516   1.1  dholland 			case QL_S_DENY_GRACE:
    517   1.1  dholland 				if ((dq->dq_flags & DQ_WARN(vtype)) == 0) {
    518   1.1  dholland 					uprintf("\n%s: write failed, %s %s "
    519   1.1  dholland 					    "limit reached\n",
    520   1.1  dholland 					    mp->mnt_stat.f_mntonname,
    521   1.5  dholland 					    lfs_quotatypes[i], limnames[vtype]);
    522   1.1  dholland 					dq->dq_flags |= DQ_WARN(vtype);
    523   1.1  dholland 				}
    524   1.1  dholland 				error = EDQUOT;
    525   1.1  dholland 				break;
    526   1.1  dholland 			case QL_S_ALLOW_SOFT:
    527   1.1  dholland 				if ((dq->dq_flags & DQ_WARN(vtype)) == 0) {
    528   1.1  dholland 					uprintf("\n%s: warning, %s %s "
    529   1.1  dholland 					    "quota exceeded\n",
    530   1.1  dholland 					    mp->mnt_stat.f_mntonname,
    531   1.5  dholland 					    lfs_quotatypes[i], limnames[vtype]);
    532   1.1  dholland 					dq->dq_flags |= DQ_WARN(vtype);
    533   1.1  dholland 				}
    534   1.1  dholland 				break;
    535   1.1  dholland 			}
    536   1.1  dholland 		}
    537   1.1  dholland 		/*
    538   1.1  dholland 		 * always do this; we don't know if the allocation will
    539   1.1  dholland 		 * succed or not in the end. if we don't do the allocation
    540   1.1  dholland 		 * q2v_time will be ignored anyway
    541   1.1  dholland 		 */
    542   1.1  dholland 		if (ql_stat & QL_F_CROSS) {
    543   1.1  dholland 			q2v.q2v_time = time_second + q2v.q2v_grace;
    544   1.5  dholland 			lfsquota2_ulfs_rwq2v(&q2v, &q2e[i]->q2e_val[vtype],
    545   1.1  dholland 			    needswap);
    546   1.1  dholland 		}
    547   1.1  dholland 	}
    548   1.1  dholland 
    549   1.1  dholland 	/* now do the allocation if allowed */
    550   1.4  dholland 	for (i = 0; i < ULFS_MAXQUOTAS; i++) {
    551   1.1  dholland 		dq = ip->i_dquot[i];
    552   1.1  dholland 		if (dq == NODQUOT)
    553   1.1  dholland 			continue;
    554   1.1  dholland 		KASSERT(q2e[i] != NULL);
    555   1.1  dholland 		if (error == 0) {
    556   1.1  dholland 			q2vp = &q2e[i]->q2e_val[vtype];
    557   1.4  dholland 			ncurblks = ulfs_rw64(q2vp->q2v_cur, needswap);
    558   1.4  dholland 			q2vp->q2v_cur = ulfs_rw64(ncurblks + change, needswap);
    559   1.1  dholland 			quota2_bwrite(mp, bp[i]);
    560   1.1  dholland 		} else
    561   1.1  dholland 			brelse(bp[i], 0);
    562   1.1  dholland 		mutex_exit(&dq->dq_interlock);
    563   1.1  dholland 	}
    564   1.1  dholland 	return error;
    565   1.1  dholland }
    566   1.1  dholland 
    567   1.1  dholland int
    568   1.5  dholland lfs_chkdq2(struct inode *ip, int64_t change, kauth_cred_t cred, int flags)
    569   1.1  dholland {
    570   1.1  dholland 	return quota2_check(ip, QL_BLOCK, change, cred, flags);
    571   1.1  dholland }
    572   1.1  dholland 
    573   1.1  dholland int
    574   1.5  dholland lfs_chkiq2(struct inode *ip, int32_t change, kauth_cred_t cred, int flags)
    575   1.1  dholland {
    576   1.1  dholland 	return quota2_check(ip, QL_FILE, change, cred, flags);
    577   1.1  dholland }
    578   1.1  dholland 
    579   1.1  dholland int
    580   1.5  dholland lfsquota2_handle_cmd_put(struct ulfsmount *ump, const struct quotakey *key,
    581   1.1  dholland     const struct quotaval *val)
    582   1.1  dholland {
    583   1.1  dholland 	int error;
    584   1.1  dholland 	struct dquot *dq;
    585   1.1  dholland 	struct quota2_header *q2h;
    586   1.1  dholland 	struct quota2_entry q2e, *q2ep;
    587   1.1  dholland 	struct buf *bp;
    588  1.12  dholland 	struct lfs *fs = ump->um_lfs;
    589   1.9  dholland 	const int needswap = ULFS_MPNEEDSWAP(fs);
    590   1.1  dholland 
    591   1.1  dholland 	/* make sure we can index by the fs-independent idtype */
    592   1.4  dholland 	CTASSERT(QUOTA_IDTYPE_USER == ULFS_USRQUOTA);
    593   1.4  dholland 	CTASSERT(QUOTA_IDTYPE_GROUP == ULFS_GRPQUOTA);
    594   1.1  dholland 
    595   1.1  dholland 	if (ump->um_quotas[key->qk_idtype] == NULLVP)
    596   1.1  dholland 		return ENODEV;
    597   1.1  dholland 
    598   1.1  dholland 	if (key->qk_id == QUOTA_DEFAULTID) {
    599   1.5  dholland 		mutex_enter(&lfs_dqlock);
    600   1.1  dholland 		error = getq2h(ump, key->qk_idtype, &bp, &q2h, B_MODIFY);
    601   1.1  dholland 		if (error) {
    602   1.5  dholland 			mutex_exit(&lfs_dqlock);
    603   1.1  dholland 			goto out_wapbl;
    604   1.1  dholland 		}
    605   1.5  dholland 		lfsquota2_ulfs_rwq2e(&q2h->q2h_defentry, &q2e, needswap);
    606   1.1  dholland 		quota2_dict_update_q2e_limits(key->qk_objtype, val, &q2e);
    607   1.5  dholland 		lfsquota2_ulfs_rwq2e(&q2e, &q2h->q2h_defentry, needswap);
    608   1.5  dholland 		mutex_exit(&lfs_dqlock);
    609   1.1  dholland 		quota2_bwrite(ump->um_mountp, bp);
    610   1.1  dholland 		goto out_wapbl;
    611   1.1  dholland 	}
    612   1.1  dholland 
    613   1.5  dholland 	error = lfs_dqget(NULLVP, key->qk_id, ump, key->qk_idtype, &dq);
    614   1.1  dholland 	if (error)
    615   1.1  dholland 		goto out_wapbl;
    616   1.1  dholland 
    617   1.1  dholland 	mutex_enter(&dq->dq_interlock);
    618   1.1  dholland 	if (dq->dq2_lblkno == 0 && dq->dq2_blkoff == 0) {
    619   1.1  dholland 		/* need to alloc a new on-disk quot */
    620   1.5  dholland 		mutex_enter(&lfs_dqlock);
    621   1.1  dholland 		error = quota2_q2ealloc(ump, key->qk_idtype, key->qk_id, dq);
    622   1.5  dholland 		mutex_exit(&lfs_dqlock);
    623   1.1  dholland 		if (error)
    624   1.1  dholland 			goto out_il;
    625   1.1  dholland 	}
    626   1.1  dholland 	KASSERT(dq->dq2_lblkno != 0 || dq->dq2_blkoff != 0);
    627   1.1  dholland 	error = getq2e(ump, key->qk_idtype, dq->dq2_lblkno,
    628   1.1  dholland 	    dq->dq2_blkoff, &bp, &q2ep, B_MODIFY);
    629   1.1  dholland 	if (error)
    630   1.1  dholland 		goto out_il;
    631   1.1  dholland 
    632   1.5  dholland 	lfsquota2_ulfs_rwq2e(q2ep, &q2e, needswap);
    633   1.1  dholland 	quota2_dict_update_q2e_limits(key->qk_objtype, val, &q2e);
    634   1.5  dholland 	lfsquota2_ulfs_rwq2e(&q2e, q2ep, needswap);
    635   1.1  dholland 	quota2_bwrite(ump->um_mountp, bp);
    636   1.1  dholland 
    637   1.1  dholland out_il:
    638   1.1  dholland 	mutex_exit(&dq->dq_interlock);
    639   1.5  dholland 	lfs_dqrele(NULLVP, dq);
    640   1.1  dholland out_wapbl:
    641   1.1  dholland 	return error;
    642   1.1  dholland }
    643   1.1  dholland 
    644   1.1  dholland struct dq2clear_callback {
    645   1.1  dholland 	uid_t id;
    646   1.1  dholland 	struct dquot *dq;
    647   1.1  dholland 	struct quota2_header *q2h;
    648   1.1  dholland };
    649   1.1  dholland 
    650   1.1  dholland static int
    651   1.4  dholland dq2clear_callback(struct ulfsmount *ump, uint64_t *offp, struct quota2_entry *q2e,
    652   1.1  dholland     uint64_t off, void *v)
    653   1.1  dholland {
    654   1.1  dholland 	struct dq2clear_callback *c = v;
    655   1.9  dholland 	struct lfs *fs = ump->um_lfs;
    656   1.9  dholland 	const int needswap = ULFS_MPNEEDSWAP(fs);
    657   1.1  dholland 	uint64_t myoff;
    658   1.1  dholland 
    659   1.4  dholland 	if (ulfs_rw32(q2e->q2e_uid, needswap) == c->id) {
    660   1.1  dholland 		KASSERT(mutex_owned(&c->dq->dq_interlock));
    661   1.1  dholland 		c->dq->dq2_lblkno = 0;
    662   1.1  dholland 		c->dq->dq2_blkoff = 0;
    663   1.1  dholland 		myoff = *offp;
    664   1.1  dholland 		/* remove from hash list */
    665   1.1  dholland 		*offp = q2e->q2e_next;
    666   1.1  dholland 		/* add to free list */
    667   1.1  dholland 		q2e->q2e_next = c->q2h->q2h_free;
    668   1.1  dholland 		c->q2h->q2h_free = myoff;
    669   1.1  dholland 		return Q2WL_ABORT;
    670   1.1  dholland 	}
    671   1.1  dholland 	return 0;
    672   1.1  dholland }
    673   1.1  dholland int
    674  1.16  dholland lfsquota2_handle_cmd_del(struct ulfsmount *ump, const struct quotakey *qk)
    675   1.1  dholland {
    676   1.1  dholland 	int idtype;
    677   1.1  dholland 	id_t id;
    678   1.1  dholland 	int objtype;
    679   1.1  dholland 	int error, i, canfree;
    680   1.1  dholland 	struct dquot *dq;
    681   1.1  dholland 	struct quota2_header *q2h;
    682   1.1  dholland 	struct quota2_entry q2e, *q2ep;
    683   1.1  dholland 	struct buf *hbp, *bp;
    684   1.1  dholland 	u_long hash_mask;
    685   1.1  dholland 	struct dq2clear_callback c;
    686   1.1  dholland 
    687   1.1  dholland 	idtype = qk->qk_idtype;
    688   1.1  dholland 	id = qk->qk_id;
    689   1.1  dholland 	objtype = qk->qk_objtype;
    690   1.1  dholland 
    691   1.1  dholland 	if (ump->um_quotas[idtype] == NULLVP)
    692   1.1  dholland 		return ENODEV;
    693   1.1  dholland 	if (id == QUOTA_DEFAULTID)
    694   1.1  dholland 		return EOPNOTSUPP;
    695   1.1  dholland 
    696   1.1  dholland 	/* get the default entry before locking the entry's buffer */
    697   1.5  dholland 	mutex_enter(&lfs_dqlock);
    698   1.1  dholland 	error = getq2h(ump, idtype, &hbp, &q2h, 0);
    699   1.1  dholland 	if (error) {
    700   1.5  dholland 		mutex_exit(&lfs_dqlock);
    701   1.1  dholland 		return error;
    702   1.1  dholland 	}
    703   1.1  dholland 	/* we'll copy to another disk entry, so no need to swap */
    704   1.1  dholland 	memcpy(&q2e, &q2h->q2h_defentry, sizeof(q2e));
    705   1.5  dholland 	mutex_exit(&lfs_dqlock);
    706   1.1  dholland 	brelse(hbp, 0);
    707   1.1  dholland 
    708   1.5  dholland 	error = lfs_dqget(NULLVP, id, ump, idtype, &dq);
    709   1.1  dholland 	if (error)
    710   1.1  dholland 		return error;
    711   1.1  dholland 
    712   1.1  dholland 	mutex_enter(&dq->dq_interlock);
    713   1.1  dholland 	if (dq->dq2_lblkno == 0 && dq->dq2_blkoff == 0) {
    714   1.1  dholland 		/* already clear, nothing to do */
    715   1.1  dholland 		error = ENOENT;
    716   1.1  dholland 		goto out_il;
    717   1.1  dholland 	}
    718   1.6  dholland 
    719   1.1  dholland 	error = getq2e(ump, idtype, dq->dq2_lblkno, dq->dq2_blkoff,
    720   1.1  dholland 	    &bp, &q2ep, B_MODIFY);
    721   1.1  dholland 	if (error)
    722   1.1  dholland 		goto out_wapbl;
    723   1.1  dholland 
    724   1.1  dholland 	/* make sure we can index by the objtype passed in */
    725   1.1  dholland 	CTASSERT(QUOTA_OBJTYPE_BLOCKS == QL_BLOCK);
    726   1.1  dholland 	CTASSERT(QUOTA_OBJTYPE_FILES == QL_FILE);
    727   1.1  dholland 
    728   1.1  dholland 	/* clear the requested objtype by copying from the default entry */
    729   1.1  dholland 	q2ep->q2e_val[objtype].q2v_softlimit =
    730   1.1  dholland 		q2e.q2e_val[objtype].q2v_softlimit;
    731   1.1  dholland 	q2ep->q2e_val[objtype].q2v_hardlimit =
    732   1.1  dholland 		q2e.q2e_val[objtype].q2v_hardlimit;
    733   1.1  dholland 	q2ep->q2e_val[objtype].q2v_grace =
    734   1.1  dholland 		q2e.q2e_val[objtype].q2v_grace;
    735   1.1  dholland 	q2ep->q2e_val[objtype].q2v_time = 0;
    736   1.1  dholland 
    737   1.1  dholland 	/* if this entry now contains no information, we can free it */
    738   1.1  dholland 	canfree = 1;
    739   1.1  dholland 	for (i = 0; i < N_QL; i++) {
    740   1.1  dholland 		if (q2ep->q2e_val[i].q2v_cur != 0 ||
    741   1.1  dholland 		    (q2ep->q2e_val[i].q2v_softlimit !=
    742   1.1  dholland 		     q2e.q2e_val[i].q2v_softlimit) ||
    743   1.1  dholland 		    (q2ep->q2e_val[i].q2v_hardlimit !=
    744   1.1  dholland 		     q2e.q2e_val[i].q2v_hardlimit) ||
    745   1.1  dholland 		    (q2ep->q2e_val[i].q2v_grace !=
    746   1.1  dholland 		     q2e.q2e_val[i].q2v_grace)) {
    747   1.1  dholland 			canfree = 0;
    748   1.1  dholland 			break;
    749   1.1  dholland 		}
    750   1.1  dholland 		/* note: do not need to check q2v_time */
    751   1.1  dholland 	}
    752   1.1  dholland 
    753   1.1  dholland 	if (canfree == 0) {
    754   1.1  dholland 		quota2_bwrite(ump->um_mountp, bp);
    755   1.1  dholland 		goto out_wapbl;
    756   1.1  dholland 	}
    757   1.1  dholland 	/* we can free it. release bp so we can walk the list */
    758   1.1  dholland 	brelse(bp, 0);
    759   1.5  dholland 	mutex_enter(&lfs_dqlock);
    760   1.1  dholland 	error = getq2h(ump, idtype, &hbp, &q2h, 0);
    761   1.1  dholland 	if (error)
    762   1.1  dholland 		goto out_dqlock;
    763   1.1  dholland 
    764   1.1  dholland 	hash_mask = ((1 << q2h->q2h_hash_shift) - 1);
    765   1.1  dholland 	c.dq = dq;
    766   1.1  dholland 	c.id = id;
    767   1.1  dholland 	c.q2h = q2h;
    768   1.1  dholland 	error = quota2_walk_list(ump, hbp, idtype,
    769   1.1  dholland 	    &q2h->q2h_entries[id & hash_mask], B_MODIFY, &c,
    770   1.1  dholland 	    dq2clear_callback);
    771   1.1  dholland 
    772   1.1  dholland 	bwrite(hbp);
    773   1.1  dholland 
    774   1.1  dholland out_dqlock:
    775   1.5  dholland 	mutex_exit(&lfs_dqlock);
    776   1.1  dholland out_wapbl:
    777   1.1  dholland out_il:
    778   1.1  dholland 	mutex_exit(&dq->dq_interlock);
    779   1.5  dholland 	lfs_dqrele(NULLVP, dq);
    780   1.1  dholland 	return error;
    781   1.1  dholland }
    782   1.1  dholland 
    783   1.1  dholland static int
    784   1.4  dholland quota2_fetch_q2e(struct ulfsmount *ump, const struct quotakey *qk,
    785   1.1  dholland     struct quota2_entry *ret)
    786   1.1  dholland {
    787   1.1  dholland 	struct dquot *dq;
    788   1.1  dholland 	int error;
    789   1.1  dholland 	struct quota2_entry *q2ep;
    790   1.1  dholland 	struct buf *bp;
    791  1.12  dholland 	struct lfs *fs = ump->um_lfs;
    792   1.9  dholland 	const int needswap = ULFS_MPNEEDSWAP(fs);
    793   1.1  dholland 
    794   1.5  dholland 	error = lfs_dqget(NULLVP, qk->qk_id, ump, qk->qk_idtype, &dq);
    795   1.1  dholland 	if (error)
    796   1.1  dholland 		return error;
    797   1.1  dholland 
    798   1.1  dholland 	mutex_enter(&dq->dq_interlock);
    799   1.1  dholland 	if (dq->dq2_lblkno == 0 && dq->dq2_blkoff == 0) {
    800   1.1  dholland 		mutex_exit(&dq->dq_interlock);
    801   1.5  dholland 		lfs_dqrele(NULLVP, dq);
    802   1.1  dholland 		return ENOENT;
    803   1.1  dholland 	}
    804   1.1  dholland 	error = getq2e(ump, qk->qk_idtype, dq->dq2_lblkno, dq->dq2_blkoff,
    805   1.1  dholland 	    &bp, &q2ep, 0);
    806   1.1  dholland 	if (error) {
    807   1.1  dholland 		mutex_exit(&dq->dq_interlock);
    808   1.5  dholland 		lfs_dqrele(NULLVP, dq);
    809   1.1  dholland 		return error;
    810   1.1  dholland 	}
    811   1.5  dholland 	lfsquota2_ulfs_rwq2e(q2ep, ret, needswap);
    812   1.1  dholland 	brelse(bp, 0);
    813   1.1  dholland 	mutex_exit(&dq->dq_interlock);
    814   1.5  dholland 	lfs_dqrele(NULLVP, dq);
    815   1.1  dholland 
    816   1.1  dholland 	return 0;
    817   1.1  dholland }
    818   1.1  dholland 
    819   1.1  dholland static int
    820   1.4  dholland quota2_fetch_quotaval(struct ulfsmount *ump, const struct quotakey *qk,
    821   1.1  dholland     struct quotaval *ret)
    822   1.1  dholland {
    823   1.1  dholland 	struct dquot *dq;
    824   1.1  dholland 	int error;
    825   1.1  dholland 	struct quota2_entry *q2ep, q2e;
    826   1.1  dholland 	struct buf  *bp;
    827  1.12  dholland 	struct lfs *fs = ump->um_lfs;
    828   1.9  dholland 	const int needswap = ULFS_MPNEEDSWAP(fs);
    829   1.1  dholland 	id_t id2;
    830   1.1  dholland 
    831   1.5  dholland 	error = lfs_dqget(NULLVP, qk->qk_id, ump, qk->qk_idtype, &dq);
    832   1.1  dholland 	if (error)
    833   1.1  dholland 		return error;
    834   1.1  dholland 
    835   1.1  dholland 	mutex_enter(&dq->dq_interlock);
    836   1.1  dholland 	if (dq->dq2_lblkno == 0 && dq->dq2_blkoff == 0) {
    837   1.1  dholland 		mutex_exit(&dq->dq_interlock);
    838   1.5  dholland 		lfs_dqrele(NULLVP, dq);
    839   1.1  dholland 		return ENOENT;
    840   1.1  dholland 	}
    841   1.1  dholland 	error = getq2e(ump, qk->qk_idtype, dq->dq2_lblkno, dq->dq2_blkoff,
    842   1.1  dholland 	    &bp, &q2ep, 0);
    843   1.1  dholland 	if (error) {
    844   1.1  dholland 		mutex_exit(&dq->dq_interlock);
    845   1.5  dholland 		lfs_dqrele(NULLVP, dq);
    846   1.1  dholland 		return error;
    847   1.1  dholland 	}
    848   1.5  dholland 	lfsquota2_ulfs_rwq2e(q2ep, &q2e, needswap);
    849   1.1  dholland 	brelse(bp, 0);
    850   1.1  dholland 	mutex_exit(&dq->dq_interlock);
    851   1.5  dholland 	lfs_dqrele(NULLVP, dq);
    852   1.1  dholland 
    853   1.1  dholland 	q2e_to_quotaval(&q2e, 0, &id2, qk->qk_objtype, ret);
    854   1.1  dholland 	KASSERT(id2 == qk->qk_id);
    855   1.1  dholland 	return 0;
    856   1.1  dholland }
    857   1.1  dholland 
    858   1.1  dholland int
    859   1.5  dholland lfsquota2_handle_cmd_get(struct ulfsmount *ump, const struct quotakey *qk,
    860   1.1  dholland     struct quotaval *qv)
    861   1.1  dholland {
    862   1.1  dholland 	int error;
    863   1.1  dholland 	struct quota2_header *q2h;
    864   1.1  dholland 	struct quota2_entry q2e;
    865   1.1  dholland 	struct buf *bp;
    866  1.12  dholland 	struct lfs *fs = ump->um_lfs;
    867   1.9  dholland 	const int needswap = ULFS_MPNEEDSWAP(fs);
    868   1.1  dholland 	id_t id2;
    869   1.1  dholland 
    870   1.1  dholland 	/*
    871   1.1  dholland 	 * Make sure the FS-independent codes match the internal ones,
    872   1.1  dholland 	 * so we can use the passed-in objtype without having to
    873   1.1  dholland 	 * convert it explicitly to QL_BLOCK/QL_FILE.
    874   1.1  dholland 	 */
    875   1.1  dholland 	CTASSERT(QL_BLOCK == QUOTA_OBJTYPE_BLOCKS);
    876   1.1  dholland 	CTASSERT(QL_FILE == QUOTA_OBJTYPE_FILES);
    877   1.1  dholland 	CTASSERT(N_QL == 2);
    878   1.1  dholland 
    879   1.1  dholland 	if (qk->qk_objtype < 0 || qk->qk_objtype >= N_QL) {
    880   1.1  dholland 		return EINVAL;
    881   1.1  dholland 	}
    882   1.1  dholland 
    883   1.1  dholland 	if (ump->um_quotas[qk->qk_idtype] == NULLVP)
    884   1.1  dholland 		return ENODEV;
    885   1.1  dholland 	if (qk->qk_id == QUOTA_DEFAULTID) {
    886   1.5  dholland 		mutex_enter(&lfs_dqlock);
    887   1.1  dholland 		error = getq2h(ump, qk->qk_idtype, &bp, &q2h, 0);
    888   1.1  dholland 		if (error) {
    889   1.5  dholland 			mutex_exit(&lfs_dqlock);
    890   1.1  dholland 			return error;
    891   1.1  dholland 		}
    892   1.5  dholland 		lfsquota2_ulfs_rwq2e(&q2h->q2h_defentry, &q2e, needswap);
    893   1.5  dholland 		mutex_exit(&lfs_dqlock);
    894   1.1  dholland 		brelse(bp, 0);
    895   1.1  dholland 		q2e_to_quotaval(&q2e, qk->qk_id == QUOTA_DEFAULTID, &id2,
    896   1.1  dholland 				qk->qk_objtype, qv);
    897   1.1  dholland 		(void)id2;
    898   1.1  dholland 	} else
    899   1.1  dholland 		error = quota2_fetch_quotaval(ump, qk, qv);
    900   1.1  dholland 
    901   1.1  dholland 	return error;
    902   1.1  dholland }
    903   1.1  dholland 
    904   1.1  dholland /*
    905   1.1  dholland  * Cursor structure we used.
    906   1.1  dholland  *
    907   1.1  dholland  * This will get stored in userland between calls so we must not assume
    908   1.1  dholland  * it isn't arbitrarily corrupted.
    909   1.1  dholland  */
    910   1.4  dholland struct ulfsq2_cursor {
    911   1.1  dholland 	uint32_t q2c_magic;	/* magic number */
    912   1.1  dholland 	int q2c_hashsize;	/* size of hash table at last go */
    913   1.1  dholland 
    914   1.1  dholland 	int q2c_users_done;	/* true if we've returned all user data */
    915   1.1  dholland 	int q2c_groups_done;	/* true if we've returned all group data */
    916   1.1  dholland 	int q2c_defaults_done;	/* true if we've returned the default values */
    917   1.1  dholland 	int q2c_hashpos;	/* slot to start at in hash table */
    918   1.1  dholland 	int q2c_uidpos;		/* number of ids we've handled */
    919   1.1  dholland 	int q2c_blocks_done;	/* true if we've returned the blocks value */
    920   1.1  dholland };
    921   1.1  dholland 
    922   1.1  dholland /*
    923   1.1  dholland  * State of a single cursorget call, or at least the part of it that
    924   1.1  dholland  * needs to be passed around.
    925   1.1  dholland  */
    926   1.1  dholland struct q2cursor_state {
    927   1.1  dholland 	/* data return pointers */
    928   1.1  dholland 	struct quotakey *keys;
    929   1.1  dholland 	struct quotaval *vals;
    930   1.1  dholland 
    931   1.1  dholland 	/* key/value counters */
    932   1.1  dholland 	unsigned maxkeyvals;
    933   1.1  dholland 	unsigned numkeys;	/* number of keys assigned */
    934   1.1  dholland 
    935   1.1  dholland 	/* ID to key/value conversion state */
    936   1.1  dholland 	int skipfirst;		/* if true skip first key/value */
    937   1.1  dholland 	int skiplast;		/* if true skip last key/value */
    938   1.1  dholland 
    939   1.1  dholland 	/* ID counters */
    940   1.1  dholland 	unsigned maxids;	/* maximum number of IDs to handle */
    941   1.1  dholland 	unsigned numids;	/* number of IDs handled */
    942   1.1  dholland };
    943   1.1  dholland 
    944   1.1  dholland /*
    945   1.1  dholland  * Additional structure for getids callback.
    946   1.1  dholland  */
    947   1.1  dholland struct q2cursor_getids {
    948   1.1  dholland 	struct q2cursor_state *state;
    949   1.1  dholland 	int idtype;
    950   1.1  dholland 	unsigned skip;		/* number of ids to skip over */
    951   1.1  dholland 	unsigned new_skip;	/* number of ids to skip over next time */
    952   1.1  dholland 	unsigned skipped;	/* number skipped so far */
    953   1.1  dholland 	int stopped;		/* true if we stopped quota_walk_list early */
    954   1.1  dholland };
    955   1.1  dholland 
    956   1.1  dholland /*
    957   1.1  dholland  * Cursor-related functions
    958   1.1  dholland  */
    959   1.1  dholland 
    960   1.1  dholland /* magic number */
    961   1.1  dholland #define Q2C_MAGIC (0xbeebe111)
    962   1.1  dholland 
    963   1.1  dholland /* extract cursor from caller form */
    964   1.4  dholland #define Q2CURSOR(qkc) ((struct ulfsq2_cursor *)&qkc->u.qkc_space[0])
    965   1.1  dholland 
    966   1.1  dholland /*
    967   1.1  dholland  * Check that a cursor we're handed is something like valid. If
    968   1.1  dholland  * someone munges it and it still passes these checks, they'll get
    969   1.1  dholland  * partial or odd results back but won't break anything.
    970   1.1  dholland  */
    971   1.1  dholland static int
    972   1.4  dholland q2cursor_check(struct ulfsq2_cursor *cursor)
    973   1.1  dholland {
    974   1.1  dholland 	if (cursor->q2c_magic != Q2C_MAGIC) {
    975   1.1  dholland 		return EINVAL;
    976   1.1  dholland 	}
    977   1.1  dholland 	if (cursor->q2c_hashsize < 0) {
    978   1.1  dholland 		return EINVAL;
    979   1.1  dholland 	}
    980   1.1  dholland 
    981   1.1  dholland 	if (cursor->q2c_users_done != 0 && cursor->q2c_users_done != 1) {
    982   1.1  dholland 		return EINVAL;
    983   1.1  dholland 	}
    984   1.1  dholland 	if (cursor->q2c_groups_done != 0 && cursor->q2c_groups_done != 1) {
    985   1.1  dholland 		return EINVAL;
    986   1.1  dholland 	}
    987   1.1  dholland 	if (cursor->q2c_defaults_done != 0 && cursor->q2c_defaults_done != 1) {
    988   1.1  dholland 		return EINVAL;
    989   1.1  dholland 	}
    990   1.1  dholland 	if (cursor->q2c_hashpos < 0 || cursor->q2c_uidpos < 0) {
    991   1.1  dholland 		return EINVAL;
    992   1.1  dholland 	}
    993   1.1  dholland 	if (cursor->q2c_blocks_done != 0 && cursor->q2c_blocks_done != 1) {
    994   1.1  dholland 		return EINVAL;
    995   1.1  dholland 	}
    996   1.1  dholland 	return 0;
    997   1.1  dholland }
    998   1.1  dholland 
    999   1.1  dholland /*
   1000   1.1  dholland  * Set up the q2cursor state.
   1001   1.1  dholland  */
   1002   1.1  dholland static void
   1003   1.1  dholland q2cursor_initstate(struct q2cursor_state *state, struct quotakey *keys,
   1004   1.1  dholland     struct quotaval *vals, unsigned maxkeyvals, int blocks_done)
   1005   1.1  dholland {
   1006   1.1  dholland 	state->keys = keys;
   1007   1.1  dholland 	state->vals = vals;
   1008   1.1  dholland 
   1009   1.1  dholland 	state->maxkeyvals = maxkeyvals;
   1010   1.1  dholland 	state->numkeys = 0;
   1011   1.1  dholland 
   1012   1.1  dholland 	/*
   1013   1.1  dholland 	 * For each ID there are two quotavals to return. If the
   1014   1.1  dholland 	 * maximum number of entries to return is odd, we might want
   1015   1.1  dholland 	 * to skip the first quotaval of the first ID, or the last
   1016   1.1  dholland 	 * quotaval of the last ID, but not both. So the number of IDs
   1017   1.1  dholland 	 * we want is (up to) half the number of return slots we have,
   1018   1.1  dholland 	 * rounded up.
   1019   1.1  dholland 	 */
   1020   1.1  dholland 
   1021   1.1  dholland 	state->maxids = (state->maxkeyvals + 1) / 2;
   1022   1.1  dholland 	state->numids = 0;
   1023   1.1  dholland 	if (state->maxkeyvals % 2) {
   1024   1.1  dholland 		if (blocks_done) {
   1025   1.1  dholland 			state->skipfirst = 1;
   1026   1.1  dholland 			state->skiplast = 0;
   1027   1.1  dholland 		} else {
   1028   1.1  dholland 			state->skipfirst = 0;
   1029   1.1  dholland 			state->skiplast = 1;
   1030   1.1  dholland 		}
   1031   1.1  dholland 	} else {
   1032   1.1  dholland 		state->skipfirst = 0;
   1033   1.1  dholland 		state->skiplast = 0;
   1034   1.1  dholland 	}
   1035   1.1  dholland }
   1036   1.1  dholland 
   1037   1.1  dholland /*
   1038   1.1  dholland  * Choose which idtype we're going to work on. If doing a full
   1039   1.1  dholland  * iteration, we do users first, then groups, but either might be
   1040   1.1  dholland  * disabled or marked to skip via cursorsetidtype(), so don't make
   1041   1.1  dholland  * silly assumptions.
   1042   1.1  dholland  */
   1043   1.1  dholland static int
   1044   1.4  dholland q2cursor_pickidtype(struct ulfsq2_cursor *cursor, int *idtype_ret)
   1045   1.1  dholland {
   1046   1.1  dholland 	if (cursor->q2c_users_done == 0) {
   1047   1.1  dholland 		*idtype_ret = QUOTA_IDTYPE_USER;
   1048   1.1  dholland 	} else if (cursor->q2c_groups_done == 0) {
   1049   1.1  dholland 		*idtype_ret = QUOTA_IDTYPE_GROUP;
   1050   1.1  dholland 	} else {
   1051   1.1  dholland 		return EAGAIN;
   1052   1.1  dholland 	}
   1053   1.1  dholland 	return 0;
   1054   1.1  dholland }
   1055   1.1  dholland 
   1056   1.1  dholland /*
   1057   1.1  dholland  * Add an ID to the current state. Sets up either one or two keys to
   1058   1.1  dholland  * refer to it, depending on whether it's first/last and the setting
   1059   1.1  dholland  * of skipfirst. (skiplast does not need to be explicitly tested)
   1060   1.1  dholland  */
   1061   1.1  dholland static void
   1062   1.1  dholland q2cursor_addid(struct q2cursor_state *state, int idtype, id_t id)
   1063   1.1  dholland {
   1064   1.1  dholland 	KASSERT(state->numids < state->maxids);
   1065   1.1  dholland 	KASSERT(state->numkeys < state->maxkeyvals);
   1066   1.1  dholland 
   1067   1.1  dholland 	if (!state->skipfirst || state->numkeys > 0) {
   1068   1.1  dholland 		state->keys[state->numkeys].qk_idtype = idtype;
   1069   1.1  dholland 		state->keys[state->numkeys].qk_id = id;
   1070   1.1  dholland 		state->keys[state->numkeys].qk_objtype = QUOTA_OBJTYPE_BLOCKS;
   1071   1.1  dholland 		state->numkeys++;
   1072   1.1  dholland 	}
   1073   1.1  dholland 	if (state->numkeys < state->maxkeyvals) {
   1074   1.1  dholland 		state->keys[state->numkeys].qk_idtype = idtype;
   1075   1.1  dholland 		state->keys[state->numkeys].qk_id = id;
   1076   1.1  dholland 		state->keys[state->numkeys].qk_objtype = QUOTA_OBJTYPE_FILES;
   1077   1.1  dholland 		state->numkeys++;
   1078   1.1  dholland 	} else {
   1079   1.1  dholland 		KASSERT(state->skiplast);
   1080   1.1  dholland 	}
   1081   1.1  dholland 	state->numids++;
   1082   1.1  dholland }
   1083   1.1  dholland 
   1084   1.1  dholland /*
   1085   1.1  dholland  * Callback function for getting IDs. Update counting and call addid.
   1086   1.1  dholland  */
   1087   1.1  dholland static int
   1088   1.4  dholland q2cursor_getids_callback(struct ulfsmount *ump, uint64_t *offp,
   1089   1.1  dholland     struct quota2_entry *q2ep, uint64_t off, void *v)
   1090   1.1  dholland {
   1091   1.1  dholland 	struct q2cursor_getids *gi = v;
   1092   1.1  dholland 	id_t id;
   1093   1.9  dholland 	struct lfs *fs = ump->um_lfs;
   1094   1.9  dholland 	const int needswap = ULFS_MPNEEDSWAP(fs);
   1095   1.1  dholland 
   1096   1.1  dholland 	if (gi->skipped < gi->skip) {
   1097   1.1  dholland 		gi->skipped++;
   1098   1.1  dholland 		return 0;
   1099   1.1  dholland 	}
   1100   1.4  dholland 	id = ulfs_rw32(q2ep->q2e_uid, needswap);
   1101   1.1  dholland 	q2cursor_addid(gi->state, gi->idtype, id);
   1102   1.1  dholland 	gi->new_skip++;
   1103   1.1  dholland 	if (gi->state->numids >= gi->state->maxids) {
   1104   1.1  dholland 		/* got enough ids, stop now */
   1105   1.1  dholland 		gi->stopped = 1;
   1106   1.1  dholland 		return Q2WL_ABORT;
   1107   1.1  dholland 	}
   1108   1.1  dholland 	return 0;
   1109   1.1  dholland }
   1110   1.1  dholland 
   1111   1.1  dholland /*
   1112   1.1  dholland  * Fill in a batch of quotakeys by scanning one or more hash chains.
   1113   1.1  dholland  */
   1114   1.1  dholland static int
   1115   1.4  dholland q2cursor_getkeys(struct ulfsmount *ump, int idtype, struct ulfsq2_cursor *cursor,
   1116   1.1  dholland     struct q2cursor_state *state,
   1117   1.1  dholland     int *hashsize_ret, struct quota2_entry *default_q2e_ret)
   1118   1.1  dholland {
   1119  1.12  dholland 	struct lfs *fs = ump->um_lfs;
   1120   1.9  dholland 	const int needswap = ULFS_MPNEEDSWAP(fs);
   1121   1.1  dholland 	struct buf *hbp;
   1122   1.1  dholland 	struct quota2_header *q2h;
   1123   1.1  dholland 	int quota2_hash_size;
   1124   1.1  dholland 	struct q2cursor_getids gi;
   1125   1.1  dholland 	uint64_t offset;
   1126   1.1  dholland 	int error;
   1127   1.1  dholland 
   1128   1.1  dholland 	/*
   1129   1.1  dholland 	 * Read the header block.
   1130   1.1  dholland 	 */
   1131   1.1  dholland 
   1132   1.5  dholland 	mutex_enter(&lfs_dqlock);
   1133   1.1  dholland 	error = getq2h(ump, idtype, &hbp, &q2h, 0);
   1134   1.1  dholland 	if (error) {
   1135   1.5  dholland 		mutex_exit(&lfs_dqlock);
   1136   1.1  dholland 		return error;
   1137   1.1  dholland 	}
   1138   1.1  dholland 
   1139   1.1  dholland 	/* if the table size has changed, make the caller start over */
   1140   1.4  dholland 	quota2_hash_size = ulfs_rw16(q2h->q2h_hash_size, needswap);
   1141   1.1  dholland 	if (cursor->q2c_hashsize == 0) {
   1142   1.1  dholland 		cursor->q2c_hashsize = quota2_hash_size;
   1143   1.1  dholland 	} else if (cursor->q2c_hashsize != quota2_hash_size) {
   1144   1.1  dholland 		error = EDEADLK;
   1145   1.1  dholland 		goto scanfail;
   1146   1.1  dholland 	}
   1147   1.1  dholland 
   1148   1.1  dholland 	/* grab the entry with the default values out of the header */
   1149   1.5  dholland 	lfsquota2_ulfs_rwq2e(&q2h->q2h_defentry, default_q2e_ret, needswap);
   1150   1.1  dholland 
   1151   1.1  dholland 	/* If we haven't done the defaults yet, that goes first. */
   1152   1.1  dholland 	if (cursor->q2c_defaults_done == 0) {
   1153   1.1  dholland 		q2cursor_addid(state, idtype, QUOTA_DEFAULTID);
   1154   1.1  dholland 		/* if we read both halves, mark it done */
   1155   1.1  dholland 		if (state->numids < state->maxids || !state->skiplast) {
   1156   1.1  dholland 			cursor->q2c_defaults_done = 1;
   1157   1.1  dholland 		}
   1158   1.1  dholland 	}
   1159   1.1  dholland 
   1160   1.1  dholland 	gi.state = state;
   1161   1.1  dholland 	gi.idtype = idtype;
   1162   1.1  dholland 
   1163   1.1  dholland 	while (state->numids < state->maxids) {
   1164   1.1  dholland 		if (cursor->q2c_hashpos >= quota2_hash_size) {
   1165   1.1  dholland 			/* nothing more left */
   1166   1.1  dholland 			break;
   1167   1.1  dholland 		}
   1168   1.1  dholland 
   1169   1.1  dholland 		/* scan this hash chain */
   1170   1.1  dholland 		gi.skip = cursor->q2c_uidpos;
   1171   1.1  dholland 		gi.new_skip = gi.skip;
   1172   1.1  dholland 		gi.skipped = 0;
   1173   1.1  dholland 		gi.stopped = 0;
   1174   1.1  dholland 		offset = q2h->q2h_entries[cursor->q2c_hashpos];
   1175   1.1  dholland 
   1176   1.1  dholland 		error = quota2_walk_list(ump, hbp, idtype, &offset, 0, &gi,
   1177   1.1  dholland 		    q2cursor_getids_callback);
   1178   1.1  dholland 		KASSERT(error != Q2WL_ABORT);
   1179   1.1  dholland 		if (error) {
   1180   1.1  dholland 			break;
   1181   1.1  dholland 		}
   1182   1.1  dholland 		if (gi.stopped) {
   1183   1.1  dholland 			/* callback stopped before reading whole chain */
   1184   1.1  dholland 			cursor->q2c_uidpos = gi.new_skip;
   1185   1.1  dholland 			/* if we didn't get both halves, back up */
   1186   1.1  dholland 			if (state->numids == state->maxids && state->skiplast){
   1187   1.1  dholland 				KASSERT(cursor->q2c_uidpos > 0);
   1188   1.1  dholland 				cursor->q2c_uidpos--;
   1189   1.1  dholland 			}
   1190   1.1  dholland 		} else {
   1191   1.1  dholland 			/* read whole chain */
   1192   1.1  dholland 			/* if we got both halves of the last id, advance */
   1193   1.1  dholland 			if (state->numids < state->maxids || !state->skiplast){
   1194   1.1  dholland 				cursor->q2c_uidpos = 0;
   1195   1.1  dholland 				cursor->q2c_hashpos++;
   1196   1.1  dholland 			}
   1197   1.1  dholland 		}
   1198   1.1  dholland 	}
   1199   1.1  dholland 
   1200   1.1  dholland scanfail:
   1201   1.5  dholland 	mutex_exit(&lfs_dqlock);
   1202   1.1  dholland 	brelse(hbp, 0);
   1203   1.1  dholland 	if (error)
   1204   1.1  dholland 		return error;
   1205   1.1  dholland 
   1206   1.1  dholland 	*hashsize_ret = quota2_hash_size;
   1207   1.1  dholland 	return 0;
   1208   1.1  dholland }
   1209   1.1  dholland 
   1210   1.1  dholland /*
   1211   1.1  dholland  * Fetch the quotavals for the quotakeys.
   1212   1.1  dholland  */
   1213   1.1  dholland static int
   1214   1.4  dholland q2cursor_getvals(struct ulfsmount *ump, struct q2cursor_state *state,
   1215   1.1  dholland     const struct quota2_entry *default_q2e)
   1216   1.1  dholland {
   1217   1.1  dholland 	int hasid;
   1218   1.1  dholland 	id_t loadedid, id;
   1219   1.1  dholland 	unsigned pos;
   1220   1.1  dholland 	struct quota2_entry q2e;
   1221   1.1  dholland 	int objtype;
   1222   1.1  dholland 	int error;
   1223   1.1  dholland 
   1224   1.1  dholland 	hasid = 0;
   1225   1.1  dholland 	loadedid = 0;
   1226   1.1  dholland 	for (pos = 0; pos < state->numkeys; pos++) {
   1227   1.1  dholland 		id = state->keys[pos].qk_id;
   1228   1.1  dholland 		if (!hasid || id != loadedid) {
   1229   1.1  dholland 			hasid = 1;
   1230   1.1  dholland 			loadedid = id;
   1231   1.1  dholland 			if (id == QUOTA_DEFAULTID) {
   1232   1.1  dholland 				q2e = *default_q2e;
   1233   1.1  dholland 			} else {
   1234   1.1  dholland 				error = quota2_fetch_q2e(ump,
   1235   1.1  dholland 							 &state->keys[pos],
   1236   1.1  dholland 							 &q2e);
   1237   1.1  dholland 				if (error == ENOENT) {
   1238   1.1  dholland 					/* something changed - start over */
   1239   1.1  dholland 					error = EDEADLK;
   1240   1.1  dholland 				}
   1241   1.1  dholland 				if (error) {
   1242   1.1  dholland 					return error;
   1243   1.1  dholland 				}
   1244   1.1  dholland  			}
   1245   1.1  dholland 		}
   1246   1.1  dholland 
   1247   1.1  dholland 
   1248   1.1  dholland 		objtype = state->keys[pos].qk_objtype;
   1249   1.1  dholland 		KASSERT(objtype >= 0 && objtype < N_QL);
   1250   1.1  dholland 		q2val_to_quotaval(&q2e.q2e_val[objtype], &state->vals[pos]);
   1251   1.1  dholland 	}
   1252   1.1  dholland 
   1253   1.1  dholland 	return 0;
   1254   1.1  dholland }
   1255   1.1  dholland 
   1256   1.1  dholland /*
   1257   1.1  dholland  * Handle cursorget.
   1258   1.1  dholland  *
   1259   1.1  dholland  * We can't just read keys and values directly, because we can't walk
   1260   1.1  dholland  * the list with qdlock and grab dq_interlock to read the entries at
   1261   1.1  dholland  * the same time. So we're going to do two passes: one to figure out
   1262   1.1  dholland  * which IDs we want and fill in the keys, and then a second to use
   1263   1.1  dholland  * the keys to fetch the values.
   1264   1.1  dholland  */
   1265   1.1  dholland int
   1266   1.5  dholland lfsquota2_handle_cmd_cursorget(struct ulfsmount *ump, struct quotakcursor *qkc,
   1267   1.1  dholland     struct quotakey *keys, struct quotaval *vals, unsigned maxreturn,
   1268   1.1  dholland     unsigned *ret)
   1269   1.1  dholland {
   1270   1.1  dholland 	int error;
   1271   1.4  dholland 	struct ulfsq2_cursor *cursor;
   1272   1.4  dholland 	struct ulfsq2_cursor newcursor;
   1273   1.1  dholland 	struct q2cursor_state state;
   1274   1.1  dholland 	struct quota2_entry default_q2e;
   1275   1.1  dholland 	int idtype;
   1276  1.17    justin 	int quota2_hash_size = 0; /* XXXuninit */
   1277   1.1  dholland 
   1278   1.1  dholland 	/*
   1279   1.1  dholland 	 * Convert and validate the cursor.
   1280   1.1  dholland 	 */
   1281   1.1  dholland 	cursor = Q2CURSOR(qkc);
   1282   1.1  dholland 	error = q2cursor_check(cursor);
   1283   1.1  dholland 	if (error) {
   1284   1.1  dholland 		return error;
   1285   1.1  dholland 	}
   1286   1.1  dholland 
   1287   1.1  dholland 	/*
   1288   1.1  dholland 	 * Make sure our on-disk codes match the values of the
   1289   1.1  dholland 	 * FS-independent ones. This avoids the need for explicit
   1290   1.1  dholland 	 * conversion (which would be a NOP anyway and thus easily
   1291   1.1  dholland 	 * left out or called in the wrong places...)
   1292   1.1  dholland 	 */
   1293   1.4  dholland 	CTASSERT(QUOTA_IDTYPE_USER == ULFS_USRQUOTA);
   1294   1.4  dholland 	CTASSERT(QUOTA_IDTYPE_GROUP == ULFS_GRPQUOTA);
   1295   1.1  dholland 	CTASSERT(QUOTA_OBJTYPE_BLOCKS == QL_BLOCK);
   1296   1.1  dholland 	CTASSERT(QUOTA_OBJTYPE_FILES == QL_FILE);
   1297   1.1  dholland 
   1298   1.1  dholland 	/*
   1299   1.1  dholland 	 * If some of the idtypes aren't configured/enabled, arrange
   1300   1.1  dholland 	 * to skip over them.
   1301   1.1  dholland 	 */
   1302   1.1  dholland 	if (cursor->q2c_users_done == 0 &&
   1303   1.4  dholland 	    ump->um_quotas[ULFS_USRQUOTA] == NULLVP) {
   1304   1.1  dholland 		cursor->q2c_users_done = 1;
   1305   1.1  dholland 	}
   1306   1.1  dholland 	if (cursor->q2c_groups_done == 0 &&
   1307   1.4  dholland 	    ump->um_quotas[ULFS_GRPQUOTA] == NULLVP) {
   1308   1.1  dholland 		cursor->q2c_groups_done = 1;
   1309   1.1  dholland 	}
   1310   1.1  dholland 
   1311   1.1  dholland 	/* Loop over, potentially, both idtypes */
   1312   1.1  dholland 	while (1) {
   1313   1.1  dholland 
   1314   1.1  dholland 		/* Choose id type */
   1315   1.1  dholland 		error = q2cursor_pickidtype(cursor, &idtype);
   1316   1.1  dholland 		if (error == EAGAIN) {
   1317   1.1  dholland 			/* nothing more to do, return 0 */
   1318   1.1  dholland 			*ret = 0;
   1319   1.1  dholland 			return 0;
   1320   1.1  dholland 		}
   1321   1.1  dholland 		KASSERT(ump->um_quotas[idtype] != NULLVP);
   1322   1.1  dholland 
   1323   1.1  dholland 		/*
   1324   1.1  dholland 		 * Initialize the per-call iteration state. Copy the
   1325   1.1  dholland 		 * cursor state so we can update it in place but back
   1326   1.1  dholland 		 * out on error.
   1327   1.1  dholland 		 */
   1328   1.1  dholland 		q2cursor_initstate(&state, keys, vals, maxreturn,
   1329   1.1  dholland 				   cursor->q2c_blocks_done);
   1330   1.1  dholland 		newcursor = *cursor;
   1331   1.1  dholland 
   1332   1.1  dholland 		/* Assign keys */
   1333   1.1  dholland 		error = q2cursor_getkeys(ump, idtype, &newcursor, &state,
   1334   1.1  dholland 					 &quota2_hash_size, &default_q2e);
   1335   1.1  dholland 		if (error) {
   1336   1.1  dholland 			return error;
   1337   1.1  dholland 		}
   1338   1.1  dholland 
   1339   1.1  dholland 		/* Now fill in the values. */
   1340   1.1  dholland 		error = q2cursor_getvals(ump, &state, &default_q2e);
   1341   1.1  dholland 		if (error) {
   1342   1.1  dholland 			return error;
   1343   1.1  dholland 		}
   1344   1.1  dholland 
   1345   1.1  dholland 		/*
   1346   1.1  dholland 		 * Now that we aren't going to fail and lose what we
   1347   1.1  dholland 		 * did so far, we can update the cursor state.
   1348   1.1  dholland 		 */
   1349   1.1  dholland 
   1350   1.1  dholland 		if (newcursor.q2c_hashpos >= quota2_hash_size) {
   1351   1.1  dholland 			if (idtype == QUOTA_IDTYPE_USER)
   1352   1.1  dholland 				cursor->q2c_users_done = 1;
   1353   1.1  dholland 			else
   1354   1.1  dholland 				cursor->q2c_groups_done = 1;
   1355   1.1  dholland 
   1356   1.1  dholland 			/* start over on another id type */
   1357   1.1  dholland 			cursor->q2c_hashsize = 0;
   1358   1.1  dholland 			cursor->q2c_defaults_done = 0;
   1359   1.1  dholland 			cursor->q2c_hashpos = 0;
   1360   1.1  dholland 			cursor->q2c_uidpos = 0;
   1361   1.1  dholland 			cursor->q2c_blocks_done = 0;
   1362   1.1  dholland 		} else {
   1363   1.1  dholland 			*cursor = newcursor;
   1364   1.1  dholland 			cursor->q2c_blocks_done = state.skiplast;
   1365   1.1  dholland 		}
   1366   1.1  dholland 
   1367   1.1  dholland 		/*
   1368   1.1  dholland 		 * If we have something to return, return it.
   1369   1.1  dholland 		 * Otherwise, continue to the other idtype, if any,
   1370   1.1  dholland 		 * and only return zero at end of iteration.
   1371   1.1  dholland 		 */
   1372   1.1  dholland 		if (state.numkeys > 0) {
   1373   1.1  dholland 			break;
   1374   1.1  dholland 		}
   1375   1.1  dholland 	}
   1376   1.1  dholland 
   1377   1.1  dholland 	*ret = state.numkeys;
   1378   1.1  dholland 	return 0;
   1379   1.1  dholland }
   1380   1.1  dholland 
   1381   1.1  dholland int
   1382   1.5  dholland lfsquota2_handle_cmd_cursoropen(struct ulfsmount *ump, struct quotakcursor *qkc)
   1383   1.1  dholland {
   1384   1.4  dholland 	struct ulfsq2_cursor *cursor;
   1385   1.1  dholland 
   1386   1.1  dholland 	CTASSERT(sizeof(*cursor) <= sizeof(qkc->u.qkc_space));
   1387   1.1  dholland 	cursor = Q2CURSOR(qkc);
   1388   1.1  dholland 
   1389   1.1  dholland 	cursor->q2c_magic = Q2C_MAGIC;
   1390   1.1  dholland 	cursor->q2c_hashsize = 0;
   1391   1.1  dholland 
   1392   1.1  dholland 	cursor->q2c_users_done = 0;
   1393   1.1  dholland 	cursor->q2c_groups_done = 0;
   1394   1.1  dholland 	cursor->q2c_defaults_done = 0;
   1395   1.1  dholland 	cursor->q2c_hashpos = 0;
   1396   1.1  dholland 	cursor->q2c_uidpos = 0;
   1397   1.1  dholland 	cursor->q2c_blocks_done = 0;
   1398   1.1  dholland 	return 0;
   1399   1.1  dholland }
   1400   1.1  dholland 
   1401   1.1  dholland int
   1402   1.5  dholland lfsquota2_handle_cmd_cursorclose(struct ulfsmount *ump, struct quotakcursor *qkc)
   1403   1.1  dholland {
   1404   1.4  dholland 	struct ulfsq2_cursor *cursor;
   1405   1.1  dholland 	int error;
   1406   1.1  dholland 
   1407   1.1  dholland 	cursor = Q2CURSOR(qkc);
   1408   1.1  dholland 	error = q2cursor_check(cursor);
   1409   1.1  dholland 	if (error) {
   1410   1.1  dholland 		return error;
   1411   1.1  dholland 	}
   1412   1.1  dholland 
   1413   1.1  dholland 	/* nothing to do */
   1414   1.1  dholland 
   1415   1.1  dholland 	return 0;
   1416   1.1  dholland }
   1417   1.1  dholland 
   1418   1.1  dholland int
   1419   1.5  dholland lfsquota2_handle_cmd_cursorskipidtype(struct ulfsmount *ump,
   1420   1.1  dholland     struct quotakcursor *qkc, int idtype)
   1421   1.1  dholland {
   1422   1.4  dholland 	struct ulfsq2_cursor *cursor;
   1423   1.1  dholland 	int error;
   1424   1.1  dholland 
   1425   1.1  dholland 	cursor = Q2CURSOR(qkc);
   1426   1.1  dholland 	error = q2cursor_check(cursor);
   1427   1.1  dholland 	if (error) {
   1428   1.1  dholland 		return error;
   1429   1.1  dholland 	}
   1430   1.1  dholland 
   1431   1.1  dholland 	switch (idtype) {
   1432   1.1  dholland 	    case QUOTA_IDTYPE_USER:
   1433   1.1  dholland 		cursor->q2c_users_done = 1;
   1434   1.1  dholland 		break;
   1435   1.1  dholland 	    case QUOTA_IDTYPE_GROUP:
   1436   1.1  dholland 		cursor->q2c_groups_done = 1;
   1437   1.1  dholland 		break;
   1438   1.1  dholland 	    default:
   1439   1.1  dholland 		return EINVAL;
   1440   1.1  dholland 	}
   1441   1.1  dholland 
   1442   1.1  dholland 	return 0;
   1443   1.1  dholland }
   1444   1.1  dholland 
   1445   1.1  dholland int
   1446   1.5  dholland lfsquota2_handle_cmd_cursoratend(struct ulfsmount *ump, struct quotakcursor *qkc,
   1447   1.1  dholland     int *ret)
   1448   1.1  dholland {
   1449   1.4  dholland 	struct ulfsq2_cursor *cursor;
   1450   1.1  dholland 	int error;
   1451   1.1  dholland 
   1452   1.1  dholland 	cursor = Q2CURSOR(qkc);
   1453   1.1  dholland 	error = q2cursor_check(cursor);
   1454   1.1  dholland 	if (error) {
   1455   1.1  dholland 		return error;
   1456   1.1  dholland 	}
   1457   1.1  dholland 
   1458   1.1  dholland 	*ret = (cursor->q2c_users_done && cursor->q2c_groups_done);
   1459   1.1  dholland 	return 0;
   1460   1.1  dholland }
   1461   1.1  dholland 
   1462   1.1  dholland int
   1463   1.5  dholland lfsquota2_handle_cmd_cursorrewind(struct ulfsmount *ump, struct quotakcursor *qkc)
   1464   1.1  dholland {
   1465   1.4  dholland 	struct ulfsq2_cursor *cursor;
   1466   1.1  dholland 	int error;
   1467   1.1  dholland 
   1468   1.1  dholland 	cursor = Q2CURSOR(qkc);
   1469   1.1  dholland 	error = q2cursor_check(cursor);
   1470   1.1  dholland 	if (error) {
   1471   1.1  dholland 		return error;
   1472   1.1  dholland 	}
   1473   1.1  dholland 
   1474   1.1  dholland 	cursor->q2c_hashsize = 0;
   1475   1.1  dholland 
   1476   1.1  dholland 	cursor->q2c_users_done = 0;
   1477   1.1  dholland 	cursor->q2c_groups_done = 0;
   1478   1.1  dholland 	cursor->q2c_defaults_done = 0;
   1479   1.1  dholland 	cursor->q2c_hashpos = 0;
   1480   1.1  dholland 	cursor->q2c_uidpos = 0;
   1481   1.1  dholland 	cursor->q2c_blocks_done = 0;
   1482   1.1  dholland 
   1483   1.1  dholland 	return 0;
   1484   1.1  dholland }
   1485   1.1  dholland 
   1486   1.1  dholland int
   1487   1.5  dholland lfs_q2sync(struct mount *mp)
   1488   1.1  dholland {
   1489   1.1  dholland 	return 0;
   1490   1.1  dholland }
   1491   1.1  dholland 
   1492   1.1  dholland struct dq2get_callback {
   1493   1.1  dholland 	uid_t id;
   1494   1.1  dholland 	struct dquot *dq;
   1495   1.1  dholland };
   1496   1.1  dholland 
   1497   1.1  dholland static int
   1498   1.4  dholland dq2get_callback(struct ulfsmount *ump, uint64_t *offp, struct quota2_entry *q2e,
   1499   1.1  dholland     uint64_t off, void *v)
   1500   1.1  dholland {
   1501   1.1  dholland 	struct dq2get_callback *c = v;
   1502   1.1  dholland 	daddr_t lblkno;
   1503   1.1  dholland 	int blkoff;
   1504   1.9  dholland 	struct lfs *fs = ump->um_lfs;
   1505   1.9  dholland 	const int needswap = ULFS_MPNEEDSWAP(fs);
   1506   1.1  dholland 
   1507   1.4  dholland 	if (ulfs_rw32(q2e->q2e_uid, needswap) == c->id) {
   1508   1.1  dholland 		KASSERT(mutex_owned(&c->dq->dq_interlock));
   1509   1.1  dholland 		lblkno = (off >> ump->um_mountp->mnt_fs_bshift);
   1510   1.1  dholland 		blkoff = (off & ump->umq2_bmask);
   1511   1.1  dholland 		c->dq->dq2_lblkno = lblkno;
   1512   1.1  dholland 		c->dq->dq2_blkoff = blkoff;
   1513   1.1  dholland 		return Q2WL_ABORT;
   1514   1.1  dholland 	}
   1515   1.1  dholland 	return 0;
   1516   1.1  dholland }
   1517   1.1  dholland 
   1518   1.1  dholland int
   1519   1.5  dholland lfs_dq2get(struct vnode *dqvp, u_long id, struct ulfsmount *ump, int type,
   1520   1.1  dholland     struct dquot *dq)
   1521   1.1  dholland {
   1522   1.1  dholland 	struct buf *bp;
   1523   1.1  dholland 	struct quota2_header *q2h;
   1524   1.1  dholland 	int error;
   1525   1.1  dholland 	daddr_t offset;
   1526   1.1  dholland 	u_long hash_mask;
   1527   1.1  dholland 	struct dq2get_callback c = {
   1528   1.1  dholland 		.id = id,
   1529   1.1  dholland 		.dq = dq
   1530   1.1  dholland 	};
   1531   1.1  dholland 
   1532   1.1  dholland 	KASSERT(mutex_owned(&dq->dq_interlock));
   1533   1.5  dholland 	mutex_enter(&lfs_dqlock);
   1534   1.1  dholland 	error = getq2h(ump, type, &bp, &q2h, 0);
   1535   1.1  dholland 	if (error)
   1536   1.1  dholland 		goto out_mutex;
   1537   1.1  dholland 	/* look for our entry */
   1538   1.1  dholland 	hash_mask = ((1 << q2h->q2h_hash_shift) - 1);
   1539   1.1  dholland 	offset = q2h->q2h_entries[id & hash_mask];
   1540   1.1  dholland 	error = quota2_walk_list(ump, bp, type, &offset, 0, (void *)&c,
   1541   1.1  dholland 	    dq2get_callback);
   1542   1.1  dholland 	brelse(bp, 0);
   1543   1.1  dholland out_mutex:
   1544   1.5  dholland 	mutex_exit(&lfs_dqlock);
   1545   1.1  dholland 	return error;
   1546   1.1  dholland }
   1547   1.1  dholland 
   1548   1.1  dholland int
   1549   1.5  dholland lfs_dq2sync(struct vnode *vp, struct dquot *dq)
   1550   1.1  dholland {
   1551   1.1  dholland 	return 0;
   1552   1.1  dholland }
   1553  1.10  dholland 
   1554  1.10  dholland int
   1555  1.10  dholland lfs_quota2_mount(struct mount *mp)
   1556  1.10  dholland {
   1557  1.10  dholland 	struct ulfsmount *ump = VFSTOULFS(mp);
   1558  1.10  dholland 	struct lfs *fs = ump->um_lfs;
   1559  1.10  dholland 	int error = 0;
   1560  1.10  dholland 	struct vnode *vp;
   1561  1.10  dholland 	struct lwp *l = curlwp;
   1562  1.10  dholland 
   1563  1.10  dholland 	if ((fs->lfs_use_quota2) == 0)
   1564  1.10  dholland 		return 0;
   1565  1.10  dholland 
   1566  1.10  dholland 	fs->um_flags |= ULFS_QUOTA2;
   1567  1.19  dholland 	ump->umq2_bsize = lfs_sb_getbsize(fs);
   1568  1.20  dholland 	ump->umq2_bmask = lfs_sb_getbmask(fs);
   1569  1.10  dholland 	if (fs->lfs_quota_magic != Q2_HEAD_MAGIC) {
   1570  1.10  dholland 		printf("%s: Invalid quota magic number\n",
   1571  1.10  dholland 		    mp->mnt_stat.f_mntonname);
   1572  1.10  dholland 		return EINVAL;
   1573  1.10  dholland 	}
   1574  1.10  dholland         if ((fs->lfs_quota_flags & FS_Q2_DO_TYPE(ULFS_USRQUOTA)) &&
   1575  1.10  dholland             fs->lfs_quotaino[ULFS_USRQUOTA] == 0) {
   1576  1.10  dholland                 printf("%s: no user quota inode\n",
   1577  1.10  dholland 		    mp->mnt_stat.f_mntonname);
   1578  1.10  dholland                 error = EINVAL;
   1579  1.10  dholland         }
   1580  1.10  dholland         if ((fs->lfs_quota_flags & FS_Q2_DO_TYPE(ULFS_GRPQUOTA)) &&
   1581  1.10  dholland             fs->lfs_quotaino[ULFS_GRPQUOTA] == 0) {
   1582  1.10  dholland                 printf("%s: no group quota inode\n",
   1583  1.10  dholland 		    mp->mnt_stat.f_mntonname);
   1584  1.10  dholland                 error = EINVAL;
   1585  1.10  dholland         }
   1586  1.10  dholland 	if (error)
   1587  1.10  dholland 		return error;
   1588  1.10  dholland 
   1589  1.10  dholland         if (fs->lfs_quota_flags & FS_Q2_DO_TYPE(ULFS_USRQUOTA) &&
   1590  1.10  dholland 	    ump->um_quotas[ULFS_USRQUOTA] == NULLVP) {
   1591  1.10  dholland 		error = VFS_VGET(mp, fs->lfs_quotaino[ULFS_USRQUOTA], &vp);
   1592  1.10  dholland 		if (error) {
   1593  1.10  dholland 			printf("%s: can't vget() user quota inode: %d\n",
   1594  1.10  dholland 			    mp->mnt_stat.f_mntonname, error);
   1595  1.10  dholland 			return error;
   1596  1.10  dholland 		}
   1597  1.10  dholland 		ump->um_quotas[ULFS_USRQUOTA] = vp;
   1598  1.10  dholland 		ump->um_cred[ULFS_USRQUOTA] = l->l_cred;
   1599  1.10  dholland 		mutex_enter(vp->v_interlock);
   1600  1.10  dholland 		vp->v_writecount++;
   1601  1.10  dholland 		mutex_exit(vp->v_interlock);
   1602  1.10  dholland 		VOP_UNLOCK(vp);
   1603  1.10  dholland 	}
   1604  1.10  dholland         if (fs->lfs_quota_flags & FS_Q2_DO_TYPE(ULFS_GRPQUOTA) &&
   1605  1.10  dholland 	    ump->um_quotas[ULFS_GRPQUOTA] == NULLVP) {
   1606  1.10  dholland 		error = VFS_VGET(mp, fs->lfs_quotaino[ULFS_GRPQUOTA], &vp);
   1607  1.10  dholland 		if (error) {
   1608  1.10  dholland 			vn_close(ump->um_quotas[ULFS_USRQUOTA],
   1609  1.10  dholland 			    FREAD|FWRITE, l->l_cred);
   1610  1.10  dholland 			printf("%s: can't vget() group quota inode: %d\n",
   1611  1.10  dholland 			    mp->mnt_stat.f_mntonname, error);
   1612  1.10  dholland 			return error;
   1613  1.10  dholland 		}
   1614  1.10  dholland 		ump->um_quotas[ULFS_GRPQUOTA] = vp;
   1615  1.10  dholland 		ump->um_cred[ULFS_GRPQUOTA] = l->l_cred;
   1616  1.10  dholland 		mutex_enter(vp->v_interlock);
   1617  1.10  dholland 		vp->v_vflag |= VV_SYSTEM;
   1618  1.10  dholland 		vp->v_writecount++;
   1619  1.10  dholland 		mutex_exit(vp->v_interlock);
   1620  1.10  dholland 		VOP_UNLOCK(vp);
   1621  1.10  dholland 	}
   1622  1.10  dholland 	mp->mnt_flag |= MNT_QUOTA;
   1623  1.10  dholland 	return 0;
   1624  1.10  dholland }
   1625