* bitmaps.c --- routines to read, write, and manipulate the inode and
* block bitmaps.
*
- * Copyright (C) 1993 Theodore Ts'o. This file may be redistributed
- * under the terms of the GNU Public License.
+ * 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 <stdio.h>
#include <string.h>
+#if HAVE_UNISTD_H
#include <unistd.h>
-#include <stdlib.h>
+#endif
#include <fcntl.h>
#include <time.h>
+#if HAVE_SYS_STAT_H
#include <sys/stat.h>
+#endif
+#if HAVE_SYS_TYPES_H
#include <sys/types.h>
+#endif
-#include <linux/fs.h>
-#include <linux/ext2_fs.h>
-
+#include "ext2_fs.h"
#include "ext2fs.h"
-errcode_t ext2fs_write_inode_bitmap(ext2_filsys fs)
+void ext2fs_free_inode_bitmap(ext2fs_inode_bitmap bitmap)
{
- int i;
- int nbytes;
- errcode_t retval;
- char * inode_bitmap = fs->inode_map;
- char * bitmap_block = NULL;
-
- if (!(fs->flags & EXT2_FLAG_RW))
- return EXT2_ET_RO_FILSYS;
- if (!inode_bitmap)
- return 0;
- nbytes = EXT2_INODES_PER_GROUP(fs->super) / 8;
- bitmap_block = malloc(fs->blocksize);
- if (!bitmap_block)
- return ENOMEM;
- memset(bitmap_block, 0xff, fs->blocksize);
- for (i = 0; i < fs->group_desc_count; i++) {
- memcpy(bitmap_block, inode_bitmap, nbytes);
- retval = io_channel_write_blk(fs->io,
- fs->group_desc[i].bg_inode_bitmap, 1,
- bitmap_block);
- if (retval)
- return EXT2_ET_INODE_BITMAP_WRITE;
- inode_bitmap += nbytes;
- }
- fs->flags |= EXT2_FLAG_CHANGED;
- fs->flags &= ~EXT2_FLAG_IB_DIRTY;
- free(bitmap_block);
- return 0;
+ ext2fs_free_generic_bitmap(bitmap);
}
-errcode_t ext2fs_write_block_bitmap (ext2_filsys fs)
+void ext2fs_free_block_bitmap(ext2fs_block_bitmap bitmap)
{
- int i;
- int j;
- int nbytes;
- int nbits;
- errcode_t retval;
- char * block_bitmap = fs->block_map;
- char * bitmap_block = NULL;
+ ext2fs_free_generic_bitmap(bitmap);
+}
- if (!(fs->flags & EXT2_FLAG_RW))
- return EXT2_ET_RO_FILSYS;
- if (!block_bitmap)
- return 0;
- nbytes = EXT2_BLOCKS_PER_GROUP(fs->super) / 8;
- bitmap_block = malloc(fs->blocksize);
- if (!bitmap_block)
- return ENOMEM;
- memset(bitmap_block, 0xff, fs->blocksize);
- for (i = 0; i < fs->group_desc_count; i++) {
- memcpy(bitmap_block, block_bitmap, nbytes);
- if (i == fs->group_desc_count - 1) {
- /* Force bitmap padding for the last group */
- nbits = (fs->super->s_blocks_count
- - fs->super->s_first_data_block)
- % EXT2_BLOCKS_PER_GROUP(fs->super);
- for (j = nbits; j < fs->blocksize * 8; j++)
- set_bit(j, bitmap_block);
- }
- retval = io_channel_write_blk(fs->io,
- fs->group_desc[i].bg_block_bitmap, 1,
- bitmap_block);
- if (retval)
- return EXT2_ET_BLOCK_BITMAP_WRITE;
- block_bitmap += nbytes;
- }
- fs->flags |= EXT2_FLAG_CHANGED;
- fs->flags &= ~EXT2_FLAG_BB_DIRTY;
- free(bitmap_block);
- return 0;
+errcode_t ext2fs_copy_bitmap(ext2fs_generic_bitmap src,
+ ext2fs_generic_bitmap *dest)
+{
+ return (ext2fs_copy_generic_bitmap(src, dest));
}
-errcode_t ext2fs_read_inode_bitmap (ext2_filsys fs)
+void ext2fs_set_bitmap_padding(ext2fs_generic_bitmap map)
{
- int i;
- char * inode_bitmap;
- char *buf = 0;
- errcode_t retval;
- int nbytes;
+ ext2fs_set_generic_bitmap_padding(map);
+}
- fs->write_bitmaps = ext2fs_write_bitmaps;
+errcode_t ext2fs_allocate_inode_bitmap(ext2_filsys fs,
+ const char *descr,
+ ext2fs_inode_bitmap *ret)
+{
+ __u32 start, end, real_end;
- if (fs->inode_map)
- free(fs->inode_map);
- nbytes = EXT2_INODES_PER_GROUP(fs->super) / 8;
- fs->flags &= ~EXT2_FLAG_IB_DIRTY;
- fs->inode_map = malloc((nbytes * fs->group_desc_count) + 1);
- if (!fs->inode_map)
- return ENOMEM;
- inode_bitmap = fs->inode_map;
+ EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
- buf = malloc(fs->blocksize);
- if (!buf)
- return ENOMEM;
+ fs->write_bitmaps = ext2fs_write_bitmaps;
- for (i = 0; i < fs->group_desc_count; i++) {
- retval = io_channel_read_blk(fs->io,
- fs->group_desc[i].bg_inode_bitmap, 1,
- buf);
- if (retval) {
- retval = EXT2_ET_INODE_BITMAP_READ;
- goto cleanup;
- }
- memcpy(inode_bitmap, buf, nbytes);
- inode_bitmap += nbytes;
- }
- free(buf);
- return 0;
-
-cleanup:
- free(fs->inode_map);
- fs->inode_map = 0;
- if (buf)
- free(buf);
- return retval;
+ start = 1;
+ end = fs->super->s_inodes_count;
+ real_end = (EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count);
+
+ return (ext2fs_make_generic_bitmap(EXT2_ET_MAGIC_INODE_BITMAP, fs,
+ start, end, real_end,
+ descr, 0, ret));
}
-errcode_t ext2fs_read_block_bitmap(ext2_filsys fs)
+errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs,
+ const char *descr,
+ ext2fs_block_bitmap *ret)
{
- int i;
- char * block_bitmap;
- char *buf = 0;
- errcode_t retval;
- int nbytes;
-
- fs->write_bitmaps = ext2fs_write_bitmaps;
+ __u32 start, end, real_end;
- if (fs->block_map)
- free(fs->block_map);
- nbytes = EXT2_BLOCKS_PER_GROUP(fs->super) / 8;
- fs->flags &= ~EXT2_FLAG_BB_DIRTY;
- fs->block_map = malloc((nbytes * fs->group_desc_count) + 1);
- if (!fs->block_map)
- return ENOMEM;
- block_bitmap = fs->block_map;
+ EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
- buf = malloc(fs->blocksize);
- if (!buf)
- return ENOMEM;
+ fs->write_bitmaps = ext2fs_write_bitmaps;
- for (i = 0; i < fs->group_desc_count; i++) {
- retval = io_channel_read_blk(fs->io,
- fs->group_desc[i].bg_block_bitmap, 1,
- buf);
- if (retval) {
- retval = EXT2_ET_BLOCK_BITMAP_READ;
- goto cleanup;
- }
- memcpy(block_bitmap, buf, nbytes);
- block_bitmap += nbytes;
- }
- free(buf);
- return 0;
+ start = fs->super->s_first_data_block;
+ end = fs->super->s_blocks_count-1;
+ real_end = (EXT2_BLOCKS_PER_GROUP(fs->super)
+ * fs->group_desc_count)-1 + start;
-cleanup:
- free(fs->block_map);
- fs->block_map = 0;
- if (buf)
- free(buf);
- return retval;
+ return (ext2fs_make_generic_bitmap(EXT2_ET_MAGIC_BLOCK_BITMAP, fs,
+ start, end, real_end,
+ descr, 0, ret));
}
-errcode_t ext2fs_allocate_inode_bitmap(ext2_filsys fs, char **ret)
+errcode_t ext2fs_fudge_inode_bitmap_end(ext2fs_inode_bitmap bitmap,
+ ext2_ino_t end, ext2_ino_t *oend)
{
- char *map;
- int size;
-
- fs->write_bitmaps = ext2fs_write_bitmaps;
- size = (fs->super->s_inodes_count / 8) + 1;
- map = malloc(size);
- if (!map)
- return ENOMEM;
- memset(map, 0, size);
- *ret = map;
- return 0;
+ return (ext2fs_fudge_generic_bitmap_end(bitmap,
+ EXT2_ET_MAGIC_INODE_BITMAP,
+ EXT2_ET_FUDGE_INODE_BITMAP_END,
+ end, oend));
}
-errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs, char **ret)
+errcode_t ext2fs_fudge_block_bitmap_end(ext2fs_block_bitmap bitmap,
+ blk_t end, blk_t *oend)
{
- char *map;
- int size;
-
- fs->write_bitmaps = ext2fs_write_bitmaps;
-
- size = (fs->super->s_blocks_count / 8) + 1;
- map = malloc(size);
- if (!map)
- return ENOMEM;
- memset(map, 0, size);
- *ret = map;
- return 0;
+ return (ext2fs_fudge_generic_bitmap_end(bitmap,
+ EXT2_ET_MAGIC_BLOCK_BITMAP,
+ EXT2_ET_FUDGE_BLOCK_BITMAP_END,
+ end, oend));
}
-errcode_t ext2fs_read_bitmaps(ext2_filsys fs)
+void ext2fs_clear_inode_bitmap(ext2fs_inode_bitmap bitmap)
{
- errcode_t retval;
+ ext2fs_clear_generic_bitmap(bitmap);
+}
- fs->write_bitmaps = ext2fs_write_bitmaps;
+void ext2fs_clear_block_bitmap(ext2fs_block_bitmap bitmap)
+{
+ ext2fs_clear_generic_bitmap(bitmap);
+}
- if (!fs->inode_map) {
- retval = ext2fs_read_inode_bitmap(fs);
- if (retval)
- return retval;
- }
- if (!fs->block_map) {
- retval = ext2fs_read_block_bitmap(fs);
- if (retval)
- return retval;
- }
- return 0;
+errcode_t ext2fs_resize_inode_bitmap(__u32 new_end, __u32 new_real_end,
+ ext2fs_inode_bitmap bmap)
+{
+ return (ext2fs_resize_generic_bitmap(EXT2_ET_MAGIC_INODE_BITMAP,
+ new_end, new_real_end, bmap));
}
-errcode_t ext2fs_write_bitmaps(ext2_filsys fs)
+errcode_t ext2fs_resize_block_bitmap(__u32 new_end, __u32 new_real_end,
+ ext2fs_block_bitmap bmap)
{
- errcode_t retval;
+ return (ext2fs_resize_generic_bitmap(EXT2_ET_MAGIC_BLOCK_BITMAP,
+ new_end, new_real_end, bmap));
+}
- if (fs->block_map && ext2fs_test_bb_dirty(fs)) {
- retval = ext2fs_write_block_bitmap(fs);
- if (retval)
- return retval;
- }
- if (fs->inode_map && ext2fs_test_ib_dirty(fs)) {
- retval = ext2fs_write_inode_bitmap(fs);
- if (retval)
- return retval;
- }
- return 0;
-}
+errcode_t ext2fs_compare_block_bitmap(ext2fs_block_bitmap bm1,
+ ext2fs_block_bitmap bm2)
+{
+ return (ext2fs_compare_generic_bitmap(EXT2_ET_MAGIC_BLOCK_BITMAP,
+ EXT2_ET_NEQ_BLOCK_BITMAP,
+ bm1, bm2));
+}
+errcode_t ext2fs_compare_inode_bitmap(ext2fs_inode_bitmap bm1,
+ ext2fs_inode_bitmap bm2)
+{
+ return (ext2fs_compare_generic_bitmap(EXT2_ET_MAGIC_INODE_BITMAP,
+ EXT2_ET_NEQ_INODE_BITMAP,
+ bm1, bm2));
+}
+errcode_t ext2fs_set_inode_bitmap_range(ext2fs_inode_bitmap bmap,
+ ext2_ino_t start, unsigned int num,
+ void *in)
+{
+ return (ext2fs_set_generic_bitmap_range(bmap,
+ EXT2_ET_MAGIC_INODE_BITMAP,
+ start, num, in));
+}
+errcode_t ext2fs_get_inode_bitmap_range(ext2fs_inode_bitmap bmap,
+ ext2_ino_t start, unsigned int num,
+ void *out)
+{
+ return (ext2fs_get_generic_bitmap_range(bmap,
+ EXT2_ET_MAGIC_INODE_BITMAP,
+ start, num, out));
+}
+errcode_t ext2fs_set_block_bitmap_range(ext2fs_block_bitmap bmap,
+ blk_t start, unsigned int num,
+ void *in)
+{
+ return (ext2fs_set_generic_bitmap_range(bmap,
+ EXT2_ET_MAGIC_BLOCK_BITMAP,
+ start, num, in));
+}
+errcode_t ext2fs_get_block_bitmap_range(ext2fs_block_bitmap bmap,
+ blk_t start, unsigned int num,
+ void *out)
+{
+ return (ext2fs_get_generic_bitmap_range(bmap,
+ EXT2_ET_MAGIC_BLOCK_BITMAP,
+ start, num, out));
+}
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff