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
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
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
|
|
|
|
|
1998-02-01 16:23:02 +03:00
|
|
|
#if ((defined __GNUC__) && (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_
|
|
|
|
|
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-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;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
#ifdef __sparc__
|
|
|
|
|
|
|
|
#define _EXT2_HAVE_ASM_BITOPS_
|
|
|
|
|
1997-04-29 18:53:37 +04:00
|
|
|
#ifndef EXT2_OLD_BITOPS
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Do the bitops so that we are compatible with the standard i386
|
|
|
|
* convention.
|
|
|
|
*/
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_set_bit(int nr,void * addr)
|
|
|
|
{
|
|
|
|
#if 1
|
|
|
|
int mask;
|
|
|
|
unsigned char *ADDR = (unsigned char *) addr;
|
|
|
|
|
|
|
|
ADDR += nr >> 3;
|
|
|
|
mask = 1 << (nr & 0x07);
|
|
|
|
__asm__ __volatile__("ldub [%0], %%g6\n\t"
|
|
|
|
"or %%g6, %2, %%g5\n\t"
|
|
|
|
"stb %%g5, [%0]\n\t"
|
|
|
|
"and %%g6, %2, %0\n"
|
|
|
|
: "=&r" (ADDR)
|
|
|
|
: "0" (ADDR), "r" (mask)
|
|
|
|
: "g5", "g6");
|
|
|
|
return (int) ADDR;
|
|
|
|
#else
|
|
|
|
int mask, retval;
|
|
|
|
unsigned char *ADDR = (unsigned char *) addr;
|
|
|
|
|
|
|
|
ADDR += nr >> 3;
|
|
|
|
mask = 1 << (nr & 0x07);
|
|
|
|
retval = (mask & *ADDR) != 0;
|
|
|
|
*ADDR |= mask;
|
|
|
|
return retval;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_clear_bit(int nr, void * addr)
|
|
|
|
{
|
|
|
|
#if 1
|
|
|
|
int mask;
|
|
|
|
unsigned char *ADDR = (unsigned char *) addr;
|
|
|
|
|
|
|
|
ADDR += nr >> 3;
|
|
|
|
mask = 1 << (nr & 0x07);
|
|
|
|
__asm__ __volatile__("ldub [%0], %%g6\n\t"
|
|
|
|
"andn %%g6, %2, %%g5\n\t"
|
|
|
|
"stb %%g5, [%0]\n\t"
|
|
|
|
"and %%g6, %2, %0\n"
|
|
|
|
: "=&r" (ADDR)
|
|
|
|
: "0" (ADDR), "r" (mask)
|
|
|
|
: "g5", "g6");
|
|
|
|
return (int) ADDR;
|
|
|
|
|
|
|
|
#else
|
|
|
|
int mask, retval;
|
|
|
|
unsigned char *ADDR = (unsigned char *) addr;
|
|
|
|
|
|
|
|
ADDR += nr >> 3;
|
|
|
|
mask = 1 << (nr & 0x07);
|
|
|
|
retval = (mask & *ADDR) != 0;
|
|
|
|
*ADDR &= ~mask;
|
|
|
|
return retval;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_test_bit(int nr, const void * addr)
|
|
|
|
{
|
|
|
|
int mask;
|
|
|
|
const unsigned char *ADDR = (const unsigned char *) addr;
|
|
|
|
|
|
|
|
ADDR += nr >> 3;
|
|
|
|
mask = 1 << (nr & 0x07);
|
|
|
|
return ((mask & *ADDR) != 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
/* Do things the old, unplesant way. */
|
|
|
|
|
1997-04-26 18:37:06 +04:00
|
|
|
_INLINE_ int ext2fs_set_bit(int nr, void *addr)
|
1997-04-26 17:58:21 +04:00
|
|
|
{
|
|
|
|
int mask, retval;
|
|
|
|
unsigned long *ADDR = (unsigned long *) addr;
|
|
|
|
|
|
|
|
ADDR += nr >> 5;
|
|
|
|
mask = 1 << (nr & 31);
|
|
|
|
retval = ((mask & *ADDR) != 0);
|
|
|
|
*ADDR |= mask;
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
1997-04-26 18:37:06 +04:00
|
|
|
_INLINE_ int ext2fs_clear_bit(int nr, void *addr)
|
1997-04-26 17:58:21 +04:00
|
|
|
{
|
|
|
|
int mask, retval;
|
|
|
|
unsigned long *ADDR = (unsigned long *) addr;
|
|
|
|
|
|
|
|
ADDR += nr >> 5;
|
|
|
|
mask = 1 << (nr & 31);
|
|
|
|
retval = ((mask & *ADDR) != 0);
|
|
|
|
*ADDR &= ~mask;
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
1997-04-26 18:37:06 +04:00
|
|
|
_INLINE_ int ext2fs_test_bit(int nr, const void *addr)
|
1997-04-26 17:58:21 +04:00
|
|
|
{
|
|
|
|
int mask;
|
|
|
|
const unsigned long *ADDR = (const unsigned long *) addr;
|
|
|
|
|
|
|
|
ADDR += nr >> 5;
|
|
|
|
mask = 1 << (nr & 31);
|
|
|
|
return ((mask & *ADDR) != 0);
|
|
|
|
}
|
1997-04-29 18:53:37 +04:00
|
|
|
#endif
|
1997-04-26 17:58:21 +04:00
|
|
|
|
|
|
|
#endif /* __sparc__ */
|
|
|
|
|
2001-02-20 19:28:40 +03:00
|
|
|
#ifndef _EXT2_HAVE_ASM_SWAB_
|
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 */
|
|
|
|
|
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_generic_bitmap(ext2fs_generic_bitmap bitmap,
|
1997-04-29 20:15:03 +04:00
|
|
|
__u32 bitno);
|
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_generic_bitmap(ext2fs_generic_bitmap bitmap,
|
1997-04-29 20:15:03 +04:00
|
|
|
blk_t bitno);
|
|
|
|
_INLINE_ int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap,
|
|
|
|
blk_t bitno);
|
|
|
|
|
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_generic_bitmap(ext2fs_generic_bitmap bitmap,
|
1997-04-29 20:15:03 +04:00
|
|
|
__u32 bitno)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
1997-04-29 18:53:37 +04:00
|
|
|
if ((bitno < bitmap->start) || (bitno > bitmap->end)) {
|
|
|
|
ext2fs_warn_bitmap2(bitmap, EXT2FS_MARK_ERROR, bitno);
|
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 0;
|
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_set_bit(bitno - bitmap->start, bitmap->bitmap);
|
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_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)) {
|
|
|
|
ext2fs_warn_bitmap2(bitmap, EXT2FS_UNMARK_ERROR, bitno);
|
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 0;
|
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_clear_bit(bitno - bitmap->start, bitmap->bitmap);
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|