svn commit: r240262 - vendor-sys/illumos/dist/common/nvpair vendor-sys/illumos/dist/uts/common/fs/zfs vendor-sys/illumos/dist/uts/common/sys vendor/illumos/dist/cmd/zfs vendor/illumos/dist/cmd/ztes...

Martin Matuska mm at FreeBSD.org
Sun Sep 9 07:52:14 UTC 2012 

Author: mm
Date: Sun Sep  9 07:52:13 2012
New Revision: 240262
URL: http://svn.freebsd.org/changeset/base/240262

Log:
  Update vendor/illumos/dist and vendor/illumos-sys/dist
  to illumos-gate 13805:e3a9ae14a119
  (zfs changes, illumos issues #1884, #3006)

Modified:
  vendor-sys/illumos/dist/common/nvpair/fnvpair.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/arc.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/bpobj.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/bptree.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/dbuf.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/dmu_send.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/dmu_traverse.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/dmu_tx.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/dnode.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/dnode_sync.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_dataset.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_dir.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_pool.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_synctask.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/metaslab.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/spa.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/space_map.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/vdev.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/vdev_raidz.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/zap.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/zap_micro.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/zfs_debug.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/zfs_ioctl.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/zfs_rlock.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/zfs_vfsops.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/zfs_vnops.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/zfs_znode.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/zil.c
  vendor-sys/illumos/dist/uts/common/fs/zfs/zio.c
  vendor-sys/illumos/dist/uts/common/sys/debug.h

Changes in other areas also in this revision:
Modified:
  vendor/illumos/dist/cmd/zfs/zfs_main.c
  vendor/illumos/dist/cmd/ztest/ztest.c
  vendor/illumos/dist/lib/libzpool/common/sys/zfs_context.h
  vendor/illumos/dist/man/man1m/zfs.1m

Modified: vendor-sys/illumos/dist/common/nvpair/fnvpair.c
==============================================================================
--- vendor-sys/illumos/dist/common/nvpair/fnvpair.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/common/nvpair/fnvpair.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -50,7 +50,7 @@ nvlist_t *
 fnvlist_alloc(void)
 {
 	nvlist_t *nvl;
-	VERIFY3U(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP), ==, 0);
+	VERIFY0(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP));
 	return (nvl);
 }
 
@@ -64,7 +64,7 @@ size_t
 fnvlist_size(nvlist_t *nvl)
 {
 	size_t size;
-	VERIFY3U(nvlist_size(nvl, &size, NV_ENCODE_NATIVE), ==, 0);
+	VERIFY0(nvlist_size(nvl, &size, NV_ENCODE_NATIVE));
 	return (size);
 }
 
@@ -96,7 +96,7 @@ nvlist_t *
 fnvlist_unpack(char *buf, size_t buflen)
 {
 	nvlist_t *rv;
-	VERIFY3U(nvlist_unpack(buf, buflen, &rv, KM_SLEEP), ==, 0);
+	VERIFY0(nvlist_unpack(buf, buflen, &rv, KM_SLEEP));
 	return (rv);
 }
 
@@ -104,195 +104,195 @@ nvlist_t *
 fnvlist_dup(nvlist_t *nvl)
 {
 	nvlist_t *rv;
-	VERIFY3U(nvlist_dup(nvl, &rv, KM_SLEEP), ==, 0);
+	VERIFY0(nvlist_dup(nvl, &rv, KM_SLEEP));
 	return (rv);
 }
 
 void
 fnvlist_merge(nvlist_t *dst, nvlist_t *src)
 {
-	VERIFY3U(nvlist_merge(dst, src, KM_SLEEP), ==, 0);
+	VERIFY0(nvlist_merge(dst, src, KM_SLEEP));
 }
 
 void
 fnvlist_add_boolean(nvlist_t *nvl, const char *name)
 {
-	VERIFY3U(nvlist_add_boolean(nvl, name), ==, 0);
+	VERIFY0(nvlist_add_boolean(nvl, name));
 }
 
 void
 fnvlist_add_boolean_value(nvlist_t *nvl, const char *name, boolean_t val)
 {
-	VERIFY3U(nvlist_add_boolean_value(nvl, name, val), ==, 0);
+	VERIFY0(nvlist_add_boolean_value(nvl, name, val));
 }
 
 void
 fnvlist_add_byte(nvlist_t *nvl, const char *name, uchar_t val)
 {
-	VERIFY3U(nvlist_add_byte(nvl, name, val), ==, 0);
+	VERIFY0(nvlist_add_byte(nvl, name, val));
 }
 
 void
 fnvlist_add_int8(nvlist_t *nvl, const char *name, int8_t val)
 {
-	VERIFY3U(nvlist_add_int8(nvl, name, val), ==, 0);
+	VERIFY0(nvlist_add_int8(nvl, name, val));
 }
 
 void
 fnvlist_add_uint8(nvlist_t *nvl, const char *name, uint8_t val)
 {
-	VERIFY3U(nvlist_add_uint8(nvl, name, val), ==, 0);
+	VERIFY0(nvlist_add_uint8(nvl, name, val));
 }
 
 void
 fnvlist_add_int16(nvlist_t *nvl, const char *name, int16_t val)
 {
-	VERIFY3U(nvlist_add_int16(nvl, name, val), ==, 0);
+	VERIFY0(nvlist_add_int16(nvl, name, val));
 }
 
 void
 fnvlist_add_uint16(nvlist_t *nvl, const char *name, uint16_t val)
 {
-	VERIFY3U(nvlist_add_uint16(nvl, name, val), ==, 0);
+	VERIFY0(nvlist_add_uint16(nvl, name, val));
 }
 
 void
 fnvlist_add_int32(nvlist_t *nvl, const char *name, int32_t val)
 {
-	VERIFY3U(nvlist_add_int32(nvl, name, val), ==, 0);
+	VERIFY0(nvlist_add_int32(nvl, name, val));
 }
 
 void
 fnvlist_add_uint32(nvlist_t *nvl, const char *name, uint32_t val)
 {
-	VERIFY3U(nvlist_add_uint32(nvl, name, val), ==, 0);
+	VERIFY0(nvlist_add_uint32(nvl, name, val));
 }
 
 void
 fnvlist_add_int64(nvlist_t *nvl, const char *name, int64_t val)
 {
-	VERIFY3U(nvlist_add_int64(nvl, name, val), ==, 0);
+	VERIFY0(nvlist_add_int64(nvl, name, val));
 }
 
 void
 fnvlist_add_uint64(nvlist_t *nvl, const char *name, uint64_t val)
 {
-	VERIFY3U(nvlist_add_uint64(nvl, name, val), ==, 0);
+	VERIFY0(nvlist_add_uint64(nvl, name, val));
 }
 
 void
 fnvlist_add_string(nvlist_t *nvl, const char *name, const char *val)
 {
-	VERIFY3U(nvlist_add_string(nvl, name, val), ==, 0);
+	VERIFY0(nvlist_add_string(nvl, name, val));
 }
 
 void
 fnvlist_add_nvlist(nvlist_t *nvl, const char *name, nvlist_t *val)
 {
-	VERIFY3U(nvlist_add_nvlist(nvl, name, val), ==, 0);
+	VERIFY0(nvlist_add_nvlist(nvl, name, val));
 }
 
 void
 fnvlist_add_nvpair(nvlist_t *nvl, nvpair_t *pair)
 {
-	VERIFY3U(nvlist_add_nvpair(nvl, pair), ==, 0);
+	VERIFY0(nvlist_add_nvpair(nvl, pair));
 }
 
 void
 fnvlist_add_boolean_array(nvlist_t *nvl, const char *name,
     boolean_t *val, uint_t n)
 {
-	VERIFY3U(nvlist_add_boolean_array(nvl, name, val, n), ==, 0);
+	VERIFY0(nvlist_add_boolean_array(nvl, name, val, n));
 }
 
 void
 fnvlist_add_byte_array(nvlist_t *nvl, const char *name, uchar_t *val, uint_t n)
 {
-	VERIFY3U(nvlist_add_byte_array(nvl, name, val, n), ==, 0);
+	VERIFY0(nvlist_add_byte_array(nvl, name, val, n));
 }
 
 void
 fnvlist_add_int8_array(nvlist_t *nvl, const char *name, int8_t *val, uint_t n)
 {
-	VERIFY3U(nvlist_add_int8_array(nvl, name, val, n), ==, 0);
+	VERIFY0(nvlist_add_int8_array(nvl, name, val, n));
 }
 
 void
 fnvlist_add_uint8_array(nvlist_t *nvl, const char *name, uint8_t *val, uint_t n)
 {
-	VERIFY3U(nvlist_add_uint8_array(nvl, name, val, n), ==, 0);
+	VERIFY0(nvlist_add_uint8_array(nvl, name, val, n));
 }
 
 void
 fnvlist_add_int16_array(nvlist_t *nvl, const char *name, int16_t *val, uint_t n)
 {
-	VERIFY3U(nvlist_add_int16_array(nvl, name, val, n), ==, 0);
+	VERIFY0(nvlist_add_int16_array(nvl, name, val, n));
 }
 
 void
 fnvlist_add_uint16_array(nvlist_t *nvl, const char *name,
     uint16_t *val, uint_t n)
 {
-	VERIFY3U(nvlist_add_uint16_array(nvl, name, val, n), ==, 0);
+	VERIFY0(nvlist_add_uint16_array(nvl, name, val, n));
 }
 
 void
 fnvlist_add_int32_array(nvlist_t *nvl, const char *name, int32_t *val, uint_t n)
 {
-	VERIFY3U(nvlist_add_int32_array(nvl, name, val, n), ==, 0);
+	VERIFY0(nvlist_add_int32_array(nvl, name, val, n));
 }
 
 void
 fnvlist_add_uint32_array(nvlist_t *nvl, const char *name,
     uint32_t *val, uint_t n)
 {
-	VERIFY3U(nvlist_add_uint32_array(nvl, name, val, n), ==, 0);
+	VERIFY0(nvlist_add_uint32_array(nvl, name, val, n));
 }
 
 void
 fnvlist_add_int64_array(nvlist_t *nvl, const char *name, int64_t *val, uint_t n)
 {
-	VERIFY3U(nvlist_add_int64_array(nvl, name, val, n), ==, 0);
+	VERIFY0(nvlist_add_int64_array(nvl, name, val, n));
 }
 
 void
 fnvlist_add_uint64_array(nvlist_t *nvl, const char *name,
     uint64_t *val, uint_t n)
 {
-	VERIFY3U(nvlist_add_uint64_array(nvl, name, val, n), ==, 0);
+	VERIFY0(nvlist_add_uint64_array(nvl, name, val, n));
 }
 
 void
 fnvlist_add_string_array(nvlist_t *nvl, const char *name,
     char * const *val, uint_t n)
 {
-	VERIFY3U(nvlist_add_string_array(nvl, name, val, n), ==, 0);
+	VERIFY0(nvlist_add_string_array(nvl, name, val, n));
 }
 
 void
 fnvlist_add_nvlist_array(nvlist_t *nvl, const char *name,
     nvlist_t **val, uint_t n)
 {
-	VERIFY3U(nvlist_add_nvlist_array(nvl, name, val, n), ==, 0);
+	VERIFY0(nvlist_add_nvlist_array(nvl, name, val, n));
 }
 
 void
 fnvlist_remove(nvlist_t *nvl, const char *name)
 {
-	VERIFY3U(nvlist_remove_all(nvl, name), ==, 0);
+	VERIFY0(nvlist_remove_all(nvl, name));
 }
 
 void
 fnvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *pair)
 {
-	VERIFY3U(nvlist_remove_nvpair(nvl, pair), ==, 0);
+	VERIFY0(nvlist_remove_nvpair(nvl, pair));
 }
 
 nvpair_t *
 fnvlist_lookup_nvpair(nvlist_t *nvl, const char *name)
 {
 	nvpair_t *rv;
-	VERIFY3U(nvlist_lookup_nvpair(nvl, name, &rv), ==, 0);
+	VERIFY0(nvlist_lookup_nvpair(nvl, name, &rv));
 	return (rv);
 }
 
@@ -307,7 +307,7 @@ boolean_t
 fnvlist_lookup_boolean_value(nvlist_t *nvl, const char *name)
 {
 	boolean_t rv;
-	VERIFY3U(nvlist_lookup_boolean_value(nvl, name, &rv), ==, 0);
+	VERIFY0(nvlist_lookup_boolean_value(nvl, name, &rv));
 	return (rv);
 }
 
@@ -315,7 +315,7 @@ uchar_t
 fnvlist_lookup_byte(nvlist_t *nvl, const char *name)
 {
 	uchar_t rv;
-	VERIFY3U(nvlist_lookup_byte(nvl, name, &rv), ==, 0);
+	VERIFY0(nvlist_lookup_byte(nvl, name, &rv));
 	return (rv);
 }
 
@@ -323,7 +323,7 @@ int8_t
 fnvlist_lookup_int8(nvlist_t *nvl, const char *name)
 {
 	int8_t rv;
-	VERIFY3U(nvlist_lookup_int8(nvl, name, &rv), ==, 0);
+	VERIFY0(nvlist_lookup_int8(nvl, name, &rv));
 	return (rv);
 }
 
@@ -331,7 +331,7 @@ int16_t
 fnvlist_lookup_int16(nvlist_t *nvl, const char *name)
 {
 	int16_t rv;
-	VERIFY3U(nvlist_lookup_int16(nvl, name, &rv), ==, 0);
+	VERIFY0(nvlist_lookup_int16(nvl, name, &rv));
 	return (rv);
 }
 
@@ -339,7 +339,7 @@ int32_t
 fnvlist_lookup_int32(nvlist_t *nvl, const char *name)
 {
 	int32_t rv;
-	VERIFY3U(nvlist_lookup_int32(nvl, name, &rv), ==, 0);
+	VERIFY0(nvlist_lookup_int32(nvl, name, &rv));
 	return (rv);
 }
 
@@ -347,7 +347,7 @@ int64_t
 fnvlist_lookup_int64(nvlist_t *nvl, const char *name)
 {
 	int64_t rv;
-	VERIFY3U(nvlist_lookup_int64(nvl, name, &rv), ==, 0);
+	VERIFY0(nvlist_lookup_int64(nvl, name, &rv));
 	return (rv);
 }
 
@@ -355,7 +355,7 @@ uint8_t
 fnvlist_lookup_uint8_t(nvlist_t *nvl, const char *name)
 {
 	uint8_t rv;
-	VERIFY3U(nvlist_lookup_uint8(nvl, name, &rv), ==, 0);
+	VERIFY0(nvlist_lookup_uint8(nvl, name, &rv));
 	return (rv);
 }
 
@@ -363,7 +363,7 @@ uint16_t
 fnvlist_lookup_uint16(nvlist_t *nvl, const char *name)
 {
 	uint16_t rv;
-	VERIFY3U(nvlist_lookup_uint16(nvl, name, &rv), ==, 0);
+	VERIFY0(nvlist_lookup_uint16(nvl, name, &rv));
 	return (rv);
 }
 
@@ -371,7 +371,7 @@ uint32_t
 fnvlist_lookup_uint32(nvlist_t *nvl, const char *name)
 {
 	uint32_t rv;
-	VERIFY3U(nvlist_lookup_uint32(nvl, name, &rv), ==, 0);
+	VERIFY0(nvlist_lookup_uint32(nvl, name, &rv));
 	return (rv);
 }
 
@@ -379,7 +379,7 @@ uint64_t
 fnvlist_lookup_uint64(nvlist_t *nvl, const char *name)
 {
 	uint64_t rv;
-	VERIFY3U(nvlist_lookup_uint64(nvl, name, &rv), ==, 0);
+	VERIFY0(nvlist_lookup_uint64(nvl, name, &rv));
 	return (rv);
 }
 
@@ -387,7 +387,7 @@ char *
 fnvlist_lookup_string(nvlist_t *nvl, const char *name)
 {
 	char *rv;
-	VERIFY3U(nvlist_lookup_string(nvl, name, &rv), ==, 0);
+	VERIFY0(nvlist_lookup_string(nvl, name, &rv));
 	return (rv);
 }
 
@@ -395,7 +395,7 @@ nvlist_t *
 fnvlist_lookup_nvlist(nvlist_t *nvl, const char *name)
 {
 	nvlist_t *rv;
-	VERIFY3U(nvlist_lookup_nvlist(nvl, name, &rv), ==, 0);
+	VERIFY0(nvlist_lookup_nvlist(nvl, name, &rv));
 	return (rv);
 }
 
@@ -403,7 +403,7 @@ boolean_t
 fnvpair_value_boolean_value(nvpair_t *nvp)
 {
 	boolean_t rv;
-	VERIFY3U(nvpair_value_boolean_value(nvp, &rv), ==, 0);
+	VERIFY0(nvpair_value_boolean_value(nvp, &rv));
 	return (rv);
 }
 
@@ -411,7 +411,7 @@ uchar_t
 fnvpair_value_byte(nvpair_t *nvp)
 {
 	uchar_t rv;
-	VERIFY3U(nvpair_value_byte(nvp, &rv), ==, 0);
+	VERIFY0(nvpair_value_byte(nvp, &rv));
 	return (rv);
 }
 
@@ -419,7 +419,7 @@ int8_t
 fnvpair_value_int8(nvpair_t *nvp)
 {
 	int8_t rv;
-	VERIFY3U(nvpair_value_int8(nvp, &rv), ==, 0);
+	VERIFY0(nvpair_value_int8(nvp, &rv));
 	return (rv);
 }
 
@@ -427,7 +427,7 @@ int16_t
 fnvpair_value_int16(nvpair_t *nvp)
 {
 	int16_t rv;
-	VERIFY3U(nvpair_value_int16(nvp, &rv), ==, 0);
+	VERIFY0(nvpair_value_int16(nvp, &rv));
 	return (rv);
 }
 
@@ -435,7 +435,7 @@ int32_t
 fnvpair_value_int32(nvpair_t *nvp)
 {
 	int32_t rv;
-	VERIFY3U(nvpair_value_int32(nvp, &rv), ==, 0);
+	VERIFY0(nvpair_value_int32(nvp, &rv));
 	return (rv);
 }
 
@@ -443,7 +443,7 @@ int64_t
 fnvpair_value_int64(nvpair_t *nvp)
 {
 	int64_t rv;
-	VERIFY3U(nvpair_value_int64(nvp, &rv), ==, 0);
+	VERIFY0(nvpair_value_int64(nvp, &rv));
 	return (rv);
 }
 
@@ -451,7 +451,7 @@ uint8_t
 fnvpair_value_uint8_t(nvpair_t *nvp)
 {
 	uint8_t rv;
-	VERIFY3U(nvpair_value_uint8(nvp, &rv), ==, 0);
+	VERIFY0(nvpair_value_uint8(nvp, &rv));
 	return (rv);
 }
 
@@ -459,7 +459,7 @@ uint16_t
 fnvpair_value_uint16(nvpair_t *nvp)
 {
 	uint16_t rv;
-	VERIFY3U(nvpair_value_uint16(nvp, &rv), ==, 0);
+	VERIFY0(nvpair_value_uint16(nvp, &rv));
 	return (rv);
 }
 
@@ -467,7 +467,7 @@ uint32_t
 fnvpair_value_uint32(nvpair_t *nvp)
 {
 	uint32_t rv;
-	VERIFY3U(nvpair_value_uint32(nvp, &rv), ==, 0);
+	VERIFY0(nvpair_value_uint32(nvp, &rv));
 	return (rv);
 }
 
@@ -475,7 +475,7 @@ uint64_t
 fnvpair_value_uint64(nvpair_t *nvp)
 {
 	uint64_t rv;
-	VERIFY3U(nvpair_value_uint64(nvp, &rv), ==, 0);
+	VERIFY0(nvpair_value_uint64(nvp, &rv));
 	return (rv);
 }
 
@@ -483,7 +483,7 @@ char *
 fnvpair_value_string(nvpair_t *nvp)
 {
 	char *rv;
-	VERIFY3U(nvpair_value_string(nvp, &rv), ==, 0);
+	VERIFY0(nvpair_value_string(nvp, &rv));
 	return (rv);
 }
 
@@ -491,6 +491,6 @@ nvlist_t *
 fnvpair_value_nvlist(nvpair_t *nvp)
 {
 	nvlist_t *rv;
-	VERIFY3U(nvpair_value_nvlist(nvp, &rv), ==, 0);
+	VERIFY0(nvpair_value_nvlist(nvp, &rv));
 	return (rv);
 }

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/arc.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/arc.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/arc.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -1064,7 +1064,7 @@ add_reference(arc_buf_hdr_t *ab, kmutex_
 		ASSERT(list_link_active(&ab->b_arc_node));
 		list_remove(list, ab);
 		if (GHOST_STATE(ab->b_state)) {
-			ASSERT3U(ab->b_datacnt, ==, 0);
+			ASSERT0(ab->b_datacnt);
 			ASSERT3P(ab->b_buf, ==, NULL);
 			delta = ab->b_size;
 		}
@@ -1691,7 +1691,7 @@ arc_evict(arc_state_t *state, uint64_t s
 		hash_lock = HDR_LOCK(ab);
 		have_lock = MUTEX_HELD(hash_lock);
 		if (have_lock || mutex_tryenter(hash_lock)) {
-			ASSERT3U(refcount_count(&ab->b_refcnt), ==, 0);
+			ASSERT0(refcount_count(&ab->b_refcnt));
 			ASSERT(ab->b_datacnt > 0);
 			while (ab->b_buf) {
 				arc_buf_t *buf = ab->b_buf;
@@ -2519,7 +2519,7 @@ arc_access(arc_buf_hdr_t *buf, kmutex_t 
 			 * This is a prefetch access...
 			 * move this block back to the MRU state.
 			 */
-			ASSERT3U(refcount_count(&buf->b_refcnt), ==, 0);
+			ASSERT0(refcount_count(&buf->b_refcnt));
 			new_state = arc_mru;
 		}
 
@@ -2861,7 +2861,7 @@ top:
 			/* this block is in the ghost cache */
 			ASSERT(GHOST_STATE(hdr->b_state));
 			ASSERT(!HDR_IO_IN_PROGRESS(hdr));
-			ASSERT3U(refcount_count(&hdr->b_refcnt), ==, 0);
+			ASSERT0(refcount_count(&hdr->b_refcnt));
 			ASSERT(hdr->b_buf == NULL);
 
 			/* if this is a prefetch, we don't have a reference */
@@ -4436,7 +4436,7 @@ l2arc_write_buffers(spa_t *spa, l2arc_de
 	mutex_exit(&l2arc_buflist_mtx);
 
 	if (pio == NULL) {
-		ASSERT3U(write_sz, ==, 0);
+		ASSERT0(write_sz);
 		kmem_cache_free(hdr_cache, head);
 		return (0);
 	}

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/bpobj.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/bpobj.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/bpobj.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -43,7 +43,7 @@ bpobj_alloc_empty(objset_t *os, int bloc
 
 	if (spa_feature_is_enabled(spa, empty_bpobj_feat)) {
 		if (!spa_feature_is_active(spa, empty_bpobj_feat)) {
-			ASSERT3U(dp->dp_empty_bpobj, ==, 0);
+			ASSERT0(dp->dp_empty_bpobj);
 			dp->dp_empty_bpobj =
 			    bpobj_alloc(os, SPA_MAXBLOCKSIZE, tx);
 			VERIFY(zap_add(os,

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/bptree.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/bptree.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/bptree.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -94,9 +94,9 @@ bptree_free(objset_t *os, uint64_t obj, 
 	VERIFY3U(0, ==, dmu_bonus_hold(os, obj, FTAG, &db));
 	bt = db->db_data;
 	ASSERT3U(bt->bt_begin, ==, bt->bt_end);
-	ASSERT3U(bt->bt_bytes, ==, 0);
-	ASSERT3U(bt->bt_comp, ==, 0);
-	ASSERT3U(bt->bt_uncomp, ==, 0);
+	ASSERT0(bt->bt_bytes);
+	ASSERT0(bt->bt_comp);
+	ASSERT0(bt->bt_uncomp);
 	dmu_buf_rele(db, FTAG);
 
 	return (dmu_object_free(os, obj, tx));
@@ -198,7 +198,7 @@ bptree_iterate(objset_t *os, uint64_t ob
 				/* save bookmark for future resume */
 				ASSERT3U(bte.be_zb.zb_objset, ==,
 				    ZB_DESTROYED_OBJSET);
-				ASSERT3U(bte.be_zb.zb_level, ==, 0);
+				ASSERT0(bte.be_zb.zb_level);
 				dmu_write(os, obj, i * sizeof (bte),
 				    sizeof (bte), &bte, tx);
 				break;
@@ -214,9 +214,9 @@ bptree_iterate(objset_t *os, uint64_t ob
 
 	/* if all blocks are free there should be no used space */
 	if (ba.ba_phys->bt_begin == ba.ba_phys->bt_end) {
-		ASSERT3U(ba.ba_phys->bt_bytes, ==, 0);
-		ASSERT3U(ba.ba_phys->bt_comp, ==, 0);
-		ASSERT3U(ba.ba_phys->bt_uncomp, ==, 0);
+		ASSERT0(ba.ba_phys->bt_bytes);
+		ASSERT0(ba.ba_phys->bt_comp);
+		ASSERT0(ba.ba_phys->bt_uncomp);
 	}
 
 	dmu_buf_rele(db, FTAG);

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/dbuf.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/dbuf.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/dbuf.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -328,7 +328,7 @@ dbuf_verify(dmu_buf_impl_t *db)
 	} else if (db->db_blkid == DMU_SPILL_BLKID) {
 		ASSERT(dn != NULL);
 		ASSERT3U(db->db.db_size, >=, dn->dn_bonuslen);
-		ASSERT3U(db->db.db_offset, ==, 0);
+		ASSERT0(db->db.db_offset);
 	} else {
 		ASSERT3U(db->db.db_offset, ==, db->db_blkid * db->db.db_size);
 	}
@@ -2308,7 +2308,7 @@ dbuf_sync_leaf(dbuf_dirty_record_t *dr, 
 		dbuf_dirty_record_t **drp;
 
 		ASSERT(*datap != NULL);
-		ASSERT3U(db->db_level, ==, 0);
+		ASSERT0(db->db_level);
 		ASSERT3U(dn->dn_phys->dn_bonuslen, <=, DN_MAX_BONUSLEN);
 		bcopy(*datap, DN_BONUS(dn->dn_phys), dn->dn_phys->dn_bonuslen);
 		DB_DNODE_EXIT(db);
@@ -2507,7 +2507,7 @@ dbuf_write_done(zio_t *zio, arc_buf_t *b
 	uint64_t txg = zio->io_txg;
 	dbuf_dirty_record_t **drp, *dr;
 
-	ASSERT3U(zio->io_error, ==, 0);
+	ASSERT0(zio->io_error);
 	ASSERT(db->db_blkptr == bp);
 
 	if (zio->io_flags & ZIO_FLAG_IO_REWRITE) {

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/dmu_send.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/dmu_send.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/dmu_send.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -57,7 +57,7 @@ dump_bytes(dmu_sendarg_t *dsp, void *buf
 {
 	dsl_dataset_t *ds = dsp->dsa_os->os_dsl_dataset;
 	ssize_t resid; /* have to get resid to get detailed errno */
-	ASSERT3U(len % 8, ==, 0);
+	ASSERT0(len % 8);
 
 	fletcher_4_incremental_native(buf, len, &dsp->dsa_zc);
 	dsp->dsa_err = vn_rdwr(UIO_WRITE, dsp->dsa_vp,
@@ -961,7 +961,7 @@ restore_read(struct restorearg *ra, int 
 	int done = 0;
 
 	/* some things will require 8-byte alignment, so everything must */
-	ASSERT3U(len % 8, ==, 0);
+	ASSERT0(len % 8);
 
 	while (done < len) {
 		ssize_t resid;
@@ -1638,7 +1638,7 @@ out:
 		(void) add_ds_to_guidmap(drc->drc_guid_to_ds_map, ds);
 	dsl_dataset_disown(ds, dmu_recv_tag);
 	myerr = dsl_dataset_destroy(drc->drc_real_ds, dmu_recv_tag, B_FALSE);
-	ASSERT3U(myerr, ==, 0);
+	ASSERT0(myerr);
 	return (err);
 }
 

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/dmu_traverse.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/dmu_traverse.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/dmu_traverse.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -176,7 +176,7 @@ static void
 traverse_pause(traverse_data_t *td, const zbookmark_t *zb)
 {
 	ASSERT(td->td_resume != NULL);
-	ASSERT3U(zb->zb_level, ==, 0);
+	ASSERT0(zb->zb_level);
 	bcopy(zb, td->td_resume, sizeof (*td->td_resume));
 }
 

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/dmu_tx.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/dmu_tx.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/dmu_tx.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -911,7 +911,7 @@ dmu_tx_try_assign(dmu_tx_t *tx, uint64_t
 	uint64_t memory, asize, fsize, usize;
 	uint64_t towrite, tofree, tooverwrite, tounref, tohold, fudge;
 
-	ASSERT3U(tx->tx_txg, ==, 0);
+	ASSERT0(tx->tx_txg);
 
 	if (tx->tx_err)
 		return (tx->tx_err);

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/dnode.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/dnode.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/dnode.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -137,32 +137,32 @@ dnode_dest(void *arg, void *unused)
 		ASSERT(!list_link_active(&dn->dn_dirty_link[i]));
 		avl_destroy(&dn->dn_ranges[i]);
 		list_destroy(&dn->dn_dirty_records[i]);
-		ASSERT3U(dn->dn_next_nblkptr[i], ==, 0);
-		ASSERT3U(dn->dn_next_nlevels[i], ==, 0);
-		ASSERT3U(dn->dn_next_indblkshift[i], ==, 0);
-		ASSERT3U(dn->dn_next_bonustype[i], ==, 0);
-		ASSERT3U(dn->dn_rm_spillblk[i], ==, 0);
-		ASSERT3U(dn->dn_next_bonuslen[i], ==, 0);
-		ASSERT3U(dn->dn_next_blksz[i], ==, 0);
+		ASSERT0(dn->dn_next_nblkptr[i]);
+		ASSERT0(dn->dn_next_nlevels[i]);
+		ASSERT0(dn->dn_next_indblkshift[i]);
+		ASSERT0(dn->dn_next_bonustype[i]);
+		ASSERT0(dn->dn_rm_spillblk[i]);
+		ASSERT0(dn->dn_next_bonuslen[i]);
+		ASSERT0(dn->dn_next_blksz[i]);
 	}
 
-	ASSERT3U(dn->dn_allocated_txg, ==, 0);
-	ASSERT3U(dn->dn_free_txg, ==, 0);
-	ASSERT3U(dn->dn_assigned_txg, ==, 0);
-	ASSERT3U(dn->dn_dirtyctx, ==, 0);
+	ASSERT0(dn->dn_allocated_txg);
+	ASSERT0(dn->dn_free_txg);
+	ASSERT0(dn->dn_assigned_txg);
+	ASSERT0(dn->dn_dirtyctx);
 	ASSERT3P(dn->dn_dirtyctx_firstset, ==, NULL);
 	ASSERT3P(dn->dn_bonus, ==, NULL);
 	ASSERT(!dn->dn_have_spill);
 	ASSERT3P(dn->dn_zio, ==, NULL);
-	ASSERT3U(dn->dn_oldused, ==, 0);
-	ASSERT3U(dn->dn_oldflags, ==, 0);
-	ASSERT3U(dn->dn_olduid, ==, 0);
-	ASSERT3U(dn->dn_oldgid, ==, 0);
-	ASSERT3U(dn->dn_newuid, ==, 0);
-	ASSERT3U(dn->dn_newgid, ==, 0);
-	ASSERT3U(dn->dn_id_flags, ==, 0);
+	ASSERT0(dn->dn_oldused);
+	ASSERT0(dn->dn_oldflags);
+	ASSERT0(dn->dn_olduid);
+	ASSERT0(dn->dn_oldgid);
+	ASSERT0(dn->dn_newuid);
+	ASSERT0(dn->dn_newgid);
+	ASSERT0(dn->dn_id_flags);
 
-	ASSERT3U(dn->dn_dbufs_count, ==, 0);
+	ASSERT0(dn->dn_dbufs_count);
 	list_destroy(&dn->dn_dbufs);
 }
 
@@ -361,7 +361,7 @@ dnode_rm_spill(dnode_t *dn, dmu_tx_t *tx
 static void
 dnode_setdblksz(dnode_t *dn, int size)
 {
-	ASSERT3U(P2PHASE(size, SPA_MINBLOCKSIZE), ==, 0);
+	ASSERT0(P2PHASE(size, SPA_MINBLOCKSIZE));
 	ASSERT3U(size, <=, SPA_MAXBLOCKSIZE);
 	ASSERT3U(size, >=, SPA_MINBLOCKSIZE);
 	ASSERT3U(size >> SPA_MINBLOCKSHIFT, <,
@@ -506,24 +506,24 @@ dnode_allocate(dnode_t *dn, dmu_object_t
 	ASSERT(DMU_OT_IS_VALID(bonustype));
 	ASSERT3U(bonuslen, <=, DN_MAX_BONUSLEN);
 	ASSERT(dn->dn_type == DMU_OT_NONE);
-	ASSERT3U(dn->dn_maxblkid, ==, 0);
-	ASSERT3U(dn->dn_allocated_txg, ==, 0);
-	ASSERT3U(dn->dn_assigned_txg, ==, 0);
+	ASSERT0(dn->dn_maxblkid);
+	ASSERT0(dn->dn_allocated_txg);
+	ASSERT0(dn->dn_assigned_txg);
 	ASSERT(refcount_is_zero(&dn->dn_tx_holds));
 	ASSERT3U(refcount_count(&dn->dn_holds), <=, 1);
 	ASSERT3P(list_head(&dn->dn_dbufs), ==, NULL);
 
 	for (i = 0; i < TXG_SIZE; i++) {
-		ASSERT3U(dn->dn_next_nblkptr[i], ==, 0);
-		ASSERT3U(dn->dn_next_nlevels[i], ==, 0);
-		ASSERT3U(dn->dn_next_indblkshift[i], ==, 0);
-		ASSERT3U(dn->dn_next_bonuslen[i], ==, 0);
-		ASSERT3U(dn->dn_next_bonustype[i], ==, 0);
-		ASSERT3U(dn->dn_rm_spillblk[i], ==, 0);
-		ASSERT3U(dn->dn_next_blksz[i], ==, 0);
+		ASSERT0(dn->dn_next_nblkptr[i]);
+		ASSERT0(dn->dn_next_nlevels[i]);
+		ASSERT0(dn->dn_next_indblkshift[i]);
+		ASSERT0(dn->dn_next_bonuslen[i]);
+		ASSERT0(dn->dn_next_bonustype[i]);
+		ASSERT0(dn->dn_rm_spillblk[i]);
+		ASSERT0(dn->dn_next_blksz[i]);
 		ASSERT(!list_link_active(&dn->dn_dirty_link[i]));
 		ASSERT3P(list_head(&dn->dn_dirty_records[i]), ==, NULL);
-		ASSERT3U(avl_numnodes(&dn->dn_ranges[i]), ==, 0);
+		ASSERT0(avl_numnodes(&dn->dn_ranges[i]));
 	}
 
 	dn->dn_type = ot;
@@ -565,7 +565,7 @@ dnode_reallocate(dnode_t *dn, dmu_object
 
 	ASSERT3U(blocksize, >=, SPA_MINBLOCKSIZE);
 	ASSERT3U(blocksize, <=, SPA_MAXBLOCKSIZE);
-	ASSERT3U(blocksize % SPA_MINBLOCKSIZE, ==, 0);
+	ASSERT0(blocksize % SPA_MINBLOCKSIZE);
 	ASSERT(dn->dn_object != DMU_META_DNODE_OBJECT || dmu_tx_private_ok(tx));
 	ASSERT(tx->tx_txg != 0);
 	ASSERT((bonustype == DMU_OT_NONE && bonuslen == 0) ||
@@ -1235,9 +1235,9 @@ dnode_setdirty(dnode_t *dn, dmu_tx_t *tx
 
 	ASSERT(!refcount_is_zero(&dn->dn_holds) || list_head(&dn->dn_dbufs));
 	ASSERT(dn->dn_datablksz != 0);
-	ASSERT3U(dn->dn_next_bonuslen[txg&TXG_MASK], ==, 0);
-	ASSERT3U(dn->dn_next_blksz[txg&TXG_MASK], ==, 0);
-	ASSERT3U(dn->dn_next_bonustype[txg&TXG_MASK], ==, 0);
+	ASSERT0(dn->dn_next_bonuslen[txg&TXG_MASK]);
+	ASSERT0(dn->dn_next_blksz[txg&TXG_MASK]);
+	ASSERT0(dn->dn_next_bonustype[txg&TXG_MASK]);
 
 	dprintf_ds(os->os_dsl_dataset, "obj=%llu txg=%llu\n",
 	    dn->dn_object, txg);
@@ -1587,7 +1587,7 @@ dnode_free_range(dnode_t *dn, uint64_t o
 	else
 		tail = P2PHASE(len, blksz);
 
-	ASSERT3U(P2PHASE(off, blksz), ==, 0);
+	ASSERT0(P2PHASE(off, blksz));
 	/* zero out any partial block data at the end of the range */
 	if (tail) {
 		if (len < tail)
@@ -1769,7 +1769,7 @@ dnode_diduse_space(dnode_t *dn, int64_t 
 	space += delta;
 	if (spa_version(dn->dn_objset->os_spa) < SPA_VERSION_DNODE_BYTES) {
 		ASSERT((dn->dn_phys->dn_flags & DNODE_FLAG_USED_BYTES) == 0);
-		ASSERT3U(P2PHASE(space, 1<<DEV_BSHIFT), ==, 0);
+		ASSERT0(P2PHASE(space, 1<<DEV_BSHIFT));
 		dn->dn_phys->dn_used = space >> DEV_BSHIFT;
 	} else {
 		dn->dn_phys->dn_used = space;

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/dnode_sync.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/dnode_sync.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/dnode_sync.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -274,7 +274,7 @@ free_children(dmu_buf_impl_t *db, uint64
 			continue;
 		rw_enter(&dn->dn_struct_rwlock, RW_READER);
 		err = dbuf_hold_impl(dn, db->db_level-1, i, TRUE, FTAG, &subdb);
-		ASSERT3U(err, ==, 0);
+		ASSERT0(err);
 		rw_exit(&dn->dn_struct_rwlock);
 
 		if (free_children(subdb, blkid, nblks, trunc, tx) == ALL) {
@@ -294,7 +294,7 @@ free_children(dmu_buf_impl_t *db, uint64
 			continue;
 		else if (i == end && !trunc)
 			continue;
-		ASSERT3U(bp->blk_birth, ==, 0);
+		ASSERT0(bp->blk_birth);
 	}
 #endif
 	ASSERT(all || blocks_freed == 0 || db->db_last_dirty);
@@ -350,7 +350,7 @@ dnode_sync_free_range(dnode_t *dn, uint6
 			continue;
 		rw_enter(&dn->dn_struct_rwlock, RW_READER);
 		err = dbuf_hold_impl(dn, dnlevel-1, i, TRUE, FTAG, &db);
-		ASSERT3U(err, ==, 0);
+		ASSERT0(err);
 		rw_exit(&dn->dn_struct_rwlock);
 
 		if (free_children(db, blkid, nblks, trunc, tx) == ALL) {
@@ -471,7 +471,7 @@ dnode_sync_free(dnode_t *dn, dmu_tx_t *t
 	 * Our contents should have been freed in dnode_sync() by the
 	 * free range record inserted by the caller of dnode_free().
 	 */
-	ASSERT3U(DN_USED_BYTES(dn->dn_phys), ==, 0);
+	ASSERT0(DN_USED_BYTES(dn->dn_phys));
 	ASSERT(BP_IS_HOLE(dn->dn_phys->dn_blkptr));
 
 	dnode_undirty_dbufs(&dn->dn_dirty_records[txgoff]);

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_dataset.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_dataset.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_dataset.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -1498,7 +1498,7 @@ remove_from_next_clones(dsl_dataset_t *d
 	 * remove this one.
 	 */
 	if (err != ENOENT) {
-		VERIFY3U(err, ==, 0);
+		VERIFY0(err);
 	}
 	ASSERT3U(0, ==, zap_count(mos, ds->ds_phys->ds_next_clones_obj,
 	    &count));
@@ -1585,7 +1585,7 @@ process_old_deadlist(dsl_dataset_t *ds, 
 	poa.pio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
 	VERIFY3U(0, ==, bpobj_iterate(&ds_next->ds_deadlist.dl_bpobj,
 	    process_old_cb, &poa, tx));
-	VERIFY3U(zio_wait(poa.pio), ==, 0);
+	VERIFY0(zio_wait(poa.pio));
 	ASSERT3U(poa.used, ==, ds->ds_phys->ds_unique_bytes);
 
 	/* change snapused */
@@ -1620,7 +1620,7 @@ old_synchronous_dataset_destroy(dsl_data
 	err = traverse_dataset(ds,
 	    ds->ds_phys->ds_prev_snap_txg, TRAVERSE_POST,
 	    kill_blkptr, &ka);
-	ASSERT3U(err, ==, 0);
+	ASSERT0(err);
 	ASSERT(!DS_UNIQUE_IS_ACCURATE(ds) || ds->ds_phys->ds_unique_bytes == 0);
 
 	return (err);
@@ -1676,7 +1676,7 @@ dsl_dataset_destroy_sync(void *arg1, voi
 		psa.psa_effective_value = 0;	/* predict default value */
 
 		dsl_dataset_set_reservation_sync(ds, &psa, tx);
-		ASSERT3U(ds->ds_reserved, ==, 0);
+		ASSERT0(ds->ds_reserved);
 	}
 
 	ASSERT(RW_WRITE_HELD(&dp->dp_config_rwlock));
@@ -1943,7 +1943,7 @@ dsl_dataset_destroy_sync(void *arg1, voi
 
 			err = dsl_dataset_snap_lookup(ds_head,
 			    ds->ds_snapname, &val);
-			ASSERT3U(err, ==, 0);
+			ASSERT0(err);
 			ASSERT3U(val, ==, obj);
 		}
 #endif
@@ -2437,13 +2437,13 @@ dsl_dataset_snapshot_rename_sync(void *a
 
 	VERIFY(0 == dsl_dataset_get_snapname(ds));
 	err = dsl_dataset_snap_remove(hds, ds->ds_snapname, tx);
-	ASSERT3U(err, ==, 0);
+	ASSERT0(err);
 	mutex_enter(&ds->ds_lock);
 	(void) strcpy(ds->ds_snapname, newsnapname);
 	mutex_exit(&ds->ds_lock);
 	err = zap_add(mos, hds->ds_phys->ds_snapnames_zapobj,
 	    ds->ds_snapname, 8, 1, &ds->ds_object, tx);
-	ASSERT3U(err, ==, 0);
+	ASSERT0(err);
 
 	spa_history_log_internal_ds(ds, "rename", tx,
 	    "-> @%s", newsnapname);
@@ -2897,7 +2897,7 @@ dsl_dataset_promote_sync(void *arg1, voi
 			zap_cursor_fini(&zc);
 		}
 
-		ASSERT3U(dsl_prop_numcb(ds), ==, 0);
+		ASSERT0(dsl_prop_numcb(ds));
 	}
 
 	/*

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_dir.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_dir.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_dir.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -492,10 +492,10 @@ dsl_dir_destroy_sync(void *arg1, void *t
 	 */
 	dsl_dir_set_reservation_sync_impl(dd, 0, tx);
 
-	ASSERT3U(dd->dd_phys->dd_used_bytes, ==, 0);
-	ASSERT3U(dd->dd_phys->dd_reserved, ==, 0);
+	ASSERT0(dd->dd_phys->dd_used_bytes);
+	ASSERT0(dd->dd_phys->dd_reserved);
 	for (t = 0; t < DD_USED_NUM; t++)
-		ASSERT3U(dd->dd_phys->dd_used_breakdown[t], ==, 0);
+		ASSERT0(dd->dd_phys->dd_used_breakdown[t]);
 
 	VERIFY(0 == zap_destroy(mos, dd->dd_phys->dd_child_dir_zapobj, tx));
 	VERIFY(0 == zap_destroy(mos, dd->dd_phys->dd_props_zapobj, tx));
@@ -584,7 +584,7 @@ dsl_dir_sync(dsl_dir_t *dd, dmu_tx_t *tx
 	ASSERT(dmu_tx_is_syncing(tx));
 
 	mutex_enter(&dd->dd_lock);
-	ASSERT3U(dd->dd_tempreserved[tx->tx_txg&TXG_MASK], ==, 0);
+	ASSERT0(dd->dd_tempreserved[tx->tx_txg&TXG_MASK]);
 	dprintf_dd(dd, "txg=%llu towrite=%lluK\n", tx->tx_txg,
 	    dd->dd_space_towrite[tx->tx_txg&TXG_MASK] / 1024);
 	dd->dd_space_towrite[tx->tx_txg&TXG_MASK] = 0;
@@ -1326,7 +1326,7 @@ dsl_dir_rename_sync(void *arg1, void *ar
 	/* remove from old parent zapobj */
 	err = zap_remove(mos, dd->dd_parent->dd_phys->dd_child_dir_zapobj,
 	    dd->dd_myname, tx);
-	ASSERT3U(err, ==, 0);
+	ASSERT0(err);
 
 	(void) strcpy(dd->dd_myname, ra->mynewname);
 	dsl_dir_close(dd->dd_parent, dd);
@@ -1337,7 +1337,7 @@ dsl_dir_rename_sync(void *arg1, void *ar
 	/* add to new parent zapobj */
 	err = zap_add(mos, ra->newparent->dd_phys->dd_child_dir_zapobj,
 	    dd->dd_myname, 8, 1, &dd->dd_object, tx);
-	ASSERT3U(err, ==, 0);
+	ASSERT0(err);
 
 }
 

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_pool.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_pool.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_pool.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -264,7 +264,7 @@ dsl_pool_create(spa_t *spa, nvlist_t *zp
 	/* create the pool directory */
 	err = zap_create_claim(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
 	    DMU_OT_OBJECT_DIRECTORY, DMU_OT_NONE, 0, tx);
-	ASSERT3U(err, ==, 0);
+	ASSERT0(err);
 
 	/* Initialize scan structures */
 	VERIFY3U(0, ==, dsl_scan_init(dp, txg));

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_synctask.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_synctask.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/dsl_synctask.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -163,7 +163,7 @@ dsl_sync_task_group_sync(dsl_sync_task_g
 	dsl_pool_t *dp = dstg->dstg_pool;
 	uint64_t quota, used;
 
-	ASSERT3U(dstg->dstg_err, ==, 0);
+	ASSERT0(dstg->dstg_err);
 
 	/*
 	 * Check for sufficient space.  We just check against what's

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/metaslab.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/metaslab.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/metaslab.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -769,7 +769,7 @@ metaslab_fini(metaslab_t *msp)
 	for (int t = 0; t < TXG_DEFER_SIZE; t++)
 		space_map_destroy(&msp->ms_defermap[t]);
 
-	ASSERT3S(msp->ms_deferspace, ==, 0);
+	ASSERT0(msp->ms_deferspace);
 
 	mutex_exit(&msp->ms_lock);
 	mutex_destroy(&msp->ms_lock);

Modified: vendor-sys/illumos/dist/uts/common/fs/zfs/spa.c
==============================================================================
--- vendor-sys/illumos/dist/uts/common/fs/zfs/spa.c	Sun Sep  9 07:48:51 2012	(r240261)
+++ vendor-sys/illumos/dist/uts/common/fs/zfs/spa.c	Sun Sep  9 07:52:13 2012	(r240262)
@@ -714,7 +714,7 @@ spa_change_guid_sync(void *arg1, void *a
 	vdev_config_dirty(rvd);
 	spa_config_exit(spa, SCL_STATE, FTAG);
 
-	spa_history_log_internal(spa, "guid change", tx, "old=%llu new=%llu",
+	spa_history_log_internal(spa, "guid change", tx, "old=%lld new=%lld",
 	    oldguid, *newguid);
 }
 
@@ -5027,7 +5027,7 @@ spa_vdev_remove_evacuate(spa_t *spa, vde
 	 * The evacuation succeeded.  Remove any remaining MOS metadata
 	 * associated with this vdev, and wait for these changes to sync.
 	 */
-	ASSERT3U(vd->vdev_stat.vs_alloc, ==, 0);
+	ASSERT0(vd->vdev_stat.vs_alloc);
 	txg = spa_vdev_config_enter(spa);
 	vd->vdev_removing = B_TRUE;
 	vdev_dirty(vd, 0, NULL, txg);
@@ -6019,7 +6019,7 @@ spa_sync(spa_t *spa, uint64_t txg)
 		zio_t *zio = zio_root(spa, NULL, NULL, 0);
 		VERIFY3U(bpobj_iterate(defer_bpo,
 		    spa_free_sync_cb, zio, tx), ==, 0);
-		VERIFY3U(zio_wait(zio), ==, 0);
+		VERIFY0(zio_wait(zio));
 	}
 
 	/*

*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***

More information about the svn-src-all mailing list