BITMAP OVERVIEW(9)

💅 bitmap overview

ok so bestie, this is bitmap overview(9) from the Kernel API Manual — the literal glow-up tour of every bitmap operation in the kernel, and what each one roughly means when your bitmap is a single unsigned long. Think of it as the group chat where all the bit-twiddling girlies get introduced. 🎀

Periodt, here's the whole roster, with the "if the bitmap is one unsigned long" cheat-sheet of what each call actually does to *dst:

Heads up first, because it's giving efficiency queen: the generated code is more efficient when nbits is known at compile-time and at most BITS_PER_LONG. ✨

And yes, the manpage genuinely drops a lone : right before the list — no cap, I'm keeping it because it's iconic in a weird way:

:

bitmap_zero(dst, nbits)                     *dst = 0UL
bitmap_fill(dst, nbits)                     *dst = ~0UL
bitmap_copy(dst, src, nbits)                *dst = *src
bitmap_and(dst, src1, src2, nbits)          *dst = *src1 & *src2
bitmap_or(dst, src1, src2, nbits)           *dst = *src1 | *src2
bitmap_weighted_or(dst, src1, src2, nbits)  *dst = *src1 | *src2. Returns Hamming Weight of dst
bitmap_weighted_xor(dst, src1, src2, nbits) *dst = *src1 ^ *src2. Returns Hamming Weight of dst
bitmap_xor(dst, src1, src2, nbits)          *dst = *src1 ^ *src2
bitmap_andnot(dst, src1, src2, nbits)       *dst = *src1 & ~(*src2)
bitmap_complement(dst, src, nbits)          *dst = ~(*src)
bitmap_equal(src1, src2, nbits)             Are *src1 and *src2 equal?
bitmap_intersects(src1, src2, nbits)        Do *src1 and *src2 overlap?
bitmap_subset(src1, src2, nbits)            Is *src1 a subset of *src2?
bitmap_empty(src, nbits)                    Are all bits zero in *src?
bitmap_full(src, nbits)                     Are all bits set in *src?
bitmap_weight(src, nbits)                   Hamming Weight: number set bits
bitmap_weight_and(src1, src2, nbits)        Hamming Weight of and'ed bitmap
bitmap_weight_andnot(src1, src2, nbits)     Hamming Weight of andnot'ed bitmap
bitmap_weight_from(src, start, end)         Hamming Weight starting from start
bitmap_set(dst, pos, nbits)                 Set specified bit area
bitmap_clear(dst, pos, nbits)               Clear specified bit area
bitmap_find_next_zero_area(buf, len, pos, n, mask)  Find bit free area
bitmap_find_next_zero_area_off(buf, len, pos, n, mask, mask_off)  as above
bitmap_shift_right(dst, src, n, nbits)      *dst = *src >> n
bitmap_shift_left(dst, src, n, nbits)       *dst = *src << n
bitmap_cut(dst, src, first, n, nbits)       Cut n bits from first, copy rest
bitmap_replace(dst, old, new, mask, nbits)  *dst = (*old & ~(*mask)) | (*new & *mask)
bitmap_scatter(dst, src, mask, nbits)       *dst = map(dense, sparse)(src)
bitmap_gather(dst, src, mask, nbits)        *dst = map(sparse, dense)(src)
bitmap_remap(dst, src, old, new, nbits)     *dst = map(old, new)(src)
bitmap_bitremap(oldbit, old, new, nbits)    newbit = map(old, new)(oldbit)
bitmap_onto(dst, orig, relmap, nbits)       *dst = orig relative to relmap
bitmap_fold(dst, orig, sz, nbits)           dst bits = orig bits mod sz
bitmap_parse(buf, buflen, dst, nbits)       Parse bitmap dst from kernel buf
bitmap_parse_user(ubuf, ulen, dst, nbits)   Parse bitmap dst from user buf
bitmap_parselist(buf, dst, nbits)           Parse bitmap dst from kernel buf
bitmap_parselist_user(buf, dst, nbits)      Parse bitmap dst from user buf
bitmap_find_free_region(bitmap, bits, order)  Find and allocate bit region
bitmap_release_region(bitmap, pos, order)   Free specified bit region
bitmap_allocate_region(bitmap, pos, order)  Allocate specified bit region
bitmap_from_arr32(dst, buf, nbits)          Copy nbits from u32[] buf to dst
bitmap_from_arr64(dst, buf, nbits)          Copy nbits from u64[] buf to dst
bitmap_to_arr32(buf, src, nbits)            Copy nbits from buf to u32[] dst
bitmap_to_arr64(buf, src, nbits)            Copy nbits from buf to u64[] dst
bitmap_get_value8(map, start)               Get 8bit value from map at start
bitmap_set_value8(map, value, start)        Set 8bit value to map at start
bitmap_read(map, start, nbits)              Read an nbits-sized value from
                                            map at start
bitmap_write(map, value, start, nbits)      Write an nbits-sized value to
                                            map at start

🚨 the cautionary tale (read this one, fr fr)

Note: bitmap_zero and bitmap_fill operate over the region of unsigned longs — meaning bits behind the bitmap, all the way out to the unsigned long boundary, get zeroed or filled too. 😭 So if you only wanted your little slice touched, consider using bitmap_clear or bitmap_set to make the zeroing or filling explicit, respectively. Your future self will thank you. 🫶

👀 SEE ALSO

Your faves, all linked up — kernel file ./include/linux/bitmap.h, plus:

• bitmap bitops(9)
• declare bitmap(9)
• bitmap_find_next_zero_area(9)
• bitmap_or_equal(9)
• bitmap_weight_from(9)
• bitmap_scatter(9)
• bitmap_gather(9)
• bitmap_release_region(9)
• bitmap_allocate_region(9)
• bitmap_find_free_region(9)
• BITMAP_FROM_U64(9)
• bitmap_from_u64(9)
• bitmap_read(9)
• bitmap_write(9)

✨ that's the whole page, bestie ✨ this masterpiece lives in ./include/linux, dated October 2026, and its official title is of course bitmap overview(9). mwah 💋 go set some bits responsibly 💖🦋