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