Linux 6.12 compat: Rename range_tree_* to zfs_range_tree_*

Linux 6.12 has conflicting range_tree_{find,destroy,clear} symbols.

Signed-off-by: Ivan Volosyuk <Ivan.Volosyuk@gmail.com>
Reviewed-by: Tony Hutter <hutter2@llnl.gov>
Reviewed-by: Rob Norris <robn@despairlabs.com>

include/sys/dnode.h

@@ -335,7 +335,7 @@ struct dnode {
 	/* protected by dn_mtx: */
 	kmutex_t dn_mtx;
 	list_t dn_dirty_records[TXG_SIZE];
-	struct range_tree *dn_free_ranges[TXG_SIZE];
+	struct zfs_range_tree *dn_free_ranges[TXG_SIZE];
 	uint64_t dn_allocated_txg;
 	uint64_t dn_free_txg;
 	uint64_t dn_assigned_txg;

include/sys/metaslab.h

@@ -139,7 +139,7 @@ void metaslab_set_selected_txg(metaslab_t *, uint64_t);
 
 extern int metaslab_debug_load;
 
-range_seg_type_t metaslab_calculate_range_tree_type(vdev_t *vdev,
+zfs_range_seg_type_t metaslab_calculate_range_tree_type(vdev_t *vdev,
     metaslab_t *msp, uint64_t *start, uint64_t *shift);
 
 #ifdef	__cplusplus

include/sys/metaslab_impl.h

@@ -398,8 +398,8 @@ struct metaslab {
 	uint64_t	ms_size;
 	uint64_t	ms_fragmentation;
 
-	range_tree_t	*ms_allocating[TXG_SIZE];
-	range_tree_t	*ms_allocatable;
+	zfs_range_tree_t	*ms_allocating[TXG_SIZE];
+	zfs_range_tree_t	*ms_allocatable;
 	uint64_t	ms_allocated_this_txg;
 	uint64_t	ms_allocating_total;
 
@@ -408,10 +408,12 @@ struct metaslab {
 	 * ms_free*tree only have entries while syncing, and are empty
 	 * between syncs.
 	 */
-	range_tree_t	*ms_freeing;	/* to free this syncing txg */
-	range_tree_t	*ms_freed;	/* already freed this syncing txg */
-	range_tree_t	*ms_defer[TXG_DEFER_SIZE];
-	range_tree_t	*ms_checkpointing; /* to add to the checkpoint */
+	zfs_range_tree_t	*ms_freeing;	/* to free this syncing txg */
+	/* already freed this syncing txg */
+	zfs_range_tree_t	*ms_freed;
+	zfs_range_tree_t	*ms_defer[TXG_DEFER_SIZE];
+	/* to add to the checkpoint */
+	zfs_range_tree_t	*ms_checkpointing;
 
 	/*
 	 * The ms_trim tree is the set of allocatable segments which are
@@ -421,7 +423,7 @@ struct metaslab {
 	 * is unloaded.  Its purpose is to aggregate freed ranges to
 	 * facilitate efficient trimming.
 	 */
-	range_tree_t	*ms_trim;
+	zfs_range_tree_t	*ms_trim;
 
 	boolean_t	ms_condensing;	/* condensing? */
 	boolean_t	ms_condense_wanted;
@@ -542,8 +544,8 @@ struct metaslab {
 	 * Allocs and frees that are committed to the vdev log spacemap but
 	 * not yet to this metaslab's spacemap.
 	 */
-	range_tree_t	*ms_unflushed_allocs;
-	range_tree_t	*ms_unflushed_frees;
+	zfs_range_tree_t	*ms_unflushed_allocs;
+	zfs_range_tree_t	*ms_unflushed_frees;
 
 	/*
 	 * We have flushed entries up to but not including this TXG. In

include/sys/range_tree.h

@@ -39,23 +39,23 @@ extern "C" {
 
 #define	RANGE_TREE_HISTOGRAM_SIZE	64
 
-typedef struct range_tree_ops range_tree_ops_t;
+typedef struct zfs_range_tree_ops zfs_range_tree_ops_t;
 
-typedef enum range_seg_type {
-	RANGE_SEG32,
-	RANGE_SEG64,
-	RANGE_SEG_GAP,
-	RANGE_SEG_NUM_TYPES,
-} range_seg_type_t;
+typedef enum zfs_range_seg_type {
+	ZFS_RANGE_SEG32,
+	ZFS_RANGE_SEG64,
+	ZFS_RANGE_SEG_GAP,
+	ZFS_RANGE_SEG_NUM_TYPES,
+} zfs_range_seg_type_t;
 
 /*
  * Note: the range_tree may not be accessed concurrently; consumers
  * must provide external locking if required.
  */
-typedef struct range_tree {
+typedef struct zfs_range_tree {
 	zfs_btree_t	rt_root;	/* offset-ordered segment b-tree */
 	uint64_t	rt_space;	/* sum of all segments in the map */
-	range_seg_type_t rt_type;	/* type of range_seg_t in use */
+	zfs_range_seg_type_t rt_type;	/* type of zfs_range_seg_t in use */
 	/*
 	 * All data that is stored in the range tree must have a start higher
 	 * than or equal to rt_start, and all sizes and offsets must be
@@ -63,7 +63,7 @@ typedef struct range_tree {
 	 */
 	uint8_t		rt_shift;
 	uint64_t	rt_start;
-	const range_tree_ops_t *rt_ops;
+	const zfs_range_tree_ops_t *rt_ops;
 	void		*rt_arg;
 	uint64_t	rt_gap;		/* allowable inter-segment gap */
 
@@ -73,7 +73,7 @@ typedef struct range_tree {
 	 * 2^i <= size of range in bytes < 2^(i+1)
 	 */
 	uint64_t	rt_histogram[RANGE_TREE_HISTOGRAM_SIZE];
-} range_tree_t;
+} zfs_range_tree_t;
 
 typedef struct range_seg32 {
 	uint32_t	rs_start;	/* starting offset of this segment */
@@ -106,26 +106,26 @@ typedef range_seg_gap_t range_seg_max_t;
  * pointer is to a range seg of some type; when we need to do the actual math,
  * we'll figure out the real type.
  */
-typedef void range_seg_t;
+typedef void zfs_range_seg_t;
 
-struct range_tree_ops {
-	void    (*rtop_create)(range_tree_t *rt, void *arg);
-	void    (*rtop_destroy)(range_tree_t *rt, void *arg);
-	void	(*rtop_add)(range_tree_t *rt, void *rs, void *arg);
-	void    (*rtop_remove)(range_tree_t *rt, void *rs, void *arg);
-	void	(*rtop_vacate)(range_tree_t *rt, void *arg);
+struct zfs_range_tree_ops {
+	void    (*rtop_create)(zfs_range_tree_t *rt, void *arg);
+	void    (*rtop_destroy)(zfs_range_tree_t *rt, void *arg);
+	void	(*rtop_add)(zfs_range_tree_t *rt, void *rs, void *arg);
+	void    (*rtop_remove)(zfs_range_tree_t *rt, void *rs, void *arg);
+	void	(*rtop_vacate)(zfs_range_tree_t *rt, void *arg);
 };
 
 static inline uint64_t
-rs_get_start_raw(const range_seg_t *rs, const range_tree_t *rt)
+zfs_rs_get_start_raw(const zfs_range_seg_t *rs, const zfs_range_tree_t *rt)
 {
-	ASSERT3U(rt->rt_type, <=, RANGE_SEG_NUM_TYPES);
+	ASSERT3U(rt->rt_type, <=, ZFS_RANGE_SEG_NUM_TYPES);
 	switch (rt->rt_type) {
-	case RANGE_SEG32:
+	case ZFS_RANGE_SEG32:
 		return (((const range_seg32_t *)rs)->rs_start);
-	case RANGE_SEG64:
+	case ZFS_RANGE_SEG64:
 		return (((const range_seg64_t *)rs)->rs_start);
-	case RANGE_SEG_GAP:
+	case ZFS_RANGE_SEG_GAP:
 		return (((const range_seg_gap_t *)rs)->rs_start);
 	default:
 		VERIFY(0);
@@ -134,15 +134,15 @@ rs_get_start_raw(const range_seg_t *rs, const range_tree_t *rt)
 }
 
 static inline uint64_t
-rs_get_end_raw(const range_seg_t *rs, const range_tree_t *rt)
+zfs_rs_get_end_raw(const zfs_range_seg_t *rs, const zfs_range_tree_t *rt)
 {
-	ASSERT3U(rt->rt_type, <=, RANGE_SEG_NUM_TYPES);
+	ASSERT3U(rt->rt_type, <=, ZFS_RANGE_SEG_NUM_TYPES);
 	switch (rt->rt_type) {
-	case RANGE_SEG32:
+	case ZFS_RANGE_SEG32:
 		return (((const range_seg32_t *)rs)->rs_end);
-	case RANGE_SEG64:
+	case ZFS_RANGE_SEG64:
 		return (((const range_seg64_t *)rs)->rs_end);
-	case RANGE_SEG_GAP:
+	case ZFS_RANGE_SEG_GAP:
 		return (((const range_seg_gap_t *)rs)->rs_end);
 	default:
 		VERIFY(0);
@@ -151,19 +151,19 @@ rs_get_end_raw(const range_seg_t *rs, const range_tree_t *rt)
 }
 
 static inline uint64_t
-rs_get_fill_raw(const range_seg_t *rs, const range_tree_t *rt)
+zfs_rs_get_fill_raw(const zfs_range_seg_t *rs, const zfs_range_tree_t *rt)
 {
-	ASSERT3U(rt->rt_type, <=, RANGE_SEG_NUM_TYPES);
+	ASSERT3U(rt->rt_type, <=, ZFS_RANGE_SEG_NUM_TYPES);
 	switch (rt->rt_type) {
-	case RANGE_SEG32: {
+	case ZFS_RANGE_SEG32: {
 		const range_seg32_t *r32 = (const range_seg32_t *)rs;
 		return (r32->rs_end - r32->rs_start);
 	}
-	case RANGE_SEG64: {
+	case ZFS_RANGE_SEG64: {
 		const range_seg64_t *r64 = (const range_seg64_t *)rs;
 		return (r64->rs_end - r64->rs_start);
 	}
-	case RANGE_SEG_GAP:
+	case ZFS_RANGE_SEG_GAP:
 		return (((const range_seg_gap_t *)rs)->rs_fill);
 	default:
 		VERIFY(0);
@@ -173,36 +173,36 @@ rs_get_fill_raw(const range_seg_t *rs, const range_tree_t *rt)
 }
 
 static inline uint64_t
-rs_get_start(const range_seg_t *rs, const range_tree_t *rt)
+zfs_rs_get_start(const zfs_range_seg_t *rs, const zfs_range_tree_t *rt)
 {
-	return ((rs_get_start_raw(rs, rt) << rt->rt_shift) + rt->rt_start);
+	return ((zfs_rs_get_start_raw(rs, rt) << rt->rt_shift) + rt->rt_start);
 }
 
 static inline uint64_t
-rs_get_end(const range_seg_t *rs, const range_tree_t *rt)
+zfs_rs_get_end(const zfs_range_seg_t *rs, const zfs_range_tree_t *rt)
 {
-	return ((rs_get_end_raw(rs, rt) << rt->rt_shift) + rt->rt_start);
+	return ((zfs_rs_get_end_raw(rs, rt) << rt->rt_shift) + rt->rt_start);
 }
 
 static inline uint64_t
-rs_get_fill(const range_seg_t *rs, const range_tree_t *rt)
+zfs_rs_get_fill(const zfs_range_seg_t *rs, const zfs_range_tree_t *rt)
 {
-	return (rs_get_fill_raw(rs, rt) << rt->rt_shift);
+	return (zfs_rs_get_fill_raw(rs, rt) << rt->rt_shift);
 }
 
 static inline void
-rs_set_start_raw(range_seg_t *rs, range_tree_t *rt, uint64_t start)
+zfs_rs_set_start_raw(zfs_range_seg_t *rs, zfs_range_tree_t *rt, uint64_t start)
 {
-	ASSERT3U(rt->rt_type, <=, RANGE_SEG_NUM_TYPES);
+	ASSERT3U(rt->rt_type, <=, ZFS_RANGE_SEG_NUM_TYPES);
 	switch (rt->rt_type) {
-	case RANGE_SEG32:
+	case ZFS_RANGE_SEG32:
 		ASSERT3U(start, <=, UINT32_MAX);
 		((range_seg32_t *)rs)->rs_start = (uint32_t)start;
 		break;
-	case RANGE_SEG64:
+	case ZFS_RANGE_SEG64:
 		((range_seg64_t *)rs)->rs_start = start;
 		break;
-	case RANGE_SEG_GAP:
+	case ZFS_RANGE_SEG_GAP:
 		((range_seg_gap_t *)rs)->rs_start = start;
 		break;
 	default:
@@ -211,18 +211,18 @@ rs_set_start_raw(range_seg_t *rs, range_tree_t *rt, uint64_t start)
 }
 
 static inline void
-rs_set_end_raw(range_seg_t *rs, range_tree_t *rt, uint64_t end)
+zfs_rs_set_end_raw(zfs_range_seg_t *rs, zfs_range_tree_t *rt, uint64_t end)
 {
-	ASSERT3U(rt->rt_type, <=, RANGE_SEG_NUM_TYPES);
+	ASSERT3U(rt->rt_type, <=, ZFS_RANGE_SEG_NUM_TYPES);
 	switch (rt->rt_type) {
-	case RANGE_SEG32:
+	case ZFS_RANGE_SEG32:
 		ASSERT3U(end, <=, UINT32_MAX);
 		((range_seg32_t *)rs)->rs_end = (uint32_t)end;
 		break;
-	case RANGE_SEG64:
+	case ZFS_RANGE_SEG64:
 		((range_seg64_t *)rs)->rs_end = end;
 		break;
-	case RANGE_SEG_GAP:
+	case ZFS_RANGE_SEG_GAP:
 		((range_seg_gap_t *)rs)->rs_end = end;
 		break;
 	default:
@@ -231,17 +231,18 @@ rs_set_end_raw(range_seg_t *rs, range_tree_t *rt, uint64_t end)
 }
 
 static inline void
-rs_set_fill_raw(range_seg_t *rs, range_tree_t *rt, uint64_t fill)
+zfs_zfs_rs_set_fill_raw(zfs_range_seg_t *rs, zfs_range_tree_t *rt,
+    uint64_t fill)
 {
-	ASSERT3U(rt->rt_type, <=, RANGE_SEG_NUM_TYPES);
+	ASSERT3U(rt->rt_type, <=, ZFS_RANGE_SEG_NUM_TYPES);
 	switch (rt->rt_type) {
-	case RANGE_SEG32:
+	case ZFS_RANGE_SEG32:
 		/* fall through */
-	case RANGE_SEG64:
-		ASSERT3U(fill, ==, rs_get_end_raw(rs, rt) - rs_get_start_raw(rs,
-		    rt));
+	case ZFS_RANGE_SEG64:
+		ASSERT3U(fill, ==, zfs_rs_get_end_raw(rs, rt) -
+		    zfs_rs_get_start_raw(rs, rt));
 		break;
-	case RANGE_SEG_GAP:
+	case ZFS_RANGE_SEG_GAP:
 		((range_seg_gap_t *)rs)->rs_fill = fill;
 		break;
 	default:
@@ -250,67 +251,73 @@ rs_set_fill_raw(range_seg_t *rs, range_tree_t *rt, uint64_t fill)
 }
 
 static inline void
-rs_set_start(range_seg_t *rs, range_tree_t *rt, uint64_t start)
+zfs_rs_set_start(zfs_range_seg_t *rs, zfs_range_tree_t *rt, uint64_t start)
 {
 	ASSERT3U(start, >=, rt->rt_start);
 	ASSERT(IS_P2ALIGNED(start, 1ULL << rt->rt_shift));
-	rs_set_start_raw(rs, rt, (start - rt->rt_start) >> rt->rt_shift);
+	zfs_rs_set_start_raw(rs, rt, (start - rt->rt_start) >> rt->rt_shift);
 }
 
 static inline void
-rs_set_end(range_seg_t *rs, range_tree_t *rt, uint64_t end)
+zfs_rs_set_end(zfs_range_seg_t *rs, zfs_range_tree_t *rt, uint64_t end)
 {
 	ASSERT3U(end, >=, rt->rt_start);
 	ASSERT(IS_P2ALIGNED(end, 1ULL << rt->rt_shift));
-	rs_set_end_raw(rs, rt, (end - rt->rt_start) >> rt->rt_shift);
+	zfs_rs_set_end_raw(rs, rt, (end - rt->rt_start) >> rt->rt_shift);
 }
 
 static inline void
-rs_set_fill(range_seg_t *rs, range_tree_t *rt, uint64_t fill)
+zfs_rs_set_fill(zfs_range_seg_t *rs, zfs_range_tree_t *rt, uint64_t fill)
 {
 	ASSERT(IS_P2ALIGNED(fill, 1ULL << rt->rt_shift));
-	rs_set_fill_raw(rs, rt, fill >> rt->rt_shift);
+	zfs_zfs_rs_set_fill_raw(rs, rt, fill >> rt->rt_shift);
 }
 
-typedef void range_tree_func_t(void *arg, uint64_t start, uint64_t size);
+typedef void zfs_range_tree_func_t(void *arg, uint64_t start, uint64_t size);
 
-range_tree_t *range_tree_create_gap(const range_tree_ops_t *ops,
-    range_seg_type_t type, void *arg, uint64_t start, uint64_t shift,
+zfs_range_tree_t *zfs_range_tree_create_gap(const zfs_range_tree_ops_t *ops,
+    zfs_range_seg_type_t type, void *arg, uint64_t start, uint64_t shift,
     uint64_t gap);
-range_tree_t *range_tree_create(const range_tree_ops_t *ops,
-    range_seg_type_t type, void *arg, uint64_t start, uint64_t shift);
-void range_tree_destroy(range_tree_t *rt);
-boolean_t range_tree_contains(range_tree_t *rt, uint64_t start, uint64_t size);
-range_seg_t *range_tree_find(range_tree_t *rt, uint64_t start, uint64_t size);
-boolean_t range_tree_find_in(range_tree_t *rt, uint64_t start, uint64_t size,
-    uint64_t *ostart, uint64_t *osize);
-void range_tree_verify_not_present(range_tree_t *rt,
+zfs_range_tree_t *zfs_range_tree_create(const zfs_range_tree_ops_t *ops,
+    zfs_range_seg_type_t type, void *arg, uint64_t start, uint64_t shift);
+void zfs_range_tree_destroy(zfs_range_tree_t *rt);
+boolean_t zfs_range_tree_contains(zfs_range_tree_t *rt, uint64_t start,
+    uint64_t size);
+zfs_range_seg_t *zfs_range_tree_find(zfs_range_tree_t *rt, uint64_t start,
+    uint64_t size);
+boolean_t zfs_range_tree_find_in(zfs_range_tree_t *rt, uint64_t start,
+    uint64_t size, uint64_t *ostart, uint64_t *osize);
+void zfs_range_tree_verify_not_present(zfs_range_tree_t *rt,
     uint64_t start, uint64_t size);
-void range_tree_resize_segment(range_tree_t *rt, range_seg_t *rs,
+void zfs_range_tree_resize_segment(zfs_range_tree_t *rt, zfs_range_seg_t *rs,
     uint64_t newstart, uint64_t newsize);
-uint64_t range_tree_space(range_tree_t *rt);
-uint64_t range_tree_numsegs(range_tree_t *rt);
-boolean_t range_tree_is_empty(range_tree_t *rt);
-void range_tree_swap(range_tree_t **rtsrc, range_tree_t **rtdst);
-void range_tree_stat_verify(range_tree_t *rt);
-uint64_t range_tree_min(range_tree_t *rt);
-uint64_t range_tree_max(range_tree_t *rt);
-uint64_t range_tree_span(range_tree_t *rt);
+uint64_t zfs_range_tree_space(zfs_range_tree_t *rt);
+uint64_t zfs_range_tree_numsegs(zfs_range_tree_t *rt);
+boolean_t zfs_range_tree_is_empty(zfs_range_tree_t *rt);
+void zfs_range_tree_swap(zfs_range_tree_t **rtsrc, zfs_range_tree_t **rtdst);
+void zfs_range_tree_stat_verify(zfs_range_tree_t *rt);
+uint64_t zfs_range_tree_min(zfs_range_tree_t *rt);
+uint64_t zfs_range_tree_max(zfs_range_tree_t *rt);
+uint64_t zfs_range_tree_span(zfs_range_tree_t *rt);
 
-void range_tree_add(void *arg, uint64_t start, uint64_t size);
-void range_tree_remove(void *arg, uint64_t start, uint64_t size);
-void range_tree_remove_fill(range_tree_t *rt, uint64_t start, uint64_t size);
-void range_tree_adjust_fill(range_tree_t *rt, range_seg_t *rs, int64_t delta);
-void range_tree_clear(range_tree_t *rt, uint64_t start, uint64_t size);
+void zfs_range_tree_add(void *arg, uint64_t start, uint64_t size);
+void zfs_range_tree_remove(void *arg, uint64_t start, uint64_t size);
+void zfs_range_tree_remove_fill(zfs_range_tree_t *rt, uint64_t start,
+    uint64_t size);
+void zfs_range_tree_adjust_fill(zfs_range_tree_t *rt, zfs_range_seg_t *rs,
+    int64_t delta);
+void zfs_range_tree_clear(zfs_range_tree_t *rt, uint64_t start, uint64_t size);
 
-void range_tree_vacate(range_tree_t *rt, range_tree_func_t *func, void *arg);
-void range_tree_walk(range_tree_t *rt, range_tree_func_t *func, void *arg);
-range_seg_t *range_tree_first(range_tree_t *rt);
+void zfs_range_tree_vacate(zfs_range_tree_t *rt, zfs_range_tree_func_t *func,
+    void *arg);
+void zfs_range_tree_walk(zfs_range_tree_t *rt, zfs_range_tree_func_t *func,
+    void *arg);
+zfs_range_seg_t *zfs_range_tree_first(zfs_range_tree_t *rt);
 
-void range_tree_remove_xor_add_segment(uint64_t start, uint64_t end,
-    range_tree_t *removefrom, range_tree_t *addto);
-void range_tree_remove_xor_add(range_tree_t *rt, range_tree_t *removefrom,
-    range_tree_t *addto);
+void zfs_range_tree_remove_xor_add_segment(uint64_t start, uint64_t end,
+    zfs_range_tree_t *removefrom, zfs_range_tree_t *addto);
+void zfs_range_tree_remove_xor_add(zfs_range_tree_t *rt,
+    zfs_range_tree_t *removefrom, zfs_range_tree_t *addto);
 
 #ifdef	__cplusplus
 }

include/sys/space_map.h

@@ -207,28 +207,28 @@ boolean_t sm_entry_is_double_word(uint64_t e);
 
 typedef int (*sm_cb_t)(space_map_entry_t *sme, void *arg);
 
-int space_map_load(space_map_t *sm, range_tree_t *rt, maptype_t maptype);
-int space_map_load_length(space_map_t *sm, range_tree_t *rt, maptype_t maptype,
-    uint64_t length);
+int space_map_load(space_map_t *sm, zfs_range_tree_t *rt, maptype_t maptype);
+int space_map_load_length(space_map_t *sm, zfs_range_tree_t *rt,
+    maptype_t maptype, uint64_t length);
 int space_map_iterate(space_map_t *sm, uint64_t length,
     sm_cb_t callback, void *arg);
 int space_map_incremental_destroy(space_map_t *sm, sm_cb_t callback, void *arg,
     dmu_tx_t *tx);
 
-boolean_t space_map_histogram_verify(space_map_t *sm, range_tree_t *rt);
+boolean_t space_map_histogram_verify(space_map_t *sm, zfs_range_tree_t *rt);
 void space_map_histogram_clear(space_map_t *sm);
-void space_map_histogram_add(space_map_t *sm, range_tree_t *rt,
+void space_map_histogram_add(space_map_t *sm, zfs_range_tree_t *rt,
     dmu_tx_t *tx);
 
 uint64_t space_map_object(space_map_t *sm);
 int64_t space_map_allocated(space_map_t *sm);
 uint64_t space_map_length(space_map_t *sm);
-uint64_t space_map_entries(space_map_t *sm, range_tree_t *rt);
+uint64_t space_map_entries(space_map_t *sm, zfs_range_tree_t *rt);
 uint64_t space_map_nblocks(space_map_t *sm);
 
-void space_map_write(space_map_t *sm, range_tree_t *rt, maptype_t maptype,
+void space_map_write(space_map_t *sm, zfs_range_tree_t *rt, maptype_t maptype,
     uint64_t vdev_id, dmu_tx_t *tx);
-uint64_t space_map_estimate_optimal_size(space_map_t *sm, range_tree_t *rt,
+uint64_t space_map_estimate_optimal_size(space_map_t *sm, zfs_range_tree_t *rt,
     uint64_t vdev_id);
 void space_map_truncate(space_map_t *sm, int blocksize, dmu_tx_t *tx);
 uint64_t space_map_alloc(objset_t *os, int blocksize, dmu_tx_t *tx);

include/sys/space_reftree.h

@@ -46,8 +46,8 @@ void space_reftree_create(avl_tree_t *t);
 void space_reftree_destroy(avl_tree_t *t);
 void space_reftree_add_seg(avl_tree_t *t, uint64_t start, uint64_t end,
     int64_t refcnt);
-void space_reftree_add_map(avl_tree_t *t, range_tree_t *rt, int64_t refcnt);
-void space_reftree_generate_map(avl_tree_t *t, range_tree_t *rt,
+void space_reftree_add_map(avl_tree_t *t, zfs_range_tree_t *rt, int64_t refcnt);
+void space_reftree_generate_map(avl_tree_t *t, zfs_range_tree_t *rt,
     int64_t minref);
 
 #ifdef	__cplusplus

include/sys/vdev_impl.h

@@ -299,7 +299,8 @@ struct vdev {
 	kcondvar_t	vdev_initialize_cv;
 	uint64_t	vdev_initialize_offset[TXG_SIZE];
 	uint64_t	vdev_initialize_last_offset;
-	range_tree_t	*vdev_initialize_tree;	/* valid while initializing */
+	/* valid while initializing */
+	zfs_range_tree_t	*vdev_initialize_tree;
 	uint64_t	vdev_initialize_bytes_est;
 	uint64_t	vdev_initialize_bytes_done;
 	uint64_t	vdev_initialize_action_time;	/* start and end time */
@@ -375,7 +376,7 @@ struct vdev {
 	 * from multiple zio threads.
 	 */
 	kmutex_t	vdev_obsolete_lock;
-	range_tree_t	*vdev_obsolete_segments;
+	zfs_range_tree_t	*vdev_obsolete_segments;
 	space_map_t	*vdev_obsolete_sm;
 
 	/*
@@ -388,7 +389,7 @@ struct vdev {
 	/*
 	 * Leaf vdev state.
 	 */
-	range_tree_t	*vdev_dtl[DTL_TYPES]; /* dirty time logs	*/
+	zfs_range_tree_t	*vdev_dtl[DTL_TYPES]; /* dirty time logs */
 	space_map_t	*vdev_dtl_sm;	/* dirty time log space map	*/
 	txg_node_t	vdev_dtl_node;	/* per-txg dirty DTL linkage	*/
 	uint64_t	vdev_dtl_object; /* DTL object			*/

include/sys/vdev_rebuild.h

@@ -65,7 +65,8 @@ typedef struct vdev_rebuild_phys {
 typedef struct vdev_rebuild {
 	vdev_t		*vr_top_vdev;		/* top-level vdev to rebuild */
 	metaslab_t	*vr_scan_msp;		/* scanning disabled metaslab */
-	range_tree_t	*vr_scan_tree;		/* scan ranges (in metaslab) */
+	/* scan ranges (in metaslab) */
+	zfs_range_tree_t	*vr_scan_tree;
 	kmutex_t	vr_io_lock;		/* inflight IO lock */
 	kcondvar_t	vr_io_cv;		/* inflight IO cv */
 

include/sys/vdev_removal.h

@@ -35,7 +35,7 @@ typedef struct spa_vdev_removal {
 	/* Thread performing a vdev removal. */
 	kthread_t	*svr_thread;
 	/* Segments left to copy from the current metaslab. */
-	range_tree_t	*svr_allocd_segs;
+	zfs_range_tree_t	*svr_allocd_segs;
 	kmutex_t	svr_lock;
 	kcondvar_t	svr_cv;
 	boolean_t	svr_thread_exit;
@@ -49,7 +49,7 @@ typedef struct spa_vdev_removal {
 	 * Ranges that were freed while a mapping was in flight.  This is
 	 * a subset of the ranges covered by vdev_im_new_segments.
 	 */
-	range_tree_t	*svr_frees[TXG_SIZE];
+	zfs_range_tree_t	*svr_frees[TXG_SIZE];
 
 	/*
 	 * Number of bytes which we have finished our work for