 @@ -1,14 +1,14 @@
-/* $NetBSD: ufs_quota2.c,v 1.29 2012/01/29 07:20:27 dholland Exp $ */
+/* $NetBSD: ufs_quota2.c,v 1.30 2012/01/29 07:21:00 dholland Exp $ */
 /*-
   * Copyright (c) 2010 Manuel Bouyer
   * All rights reserved.
+  *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in the
   *    documentation and/or other materials provided with the distribution.
+  *
 @@ -16,33 +16,32 @@
   * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ufs_quota2.c,v 1.29 2012/01/29 07:20:27 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ufs_quota2.c,v 1.30 2012/01/29 07:21:00 dholland Exp $");
 #include <sys/buf.h>
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/malloc.h>
 #include <sys/namei.h>
 #include <sys/file.h>
 #include <sys/proc.h>
 #include <sys/vnode.h>
 #include <sys/mount.h>
 #include <sys/fstrans.h>
 #include <sys/kauth.h>
 #include <sys/wapbl.h>
 #include <sys/quota.h>
 #include <sys/quotactl.h>
 #include <ufs/ufs/quota2.h>
 #include <ufs/ufs/inode.h>
 @@ -784,79 +783,62 @@ quota2_handle_cmd_delete(struct ufsmount
 out_dqlock:
 	mutex_exit(&dqlock);
 out_wapbl:
 	UFS_WAPBL_END(ump->um_mountp);
 out_il:
 	mutex_exit(&dq->dq_interlock);
 out_dq:
 	dqrele(NULLVP, dq);
 	return error;
+}
 static int
-quota2_result_add_q2e(struct ufsmount *ump, int idtype,
+quota2_fetch_q2e(struct ufsmount *ump, const struct quotakey *qk,
-    int id, struct quotakey *keys, struct quotaval *vals, unsigned pos,
+    struct quota2_entry *ret)
     int skipfirst, int skiplast)
+{
 	struct dquot *dq;
 	int error;
-	struct quota2_entry *q2ep, q2e;
+	struct quota2_entry *q2ep;
-	struct buf  *bp;
+	struct buf *bp;
 	const int needswap = UFS_MPNEEDSWAP(ump);
-	error = dqget(NULLVP, id, ump, idtype, &dq);
+	error = dqget(NULLVP, qk->qk_id, ump, qk->qk_idtype, &dq);
 	if (error)
 		return error;
 	mutex_enter(&dq->dq_interlock);
 	if (dq->dq2_lblkno == 0 && dq->dq2_blkoff == 0) {
 		mutex_exit(&dq->dq_interlock);
 		dqrele(NULLVP, dq);
 		return ENOENT;
+	}
-	error = getq2e(ump, idtype, dq->dq2_lblkno, dq->dq2_blkoff,
+	error = getq2e(ump, qk->qk_idtype, dq->dq2_lblkno, dq->dq2_blkoff,
 	    &bp, &q2ep, 0);
 	if (error) {
 		mutex_exit(&dq->dq_interlock);
 		dqrele(NULLVP, dq);
 		return error;
+	}
-	quota2_ufs_rwq2e(q2ep, &q2e, needswap);
+	quota2_ufs_rwq2e(q2ep, ret, needswap);
 	brelse(bp, 0);
 	mutex_exit(&dq->dq_interlock);
 	dqrele(NULLVP, dq);
 	if (skipfirst == 0) {
 		keys[pos].qk_idtype = idtype;
 		keys[pos].qk_objtype = QUOTA_OBJTYPE_BLOCKS;
 		q2e_to_quotaval(&q2e, 0, &keys[pos].qk_id,
 				QL_BLOCK, &vals[pos]);
 		pos++;
 	if (skiplast == 0) {
 		keys[pos].qk_idtype = idtype;
 		keys[pos].qk_objtype = QUOTA_OBJTYPE_FILES;
 		q2e_to_quotaval(&q2e, 0, &keys[pos].qk_id,
 				QL_FILE, &vals[pos]);
 		pos++;
 	return 0;
+}
 static int
-quota2_fetch_q2e(struct ufsmount *ump, const struct quotakey *qk,
+quota2_fetch_quotaval(struct ufsmount *ump, const struct quotakey *qk,
     struct quotaval *ret)
+{
 	struct dquot *dq;
 	int error;
 	struct quota2_entry *q2ep, q2e;
 	struct buf  *bp;
 	const int needswap = UFS_MPNEEDSWAP(ump);
 	id_t id2;
 	error = dqget(NULLVP, qk->qk_id, ump, qk->qk_idtype, &dq);
 	if (error)
 		return error;
 @@ -913,47 +895,97 @@ quota2_handle_cmd_get(struct ufsmount *u
 		mutex_enter(&dqlock);
 		error = getq2h(ump, qk->qk_idtype, &bp, &q2h, 0);
 		if (error) {
 			mutex_exit(&dqlock);
 			return error;
+		}
 		quota2_ufs_rwq2e(&q2h->q2h_defentry, &q2e, needswap);
 		mutex_exit(&dqlock);
 		brelse(bp, 0);
 		q2e_to_quotaval(&q2e, qk->qk_id == QUOTA_DEFAULTID, &id2,
 				qk->qk_objtype, ret);
 		(void)id2;
 	} else
-		error = quota2_fetch_q2e(ump, qk, ret);
+		error = quota2_fetch_quotaval(ump, qk, ret);
 	return error;
+}
 /*
  * Cursor structure we used.
+ *
  * This will get stored in userland between calls so we must not assume
  * it isn't arbitrarily corrupted.
  */
 struct ufsq2_cursor {
 	uint32_t q2c_magic;	/* magic number */
 	int q2c_hashsize;	/* size of hash table at last go */
 	int q2c_users_done;	/* true if we've returned all user data */
 	int q2c_groups_done;	/* true if we've returned all group data */
 	int q2c_defaults_done;	/* true if we've returned the default values */
 	int q2c_hashpos;	/* slot to start at in hash table */
 	int q2c_uidpos;		/* number of ids we've handled */
 	int q2c_blocks_done;	/* true if we've returned the blocks value */
 };
 /*
  * State of a single cursorget call, or at least the part of it that
  * needs to be passed around.
  */
 struct q2cursor_state {
 	/* data return pointers */
 	struct quotakey *keys;
 	struct quotaval *vals;
 	/* key/value counters */
 	unsigned maxkeyvals;
 	unsigned numkeys;	/* number of keys assigned */
 	/* ID to key/value conversion state */
 	int skipfirst;		/* if true skip first key/value */
 	int skiplast;		/* if true skip last key/value */
 	/* ID counters */
 	unsigned maxids;	/* maximum number of IDs to handle */
 	unsigned numids;	/* number of IDs handled */
 };
 /*
  * Additional structure for getids callback.
  */
 struct q2cursor_getids {
 	struct q2cursor_state *state;
 	int idtype;
 	unsigned skip;		/* number of ids to skip over */
 	unsigned new_skip;	/* number of ids to skip over next time */
 	unsigned skipped;	/* number skipped so far */
 };
 /*
  * Cursor-related functions
  */
 /* magic number */
 #define Q2C_MAGIC (0xbeebe111)
 /* extract cursor from caller form */
 #define Q2CURSOR(qkc) ((struct ufsq2_cursor *)&qkc->u.qkc_space[0])
 /*
  * Check that a cursor we're handed is something like valid. If
  * someone munges it and it still passes these checks, they'll get
  * partial or odd results back but won't break anything.
  */
 static int
 q2cursor_check(struct ufsq2_cursor *cursor)
+{
 	if (cursor->q2c_magic != Q2C_MAGIC) {
 		return EINVAL;
+	}
 	if (cursor->q2c_hashsize < 0) {
 		return EINVAL;
+	}
 	if (cursor->q2c_users_done != 0 && cursor->q2c_users_done != 1) {
 		return EINVAL;
+	}
 @@ -962,260 +994,393 @@ q2cursor_check(struct ufsq2_cursor *curs
+	}
 	if (cursor->q2c_defaults_done != 0 && cursor->q2c_defaults_done != 1) {
 		return EINVAL;
+	}
 	if (cursor->q2c_hashpos < 0 || cursor->q2c_uidpos < 0) {
 		return EINVAL;
+	}
 	if (cursor->q2c_blocks_done != 0 && cursor->q2c_blocks_done != 1) {
 		return EINVAL;
+	}
 	return 0;
+}
-struct getuids {
+/*
-	long nuids; /* number of uids in array */
+ * Set up the q2cursor state.
-	long maxuids;  /* number of uids allocated */
+ */
-	uid_t *uids; /* array of uids, dynamically allocated */
+static void
-	long skip;
+q2cursor_initstate(struct q2cursor_state *state, struct quotakey *keys,
-	long seen;
+    struct quotaval *vals, unsigned maxkeyvals, int blocks_done)
 	long limit;
-};
+	state->keys = keys;
 	state->vals = vals;
 	state->maxkeyvals = maxkeyvals;
 	state->numkeys = 0;
 	/*
 	 * For each ID there are two quotavals to return. If the
 	 * maximum number of entries to return is odd, we might want
 	 * to skip the first quotaval of the first ID, or the last
 	 * quotaval of the last ID, but not both. So the number of IDs
 	 * we want is (up to) half the number of return slots we have,
 	 * rounded up.
 	 */
 	state->maxids = (state->maxkeyvals + 1) / 2;
 	state->numids = 0;
 	if (state->maxkeyvals % 2) {
 		if (blocks_done) {
 			state->skipfirst = 1;
 			state->skiplast = 0;
 		} else {
 			state->skipfirst = 0;
 			state->skiplast = 1;
+		}
 	} else {
 		state->skipfirst = 0;
 		state->skiplast = 0;
+	}
+}
 /*
  * Choose which idtype we're going to work on. If doing a full
  * iteration, we do users first, then groups, but either might be
  * disabled or marked to skip via cursorsetidtype(), so don't make
  * silly assumptions.
  */
 static int
 q2cursor_pickidtype(struct ufsq2_cursor *cursor, int *idtype_ret)
+{
 	if (cursor->q2c_users_done == 0) {
 		*idtype_ret = QUOTA_IDTYPE_USER;
 	} else if (cursor->q2c_groups_done == 0) {
 		*idtype_ret = QUOTA_IDTYPE_GROUP;
 	} else {
 		return EAGAIN;
+	}
 	return 0;
+}
 /*
  * Add an ID to the current state. Sets up either one or two keys to
  * refer to it, depending on whether it's first/last and the setting
  * of skipfirst. (skiplast does not need to be explicitly tested)
  */
 static void
 q2cursor_addid(struct q2cursor_state *state, int idtype, id_t id)
+{
 	KASSERT(state->numids < state->maxids);
 	KASSERT(state->numkeys < state->maxkeyvals);
 	if (!state->skipfirst || state->numkeys > 0) {
 		state->keys[state->numkeys].qk_idtype = idtype;
 		state->keys[state->numkeys].qk_id = id;
 		state->keys[state->numkeys].qk_objtype = QUOTA_OBJTYPE_BLOCKS;
 		state->numkeys++;
+	}
 	if (state->numkeys < state->maxkeyvals) {
 		state->keys[state->numkeys].qk_idtype = idtype;
 		state->keys[state->numkeys].qk_id = id;
 		state->keys[state->numkeys].qk_objtype = QUOTA_OBJTYPE_FILES;
 		state->numkeys++;
 	} else {
 		KASSERT(state->skiplast);
+	}
 	state->numids++;
+}
 /*
  * Callback function for getting IDs. Update counting and call addid.
  */
 static int
-quota2_getuids_callback(struct ufsmount *ump, uint64_t *offp,
+q2cursor_getids_callback(struct ufsmount *ump, uint64_t *offp,
     struct quota2_entry *q2ep, uint64_t off, void *v)
+{
-	struct getuids *gu = v;
+	struct q2cursor_getids *gi = v;
-	uid_t *newuids;
+	id_t id;
 	long newmax;
 #ifdef FFS_EI
 	const int needswap = UFS_MPNEEDSWAP(ump);
 #endif
-	if (gu->skip > 0) {
+	if (gi->skipped < gi->skip) {
-		gu->skip--;
+		gi->skipped++;
 		return 0;
+	}
-	if (gu->nuids == gu->maxuids) {
+	id = ufs_rw32(q2ep->q2e_uid, needswap);
-		newmax = gu->maxuids + PAGE_SIZE / sizeof(uid_t);
+	q2cursor_addid(gi->state, gi->idtype, id);
-		newuids = realloc(gu->uids, newmax * sizeof(gu->uids[0]),
+	gi->new_skip++;
-		    M_TEMP, M_WAITOK);
+	if (gi->state->numids >= gi->state->maxids) {
-		if (newuids == NULL) {
+		/* got enough ids, stop now */
 			return ENOMEM;
 		gu->uids = newuids;
 		gu->maxuids = newmax;
 	gu->uids[gu->nuids] = ufs_rw32(q2ep->q2e_uid, needswap);
 	gu->nuids++;
 	gu->seen++;
 	if (gu->nuids == gu->limit) {
 		return Q2WL_ABORT;
+	}
 	return 0;
+}
-int
+/*
-quota2_handle_cmd_cursorget(struct ufsmount *ump, struct quotakcursor *qkc,
+ * Fill in a batch of quotakeys by scanning one or more hash chains.
-    struct quotakey *keys, struct quotaval *vals, unsigned maxreturn,
+ */
-    unsigned *ret)
+static int
 q2cursor_getkeys(struct ufsmount *ump, int idtype, struct ufsq2_cursor *cursor,
     struct q2cursor_state *state,
     int *hashsize_ret, struct quota2_entry *default_q2e_ret)
+{
-	int error;
+	const int needswap = UFS_MPNEEDSWAP(ump);
 	struct ufsq2_cursor *cursor;
 	struct quota2_header *q2h;
 	struct quota2_entry  q2e;
 	struct buf *hbp;
-	uint64_t offset;
+	struct quota2_header *q2h;
 	int idtype;
 	int can_switch_idtype;
 	int i, j;
 	int quota2_hash_size;
-	const int needswap = UFS_MPNEEDSWAP(ump);
+	struct q2cursor_getids gi;
-	struct getuids gu;
+	uint64_t offset;
-	long excess;
+	int error;
 	id_t junkid;
 	struct quotaval qv;
 	unsigned num, maxnum;
 	int skipfirst, skiplast;
 	int numreturn;
 	cursor = Q2CURSOR(qkc);
 	error = q2cursor_check(cursor);
 	if (error) {
 		return error;
 	CTASSERT(USRQUOTA == QUOTA_IDTYPE_USER);
 	CTASSERT(GRPQUOTA == QUOTA_IDTYPE_GROUP);
 	if (cursor->q2c_users_done == 0 &&
 	    ump->um_quotas[USRQUOTA] == NULLVP) {
 		cursor->q2c_users_done = 1;
 	if (cursor->q2c_groups_done == 0 &&
 	    ump->um_quotas[GRPQUOTA] == NULLVP) {
 		cursor->q2c_groups_done = 1;
 restart:
 	if (cursor->q2c_users_done == 0) {
 		idtype = QUOTA_IDTYPE_USER;
 		can_switch_idtype = 1;
 	} else if (cursor->q2c_groups_done == 0) {
 		idtype = QUOTA_IDTYPE_GROUP;
 		can_switch_idtype = 0;
 	} else {
 		/* nothing more to do, return 0 */
 		*ret = 0;
 		return 0;
 	KASSERT(ump->um_quotas[idtype] != NULLVP);
-	numreturn = 0;
+	/*
 	 * Read the header block.
 	 */
 	mutex_enter(&dqlock);
 	error = getq2h(ump, idtype, &hbp, &q2h, 0);
 	if (error) {
 		mutex_exit(&dqlock);
 		return error;
+	}
 	if (cursor->q2c_defaults_done == 0) {
 		quota2_ufs_rwq2e(&q2h->q2h_defentry, &q2e, needswap);
 		if (cursor->q2c_blocks_done == 0) {
 			q2e_to_quotaval(&q2e, 1, &junkid, QL_BLOCK, &qv);
 			keys[numreturn].qk_idtype = idtype;
 			keys[numreturn].qk_id = QUOTA_DEFAULTID;
 			keys[numreturn].qk_objtype = QUOTA_OBJTYPE_BLOCKS;
 			vals[numreturn++] = qv;
 			cursor->q2c_blocks_done = 1;
 		if (cursor->q2c_blocks_done == 1) {
 			q2e_to_quotaval(&q2e, 1, &junkid, QL_FILE, &qv);
 			keys[numreturn].qk_idtype = idtype;
 			keys[numreturn].qk_id = QUOTA_DEFAULTID;
 			keys[numreturn].qk_objtype = QUOTA_OBJTYPE_FILES;
 			vals[numreturn++] = qv;
 			cursor->q2c_blocks_done = 0;
 			cursor->q2c_defaults_done = 1;
 	/*
 	 * we can't directly get entries as we can't walk the list
 	 * with qdlock and grab dq_interlock to read the entries
 	 * at the same time. So just walk the lists to build a list of uid,
 	 * and then read entries for these uids
 	 */
 	memset(&gu, 0, sizeof(gu));
 	quota2_hash_size = ufs_rw16(q2h->q2h_hash_size, needswap);
 	/* if the table size has changed, make the caller start over */
 	quota2_hash_size = ufs_rw16(q2h->q2h_hash_size, needswap);
 	if (cursor->q2c_hashsize == 0) {
 		cursor->q2c_hashsize = quota2_hash_size;
 	} else if (cursor->q2c_hashsize != quota2_hash_size) {
 		error = EDEADLK;
-		goto fail;
+		goto scanfail;
+	}
-	gu.skip = cursor->q2c_uidpos;
+	/* grab the entry with the default values out of the header */
-	gu.seen = 0;
+	quota2_ufs_rwq2e(&q2h->q2h_defentry, default_q2e_ret, needswap);
 	gu.limit = (maxreturn - numreturn) / 2;
-	if (gu.limit == 0 && (maxreturn - numreturn) > 0) {
+	/* If we haven't done the defaults yet, that goes first. */
-		gu.limit = 1;
+	if (cursor->q2c_defaults_done == 0) {
 		q2cursor_addid(state, idtype, QUOTA_DEFAULTID);
-	for (i = cursor->q2c_hashpos; i < quota2_hash_size ; i++) {
+		cursor->q2c_defaults_done = 1;
 		offset = q2h->q2h_entries[i];
 		gu.seen = 0;
-		error = quota2_walk_list(ump, hbp, idtype, &offset, 0, &gu,
+	gi.state = state;
-		    quota2_getuids_callback);
+	gi.idtype = idtype;
 		if (error && error != Q2WL_ABORT) {
-			if (gu.uids != NULL)
+	while (state->numids < state->maxids) {
-				free(gu.uids, M_TEMP);
+		if (cursor->q2c_hashpos >= quota2_hash_size) {
 			/* nothing more left */
 			break;
+		}
 		/* scan this hash chain */
 		gi.skip = cursor->q2c_uidpos;
 		gi.new_skip = gi.skip;
 		gi.skipped = 0;
 		offset = q2h->q2h_entries[cursor->q2c_hashpos];
 		error = quota2_walk_list(ump, hbp, idtype, &offset, 0, &gi,
 		    q2cursor_getids_callback);
 		if (error == Q2WL_ABORT) {
-			/* got enough uids for now */
+			/* callback stopped before reading whole chain */
 			cursor->q2c_uidpos = gi.new_skip;
 			/* not an error */
 			error = 0;
 		} else if (error) {
 		if (gu.nuids > gu.limit) {
 			excess = gu.nuids - gu.limit;
 			KASSERT(excess < gu.seen);
 			gu.seen -= excess;
 			gu.nuids -= excess;
 		if (gu.nuids == gu.limit) {
 			break;
 		} else {
 			/* read whole chain, advance to next */
 			cursor->q2c_uidpos = 0;
 			cursor->q2c_hashpos++;
+		}
+	}
 	KASSERT(gu.nuids <= gu.limit);
 	cursor->q2c_hashpos = i;
 	cursor->q2c_uidpos = gu.seen;
-fail:
+scanfail:
 	mutex_exit(&dqlock);
 	brelse(hbp, 0);
 	if (error)
 		return error;
-	if (gu.nuids == 0) {
+	*hashsize_ret = quota2_hash_size;
-		if (idtype == QUOTA_IDTYPE_USER)
+	return 0;
 			cursor->q2c_users_done = 1;
 		else
-			cursor->q2c_groups_done = 1;
+/*
-		if (can_switch_idtype) {
+ * Fetch the quotavals for the quotakeys.
-			goto restart;
+ */
 static int
 q2cursor_getvals(struct ufsmount *ump, struct q2cursor_state *state,
     const struct quota2_entry *default_q2e)
+{
 	int hasid;
 	id_t loadedid, id;
 	unsigned pos;
 	struct quota2_entry q2e;
 	int objtype;
 	int error;
 	hasid = 0;
 	loadedid = 0;
 	for (pos = 0; pos < state->numkeys; pos++) {
 		id = state->keys[pos].qk_id;
 		if (!hasid || id != loadedid) {
 			hasid = 1;
 			loadedid = id;
 			if (id == QUOTA_DEFAULTID) {
 				q2e = *default_q2e;
 			} else {
 				error = quota2_fetch_q2e(ump,
 							 &state->keys[pos],
 							 &q2e);
 				if (error == ENOENT) {
 					/* something changed - start over */
 					error = EDEADLK;
+				}
 				if (error) {
 					return error;
+				}
+ 			}
+		}
 		objtype = state->keys[pos].qk_objtype;
 		KASSERT(objtype >= 0 && objtype < N_QL);
 		q2val_to_quotaval(&q2e.q2e_val[objtype], &state->vals[pos]);
+	}
-	maxnum = gu.nuids*2;
+	return 0;
+}
 /*
  * Handle cursorget.
+ *
  * We can't just read keys and values directly, because we can't walk
  * the list with qdlock and grab dq_interlock to read the entries at
  * the same time. So we're going to do two passes: one to figure out
  * which IDs we want and fill in the keys, and then a second to use
  * the keys to fetch the values.
  */
 int
 quota2_handle_cmd_cursorget(struct ufsmount *ump, struct quotakcursor *qkc,
     struct quotakey *keys, struct quotaval *vals, unsigned maxreturn,
     unsigned *ret)
+{
 	int error;
 	struct ufsq2_cursor *cursor;
 	struct ufsq2_cursor newcursor;
 	struct q2cursor_state state;
 	struct quota2_entry default_q2e;
 	int idtype;
 	int quota2_hash_size;
 	/*
-	 * If we've already sent back the blocks value for the first id,
+	 * Convert and validate the cursor.
 	 * don't send it again (skipfirst).
 	 * If we have an odd number of available result slots and we
 	 * aren't going to skip the first result entry, we need to
 	 * leave off the last result entry (skiplast).
 	 */
-	skipfirst = (cursor->q2c_blocks_done != 0);
+	cursor = Q2CURSOR(qkc);
-	skiplast = skipfirst == 0 && (maxreturn < maxnum);
+	error = q2cursor_check(cursor);
-	num = 0;
+	if (error) {
-	for (j = 0; j < gu.nuids; j++) {
+		return error;
 		error = quota2_result_add_q2e(ump, idtype,
 		    gu.uids[j], keys, vals, numreturn + j*2,
-		    j == 0 && skipfirst,
+	/*
-		    j + 1 == gu.nuids && skiplast);
+	 * Make sure our on-disk codes match the values of the
-		if (error == ENOENT)
+	 * FS-independent ones. This avoids the need for explicit
-			continue;
+	 * conversion (which would be a NOP anyway and thus easily
-		if (error)
+	 * left out or called in the wrong places...)
-			break;
+	 */
-		if ((j == 0 && skipfirst) || (j + 1 == gu.nuids && skiplast)) {
+	CTASSERT(QUOTA_IDTYPE_USER == USRQUOTA);
-			num += 1;
+	CTASSERT(QUOTA_IDTYPE_GROUP == GRPQUOTA);
 	CTASSERT(QUOTA_OBJTYPE_BLOCKS == QL_BLOCK);
 	CTASSERT(QUOTA_OBJTYPE_FILES == QL_FILE);
 	/*
 	 * If some of the idtypes aren't configured/enabled, arrange
 	 * to skip over them.
 	 */
 	if (cursor->q2c_users_done == 0 &&
 	    ump->um_quotas[USRQUOTA] == NULLVP) {
 		cursor->q2c_users_done = 1;
+	}
 	if (cursor->q2c_groups_done == 0 &&
 	    ump->um_quotas[GRPQUOTA] == NULLVP) {
 		cursor->q2c_groups_done = 1;
+	}
 	/* Loop over, potentially, both idtypes */
 	while (1) {
 		/* Choose id type */
 		error = q2cursor_pickidtype(cursor, &idtype);
 		if (error == EAGAIN) {
 			/* nothing more to do, return 0 */
 			*ret = 0;
 			return 0;
+		}
 		KASSERT(ump->um_quotas[idtype] != NULLVP);
 		/*
 		 * Initialize the per-call iteration state. Copy the
 		 * cursor state so we can update it in place but back
 		 * out on error.
 		 */
 		q2cursor_initstate(&state, keys, vals, maxreturn,
 				   cursor->q2c_blocks_done);
 		newcursor = *cursor;
 		/* Assign keys */
 		error = q2cursor_getkeys(ump, idtype, &newcursor, &state,
 					 &quota2_hash_size, &default_q2e);
 		if (error) {
 			return error;
+		}
 		/* Now fill in the values. */
 		error = q2cursor_getvals(ump, &state, &default_q2e);
 		if (error) {
 			return error;
+		}
 		/*
 		 * Now that we aren't going to fail and lose what we
 		 * did so far, we can update the cursor state.
 		 */
 		if (newcursor.q2c_hashpos >= quota2_hash_size) {
 			if (idtype == QUOTA_IDTYPE_USER)
 				cursor->q2c_users_done = 1;
 			else
 				cursor->q2c_groups_done = 1;
 			/* start over on another id type */
 			cursor->q2c_hashsize = 0;
 			cursor->q2c_defaults_done = 0;
 			cursor->q2c_hashpos = 0;
 			cursor->q2c_uidpos = 0;
 			cursor->q2c_blocks_done = 0;
 		} else {
-			num += 2;
+			*cursor = newcursor;
 			cursor->q2c_blocks_done = state.skiplast;
+		}
 	numreturn += num;
 	*ret = numreturn;
-	cursor->q2c_blocks_done = skiplast;
+		/*
 		 * If we have something to return, return it.
 		 * Otherwise, continue to the other idtype, if any,
 		 * and only return zero at end of iteration.
 		 */
 		if (state.numkeys > 0) {
 			break;
+		}
+	}
-	if (gu.uids != NULL)
+	*ret = state.numkeys;
-		free(gu.uids, M_TEMP);
+	return 0;
 	return error;
+}
 int
 quota2_handle_cmd_cursoropen(struct ufsmount *ump, struct quotakcursor *qkc)
+{
 	struct ufsq2_cursor *cursor;
 	CTASSERT(sizeof(*cursor) <= sizeof(qkc->u.qkc_space));
 	cursor = Q2CURSOR(qkc);
 	cursor->q2c_magic = Q2C_MAGIC;
 	cursor->q2c_hashsize = 0;