On 05/08/22(Fri) 18:10, Sebastien Marie wrote: > Hi, > > When initially ported blist from DragonFlyBSD, we used custom type bsblk_t > and > bsbmp_t instead of the one used by DragonFlyBSD (swblk_t and u_swblk_t). > > The reason was swblk_t is already defined on OpenBSD, and was incompatible > with > blist (int32_t). It is defined, but not used (outside some regress file which > seems to be not affected by type change). > > This diff changes the __swblk_t definition in sys/_types.h to be 'unsigned > long', and switch back blist to use swblk_t (and u_swblk_t, even if it isn't > 'unsigned swblk_t'). > > It makes the diff with DragonFlyBSD more thin. I added a comment with the git > id > used for the initial port. > > I tested it on i386 and amd64 (kernel and userland). > > By changing bitmap type from 'u_long' to 'u_swblk_t' ('u_int64_t'), it makes > the > regress the same on 64 and 32bits archs (and it success on both). > > Comments or OK ?
Makes sense to me. I'm not a standard/type lawyer so I don't know if this is fine for userland. So I'm ok with it. > diff /home/semarie/repos/openbsd/src > commit - 73f52ef7130cefbe5a8fe028eedaad0e54be7303 > path + /home/semarie/repos/openbsd/src > blob - e05867429cdd81c434f9ca589c1fb8c6d25957f8 > file + sys/sys/_types.h > --- sys/sys/_types.h > +++ sys/sys/_types.h > @@ -60,7 +60,7 @@ typedef __uint8_t __sa_family_t; /* sockaddr > address f > typedef __int32_t __segsz_t; /* segment size */ > typedef __uint32_t __socklen_t; /* length type for network > syscalls */ > typedef long __suseconds_t; /* microseconds (signed) */ > -typedef __int32_t __swblk_t; /* swap offset */ > +typedef unsigned long __swblk_t; /* swap offset */ > typedef __int64_t __time_t; /* epoch time */ > typedef __int32_t __timer_t; /* POSIX timer identifiers */ > typedef __uint32_t __uid_t; /* user id */ > blob - 102ca95dd45ba6d9cab0f3fcbb033d6043ec1606 > file + sys/sys/blist.h > --- sys/sys/blist.h > +++ sys/sys/blist.h > @@ -1,4 +1,5 @@ > /* $OpenBSD: blist.h,v 1.1 2022/07/29 17:47:12 semarie Exp $ */ > +/* DragonFlyBSD:7b80531f545c7d3c51c1660130c71d01f6bccbe0:/sys/sys/blist.h */ > /* > * Copyright (c) 2003,2004 The DragonFly Project. All rights reserved. > * > @@ -65,15 +66,13 @@ > #include <sys/types.h> > #endif > > -#define SWBLK_BITS 64 > -typedef u_long bsbmp_t; > -typedef u_long bsblk_t; > +typedef u_int64_t u_swblk_t; > > /* > * note: currently use SWAPBLK_NONE as an absolute value rather then > * a flag bit. > */ > -#define SWAPBLK_NONE ((bsblk_t)-1) > +#define SWAPBLK_NONE ((swblk_t)-1) > > /* > * blmeta and bl_bitmap_t MUST be a power of 2 in size. > @@ -81,39 +80,39 @@ typedef u_long bsblk_t; > > typedef struct blmeta { > union { > - bsblk_t bmu_avail; /* space available under us */ > - bsbmp_t bmu_bitmap; /* bitmap if we are a leaf */ > + swblk_t bmu_avail; /* space available under us */ > + u_swblk_t bmu_bitmap; /* bitmap if we are a leaf */ > } u; > - bsblk_t bm_bighint; /* biggest contiguous block hint*/ > + swblk_t bm_bighint; /* biggest contiguous block hint*/ > } blmeta_t; > > typedef struct blist { > - bsblk_t bl_blocks; /* area of coverage */ > + swblk_t bl_blocks; /* area of coverage */ > /* XXX int64_t bl_radix */ > - bsblk_t bl_radix; /* coverage radix */ > - bsblk_t bl_skip; /* starting skip */ > - bsblk_t bl_free; /* number of free blocks */ > + swblk_t bl_radix; /* coverage radix */ > + swblk_t bl_skip; /* starting skip */ > + swblk_t bl_free; /* number of free blocks */ > blmeta_t *bl_root; /* root of radix tree */ > - bsblk_t bl_rootblks; /* bsblk_t blks allocated for tree */ > + swblk_t bl_rootblks; /* swblk_t blks allocated for tree */ > } *blist_t; > > -#define BLIST_META_RADIX (sizeof(bsbmp_t)*8/2) /* 2 bits per */ > -#define BLIST_BMAP_RADIX (sizeof(bsbmp_t)*8) /* 1 bit per */ > +#define BLIST_META_RADIX (sizeof(u_swblk_t)*8/2) /* 2 bits per */ > +#define BLIST_BMAP_RADIX (sizeof(u_swblk_t)*8) /* 1 bit per */ > > /* > * The radix may exceed the size of a 64 bit signed (or unsigned) int > - * when the maximal number of blocks is allocated. With a 32-bit bsblk_t > + * when the maximal number of blocks is allocated. With a 32-bit swblk_t > * this corresponds to ~1G x PAGE_SIZE = 4096GB. The swap code usually > * divides this by 4, leaving us with a capability of up to four 1TB swap > * devices. > * > - * With a 64-bit bsblk_t the limitation is some insane number. > + * With a 64-bit swblk_t the limitation is some insane number. > * > * NOTE: For now I don't trust that we overflow-detect properly so we divide > * out to ensure that no overflow occurs. > */ > > -#if SWBLK_BITS == 64 > +#if defined(_LP64) > #define BLIST_MAXBLKS (0x4000000000000000LL / \ > (BLIST_BMAP_RADIX / BLIST_META_RADIX)) > #else > @@ -123,14 +122,14 @@ typedef struct blist { > > #define BLIST_MAX_ALLOC BLIST_BMAP_RADIX > > -blist_t blist_create(bsblk_t); > +blist_t blist_create(swblk_t); > void blist_destroy(blist_t); > -bsblk_t blist_alloc(blist_t, bsblk_t); > -bsblk_t blist_allocat(blist_t, bsblk_t, bsblk_t); > -void blist_free(blist_t, bsblk_t, bsblk_t); > -bsblk_t blist_fill(blist_t, bsblk_t, bsblk_t); > +swblk_t blist_alloc(blist_t, swblk_t); > +swblk_t blist_allocat(blist_t, swblk_t, swblk_t); > +void blist_free(blist_t, swblk_t, swblk_t); > +swblk_t blist_fill(blist_t, swblk_t, swblk_t); > void blist_print(blist_t); > -void blist_resize(blist_t *, bsblk_t, int); > -void blist_gapfind(blist_t, bsblk_t *, bsblk_t *); > +void blist_resize(blist_t *, swblk_t, int); > +void blist_gapfind(blist_t, swblk_t *, swblk_t *); > > #endif /* _SYS_BLIST_H_ */ > blob - 4cf6259417df583dadc5d63e7bb1753628eb8b50 > file + sys/kern/subr_blist.c > --- sys/kern/subr_blist.c > +++ sys/kern/subr_blist.c > @@ -1,4 +1,5 @@ > /* $OpenBSD: subr_blist.c,v 1.1 2022/07/29 17:47:12 semarie Exp $ */ > +/* > DragonFlyBSD:7b80531f545c7d3c51c1660130c71d01f6bccbe0:/sys/kern/subr_blist.c > */ > /* > * BLIST.C - Bitmap allocator/deallocator, using a radix tree with hinting > * > @@ -133,29 +134,29 @@ > * static support functions > */ > > -static bsblk_t blst_leaf_alloc(blmeta_t *scan, bsblk_t blkat, > - bsblk_t blk, bsblk_t count); > -static bsblk_t blst_meta_alloc(blmeta_t *scan, bsblk_t blkat, > - bsblk_t blk, bsblk_t count, > - bsblk_t radix, bsblk_t skip); > -static void blst_leaf_free(blmeta_t *scan, bsblk_t relblk, bsblk_t count); > -static void blst_meta_free(blmeta_t *scan, bsblk_t freeBlk, bsblk_t count, > - bsblk_t radix, bsblk_t skip, > - bsblk_t blk); > -static bsblk_t blst_leaf_fill(blmeta_t *scan, bsblk_t blk, bsblk_t count); > -static bsblk_t blst_meta_fill(blmeta_t *scan, bsblk_t fillBlk, bsblk_t count, > - bsblk_t radix, bsblk_t skip, > - bsblk_t blk); > -static void blst_copy(blmeta_t *scan, bsblk_t blk, bsblk_t radix, > - bsblk_t skip, blist_t dest, bsblk_t count); > -static bsblk_t blst_radix_init(blmeta_t *scan, bsblk_t radix, > - bsblk_t skip, bsblk_t count); > -static int blst_radix_gapfind(blmeta_t *scan, bsblk_t blk, bsblk_t radix, > bsblk_t skip, > - int state, bsblk_t *maxbp, bsblk_t *maxep, bsblk_t *bp, bsblk_t *ep); > +static swblk_t blst_leaf_alloc(blmeta_t *scan, swblk_t blkat, > + swblk_t blk, swblk_t count); > +static swblk_t blst_meta_alloc(blmeta_t *scan, swblk_t blkat, > + swblk_t blk, swblk_t count, > + swblk_t radix, swblk_t skip); > +static void blst_leaf_free(blmeta_t *scan, swblk_t relblk, swblk_t count); > +static void blst_meta_free(blmeta_t *scan, swblk_t freeBlk, swblk_t count, > + swblk_t radix, swblk_t skip, > + swblk_t blk); > +static swblk_t blst_leaf_fill(blmeta_t *scan, swblk_t blk, swblk_t count); > +static swblk_t blst_meta_fill(blmeta_t *scan, swblk_t fillBlk, swblk_t count, > + swblk_t radix, swblk_t skip, > + swblk_t blk); > +static void blst_copy(blmeta_t *scan, swblk_t blk, swblk_t radix, > + swblk_t skip, blist_t dest, swblk_t count); > +static swblk_t blst_radix_init(blmeta_t *scan, swblk_t radix, > + swblk_t skip, swblk_t count); > +static int blst_radix_gapfind(blmeta_t *scan, swblk_t blk, swblk_t radix, > swblk_t skip, > + int state, swblk_t *maxbp, swblk_t *maxep, swblk_t *bp, swblk_t *ep); > > #if defined(BLIST_DEBUG) || defined(DDB) > -static void blst_radix_print(blmeta_t *scan, bsblk_t blk, > - bsblk_t radix, bsblk_t skip, int tab); > +static void blst_radix_print(blmeta_t *scan, swblk_t blk, > + swblk_t radix, swblk_t skip, int tab); > #endif > > /* > @@ -171,18 +172,18 @@ static void blst_radix_print(blmeta_t *scan, > bsblk_t b > */ > > blist_t > -blist_create(bsblk_t blocks) > +blist_create(swblk_t blocks) > { > blist_t bl; > - bsblk_t radix; > - bsblk_t skip = 0; > + swblk_t radix; > + swblk_t skip = 0; > > KASSERT(blocks > 0); > > /* > * Calculate radix and skip field used for scanning. > * > - * Radix can exceed BLIST_BMAP_RADIX bits even if bsblk_t is limited > + * Radix can exceed BLIST_BMAP_RADIX bits even if swblk_t is limited > * to BLIST_BMAP_RADIX bits. > * > * XXX check overflow > @@ -236,10 +237,10 @@ blist_destroy(blist_t bl) > * not be allocated. > */ > > -bsblk_t > -blist_alloc(blist_t bl, bsblk_t count) > +swblk_t > +blist_alloc(blist_t bl, swblk_t count) > { > - bsblk_t blk = SWAPBLK_NONE; > + swblk_t blk = SWAPBLK_NONE; > > if (bl) { > if (bl->bl_radix == BLIST_BMAP_RADIX) > @@ -253,10 +254,10 @@ blist_alloc(blist_t bl, bsblk_t count) > return(blk); > } > > -bsblk_t > -blist_allocat(blist_t bl, bsblk_t count, bsblk_t blkat) > +swblk_t > +blist_allocat(blist_t bl, swblk_t count, swblk_t blkat) > { > - bsblk_t blk = SWAPBLK_NONE; > + swblk_t blk = SWAPBLK_NONE; > > if (bl) { > KASSERT(blkat < bl->bl_blocks); > @@ -280,7 +281,7 @@ blist_allocat(blist_t bl, bsblk_t count, bsblk_t blkat > */ > > void > -blist_free(blist_t bl, bsblk_t blkno, bsblk_t count) > +blist_free(blist_t bl, swblk_t blkno, swblk_t count) > { > if (bl) { > KASSERT(blkno < bl->bl_blocks); > @@ -301,10 +302,10 @@ blist_free(blist_t bl, bsblk_t blkno, bsblk_t count) > * actually filled that were free before the call. > */ > > -bsblk_t > -blist_fill(blist_t bl, bsblk_t blkno, bsblk_t count) > +swblk_t > +blist_fill(blist_t bl, swblk_t blkno, swblk_t count) > { > - bsblk_t filled; > + swblk_t filled; > > if (bl) { > KASSERT(blkno < bl->bl_blocks); > @@ -332,7 +333,7 @@ blist_fill(blist_t bl, bsblk_t blkno, bsblk_t count) > */ > > void > -blist_resize(blist_t *pbl, bsblk_t count, int freenew) > +blist_resize(blist_t *pbl, swblk_t count, int freenew) > { > blist_t newbl = blist_create(count); > blist_t save = *pbl; > @@ -362,10 +363,10 @@ blist_resize(blist_t *pbl, bsblk_t count, int freenew) > */ > > void > -blist_gapfind(blist_t bl, bsblk_t *maxbp, bsblk_t *maxep) > +blist_gapfind(blist_t bl, swblk_t *maxbp, swblk_t *maxep) > { > int state; > - bsblk_t b, e; > + swblk_t b, e; > > /* initialize gaps (max and current) */ > *maxbp = *maxep = 0; > @@ -398,16 +399,16 @@ blist_gapfind(blist_t bl, bsblk_t *maxbp, bsblk_t *max > * - max is the larger free gap > */ > static int > -blst_radix_gapfind(blmeta_t *scan, bsblk_t blk, bsblk_t radix, bsblk_t skip, > - int state, bsblk_t *maxbp, bsblk_t *maxep, bsblk_t *bp, bsblk_t *ep) > +blst_radix_gapfind(blmeta_t *scan, swblk_t blk, swblk_t radix, swblk_t skip, > + int state, swblk_t *maxbp, swblk_t *maxep, swblk_t *bp, swblk_t *ep) > { > - bsblk_t i; > - bsblk_t next_skip; > + swblk_t i; > + swblk_t next_skip; > > if (radix == BLIST_BMAP_RADIX) { > /* leaf node: we considere only completely free bitmap as free > */ > if (state == GAPFIND_FIRSTFREE) { > - if (scan->u.bmu_bitmap == (bsbmp_t)-1) { > + if (scan->u.bmu_bitmap == (u_swblk_t)-1) { > /* node is fully free */ > *bp = blk; > return GAPFIND_FIRSTUSED; > @@ -417,7 +418,7 @@ blst_radix_gapfind(blmeta_t *scan, bsblk_t blk, bsblk_ > return state; > > } else if (state == GAPFIND_FIRSTUSED) { > - if (scan->u.bmu_bitmap == (bsbmp_t)-1) { > + if (scan->u.bmu_bitmap == (u_swblk_t)-1) { > /* it is free, not found, keep state */ > return state; > } > @@ -466,7 +467,7 @@ blst_radix_gapfind(blmeta_t *scan, bsblk_t blk, bsblk_ > next_skip = (skip / BLIST_META_RADIX); > > for (i = 1; i <= skip; i += next_skip) { > - if (scan[i].bm_bighint == (bsblk_t)-1) > + if (scan[i].bm_bighint == (swblk_t)-1) > /* Terminator */ > break; > > @@ -514,11 +515,11 @@ blist_print(blist_t bl) > * quick. > */ > > -static bsblk_t > -blst_leaf_alloc(blmeta_t *scan, bsblk_t blkat __unused, bsblk_t blk, > - bsblk_t count) > +static swblk_t > +blst_leaf_alloc(blmeta_t *scan, swblk_t blkat __unused, swblk_t blk, > + swblk_t count) > { > - bsbmp_t orig = scan->u.bmu_bitmap; > + u_swblk_t orig = scan->u.bmu_bitmap; > > if (orig == 0) { > /* > @@ -533,11 +534,11 @@ blst_leaf_alloc(blmeta_t *scan, bsblk_t blkat __unused > /* > * Optimized code to allocate one bit out of the bitmap > */ > - bsbmp_t mask; > + u_swblk_t mask; > int j = BLIST_BMAP_RADIX/2; > int r = 0; > > - mask = (bsbmp_t)-1 >> (BLIST_BMAP_RADIX/2); > + mask = (u_swblk_t)-1 >> (BLIST_BMAP_RADIX/2); > > while (j) { > if ((orig & mask) == 0) { > @@ -547,7 +548,7 @@ blst_leaf_alloc(blmeta_t *scan, bsblk_t blkat __unused > j >>= 1; > mask >>= j; > } > - scan->u.bmu_bitmap &= ~((bsbmp_t)1 << r); > + scan->u.bmu_bitmap &= ~((u_swblk_t)1 << r); > return(blk + r); > } > if (count <= BLIST_BMAP_RADIX) { > @@ -560,9 +561,9 @@ blst_leaf_alloc(blmeta_t *scan, bsblk_t blkat __unused > */ > int j; > int n = (int)(BLIST_BMAP_RADIX - count); > - bsbmp_t mask; > + u_swblk_t mask; > > - mask = (bsbmp_t)-1 >> n; > + mask = (u_swblk_t)-1 >> n; > > for (j = 0; j <= n; ++j) { > if ((orig & mask) == mask) { > @@ -589,14 +590,14 @@ blst_leaf_alloc(blmeta_t *scan, bsblk_t blkat __unused > * calls that hit this node. We have to check for our collapse cases > * and we have a few optimizations strewn in as well. > */ > -static bsblk_t > -blst_meta_alloc(blmeta_t *scan, bsblk_t blkat, > - bsblk_t blk, bsblk_t count, > - bsblk_t radix, bsblk_t skip) > +static swblk_t > +blst_meta_alloc(blmeta_t *scan, swblk_t blkat, > + swblk_t blk, swblk_t count, > + swblk_t radix, swblk_t skip) > { > int hintok = (blk >= blkat); > - bsblk_t next_skip = ((bsblk_t)skip / BLIST_META_RADIX); > - bsblk_t i; > + swblk_t next_skip = ((swblk_t)skip / BLIST_META_RADIX); > + swblk_t i; > > #ifndef _KERNEL > printf("blist_meta_alloc blkat %lu blk %lu count %lu radix %lu\n", > @@ -622,14 +623,14 @@ blst_meta_alloc(blmeta_t *scan, bsblk_t blkat, > > radix /= BLIST_META_RADIX; > for (i = 1; i <= skip; i += next_skip) { > - if (scan[i].bm_bighint == (bsblk_t)-1) > + if (scan[i].bm_bighint == (swblk_t)-1) > break; > if (next_skip == 1) { > - scan[i].u.bmu_bitmap = (bsbmp_t)-1; > + scan[i].u.bmu_bitmap = (u_swblk_t)-1; > scan[i].bm_bighint = BLIST_BMAP_RADIX; > } else { > - scan[i].bm_bighint = (bsblk_t)radix; > - scan[i].u.bmu_avail = (bsblk_t)radix; > + scan[i].bm_bighint = (swblk_t)radix; > + scan[i].u.bmu_avail = (swblk_t)radix; > } > } > } else { > @@ -638,11 +639,11 @@ blst_meta_alloc(blmeta_t *scan, bsblk_t blkat, > > for (i = 1; i <= skip; i += next_skip) { > if (count <= scan[i].bm_bighint && > - blk + (bsblk_t)radix > blkat) { > + blk + (swblk_t)radix > blkat) { > /* > * count fits in object > */ > - bsblk_t r; > + swblk_t r; > if (next_skip == 1) { > r = blst_leaf_alloc(&scan[i], blkat, > blk, count); > @@ -658,12 +659,12 @@ blst_meta_alloc(blmeta_t *scan, bsblk_t blkat, > return(r); > } > /* bighint was updated by recursion */ > - } else if (scan[i].bm_bighint == (bsblk_t)-1) { > + } else if (scan[i].bm_bighint == (swblk_t)-1) { > /* > * Terminator > */ > break; > - } else if (count > (bsblk_t)radix) { > + } else if (count > (swblk_t)radix) { > /* > * count does not fit in object even if it were > * complete free. > @@ -671,7 +672,7 @@ blst_meta_alloc(blmeta_t *scan, bsblk_t blkat, > panic("%s: allocation too large %lu/%lu", > __func__, count, radix); > } > - blk += (bsblk_t)radix; > + blk += (swblk_t)radix; > } > > /* > @@ -686,7 +687,7 @@ blst_meta_alloc(blmeta_t *scan, bsblk_t blkat, > * BLST_LEAF_FREE() - free allocated block from leaf bitmap > */ > static void > -blst_leaf_free(blmeta_t *scan, bsblk_t blk, bsblk_t count) > +blst_leaf_free(blmeta_t *scan, swblk_t blk, swblk_t count) > { > /* > * free some data in this bitmap > @@ -697,10 +698,10 @@ blst_leaf_free(blmeta_t *scan, bsblk_t blk, bsblk_t co > * v n > */ > int n = blk & (BLIST_BMAP_RADIX - 1); > - bsbmp_t mask; > + u_swblk_t mask; > > - mask = ((bsbmp_t)-1 << n) & > - ((bsbmp_t)-1 >> (BLIST_BMAP_RADIX - count - n)); > + mask = ((u_swblk_t)-1 << n) & > + ((u_swblk_t)-1 >> (BLIST_BMAP_RADIX - count - n)); > > if (scan->u.bmu_bitmap & mask) > panic("%s: freeing free block", __func__); > @@ -727,11 +728,11 @@ blst_leaf_free(blmeta_t *scan, bsblk_t blk, bsblk_t co > */ > > static void > -blst_meta_free(blmeta_t *scan, bsblk_t freeBlk, bsblk_t count, > - bsblk_t radix, bsblk_t skip, bsblk_t blk) > +blst_meta_free(blmeta_t *scan, swblk_t freeBlk, swblk_t count, > + swblk_t radix, swblk_t skip, swblk_t blk) > { > - bsblk_t i; > - bsblk_t next_skip = ((bsblk_t)skip / BLIST_META_RADIX); > + swblk_t i; > + swblk_t next_skip = ((swblk_t)skip / BLIST_META_RADIX); > > #if 0 > printf("FREE (%04lx,%lu) FROM (%04lx,%lu)\n", > @@ -751,7 +752,7 @@ blst_meta_free(blmeta_t *scan, bsblk_t freeBlk, bsblk_ > > if (count != radix) { > for (i = 1; i <= skip; i += next_skip) { > - if (scan[i].bm_bighint == (bsblk_t)-1) > + if (scan[i].bm_bighint == (swblk_t)-1) > break; > scan[i].bm_bighint = 0; > if (next_skip == 1) { > @@ -788,18 +789,18 @@ blst_meta_free(blmeta_t *scan, bsblk_t freeBlk, bsblk_ > > radix /= BLIST_META_RADIX; > > - i = (freeBlk - blk) / (bsblk_t)radix; > - blk += i * (bsblk_t)radix; > + i = (freeBlk - blk) / (swblk_t)radix; > + blk += i * (swblk_t)radix; > i = i * next_skip + 1; > > while (i <= skip && blk < freeBlk + count) { > - bsblk_t v; > + swblk_t v; > > - v = blk + (bsblk_t)radix - freeBlk; > + v = blk + (swblk_t)radix - freeBlk; > if (v > count) > v = count; > > - if (scan->bm_bighint == (bsblk_t)-1) > + if (scan->bm_bighint == (swblk_t)-1) > panic("%s: freeing unexpected range", __func__); > > if (next_skip == 1) { > @@ -822,7 +823,7 @@ blst_meta_free(blmeta_t *scan, bsblk_t freeBlk, bsblk_ > } > count -= v; > freeBlk += v; > - blk += (bsblk_t)radix; > + blk += (swblk_t)radix; > i += next_skip; > } > } > @@ -834,15 +835,15 @@ blst_meta_free(blmeta_t *scan, bsblk_t freeBlk, bsblk_ > * any existing allocations in that range. Returns the number > * of blocks allocated by the call. > */ > -static bsblk_t > -blst_leaf_fill(blmeta_t *scan, bsblk_t blk, bsblk_t count) > +static swblk_t > +blst_leaf_fill(blmeta_t *scan, swblk_t blk, swblk_t count) > { > int n = blk & (BLIST_BMAP_RADIX - 1); > - bsblk_t nblks; > - bsbmp_t mask, bitmap; > + swblk_t nblks; > + u_swblk_t mask, bitmap; > > - mask = ((bsbmp_t)-1 << n) & > - ((bsbmp_t)-1 >> (BLIST_BMAP_RADIX - count - n)); > + mask = ((u_swblk_t)-1 << n) & > + ((u_swblk_t)-1 >> (BLIST_BMAP_RADIX - count - n)); > > /* Count the number of blocks we're about to allocate */ > bitmap = scan->u.bmu_bitmap & mask; > @@ -861,13 +862,13 @@ blst_leaf_fill(blmeta_t *scan, bsblk_t blk, bsblk_t co > * be within the extent of this node. Returns the number > * of blocks allocated by the call. > */ > -static bsblk_t > -blst_meta_fill(blmeta_t *scan, bsblk_t fillBlk, bsblk_t count, > - bsblk_t radix, bsblk_t skip, bsblk_t blk) > +static swblk_t > +blst_meta_fill(blmeta_t *scan, swblk_t fillBlk, swblk_t count, > + swblk_t radix, swblk_t skip, swblk_t blk) > { > - bsblk_t i; > - bsblk_t next_skip = ((bsblk_t)skip / BLIST_META_RADIX); > - bsblk_t nblks = 0; > + swblk_t i; > + swblk_t next_skip = ((swblk_t)skip / BLIST_META_RADIX); > + swblk_t nblks = 0; > > if (count == radix || scan->u.bmu_avail == 0) { > /* > @@ -886,35 +887,35 @@ blst_meta_fill(blmeta_t *scan, bsblk_t fillBlk, bsblk_ > * ALL-FREE special case, initialize sublevel > */ > for (i = 1; i <= skip; i += next_skip) { > - if (scan[i].bm_bighint == (bsblk_t)-1) > + if (scan[i].bm_bighint == (swblk_t)-1) > break; > if (next_skip == 1) { > - scan[i].u.bmu_bitmap = (bsbmp_t)-1; > + scan[i].u.bmu_bitmap = (u_swblk_t)-1; > scan[i].bm_bighint = BLIST_BMAP_RADIX; > } else { > - scan[i].bm_bighint = (bsblk_t)radix; > - scan[i].u.bmu_avail = (bsblk_t)radix; > + scan[i].bm_bighint = (swblk_t)radix; > + scan[i].u.bmu_avail = (swblk_t)radix; > } > } > } else { > radix /= BLIST_META_RADIX; > } > > - if (count > (bsblk_t)radix) > + if (count > (swblk_t)radix) > panic("%s: allocation too large", __func__); > > - i = (fillBlk - blk) / (bsblk_t)radix; > - blk += i * (bsblk_t)radix; > + i = (fillBlk - blk) / (swblk_t)radix; > + blk += i * (swblk_t)radix; > i = i * next_skip + 1; > > while (i <= skip && blk < fillBlk + count) { > - bsblk_t v; > + swblk_t v; > > - v = blk + (bsblk_t)radix - fillBlk; > + v = blk + (swblk_t)radix - fillBlk; > if (v > count) > v = count; > > - if (scan->bm_bighint == (bsblk_t)-1) > + if (scan->bm_bighint == (swblk_t)-1) > panic("%s: filling unexpected range", __func__); > > if (next_skip == 1) { > @@ -925,7 +926,7 @@ blst_meta_fill(blmeta_t *scan, bsblk_t fillBlk, bsblk_ > } > count -= v; > fillBlk += v; > - blk += (bsblk_t)radix; > + blk += (swblk_t)radix; > i += next_skip; > } > scan->u.bmu_avail -= nblks; > @@ -940,24 +941,24 @@ blst_meta_fill(blmeta_t *scan, bsblk_t fillBlk, bsblk_ > */ > > static void > -blst_copy(blmeta_t *scan, bsblk_t blk, bsblk_t radix, > - bsblk_t skip, blist_t dest, bsblk_t count) > +blst_copy(blmeta_t *scan, swblk_t blk, swblk_t radix, > + swblk_t skip, blist_t dest, swblk_t count) > { > - bsblk_t next_skip; > - bsblk_t i; > + swblk_t next_skip; > + swblk_t i; > > /* > * Leaf node > */ > > if (radix == BLIST_BMAP_RADIX) { > - bsbmp_t v = scan->u.bmu_bitmap; > + u_swblk_t v = scan->u.bmu_bitmap; > > - if (v == (bsbmp_t)-1) { > + if (v == (u_swblk_t)-1) { > blist_free(dest, blk, count); > } else if (v != 0) { > for (i = 0; i < BLIST_BMAP_RADIX && i < count; ++i) { > - if (v & ((bsblk_t)1 << i)) > + if (v & ((swblk_t)1 << i)) > blist_free(dest, blk + i, 1); > } > } > @@ -981,28 +982,28 @@ blst_copy(blmeta_t *scan, bsblk_t blk, bsblk_t radix, > if (count < radix) > blist_free(dest, blk, count); > else > - blist_free(dest, blk, (bsblk_t)radix); > + blist_free(dest, blk, (swblk_t)radix); > return; > } > > > radix /= BLIST_META_RADIX; > - next_skip = ((bsbmp_t)skip / BLIST_META_RADIX); > + next_skip = ((u_swblk_t)skip / BLIST_META_RADIX); > > for (i = 1; count && i <= skip; i += next_skip) { > - if (scan[i].bm_bighint == (bsblk_t)-1) > + if (scan[i].bm_bighint == (swblk_t)-1) > break; > > - if (count >= (bsblk_t)radix) { > + if (count >= (swblk_t)radix) { > blst_copy( > &scan[i], > blk, > radix, > next_skip - 1, > dest, > - (bsblk_t)radix > + (swblk_t)radix > ); > - count -= (bsblk_t)radix; > + count -= (swblk_t)radix; > } else { > if (count) { > blst_copy( > @@ -1016,7 +1017,7 @@ blst_copy(blmeta_t *scan, bsblk_t blk, bsblk_t radix, > } > count = 0; > } > - blk += (bsblk_t)radix; > + blk += (swblk_t)radix; > } > } > > @@ -1029,12 +1030,12 @@ blst_copy(blmeta_t *scan, bsblk_t blk, bsblk_t radix, > * RADIX values we use. > */ > > -static bsblk_t > -blst_radix_init(blmeta_t *scan, bsblk_t radix, bsblk_t skip, bsblk_t count) > +static swblk_t > +blst_radix_init(blmeta_t *scan, swblk_t radix, swblk_t skip, swblk_t count) > { > - bsblk_t i; > - bsblk_t next_skip; > - bsblk_t memindex = 0; > + swblk_t i; > + swblk_t next_skip; > + swblk_t memindex = 0; > > /* > * Leaf node > @@ -1060,10 +1061,10 @@ blst_radix_init(blmeta_t *scan, bsblk_t radix, bsblk_t > } > > radix /= BLIST_META_RADIX; > - next_skip = ((bsbmp_t)skip / BLIST_META_RADIX); > + next_skip = ((u_swblk_t)skip / BLIST_META_RADIX); > > for (i = 1; i <= skip; i += next_skip) { > - if (count >= (bsblk_t)radix) { > + if (count >= (swblk_t)radix) { > /* > * Allocate the entire object > */ > @@ -1071,9 +1072,9 @@ blst_radix_init(blmeta_t *scan, bsblk_t radix, bsblk_t > ((scan) ? &scan[i] : NULL), > radix, > next_skip - 1, > - (bsblk_t)radix > + (swblk_t)radix > ); > - count -= (bsblk_t)radix; > + count -= (swblk_t)radix; > } else if (count > 0) { > /* > * Allocate a partial object > @@ -1090,7 +1091,7 @@ blst_radix_init(blmeta_t *scan, bsblk_t radix, bsblk_t > * Add terminator and break out > */ > if (scan) > - scan[i].bm_bighint = (bsblk_t)-1; > + scan[i].bm_bighint = (swblk_t)-1; > break; > } > } > @@ -1102,14 +1103,14 @@ blst_radix_init(blmeta_t *scan, bsblk_t radix, bsblk_t > #if defined(BLIST_DEBUG) || defined(DDB) > > static void > -blst_radix_print(blmeta_t *scan, bsblk_t blk, bsblk_t radix, bsblk_t skip, > int tab) > +blst_radix_print(blmeta_t *scan, swblk_t blk, swblk_t radix, swblk_t skip, > int tab) > { > - bsblk_t i; > - bsblk_t next_skip; > + swblk_t i; > + swblk_t next_skip; > > if (radix == BLIST_BMAP_RADIX) { > printf( > - "%*.*s(%04lx,%lu): bitmap %0*lx big=%lu\n", > + "%*.*s(%04lx,%lu): bitmap %0*llx big=%lu\n", > tab, tab, "", > blk, radix, > (int)(1 + (BLIST_BMAP_RADIX - 1) / 4), > @@ -1148,11 +1149,11 @@ blst_radix_print(blmeta_t *scan, bsblk_t blk, bsblk_t > ); > > radix /= BLIST_META_RADIX; > - next_skip = ((bsbmp_t)skip / BLIST_META_RADIX); > + next_skip = ((u_swblk_t)skip / BLIST_META_RADIX); > tab += 4; > > for (i = 1; i <= skip; i += next_skip) { > - if (scan[i].bm_bighint == (bsblk_t)-1) { > + if (scan[i].bm_bighint == (swblk_t)-1) { > printf( > "%*.*s(%04lx,%lu): Terminator\n", > tab, tab, "", > @@ -1167,7 +1168,7 @@ blst_radix_print(blmeta_t *scan, bsblk_t blk, bsblk_t > next_skip - 1, > tab > ); > - blk += (bsblk_t)radix; > + blk += (swblk_t)radix; > } > tab -= 4; > > @@ -1184,11 +1185,11 @@ blst_radix_print(blmeta_t *scan, bsblk_t blk, bsblk_t > int > main(int ac, char **av) > { > - bsblk_t size = 1024; > - bsblk_t i; > + swblk_t size = 1024; > + swblk_t i; > blist_t bl; > > - for (i = 1; i < (bsblk_t)ac; ++i) { > + for (i = 1; i < (swblk_t)ac; ++i) { > const char *ptr = av[i]; > if (*ptr != '-') { > size = strtol(ptr, NULL, 0); > @@ -1203,9 +1204,9 @@ main(int ac, char **av) > > for (;;) { > char buf[1024]; > - bsblk_t da = 0; > - bsblk_t count = 0; > - bsblk_t blkat; > + swblk_t da = 0; > + swblk_t count = 0; > + swblk_t blkat; > > > printf("%lu/%lu/%lu> ", > @@ -1229,10 +1230,10 @@ main(int ac, char **av) > case 'a': > if (sscanf(buf + 1, "%li %li", &count, &blkat) == 1) { > printf("count %lu\n", count); > - bsblk_t blk = blist_alloc(bl, count); > + swblk_t blk = blist_alloc(bl, count); > printf(" R=%04lx\n", blk); > } else if (sscanf(buf + 1, "%li %li", &count, &blkat) > == 2) { > - bsblk_t blk = blist_allocat(bl, count, blkat); > + swblk_t blk = blist_allocat(bl, count, blkat); > printf(" R=%04lx\n", blk); > } else { > printf("?\n"); > @@ -1246,7 +1247,7 @@ main(int ac, char **av) > } > break; > case 'g': { > - bsblk_t b, e; > + swblk_t b, e; > blist_gapfind(bl, &b, &e); > printf("gapfind: begin=%04lx end=%04lx > size=%lu\n", > b, e, e-b);