Commit cd915493 authored by Steven Whitehouse's avatar Steven Whitehouse
Browse files

[GFS2] Change all types to uX style 



This makes all fixed size types have consistent names.

Cc: Jan Engelhardt <jengelh@linux01.gwdg.de>
Signed-off-by: default avatarSteven Whitehouse <swhiteho@redhat.com>
parent a91ea69f

fs/gfs2/bmap.c

+30 −30
Original line number Diff line number Diff line
@@ -38,8 +38,8 @@ struct metapath { 
};



typedef int (*block_call_t) (struct gfs2_inode *ip, struct buffer_head *dibh,

			     struct buffer_head *bh, uint64_t *top,

			     uint64_t *bottom, unsigned int height,

			     struct buffer_head *bh, u64 *top,

			     u64 *bottom, unsigned int height,

			     void *data);



struct strip_mine {
@@ -58,7 +58,7 @@ struct strip_mine { 
 */



static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh,

			       uint64_t block, struct page *page)

			       u64 block, struct page *page)

{

	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);

	struct inode *inode = &ip->i_inode;
@@ -121,7 +121,7 @@ static int gfs2_unstuffer_page(struct gfs2_inode *ip, struct buffer_head *dibh, 
int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page)

{

	struct buffer_head *bh, *dibh;

	uint64_t block = 0;

	u64 block = 0;

	int isdir = gfs2_is_dir(ip);

	int error;
@@ -161,7 +161,7 @@ int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page) 
	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));



	if (ip->i_di.di_size) {

		*(uint64_t *)(dibh->b_data + sizeof(struct gfs2_dinode)) =

		*(u64 *)(dibh->b_data + sizeof(struct gfs2_dinode)) =

			cpu_to_be64(block);

		ip->i_di.di_blocks++;

	}
@@ -190,10 +190,10 @@ int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page) 
 * Returns: the height the tree should be

 */



static unsigned int calc_tree_height(struct gfs2_inode *ip, uint64_t size)

static unsigned int calc_tree_height(struct gfs2_inode *ip, u64 size)

{

	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);

	uint64_t *arr;

	u64 *arr;

	unsigned int max, height;



	if (ip->i_di.di_size > size)
@@ -336,11 +336,11 @@ static int build_height(struct inode *inode, unsigned height) 
 *

 */



static void find_metapath(struct gfs2_inode *ip, uint64_t block,

static void find_metapath(struct gfs2_inode *ip, u64 block,

			  struct metapath *mp)

{

	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);

	uint64_t b = block;

	u64 b = block;

	unsigned int i;



	for (i = ip->i_di.di_height; i--;)
@@ -390,10 +390,10 @@ static inline u64 *metapointer(struct buffer_head *bh, int *boundary, 


static int lookup_block(struct gfs2_inode *ip, struct buffer_head *bh,

			unsigned int height, struct metapath *mp, int create,

			int *new, uint64_t *block)

			int *new, u64 *block)

{

	int boundary;

	uint64_t *ptr = metapointer(bh, &boundary, height, mp);

	u64 *ptr = metapointer(bh, &boundary, height, mp);



	if (*ptr) {

		*block = be64_to_cpu(*ptr);
@@ -594,13 +594,13 @@ int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsi 


static int recursive_scan(struct gfs2_inode *ip, struct buffer_head *dibh,

			  struct metapath *mp, unsigned int height,

			  uint64_t block, int first, block_call_t bc,

			  u64 block, int first, block_call_t bc,

			  void *data)

{

	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);

	struct buffer_head *bh = NULL;

	uint64_t *top, *bottom;

	uint64_t bn;

	u64 *top, *bottom;

	u64 bn;

	int error;

	int mh_size = sizeof(struct gfs2_meta_header);
@@ -617,10 +617,10 @@ static int recursive_scan(struct gfs2_inode *ip, struct buffer_head *dibh, 
		if (error)

			return error;



		top = (uint64_t *)(bh->b_data + mh_size) +

		top = (u64 *)(bh->b_data + mh_size) +

				  ((first) ? mp->mp_list[height] : 0);



		bottom = (uint64_t *)(bh->b_data + mh_size) + sdp->sd_inptrs;

		bottom = (u64 *)(bh->b_data + mh_size) + sdp->sd_inptrs;

	}



	error = bc(ip, dibh, bh, top, bottom, height, data);
@@ -659,15 +659,15 @@ static int recursive_scan(struct gfs2_inode *ip, struct buffer_head *dibh, 
 */



static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh,

		    struct buffer_head *bh, uint64_t *top, uint64_t *bottom,

		    struct buffer_head *bh, u64 *top, u64 *bottom,

		    unsigned int height, void *data)

{

	struct strip_mine *sm = data;

	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);

	struct gfs2_rgrp_list rlist;

	uint64_t bn, bstart;

	uint32_t blen;

	uint64_t *p;

	u64 bn, bstart;

	u32 blen;

	u64 *p;

	unsigned int rg_blocks = 0;

	int metadata;

	unsigned int revokes = 0;
@@ -804,7 +804,7 @@ static int do_strip(struct gfs2_inode *ip, struct buffer_head *dibh, 
 * Returns: errno

 */



static int do_grow(struct gfs2_inode *ip, uint64_t size)

static int do_grow(struct gfs2_inode *ip, u64 size)

{

	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);

	struct gfs2_alloc *al;
@@ -949,7 +949,7 @@ static int gfs2_block_truncate_page(struct address_space *mapping) 
	return err;

}



static int trunc_start(struct gfs2_inode *ip, uint64_t size)

static int trunc_start(struct gfs2_inode *ip, u64 size)

{

	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);

	struct buffer_head *dibh;
@@ -974,7 +974,7 @@ static int trunc_start(struct gfs2_inode *ip, uint64_t size) 
		error = 1;



	} else {

		if (size & (uint64_t)(sdp->sd_sb.sb_bsize - 1))

		if (size & (u64)(sdp->sd_sb.sb_bsize - 1))

			error = gfs2_block_truncate_page(ip->i_inode.i_mapping);



		if (!error) {
@@ -993,10 +993,10 @@ static int trunc_start(struct gfs2_inode *ip, uint64_t size) 
	return error;

}



static int trunc_dealloc(struct gfs2_inode *ip, uint64_t size)

static int trunc_dealloc(struct gfs2_inode *ip, u64 size)

{

	unsigned int height = ip->i_di.di_height;

	uint64_t lblock;

	u64 lblock;

	struct metapath mp;

	int error;
@@ -1076,7 +1076,7 @@ static int trunc_end(struct gfs2_inode *ip) 
 * Returns: errno

 */



static int do_shrink(struct gfs2_inode *ip, uint64_t size)

static int do_shrink(struct gfs2_inode *ip, u64 size)

{

	int error;
@@ -1104,7 +1104,7 @@ static int do_shrink(struct gfs2_inode *ip, uint64_t size) 
 * Returns: errno

 */



int gfs2_truncatei(struct gfs2_inode *ip, uint64_t size)

int gfs2_truncatei(struct gfs2_inode *ip, u64 size)

{

	int error;
@@ -1172,12 +1172,12 @@ void gfs2_write_calc_reserv(struct gfs2_inode *ip, unsigned int len, 
 * Returns: errno

 */



int gfs2_write_alloc_required(struct gfs2_inode *ip, uint64_t offset,

int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,

			      unsigned int len, int *alloc_required)

{

	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);

	uint64_t lblock, lblock_stop, dblock;

	uint32_t extlen;

	u64 lblock, lblock_stop, dblock;

	u32 extlen;

	int new = 0;

	int error = 0;

fs/gfs2/bmap.h

+2 −2
Original line number Diff line number Diff line
@@ -14,14 +14,14 @@ int gfs2_unstuff_dinode(struct gfs2_inode *ip, struct page *page); 
int gfs2_block_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, int *boundary);

int gfs2_extent_map(struct inode *inode, u64 lblock, int *new, u64 *dblock, unsigned *extlen);



int gfs2_truncatei(struct gfs2_inode *ip, uint64_t size);

int gfs2_truncatei(struct gfs2_inode *ip, u64 size);

int gfs2_truncatei_resume(struct gfs2_inode *ip);

int gfs2_file_dealloc(struct gfs2_inode *ip);



void gfs2_write_calc_reserv(struct gfs2_inode *ip, unsigned int len,

			    unsigned int *data_blocks,

			    unsigned int *ind_blocks);

int gfs2_write_alloc_required(struct gfs2_inode *ip, uint64_t offset,

int gfs2_write_alloc_required(struct gfs2_inode *ip, u64 offset,

			      unsigned int len, int *alloc_required);



#endif /* __BMAP_DOT_H__ */

fs/gfs2/dir.c

+62 −62
Original line number Diff line number Diff line
@@ -78,15 +78,15 @@ 
#define IS_LEAF     1 /* Hashed (leaf) directory */

#define IS_DINODE   2 /* Linear (stuffed dinode block) directory */



#define gfs2_disk_hash2offset(h) (((uint64_t)(h)) >> 1)

#define gfs2_dir_offset2hash(p) ((uint32_t)(((uint64_t)(p)) << 1))

#define gfs2_disk_hash2offset(h) (((u64)(h)) >> 1)

#define gfs2_dir_offset2hash(p) ((u32)(((u64)(p)) << 1))



typedef int (*leaf_call_t) (struct gfs2_inode *dip,

			    uint32_t index, uint32_t len, uint64_t leaf_no,

			    u32 index, u32 len, u64 leaf_no,

			    void *data);





int gfs2_dir_get_new_buffer(struct gfs2_inode *ip, uint64_t block,

int gfs2_dir_get_new_buffer(struct gfs2_inode *ip, u64 block,

			    struct buffer_head **bhp)

{

	struct buffer_head *bh;
@@ -99,7 +99,7 @@ int gfs2_dir_get_new_buffer(struct gfs2_inode *ip, uint64_t block, 
	return 0;

}



static int gfs2_dir_get_existing_buffer(struct gfs2_inode *ip, uint64_t block,

static int gfs2_dir_get_existing_buffer(struct gfs2_inode *ip, u64 block,

					struct buffer_head **bhp)

{

	struct buffer_head *bh;
@@ -151,12 +151,12 @@ static int gfs2_dir_write_stuffed(struct gfs2_inode *ip, const char *buf, 
 * Returns: The number of bytes correctly written or error code

 */

static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf,

			       uint64_t offset, unsigned int size)

			       u64 offset, unsigned int size)

{

	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);

	struct buffer_head *dibh;

	uint64_t lblock, dblock;

	uint32_t extlen = 0;

	u64 lblock, dblock;

	u32 extlen = 0;

	unsigned int o;

	int copied = 0;

	int error = 0;
@@ -271,11 +271,11 @@ static int gfs2_dir_read_stuffed(struct gfs2_inode *ip, char *buf, 
 * Returns: The amount of data actually copied or the error

 */

static int gfs2_dir_read_data(struct gfs2_inode *ip, char *buf,

			      uint64_t offset, unsigned int size)

			      u64 offset, unsigned int size)

{

	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);

	uint64_t lblock, dblock;

	uint32_t extlen = 0;

	u64 lblock, dblock;

	u32 extlen = 0;

	unsigned int o;

	int copied = 0;

	int error = 0;
@@ -581,7 +581,7 @@ static int dirent_next(struct gfs2_inode *dip, struct buffer_head *bh, 
{

	struct gfs2_dirent *tmp, *cur;

	char *bh_end;

	uint16_t cur_rec_len;

	u16 cur_rec_len;



	cur = *dent;

	bh_end = bh->b_data + bh->b_size;
@@ -630,7 +630,7 @@ static int dirent_next(struct gfs2_inode *dip, struct buffer_head *bh, 
static void dirent_del(struct gfs2_inode *dip, struct buffer_head *bh,

		       struct gfs2_dirent *prev, struct gfs2_dirent *cur)

{

	uint16_t cur_rec_len, prev_rec_len;

	u16 cur_rec_len, prev_rec_len;



	if (!cur->de_inum.no_addr) {

		gfs2_consist_inode(dip);
@@ -698,7 +698,7 @@ static struct gfs2_dirent *gfs2_dirent_alloc(struct inode *inode, 
	return gfs2_init_dirent(inode, dent, name, bh);

}



static int get_leaf(struct gfs2_inode *dip, uint64_t leaf_no,

static int get_leaf(struct gfs2_inode *dip, u64 leaf_no,

		    struct buffer_head **bhp)

{

	int error;
@@ -721,16 +721,16 @@ static int get_leaf(struct gfs2_inode *dip, uint64_t leaf_no, 
 * Returns: 0 on success, error code otherwise

 */



static int get_leaf_nr(struct gfs2_inode *dip, uint32_t index,

		       uint64_t *leaf_out)

static int get_leaf_nr(struct gfs2_inode *dip, u32 index,

		       u64 *leaf_out)

{

	uint64_t leaf_no;

	u64 leaf_no;

	int error;



	error = gfs2_dir_read_data(dip, (char *)&leaf_no,

				    index * sizeof(uint64_t),

				    sizeof(uint64_t));

	if (error != sizeof(uint64_t))

				    index * sizeof(u64),

				    sizeof(u64));

	if (error != sizeof(u64))

		return (error < 0) ? error : -EIO;



	*leaf_out = be64_to_cpu(leaf_no);
@@ -738,10 +738,10 @@ static int get_leaf_nr(struct gfs2_inode *dip, uint32_t index, 
	return 0;

}



static int get_first_leaf(struct gfs2_inode *dip, uint32_t index,

static int get_first_leaf(struct gfs2_inode *dip, u32 index,

			  struct buffer_head **bh_out)

{

	uint64_t leaf_no;

	u64 leaf_no;

	int error;



	error = get_leaf_nr(dip, index, &leaf_no);
@@ -847,8 +847,8 @@ static int dir_make_exhash(struct inode *inode) 
	struct buffer_head *bh, *dibh;

	struct gfs2_leaf *leaf;

	int y;

	uint32_t x;

	uint64_t *lp, bn;

	u32 x;

	u64 *lp, bn;

	int error;



	error = gfs2_meta_inode_buffer(dip, &dibh);
@@ -904,7 +904,7 @@ static int dir_make_exhash(struct inode *inode) 
	gfs2_trans_add_bh(dip->i_gl, dibh, 1);

	gfs2_buffer_clear_tail(dibh, sizeof(struct gfs2_dinode));



	lp = (uint64_t *)(dibh->b_data + sizeof(struct gfs2_dinode));

	lp = (u64 *)(dibh->b_data + sizeof(struct gfs2_dinode));



	for (x = sdp->sd_hash_ptrs; x--; lp++)

		*lp = cpu_to_be64(bn);
@@ -939,9 +939,9 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name) 
	struct buffer_head *nbh, *obh, *dibh;

	struct gfs2_leaf *nleaf, *oleaf;

	struct gfs2_dirent *dent = NULL, *prev = NULL, *next = NULL, *new;

	uint32_t start, len, half_len, divider;

	uint64_t bn, *lp, leaf_no;

	uint32_t index;

	u32 start, len, half_len, divider;

	u64 bn, *lp, leaf_no;

	u32 index;

	int x, moved = 0;

	int error;
@@ -985,14 +985,14 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name) 
	/* Change the pointers.

	   Don't bother distinguishing stuffed from non-stuffed.

	   This code is complicated enough already. */

	lp = kmalloc(half_len * sizeof(uint64_t), GFP_NOFS | __GFP_NOFAIL);

	lp = kmalloc(half_len * sizeof(u64), GFP_NOFS | __GFP_NOFAIL);

	/*  Change the pointers  */

	for (x = 0; x < half_len; x++)

		lp[x] = cpu_to_be64(bn);



	error = gfs2_dir_write_data(dip, (char *)lp, start * sizeof(uint64_t),

				    half_len * sizeof(uint64_t));

	if (error != half_len * sizeof(uint64_t)) {

	error = gfs2_dir_write_data(dip, (char *)lp, start * sizeof(u64),

				    half_len * sizeof(u64));

	if (error != half_len * sizeof(u64)) {

		if (error >= 0)

			error = -EIO;

		goto fail_lpfree;
@@ -1077,15 +1077,15 @@ static int dir_double_exhash(struct gfs2_inode *dip) 
{

	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);

	struct buffer_head *dibh;

	uint32_t hsize;

	uint64_t *buf;

	uint64_t *from, *to;

	uint64_t block;

	u32 hsize;

	u64 *buf;

	u64 *from, *to;

	u64 block;

	int x;

	int error = 0;



	hsize = 1 << dip->i_di.di_depth;

	if (hsize * sizeof(uint64_t) != dip->i_di.di_size) {

	if (hsize * sizeof(u64) != dip->i_di.di_size) {

		gfs2_consist_inode(dip);

		return -EIO;

	}
@@ -1105,7 +1105,7 @@ static int dir_double_exhash(struct gfs2_inode *dip) 
		}



		from = buf;

		to = (uint64_t *)((char *)buf + sdp->sd_hash_bsize);

		to = (u64 *)((char *)buf + sdp->sd_hash_bsize);



		for (x = sdp->sd_hash_ptrs; x--; from++) {

			*to++ = *from;	/*  No endianess worries  */
@@ -1153,7 +1153,7 @@ static int dir_double_exhash(struct gfs2_inode *dip) 
static int compare_dents(const void *a, const void *b)

{

	struct gfs2_dirent *dent_a, *dent_b;

	uint32_t hash_a, hash_b;

	u32 hash_a, hash_b;

	int ret = 0;



	dent_a = *(struct gfs2_dirent **)a;
@@ -1201,14 +1201,14 @@ static int compare_dents(const void *a, const void *b) 
 * Returns: errno, >0 on exception from filldir

 */



static int do_filldir_main(struct gfs2_inode *dip, uint64_t *offset,

static int do_filldir_main(struct gfs2_inode *dip, u64 *offset,

			   void *opaque, gfs2_filldir_t filldir,

			   const struct gfs2_dirent **darr, uint32_t entries,

			   const struct gfs2_dirent **darr, u32 entries,

			   int *copied)

{

	const struct gfs2_dirent *dent, *dent_next;

	struct gfs2_inum inum;

	uint64_t off, off_next;

	u64 off, off_next;

	unsigned int x, y;

	int run = 0;

	int error = 0;
@@ -1346,21 +1346,21 @@ static int gfs2_dir_read_leaf(struct inode *inode, u64 *offset, void *opaque, 
 * Returns: errno

 */



static int dir_e_read(struct inode *inode, uint64_t *offset, void *opaque,

static int dir_e_read(struct inode *inode, u64 *offset, void *opaque,

		      gfs2_filldir_t filldir)

{

	struct gfs2_inode *dip = GFS2_I(inode);

	struct gfs2_sbd *sdp = GFS2_SB(inode);

	uint32_t hsize, len = 0;

	uint32_t ht_offset, lp_offset, ht_offset_cur = -1;

	uint32_t hash, index;

	uint64_t *lp;

	u32 hsize, len = 0;

	u32 ht_offset, lp_offset, ht_offset_cur = -1;

	u32 hash, index;

	u64 *lp;

	int copied = 0;

	int error = 0;

	unsigned depth = 0;



	hsize = 1 << dip->i_di.di_depth;

	if (hsize * sizeof(uint64_t) != dip->i_di.di_size) {

	if (hsize * sizeof(u64) != dip->i_di.di_size) {

		gfs2_consist_inode(dip);

		return -EIO;

	}
@@ -1378,7 +1378,7 @@ static int dir_e_read(struct inode *inode, uint64_t *offset, void *opaque, 


		if (ht_offset_cur != ht_offset) {

			error = gfs2_dir_read_data(dip, (char *)lp,

						ht_offset * sizeof(uint64_t),

						ht_offset * sizeof(u64),

						sdp->sd_hash_bsize);

			if (error != sdp->sd_hash_bsize) {

				if (error >= 0)
@@ -1405,7 +1405,7 @@ static int dir_e_read(struct inode *inode, uint64_t *offset, void *opaque, 
	return error;

}



int gfs2_dir_read(struct inode *inode, uint64_t *offset, void *opaque,

int gfs2_dir_read(struct inode *inode, u64 *offset, void *opaque,

		  gfs2_filldir_t filldir)

{

	struct gfs2_inode *dip = GFS2_I(inode);
@@ -1725,15 +1725,15 @@ static int foreach_leaf(struct gfs2_inode *dip, leaf_call_t lc, void *data) 
	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);

	struct buffer_head *bh;

	struct gfs2_leaf *leaf;

	uint32_t hsize, len;

	uint32_t ht_offset, lp_offset, ht_offset_cur = -1;

	uint32_t index = 0;

	uint64_t *lp;

	uint64_t leaf_no;

	u32 hsize, len;

	u32 ht_offset, lp_offset, ht_offset_cur = -1;

	u32 index = 0;

	u64 *lp;

	u64 leaf_no;

	int error = 0;



	hsize = 1 << dip->i_di.di_depth;

	if (hsize * sizeof(uint64_t) != dip->i_di.di_size) {

	if (hsize * sizeof(u64) != dip->i_di.di_size) {

		gfs2_consist_inode(dip);

		return -EIO;

	}
@@ -1748,7 +1748,7 @@ static int foreach_leaf(struct gfs2_inode *dip, leaf_call_t lc, void *data) 


		if (ht_offset_cur != ht_offset) {

			error = gfs2_dir_read_data(dip, (char *)lp,

						ht_offset * sizeof(uint64_t),

						ht_offset * sizeof(u64),

						sdp->sd_hash_bsize);

			if (error != sdp->sd_hash_bsize) {

				if (error >= 0)
@@ -1798,17 +1798,17 @@ static int foreach_leaf(struct gfs2_inode *dip, leaf_call_t lc, void *data) 
 * Returns: errno

 */



static int leaf_dealloc(struct gfs2_inode *dip, uint32_t index, uint32_t len,

			uint64_t leaf_no, void *data)

static int leaf_dealloc(struct gfs2_inode *dip, u32 index, u32 len,

			u64 leaf_no, void *data)

{

	struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);

	struct gfs2_leaf *tmp_leaf;

	struct gfs2_rgrp_list rlist;

	struct buffer_head *bh, *dibh;

	uint64_t blk, nblk;

	u64 blk, nblk;

	unsigned int rg_blocks = 0, l_blocks = 0;

	char *ht;

	unsigned int x, size = len * sizeof(uint64_t);

	unsigned int x, size = len * sizeof(u64);

	int error;



	memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
@@ -1874,7 +1874,7 @@ static int leaf_dealloc(struct gfs2_inode *dip, uint32_t index, uint32_t len, 
		dip->i_di.di_blocks--;

	}



	error = gfs2_dir_write_data(dip, ht, index * sizeof(uint64_t), size);

	error = gfs2_dir_write_data(dip, ht, index * sizeof(u64), size);

	if (error != size) {

		if (error >= 0)

			error = -EIO;

fs/gfs2/dir.h

+4 −4
Original line number Diff line number Diff line
@@ -24,7 +24,7 @@ 


typedef int (*gfs2_filldir_t) (void *opaque,

			      const char *name, unsigned int length,

			      uint64_t offset,

			      u64 offset,

			      struct gfs2_inum *inum, unsigned int type);



int gfs2_dir_search(struct inode *dir, const struct qstr *filename,
@@ -32,7 +32,7 @@ int gfs2_dir_search(struct inode *dir, const struct qstr *filename, 
int gfs2_dir_add(struct inode *inode, const struct qstr *filename,

		 const struct gfs2_inum *inum, unsigned int type);

int gfs2_dir_del(struct gfs2_inode *dip, const struct qstr *filename);

int gfs2_dir_read(struct inode *inode, uint64_t * offset, void *opaque,

int gfs2_dir_read(struct inode *inode, u64 * offset, void *opaque,

		  gfs2_filldir_t filldir);

int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,

		   struct gfs2_inum *new_inum, unsigned int new_type);
@@ -41,10 +41,10 @@ int gfs2_dir_exhash_dealloc(struct gfs2_inode *dip); 


int gfs2_diradd_alloc_required(struct inode *dir,

			       const struct qstr *filename);

int gfs2_dir_get_new_buffer(struct gfs2_inode *ip, uint64_t block,

int gfs2_dir_get_new_buffer(struct gfs2_inode *ip, u64 block,

			    struct buffer_head **bhp);



static inline uint32_t gfs2_disk_hash(const char *data, int len)

static inline u32 gfs2_disk_hash(const char *data, int len)

{

        return crc32_le(0xFFFFFFFF, data, len) ^ 0xFFFFFFFF;

}

fs/gfs2/eattr.c

+28 −28
Original line number Diff line number Diff line
@@ -115,7 +115,7 @@ static int ea_foreach_i(struct gfs2_inode *ip, struct buffer_head *bh, 
static int ea_foreach(struct gfs2_inode *ip, ea_call_t ea_call, void *data)

{

	struct buffer_head *bh, *eabh;

	uint64_t *eablk, *end;

	u64 *eablk, *end;

	int error;



	error = gfs2_meta_read(ip->i_gl, ip->i_di.di_eattr,
@@ -133,11 +133,11 @@ static int ea_foreach(struct gfs2_inode *ip, ea_call_t ea_call, void *data) 
		goto out;

	}



	eablk = (uint64_t *)(bh->b_data + sizeof(struct gfs2_meta_header));

	eablk = (u64 *)(bh->b_data + sizeof(struct gfs2_meta_header));

	end = eablk + GFS2_SB(&ip->i_inode)->sd_inptrs;



	for (; eablk < end; eablk++) {

		uint64_t bn;

		u64 bn;



		if (!*eablk)

			break;
@@ -235,8 +235,8 @@ static int ea_dealloc_unstuffed(struct gfs2_inode *ip, struct buffer_head *bh, 
	struct gfs2_rgrpd *rgd;

	struct gfs2_holder rg_gh;

	struct buffer_head *dibh;

	uint64_t *dataptrs, bn = 0;

	uint64_t bstart = 0;

	u64 *dataptrs, bn = 0;

	u64 bstart = 0;

	unsigned int blen = 0;

	unsigned int blks = 0;

	unsigned int x;
@@ -296,7 +296,7 @@ static int ea_dealloc_unstuffed(struct gfs2_inode *ip, struct buffer_head *bh, 
		gfs2_free_meta(ip, bstart, blen);



	if (prev && !leave) {

		uint32_t len;

		u32 len;



		len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);

		prev->ea_rec_len = cpu_to_be32(len);
@@ -459,7 +459,7 @@ static int ea_get_unstuffed(struct gfs2_inode *ip, struct gfs2_ea_header *ea, 
	struct buffer_head **bh;

	unsigned int amount = GFS2_EA_DATA_LEN(ea);

	unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);

	uint64_t *dataptrs = GFS2_EA2DATAPTRS(ea);

	u64 *dataptrs = GFS2_EA2DATAPTRS(ea);

	unsigned int x;

	int error = 0;
@@ -601,7 +601,7 @@ static int ea_alloc_blk(struct gfs2_inode *ip, struct buffer_head **bhp) 
{

	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);

	struct gfs2_ea_header *ea;

	uint64_t block;

	u64 block;



	block = gfs2_alloc_meta(ip);
@@ -649,7 +649,7 @@ static int ea_write(struct gfs2_inode *ip, struct gfs2_ea_header *ea, 
		ea->ea_num_ptrs = 0;

		memcpy(GFS2_EA2DATA(ea), er->er_data, er->er_data_len);

	} else {

		uint64_t *dataptr = GFS2_EA2DATAPTRS(ea);

		u64 *dataptr = GFS2_EA2DATAPTRS(ea);

		const char *data = er->er_data;

		unsigned int data_len = er->er_data_len;

		unsigned int copy;
@@ -658,7 +658,7 @@ static int ea_write(struct gfs2_inode *ip, struct gfs2_ea_header *ea, 
		ea->ea_num_ptrs = DIV_ROUND_UP(er->er_data_len, sdp->sd_jbsize);

		for (x = 0; x < ea->ea_num_ptrs; x++) {

			struct buffer_head *bh;

			uint64_t block;

			u64 block;

			int mh_size = sizeof(struct gfs2_meta_header);



			block = gfs2_alloc_meta(ip);
@@ -676,7 +676,7 @@ static int ea_write(struct gfs2_inode *ip, struct gfs2_ea_header *ea, 
				memset(bh->b_data + mh_size + copy, 0,

				       sdp->sd_jbsize - copy);



			*dataptr++ = cpu_to_be64((uint64_t)bh->b_blocknr);

			*dataptr++ = cpu_to_be64((u64)bh->b_blocknr);

			data += copy;

			data_len -= copy;
@@ -792,10 +792,10 @@ static int ea_init(struct gfs2_inode *ip, struct gfs2_ea_request *er) 


static struct gfs2_ea_header *ea_split_ea(struct gfs2_ea_header *ea)

{

	uint32_t ea_size = GFS2_EA_SIZE(ea);

	u32 ea_size = GFS2_EA_SIZE(ea);

	struct gfs2_ea_header *new = (struct gfs2_ea_header *)((char *)ea +

				     ea_size);

	uint32_t new_size = GFS2_EA_REC_LEN(ea) - ea_size;

	u32 new_size = GFS2_EA_REC_LEN(ea) - ea_size;

	int last = ea->ea_flags & GFS2_EAFLAG_LAST;



	ea->ea_rec_len = cpu_to_be32(ea_size);
@@ -812,7 +812,7 @@ static void ea_set_remove_stuffed(struct gfs2_inode *ip, 
{

	struct gfs2_ea_header *ea = el->el_ea;

	struct gfs2_ea_header *prev = el->el_prev;

	uint32_t len;

	u32 len;



	gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
@@ -953,12 +953,12 @@ static int ea_set_block(struct gfs2_inode *ip, struct gfs2_ea_request *er, 
{

	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);

	struct buffer_head *indbh, *newbh;

	uint64_t *eablk;

	u64 *eablk;

	int error;

	int mh_size = sizeof(struct gfs2_meta_header);



	if (ip->i_di.di_flags & GFS2_DIF_EA_INDIRECT) {

		uint64_t *end;

		u64 *end;



		error = gfs2_meta_read(ip->i_gl, ip->i_di.di_eattr,

				       DIO_START | DIO_WAIT, &indbh);
@@ -970,7 +970,7 @@ static int ea_set_block(struct gfs2_inode *ip, struct gfs2_ea_request *er, 
			goto out;

		}



		eablk = (uint64_t *)(indbh->b_data + mh_size);

		eablk = (u64 *)(indbh->b_data + mh_size);

		end = eablk + sdp->sd_inptrs;



		for (; eablk < end; eablk++)
@@ -984,7 +984,7 @@ static int ea_set_block(struct gfs2_inode *ip, struct gfs2_ea_request *er, 


		gfs2_trans_add_bh(ip->i_gl, indbh, 1);

	} else {

		uint64_t blk;

		u64 blk;



		blk = gfs2_alloc_meta(ip);
@@ -993,7 +993,7 @@ static int ea_set_block(struct gfs2_inode *ip, struct gfs2_ea_request *er, 
		gfs2_metatype_set(indbh, GFS2_METATYPE_IN, GFS2_FORMAT_IN);

		gfs2_buffer_clear_tail(indbh, mh_size);



		eablk = (uint64_t *)(indbh->b_data + mh_size);

		eablk = (u64 *)(indbh->b_data + mh_size);

		*eablk = cpu_to_be64(ip->i_di.di_eattr);

		ip->i_di.di_eattr = blk;

		ip->i_di.di_flags |= GFS2_DIF_EA_INDIRECT;
@@ -1006,7 +1006,7 @@ static int ea_set_block(struct gfs2_inode *ip, struct gfs2_ea_request *er, 
	if (error)

		goto out;



	*eablk = cpu_to_be64((uint64_t)newbh->b_blocknr);

	*eablk = cpu_to_be64((u64)newbh->b_blocknr);

	error = ea_write(ip, GFS2_EA_BH2FIRST(newbh), er);

	brelse(newbh);

	if (error)
@@ -1140,7 +1140,7 @@ static int ea_remove_stuffed(struct gfs2_inode *ip, struct gfs2_ea_location *el) 
	gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);



	if (prev) {

		uint32_t len;

		u32 len;



		len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);

		prev->ea_rec_len = cpu_to_be32(len);
@@ -1225,7 +1225,7 @@ static int ea_acl_chmod_unstuffed(struct gfs2_inode *ip, 
	struct buffer_head **bh;

	unsigned int amount = GFS2_EA_DATA_LEN(ea);

	unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);

	uint64_t *dataptrs = GFS2_EA2DATAPTRS(ea);

	u64 *dataptrs = GFS2_EA2DATAPTRS(ea);

	unsigned int x;

	int error;
@@ -1325,9 +1325,9 @@ static int ea_dealloc_indirect(struct gfs2_inode *ip) 
	struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);

	struct gfs2_rgrp_list rlist;

	struct buffer_head *indbh, *dibh;

	uint64_t *eablk, *end;

	u64 *eablk, *end;

	unsigned int rg_blocks = 0;

	uint64_t bstart = 0;

	u64 bstart = 0;

	unsigned int blen = 0;

	unsigned int blks = 0;

	unsigned int x;
@@ -1345,11 +1345,11 @@ static int ea_dealloc_indirect(struct gfs2_inode *ip) 
		goto out;

	}



	eablk = (uint64_t *)(indbh->b_data + sizeof(struct gfs2_meta_header));

	eablk = (u64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));

	end = eablk + sdp->sd_inptrs;



	for (; eablk < end; eablk++) {

		uint64_t bn;

		u64 bn;



		if (!*eablk)

			break;
@@ -1390,12 +1390,12 @@ static int ea_dealloc_indirect(struct gfs2_inode *ip) 


	gfs2_trans_add_bh(ip->i_gl, indbh, 1);



	eablk = (uint64_t *)(indbh->b_data + sizeof(struct gfs2_meta_header));

	eablk = (u64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));

	bstart = 0;

	blen = 0;



	for (; eablk < end; eablk++) {

		uint64_t bn;

		u64 bn;



		if (!*eablk)

			break;