1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _LINUX_BITOPS_H 3 #define _LINUX_BITOPS_H 4 5 #include <asm/types.h> 6 #include <linux/bits.h> 7 #include <linux/typecheck.h> 8 9 #include <uapi/linux/kernel.h> 10 11 #define BITS_TO_LONGS(nr) __KERNEL_DIV_ROUND_UP(nr, BITS_PER_TYPE(long)) 12 #define BITS_TO_U64(nr) __KERNEL_DIV_ROUND_UP(nr, BITS_PER_TYPE(u64)) 13 #define BITS_TO_U32(nr) __KERNEL_DIV_ROUND_UP(nr, BITS_PER_TYPE(u32)) 14 #define BITS_TO_BYTES(nr) __KERNEL_DIV_ROUND_UP(nr, BITS_PER_TYPE(char)) 15 16 #define BYTES_TO_BITS(nb) ((nb) * BITS_PER_BYTE) 17 18 extern unsigned int __sw_hweight8(unsigned int w); 19 extern unsigned int __sw_hweight16(unsigned int w); 20 extern unsigned int __sw_hweight32(unsigned int w); 21 extern unsigned long __sw_hweight64(__u64 w); 22 23 /* 24 * Defined here because those may be needed by architecture-specific static 25 * inlines. 26 */ 27 28 #include <asm-generic/bitops/generic-non-atomic.h> 29 30 /* 31 * Many architecture-specific non-atomic bitops contain inline asm code and due 32 * to that the compiler can't optimize them to compile-time expressions or 33 * constants. In contrary, generic_*() helpers are defined in pure C and 34 * compilers optimize them just well. 35 * Therefore, to make `unsigned long foo = 0; __set_bit(BAR, &foo)` effectively 36 * equal to `unsigned long foo = BIT(BAR)`, pick the generic C alternative when 37 * the arguments can be resolved at compile time. That expression itself is a 38 * constant and doesn't bring any functional changes to the rest of cases. 39 * The casts to `uintptr_t` are needed to mitigate `-Waddress` warnings when 40 * passing a bitmap from .bss or .data (-> `!!addr` is always true). 41 */ 42 #define bitop(op, nr, addr) \ 43 ((__builtin_constant_p(nr) && \ 44 __builtin_constant_p((uintptr_t)(addr) != (uintptr_t)NULL) && \ 45 (uintptr_t)(addr) != (uintptr_t)NULL && \ 46 __builtin_constant_p(*(const unsigned long *)(addr))) ? \ 47 const##op(nr, addr) : op(nr, addr)) 48 49 /* 50 * The following macros are non-atomic versions of their non-underscored 51 * counterparts. 52 */ 53 #define __set_bit(nr, addr) bitop(___set_bit, nr, addr) 54 #define __clear_bit(nr, addr) bitop(___clear_bit, nr, addr) 55 #define __change_bit(nr, addr) bitop(___change_bit, nr, addr) 56 #define __test_and_set_bit(nr, addr) bitop(___test_and_set_bit, nr, addr) 57 #define __test_and_clear_bit(nr, addr) bitop(___test_and_clear_bit, nr, addr) 58 #define __test_and_change_bit(nr, addr) bitop(___test_and_change_bit, nr, addr) 59 60 #define test_bit(nr, addr) bitop(_test_bit, nr, addr) 61 #define test_bit_acquire(nr, addr) bitop(_test_bit_acquire, nr, addr) 62 63 /* 64 * Include this here because some architectures need generic_ffs/fls in 65 * scope 66 */ 67 #include <asm/bitops.h> 68 69 /* Check that the bitops prototypes are sane */ 70 #define __check_bitop_pr(name) \ 71 static_assert(__same_type(arch_##name, generic_##name) && \ 72 __same_type(const_##name, generic_##name) && \ 73 __same_type(_##name, generic_##name)) 74 75 __check_bitop_pr(__set_bit); 76 __check_bitop_pr(__clear_bit); 77 __check_bitop_pr(__change_bit); 78 __check_bitop_pr(__test_and_set_bit); 79 __check_bitop_pr(__test_and_clear_bit); 80 __check_bitop_pr(__test_and_change_bit); 81 __check_bitop_pr(test_bit); 82 __check_bitop_pr(test_bit_acquire); 83 84 #undef __check_bitop_pr 85 86 static inline int get_bitmask_order(unsigned int count) 87 { 88 int order; 89 90 order = fls(count); 91 return order; /* We could be slightly more clever with -1 here... */ 92 } 93 94 static __always_inline unsigned long hweight_long(unsigned long w) 95 { 96 return sizeof(w) == 4 ? hweight32(w) : hweight64((__u64)w); 97 } 98 99 /** 100 * rol64 - rotate a 64-bit value left 101 * @word: value to rotate 102 * @shift: bits to roll 103 */ 104 static inline __u64 rol64(__u64 word, unsigned int shift) 105 { 106 return (word << (shift & 63)) | (word >> ((-shift) & 63)); 107 } 108 109 /** 110 * ror64 - rotate a 64-bit value right 111 * @word: value to rotate 112 * @shift: bits to roll 113 */ 114 static inline __u64 ror64(__u64 word, unsigned int shift) 115 { 116 return (word >> (shift & 63)) | (word << ((-shift) & 63)); 117 } 118 119 /** 120 * rol32 - rotate a 32-bit value left 121 * @word: value to rotate 122 * @shift: bits to roll 123 */ 124 static inline __u32 rol32(__u32 word, unsigned int shift) 125 { 126 return (word << (shift & 31)) | (word >> ((-shift) & 31)); 127 } 128 129 /** 130 * ror32 - rotate a 32-bit value right 131 * @word: value to rotate 132 * @shift: bits to roll 133 */ 134 static inline __u32 ror32(__u32 word, unsigned int shift) 135 { 136 return (word >> (shift & 31)) | (word << ((-shift) & 31)); 137 } 138 139 /** 140 * rol16 - rotate a 16-bit value left 141 * @word: value to rotate 142 * @shift: bits to roll 143 */ 144 static inline __u16 rol16(__u16 word, unsigned int shift) 145 { 146 return (word << (shift & 15)) | (word >> ((-shift) & 15)); 147 } 148 149 /** 150 * ror16 - rotate a 16-bit value right 151 * @word: value to rotate 152 * @shift: bits to roll 153 */ 154 static inline __u16 ror16(__u16 word, unsigned int shift) 155 { 156 return (word >> (shift & 15)) | (word << ((-shift) & 15)); 157 } 158 159 /** 160 * rol8 - rotate an 8-bit value left 161 * @word: value to rotate 162 * @shift: bits to roll 163 */ 164 static inline __u8 rol8(__u8 word, unsigned int shift) 165 { 166 return (word << (shift & 7)) | (word >> ((-shift) & 7)); 167 } 168 169 /** 170 * ror8 - rotate an 8-bit value right 171 * @word: value to rotate 172 * @shift: bits to roll 173 */ 174 static inline __u8 ror8(__u8 word, unsigned int shift) 175 { 176 return (word >> (shift & 7)) | (word << ((-shift) & 7)); 177 } 178 179 /** 180 * sign_extend32 - sign extend a 32-bit value using specified bit as sign-bit 181 * @value: value to sign extend 182 * @index: 0 based bit index (0 <= index < 32) to sign bit 183 * 184 * This is safe to use for 16- and 8-bit types as well. 185 * 186 * Return: 32-bit sign extended value 187 */ 188 static __always_inline __s32 sign_extend32(__u32 value, int index) 189 { 190 __u8 shift = 31 - index; 191 return (__s32)(value << shift) >> shift; 192 } 193 194 /** 195 * sign_extend64 - sign extend a 64-bit value using specified bit as sign-bit 196 * @value: value to sign extend 197 * @index: 0 based bit index (0 <= index < 64) to sign bit 198 * 199 * This is safe to use for 32-, 16- and 8-bit types as well. 200 * 201 * Return: 64-bit sign extended value 202 */ 203 static __always_inline __s64 sign_extend64(__u64 value, int index) 204 { 205 __u8 shift = 63 - index; 206 return (__s64)(value << shift) >> shift; 207 } 208 209 static inline unsigned int fls_long(unsigned long l) 210 { 211 if (sizeof(l) == 4) 212 return fls(l); 213 return fls64(l); 214 } 215 216 static inline int get_count_order(unsigned int count) 217 { 218 if (count == 0) 219 return -1; 220 221 return fls(--count); 222 } 223 224 /** 225 * get_count_order_long - get order after rounding @l up to power of 2 226 * @l: parameter 227 * 228 * it is same as get_count_order() but with long type parameter 229 */ 230 static inline int get_count_order_long(unsigned long l) 231 { 232 if (l == 0UL) 233 return -1; 234 return (int)fls_long(--l); 235 } 236 237 /** 238 * parity8 - get the parity of an u8 value 239 * @val: the value to be examined 240 * 241 * Determine the parity of the u8 argument. 242 * 243 * Returns: 244 * 0 for even parity, 1 for odd parity 245 * 246 * Note: This function informs you about the current parity. Example to bail 247 * out when parity is odd: 248 * 249 * if (parity8(val) == 1) 250 * return -EBADMSG; 251 * 252 * If you need to calculate a parity bit, you need to draw the conclusion from 253 * this result yourself. Example to enforce odd parity, parity bit is bit 7: 254 * 255 * if (parity8(val) == 0) 256 * val ^= BIT(7); 257 */ 258 static inline int parity8(u8 val) 259 { 260 /* 261 * One explanation of this algorithm: 262 * https://funloop.org/codex/problem/parity/README.html 263 */ 264 val ^= val >> 4; 265 return (0x6996 >> (val & 0xf)) & 1; 266 } 267 268 /** 269 * __ffs64 - find first set bit in a 64 bit word 270 * @word: The 64 bit word 271 * 272 * On 64 bit arches this is a synonym for __ffs 273 * The result is not defined if no bits are set, so check that @word 274 * is non-zero before calling this. 275 */ 276 static inline __attribute_const__ unsigned int __ffs64(u64 word) 277 { 278 #if BITS_PER_LONG == 32 279 if (((u32)word) == 0UL) 280 return __ffs((u32)(word >> 32)) + 32; 281 #elif BITS_PER_LONG != 64 282 #error BITS_PER_LONG not 32 or 64 283 #endif 284 return __ffs((unsigned long)word); 285 } 286 287 /** 288 * fns - find N'th set bit in a word 289 * @word: The word to search 290 * @n: Bit to find 291 */ 292 static inline unsigned int fns(unsigned long word, unsigned int n) 293 { 294 while (word && n--) 295 word &= word - 1; 296 297 return word ? __ffs(word) : BITS_PER_LONG; 298 } 299 300 /** 301 * assign_bit - Assign value to a bit in memory 302 * @nr: the bit to set 303 * @addr: the address to start counting from 304 * @value: the value to assign 305 */ 306 #define assign_bit(nr, addr, value) \ 307 ((value) ? set_bit((nr), (addr)) : clear_bit((nr), (addr))) 308 309 #define __assign_bit(nr, addr, value) \ 310 ((value) ? __set_bit((nr), (addr)) : __clear_bit((nr), (addr))) 311 312 /** 313 * __ptr_set_bit - Set bit in a pointer's value 314 * @nr: the bit to set 315 * @addr: the address of the pointer variable 316 * 317 * Example: 318 * void *p = foo(); 319 * __ptr_set_bit(bit, &p); 320 */ 321 #define __ptr_set_bit(nr, addr) \ 322 ({ \ 323 typecheck_pointer(*(addr)); \ 324 __set_bit(nr, (unsigned long *)(addr)); \ 325 }) 326 327 /** 328 * __ptr_clear_bit - Clear bit in a pointer's value 329 * @nr: the bit to clear 330 * @addr: the address of the pointer variable 331 * 332 * Example: 333 * void *p = foo(); 334 * __ptr_clear_bit(bit, &p); 335 */ 336 #define __ptr_clear_bit(nr, addr) \ 337 ({ \ 338 typecheck_pointer(*(addr)); \ 339 __clear_bit(nr, (unsigned long *)(addr)); \ 340 }) 341 342 /** 343 * __ptr_test_bit - Test bit in a pointer's value 344 * @nr: the bit to test 345 * @addr: the address of the pointer variable 346 * 347 * Example: 348 * void *p = foo(); 349 * if (__ptr_test_bit(bit, &p)) { 350 * ... 351 * } else { 352 * ... 353 * } 354 */ 355 #define __ptr_test_bit(nr, addr) \ 356 ({ \ 357 typecheck_pointer(*(addr)); \ 358 test_bit(nr, (unsigned long *)(addr)); \ 359 }) 360 361 #ifdef __KERNEL__ 362 363 #ifndef set_mask_bits 364 #define set_mask_bits(ptr, mask, bits) \ 365 ({ \ 366 const typeof(*(ptr)) mask__ = (mask), bits__ = (bits); \ 367 typeof(*(ptr)) old__, new__; \ 368 \ 369 old__ = READ_ONCE(*(ptr)); \ 370 do { \ 371 new__ = (old__ & ~mask__) | bits__; \ 372 } while (!try_cmpxchg(ptr, &old__, new__)); \ 373 \ 374 old__; \ 375 }) 376 #endif 377 378 #ifndef bit_clear_unless 379 #define bit_clear_unless(ptr, clear, test) \ 380 ({ \ 381 const typeof(*(ptr)) clear__ = (clear), test__ = (test);\ 382 typeof(*(ptr)) old__, new__; \ 383 \ 384 old__ = READ_ONCE(*(ptr)); \ 385 do { \ 386 if (old__ & test__) \ 387 break; \ 388 new__ = old__ & ~clear__; \ 389 } while (!try_cmpxchg(ptr, &old__, new__)); \ 390 \ 391 !(old__ & test__); \ 392 }) 393 #endif 394 395 #endif /* __KERNEL__ */ 396 #endif 397