7ad978045

Mike Frysinger

2005-09-25

SOURCE BUG Duration: 7s

Subject

fix building with debugging enabled #413

SOURCE BUG

This commit was genuinely broken at the time (not related to our build system): scripts/config/mkconfigs.c (2005-08-01 - 2006-10-05 arasi) uretilen bbconfigopts.h icine .config satirlarini kacissiz, ham newline'larla gömüyordu - gecerli C degildi, busybox'un kendi bb_mkdep araci bile parse edemiyordu (7d219aab7 ile duzeltildi, mkconfigs shell scripte cevrildi)

→ Bu hatanin tam hikayesini ve duzeltme diffini gor

Binary

No binary (build failed)

Architecture & Compiler Flags

Architecture: x86_64-linux-gnu Compiler: gcc (Ubuntu 11.4.0-1ubuntu1~22.04.3) 11.4.0

—

Build Log

(log yok)

Commit Diff GitHub →

e2fsprogs/Makefile.in +2 -2 e2fsprogs/e2fsck/dict.c +11 -1 e2fsprogs/ext2fs/bitops.h +0 -513 e2fsprogs/ext2fs/ext2fs.h +0 -166 e2fsprogs/ext2fs/ext2fs_inline.c +472 -0

e2fsprogs/Makefile.in+2 -2

@@ -36,7 +36,7 @@ EXT2FS_SRC := gen_bitmap.c bitops.c ismounted.c mkjournal.c unix_io.c \
	bb_inode.c newdir.c alloc_sb.c lookup.c dirblock.c expanddir.c \
	dir_iterate.c link.c res_gdt.c icount.c get_pathname.c dblist.c \
	dirhash.c version.c flushb.c unlink.c check_desc.c valid_blk.c \
-	ext_attr.c bmap.c dblist_dir.c
+	ext_attr.c bmap.c dblist_dir.c ext2fs_inline.c
	EXT2FS_SRCS := $(patsubst %,ext2fs/%, $(EXT2FS_SRC))
	EXT2FS_OBJS := $(patsubst %.c,%.o, $(EXT2FS_SRCS))

@@ -47,7 +47,7 @@ UUID_OBJS := $(patsubst %.c,%.o, $(UUID_SRCS))

	E2FSPROGS-:=
	E2FSPROGS-$(CONFIG_CHATTR) += chattr.o $(E2P_OBJS)
-	E2FSPROGS-$(CONFIG_E2FSCK) += e2fsck.o $(BLKID_OBJS) $(E2FSCK_OBJS)
+	E2FSPROGS-$(CONFIG_E2FSCK) += e2fsck.o util.o $(BLKID_OBJS) $(E2FSCK_OBJS)
	E2FSPROGS-$(CONFIG_FSCK) += fsck.o base_device.o
	E2FSPROGS-$(CONFIG_LSATTR) += lsattr.o $(E2P_OBJS)
	E2FSPROGS-$(CONFIG_MKE2FS) += mke2fs.o util.o $(E2P_OBJS) $(BLKID_OBJS) $(EXT2FS_OBJS) $(UUID_OBJS)

e2fsprogs/e2fsck/dict.c+11 -1

@@ -562,9 +562,11 @@ void dict_insert(dict_t dict, dnode_t node, const void *key)

	node->key = key;

+	#ifndef NDEBUG
	assert (!dict_isfull(dict));
	assert (!dict_contains(dict, node));
	assert (!dnode_is_in_a_dict(node));
+	#endif

	/* basic binary tree insert */

@@ -642,7 +644,9 @@ void dict_insert(dict_t dict, dnode_t node, const void *key)

	dict_root(dict)->color = dnode_black;

+	#ifdef E2FSCK_NOTUSED
	assert (dict_verify(dict));
+	#endif
	}

	#ifdef E2FSCK_NOTUSED
@@ -816,7 +820,9 @@ dnode_t dict_delete(dict_t dict, dnode_t *delete)
	dict_root(dict)->color = dnode_black;
	}

+	#ifdef E2FSCK_NOTUSED
	assert (dict_verify(dict));
+	#endif

	return delete;
	}
@@ -998,7 +1004,9 @@ dnode_t dnode_init(dnode_t dnode, void *data)

	void dnode_destroy(dnode_t *dnode)
	{
+	#ifndef NDEBUG
	assert (!dnode_is_in_a_dict(dnode));
+	#endif
	free(dnode);
	}

@@ -1055,10 +1063,10 @@ void dict_load_next(dict_load_t load, dnode_t newnode, const void *key)
	dict_t *dict = load->dictptr;
	dnode_t *nil = &load->nilnode;

+	#ifndef NDEBUG
	assert (!dnode_is_in_a_dict(newnode));
	assert (dict->nodecount < dict->maxcount);

-	#ifndef NDEBUG
	if (dict->nodecount > 0) {
	if (dict->dupes)
	assert (dict->compare(nil->left->key, key) <= 0);
@@ -1152,7 +1160,9 @@ void dict_load_end(dict_load_t *load)
	complete->color = dnode_black;
	dict_root(dict) = complete;

+	#ifdef E2FSCK_NOTUSED
	assert (dict_verify(dict));
+	#endif
	}

	void dict_merge(dict_t dest, dict_t source)

e2fsprogs/ext2fs/bitops.h+0 -513

@@ -103,516 +103,3 @@ 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);
-	/*
-	* The inline routines themselves...
-	*
-	* If NO_INLINE_FUNCS is defined, then we won't try to do inline
-	* functions at all; they will be included as normal functions in
-	* inline.c
-	*/
-	#ifdef NO_INLINE_FUNCS
-	#if (defined(__GNUC__) && (defined(__i386__) \|\| defined(__i486__) \|\| \
-	defined(__i586__) \|\| defined(__mc68000__) \|\| \
-	defined(__sparc__)))
-	/* 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 */
-
-	#if (defined(INCLUDE_INLINE_FUNCS) \|\| !defined(NO_INLINE_FUNCS))
-	#ifdef INCLUDE_INLINE_FUNCS
-	#define _INLINE_ extern
-	#else
-	#ifdef __GNUC__
-	#define _INLINE_ extern __inline__
-	#else /* For Watcom C */
-	#define _INLINE_ extern inline
-	#endif
-	#endif
-
-	#if ((defined __GNUC__) && !defined(_EXT2_USE_C_VERSIONS_) && \
-	(defined(__i386__) \|\| defined(__i486__) \|\| defined(__i586__)))
-
-	#define _EXT2_HAVE_ASM_BITOPS_
-	#define _EXT2_HAVE_ASM_SWAB_
-	#define _EXT2_HAVE_ASM_FINDBIT_
-
-	/*
-	* 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]; };
-	#define EXT2FS_ADDR ((struct __dummy_h ) addr)
-	#define EXT2FS_CONST_ADDR ((const struct __dummy_h ) addr)
-
-	_INLINE_ int ext2fs_set_bit(int nr, void * addr)
-	{
-	int oldbit;
-
-	__asm__ __volatile__("btsl %2,%1\n\tsbbl %0,%0"
-	:"=r" (oldbit),"=m" (EXT2FS_ADDR)
-	:"r" (nr));
-	return oldbit;
-	}
-
-	_INLINE_ int ext2fs_clear_bit(int nr, void * addr)
-	{
-	int oldbit;
-
-	__asm__ __volatile__("btrl %2,%1\n\tsbbl %0,%0"
-	:"=r" (oldbit),"=m" (EXT2FS_ADDR)
-	:"r" (nr));
-	return oldbit;
-	}
-
-	_INLINE_ int ext2fs_test_bit(int nr, const void * addr)
-	{
-	int oldbit;
-
-	__asm__ __volatile__("btl %2,%1\n\tsbbl %0,%0"
-	:"=r" (oldbit)
-	:"m" (EXT2FS_CONST_ADDR),"r" (nr));
-	return oldbit;
-	}
-
-	#if 0
-	_INLINE_ int ext2fs_find_first_bit_set(void * addr, unsigned size)
-	{
-	int d0, d1, d2;
-	int res;
-
-	if (!size)
-	return 0;
-	/* This looks at memory. Mark it volatile to tell gcc not to move it around */
-	__asm__ __volatile__(
-	"cld\n\t"
-	"xorl %%eax,%%eax\n\t"
-	"xorl %%edx,%%edx\n\t"
-	"repe; scasl\n\t"
-	"je 1f\n\t"
-	"movl -4(%%edi),%%eax\n\t"
-	"subl $4,%%edi\n\t"
-	"bsfl %%eax,%%edx\n"
-	"1:\tsubl %%esi,%%edi\n\t"
-	"shll $3,%%edi\n\t"
-	"addl %%edi,%%edx"
-	:"=d" (res), "=&c" (d0), "=&D" (d1), "=&a" (d2)
-	:"1" ((size + 31) >> 5), "2" (addr), "S" (addr));
-	return res;
-	}
-
-	_INLINE_ int ext2fs_find_next_bit_set (void * addr, int size, int offset)
-	{
-	unsigned long * p = ((unsigned long *) addr) + (offset >> 5);
-	int set = 0, bit = offset & 31, res;
-
-	if (bit) {
-	/*
-	* Look for zero in first byte
-	*/
-	__asm__("bsfl %1,%0\n\t"
-	"jne 1f\n\t"
-	"movl $32, %0\n"
-	"1:"
-	: "=r" (set)
-	: "r" (*p >> bit));
-	if (set < (32 - bit))
-	return set + offset;
-	set = 32 - bit;
-	p++;
-	}
-	/*
-	* No bit found yet, search remaining full bytes for a bit
-	*/
-	res = ext2fs_find_first_bit_set(p, size - 32 * (p - (unsigned long *) addr));
-	return (offset + set + res);
-	}
-	#endif
-
-	#ifdef EXT2FS_ENABLE_SWAPFS
-	_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;
-	}
-	#endif
-
-	#undef EXT2FS_ADDR
-
-	#endif /* i386 */
-
-	#ifdef __mc68000__
-
-	#define _EXT2_HAVE_ASM_BITOPS_
-
-	_INLINE_ int ext2fs_set_bit(int nr,void * addr)
-	{
-	char retval;
-
-	__asm__ __volatile__ ("bfset %2@{%1:#1}; sne %0"
-	: "=d" (retval) : "d" (nr^7), "a" (addr));
-
-	return retval;
-	}
-
-	_INLINE_ int ext2fs_clear_bit(int nr, void * addr)
-	{
-	char retval;
-
-	__asm__ __volatile__ ("bfclr %2@{%1:#1}; sne %0"
-	: "=d" (retval) : "d" (nr^7), "a" (addr));
-
-	return retval;
-	}
-
-	_INLINE_ int ext2fs_test_bit(int nr, const void * addr)
-	{
-	char retval;
-
-	__asm__ __volatile__ ("bftst %2@{%1:#1}; sne %0"
-	: "=d" (retval) : "d" (nr^7), "a" (addr));
-
-	return retval;
-	}
-
-	#endif /* __mc68000__ */
-
-
-	#if !defined(_EXT2_HAVE_ASM_SWAB_) && defined(EXT2FS_ENABLE_SWAPFS)
-
-	_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 */
-
-	#if !defined(_EXT2_HAVE_ASM_FINDBIT_)
-	_INLINE_ int ext2fs_find_first_bit_set(void * addr, unsigned size)
-	{
-	unsigned char cp = (unsigned char ) addr;
-	int res = 0, d0;
-
-	if (!size)
-	return 0;
-
-	while ((size > res) && (*cp == 0)) {
-	cp++;
-	res += 8;
-	}
-	d0 = ffs(*cp);
-	if (d0 == 0)
-	return size;
-
-	return res + d0 - 1;
-	}
-
-	_INLINE_ int ext2fs_find_next_bit_set (void * addr, int size, int offset)
-	{
-	unsigned char * p;
-	int set = 0, bit = offset & 7, res = 0, d0;
-
-	res = offset >> 3;
-	p = ((unsigned char *) addr) + res;
-
-	if (bit) {
-	set = ffs(*p & ~((1 << bit) - 1));
-	if (set)
-	return (offset & ~7) + set - 1;
-	p++;
-	res += 8;
-	}
-	while ((size > res) && (*p == 0)) {
-	p++;
-	res += 8;
-	}
-	d0 = ffs(*p);
-	if (d0 == 0)
-	return size;
-
-	return (res + d0 - 1);
-	}
-	#endif
-
-	_INLINE_ int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap,
-	blk_t bitno);
-
-	_INLINE_ int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap,
-	blk_t bitno)
-	{
-	if ((bitno < bitmap->start) \|\| (bitno > bitmap->end)) {
-	ext2fs_warn_bitmap2(bitmap, EXT2FS_TEST_ERROR, bitno);
-	return 0;
-	}
-	return ext2fs_test_bit(bitno - bitmap->start, bitmap->bitmap);
-	}
-
-	_INLINE_ int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap,
-	blk_t block)
-	{
-	return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap)
-	bitmap,
-	block);
-	}
-
-	_INLINE_ int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
-	blk_t block)
-	{
-	return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
-	block);
-	}
-
-	_INLINE_ int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap,
-	blk_t block)
-	{
-	return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
-	block);
-	}
-
-	_INLINE_ int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,
-	ext2_ino_t inode)
-	{
-	return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
-	inode);
-	}
-
-	_INLINE_ int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
-	ext2_ino_t inode)
-	{
-	return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
-	inode);
-	}
-
-	_INLINE_ int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap,
-	ext2_ino_t inode)
-	{
-	return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
-	inode);
-	}
-
-	_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
-	ext2fs_set_bit(block - bitmap->start, bitmap->bitmap);
-	}
-
-	_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
-	ext2fs_clear_bit(block - bitmap->start, bitmap->bitmap);
-	}
-
-	_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
-	return ext2fs_test_bit(block - bitmap->start, bitmap->bitmap);
-	}
-
-	_INLINE_ void ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,
-	ext2_ino_t inode)
-	{
-	#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
-	ext2fs_set_bit(inode - bitmap->start, bitmap->bitmap);
-	}
-
-	_INLINE_ void ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
-	ext2_ino_t inode)
-	{
-	#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
-	ext2fs_clear_bit(inode - bitmap->start, bitmap->bitmap);
-	}
-
-	_INLINE_ int ext2fs_fast_test_inode_bitmap(ext2fs_inode_bitmap bitmap,
-	ext2_ino_t inode)
-	{
-	#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
-	return ext2fs_test_bit(inode - bitmap->start, bitmap->bitmap);
-	}
-
-	_INLINE_ blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap)
-	{
-	return bitmap->start;
-	}
-
-	_INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap)
-	{
-	return bitmap->start;
-	}
-
-	_INLINE_ blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap)
-	{
-	return bitmap->end;
-	}
-
-	_INLINE_ ext2_ino_t ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap)
-	{
-	return bitmap->end;
-	}
-
-	_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);
-	}
-	#undef _INLINE_
-	#endif
-

e2fsprogs/ext2fs/ext2fs.h+0 -166

@@ -962,172 +962,6 @@ extern int ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino);
	extern blk_t ext2fs_inode_data_blocks(ext2_filsys fs,
	struct ext2_inode *inode);

-	/*
-	* The actual inlined functions definitions themselves...
-	*
-	* If NO_INLINE_FUNCS is defined, then we won't try to do inline
-	* functions at all!
-	*/
-	#if (defined(INCLUDE_INLINE_FUNCS) \|\| !defined(NO_INLINE_FUNCS))
-	#ifdef INCLUDE_INLINE_FUNCS
-	#define _INLINE_ extern
-	#else
-	#ifdef __GNUC__
-	#define _INLINE_ extern __inline__
-	#else /* For Watcom C */
-	#define _INLINE_ extern inline
-	#endif
-	#endif
-
-	#ifndef EXT2_CUSTOM_MEMORY_ROUTINES
-	/*
-	* Allocate memory
-	*/
-	_INLINE_ errcode_t ext2fs_get_mem(unsigned long size, void *ptr)
-	{
-	void pp = (void )ptr;
-
-	*pp = malloc(size);
-	if (!*pp)
-	return EXT2_ET_NO_MEMORY;
-	return 0;
-	}
-
-	/*
-	* Free memory
-	*/
-	_INLINE_ errcode_t ext2fs_free_mem(void *ptr)
-	{
-	void pp = (void )ptr;
-
-	free(*pp);
-	*pp = 0;
-	return 0;
-	}
-
-	/*
-	* Resize memory
-	*/
-	_INLINE_ errcode_t ext2fs_resize_mem(unsigned long EXT2FS_ATTR((unused)) old_size,
-	unsigned long size, void *ptr)
-	{
-	void *p;
-	void pp = (void )ptr;
-
-	p = realloc(*pp, size);
-	if (!p)
-	return EXT2_ET_NO_MEMORY;
-	*pp = p;
-	return 0;
-	}
-	#endif /* Custom memory routines */
-
-	/*
-	* Mark a filesystem superblock as dirty
-	*/
-	_INLINE_ void ext2fs_mark_super_dirty(ext2_filsys fs)
-	{
-	fs->flags \|= EXT2_FLAG_DIRTY \| EXT2_FLAG_CHANGED;
-	}
-
-	/*
-	* Mark a filesystem as changed
-	*/
-	_INLINE_ void ext2fs_mark_changed(ext2_filsys fs)
-	{
-	fs->flags \|= EXT2_FLAG_CHANGED;
-	}
-
-	/*
-	* Check to see if a filesystem has changed
-	*/
-	_INLINE_ int ext2fs_test_changed(ext2_filsys fs)
-	{
-	return (fs->flags & EXT2_FLAG_CHANGED);
-	}
-
-	/*
-	* Mark a filesystem as valid
-	*/
-	_INLINE_ void ext2fs_mark_valid(ext2_filsys fs)
-	{
-	fs->flags \|= EXT2_FLAG_VALID;
-	}
-
-	/*
-	* Mark a filesystem as NOT valid
-	*/
-	_INLINE_ void ext2fs_unmark_valid(ext2_filsys fs)
-	{
-	fs->flags &= ~EXT2_FLAG_VALID;
-	}
-
-	/*
-	* Check to see if a filesystem is valid
-	*/
-	_INLINE_ int ext2fs_test_valid(ext2_filsys fs)
-	{
-	return (fs->flags & EXT2_FLAG_VALID);
-	}
-
-	/*
-	* Mark the inode bitmap as dirty
-	*/
-	_INLINE_ void ext2fs_mark_ib_dirty(ext2_filsys fs)
-	{
-	fs->flags \|= EXT2_FLAG_IB_DIRTY \| EXT2_FLAG_CHANGED;
-	}
-
-	/*
-	* Mark the block bitmap as dirty
-	*/
-	_INLINE_ void ext2fs_mark_bb_dirty(ext2_filsys fs)
-	{
-	fs->flags \|= EXT2_FLAG_BB_DIRTY \| EXT2_FLAG_CHANGED;
-	}
-
-	/*
-	* Check to see if a filesystem's inode bitmap is dirty
-	*/
-	_INLINE_ int ext2fs_test_ib_dirty(ext2_filsys fs)
-	{
-	return (fs->flags & EXT2_FLAG_IB_DIRTY);
-	}
-
-	/*
-	* Check to see if a filesystem's block bitmap is dirty
-	*/
-	_INLINE_ int ext2fs_test_bb_dirty(ext2_filsys fs)
-	{
-	return (fs->flags & EXT2_FLAG_BB_DIRTY);
-	}
-
-	/*
-	* Return the group # of a block
-	*/
-	_INLINE_ int ext2fs_group_of_blk(ext2_filsys fs, blk_t blk)
-	{
-	return (blk - fs->super->s_first_data_block) /
-	fs->super->s_blocks_per_group;
-	}
-
-	/*
-	* Return the group # of an inode number
-	*/
-	_INLINE_ int ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino)
-	{
-	return (ino - 1) / fs->super->s_inodes_per_group;
-	}
-
-	_INLINE_ blk_t ext2fs_inode_data_blocks(ext2_filsys fs,
-	struct ext2_inode *inode)
-	{
-	return inode->i_blocks -
-	(inode->i_file_acl ? fs->blocksize >> 9 : 0);
-	}
-	#undef _INLINE_
-	#endif
-
	#ifdef __cplusplus
	}
	#endif

e2fsprogs/ext2fs/ext2fs_inline.c+472 -0

@@ -0,0 +1,472 @@
+	/*
+	* ext2fs.h --- ext2fs
+	*
+	* 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%
+	*/
+
+	#include "ext2fs/ext2fs.h"
+	#include "ext2fs/bitops.h"
+
+	/*
+	* Allocate memory
+	*/
+	errcode_t ext2fs_get_mem(unsigned long size, void *ptr)
+	{
+	void pp = (void )ptr;
+
+	*pp = malloc(size);
+	if (!*pp)
+	return EXT2_ET_NO_MEMORY;
+	return 0;
+	}
+
+	/*
+	* Free memory
+	*/
+	errcode_t ext2fs_free_mem(void *ptr)
+	{
+	void pp = (void )ptr;
+
+	free(*pp);
+	*pp = 0;
+	return 0;
+	}
+
+	/*
+	* Resize memory
+	*/
+	errcode_t ext2fs_resize_mem(unsigned long EXT2FS_ATTR((unused)) old_size,
+	unsigned long size, void *ptr)
+	{
+	void *p;
+	void pp = (void )ptr;
+
+	p = realloc(*pp, size);
+	if (!p)
+	return EXT2_ET_NO_MEMORY;
+	*pp = p;
+	return 0;
+	}
+
+	/*
+	* Mark a filesystem superblock as dirty
+	*/
+	void ext2fs_mark_super_dirty(ext2_filsys fs)
+	{
+	fs->flags \|= EXT2_FLAG_DIRTY \| EXT2_FLAG_CHANGED;
+	}
+
+	/*
+	* Mark a filesystem as changed
+	*/
+	void ext2fs_mark_changed(ext2_filsys fs)
+	{
+	fs->flags \|= EXT2_FLAG_CHANGED;
+	}
+
+	/*
+	* Check to see if a filesystem has changed
+	*/
+	int ext2fs_test_changed(ext2_filsys fs)
+	{
+	return (fs->flags & EXT2_FLAG_CHANGED);
+	}
+
+	/*
+	* Mark a filesystem as valid
+	*/
+	void ext2fs_mark_valid(ext2_filsys fs)
+	{
+	fs->flags \|= EXT2_FLAG_VALID;
+	}
+
+	/*
+	* Mark a filesystem as NOT valid
+	*/
+	void ext2fs_unmark_valid(ext2_filsys fs)
+	{
+	fs->flags &= ~EXT2_FLAG_VALID;
+	}
+
+	/*
+	* Check to see if a filesystem is valid
+	*/
+	int ext2fs_test_valid(ext2_filsys fs)
+	{
+	return (fs->flags & EXT2_FLAG_VALID);
+	}
+
+	/*
+	* Mark the inode bitmap as dirty
+	*/
+	void ext2fs_mark_ib_dirty(ext2_filsys fs)
+	{
+	fs->flags \|= EXT2_FLAG_IB_DIRTY \| EXT2_FLAG_CHANGED;
+	}
+
+	/*
+	* Mark the block bitmap as dirty
+	*/
+	void ext2fs_mark_bb_dirty(ext2_filsys fs)
+	{
+	fs->flags \|= EXT2_FLAG_BB_DIRTY \| EXT2_FLAG_CHANGED;
+	}
+
+	/*
+	* Check to see if a filesystem's inode bitmap is dirty
+	*/
+	int ext2fs_test_ib_dirty(ext2_filsys fs)
+	{
+	return (fs->flags & EXT2_FLAG_IB_DIRTY);
+	}
+
+	/*
+	* Check to see if a filesystem's block bitmap is dirty
+	*/
+	int ext2fs_test_bb_dirty(ext2_filsys fs)
+	{
+	return (fs->flags & EXT2_FLAG_BB_DIRTY);
+	}
+
+	/*
+	* Return the group # of a block
+	*/
+	int ext2fs_group_of_blk(ext2_filsys fs, blk_t blk)
+	{
+	return (blk - fs->super->s_first_data_block) /
+	fs->super->s_blocks_per_group;
+	}
+
+	/*
+	* Return the group # of an inode number
+	*/
+	int ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino)
+	{
+	return (ino - 1) / fs->super->s_inodes_per_group;
+	}
+
+	blk_t ext2fs_inode_data_blocks(ext2_filsys fs,
+	struct ext2_inode *inode)
+	{
+	return inode->i_blocks -
+	(inode->i_file_acl ? fs->blocksize >> 9 : 0);
+	}
+
+
+
+
+
+
+
+
+
+	__u16 ext2fs_swab16(__u16 val)
+	{
+	return (val >> 8) \| (val << 8);
+	}
+
+	__u32 ext2fs_swab32(__u32 val)
+	{
+	return ((val>>24) \| ((val>>8)&0xFF00) \|
+	((val<<8)&0xFF0000) \| (val<<24));
+	}
+
+	int ext2fs_find_first_bit_set(void * addr, unsigned size)
+	{
+	char cp = (unsigned char ) addr;
+	int res = 0, d0;
+
+	if (!size)
+	return 0;
+
+	while ((size > res) && (*cp == 0)) {
+	cp++;
+	res += 8;
+	}
+	d0 = ffs(*cp);
+	if (d0 == 0)
+	return size;
+
+	return res + d0 - 1;
+	}
+
+	int ext2fs_find_next_bit_set (void * addr, int size, int offset)
+	{
+	unsigned char * p;
+	int set = 0, bit = offset & 7, res = 0, d0;
+
+	res = offset >> 3;
+	p = ((unsigned char *) addr) + res;
+
+	if (bit) {
+	set = ffs(*p & ~((1 << bit) - 1));
+	if (set)
+	return (offset & ~7) + set - 1;
+	p++;
+	res += 8;
+	}
+	while ((size > res) && (*p == 0)) {
+	p++;
+	res += 8;
+	}
+	d0 = ffs(*p);
+	if (d0 == 0)
+	return size;
+
+	return (res + d0 - 1);
+	}
+
+	int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap,
+	blk_t bitno);
+
+	int ext2fs_test_generic_bitmap(ext2fs_generic_bitmap bitmap,
+	blk_t bitno)
+	{
+	if ((bitno < bitmap->start) \|\| (bitno > bitmap->end)) {
+	ext2fs_warn_bitmap2(bitmap, EXT2FS_TEST_ERROR, bitno);
+	return 0;
+	}
+	return ext2fs_test_bit(bitno - bitmap->start, bitmap->bitmap);
+	}
+
+	int ext2fs_mark_block_bitmap(ext2fs_block_bitmap bitmap,
+	blk_t block)
+	{
+	return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap)
+	bitmap,
+	block);
+	}
+
+	int ext2fs_unmark_block_bitmap(ext2fs_block_bitmap bitmap,
+	blk_t block)
+	{
+	return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
+	block);
+	}
+
+	int ext2fs_test_block_bitmap(ext2fs_block_bitmap bitmap,
+	blk_t block)
+	{
+	return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
+	block);
+	}
+
+	int ext2fs_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,
+	ext2_ino_t inode)
+	{
+	return ext2fs_mark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
+	inode);
+	}
+
+	int ext2fs_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
+	ext2_ino_t inode)
+	{
+	return ext2fs_unmark_generic_bitmap((ext2fs_generic_bitmap) bitmap,
+	inode);
+	}
+
+	int ext2fs_test_inode_bitmap(ext2fs_inode_bitmap bitmap,
+	ext2_ino_t inode)
+	{
+	return ext2fs_test_generic_bitmap((ext2fs_generic_bitmap) bitmap,
+	inode);
+	}
+
+	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
+	ext2fs_set_bit(block - bitmap->start, bitmap->bitmap);
+	}
+
+	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
+	ext2fs_clear_bit(block - bitmap->start, bitmap->bitmap);
+	}
+
+	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
+	return ext2fs_test_bit(block - bitmap->start, bitmap->bitmap);
+	}
+
+	void ext2fs_fast_mark_inode_bitmap(ext2fs_inode_bitmap bitmap,
+	ext2_ino_t inode)
+	{
+	#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
+	ext2fs_set_bit(inode - bitmap->start, bitmap->bitmap);
+	}
+
+	void ext2fs_fast_unmark_inode_bitmap(ext2fs_inode_bitmap bitmap,
+	ext2_ino_t inode)
+	{
+	#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
+	ext2fs_clear_bit(inode - bitmap->start, bitmap->bitmap);
+	}
+
+	int ext2fs_fast_test_inode_bitmap(ext2fs_inode_bitmap bitmap,
+	ext2_ino_t inode)
+	{
+	#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
+	return ext2fs_test_bit(inode - bitmap->start, bitmap->bitmap);
+	}
+
+	blk_t ext2fs_get_block_bitmap_start(ext2fs_block_bitmap bitmap)
+	{
+	return bitmap->start;
+	}
+
+	ext2_ino_t ext2fs_get_inode_bitmap_start(ext2fs_inode_bitmap bitmap)
+	{
+	return bitmap->start;
+	}
+
+	blk_t ext2fs_get_block_bitmap_end(ext2fs_block_bitmap bitmap)
+	{
+	return bitmap->end;
+	}
+
+	ext2_ino_t ext2fs_get_inode_bitmap_end(ext2fs_inode_bitmap bitmap)
+	{
+	return bitmap->end;
+	}
+
+	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;
+	}
+
+	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;
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}
+
+	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);
+	}