[PATCH] befs: endianness annotations

split the data structures that exist in host- and disk-endian variants,
annotate the fields of disk-endian ones, propagate changes.

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/fs/befs/befs.h b/fs/befs/befs.h
index c400bb6a6b71fa9bef13115c73443fe9bdfd5d7c..d9a40abda6b700e6fd0c6fcf5cd65b0f97cfb193 100644 (file)
--- a/fs/befs/befs.h
+++ b/fs/befs/befs.h
@@ -94,7 +94,7 @@ void befs_debug(const struct super_block *sb, const char *fmt, ...);
 
 void befs_dump_super_block(const struct super_block *sb, befs_super_block *);
 void befs_dump_inode(const struct super_block *sb, befs_inode *);
-void befs_dump_index_entry(const struct super_block *sb, befs_btree_super *);
+void befs_dump_index_entry(const struct super_block *sb, befs_disk_btree_super *);
 void befs_dump_index_node(const struct super_block *sb, befs_btree_nodehead *);
 /****************************/
 
@@ -136,7 +136,7 @@ blockno2iaddr(struct super_block *sb, befs_blocknr_t blockno)
 static inline unsigned int
 befs_iaddrs_per_block(struct super_block *sb)
 {
-       return BEFS_SB(sb)->block_size / sizeof (befs_inode_addr);
+       return BEFS_SB(sb)->block_size / sizeof (befs_disk_inode_addr);
 }
 
 static inline int

diff --git a/fs/befs/befs_fs_types.h b/fs/befs/befs_fs_types.h
index 128066b1c4b057dd27d6dc48bac6dc952dd4f6fd..e2595c2c403a9bfd01dffc1ac54594356e09e811 100644 (file)
--- a/fs/befs/befs_fs_types.h
+++ b/fs/befs/befs_fs_types.h
@@ -84,15 +84,22 @@ typedef u32 __bitwise fs32;
 typedef u16 __bitwise fs16;
 
 typedef u64 befs_off_t;
-typedef u64 befs_time_t;
+typedef fs64 befs_time_t;
 
 /* Block runs */
+typedef struct {
+       fs32 allocation_group;
+       fs16 start;
+       fs16 len;
+} PACKED befs_disk_block_run;
+
 typedef struct {
        u32 allocation_group;
        u16 start;
        u16 len;
 } PACKED befs_block_run;
 
+typedef befs_disk_block_run befs_disk_inode_addr;
 typedef befs_block_run befs_inode_addr;
 
 /*
@@ -100,31 +107,31 @@ typedef befs_block_run befs_inode_addr;
  */
 typedef struct {
        char name[B_OS_NAME_LENGTH];
-       u32 magic1;
-       u32 fs_byte_order;
+       fs32 magic1;
+       fs32 fs_byte_order;
 
-       u32 block_size;
-       u32 block_shift;
+       fs32 block_size;
+       fs32 block_shift;
 
-       befs_off_t num_blocks;
-       befs_off_t used_blocks;
+       fs64 num_blocks;
+       fs64 used_blocks;
 
-       u32 inode_size;
+       fs32 inode_size;
 
-       u32 magic2;
-       u32 blocks_per_ag;
-       u32 ag_shift;
-       u32 num_ags;
+       fs32 magic2;
+       fs32 blocks_per_ag;
+       fs32 ag_shift;
+       fs32 num_ags;
 
-       u32 flags;
+       fs32 flags;
 
-       befs_block_run log_blocks;
-       befs_off_t log_start;
-       befs_off_t log_end;
+       befs_disk_block_run log_blocks;
+       fs64 log_start;
+       fs64 log_end;
 
-       u32 magic3;
-       befs_inode_addr root_dir;
-       befs_inode_addr indices;
+       fs32 magic3;
+       befs_disk_inode_addr root_dir;
+       befs_disk_inode_addr indices;
 
 } PACKED befs_super_block;
 
@@ -132,6 +139,16 @@ typedef struct {
  * Note: the indirect and dbl_indir block_runs may
  * be longer than one block!
  */
+typedef struct {
+       befs_disk_block_run direct[BEFS_NUM_DIRECT_BLOCKS];
+       fs64 max_direct_range;
+       befs_disk_block_run indirect;
+       fs64 max_indirect_range;
+       befs_disk_block_run double_indirect;
+       fs64 max_double_indirect_range;
+       fs64 size;
+} PACKED befs_disk_data_stream;
+
 typedef struct {
        befs_block_run direct[BEFS_NUM_DIRECT_BLOCKS];
        befs_off_t max_direct_range;
@@ -144,35 +161,35 @@ typedef struct {
 
 /* Attribute */
 typedef struct {
-       u32 type;
-       u16 name_size;
-       u16 data_size;
+       fs32 type;
+       fs16 name_size;
+       fs16 data_size;
        char name[1];
 } PACKED befs_small_data;
 
 /* Inode structure */
 typedef struct {
-       u32 magic1;
-       befs_inode_addr inode_num;
-       u32 uid;
-       u32 gid;
-       u32 mode;
-       u32 flags;
+       fs32 magic1;
+       befs_disk_inode_addr inode_num;
+       fs32 uid;
+       fs32 gid;
+       fs32 mode;
+       fs32 flags;
        befs_time_t create_time;
        befs_time_t last_modified_time;
-       befs_inode_addr parent;
-       befs_inode_addr attributes;
-       u32 type;
+       befs_disk_inode_addr parent;
+       befs_disk_inode_addr attributes;
+       fs32 type;
 
-       u32 inode_size;
-       u32 etc;                /* not use */
+       fs32 inode_size;
+       fs32 etc;               /* not use */
 
        union {
-               befs_data_stream datastream;
+               befs_disk_data_stream datastream;
                char symlink[BEFS_SYMLINK_LEN];
        } data;
 
-       u32 pad[4];             /* not use */
+       fs32 pad[4];            /* not use */
        befs_small_data small_data[1];
 } PACKED befs_inode;
 
@@ -192,6 +209,16 @@ enum btree_types {
        BTREE_DOUBLE_TYPE = 6
 };
 
+typedef struct {
+       fs32 magic;
+       fs32 node_size;
+       fs32 max_depth;
+       fs32 data_type;
+       fs64 root_node_ptr;
+       fs64 free_node_ptr;
+       fs64 max_size;
+} PACKED befs_disk_btree_super;
+
 typedef struct {
        u32 magic;
        u32 node_size;
@@ -205,12 +232,20 @@ typedef struct {
 /*
  * Header stucture of each btree node
  */
+typedef struct {
+       fs64 left;
+       fs64 right;
+       fs64 overflow;
+       fs16 all_key_count;
+       fs16 all_key_length;
+} PACKED befs_btree_nodehead;
+
 typedef struct {
        befs_off_t left;
        befs_off_t right;
        befs_off_t overflow;
        u16 all_key_count;
        u16 all_key_length;
-} PACKED befs_btree_nodehead;
+} PACKED befs_host_btree_nodehead;
 
 #endif                         /* _LINUX_BEFS_FS_TYPES */

diff --git a/fs/befs/btree.c b/fs/befs/btree.c
index 12e0fd60033efa48d43854580212d6ccd08fbf36..81b042ee24e650339445504e5e83a9ecda9ca384 100644 (file)
--- a/fs/befs/btree.c
+++ b/fs/befs/btree.c
@@ -79,7 +79,7 @@
  * In memory structure of each btree node
  */
 typedef struct {
-       befs_btree_nodehead head;       /* head of node converted to cpu byteorder */
+       befs_host_btree_nodehead head;  /* head of node converted to cpu byteorder */
        struct buffer_head *bh;
        befs_btree_nodehead *od_node;   /* on disk node */
 } befs_btree_node;
@@ -101,9 +101,9 @@ static int befs_bt_read_node(struct super_block *sb, befs_data_stream * ds,
 
 static int befs_leafnode(befs_btree_node * node);
 
-static u16 *befs_bt_keylen_index(befs_btree_node * node);
+static fs16 *befs_bt_keylen_index(befs_btree_node * node);
 
-static befs_off_t *befs_bt_valarray(befs_btree_node * node);
+static fs64 *befs_bt_valarray(befs_btree_node * node);
 
 static char *befs_bt_keydata(befs_btree_node * node);
 
@@ -135,7 +135,7 @@ befs_bt_read_super(struct super_block *sb, befs_data_stream * ds,
                   befs_btree_super * sup)
 {
        struct buffer_head *bh = NULL;
-       befs_btree_super *od_sup = NULL;
+       befs_disk_btree_super *od_sup = NULL;
 
        befs_debug(sb, "---> befs_btree_read_super()");
 
@@ -145,7 +145,7 @@ befs_bt_read_super(struct super_block *sb, befs_data_stream * ds,
                befs_error(sb, "Couldn't read index header.");
                goto error;
        }
-       od_sup = (befs_btree_super *) bh->b_data;
+       od_sup = (befs_disk_btree_super *) bh->b_data;
        befs_dump_index_entry(sb, od_sup);
 
        sup->magic = fs32_to_cpu(sb, od_sup->magic);
@@ -341,7 +341,7 @@ befs_find_key(struct super_block *sb, befs_btree_node * node,
        u16 keylen;
        int findkey_len;
        char *thiskey;
-       befs_off_t *valarray;
+       fs64 *valarray;
 
        befs_debug(sb, "---> befs_find_key() %s", findkey);
 
@@ -421,7 +421,7 @@ befs_btree_read(struct super_block *sb, befs_data_stream * ds,
        befs_btree_super bt_super;
        befs_off_t node_off = 0;
        int cur_key;
-       befs_off_t *valarray;
+       fs64 *valarray;
        char *keystart;
        u16 keylen;
        int res;
@@ -571,7 +571,7 @@ befs_btree_seekleaf(struct super_block *sb, befs_data_stream * ds,
                                   this_node->head.overflow);
                        *node_off = this_node->head.overflow;
                } else {
-                       befs_off_t *valarray = befs_bt_valarray(this_node);
+                       fs64 *valarray = befs_bt_valarray(this_node);
                        *node_off = fs64_to_cpu(sb, valarray[0]);
                }
                if (befs_bt_read_node(sb, ds, this_node, *node_off) != BEFS_OK) {
@@ -621,7 +621,7 @@ befs_leafnode(befs_btree_node * node)
  *
  * Except that rounding up to 8 works, and rounding up to 4 doesn't.
  */
-static u16 *
+static fs16 *
 befs_bt_keylen_index(befs_btree_node * node)
 {
        const int keylen_align = 8;
@@ -632,7 +632,7 @@ befs_bt_keylen_index(befs_btree_node * node)
        if (tmp)
                off += keylen_align - tmp;
 
-       return (u16 *) ((void *) node->od_node + off);
+       return (fs16 *) ((void *) node->od_node + off);
 }
 
 /**
@@ -642,13 +642,13 @@ befs_bt_keylen_index(befs_btree_node * node)
  * Returns a pointer to the start of the value array
  * of the node pointed to by the node header
  */
-static befs_off_t *
+static fs64 *
 befs_bt_valarray(befs_btree_node * node)
 {
        void *keylen_index_start = (void *) befs_bt_keylen_index(node);
-       size_t keylen_index_size = node->head.all_key_count * sizeof (u16);
+       size_t keylen_index_size = node->head.all_key_count * sizeof (fs16);
 
-       return (befs_off_t *) (keylen_index_start + keylen_index_size);
+       return (fs64 *) (keylen_index_start + keylen_index_size);
 }
 
 /**
@@ -680,7 +680,7 @@ befs_bt_get_key(struct super_block *sb, befs_btree_node * node,
 {
        int prev_key_end;
        char *keystart;
-       u16 *keylen_index;
+       fs16 *keylen_index;
 
        if (index < 0 || index > node->head.all_key_count) {
                *keylen = 0;

diff --git a/fs/befs/datastream.c b/fs/befs/datastream.c
index 67335e2853f6b5c4095a8ef1b5d70300168da512..aacb4da6298aefe41200fb587784e09ce7d842ae 100644 (file)
--- a/fs/befs/datastream.c
+++ b/fs/befs/datastream.c
@@ -311,7 +311,7 @@ befs_find_brun_indirect(struct super_block *sb,
        befs_blocknr_t indir_start_blk;
        befs_blocknr_t search_blk;
        struct buffer_head *indirblock;
-       befs_block_run *array;
+       befs_disk_block_run *array;
 
        befs_block_run indirect = data->indirect;
        befs_blocknr_t indirblockno = iaddr2blockno(sb, &indirect);
@@ -333,7 +333,7 @@ befs_find_brun_indirect(struct super_block *sb,
                        return BEFS_ERR;
                }
 
-               array = (befs_block_run *) indirblock->b_data;
+               array = (befs_disk_block_run *) indirblock->b_data;
 
                for (j = 0; j < arraylen; ++j) {
                        int len = fs16_to_cpu(sb, array[j].len);
@@ -426,7 +426,7 @@ befs_find_brun_dblindirect(struct super_block *sb,
        struct buffer_head *dbl_indir_block;
        struct buffer_head *indir_block;
        befs_block_run indir_run;
-       befs_inode_addr *iaddr_array = NULL;
+       befs_disk_inode_addr *iaddr_array = NULL;
        befs_sb_info *befs_sb = BEFS_SB(sb);
 
        befs_blocknr_t indir_start_blk =
@@ -481,7 +481,7 @@ befs_find_brun_dblindirect(struct super_block *sb,
 
        dbl_block_indx =
            dblindir_indx - (dbl_which_block * befs_iaddrs_per_block(sb));
-       iaddr_array = (befs_inode_addr *) dbl_indir_block->b_data;
+       iaddr_array = (befs_disk_inode_addr *) dbl_indir_block->b_data;
        indir_run = fsrun_to_cpu(sb, iaddr_array[dbl_block_indx]);
        brelse(dbl_indir_block);
        iaddr_array = NULL;
@@ -506,7 +506,7 @@ befs_find_brun_dblindirect(struct super_block *sb,
        }
 
        block_indx = indir_indx - (which_block * befs_iaddrs_per_block(sb));
-       iaddr_array = (befs_inode_addr *) indir_block->b_data;
+       iaddr_array = (befs_disk_inode_addr *) indir_block->b_data;
        *run = fsrun_to_cpu(sb, iaddr_array[block_indx]);
        brelse(indir_block);
        iaddr_array = NULL;

diff --git a/fs/befs/debug.c b/fs/befs/debug.c
index bb68370f6494a68e1a5c5288ee8316a34c077acc..e831a8f30849a98a088d46394742cc3b4c476182 100644 (file)
--- a/fs/befs/debug.c
+++ b/fs/befs/debug.c
@@ -230,21 +230,20 @@ befs_dump_small_data(const struct super_block *sb, befs_small_data * sd)
 
 /* unused */
 void
-befs_dump_run(const struct super_block *sb, befs_block_run run)
+befs_dump_run(const struct super_block *sb, befs_disk_block_run run)
 {
 #ifdef CONFIG_BEFS_DEBUG
 
-       run = fsrun_to_cpu(sb, run);
+       befs_block_run n = fsrun_to_cpu(sb, run);
 
-       befs_debug(sb, "[%u, %hu, %hu]",
-                  run.allocation_group, run.start, run.len);
+       befs_debug(sb, "[%u, %hu, %hu]", n.allocation_group, n.start, n.len);
 
 #endif                         //CONFIG_BEFS_DEBUG
 }
 #endif  /*  0  */
 
 void
-befs_dump_index_entry(const struct super_block *sb, befs_btree_super * super)
+befs_dump_index_entry(const struct super_block *sb, befs_disk_btree_super * super)
 {
 #ifdef CONFIG_BEFS_DEBUG
 

diff --git a/fs/befs/endian.h b/fs/befs/endian.h
index 979c543e6c587e6bf00b79bd0189e4a27c77e8ef..e254a20869f4084bca2fd850af876919fd935ccb 100644 (file)
--- a/fs/befs/endian.h
+++ b/fs/befs/endian.h
@@ -68,26 +68,26 @@ cpu_to_fs16(const struct super_block *sb, u16 n)
 /* Composite types below here */
 
 static inline befs_block_run
-fsrun_to_cpu(const struct super_block *sb, befs_block_run n)
+fsrun_to_cpu(const struct super_block *sb, befs_disk_block_run n)
 {
        befs_block_run run;
 
        if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE) {
-               run.allocation_group = le32_to_cpu(n.allocation_group);
-               run.start = le16_to_cpu(n.start);
-               run.len = le16_to_cpu(n.len);
+               run.allocation_group = le32_to_cpu((__force __le32)n.allocation_group);
+               run.start = le16_to_cpu((__force __le16)n.start);
+               run.len = le16_to_cpu((__force __le16)n.len);
        } else {
-               run.allocation_group = be32_to_cpu(n.allocation_group);
-               run.start = be16_to_cpu(n.start);
-               run.len = be16_to_cpu(n.len);
+               run.allocation_group = be32_to_cpu((__force __be32)n.allocation_group);
+               run.start = be16_to_cpu((__force __be16)n.start);
+               run.len = be16_to_cpu((__force __be16)n.len);
        }
        return run;
 }
 
-static inline befs_block_run
+static inline befs_disk_block_run
 cpu_to_fsrun(const struct super_block *sb, befs_block_run n)
 {
-       befs_block_run run;
+       befs_disk_block_run run;
 
        if (BEFS_SB(sb)->byte_order == BEFS_BYTESEX_LE) {
                run.allocation_group = cpu_to_le32(n.allocation_group);
@@ -102,7 +102,7 @@ cpu_to_fsrun(const struct super_block *sb, befs_block_run n)
 }
 
 static inline befs_data_stream
-fsds_to_cpu(const struct super_block *sb, befs_data_stream n)
+fsds_to_cpu(const struct super_block *sb, befs_disk_data_stream n)
 {
        befs_data_stream data;
        int i;