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
ext2fs_fast_set_bit(unsigned int nr,void * addr)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
ext2fs_fast_clear_bit(unsigned int nr,void * addr)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
ext2fs_fast_set_bit64(__u64 nr,void * addr)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
ext2fs_fast_clear_bit64(__u64 nr,void * addr)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
ext2fs_set_bit(unsigned int nr,void * addr)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
ext2fs_clear_bit(unsigned int nr,void * addr)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
ext2fs_test_bit(unsigned int nr,const void * addr)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
ext2fs_swab32(__u32 val)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
ext2fs_swab16(__u16 val)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
ext2fs_swab16(__u16 val)372 _INLINE_ __u16 ext2fs_swab16(__u16 val)
373 {
374 return (val >> 8) | (__u16) (val << 8);
375 }
376
ext2fs_swab32(__u32 val)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
ext2fs_swab64(__u64 val)385 _INLINE_ __u64 ext2fs_swab64(__u64 val)
386 {
387 return (ext2fs_swab32((__u32) (val >> 32)) |
388 (((__u64)ext2fs_swab32(val & 0xFFFFFFFFUL)) << 32));
389 }
390
ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap,blk_t block)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
ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap,blk_t block)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
ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap,blk_t block)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
ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,ext2_ino_t inode)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
ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,ext2_ino_t inode)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
ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap,ext2_ino_t inode)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
ext2fs_fast_mark_block_bitmap(ext2fs_block_bitmap bitmap,blk_t block)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
ext2fs_fast_unmark_block_bitmap(ext2fs_block_bitmap bitmap,blk_t block)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
ext2fs_fast_test_block_bitmap(ext2fs_block_bitmap bitmap,blk_t block)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
ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,ext2_ino_t inode)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
ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,ext2_ino_t inode)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
ext2fs_fast_test_inode_bitmap(ext2fs_inode_bitmap bitmap,ext2_ino_t inode)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
ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap)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
ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap)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
ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap)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
ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap)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
ext2fs_fast_test_block_bitmap_range(ext2fs_block_bitmap bitmap,blk_t block,int num)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
ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,blk_t block,int num)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
ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,blk_t block,int num)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
ext2fs_mark_block_bitmap2(ext2fs_block_bitmap bitmap,blk64_t block)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
ext2fs_unmark_block_bitmap2(ext2fs_block_bitmap bitmap,blk64_t block)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
ext2fs_test_block_bitmap2(ext2fs_block_bitmap bitmap,blk64_t block)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
ext2fs_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap,ext2_ino_t inode)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
ext2fs_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap,ext2_ino_t inode)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
ext2fs_test_inode_bitmap2(ext2fs_inode_bitmap bitmap,ext2_ino_t inode)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
ext2fs_fast_mark_block_bitmap2(ext2fs_block_bitmap bitmap,blk64_t block)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
ext2fs_fast_unmark_block_bitmap2(ext2fs_block_bitmap bitmap,blk64_t block)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
ext2fs_fast_test_block_bitmap2(ext2fs_block_bitmap bitmap,blk64_t block)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
ext2fs_fast_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap,ext2_ino_t inode)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
ext2fs_fast_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap,ext2_ino_t inode)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
ext2fs_fast_test_inode_bitmap2(ext2fs_inode_bitmap bitmap,ext2_ino_t inode)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
ext2fs_find_first_zero_block_bitmap2(ext2fs_block_bitmap bitmap,blk64_t start,blk64_t end,blk64_t * out)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
ext2fs_find_first_zero_inode_bitmap2(ext2fs_inode_bitmap bitmap,ext2_ino_t start,ext2_ino_t end,ext2_ino_t * out)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
ext2fs_find_first_set_block_bitmap2(ext2fs_block_bitmap bitmap,blk64_t start,blk64_t end,blk64_t * out)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
ext2fs_find_first_set_inode_bitmap2(ext2fs_inode_bitmap bitmap,ext2_ino_t start,ext2_ino_t end,ext2_ino_t * out)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
ext2fs_get_block_bitmap_start2(ext2fs_block_bitmap bitmap)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
ext2fs_get_inode_bitmap_start2(ext2fs_inode_bitmap bitmap)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
ext2fs_get_block_bitmap_end2(ext2fs_block_bitmap bitmap)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
ext2fs_get_inode_bitmap_end2(ext2fs_inode_bitmap bitmap)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
ext2fs_fast_test_block_bitmap_range2(ext2fs_block_bitmap bitmap,blk64_t block,unsigned int num)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
ext2fs_fast_mark_block_bitmap_range2(ext2fs_block_bitmap bitmap,blk64_t block,unsigned int num)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
ext2fs_fast_unmark_block_bitmap_range2(ext2fs_block_bitmap bitmap,blk64_t block,unsigned int num)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);
704