c/mirror_zfs
1
0
Fork 0
mirror of https://git.proxmox.com/git/mirror_zfs.git synced 2026-04-13 07:01:46 +03:00
Code Issues Packages Projects Releases Wiki Activity

More consistent use of TREE_* macros in AVL comparators

Browse Source 
Where is it appropriate and obvious, use TREE_CMP(), TREE_ISIGN() and
TREE_PCMP() instead or direct comparisons. It can make the code a lot
smaller, less error prone, and easier to read.

Sponsored-by: TrueNAS
Reviewed-by: Alexander Motin <alexander.motin@TrueNAS.com>
Reviewed-by: Brian Behlendorf <behlendorf1@llnl.gov>
Signed-off-by: Rob Norris <rob.norris@truenas.com>
Closes #18259
This commit is contained in:
Rob Norris 2026-03-04 04:08:23 +11:00 committed by GitHub
parent 0f90a797dd
commit 1e2c94a043
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
19 changed files with 88 additions and 199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
cmd/zed/zed_exec.c
View File

@ -45,21 +45,10 @@ struct launched_process_node {
static int
_launched_process_node_compare(const void *x1, const void *x2)
{
pid_t p1;
pid_t p2;
const struct launched_process_node *node1 = x1;
const struct launched_process_node *node2 = x2;
assert(x1 != NULL);
assert(x2 != NULL);
p1 = ((const struct launched_process_node *) x1)->pid;
p2 = ((const struct launched_process_node *) x2)->pid;
if (p1 < p2)
return (-1);
else if (p1 == p2)
return (0);
else
return (1);
return (TREE_CMP(node1->pid, node2->pid));
}
static pthread_t _reap_children_tid = (pthread_t)-1;

22
cmd/zed/zed_strings.c
View File

@ -42,26 +42,10 @@ typedef struct zed_strings_node zed_strings_node_t;
static int
_zed_strings_node_compare(const void *x1, const void *x2)
{
const char *s1;
const char *s2;
int rv;
const zed_strings_node_t *n1 = x1;
const zed_strings_node_t *n2 = x2;
assert(x1 != NULL);
assert(x2 != NULL);
s1 = ((const zed_strings_node_t *) x1)->key;
assert(s1 != NULL);
s2 = ((const zed_strings_node_t *) x2)->key;
assert(s2 != NULL);
rv = strcmp(s1, s2);
if (rv < 0)
return (-1);
if (rv > 0)
return (1);
return (0);
return (TREE_ISIGN(strcmp(n1->key, n2->key)));
}
/*

8
cmd/zfs/zfs_iter.c
View File

@ -413,14 +413,12 @@ zfs_sort(const void *larg, const void *rarg)
if (lstr)
ret = TREE_ISIGN(strcmp(lstr, rstr));
else if (lnum < rnum)
ret = -1;
else if (lnum > rnum)
ret = 1;
else
ret = TREE_CMP(lnum, rnum);
if (ret != 0) {
if (psc->sc_reverse == B_TRUE)
ret = (ret < 0) ? 1 : -1;
ret = -ret;
return (ret);
}
}

32
cmd/zfs/zfs_main.c
View File

@ -2905,15 +2905,13 @@ us_compare(const void *larg, const void *rarg)
uint64_t rv64 = 0;
zfs_prop_t prop = sortcol->sc_prop;
const char *propname = NULL;
boolean_t reverse = sortcol->sc_reverse;
switch (prop) {
case ZFS_PROP_TYPE:
propname = "type";
(void) nvlist_lookup_uint32(lnvl, propname, &lv32);
(void) nvlist_lookup_uint32(rnvl, propname, &rv32);
if (rv32 != lv32)
rc = (rv32 < lv32) ? 1 : -1;
rc = TREE_CMP(lv32, rv32);
break;
case ZFS_PROP_NAME:
propname = "name";
@ -2923,8 +2921,7 @@ compare_nums:
&lv64);
(void) nvlist_lookup_uint64(rnvl, propname,
&rv64);
if (rv64 != lv64)
rc = (rv64 < lv64) ? 1 : -1;
rc = TREE_CMP(lv64, rv64);
} else {
if ((nvlist_lookup_string(lnvl, propname,
&lvstr) == ENOENT) ||
@ -2932,7 +2929,7 @@ compare_nums:
&rvstr) == ENOENT)) {
goto compare_nums;
}
rc = strcmp(lvstr, rvstr);
rc = TREE_ISIGN(strcmp(lvstr, rvstr));
}
break;
case ZFS_PROP_USED:
@ -2945,8 +2942,7 @@ compare_nums:
propname = "quota";
(void) nvlist_lookup_uint64(lnvl, propname, &lv64);
(void) nvlist_lookup_uint64(rnvl, propname, &rv64);
if (rv64 != lv64)
rc = (rv64 < lv64) ? 1 : -1;
rc = TREE_CMP(lv64, rv64);
break;
default:
@ -2954,10 +2950,9 @@ compare_nums:
}
if (rc != 0) {
if (rc < 0)
return (reverse ? 1 : -1);
else
return (reverse ? -1 : 1);
if (sortcol->sc_reverse)
return (-rc);
return (rc);
}
}
@ -2967,9 +2962,8 @@ compare_nums:
* translation where we can have duplicate type/name combinations).
*/
if (nvlist_lookup_boolean_value(lnvl, "smbentity", &lvb) == 0 &&
nvlist_lookup_boolean_value(rnvl, "smbentity", &rvb) == 0 &&
lvb != rvb)
return (lvb < rvb ? -1 : 1);
nvlist_lookup_boolean_value(rnvl, "smbentity", &rvb) == 0)
return (TREE_CMP(lvb, rvb));
return (0);
}
@ -5497,11 +5491,11 @@ who_perm_compare(const void *larg, const void *rarg)
zfs_deleg_who_type_t rtype = r->who_perm.who_type;
int lweight = who_type2weight(ltype);
int rweight = who_type2weight(rtype);
int res = lweight - rweight;
int res = TREE_CMP(lweight, rweight);
if (res == 0)
res = strncmp(l->who_perm.who_name, r->who_perm.who_name,
ZFS_MAX_DELEG_NAME-1);
return (TREE_ISIGN(res));
res = TREE_ISIGN(strncmp(l->who_perm.who_name,
r->who_perm.who_name, ZFS_MAX_DELEG_NAME-1));
return (res);
}
static int

32
lib/libzdb/libzdb.c
View File

@ -68,35 +68,23 @@ livelist_compare(const void *larg, const void *rarg)
{
const blkptr_t *l = larg;
const blkptr_t *r = rarg;
int cmp = 0;
/* Sort them according to dva[0] */
uint64_t l_dva0_vdev, r_dva0_vdev;
l_dva0_vdev = DVA_GET_VDEV(&l->blk_dva[0]);
r_dva0_vdev = DVA_GET_VDEV(&r->blk_dva[0]);
if (l_dva0_vdev < r_dva0_vdev)
return (-1);
else if (l_dva0_vdev > r_dva0_vdev)
return (+1);
cmp = TREE_CMP(DVA_GET_VDEV(&l->blk_dva[0]),
DVA_GET_VDEV(&r->blk_dva[0]));
if (cmp != 0)
return (cmp);
/* if vdevs are equal, sort by offsets. */
uint64_t l_dva0_offset;
uint64_t r_dva0_offset;
l_dva0_offset = DVA_GET_OFFSET(&l->blk_dva[0]);
r_dva0_offset = DVA_GET_OFFSET(&r->blk_dva[0]);
if (l_dva0_offset < r_dva0_offset) {
return (-1);
} else if (l_dva0_offset > r_dva0_offset) {
return (+1);
}
cmp = TREE_CMP(DVA_GET_OFFSET(&l->blk_dva[0]),
DVA_GET_OFFSET(&r->blk_dva[0]));
if (cmp != 0)
return (cmp);
/*
* Since we're storing blkptrs without cancelling FREE/ALLOC pairs,
* it's possible the offsets are equal. In that case, sort by txg
*/
if (BP_GET_BIRTH(l) < BP_GET_BIRTH(r)) {
return (-1);
} else if (BP_GET_BIRTH(l) > BP_GET_BIRTH(r)) {
return (+1);
}
return (0);
return (TREE_CMP(BP_GET_BIRTH(l), BP_GET_BIRTH(r)));
}

4
module/icp/core/kcf_mech_tabs.c
View File

@ -90,8 +90,8 @@ static int
kcf_mech_hash_compar(const void *lhs, const void *rhs)
{
const kcf_mech_entry_t *l = lhs, *r = rhs;
int cmp = strncmp(l->me_name, r->me_name, CRYPTO_MAX_MECH_NAME);
return ((0 < cmp) - (cmp < 0));
return (TREE_ISIGN(strncmp(l->me_name, r->me_name,
CRYPTO_MAX_MECH_NAME)));
}
void

10
module/os/freebsd/spl/acl_common.c
View File

@ -1213,15 +1213,7 @@ static int
acevals_compare(const void *va, const void *vb)
{
const acevals_t *a = va, *b = vb;
if (a->key == b->key)
return (0);
if (a->key > b->key)
return (1);
else
return (-1);
return (TREE_CMP(a->key, b->key));
}
/*

24
module/os/linux/zfs/zfs_ctldir.c
View File

@ -251,16 +251,7 @@ snapentry_compare_by_name(const void *a, const void *b)
{
const zfs_snapentry_t *se_a = a;
const zfs_snapentry_t *se_b = b;
int ret;
ret = strcmp(se_a->se_name, se_b->se_name);
if (ret < 0)
return (-1);
else if (ret > 0)
return (1);
else
return (0);
return (TREE_ISIGN(strcmp(se_a->se_name, se_b->se_name)));
}
/*
@ -272,15 +263,10 @@ snapentry_compare_by_objsetid(const void *a, const void *b)
const zfs_snapentry_t *se_a = a;
const zfs_snapentry_t *se_b = b;
if (se_a->se_spa != se_b->se_spa)
return ((ulong_t)se_a->se_spa < (ulong_t)se_b->se_spa ? -1 : 1);
if (se_a->se_objsetid < se_b->se_objsetid)
return (-1);
else if (se_a->se_objsetid > se_b->se_objsetid)
return (1);
else
return (0);
int cmp = TREE_PCMP(se_a->se_spa, se_b->se_spa);
if (cmp != 0)
return (cmp);
return (TREE_CMP(se_a->se_objsetid, se_b->se_objsetid));
}
/*

22
module/zfs/dmu_redact.c
View File

@ -176,11 +176,7 @@ objnode_compare(const void *o1, const void *o2)
{
const struct objnode *obj1 = o1;
const struct objnode *obj2 = o2;
if (obj1->obj < obj2->obj)
return (-1);
if (obj1->obj > obj2->obj)
return (1);
return (0);
return (TREE_CMP(obj1->obj, obj2->obj));
}
@ -425,11 +421,11 @@ redact_node_compare_start(const void *arg1, const void *arg2)
if (rr2->eos_marker)
return (-1);
int cmp = redact_range_compare(rr1->start_object, rr1->start_blkid,
rr1->datablksz, rr2->start_object, rr2->start_blkid,
rr2->datablksz);
int cmp = redact_range_compare(
rr1->start_object, rr1->start_blkid, rr1->datablksz,
rr2->start_object, rr2->start_blkid, rr2->datablksz);
if (cmp == 0)
cmp = (rn1->thread_num < rn2->thread_num ? -1 : 1);
cmp = TREE_CMP(rn1->thread_num, rn2->thread_num);
return (cmp);
}
@ -451,11 +447,11 @@ redact_node_compare_end(const void *arg1, const void *arg2)
if (srr2->eos_marker)
return (-1);
int cmp = redact_range_compare(srr1->end_object, srr1->end_blkid,
srr1->datablksz, srr2->end_object, srr2->end_blkid,
srr2->datablksz);
int cmp = redact_range_compare(
srr1->end_object, srr1->end_blkid, srr1->datablksz,
srr2->end_object, srr2->end_blkid, srr2->datablksz);
if (cmp == 0)
cmp = (rn1->thread_num < rn2->thread_num ? -1 : 1);
cmp = TREE_CMP(rn1->thread_num, rn2->thread_num);
return (cmp);
}

3
module/zfs/dsl_bookmark.c
View File

@ -837,8 +837,7 @@ dsl_bookmark_compare(const void *l, const void *r)
(rdbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN));
if (likely(cmp))
return (cmp);
cmp = strcmp(ldbn->dbn_name, rdbn->dbn_name);
return (TREE_ISIGN(cmp));
return (TREE_ISIGN(strcmp(ldbn->dbn_name, rdbn->dbn_name)));
}
/*

21
module/zfs/dsl_crypt.c
View File

@ -259,12 +259,7 @@ spa_crypto_key_compare(const void *a, const void *b)
{
const dsl_crypto_key_t *dcka = a;
const dsl_crypto_key_t *dckb = b;
if (dcka->dck_obj < dckb->dck_obj)
return (-1);
if (dcka->dck_obj > dckb->dck_obj)
return (1);
return (0);
return (TREE_CMP(dcka->dck_obj, dckb->dck_obj));
}
/*
@ -306,12 +301,7 @@ spa_key_mapping_compare(const void *a, const void *b)
{
const dsl_key_mapping_t *kma = a;
const dsl_key_mapping_t *kmb = b;
if (kma->km_dsobj < kmb->km_dsobj)
return (-1);
if (kma->km_dsobj > kmb->km_dsobj)
return (1);
return (0);
return (TREE_CMP(kma->km_dsobj, kmb->km_dsobj));
}
static int
@ -319,12 +309,7 @@ spa_wkey_compare(const void *a, const void *b)
{
const dsl_wrapping_key_t *wka = a;
const dsl_wrapping_key_t *wkb = b;
if (wka->wk_ddobj < wkb->wk_ddobj)
return (-1);
if (wka->wk_ddobj > wkb->wk_ddobj)
return (1);
return (0);
return (TREE_CMP(wka->wk_ddobj, wkb->wk_ddobj));
}
void

14
module/zfs/dsl_deadlist.c
View File

@ -1001,16 +1001,14 @@ livelist_compare(const void *larg, const void *rarg)
const blkptr_t *r = &((livelist_entry_t *)rarg)->le_bp;
/* Sort them according to dva[0] */
uint64_t l_dva0_vdev = DVA_GET_VDEV(&l->blk_dva[0]);
uint64_t r_dva0_vdev = DVA_GET_VDEV(&r->blk_dva[0]);
if (l_dva0_vdev != r_dva0_vdev)
return (TREE_CMP(l_dva0_vdev, r_dva0_vdev));
int cmp = TREE_CMP(DVA_GET_VDEV(&l->blk_dva[0]),
DVA_GET_VDEV(&r->blk_dva[0]));
if (cmp != 0)
return (cmp);
/* if vdevs are equal, sort by offsets. */
uint64_t l_dva0_offset = DVA_GET_OFFSET(&l->blk_dva[0]);
uint64_t r_dva0_offset = DVA_GET_OFFSET(&r->blk_dva[0]);
return (TREE_CMP(l_dva0_offset, r_dva0_offset));
return (TREE_CMP(DVA_GET_OFFSET(&l->blk_dva[0]),
DVA_GET_OFFSET(&r->blk_dva[0])));
}
struct livelist_iter_arg {

6
module/zfs/dsl_deleg.c
View File

@ -395,11 +395,7 @@ perm_set_compare(const void *arg1, const void *arg2)
{
const perm_set_t *node1 = (const perm_set_t *)arg1;
const perm_set_t *node2 = (const perm_set_t *)arg2;
int val;
val = strcmp(node1->p_setname, node2->p_setname);
return (TREE_ISIGN(val));
return (TREE_ISIGN(strcmp(node1->p_setname, node2->p_setname)));
}
/*

7
module/zfs/dsl_scan.c
View File

@ -1473,12 +1473,7 @@ static int
scan_ds_queue_compare(const void *a, const void *b)
{
const scan_ds_t *sds_a = a, *sds_b = b;
if (sds_a->sds_dsobj < sds_b->sds_dsobj)
return (-1);
if (sds_a->sds_dsobj == sds_b->sds_dsobj)
return (0);
return (1);
return (TREE_CMP(sds_a->sds_dsobj, sds_b->sds_dsobj));
}
static void

10
module/zfs/refcount.c
View File

@ -57,10 +57,12 @@ zfs_refcount_compare(const void *x1, const void *x2)
const reference_t *r1 = (const reference_t *)x1;
const reference_t *r2 = (const reference_t *)x2;
int cmp1 = TREE_CMP(r1->ref_holder, r2->ref_holder);
int cmp2 = TREE_CMP(r1->ref_number, r2->ref_number);
int cmp = cmp1 ? cmp1 : cmp2;
return ((cmp || r1->ref_search) ? cmp : TREE_PCMP(r1, r2));
int cmp = TREE_CMP(r1->ref_holder, r2->ref_holder);
if (cmp == 0)
cmp = TREE_CMP(r1->ref_number, r2->ref_number);
if (cmp | r1->ref_search)
return (cmp);
return (TREE_PCMP(r1, r2));
}
void

5
module/zfs/spa_misc.c
View File

@ -2616,11 +2616,8 @@ spa_name_compare(const void *a1, const void *a2)
{
const spa_t *s1 = a1;
const spa_t *s2 = a2;
int s;
s = strcmp(s1->spa_name, s2->spa_name);
return (TREE_ISIGN(s));
return (TREE_ISIGN(strcmp(s1->spa_name, s2->spa_name)));
}
void

6
module/zfs/vdev_queue.c
View File

@ -226,10 +226,10 @@ vdev_queue_to_compare(const void *x1, const void *x2)
const zio_t *z1 = (const zio_t *)x1;
const zio_t *z2 = (const zio_t *)x2;
int tcmp = TREE_CMP(z1->io_timestamp >> VDQ_T_SHIFT,
int cmp = TREE_CMP(z1->io_timestamp >> VDQ_T_SHIFT,
z2->io_timestamp >> VDQ_T_SHIFT);
int ocmp = TREE_CMP(z1->io_offset, z2->io_offset);
int cmp = tcmp ? tcmp : ocmp;
if (cmp == 0)
cmp = TREE_CMP(z1->io_offset, z2->io_offset);
if (likely(cmp | (z1->io_queue_state == ZIO_QS_NONE)))
return (cmp);

7
module/zfs/zfs_fuid.c
View File

@ -84,11 +84,8 @@ domain_compare(const void *arg1, const void *arg2)
{
const fuid_domain_t *node1 = (const fuid_domain_t *)arg1;
const fuid_domain_t *node2 = (const fuid_domain_t *)arg2;
int val;
val = strcmp(node1->f_ksid->kd_name, node2->f_ksid->kd_name);
return (TREE_ISIGN(val));
return (TREE_ISIGN(strcmp(node1->f_ksid->kd_name,
node2->f_ksid->kd_name)));
}
void

37
module/zfs/zio.c
View File

@ -910,33 +910,26 @@ zio_bookmark_compare(const void *x1, const void *x2)
{
const zio_t *z1 = x1;
const zio_t *z2 = x2;
const zbookmark_phys_t *zb1 = &z1->io_bookmark;
const zbookmark_phys_t *zb2 = &z2->io_bookmark;
if (z1->io_bookmark.zb_objset < z2->io_bookmark.zb_objset)
return (-1);
if (z1->io_bookmark.zb_objset > z2->io_bookmark.zb_objset)
return (1);
int cmp = TREE_CMP(zb1->zb_objset, zb2->zb_objset);
if (cmp != 0)
return (cmp);
if (z1->io_bookmark.zb_object < z2->io_bookmark.zb_object)
return (-1);
if (z1->io_bookmark.zb_object > z2->io_bookmark.zb_object)
return (1);
cmp = TREE_CMP(zb1->zb_object, zb2->zb_object);
if (cmp != 0)
return (cmp);
if (z1->io_bookmark.zb_level < z2->io_bookmark.zb_level)
return (-1);
if (z1->io_bookmark.zb_level > z2->io_bookmark.zb_level)
return (1);
cmp = TREE_CMP(zb1->zb_level, zb2->zb_level);
if (cmp != 0)
return (cmp);
if (z1->io_bookmark.zb_blkid < z2->io_bookmark.zb_blkid)
return (-1);
if (z1->io_bookmark.zb_blkid > z2->io_bookmark.zb_blkid)
return (1);
cmp = TREE_CMP(zb1->zb_blkid, zb2->zb_blkid);
if (cmp != 0)
return (cmp);
if (z1 < z2)
return (-1);
if (z1 > z2)
return (1);
return (0);
return (TREE_PCMP(z1, z2));
}
/*