 @@ -1,801 +1,801 @@
-/*	$NetBSD: vfs_quotactl.c,v 1.28 2012/01/29 07:08:58 dholland Exp $	*/
+/*	$NetBSD: vfs_quotactl.c,v 1.29 2012/01/29 07:09:52 dholland Exp $	*/
 /*
  * Copyright (c) 1991, 1993, 1994
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
+ *
  * 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.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS 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.
+ *
  *	@(#)ufs_vfsops.c	8.8 (Berkeley) 5/20/95
  *	From NetBSD: ufs_vfsops.c,v 1.42 2011/03/24 17:05:46 bouyer Exp
  */
 /*
  * Copyright (c) 1982, 1986, 1990, 1993, 1995
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Robert Elz at The University of Melbourne.
+ *
  * 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.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS 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.
+ *
  *	@(#)ufs_quota.c	8.5 (Berkeley) 5/20/95
  *	From NetBSD: ufs_quota.c,v 1.70 2011/03/24 17:05:46 bouyer Exp
  */
 /*
  * Note that both of the copyrights above are moderately spurious;
  * this code should almost certainly have the Copyright 2010 Manuel
  * Bouyer notice and license found in e.g. sys/ufs/ufs/quota2_subr.c.
  * However, they're what was on the files this code was sliced out of.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_quotactl.c,v 1.28 2012/01/29 07:08:58 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_quotactl.c,v 1.29 2012/01/29 07:09:52 dholland Exp $");
 #include <sys/malloc.h> /* XXX: temporary */
 #include <sys/mount.h>
 #include <sys/quota.h>
 #include <sys/quotactl.h>
 #include <quota/quotaprop.h>
 static int
 vfs_quotactl_getversion(struct mount *mp,
 			prop_dictionary_t cmddict, int q2type,
 			prop_array_t datas)
+{
 	prop_array_t replies;
 	prop_dictionary_t data;
 	int q2version;
 	struct vfs_quotactl_args args;
 	int error;
 	KASSERT(prop_object_type(cmddict) == PROP_TYPE_DICTIONARY);
 	KASSERT(prop_object_type(datas) == PROP_TYPE_ARRAY);
 	args.qc_type = QCT_GETVERSION;
 	args.u.getversion.qc_version_ret = &q2version;
 	error = VFS_QUOTACTL(mp, QUOTACTL_GETVERSION, &args);
 	if (error) {
 		return error;
+	}
 	data = prop_dictionary_create();
 	if (data == NULL) {
 		return ENOMEM;
+	}
 	if (!prop_dictionary_set_int8(data, "version", q2version)) {
 		prop_object_release(data);
 		return ENOMEM;
+	}
 	replies = prop_array_create();
 	if (replies == NULL) {
 		prop_object_release(data);
 		return ENOMEM;
+	}
 	if (!prop_array_add_and_rel(replies, data)) {
 		prop_object_release(data);
 		prop_object_release(replies);
 		return ENOMEM;
+	}
 	if (!prop_dictionary_set_and_rel(cmddict, "data", replies)) {
 		prop_object_release(replies);
 		return ENOMEM;
+	}
 	return error;
+}
 static int
 vfs_quotactl_quotaon(struct mount *mp,
 		     prop_dictionary_t cmddict, int q2type,
 		     prop_array_t datas)
+{
 	struct vfs_quotactl_args args;
 	args.qc_type = QCT_PROPLIB;
 	args.u.proplib.qc_cmddict = cmddict;
 	args.u.proplib.qc_q2type = q2type;
 	args.u.proplib.qc_datas = datas;
 	return VFS_QUOTACTL(mp, QUOTACTL_QUOTAON, &args);
+}
 static int
 vfs_quotactl_quotaoff(struct mount *mp,
 			prop_dictionary_t cmddict, int q2type,
 			prop_array_t datas)
+{
 	struct vfs_quotactl_args args;
 	args.qc_type = QCT_PROPLIB;
 	args.u.proplib.qc_cmddict = cmddict;
 	args.u.proplib.qc_q2type = q2type;
 	args.u.proplib.qc_datas = datas;
 	return VFS_QUOTACTL(mp, QUOTACTL_QUOTAOFF, &args);
+}
 static int
 vfs_quotactl_get_addreply(const struct quotakey *qk,
 			  const struct quotaval *blocks,
 			  const struct quotaval *files,
 			  prop_array_t replies)
+{
 	prop_dictionary_t dict;
 	id_t id;
 	int defaultq;
 	uint64_t *valuesp[QUOTA_NLIMITS];
 	/* XXX illegal casts */
 	valuesp[QUOTA_LIMIT_BLOCK] = (void *)(intptr_t)&blocks->qv_hardlimit;
 	valuesp[QUOTA_LIMIT_FILE] =  (void *)(intptr_t)&files->qv_hardlimit;
 	if (qk->qk_id == QUOTA_DEFAULTID) {
 		id = 0;
 		defaultq = 1;
 	} else {
 		id = qk->qk_id;
 		defaultq = 0;
+	}
 	dict = quota64toprop(id, defaultq, valuesp,
 	    ufs_quota_entry_names, UFS_QUOTA_NENTRIES,
 	    ufs_quota_limit_names, QUOTA_NLIMITS);
 	if (dict == NULL)
 		return ENOMEM;
 	if (!prop_array_add_and_rel(replies, dict)) {
 		prop_object_release(dict);
 		return ENOMEM;
+	}
 	return 0;
+}
 static int
 vfs_quotactl_get(struct mount *mp,
 			prop_dictionary_t cmddict, int idtype,
 			prop_array_t datas)
+{
 	prop_object_iterator_t iter;
 	prop_dictionary_t data;
 	prop_array_t replies;
 	uint32_t id;
 	const char *idstr;
 	struct vfs_quotactl_args args;
 	struct quotakey qk;
 	struct quotaval blocks, files;
 	int error;
 	KASSERT(prop_object_type(cmddict) == PROP_TYPE_DICTIONARY);
 	KASSERT(prop_object_type(datas) == PROP_TYPE_ARRAY);
 	replies = prop_array_create();
 	if (replies == NULL) {
 		return ENOMEM;
+	}
 	iter = prop_array_iterator(datas);
 	if (iter == NULL) {
 		prop_object_release(replies);
 		return ENOMEM;
+	}
 	while ((data = prop_object_iterator_next(iter)) != NULL) {
 		qk.qk_idtype = idtype;
 		if (!prop_dictionary_get_uint32(data, "id", &id)) {
 			if (!prop_dictionary_get_cstring_nocopy(data, "id",
 			    &idstr))
 				continue;
 			if (strcmp(idstr, "default")) {
 				error = EINVAL;
 				goto fail;
+			}
 			qk.qk_id = QUOTA_DEFAULTID;
 		} else {
 			qk.qk_id = id;
+		}
 		qk.qk_objtype = QUOTA_OBJTYPE_BLOCKS;
 		args.qc_type = QCT_GET;
 		args.u.get.qc_key = &qk;
 		args.u.get.qc_ret = &blocks;
 		error = VFS_QUOTACTL(mp, QUOTACTL_GET, &args);
 		if (error == EPERM) {
 			/* XXX does this make sense? */
 			continue;
 		} else if (error == ENOENT) {
 			/* XXX does *this* make sense? */
 			continue;
 		} else if (error) {
 			goto fail;
+		}
 		qk.qk_objtype = QUOTA_OBJTYPE_FILES;
 		args.qc_type = QCT_GET;
 		args.u.get.qc_key = &qk;
 		args.u.get.qc_ret = &files;
 		error = VFS_QUOTACTL(mp, QUOTACTL_GET, &args);
 		if (error == EPERM) {
 			/* XXX does this make sense? */
 			continue;
 		} else if (error == ENOENT) {
 			/* XXX does *this* make sense? */
 			continue;
 		} else if (error) {
 			goto fail;
+		}
 		error = vfs_quotactl_get_addreply(&qk, &blocks, &files,
 						  replies);
+	}
 	prop_object_iterator_release(iter);
 	if (!prop_dictionary_set_and_rel(cmddict, "data", replies)) {
 		error = ENOMEM;
 	} else {
 		error = 0;
+	}
 	return error;
  fail:
 	prop_object_iterator_release(iter);
 	prop_object_release(replies);
 	return error;
+}
 static int
 vfs_quotactl_put_extractinfo(prop_dictionary_t data,
 			struct quotaval *blocks, struct quotaval *files)
+{
 	/*
 	 * So, the way proptoquota64 works is that you pass it an
 	 * array of pointers to uint64. Each of these pointers is
 	 * supposed to point to 5 (UFS_QUOTA_NENTRIES) uint64s. This
 	 * array of pointers is the second argument. The third and
 	 * forth argument are the names of the five values to extract,
 	 * and UFS_QUOTA_NENTRIES. The last two arguments are the
 	 * names assocated with the pointers (QUOTATYPE_LDICT_BLOCK,
 	 * QUOTADICT_LTYPE_FILE) and the number of pointers. Most of
 	 * the existing code was unsafely casting struct quotaval
 	 * (formerly struct ufs_quota_entry) to (uint64_t *) and using
 	 * that as the block of 5 uint64s. Or worse, pointing to
 	 * subregions of that and reducing the number of uint64s to
 	 * pull "adjacent" values. Demons fly out of your nose!
 	 */
 	uint64_t bvals[UFS_QUOTA_NENTRIES];
 	uint64_t fvals[UFS_QUOTA_NENTRIES];
 	uint64_t *valptrs[QUOTA_NLIMITS];
 	int error;
 	valptrs[QUOTA_LIMIT_BLOCK] = bvals;
 	valptrs[QUOTA_LIMIT_FILE] = fvals;
 	error = proptoquota64(data, valptrs,
 			      ufs_quota_entry_names, UFS_QUOTA_NENTRIES,
 			      ufs_quota_limit_names, QUOTA_NLIMITS);
 	if (error) {
 		return error;
+	}
 	/*
 	 * There are no symbolic constants for these indexes!
 	 */
 	blocks->qv_hardlimit = bvals[0];
 	blocks->qv_softlimit = bvals[1];
 	blocks->qv_usage = bvals[2];
 	blocks->qv_expiretime = bvals[3];
 	blocks->qv_grace = bvals[4];
 	files->qv_hardlimit = fvals[0];
 	files->qv_softlimit = fvals[1];
 	files->qv_usage = fvals[2];
 	files->qv_expiretime = fvals[3];
 	files->qv_grace = fvals[4];
 	return 0;
+}
 static int
 vfs_quotactl_put(struct mount *mp,
 			prop_dictionary_t cmddict, int q2type,
 			prop_array_t datas)
+{
 	prop_array_t replies;
 	prop_object_iterator_t iter;
 	prop_dictionary_t data;
 	int defaultq;
 	uint32_t id;
 	const char *idstr;
 	struct quotakey qk;
 	struct quotaval blocks, files;
 	struct vfs_quotactl_args args;
 	int error;
 	KASSERT(prop_object_type(cmddict) == PROP_TYPE_DICTIONARY);
 	KASSERT(prop_object_type(datas) == PROP_TYPE_ARRAY);
 	replies = prop_array_create();
 	if (replies == NULL)
 		return ENOMEM;
 	iter = prop_array_iterator(datas);
 	if (iter == NULL) {
 		prop_object_release(replies);
 		return ENOMEM;
+	}
 	while ((data = prop_object_iterator_next(iter)) != NULL) {
 		KASSERT(prop_object_type(data) == PROP_TYPE_DICTIONARY);
 		if (!prop_dictionary_get_uint32(data, "id", &id)) {
 			if (!prop_dictionary_get_cstring_nocopy(data, "id",
 			    &idstr))
 				continue;
 			if (strcmp(idstr, "default"))
 				continue;
 			id = 0;
 			defaultq = 1;
 		} else {
 			defaultq = 0;
+		}
 		error = vfs_quotactl_put_extractinfo(data, &blocks, &files);
 		if (error) {
 			goto err;
+		}
 		qk.qk_idtype = q2type;
 		qk.qk_id = defaultq ? QUOTA_DEFAULTID : id;
 		qk.qk_objtype = QUOTA_OBJTYPE_BLOCKS;
 		args.qc_type = QCT_PUT;
 		args.u.put.qc_key = &qk;
 		args.u.put.qc_val = &blocks;
 		error = VFS_QUOTACTL(mp, QUOTACTL_PUT, &args);
 		if (error) {
 			goto err;
+		}
 		qk.qk_idtype = q2type;
 		qk.qk_id = defaultq ? QUOTA_DEFAULTID : id;
 		qk.qk_objtype = QUOTA_OBJTYPE_FILES;
 		args.qc_type = QCT_PUT;
 		args.u.put.qc_key = &qk;
 		args.u.put.qc_val = &files;
 		error = VFS_QUOTACTL(mp, QUOTACTL_PUT, &args);
 		if (error) {
 			goto err;
+		}
+	}
 	prop_object_iterator_release(iter);
 	if (!prop_dictionary_set_and_rel(cmddict, "data", replies)) {
 		error = ENOMEM;
 	} else {
 		error = 0;
+	}
 	return error;
 err:
 	prop_object_iterator_release(iter);
 	prop_object_release(replies);
 	return error;
+}
 static prop_dictionary_t
 vfs_quotactl_getall_makereply(const struct quotakey *key)
+{
 	prop_dictionary_t dict;
 	id_t id;
 	int defaultq;
 	dict = prop_dictionary_create();
 	if (dict == NULL)
 		return NULL;
 	id = key->qk_id;
 	if (id == QUOTA_DEFAULTID) {
 		id = 0;
 		defaultq = 1;
 	} else {
 		defaultq = 0;
+	}
 	if (defaultq) {
 		if (!prop_dictionary_set_cstring_nocopy(dict, "id",
 		    "default")) {
 			goto err;
+		}
 	} else {
 		if (!prop_dictionary_set_uint32(dict, "id", id)) {
 			goto err;
+		}
+	}
 	return dict;
 err:
 	prop_object_release(dict);
 	return NULL;
+}
 static int
 vfs_quotactl_getall_addreply(prop_dictionary_t thisreply,
     const struct quotakey *key, const struct quotaval *val)
+{
 #define INITQVNAMES_ALL { \
     QUOTADICT_LIMIT_HARD, \
     QUOTADICT_LIMIT_SOFT, \
     QUOTADICT_LIMIT_USAGE, \
     QUOTADICT_LIMIT_ETIME, \
     QUOTADICT_LIMIT_GTIME \
+    }
 #define N_QV 5
 	const char *val_names[] = INITQVNAMES_ALL;
 	uint64_t vals[N_QV];
 	prop_dictionary_t dict2;
 	const char *objtypename;
 	switch (key->qk_objtype) {
 	    case QUOTA_OBJTYPE_BLOCKS:
 		objtypename = QUOTADICT_LTYPE_BLOCK;
 		break;
 	    case QUOTA_OBJTYPE_FILES:
 		objtypename = QUOTADICT_LTYPE_FILE;
 		break;
 	    default:
 		return EINVAL;
+	}
 	vals[0] = val->qv_hardlimit;
 	vals[1] = val->qv_softlimit;
 	vals[2] = val->qv_usage;
 	vals[3] = val->qv_expiretime;
 	vals[4] = val->qv_grace;
 	dict2 = limits64toprop(vals, val_names, N_QV);
 	if (dict2 == NULL)
 		return ENOMEM;
 	if (!prop_dictionary_set_and_rel(thisreply, objtypename, dict2))
 		return ENOMEM;
 	return 0;
+}
 static int
 vfs_quotactl_getall(struct mount *mp,
 			prop_dictionary_t cmddict, int q2type,
 			prop_array_t datas)
+{
 	struct quotakcursor cursor;
 	struct quotakey *keys;
 	struct quotaval *vals;
 	unsigned loopmax = 8;
 	unsigned loopnum;
 	struct vfs_quotactl_args args;
 	prop_array_t replies;
 	struct quotakey *key;
 	struct quotaval *val;
 	id_t lastid;
 	prop_dictionary_t thisreply;
 	unsigned i;
 	int error, error2;
 	KASSERT(prop_object_type(cmddict) == PROP_TYPE_DICTIONARY);
 	args.qc_type = QCT_CURSOROPEN;
 	args.u.cursoropen.qc_cursor = &cursor;
 	error = VFS_QUOTACTL(mp, QUOTACTL_CURSOROPEN, &args);
 	if (error) {
 		return error;
+	}
 	keys = malloc(loopmax * sizeof(keys[0]), M_TEMP, M_WAITOK);
 	vals = malloc(loopmax * sizeof(vals[0]), M_TEMP, M_WAITOK);
 	replies = prop_array_create();
 	if (replies == NULL) {
 		error = ENOMEM;
 		goto err;
+	}
 	thisreply = NULL;
 	lastid = 0; /* value not actually referenced */
 	while (1) {
-		args.qc_type = QCT_GETALL;
+		args.qc_type = QCT_CURSORGET;
-		args.u.getall.qc_cursor = &cursor;
+		args.u.cursorget.qc_cursor = &cursor;
-		args.u.getall.qc_keys = keys;
+		args.u.cursorget.qc_keys = keys;
-		args.u.getall.qc_vals = vals;
+		args.u.cursorget.qc_vals = vals;
-		args.u.getall.qc_maxnum = loopmax;
+		args.u.cursorget.qc_maxnum = loopmax;
-		args.u.getall.qc_ret = &loopnum;
+		args.u.cursorget.qc_ret = &loopnum;
-		error = VFS_QUOTACTL(mp, QUOTACTL_GETALL, &args);
+		error = VFS_QUOTACTL(mp, QUOTACTL_CURSORGET, &args);
 		if (error) {
 			goto err;
+		}
 		if (loopnum == 0) {
 			/* end of iteration */
 			break;
+		}
 		for (i = 0; i < loopnum; i++) {
 			key = &keys[i];
 			val = &vals[i];
 			if (key->qk_idtype != q2type) {
 				/* don't want this result */
 				continue;
+			}
 			if (thisreply == NULL || key->qk_id != lastid) {
 				lastid = key->qk_id;
 				thisreply = vfs_quotactl_getall_makereply(key);
 				if (thisreply == NULL) {
 					error = ENOMEM;
 					goto err;
+				}
 				/*
 				 * Note: while we release our reference to
 				 * thisreply here, we can (and do) continue to
 				 * use the pointer in the loop because the
 				 * copy attached to the replies array is not
 				 * going away.
 				 */
 				if (!prop_array_add_and_rel(replies,
 							    thisreply)) {
 					error = ENOMEM;
 					goto err;
+				}
+			}
 			error = vfs_quotactl_getall_addreply(thisreply,
 							     key, val);
 			if (error) {
 				goto err;
+			}
+		}
+	}
 	if (!prop_dictionary_set_and_rel(cmddict, "data", replies)) {
 		error = ENOMEM;
 		goto err;
+	}
 	error = 0;
  err:
 	free(keys, M_TEMP);
 	free(vals, M_TEMP);
 	args.qc_type = QCT_CURSORCLOSE;
 	args.u.cursorclose.qc_cursor = &cursor;
 	error2 = VFS_QUOTACTL(mp, QUOTACTL_CURSORCLOSE, &args);
 	if (error) {
 		return error;
+	}
 	error = error2;
 	return error;
+}
 static int
 vfs_quotactl_clear(struct mount *mp,
 			prop_dictionary_t cmddict, int q2type,
 			prop_array_t datas)
+{
 	prop_array_t replies;
 	prop_object_iterator_t iter;
 	prop_dictionary_t data;
 	uint32_t id;
 	int defaultq;
 	const char *idstr;
 	struct quotakey qk;
 	struct vfs_quotactl_args args;
 	int error;
 	KASSERT(prop_object_type(cmddict) == PROP_TYPE_DICTIONARY);
 	KASSERT(prop_object_type(datas) == PROP_TYPE_ARRAY);
 	replies = prop_array_create();
 	if (replies == NULL)
 		return ENOMEM;
 	iter = prop_array_iterator(datas);
 	if (iter == NULL) {
 		prop_object_release(replies);
 		return ENOMEM;
+	}
 	while ((data = prop_object_iterator_next(iter)) != NULL) {
 		if (!prop_dictionary_get_uint32(data, "id", &id)) {
 			if (!prop_dictionary_get_cstring_nocopy(data, "id",
 			    &idstr))
 				continue;
 			if (strcmp(idstr, "default"))
 				continue;
 			id = 0;
 			defaultq = 1;
 		} else {
 			defaultq = 0;
+		}
 		qk.qk_idtype = q2type;
 		qk.qk_id = defaultq ? QUOTA_DEFAULTID : id;
 		qk.qk_objtype = QUOTA_OBJTYPE_BLOCKS;
 		args.qc_type = QCT_DELETE;
 		args.u.delete.qc_key = &qk;
 		error = VFS_QUOTACTL(mp, QUOTACTL_DELETE, &args);
 		if (error) {
 			goto err;
+		}
 		qk.qk_idtype = q2type;
 		qk.qk_id = defaultq ? QUOTA_DEFAULTID : id;
 		qk.qk_objtype = QUOTA_OBJTYPE_FILES;
 		args.qc_type = QCT_DELETE;
 		args.u.delete.qc_key = &qk;
 		error = VFS_QUOTACTL(mp, QUOTACTL_DELETE, &args);
 		if (error) {
 			goto err;
+		}
+	}
 	prop_object_iterator_release(iter);
 	if (!prop_dictionary_set_and_rel(cmddict, "data", replies)) {
 		error = ENOMEM;
 	} else {
 		error = 0;
+	}
 	return error;
 err:
 	prop_object_iterator_release(iter);
 	prop_object_release(replies);
 	return error;
+}
 static int
 vfs_quotactl_cmd(struct mount *mp, prop_dictionary_t cmddict)
+{
 	int error;
 	const char *cmd, *type;
 	prop_array_t datas;
 	int q2type;
 	if (!prop_dictionary_get_cstring_nocopy(cmddict, "command", &cmd))
 		return EINVAL;
 	if (!prop_dictionary_get_cstring_nocopy(cmddict, "type", &type))
 		return EINVAL;
 	if (!strcmp(type, QUOTADICT_CLASS_USER)) {
 		q2type = QUOTA_CLASS_USER;
 	} else if (!strcmp(type, QUOTADICT_CLASS_GROUP)) {
 		q2type = QUOTA_CLASS_GROUP;
 	} else {
 		/* XXX this is a bad errno for this case */
 		return EOPNOTSUPP;
+	}
 	datas = prop_dictionary_get(cmddict, "data");
 	if (datas == NULL || prop_object_type(datas) != PROP_TYPE_ARRAY)
 		return EINVAL;
 	prop_object_retain(datas);
 	prop_dictionary_remove(cmddict, "data"); /* prepare for return */
 	if (strcmp(cmd, "get version") == 0) {
 		error = vfs_quotactl_getversion(mp, cmddict, q2type, datas);
 	} else if (strcmp(cmd, "quotaon") == 0) {
 		error = vfs_quotactl_quotaon(mp, cmddict, q2type, datas);
 	} else if (strcmp(cmd, "quotaoff") == 0) {
 		error = vfs_quotactl_quotaoff(mp, cmddict, q2type, datas);
 	} else if (strcmp(cmd, "get") == 0) {
 		error = vfs_quotactl_get(mp, cmddict, q2type, datas);
 	} else if (strcmp(cmd, "set") == 0) {
 		error = vfs_quotactl_put(mp, cmddict, q2type, datas);
 	} else if (strcmp(cmd, "getall") == 0) {
 		error = vfs_quotactl_getall(mp, cmddict, q2type, datas);
 	} else if (strcmp(cmd, "clear") == 0) {
 		error = vfs_quotactl_clear(mp, cmddict, q2type, datas);
 	} else {
 		/* XXX this a bad errno for this case */
 		error = EOPNOTSUPP;
+	}
 	error = (prop_dictionary_set_int8(cmddict, "return",
 	    error) ? 0 : ENOMEM);
 	prop_object_release(datas);
 	return error;
+}
 int
 vfs_quotactl(struct mount *mp, prop_dictionary_t dict)
+{
 	prop_dictionary_t cmddict;
 	prop_array_t commands;
 	prop_object_iterator_t iter;
 	int error;
 	error = quota_get_cmds(dict, &commands);
 	if (error) {
 		return error;
+	}
 	iter = prop_array_iterator(commands);
 	if (iter == NULL) {
 		return ENOMEM;
+	}
 	while ((cmddict = prop_object_iterator_next(iter)) != NULL) {
 		if (prop_object_type(cmddict) != PROP_TYPE_DICTIONARY) {
 			/* XXX shouldn't this be an error? */
 			continue;
+		}
 		error = vfs_quotactl_cmd(mp, cmddict);
 		if (error) {
 			break;
+		}
+	}
 	prop_object_iterator_release(iter);
 	return error;
+}

 @@ -1,840 +1,922 @@
-/*	$NetBSD: ufs_quota.c,v 1.97 2012/01/29 07:08:58 dholland Exp $	*/
+/*	$NetBSD: ufs_quota.c,v 1.98 2012/01/29 07:09:52 dholland Exp $	*/
 /*
  * Copyright (c) 1982, 1986, 1990, 1993, 1995
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Robert Elz at The University of Melbourne.
+ *
  * 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.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``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 REGENTS 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.
+ *
  *	@(#)ufs_quota.c	8.5 (Berkeley) 5/20/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ufs_quota.c,v 1.97 2012/01/29 07:08:58 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ufs_quota.c,v 1.98 2012/01/29 07:09:52 dholland Exp $");
 #if defined(_KERNEL_OPT)
 #include "opt_quota.h"
 #endif
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/systm.h>
 #include <sys/namei.h>
 #include <sys/file.h>
 #include <sys/proc.h>
 #include <sys/vnode.h>
 #include <sys/mount.h>
 #include <sys/kauth.h>
 #include <sys/quotactl.h>
 #include <ufs/ufs/quota.h>
 #include <ufs/ufs/inode.h>
 #include <ufs/ufs/ufsmount.h>
 #include <ufs/ufs/ufs_extern.h>
 #include <ufs/ufs/ufs_quota.h>
 #include <quota/quotaprop.h>
 kmutex_t dqlock;
 kcondvar_t dqcv;
 /*
  * Code pertaining to management of the in-core dquot data structures.
  */
 #define DQHASH(dqvp, id) \
 	(((((long)(dqvp)) >> 8) + id) & dqhash)
 static LIST_HEAD(dqhashhead, dquot) *dqhashtbl;
 static u_long dqhash;
 static pool_cache_t dquot_cache;
 static int quota_handle_cmd_get_version(struct mount *, struct lwp *,
     struct vfs_quotactl_args *args);
 static int quota_handle_cmd_get(struct mount *, struct lwp *,
     struct vfs_quotactl_args *args);
 static int quota_handle_cmd_put(struct mount *, struct lwp *,
     struct vfs_quotactl_args *args);
-static int quota_handle_cmd_getall(struct mount *, struct lwp *,
+static int quota_handle_cmd_cursorget(struct mount *, struct lwp *,
     struct vfs_quotactl_args *args);
 static int quota_handle_cmd_delete(struct mount *, struct lwp *,
     struct vfs_quotactl_args *args);
 static int quota_handle_cmd_quotaon(struct mount *, struct lwp *,
     struct vfs_quotactl_args *args);
 static int quota_handle_cmd_quotaoff(struct mount *, struct lwp *,
     struct vfs_quotactl_args *args);
 static int quota_handle_cmd_cursoropen(struct mount *, struct lwp *,
     struct vfs_quotactl_args *args);
 static int quota_handle_cmd_cursorclose(struct mount *, struct lwp *,
     struct vfs_quotactl_args *args);
 static int quota_handle_cmd_cursorskipidtype(struct mount *, struct lwp *,
     struct vfs_quotactl_args *args);
 static int quota_handle_cmd_cursoratend(struct mount *, struct lwp *,
     struct vfs_quotactl_args *args);
 static int quota_handle_cmd_cursorrewind(struct mount *, struct lwp *,
     struct vfs_quotactl_args *args);
 /*
  * Initialize the quota fields of an inode.
  */
 void
 ufsquota_init(struct inode *ip)
+{
 	int i;
 	for (i = 0; i < MAXQUOTAS; i++)
 		ip->i_dquot[i] = NODQUOT;
+}
 /*
  * Release the quota fields from an inode.
  */
 void
 ufsquota_free(struct inode *ip)
+{
 	int i;
 	for (i = 0; i < MAXQUOTAS; i++) {
 		dqrele(ITOV(ip), ip->i_dquot[i]);
 		ip->i_dquot[i] = NODQUOT;
+	}
+}
 /*
  * Update disk usage, and take corrective action.
  */
 int
 chkdq(struct inode *ip, int64_t change, kauth_cred_t cred, int flags)
+{
 	/* do not track snapshot usage, or we will deadlock */
 	if ((ip->i_flags & SF_SNAPSHOT) != 0)
 		return 0;
 #ifdef QUOTA
 	if (ip->i_ump->um_flags & UFS_QUOTA)
 		return chkdq1(ip, change, cred, flags);
 #endif
 #ifdef QUOTA2
 	if (ip->i_ump->um_flags & UFS_QUOTA2)
 		return chkdq2(ip, change, cred, flags);
 #endif
 	return 0;
+}
 /*
  * Check the inode limit, applying corrective action.
  */
 int
 chkiq(struct inode *ip, int32_t change, kauth_cred_t cred, int flags)
+{
 	/* do not track snapshot usage, or we will deadlock */
 	if ((ip->i_flags & SF_SNAPSHOT) != 0)
 		return 0;
 #ifdef QUOTA
 	if (ip->i_ump->um_flags & UFS_QUOTA)
 		return chkiq1(ip, change, cred, flags);
 #endif
 #ifdef QUOTA2
 	if (ip->i_ump->um_flags & UFS_QUOTA2)
 		return chkiq2(ip, change, cred, flags);
 #endif
 	return 0;
+}
 int
 quota_handle_cmd(struct mount *mp, struct lwp *l, int op,
 		 struct vfs_quotactl_args *args)
+{
 	int error = 0;
 	switch (op) {
 	    case QUOTACTL_GETVERSION:
 		error = quota_handle_cmd_get_version(mp, l, args);
 		break;
 	    case QUOTACTL_QUOTAON:
 		error = quota_handle_cmd_quotaon(mp, l, args);
 		break;
 	    case QUOTACTL_QUOTAOFF:
 		error = quota_handle_cmd_quotaoff(mp, l, args);
 		break;
 	    case QUOTACTL_GET:
 		error = quota_handle_cmd_get(mp, l, args);
 		break;
 	    case QUOTACTL_PUT:
 		error = quota_handle_cmd_put(mp, l, args);
 		break;
-	    case QUOTACTL_GETALL:
+	    case QUOTACTL_CURSORGET:
-		error = quota_handle_cmd_getall(mp, l, args);
+		error = quota_handle_cmd_cursorget(mp, l, args);
 		break;
 	    case QUOTACTL_DELETE:
 		error = quota_handle_cmd_delete(mp, l, args);
 		break;
 	    case QUOTACTL_CURSOROPEN:
 		error = quota_handle_cmd_cursoropen(mp, l, args);
 		break;
 	    case QUOTACTL_CURSORCLOSE:
 		error = quota_handle_cmd_cursorclose(mp, l, args);
 		break;
 	    case QUOTACTL_CURSORSKIPIDTYPE:
 		error = quota_handle_cmd_cursorskipidtype(mp, l, args);
 		break;
 	    case QUOTACTL_CURSORATEND:
 		error = quota_handle_cmd_cursoratend(mp, l, args);
 		break;
 	    case QUOTACTL_CURSORREWIND:
 		error = quota_handle_cmd_cursorrewind(mp, l, args);
 		break;
 	    default:
 		panic("Invalid quotactl operation %d\n", op);
+	}
 	return error;
+}
 static int
 quota_handle_cmd_get_version(struct mount *mp, struct lwp *l,
     struct vfs_quotactl_args *args)
+{
 	struct ufsmount *ump = VFSTOUFS(mp);
 	int *version_ret;
 	KASSERT(args->qc_type == QCT_GETVERSION);
 	version_ret = args->u.getversion.qc_version_ret;
 	if ((ump->um_flags & (UFS_QUOTA|UFS_QUOTA2)) == 0)
 		return EOPNOTSUPP;
 #ifdef QUOTA
 	if (ump->um_flags & UFS_QUOTA) {
 		*version_ret = 1;
 	} else
 #endif
 #ifdef QUOTA2
 	if (ump->um_flags & UFS_QUOTA2) {
 		*version_ret = 2;
 	} else
 #endif
 		return EOPNOTSUPP;
 	return 0;
+}
 /* XXX shouldn't all this be in kauth ? */
 static int
 quota_get_auth(struct mount *mp, struct lwp *l, uid_t id) {
 	/* The user can always query about his own quota. */
 	if (id == kauth_cred_getuid(l->l_cred))
 		return 0;
 	return kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FS_QUOTA,
 	    KAUTH_REQ_SYSTEM_FS_QUOTA_GET, mp, KAUTH_ARG(id), NULL);
+}
 static int
 quota_handle_cmd_get(struct mount *mp, struct lwp *l,
     struct vfs_quotactl_args *args)
+{
 	struct ufsmount *ump = VFSTOUFS(mp);
 	int error;
 	const struct quotakey *qk;
 	struct quotaval *ret;
 	KASSERT(args->qc_type == QCT_GET);
 	qk = args->u.get.qc_key;
 	ret = args->u.get.qc_ret;
 	if ((ump->um_flags & (UFS_QUOTA|UFS_QUOTA2)) == 0)
 		return EOPNOTSUPP;
 	error = quota_get_auth(mp, l, qk->qk_id);
 	if (error != 0)
 		return error;
 #ifdef QUOTA
 	if (ump->um_flags & UFS_QUOTA) {
 		error = quota1_handle_cmd_get(ump, qk, ret);
 	} else
 #endif
 #ifdef QUOTA2
 	if (ump->um_flags & UFS_QUOTA2) {
 		error = quota2_handle_cmd_get(ump, qk, ret);
 	} else
 #endif
 		panic("quota_handle_cmd_get: no support ?");
 	if (error != 0)
 		return error;
 	return error;
+}
 static int
 quota_handle_cmd_put(struct mount *mp, struct lwp *l,
     struct vfs_quotactl_args *args)
+{
 	struct ufsmount *ump = VFSTOUFS(mp);
 	const struct quotakey *qk;
 	const struct quotaval *qv;
 	id_t kauth_id;
 	int error;
 	KASSERT(args->qc_type == QCT_PUT);
 	qk = args->u.put.qc_key;
 	qv = args->u.put.qc_val;
 	if ((ump->um_flags & (UFS_QUOTA|UFS_QUOTA2)) == 0)
 		return EOPNOTSUPP;
 	kauth_id = qk->qk_id;
 	if (kauth_id == QUOTA_DEFAULTID) {
 		kauth_id = 0;
+	}
 	error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FS_QUOTA,
 	    KAUTH_REQ_SYSTEM_FS_QUOTA_MANAGE, mp, KAUTH_ARG(kauth_id),
 	    NULL);
 	if (error != 0) {
 		return error;
+	}
 #ifdef QUOTA
 	if (ump->um_flags & UFS_QUOTA)
 		error = quota1_handle_cmd_put(ump, qk, qv);
 	else
 #endif
 #ifdef QUOTA2
 	if (ump->um_flags & UFS_QUOTA2) {
 		error = quota2_handle_cmd_put(ump, qk, qv);
 	} else
 #endif
 		panic("quota_handle_cmd_get: no support ?");
 	if (error == ENOENT) {
 		error = 0;
+	}
 	return error;
+}
 static int
 quota_handle_cmd_delete(struct mount *mp, struct lwp *l,
     struct vfs_quotactl_args *args)
+{
 	struct ufsmount *ump = VFSTOUFS(mp);
 	const struct quotakey *qk;
 	id_t kauth_id;
 	int error;
 	KASSERT(args->qc_type == QCT_DELETE);
 	qk = args->u.delete.qc_key;
 	kauth_id = qk->qk_id;
 	if (kauth_id == QUOTA_DEFAULTID) {
 		kauth_id = 0;
+	}
 	if ((ump->um_flags & UFS_QUOTA2) == 0)
 		return EOPNOTSUPP;
 	/* avoid whitespace changes */
+	{
 		error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FS_QUOTA,
 		    KAUTH_REQ_SYSTEM_FS_QUOTA_MANAGE, mp, KAUTH_ARG(kauth_id),
 		    NULL);
 		if (error != 0)
 			goto err;
 #ifdef QUOTA2
 		if (ump->um_flags & UFS_QUOTA2) {
 			error = quota2_handle_cmd_delete(ump, qk);
 		} else
 #endif
 			panic("quota_handle_cmd_get: no support ?");
 		if (error && error != ENOENT)
 			goto err;
+	}
 	return 0;
  err:
 	return error;
+}
 static int
-quota_handle_cmd_getall(struct mount *mp, struct lwp *l,
+quota_handle_cmd_cursorget(struct mount *mp, struct lwp *l,
     struct vfs_quotactl_args *args)
+{
 	struct ufsmount *ump = VFSTOUFS(mp);
 	struct quotakcursor *cursor;
 	struct quotakey *keys;
 	struct quotaval *vals;
 	unsigned maxnum;
 	unsigned *ret;
 	int error;
-	KASSERT(args->qc_type == QCT_GETALL);
+	KASSERT(args->qc_type == QCT_CURSORGET);
-	cursor = args->u.getall.qc_cursor;
+	cursor = args->u.cursorget.qc_cursor;
-	keys = args->u.getall.qc_keys;
+	keys = args->u.cursorget.qc_keys;
-	vals = args->u.getall.qc_vals;
+	vals = args->u.cursorget.qc_vals;
-	maxnum = args->u.getall.qc_maxnum;
+	maxnum = args->u.cursorget.qc_maxnum;
-	ret = args->u.getall.qc_ret;
+	ret = args->u.cursorget.qc_ret;
 	if ((ump->um_flags & UFS_QUOTA2) == 0)
 		return EOPNOTSUPP;
 	error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FS_QUOTA,
 	    KAUTH_REQ_SYSTEM_FS_QUOTA_GET, mp, NULL, NULL);
 	if (error)
 		return error;
 #ifdef QUOTA2
 	if (ump->um_flags & UFS_QUOTA2) {
-		error = quota2_handle_cmd_getall(ump, cursor,
+		error = quota2_handle_cmd_cursorget(ump, cursor, keys, vals,
-						 keys, vals, maxnum, ret);
+						    maxnum, ret);
 	} else
 #endif
-		panic("quota_handle_cmd_getall: no support ?");
+		panic("quota_handle_cmd_cursorget: no support ?");
 	return error;
+}
 static int
 quota_handle_cmd_cursoropen(struct mount *mp, struct lwp *l,
     struct vfs_quotactl_args *args)
+{
 	struct ufsmount *ump = VFSTOUFS(mp);
 	struct quotakcursor *cursor;
 	int error;
 	KASSERT(args->qc_type == QCT_CURSOROPEN);
 	cursor = args->u.cursoropen.qc_cursor;
 	error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FS_QUOTA,
 	    KAUTH_REQ_SYSTEM_FS_QUOTA_GET, mp, NULL, NULL);
 	if (error)
 		return error;
 #ifdef QUOTA2
 	if (ump->um_flags & UFS_QUOTA2) {
 		error = quota2_handle_cmd_cursoropen(ump, cursor);
 	} else
 #endif
 		error = EOPNOTSUPP;
 	return error;
+}
 static int
 quota_handle_cmd_cursorclose(struct mount *mp, struct lwp *l,
     struct vfs_quotactl_args *args)
+{
 	struct ufsmount *ump = VFSTOUFS(mp);
 	struct quotakcursor *cursor;
 	int error;
 	KASSERT(args->qc_type == QCT_CURSORCLOSE);
 	cursor = args->u.cursorclose.qc_cursor;
 	error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FS_QUOTA,
 	    KAUTH_REQ_SYSTEM_FS_QUOTA_GET, mp, NULL, NULL);
 	if (error)
 		return error;
 #ifdef QUOTA2
 	if (ump->um_flags & UFS_QUOTA2) {
 		error = quota2_handle_cmd_cursorclose(ump, cursor);
 	} else
 #endif
 		error = EOPNOTSUPP;
 	return error;
+}
 static int
 quota_handle_cmd_cursorskipidtype(struct mount *mp, struct lwp *l,
     struct vfs_quotactl_args *args)
+{
 	struct ufsmount *ump = VFSTOUFS(mp);
 	struct quotakcursor *cursor;
 	int idtype;
 	int error;
 	KASSERT(args->qc_type == QCT_CURSORSKIPIDTYPE);
 	cursor = args->u.cursorskipidtype.qc_cursor;
 	idtype = args->u.cursorskipidtype.qc_idtype;
 #ifdef QUOTA2
 	if (ump->um_flags & UFS_QUOTA2) {
 		error = quota2_handle_cmd_cursorskipidtype(ump, cursor, idtype);
 	} else
 #endif
 		error = EOPNOTSUPP;
 	return error;
+}
 static int
 quota_handle_cmd_cursoratend(struct mount *mp, struct lwp *l,
     struct vfs_quotactl_args *args)
+{
 	struct ufsmount *ump = VFSTOUFS(mp);
 	struct quotakcursor *cursor;
 	int *ret;
 	int error;
 	KASSERT(args->qc_type == QCT_CURSORATEND);
 	cursor = args->u.cursoratend.qc_cursor;
 	ret = args->u.cursoratend.qc_ret;
 #ifdef QUOTA2
 	if (ump->um_flags & UFS_QUOTA2) {
 		error = quota2_handle_cmd_cursoratend(ump, cursor, ret);
 	} else
 #endif
 		error = EOPNOTSUPP;
 	return error;
+}
 static int
 quota_handle_cmd_cursorrewind(struct mount *mp, struct lwp *l,
     struct vfs_quotactl_args *args)
+{
 	struct ufsmount *ump = VFSTOUFS(mp);
 	struct quotakcursor *cursor;
 	int error;
 	KASSERT(args->qc_type == QCT_CURSORREWIND);
 	cursor = args->u.cursorrewind.qc_cursor;
 #ifdef QUOTA2
 	if (ump->um_flags & UFS_QUOTA2) {
 		error = quota2_handle_cmd_cursorrewind(ump, cursor);
 	} else
 #endif
 		error = EOPNOTSUPP;
 	return error;
+}
 static int
 quota_handle_cmd_quotaon(struct mount *mp, struct lwp *l,
     struct vfs_quotactl_args *args)
+{
 	prop_dictionary_t data;
 	struct ufsmount *ump = VFSTOUFS(mp);
 	int error;
 	const char *qfile;
 	prop_dictionary_t cmddict;
 	int q2type;
 	prop_array_t datas;
 	KASSERT(args->qc_type == QCT_PROPLIB);
 	cmddict = args->u.proplib.qc_cmddict;
 	q2type = args->u.proplib.qc_q2type;
 	datas = args->u.proplib.qc_datas;
 	KASSERT(prop_object_type(cmddict) == PROP_TYPE_DICTIONARY);
 	KASSERT(prop_object_type(datas) == PROP_TYPE_ARRAY);
 	if ((ump->um_flags & UFS_QUOTA2) != 0)
 		return EBUSY;
 	if (prop_array_count(datas) != 1)
 		return EINVAL;
 	data = prop_array_get(datas, 0);
 	if (data == NULL)
 		return ENOMEM;
 	if (!prop_dictionary_get_cstring_nocopy(data, "quotafile",
 	    &qfile))
 		return EINVAL;
 	error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FS_QUOTA,
 	    KAUTH_REQ_SYSTEM_FS_QUOTA_ONOFF, mp, NULL, NULL);
 	if (error != 0) {
 		return error;
+	}
 #ifdef QUOTA
 	error = quota1_handle_cmd_quotaon(l, ump, q2type, qfile);
 #else
 	error = EOPNOTSUPP;
 #endif
 	return error;
+}
 static int
 quota_handle_cmd_quotaoff(struct mount *mp, struct lwp *l,
     struct vfs_quotactl_args *args)
+{
 	struct ufsmount *ump = VFSTOUFS(mp);
 	int error;
 	prop_dictionary_t cmddict;
 	int q2type;
 	prop_array_t datas;
 	KASSERT(args->qc_type == QCT_PROPLIB);
 	cmddict = args->u.proplib.qc_cmddict;
 	q2type = args->u.proplib.qc_q2type;
 	datas = args->u.proplib.qc_datas;
 	KASSERT(prop_object_type(cmddict) == PROP_TYPE_DICTIONARY);
 	KASSERT(prop_object_type(datas) == PROP_TYPE_ARRAY);
 	if ((ump->um_flags & UFS_QUOTA2) != 0)
 		return EOPNOTSUPP;
 	if (prop_array_count(datas) != 0)
 		return EINVAL;
 	error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FS_QUOTA,
 	    KAUTH_REQ_SYSTEM_FS_QUOTA_ONOFF, mp, NULL, NULL);
 	if (error != 0) {
 		return error;
+	}
 #ifdef QUOTA
 	error = quota1_handle_cmd_quotaoff(l, ump, q2type);
 #else
 	error = EOPNOTSUPP;
 #endif
 	return error;
+}
 /*
  * Initialize the quota system.
  */
 void
 dqinit(void)
+{
 	mutex_init(&dqlock, MUTEX_DEFAULT, IPL_NONE);
 	cv_init(&dqcv, "quota");
 	dqhashtbl = hashinit(desiredvnodes, HASH_LIST, true, &dqhash);
 	dquot_cache = pool_cache_init(sizeof(struct dquot), 0, 0, 0, "ufsdq",
 	    NULL, IPL_NONE, NULL, NULL, NULL);
+}
 void
 dqreinit(void)
+{
 	struct dquot *dq;
 	struct dqhashhead *oldhash, *hash;
 	struct vnode *dqvp;
 	u_long oldmask, mask, hashval;
 	int i;
 	hash = hashinit(desiredvnodes, HASH_LIST, true, &mask);
 	mutex_enter(&dqlock);
 	oldhash = dqhashtbl;
 	oldmask = dqhash;
 	dqhashtbl = hash;
 	dqhash = mask;
 	for (i = 0; i <= oldmask; i++) {
 		while ((dq = LIST_FIRST(&oldhash[i])) != NULL) {
 			dqvp = dq->dq_ump->um_quotas[dq->dq_type];
 			LIST_REMOVE(dq, dq_hash);
 			hashval = DQHASH(dqvp, dq->dq_id);
 			LIST_INSERT_HEAD(&dqhashtbl[hashval], dq, dq_hash);
+		}
+	}
 	mutex_exit(&dqlock);
 	hashdone(oldhash, HASH_LIST, oldmask);
+}
 /*
  * Free resources held by quota system.
  */
 void
 dqdone(void)
+{
 	pool_cache_destroy(dquot_cache);
 	hashdone(dqhashtbl, HASH_LIST, dqhash);
 	cv_destroy(&dqcv);
 	mutex_destroy(&dqlock);
+}
 /*
  * Set up the quotas for an inode.
+ *
  * This routine completely defines the semantics of quotas.
  * If other criterion want to be used to establish quotas, the
  * MAXQUOTAS value in quotas.h should be increased, and the
  * additional dquots set up here.
  */
 int
 getinoquota(struct inode *ip)
+{
 	struct ufsmount *ump = ip->i_ump;
 	struct vnode *vp = ITOV(ip);
 	int i, error;
 	u_int32_t ino_ids[MAXQUOTAS];
 	/*
 	 * To avoid deadlocks never update quotas for quota files
 	 * on the same file system
 	 */
 	for (i = 0; i < MAXQUOTAS; i++)
 		if (vp == ump->um_quotas[i])
 			return 0;
 	ino_ids[USRQUOTA] = ip->i_uid;
 	ino_ids[GRPQUOTA] = ip->i_gid;
 	for (i = 0; i < MAXQUOTAS; i++) {
 		/*
 		 * If the file id changed the quota needs update.
 		 */
 		if (ip->i_dquot[i] != NODQUOT &&
 		    ip->i_dquot[i]->dq_id != ino_ids[i]) {
 			dqrele(ITOV(ip), ip->i_dquot[i]);
 			ip->i_dquot[i] = NODQUOT;
+		}
 		/*
 		 * Set up the quota based on file id.
 		 * ENODEV means that quotas are not enabled.
 		 */
 		if (ip->i_dquot[i] == NODQUOT &&
 		    (error = dqget(vp, ino_ids[i], ump, i, &ip->i_dquot[i])) &&
 		    error != ENODEV)
 			return (error);
+	}
 	return 0;
+}
 /*
  * Obtain a dquot structure for the specified identifier and quota file
  * reading the information from the file if necessary.
  */
 int
 dqget(struct vnode *vp, u_long id, struct ufsmount *ump, int type,
     struct dquot **dqp)
+{
 	struct dquot *dq, *ndq;
 	struct dqhashhead *dqh;
 	struct vnode *dqvp;
 	int error = 0; /* XXX gcc */
 	/* Lock to see an up to date value for QTF_CLOSING. */
 	mutex_enter(&dqlock);
 	if ((ump->um_flags & (UFS_QUOTA|UFS_QUOTA2)) == 0) {
 		mutex_exit(&dqlock);
 		*dqp = NODQUOT;
 		return (ENODEV);
+	}
 	dqvp = ump->um_quotas[type];
 #ifdef QUOTA
 	if (ump->um_flags & UFS_QUOTA) {
 		if (dqvp == NULLVP || (ump->umq1_qflags[type] & QTF_CLOSING)) {
 			mutex_exit(&dqlock);
 			*dqp = NODQUOT;
 			return (ENODEV);
+		}
+	}
 #endif
 #ifdef QUOTA2
 	if (ump->um_flags & UFS_QUOTA2) {
 		if (dqvp == NULLVP) {
 			mutex_exit(&dqlock);
 			*dqp = NODQUOT;
 			return (ENODEV);
+		}
+	}
 #endif
 	KASSERT(dqvp != vp);
 	/*
 	 * Check the cache first.
 	 */
 	dqh = &dqhashtbl[DQHASH(dqvp, id)];
 	LIST_FOREACH(dq, dqh, dq_hash) {
 		if (dq->dq_id != id ||
 		    dq->dq_ump->um_quotas[dq->dq_type] != dqvp)
 			continue;
 		KASSERT(dq->dq_cnt > 0);
 		dqref(dq);
 		mutex_exit(&dqlock);
 		*dqp = dq;
 		return (0);
+	}
 	/*
 	 * Not in cache, allocate a new one.
 	 */
 	mutex_exit(&dqlock);
 	ndq = pool_cache_get(dquot_cache, PR_WAITOK);
 	/*
 	 * Initialize the contents of the dquot structure.
 	 */
 	memset((char *)ndq, 0, sizeof *ndq);
 	ndq->dq_flags = 0;
 	ndq->dq_id = id;
 	ndq->dq_ump = ump;
 	ndq->dq_type = type;
 	mutex_init(&ndq->dq_interlock, MUTEX_DEFAULT, IPL_NONE);
 	mutex_enter(&dqlock);
 	dqh = &dqhashtbl[DQHASH(dqvp, id)];
 	LIST_FOREACH(dq, dqh, dq_hash) {
 		if (dq->dq_id != id ||
 		    dq->dq_ump->um_quotas[dq->dq_type] != dqvp)
 			continue;
 		/*
 		 * Another thread beat us allocating this dquot.
 		 */
 		KASSERT(dq->dq_cnt > 0);
 		dqref(dq);
 		mutex_exit(&dqlock);
 		mutex_destroy(&ndq->dq_interlock);
 		pool_cache_put(dquot_cache, ndq);
 		*dqp = dq;
 		return 0;
+	}
 	dq = ndq;
 	LIST_INSERT_HEAD(dqh, dq, dq_hash);
 	dqref(dq);
 	mutex_enter(&dq->dq_interlock);
 	mutex_exit(&dqlock);
 #ifdef QUOTA
 	if (ump->um_flags & UFS_QUOTA)
 		error = dq1get(dqvp, id, ump, type, dq);
 #endif
 #ifdef QUOTA2
 	if (ump->um_flags & UFS_QUOTA2)
 		error = dq2get(dqvp, id, ump, type, dq);
 #endif
 	/*
 	 * I/O error in reading quota file, release
 	 * quota structure and reflect problem to caller.
 	 */
 	if (error) {
 		mutex_enter(&dqlock);
 		LIST_REMOVE(dq, dq_hash);
 		mutex_exit(&dqlock);
 		mutex_exit(&dq->dq_interlock);
 		dqrele(vp, dq);
 		*dqp = NODQUOT;
 		return (error);
+	}
 	mutex_exit(&dq->dq_interlock);
 	*dqp = dq;
 	return (0);
+}
 /*
  * Obtain a reference to a dquot.
  */
 void
 dqref(struct dquot *dq)
+{
 	KASSERT(mutex_owned(&dqlock));
 	dq->dq_cnt++;
 	KASSERT(dq->dq_cnt > 0);
+}
 /*
  * Release a reference to a dquot.
  */
 void
 dqrele(struct vnode *vp, struct dquot *dq)
+{
 	if (dq == NODQUOT)
 		return;
 	mutex_enter(&dq->dq_interlock);
 	for (;;) {
 		mutex_enter(&dqlock);
 		if (dq->dq_cnt > 1) {
 			dq->dq_cnt--;
 			mutex_exit(&dqlock);
 			mutex_exit(&dq->dq_interlock);
 			return;
+		}
 		if ((dq->dq_flags & DQ_MOD) == 0)
 			break;
 		mutex_exit(&dqlock);
 #ifdef QUOTA
 		if (dq->dq_ump->um_flags & UFS_QUOTA)
 			(void) dq1sync(vp, dq);
 #endif
 #ifdef QUOTA2
 		if (dq->dq_ump->um_flags & UFS_QUOTA2)
 			(void) dq2sync(vp, dq);
 #endif
+	}
 	KASSERT(dq->dq_cnt == 1 && (dq->dq_flags & DQ_MOD) == 0);
 	LIST_REMOVE(dq, dq_hash);
 	mutex_exit(&dqlock);
 	mutex_exit(&dq->dq_interlock);
 	mutex_destroy(&dq->dq_interlock);
 	pool_cache_put(dquot_cache, dq);
+}
 int
 qsync(struct mount *mp)
+{
 	struct ufsmount *ump = VFSTOUFS(mp);
 #ifdef QUOTA
 	if (ump->um_flags & UFS_QUOTA)
 		return q1sync(mp);
 #endif
 #ifdef QUOTA2
 	if (ump->um_flags & UFS_QUOTA2)
 		return q2sync(mp);
 #endif
 	return 0;
+}
 #ifdef DIAGNOSTIC
 /*
  * Check the hash chains for stray dquot's.
  */
 void
 dqflush(struct vnode *vp)
+{
 	struct dquot *dq;
 	int i;
 	mutex_enter(&dqlock);
 	for (i = 0; i <= dqhash; i++)
 		LIST_FOREACH(dq, &dqhashtbl[i], dq_hash)
 			KASSERT(dq->dq_ump->um_quotas[dq->dq_type] != vp);
 	mutex_exit(&dqlock);
+}
 #endif

 @@ -1,1349 +1,1417 @@
-/* $NetBSD: ufs_quota2.c,v 1.25 2012/01/29 07:08:58 dholland Exp $ */
+/* $NetBSD: ufs_quota2.c,v 1.26 2012/01/29 07:09:52 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.
+  *
   * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   * ``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.25 2012/01/29 07:08:58 dholland Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ufs_quota2.c,v 1.26 2012/01/29 07:09:52 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>
 #include <ufs/ufs/ufsmount.h>
 #include <ufs/ufs/ufs_bswap.h>
 #include <ufs/ufs/ufs_extern.h>
 #include <ufs/ufs/ufs_quota.h>
 #include <ufs/ufs/ufs_wapbl.h>
 #include <quota/quotaprop.h>
 /*
  * LOCKING:
  * Data in the entries are protected by the associated struct dquot's
  * dq_interlock (this means we can't read or change a quota entry without
  * grabing a dquot for it).
  * The header and lists (including pointers in the data entries, and q2e_uid)
  * are protected by the global dqlock.
  * the locking order is dq_interlock -> dqlock
  */
 static int quota2_bwrite(struct mount *, struct buf *);
 static int getinoquota2(struct inode *, bool, bool, struct buf **,
     struct quota2_entry **);
 static int getq2h(struct ufsmount *, int, struct buf **,
     struct quota2_header **, int);
 static int getq2e(struct ufsmount *, int, daddr_t, int, struct buf **,
     struct quota2_entry **, int);
 static int quota2_walk_list(struct ufsmount *, struct buf *, int,
     uint64_t *, int, void *,
     int (*func)(struct ufsmount *, uint64_t *, struct quota2_entry *,
       uint64_t, void *));
 #if 0
 static prop_dictionary_t q2etoprop(struct quota2_entry *, int);
 #endif
 static const char *limnames[] = INITQLNAMES;
 static void
 quota2_dict_update_q2e_limits(int objtype, const struct quotaval *val,
     struct quota2_entry *q2e)
+{
 	/* make sure we can index q2e_val[] by the fs-independent objtype */
 	CTASSERT(QUOTA_OBJTYPE_BLOCKS == QL_BLOCK);
 	CTASSERT(QUOTA_OBJTYPE_FILES == QL_FILE);
 	q2e->q2e_val[objtype].q2v_hardlimit = val->qv_hardlimit;
 	q2e->q2e_val[objtype].q2v_softlimit = val->qv_softlimit;
 	q2e->q2e_val[objtype].q2v_grace = val->qv_grace;
+}
 #if 0
 static prop_dictionary_t
 q2etoprop(struct quota2_entry *q2e, int def)
+{
 	const char *val_names[] = INITQVNAMES_ALL;
 	prop_dictionary_t dict1 = prop_dictionary_create();
 	prop_dictionary_t dict2;
 	int i;
 	if (dict1 == NULL)
 		return NULL;
 	if (def) {
 		if (!prop_dictionary_set_cstring_nocopy(dict1, "id",
 		    "default")) {
 			goto err;
+		}
 	} else {
 		if (!prop_dictionary_set_uint32(dict1, "id", q2e->q2e_uid)) {
 			goto err;
+		}
+	}
 	for (i = 0; i < N_QL; i++) {
 		dict2 = limits64toprop(&q2e->q2e_val[i].q2v_hardlimit,
 		    val_names, N_QV);
 		if (dict2 == NULL)
 			goto err;
 		if (!prop_dictionary_set_and_rel(dict1, limnames[i], dict2))
 			goto err;
+	}
 	return dict1;
 err:
 	prop_object_release(dict1);
 	return NULL;
+}
 #endif
 /*
  * Convert internal representation to FS-independent representation.
  * (Note that while the two types are currently identical, the
  * internal representation is an on-disk struct and the FS-independent
  * representation is not, and they might diverge in the future.)
  */
 static void
 q2val_to_quotaval(struct quota2_val *q2v, struct quotaval *qv)
+{
 	qv->qv_softlimit = q2v->q2v_softlimit;
 	qv->qv_hardlimit = q2v->q2v_hardlimit;
 	qv->qv_usage = q2v->q2v_cur;
 	qv->qv_expiretime = q2v->q2v_time;
 	qv->qv_grace = q2v->q2v_grace;
+}
 /*
  * Convert a quota2entry and default-flag to the FS-independent
  * representation.
  */
 static void
 q2e_to_quotaval(struct quota2_entry *q2e, int def,
 	       id_t *id, int objtype, struct quotaval *ret)
+{
 	if (def) {
 		*id = QUOTA_DEFAULTID;
 	} else {
 		*id = q2e->q2e_uid;
+	}
 	KASSERT(objtype >= 0 && objtype < N_QL);
 	q2val_to_quotaval(&q2e->q2e_val[objtype], ret);
+}
 static int
 quota2_bwrite(struct mount *mp, struct buf *bp)
+{
 	if (mp->mnt_flag & MNT_SYNCHRONOUS)
 		return bwrite(bp);
 	else {
 		bdwrite(bp);
 		return 0;
+	}
+}
 static int
 getq2h(struct ufsmount *ump, int type,
     struct buf **bpp, struct quota2_header **q2hp, int flags)
+{
 #ifdef FFS_EI
 	const int needswap = UFS_MPNEEDSWAP(ump);
 #endif
 	int error;
 	struct buf *bp;
 	struct quota2_header *q2h;
 	KASSERT(mutex_owned(&dqlock));
 	error = bread(ump->um_quotas[type], 0, ump->umq2_bsize,
 	    ump->um_cred[type], flags, &bp);
 	if (error)
 		return error;
 	if (bp->b_resid != 0)
 		panic("dq2get: %s quota file truncated", quotatypes[type]);
 	q2h = (void *)bp->b_data;
 	if (ufs_rw32(q2h->q2h_magic_number, needswap) != Q2_HEAD_MAGIC ||
 	    q2h->q2h_type != type)
 		panic("dq2get: corrupted %s quota header", quotatypes[type]);
 	*bpp = bp;
 	*q2hp = q2h;
 	return 0;
+}
 static int
 getq2e(struct ufsmount *ump, int type, daddr_t lblkno, int blkoffset,
     struct buf **bpp, struct quota2_entry **q2ep, int flags)
+{
 	int error;
 	struct buf *bp;
 	if (blkoffset & (sizeof(uint64_t) - 1)) {
 		panic("dq2get: %s quota file corrupted",
 		    quotatypes[type]);
+	}
 	error = bread(ump->um_quotas[type], lblkno, ump->umq2_bsize,
 	    ump->um_cred[type], flags, &bp);
 	if (error)
 		return error;
 	if (bp->b_resid != 0) {
 		panic("dq2get: %s quota file corrupted",
 		    quotatypes[type]);
+	}
 	*q2ep = (void *)((char *)bp->b_data + blkoffset);
 	*bpp = bp;
 	return 0;
+}
 /* walk a quota entry list, calling the callback for each entry */
 #define Q2WL_ABORT 0x10000000
 static int
 quota2_walk_list(struct ufsmount *ump, struct buf *hbp, int type,
     uint64_t *offp, int flags, void *a,
     int (*func)(struct ufsmount *, uint64_t *, struct quota2_entry *, uint64_t, void *))
+{
 #ifdef FFS_EI
 	const int needswap = UFS_MPNEEDSWAP(ump);
 #endif
 	daddr_t off = ufs_rw64(*offp, needswap);
 	struct buf *bp, *obp = hbp;
 	int ret = 0, ret2 = 0;
 	struct quota2_entry *q2e;
 	daddr_t lblkno, blkoff, olblkno = 0;
 	KASSERT(mutex_owner(&dqlock));
 	while (off != 0) {
 		lblkno = (off >> ump->um_mountp->mnt_fs_bshift);
 		blkoff = (off & ump->umq2_bmask);
 		if (lblkno == 0) {
 			/* in the header block */
 			bp = hbp;
 		} else if (lblkno == olblkno) {
 			/* still in the same buf */
 			bp = obp;
 		} else {
 			ret = bread(ump->um_quotas[type], lblkno,
 			    ump->umq2_bsize,
 			    ump->um_cred[type], flags, &bp);
 			if (ret)
 				return ret;
 			if (bp->b_resid != 0) {
 				panic("quota2_walk_list: %s quota file corrupted",
 				    quotatypes[type]);
+			}
+		}
 		q2e = (void *)((char *)(bp->b_data) + blkoff);
 		ret = (*func)(ump, offp, q2e, off, a);
 		if (off != ufs_rw64(*offp, needswap)) {
 			/* callback changed parent's pointer, redo */
 			off = ufs_rw64(*offp, needswap);
 			if (bp != hbp && bp != obp)
 				ret2 = bwrite(bp);
 		} else {
 			/* parent if now current */
 			if (obp != bp && obp != hbp) {
 				if (flags & B_MODIFY)
 					ret2 = bwrite(obp);
 				else
 					brelse(obp, 0);
+			}
 			obp = bp;
 			olblkno = lblkno;
 			offp = &(q2e->q2e_next);
 			off = ufs_rw64(*offp, needswap);
+		}
 		if (ret)
 			break;
 		if (ret2) {
 			ret = ret2;
 			break;
+		}
+	}
 	if (obp != hbp) {
 		if (flags & B_MODIFY)
 			ret2 = bwrite(obp);
 		else
 			brelse(obp, 0);
+	}
 	if (ret & Q2WL_ABORT)
 		return 0;
 	if (ret == 0)
 		return ret2;
 	return ret;
+}
 int
 quota2_umount(struct mount *mp, int flags)
+{
 	int i, error;
 	struct ufsmount *ump = VFSTOUFS(mp);
 	if ((ump->um_flags & UFS_QUOTA2) == 0)
 		return 0;
 	for (i = 0; i < MAXQUOTAS; i++) {
 		if (ump->um_quotas[i] != NULLVP) {
 			error = vn_close(ump->um_quotas[i], FREAD|FWRITE,
 			    ump->um_cred[i]);
 			if (error) {
 				printf("quota2_umount failed: close(%p) %d\n",
 				    ump->um_quotas[i], error);
 				return error;
+			}
+		}
 		ump->um_quotas[i] = NULLVP;
+	}
 	return 0;
+}
 static int
 quota2_q2ealloc(struct ufsmount *ump, int type, uid_t uid, struct dquot *dq,
     struct buf **bpp, struct quota2_entry **q2ep)
+{
 	int error, error2;
 	struct buf *hbp, *bp;
 	struct quota2_header *q2h;
 	struct quota2_entry *q2e;
 	daddr_t offset;
 	u_long hash_mask;
 	const int needswap = UFS_MPNEEDSWAP(ump);
 	KASSERT(mutex_owned(&dq->dq_interlock));
 	KASSERT(mutex_owned(&dqlock));
 	error = getq2h(ump, type, &hbp, &q2h, B_MODIFY);
 	if (error)
 		return error;
 	offset = ufs_rw64(q2h->q2h_free, needswap);
 	if (offset == 0) {
 		struct vnode *vp = ump->um_quotas[type];
 		struct inode *ip = VTOI(vp);
 		uint64_t size = ip->i_size;
 		/* need to alocate a new disk block */
 		error = UFS_BALLOC(vp, size, ump->umq2_bsize,
 		    ump->um_cred[type], B_CLRBUF | B_SYNC, &bp);
 		if (error) {
 			brelse(hbp, 0);
 			return error;
+		}
 		KASSERT((ip->i_size % ump->umq2_bsize) == 0);
 		ip->i_size += ump->umq2_bsize;
 		DIP_ASSIGN(ip, size, ip->i_size);
 		ip->i_flag |= IN_CHANGE | IN_UPDATE;
 		uvm_vnp_setsize(vp, ip->i_size);
 		quota2_addfreeq2e(q2h, bp->b_data, size, ump->umq2_bsize,
 		    needswap);
 		error = bwrite(bp);
 		error2 = UFS_UPDATE(vp, NULL, NULL, UPDATE_WAIT);
 		if (error || error2) {
 			brelse(hbp, 0);
 			if (error)
 				return error;
 			return error2;
+		}
 		offset = ufs_rw64(q2h->q2h_free, needswap);
 		KASSERT(offset != 0);
+	}
 	dq->dq2_lblkno = (offset >> ump->um_mountp->mnt_fs_bshift);
 	dq->dq2_blkoff = (offset & ump->umq2_bmask);
 	if (dq->dq2_lblkno == 0) {
 		bp = hbp;
 		q2e = (void *)((char *)bp->b_data + dq->dq2_blkoff);
 	} else {
 		error = getq2e(ump, type, dq->dq2_lblkno,
 		    dq->dq2_blkoff, &bp, &q2e, B_MODIFY);
 		if (error) {
 			brelse(hbp, 0);
 			return error;
+		}
+	}
 	hash_mask = ((1 << q2h->q2h_hash_shift) - 1);
 	/* remove from free list */
 	q2h->q2h_free = q2e->q2e_next;
 	memcpy(q2e, &q2h->q2h_defentry, sizeof(*q2e));
 	q2e->q2e_uid = ufs_rw32(uid, needswap);
 	/* insert in hash list */
 	q2e->q2e_next = q2h->q2h_entries[uid & hash_mask];
 	q2h->q2h_entries[uid & hash_mask] = ufs_rw64(offset, needswap);
 	if (hbp != bp) {
 		bwrite(hbp);
+	}
 	*q2ep = q2e;
 	*bpp = bp;
 	return 0;
+}
 static int
 getinoquota2(struct inode *ip, bool alloc, bool modify, struct buf **bpp,
     struct quota2_entry **q2ep)
+{
 	int error;
 	int i;
 	struct dquot *dq;
 	struct ufsmount *ump = ip->i_ump;
 	u_int32_t ino_ids[MAXQUOTAS];
 	error = getinoquota(ip);
 	if (error)
 		return error;
 	if (alloc) {
 		UFS_WAPBL_JLOCK_ASSERT(ump->um_mountp);
+	}
         ino_ids[USRQUOTA] = ip->i_uid;
         ino_ids[GRPQUOTA] = ip->i_gid;
 	/* first get the interlock for all dquot */
 	for (i = 0; i < MAXQUOTAS; i++) {
 		dq = ip->i_dquot[i];
 		if (dq == NODQUOT)
 			continue;
 		mutex_enter(&dq->dq_interlock);
+	}
 	/* now get the corresponding quota entry */
 	for (i = 0; i < MAXQUOTAS; i++) {
 		bpp[i] = NULL;
 		q2ep[i] = NULL;
 		dq = ip->i_dquot[i];
 		if (dq == NODQUOT)
 			continue;
 		if (__predict_false(ump->um_quotas[i] == NULL)) {
 			/*
 			 * quotas have been turned off. This can happen
 			 * at umount time.
 			 */
 			mutex_exit(&dq->dq_interlock);
 			dqrele(NULLVP, dq);
 			ip->i_dquot[i] = NULL;
 			continue;
+		}
 		if ((dq->dq2_lblkno | dq->dq2_blkoff) == 0) {
 			if (!alloc) {
 				continue;
+			}
 			/* need to alloc a new on-disk quot */
 			mutex_enter(&dqlock);
 			error = quota2_q2ealloc(ump, i, ino_ids[i], dq,
 			    &bpp[i], &q2ep[i]);
 			mutex_exit(&dqlock);
 			if (error)
 				return error;
 		} else {
 			error = getq2e(ump, i, dq->dq2_lblkno,
 			    dq->dq2_blkoff, &bpp[i], &q2ep[i],
 			    modify ? B_MODIFY : 0);
 			if (error)
 				return error;
+		}
+	}
 	return 0;
+}
 static int
 quota2_check(struct inode *ip, int vtype, int64_t change, kauth_cred_t cred,
     int flags)
+{
 	int error;
 	struct buf *bp[MAXQUOTAS];
 	struct quota2_entry *q2e[MAXQUOTAS];
 	struct quota2_val *q2vp;
 	struct dquot *dq;
 	uint64_t ncurblks;
 	struct ufsmount *ump = ip->i_ump;
 	struct mount *mp = ump->um_mountp;
 	const int needswap = UFS_MPNEEDSWAP(ump);
 	int i;
 	if ((error = getinoquota2(ip, change > 0, change != 0, bp, q2e)) != 0)
 		return error;
 	if (change == 0) {
 		for (i = 0; i < MAXQUOTAS; i++) {
 			dq = ip->i_dquot[i];
 			if (dq == NODQUOT)
 				continue;
 			if (bp[i])
 				brelse(bp[i], 0);
 			mutex_exit(&dq->dq_interlock);
+		}
 		return 0;
+	}
 	if (change < 0) {
 		for (i = 0; i < MAXQUOTAS; i++) {
 			dq = ip->i_dquot[i];
 			if (dq == NODQUOT)
 				continue;
 			if (q2e[i] == NULL) {
 				mutex_exit(&dq->dq_interlock);
 				continue;
+			}
 			q2vp = &q2e[i]->q2e_val[vtype];
 			ncurblks = ufs_rw64(q2vp->q2v_cur, needswap);
 			if (ncurblks < -change)
 				ncurblks = 0;
 			else
 				ncurblks += change;
 			q2vp->q2v_cur = ufs_rw64(ncurblks, needswap);
 			quota2_bwrite(mp, bp[i]);
 			mutex_exit(&dq->dq_interlock);
+		}
 		return 0;
+	}
 	/* see if the allocation is allowed */
 	for (i = 0; i < MAXQUOTAS; i++) {
 		struct quota2_val q2v;
 		int ql_stat;
 		dq = ip->i_dquot[i];
 		if (dq == NODQUOT)
 			continue;
 		KASSERT(q2e[i] != NULL);
 		quota2_ufs_rwq2v(&q2e[i]->q2e_val[vtype], &q2v, needswap);
 		ql_stat = quota2_check_limit(&q2v, change, time_second);
 		if ((flags & FORCE) == 0 &&
 		    kauth_authorize_system(cred, KAUTH_SYSTEM_FS_QUOTA,
 		    KAUTH_REQ_SYSTEM_FS_QUOTA_NOLIMIT,
 		    KAUTH_ARG(i), KAUTH_ARG(vtype), NULL) != 0) {
 			/* enforce this limit */
 			switch(QL_STATUS(ql_stat)) {
 			case QL_S_DENY_HARD:
 				if ((dq->dq_flags & DQ_WARN(vtype)) == 0) {
 					uprintf("\n%s: write failed, %s %s "
 					    "limit reached\n",
 					    mp->mnt_stat.f_mntonname,
 					    quotatypes[i], limnames[vtype]);
 					dq->dq_flags |= DQ_WARN(vtype);
+				}
 				error = EDQUOT;
 				break;
 			case QL_S_DENY_GRACE:
 				if ((dq->dq_flags & DQ_WARN(vtype)) == 0) {
 					uprintf("\n%s: write failed, %s %s "
 					    "limit reached\n",
 					    mp->mnt_stat.f_mntonname,
 					    quotatypes[i], limnames[vtype]);
 					dq->dq_flags |= DQ_WARN(vtype);
+				}
 				error = EDQUOT;
 				break;
 			case QL_S_ALLOW_SOFT:
 				if ((dq->dq_flags & DQ_WARN(vtype)) == 0) {
 					uprintf("\n%s: warning, %s %s "
 					    "quota exceeded\n",
 					    mp->mnt_stat.f_mntonname,
 					    quotatypes[i], limnames[vtype]);
 					dq->dq_flags |= DQ_WARN(vtype);
+				}
 				break;
+			}
+		}
 		/*
 		 * always do this; we don't know if the allocation will
 		 * succed or not in the end. if we don't do the allocation
 		 * q2v_time will be ignored anyway
 		 */
 		if (ql_stat & QL_F_CROSS) {
 			q2v.q2v_time = time_second + q2v.q2v_grace;
 			quota2_ufs_rwq2v(&q2v, &q2e[i]->q2e_val[vtype],
 			    needswap);
+		}
+	}
 	/* now do the allocation if allowed */
 	for (i = 0; i < MAXQUOTAS; i++) {
 		dq = ip->i_dquot[i];
 		if (dq == NODQUOT)
 			continue;
 		KASSERT(q2e[i] != NULL);
 		if (error == 0) {
 			q2vp = &q2e[i]->q2e_val[vtype];
 			ncurblks = ufs_rw64(q2vp->q2v_cur, needswap);
 			q2vp->q2v_cur = ufs_rw64(ncurblks + change, needswap);
 			quota2_bwrite(mp, bp[i]);
 		} else
 			brelse(bp[i], 0);
 		mutex_exit(&dq->dq_interlock);
+	}
 	return error;
+}
 int
 chkdq2(struct inode *ip, int64_t change, kauth_cred_t cred, int flags)
+{
 	return quota2_check(ip, QL_BLOCK, change, cred, flags);
+}
 int
 chkiq2(struct inode *ip, int32_t change, kauth_cred_t cred, int flags)
+{
 	return quota2_check(ip, QL_FILE, change, cred, flags);
+}
 int
 quota2_handle_cmd_put(struct ufsmount *ump, const struct quotakey *key,
     const struct quotaval *val)
+{
 	int error;
 	struct dquot *dq;
 	struct quota2_header *q2h;
 	struct quota2_entry q2e, *q2ep;
 	struct buf *bp;
 	const int needswap = UFS_MPNEEDSWAP(ump);
 	/* make sure we can index by the fs-independent idtype */
 	CTASSERT(QUOTA_IDTYPE_USER == USRQUOTA);
 	CTASSERT(QUOTA_IDTYPE_GROUP == GRPQUOTA);
 	if (ump->um_quotas[key->qk_idtype] == NULLVP)
 		return ENODEV;
 	error = UFS_WAPBL_BEGIN(ump->um_mountp);
 	if (error)
 		return error;
 	if (key->qk_id == QUOTA_DEFAULTID) {
 		mutex_enter(&dqlock);
 		error = getq2h(ump, key->qk_idtype, &bp, &q2h, B_MODIFY);
 		if (error) {
 			mutex_exit(&dqlock);
 			goto out_wapbl;
+		}
 		quota2_ufs_rwq2e(&q2h->q2h_defentry, &q2e, needswap);
 		quota2_dict_update_q2e_limits(key->qk_objtype, val, &q2e);
 		quota2_ufs_rwq2e(&q2e, &q2h->q2h_defentry, needswap);
 		mutex_exit(&dqlock);
 		quota2_bwrite(ump->um_mountp, bp);
 		goto out_wapbl;
+	}
 	error = dqget(NULLVP, key->qk_id, ump, key->qk_idtype, &dq);
 	if (error)
 		goto out_wapbl;
 	mutex_enter(&dq->dq_interlock);
 	if (dq->dq2_lblkno == 0 && dq->dq2_blkoff == 0) {
 		/* need to alloc a new on-disk quot */
 		mutex_enter(&dqlock);
 		error = quota2_q2ealloc(ump, key->qk_idtype, key->qk_id, dq,
 		    &bp, &q2ep);
 		mutex_exit(&dqlock);
 	} else {
 		error = getq2e(ump, key->qk_idtype, dq->dq2_lblkno,
 		    dq->dq2_blkoff, &bp, &q2ep, B_MODIFY);
+	}
 	if (error)
 		goto out_il;
 	quota2_ufs_rwq2e(q2ep, &q2e, needswap);
 	quota2_dict_update_q2e_limits(key->qk_objtype, val, &q2e);
 	quota2_ufs_rwq2e(&q2e, q2ep, needswap);
 	quota2_bwrite(ump->um_mountp, bp);
 out_il:
 	mutex_exit(&dq->dq_interlock);
 	dqrele(NULLVP, dq);
 out_wapbl:
 	UFS_WAPBL_END(ump->um_mountp);
 	return error;
+}
 struct dq2clear_callback {
 	uid_t id;
 	struct dquot *dq;
 	struct quota2_header *q2h;
 };
 static int
 dq2clear_callback(struct ufsmount *ump, uint64_t *offp, struct quota2_entry *q2e,
     uint64_t off, void *v)
+{
 	struct dq2clear_callback *c = v;
 #ifdef FFS_EI
 	const int needswap = UFS_MPNEEDSWAP(ump);
 #endif
 	uint64_t myoff;
 	if (ufs_rw32(q2e->q2e_uid, needswap) == c->id) {
 		KASSERT(mutex_owned(&c->dq->dq_interlock));
 		c->dq->dq2_lblkno = 0;
 		c->dq->dq2_blkoff = 0;
 		myoff = *offp;
 		/* remove from hash list */
 		*offp = q2e->q2e_next;
 		/* add to free list */
 		q2e->q2e_next = c->q2h->q2h_free;
 		c->q2h->q2h_free = myoff;
 		return Q2WL_ABORT;
+	}
 	return 0;
+}
 int
 quota2_handle_cmd_delete(struct ufsmount *ump, const struct quotakey *qk)
+{
 	int idtype;
 	id_t id;
 	int objtype;
 	int error, i, canfree;
 	struct dquot *dq;
 	struct quota2_header *q2h;
 	struct quota2_entry q2e, *q2ep;
 	struct buf *hbp, *bp;
 	u_long hash_mask;
 	struct dq2clear_callback c;
 	idtype = qk->qk_idtype;
 	id = qk->qk_id;
 	objtype = qk->qk_objtype;
 	if (ump->um_quotas[idtype] == NULLVP)
 		return ENODEV;
 	if (id == QUOTA_DEFAULTID)
 		return EOPNOTSUPP;
 	/* get the default entry before locking the entry's buffer */
 	mutex_enter(&dqlock);
 	error = getq2h(ump, idtype, &hbp, &q2h, 0);
 	if (error) {
 		mutex_exit(&dqlock);
 		return error;
+	}
 	/* we'll copy to another disk entry, so no need to swap */
 	memcpy(&q2e, &q2h->q2h_defentry, sizeof(q2e));
 	mutex_exit(&dqlock);
 	brelse(hbp, 0);
 	error = dqget(NULLVP, id, ump, idtype, &dq);
 	if (error)
 		return error;
 	mutex_enter(&dq->dq_interlock);
 	if (dq->dq2_lblkno == 0 && dq->dq2_blkoff == 0) {
 		/* already clear, nothing to do */
 		error = ENOENT;
 		goto out_il;
+	}
 	error = UFS_WAPBL_BEGIN(ump->um_mountp);
 	if (error)
 		goto out_dq;
 	error = getq2e(ump, idtype, dq->dq2_lblkno, dq->dq2_blkoff,
 	    &bp, &q2ep, B_MODIFY);
 	if (error)
 		goto out_wapbl;
 	/* make sure we can index by the objtype passed in */
 	CTASSERT(QUOTA_OBJTYPE_BLOCKS == QL_BLOCK);
 	CTASSERT(QUOTA_OBJTYPE_FILES == QL_FILE);
 	/* clear the requested objtype by copying from the default entry */
 	q2ep->q2e_val[objtype].q2v_softlimit =
 		q2e.q2e_val[objtype].q2v_softlimit;
 	q2ep->q2e_val[objtype].q2v_hardlimit =
 		q2e.q2e_val[objtype].q2v_hardlimit;
 	q2ep->q2e_val[objtype].q2v_grace =
 		q2e.q2e_val[objtype].q2v_grace;
 	q2ep->q2e_val[objtype].q2v_time = 0;
 	/* if this entry now contains no information, we can free it */
 	canfree = 1;
 	for (i = 0; i < N_QL; i++) {
 		if (q2ep->q2e_val[i].q2v_cur != 0 ||
 		    (q2ep->q2e_val[i].q2v_softlimit !=
 		     q2e.q2e_val[i].q2v_softlimit) ||
 		    (q2ep->q2e_val[i].q2v_hardlimit !=
 		     q2e.q2e_val[i].q2v_hardlimit) ||
 		    (q2ep->q2e_val[i].q2v_grace !=
 		     q2e.q2e_val[i].q2v_grace)) {
 			canfree = 0;
 			break;
+		}
 		/* note: do not need to check q2v_time */
+	}
 	if (canfree == 0) {
 		quota2_bwrite(ump->um_mountp, bp);
 		goto out_wapbl;
+	}
 	/* we can free it. release bp so we can walk the list */
 	brelse(bp, 0);
 	mutex_enter(&dqlock);
 	error = getq2h(ump, idtype, &hbp, &q2h, 0);
 	if (error)
 		goto out_dqlock;
 	hash_mask = ((1 << q2h->q2h_hash_shift) - 1);
 	c.dq = dq;
 	c.id = id;
 	c.q2h = q2h;
 	error = quota2_walk_list(ump, hbp, idtype,
 	    &q2h->q2h_entries[id & hash_mask], B_MODIFY, &c,
 	    dq2clear_callback);
 	bwrite(hbp);
 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,
     int id, struct quotakey *keys, struct quotaval *vals, unsigned pos,
     int skipfirst, int skiplast)
+{
 	struct dquot *dq;
 	int error;
 	struct quota2_entry *q2ep, q2e;
 	struct buf  *bp;
 	const int needswap = UFS_MPNEEDSWAP(ump);
 	error = dqget(NULLVP, id, ump, 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,
 	    &bp, &q2ep, 0);
 	if (error) {
 		mutex_exit(&dq->dq_interlock);
 		dqrele(NULLVP, dq);
 		return error;
+	}
 	quota2_ufs_rwq2e(q2ep, &q2e, 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,
     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;
 	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, 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);
 	brelse(bp, 0);
 	mutex_exit(&dq->dq_interlock);
 	dqrele(NULLVP, dq);
 	q2e_to_quotaval(&q2e, 0, &id2, qk->qk_objtype, ret);
 	KASSERT(id2 == qk->qk_id);
 	return 0;
+}
 int
 quota2_handle_cmd_get(struct ufsmount *ump, const struct quotakey *qk,
     struct quotaval *ret)
+{
 	int error;
 	struct quota2_header *q2h;
 	struct quota2_entry q2e;
 	struct buf *bp;
 	const int needswap = UFS_MPNEEDSWAP(ump);
 	id_t id2;
 	/*
 	 * Make sure the FS-independent codes match the internal ones,
 	 * so we can use the passed-in objtype without having to
 	 * convert it explicitly to QL_BLOCK/QL_FILE.
 	 */
 	CTASSERT(QL_BLOCK == QUOTA_OBJTYPE_BLOCKS);
 	CTASSERT(QL_FILE == QUOTA_OBJTYPE_FILES);
 	CTASSERT(N_QL == 2);
 	if (qk->qk_objtype < 0 || qk->qk_objtype >= N_QL) {
 		return EINVAL;
+	}
 	if (ump->um_quotas[qk->qk_idtype] == NULLVP)
 		return ENODEV;
 	if (qk->qk_id == QUOTA_DEFAULTID) {
 		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);
 	return error;
+}
 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 */
 };
 #define Q2C_MAGIC (0xbeebe111)
 #define Q2CURSOR(qkc) ((struct ufsq2_cursor *)&qkc->u.qkc_space[0])
 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;
+	}
 	if (cursor->q2c_groups_done != 0 && cursor->q2c_groups_done != 1) {
 		return EINVAL;
+	}
 	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 */
 	long maxuids;  /* number of uids allocated */
 	uid_t *uids; /* array of uids, dynamically allocated */
 	long skip;
 	long seen;
 	long limit;
 };
 static int
 quota2_getuids_callback(struct ufsmount *ump, uint64_t *offp,
     struct quota2_entry *q2ep, uint64_t off, void *v)
+{
 	struct getuids *gu = v;
 	uid_t *newuids;
 	long newmax;
 #ifdef FFS_EI
 	const int needswap = UFS_MPNEEDSWAP(ump);
 #endif
 	if (gu->skip > 0) {
 		gu->skip--;
 		return 0;
+	}
 	if (gu->nuids == gu->maxuids) {
 		newmax = gu->maxuids + PAGE_SIZE / sizeof(uid_t);
 		newuids = realloc(gu->uids, newmax * sizeof(gu->uids[0]),
 		    M_TEMP, M_WAITOK);
 		if (newuids == NULL) {
 			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_getall(struct ufsmount *ump, struct quotakcursor *qkc,
+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 quota2_header *q2h;
 	struct quota2_entry  q2e;
 	struct buf *hbp;
 	uint64_t offset;
 	int idtype;
 	int can_switch_idtype;
 	int i, j;
 	int quota2_hash_size;
 	const int needswap = UFS_MPNEEDSWAP(ump);
 	struct getuids gu;
 	long excess;
 	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;
 	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 */
 	if (cursor->q2c_hashsize == 0) {
 		cursor->q2c_hashsize = quota2_hash_size;
 	} else if (cursor->q2c_hashsize != quota2_hash_size) {
 		error = EDEADLK;
 		goto fail;
+	}
 	gu.skip = cursor->q2c_uidpos;
 	gu.seen = 0;
 	gu.limit = (maxreturn - numreturn) / 2;
 	if (gu.limit == 0 && (maxreturn - numreturn) > 0) {
 		gu.limit = 1;
+	}
 	for (i = cursor->q2c_hashpos; i < quota2_hash_size ; i++) {
 		offset = q2h->q2h_entries[i];
 		gu.seen = 0;
 		error = quota2_walk_list(ump, hbp, idtype, &offset, 0, &gu,
 		    quota2_getuids_callback);
 		if (error && error != Q2WL_ABORT) {
 			if (gu.uids != NULL)
 				free(gu.uids, M_TEMP);
 			break;
+		}
 		if (error == Q2WL_ABORT) {
 			/* got enough uids for now */
 			error = 0;
+		}
 		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;
+		}
+	}
 	KASSERT(gu.nuids <= gu.limit);
 	cursor->q2c_hashpos = i;
 	cursor->q2c_uidpos = gu.seen;
 fail:
 	mutex_exit(&dqlock);
 	brelse(hbp, 0);
 	if (error)
 		return error;
 	if (gu.nuids == 0) {
 		if (idtype == QUOTA_IDTYPE_USER)
 			cursor->q2c_users_done = 1;
 		else
 			cursor->q2c_groups_done = 1;
 		if (can_switch_idtype) {
 			goto restart;
+		}
+	}
 	maxnum = gu.nuids*2;
 	/*
 	 * If we've already sent back the blocks value for the first id,
 	 * 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);
 	skiplast = skipfirst == 0 && (maxreturn < maxnum);
 	num = 0;
 	for (j = 0; j < gu.nuids; j++) {
 		error = quota2_result_add_q2e(ump, idtype,
 		    gu.uids[j], keys, vals, numreturn + j*2,
 		    j == 0 && skipfirst,
 		    j + 1 == gu.nuids && skiplast);
 		if (error == ENOENT)
 			continue;
 		if (error)
 			break;
 		if ((j == 0 && skipfirst) || (j + 1 == gu.nuids && skiplast)) {
 			num += 1;
 		} else {
 			num += 2;
+		}
+	}
 	numreturn += num;
 	*ret = numreturn;
 	cursor->q2c_blocks_done = skiplast;
 	if (gu.uids != NULL)
 		free(gu.uids, M_TEMP);
 	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;
 	cursor->q2c_users_done = 0;
 	cursor->q2c_groups_done = 0;
 	cursor->q2c_defaults_done = 0;
 	cursor->q2c_hashpos = 0;
 	cursor->q2c_uidpos = 0;
 	cursor->q2c_blocks_done = 0;
 	return 0;
+}
 int
 quota2_handle_cmd_cursorclose(struct ufsmount *ump, struct quotakcursor *qkc)
+{
 	struct ufsq2_cursor *cursor;
 	int error;
 	cursor = Q2CURSOR(qkc);
 	error = q2cursor_check(cursor);
 	if (error) {
 		return error;
+	}
 	/* nothing to do */
 	return 0;
+}
 int
 quota2_handle_cmd_cursorskipidtype(struct ufsmount *ump,
     struct quotakcursor *qkc, int idtype)
+{
 	struct ufsq2_cursor *cursor;
 	int error;
 	cursor = Q2CURSOR(qkc);
 	error = q2cursor_check(cursor);
 	if (error) {
 		return error;
+	}
 	switch (idtype) {
 	    case QUOTA_IDTYPE_USER:
 		cursor->q2c_users_done = 1;
 		break;
 	    case QUOTA_IDTYPE_GROUP:
 		cursor->q2c_groups_done = 1;
 		break;
 	    default:
 		return EINVAL;
+	}
 	return 0;
+}
 int
 quota2_handle_cmd_cursoratend(struct ufsmount *ump, struct quotakcursor *qkc,
     int *ret)
+{
 	struct ufsq2_cursor *cursor;
 	int error;
 	cursor = Q2CURSOR(qkc);
 	error = q2cursor_check(cursor);
 	if (error) {
 		return error;
+	}
 	*ret = (cursor->q2c_users_done && cursor->q2c_groups_done);
 	return 0;
+}
 int
 quota2_handle_cmd_cursorrewind(struct ufsmount *ump, struct quotakcursor *qkc)
+{
 	struct ufsq2_cursor *cursor;
 	int error;
 	cursor = Q2CURSOR(qkc);
 	error = q2cursor_check(cursor);
 	if (error) {
 		return error;
+	}
 	cursor->q2c_hashsize = 0;
 	cursor->q2c_users_done = 0;
 	cursor->q2c_groups_done = 0;
 	cursor->q2c_defaults_done = 0;
 	cursor->q2c_hashpos = 0;
 	cursor->q2c_uidpos = 0;
 	cursor->q2c_blocks_done = 0;
 	return 0;
+}
 int
 q2sync(struct mount *mp)
+{
 	return 0;
+}
 struct dq2get_callback {
 	uid_t id;
 	struct dquot *dq;
 };
 static int
 dq2get_callback(struct ufsmount *ump, uint64_t *offp, struct quota2_entry *q2e,
     uint64_t off, void *v)
+{
 	struct dq2get_callback *c = v;
 	daddr_t lblkno;
 	int blkoff;
 #ifdef FFS_EI
 	const int needswap = UFS_MPNEEDSWAP(ump);
 #endif
 	if (ufs_rw32(q2e->q2e_uid, needswap) == c->id) {
 		KASSERT(mutex_owned(&c->dq->dq_interlock));
 		lblkno = (off >> ump->um_mountp->mnt_fs_bshift);
 		blkoff = (off & ump->umq2_bmask);
 		c->dq->dq2_lblkno = lblkno;
 		c->dq->dq2_blkoff = blkoff;
 		return Q2WL_ABORT;
+	}
 	return 0;
+}
 int
 dq2get(struct vnode *dqvp, u_long id, struct ufsmount *ump, int type,
     struct dquot *dq)
+{
 	struct buf *bp;
 	struct quota2_header *q2h;
 	int error;
 	daddr_t offset;
 	u_long hash_mask;
 	struct dq2get_callback c = {
 		.id = id,
 		.dq = dq
 	};
 	KASSERT(mutex_owned(&dq->dq_interlock));
 	mutex_enter(&dqlock);
 	error = getq2h(ump, type, &bp, &q2h, 0);
 	if (error)
 		goto out_mutex;
 	/* look for our entry */
 	hash_mask = ((1 << q2h->q2h_hash_shift) - 1);
 	offset = q2h->q2h_entries[id & hash_mask];
 	error = quota2_walk_list(ump, bp, type, &offset, 0, (void *)&c,
 	    dq2get_callback);
 	brelse(bp, 0);
 out_mutex:
 	mutex_exit(&dqlock);
 	return error;
+}
 int
 dq2sync(struct vnode *vp, struct dquot *dq)
+{
 	return 0;
+}