bitops.h revision bf0449b1a6547a566975cb32c18a2ba5972deace
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 blk64_t ext2fs_get_block_bitmap_start2(ext2fs_block_bitmap bitmap); 156extern ext2_ino_t ext2fs_get_inode_bitmap_start2(ext2fs_inode_bitmap bitmap); 157extern blk64_t ext2fs_get_block_bitmap_end2(ext2fs_block_bitmap bitmap); 158extern ext2_ino_t ext2fs_get_inode_bitmap_end2(ext2fs_inode_bitmap bitmap); 159 160extern int ext2fs_fast_test_block_bitmap_range2(ext2fs_block_bitmap bitmap, 161 blk64_t block, 162 unsigned int num); 163extern void ext2fs_fast_mark_block_bitmap_range2(ext2fs_block_bitmap bitmap, 164 blk64_t block, 165 unsigned int num); 166extern void ext2fs_fast_unmark_block_bitmap_range2(ext2fs_block_bitmap bitmap, 167 blk64_t block, 168 unsigned int num); 169/* These routines moved to gen_bitmap64.c */ 170extern void ext2fs_clear_generic_bmap(ext2fs_generic_bitmap bitmap); 171extern errcode_t ext2fs_compare_generic_bmap(errcode_t neq, 172 ext2fs_generic_bitmap bm1, 173 ext2fs_generic_bitmap bm2); 174extern void ext2fs_set_generic_bmap_padding(ext2fs_generic_bitmap bmap); 175extern int ext2fs_mark_generic_bmap(ext2fs_generic_bitmap bitmap, 176 blk64_t bitno); 177extern int ext2fs_unmark_generic_bmap(ext2fs_generic_bitmap bitmap, 178 blk64_t bitno); 179extern int ext2fs_test_generic_bmap(ext2fs_generic_bitmap bitmap, 180 blk64_t bitno); 181extern int ext2fs_test_block_bitmap_range2(ext2fs_block_bitmap bitmap, 182 blk64_t block, unsigned int num); 183extern __u64 ext2fs_get_generic_bmap_start(ext2fs_generic_bitmap bitmap); 184extern __u64 ext2fs_get_generic_bmap_end(ext2fs_generic_bitmap bitmap); 185extern int ext2fs_test_block_bitmap_range2(ext2fs_block_bitmap bitmap, 186 blk64_t block, unsigned int num); 187extern void ext2fs_mark_block_bitmap_range2(ext2fs_block_bitmap bitmap, 188 blk64_t block, unsigned int num); 189extern void ext2fs_unmark_block_bitmap_range2(ext2fs_block_bitmap bitmap, 190 blk64_t block, unsigned int num); 191 192/* 193 * The inline routines themselves... 194 * 195 * If NO_INLINE_FUNCS is defined, then we won't try to do inline 196 * functions at all; they will be included as normal functions in 197 * inline.c 198 */ 199#ifdef NO_INLINE_FUNCS 200#if (defined(__GNUC__) && (defined(__i386__) || defined(__i486__) || \ 201 defined(__i586__) || defined(__mc68000__))) 202 /* This prevents bitops.c from trying to include the C */ 203 /* function version of these functions */ 204#define _EXT2_HAVE_ASM_BITOPS_ 205#endif 206#endif /* NO_INLINE_FUNCS */ 207 208#if (defined(INCLUDE_INLINE_FUNCS) || !defined(NO_INLINE_FUNCS)) 209#ifdef INCLUDE_INLINE_FUNCS 210#define _INLINE_ extern 211#else 212#ifdef __GNUC__ 213#define _INLINE_ extern __inline__ 214#else /* For Watcom C */ 215#define _INLINE_ extern inline 216#endif 217#endif 218 219/* 220 * Fast bit set/clear functions that doesn't need to return the 221 * previous bit value. 222 */ 223 224_INLINE_ void ext2fs_fast_set_bit(unsigned int nr,void * addr) 225{ 226 unsigned char *ADDR = (unsigned char *) addr; 227 228 ADDR += nr >> 3; 229 *ADDR |= (1 << (nr & 0x07)); 230} 231 232_INLINE_ void ext2fs_fast_clear_bit(unsigned int nr, void * addr) 233{ 234 unsigned char *ADDR = (unsigned char *) addr; 235 236 ADDR += nr >> 3; 237 *ADDR &= ~(1 << (nr & 0x07)); 238} 239 240 241_INLINE_ void ext2fs_fast_set_bit64(__u64 nr, void * addr) 242{ 243 unsigned char *ADDR = (unsigned char *) addr; 244 245 ADDR += nr >> 3; 246 *ADDR |= (1 << (nr & 0x07)); 247} 248 249_INLINE_ void ext2fs_fast_clear_bit64(__u64 nr, void * addr) 250{ 251 unsigned char *ADDR = (unsigned char *) addr; 252 253 ADDR += nr >> 3; 254 *ADDR &= ~(1 << (nr & 0x07)); 255} 256 257 258#if ((defined __GNUC__) && !defined(_EXT2_USE_C_VERSIONS_) && \ 259 (defined(__i386__) || defined(__i486__) || defined(__i586__))) 260 261#define _EXT2_HAVE_ASM_BITOPS_ 262#define _EXT2_HAVE_ASM_SWAB_ 263 264/* 265 * These are done by inline assembly for speed reasons..... 266 * 267 * All bitoperations return 0 if the bit was cleared before the 268 * operation and != 0 if it was not. Bit 0 is the LSB of addr; bit 32 269 * is the LSB of (addr+1). 270 */ 271 272/* 273 * Some hacks to defeat gcc over-optimizations.. 274 */ 275struct __dummy_h { unsigned long a[100]; }; 276#define EXT2FS_ADDR (*(struct __dummy_h *) addr) 277#define EXT2FS_CONST_ADDR (*(const struct __dummy_h *) addr) 278 279_INLINE_ int ext2fs_set_bit(unsigned int nr, void * addr) 280{ 281 int oldbit; 282 283 addr = (void *) (((unsigned char *) addr) + (nr >> 3)); 284 __asm__ __volatile__("btsl %2,%1\n\tsbbl %0,%0" 285 :"=r" (oldbit),"+m" (EXT2FS_ADDR) 286 :"r" (nr & 7)); 287 return oldbit; 288} 289 290_INLINE_ int ext2fs_clear_bit(unsigned int nr, void * addr) 291{ 292 int oldbit; 293 294 addr = (void *) (((unsigned char *) addr) + (nr >> 3)); 295 __asm__ __volatile__("btrl %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_test_bit(unsigned int nr, const void * addr) 302{ 303 int oldbit; 304 305 addr = (const void *) (((const unsigned char *) addr) + (nr >> 3)); 306 __asm__ __volatile__("btl %2,%1\n\tsbbl %0,%0" 307 :"=r" (oldbit) 308 :"m" (EXT2FS_CONST_ADDR),"r" (nr & 7)); 309 return oldbit; 310} 311 312_INLINE_ __u32 ext2fs_swab32(__u32 val) 313{ 314#ifdef EXT2FS_REQUIRE_486 315 __asm__("bswap %0" : "=r" (val) : "0" (val)); 316#else 317 __asm__("xchgb %b0,%h0\n\t" /* swap lower bytes */ 318 "rorl $16,%0\n\t" /* swap words */ 319 "xchgb %b0,%h0" /* swap higher bytes */ 320 :"=q" (val) 321 : "0" (val)); 322#endif 323 return val; 324} 325 326_INLINE_ __u16 ext2fs_swab16(__u16 val) 327{ 328 __asm__("xchgb %b0,%h0" /* swap bytes */ \ 329 : "=q" (val) \ 330 : "0" (val)); \ 331 return val; 332} 333 334#undef EXT2FS_ADDR 335 336#endif /* i386 */ 337 338#if ((defined __GNUC__) && !defined(_EXT2_USE_C_VERSIONS_) && \ 339 (defined(__mc68000__))) 340 341#define _EXT2_HAVE_ASM_BITOPS_ 342 343_INLINE_ int ext2fs_set_bit(unsigned int nr,void * addr) 344{ 345 char retval; 346 347 __asm__ __volatile__ ("bfset %2@{%1:#1}; sne %0" 348 : "=d" (retval) : "d" (nr^7), "a" (addr)); 349 350 return retval; 351} 352 353_INLINE_ int ext2fs_clear_bit(unsigned int nr, void * addr) 354{ 355 char retval; 356 357 __asm__ __volatile__ ("bfclr %2@{%1:#1}; sne %0" 358 : "=d" (retval) : "d" (nr^7), "a" (addr)); 359 360 return retval; 361} 362 363_INLINE_ int ext2fs_test_bit(unsigned int nr, const void * addr) 364{ 365 char retval; 366 367 __asm__ __volatile__ ("bftst %2@{%1:#1}; sne %0" 368 : "=d" (retval) : "d" (nr^7), "a" (addr)); 369 370 return retval; 371} 372 373#endif /* __mc68000__ */ 374 375 376#if !defined(_EXT2_HAVE_ASM_SWAB_) 377 378_INLINE_ __u16 ext2fs_swab16(__u16 val) 379{ 380 return (val >> 8) | (val << 8); 381} 382 383_INLINE_ __u32 ext2fs_swab32(__u32 val) 384{ 385 return ((val>>24) | ((val>>8)&0xFF00) | 386 ((val<<8)&0xFF0000) | (val<<24)); 387} 388 389#endif /* !_EXT2_HAVE_ASM_SWAB */ 390 391_INLINE_ __u64 ext2fs_swab64(__u64 val) 392{ 393 return (ext2fs_swab32(val >> 32) | 394 (((__u64)ext2fs_swab32(val & 0xFFFFFFFFUL)) << 32)); 395} 396 397_INLINE_ int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap, 398 blk_t block) 399{ 400 return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, 401 block); 402} 403 404_INLINE_ int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap, 405 blk_t block) 406{ 407 return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, 408 block); 409} 410 411_INLINE_ int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap, 412 blk_t block) 413{ 414 return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, 415 block); 416} 417 418_INLINE_ int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, 419 ext2_ino_t inode) 420{ 421 return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, 422 inode); 423} 424 425_INLINE_ int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap, 426 ext2_ino_t inode) 427{ 428 return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, 429 inode); 430} 431 432_INLINE_ int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap, 433 ext2_ino_t inode) 434{ 435 return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, 436 inode); 437} 438 439_INLINE_ void ext2fs_fast_mark_block_bitmap(ext2fs_block_bitmap bitmap, 440 blk_t block) 441{ 442 ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, block); 443} 444 445_INLINE_ void ext2fs_fast_unmark_block_bitmap(ext2fs_block_bitmap bitmap, 446 blk_t block) 447{ 448 ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, block); 449} 450 451_INLINE_ int ext2fs_fast_test_block_bitmap(ext2fs_block_bitmap bitmap, 452 blk_t block) 453{ 454 return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, 455 block); 456} 457 458_INLINE_ void ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, 459 ext2_ino_t inode) 460{ 461 ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, inode); 462} 463 464_INLINE_ void ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap, 465 ext2_ino_t inode) 466{ 467 ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, inode); 468} 469 470_INLINE_ int ext2fs_fast_test_inode_bitmap(ext2fs_inode_bitmap bitmap, 471 ext2_ino_t inode) 472{ 473 return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, 474 inode); 475} 476 477_INLINE_ blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap) 478{ 479 return ext2fs_get_generic_bitmap_start((ext2fs_generic_bitmap) bitmap); 480} 481 482_INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap) 483{ 484 return ext2fs_get_generic_bitmap_start((ext2fs_generic_bitmap) bitmap); 485} 486 487_INLINE_ blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap) 488{ 489 return ext2fs_get_generic_bitmap_end((ext2fs_generic_bitmap) bitmap); 490} 491 492_INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap) 493{ 494 return ext2fs_get_generic_bitmap_end((ext2fs_generic_bitmap) bitmap); 495} 496 497_INLINE_ int ext2fs_fast_test_block_bitmap_range(ext2fs_block_bitmap bitmap, 498 blk_t block, int num) 499{ 500 return ext2fs_test_block_bitmap_range(bitmap, block, num); 501} 502 503_INLINE_ void ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap, 504 blk_t block, int num) 505{ 506 ext2fs_mark_block_bitmap_range(bitmap, block, num); 507} 508 509_INLINE_ void ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap, 510 blk_t block, int num) 511{ 512 ext2fs_unmark_block_bitmap_range(bitmap, block, num); 513} 514 515/* 64-bit versions */ 516 517_INLINE_ int ext2fs_mark_block_bitmap2(ext2fs_block_bitmap bitmap, 518 blk64_t block) 519{ 520 return ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, 521 block); 522} 523 524_INLINE_ int ext2fs_unmark_block_bitmap2(ext2fs_block_bitmap bitmap, 525 blk64_t block) 526{ 527 return ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, block); 528} 529 530_INLINE_ int ext2fs_test_block_bitmap2(ext2fs_block_bitmap bitmap, 531 blk64_t block) 532{ 533 return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap, 534 block); 535} 536 537_INLINE_ int ext2fs_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap, 538 ext2_ino_t inode) 539{ 540 return ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, 541 inode); 542} 543 544_INLINE_ int ext2fs_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap, 545 ext2_ino_t inode) 546{ 547 return ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, 548 inode); 549} 550 551_INLINE_ int ext2fs_test_inode_bitmap2(ext2fs_inode_bitmap bitmap, 552 ext2_ino_t inode) 553{ 554 return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap, 555 inode); 556} 557 558_INLINE_ void ext2fs_fast_mark_block_bitmap2(ext2fs_block_bitmap bitmap, 559 blk64_t block) 560{ 561 ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, block); 562} 563 564_INLINE_ void ext2fs_fast_unmark_block_bitmap2(ext2fs_block_bitmap bitmap, 565 blk64_t block) 566{ 567 ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, block); 568} 569 570_INLINE_ int ext2fs_fast_test_block_bitmap2(ext2fs_block_bitmap bitmap, 571 blk64_t block) 572{ 573 return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap, 574 block); 575} 576 577_INLINE_ void ext2fs_fast_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap, 578 ext2_ino_t inode) 579{ 580 ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, inode); 581} 582 583_INLINE_ void ext2fs_fast_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap, 584 ext2_ino_t inode) 585{ 586 ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, inode); 587} 588 589_INLINE_ int ext2fs_fast_test_inode_bitmap2(ext2fs_inode_bitmap bitmap, 590 ext2_ino_t inode) 591{ 592 return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap, 593 inode); 594} 595 596_INLINE_ blk64_t ext2fs_get_block_bitmap_start2(ext2fs_block_bitmap bitmap) 597{ 598 return ext2fs_get_generic_bmap_start((ext2fs_generic_bitmap) bitmap); 599} 600 601_INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_start2(ext2fs_inode_bitmap bitmap) 602{ 603 return ext2fs_get_generic_bmap_start((ext2fs_generic_bitmap) bitmap); 604} 605 606_INLINE_ blk64_t ext2fs_get_block_bitmap_end2(ext2fs_block_bitmap bitmap) 607{ 608 return ext2fs_get_generic_bmap_end((ext2fs_generic_bitmap) bitmap); 609} 610 611_INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_end2(ext2fs_inode_bitmap bitmap) 612{ 613 return ext2fs_get_generic_bmap_end((ext2fs_generic_bitmap) bitmap); 614} 615 616_INLINE_ int ext2fs_fast_test_block_bitmap_range2(ext2fs_block_bitmap bitmap, 617 blk64_t block, 618 unsigned int num) 619{ 620 return ext2fs_test_block_bitmap_range2(bitmap, block, num); 621} 622 623_INLINE_ void ext2fs_fast_mark_block_bitmap_range2(ext2fs_block_bitmap bitmap, 624 blk64_t block, 625 unsigned int num) 626{ 627 ext2fs_mark_block_bitmap_range2(bitmap, block, num); 628} 629 630_INLINE_ void ext2fs_fast_unmark_block_bitmap_range2(ext2fs_block_bitmap bitmap, 631 blk64_t block, 632 unsigned int num) 633{ 634 ext2fs_unmark_block_bitmap_range2(bitmap, block, num); 635} 636 637#undef _INLINE_ 638#endif 639 640