• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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