bitops.h revision dbe5c43b2e6fcc8fe831a134fbc3dda1f5dd0733
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__))) 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 349#if !defined(_EXT2_HAVE_ASM_SWAB_) 350 351_INLINE_ __u16 ext2fs_swab16(__u16 val) 352{ 353 return (val >> 8) | (val << 8); 354} 355 356_INLINE_ __u32 ext2fs_swab32(__u32 val) 357{ 358 return ((val>>24) | ((val>>8)&0xFF00) | 359 ((val<<8)&0xFF0000) | (val<<24)); 360} 361 362#endif /* !_EXT2_HAVE_ASM_SWAB */ 363 364_INLINE_ __u64 ext2fs_swab64(__u64 val) 365{ 366 return (ext2fs_swab32(val >> 32) | 367 (((__u64)ext2fs_swab32(val & 0xFFFFFFFFUL)) << 32)); 368} 369 370_INLINE_ int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap, 371 blk_t block) 372{ 373 return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, 374 block); 375} 376 377_INLINE_ int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap, 378 blk_t block) 379{ 380 return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, 381 block); 382} 383 384_INLINE_ int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap, 385 blk_t block) 386{ 387 return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, 388 block); 389} 390 391_INLINE_ int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, 392 ext2_ino_t inode) 393{ 394 return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, 395 inode); 396} 397 398_INLINE_ int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap, 399 ext2_ino_t inode) 400{ 401 return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, 402 inode); 403} 404 405_INLINE_ int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap, 406 ext2_ino_t inode) 407{ 408 return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, 409 inode); 410} 411 412_INLINE_ void ext2fs_fast_mark_block_bitmap(ext2fs_block_bitmap bitmap, 413 blk_t block) 414{ 415 ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, block); 416} 417 418_INLINE_ void ext2fs_fast_unmark_block_bitmap(ext2fs_block_bitmap bitmap, 419 blk_t block) 420{ 421 ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, block); 422} 423 424_INLINE_ int ext2fs_fast_test_block_bitmap(ext2fs_block_bitmap bitmap, 425 blk_t block) 426{ 427 return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap, 428 block); 429} 430 431_INLINE_ void ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, 432 ext2_ino_t inode) 433{ 434 ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, inode); 435} 436 437_INLINE_ void ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap, 438 ext2_ino_t inode) 439{ 440 ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, inode); 441} 442 443_INLINE_ int ext2fs_fast_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_ blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap) 451{ 452 return ext2fs_get_generic_bitmap_start((ext2fs_generic_bitmap) bitmap); 453} 454 455_INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap) 456{ 457 return ext2fs_get_generic_bitmap_start((ext2fs_generic_bitmap) bitmap); 458} 459 460_INLINE_ blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap) 461{ 462 return ext2fs_get_generic_bitmap_end((ext2fs_generic_bitmap) bitmap); 463} 464 465_INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap) 466{ 467 return ext2fs_get_generic_bitmap_end((ext2fs_generic_bitmap) bitmap); 468} 469 470_INLINE_ int ext2fs_fast_test_block_bitmap_range(ext2fs_block_bitmap bitmap, 471 blk_t block, int num) 472{ 473 return ext2fs_test_block_bitmap_range(bitmap, block, num); 474} 475 476_INLINE_ void ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap, 477 blk_t block, int num) 478{ 479 ext2fs_mark_block_bitmap_range(bitmap, block, num); 480} 481 482_INLINE_ void ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap, 483 blk_t block, int num) 484{ 485 ext2fs_unmark_block_bitmap_range(bitmap, block, num); 486} 487 488/* 64-bit versions */ 489 490_INLINE_ int ext2fs_mark_block_bitmap2(ext2fs_block_bitmap bitmap, 491 blk64_t block) 492{ 493 return ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, 494 block); 495} 496 497_INLINE_ int ext2fs_unmark_block_bitmap2(ext2fs_block_bitmap bitmap, 498 blk64_t block) 499{ 500 return ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, block); 501} 502 503_INLINE_ int ext2fs_test_block_bitmap2(ext2fs_block_bitmap bitmap, 504 blk64_t block) 505{ 506 return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap, 507 block); 508} 509 510_INLINE_ int ext2fs_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap, 511 ext2_ino_t inode) 512{ 513 return ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, 514 inode); 515} 516 517_INLINE_ int ext2fs_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap, 518 ext2_ino_t inode) 519{ 520 return ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, 521 inode); 522} 523 524_INLINE_ int ext2fs_test_inode_bitmap2(ext2fs_inode_bitmap bitmap, 525 ext2_ino_t inode) 526{ 527 return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap, 528 inode); 529} 530 531_INLINE_ void ext2fs_fast_mark_block_bitmap2(ext2fs_block_bitmap bitmap, 532 blk64_t block) 533{ 534 ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, block); 535} 536 537_INLINE_ void ext2fs_fast_unmark_block_bitmap2(ext2fs_block_bitmap bitmap, 538 blk64_t block) 539{ 540 ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, block); 541} 542 543_INLINE_ int ext2fs_fast_test_block_bitmap2(ext2fs_block_bitmap bitmap, 544 blk64_t block) 545{ 546 return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap, 547 block); 548} 549 550_INLINE_ void ext2fs_fast_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap, 551 ext2_ino_t inode) 552{ 553 ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, inode); 554} 555 556_INLINE_ void ext2fs_fast_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap, 557 ext2_ino_t inode) 558{ 559 ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, inode); 560} 561 562_INLINE_ int ext2fs_fast_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_ errcode_t ext2fs_find_first_zero_block_bitmap2(ext2fs_block_bitmap bitmap, 570 blk64_t start, 571 blk64_t end, 572 blk64_t *out) 573{ 574 __u64 o; 575 errcode_t rv; 576 577 rv = ext2fs_find_first_zero_generic_bmap((ext2fs_generic_bitmap) bitmap, 578 start, end, &o); 579 if (!rv) 580 *out = o; 581 return rv; 582} 583 584_INLINE_ errcode_t ext2fs_find_first_zero_inode_bitmap2(ext2fs_inode_bitmap bitmap, 585 ext2_ino_t start, 586 ext2_ino_t end, 587 ext2_ino_t *out) 588{ 589 __u64 o; 590 errcode_t rv; 591 592 rv = ext2fs_find_first_zero_generic_bmap((ext2fs_generic_bitmap) bitmap, 593 start, end, &o); 594 if (!rv) 595 *out = o; 596 return rv; 597} 598 599_INLINE_ blk64_t ext2fs_get_block_bitmap_start2(ext2fs_block_bitmap bitmap) 600{ 601 return ext2fs_get_generic_bmap_start((ext2fs_generic_bitmap) bitmap); 602} 603 604_INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_start2(ext2fs_inode_bitmap bitmap) 605{ 606 return ext2fs_get_generic_bmap_start((ext2fs_generic_bitmap) bitmap); 607} 608 609_INLINE_ blk64_t ext2fs_get_block_bitmap_end2(ext2fs_block_bitmap bitmap) 610{ 611 return ext2fs_get_generic_bmap_end((ext2fs_generic_bitmap) bitmap); 612} 613 614_INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_end2(ext2fs_inode_bitmap bitmap) 615{ 616 return ext2fs_get_generic_bmap_end((ext2fs_generic_bitmap) bitmap); 617} 618 619_INLINE_ int ext2fs_fast_test_block_bitmap_range2(ext2fs_block_bitmap bitmap, 620 blk64_t block, 621 unsigned int num) 622{ 623 return ext2fs_test_block_bitmap_range2(bitmap, block, num); 624} 625 626_INLINE_ void ext2fs_fast_mark_block_bitmap_range2(ext2fs_block_bitmap bitmap, 627 blk64_t block, 628 unsigned int num) 629{ 630 ext2fs_mark_block_bitmap_range2(bitmap, block, num); 631} 632 633_INLINE_ void ext2fs_fast_unmark_block_bitmap_range2(ext2fs_block_bitmap bitmap, 634 blk64_t block, 635 unsigned int num) 636{ 637 ext2fs_unmark_block_bitmap_range2(bitmap, block, num); 638} 639 640#undef _INLINE_ 641#endif 642 643#ifndef _EXT2_HAVE_ASM_BITOPS_ 644extern int ext2fs_set_bit(unsigned int nr,void * addr); 645extern int ext2fs_clear_bit(unsigned int nr, void * addr); 646extern int ext2fs_test_bit(unsigned int nr, const void * addr); 647#endif 648 649extern int ext2fs_set_bit64(__u64 nr,void * addr); 650extern int ext2fs_clear_bit64(__u64 nr, void * addr); 651extern int ext2fs_test_bit64(__u64 nr, const void * addr); 652extern unsigned int ext2fs_bitcount(const void *addr, unsigned int nbytes); 653 654#ifdef NO_INLINE_FUNCS 655extern void ext2fs_fast_set_bit(unsigned int nr,void * addr); 656extern void ext2fs_fast_clear_bit(unsigned int nr, void * addr); 657extern void ext2fs_fast_set_bit64(__u64 nr,void * addr); 658extern void ext2fs_fast_clear_bit64(__u64 nr, void * addr); 659extern __u16 ext2fs_swab16(__u16 val); 660extern __u32 ext2fs_swab32(__u32 val); 661extern __u64 ext2fs_swab64(__u64 val); 662#endif 663 664