Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a9721f31 authored by Al Viro's avatar Al Viro Committed by Linus Torvalds
Browse files

[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: default avatarAl Viro <viro@zeniv.linux.org.uk>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent e5201c58

fs/befs/befs.h

+2 −2
Original line number Diff line number Diff line
@@ -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

fs/befs/befs_fs_types.h

+71 −36
Original line number Diff line number Diff line
@@ -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 */

fs/befs/btree.c

+14 −14
Original line number Diff line number Diff line
@@ -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;

fs/befs/datastream.c

+5 −5
Original line number Diff line number Diff line
@@ -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;

fs/befs/debug.c

+4 −5
Original line number Diff line number Diff line
@@ -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