X-Git-Url: https://err.no/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=fs%2Fgfs2%2Fdir.c;h=d74a52bda540510af1f6552fd2dfa4397e0ea479;hb=2bdbc5d73961c040fdc9b30d985fab3047d697a0;hp=b0353884dd7d116b49bd33ff383555d63353c44b;hpb=71ec63c5d66b577a71910b82740751be73e81310;p=linux-2.6

diff --git a/fs/gfs2/dir.c b/fs/gfs2/dir.c
index b0353884dd..d74a52bda5 100644
--- a/fs/gfs2/dir.c
+++ b/fs/gfs2/dir.c
@@ -4,7 +4,7 @@
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
- * of the GNU General Public License v.2.
+ * of the GNU General Public License version 2.
  */
 
 /*
@@ -78,20 +78,16 @@
 #define IS_LEAF     1 /* Hashed (leaf) directory */
 #define IS_DINODE   2 /* Linear (stuffed dinode block) directory */
 
-#if 1
-#define gfs2_disk_hash2offset(h) (((uint64_t)(h)) >> 1)
-#define gfs2_dir_offset2hash(p) ((uint32_t)(((uint64_t)(p)) << 1))
-#else
-#define gfs2_disk_hash2offset(h) (((uint64_t)(h)))
-#define gfs2_dir_offset2hash(p) ((uint32_t)(((uint64_t)(p))))
-#endif
+#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,
-			    void *data);
+typedef int (*leaf_call_t) (struct gfs2_inode *dip, u32 index, u32 len, 
+			    u64 leaf_no, void *data);
+typedef int (*gfs2_dscan_t)(const struct gfs2_dirent *dent,
+			    const struct qstr *name, void *opaque);
 
 
-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;
@@ -104,7 +100,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;
@@ -156,12 +152,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;
@@ -178,7 +174,7 @@ static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf,
 		return -EINVAL;
 
 	if (gfs2_is_stuffed(ip)) {
-		error = gfs2_unstuff_dinode(ip, NULL, NULL);
+		error = gfs2_unstuff_dinode(ip, NULL);
 		if (error)
 			return error;
 	}
@@ -220,6 +216,7 @@ static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf,
 		if (error)
 			goto fail;
 
+		buf += amount;
 		copied += amount;
 		lblock++;
 		dblock++;
@@ -275,11 +272,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;
@@ -340,6 +337,7 @@ static int gfs2_dir_read_data(struct gfs2_inode *ip, char *buf,
 		if (error)
 			goto fail;
 
+		buf += amount;
 		copied += amount;
 		lblock++;
 
@@ -351,17 +349,13 @@ fail:
 	return (copied) ? copied : error;
 }
 
-typedef int (*gfs2_dscan_t)(const struct gfs2_dirent *dent,
-			    const struct qstr *name,
-			    void *opaque);
-
 static inline int __gfs2_dirent_find(const struct gfs2_dirent *dent,
 				     const struct qstr *name, int ret)
 {
 	if (dent->de_inum.no_addr != 0 &&
 	    be32_to_cpu(dent->de_hash) == name->hash &&
 	    be16_to_cpu(dent->de_name_len) == name->len &&
-	    memcmp((char *)(dent+1), name->name, name->len) == 0)
+	    memcmp(dent+1, name->name, name->len) == 0)
 		return ret;
 	return 0;
 }
@@ -486,8 +480,7 @@ wrong_type:
 	return -1;
 }
 
-static struct gfs2_dirent *gfs2_dirent_scan(struct inode *inode,
-					    void *buf,
+static struct gfs2_dirent *gfs2_dirent_scan(struct inode *inode, void *buf,
 					    unsigned int len, gfs2_dscan_t scan,
 					    const struct qstr *name,
 					    void *opaque)
@@ -503,7 +496,7 @@ static struct gfs2_dirent *gfs2_dirent_scan(struct inode *inode,
 
 	offset = ret;
 	prev = NULL;
-	dent = (struct gfs2_dirent *)(buf + offset);
+	dent = buf + offset;
 	size = be16_to_cpu(dent->de_rec_len);
 	if (gfs2_check_dirent(dent, offset, size, len, 1))
 		goto consist_inode;
@@ -515,7 +508,7 @@ static struct gfs2_dirent *gfs2_dirent_scan(struct inode *inode,
 		if (offset == len)
 			break;
 		prev = dent;
-		dent = (struct gfs2_dirent *)(buf + offset);
+		dent = buf + offset;
 		size = be16_to_cpu(dent->de_rec_len);
 		if (gfs2_check_dirent(dent, offset, size, len, 0))
 			goto consist_inode;
@@ -570,6 +563,24 @@ static int dirent_first(struct gfs2_inode *dip, struct buffer_head *bh,
 	}
 }
 
+static int dirent_check_reclen(struct gfs2_inode *dip,
+			       const struct gfs2_dirent *d, const void *end_p)
+{
+	const void *ptr = d;
+	u16 rec_len = be16_to_cpu(d->de_rec_len);
+
+	if (unlikely(rec_len < sizeof(struct gfs2_dirent)))
+		goto broken;
+	ptr += rec_len;
+	if (ptr < end_p)
+		return rec_len;
+	if (ptr == end_p)
+		return -ENOENT;
+broken:
+	gfs2_consist_inode(dip);
+	return -EIO;
+}
+
 /**
  * dirent_next - Next dirent
  * @dip: the directory
@@ -582,33 +593,18 @@ static int dirent_first(struct gfs2_inode *dip, struct buffer_head *bh,
 static int dirent_next(struct gfs2_inode *dip, struct buffer_head *bh,
 		       struct gfs2_dirent **dent)
 {
-	struct gfs2_dirent *tmp, *cur;
-	char *bh_end;
-	uint16_t cur_rec_len;
-
-	cur = *dent;
-	bh_end = bh->b_data + bh->b_size;
-	cur_rec_len = be16_to_cpu(cur->de_rec_len);
+	struct gfs2_dirent *cur = *dent, *tmp;
+	char *bh_end = bh->b_data + bh->b_size;
+	int ret;
 
-	if ((char *)cur + cur_rec_len >= bh_end) {
-		if ((char *)cur + cur_rec_len > bh_end) {
-			gfs2_consist_inode(dip);
-			return -EIO;
-		}
-		return -ENOENT;
-	}
-
-	tmp = (struct gfs2_dirent *)((char *)cur + cur_rec_len);
-
-	if ((char *)tmp + be16_to_cpu(tmp->de_rec_len) > bh_end) {
-		gfs2_consist_inode(dip);
-		return -EIO;
-	}
+	ret = dirent_check_reclen(dip, cur, bh_end);
+	if (ret < 0)
+		return ret;
 
-	if (cur_rec_len == 0) {
-		gfs2_consist_inode(dip);
-		return -EIO;
-	}
+	tmp = (void *)cur + ret;
+	ret = dirent_check_reclen(dip, tmp, bh_end);
+	if (ret == -EIO)
+		return ret;
 
         /* Only the first dent could ever have de_inum.no_addr == 0 */
 	if (!tmp->de_inum.no_addr) {
@@ -617,7 +613,6 @@ static int dirent_next(struct gfs2_inode *dip, struct buffer_head *bh,
 	}
 
 	*dent = tmp;
-
 	return 0;
 }
 
@@ -633,7 +628,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);
@@ -701,7 +696,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;
@@ -724,16 +719,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);
@@ -741,10 +736,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);
@@ -824,9 +819,9 @@ static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh,
 	gfs2_metatype_set(bh, GFS2_METATYPE_LF, GFS2_FORMAT_LF);
 	leaf = (struct gfs2_leaf *)bh->b_data;
 	leaf->lf_depth = cpu_to_be16(depth);
-	leaf->lf_entries = cpu_to_be16(0);
+	leaf->lf_entries = 0;
 	leaf->lf_dirent_format = cpu_to_be16(GFS2_FORMAT_DE);
-	leaf->lf_next = cpu_to_be64(0);
+	leaf->lf_next = 0;
 	memset(leaf->lf_reserved, 0, sizeof(leaf->lf_reserved));
 	dent = (struct gfs2_dirent *)(leaf+1);
 	gfs2_qstr2dirent(&name, bh->b_size - sizeof(struct gfs2_leaf), dent);
@@ -850,8 +845,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);
@@ -907,7 +902,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);
@@ -941,10 +936,10 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name)
 	struct gfs2_inode *dip = GFS2_I(inode);
 	struct buffer_head *nbh, *obh, *dibh;
 	struct gfs2_leaf *nleaf, *oleaf;
-	struct gfs2_dirent *dent, *prev = NULL, *next = NULL, *new;
-	uint32_t start, len, half_len, divider;
-	uint64_t bn, *lp, leaf_no;
-	uint32_t index;
+	struct gfs2_dirent *dent = NULL, *prev = NULL, *next = NULL, *new;
+	u32 start, len, half_len, divider;
+	u64 bn, *lp, leaf_no;
+	u32 index;
 	int x, moved = 0;
 	int error;
 
@@ -988,14 +983,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;
@@ -1080,15 +1075,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;
 	}
@@ -1108,7 +1103,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  */
@@ -1137,9 +1132,8 @@ static int dir_double_exhash(struct gfs2_inode *dip)
 
 	return error;
 
- fail:
+fail:
 	kfree(buf);
-
 	return error;
 }
 
@@ -1156,14 +1150,14 @@ 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;
+	const struct gfs2_dirent *dent_a, *dent_b;
+	u32 hash_a, hash_b;
 	int ret = 0;
 
-	dent_a = *(struct gfs2_dirent **)a;
+	dent_a = *(const struct gfs2_dirent **)a;
 	hash_a = be32_to_cpu(dent_a->de_hash);
 
-	dent_b = *(struct gfs2_dirent **)b;
+	dent_b = *(const struct gfs2_dirent **)b;
 	hash_b = be32_to_cpu(dent_b->de_hash);
 
 	if (hash_a > hash_b)
@@ -1179,9 +1173,7 @@ static int compare_dents(const void *a, const void *b)
 		else if (len_a < len_b)
 			ret = -1;
 		else
-			ret = memcmp((char *)(dent_a + 1),
-				     (char *)(dent_b + 1),
-				     len_a);
+			ret = memcmp(dent_a + 1, dent_b + 1, len_a);
 	}
 
 	return ret;
@@ -1205,14 +1197,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;
@@ -1250,7 +1242,7 @@ static int do_filldir_main(struct gfs2_inode *dip, uint64_t *offset,
 
 		gfs2_inum_in(&inum, (char *)&dent->de_inum);
 
-		error = filldir(opaque, (char *)(dent + 1),
+		error = filldir(opaque, (const char *)(dent + 1),
 				be16_to_cpu(dent->de_name_len),
 				off, &inum,
 				be16_to_cpu(dent->de_type));
@@ -1302,7 +1294,7 @@ static int gfs2_dir_read_leaf(struct inode *inode, u64 *offset, void *opaque,
 		return 0;
 
 	error = -ENOMEM;
-	larr = vmalloc((leaves + entries) * sizeof(void*));
+	larr = vmalloc((leaves + entries) * sizeof(void *));
 	if (!larr)
 		goto out;
 	darr = (const struct gfs2_dirent **)(larr + leaves);
@@ -1350,21 +1342,21 @@ out:
  * 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;
+	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;
 	}
@@ -1382,7 +1374,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)
@@ -1409,7 +1401,7 @@ out:
 	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);
@@ -1729,15 +1721,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;
 	}
@@ -1752,7 +1744,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)
@@ -1768,9 +1760,8 @@ static int foreach_leaf(struct gfs2_inode *dip, leaf_call_t lc, void *data)
 			if (error)
 				goto out;
 			leaf = (struct gfs2_leaf *)bh->b_data;
-			brelse(bh);
-
 			len = 1 << (dip->i_di.di_depth - be16_to_cpu(leaf->lf_depth));
+			brelse(bh);
 
 			error = lc(dip, index, len, leaf_no, data);
 			if (error)
@@ -1786,7 +1777,7 @@ static int foreach_leaf(struct gfs2_inode *dip, leaf_call_t lc, void *data)
 		error = -EIO;
 	}
 
- out:
+out:
 	kfree(lp);
 
 	return error;
@@ -1803,17 +1794,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));
@@ -1879,7 +1870,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;
@@ -1894,23 +1885,18 @@ static int leaf_dealloc(struct gfs2_inode *dip, uint32_t index, uint32_t len,
 	gfs2_dinode_out(&dip->i_di, dibh->b_data);
 	brelse(dibh);
 
- out_end_trans:
+out_end_trans:
 	gfs2_trans_end(sdp);
-
- out_rg_gunlock:
+out_rg_gunlock:
 	gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
-
- out_rlist:
+out_rlist:
 	gfs2_rlist_free(&rlist);
 	gfs2_glock_dq_uninit(&dip->i_alloc.al_ri_gh);
-
- out_qs:
+out_qs:
 	gfs2_quota_unhold(dip);
-
- out:
+out:
 	gfs2_alloc_put(dip);
 	kfree(ht);
-
 	return error;
 }