1997-04-26 17:21:57 +04:00
|
|
|
/*
|
1997-04-26 17:58:21 +04:00
|
|
|
* bitops.h --- Bitmap frobbing code. The byte swapping routines are
|
|
|
|
* also included here.
|
1997-04-26 17:21:57 +04:00
|
|
|
*
|
1997-04-29 20:15:03 +04:00
|
|
|
* Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
|
|
|
|
*
|
|
|
|
* %Begin-Header%
|
|
|
|
* This file may be redistributed under the terms of the GNU Public
|
|
|
|
* License.
|
|
|
|
* %End-Header%
|
1997-04-26 17:21:57 +04:00
|
|
|
*
|
1997-04-29 20:15:03 +04:00
|
|
|
* i386 bitops operations taken from <asm/bitops.h>, Copyright 1992,
|
|
|
|
* Linus Torvalds.
|
1997-04-26 17:21:57 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
1997-04-26 18:37:06 +04:00
|
|
|
extern int ext2fs_set_bit(int nr,void * addr);
|
|
|
|
extern int ext2fs_clear_bit(int nr, void * addr);
|
|
|
|
extern int ext2fs_test_bit(int nr, const void * addr);
|
1997-04-26 17:58:21 +04:00
|
|
|
extern __u16 ext2fs_swab16(__u16 val);
|
|
|
|
extern __u32 ext2fs_swab32(__u32 val);
|
1997-04-26 17:21:57 +04:00
|
|
|
|
2002-06-28 16:10:29 +04:00
|
|
|
#ifdef WORDS_BIGENDIAN
|
|
|
|
#define ext2fs_cpu_to_le32(x) ext2fs_swab32((x))
|
|
|
|
#define ext2fs_le32_to_cpu(x) ext2fs_swab32((x))
|
|
|
|
#define ext2fs_cpu_to_le16(x) ext2fs_swab16((x))
|
|
|
|
#define ext2fs_le16_to_cpu(x) ext2fs_swab16((x))
|
|
|
|
#define ext2fs_cpu_to_be32(x) ((__u32)(x))
|
|
|
|
#define ext2fs_be32_to_cpu(x) ((__u32)(x))
|
|
|
|
#define ext2fs_cpu_to_be16(x) ((__u16)(x))
|
|
|
|
#define ext2fs_be16_to_cpu(x) ((__u16)(x))
|
|
|
|
#else
|
|
|
|
#define ext2fs_cpu_to_le32(x) ((__u32)(x))
|
|
|
|
#define ext2fs_le32_to_cpu(x) ((__u32)(x))
|
|
|
|
#define ext2fs_cpu_to_le16(x) ((__u16)(x))
|
|
|
|
#define ext2fs_le16_to_cpu(x) ((__u16)(x))
|
|
|
|
#define ext2fs_cpu_to_be32(x) ext2fs_swab32((x))
|
|
|
|
#define ext2fs_be32_to_cpu(x) ext2fs_swab32((x))
|
|
|
|
#define ext2fs_cpu_to_be16(x) ext2fs_swab16((x))
|
|
|
|
#define ext2fs_be16_to_cpu(x) ext2fs_swab16((x))
|
|
|
|
#endif
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
/*
|
|
|
|
* EXT2FS bitmap manipulation routines.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Support for sending warning messages from the inline subroutines */
|
|
|
|
extern const char *ext2fs_block_string;
|
|
|
|
extern const char *ext2fs_inode_string;
|
|
|
|
extern const char *ext2fs_mark_string;
|
|
|
|
extern const char *ext2fs_unmark_string;
|
|
|
|
extern const char *ext2fs_test_string;
|
1997-04-26 17:34:30 +04:00
|
|
|
extern void ext2fs_warn_bitmap(errcode_t errcode, unsigned long arg,
|
|
|
|
const char *description);
|
1997-04-29 18:53:37 +04:00
|
|
|
extern void ext2fs_warn_bitmap2(ext2fs_generic_bitmap bitmap,
|
|
|
|
int code, unsigned long arg);
|
1997-04-26 17:34:30 +04:00
|
|
|
|
ChangeLog, bitops.h:
bitops.h (ext2fs_mark_generic_bitmap, ext2fs_unmark_generic_bitmap,
ext2fs_mark_block_bitmap, ext2fs_unmark_block_bitmap,
ext2fs_mark_inode_bitmap, ext2fs_unmark_inode_bitmap): Change to
return the previous state of the bit that is being marked or unmarked.
For speed optimization.
ChangeLog, pass3.c:
pass3.c (check_directory): Only do the loop detection algorithm if
we've searched over 2048 parent directories and haven't found the end
yet. This means that in the common case, we don't allocate or clear
the inode_loop_detection bitmap, which for large systems, merely
clearing the bitmap for each directory was turning out to be quite
expensive. Thanks to Jani Jaakkola (jjaakkol@cs.helsinki.fi) for
identifying this problem.
ChangeLog, Makefile.in, e2fsck.h, unix.c:
Makefile.in: Call sync after finishing building all in this directory.
unix.c (PRS): sync the filesystem before trying to use BLKFLSBUF, to
minimize the chance of causing dirty blocks to get dropped.
e2fsck.h: Manually define BLKFLSBUF if not defined, and we're on a
Linux/i386 system.
2000-02-08 22:14:02 +03:00
|
|
|
extern int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block);
|
|
|
|
extern int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
|
1997-04-26 17:34:30 +04:00
|
|
|
blk_t block);
|
|
|
|
extern int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap, blk_t block);
|
|
|
|
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
extern int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode);
|
ChangeLog, bitops.h:
bitops.h (ext2fs_mark_generic_bitmap, ext2fs_unmark_generic_bitmap,
ext2fs_mark_block_bitmap, ext2fs_unmark_block_bitmap,
ext2fs_mark_inode_bitmap, ext2fs_unmark_inode_bitmap): Change to
return the previous state of the bit that is being marked or unmarked.
For speed optimization.
ChangeLog, pass3.c:
pass3.c (check_directory): Only do the loop detection algorithm if
we've searched over 2048 parent directories and haven't found the end
yet. This means that in the common case, we don't allocate or clear
the inode_loop_detection bitmap, which for large systems, merely
clearing the bitmap for each directory was turning out to be quite
expensive. Thanks to Jani Jaakkola (jjaakkol@cs.helsinki.fi) for
identifying this problem.
ChangeLog, Makefile.in, e2fsck.h, unix.c:
Makefile.in: Call sync after finishing building all in this directory.
unix.c (PRS): sync the filesystem before trying to use BLKFLSBUF, to
minimize the chance of causing dirty blocks to get dropped.
e2fsck.h: Manually define BLKFLSBUF if not defined, and we're on a
Linux/i386 system.
2000-02-08 22:14:02 +03:00
|
|
|
extern int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
ext2_ino_t inode);
|
|
|
|
extern int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap, ext2_ino_t inode);
|
1997-04-26 17:21:57 +04:00
|
|
|
|
1997-04-26 17:58:21 +04:00
|
|
|
extern void ext2fs_fast_mark_block_bitmap(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block);
|
|
|
|
extern void ext2fs_fast_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block);
|
|
|
|
extern int ext2fs_fast_test_block_bitmap(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block);
|
|
|
|
|
|
|
|
extern void ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
ext2_ino_t inode);
|
1997-04-26 17:58:21 +04:00
|
|
|
extern void ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
ext2_ino_t inode);
|
1997-04-26 17:58:21 +04:00
|
|
|
extern int ext2fs_fast_test_inode_bitmap(ext2fs_inode_bitmap bitmap,
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
ext2_ino_t inode);
|
1997-04-26 17:58:21 +04:00
|
|
|
extern blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap);
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
extern ext2_ino_t ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap);
|
1997-04-26 17:58:21 +04:00
|
|
|
extern blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap);
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
extern ext2_ino_t ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap);
|
1997-04-29 20:15:03 +04:00
|
|
|
|
|
|
|
extern void ext2fs_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num);
|
|
|
|
extern void ext2fs_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num);
|
|
|
|
extern int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num);
|
|
|
|
extern void ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num);
|
|
|
|
extern void ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num);
|
|
|
|
extern int ext2fs_fast_test_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num);
|
1997-09-13 04:32:29 +04:00
|
|
|
extern void ext2fs_set_bitmap_padding(ext2fs_generic_bitmap map);
|
1997-04-26 17:58:21 +04:00
|
|
|
|
2001-12-17 07:23:37 +03:00
|
|
|
/* These two routines moved to gen_bitmap.c */
|
|
|
|
extern int ext2fs_mark_generic_bitmap(ext2fs_generic_bitmap bitmap,
|
|
|
|
__u32 bitno);
|
|
|
|
extern int ext2fs_unmark_generic_bitmap(ext2fs_generic_bitmap bitmap,
|
|
|
|
blk_t bitno);
|
1997-04-26 17:21:57 +04:00
|
|
|
/*
|
|
|
|
* The inline routines themselves...
|
|
|
|
*
|
|
|
|
* If NO_INLINE_FUNCS is defined, then we won't try to do inline
|
1997-04-26 17:58:21 +04:00
|
|
|
* functions at all; they will be included as normal functions in
|
|
|
|
* inline.c
|
1997-04-26 17:21:57 +04:00
|
|
|
*/
|
1997-04-26 17:58:21 +04:00
|
|
|
#ifdef NO_INLINE_FUNCS
|
1998-02-01 16:23:02 +03:00
|
|
|
#if (defined(__GNUC__) && (defined(__i386__) || defined(__i486__) || \
|
|
|
|
defined(__i586__) || defined(__mc68000__) || \
|
|
|
|
defined(__sparc__)))
|
1997-04-26 17:58:21 +04:00
|
|
|
/* This prevents bitops.c from trying to include the C */
|
|
|
|
/* function version of these functions */
|
|
|
|
#define _EXT2_HAVE_ASM_BITOPS_
|
|
|
|
#endif
|
|
|
|
#endif /* NO_INLINE_FUNCS */
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
#if (defined(INCLUDE_INLINE_FUNCS) || !defined(NO_INLINE_FUNCS))
|
|
|
|
#ifdef INCLUDE_INLINE_FUNCS
|
|
|
|
#define _INLINE_ extern
|
|
|
|
#else
|
1998-04-27 05:41:13 +04:00
|
|
|
#ifdef __GNUC__
|
1997-04-26 17:21:57 +04:00
|
|
|
#define _INLINE_ extern __inline__
|
1998-04-27 05:41:13 +04:00
|
|
|
#else /* For Watcom C */
|
|
|
|
#define _INLINE_ extern inline
|
|
|
|
#endif
|
1997-04-26 17:21:57 +04:00
|
|
|
#endif
|
|
|
|
|
2001-07-04 22:04:58 +04:00
|
|
|
#if ((defined __GNUC__) && !defined(_EXT2_USE_C_VERSIONS_) && \
|
|
|
|
(defined(__i386__) || defined(__i486__) || defined(__i586__)))
|
1997-04-26 17:34:30 +04:00
|
|
|
|
|
|
|
#define _EXT2_HAVE_ASM_BITOPS_
|
2001-02-20 19:28:40 +03:00
|
|
|
#define _EXT2_HAVE_ASM_SWAB_
|
2001-07-04 22:04:58 +04:00
|
|
|
#define _EXT2_HAVE_ASM_FINDBIT_
|
2001-02-20 19:28:40 +03:00
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
/*
|
|
|
|
* These are done by inline assembly for speed reasons.....
|
|
|
|
*
|
|
|
|
* All bitoperations return 0 if the bit was cleared before the
|
|
|
|
* operation and != 0 if it was not. Bit 0 is the LSB of addr; bit 32
|
|
|
|
* is the LSB of (addr+1).
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some hacks to defeat gcc over-optimizations..
|
|
|
|
*/
|
|
|
|
struct __dummy_h { unsigned long a[100]; };
|
1997-04-26 18:37:06 +04:00
|
|
|
#define EXT2FS_ADDR (*(struct __dummy_h *) addr)
|
|
|
|
#define EXT2FS_CONST_ADDR (*(const struct __dummy_h *) addr)
|
1997-04-26 17:21:57 +04:00
|
|
|
|
1997-04-26 18:37:06 +04:00
|
|
|
_INLINE_ int ext2fs_set_bit(int nr, void * addr)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
|
|
|
int oldbit;
|
|
|
|
|
|
|
|
__asm__ __volatile__("btsl %2,%1\n\tsbbl %0,%0"
|
1997-04-26 18:37:06 +04:00
|
|
|
:"=r" (oldbit),"=m" (EXT2FS_ADDR)
|
1997-04-26 17:21:57 +04:00
|
|
|
:"r" (nr));
|
|
|
|
return oldbit;
|
|
|
|
}
|
|
|
|
|
1997-04-26 18:37:06 +04:00
|
|
|
_INLINE_ int ext2fs_clear_bit(int nr, void * addr)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
|
|
|
int oldbit;
|
|
|
|
|
|
|
|
__asm__ __volatile__("btrl %2,%1\n\tsbbl %0,%0"
|
1997-04-26 18:37:06 +04:00
|
|
|
:"=r" (oldbit),"=m" (EXT2FS_ADDR)
|
1997-04-26 17:21:57 +04:00
|
|
|
:"r" (nr));
|
|
|
|
return oldbit;
|
|
|
|
}
|
|
|
|
|
1997-04-26 18:37:06 +04:00
|
|
|
_INLINE_ int ext2fs_test_bit(int nr, const void * addr)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
|
|
|
int oldbit;
|
|
|
|
|
|
|
|
__asm__ __volatile__("btl %2,%1\n\tsbbl %0,%0"
|
|
|
|
:"=r" (oldbit)
|
1997-04-26 18:37:06 +04:00
|
|
|
:"m" (EXT2FS_CONST_ADDR),"r" (nr));
|
1997-04-26 17:21:57 +04:00
|
|
|
return oldbit;
|
|
|
|
}
|
|
|
|
|
2001-07-20 20:33:37 +04:00
|
|
|
#if 0
|
2001-07-04 22:04:58 +04:00
|
|
|
_INLINE_ int ext2fs_find_first_bit_set(void * addr, unsigned size)
|
|
|
|
{
|
|
|
|
int d0, d1, d2;
|
|
|
|
int res;
|
|
|
|
|
|
|
|
if (!size)
|
|
|
|
return 0;
|
|
|
|
/* This looks at memory. Mark it volatile to tell gcc not to move it around */
|
|
|
|
__asm__ __volatile__(
|
|
|
|
"cld\n\t"
|
|
|
|
"xorl %%eax,%%eax\n\t"
|
|
|
|
"xorl %%edx,%%edx\n\t"
|
|
|
|
"repe; scasl\n\t"
|
|
|
|
"je 1f\n\t"
|
|
|
|
"movl -4(%%edi),%%eax\n\t"
|
|
|
|
"subl $4,%%edi\n\t"
|
|
|
|
"bsfl %%eax,%%edx\n"
|
2001-07-08 06:14:23 +04:00
|
|
|
"1:\tsubl %%esi,%%edi\n\t"
|
2001-07-04 22:04:58 +04:00
|
|
|
"shll $3,%%edi\n\t"
|
|
|
|
"addl %%edi,%%edx"
|
|
|
|
:"=d" (res), "=&c" (d0), "=&D" (d1), "=&a" (d2)
|
2001-07-08 06:14:23 +04:00
|
|
|
:"1" ((size + 31) >> 5), "2" (addr), "S" (addr));
|
2001-07-04 22:04:58 +04:00
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_find_next_bit_set (void * addr, int size, int offset)
|
|
|
|
{
|
|
|
|
unsigned long * p = ((unsigned long *) addr) + (offset >> 5);
|
|
|
|
int set = 0, bit = offset & 31, res;
|
|
|
|
|
|
|
|
if (bit) {
|
|
|
|
/*
|
|
|
|
* Look for zero in first byte
|
|
|
|
*/
|
|
|
|
__asm__("bsfl %1,%0\n\t"
|
|
|
|
"jne 1f\n\t"
|
|
|
|
"movl $32, %0\n"
|
|
|
|
"1:"
|
|
|
|
: "=r" (set)
|
|
|
|
: "r" (*p >> bit));
|
|
|
|
if (set < (32 - bit))
|
|
|
|
return set + offset;
|
|
|
|
set = 32 - bit;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* No bit found yet, search remaining full bytes for a bit
|
|
|
|
*/
|
|
|
|
res = ext2fs_find_first_bit_set(p, size - 32 * (p - (unsigned long *) addr));
|
|
|
|
return (offset + set + res);
|
|
|
|
}
|
2001-07-20 20:33:37 +04:00
|
|
|
#endif
|
2001-07-04 22:04:58 +04:00
|
|
|
|
ChangeLog, Makefile.in, swapfs.c, unix.c:
Makefile.in: Add message.c and swapfs.c to the list of source files to
build the make depend.
swapfs.c, unix.c: Only support the -s and -S options to e2fsck if
ENABLE_SWAPFS is defined.
Many files:
ext2fs.h, bitops.h, block.c, bmap.c, closefs.c, dirblock.c, inode.c,
native.c, openfs.c, rw_bitmaps.c, swapfs.c: Only include the
byte-swapping logic if ENABLE_SWAPFS is turned on or if we're on a
big-endian machine.
initialize.c (ext2fs_initialize):Use WORDS_BIGENDIAN directly to set
EXT2_FLAG_SWAP_BYTES, instead of using ext2fs_native_flag.
native.c (ext2fs_native_flag): Use WORDS_BIGENDIAN provided by
autoconf to determine whether or not return EXT2_FLAG_SWAP_BYTES.
2001-06-11 11:00:04 +04:00
|
|
|
#ifdef EXT2FS_ENABLE_SWAPFS
|
2001-02-20 19:28:40 +03:00
|
|
|
_INLINE_ __u32 ext2fs_swab32(__u32 val)
|
|
|
|
{
|
|
|
|
#ifdef EXT2FS_REQUIRE_486
|
|
|
|
__asm__("bswap %0" : "=r" (val) : "0" (val));
|
|
|
|
#else
|
|
|
|
__asm__("xchgb %b0,%h0\n\t" /* swap lower bytes */
|
|
|
|
"rorl $16,%0\n\t" /* swap words */
|
|
|
|
"xchgb %b0,%h0" /* swap higher bytes */
|
|
|
|
:"=q" (val)
|
|
|
|
: "0" (val));
|
|
|
|
#endif
|
|
|
|
return val;
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ __u16 ext2fs_swab16(__u16 val)
|
|
|
|
{
|
|
|
|
__asm__("xchgb %b0,%h0" /* swap bytes */ \
|
|
|
|
: "=q" (val) \
|
|
|
|
: "0" (val)); \
|
|
|
|
return val;
|
|
|
|
}
|
ChangeLog, Makefile.in, swapfs.c, unix.c:
Makefile.in: Add message.c and swapfs.c to the list of source files to
build the make depend.
swapfs.c, unix.c: Only support the -s and -S options to e2fsck if
ENABLE_SWAPFS is defined.
Many files:
ext2fs.h, bitops.h, block.c, bmap.c, closefs.c, dirblock.c, inode.c,
native.c, openfs.c, rw_bitmaps.c, swapfs.c: Only include the
byte-swapping logic if ENABLE_SWAPFS is turned on or if we're on a
big-endian machine.
initialize.c (ext2fs_initialize):Use WORDS_BIGENDIAN directly to set
EXT2_FLAG_SWAP_BYTES, instead of using ext2fs_native_flag.
native.c (ext2fs_native_flag): Use WORDS_BIGENDIAN provided by
autoconf to determine whether or not return EXT2_FLAG_SWAP_BYTES.
2001-06-11 11:00:04 +04:00
|
|
|
#endif
|
2001-02-20 19:28:40 +03:00
|
|
|
|
1997-04-26 18:37:06 +04:00
|
|
|
#undef EXT2FS_ADDR
|
1997-04-26 17:21:57 +04:00
|
|
|
|
|
|
|
#endif /* i386 */
|
|
|
|
|
1997-04-26 17:34:30 +04:00
|
|
|
#ifdef __mc68000__
|
|
|
|
|
|
|
|
#define _EXT2_HAVE_ASM_BITOPS_
|
|
|
|
|
1997-04-26 18:37:06 +04:00
|
|
|
_INLINE_ int ext2fs_set_bit(int nr,void * addr)
|
1997-04-26 17:34:30 +04:00
|
|
|
{
|
|
|
|
char retval;
|
|
|
|
|
|
|
|
__asm__ __volatile__ ("bfset %2@{%1:#1}; sne %0"
|
1997-04-26 18:48:50 +04:00
|
|
|
: "=d" (retval) : "d" (nr^7), "a" (addr));
|
1997-04-26 17:34:30 +04:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
1997-04-26 18:37:06 +04:00
|
|
|
_INLINE_ int ext2fs_clear_bit(int nr, void * addr)
|
1997-04-26 17:34:30 +04:00
|
|
|
{
|
|
|
|
char retval;
|
|
|
|
|
|
|
|
__asm__ __volatile__ ("bfclr %2@{%1:#1}; sne %0"
|
1997-04-26 18:48:50 +04:00
|
|
|
: "=d" (retval) : "d" (nr^7), "a" (addr));
|
1997-04-26 17:34:30 +04:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
1997-04-26 18:37:06 +04:00
|
|
|
_INLINE_ int ext2fs_test_bit(int nr, const void * addr)
|
1997-04-26 17:34:30 +04:00
|
|
|
{
|
|
|
|
char retval;
|
|
|
|
|
|
|
|
__asm__ __volatile__ ("bftst %2@{%1:#1}; sne %0"
|
1997-04-26 18:48:50 +04:00
|
|
|
: "=d" (retval) : "d" (nr^7), "a" (addr));
|
1997-04-26 17:34:30 +04:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* __mc68000__ */
|
|
|
|
|
1997-04-26 17:58:21 +04:00
|
|
|
|
2001-06-23 04:54:11 +04:00
|
|
|
#if !defined(_EXT2_HAVE_ASM_SWAB_) && defined(EXT2FS_ENABLE_SWAPFS)
|
1997-04-26 17:58:21 +04:00
|
|
|
|
|
|
|
_INLINE_ __u16 ext2fs_swab16(__u16 val)
|
|
|
|
{
|
|
|
|
return (val >> 8) | (val << 8);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ __u32 ext2fs_swab32(__u32 val)
|
|
|
|
{
|
|
|
|
return ((val>>24) | ((val>>8)&0xFF00) |
|
|
|
|
((val<<8)&0xFF0000) | (val<<24));
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* !_EXT2_HAVE_ASM_SWAB */
|
|
|
|
|
2001-07-04 22:04:58 +04:00
|
|
|
#if !defined(_EXT2_HAVE_ASM_FINDBIT_)
|
|
|
|
_INLINE_ int ext2fs_find_first_bit_set(void * addr, unsigned size)
|
|
|
|
{
|
|
|
|
char *cp = (unsigned char *) addr;
|
|
|
|
int res = 0, d0;
|
|
|
|
|
|
|
|
if (!size)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
while ((size > res) && (*cp == 0)) {
|
|
|
|
cp++;
|
|
|
|
res += 8;
|
|
|
|
}
|
|
|
|
d0 = ffs(*cp);
|
|
|
|
if (d0 == 0)
|
|
|
|
return size;
|
|
|
|
|
|
|
|
return res + d0 - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_find_next_bit_set (void * addr, int size, int offset)
|
|
|
|
{
|
|
|
|
unsigned char * p;
|
|
|
|
int set = 0, bit = offset & 7, res = 0, d0;
|
|
|
|
|
|
|
|
res = offset >> 3;
|
|
|
|
p = ((unsigned char *) addr) + res;
|
|
|
|
|
|
|
|
if (bit) {
|
|
|
|
set = ffs(*p & ~((1 << bit) - 1));
|
|
|
|
if (set)
|
|
|
|
return (offset & ~7) + set - 1;
|
|
|
|
p++;
|
|
|
|
res += 8;
|
|
|
|
}
|
|
|
|
while ((size > res) && (*p == 0)) {
|
|
|
|
p++;
|
|
|
|
res += 8;
|
|
|
|
}
|
|
|
|
d0 = ffs(*p);
|
|
|
|
if (d0 == 0)
|
|
|
|
return size;
|
|
|
|
|
|
|
|
return (res + d0 - 1);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
1997-04-29 20:15:03 +04:00
|
|
|
_INLINE_ int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap,
|
|
|
|
blk_t bitno);
|
|
|
|
|
1997-04-29 18:53:37 +04:00
|
|
|
_INLINE_ int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap,
|
1997-04-29 20:15:03 +04:00
|
|
|
blk_t bitno)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
1997-04-29 18:53:37 +04:00
|
|
|
if ((bitno < bitmap->start) || (bitno > bitmap->end)) {
|
1997-04-29 21:48:10 +04:00
|
|
|
ext2fs_warn_bitmap2(bitmap, EXT2FS_TEST_ERROR, bitno);
|
1997-04-26 17:21:57 +04:00
|
|
|
return 0;
|
|
|
|
}
|
1997-04-29 18:53:37 +04:00
|
|
|
return ext2fs_test_bit(bitno - bitmap->start, bitmap->bitmap);
|
|
|
|
}
|
|
|
|
|
ChangeLog, bitops.h:
bitops.h (ext2fs_mark_generic_bitmap, ext2fs_unmark_generic_bitmap,
ext2fs_mark_block_bitmap, ext2fs_unmark_block_bitmap,
ext2fs_mark_inode_bitmap, ext2fs_unmark_inode_bitmap): Change to
return the previous state of the bit that is being marked or unmarked.
For speed optimization.
ChangeLog, pass3.c:
pass3.c (check_directory): Only do the loop detection algorithm if
we've searched over 2048 parent directories and haven't found the end
yet. This means that in the common case, we don't allocate or clear
the inode_loop_detection bitmap, which for large systems, merely
clearing the bitmap for each directory was turning out to be quite
expensive. Thanks to Jani Jaakkola (jjaakkol@cs.helsinki.fi) for
identifying this problem.
ChangeLog, Makefile.in, e2fsck.h, unix.c:
Makefile.in: Call sync after finishing building all in this directory.
unix.c (PRS): sync the filesystem before trying to use BLKFLSBUF, to
minimize the chance of causing dirty blocks to get dropped.
e2fsck.h: Manually define BLKFLSBUF if not defined, and we're on a
Linux/i386 system.
2000-02-08 22:14:02 +03:00
|
|
|
_INLINE_ int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap,
|
1997-04-29 18:53:37 +04:00
|
|
|
blk_t block)
|
|
|
|
{
|
ChangeLog, bitops.h:
bitops.h (ext2fs_mark_generic_bitmap, ext2fs_unmark_generic_bitmap,
ext2fs_mark_block_bitmap, ext2fs_unmark_block_bitmap,
ext2fs_mark_inode_bitmap, ext2fs_unmark_inode_bitmap): Change to
return the previous state of the bit that is being marked or unmarked.
For speed optimization.
ChangeLog, pass3.c:
pass3.c (check_directory): Only do the loop detection algorithm if
we've searched over 2048 parent directories and haven't found the end
yet. This means that in the common case, we don't allocate or clear
the inode_loop_detection bitmap, which for large systems, merely
clearing the bitmap for each directory was turning out to be quite
expensive. Thanks to Jani Jaakkola (jjaakkol@cs.helsinki.fi) for
identifying this problem.
ChangeLog, Makefile.in, e2fsck.h, unix.c:
Makefile.in: Call sync after finishing building all in this directory.
unix.c (PRS): sync the filesystem before trying to use BLKFLSBUF, to
minimize the chance of causing dirty blocks to get dropped.
e2fsck.h: Manually define BLKFLSBUF if not defined, and we're on a
Linux/i386 system.
2000-02-08 22:14:02 +03:00
|
|
|
return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap)
|
|
|
|
bitmap,
|
|
|
|
block);
|
1997-04-29 18:53:37 +04:00
|
|
|
}
|
|
|
|
|
ChangeLog, bitops.h:
bitops.h (ext2fs_mark_generic_bitmap, ext2fs_unmark_generic_bitmap,
ext2fs_mark_block_bitmap, ext2fs_unmark_block_bitmap,
ext2fs_mark_inode_bitmap, ext2fs_unmark_inode_bitmap): Change to
return the previous state of the bit that is being marked or unmarked.
For speed optimization.
ChangeLog, pass3.c:
pass3.c (check_directory): Only do the loop detection algorithm if
we've searched over 2048 parent directories and haven't found the end
yet. This means that in the common case, we don't allocate or clear
the inode_loop_detection bitmap, which for large systems, merely
clearing the bitmap for each directory was turning out to be quite
expensive. Thanks to Jani Jaakkola (jjaakkol@cs.helsinki.fi) for
identifying this problem.
ChangeLog, Makefile.in, e2fsck.h, unix.c:
Makefile.in: Call sync after finishing building all in this directory.
unix.c (PRS): sync the filesystem before trying to use BLKFLSBUF, to
minimize the chance of causing dirty blocks to get dropped.
e2fsck.h: Manually define BLKFLSBUF if not defined, and we're on a
Linux/i386 system.
2000-02-08 22:14:02 +03:00
|
|
|
_INLINE_ int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
|
1997-04-29 18:53:37 +04:00
|
|
|
blk_t block)
|
|
|
|
{
|
ChangeLog, bitops.h:
bitops.h (ext2fs_mark_generic_bitmap, ext2fs_unmark_generic_bitmap,
ext2fs_mark_block_bitmap, ext2fs_unmark_block_bitmap,
ext2fs_mark_inode_bitmap, ext2fs_unmark_inode_bitmap): Change to
return the previous state of the bit that is being marked or unmarked.
For speed optimization.
ChangeLog, pass3.c:
pass3.c (check_directory): Only do the loop detection algorithm if
we've searched over 2048 parent directories and haven't found the end
yet. This means that in the common case, we don't allocate or clear
the inode_loop_detection bitmap, which for large systems, merely
clearing the bitmap for each directory was turning out to be quite
expensive. Thanks to Jani Jaakkola (jjaakkol@cs.helsinki.fi) for
identifying this problem.
ChangeLog, Makefile.in, e2fsck.h, unix.c:
Makefile.in: Call sync after finishing building all in this directory.
unix.c (PRS): sync the filesystem before trying to use BLKFLSBUF, to
minimize the chance of causing dirty blocks to get dropped.
e2fsck.h: Manually define BLKFLSBUF if not defined, and we're on a
Linux/i386 system.
2000-02-08 22:14:02 +03:00
|
|
|
return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
block);
|
1997-04-29 18:53:37 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block)
|
|
|
|
{
|
|
|
|
return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
block);
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
ChangeLog, bitops.h:
bitops.h (ext2fs_mark_generic_bitmap, ext2fs_unmark_generic_bitmap,
ext2fs_mark_block_bitmap, ext2fs_unmark_block_bitmap,
ext2fs_mark_inode_bitmap, ext2fs_unmark_inode_bitmap): Change to
return the previous state of the bit that is being marked or unmarked.
For speed optimization.
ChangeLog, pass3.c:
pass3.c (check_directory): Only do the loop detection algorithm if
we've searched over 2048 parent directories and haven't found the end
yet. This means that in the common case, we don't allocate or clear
the inode_loop_detection bitmap, which for large systems, merely
clearing the bitmap for each directory was turning out to be quite
expensive. Thanks to Jani Jaakkola (jjaakkol@cs.helsinki.fi) for
identifying this problem.
ChangeLog, Makefile.in, e2fsck.h, unix.c:
Makefile.in: Call sync after finishing building all in this directory.
unix.c (PRS): sync the filesystem before trying to use BLKFLSBUF, to
minimize the chance of causing dirty blocks to get dropped.
e2fsck.h: Manually define BLKFLSBUF if not defined, and we're on a
Linux/i386 system.
2000-02-08 22:14:02 +03:00
|
|
|
_INLINE_ int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
ext2_ino_t inode)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
ChangeLog, bitops.h:
bitops.h (ext2fs_mark_generic_bitmap, ext2fs_unmark_generic_bitmap,
ext2fs_mark_block_bitmap, ext2fs_unmark_block_bitmap,
ext2fs_mark_inode_bitmap, ext2fs_unmark_inode_bitmap): Change to
return the previous state of the bit that is being marked or unmarked.
For speed optimization.
ChangeLog, pass3.c:
pass3.c (check_directory): Only do the loop detection algorithm if
we've searched over 2048 parent directories and haven't found the end
yet. This means that in the common case, we don't allocate or clear
the inode_loop_detection bitmap, which for large systems, merely
clearing the bitmap for each directory was turning out to be quite
expensive. Thanks to Jani Jaakkola (jjaakkol@cs.helsinki.fi) for
identifying this problem.
ChangeLog, Makefile.in, e2fsck.h, unix.c:
Makefile.in: Call sync after finishing building all in this directory.
unix.c (PRS): sync the filesystem before trying to use BLKFLSBUF, to
minimize the chance of causing dirty blocks to get dropped.
e2fsck.h: Manually define BLKFLSBUF if not defined, and we're on a
Linux/i386 system.
2000-02-08 22:14:02 +03:00
|
|
|
return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
inode);
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
ChangeLog, bitops.h:
bitops.h (ext2fs_mark_generic_bitmap, ext2fs_unmark_generic_bitmap,
ext2fs_mark_block_bitmap, ext2fs_unmark_block_bitmap,
ext2fs_mark_inode_bitmap, ext2fs_unmark_inode_bitmap): Change to
return the previous state of the bit that is being marked or unmarked.
For speed optimization.
ChangeLog, pass3.c:
pass3.c (check_directory): Only do the loop detection algorithm if
we've searched over 2048 parent directories and haven't found the end
yet. This means that in the common case, we don't allocate or clear
the inode_loop_detection bitmap, which for large systems, merely
clearing the bitmap for each directory was turning out to be quite
expensive. Thanks to Jani Jaakkola (jjaakkol@cs.helsinki.fi) for
identifying this problem.
ChangeLog, Makefile.in, e2fsck.h, unix.c:
Makefile.in: Call sync after finishing building all in this directory.
unix.c (PRS): sync the filesystem before trying to use BLKFLSBUF, to
minimize the chance of causing dirty blocks to get dropped.
e2fsck.h: Manually define BLKFLSBUF if not defined, and we're on a
Linux/i386 system.
2000-02-08 22:14:02 +03:00
|
|
|
_INLINE_ int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
ext2_ino_t inode)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
ChangeLog, bitops.h:
bitops.h (ext2fs_mark_generic_bitmap, ext2fs_unmark_generic_bitmap,
ext2fs_mark_block_bitmap, ext2fs_unmark_block_bitmap,
ext2fs_mark_inode_bitmap, ext2fs_unmark_inode_bitmap): Change to
return the previous state of the bit that is being marked or unmarked.
For speed optimization.
ChangeLog, pass3.c:
pass3.c (check_directory): Only do the loop detection algorithm if
we've searched over 2048 parent directories and haven't found the end
yet. This means that in the common case, we don't allocate or clear
the inode_loop_detection bitmap, which for large systems, merely
clearing the bitmap for each directory was turning out to be quite
expensive. Thanks to Jani Jaakkola (jjaakkol@cs.helsinki.fi) for
identifying this problem.
ChangeLog, Makefile.in, e2fsck.h, unix.c:
Makefile.in: Call sync after finishing building all in this directory.
unix.c (PRS): sync the filesystem before trying to use BLKFLSBUF, to
minimize the chance of causing dirty blocks to get dropped.
e2fsck.h: Manually define BLKFLSBUF if not defined, and we're on a
Linux/i386 system.
2000-02-08 22:14:02 +03:00
|
|
|
return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
inode);
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
1997-04-26 17:34:30 +04:00
|
|
|
_INLINE_ int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap,
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
ext2_ino_t inode)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
1997-04-29 18:53:37 +04:00
|
|
|
return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
inode);
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
1997-04-26 17:58:21 +04:00
|
|
|
_INLINE_ void ext2fs_fast_mark_block_bitmap(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block)
|
|
|
|
{
|
|
|
|
#ifdef EXT2FS_DEBUG_FAST_OPS
|
|
|
|
if ((block < bitmap->start) || (block > bitmap->end)) {
|
|
|
|
ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_MARK, block,
|
|
|
|
bitmap->description);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
1997-04-26 18:37:06 +04:00
|
|
|
ext2fs_set_bit(block - bitmap->start, bitmap->bitmap);
|
1997-04-26 17:58:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block)
|
|
|
|
{
|
|
|
|
#ifdef EXT2FS_DEBUG_FAST_OPS
|
|
|
|
if ((block < bitmap->start) || (block > bitmap->end)) {
|
|
|
|
ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_UNMARK,
|
|
|
|
block, bitmap->description);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
1997-04-26 18:37:06 +04:00
|
|
|
ext2fs_clear_bit(block - bitmap->start, bitmap->bitmap);
|
1997-04-26 17:58:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_fast_test_block_bitmap(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block)
|
|
|
|
{
|
|
|
|
#ifdef EXT2FS_DEBUG_FAST_OPS
|
|
|
|
if ((block < bitmap->start) || (block > bitmap->end)) {
|
|
|
|
ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_TEST,
|
|
|
|
block, bitmap->description);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
1997-04-26 18:37:06 +04:00
|
|
|
return ext2fs_test_bit(block - bitmap->start, bitmap->bitmap);
|
1997-04-26 17:58:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
ext2_ino_t inode)
|
1997-04-26 17:58:21 +04:00
|
|
|
{
|
|
|
|
#ifdef EXT2FS_DEBUG_FAST_OPS
|
|
|
|
if ((inode < bitmap->start) || (inode > bitmap->end)) {
|
|
|
|
ext2fs_warn_bitmap(EXT2_ET_BAD_INODE_MARK,
|
|
|
|
inode, bitmap->description);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
1997-04-26 18:37:06 +04:00
|
|
|
ext2fs_set_bit(inode - bitmap->start, bitmap->bitmap);
|
1997-04-26 17:58:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
ext2_ino_t inode)
|
1997-04-26 17:58:21 +04:00
|
|
|
{
|
|
|
|
#ifdef EXT2FS_DEBUG_FAST_OPS
|
|
|
|
if ((inode < bitmap->start) || (inode > bitmap->end)) {
|
|
|
|
ext2fs_warn_bitmap(EXT2_ET_BAD_INODE_UNMARK,
|
|
|
|
inode, bitmap->description);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
1997-04-26 18:37:06 +04:00
|
|
|
ext2fs_clear_bit(inode - bitmap->start, bitmap->bitmap);
|
1997-04-26 17:58:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_fast_test_inode_bitmap(ext2fs_inode_bitmap bitmap,
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
ext2_ino_t inode)
|
1997-04-26 17:58:21 +04:00
|
|
|
{
|
|
|
|
#ifdef EXT2FS_DEBUG_FAST_OPS
|
|
|
|
if ((inode < bitmap->start) || (inode > bitmap->end)) {
|
|
|
|
ext2fs_warn_bitmap(EXT2_ET_BAD_INODE_TEST,
|
|
|
|
inode, bitmap->description);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
1997-04-26 18:37:06 +04:00
|
|
|
return ext2fs_test_bit(inode - bitmap->start, bitmap->bitmap);
|
1997-04-26 17:58:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap)
|
|
|
|
{
|
|
|
|
return bitmap->start;
|
|
|
|
}
|
|
|
|
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
_INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap)
|
1997-04-26 17:58:21 +04:00
|
|
|
{
|
|
|
|
return bitmap->start;
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap)
|
|
|
|
{
|
|
|
|
return bitmap->end;
|
|
|
|
}
|
|
|
|
|
Many files:
alloc.c, bb_inode.c, bitmaps.c, bitops.h, block.c, bmap.c, bmove.c,
brel.h, cmp_bitmaps.c, dblist.c, dblist_dir.c, dir_iterate.c,
expanddir.c, ext2fs.h, ext2fsP.h, fileio.c, finddev.c, get_pathname.c,
icount.c, inode.c, irel.h, irel_ma.c, ismounted.c, link.c, lookup.c,
mkdir.c, mkjournal.c, namei.c, newdir.c, read_bb_file.c, test_io.c,
tst_iscan.c, unix_io.c, unlink.c: Change use of ino_t to ext2_ino_t,
to protect applications that attempt to compile
-D_FILE_OFFSET_BITS=64, since this inexplicably changes ino_t(!?). So
we use ext2_ino_t to avoid an unexpected ABI change.
2001-01-11 07:54:39 +03:00
|
|
|
_INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap)
|
1997-04-26 17:58:21 +04:00
|
|
|
{
|
|
|
|
return bitmap->end;
|
|
|
|
}
|
|
|
|
|
1997-04-29 20:15:03 +04:00
|
|
|
_INLINE_ int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
|
|
|
|
ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_TEST,
|
|
|
|
block, bitmap->description);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
for (i=0; i < num; i++) {
|
|
|
|
if (ext2fs_fast_test_block_bitmap(bitmap, block+i))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_fast_test_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
#ifdef EXT2FS_DEBUG_FAST_OPS
|
|
|
|
if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
|
|
|
|
ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_TEST,
|
|
|
|
block, bitmap->description);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
for (i=0; i < num; i++) {
|
|
|
|
if (ext2fs_fast_test_block_bitmap(bitmap, block+i))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
|
|
|
|
ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_MARK, block,
|
|
|
|
bitmap->description);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (i=0; i < num; i++)
|
|
|
|
ext2fs_set_bit(block + i - bitmap->start, bitmap->bitmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
#ifdef EXT2FS_DEBUG_FAST_OPS
|
|
|
|
if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
|
|
|
|
ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_MARK, block,
|
|
|
|
bitmap->description);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
for (i=0; i < num; i++)
|
|
|
|
ext2fs_set_bit(block + i - bitmap->start, bitmap->bitmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
|
|
|
|
ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_UNMARK, block,
|
|
|
|
bitmap->description);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
for (i=0; i < num; i++)
|
|
|
|
ext2fs_clear_bit(block + i - bitmap->start, bitmap->bitmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
#ifdef EXT2FS_DEBUG_FAST_OPS
|
|
|
|
if ((block < bitmap->start) || (block+num-1 > bitmap->end)) {
|
|
|
|
ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_UNMARK, block,
|
|
|
|
bitmap->description);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
for (i=0; i < num; i++)
|
|
|
|
ext2fs_clear_bit(block + i - bitmap->start, bitmap->bitmap);
|
|
|
|
}
|
1997-04-26 17:21:57 +04:00
|
|
|
#undef _INLINE_
|
|
|
|
#endif
|
1997-04-26 17:58:21 +04:00
|
|
|
|