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);
