include/asm-x86/bitops_32.h

   1 #ifndef _I386_BITOPS_H
   2 #define _I386_BITOPS_H
   3
   4 /*
   5  * Copyright 1992, Linus Torvalds.
   6  */
   7
   8 #ifndef _LINUX_BITOPS_H
   9 #error only <linux/bitops.h> can be included directly
  10 #endif
  11
  12 #include <linux/compiler.h>
  13 #include <asm/alternative.h>
  14
  15 /*
  16  * These have to be done with inline assembly: that way the bit-setting
  17  * is guaranteed to be atomic. All bit operations return 0 if the bit
  18  * was cleared before the operation and != 0 if it was not.
  19  *
  20  * bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).
  21  */
  22
  23 #define ADDR (*(volatile long *) addr)
  24
  25 /**
  26  * set_bit - Atomically set a bit in memory
  27  * @nr: the bit to set
  28  * @addr: the address to start counting from
  29  *
  30  * This function is atomic and may not be reordered.  See __set_bit()
  31  * if you do not require the atomic guarantees.
  32  *
  33  * Note: there are no guarantees that this function will not be reordered
  34  * on non x86 architectures, so if you are writing portable code,
  35  * make sure not to rely on its reordering guarantees.
  36  *
  37  * Note that @nr may be almost arbitrarily large; this function is not
  38  * restricted to acting on a single-word quantity.
  39  */
  40 static inline void set_bit(int nr, volatile unsigned long * addr)
  41 {
  42         __asm__ __volatile__( LOCK_PREFIX
  43                 "btsl %1,%0"
  44                 :"+m" (ADDR)
  45                 :"Ir" (nr));
  46 }
  47
  48 /**
  49  * __set_bit - Set a bit in memory
  50  * @nr: the bit to set
  51  * @addr: the address to start counting from
  52  *
  53  * Unlike set_bit(), this function is non-atomic and may be reordered.
  54  * If it's called on the same region of memory simultaneously, the effect
  55  * may be that only one operation succeeds.
  56  */
  57 static inline void __set_bit(int nr, volatile unsigned long * addr)
  58 {
  59         __asm__(
  60                 "btsl %1,%0"
  61                 :"+m" (ADDR)
  62                 :"Ir" (nr));
  63 }
  64
  65 /**
  66  * clear_bit - Clears a bit in memory
  67  * @nr: Bit to clear
  68  * @addr: Address to start counting from
  69  *
  70  * clear_bit() is atomic and may not be reordered.  However, it does
  71  * not contain a memory barrier, so if it is used for locking purposes,
  72  * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
  73  * in order to ensure changes are visible on other processors.
  74  */
  75 static inline void clear_bit(int nr, volatile unsigned long * addr)
  76 {
  77         __asm__ __volatile__( LOCK_PREFIX
  78                 "btrl %1,%0"
  79                 :"+m" (ADDR)
  80                 :"Ir" (nr));
  81 }
  82
  83 static inline void __clear_bit(int nr, volatile unsigned long * addr)
  84 {
  85         __asm__ __volatile__(
  86                 "btrl %1,%0"
  87                 :"+m" (ADDR)
  88                 :"Ir" (nr));
  89 }
  90 #define smp_mb__before_clear_bit()      barrier()
  91 #define smp_mb__after_clear_bit()       barrier()
  92
  93 /**
  94  * __change_bit - Toggle a bit in memory
  95  * @nr: the bit to change
  96  * @addr: the address to start counting from
  97  *
  98  * Unlike change_bit(), this function is non-atomic and may be reordered.
  99  * If it's called on the same region of memory simultaneously, the effect
 100  * may be that only one operation succeeds.
 101  */
 102 static inline void __change_bit(int nr, volatile unsigned long * addr)
 103 {
 104         __asm__ __volatile__(
 105                 "btcl %1,%0"
 106                 :"+m" (ADDR)
 107                 :"Ir" (nr));
 108 }
 109
 110 /**
 111  * change_bit - Toggle a bit in memory
 112  * @nr: Bit to change
 113  * @addr: Address to start counting from
 114  *
 115  * change_bit() is atomic and may not be reordered. It may be
 116  * reordered on other architectures than x86.
 117  * Note that @nr may be almost arbitrarily large; this function is not
 118  * restricted to acting on a single-word quantity.
 119  */
 120 static inline void change_bit(int nr, volatile unsigned long * addr)
 121 {
 122         __asm__ __volatile__( LOCK_PREFIX
 123                 "btcl %1,%0"
 124                 :"+m" (ADDR)
 125                 :"Ir" (nr));
 126 }
 127
 128 /**
 129  * test_and_set_bit - Set a bit and return its old value
 130  * @nr: Bit to set
 131  * @addr: Address to count from
 132  *
 133  * This operation is atomic and cannot be reordered.
 134  * It may be reordered on other architectures than x86.
 135  * It also implies a memory barrier.
 136  */
 137 static inline int test_and_set_bit(int nr, volatile unsigned long * addr)
 138 {
 139         int oldbit;
 140
 141         __asm__ __volatile__( LOCK_PREFIX
 142                 "btsl %2,%1\n\tsbbl %0,%0"
 143                 :"=r" (oldbit),"+m" (ADDR)
 144                 :"Ir" (nr) : "memory");
 145         return oldbit;
 146 }
 147
 148 /**
 149  * __test_and_set_bit - Set a bit and return its old value
 150  * @nr: Bit to set
 151  * @addr: Address to count from
 152  *
 153  * This operation is non-atomic and can be reordered.
 154  * If two examples of this operation race, one can appear to succeed
 155  * but actually fail.  You must protect multiple accesses with a lock.
 156  */
 157 static inline int __test_and_set_bit(int nr, volatile unsigned long * addr)
 158 {
 159         int oldbit;
 160
 161         __asm__(
 162                 "btsl %2,%1\n\tsbbl %0,%0"
 163                 :"=r" (oldbit),"+m" (ADDR)
 164                 :"Ir" (nr));
 165         return oldbit;
 166 }
 167
 168 /**
 169  * test_and_clear_bit - Clear a bit and return its old value
 170  * @nr: Bit to clear
 171  * @addr: Address to count from
 172  *
 173  * This operation is atomic and cannot be reordered.
 174  * It can be reorderdered on other architectures other than x86.
 175  * It also implies a memory barrier.
 176  */
 177 static inline int test_and_clear_bit(int nr, volatile unsigned long * addr)
 178 {
 179         int oldbit;
 180
 181         __asm__ __volatile__( LOCK_PREFIX
 182                 "btrl %2,%1\n\tsbbl %0,%0"
 183                 :"=r" (oldbit),"+m" (ADDR)
 184                 :"Ir" (nr) : "memory");
 185         return oldbit;
 186 }
 187
 188 /**
 189  * __test_and_clear_bit - Clear a bit and return its old value
 190  * @nr: Bit to clear
 191  * @addr: Address to count from
 192  *
 193  * This operation is non-atomic and can be reordered.
 194  * If two examples of this operation race, one can appear to succeed
 195  * but actually fail.  You must protect multiple accesses with a lock.
 196  */
 197 static inline int __test_and_clear_bit(int nr, volatile unsigned long *addr)
 198 {
 199         int oldbit;
 200
 201         __asm__(
 202                 "btrl %2,%1\n\tsbbl %0,%0"
 203                 :"=r" (oldbit),"+m" (ADDR)
 204                 :"Ir" (nr));
 205         return oldbit;
 206 }
 207
 208 /* WARNING: non atomic and it can be reordered! */
 209 static inline int __test_and_change_bit(int nr, volatile unsigned long *addr)
 210 {
 211         int oldbit;
 212
 213         __asm__ __volatile__(
 214                 "btcl %2,%1\n\tsbbl %0,%0"
 215                 :"=r" (oldbit),"+m" (ADDR)
 216                 :"Ir" (nr) : "memory");
 217         return oldbit;
 218 }
 219
 220 /**
 221  * test_and_change_bit - Change a bit and return its old value
 222  * @nr: Bit to change
 223  * @addr: Address to count from
 224  *
 225  * This operation is atomic and cannot be reordered.
 226  * It also implies a memory barrier.
 227  */
 228 static inline int test_and_change_bit(int nr, volatile unsigned long* addr)
 229 {
 230         int oldbit;
 231
 232         __asm__ __volatile__( LOCK_PREFIX
 233                 "btcl %2,%1\n\tsbbl %0,%0"
 234                 :"=r" (oldbit),"+m" (ADDR)
 235                 :"Ir" (nr) : "memory");
 236         return oldbit;
 237 }
 238
 239 #if 0 /* Fool kernel-doc since it doesn't do macros yet */
 240 /**
 241  * test_bit - Determine whether a bit is set
 242  * @nr: bit number to test
 243  * @addr: Address to start counting from
 244  */
 245 static int test_bit(int nr, const volatile void * addr);
 246 #endif
 247
 248 static __always_inline int constant_test_bit(int nr, const volatile unsigned long *addr)
 249 {
 250         return ((1UL << (nr & 31)) & (addr[nr >> 5])) != 0;
 251 }
 252
 253 static inline int variable_test_bit(int nr, const volatile unsigned long * addr)
 254 {
 255         int oldbit;
 256
 257         __asm__ __volatile__(
 258                 "btl %2,%1\n\tsbbl %0,%0"
 259                 :"=r" (oldbit)
 260                 :"m" (ADDR),"Ir" (nr));
 261         return oldbit;
 262 }
 263
 264 #define test_bit(nr,addr) \
 265 (__builtin_constant_p(nr) ? \
 266  constant_test_bit((nr),(addr)) : \
 267  variable_test_bit((nr),(addr)))
 268
 269 #undef ADDR
 270
 271 /**
 272  * find_first_zero_bit - find the first zero bit in a memory region
 273  * @addr: The address to start the search at
 274  * @size: The maximum size to search
 275  *
 276  * Returns the bit-number of the first zero bit, not the number of the byte
 277  * containing a bit.
 278  */
 279 static inline int find_first_zero_bit(const unsigned long *addr, unsigned size)
 280 {
 281         int d0, d1, d2;
 282         int res;
 283
 284         if (!size)
 285                 return 0;
 286         /* This looks at memory. Mark it volatile to tell gcc not to move it around */
 287         __asm__ __volatile__(
 288                 "movl $-1,%%eax\n\t"
 289                 "xorl %%edx,%%edx\n\t"
 290                 "repe; scasl\n\t"
 291                 "je 1f\n\t"
 292                 "xorl -4(%%edi),%%eax\n\t"
 293                 "subl $4,%%edi\n\t"
 294                 "bsfl %%eax,%%edx\n"
 295                 "1:\tsubl %%ebx,%%edi\n\t"
 296                 "shll $3,%%edi\n\t"
 297                 "addl %%edi,%%edx"
 298                 :"=d" (res), "=&c" (d0), "=&D" (d1), "=&a" (d2)
 299                 :"1" ((size + 31) >> 5), "2" (addr), "b" (addr) : "memory");
 300         return res;
 301 }
 302
 303 /**
 304  * find_next_zero_bit - find the first zero bit in a memory region
 305  * @addr: The address to base the search on
 306  * @offset: The bitnumber to start searching at
 307  * @size: The maximum size to search
 308  */
 309 int find_next_zero_bit(const unsigned long *addr, int size, int offset);
 310
 311 /**
 312  * __ffs - find first bit in word.
 313  * @word: The word to search
 314  *
 315  * Undefined if no bit exists, so code should check against 0 first.
 316  */
 317 static inline unsigned long __ffs(unsigned long word)
 318 {
 319         __asm__("bsfl %1,%0"
 320                 :"=r" (word)
 321                 :"rm" (word));
 322         return word;
 323 }
 324
 325 /**
 326  * find_first_bit - find the first set bit in a memory region
 327  * @addr: The address to start the search at
 328  * @size: The maximum size to search
 329  *
 330  * Returns the bit-number of the first set bit, not the number of the byte
 331  * containing a bit.
 332  */
 333 static inline unsigned find_first_bit(const unsigned long *addr, unsigned size)
 334 {
 335         unsigned x = 0;
 336
 337         while (x < size) {
 338                 unsigned long val = *addr++;
 339                 if (val)
 340                         return __ffs(val) + x;
 341                 x += (sizeof(*addr)<<3);
 342         }
 343         return x;
 344 }
 345
 346 /**
 347  * find_next_bit - find the first set bit in a memory region
 348  * @addr: The address to base the search on
 349  * @offset: The bitnumber to start searching at
 350  * @size: The maximum size to search
 351  */
 352 int find_next_bit(const unsigned long *addr, int size, int offset);
 353
 354 /**
 355  * ffz - find first zero in word.
 356  * @word: The word to search
 357  *
 358  * Undefined if no zero exists, so code should check against ~0UL first.
 359  */
 360 static inline unsigned long ffz(unsigned long word)
 361 {
 362         __asm__("bsfl %1,%0"
 363                 :"=r" (word)
 364                 :"r" (~word));
 365         return word;
 366 }
 367
 368 #ifdef __KERNEL__
 369
 370 #include <asm-generic/bitops/sched.h>
 371
 372 /**
 373  * ffs - find first bit set
 374  * @x: the word to search
 375  *
 376  * This is defined the same way as
 377  * the libc and compiler builtin ffs routines, therefore
 378  * differs in spirit from the above ffz() (man ffs).
 379  */
 380 static inline int ffs(int x)
 381 {
 382         int r;
 383
 384         __asm__("bsfl %1,%0\n\t"
 385                 "jnz 1f\n\t"
 386                 "movl $-1,%0\n"
 387                 "1:" : "=r" (r) : "rm" (x));
 388         return r+1;
 389 }
 390
 391 /**
 392  * fls - find last bit set
 393  * @x: the word to search
 394  *
 395  * This is defined the same way as ffs().
 396  */
 397 static inline int fls(int x)
 398 {
 399         int r;
 400
 401         __asm__("bsrl %1,%0\n\t"
 402                 "jnz 1f\n\t"
 403                 "movl $-1,%0\n"
 404                 "1:" : "=r" (r) : "rm" (x));
 405         return r+1;
 406 }
 407
 408 #include <asm-generic/bitops/hweight.h>
 409 #include <asm-generic/bitops/lock.h>
 410
 411 #endif /* __KERNEL__ */
 412
 413 #include <asm-generic/bitops/fls64.h>
 414
 415 #ifdef __KERNEL__
 416
 417 #include <asm-generic/bitops/ext2-non-atomic.h>
 418
 419 #define ext2_set_bit_atomic(lock,nr,addr) \
 420         test_and_set_bit((nr),(unsigned long*)addr)
 421 #define ext2_clear_bit_atomic(lock,nr, addr) \
 422                 test_and_clear_bit((nr),(unsigned long*)addr)
 423
 424 #include <asm-generic/bitops/minix.h>
 425
 426 #endif /* __KERNEL__ */
 427
 428 #endif /* _I386_BITOPS_H */