3006 VERIFY[S,U,P] and ASSERT[S,U,P] frequently check if first argument is zero

@@ -18,11 +18,11 @@
  *
  * CDDL HEADER END
  */
 /*
  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2011 by Delphix. All rights reserved.
+ * Copyright (c) 2012 by Delphix. All rights reserved.
  */
 
 #include <sys/bpobj.h>
 #include <sys/zfs_context.h>
 #include <sys/refcount.h>

@@ -51,18 +51,18 @@
         bpobj_t bpo;
         dmu_object_info_t doi;
         int epb;
         dmu_buf_t *dbuf = NULL;
 
-        VERIFY3U(0, ==, bpobj_open(&bpo, os, obj));
+        VERIFY0(bpobj_open(&bpo, os, obj));
 
         mutex_enter(&bpo.bpo_lock);
 
         if (!bpo.bpo_havesubobj || bpo.bpo_phys->bpo_subobjs == 0)
                 goto out;
 
-        VERIFY3U(0, ==, dmu_object_info(os, bpo.bpo_phys->bpo_subobjs, &doi));
+        VERIFY0(dmu_object_info(os, bpo.bpo_phys->bpo_subobjs, &doi));
         epb = doi.doi_data_block_size / sizeof (uint64_t);
 
         for (i = bpo.bpo_phys->bpo_num_subobjs - 1; i >= 0; i--) {
                 uint64_t *objarray;
                 uint64_t offset, blkoff;

@@ -71,11 +71,11 @@
                 blkoff = P2PHASE(i, epb);
 
                 if (dbuf == NULL || dbuf->db_offset > offset) {
                         if (dbuf)
                                 dmu_buf_rele(dbuf, FTAG);
-                        VERIFY3U(0, ==, dmu_buf_hold(os,
+                        VERIFY0(dmu_buf_hold(os,
                             bpo.bpo_phys->bpo_subobjs, offset, FTAG, &dbuf, 0));
                 }
 
                 ASSERT3U(offset, >=, dbuf->db_offset);
                 ASSERT3U(offset, <, dbuf->db_offset + dbuf->db_size);

@@ -85,17 +85,17 @@
         }
         if (dbuf) {
                 dmu_buf_rele(dbuf, FTAG);
                 dbuf = NULL;
         }
-        VERIFY3U(0, ==, dmu_object_free(os, bpo.bpo_phys->bpo_subobjs, tx));
+        VERIFY0(dmu_object_free(os, bpo.bpo_phys->bpo_subobjs, tx));
 
 out:
         mutex_exit(&bpo.bpo_lock);
         bpobj_close(&bpo);
 
-        VERIFY3U(0, ==, dmu_object_free(os, obj, tx));
+        VERIFY0(dmu_object_free(os, obj, tx));
 }
 
 int
 bpobj_open(bpobj_t *bpo, objset_t *os, uint64_t object)
 {

@@ -202,11 +202,11 @@
                 dmu_buf_rele(dbuf, FTAG);
                 dbuf = NULL;
         }
         if (free) {
                 i++;
-                VERIFY3U(0, ==, dmu_free_range(bpo->bpo_os, bpo->bpo_object,
+                VERIFY0(dmu_free_range(bpo->bpo_os, bpo->bpo_object,
                     i * sizeof (blkptr_t), -1ULL, tx));
         }
         if (err || !bpo->bpo_havesubobj || bpo->bpo_phys->bpo_subobjs == 0)
                 goto out;
 

@@ -250,11 +250,11 @@
                         if (err)
                                 break;
                 }
                 err = bpobj_iterate_impl(&sublist, func, arg, tx, free);
                 if (free) {
-                        VERIFY3U(0, ==, bpobj_space(&sublist,
+                        VERIFY0(bpobj_space(&sublist,
                             &used_after, &comp_after, &uncomp_after));
                         bpo->bpo_phys->bpo_bytes -= used_before - used_after;
                         ASSERT3S(bpo->bpo_phys->bpo_bytes, >=, 0);
                         bpo->bpo_phys->bpo_comp -= comp_before - comp_after;
                         bpo->bpo_phys->bpo_uncomp -=

@@ -276,11 +276,11 @@
         if (dbuf) {
                 dmu_buf_rele(dbuf, FTAG);
                 dbuf = NULL;
         }
         if (free) {
-                VERIFY3U(0, ==, dmu_free_range(bpo->bpo_os,
+                VERIFY0(dmu_free_range(bpo->bpo_os,
                     bpo->bpo_phys->bpo_subobjs,
                     (i + 1) * sizeof (uint64_t), -1ULL, tx));
         }
 
 out:

@@ -319,12 +319,12 @@
         uint64_t used, comp, uncomp, subsubobjs;
 
         ASSERT(bpo->bpo_havesubobj);
         ASSERT(bpo->bpo_havecomp);
 
-        VERIFY3U(0, ==, bpobj_open(&subbpo, bpo->bpo_os, subobj));
-        VERIFY3U(0, ==, bpobj_space(&subbpo, &used, &comp, &uncomp));
+        VERIFY0(bpobj_open(&subbpo, bpo->bpo_os, subobj));
+        VERIFY0(bpobj_space(&subbpo, &used, &comp, &uncomp));
 
         if (used == 0) {
                 /* No point in having an empty subobj. */
                 bpobj_close(&subbpo);
                 bpobj_free(bpo->bpo_os, subobj, tx);

@@ -350,26 +350,26 @@
          */
         subsubobjs = subbpo.bpo_phys->bpo_subobjs;
         if (subsubobjs != 0) {
                 dmu_object_info_t doi;
 
-                VERIFY3U(0, ==, dmu_object_info(bpo->bpo_os, subsubobjs, &doi));
+                VERIFY0(dmu_object_info(bpo->bpo_os, subsubobjs, &doi));
                 if (doi.doi_max_offset == doi.doi_data_block_size) {
                         dmu_buf_t *subdb;
                         uint64_t numsubsub = subbpo.bpo_phys->bpo_num_subobjs;
 
-                        VERIFY3U(0, ==, dmu_buf_hold(bpo->bpo_os, subsubobjs,
+                        VERIFY0(dmu_buf_hold(bpo->bpo_os, subsubobjs,
                             0, FTAG, &subdb, 0));
                         dmu_write(bpo->bpo_os, bpo->bpo_phys->bpo_subobjs,
                             bpo->bpo_phys->bpo_num_subobjs * sizeof (subobj),
                             numsubsub * sizeof (subobj), subdb->db_data, tx);
                         dmu_buf_rele(subdb, FTAG);
                         bpo->bpo_phys->bpo_num_subobjs += numsubsub;
 
                         dmu_buf_will_dirty(subbpo.bpo_dbuf, tx);
                         subbpo.bpo_phys->bpo_subobjs = 0;
-                        VERIFY3U(0, ==, dmu_object_free(bpo->bpo_os,
+                        VERIFY0(dmu_object_free(bpo->bpo_os,
                             subsubobjs, tx));
                 }
         }
         bpo->bpo_phys->bpo_bytes += used;
         bpo->bpo_phys->bpo_comp += comp;

@@ -405,11 +405,11 @@
             offset < bpo->bpo_cached_dbuf->db_offset ||
             offset >= bpo->bpo_cached_dbuf->db_offset +
             bpo->bpo_cached_dbuf->db_size) {
                 if (bpo->bpo_cached_dbuf)
                         dmu_buf_rele(bpo->bpo_cached_dbuf, bpo);
-                VERIFY3U(0, ==, dmu_buf_hold(bpo->bpo_os, bpo->bpo_object,
+                VERIFY0(dmu_buf_hold(bpo->bpo_os, bpo->bpo_object,
                     offset, bpo, &bpo->bpo_cached_dbuf, 0));
         }
 
         dmu_buf_will_dirty(bpo->bpo_cached_dbuf, tx);
         bparray = bpo->bpo_cached_dbuf->db_data;