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