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.
|
2008-08-28 07:07:54 +04:00
|
|
|
*
|
1997-04-29 20:15:03 +04:00
|
|
|
* Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
|
|
|
|
*
|
|
|
|
* %Begin-Header%
|
2010-05-18 05:31:56 +04:00
|
|
|
* This file may be redistributed under the terms of the GNU Library
|
|
|
|
* General Public License, version 2.
|
1997-04-29 20:15:03 +04:00
|
|
|
* %End-Header%
|
1997-04-26 17:21:57 +04:00
|
|
|
*/
|
|
|
|
|
2002-06-28 16:10:29 +04:00
|
|
|
#ifdef WORDS_BIGENDIAN
|
2006-08-06 09:39:30 +04:00
|
|
|
#define ext2fs_cpu_to_le64(x) ext2fs_swab64((x))
|
|
|
|
#define ext2fs_le64_to_cpu(x) ext2fs_swab64((x))
|
2002-06-28 16:10:29 +04:00
|
|
|
#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))
|
2011-05-18 15:36:53 +04:00
|
|
|
#define ext2fs_cpu_to_be64(x) ((__u64)(x))
|
|
|
|
#define ext2fs_be64_to_cpu(x) ((__u64)(x))
|
2002-06-28 16:10:29 +04:00
|
|
|
#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
|
2006-08-06 09:39:30 +04:00
|
|
|
#define ext2fs_cpu_to_le64(x) ((__u64)(x))
|
|
|
|
#define ext2fs_le64_to_cpu(x) ((__u64)(x))
|
2002-06-28 16:10:29 +04:00
|
|
|
#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))
|
2011-05-18 15:36:53 +04:00
|
|
|
#define ext2fs_cpu_to_be64(x) ext2fs_swab64((x))
|
|
|
|
#define ext2fs_be64_to_cpu(x) ext2fs_swab64((x))
|
2002-06-28 16:10:29 +04:00
|
|
|
#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
|
|
|
|
2012-09-10 05:35:39 +04:00
|
|
|
#ifdef NO_INLINE_FUNCS
|
2013-05-20 02:50:10 +04:00
|
|
|
extern void ext2fs_fast_set_bit(unsigned int nr,void * addr);
|
|
|
|
extern void ext2fs_fast_clear_bit(unsigned int nr, void * addr);
|
|
|
|
extern void ext2fs_fast_set_bit64(__u64 nr,void * addr);
|
|
|
|
extern void ext2fs_fast_clear_bit64(__u64 nr, void * addr);
|
|
|
|
extern __u16 ext2fs_swab16(__u16 val);
|
|
|
|
extern __u32 ext2fs_swab32(__u32 val);
|
|
|
|
extern __u64 ext2fs_swab64(__u64 val);
|
|
|
|
|
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
|
|
|
|
2012-09-10 05:35:39 +04:00
|
|
|
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);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* These functions routines moved to gen_bitmap.c */
|
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);
|
2009-07-09 22:32:52 +04:00
|
|
|
extern int ext2fs_test_inode_bitmap_range(ext2fs_inode_bitmap bitmap,
|
|
|
|
ino_t inode, int num);
|
2001-12-17 07:23:37 +03:00
|
|
|
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);
|
2007-07-23 01:42:52 +04:00
|
|
|
extern int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap,
|
|
|
|
blk_t bitno);
|
2007-07-23 02:54:10 +04:00
|
|
|
extern int ext2fs_test_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num);
|
2012-09-10 05:35:39 +04:00
|
|
|
extern void ext2fs_set_bitmap_padding(ext2fs_generic_bitmap map);
|
2007-07-23 03:16:08 +04:00
|
|
|
extern __u32 ext2fs_get_generic_bitmap_start(ext2fs_generic_bitmap bitmap);
|
|
|
|
extern __u32 ext2fs_get_generic_bitmap_end(ext2fs_generic_bitmap bitmap);
|
2007-07-23 01:42:52 +04:00
|
|
|
|
2009-08-22 21:27:40 +04:00
|
|
|
/* 64-bit versions */
|
|
|
|
|
2012-09-10 05:35:39 +04:00
|
|
|
#ifdef NO_INLINE_FUNCS
|
2009-08-22 21:27:40 +04:00
|
|
|
extern int ext2fs_mark_block_bitmap2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block);
|
|
|
|
extern int ext2fs_unmark_block_bitmap2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block);
|
|
|
|
extern int ext2fs_test_block_bitmap2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block);
|
|
|
|
|
|
|
|
extern int ext2fs_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t inode);
|
|
|
|
extern int ext2fs_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t inode);
|
|
|
|
extern int ext2fs_test_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t inode);
|
|
|
|
|
|
|
|
extern void ext2fs_fast_mark_block_bitmap2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block);
|
|
|
|
extern void ext2fs_fast_unmark_block_bitmap2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block);
|
|
|
|
extern int ext2fs_fast_test_block_bitmap2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block);
|
|
|
|
|
|
|
|
extern void ext2fs_fast_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t inode);
|
|
|
|
extern void ext2fs_fast_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t inode);
|
|
|
|
extern int ext2fs_fast_test_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t inode);
|
2012-03-11 00:36:12 +04:00
|
|
|
extern errcode_t ext2fs_find_first_zero_block_bitmap2(ext2fs_block_bitmap bitmap,
|
2012-04-06 22:49:22 +04:00
|
|
|
blk64_t start,
|
|
|
|
blk64_t end,
|
|
|
|
blk64_t *out);
|
2012-03-11 00:36:12 +04:00
|
|
|
extern errcode_t ext2fs_find_first_zero_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t start,
|
|
|
|
ext2_ino_t end,
|
|
|
|
ext2_ino_t *out);
|
2014-01-13 00:57:31 +04:00
|
|
|
extern errcode_t ext2fs_find_first_set_block_bitmap2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t start,
|
|
|
|
blk64_t end,
|
|
|
|
blk64_t *out);
|
|
|
|
extern errcode_t ext2fs_find_first_set_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t start,
|
|
|
|
ext2_ino_t end,
|
|
|
|
ext2_ino_t *out);
|
2009-08-22 21:27:40 +04:00
|
|
|
extern blk64_t ext2fs_get_block_bitmap_start2(ext2fs_block_bitmap bitmap);
|
|
|
|
extern ext2_ino_t ext2fs_get_inode_bitmap_start2(ext2fs_inode_bitmap bitmap);
|
|
|
|
extern blk64_t ext2fs_get_block_bitmap_end2(ext2fs_block_bitmap bitmap);
|
|
|
|
extern ext2_ino_t ext2fs_get_inode_bitmap_end2(ext2fs_inode_bitmap bitmap);
|
|
|
|
|
|
|
|
extern int ext2fs_fast_test_block_bitmap_range2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block,
|
|
|
|
unsigned int num);
|
|
|
|
extern void ext2fs_fast_mark_block_bitmap_range2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block,
|
|
|
|
unsigned int num);
|
|
|
|
extern void ext2fs_fast_unmark_block_bitmap_range2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block,
|
|
|
|
unsigned int num);
|
2012-09-10 05:35:39 +04:00
|
|
|
#endif
|
|
|
|
|
2009-08-22 21:27:40 +04:00
|
|
|
/* These routines moved to gen_bitmap64.c */
|
|
|
|
extern void ext2fs_clear_generic_bmap(ext2fs_generic_bitmap bitmap);
|
|
|
|
extern errcode_t ext2fs_compare_generic_bmap(errcode_t neq,
|
|
|
|
ext2fs_generic_bitmap bm1,
|
|
|
|
ext2fs_generic_bitmap bm2);
|
|
|
|
extern void ext2fs_set_generic_bmap_padding(ext2fs_generic_bitmap bmap);
|
|
|
|
extern int ext2fs_mark_generic_bmap(ext2fs_generic_bitmap bitmap,
|
|
|
|
blk64_t bitno);
|
|
|
|
extern int ext2fs_unmark_generic_bmap(ext2fs_generic_bitmap bitmap,
|
|
|
|
blk64_t bitno);
|
|
|
|
extern int ext2fs_test_generic_bmap(ext2fs_generic_bitmap bitmap,
|
|
|
|
blk64_t bitno);
|
|
|
|
extern int ext2fs_test_block_bitmap_range2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block, unsigned int num);
|
|
|
|
extern __u64 ext2fs_get_generic_bmap_start(ext2fs_generic_bitmap bitmap);
|
|
|
|
extern __u64 ext2fs_get_generic_bmap_end(ext2fs_generic_bitmap bitmap);
|
|
|
|
extern int ext2fs_test_block_bitmap_range2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block, unsigned int num);
|
|
|
|
extern void ext2fs_mark_block_bitmap_range2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block, unsigned int num);
|
|
|
|
extern void ext2fs_unmark_block_bitmap_range2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block, unsigned int num);
|
2012-03-11 00:36:12 +04:00
|
|
|
extern errcode_t ext2fs_find_first_zero_generic_bmap(ext2fs_generic_bitmap bitmap,
|
|
|
|
__u64 start, __u64 end,
|
|
|
|
__u64 *out);
|
2014-01-13 00:57:31 +04:00
|
|
|
extern errcode_t ext2fs_find_first_set_generic_bmap(ext2fs_generic_bitmap bitmap,
|
|
|
|
__u64 start, __u64 end,
|
|
|
|
__u64 *out);
|
2009-08-22 21:27:40 +04:00
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
/*
|
|
|
|
* The inline routines themselves...
|
2008-08-28 07:07:54 +04:00
|
|
|
*
|
1997-04-26 17:21:57 +04:00
|
|
|
* 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__) || \
|
2012-12-17 18:42:25 +04:00
|
|
|
defined(__i586__)))
|
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
|
2012-09-10 05:35:39 +04:00
|
|
|
#if (__STDC_VERSION__ >= 199901L)
|
|
|
|
#define _INLINE_ extern inline
|
1997-04-26 17:21:57 +04:00
|
|
|
#else
|
2012-09-10 05:35:39 +04:00
|
|
|
#define _INLINE_ inline
|
|
|
|
#endif
|
|
|
|
#else /* !INCLUDE_INLINE FUNCS */
|
|
|
|
#if (__STDC_VERSION__ >= 199901L)
|
|
|
|
#define _INLINE_ inline
|
|
|
|
#else /* not C99 */
|
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
|
2012-09-10 05:35:39 +04:00
|
|
|
#endif /* __GNUC__ */
|
|
|
|
#endif /* __STDC_VERSION__ >= 199901L */
|
|
|
|
#endif /* INCLUDE_INLINE_FUNCS */
|
1997-04-26 17:21:57 +04:00
|
|
|
|
Fix the i386 bitmap operations so they are 32-bit clean
The x86 assembly instructures for bit test-and-set, test-and-clear,
etc., interpret the bit number as a 32-bit signed number, which is
problematic in order to support filesystems > 8TB.
Added new inline functions (in C) to implement a
ext2fs_fast_set/clear_bit() that does not return the old value of the
bit, and use it for the fast block/bitmap functions.
Added a regression test suite to test the low-level bit operations
functions to make sure they work correctly.
Note that a bitmap can address 2**32 blocks requires 2**29 bytes, or
512 megabytes. E2fsck requires 3 (and possibly 4 block bitmaps),
which means that the block bitmaps can require 2GB all by themselves,
and this doesn't include the 4 or 5 inode bitmaps (which assuming an
8k inode ratio, will take 256 megabytes each). This means that it's
more likely that a filesystem check of a filesystem greater than 2**31
blocks will fail if the e2fsck is dynamically linked (since the shared
libraries can consume a substantial portion of the 3GB address space
available to x86 userspace applications). Even if e2fsck is
statically linked, for a badly damaged filesystem, which may require
additional block and/or inode bitmaps, I am not sure e2fsck will
succeed in all cases.
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2006-03-25 21:42:45 +03:00
|
|
|
/*
|
|
|
|
* Fast bit set/clear functions that doesn't need to return the
|
|
|
|
* previous bit value.
|
|
|
|
*/
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_set_bit(unsigned int nr,void * addr)
|
|
|
|
{
|
|
|
|
unsigned char *ADDR = (unsigned char *) addr;
|
|
|
|
|
|
|
|
ADDR += nr >> 3;
|
2013-12-03 07:24:12 +04:00
|
|
|
*ADDR |= (unsigned char) (1 << (nr & 0x07));
|
Fix the i386 bitmap operations so they are 32-bit clean
The x86 assembly instructures for bit test-and-set, test-and-clear,
etc., interpret the bit number as a 32-bit signed number, which is
problematic in order to support filesystems > 8TB.
Added new inline functions (in C) to implement a
ext2fs_fast_set/clear_bit() that does not return the old value of the
bit, and use it for the fast block/bitmap functions.
Added a regression test suite to test the low-level bit operations
functions to make sure they work correctly.
Note that a bitmap can address 2**32 blocks requires 2**29 bytes, or
512 megabytes. E2fsck requires 3 (and possibly 4 block bitmaps),
which means that the block bitmaps can require 2GB all by themselves,
and this doesn't include the 4 or 5 inode bitmaps (which assuming an
8k inode ratio, will take 256 megabytes each). This means that it's
more likely that a filesystem check of a filesystem greater than 2**31
blocks will fail if the e2fsck is dynamically linked (since the shared
libraries can consume a substantial portion of the 3GB address space
available to x86 userspace applications). Even if e2fsck is
statically linked, for a badly damaged filesystem, which may require
additional block and/or inode bitmaps, I am not sure e2fsck will
succeed in all cases.
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2006-03-25 21:42:45 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_clear_bit(unsigned int nr, void * addr)
|
|
|
|
{
|
|
|
|
unsigned char *ADDR = (unsigned char *) addr;
|
|
|
|
|
|
|
|
ADDR += nr >> 3;
|
2013-12-03 07:24:12 +04:00
|
|
|
*ADDR &= (unsigned char) ~(1 << (nr & 0x07));
|
Fix the i386 bitmap operations so they are 32-bit clean
The x86 assembly instructures for bit test-and-set, test-and-clear,
etc., interpret the bit number as a 32-bit signed number, which is
problematic in order to support filesystems > 8TB.
Added new inline functions (in C) to implement a
ext2fs_fast_set/clear_bit() that does not return the old value of the
bit, and use it for the fast block/bitmap functions.
Added a regression test suite to test the low-level bit operations
functions to make sure they work correctly.
Note that a bitmap can address 2**32 blocks requires 2**29 bytes, or
512 megabytes. E2fsck requires 3 (and possibly 4 block bitmaps),
which means that the block bitmaps can require 2GB all by themselves,
and this doesn't include the 4 or 5 inode bitmaps (which assuming an
8k inode ratio, will take 256 megabytes each). This means that it's
more likely that a filesystem check of a filesystem greater than 2**31
blocks will fail if the e2fsck is dynamically linked (since the shared
libraries can consume a substantial portion of the 3GB address space
available to x86 userspace applications). Even if e2fsck is
statically linked, for a badly damaged filesystem, which may require
additional block and/or inode bitmaps, I am not sure e2fsck will
succeed in all cases.
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2006-03-25 21:42:45 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-06-02 00:15:40 +04:00
|
|
|
_INLINE_ void ext2fs_fast_set_bit64(__u64 nr, void * addr)
|
|
|
|
{
|
|
|
|
unsigned char *ADDR = (unsigned char *) addr;
|
|
|
|
|
|
|
|
ADDR += nr >> 3;
|
2013-12-03 07:24:12 +04:00
|
|
|
*ADDR |= (unsigned char) (1 << (nr & 0x07));
|
2009-06-02 00:15:40 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_clear_bit64(__u64 nr, void * addr)
|
|
|
|
{
|
|
|
|
unsigned char *ADDR = (unsigned char *) addr;
|
|
|
|
|
|
|
|
ADDR += nr >> 3;
|
2013-12-03 07:24:12 +04:00
|
|
|
*ADDR &= (unsigned char) ~(1 << (nr & 0x07));
|
2009-06-02 00:15:40 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
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_
|
|
|
|
|
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)
|
2008-08-28 07:07:54 +04:00
|
|
|
#define EXT2FS_CONST_ADDR (*(const struct __dummy_h *) addr)
|
1997-04-26 17:21:57 +04:00
|
|
|
|
2005-07-01 03:40:18 +04:00
|
|
|
_INLINE_ int ext2fs_set_bit(unsigned int nr, void * addr)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
|
|
|
int oldbit;
|
|
|
|
|
Fix the i386 bitmap operations so they are 32-bit clean
The x86 assembly instructures for bit test-and-set, test-and-clear,
etc., interpret the bit number as a 32-bit signed number, which is
problematic in order to support filesystems > 8TB.
Added new inline functions (in C) to implement a
ext2fs_fast_set/clear_bit() that does not return the old value of the
bit, and use it for the fast block/bitmap functions.
Added a regression test suite to test the low-level bit operations
functions to make sure they work correctly.
Note that a bitmap can address 2**32 blocks requires 2**29 bytes, or
512 megabytes. E2fsck requires 3 (and possibly 4 block bitmaps),
which means that the block bitmaps can require 2GB all by themselves,
and this doesn't include the 4 or 5 inode bitmaps (which assuming an
8k inode ratio, will take 256 megabytes each). This means that it's
more likely that a filesystem check of a filesystem greater than 2**31
blocks will fail if the e2fsck is dynamically linked (since the shared
libraries can consume a substantial portion of the 3GB address space
available to x86 userspace applications). Even if e2fsck is
statically linked, for a badly damaged filesystem, which may require
additional block and/or inode bitmaps, I am not sure e2fsck will
succeed in all cases.
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2006-03-25 21:42:45 +03:00
|
|
|
addr = (void *) (((unsigned char *) addr) + (nr >> 3));
|
1997-04-26 17:21:57 +04:00
|
|
|
__asm__ __volatile__("btsl %2,%1\n\tsbbl %0,%0"
|
2006-03-29 23:23:00 +04:00
|
|
|
:"=r" (oldbit),"+m" (EXT2FS_ADDR)
|
Fix the i386 bitmap operations so they are 32-bit clean
The x86 assembly instructures for bit test-and-set, test-and-clear,
etc., interpret the bit number as a 32-bit signed number, which is
problematic in order to support filesystems > 8TB.
Added new inline functions (in C) to implement a
ext2fs_fast_set/clear_bit() that does not return the old value of the
bit, and use it for the fast block/bitmap functions.
Added a regression test suite to test the low-level bit operations
functions to make sure they work correctly.
Note that a bitmap can address 2**32 blocks requires 2**29 bytes, or
512 megabytes. E2fsck requires 3 (and possibly 4 block bitmaps),
which means that the block bitmaps can require 2GB all by themselves,
and this doesn't include the 4 or 5 inode bitmaps (which assuming an
8k inode ratio, will take 256 megabytes each). This means that it's
more likely that a filesystem check of a filesystem greater than 2**31
blocks will fail if the e2fsck is dynamically linked (since the shared
libraries can consume a substantial portion of the 3GB address space
available to x86 userspace applications). Even if e2fsck is
statically linked, for a badly damaged filesystem, which may require
additional block and/or inode bitmaps, I am not sure e2fsck will
succeed in all cases.
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2006-03-25 21:42:45 +03:00
|
|
|
:"r" (nr & 7));
|
1997-04-26 17:21:57 +04:00
|
|
|
return oldbit;
|
|
|
|
}
|
|
|
|
|
2005-07-01 03:40:18 +04:00
|
|
|
_INLINE_ int ext2fs_clear_bit(unsigned int nr, void * addr)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
|
|
|
int oldbit;
|
|
|
|
|
Fix the i386 bitmap operations so they are 32-bit clean
The x86 assembly instructures for bit test-and-set, test-and-clear,
etc., interpret the bit number as a 32-bit signed number, which is
problematic in order to support filesystems > 8TB.
Added new inline functions (in C) to implement a
ext2fs_fast_set/clear_bit() that does not return the old value of the
bit, and use it for the fast block/bitmap functions.
Added a regression test suite to test the low-level bit operations
functions to make sure they work correctly.
Note that a bitmap can address 2**32 blocks requires 2**29 bytes, or
512 megabytes. E2fsck requires 3 (and possibly 4 block bitmaps),
which means that the block bitmaps can require 2GB all by themselves,
and this doesn't include the 4 or 5 inode bitmaps (which assuming an
8k inode ratio, will take 256 megabytes each). This means that it's
more likely that a filesystem check of a filesystem greater than 2**31
blocks will fail if the e2fsck is dynamically linked (since the shared
libraries can consume a substantial portion of the 3GB address space
available to x86 userspace applications). Even if e2fsck is
statically linked, for a badly damaged filesystem, which may require
additional block and/or inode bitmaps, I am not sure e2fsck will
succeed in all cases.
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2006-03-25 21:42:45 +03:00
|
|
|
addr = (void *) (((unsigned char *) addr) + (nr >> 3));
|
1997-04-26 17:21:57 +04:00
|
|
|
__asm__ __volatile__("btrl %2,%1\n\tsbbl %0,%0"
|
2006-03-29 23:23:00 +04:00
|
|
|
:"=r" (oldbit),"+m" (EXT2FS_ADDR)
|
Fix the i386 bitmap operations so they are 32-bit clean
The x86 assembly instructures for bit test-and-set, test-and-clear,
etc., interpret the bit number as a 32-bit signed number, which is
problematic in order to support filesystems > 8TB.
Added new inline functions (in C) to implement a
ext2fs_fast_set/clear_bit() that does not return the old value of the
bit, and use it for the fast block/bitmap functions.
Added a regression test suite to test the low-level bit operations
functions to make sure they work correctly.
Note that a bitmap can address 2**32 blocks requires 2**29 bytes, or
512 megabytes. E2fsck requires 3 (and possibly 4 block bitmaps),
which means that the block bitmaps can require 2GB all by themselves,
and this doesn't include the 4 or 5 inode bitmaps (which assuming an
8k inode ratio, will take 256 megabytes each). This means that it's
more likely that a filesystem check of a filesystem greater than 2**31
blocks will fail if the e2fsck is dynamically linked (since the shared
libraries can consume a substantial portion of the 3GB address space
available to x86 userspace applications). Even if e2fsck is
statically linked, for a badly damaged filesystem, which may require
additional block and/or inode bitmaps, I am not sure e2fsck will
succeed in all cases.
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2006-03-25 21:42:45 +03:00
|
|
|
:"r" (nr & 7));
|
1997-04-26 17:21:57 +04:00
|
|
|
return oldbit;
|
|
|
|
}
|
|
|
|
|
2005-07-01 03:40:18 +04:00
|
|
|
_INLINE_ int ext2fs_test_bit(unsigned int nr, const void * addr)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
|
|
|
int oldbit;
|
|
|
|
|
2006-11-15 07:14:12 +03:00
|
|
|
addr = (const void *) (((const unsigned char *) addr) + (nr >> 3));
|
1997-04-26 17:21:57 +04:00
|
|
|
__asm__ __volatile__("btl %2,%1\n\tsbbl %0,%0"
|
|
|
|
:"=r" (oldbit)
|
Fix the i386 bitmap operations so they are 32-bit clean
The x86 assembly instructures for bit test-and-set, test-and-clear,
etc., interpret the bit number as a 32-bit signed number, which is
problematic in order to support filesystems > 8TB.
Added new inline functions (in C) to implement a
ext2fs_fast_set/clear_bit() that does not return the old value of the
bit, and use it for the fast block/bitmap functions.
Added a regression test suite to test the low-level bit operations
functions to make sure they work correctly.
Note that a bitmap can address 2**32 blocks requires 2**29 bytes, or
512 megabytes. E2fsck requires 3 (and possibly 4 block bitmaps),
which means that the block bitmaps can require 2GB all by themselves,
and this doesn't include the 4 or 5 inode bitmaps (which assuming an
8k inode ratio, will take 256 megabytes each). This means that it's
more likely that a filesystem check of a filesystem greater than 2**31
blocks will fail if the e2fsck is dynamically linked (since the shared
libraries can consume a substantial portion of the 3GB address space
available to x86 userspace applications). Even if e2fsck is
statically linked, for a badly damaged filesystem, which may require
additional block and/or inode bitmaps, I am not sure e2fsck will
succeed in all cases.
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
2006-03-25 21:42:45 +03:00
|
|
|
:"m" (EXT2FS_CONST_ADDR),"r" (nr & 7));
|
1997-04-26 17:21:57 +04:00
|
|
|
return oldbit;
|
|
|
|
}
|
|
|
|
|
2008-05-24 05:35:50 +04: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:58:21 +04:00
|
|
|
|
2008-05-24 05:35:50 +04:00
|
|
|
#if !defined(_EXT2_HAVE_ASM_SWAB_)
|
1997-04-26 17:58:21 +04:00
|
|
|
|
|
|
|
_INLINE_ __u16 ext2fs_swab16(__u16 val)
|
|
|
|
{
|
2013-12-03 07:24:12 +04:00
|
|
|
return (val >> 8) | (__u16) (val << 8);
|
1997-04-26 17:58:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ __u32 ext2fs_swab32(__u32 val)
|
|
|
|
{
|
|
|
|
return ((val>>24) | ((val>>8)&0xFF00) |
|
|
|
|
((val<<8)&0xFF0000) | (val<<24));
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* !_EXT2_HAVE_ASM_SWAB */
|
|
|
|
|
2008-09-02 16:49:10 +04:00
|
|
|
_INLINE_ __u64 ext2fs_swab64(__u64 val)
|
|
|
|
{
|
2013-12-03 07:24:12 +04:00
|
|
|
return (ext2fs_swab32((__u32) (val >> 32)) |
|
2008-09-02 16:49:10 +04:00
|
|
|
(((__u64)ext2fs_swab32(val & 0xFFFFFFFFUL)) << 32));
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
{
|
2007-07-23 01:42:52 +04:00
|
|
|
return ext2fs_mark_generic_bitmap((ext2fs_generic_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
|
|
|
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)
|
|
|
|
{
|
2008-08-28 07:07:54 +04:00
|
|
|
return ext2fs_unmark_generic_bitmap((ext2fs_generic_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
|
|
|
block);
|
1997-04-29 18:53:37 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block)
|
|
|
|
{
|
2008-08-28 07:07:54 +04:00
|
|
|
return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
|
1997-04-29 18:53:37 +04:00
|
|
|
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
|
|
|
{
|
2008-08-28 07:07:54 +04:00
|
|
|
return ext2fs_mark_generic_bitmap((ext2fs_generic_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
|
|
|
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
|
|
|
{
|
2008-08-28 07:07:54 +04:00
|
|
|
return ext2fs_unmark_generic_bitmap((ext2fs_generic_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
|
|
|
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
|
|
|
{
|
2008-08-28 07:07:54 +04:00
|
|
|
return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
|
1997-04-29 18:53:37 +04:00
|
|
|
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)
|
|
|
|
{
|
2007-07-23 01:57:13 +04:00
|
|
|
ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, block);
|
1997-04-26 17:58:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block)
|
|
|
|
{
|
2007-07-23 01:57:13 +04:00
|
|
|
ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, block);
|
1997-04-26 17:58:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_fast_test_block_bitmap(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block)
|
|
|
|
{
|
2008-08-28 07:07:54 +04:00
|
|
|
return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
|
2007-07-23 01:57:13 +04:00
|
|
|
block);
|
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
|
|
|
{
|
2007-07-23 01:57:13 +04:00
|
|
|
ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap, inode);
|
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
|
|
|
{
|
2007-07-23 01:57:13 +04:00
|
|
|
ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap, inode);
|
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
|
|
|
{
|
2008-08-28 07:07:54 +04:00
|
|
|
return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
|
2007-07-23 01:57:13 +04:00
|
|
|
inode);
|
1997-04-26 17:58:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap)
|
|
|
|
{
|
2007-07-23 03:16:08 +04:00
|
|
|
return ext2fs_get_generic_bitmap_start((ext2fs_generic_bitmap) bitmap);
|
1997-04-26 17:58:21 +04:00
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2007-07-23 03:16:08 +04:00
|
|
|
return ext2fs_get_generic_bitmap_start((ext2fs_generic_bitmap) bitmap);
|
1997-04-26 17:58:21 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap)
|
|
|
|
{
|
2007-07-23 03:16:08 +04:00
|
|
|
return ext2fs_get_generic_bitmap_end((ext2fs_generic_bitmap) bitmap);
|
1997-04-26 17:58:21 +04:00
|
|
|
}
|
|
|
|
|
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
|
|
|
{
|
2007-07-23 03:16:08 +04:00
|
|
|
return ext2fs_get_generic_bitmap_end((ext2fs_generic_bitmap) bitmap);
|
1997-04-26 17:58:21 +04:00
|
|
|
}
|
|
|
|
|
1997-04-29 20:15:03 +04:00
|
|
|
_INLINE_ int ext2fs_fast_test_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num)
|
|
|
|
{
|
2007-07-23 02:54:10 +04:00
|
|
|
return ext2fs_test_block_bitmap_range(bitmap, block, num);
|
1997-04-29 20:15:03 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_mark_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num)
|
|
|
|
{
|
2007-07-23 02:54:10 +04:00
|
|
|
ext2fs_mark_block_bitmap_range(bitmap, block, num);
|
1997-04-29 20:15:03 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_unmark_block_bitmap_range(ext2fs_block_bitmap bitmap,
|
|
|
|
blk_t block, int num)
|
|
|
|
{
|
2007-07-23 02:54:10 +04:00
|
|
|
ext2fs_unmark_block_bitmap_range(bitmap, block, num);
|
1997-04-29 20:15:03 +04:00
|
|
|
}
|
2009-08-22 21:27:40 +04:00
|
|
|
|
|
|
|
/* 64-bit versions */
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_mark_block_bitmap2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block)
|
|
|
|
{
|
|
|
|
return ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
block);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_unmark_block_bitmap2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block)
|
|
|
|
{
|
|
|
|
return ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, block);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_test_block_bitmap2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block)
|
|
|
|
{
|
|
|
|
return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
block);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t inode)
|
|
|
|
{
|
|
|
|
return ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
inode);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t inode)
|
|
|
|
{
|
|
|
|
return ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
inode);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_test_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t inode)
|
|
|
|
{
|
|
|
|
return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
inode);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_mark_block_bitmap2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block)
|
|
|
|
{
|
|
|
|
ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, block);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_unmark_block_bitmap2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block)
|
|
|
|
{
|
|
|
|
ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, block);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_fast_test_block_bitmap2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block)
|
|
|
|
{
|
|
|
|
return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
block);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_mark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t inode)
|
|
|
|
{
|
|
|
|
ext2fs_mark_generic_bmap((ext2fs_generic_bitmap) bitmap, inode);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_unmark_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t inode)
|
|
|
|
{
|
|
|
|
ext2fs_unmark_generic_bmap((ext2fs_generic_bitmap) bitmap, inode);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_fast_test_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t inode)
|
|
|
|
{
|
|
|
|
return ext2fs_test_generic_bmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
inode);
|
|
|
|
}
|
|
|
|
|
2012-03-11 00:36:12 +04:00
|
|
|
_INLINE_ errcode_t ext2fs_find_first_zero_block_bitmap2(ext2fs_block_bitmap bitmap,
|
2012-04-06 22:49:22 +04:00
|
|
|
blk64_t start,
|
|
|
|
blk64_t end,
|
|
|
|
blk64_t *out)
|
2012-03-11 00:36:12 +04:00
|
|
|
{
|
|
|
|
__u64 o;
|
|
|
|
errcode_t rv;
|
|
|
|
|
|
|
|
rv = ext2fs_find_first_zero_generic_bmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
start, end, &o);
|
|
|
|
if (!rv)
|
|
|
|
*out = o;
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ errcode_t ext2fs_find_first_zero_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t start,
|
|
|
|
ext2_ino_t end,
|
|
|
|
ext2_ino_t *out)
|
|
|
|
{
|
|
|
|
__u64 o;
|
|
|
|
errcode_t rv;
|
|
|
|
|
|
|
|
rv = ext2fs_find_first_zero_generic_bmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
start, end, &o);
|
|
|
|
if (!rv)
|
2013-12-03 07:24:12 +04:00
|
|
|
*out = (ext2_ino_t) o;
|
2012-03-11 00:36:12 +04:00
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2014-01-13 00:57:31 +04:00
|
|
|
_INLINE_ errcode_t ext2fs_find_first_set_block_bitmap2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t start,
|
|
|
|
blk64_t end,
|
|
|
|
blk64_t *out)
|
|
|
|
{
|
|
|
|
__u64 o;
|
|
|
|
errcode_t rv;
|
|
|
|
|
|
|
|
rv = ext2fs_find_first_set_generic_bmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
start, end, &o);
|
|
|
|
if (!rv)
|
|
|
|
*out = o;
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ errcode_t ext2fs_find_first_set_inode_bitmap2(ext2fs_inode_bitmap bitmap,
|
|
|
|
ext2_ino_t start,
|
|
|
|
ext2_ino_t end,
|
|
|
|
ext2_ino_t *out)
|
|
|
|
{
|
|
|
|
__u64 o;
|
|
|
|
errcode_t rv;
|
|
|
|
|
|
|
|
rv = ext2fs_find_first_set_generic_bmap((ext2fs_generic_bitmap) bitmap,
|
|
|
|
start, end, &o);
|
|
|
|
if (!rv)
|
|
|
|
*out = (ext2_ino_t) o;
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2009-08-22 21:27:40 +04:00
|
|
|
_INLINE_ blk64_t ext2fs_get_block_bitmap_start2(ext2fs_block_bitmap bitmap)
|
|
|
|
{
|
|
|
|
return ext2fs_get_generic_bmap_start((ext2fs_generic_bitmap) bitmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_start2(ext2fs_inode_bitmap bitmap)
|
|
|
|
{
|
2013-12-03 07:24:12 +04:00
|
|
|
return (ext2_ino_t) ext2fs_get_generic_bmap_start((ext2fs_generic_bitmap) bitmap);
|
2009-08-22 21:27:40 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ blk64_t ext2fs_get_block_bitmap_end2(ext2fs_block_bitmap bitmap)
|
|
|
|
{
|
|
|
|
return ext2fs_get_generic_bmap_end((ext2fs_generic_bitmap) bitmap);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_end2(ext2fs_inode_bitmap bitmap)
|
|
|
|
{
|
2013-12-03 07:24:12 +04:00
|
|
|
return (ext2_ino_t) ext2fs_get_generic_bmap_end((ext2fs_generic_bitmap) bitmap);
|
2009-08-22 21:27:40 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ int ext2fs_fast_test_block_bitmap_range2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block,
|
|
|
|
unsigned int num)
|
|
|
|
{
|
|
|
|
return ext2fs_test_block_bitmap_range2(bitmap, block, num);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_mark_block_bitmap_range2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block,
|
|
|
|
unsigned int num)
|
|
|
|
{
|
|
|
|
ext2fs_mark_block_bitmap_range2(bitmap, block, num);
|
|
|
|
}
|
|
|
|
|
|
|
|
_INLINE_ void ext2fs_fast_unmark_block_bitmap_range2(ext2fs_block_bitmap bitmap,
|
|
|
|
blk64_t block,
|
|
|
|
unsigned int num)
|
|
|
|
{
|
|
|
|
ext2fs_unmark_block_bitmap_range2(bitmap, block, num);
|
|
|
|
}
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
#undef _INLINE_
|
|
|
|
#endif
|
1997-04-26 17:58:21 +04:00
|
|
|
|
2012-09-10 05:35:39 +04:00
|
|
|
#ifndef _EXT2_HAVE_ASM_BITOPS_
|
|
|
|
extern int ext2fs_set_bit(unsigned int nr,void * addr);
|
|
|
|
extern int ext2fs_clear_bit(unsigned int nr, void * addr);
|
|
|
|
extern int ext2fs_test_bit(unsigned int nr, const void * addr);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
extern int ext2fs_set_bit64(__u64 nr,void * addr);
|
|
|
|
extern int ext2fs_clear_bit64(__u64 nr, void * addr);
|
|
|
|
extern int ext2fs_test_bit64(__u64 nr, const void * addr);
|
2012-11-25 00:58:59 +04:00
|
|
|
extern unsigned int ext2fs_bitcount(const void *addr, unsigned int nbytes);
|