Fix gcc -Wall warnings in libext2fs

Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

diff --git a/lib/ext2fs/alloc_tables.c b/lib/ext2fs/alloc_tables.c
index d87585b..b3da037 100644 (file)
--- a/lib/ext2fs/alloc_tables.c
+++ b/lib/ext2fs/alloc_tables.c
@@ -43,8 +43,8 @@ static blk_t flexbg_offset(ext2_filsys fs, dgrp_t group, blk_t start_blk,
        flexbg_size = 1 << fs->super->s_log_groups_per_flex;
        flexbg = group / flexbg_size;
 
-       if (size > fs->super->s_blocks_per_group / 8)
-               size = fs->super->s_blocks_per_group / 8;
+       if (size > (int) (fs->super->s_blocks_per_group / 8))
+               size = (int) fs->super->s_blocks_per_group / 8;
 
        /*
         * Dont do a long search if the previous block
@@ -83,8 +83,8 @@ errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group,
 {
        errcode_t       retval;
        blk_t           group_blk, start_blk, last_blk, new_blk, blk;
-       dgrp_t          last_grp;
-       int             j, rem_grps, flexbg_size = 0;
+       dgrp_t          last_grp = 0;
+       int             j, rem_grps = 0, flexbg_size = 0;
 
        group_blk = ext2fs_group_first_block(fs, group);
        last_blk = ext2fs_group_last_block(fs, group);

diff --git a/lib/ext2fs/csum.c b/lib/ext2fs/csum.c
index 1091d73..ce1508e 100644 (file)
--- a/lib/ext2fs/csum.c
+++ b/lib/ext2fs/csum.c
@@ -96,7 +96,7 @@ errcode_t ext2fs_set_gdt_csum(ext2_filsys fs)
 {
        struct ext2_super_block *sb = fs->super;
        struct ext2_group_desc *bg = fs->group_desc;
-       int blks, dirty = 0;
+       int dirty = 0;
        dgrp_t i;
 
        if (!fs->inode_map)

diff --git a/lib/ext2fs/extent.c b/lib/ext2fs/extent.c
index d4c84d0..78c605f 100644 (file)
--- a/lib/ext2fs/extent.c
+++ b/lib/ext2fs/extent.c
@@ -762,7 +762,7 @@ errcode_t ext2fs_extent_replace(ext2_extent_handle_t handle,
  *
  * handle will be left pointing at original record.
  */
-static errcode_t extent_node_split(ext2_extent_handle_t handle, int flags)
+static errcode_t extent_node_split(ext2_extent_handle_t handle)
 {
        errcode_t                       retval = 0;
        blk_t                           new_node_pblk;
@@ -773,9 +773,7 @@ static errcode_t extent_node_split(ext2_extent_handle_t handle, int flags)
        char                            *block_buf = NULL;
        struct ext2fs_extent            extent;
        struct extent_path              *path, *newpath = 0;
-       struct ext3_extent              *ex;
        struct ext3_extent_header       *eh, *neweh;
-       char                            *cp;
        int                             tocopy;
        int                             new_root = 0;
        struct ext2_extent_info         info;
@@ -816,7 +814,7 @@ static errcode_t extent_node_split(ext2_extent_handle_t handle, int flags)
                        goto done;
                goal_blk = extent.e_pblk;
 
-               retval = extent_node_split(handle, 0);
+               retval = extent_node_split(handle);
                if (retval)
                        goto done;
 
@@ -1004,8 +1002,9 @@ errcode_t ext2fs_extent_insert(ext2_extent_handle_t handle, int flags,
                if (flags & EXT2_EXTENT_INSERT_NOSPLIT) {
                        return EXT2_ET_CANT_INSERT_EXTENT;
                } else {
-                       dbg_printf("node full - splitting\n");
-                       retval = extent_node_split(handle, 0);
+                       dbg_printf("node full (level %d) - splitting\n",
+                                  handle->level);
+                       retval = extent_node_split(handle);
                        if (retval)
                                goto errout;
                        path = handle->path + handle->level;
@@ -1113,7 +1112,7 @@ errcode_t ext2fs_extent_set_bmap(ext2_extent_handle_t handle,
        /* special case if the extent tree is completely empty */
        if ((handle->max_depth == 0) && (path->entries == 0)) {
                retval = ext2fs_extent_insert(handle, 0, &newextent);
-               goto done;
+               return retval;
        }
 
        /* save our original location in the extent tree */
@@ -1135,7 +1134,8 @@ errcode_t ext2fs_extent_set_bmap(ext2_extent_handle_t handle,
                        retval = 0;
                        mapped = 0;
                        if (!physical) {
-                               dbg_printf("block already unmapped\n");
+                               dbg_printf("block %llu already unmapped\n",
+                                       logical);
                                goto done;
                        }
                } else
@@ -1155,16 +1155,16 @@ errcode_t ext2fs_extent_set_bmap(ext2_extent_handle_t handle,
        /* check if already pointing to the requested physical */
        if (mapped && (new_uninit == extent_uninit) &&
            (extent.e_pblk + (logical - extent.e_lblk) == physical)) {
-               dbg_printf("physical block unchanged\n");
+               dbg_printf("physical block (at %llu) unchanged\n", logical);
                goto done;
        }
 
        if (!mapped) {
-               dbg_printf("mapping unmapped logical block\n");
+               dbg_printf("mapping unmapped logical block %llu\n", logical);
                if ((logical == extent.e_lblk + extent.e_len) &&
                    (physical == extent.e_pblk + extent.e_len) &&
                    (new_uninit == extent_uninit) &&
-                   (extent.e_len < max_len-1)) {
+                   ((int) extent.e_len < max_len-1)) {
                        extent.e_len++;
                        retval = ext2fs_extent_replace(handle, 0, &extent);
                } else
@@ -1266,7 +1266,7 @@ errcode_t ext2fs_extent_delete(ext2_extent_handle_t handle, int flags)
        struct extent_path              *path;
        char                            *cp;
        struct ext3_extent_header       *eh;
-       errcode_t                       retval;
+       errcode_t                       retval = 0;
 
        EXT2_CHECK_MAGIC(handle, EXT2_ET_MAGIC_EXTENT_HANDLE);
 
@@ -1572,13 +1572,12 @@ void do_split_node(int argc, char *argv[])
        errcode_t       retval;
        struct ext2fs_extent extent;
        int err;
-       int flags = 0;
 
        if (common_extent_args_process(argc, argv, 1, 1, "split_node",
                                       "", CHECK_FS_RW | CHECK_FS_BITMAPS))
                return;
 
-       retval = extent_node_split(current_handle, flags);
+       retval = extent_node_split(current_handle);
        if (retval) {
                com_err(argv[0], retval, 0);
                return;

diff --git a/lib/ext2fs/undo_io.c b/lib/ext2fs/undo_io.c
index e1e6458..827c038 100644 (file)
--- a/lib/ext2fs/undo_io.c
+++ b/lib/ext2fs/undo_io.c
@@ -42,6 +42,12 @@
 #include "ext2_fs.h"
 #include "ext2fs.h"
 
+#ifdef __GNUC__
+#define ATTR(x) __attribute__(x)
+#else
+#define ATTR(x)
+#endif
+
 /*
  * For checking structure magic numbers...
  */
@@ -95,6 +101,10 @@ static io_manager undo_io_backing_manager ;
 static char *tdb_file;
 static int actual_size;
 
+static unsigned char mtime_key[] = "filesystem MTIME";
+static unsigned char blksize_key[] = "filesystem BLKSIZE";
+static unsigned char uuid_key[] = "filesystem UUID";
+
 errcode_t set_undo_io_backing_manager(io_manager manager)
 {
        /*
@@ -135,8 +145,8 @@ static errcode_t write_file_system_identity(io_channel undo_channel,
                goto err_out;
 
        /* Write to tdb file in the file system byte order */
-       tdb_key.dptr = "filesystem MTIME";
-       tdb_key.dsize = sizeof("filesystem MTIME");
+       tdb_key.dptr = mtime_key;
+       tdb_key.dsize = sizeof(mtime_key);
        tdb_data.dptr = (unsigned char *) &(super.s_mtime);
        tdb_data.dsize = sizeof(super.s_mtime);
 
@@ -146,8 +156,8 @@ static errcode_t write_file_system_identity(io_channel undo_channel,
                goto err_out;
        }
 
-       tdb_key.dptr = "filesystem UUID";
-       tdb_key.dsize = sizeof("filesystem UUID");
+       tdb_key.dptr = uuid_key;
+       tdb_key.dsize = sizeof(uuid_key);
        tdb_data.dptr = (unsigned char *)&(super.s_uuid);
        tdb_data.dsize = sizeof(super.s_uuid);
 
@@ -166,8 +176,8 @@ static errcode_t write_block_size(TDB_CONTEXT *tdb, int block_size)
        errcode_t retval;
        TDB_DATA tdb_key, tdb_data;
 
-       tdb_key.dptr = "filesystem BLKSIZE";
-       tdb_key.dsize = sizeof("filesystem BLKSIZE");
+       tdb_key.dptr = blksize_key;
+       tdb_key.dsize = sizeof(blksize_key);
        tdb_data.dptr = (unsigned char *)&(block_size);
        tdb_data.dsize = sizeof(block_size);
 
@@ -183,13 +193,13 @@ static errcode_t undo_write_tdb(io_channel channel,
                                unsigned long block, int count)
 
 {
-       int size, i, sz;
+       int size, sz;
        unsigned long block_num, backing_blk_num;
        errcode_t retval = 0;
        ext2_loff_t offset;
        struct undo_private_data *data;
        TDB_DATA tdb_key, tdb_data;
-       char *read_ptr;
+       unsigned char *read_ptr;
        unsigned long end_block;
 
        data = (struct undo_private_data *) channel->private_data;
@@ -312,9 +322,13 @@ static errcode_t undo_write_tdb(io_channel channel,
        return retval;
 }
 
-static errcode_t undo_io_read_error(io_channel channel,
-                       unsigned long block, int count, void *data,
-                       size_t size, int actual, errcode_t error)
+static errcode_t undo_io_read_error(io_channel channel ATTR((unused)),
+                                   unsigned long block ATTR((unused)),
+                                   int count ATTR((unused)),
+                                   void *data ATTR((unused)),
+                                   size_t size ATTR((unused)),
+                                   int actual,
+                                   errcode_t error ATTR((unused)))
 {
        actual_size = actual;
        return error;
@@ -330,8 +344,6 @@ static errcode_t undo_open(const char *name, int flags, io_channel *channel)
        io_channel      io = NULL;
        struct undo_private_data *data = NULL;
        errcode_t       retval;
-       int             open_flags;
-       struct stat     st;
 
        if (name == 0)
                return EXT2_ET_BAD_DEVICE_NAME;
@@ -425,7 +437,7 @@ static errcode_t undo_close(io_channel channel)
 static errcode_t undo_set_blksize(io_channel channel, int blksize)
 {
        struct undo_private_data *data;
-       errcode_t               retval;
+       errcode_t               retval = 0;
 
        EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
        data = (struct undo_private_data *) channel->private_data;
@@ -446,7 +458,7 @@ static errcode_t undo_set_blksize(io_channel channel, int blksize)
 static errcode_t undo_read_blk(io_channel channel, unsigned long block,
                               int count, void *buf)
 {
-       errcode_t       retval;
+       errcode_t       retval = 0;
        struct undo_private_data *data;
 
        EXT2_CHECK_MAGIC(channel, EXT2_ET_MAGIC_IO_CHANNEL);
@@ -485,7 +497,6 @@ static errcode_t undo_write_byte(io_channel channel, unsigned long offset,
 {
        struct undo_private_data *data;
        errcode_t       retval = 0;
-       ssize_t         actual;
        ext2_loff_t     location;
        unsigned long blk_num, count;;