-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 Am Tue, 15 Oct 2019 15:09:36 +0000 (UTC) Andriy Gapon <a...@freebsd.org> schrieb:
> Author: avg > Date: Tue Oct 15 15:09:36 2019 > New Revision: 353565 > URL: https://svnweb.freebsd.org/changeset/base/353565 > > Log: > MFV r353561: 10343 ZoL: Prefix all refcount functions with zfs_ > > illumos/illumos-gate@e914ace2e9d9bf2dbf9a1f1ce81cb776022096f5 > > https://github.com/illumos/illumos-gate/commit/e914ace2e9d9bf2dbf9a1f1ce81cb776022096f5 > > https://www.illumos.org/issues/10343 > On the openzfs feature/porting matrix, this is listed as: > prefix to refcount funcs/types > Having these changes will make it easier to share other work across the > different ZFS operating systems. > PR 7963 424fd7c3e Prefix all refcount functions with zfs_ > PR 7885 & 7932 c13060e47 Linux 4.19-rc3+ compat: Remove refcount_t compat > PR 5823 & 5842 4859fe796 Linux 4.11 compat: avoid refcount_t name conflict > > Author: Tim Schumacher <timsch...@gmx.de> > Obtained from: illumos, ZoL > MFC after: 3 weeks > > Modified: > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/abd.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dbuf.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dmu.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dmu_tx.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dnode.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dnode_sync.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dsl_dataset.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dsl_destroy.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/metaslab.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/refcount.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/rrwlock.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sa.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/spa.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/spa_misc.c > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/abd.h > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/dbuf.h > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/dmu_tx.h > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/dnode.h > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/dsl_dataset.h > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/metaslab_impl.h > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/refcount.h > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/rrwlock.h > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/sa_impl.h > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/spa_impl.h > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/zap.h > head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/zio.c > Directory Properties: > head/sys/cddl/contrib/opensolaris/ (props changed) > > Modified: head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/abd.c > ============================================================================== > --- head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/abd.c Tue Oct 15 > 14:51:22 > 2019 (r353564) +++ head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/abd.c > Tue Oct 15 15:09:36 2019 (r353565) @@ -304,7 +304,7 @@ abd_alloc(size_t > size, > boolean_t is_metadata) } > abd->abd_size = size; > abd->abd_parent = NULL; > - refcount_create(&abd->abd_children); > + zfs_refcount_create(&abd->abd_children); > > abd->abd_u.abd_scatter.abd_offset = 0; > abd->abd_u.abd_scatter.abd_chunk_size = zfs_abd_chunk_size; > @@ -331,7 +331,7 @@ abd_free_scatter(abd_t *abd) > abd_free_chunk(abd->abd_u.abd_scatter.abd_chunks[i]); > } > > - refcount_destroy(&abd->abd_children); > + zfs_refcount_destroy(&abd->abd_children); > ABDSTAT_BUMPDOWN(abdstat_scatter_cnt); > ABDSTAT_INCR(abdstat_scatter_data_size, -(int)abd->abd_size); > ABDSTAT_INCR(abdstat_scatter_chunk_waste, > @@ -358,7 +358,7 @@ abd_alloc_linear(size_t size, boolean_t is_metadata) > } > abd->abd_size = size; > abd->abd_parent = NULL; > - refcount_create(&abd->abd_children); > + zfs_refcount_create(&abd->abd_children); > > if (is_metadata) { > abd->abd_u.abd_linear.abd_buf = zio_buf_alloc(size); > @@ -381,7 +381,7 @@ abd_free_linear(abd_t *abd) > zio_data_buf_free(abd->abd_u.abd_linear.abd_buf, abd->abd_size); > } > > - refcount_destroy(&abd->abd_children); > + zfs_refcount_destroy(&abd->abd_children); > ABDSTAT_BUMPDOWN(abdstat_linear_cnt); > ABDSTAT_INCR(abdstat_linear_data_size, -(int)abd->abd_size); > > @@ -487,8 +487,8 @@ abd_get_offset(abd_t *sabd, size_t off) > > abd->abd_size = sabd->abd_size - off; > abd->abd_parent = sabd; > - refcount_create(&abd->abd_children); > - (void) refcount_add_many(&sabd->abd_children, abd->abd_size, abd); > + zfs_refcount_create(&abd->abd_children); > + (void) zfs_refcount_add_many(&sabd->abd_children, abd->abd_size, abd); > > return (abd); > } > @@ -512,7 +512,7 @@ abd_get_from_buf(void *buf, size_t size) > abd->abd_flags = ABD_FLAG_LINEAR; > abd->abd_size = size; > abd->abd_parent = NULL; > - refcount_create(&abd->abd_children); > + zfs_refcount_create(&abd->abd_children); > > abd->abd_u.abd_linear.abd_buf = buf; > > @@ -530,11 +530,11 @@ abd_put(abd_t *abd) > ASSERT(!(abd->abd_flags & ABD_FLAG_OWNER)); > > if (abd->abd_parent != NULL) { > - (void) refcount_remove_many(&abd->abd_parent->abd_children, > + (void) zfs_refcount_remove_many(&abd->abd_parent->abd_children, > abd->abd_size, abd); > } > > - refcount_destroy(&abd->abd_children); > + zfs_refcount_destroy(&abd->abd_children); > abd_free_struct(abd); > } > > @@ -566,7 +566,7 @@ abd_borrow_buf(abd_t *abd, size_t n) > } else { > buf = zio_buf_alloc(n); > } > - (void) refcount_add_many(&abd->abd_children, n, buf); > + (void) zfs_refcount_add_many(&abd->abd_children, n, buf); > > return (buf); > } > @@ -598,7 +598,7 @@ abd_return_buf(abd_t *abd, void *buf, size_t n) > ASSERT0(abd_cmp_buf(abd, buf, n)); > zio_buf_free(buf, n); > } > - (void) refcount_remove_many(&abd->abd_children, n, buf); > + (void) zfs_refcount_remove_many(&abd->abd_children, n, buf); > } > > void > > Modified: head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c > ============================================================================== > --- head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c Tue Oct 15 > 14:51:22 > 2019 (r353564) +++ head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/arc.c > Tue Oct 15 15:09:36 2019 (r353565) @@ -538,12 +538,12 @@ typedef struct > arc_state { > /* > * total amount of evictable data in this state > */ > - refcount_t arcs_esize[ARC_BUFC_NUMTYPES]; > + zfs_refcount_t arcs_esize[ARC_BUFC_NUMTYPES]; > /* > * total amount of data in this state; this includes: evictable, > * non-evictable, ARC_BUFC_DATA, and ARC_BUFC_METADATA. > */ > - refcount_t arcs_size; > + zfs_refcount_t arcs_size; > /* > * supports the "dbufs" kstat > */ > @@ -1158,7 +1158,7 @@ typedef struct l1arc_buf_hdr { > uint32_t b_l2_hits; > > /* self protecting */ > - refcount_t b_refcnt; > + zfs_refcount_t b_refcnt; > > arc_callback_t *b_acb; > abd_t *b_pabd; > @@ -1534,7 +1534,7 @@ struct l2arc_dev { > kmutex_t l2ad_mtx; /* lock for buffer list */ > list_t l2ad_buflist; /* buffer list */ > list_node_t l2ad_node; /* device list node */ > - refcount_t l2ad_alloc; /* allocated bytes */ > + zfs_refcount_t l2ad_alloc; /* allocated bytes */ > }; > > static list_t L2ARC_dev_list; /* device list */ > @@ -1765,7 +1765,7 @@ hdr_full_cons(void *vbuf, void *unused, int kmflag) > > bzero(hdr, HDR_FULL_SIZE); > cv_init(&hdr->b_l1hdr.b_cv, NULL, CV_DEFAULT, NULL); > - refcount_create(&hdr->b_l1hdr.b_refcnt); > + zfs_refcount_create(&hdr->b_l1hdr.b_refcnt); > mutex_init(&hdr->b_l1hdr.b_freeze_lock, NULL, MUTEX_DEFAULT, NULL); > multilist_link_init(&hdr->b_l1hdr.b_arc_node); > arc_space_consume(HDR_FULL_SIZE, ARC_SPACE_HDRS); > @@ -1810,7 +1810,7 @@ hdr_full_dest(void *vbuf, void *unused) > > ASSERT(HDR_EMPTY(hdr)); > cv_destroy(&hdr->b_l1hdr.b_cv); > - refcount_destroy(&hdr->b_l1hdr.b_refcnt); > + zfs_refcount_destroy(&hdr->b_l1hdr.b_refcnt); > mutex_destroy(&hdr->b_l1hdr.b_freeze_lock); > ASSERT(!multilist_link_active(&hdr->b_l1hdr.b_arc_node)); > arc_space_return(HDR_FULL_SIZE, ARC_SPACE_HDRS); > @@ -2495,21 +2495,21 @@ arc_evictable_space_increment(arc_buf_hdr_t *hdr, arc_ > ASSERT0(hdr->b_l1hdr.b_bufcnt); > ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL); > ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL); > - (void) refcount_add_many(&state->arcs_esize[type], > + (void) zfs_refcount_add_many(&state->arcs_esize[type], > HDR_GET_LSIZE(hdr), hdr); > return; > } > > ASSERT(!GHOST_STATE(state)); > if (hdr->b_l1hdr.b_pabd != NULL) { > - (void) refcount_add_many(&state->arcs_esize[type], > + (void) zfs_refcount_add_many(&state->arcs_esize[type], > arc_hdr_size(hdr), hdr); > } > for (arc_buf_t *buf = hdr->b_l1hdr.b_buf; buf != NULL; > buf = buf->b_next) { > if (arc_buf_is_shared(buf)) > continue; > - (void) refcount_add_many(&state->arcs_esize[type], > + (void) zfs_refcount_add_many(&state->arcs_esize[type], > arc_buf_size(buf), buf); > } > } > @@ -2530,21 +2530,21 @@ arc_evictable_space_decrement(arc_buf_hdr_t *hdr, arc_ > ASSERT0(hdr->b_l1hdr.b_bufcnt); > ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL); > ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL); > - (void) refcount_remove_many(&state->arcs_esize[type], > + (void) zfs_refcount_remove_many(&state->arcs_esize[type], > HDR_GET_LSIZE(hdr), hdr); > return; > } > > ASSERT(!GHOST_STATE(state)); > if (hdr->b_l1hdr.b_pabd != NULL) { > - (void) refcount_remove_many(&state->arcs_esize[type], > + (void) zfs_refcount_remove_many(&state->arcs_esize[type], > arc_hdr_size(hdr), hdr); > } > for (arc_buf_t *buf = hdr->b_l1hdr.b_buf; buf != NULL; > buf = buf->b_next) { > if (arc_buf_is_shared(buf)) > continue; > - (void) refcount_remove_many(&state->arcs_esize[type], > + (void) zfs_refcount_remove_many(&state->arcs_esize[type], > arc_buf_size(buf), buf); > } > } > @@ -2561,13 +2561,13 @@ add_reference(arc_buf_hdr_t *hdr, void *tag) > ASSERT(HDR_HAS_L1HDR(hdr)); > if (!MUTEX_HELD(HDR_LOCK(hdr))) { > ASSERT(hdr->b_l1hdr.b_state == arc_anon); > - ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > + ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL); > } > > arc_state_t *state = hdr->b_l1hdr.b_state; > > - if ((refcount_add(&hdr->b_l1hdr.b_refcnt, tag) == 1) && > + if ((zfs_refcount_add(&hdr->b_l1hdr.b_refcnt, tag) == 1) && > (state != arc_anon)) { > /* We don't use the L2-only state list. */ > if (state != arc_l2c_only) { > @@ -2599,7 +2599,7 @@ remove_reference(arc_buf_hdr_t *hdr, kmutex_t *hash_lo > * arc_l2c_only counts as a ghost state so we don't need to explicitly > * check to prevent usage of the arc_l2c_only list. > */ > - if (((cnt = refcount_remove(&hdr->b_l1hdr.b_refcnt, tag)) == 0) && > + if (((cnt = zfs_refcount_remove(&hdr->b_l1hdr.b_refcnt, tag)) == 0) && > (state != arc_anon)) { > multilist_insert(state->arcs_list[arc_buf_type(hdr)], hdr); > ASSERT3U(hdr->b_l1hdr.b_bufcnt, >, 0); > @@ -2644,7 +2644,7 @@ arc_buf_info(arc_buf_t *ab, arc_buf_info_t *abi, int s > abi->abi_mru_ghost_hits = l1hdr->b_mru_ghost_hits; > abi->abi_mfu_hits = l1hdr->b_mfu_hits; > abi->abi_mfu_ghost_hits = l1hdr->b_mfu_ghost_hits; > - abi->abi_holds = refcount_count(&l1hdr->b_refcnt); > + abi->abi_holds = zfs_refcount_count(&l1hdr->b_refcnt); > } > > if (l2hdr) { > @@ -2680,7 +2680,7 @@ arc_change_state(arc_state_t *new_state, arc_buf_hdr_t > */ > if (HDR_HAS_L1HDR(hdr)) { > old_state = hdr->b_l1hdr.b_state; > - refcnt = refcount_count(&hdr->b_l1hdr.b_refcnt); > + refcnt = zfs_refcount_count(&hdr->b_l1hdr.b_refcnt); > bufcnt = hdr->b_l1hdr.b_bufcnt; > update_old = (bufcnt > 0 || hdr->b_l1hdr.b_pabd != NULL); > } else { > @@ -2750,7 +2750,7 @@ arc_change_state(arc_state_t *new_state, arc_buf_hdr_t > * the reference. As a result, we use the arc > * header pointer for the reference. > */ > - (void) refcount_add_many(&new_state->arcs_size, > + (void) zfs_refcount_add_many(&new_state->arcs_size, > HDR_GET_LSIZE(hdr), hdr); > ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL); > } else { > @@ -2776,13 +2776,15 @@ arc_change_state(arc_state_t *new_state, arc_buf_hdr_t > if (arc_buf_is_shared(buf)) > continue; > > - (void) refcount_add_many(&new_state->arcs_size, > + (void) zfs_refcount_add_many( > + &new_state->arcs_size, > arc_buf_size(buf), buf); > } > ASSERT3U(bufcnt, ==, buffers); > > if (hdr->b_l1hdr.b_pabd != NULL) { > - (void) refcount_add_many(&new_state->arcs_size, > + (void) zfs_refcount_add_many( > + &new_state->arcs_size, > arc_hdr_size(hdr), hdr); > } else { > ASSERT(GHOST_STATE(old_state)); > @@ -2804,7 +2806,7 @@ arc_change_state(arc_state_t *new_state, arc_buf_hdr_t > * header on the ghost state. > */ > > - (void) refcount_remove_many(&old_state->arcs_size, > + (void) zfs_refcount_remove_many(&old_state->arcs_size, > HDR_GET_LSIZE(hdr), hdr); > } else { > uint32_t buffers = 0; > @@ -2829,13 +2831,13 @@ arc_change_state(arc_state_t *new_state, arc_buf_hdr_t > if (arc_buf_is_shared(buf)) > continue; > > - (void) refcount_remove_many( > + (void) zfs_refcount_remove_many( > &old_state->arcs_size, arc_buf_size(buf), > buf); > } > ASSERT3U(bufcnt, ==, buffers); > ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL); > - (void) refcount_remove_many( > + (void) zfs_refcount_remove_many( > &old_state->arcs_size, arc_hdr_size(hdr), hdr); > } > } > @@ -3101,8 +3103,8 @@ arc_return_buf(arc_buf_t *buf, void *tag) > > ASSERT3P(buf->b_data, !=, NULL); > ASSERT(HDR_HAS_L1HDR(hdr)); > - (void) refcount_add(&hdr->b_l1hdr.b_refcnt, tag); > - (void) refcount_remove(&hdr->b_l1hdr.b_refcnt, arc_onloan_tag); > + (void) zfs_refcount_add(&hdr->b_l1hdr.b_refcnt, tag); > + (void) zfs_refcount_remove(&hdr->b_l1hdr.b_refcnt, arc_onloan_tag); > > arc_loaned_bytes_update(-arc_buf_size(buf)); > } > @@ -3115,8 +3117,8 @@ arc_loan_inuse_buf(arc_buf_t *buf, void *tag) > > ASSERT3P(buf->b_data, !=, NULL); > ASSERT(HDR_HAS_L1HDR(hdr)); > - (void) refcount_add(&hdr->b_l1hdr.b_refcnt, arc_onloan_tag); > - (void) refcount_remove(&hdr->b_l1hdr.b_refcnt, tag); > + (void) zfs_refcount_add(&hdr->b_l1hdr.b_refcnt, arc_onloan_tag); > + (void) zfs_refcount_remove(&hdr->b_l1hdr.b_refcnt, tag); > > arc_loaned_bytes_update(arc_buf_size(buf)); > } > @@ -3143,13 +3145,13 @@ arc_hdr_free_on_write(arc_buf_hdr_t *hdr) > > /* protected by hash lock, if in the hash table */ > if (multilist_link_active(&hdr->b_l1hdr.b_arc_node)) { > - ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > + ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > ASSERT(state != arc_anon && state != arc_l2c_only); > > - (void) refcount_remove_many(&state->arcs_esize[type], > + (void) zfs_refcount_remove_many(&state->arcs_esize[type], > size, hdr); > } > - (void) refcount_remove_many(&state->arcs_size, size, hdr); > + (void) zfs_refcount_remove_many(&state->arcs_size, size, hdr); > if (type == ARC_BUFC_METADATA) { > arc_space_return(size, ARC_SPACE_META); > } else { > @@ -3179,7 +3181,7 @@ arc_share_buf(arc_buf_hdr_t *hdr, arc_buf_t *buf) > * refcount ownership to the hdr since it always owns > * the refcount whenever an arc_buf_t is shared. > */ > - refcount_transfer_ownership(&state->arcs_size, buf, hdr); > + zfs_refcount_transfer_ownership(&state->arcs_size, buf, hdr); > hdr->b_l1hdr.b_pabd = abd_get_from_buf(buf->b_data, arc_buf_size(buf)); > abd_take_ownership_of_buf(hdr->b_l1hdr.b_pabd, > HDR_ISTYPE_METADATA(hdr)); > @@ -3209,7 +3211,7 @@ arc_unshare_buf(arc_buf_hdr_t *hdr, arc_buf_t *buf) > * We are no longer sharing this buffer so we need > * to transfer its ownership to the rightful owner. > */ > - refcount_transfer_ownership(&state->arcs_size, hdr, buf); > + zfs_refcount_transfer_ownership(&state->arcs_size, hdr, buf); > arc_hdr_clear_flags(hdr, ARC_FLAG_SHARED_DATA); > abd_release_ownership_of_buf(hdr->b_l1hdr.b_pabd); > abd_put(hdr->b_l1hdr.b_pabd); > @@ -3436,7 +3438,7 @@ arc_hdr_alloc(uint64_t spa, int32_t psize, int32_t lsi > * it references and compressed arc enablement. > */ > arc_hdr_alloc_pabd(hdr, B_TRUE); > - ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > + ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > > return (hdr); > } > @@ -3538,8 +3540,10 @@ arc_hdr_realloc(arc_buf_hdr_t *hdr, kmem_cache_t *old, > * the wrong pointer address when calling arc_hdr_destroy() later. > */ > > - (void) refcount_remove_many(&dev->l2ad_alloc, arc_hdr_size(hdr), hdr); > - (void) refcount_add_many(&dev->l2ad_alloc, arc_hdr_size(nhdr), nhdr); > + (void) zfs_refcount_remove_many(&dev->l2ad_alloc, arc_hdr_size(hdr), > + hdr); > + (void) zfs_refcount_add_many(&dev->l2ad_alloc, arc_hdr_size(nhdr), > + nhdr); > > buf_discard_identity(hdr); > kmem_cache_free(old, hdr); > @@ -3619,7 +3623,7 @@ arc_hdr_l2hdr_destroy(arc_buf_hdr_t *hdr) > > vdev_space_update(dev->l2ad_vdev, -psize, 0, 0); > > - (void) refcount_remove_many(&dev->l2ad_alloc, psize, hdr); > + (void) zfs_refcount_remove_many(&dev->l2ad_alloc, psize, hdr); > arc_hdr_clear_flags(hdr, ARC_FLAG_HAS_L2HDR); > } > > @@ -3629,7 +3633,7 @@ arc_hdr_destroy(arc_buf_hdr_t *hdr) > if (HDR_HAS_L1HDR(hdr)) { > ASSERT(hdr->b_l1hdr.b_buf == NULL || > hdr->b_l1hdr.b_bufcnt > 0); > - ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > + ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > ASSERT3P(hdr->b_l1hdr.b_state, ==, arc_anon); > } > ASSERT(!HDR_IO_IN_PROGRESS(hdr)); > @@ -3793,7 +3797,7 @@ arc_evict_hdr(arc_buf_hdr_t *hdr, kmutex_t *hash_lock) > return (bytes_evicted); > } > > - ASSERT0(refcount_count(&hdr->b_l1hdr.b_refcnt)); > + ASSERT0(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt)); > while (hdr->b_l1hdr.b_buf) { > arc_buf_t *buf = hdr->b_l1hdr.b_buf; > if (!mutex_tryenter(&buf->b_evict_lock)) { > @@ -4107,7 +4111,7 @@ arc_flush_state(arc_state_t *state, uint64_t spa, arc_ > { > uint64_t evicted = 0; > > - while (refcount_count(&state->arcs_esize[type]) != 0) { > + while (zfs_refcount_count(&state->arcs_esize[type]) != 0) { > evicted += arc_evict_state(state, spa, ARC_EVICT_ALL, type); > > if (!retry) > @@ -4130,7 +4134,7 @@ arc_prune_task(void *ptr) > if (func != NULL) > func(ap->p_adjust, ap->p_private); > > - refcount_remove(&ap->p_refcnt, func); > + zfs_refcount_remove(&ap->p_refcnt, func); > } > > /* > @@ -4153,14 +4157,14 @@ arc_prune_async(int64_t adjust) > for (ap = list_head(&arc_prune_list); ap != NULL; > ap = list_next(&arc_prune_list, ap)) { > > - if (refcount_count(&ap->p_refcnt) >= 2) > + if (zfs_refcount_count(&ap->p_refcnt) >= 2) > continue; > > - refcount_add(&ap->p_refcnt, ap->p_pfunc); > + zfs_refcount_add(&ap->p_refcnt, ap->p_pfunc); > ap->p_adjust = adjust; > if (taskq_dispatch(arc_prune_taskq, arc_prune_task, > ap, TQ_SLEEP) == TASKQID_INVALID) { > - refcount_remove(&ap->p_refcnt, ap->p_pfunc); > + zfs_refcount_remove(&ap->p_refcnt, ap->p_pfunc); > continue; > } > ARCSTAT_BUMP(arcstat_prune); > @@ -4182,8 +4186,9 @@ arc_adjust_impl(arc_state_t *state, uint64_t spa, int6 > { > int64_t delta; > > - if (bytes > 0 && refcount_count(&state->arcs_esize[type]) > 0) { > - delta = MIN(refcount_count(&state->arcs_esize[type]), bytes); > + if (bytes > 0 && zfs_refcount_count(&state->arcs_esize[type]) > 0) { > + delta = MIN(zfs_refcount_count(&state->arcs_esize[type]), > + bytes); > return (arc_evict_state(state, spa, delta, type)); > } > > @@ -4226,8 +4231,9 @@ restart: > */ > adjustmnt = meta_used - arc_meta_limit; > > - if (adjustmnt > 0 && refcount_count(&arc_mru->arcs_esize[type]) > 0) { > - delta = MIN(refcount_count(&arc_mru->arcs_esize[type]), > + if (adjustmnt > 0 && > + zfs_refcount_count(&arc_mru->arcs_esize[type]) > 0) { > + delta = MIN(zfs_refcount_count(&arc_mru->arcs_esize[type]), > adjustmnt); > total_evicted += arc_adjust_impl(arc_mru, 0, delta, type); > adjustmnt -= delta; > @@ -4243,8 +4249,9 @@ restart: > * simply decrement the amount of data evicted from the MRU. > */ > > - if (adjustmnt > 0 && refcount_count(&arc_mfu->arcs_esize[type]) > 0) { > - delta = MIN(refcount_count(&arc_mfu->arcs_esize[type]), > + if (adjustmnt > 0 && > + zfs_refcount_count(&arc_mfu->arcs_esize[type]) > 0) { > + delta = MIN(zfs_refcount_count(&arc_mfu->arcs_esize[type]), > adjustmnt); > total_evicted += arc_adjust_impl(arc_mfu, 0, delta, type); > } > @@ -4252,17 +4259,17 @@ restart: > adjustmnt = meta_used - arc_meta_limit; > > if (adjustmnt > 0 && > - refcount_count(&arc_mru_ghost->arcs_esize[type]) > 0) { > + zfs_refcount_count(&arc_mru_ghost->arcs_esize[type]) > 0) { > delta = MIN(adjustmnt, > - refcount_count(&arc_mru_ghost->arcs_esize[type])); > + zfs_refcount_count(&arc_mru_ghost->arcs_esize[type])); > total_evicted += arc_adjust_impl(arc_mru_ghost, 0, delta, type); > adjustmnt -= delta; > } > > if (adjustmnt > 0 && > - refcount_count(&arc_mfu_ghost->arcs_esize[type]) > 0) { > + zfs_refcount_count(&arc_mfu_ghost->arcs_esize[type]) > 0) { > delta = MIN(adjustmnt, > - refcount_count(&arc_mfu_ghost->arcs_esize[type])); > + zfs_refcount_count(&arc_mfu_ghost->arcs_esize[type])); > total_evicted += arc_adjust_impl(arc_mfu_ghost, 0, delta, type); > } > > @@ -4311,8 +4318,8 @@ arc_adjust_meta_only(uint64_t meta_used) > * evict some from the MRU here, and some from the MFU below. > */ > target = MIN((int64_t)(meta_used - arc_meta_limit), > - (int64_t)(refcount_count(&arc_anon->arcs_size) + > - refcount_count(&arc_mru->arcs_size) - arc_p)); > + (int64_t)(zfs_refcount_count(&arc_anon->arcs_size) + > + zfs_refcount_count(&arc_mru->arcs_size) - arc_p)); > > total_evicted += arc_adjust_impl(arc_mru, 0, target, ARC_BUFC_METADATA); > > @@ -4322,7 +4329,7 @@ arc_adjust_meta_only(uint64_t meta_used) > * space allotted to the MFU (which is defined as arc_c - arc_p). > */ > target = MIN((int64_t)(meta_used - arc_meta_limit), > - (int64_t)(refcount_count(&arc_mfu->arcs_size) - > + (int64_t)(zfs_refcount_count(&arc_mfu->arcs_size) - > (arc_c - arc_p))); > > total_evicted += arc_adjust_impl(arc_mfu, 0, target, ARC_BUFC_METADATA); > @@ -4443,8 +4450,8 @@ arc_adjust(void) > * arc_p here, and then evict more from the MFU below. > */ > target = MIN((int64_t)(asize - arc_c), > - (int64_t)(refcount_count(&arc_anon->arcs_size) + > - refcount_count(&arc_mru->arcs_size) + ameta - arc_p)); > + (int64_t)(zfs_refcount_count(&arc_anon->arcs_size) + > + zfs_refcount_count(&arc_mru->arcs_size) + ameta - arc_p)); > > /* > * If we're below arc_meta_min, always prefer to evict data. > @@ -4534,8 +4541,8 @@ arc_adjust(void) > * cache. The following logic enforces these limits on the ghost > * caches, and evicts from them as needed. > */ > - target = refcount_count(&arc_mru->arcs_size) + > - refcount_count(&arc_mru_ghost->arcs_size) - arc_c; > + target = zfs_refcount_count(&arc_mru->arcs_size) + > + zfs_refcount_count(&arc_mru_ghost->arcs_size) - arc_c; > > bytes = arc_adjust_impl(arc_mru_ghost, 0, target, ARC_BUFC_DATA); > total_evicted += bytes; > @@ -4553,8 +4560,8 @@ arc_adjust(void) > * mru + mfu + mru ghost + mfu ghost <= 2 * arc_c > * mru ghost + mfu ghost <= arc_c > */ > - target = refcount_count(&arc_mru_ghost->arcs_size) + > - refcount_count(&arc_mfu_ghost->arcs_size) - arc_c; > + target = zfs_refcount_count(&arc_mru_ghost->arcs_size) + > + zfs_refcount_count(&arc_mfu_ghost->arcs_size) - arc_c; > > bytes = arc_adjust_impl(arc_mfu_ghost, 0, target, ARC_BUFC_DATA); > total_evicted += bytes; > @@ -5069,8 +5076,8 @@ arc_adapt(int bytes, arc_state_t *state) > { > int mult; > uint64_t arc_p_min = (arc_c >> arc_p_min_shift); > - int64_t mrug_size = refcount_count(&arc_mru_ghost->arcs_size); > - int64_t mfug_size = refcount_count(&arc_mfu_ghost->arcs_size); > + int64_t mrug_size = zfs_refcount_count(&arc_mru_ghost->arcs_size); > + int64_t mfug_size = zfs_refcount_count(&arc_mfu_ghost->arcs_size); > > if (state == arc_l2c_only) > return; > @@ -5248,7 +5255,7 @@ arc_get_data_impl(arc_buf_hdr_t *hdr, uint64_t size, v > */ > if (!GHOST_STATE(state)) { > > - (void) refcount_add_many(&state->arcs_size, size, tag); > + (void) zfs_refcount_add_many(&state->arcs_size, size, tag); > > /* > * If this is reached via arc_read, the link is > @@ -5260,8 +5267,8 @@ arc_get_data_impl(arc_buf_hdr_t *hdr, uint64_t size, v > * trying to [add|remove]_reference it. > */ > if (multilist_link_active(&hdr->b_l1hdr.b_arc_node)) { > - ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > - (void) refcount_add_many(&state->arcs_esize[type], > + ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > + (void) zfs_refcount_add_many(&state->arcs_esize[type], > size, tag); > } > > @@ -5271,8 +5278,8 @@ arc_get_data_impl(arc_buf_hdr_t *hdr, uint64_t size, v > */ > if (aggsum_upper_bound(&arc_size) < arc_c && > hdr->b_l1hdr.b_state == arc_anon && > - (refcount_count(&arc_anon->arcs_size) + > - refcount_count(&arc_mru->arcs_size) > arc_p)) > + (zfs_refcount_count(&arc_anon->arcs_size) + > + zfs_refcount_count(&arc_mru->arcs_size) > arc_p)) > arc_p = MIN(arc_c, arc_p + size); > } > ARCSTAT_BUMP(arcstat_allocated); > @@ -5310,13 +5317,13 @@ arc_free_data_impl(arc_buf_hdr_t *hdr, uint64_t size, > > /* protected by hash lock, if in the hash table */ > if (multilist_link_active(&hdr->b_l1hdr.b_arc_node)) { > - ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > + ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > ASSERT(state != arc_anon && state != arc_l2c_only); > > - (void) refcount_remove_many(&state->arcs_esize[type], > + (void) zfs_refcount_remove_many(&state->arcs_esize[type], > size, tag); > } > - (void) refcount_remove_many(&state->arcs_size, size, tag); > + (void) zfs_refcount_remove_many(&state->arcs_size, size, tag); > > VERIFY3U(hdr->b_type, ==, type); > if (type == ARC_BUFC_METADATA) { > @@ -5363,7 +5370,7 @@ arc_access(arc_buf_hdr_t *hdr, kmutex_t *hash_lock) > * another prefetch (to make it less likely to be evicted). > */ > if (HDR_PREFETCH(hdr) || HDR_PRESCIENT_PREFETCH(hdr)) { > - if (refcount_count(&hdr->b_l1hdr.b_refcnt) == 0) { > + if (zfs_refcount_count(&hdr->b_l1hdr.b_refcnt) == 0) { > /* link protected by hash lock */ > ASSERT(multilist_link_active( > &hdr->b_l1hdr.b_arc_node)); > @@ -5404,7 +5411,7 @@ arc_access(arc_buf_hdr_t *hdr, kmutex_t *hash_lock) > > if (HDR_PREFETCH(hdr) || HDR_PRESCIENT_PREFETCH(hdr)) { > new_state = arc_mru; > - if (refcount_count(&hdr->b_l1hdr.b_refcnt) > 0) { > + if (zfs_refcount_count(&hdr->b_l1hdr.b_refcnt) > 0) { > arc_hdr_clear_flags(hdr, > ARC_FLAG_PREFETCH | > ARC_FLAG_PRESCIENT_PREFETCH); > @@ -5678,7 +5685,7 @@ arc_read_done(zio_t *zio) > ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL); > } > > - ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt) || > + ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt) || > callback_list != NULL); > > if (no_zio_error) { > @@ -5689,7 +5696,7 @@ arc_read_done(zio_t *zio) > arc_change_state(arc_anon, hdr, hash_lock); > if (HDR_IN_HASH_TABLE(hdr)) > buf_hash_remove(hdr); > - freeable = refcount_is_zero(&hdr->b_l1hdr.b_refcnt); > + freeable = zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt); > } > > /* > @@ -5709,7 +5716,7 @@ arc_read_done(zio_t *zio) > * in the cache). > */ > ASSERT3P(hdr->b_l1hdr.b_state, ==, arc_anon); > - freeable = refcount_is_zero(&hdr->b_l1hdr.b_refcnt); > + freeable = zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt); > } > > /* execute each callback and free its structure */ > @@ -5875,7 +5882,7 @@ top: > ASSERT((zio_flags & ZIO_FLAG_SPECULATIVE) || > rc == 0 || rc != ENOENT); > } else if (*arc_flags & ARC_FLAG_PREFETCH && > - refcount_count(&hdr->b_l1hdr.b_refcnt) == 0) { > + zfs_refcount_count(&hdr->b_l1hdr.b_refcnt) == 0) { > arc_hdr_set_flags(hdr, ARC_FLAG_PREFETCH); > } > DTRACE_PROBE1(arc__hit, arc_buf_hdr_t *, hdr); > @@ -5933,7 +5940,7 @@ top: > ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL); > ASSERT(GHOST_STATE(hdr->b_l1hdr.b_state)); > ASSERT(!HDR_IO_IN_PROGRESS(hdr)); > - ASSERT(refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > + ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL); > ASSERT3P(hdr->b_l1hdr.b_freeze_cksum, ==, NULL); > > @@ -6154,10 +6161,10 @@ arc_add_prune_callback(arc_prune_func_t *func, void *p > p->p_pfunc = func; > p->p_private = private; > list_link_init(&p->p_node); > - refcount_create(&p->p_refcnt); > + zfs_refcount_create(&p->p_refcnt); > > mutex_enter(&arc_prune_mtx); > - refcount_add(&p->p_refcnt, &arc_prune_list); > + zfs_refcount_add(&p->p_refcnt, &arc_prune_list); > list_insert_head(&arc_prune_list, p); > mutex_exit(&arc_prune_mtx); > > @@ -6170,15 +6177,15 @@ arc_remove_prune_callback(arc_prune_t *p) > boolean_t wait = B_FALSE; > mutex_enter(&arc_prune_mtx); > list_remove(&arc_prune_list, p); > - if (refcount_remove(&p->p_refcnt, &arc_prune_list) > 0) > + if (zfs_refcount_remove(&p->p_refcnt, &arc_prune_list) > 0) > wait = B_TRUE; > mutex_exit(&arc_prune_mtx); > > /* wait for arc_prune_task to finish */ > if (wait) > taskq_wait(arc_prune_taskq); > - ASSERT0(refcount_count(&p->p_refcnt)); > - refcount_destroy(&p->p_refcnt); > + ASSERT0(zfs_refcount_count(&p->p_refcnt)); > + zfs_refcount_destroy(&p->p_refcnt); > kmem_free(p, sizeof (*p)); > } > > @@ -6221,7 +6228,7 @@ arc_freed(spa_t *spa, const blkptr_t *bp) > * this hdr, then we don't destroy the hdr. > */ > if (!HDR_HAS_L1HDR(hdr) || (!HDR_IO_IN_PROGRESS(hdr) && > - refcount_is_zero(&hdr->b_l1hdr.b_refcnt))) { > + zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt))) { > arc_change_state(arc_anon, hdr, hash_lock); > arc_hdr_destroy(hdr); > mutex_exit(hash_lock); > @@ -6264,7 +6271,7 @@ arc_release(arc_buf_t *buf, void *tag) > ASSERT(!HDR_HAS_L2HDR(hdr)); > ASSERT(HDR_EMPTY(hdr)); > ASSERT3U(hdr->b_l1hdr.b_bufcnt, ==, 1); > - ASSERT3S(refcount_count(&hdr->b_l1hdr.b_refcnt), ==, 1); > + ASSERT3S(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt), ==, 1); > ASSERT(!list_link_active(&hdr->b_l1hdr.b_arc_node)); > > hdr->b_l1hdr.b_arc_access = 0; > @@ -6292,7 +6299,7 @@ arc_release(arc_buf_t *buf, void *tag) > ASSERT3P(state, !=, arc_anon); > > /* this buffer is not on any list */ > - ASSERT3S(refcount_count(&hdr->b_l1hdr.b_refcnt), >, 0); > + ASSERT3S(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt), >, 0); > > if (HDR_HAS_L2HDR(hdr)) { > mutex_enter(&hdr->b_l2hdr.b_dev->l2ad_mtx); > @@ -6384,12 +6391,13 @@ arc_release(arc_buf_t *buf, void *tag) > ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL); > ASSERT3P(state, !=, arc_l2c_only); > > - (void) refcount_remove_many(&state->arcs_size, > + (void) zfs_refcount_remove_many(&state->arcs_size, > arc_buf_size(buf), buf); > > - if (refcount_is_zero(&hdr->b_l1hdr.b_refcnt)) { > + if (zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)) { > ASSERT3P(state, !=, arc_l2c_only); > - (void) refcount_remove_many(&state->arcs_esize[type], > + (void) zfs_refcount_remove_many( > + &state->arcs_esize[type], > arc_buf_size(buf), buf); > } > > @@ -6408,21 +6416,21 @@ arc_release(arc_buf_t *buf, void *tag) > nhdr = arc_hdr_alloc(spa, psize, lsize, compress, type); > ASSERT3P(nhdr->b_l1hdr.b_buf, ==, NULL); > ASSERT0(nhdr->b_l1hdr.b_bufcnt); > - ASSERT0(refcount_count(&nhdr->b_l1hdr.b_refcnt)); > + ASSERT0(zfs_refcount_count(&nhdr->b_l1hdr.b_refcnt)); > VERIFY3U(nhdr->b_type, ==, type); > ASSERT(!HDR_SHARED_DATA(nhdr)); > > nhdr->b_l1hdr.b_buf = buf; > nhdr->b_l1hdr.b_bufcnt = 1; > - (void) refcount_add(&nhdr->b_l1hdr.b_refcnt, tag); > + (void) zfs_refcount_add(&nhdr->b_l1hdr.b_refcnt, tag); > buf->b_hdr = nhdr; > > mutex_exit(&buf->b_evict_lock); > - (void) refcount_add_many(&arc_anon->arcs_size, > + (void) zfs_refcount_add_many(&arc_anon->arcs_size, > arc_buf_size(buf), buf); > } else { > mutex_exit(&buf->b_evict_lock); > - ASSERT(refcount_count(&hdr->b_l1hdr.b_refcnt) == 1); > + ASSERT(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt) == 1); > /* protected by hash lock, or hdr is on arc_anon */ > ASSERT(!multilist_link_active(&hdr->b_l1hdr.b_arc_node)); > ASSERT(!HDR_IO_IN_PROGRESS(hdr)); > @@ -6454,7 +6462,7 @@ arc_referenced(arc_buf_t *buf) > int referenced; > > mutex_enter(&buf->b_evict_lock); > - referenced = (refcount_count(&buf->b_hdr->b_l1hdr.b_refcnt)); > + referenced = (zfs_refcount_count(&buf->b_hdr->b_l1hdr.b_refcnt)); > mutex_exit(&buf->b_evict_lock); > return (referenced); > } > @@ -6469,7 +6477,7 @@ arc_write_ready(zio_t *zio) > uint64_t psize = BP_IS_HOLE(zio->io_bp) ? 0 : BP_GET_PSIZE(zio->io_bp); > > ASSERT(HDR_HAS_L1HDR(hdr)); > - ASSERT(!refcount_is_zero(&buf->b_hdr->b_l1hdr.b_refcnt)); > + ASSERT(!zfs_refcount_is_zero(&buf->b_hdr->b_l1hdr.b_refcnt)); > ASSERT(hdr->b_l1hdr.b_bufcnt > 0); > > /* > @@ -6624,7 +6632,7 @@ arc_write_done(zio_t *zio) > if (!BP_EQUAL(&zio->io_bp_orig, zio->io_bp)) > panic("bad overwrite, hdr=%p exists=%p", > (void *)hdr, (void *)exists); > - ASSERT(refcount_is_zero( > + ASSERT(zfs_refcount_is_zero( > &exists->b_l1hdr.b_refcnt)); > arc_change_state(arc_anon, exists, hash_lock); > mutex_exit(hash_lock); > @@ -6654,7 +6662,7 @@ arc_write_done(zio_t *zio) > arc_hdr_clear_flags(hdr, ARC_FLAG_IO_IN_PROGRESS); > } > > - ASSERT(!refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > + ASSERT(!zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)); > callback->awcb_done(zio, buf, callback->awcb_private); > > abd_put(zio->io_abd); > @@ -6800,7 +6808,7 @@ arc_tempreserve_space(spa_t *spa, uint64_t reserve, ui > /* assert that it has not wrapped around */ > ASSERT3S(atomic_add_64_nv(&arc_loaned_bytes, 0), >=, 0); > > - anon_size = MAX((int64_t)(refcount_count(&arc_anon->arcs_size) - > + anon_size = MAX((int64_t)(zfs_refcount_count(&arc_anon->arcs_size) - > arc_loaned_bytes), 0); > > /* > @@ -6835,9 +6843,10 @@ arc_tempreserve_space(spa_t *spa, uint64_t reserve, ui > anon_size > arc_c * zfs_arc_anon_limit_percent / 100 && > spa_dirty_anon > anon_size * zfs_arc_pool_dirty_percent / 100) { > uint64_t meta_esize = > - refcount_count(&arc_anon->arcs_esize[ARC_BUFC_METADATA]); > + zfs_refcount_count( > + &arc_anon->arcs_esize[ARC_BUFC_METADATA]); > uint64_t data_esize = > - refcount_count(&arc_anon->arcs_esize[ARC_BUFC_DATA]); > + zfs_refcount_count(&arc_anon->arcs_esize[ARC_BUFC_DATA]); > dprintf("failing, arc_tempreserve=%lluK anon_meta=%lluK " > "anon_data=%lluK tempreserve=%lluK arc_c=%lluK\n", > arc_tempreserve >> 10, meta_esize >> 10, > @@ -6852,11 +6861,11 @@ static void > arc_kstat_update_state(arc_state_t *state, kstat_named_t *size, > kstat_named_t *evict_data, kstat_named_t *evict_metadata) > { > - size->value.ui64 = refcount_count(&state->arcs_size); > + size->value.ui64 = zfs_refcount_count(&state->arcs_size); > evict_data->value.ui64 = > - refcount_count(&state->arcs_esize[ARC_BUFC_DATA]); > + zfs_refcount_count(&state->arcs_esize[ARC_BUFC_DATA]); > evict_metadata->value.ui64 = > - refcount_count(&state->arcs_esize[ARC_BUFC_METADATA]); > + zfs_refcount_count(&state->arcs_esize[ARC_BUFC_METADATA]); > } > > static int > @@ -7025,25 +7034,25 @@ arc_state_init(void) > offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node), > arc_state_multilist_index_func); > > - refcount_create(&arc_anon->arcs_esize[ARC_BUFC_METADATA]); > - refcount_create(&arc_anon->arcs_esize[ARC_BUFC_DATA]); > - refcount_create(&arc_mru->arcs_esize[ARC_BUFC_METADATA]); > - refcount_create(&arc_mru->arcs_esize[ARC_BUFC_DATA]); > - refcount_create(&arc_mru_ghost->arcs_esize[ARC_BUFC_METADATA]); > - refcount_create(&arc_mru_ghost->arcs_esize[ARC_BUFC_DATA]); > - refcount_create(&arc_mfu->arcs_esize[ARC_BUFC_METADATA]); > - refcount_create(&arc_mfu->arcs_esize[ARC_BUFC_DATA]); > - refcount_create(&arc_mfu_ghost->arcs_esize[ARC_BUFC_METADATA]); > - refcount_create(&arc_mfu_ghost->arcs_esize[ARC_BUFC_DATA]); > - refcount_create(&arc_l2c_only->arcs_esize[ARC_BUFC_METADATA]); > - refcount_create(&arc_l2c_only->arcs_esize[ARC_BUFC_DATA]); > + zfs_refcount_create(&arc_anon->arcs_esize[ARC_BUFC_METADATA]); > + zfs_refcount_create(&arc_anon->arcs_esize[ARC_BUFC_DATA]); > + zfs_refcount_create(&arc_mru->arcs_esize[ARC_BUFC_METADATA]); > + zfs_refcount_create(&arc_mru->arcs_esize[ARC_BUFC_DATA]); > + zfs_refcount_create(&arc_mru_ghost->arcs_esize[ARC_BUFC_METADATA]); > + zfs_refcount_create(&arc_mru_ghost->arcs_esize[ARC_BUFC_DATA]); > + zfs_refcount_create(&arc_mfu->arcs_esize[ARC_BUFC_METADATA]); > + zfs_refcount_create(&arc_mfu->arcs_esize[ARC_BUFC_DATA]); > + zfs_refcount_create(&arc_mfu_ghost->arcs_esize[ARC_BUFC_METADATA]); > + zfs_refcount_create(&arc_mfu_ghost->arcs_esize[ARC_BUFC_DATA]); > + zfs_refcount_create(&arc_l2c_only->arcs_esize[ARC_BUFC_METADATA]); > + zfs_refcount_create(&arc_l2c_only->arcs_esize[ARC_BUFC_DATA]); > > - refcount_create(&arc_anon->arcs_size); > - refcount_create(&arc_mru->arcs_size); > - refcount_create(&arc_mru_ghost->arcs_size); > - refcount_create(&arc_mfu->arcs_size); > - refcount_create(&arc_mfu_ghost->arcs_size); > - refcount_create(&arc_l2c_only->arcs_size); > + zfs_refcount_create(&arc_anon->arcs_size); > + zfs_refcount_create(&arc_mru->arcs_size); > + zfs_refcount_create(&arc_mru_ghost->arcs_size); > + zfs_refcount_create(&arc_mfu->arcs_size); > + zfs_refcount_create(&arc_mfu_ghost->arcs_size); > + zfs_refcount_create(&arc_l2c_only->arcs_size); > > aggsum_init(&arc_meta_used, 0); > aggsum_init(&arc_size, 0); > @@ -7059,25 +7068,25 @@ arc_state_init(void) > static void > arc_state_fini(void) > { > - refcount_destroy(&arc_anon->arcs_esize[ARC_BUFC_METADATA]); > - refcount_destroy(&arc_anon->arcs_esize[ARC_BUFC_DATA]); > - refcount_destroy(&arc_mru->arcs_esize[ARC_BUFC_METADATA]); > - refcount_destroy(&arc_mru->arcs_esize[ARC_BUFC_DATA]); > - refcount_destroy(&arc_mru_ghost->arcs_esize[ARC_BUFC_METADATA]); > - refcount_destroy(&arc_mru_ghost->arcs_esize[ARC_BUFC_DATA]); > - refcount_destroy(&arc_mfu->arcs_esize[ARC_BUFC_METADATA]); > - refcount_destroy(&arc_mfu->arcs_esize[ARC_BUFC_DATA]); > - refcount_destroy(&arc_mfu_ghost->arcs_esize[ARC_BUFC_METADATA]); > - refcount_destroy(&arc_mfu_ghost->arcs_esize[ARC_BUFC_DATA]); > - refcount_destroy(&arc_l2c_only->arcs_esize[ARC_BUFC_METADATA]); > - refcount_destroy(&arc_l2c_only->arcs_esize[ARC_BUFC_DATA]); > + zfs_refcount_destroy(&arc_anon->arcs_esize[ARC_BUFC_METADATA]); > + zfs_refcount_destroy(&arc_anon->arcs_esize[ARC_BUFC_DATA]); > + zfs_refcount_destroy(&arc_mru->arcs_esize[ARC_BUFC_METADATA]); > + zfs_refcount_destroy(&arc_mru->arcs_esize[ARC_BUFC_DATA]); > + zfs_refcount_destroy(&arc_mru_ghost->arcs_esize[ARC_BUFC_METADATA]); > + zfs_refcount_destroy(&arc_mru_ghost->arcs_esize[ARC_BUFC_DATA]); > + zfs_refcount_destroy(&arc_mfu->arcs_esize[ARC_BUFC_METADATA]); > + zfs_refcount_destroy(&arc_mfu->arcs_esize[ARC_BUFC_DATA]); > + zfs_refcount_destroy(&arc_mfu_ghost->arcs_esize[ARC_BUFC_METADATA]); > + zfs_refcount_destroy(&arc_mfu_ghost->arcs_esize[ARC_BUFC_DATA]); > + zfs_refcount_destroy(&arc_l2c_only->arcs_esize[ARC_BUFC_METADATA]); > + zfs_refcount_destroy(&arc_l2c_only->arcs_esize[ARC_BUFC_DATA]); > > - refcount_destroy(&arc_anon->arcs_size); > - refcount_destroy(&arc_mru->arcs_size); > - refcount_destroy(&arc_mru_ghost->arcs_size); > - refcount_destroy(&arc_mfu->arcs_size); > - refcount_destroy(&arc_mfu_ghost->arcs_size); > - refcount_destroy(&arc_l2c_only->arcs_size); > + zfs_refcount_destroy(&arc_anon->arcs_size); > + zfs_refcount_destroy(&arc_mru->arcs_size); > + zfs_refcount_destroy(&arc_mru_ghost->arcs_size); > + zfs_refcount_destroy(&arc_mfu->arcs_size); > + zfs_refcount_destroy(&arc_mfu_ghost->arcs_size); > + zfs_refcount_destroy(&arc_l2c_only->arcs_size); > > multilist_destroy(arc_mru->arcs_list[ARC_BUFC_METADATA]); > multilist_destroy(arc_mru_ghost->arcs_list[ARC_BUFC_METADATA]); > @@ -7359,8 +7368,8 @@ arc_fini(void) > mutex_enter(&arc_prune_mtx); > while ((p = list_head(&arc_prune_list)) != NULL) { > list_remove(&arc_prune_list, p); > - refcount_remove(&p->p_refcnt, &arc_prune_list); > - refcount_destroy(&p->p_refcnt); > + zfs_refcount_remove(&p->p_refcnt, &arc_prune_list); > + zfs_refcount_destroy(&p->p_refcnt); > kmem_free(p, sizeof (*p)); > } > mutex_exit(&arc_prune_mtx); > @@ -7787,7 +7796,7 @@ top: > ARCSTAT_INCR(arcstat_l2_lsize, -HDR_GET_LSIZE(hdr)); > > bytes_dropped += arc_hdr_size(hdr); > - (void) refcount_remove_many(&dev->l2ad_alloc, > + (void) zfs_refcount_remove_many(&dev->l2ad_alloc, > arc_hdr_size(hdr), hdr); > } > > @@ -8205,7 +8214,8 @@ l2arc_write_buffers(spa_t *spa, l2arc_dev_t *dev, uint > list_insert_head(&dev->l2ad_buflist, hdr); > mutex_exit(&dev->l2ad_mtx); > > - (void) refcount_add_many(&dev->l2ad_alloc, psize, hdr); > + (void) zfs_refcount_add_many(&dev->l2ad_alloc, psize, > + hdr); > > /* > * Normally the L2ARC can use the hdr's data, but if > @@ -8439,7 +8449,7 @@ l2arc_add_vdev(spa_t *spa, vdev_t *vd) > offsetof(arc_buf_hdr_t, b_l2hdr.b_l2node)); > > vdev_space_update(vd, 0, 0, adddev->l2ad_end - adddev->l2ad_hand); > - refcount_create(&adddev->l2ad_alloc); > + zfs_refcount_create(&adddev->l2ad_alloc); > > /* > * Add device to global list > @@ -8485,7 +8495,7 @@ l2arc_remove_vdev(vdev_t *vd) > l2arc_evict(remdev, 0, B_TRUE); > list_destroy(&remdev->l2ad_buflist); > mutex_destroy(&remdev->l2ad_mtx); > - refcount_destroy(&remdev->l2ad_alloc); > + zfs_refcount_destroy(&remdev->l2ad_alloc); > kmem_free(remdev, sizeof (l2arc_dev_t)); > } > > > Modified: head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dbuf.c > ============================================================================== > --- head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dbuf.c Tue Oct > 15 14:51:22 > 2019 (r353564) +++ head/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/dbuf.c > Tue Oct 15 15:09:36 2019 (r353565) @@ -226,7 +226,7 @@ static boolean_t > dbuf_evict_thread_exit; */ > typedef struct dbuf_cache { > multilist_t *cache; > - refcount_t size; > + zfs_refcount_t size; > } dbuf_cache_t; > dbuf_cache_t dbuf_caches[DB_CACHE_MAX]; > > @@ -316,7 +316,7 @@ dbuf_cons(void *vdb, void *unused, int kmflag) > mutex_init(&db->db_mtx, NULL, MUTEX_DEFAULT, NULL); > cv_init(&db->db_changed, NULL, CV_DEFAULT, NULL); > multilist_link_init(&db->db_cache_link); > - refcount_create(&db->db_holds); > + zfs_refcount_create(&db->db_holds); > > return (0); > } > @@ -329,7 +329,7 @@ dbuf_dest(void *vdb, void *unused) > mutex_destroy(&db->db_mtx); > cv_destroy(&db->db_changed); > ASSERT(!multilist_link_active(&db->db_cache_link)); > - refcount_destroy(&db->db_holds); > + zfs_refcount_destroy(&db->db_holds); > > *** DIFF OUTPUT TRUNCATED AT 1000 LINES *** > _______________________________________________ > svn-src-head@freebsd.org mailing list > https://lists.freebsd.org/mailman/listinfo/svn-src-head > To unsubscribe, send any mail to "svn-src-head-unsubscr...@freebsd.org" Buildworld fails with the error shown below: [...] - --- cddl/lib/libzfs_core__L --- - --- libzfs_core.o --- In file included from /usr/src/cddl/contrib/opensolaris/lib/libzfs_core/common/libzfs_core.c:89: In file included from /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/zfs_ioctl.h:35: In file included from /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/dsl_deleg.h:30: In file included from /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/dsl_pool.h:37: /usr/src/sys/cddl/contrib/opensolaris/uts/common/fs/zfs/sys/arc.h:89:2: error: unknown type name 'refcount_t' refcount_t p_refcnt; ^ 1 error generated. *** [libzfs_core.o] Error code 1 make[4]: stopped in /usr/src/cddl/lib/libzfs_core - -- O. Hartmann Ich widerspreche der Nutzung oder Übermittlung meiner Daten für Werbezwecke oder für die Markt- oder Meinungsforschung (§ 28 Abs. 4 BDSG). -----BEGIN PGP SIGNATURE----- iHUEARYIAB0WIQSy8IBxAPDkqVBaTJ44N1ZZPba5RwUCXaXrngAKCRA4N1ZZPba5 R9e5AP9ZR0qkGAjsJJBcVQ6CdDxCJDMyNijCAcp+0dQvJ1UxGgEAjgiFsPwkKqkc IlHXY9GuIjfjHMv4QlW+ASHQwDJsKwo= =gU4S -----END PGP SIGNATURE----- _______________________________________________ svn-src-head@freebsd.org mailing list https://lists.freebsd.org/mailman/listinfo/svn-src-head To unsubscribe, send any mail to "svn-src-head-unsubscr...@freebsd.org"
