libext2fs: precompute FS UUID checksum seed

[tools/e2fsprogs.git] / lib / ext2fs / bb_inode.c

diff --git a/lib/ext2fs/bb_inode.c b/lib/ext2fs/bb_inode.c
index 97a5608..268eecf 100644 (file)
--- a/lib/ext2fs/bb_inode.c
+++ b/lib/ext2fs/bb_inode.c
@@ -1,18 +1,19 @@
 /*
  * bb_inode.c --- routines to update the bad block inode.
- * 
+ *
  * WARNING: This routine modifies a lot of state in the filesystem; if
  * this routine returns an error, the bad block inode may be in an
  * inconsistent state.
- * 
+ *
  * Copyright (C) 1994, 1995 Theodore Ts'o.
- * 
+ *
  * %Begin-Header%
- * This file may be redistributed under the terms of the GNU Public
- * License.
+ * This file may be redistributed under the terms of the GNU Library
+ * General Public License, version 2.
  * %End-Header%
  */
 
+#include "config.h"
 #include <stdio.h>
 #include <string.h>
 #if HAVE_UNISTD_H
@@ -49,7 +50,7 @@ static int clear_bad_block_proc(ext2_filsys fs, blk_t *block_nr,
                                e2_blkcnt_t blockcnt,
                                blk_t ref_block, int ref_offset,
                                void *priv_data);
-       
+
 /*
  * Given a bad blocks bitmap, update the bad blocks inode to reflect
  * the map.
@@ -59,16 +60,15 @@ errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list)
        errcode_t                       retval;
        struct set_badblock_record      rec;
        struct ext2_inode               inode;
-       
+
        EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
        if (!fs->block_map)
                return EXT2_ET_NO_BLOCK_BITMAP;
-       
-       rec.bad_block_count = 0;
-       rec.ind_blocks_size = rec.ind_blocks_ptr = 0;
+
+       memset(&rec, 0, sizeof(rec));
        rec.max_ind_blocks = 10;
-       retval = ext2fs_get_mem(rec.max_ind_blocks * sizeof(blk_t),
+       retval = ext2fs_get_array(rec.max_ind_blocks, sizeof(blk_t),
                                &rec.ind_blocks);
        if (retval)
                return retval;
@@ -78,9 +78,9 @@ errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list)
                goto cleanup;
        memset(rec.block_buf, 0, fs->blocksize);
        rec.err = 0;
-       
+
        /*
-        * First clear the old bad blocks (while saving the indirect blocks) 
+        * First clear the old bad blocks (while saving the indirect blocks)
         */
        retval = ext2fs_block_iterate2(fs, EXT2_BAD_INO,
                                       BLOCK_FLAG_DEPTH_TRAVERSE, 0,
@@ -91,7 +91,7 @@ errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list)
                retval = rec.err;
                goto cleanup;
        }
-       
+
        /*
         * Now set the bad blocks!
         *
@@ -108,32 +108,32 @@ errcode_t ext2fs_update_bb_inode(ext2_filsys fs, ext2_badblocks_list bb_list)
                                               BLOCK_FLAG_APPEND, 0,
                                               set_bad_block_proc, &rec);
                ext2fs_badblocks_list_iterate_end(rec.bb_iter);
-               if (retval) 
+               if (retval)
                        goto cleanup;
                if (rec.err) {
                        retval = rec.err;
                        goto cleanup;
                }
        }
-       
+
        /*
         * Update the bad block inode's mod time and block count
-        * field.  
+        * field.
         */
        retval = ext2fs_read_inode(fs, EXT2_BAD_INO, &inode);
        if (retval)
                goto cleanup;
-       
+
        inode.i_atime = inode.i_mtime = fs->now ? fs->now : time(0);
        if (!inode.i_ctime)
                inode.i_ctime = fs->now ? fs->now : time(0);
-       inode.i_blocks = rec.bad_block_count * (fs->blocksize / 512);
+       ext2fs_iblk_set(fs, &inode, rec.bad_block_count);
        inode.i_size = rec.bad_block_count * fs->blocksize;
 
        retval = ext2fs_write_inode(fs, EXT2_BAD_INO, &inode);
        if (retval)
                goto cleanup;
-       
+
 cleanup:
        ext2fs_free_mem(&rec.ind_blocks);
        ext2fs_free_mem(&rec.block_buf);
@@ -166,7 +166,7 @@ static int clear_bad_block_proc(ext2_filsys fs, blk_t *block_nr,
        /*
         * If the block number is outrageous, clear it and ignore it.
         */
-       if (*block_nr >= fs->super->s_blocks_count ||
+       if (*block_nr >= ext2fs_blocks_count(fs->super) ||
            *block_nr < fs->super->s_first_data_block) {
                *block_nr = 0;
                return BLOCK_CHANGED;
@@ -176,7 +176,7 @@ static int clear_bad_block_proc(ext2_filsys fs, blk_t *block_nr,
                if (rec->ind_blocks_size >= rec->max_ind_blocks) {
                        old_size = rec->max_ind_blocks * sizeof(blk_t);
                        rec->max_ind_blocks += 10;
-                       retval = ext2fs_resize_mem(old_size, 
+                       retval = ext2fs_resize_mem(old_size,
                                   rec->max_ind_blocks * sizeof(blk_t),
                                   &rec->ind_blocks);
                        if (retval) {
@@ -191,13 +191,13 @@ static int clear_bad_block_proc(ext2_filsys fs, blk_t *block_nr,
        /*
         * Mark the block as unused, and update accounting information
         */
-       ext2fs_block_alloc_stats(fs, *block_nr, -1);
-       
+       ext2fs_block_alloc_stats2(fs, *block_nr, -1);
+
        *block_nr = 0;
        return BLOCK_CHANGED;
 }
 
-       
+
 /*
  * Helper function for update_bb_inode()
  *
@@ -235,7 +235,7 @@ static int set_bad_block_proc(ext2_filsys fs, blk_t *block_nr,
        retry:
                if (rec->ind_blocks_ptr < rec->ind_blocks_size) {
                        blk = rec->ind_blocks[rec->ind_blocks_ptr++];
-                       if (ext2fs_test_block_bitmap(fs->block_map, blk))
+                       if (ext2fs_test_block_bitmap2(fs->block_map, blk))
                                goto retry;
                } else {
                        retval = ext2fs_new_block(fs, 0, 0, &blk);
@@ -244,18 +244,18 @@ static int set_bad_block_proc(ext2_filsys fs, blk_t *block_nr,
                                return BLOCK_ABORT;
                        }
                }
-               retval = io_channel_write_blk(fs->io, blk, 1, rec->block_buf);
+               retval = io_channel_write_blk64(fs->io, blk, 1, rec->block_buf);
                if (retval) {
                        rec->err = retval;
                        return BLOCK_ABORT;
                }
        }
-       
+
        /*
         * Update block counts
         */
-       ext2fs_block_alloc_stats(fs, blk, +1);
-       
+       ext2fs_block_alloc_stats2(fs, blk, +1);
+
        *block_nr = blk;
        return BLOCK_CHANGED;
 }