bitmap_cut(9)

💅 bitmap_cut(9) — the Kernel API Manual, but make it make sense ✨

okay bestie, so we're in the bitmap_cut(9) page of the Kernel API Manual and honestly? this one is lowkey iconic once you see it. it's a little helper that goes ✂️ snip snip on a chunk of bits and then scooches everything leftward to close the gap. no cap, it's giving scissors-emoji energy. 🎀

---

✨ NAME ✨

bitmap_cut — remove bit region from bitmap and right shift remaining bits 🦋

like, literally: you pick a region, you cut it out, and the rest of the bits shift over to the right to fill the hole. periodt. 💜

---

🌸 SYNOPSIS 🌸

void bitmap_cut (unsigned long *dst , const unsigned long *src ,
       unsigned int first , unsigned int cut , unsigned int nbits );

(yes the spaces before those commas are exactly like that, don't come for me, it's literally the API 💀)

---

🫶 ARGUMENTS 🫶

• dst — the destination bitmap, and heads up bestie it might overlap with src 👀 (more on that down below, it's fine, it's fine)
• src — the source bitmap, your original bits, the main character 💖
• first — start bit of region to be removed — this is where the cutting begins ✂️
• cut — number of bits to remove, i.e. how many bits we're yeeting 🌈
• nbits — bitmap size, in bits ⭐

---

👑 DESCRIPTION 👑

so here's the whole vibe, stated precisely so you can trust me: set the n-th bit of dst iff the n-th bit of src is set and n is less than first, or the m-th bit of src is set for any m such that first <= n < nbits, and m = n + cut.

read it twice, it'll click, i promise 🧚 and now the part that actually makes it click — pictures!! 🖼️

in pictures, example for a big-endian 32-bit architecture:

the src bitmap is:

         31                                   63
         |                                    |
         10000000 11000001 11110010 00010101  10000000 11000001 01110010 00010101
                         |  |              |                                    |
                        16  14             0                                   32

if cut is 3, and first is 14, bits 14-16 in src are cut and dst is:

         31                                   63
         |                                    |
         10110000 00011000 00110010 00010101  00010000 00011000 00101110 01000010
                            |              |                                    |
                            14 (bit 17     0                                   32
                                from src)

see how bit 17 from src slid into spot 14? that's the shift-and-carry doing its lil dance 💃 slay.

💀 important vibes: note that dst and src might overlap partially or entirely. not a typo, not a drill — it's literally fine, that's the design.

and how's it built? this is implemented in the obvious way, with a shift and carry step for each moved bit 🔥 optimisation is left as an exercise for the compiler 😌 (the compiler is the one doing homework around here, not us)

---

🔍 SEE ALSO 🔍

go off, bestie, here's the whole friend group 💅:

• Kernel file ./lib/bitmap.c bitmap introduction(9)
• __bitmap_shift_right(9)
• __bitmap_shift_left(9)
• bitmap_find_next_zero_area_off(9)
• bitmap_pos_to_ord(9)
• bitmap_remap(9)
• bitmap_bitremap(9)
• bitmap_onto(9)
• bitmap_fold(9)
• bitmap_from_arr32(9)
• bitmap_to_arr32(9)
• bitmap_from_arr64(9)
• bitmap_to_arr64(9)

---

and that's the whole page, bestie!! 🥳 this legendary lil slice lives in ./lib and was stamped October 2026 — so go forth, cut those bits, shift those bits, and remember: overlap is allowed and you're doing amazing 🫶💖 ✨