[GFS2] Reduce inode size by moving i_alloc out of line
[linux-2.6.git] / fs / gfs2 / dir.c
index ffc1bef..57e2ed9 100644 (file)
@@ -1,10 +1,10 @@
 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
- * Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
+ * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
  *
  * 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.
  */
 
 /*
@@ -53,7 +53,6 @@
  * but never before the maximum hash table size has been reached.
  */
 
-#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 #include <linux/buffer_head.h>
@@ -61,9 +60,9 @@
 #include <linux/gfs2_ondisk.h>
 #include <linux/crc32.h>
 #include <linux/vmalloc.h>
+#include <linux/lm_interface.h>
 
 #include "gfs2.h"
-#include "lm_interface.h"
 #include "incore.h"
 #include "dir.h"
 #include "glock.h"
 #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,16 +99,16 @@ 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;
        int error;
 
-       error = gfs2_meta_read(ip->i_gl, block, DIO_START | DIO_WAIT, &bh);
+       error = gfs2_meta_read(ip->i_gl, block, DIO_WAIT, &bh);
        if (error)
                return error;
-       if (gfs2_metatype_check(ip->i_sbd, bh, GFS2_METATYPE_JD)) {
+       if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_JD)) {
                brelse(bh);
                return -EIO;
        }
@@ -123,7 +118,6 @@ static int gfs2_dir_get_existing_buffer(struct gfs2_inode *ip, uint64_t block,
 
 static int gfs2_dir_write_stuffed(struct gfs2_inode *ip, const char *buf,
                                  unsigned int offset, unsigned int size)
-                               
 {
        struct buffer_head *dibh;
        int error;
@@ -136,8 +130,8 @@ static int gfs2_dir_write_stuffed(struct gfs2_inode *ip, const char *buf,
        memcpy(dibh->b_data + offset + sizeof(struct gfs2_dinode), buf, size);
        if (ip->i_di.di_size < offset + size)
                ip->i_di.di_size = offset + size;
-       ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds();
-       gfs2_dinode_out(&ip->i_di, dibh->b_data);
+       ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
+       gfs2_dinode_out(ip, dibh->b_data);
 
        brelse(dibh);
 
@@ -156,12 +150,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 = ip->i_sbd;
+       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 +172,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;
        }
@@ -189,7 +183,7 @@ static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf,
        while (copied < size) {
                unsigned int amount;
                struct buffer_head *bh;
-               int new;
+               int new = 0;
 
                amount = size - copied;
                if (amount > sdp->sd_sb.sb_bsize - o)
@@ -197,8 +191,8 @@ static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf,
 
                if (!extlen) {
                        new = 1;
-                       error = gfs2_block_map(ip, lblock, &new, &dblock,
-                                              &extlen);
+                       error = gfs2_extent_map(&ip->i_inode, lblock, &new,
+                                               &dblock, &extlen);
                        if (error)
                                goto fail;
                        error = -EIO;
@@ -217,9 +211,8 @@ static int gfs2_dir_write_data(struct gfs2_inode *ip, const char *buf,
                gfs2_trans_add_bh(ip->i_gl, bh, 1);
                memcpy(bh->b_data + o, buf, amount);
                brelse(bh);
-               if (error)
-                       goto fail;
 
+               buf += amount;
                copied += amount;
                lblock++;
                dblock++;
@@ -235,10 +228,10 @@ out:
 
        if (ip->i_di.di_size < offset + copied)
                ip->i_di.di_size = offset + copied;
-       ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds();
+       ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
 
        gfs2_trans_add_bh(ip->i_gl, dibh, 1);
-       gfs2_dinode_out(&ip->i_di, dibh->b_data);
+       gfs2_dinode_out(ip, dibh->b_data);
        brelse(dibh);
 
        return copied;
@@ -249,7 +242,7 @@ fail:
 }
 
 static int gfs2_dir_read_stuffed(struct gfs2_inode *ip, char *buf,
-                                unsigned int offset, unsigned int size)
+                                u64 offset, unsigned int size)
 {
        struct buffer_head *dibh;
        int error;
@@ -274,12 +267,12 @@ 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)
+static int gfs2_dir_read_data(struct gfs2_inode *ip, char *buf, u64 offset,
+                             unsigned int size, unsigned ra)
 {
-       struct gfs2_sbd *sdp = ip->i_sbd;
-       uint64_t lblock, dblock;
-       uint32_t extlen = 0;
+       struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
+       u64 lblock, dblock;
+       u32 extlen = 0;
        unsigned int o;
        int copied = 0;
        int error = 0;
@@ -287,15 +280,14 @@ static int gfs2_dir_read_data(struct gfs2_inode *ip, char *buf,
        if (offset >= ip->i_di.di_size)
                return 0;
 
-       if ((offset + size) > ip->i_di.di_size)
+       if (offset + size > ip->i_di.di_size)
                size = ip->i_di.di_size - offset;
 
        if (!size)
                return 0;
 
        if (gfs2_is_stuffed(ip))
-               return gfs2_dir_read_stuffed(ip, buf, (unsigned int)offset,
-                                            size);
+               return gfs2_dir_read_stuffed(ip, buf, offset, size);
 
        if (gfs2_assert_warn(sdp, gfs2_is_jdata(ip)))
                return -EINVAL;
@@ -314,35 +306,31 @@ static int gfs2_dir_read_data(struct gfs2_inode *ip, char *buf,
 
                if (!extlen) {
                        new = 0;
-                       error = gfs2_block_map(ip, lblock, &new, &dblock,
-                                              &extlen);
-                       if (error)
+                       error = gfs2_extent_map(&ip->i_inode, lblock, &new,
+                                               &dblock, &extlen);
+                       if (error || !dblock)
                                goto fail;
-               }
-
-               if (extlen > 1)
-                       gfs2_meta_ra(ip->i_gl, dblock, extlen);
-
-               if (dblock) {
-                       if (new)
-                               error = gfs2_dir_get_new_buffer(ip, dblock, &bh);
-                       else
-                               error = gfs2_dir_get_existing_buffer(ip, dblock, &bh);
+                       BUG_ON(extlen < 1);
+                       if (!ra)
+                               extlen = 1;
+                       bh = gfs2_meta_ra(ip->i_gl, dblock, extlen);
+               } else {
+                       error = gfs2_meta_read(ip->i_gl, dblock, DIO_WAIT, &bh);
                        if (error)
                                goto fail;
-                       dblock++;
-                       extlen--;
-               } else
-                       bh = NULL;
-
+               }
+               error = gfs2_metatype_check(sdp, bh, GFS2_METATYPE_JD);
+               if (error) {
+                       brelse(bh);
+                       goto fail;
+               }
+               dblock++;
+               extlen--;
                memcpy(buf, bh->b_data + o, amount);
                brelse(bh);
-               if (error)
-                       goto fail;
-
+               buf += amount;
                copied += amount;
                lblock++;
-
                o = sizeof(struct gfs2_meta_header);
        }
 
@@ -351,17 +339,18 @@ 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_sentinel(const struct gfs2_dirent *dent)
+{
+       return dent->de_inum.no_addr == 0 || dent->de_inum.no_formal_ino == 0;
+}
 
 static inline int __gfs2_dirent_find(const struct gfs2_dirent *dent,
                                     const struct qstr *name, int ret)
 {
-       if (dent->de_inum.no_addr != 0 &&
+       if (!gfs2_dirent_sentinel(dent) &&
            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;
 }
@@ -403,9 +392,9 @@ static int gfs2_dirent_find_space(const struct gfs2_dirent *dent,
        unsigned actual = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));
        unsigned totlen = be16_to_cpu(dent->de_rec_len);
 
-       if (!dent->de_inum.no_addr)
+       if (gfs2_dirent_sentinel(dent))
                actual = GFS2_DIRENT_SIZE(0);
-       if ((totlen - actual) >= required)
+       if (totlen - actual >= required)
                return 1;
        return 0;
 }
@@ -420,7 +409,7 @@ static int gfs2_dirent_gather(const struct gfs2_dirent *dent,
                              void *opaque)
 {
        struct dirent_gather *g = opaque;
-       if (dent->de_inum.no_addr) {
+       if (!gfs2_dirent_sentinel(dent)) {
                g->pdent[g->offset++] = dent;
        }
        return 0;
@@ -448,10 +437,10 @@ static int gfs2_check_dirent(struct gfs2_dirent *dent, unsigned int offset,
        if (unlikely(offset + size > len))
                goto error;
        msg = "zero inode number";
-       if (unlikely(!first && !dent->de_inum.no_addr))
+       if (unlikely(!first && gfs2_dirent_sentinel(dent)))
                goto error;
        msg = "name length is greater than space in dirent";
-       if (dent->de_inum.no_addr &&
+       if (!gfs2_dirent_sentinel(dent) &&
            unlikely(sizeof(struct gfs2_dirent)+be16_to_cpu(dent->de_name_len) >
                     size))
                goto error;
@@ -486,8 +475,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 +491,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 +503,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;
@@ -534,7 +522,7 @@ static struct gfs2_dirent *gfs2_dirent_scan(struct inode *inode,
        }
 
 consist_inode:
-       gfs2_consist_inode(inode->u.generic_ip);
+       gfs2_consist_inode(GFS2_I(inode));
        return ERR_PTR(-EIO);
 }
 
@@ -556,13 +544,13 @@ static int dirent_first(struct gfs2_inode *dip, struct buffer_head *bh,
        struct gfs2_meta_header *h = (struct gfs2_meta_header *)bh->b_data;
 
        if (be32_to_cpu(h->mh_type) == GFS2_METATYPE_LF) {
-               if (gfs2_meta_check(dip->i_sbd, bh))
+               if (gfs2_meta_check(GFS2_SB(&dip->i_inode), bh))
                        return -EIO;
                *dent = (struct gfs2_dirent *)(bh->b_data +
                                               sizeof(struct gfs2_leaf));
                return IS_LEAF;
        } else {
-               if (gfs2_metatype_check(dip->i_sbd, bh, GFS2_METATYPE_DI))
+               if (gfs2_metatype_check(GFS2_SB(&dip->i_inode), bh, GFS2_METATYPE_DI))
                        return -EIO;
                *dent = (struct gfs2_dirent *)(bh->b_data +
                                               sizeof(struct gfs2_dinode));
@@ -570,6 +558,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,42 +588,26 @@ 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;
+       struct gfs2_dirent *cur = *dent, *tmp;
+       char *bh_end = bh->b_data + bh->b_size;
+       int ret;
 
-       cur = *dent;
-       bh_end = bh->b_data + bh->b_size;
-       cur_rec_len = be16_to_cpu(cur->de_rec_len);
-
-       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) {
+       if (gfs2_dirent_sentinel(tmp)) {
                gfs2_consist_inode(dip);
                return -EIO;
        }
 
        *dent = tmp;
-
        return 0;
 }
 
@@ -633,9 +623,9 @@ 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) {
+       if (gfs2_dirent_sentinel(cur)) {
                gfs2_consist_inode(dip);
                return;
        }
@@ -647,7 +637,8 @@ static void dirent_del(struct gfs2_inode *dip, struct buffer_head *bh,
           out the inode number and return.  */
 
        if (!prev) {
-               cur->de_inum.no_addr = 0;       /* No endianess worries */
+               cur->de_inum.no_addr = 0;
+               cur->de_inum.no_formal_ino = 0;
                return;
        }
 
@@ -669,16 +660,16 @@ static void dirent_del(struct gfs2_inode *dip, struct buffer_head *bh,
  * Takes a dent from which to grab space as an argument. Returns the
  * newly created dent.
  */
-struct gfs2_dirent *gfs2_init_dirent(struct inode *inode,
-                                    struct gfs2_dirent *dent,
-                                    const struct qstr *name,
-                                    struct buffer_head *bh)
+static struct gfs2_dirent *gfs2_init_dirent(struct inode *inode,
+                                           struct gfs2_dirent *dent,
+                                           const struct qstr *name,
+                                           struct buffer_head *bh)
 {
-       struct gfs2_inode *ip = inode->u.generic_ip;
+       struct gfs2_inode *ip = GFS2_I(inode);
        struct gfs2_dirent *ndent;
        unsigned offset = 0, totlen;
 
-       if (dent->de_inum.no_addr)
+       if (!gfs2_dirent_sentinel(dent))
                offset = GFS2_DIRENT_SIZE(be16_to_cpu(dent->de_name_len));
        totlen = be16_to_cpu(dent->de_rec_len);
        BUG_ON(offset + name->len > totlen);
@@ -694,21 +685,23 @@ static struct gfs2_dirent *gfs2_dirent_alloc(struct inode *inode,
                                             const struct qstr *name)
 {
        struct gfs2_dirent *dent;
-       dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size, 
+       dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
                                gfs2_dirent_find_space, name, NULL);
        if (!dent || IS_ERR(dent))
                return dent;
        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;
 
-       error = gfs2_meta_read(dip->i_gl, leaf_no, DIO_START | DIO_WAIT, bhp);
-       if (!error && gfs2_metatype_check(dip->i_sbd, *bhp, GFS2_METATYPE_LF))
+       error = gfs2_meta_read(dip->i_gl, leaf_no, DIO_WAIT, bhp);
+       if (!error && gfs2_metatype_check(GFS2_SB(&dip->i_inode), *bhp, GFS2_METATYPE_LF)) {
+               /* printk(KERN_INFO "block num=%llu\n", leaf_no); */
                error = -EIO;
+       }
 
        return error;
 }
@@ -722,16 +715,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;
+       __be64 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(__be64),
+                                   sizeof(__be64), 0);
+       if (error != sizeof(u64))
                return (error < 0) ? error : -EIO;
 
        *leaf_out = be64_to_cpu(leaf_no);
@@ -739,10 +732,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);
@@ -759,7 +752,7 @@ static struct gfs2_dirent *gfs2_dirent_search(struct inode *inode,
 {
        struct buffer_head *bh;
        struct gfs2_dirent *dent;
-       struct gfs2_inode *ip = inode->u.generic_ip;
+       struct gfs2_inode *ip = GFS2_I(inode);
        int error;
 
        if (ip->i_di.di_flags & GFS2_DIF_EXHASH) {
@@ -786,12 +779,14 @@ static struct gfs2_dirent *gfs2_dirent_search(struct inode *inode,
                        brelse(bh);
                        if (!ln)
                                break;
+
                        error = get_leaf(ip, ln, &bh);
                } while(!error);
 
                return error ? ERR_PTR(error) : NULL;
        }
 
+
        error = gfs2_meta_inode_buffer(ip, &bh);
        if (error)
                return ERR_PTR(error);
@@ -807,7 +802,7 @@ got_dent:
 
 static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh, u16 depth)
 {
-       struct gfs2_inode *ip = inode->u.generic_ip;
+       struct gfs2_inode *ip = GFS2_I(inode);
        u64 bn = gfs2_alloc_meta(ip);
        struct buffer_head *bh = gfs2_meta_new(ip->i_gl, bn);
        struct gfs2_leaf *leaf;
@@ -815,13 +810,14 @@ static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh,
        struct qstr name = { .name = "", .len = 0, .hash = 0 };
        if (!bh)
                return NULL;
+
        gfs2_trans_add_bh(ip->i_gl, bh, 1);
        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_dirent_format = cpu_to_be16(GFS2_FORMAT_DE);
-       leaf->lf_next = cpu_to_be64(0);
+       leaf->lf_entries = 0;
+       leaf->lf_dirent_format = cpu_to_be32(GFS2_FORMAT_DE);
+       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);
@@ -838,15 +834,16 @@ static struct gfs2_leaf *new_leaf(struct inode *inode, struct buffer_head **pbh,
 
 static int dir_make_exhash(struct inode *inode)
 {
-       struct gfs2_inode *dip = inode->u.generic_ip;
-       struct gfs2_sbd *sdp = dip->i_sbd;
+       struct gfs2_inode *dip = GFS2_I(inode);
+       struct gfs2_sbd *sdp = GFS2_SB(inode);
        struct gfs2_dirent *dent;
        struct qstr args;
        struct buffer_head *bh, *dibh;
        struct gfs2_leaf *leaf;
        int y;
-       uint32_t x;
-       uint64_t *lp, bn;
+       u32 x;
+       __be64 *lp;
+       u64 bn;
        int error;
 
        error = gfs2_meta_inode_buffer(dip, &dibh);
@@ -874,7 +871,7 @@ static int dir_make_exhash(struct inode *inode)
        args.len = bh->b_size - sizeof(struct gfs2_dinode) +
                   sizeof(struct gfs2_leaf);
        args.name = bh->b_data;
-       dent = gfs2_dirent_scan(dip->i_vnode, bh->b_data, bh->b_size,
+       dent = gfs2_dirent_scan(&dip->i_inode, bh->b_data, bh->b_size,
                                gfs2_dirent_last, &args, NULL);
        if (!dent) {
                brelse(bh);
@@ -902,20 +899,20 @@ 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 = (__be64 *)(dibh->b_data + sizeof(struct gfs2_dinode));
 
        for (x = sdp->sd_hash_ptrs; x--; lp++)
                *lp = cpu_to_be64(bn);
 
        dip->i_di.di_size = sdp->sd_sb.sb_bsize / 2;
        dip->i_di.di_blocks++;
+       gfs2_set_inode_blocks(&dip->i_inode);
        dip->i_di.di_flags |= GFS2_DIF_EXHASH;
-       dip->i_di.di_payload_format = 0;
 
        for (x = sdp->sd_hash_ptrs, y = -1; x; x >>= 1, y++) ;
        dip->i_di.di_depth = y;
 
-       gfs2_dinode_out(&dip->i_di, dibh->b_data);
+       gfs2_dinode_out(dip, dibh->b_data);
 
        brelse(dibh);
 
@@ -933,13 +930,14 @@ static int dir_make_exhash(struct inode *inode)
 
 static int dir_split_leaf(struct inode *inode, const struct qstr *name)
 {
-       struct gfs2_inode *dip = inode->u.generic_ip;
+       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, leaf_no;
+       __be64 *lp;
+       u32 index;
        int x, moved = 0;
        int error;
 
@@ -983,14 +981,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(__be64), 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;
@@ -1009,7 +1007,7 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name)
                if (dirent_next(dip, obh, &next))
                        next = NULL;
 
-               if (dent->de_inum.no_addr &&
+               if (!gfs2_dirent_sentinel(dent) &&
                    be32_to_cpu(dent->de_hash) < divider) {
                        struct qstr str;
                        str.name = (char*)(dent+1);
@@ -1044,9 +1042,11 @@ static int dir_split_leaf(struct inode *inode, const struct qstr *name)
        oleaf->lf_depth = nleaf->lf_depth;
 
        error = gfs2_meta_inode_buffer(dip, &dibh);
-       if (!gfs2_assert_withdraw(dip->i_sbd, !error)) {
+       if (!gfs2_assert_withdraw(GFS2_SB(&dip->i_inode), !error)) {
+               gfs2_trans_add_bh(dip->i_gl, dibh, 1);
                dip->i_di.di_blocks++;
-               gfs2_dinode_out(&dip->i_di, dibh->b_data);
+               gfs2_set_inode_blocks(&dip->i_inode);
+               gfs2_dinode_out(dip, dibh->b_data);
                brelse(dibh);
        }
 
@@ -1073,17 +1073,17 @@ fail_brelse:
 
 static int dir_double_exhash(struct gfs2_inode *dip)
 {
-       struct gfs2_sbd *sdp = dip->i_sbd;
+       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;
        }
@@ -1095,7 +1095,7 @@ static int dir_double_exhash(struct gfs2_inode *dip)
        for (block = dip->i_di.di_size >> sdp->sd_hash_bsize_shift; block--;) {
                error = gfs2_dir_read_data(dip, (char *)buf,
                                            block * sdp->sd_hash_bsize,
-                                           sdp->sd_hash_bsize);
+                                           sdp->sd_hash_bsize, 1);
                if (error != sdp->sd_hash_bsize) {
                        if (error >= 0)
                                error = -EIO;
@@ -1103,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  */
@@ -1126,15 +1126,14 @@ static int dir_double_exhash(struct gfs2_inode *dip)
        error = gfs2_meta_inode_buffer(dip, &dibh);
        if (!gfs2_assert_withdraw(sdp, !error)) {
                dip->i_di.di_depth++;
-               gfs2_dinode_out(&dip->i_di, dibh->b_data);
+               gfs2_dinode_out(dip, dibh->b_data);
                brelse(dibh);
        }
 
        return error;
 
- fail:
+fail:
        kfree(buf);
-
        return error;
 }
 
@@ -1151,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)
@@ -1174,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;
@@ -1200,14 +1197,13 @@ 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,
-                          void *opaque, gfs2_filldir_t filldir,
-                          const struct gfs2_dirent **darr, uint32_t entries,
+static int do_filldir_main(struct gfs2_inode *dip, u64 *offset,
+                          void *opaque, filldir_t filldir,
+                          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;
@@ -1243,11 +1239,9 @@ static int do_filldir_main(struct gfs2_inode *dip, uint64_t *offset,
                        *offset = off;
                }
 
-               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,
+                               off, be64_to_cpu(dent->de_inum.no_addr),
                                be16_to_cpu(dent->de_type));
                if (error)
                        return 1;
@@ -1265,13 +1259,14 @@ static int do_filldir_main(struct gfs2_inode *dip, uint64_t *offset,
 }
 
 static int gfs2_dir_read_leaf(struct inode *inode, u64 *offset, void *opaque,
-                             gfs2_filldir_t filldir, int *copied,
-                             unsigned *depth, u64 leaf_no)
+                             filldir_t filldir, int *copied, unsigned *depth,
+                             u64 leaf_no)
 {
-       struct gfs2_inode *ip = inode->u.generic_ip;
+       struct gfs2_inode *ip = GFS2_I(inode);
+       struct gfs2_sbd *sdp = GFS2_SB(inode);
        struct buffer_head *bh;
        struct gfs2_leaf *lf;
-       unsigned entries = 0;
+       unsigned entries = 0, entries2 = 0;
        unsigned leaves = 0;
        const struct gfs2_dirent **darr, *dent;
        struct dirent_gather g;
@@ -1297,7 +1292,13 @@ static int gfs2_dir_read_leaf(struct inode *inode, u64 *offset, void *opaque,
                return 0;
 
        error = -ENOMEM;
-       larr = vmalloc((leaves + entries) * sizeof(void*));
+       /*
+        * The extra 99 entries are not normally used, but are a buffer
+        * zone in case the number of entries in the leaf is corrupt.
+        * 99 is the maximum number of entries that can fit in a single
+        * leaf block.
+        */
+       larr = vmalloc((leaves + entries + 99) * sizeof(void *));
        if (!larr)
                goto out;
        darr = (const struct gfs2_dirent **)(larr + leaves);
@@ -1312,10 +1313,20 @@ static int gfs2_dir_read_leaf(struct inode *inode, u64 *offset, void *opaque,
                lf = (struct gfs2_leaf *)bh->b_data;
                lfn = be64_to_cpu(lf->lf_next);
                if (lf->lf_entries) {
+                       entries2 += be16_to_cpu(lf->lf_entries);
                        dent = gfs2_dirent_scan(inode, bh->b_data, bh->b_size,
                                                gfs2_dirent_gather, NULL, &g);
                        error = PTR_ERR(dent);
-                       if (IS_ERR(dent)) {
+                       if (IS_ERR(dent))
+                               goto out_kfree;
+                       if (entries2 != g.offset) {
+                               fs_warn(sdp, "Number of entries corrupt in dir "
+                                               "leaf %llu, entries2 (%u) != "
+                                               "g.offset (%u)\n",
+                                       (unsigned long long)bh->b_blocknr,
+                                       entries2, g.offset);
+                                       
+                               error = -EIO;
                                goto out_kfree;
                        }
                        error = 0;
@@ -1325,6 +1336,7 @@ static int gfs2_dir_read_leaf(struct inode *inode, u64 *offset, void *opaque,
                }
        } while(lfn);
 
+       BUG_ON(entries2 != entries);
        error = do_filldir_main(ip, offset, opaque, filldir, darr,
                                entries, copied);
 out_kfree:
@@ -1345,21 +1357,21 @@ out:
  * Returns: errno
  */
 
-static int dir_e_read(struct inode *inode, uint64_t *offset, void *opaque,
-                     gfs2_filldir_t filldir)
+static int dir_e_read(struct inode *inode, u64 *offset, void *opaque,
+                     filldir_t filldir)
 {
-       struct gfs2_inode *dip = inode->u.generic_ip;
-       struct gfs2_sbd *sdp = dip->i_sbd;
-       uint32_t hsize, len = 0;
-       uint32_t ht_offset, lp_offset, ht_offset_cur = -1;
-       uint32_t hash, index;
-       uint64_t *lp;
+       struct gfs2_inode *dip = GFS2_I(inode);
+       struct gfs2_sbd *sdp = GFS2_SB(inode);
+       u32 hsize, len = 0;
+       u32 ht_offset, lp_offset, ht_offset_cur = -1;
+       u32 hash, index;
+       __be64 *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;
        }
@@ -1377,8 +1389,8 @@ 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),
-                                               sdp->sd_hash_bsize);
+                                               ht_offset * sizeof(__be64),
+                                               sdp->sd_hash_bsize, 1);
                        if (error != sdp->sd_hash_bsize) {
                                if (error >= 0)
                                        error = -EIO;
@@ -1404,10 +1416,11 @@ out:
        return error;
 }
 
-int gfs2_dir_read(struct inode *inode, uint64_t *offset, void *opaque,
-                 gfs2_filldir_t filldir)
+int gfs2_dir_read(struct inode *inode, u64 *offset, void *opaque,
+                 filldir_t filldir)
 {
-       struct gfs2_inode *dip = inode->u.generic_ip;
+       struct gfs2_inode *dip = GFS2_I(inode);
+       struct gfs2_sbd *sdp = GFS2_SB(inode);
        struct dirent_gather g;
        const struct gfs2_dirent **darr, *dent;
        struct buffer_head *dibh;
@@ -1430,8 +1443,8 @@ int gfs2_dir_read(struct inode *inode, uint64_t *offset, void *opaque,
                return error;
 
        error = -ENOMEM;
-       darr = kmalloc(dip->i_di.di_entries * sizeof(struct gfs2_dirent *),
-                      GFP_KERNEL);
+       /* 96 is max number of dirents which can be stuffed into an inode */
+       darr = kmalloc(96 * sizeof(struct gfs2_dirent *), GFP_KERNEL);
        if (darr) {
                g.pdent = darr;
                g.offset = 0;
@@ -1441,6 +1454,15 @@ int gfs2_dir_read(struct inode *inode, uint64_t *offset, void *opaque,
                        error = PTR_ERR(dent);
                        goto out;
                }
+               if (dip->i_di.di_entries != g.offset) {
+                       fs_warn(sdp, "Number of entries corrupt in dir %llu, "
+                               "ip->i_di.di_entries (%u) != g.offset (%u)\n",
+                               (unsigned long long)dip->i_no_addr,
+                               dip->i_di.di_entries,
+                               g.offset);
+                       error = -EIO;
+                       goto out;
+               }
                error = do_filldir_main(dip, offset, opaque, filldir, darr,
                                        dip->i_di.di_entries, &copied);
 out:
@@ -1467,30 +1489,61 @@ out:
  * Returns: errno
  */
 
-int gfs2_dir_search(struct inode *dir, const struct qstr *name,
-                   struct gfs2_inum *inum, unsigned int *type)
+struct inode *gfs2_dir_search(struct inode *dir, const struct qstr *name)
 {
        struct buffer_head *bh;
        struct gfs2_dirent *dent;
+       struct inode *inode;
+
+       dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
+       if (dent) {
+               if (IS_ERR(dent))
+                       return ERR_PTR(PTR_ERR(dent));
+               inode = gfs2_inode_lookup(dir->i_sb, 
+                               be16_to_cpu(dent->de_type),
+                               be64_to_cpu(dent->de_inum.no_addr),
+                               be64_to_cpu(dent->de_inum.no_formal_ino), 0);
+               brelse(bh);
+               return inode;
+       }
+       return ERR_PTR(-ENOENT);
+}
+
+int gfs2_dir_check(struct inode *dir, const struct qstr *name,
+                  const struct gfs2_inode *ip)
+{
+       struct buffer_head *bh;
+       struct gfs2_dirent *dent;
+       int ret = -ENOENT;
 
        dent = gfs2_dirent_search(dir, name, gfs2_dirent_find, &bh);
        if (dent) {
                if (IS_ERR(dent))
                        return PTR_ERR(dent);
-               if (inum)
-                       gfs2_inum_in(inum, (char *)&dent->de_inum);
-               if (type)
-                       *type = be16_to_cpu(dent->de_type);
+               if (ip) {
+                       if (be64_to_cpu(dent->de_inum.no_addr) != ip->i_no_addr)
+                               goto out;
+                       if (be64_to_cpu(dent->de_inum.no_formal_ino) !=
+                           ip->i_no_formal_ino)
+                               goto out;
+                       if (unlikely(IF2DT(ip->i_inode.i_mode) !=
+                           be16_to_cpu(dent->de_type))) {
+                               gfs2_consist_inode(GFS2_I(dir));
+                               ret = -EIO;
+                               goto out;
+                       }
+               }
+               ret = 0;
+out:
                brelse(bh);
-               return 0;
        }
-       return -ENOENT;
+       return ret;
 }
 
 static int dir_new_leaf(struct inode *inode, const struct qstr *name)
 {
        struct buffer_head *bh, *obh;
-       struct gfs2_inode *ip = inode->u.generic_ip;
+       struct gfs2_inode *ip = GFS2_I(inode);
        struct gfs2_leaf *leaf, *oleaf;
        int error;
        u32 index;
@@ -1527,7 +1580,8 @@ static int dir_new_leaf(struct inode *inode, const struct qstr *name)
                return error;
        gfs2_trans_add_bh(ip->i_gl, bh, 1);
        ip->i_di.di_blocks++;
-       gfs2_dinode_out(&ip->i_di, bh->b_data);
+       gfs2_set_inode_blocks(&ip->i_inode);
+       gfs2_dinode_out(ip, bh->b_data);
        brelse(bh);
        return 0;
 }
@@ -1543,9 +1597,9 @@ static int dir_new_leaf(struct inode *inode, const struct qstr *name)
  */
 
 int gfs2_dir_add(struct inode *inode, const struct qstr *name,
-                const struct gfs2_inum *inum, unsigned type)
+                const struct gfs2_inode *nip, unsigned type)
 {
-       struct gfs2_inode *ip = inode->u.generic_ip;
+       struct gfs2_inode *ip = GFS2_I(inode);
        struct buffer_head *bh;
        struct gfs2_dirent *dent;
        struct gfs2_leaf *leaf;
@@ -1558,7 +1612,7 @@ int gfs2_dir_add(struct inode *inode, const struct qstr *name,
                        if (IS_ERR(dent))
                                return PTR_ERR(dent);
                        dent = gfs2_init_dirent(inode, dent, name, bh);
-                       gfs2_inum_out(inum, (char *)&dent->de_inum);
+                       gfs2_inum_out(nip, dent);
                        dent->de_type = cpu_to_be16(type);
                        if (ip->i_di.di_flags & GFS2_DIF_EXHASH) {
                                leaf = (struct gfs2_leaf *)bh->b_data;
@@ -1570,8 +1624,8 @@ int gfs2_dir_add(struct inode *inode, const struct qstr *name,
                                break;
                        gfs2_trans_add_bh(ip->i_gl, bh, 1);
                        ip->i_di.di_entries++;
-                       ip->i_di.di_mtime = ip->i_di.di_ctime = get_seconds();
-                       gfs2_dinode_out(&ip->i_di, bh->b_data);
+                       ip->i_inode.i_mtime = ip->i_inode.i_ctime = CURRENT_TIME;
+                       gfs2_dinode_out(ip, bh->b_data);
                        brelse(bh);
                        error = 0;
                        break;
@@ -1623,7 +1677,7 @@ int gfs2_dir_del(struct gfs2_inode *dip, const struct qstr *name)
 
        /* Returns _either_ the entry (if its first in block) or the
           previous entry otherwise */
-       dent = gfs2_dirent_search(dip->i_vnode, name, gfs2_dirent_prev, &bh);
+       dent = gfs2_dirent_search(&dip->i_inode, name, gfs2_dirent_prev, &bh);
        if (!dent) {
                gfs2_consist_inode(dip);
                return -EIO;
@@ -1656,9 +1710,10 @@ int gfs2_dir_del(struct gfs2_inode *dip, const struct qstr *name)
                gfs2_consist_inode(dip);
        gfs2_trans_add_bh(dip->i_gl, bh, 1);
        dip->i_di.di_entries--;
-       dip->i_di.di_mtime = dip->i_di.di_ctime = get_seconds();
-       gfs2_dinode_out(&dip->i_di, bh->b_data);
+       dip->i_inode.i_mtime = dip->i_inode.i_ctime = CURRENT_TIME;
+       gfs2_dinode_out(dip, bh->b_data);
        brelse(bh);
+       mark_inode_dirty(&dip->i_inode);
 
        return error;
 }
@@ -1677,13 +1732,13 @@ int gfs2_dir_del(struct gfs2_inode *dip, const struct qstr *name)
  */
 
 int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
-                  struct gfs2_inum *inum, unsigned int new_type)
+                  const struct gfs2_inode *nip, unsigned int new_type)
 {
        struct buffer_head *bh;
        struct gfs2_dirent *dent;
        int error;
 
-       dent = gfs2_dirent_search(dip->i_vnode, filename, gfs2_dirent_find, &bh);
+       dent = gfs2_dirent_search(&dip->i_inode, filename, gfs2_dirent_find, &bh);
        if (!dent) {
                gfs2_consist_inode(dip);
                return -EIO;
@@ -1692,7 +1747,7 @@ int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
                return PTR_ERR(dent);
 
        gfs2_trans_add_bh(dip->i_gl, bh, 1);
-       gfs2_inum_out(inum, (char *)&dent->de_inum);
+       gfs2_inum_out(nip, dent);
        dent->de_type = cpu_to_be16(new_type);
 
        if (dip->i_di.di_flags & GFS2_DIF_EXHASH) {
@@ -1703,8 +1758,8 @@ int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
                gfs2_trans_add_bh(dip->i_gl, bh, 1);
        }
 
-       dip->i_di.di_mtime = dip->i_di.di_ctime = get_seconds();
-       gfs2_dinode_out(&dip->i_di, bh->b_data);
+       dip->i_inode.i_mtime = dip->i_inode.i_ctime = CURRENT_TIME;
+       gfs2_dinode_out(dip, bh->b_data);
        brelse(bh);
        return 0;
 }
@@ -1720,18 +1775,18 @@ int gfs2_dir_mvino(struct gfs2_inode *dip, const struct qstr *filename,
 
 static int foreach_leaf(struct gfs2_inode *dip, leaf_call_t lc, void *data)
 {
-       struct gfs2_sbd *sdp = dip->i_sbd;
+       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;
+       __be64 *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;
        }
@@ -1746,8 +1801,8 @@ 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),
-                                               sdp->sd_hash_bsize);
+                                               ht_offset * sizeof(__be64),
+                                               sdp->sd_hash_bsize, 1);
                        if (error != sdp->sd_hash_bsize) {
                                if (error >= 0)
                                        error = -EIO;
@@ -1762,9 +1817,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)
@@ -1780,7 +1834,7 @@ static int foreach_leaf(struct gfs2_inode *dip, leaf_call_t lc, void *data)
                error = -EIO;
        }
 
- out:
+out:
        kfree(lp);
 
        return error;
@@ -1797,17 +1851,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 = dip->i_sbd;
+       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));
@@ -1822,7 +1876,7 @@ static int leaf_dealloc(struct gfs2_inode *dip, uint32_t index, uint32_t len,
        if (error)
                goto out;
 
-       error = gfs2_rindex_hold(sdp, &dip->i_alloc.al_ri_gh);
+       error = gfs2_rindex_hold(sdp, &dip->i_alloc->al_ri_gh);
        if (error)
                goto out_qs;
 
@@ -1845,7 +1899,7 @@ static int leaf_dealloc(struct gfs2_inode *dip, uint32_t index, uint32_t len,
        for (x = 0; x < rlist.rl_rgrps; x++) {
                struct gfs2_rgrpd *rgd;
                rgd = rlist.rl_ghs[x].gh_gl->gl_object;
-               rg_blocks += rgd->rd_ri.ri_length;
+               rg_blocks += rgd->rd_length;
        }
 
        error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
@@ -1871,9 +1925,10 @@ static int leaf_dealloc(struct gfs2_inode *dip, uint32_t index, uint32_t len,
                if (!dip->i_di.di_blocks)
                        gfs2_consist_inode(dip);
                dip->i_di.di_blocks--;
+               gfs2_set_inode_blocks(&dip->i_inode);
        }
 
-       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;
@@ -1885,26 +1940,21 @@ static int leaf_dealloc(struct gfs2_inode *dip, uint32_t index, uint32_t len,
                goto out_end_trans;
 
        gfs2_trans_add_bh(dip->i_gl, dibh, 1);
-       gfs2_dinode_out(&dip->i_di, dibh->b_data);
+       gfs2_dinode_out(dip, 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:
+       gfs2_glock_dq_uninit(&dip->i_alloc->al_ri_gh);
+out_qs:
        gfs2_quota_unhold(dip);
-
- out:
+out:
        gfs2_alloc_put(dip);
        kfree(ht);
-
        return error;
 }
 
@@ -1920,7 +1970,7 @@ static int leaf_dealloc(struct gfs2_inode *dip, uint32_t index, uint32_t len,
 
 int gfs2_dir_exhash_dealloc(struct gfs2_inode *dip)
 {
-       struct gfs2_sbd *sdp = dip->i_sbd;
+       struct gfs2_sbd *sdp = GFS2_SB(&dip->i_inode);
        struct buffer_head *bh;
        int error;