Print this page
3748 zfs headers should be C++ compatible
Submitted by:   Justin Gibbs <justing@spectralogic.com>
Submitted by:   Will Andrews <willa@spectralogic.com>
Reviewed by:    Matthew Ahrens <mahrens@delphix.com>
Reviewed by:    Eric Schrock <eric.schrock@delphix.com>
Reviewed by:    Robert Mustacchi <rm@joyent.com>

@@ -2784,11 +2784,11 @@
  * arc_read_done() will invoke all the requested "done" functions
  * for readers of this block.
  */
 int
 arc_read(zio_t *pio, spa_t *spa, const blkptr_t *bp, arc_done_func_t *done,
-    void *private, int priority, int zio_flags, uint32_t *arc_flags,
+    void *cb_private, int priority, int zio_flags, uint32_t *arc_flags,
     const zbookmark_t *zb)
 {
         arc_buf_hdr_t *hdr;
         arc_buf_t *buf = NULL;
         kmutex_t *hash_lock;

@@ -2815,30 +2815,30 @@
                                 arc_callback_t  *acb = NULL;
 
                                 acb = kmem_zalloc(sizeof (arc_callback_t),
                                     KM_SLEEP);
                                 acb->acb_done = done;
-                                acb->acb_private = private;
+                                acb->acb_private = cb_private;
                                 if (pio != NULL)
                                         acb->acb_zio_dummy = zio_null(pio,
                                             spa, NULL, NULL, NULL, zio_flags);
 
                                 ASSERT(acb->acb_done != NULL);
                                 acb->acb_next = hdr->b_acb;
                                 hdr->b_acb = acb;
-                                add_reference(hdr, hash_lock, private);
+                                add_reference(hdr, hash_lock, cb_private);
                                 mutex_exit(hash_lock);
                                 return (0);
                         }
                         mutex_exit(hash_lock);
                         return (0);
                 }
 
                 ASSERT(hdr->b_state == arc_mru || hdr->b_state == arc_mfu);
 
                 if (done) {
-                        add_reference(hdr, hash_lock, private);
+                        add_reference(hdr, hash_lock, cb_private);
                         /*
                          * If this block is already in use, create a new
                          * copy of the data so that we will be guaranteed
                          * that arc_release() will always succeed.
                          */

@@ -2865,11 +2865,11 @@
                 ARCSTAT_CONDSTAT(!(hdr->b_flags & ARC_PREFETCH),
                     demand, prefetch, hdr->b_type != ARC_BUFC_METADATA,
                     data, metadata, hits);
 
                 if (done)
-                        done(NULL, buf, private);
+                        done(NULL, buf, cb_private);
         } else {
                 uint64_t size = BP_GET_LSIZE(bp);
                 arc_callback_t  *acb;
                 vdev_t *vd = NULL;
                 uint64_t addr = 0;

@@ -2877,27 +2877,27 @@
 
                 if (hdr == NULL) {
                         /* this block is not in the cache */
                         arc_buf_hdr_t   *exists;
                         arc_buf_contents_t type = BP_GET_BUFC_TYPE(bp);
-                        buf = arc_buf_alloc(spa, size, private, type);
+                        buf = arc_buf_alloc(spa, size, cb_private, type);
                         hdr = buf->b_hdr;
                         hdr->b_dva = *BP_IDENTITY(bp);
                         hdr->b_birth = BP_PHYSICAL_BIRTH(bp);
                         hdr->b_cksum0 = bp->blk_cksum.zc_word[0];
                         exists = buf_hash_insert(hdr, &hash_lock);
                         if (exists) {
                                 /* somebody beat us to the hash insert */
                                 mutex_exit(hash_lock);
                                 buf_discard_identity(hdr);
-                                (void) arc_buf_remove_ref(buf, private);
+                                (void) arc_buf_remove_ref(buf, cb_private);
                                 goto top; /* restart the IO request */
                         }
                         /* if this is a prefetch, we don't have a reference */
                         if (*arc_flags & ARC_PREFETCH) {
                                 (void) remove_reference(hdr, hash_lock,
-                                    private);
+                                    cb_private);
                                 hdr->b_flags |= ARC_PREFETCH;
                         }
                         if (*arc_flags & ARC_L2CACHE)
                                 hdr->b_flags |= ARC_L2CACHE;
                         if (BP_GET_LEVEL(bp) > 0)

@@ -2911,11 +2911,11 @@
 
                         /* if this is a prefetch, we don't have a reference */
                         if (*arc_flags & ARC_PREFETCH)
                                 hdr->b_flags |= ARC_PREFETCH;
                         else
-                                add_reference(hdr, hash_lock, private);
+                                add_reference(hdr, hash_lock, cb_private);
                         if (*arc_flags & ARC_L2CACHE)
                                 hdr->b_flags |= ARC_L2CACHE;
                         buf = kmem_cache_alloc(buf_cache, KM_PUSHPAGE);
                         buf->b_hdr = hdr;
                         buf->b_data = NULL;

@@ -2931,11 +2931,11 @@
 
                 ASSERT(!GHOST_STATE(hdr->b_state));
 
                 acb = kmem_zalloc(sizeof (arc_callback_t), KM_SLEEP);
                 acb->acb_done = done;
-                acb->acb_private = private;
+                acb->acb_private = cb_private;
 
                 ASSERT(hdr->b_acb == NULL);
                 hdr->b_acb = acb;
                 hdr->b_flags |= ARC_IO_IN_PROGRESS;
 

@@ -3044,20 +3044,20 @@
         }
         return (0);
 }
 
 void
-arc_set_callback(arc_buf_t *buf, arc_evict_func_t *func, void *private)
+arc_set_callback(arc_buf_t *buf, arc_evict_func_t *func, void *cb_private)
 {
         ASSERT(buf->b_hdr != NULL);
         ASSERT(buf->b_hdr->b_state != arc_anon);
         ASSERT(!refcount_is_zero(&buf->b_hdr->b_refcnt) || func == NULL);
         ASSERT(buf->b_efunc == NULL);
         ASSERT(!HDR_BUF_AVAILABLE(buf->b_hdr));
 
         buf->b_efunc = func;
-        buf->b_private = private;
+        buf->b_private = cb_private;
 }
 
 /*
  * This is used by the DMU to let the ARC know that a buffer is
  * being evicted, so the ARC should clean up.  If this arc buf

@@ -3412,11 +3412,11 @@
 }
 
 zio_t *
 arc_write(zio_t *pio, spa_t *spa, uint64_t txg,
     blkptr_t *bp, arc_buf_t *buf, boolean_t l2arc, const zio_prop_t *zp,
-    arc_done_func_t *ready, arc_done_func_t *done, void *private,
+    arc_done_func_t *ready, arc_done_func_t *done, void *cb_private,
     int priority, int zio_flags, const zbookmark_t *zb)
 {
         arc_buf_hdr_t *hdr = buf->b_hdr;
         arc_write_callback_t *callback;
         zio_t *zio;

@@ -3429,11 +3429,11 @@
         if (l2arc)
                 hdr->b_flags |= ARC_L2CACHE;
         callback = kmem_zalloc(sizeof (arc_write_callback_t), KM_SLEEP);
         callback->awcb_ready = ready;
         callback->awcb_done = done;
-        callback->awcb_private = private;
+        callback->awcb_private = cb_private;
         callback->awcb_buf = buf;
 
         zio = zio_write(pio, spa, txg, bp, buf->b_data, hdr->b_size, zp,
             arc_write_ready, arc_write_done, callback, priority, zio_flags, zb);