c/mirror_zfs
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_zfs.git synced 2026-05-22 10:37:35 +03:00
Code Issues Packages Projects Releases Wiki Activity

Linux 6.12 compat: Rename range_tree_* to zfs_range_tree_*

Browse Source 
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>
This commit is contained in:
Ivan Volosyuk
2025-01-30 21:26:49 +11:00
committed by Tony Hutter
parent db62886d98
commit d4a5a7e3aa
29 changed files with 990 additions and 930 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/sys/range_tree.h
+101 -94
View File
@@ -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
}