__be64 *eablk, *end;
        int error;
 
-       error = gfs2_meta_read(ip->i_gl, ip->i_di.di_eattr, DIO_WAIT, &bh);
+       error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, &bh);
        if (error)
                return error;
 
        if (error)
                return error;
 
-       if (ip->i_di.di_eattr) {
+       if (ip->i_eattr) {
                struct ea_list ei = { .ei_er = er, .ei_size = 0 };
 
                error = ea_foreach(ip, ea_list_i, &ei);
        struct gfs2_ea_location el;
        int error;
 
-       if (!ip->i_di.di_eattr)
+       if (!ip->i_eattr)
                return -ENODATA;
 
        error = gfs2_ea_find(ip, er, &el);
        if (error)
                return error;
 
-       ip->i_di.di_eattr = bh->b_blocknr;
+       ip->i_eattr = bh->b_blocknr;
        error = ea_write(ip, GFS2_EA_BH2FIRST(bh), er);
 
        brelse(bh);
        if (ip->i_di.di_flags & GFS2_DIF_EA_INDIRECT) {
                __be64 *end;
 
-               error = gfs2_meta_read(ip->i_gl, ip->i_di.di_eattr, DIO_WAIT,
+               error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT,
                                       &indbh);
                if (error)
                        return error;
                gfs2_buffer_clear_tail(indbh, mh_size);
 
                eablk = (__be64 *)(indbh->b_data + mh_size);
-               *eablk = cpu_to_be64(ip->i_di.di_eattr);
-               ip->i_di.di_eattr = blk;
+               *eablk = cpu_to_be64(ip->i_eattr);
+               ip->i_eattr = blk;
                ip->i_di.di_flags |= GFS2_DIF_EA_INDIRECT;
                gfs2_add_inode_blocks(&ip->i_inode, 1);
 
        struct gfs2_ea_location el;
        int error;
 
-       if (!ip->i_di.di_eattr) {
+       if (!ip->i_eattr) {
                if (er->er_flags & XATTR_REPLACE)
                        return -ENODATA;
                return ea_init(ip, er);
        struct gfs2_ea_location el;
        int error;
 
-       if (!ip->i_di.di_eattr)
+       if (!ip->i_eattr)
                return -ENODATA;
 
        error = gfs2_ea_find(ip, er, &el);
 
        memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
 
-       error = gfs2_meta_read(ip->i_gl, ip->i_di.di_eattr, DIO_WAIT, &indbh);
+       error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, &indbh);
        if (error)
                return error;
 
        struct buffer_head *dibh;
        int error;
 
-       rgd = gfs2_blk2rgrpd(sdp, ip->i_di.di_eattr);
+       rgd = gfs2_blk2rgrpd(sdp, ip->i_eattr);
        if (!rgd) {
                gfs2_consist_inode(ip);
                return -EIO;
        if (error)
                goto out_gunlock;
 
-       gfs2_free_meta(ip, ip->i_di.di_eattr, 1);
+       gfs2_free_meta(ip, ip->i_eattr, 1);
 
-       ip->i_di.di_eattr = 0;
+       ip->i_eattr = 0;
        gfs2_add_inode_blocks(&ip->i_inode, -1);
 
        error = gfs2_meta_inode_buffer(ip, &dibh);
 
        ip->i_depth = (u8)depth;
        ip->i_entries = be32_to_cpu(str->di_entries);
 
-       di->di_eattr = be64_to_cpu(str->di_eattr);
+       ip->i_eattr = be64_to_cpu(str->di_eattr);
        if (S_ISREG(ip->i_inode.i_mode))
                gfs2_set_aops(&ip->i_inode);
 
        str->di_depth = cpu_to_be16(ip->i_depth);
        str->di_entries = cpu_to_be32(ip->i_entries);
 
-       str->di_eattr = cpu_to_be64(di->di_eattr);
+       str->di_eattr = cpu_to_be64(ip->i_eattr);
        str->di_atime_nsec = cpu_to_be32(ip->i_inode.i_atime.tv_nsec);
        str->di_mtime_nsec = cpu_to_be32(ip->i_inode.i_mtime.tv_nsec);
        str->di_ctime_nsec = cpu_to_be32(ip->i_inode.i_ctime.tv_nsec);
        printk(KERN_INFO "  i_height = %u\n", ip->i_height);
        printk(KERN_INFO "  i_depth = %u\n", ip->i_depth);
        printk(KERN_INFO "  i_entries = %u\n", ip->i_entries);
-       printk(KERN_INFO "  di_eattr = %llu\n",
-              (unsigned long long)di->di_eattr);
+       printk(KERN_INFO "  i_eattr = %llu\n",
+              (unsigned long long)ip->i_eattr);
 }