lib/ext2fs/bitops.h

   1 /*
   2  * bitops.h --- Bitmap frobbing code.  The byte swapping routines are
   3  *      also included here.
   4  *
   5  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
   6  *
   7  * %Begin-Header%
   8  * This file may be redistributed under the terms of the GNU Library
   9  * General Public License, version 2.
  10  * %End-Header%
  11  */
  12
  13 #ifdef WORDS_BIGENDIAN
  14 #define ext2fs_cpu_to_le64(x) ((__force __le64)ext2fs_swab64((__u64)(x)))
  15 #define ext2fs_le64_to_cpu(x) ext2fs_swab64((__force __u64)(__le64)(x))
  16 #define ext2fs_cpu_to_le32(x) ((__force __le32)ext2fs_swab32((__u32)(x)))
  17 #define ext2fs_le32_to_cpu(x) ext2fs_swab32((__force __u32)(__le32)(x))
  18 #define ext2fs_cpu_to_le16(x) ((__force __le16)ext2fs_swab16((__u16)(x)))
  19 #define ext2fs_le16_to_cpu(x) ext2fs_swab16((__force __u16)(__le16)(x))
  20
  21 #define ext2fs_cpu_to_be64(x) ((__force __be64)(__u64)(x))
  22 #define ext2fs_be64_to_cpu(x) ((__force __u64)(__be64)(x))
  23 #define ext2fs_cpu_to_be32(x) ((__force __be32)(__u32)(x))
  24 #define ext2fs_be32_to_cpu(x) ((__force __u32)(__be32)(x))
  25 #define ext2fs_cpu_to_be16(x) ((__force __be16)(__u16)(x))
  26 #define ext2fs_be16_to_cpu(x) ((__force __u16)(__be16)(x))
  27 #else
  28 #define ext2fs_cpu_to_le64(x) ((__force __le64)(__u64)(x))
  29 #define ext2fs_le64_to_cpu(x) ((__force __u64)(__le64)(x))
  30 #define ext2fs_cpu_to_le32(x) ((__force __le32)(__u32)(x))
  31 #define ext2fs_le32_to_cpu(x) ((__force __u32)(__le32)(x))
  32 #define ext2fs_cpu_to_le16(x) ((__force __le16)(__u16)(x))
  33 #define ext2fs_le16_to_cpu(x) ((__force __u16)(__le16)(x))
  34
  35 #define ext2fs_cpu_to_be64(x) ((__force __be64)ext2fs_swab64((__u64)(x)))
  36 #define ext2fs_be64_to_cpu(x) ext2fs_swab64((__force __u64)(__be64)(x))
  37 #define ext2fs_cpu_to_be32(x) ((__force __be32)ext2fs_swab32((__u32)(x)))
  38 #define ext2fs_be32_to_cpu(x) ext2fs_swab32((__force __u32)(__be32)(x))
  39 #define ext2fs_cpu_to_be16(x) ((__force __be16)ext2fs_swab16((__u16)(x)))
  40 #define ext2fs_be16_to_cpu(x) ext2fs_swab16((__force __u16)(__be16)(x))
  41 #endif
  42
  43 /*
  44  * EXT2FS bitmap manipulation routines.
  45  */
  46
  47 /* Support for sending warning messages from the inline subroutines */
  48 extern const char *ext2fs_block_string;
  49 extern const char *ext2fs_inode_string;
  50 extern const char *ext2fs_mark_string;
  51 extern const char *ext2fs_unmark_string;
  52 extern const char *ext2fs_test_string;
  53 extern void ext2fs_warn_bitmap(errcode_t errcode, unsigned long arg,
  54                                const char *description);
  55 extern void ext2fs_warn_bitmap2(ext2fs_generic_bitmap bitmap,
  56                                 int code, unsigned long arg);
  57
  58 #ifdef NO_INLINE_FUNCS
  59 extern void ext2fs_fast_set_bit(unsigned int nr,void * addr);
  60 extern void ext2fs_fast_clear_bit(unsigned int nr, void * addr);
  61 extern void ext2fs_fast_set_bit64(__u64 nr,void * addr);
  62 extern void ext2fs_fast_clear_bit64(__u64 nr, void * addr);
  63 extern __u16 ext2fs_swab16(__u16 val);
  64 extern __u32 ext2fs_swab32(__u32 val);
  65 extern __u64 ext2fs_swab64(__u64 val);
  66
  67 extern int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block);
  68 extern int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
  69                                        blk_t block);
  70 extern int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block);
  71
  72 extern int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode);
  73 extern int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
  74                                        ext2_ino_t inode);
  75 extern int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode);
  76
  77 extern void ext2fs_fast_mark_block_bitmap(ext2fs_block_bitmap bitmap,
  78                                           blk_t block);
  79 extern void ext2fs_fast_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
  80                                             blk_t block);
  81 extern int ext2fs_fast_test_block_bitmap(ext2fs_block_bitmap bitmap,
  82                                          blk_t block);
  83
  84 extern void ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,
  85                                           ext2_ino_t inode);
  86 extern void ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
  87                                             ext2_ino_t inode);
  88 extern int ext2fs_fast_test_inode_bitmap(ext2fs_inode_bitmap bitmap,
  89                                          ext2_ino_t inode);
  90 extern blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap);
  91 extern ext2_ino_t ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap);
  92 extern blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap);
  93 extern ext2_ino_t ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap);
  94
  95 extern void ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,
  96                                                 blk_t block, int num);
  97 extern void ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,
  98                                                   blk_t block, int num);
  99 extern int ext2fs_fast_test_block_bitmap_range(ext2fs_block_bitmap bitmap,
 100                                                blk_t block, int num);
 101 #endif
 102
 103 /* These functions routines moved to gen_bitmap.c */
 104 extern void ext2fs_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,
 105                                            blk_t block, int num);
 106 extern void ext2fs_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,
 107                                              blk_t block, int num);
 108 extern int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap bitmap,
 109                                           blk_t block, int num);
 110 extern int ext2fs_test_inode_bitmap_range(ext2fs_inode_bitmap bitmap,
 111                                           ext2_ino_t inode, int num);
 112 extern int ext2fs_mark_generic_bitmap(ext2fs_generic_bitmap bitmap,
 113                                          __u32 bitno);
 114 extern int ext2fs_unmark_generic_bitmap(ext2fs_generic_bitmap bitmap,
 115                                            blk_t bitno);
 116 extern int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap,
 117                                       blk_t bitno);
 118 extern int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap bitmap,
 119                                           blk_t block, int num);
 120 extern void ext2fs_set_bitmap_padding(ext2fs_generic_bitmap map);
 121 extern __u32 ext2fs_get_generic_bitmap_start(ext2fs_generic_bitmap bitmap);
 122 extern __u32 ext2fs_get_generic_bitmap_end(ext2fs_generic_bitmap bitmap);
 123
 124 /* 64-bit versions */
 125
 126 #ifdef NO_INLINE_FUNCS
 127 extern int ext2fs_mark_block_bitmap2(ext2fs_block_bitmap bitmap,
 128                                      blk64_t block);
 129 extern int ext2fs_unmark_block_bitmap2(ext2fs_block_bitmap bitmap,
 130                                        blk64_t block);
 131 extern int ext2fs_test_block_bitmap2(ext2fs_block_bitmap bitmap,
 132                                      blk64_t block);
 133
 134 extern int ext2fs_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 135                                      ext2_ino_t inode);
 136 extern int ext2fs_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 137                                        ext2_ino_t inode);
 138 extern int ext2fs_test_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 139                                      ext2_ino_t inode);
 140
 141 extern void ext2fs_fast_mark_block_bitmap2(ext2fs_block_bitmap bitmap,
 142                                            blk64_t block);
 143 extern void ext2fs_fast_unmark_block_bitmap2(ext2fs_block_bitmap bitmap,
 144                                              blk64_t block);
 145 extern int ext2fs_fast_test_block_bitmap2(ext2fs_block_bitmap bitmap,
 146                                           blk64_t block);
 147
 148 extern void ext2fs_fast_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 149                                            ext2_ino_t inode);
 150 extern void ext2fs_fast_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 151                                             ext2_ino_t inode);
 152 extern int ext2fs_fast_test_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 153                                           ext2_ino_t inode);
 154 extern errcode_t ext2fs_find_first_zero_block_bitmap2(ext2fs_block_bitmap bitmap,
 155                                                       blk64_t start,
 156                                                       blk64_t end,
 157                                                       blk64_t *out);
 158 extern errcode_t ext2fs_find_first_zero_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 159                                                       ext2_ino_t start,
 160                                                       ext2_ino_t end,
 161                                                       ext2_ino_t *out);
 162 extern errcode_t ext2fs_find_first_set_block_bitmap2(ext2fs_block_bitmap bitmap,
 163                                                      blk64_t start,
 164                                                      blk64_t end,
 165                                                      blk64_t *out);
 166 extern errcode_t ext2fs_find_first_set_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 167                                                       ext2_ino_t start,
 168                                                       ext2_ino_t end,
 169                                                       ext2_ino_t *out);
 170 extern blk64_t ext2fs_get_block_bitmap_start2(ext2fs_block_bitmap bitmap);
 171 extern ext2_ino_t ext2fs_get_inode_bitmap_start2(ext2fs_inode_bitmap bitmap);
 172 extern blk64_t ext2fs_get_block_bitmap_end2(ext2fs_block_bitmap bitmap);
 173 extern ext2_ino_t ext2fs_get_inode_bitmap_end2(ext2fs_inode_bitmap bitmap);
 174
 175 extern int ext2fs_fast_test_block_bitmap_range2(ext2fs_block_bitmap bitmap,
 176                                                 blk64_t block,
 177                                                 unsigned int num);
 178 extern void ext2fs_fast_mark_block_bitmap_range2(ext2fs_block_bitmap bitmap,
 179                                                  blk64_t block,
 180                                                  unsigned int num);
 181 extern void ext2fs_fast_unmark_block_bitmap_range2(ext2fs_block_bitmap bitmap,
 182                                                    blk64_t block,
 183                                                    unsigned int num);
 184 #endif
 185
 186 /* These routines moved to gen_bitmap64.c */
 187 extern void ext2fs_clear_generic_bmap(ext2fs_generic_bitmap bitmap);
 188 extern errcode_t ext2fs_compare_generic_bmap(errcode_t neq,
 189                                              ext2fs_generic_bitmap bm1,
 190                                              ext2fs_generic_bitmap bm2);
 191 extern void ext2fs_set_generic_bmap_padding(ext2fs_generic_bitmap bmap);
 192 extern int ext2fs_mark_generic_bmap(ext2fs_generic_bitmap bitmap,
 193                                     blk64_t bitno);
 194 extern int ext2fs_unmark_generic_bmap(ext2fs_generic_bitmap bitmap,
 195                                       blk64_t bitno);
 196 extern int ext2fs_test_generic_bmap(ext2fs_generic_bitmap bitmap,
 197                                     blk64_t bitno);
 198 extern int ext2fs_test_block_bitmap_range2(ext2fs_block_bitmap bitmap,
 199                                            blk64_t block, unsigned int num);
 200 extern __u64 ext2fs_get_generic_bmap_start(ext2fs_generic_bitmap bitmap);
 201 extern __u64 ext2fs_get_generic_bmap_end(ext2fs_generic_bitmap bitmap);
 202 extern int ext2fs_test_block_bitmap_range2(ext2fs_block_bitmap bitmap,
 203                                            blk64_t block, unsigned int num);
 204 extern void ext2fs_mark_block_bitmap_range2(ext2fs_block_bitmap bitmap,
 205                                             blk64_t block, unsigned int num);
 206 extern void ext2fs_unmark_block_bitmap_range2(ext2fs_block_bitmap bitmap,
 207                                               blk64_t block, unsigned int num);
 208 extern errcode_t ext2fs_find_first_zero_generic_bmap(ext2fs_generic_bitmap bitmap,
 209                                                      __u64 start, __u64 end,
 210                                                      __u64 *out);
 211 extern errcode_t ext2fs_find_first_set_generic_bmap(ext2fs_generic_bitmap bitmap,
 212                                                     __u64 start, __u64 end,
 213                                                     __u64 *out);
 214
 215 /*
 216  * The inline routines themselves...
 217  *
 218  * If NO_INLINE_FUNCS is defined, then we won't try to do inline
 219  * functions at all; they will be included as normal functions in
 220  * inline.c
 221  */
 222 #ifdef NO_INLINE_FUNCS
 223 #if (defined(__GNUC__) && (defined(__i386__) || defined(__i486__) || \
 224                            defined(__i586__)))
 225         /* This prevents bitops.c from trying to include the C */
 226         /* function version of these functions */
 227 #define _EXT2_HAVE_ASM_BITOPS_
 228 #endif
 229 #endif /* NO_INLINE_FUNCS */
 230
 231 #if (defined(INCLUDE_INLINE_FUNCS) || !defined(NO_INLINE_FUNCS))
 232 #ifdef INCLUDE_INLINE_FUNCS
 233 #if (__STDC_VERSION__ >= 199901L)
 234 #define _INLINE_ extern inline
 235 #else
 236 #define _INLINE_ inline
 237 #endif
 238 #else /* !INCLUDE_INLINE FUNCS */
 239 #if (__STDC_VERSION__ >= 199901L)
 240 #define _INLINE_ inline
 241 #else /* not C99 */
 242 #ifdef __GNUC__
 243 #define _INLINE_ extern __inline__
 244 #else                           /* For Watcom C */
 245 #define _INLINE_ extern inline
 246 #endif /* __GNUC__ */
 247 #endif /* __STDC_VERSION__ >= 199901L */
 248 #endif /* INCLUDE_INLINE_FUNCS */
 249
 250 /*
 251  * Fast bit set/clear functions that doesn't need to return the
 252  * previous bit value.
 253  */
 254
 255 _INLINE_ void ext2fs_fast_set_bit(unsigned int nr,void * addr)
 256 {
 257         unsigned char   *ADDR = (unsigned char *) addr;
 258
 259         ADDR += nr >> 3;
 260         *ADDR |= (unsigned char) (1 << (nr & 0x07));
 261 }
 262
 263 _INLINE_ void ext2fs_fast_clear_bit(unsigned int nr, void * addr)
 264 {
 265         unsigned char   *ADDR = (unsigned char *) addr;
 266
 267         ADDR += nr >> 3;
 268         *ADDR &= (unsigned char) ~(1 << (nr & 0x07));
 269 }
 270
 271
 272 _INLINE_ void ext2fs_fast_set_bit64(__u64 nr, void * addr)
 273 {
 274         unsigned char   *ADDR = (unsigned char *) addr;
 275
 276         ADDR += nr >> 3;
 277         *ADDR |= (unsigned char) (1 << (nr & 0x07));
 278 }
 279
 280 _INLINE_ void ext2fs_fast_clear_bit64(__u64 nr, void * addr)
 281 {
 282         unsigned char   *ADDR = (unsigned char *) addr;
 283
 284         ADDR += nr >> 3;
 285         *ADDR &= (unsigned char) ~(1 << (nr & 0x07));
 286 }
 287
 288
 289 #if ((defined __GNUC__) && !defined(_EXT2_USE_C_VERSIONS_) && \
 290      (defined(__i386__) || defined(__i486__) || defined(__i586__)))
 291
 292 #define _EXT2_HAVE_ASM_BITOPS_
 293 #define _EXT2_HAVE_ASM_SWAB_
 294
 295 /*
 296  * These are done by inline assembly for speed reasons.....
 297  *
 298  * All bitoperations return 0 if the bit was cleared before the
 299  * operation and != 0 if it was not.  Bit 0 is the LSB of addr; bit 32
 300  * is the LSB of (addr+1).
 301  */
 302
 303 /*
 304  * Some hacks to defeat gcc over-optimizations..
 305  */
 306 struct __dummy_h { unsigned long a[100]; };
 307 #define EXT2FS_ADDR (*(struct __dummy_h *) addr)
 308 #define EXT2FS_CONST_ADDR (*(const struct __dummy_h *) addr)
 309
 310 _INLINE_ int ext2fs_set_bit(unsigned int nr, void * addr)
 311 {
 312         int oldbit;
 313
 314         addr = (void *) (((unsigned char *) addr) + (nr >> 3));
 315         __asm__ __volatile__("btsl %2,%1\n\tsbbl %0,%0"
 316                 :"=r" (oldbit),"+m" (EXT2FS_ADDR)
 317                 :"r" (nr & 7));
 318         return oldbit;
 319 }
 320
 321 _INLINE_ int ext2fs_clear_bit(unsigned int nr, void * addr)
 322 {
 323         int oldbit;
 324
 325         addr = (void *) (((unsigned char *) addr) + (nr >> 3));
 326         __asm__ __volatile__("btrl %2,%1\n\tsbbl %0,%0"
 327                 :"=r" (oldbit),"+m" (EXT2FS_ADDR)
 328                 :"r" (nr & 7));
 329         return oldbit;
 330 }
 331
 332 _INLINE_ int ext2fs_test_bit(unsigned int nr, const void * addr)
 333 {
 334         int oldbit;
 335
 336         addr = (const void *) (((const unsigned char *) addr) + (nr >> 3));
 337         __asm__ __volatile__("btl %2,%1\n\tsbbl %0,%0"
 338                 :"=r" (oldbit)
 339                 :"m" (EXT2FS_CONST_ADDR),"r" (nr & 7));
 340         return oldbit;
 341 }
 342
 343 _INLINE_ __u32 ext2fs_swab32(__u32 val)
 344 {
 345 #ifdef EXT2FS_REQUIRE_486
 346         __asm__("bswap %0" : "=r" (val) : "0" (val));
 347 #else
 348         __asm__("xchgb %b0,%h0\n\t"     /* swap lower bytes     */
 349                 "rorl $16,%0\n\t"       /* swap words           */
 350                 "xchgb %b0,%h0"         /* swap higher bytes    */
 351                 :"=q" (val)
 352                 : "0" (val));
 353 #endif
 354         return val;
 355 }
 356
 357 _INLINE_ __u16 ext2fs_swab16(__u16 val)
 358 {
 359         __asm__("xchgb %b0,%h0"         /* swap bytes           */ \
 360                 : "=q" (val) \
 361                 :  "0" (val)); \
 362                 return val;
 363 }
 364
 365 #undef EXT2FS_ADDR
 366
 367 #endif  /* i386 */
 368
 369
 370 #if !defined(_EXT2_HAVE_ASM_SWAB_)
 371
 372 _INLINE_ __u16 ext2fs_swab16(__u16 val)
 373 {
 374         return (val >> 8) | (__u16) (val << 8);
 375 }
 376
 377 _INLINE_ __u32 ext2fs_swab32(__u32 val)
 378 {
 379         return ((val>>24) | ((val>>8)&0xFF00) |
 380                 ((val<<8)&0xFF0000) | (val<<24));
 381 }
 382
 383 #endif /* !_EXT2_HAVE_ASM_SWAB */
 384
 385 _INLINE_ __u64 ext2fs_swab64(__u64 val)
 386 {
 387         return (ext2fs_swab32((__u32) (val >> 32)) |
 388                 (((__u64)ext2fs_swab32(val & 0xFFFFFFFFUL)) << 32));
 389 }
 390
 391 _INLINE_ int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap,
 392                                        blk_t block)
 393 {
 394         return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
 395                                           block);
 396 }
 397
 398 _INLINE_ int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
 399                                          blk_t block)
 400 {
 401         return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
 402                                             block);
 403 }
 404
 405 _INLINE_ int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap,
 406                                        blk_t block)
 407 {
 408         return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
 409                                           block);
 410 }
 411
 412 _INLINE_ int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,
 413                                        ext2_ino_t inode)
 414 {
 415         return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
 416                                           inode);
 417 }
 418
 419 _INLINE_ int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
 420                                          ext2_ino_t inode)
 421 {
 422         return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
 423                                      inode);
 424 }
 425
 426 _INLINE_ int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap,
 427                                        ext2_ino_t inode)
 428 {
 429         return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
 430                                           inode);
 431 }
 432
 433 _INLINE_ void ext2fs_fast_mark_block_bitmap(ext2fs_block_bitmap bitmap,
 434                                             blk_t block)
 435 {
 436         ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, block);
 437 }
 438
 439 _INLINE_ void ext2fs_fast_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
 440                                               blk_t block)
 441 {
 442         ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, block);
 443 }
 444
 445 _INLINE_ int ext2fs_fast_test_block_bitmap(ext2fs_block_bitmap bitmap,
 446                                             blk_t block)
 447 {
 448         return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
 449                                           block);
 450 }
 451
 452 _INLINE_ void ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,
 453                                             ext2_ino_t inode)
 454 {
 455         ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, inode);
 456 }
 457
 458 _INLINE_ void ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
 459                                               ext2_ino_t inode)
 460 {
 461         ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, inode);
 462 }
 463
 464 _INLINE_ int ext2fs_fast_test_inode_bitmap(ext2fs_inode_bitmap bitmap,
 465                                            ext2_ino_t inode)
 466 {
 467         return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
 468                                           inode);
 469 }
 470
 471 _INLINE_ blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap)
 472 {
 473         return ext2fs_get_generic_bitmap_start((ext2fs_generic_bitmap) bitmap);
 474 }
 475
 476 _INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap)
 477 {
 478         return ext2fs_get_generic_bitmap_start((ext2fs_generic_bitmap) bitmap);
 479 }
 480
 481 _INLINE_ blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap)
 482 {
 483         return ext2fs_get_generic_bitmap_end((ext2fs_generic_bitmap) bitmap);
 484 }
 485
 486 _INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap)
 487 {
 488         return ext2fs_get_generic_bitmap_end((ext2fs_generic_bitmap) bitmap);
 489 }
 490
 491 _INLINE_ int ext2fs_fast_test_block_bitmap_range(ext2fs_block_bitmap bitmap,
 492                                                  blk_t block, int num)
 493 {
 494         return ext2fs_test_block_bitmap_range(bitmap, block, num);
 495 }
 496
 497 _INLINE_ void ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,
 498                                                   blk_t block, int num)
 499 {
 500         ext2fs_mark_block_bitmap_range(bitmap, block, num);
 501 }
 502
 503 _INLINE_ void ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,
 504                                                     blk_t block, int num)
 505 {
 506         ext2fs_unmark_block_bitmap_range(bitmap, block, num);
 507 }
 508
 509 /* 64-bit versions */
 510
 511 _INLINE_ int ext2fs_mark_block_bitmap2(ext2fs_block_bitmap bitmap,
 512                                        blk64_t block)
 513 {
 514         return ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap,
 515                                         block);
 516 }
 517
 518 _INLINE_ int ext2fs_unmark_block_bitmap2(ext2fs_block_bitmap bitmap,
 519                                          blk64_t block)
 520 {
 521         return ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, block);
 522 }
 523
 524 _INLINE_ int ext2fs_test_block_bitmap2(ext2fs_block_bitmap bitmap,
 525                                        blk64_t block)
 526 {
 527         return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap,
 528                                         block);
 529 }
 530
 531 _INLINE_ int ext2fs_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 532                                        ext2_ino_t inode)
 533 {
 534         return ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap,
 535                                         inode);
 536 }
 537
 538 _INLINE_ int ext2fs_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 539                                          ext2_ino_t inode)
 540 {
 541         return ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap,
 542                                           inode);
 543 }
 544
 545 _INLINE_ int ext2fs_test_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 546                                        ext2_ino_t inode)
 547 {
 548         return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap,
 549                                         inode);
 550 }
 551
 552 _INLINE_ void ext2fs_fast_mark_block_bitmap2(ext2fs_block_bitmap bitmap,
 553                                              blk64_t block)
 554 {
 555         ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, block);
 556 }
 557
 558 _INLINE_ void ext2fs_fast_unmark_block_bitmap2(ext2fs_block_bitmap bitmap,
 559                                                blk64_t block)
 560 {
 561         ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, block);
 562 }
 563
 564 _INLINE_ int ext2fs_fast_test_block_bitmap2(ext2fs_block_bitmap bitmap,
 565                                             blk64_t block)
 566 {
 567         return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap,
 568                                         block);
 569 }
 570
 571 _INLINE_ void ext2fs_fast_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 572                                              ext2_ino_t inode)
 573 {
 574         ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, inode);
 575 }
 576
 577 _INLINE_ void ext2fs_fast_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 578                                                ext2_ino_t inode)
 579 {
 580         ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, inode);
 581 }
 582
 583 _INLINE_ int ext2fs_fast_test_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 584                                             ext2_ino_t inode)
 585 {
 586         return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap,
 587                                         inode);
 588 }
 589
 590 _INLINE_ errcode_t ext2fs_find_first_zero_block_bitmap2(ext2fs_block_bitmap bitmap,
 591                                                         blk64_t start,
 592                                                         blk64_t end,
 593                                                         blk64_t *out)
 594 {
 595         __u64 o;
 596         errcode_t rv;
 597
 598         rv = ext2fs_find_first_zero_generic_bmap((ext2fs_generic_bitmap) bitmap,
 599                                                  start, end, &o);
 600         if (!rv)
 601                 *out = o;
 602         return rv;
 603 }
 604
 605 _INLINE_ errcode_t ext2fs_find_first_zero_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 606                                                         ext2_ino_t start,
 607                                                         ext2_ino_t end,
 608                                                         ext2_ino_t *out)
 609 {
 610         __u64 o;
 611         errcode_t rv;
 612
 613         rv = ext2fs_find_first_zero_generic_bmap((ext2fs_generic_bitmap) bitmap,
 614                                                  start, end, &o);
 615         if (!rv)
 616                 *out = (ext2_ino_t) o;
 617         return rv;
 618 }
 619
 620 _INLINE_ errcode_t ext2fs_find_first_set_block_bitmap2(ext2fs_block_bitmap bitmap,
 621                                                        blk64_t start,
 622                                                        blk64_t end,
 623                                                        blk64_t *out)
 624 {
 625         __u64 o;
 626         errcode_t rv;
 627
 628         rv = ext2fs_find_first_set_generic_bmap((ext2fs_generic_bitmap) bitmap,
 629                                                 start, end, &o);
 630         if (!rv)
 631                 *out = o;
 632         return rv;
 633 }
 634
 635 _INLINE_ errcode_t ext2fs_find_first_set_inode_bitmap2(ext2fs_inode_bitmap bitmap,
 636                                                        ext2_ino_t start,
 637                                                        ext2_ino_t end,
 638                                                        ext2_ino_t *out)
 639 {
 640         __u64 o;
 641         errcode_t rv;
 642
 643         rv = ext2fs_find_first_set_generic_bmap((ext2fs_generic_bitmap) bitmap,
 644                                                 start, end, &o);
 645         if (!rv)
 646                 *out = (ext2_ino_t) o;
 647         return rv;
 648 }
 649
 650 _INLINE_ blk64_t ext2fs_get_block_bitmap_start2(ext2fs_block_bitmap bitmap)
 651 {
 652         return ext2fs_get_generic_bmap_start((ext2fs_generic_bitmap) bitmap);
 653 }
 654
 655 _INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_start2(ext2fs_inode_bitmap bitmap)
 656 {
 657         return (ext2_ino_t) ext2fs_get_generic_bmap_start((ext2fs_generic_bitmap) bitmap);
 658 }
 659
 660 _INLINE_ blk64_t ext2fs_get_block_bitmap_end2(ext2fs_block_bitmap bitmap)
 661 {
 662         return ext2fs_get_generic_bmap_end((ext2fs_generic_bitmap) bitmap);
 663 }
 664
 665 _INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_end2(ext2fs_inode_bitmap bitmap)
 666 {
 667         return (ext2_ino_t) ext2fs_get_generic_bmap_end((ext2fs_generic_bitmap) bitmap);
 668 }
 669
 670 _INLINE_ int ext2fs_fast_test_block_bitmap_range2(ext2fs_block_bitmap bitmap,
 671                                                   blk64_t block,
 672                                                   unsigned int num)
 673 {
 674         return ext2fs_test_block_bitmap_range2(bitmap, block, num);
 675 }
 676
 677 _INLINE_ void ext2fs_fast_mark_block_bitmap_range2(ext2fs_block_bitmap bitmap,
 678                                                    blk64_t block,
 679                                                    unsigned int num)
 680 {
 681         ext2fs_mark_block_bitmap_range2(bitmap, block, num);
 682 }
 683
 684 _INLINE_ void ext2fs_fast_unmark_block_bitmap_range2(ext2fs_block_bitmap bitmap,
 685                                                      blk64_t block,
 686                                                      unsigned int num)
 687 {
 688         ext2fs_unmark_block_bitmap_range2(bitmap, block, num);
 689 }
 690
 691 #undef _INLINE_
 692 #endif
 693
 694 #ifndef _EXT2_HAVE_ASM_BITOPS_
 695 extern int ext2fs_set_bit(unsigned int nr,void * addr);
 696 extern int ext2fs_clear_bit(unsigned int nr, void * addr);
 697 extern int ext2fs_test_bit(unsigned int nr, const void * addr);
 698 #endif
 699
 700 extern int ext2fs_set_bit64(__u64 nr,void * addr);
 701 extern int ext2fs_clear_bit64(__u64 nr, void * addr);
 702 extern int ext2fs_test_bit64(__u64 nr, const void * addr);
 703 extern unsigned int ext2fs_bitcount(const void *addr, unsigned int nbytes);