errcode_t ext2fs_fudge_generic_bmap_end(ext2fs_generic_bitmap bitmap,
errcode_t neq,
__u64 end, __u64 *oend)
{
if (!bitmap)
return EINVAL;
if (EXT2FS_IS_32_BITMAP(bitmap)) {
ext2_ino_t tmp_oend;
int retval;
retval = ext2fs_fudge_generic_bitmap_end(bitmap, bitmap->magic,
neq, end, &tmp_oend);
if (oend)
*oend = tmp_oend;
return retval;
}
if (!EXT2FS_IS_64_BITMAP(bitmap))
return EINVAL;
if (end > bitmap->real_end)
return neq;
if (oend)
*oend = bitmap->end;
bitmap->end = end;
return 0;
}
int ext2fs_test_generic_bmap(ext2fs_generic_bitmap bitmap,
__u64 arg)
{
if (!bitmap)
return 0;
if (EXT2FS_IS_32_BITMAP(bitmap)) {
if (arg & ~0xffffffffULL) {
ext2fs_warn_bitmap2(bitmap, EXT2FS_TEST_ERROR,
0xffffffff);
return 0;
}
return ext2fs_test_generic_bitmap(bitmap, arg);
}
if (!EXT2FS_IS_64_BITMAP(bitmap))
return 0;
arg >>= bitmap->cluster_bits;
if ((arg < bitmap->start) || (arg > bitmap->end)) {
warn_bitmap(bitmap, EXT2FS_TEST_ERROR, arg);
return 0;
}
return bitmap->bitmap_ops->test_bmap(bitmap, arg);
}
void ext2fs_clear_generic_bmap(ext2fs_generic_bitmap bitmap)
{
if (EXT2FS_IS_32_BITMAP(bitmap))
ext2fs_clear_generic_bitmap(bitmap);
bitmap->bitmap_ops->clear_bmap (bitmap);
}
errcode_t ext2fs_compare_generic_bmap(errcode_t neq,
ext2fs_generic_bitmap bm1,
ext2fs_generic_bitmap bm2)
{
blk64_t i;
if (!bm1 || !bm2)
return EINVAL;
if (bm1->magic != bm2->magic)
return EINVAL;
/* Now we know both bitmaps have the same magic */
if (EXT2FS_IS_32_BITMAP(bm1))
return ext2fs_compare_generic_bitmap(bm1->magic, neq, bm1, bm2);
if (!EXT2FS_IS_64_BITMAP(bm1))
return EINVAL;
if ((bm1->start != bm2->start) ||
(bm1->end != bm2->end))
return neq;
for (i = bm1->end - ((bm1->end - bm1->start) % 8); i <= bm1->end; i++)
if (ext2fs_test_generic_bmap(bm1, i) !=
ext2fs_test_generic_bmap(bm2, i))
return neq;
return 0;
}
int ext2fs_unmark_generic_bmap(ext2fs_generic_bitmap bitmap,
__u64 arg)
{
if (!bitmap)
return 0;
if (EXT2FS_IS_32_BITMAP(bitmap)) {
if (arg & ~0xffffffffULL) {
ext2fs_warn_bitmap2(bitmap, EXT2FS_UNMARK_ERROR,
0xffffffff);
return 0;
}
return ext2fs_unmark_generic_bitmap(bitmap, arg);
}
if (!EXT2FS_IS_64_BITMAP(bitmap))
return 0;
arg >>= bitmap->cluster_bits;
INC_STAT(bitmap, unmark_count);
if ((arg < bitmap->start) || (arg > bitmap->end)) {
warn_bitmap(bitmap, EXT2FS_UNMARK_ERROR, arg);
return 0;
}
return bitmap->bitmap_ops->unmark_bmap(bitmap, arg);
}
int ext2fs_test_block_bitmap_range2(ext2fs_block_bitmap bmap,
blk64_t block, unsigned int num)
{
if (!bmap)
return EINVAL;
if (num == 1)
return !ext2fs_test_generic_bmap((ext2fs_generic_bitmap)
bmap, block);
if (EXT2FS_IS_32_BITMAP(bmap)) {
if ((block+num) & ~0xffffffffULL) {
ext2fs_warn_bitmap2((ext2fs_generic_bitmap) bmap,
EXT2FS_UNMARK_ERROR, 0xffffffff);
return EINVAL;
}
return ext2fs_test_block_bitmap_range(
(ext2fs_generic_bitmap) bmap, block, num);
}
if (!EXT2FS_IS_64_BITMAP(bmap))
return EINVAL;
return bmap->bitmap_ops->test_clear_bmap_extent(bmap, block, num);
}
void ext2fs_free_generic_bmap(ext2fs_generic_bitmap bmap)
{
if (!bmap)
return;
if (EXT2FS_IS_32_BITMAP(bmap)) {
ext2fs_free_generic_bitmap(bmap);
return;
}
if (!EXT2FS_IS_64_BITMAP(bmap))
return;
#ifdef BMAP_STATS
if (getenv("E2FSPROGS_BITMAP_STATS")) {
ext2fs_print_bmap_statistics(bmap);
bmap->bitmap_ops->print_stats(bmap);
}
#endif
bmap->bitmap_ops->free_bmap(bmap);
if (bmap->description) {
ext2fs_free_mem(&bmap->description);
bmap->description = 0;
}
bmap->magic = 0;
ext2fs_free_mem(&bmap);
}
void ext2fs_unmark_block_bitmap_range2(ext2fs_block_bitmap bmap,
blk64_t block, unsigned int num)
{
if (!bmap)
return;
if (EXT2FS_IS_32_BITMAP(bmap)) {
if ((block+num) & ~0xffffffffULL) {
ext2fs_warn_bitmap2((ext2fs_generic_bitmap) bmap,
EXT2FS_UNMARK_ERROR, 0xffffffff);
return;
}
ext2fs_unmark_block_bitmap_range((ext2fs_generic_bitmap) bmap,
block, num);
}
if (!EXT2FS_IS_64_BITMAP(bmap))
return;
if ((block < bmap->start) || (block+num-1 > bmap->end)) {
ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_UNMARK, block,
bmap->description);
return;
}
bmap->bitmap_ops->unmark_bmap_extent(bmap, block, num);
}
errcode_t ext2fs_copy_generic_bmap(ext2fs_generic_bitmap src,
ext2fs_generic_bitmap *dest)
{
char *descr, *new_descr;
ext2fs_generic_bitmap new_bmap;
errcode_t retval;
if (!src)
return EINVAL;
if (EXT2FS_IS_32_BITMAP(src))
return ext2fs_copy_generic_bitmap(src, dest);
if (!EXT2FS_IS_64_BITMAP(src))
return EINVAL;
/* Allocate a new bitmap struct */
retval = ext2fs_get_mem(sizeof(struct ext2fs_struct_generic_bitmap),
&new_bmap);
if (retval)
return retval;
/* Copy all the high-level parts over */
new_bmap->magic = src->magic;
new_bmap->fs = src->fs;
new_bmap->start = src->start;
new_bmap->end = src->end;
new_bmap->real_end = src->real_end;
new_bmap->bitmap_ops = src->bitmap_ops;
new_bmap->base_error_code = src->base_error_code;
new_bmap->cluster_bits = src->cluster_bits;
descr = src->description;
if (descr) {
retval = ext2fs_get_mem(strlen(descr)+1, &new_descr);
if (retval) {
ext2fs_free_mem(&new_bmap);
return retval;
}
strcpy(new_descr, descr);
new_bmap->description = new_descr;
}
retval = src->bitmap_ops->copy_bmap(src, new_bmap);
if (retval) {
ext2fs_free_mem(&new_bmap->description);
ext2fs_free_mem(&new_bmap);
return retval;
}
*dest = new_bmap;
return 0;
}
__u64 ext2fs_get_generic_bmap_end(ext2fs_generic_bitmap bitmap)
{
if (!bitmap)
return EINVAL;
if (EXT2FS_IS_32_BITMAP(bitmap))
return ext2fs_get_generic_bitmap_end(bitmap);
if (!EXT2FS_IS_64_BITMAP(bitmap))
return EINVAL;
return bitmap->end;
}
errcode_t ext2fs_find_first_zero_generic_bmap(ext2fs_generic_bitmap bitmap,
__u64 start, __u64 end, __u64 *out)
{
int b;
if (!bitmap)
return EINVAL;
if (EXT2FS_IS_64_BITMAP(bitmap) && bitmap->bitmap_ops->find_first_zero)
return bitmap->bitmap_ops->find_first_zero(bitmap, start,
end, out);
if (EXT2FS_IS_32_BITMAP(bitmap)) {
blk_t blk = 0;
errcode_t retval;
if (((start) & ~0xffffffffULL) ||
((end) & ~0xffffffffULL)) {
ext2fs_warn_bitmap2(bitmap, EXT2FS_TEST_ERROR, start);
return EINVAL;
}
retval = ext2fs_find_first_zero_generic_bitmap(bitmap, start,
end, &blk);
if (retval == 0)
*out = blk;
return retval;
}
if (!EXT2FS_IS_64_BITMAP(bitmap))
return EINVAL;
start >>= bitmap->cluster_bits;
end >>= bitmap->cluster_bits;
if (start < bitmap->start || end > bitmap->end || start > end) {
warn_bitmap(bitmap, EXT2FS_TEST_ERROR, start);
return EINVAL;
}
while (start <= end) {
b = bitmap->bitmap_ops->test_bmap(bitmap, start);
if (!b) {
*out = start << bitmap->cluster_bits;
return 0;
}
start++;
}
return ENOENT;
}
void ext2fs_set_generic_bmap_padding(ext2fs_generic_bitmap bmap)
{
__u64 start, num;
if (EXT2FS_IS_32_BITMAP(bmap)) {
ext2fs_set_generic_bitmap_padding(bmap);
return;
}
start = bmap->end + 1;
num = bmap->real_end - bmap->end;
bmap->bitmap_ops->mark_bmap_extent(bmap, start, num);
/* XXX ought to warn on error */
}
__u32 ext2fs_get_generic_bitmap_end(ext2fs_generic_bitmap bitmap)
{
if (!EXT2FS_IS_32_BITMAP(bitmap)) {
if (EXT2FS_IS_64_BITMAP(bitmap)) {
ext2fs_warn_bitmap32(bitmap, __func__);
return ext2fs_get_generic_bmap_end(bitmap);
}
#ifndef OMIT_COM_ERR
com_err(0, EXT2_ET_MAGIC_GENERIC_BITMAP,
"get_bitmap_end");
#endif
return 0;
}
return bitmap->end;
}
errcode_t ext2fs_resize_generic_bmap(ext2fs_generic_bitmap bmap,
__u64 new_end,
__u64 new_real_end)
{
if (!bmap)
return EINVAL;
if (EXT2FS_IS_32_BITMAP(bmap))
return ext2fs_resize_generic_bitmap(bmap->magic, new_end,
new_real_end, bmap);
if (!EXT2FS_IS_64_BITMAP(bmap))
return EINVAL;
return bmap->bitmap_ops->resize_bmap(bmap, new_end, new_real_end);
}
void ext2fs_clear_generic_bitmap(ext2fs_generic_bitmap bitmap)
{
if (!EXT2FS_IS_32_BITMAP(bitmap)) {
if (EXT2FS_IS_64_BITMAP(bitmap)) {
ext2fs_warn_bitmap32(bitmap, __func__);
ext2fs_clear_generic_bmap(bitmap);
return;
}
#ifndef OMIT_COM_ERR
com_err(0, EXT2_ET_MAGIC_GENERIC_BITMAP,
"clear_generic_bitmap");
#endif
return;
}
memset(bitmap->bitmap, 0,
(size_t) (((bitmap->real_end - bitmap->start) / 8) + 1));
}
int ext2fs_test_block_bitmap_range2(ext2fs_block_bitmap bmap,
blk64_t block, unsigned int num)
{
__u64 end = block + num;
if (!bmap)
return EINVAL;
if (num == 1)
return !ext2fs_test_generic_bmap((ext2fs_generic_bitmap)
bmap, block);
if (EXT2FS_IS_32_BITMAP(bmap)) {
if ((block+num-1) & ~0xffffffffULL) {
ext2fs_warn_bitmap2((ext2fs_generic_bitmap) bmap,
EXT2FS_UNMARK_ERROR, 0xffffffff);
return EINVAL;
}
return ext2fs_test_block_bitmap_range(
(ext2fs_generic_bitmap) bmap, block, num);
}
if (!EXT2FS_IS_64_BITMAP(bmap))
return EINVAL;
INC_STAT(bmap, test_ext_count);
/* convert to clusters if necessary */
block >>= bmap->cluster_bits;
end += (1 << bmap->cluster_bits) - 1;
end >>= bmap->cluster_bits;
num = end - block;
if ((block < bmap->start) || (block+num-1 > bmap->end)) {
ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_TEST, block,
bmap->description);
//change return value to none to 0, build error fix
return 0;
}
return bmap->bitmap_ops->test_clear_bmap_extent(bmap, block, num);
}
int ext2fs_unmark_generic_bitmap(ext2fs_generic_bitmap bitmap,
blk_t bitno)
{
if (!EXT2FS_IS_32_BITMAP(bitmap)) {
if (EXT2FS_IS_64_BITMAP(bitmap)) {
ext2fs_warn_bitmap32(bitmap, __func__);
return ext2fs_unmark_generic_bmap(bitmap, bitno);
}
#ifndef OMIT_COM_ERR
com_err(0, EXT2_ET_MAGIC_GENERIC_BITMAP,
"mark_bitmap(%lu)", (unsigned long) bitno);
#endif
return 0;
}
if ((bitno < bitmap->start) || (bitno > bitmap->end)) {
ext2fs_warn_bitmap2(bitmap, EXT2FS_UNMARK_ERROR, bitno);
return 0;
}
return ext2fs_clear_bit(bitno - bitmap->start, bitmap->bitmap);
}
void ext2fs_free_generic_bmap(ext2fs_generic_bitmap bmap)
{
if (!bmap)
return;
if (EXT2FS_IS_32_BITMAP(bmap)) {
ext2fs_free_generic_bitmap(bmap);
return;
}
if (!EXT2FS_IS_64_BITMAP(bmap))
return;
bmap->bitmap_ops->free_bmap(bmap);
if (bmap->description) {
ext2fs_free_mem(&bmap->description);
bmap->description = 0;
}
bmap->magic = 0;
ext2fs_free_mem(&bmap);
}
errcode_t ext2fs_get_generic_bmap_range(ext2fs_generic_bitmap bmap,
__u64 start, unsigned int num,
void *out)
{
if (!bmap)
return EINVAL;
if (EXT2FS_IS_32_BITMAP(bmap)) {
if ((start+num) & ~0xffffffffULL) {
ext2fs_warn_bitmap2(bmap,
EXT2FS_UNMARK_ERROR, 0xffffffff);
return EINVAL;
}
return ext2fs_get_generic_bitmap_range(bmap, bmap->magic,
start, num, out);
}
if (!EXT2FS_IS_64_BITMAP(bmap))
return EINVAL;
return bmap->bitmap_ops->get_bmap_range(bmap, start, num, out);
}
void ext2fs_unmark_block_bitmap_range2(ext2fs_block_bitmap bmap,
blk64_t block, unsigned int num)
{
__u64 end = block + num;
if (!bmap)
return;
if (EXT2FS_IS_32_BITMAP(bmap)) {
if ((block+num-1) & ~0xffffffffULL) {
ext2fs_warn_bitmap2((ext2fs_generic_bitmap) bmap,
EXT2FS_UNMARK_ERROR, 0xffffffff);
return;
}
ext2fs_unmark_block_bitmap_range((ext2fs_generic_bitmap) bmap,
block, num);
}
if (!EXT2FS_IS_64_BITMAP(bmap))
return;
INC_STAT(bmap, unmark_ext_count);
/* convert to clusters if necessary */
block >>= bmap->cluster_bits;
end += (1 << bmap->cluster_bits) - 1;
end >>= bmap->cluster_bits;
num = end - block;
if ((block < bmap->start) || (block+num-1 > bmap->end)) {
ext2fs_warn_bitmap(EXT2_ET_BAD_BLOCK_UNMARK, block,
bmap->description);
return;
}
bmap->bitmap_ops->unmark_bmap_extent(bmap, block, num);
}
int ext2fs_test_generic_bmap(ext2fs_generic_bitmap bitmap,
__u64 arg)
{
if (!bitmap)
return 0;
if (EXT2FS_IS_32_BITMAP(bitmap)) {
if (arg & ~0xffffffffULL) {
ext2fs_warn_bitmap2(bitmap, EXT2FS_TEST_ERROR,
0xffffffff);
return 0;
}
return ext2fs_test_generic_bitmap(bitmap, arg);
}
if (!EXT2FS_IS_64_BITMAP(bitmap))
return 0;
arg >>= bitmap->cluster_bits;
#ifdef BMAP_STATS_OPS
bitmap->stats.test_count++;
if (arg == bitmap->stats.last_tested + 1)
bitmap->stats.test_seq++;
if (arg < bitmap->stats.last_tested)
bitmap->stats.test_back++;
bitmap->stats.last_tested = arg;
#endif
if ((arg < bitmap->start) || (arg > bitmap->end)) {
warn_bitmap(bitmap, EXT2FS_TEST_ERROR, arg);
return 0;
}
return bitmap->bitmap_ops->test_bmap(bitmap, arg);
}
errcode_t ext2fs_copy_generic_bmap(ext2fs_generic_bitmap src,
ext2fs_generic_bitmap *dest)
{
char *descr, *new_descr;
ext2fs_generic_bitmap new_bmap;
errcode_t retval;
if (!src)
return EINVAL;
if (EXT2FS_IS_32_BITMAP(src))
return ext2fs_copy_generic_bitmap(src, dest);
if (!EXT2FS_IS_64_BITMAP(src))
return EINVAL;
/* Allocate a new bitmap struct */
retval = ext2fs_get_memzero(sizeof(struct ext2fs_struct_generic_bitmap),
&new_bmap);
if (retval)
return retval;
#ifdef BMAP_STATS_OPS
src->stats.copy_count++;
#endif
#ifdef BMAP_STATS
if (gettimeofday(&new_bmap->stats.created,
(struct timezone *) NULL) == -1) {
perror("gettimeofday");
return 1;
}
new_bmap->stats.type = src->stats.type;
#endif
/* Copy all the high-level parts over */
new_bmap->magic = src->magic;
new_bmap->fs = src->fs;
new_bmap->start = src->start;
new_bmap->end = src->end;
new_bmap->real_end = src->real_end;
new_bmap->bitmap_ops = src->bitmap_ops;
new_bmap->base_error_code = src->base_error_code;
new_bmap->cluster_bits = src->cluster_bits;
descr = src->description;
if (descr) {
retval = ext2fs_get_mem(strlen(descr)+10, &new_descr);
if (retval) {
ext2fs_free_mem(&new_bmap);
return retval;
}
sprintf(new_descr, "copy of %s", descr);
new_bmap->description = new_descr;
}
retval = src->bitmap_ops->copy_bmap(src, new_bmap);
if (retval) {
ext2fs_free_mem(&new_bmap->description);
ext2fs_free_mem(&new_bmap);
return retval;
}
*dest = new_bmap;
return 0;
}