Print this page
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) 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/dsl_dataset.h>
 #include <sys/dmu.h>
 #include <sys/refcount.h>

@@ -80,11 +80,11 @@
         for (zap_cursor_init(&zc, dl->dl_os, dl->dl_object);
             zap_cursor_retrieve(&zc, &za) == 0;
             zap_cursor_advance(&zc)) {
                 dsl_deadlist_entry_t *dle = kmem_alloc(sizeof (*dle), KM_SLEEP);
                 dle->dle_mintxg = strtonum(za.za_name, NULL);
-                VERIFY3U(0, ==, bpobj_open(&dle->dle_bpobj, dl->dl_os,
+                VERIFY0(bpobj_open(&dle->dle_bpobj, dl->dl_os,
                     za.za_first_integer));
                 avl_add(&dl->dl_tree, dle);
         }
         zap_cursor_fini(&zc);
         dl->dl_havetree = B_TRUE;

@@ -96,17 +96,17 @@
         dmu_object_info_t doi;
 
         mutex_init(&dl->dl_lock, NULL, MUTEX_DEFAULT, NULL);
         dl->dl_os = os;
         dl->dl_object = object;
-        VERIFY3U(0, ==, dmu_bonus_hold(os, object, dl, &dl->dl_dbuf));
+        VERIFY0(dmu_bonus_hold(os, object, dl, &dl->dl_dbuf));
         dmu_object_info_from_db(dl->dl_dbuf, &doi);
         if (doi.doi_type == DMU_OT_BPOBJ) {
                 dmu_buf_rele(dl->dl_dbuf, dl);
                 dl->dl_dbuf = NULL;
                 dl->dl_oldfmt = B_TRUE;
-                VERIFY3U(0, ==, bpobj_open(&dl->dl_bpobj, os, object));
+                VERIFY0(bpobj_open(&dl->dl_bpobj, os, object));
                 return;
         }
 
         dl->dl_oldfmt = B_FALSE;
         dl->dl_phys = dl->dl_dbuf->db_data;

@@ -153,11 +153,11 @@
 {
         dmu_object_info_t doi;
         zap_cursor_t zc;
         zap_attribute_t za;
 
-        VERIFY3U(0, ==, dmu_object_info(os, dlobj, &doi));
+        VERIFY0(dmu_object_info(os, dlobj, &doi));
         if (doi.doi_type == DMU_OT_BPOBJ) {
                 bpobj_free(os, dlobj, tx);
                 return;
         }
 

@@ -164,11 +164,11 @@
         for (zap_cursor_init(&zc, os, dlobj);
             zap_cursor_retrieve(&zc, &za) == 0;
             zap_cursor_advance(&zc))
                 bpobj_free(os, za.za_first_integer, tx);
         zap_cursor_fini(&zc);
-        VERIFY3U(0, ==, dmu_object_free(os, dlobj, tx));
+        VERIFY0(dmu_object_free(os, dlobj, tx));
 }
 
 void
 dsl_deadlist_insert(dsl_deadlist_t *dl, const blkptr_t *bp, dmu_tx_t *tx)
 {

@@ -216,14 +216,14 @@
         dsl_deadlist_load_tree(dl);
 
         dle = kmem_alloc(sizeof (*dle), KM_SLEEP);
         dle->dle_mintxg = mintxg;
         obj = bpobj_alloc(dl->dl_os, SPA_MAXBLOCKSIZE, tx);
-        VERIFY3U(0, ==, bpobj_open(&dle->dle_bpobj, dl->dl_os, obj));
+        VERIFY0(bpobj_open(&dle->dle_bpobj, dl->dl_os, obj));
         avl_add(&dl->dl_tree, dle);
 
-        VERIFY3U(0, ==, zap_add_int_key(dl->dl_os, dl->dl_object,
+        VERIFY0(zap_add_int_key(dl->dl_os, dl->dl_object,
             mintxg, obj, tx));
 }
 
 /*
  * Remove this key, merging its entries into the previous key.

@@ -248,11 +248,11 @@
 
         avl_remove(&dl->dl_tree, dle);
         bpobj_close(&dle->dle_bpobj);
         kmem_free(dle, sizeof (*dle));
 
-        VERIFY3U(0, ==, zap_remove_int(dl->dl_os, dl->dl_object, mintxg, tx));
+        VERIFY0(zap_remove_int(dl->dl_os, dl->dl_object, mintxg, tx));
 }
 
 /*
  * Walk ds's snapshots to regenerate generate ZAP & AVL.
  */

@@ -269,11 +269,11 @@
                 return;
         }
 
         while (mrs_obj != 0) {
                 dsl_dataset_t *ds;
-                VERIFY3U(0, ==, dsl_dataset_hold_obj(dp, mrs_obj, FTAG, &ds));
+                VERIFY0(dsl_dataset_hold_obj(dp, mrs_obj, FTAG, &ds));
                 dsl_deadlist_add_key(&dl, ds->ds_phys->ds_prev_snap_txg, tx);
                 mrs_obj = ds->ds_phys->ds_prev_snap_obj;
                 dsl_dataset_rele(ds, FTAG);
         }
         dsl_deadlist_close(&dl);

@@ -301,11 +301,11 @@
 
                 if (dle->dle_mintxg >= maxtxg)
                         break;
 
                 obj = bpobj_alloc(dl->dl_os, SPA_MAXBLOCKSIZE, tx);
-                VERIFY3U(0, ==, zap_add_int_key(dl->dl_os, newobj,
+                VERIFY0(zap_add_int_key(dl->dl_os, newobj,
                     dle->dle_mintxg, obj, tx));
         }
         return (newobj);
 }
 

@@ -312,11 +312,11 @@
 void
 dsl_deadlist_space(dsl_deadlist_t *dl,
     uint64_t *usedp, uint64_t *compp, uint64_t *uncompp)
 {
         if (dl->dl_oldfmt) {
-                VERIFY3U(0, ==, bpobj_space(&dl->dl_bpobj,
+                VERIFY0(bpobj_space(&dl->dl_bpobj,
                     usedp, compp, uncompp));
                 return;
         }
 
         mutex_enter(&dl->dl_lock);

@@ -339,11 +339,11 @@
         dsl_deadlist_entry_t *dle;
         dsl_deadlist_entry_t dle_tofind;
         avl_index_t where;
 
         if (dl->dl_oldfmt) {
-                VERIFY3U(0, ==, bpobj_space_range(&dl->dl_bpobj,
+                VERIFY0(bpobj_space_range(&dl->dl_bpobj,
                     mintxg, maxtxg, usedp, compp, uncompp));
                 return;
         }
 
         *usedp = *compp = *uncompp = 0;

@@ -361,11 +361,11 @@
 
         for (; dle && dle->dle_mintxg < maxtxg;
             dle = AVL_NEXT(&dl->dl_tree, dle)) {
                 uint64_t used, comp, uncomp;
 
-                VERIFY3U(0, ==, bpobj_space(&dle->dle_bpobj,
+                VERIFY0(bpobj_space(&dle->dle_bpobj,
                     &used, &comp, &uncomp));
 
                 *usedp += used;
                 *compp += comp;
                 *uncompp += uncomp;

@@ -381,12 +381,12 @@
         dsl_deadlist_entry_t *dle;
         avl_index_t where;
         uint64_t used, comp, uncomp;
         bpobj_t bpo;
 
-        VERIFY3U(0, ==, bpobj_open(&bpo, dl->dl_os, obj));
-        VERIFY3U(0, ==, bpobj_space(&bpo, &used, &comp, &uncomp));
+        VERIFY0(bpobj_open(&bpo, dl->dl_os, obj));
+        VERIFY0(bpobj_space(&bpo, &used, &comp, &uncomp));
         bpobj_close(&bpo);
 
         dsl_deadlist_load_tree(dl);
 
         dmu_buf_will_dirty(dl->dl_dbuf, tx);

@@ -422,15 +422,15 @@
         zap_attribute_t za;
         dmu_buf_t *bonus;
         dsl_deadlist_phys_t *dlp;
         dmu_object_info_t doi;
 
-        VERIFY3U(0, ==, dmu_object_info(dl->dl_os, obj, &doi));
+        VERIFY0(dmu_object_info(dl->dl_os, obj, &doi));
         if (doi.doi_type == DMU_OT_BPOBJ) {
                 bpobj_t bpo;
-                VERIFY3U(0, ==, bpobj_open(&bpo, dl->dl_os, obj));
-                VERIFY3U(0, ==, bpobj_iterate(&bpo,
+                VERIFY0(bpobj_open(&bpo, dl->dl_os, obj));
+                VERIFY0(bpobj_iterate(&bpo,
                     dsl_deadlist_insert_cb, dl, tx));
                 bpobj_close(&bpo);
                 return;
         }
 

@@ -437,15 +437,15 @@
         for (zap_cursor_init(&zc, dl->dl_os, obj);
             zap_cursor_retrieve(&zc, &za) == 0;
             zap_cursor_advance(&zc)) {
                 uint64_t mintxg = strtonum(za.za_name, NULL);
                 dsl_deadlist_insert_bpobj(dl, za.za_first_integer, mintxg, tx);
-                VERIFY3U(0, ==, zap_remove_int(dl->dl_os, obj, mintxg, tx));
+                VERIFY0(zap_remove_int(dl->dl_os, obj, mintxg, tx));
         }
         zap_cursor_fini(&zc);
 
-        VERIFY3U(0, ==, dmu_bonus_hold(dl->dl_os, obj, FTAG, &bonus));
+        VERIFY0(dmu_bonus_hold(dl->dl_os, obj, FTAG, &bonus));
         dlp = bonus->db_data;
         dmu_buf_will_dirty(bonus, tx);
         bzero(dlp, sizeof (*dlp));
         dmu_buf_rele(bonus, FTAG);
 }

@@ -473,11 +473,11 @@
                 uint64_t used, comp, uncomp;
                 dsl_deadlist_entry_t *dle_next;
 
                 bpobj_enqueue_subobj(bpo, dle->dle_bpobj.bpo_object, tx);
 
-                VERIFY3U(0, ==, bpobj_space(&dle->dle_bpobj,
+                VERIFY0(bpobj_space(&dle->dle_bpobj,
                     &used, &comp, &uncomp));
                 mutex_enter(&dl->dl_lock);
                 ASSERT3U(dl->dl_phys->dl_used, >=, used);
                 ASSERT3U(dl->dl_phys->dl_comp, >=, comp);
                 ASSERT3U(dl->dl_phys->dl_uncomp, >=, uncomp);

@@ -484,11 +484,11 @@
                 dl->dl_phys->dl_used -= used;
                 dl->dl_phys->dl_comp -= comp;
                 dl->dl_phys->dl_uncomp -= uncomp;
                 mutex_exit(&dl->dl_lock);
 
-                VERIFY3U(0, ==, zap_remove_int(dl->dl_os, dl->dl_object,
+                VERIFY0(zap_remove_int(dl->dl_os, dl->dl_object,
                     dle->dle_mintxg, tx));
 
                 dle_next = AVL_NEXT(&dl->dl_tree, dle);
                 avl_remove(&dl->dl_tree, dle);
                 bpobj_close(&dle->dle_bpobj);