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