1 files changed, 103 insertions, 94 deletions

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 77dd0a776c83..adec22884a3e 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -138,7 +138,7 @@ static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,
         path->leave_spinning = 1;
         btrfs_set_trans_block_group(trans, inode);
 
-        key.objectid = inode->i_ino;
+        key.objectid = btrfs_ino(inode);
         key.offset = start;
         btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
         datasize = btrfs_file_extent_calc_inline_size(cur_size);
@@ -1049,6 +1049,7 @@ static noinline int run_delalloc_nocow(struct inode *inode,
         int nocow;
         int check_prev = 1;
         bool nolock = false;
+        u64 ino = btrfs_ino(inode);
 
         path = btrfs_alloc_path();
         BUG_ON(!path);
@@ -1063,14 +1064,14 @@ static noinline int run_delalloc_nocow(struct inode *inode,
         cow_start = (u64)-1;
         cur_offset = start;
         while (1) {
-                ret = btrfs_lookup_file_extent(trans, root, path, inode->i_ino,
+                ret = btrfs_lookup_file_extent(trans, root, path, ino,
                                                cur_offset, 0);
                 BUG_ON(ret < 0);
                 if (ret > 0 && path->slots[0] > 0 && check_prev) {
                         leaf = path->nodes[0];
                         btrfs_item_key_to_cpu(leaf, &found_key,
                                               path->slots[0] - 1);
-                        if (found_key.objectid == inode->i_ino &&
+                        if (found_key.objectid == ino &&
                             found_key.type == BTRFS_EXTENT_DATA_KEY)
                                 path->slots[0]--;
                 }
@@ -1091,7 +1092,7 @@ next_slot:
                 num_bytes = 0;
                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 
-                if (found_key.objectid > inode->i_ino ||
+                if (found_key.objectid > ino ||
                     found_key.type > BTRFS_EXTENT_DATA_KEY ||
                     found_key.offset > end)
                         break;
@@ -1126,7 +1127,7 @@ next_slot:
                                 goto out_check;
                         if (btrfs_extent_readonly(root, disk_bytenr))
                                 goto out_check;
-                        if (btrfs_cross_ref_exist(trans, root, inode->i_ino,
+                        if (btrfs_cross_ref_exist(trans, root, ino,
                                                   found_key.offset -
                                                   extent_offset, disk_bytenr))
                                 goto out_check;
@@ -1643,7 +1644,7 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
                                  &hint, 0);
         BUG_ON(ret);
 
-        ins.objectid = inode->i_ino;
+        ins.objectid = btrfs_ino(inode);
         ins.offset = file_pos;
         ins.type = BTRFS_EXTENT_DATA_KEY;
         ret = btrfs_insert_empty_item(trans, root, path, &ins, sizeof(*fi));
@@ -1674,7 +1675,7 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
         ins.type = BTRFS_EXTENT_ITEM_KEY;
         ret = btrfs_alloc_reserved_file_extent(trans, root,
                                         root->root_key.objectid,
-                                        inode->i_ino, file_pos, &ins);
+                                        btrfs_ino(inode), file_pos, &ins);
         BUG_ON(ret);
         btrfs_free_path(path);
 
@@ -2004,8 +2005,9 @@ good:
 
 zeroit:
         if (printk_ratelimit()) {
-                printk(KERN_INFO "btrfs csum failed ino %lu off %llu csum %u "
-                       "private %llu\n", page->mapping->host->i_ino,
+                printk(KERN_INFO "btrfs csum failed ino %llu off %llu csum %u "
+                       "private %llu\n",
+                       (unsigned long long)btrfs_ino(page->mapping->host),
                        (unsigned long long)start, csum,
                        (unsigned long long)private);
         }
@@ -2243,7 +2245,7 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
 
         /* insert an orphan item to track this unlinked/truncated file */
         if (insert >= 1) {
-                ret = btrfs_insert_orphan_item(trans, root, inode->i_ino);
+                ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode));
                 BUG_ON(ret);
         }
 
@@ -2280,7 +2282,7 @@ int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode)
         spin_unlock(&root->orphan_lock);
 
         if (trans && delete_item) {
-                ret = btrfs_del_orphan_item(trans, root, inode->i_ino);
+                ret = btrfs_del_orphan_item(trans, root, btrfs_ino(inode));
                 BUG_ON(ret);
         }
 
@@ -2542,7 +2544,8 @@ static void btrfs_read_locked_inode(struct inode *inode)
          * try to precache a NULL acl entry for files that don't have
          * any xattrs or acls
          */
-        maybe_acls = acls_after_inode_item(leaf, path->slots[0], inode->i_ino);
+        maybe_acls = acls_after_inode_item(leaf, path->slots[0],
+                                           btrfs_ino(inode));
         if (!maybe_acls)
                 cache_no_acl(inode);
 
@@ -2688,6 +2691,8 @@ static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans,
         struct btrfs_dir_item *di;
         struct btrfs_key key;
         u64 index;
+        u64 ino = btrfs_ino(inode);
+        u64 dir_ino = btrfs_ino(dir);
 
         path = btrfs_alloc_path();
         if (!path) {
@@ -2696,7 +2701,7 @@ static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans,
         }
 
         path->leave_spinning = 1;
-        di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
+        di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
                                     name, name_len, -1);
         if (IS_ERR(di)) {
                 ret = PTR_ERR(di);
@@ -2713,17 +2718,16 @@ static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans,
                 goto err;
         btrfs_release_path(root, path);
 
-        ret = btrfs_del_inode_ref(trans, root, name, name_len,
-                                  inode->i_ino,
-                                  dir->i_ino, &index);
+        ret = btrfs_del_inode_ref(trans, root, name, name_len, ino,
+                                  dir_ino, &index);
         if (ret) {
                 printk(KERN_INFO "btrfs failed to delete reference to %.*s, "
-                       "inode %lu parent %lu\n", name_len, name,
-                       inode->i_ino, dir->i_ino);
+                       "inode %llu parent %llu\n", name_len, name,
+                       (unsigned long long)ino, (unsigned long long)dir_ino);
                 goto err;
         }
 
-        di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
+        di = btrfs_lookup_dir_index_item(trans, root, path, dir_ino,
                                          index, name, name_len, -1);
         if (IS_ERR(di)) {
                 ret = PTR_ERR(di);
@@ -2737,7 +2741,7 @@ static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans,
         btrfs_release_path(root, path);
 
         ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len,
-                                         inode, dir->i_ino);
+                                         inode, dir_ino);
         BUG_ON(ret != 0 && ret != -ENOENT);
 
         ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len,
@@ -2815,12 +2819,14 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
         int check_link = 1;
         int err = -ENOSPC;
         int ret;
+        u64 ino = btrfs_ino(inode);
+        u64 dir_ino = btrfs_ino(dir);
 
         trans = btrfs_start_transaction(root, 10);
         if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC)
                 return trans;
 
-        if (inode->i_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
+        if (ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
                 return ERR_PTR(-ENOSPC);
 
         /* check if there is someone else holds reference */
@@ -2879,7 +2885,7 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
 
         if (ret == 0 && S_ISREG(inode->i_mode)) {
                 ret = btrfs_lookup_file_extent(trans, root, path,
-                                               inode->i_ino, (u64)-1, 0);
+                                               ino, (u64)-1, 0);
                 if (ret < 0) {
                         err = ret;
                         goto out;
@@ -2895,7 +2901,7 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
                 goto out;
         }
 
-        di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
+        di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
                                 dentry->d_name.name, dentry->d_name.len, 0);
         if (IS_ERR(di)) {
                 err = PTR_ERR(di);
@@ -2912,7 +2918,7 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
 
         ref = btrfs_lookup_inode_ref(trans, root, path,
                                 dentry->d_name.name, dentry->d_name.len,
-                                inode->i_ino, dir->i_ino, 0);
+                                ino, dir_ino, 0);
         if (IS_ERR(ref)) {
                 err = PTR_ERR(ref);
                 goto out;
@@ -2923,7 +2929,7 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir,
         index = btrfs_inode_ref_index(path->nodes[0], ref);
         btrfs_release_path(root, path);
 
-        di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino, index,
+        di = btrfs_lookup_dir_index_item(trans, root, path, dir_ino, index,
                                 dentry->d_name.name, dentry->d_name.len, 0);
         if (IS_ERR(di)) {
                 err = PTR_ERR(di);
@@ -2998,12 +3004,13 @@ int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
         struct btrfs_key key;
         u64 index;
         int ret;
+        u64 dir_ino = btrfs_ino(dir);
 
         path = btrfs_alloc_path();
         if (!path)
                 return -ENOMEM;
 
-        di = btrfs_lookup_dir_item(trans, root, path, dir->i_ino,
+        di = btrfs_lookup_dir_item(trans, root, path, dir_ino,
                                    name, name_len, -1);
         BUG_ON(!di || IS_ERR(di));
 
@@ -3016,10 +3023,10 @@ int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
 
         ret = btrfs_del_root_ref(trans, root->fs_info->tree_root,
                                  objectid, root->root_key.objectid,
-                                 dir->i_ino, &index, name, name_len);
+                                 dir_ino, &index, name, name_len);
         if (ret < 0) {
                 BUG_ON(ret != -ENOENT);
-                di = btrfs_search_dir_index_item(root, path, dir->i_ino,
+                di = btrfs_search_dir_index_item(root, path, dir_ino,
                                                  name, name_len);
                 BUG_ON(!di || IS_ERR(di));
 
@@ -3029,7 +3036,7 @@ int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
                 index = key.offset;
         }
 
-        di = btrfs_lookup_dir_index_item(trans, root, path, dir->i_ino,
+        di = btrfs_lookup_dir_index_item(trans, root, path, dir_ino,
                                          index, name, name_len, -1);
         BUG_ON(!di || IS_ERR(di));
 
@@ -3058,7 +3065,7 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
         unsigned long nr = 0;
 
         if (inode->i_size > BTRFS_EMPTY_DIR_SIZE ||
-            inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
+            btrfs_ino(inode) == BTRFS_FIRST_FREE_OBJECTID)
                 return -ENOTEMPTY;
 
         trans = __unlink_start_trans(dir, dentry);
@@ -3067,7 +3074,7 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
 
         btrfs_set_trans_block_group(trans, dir);
 
-        if (unlikely(inode->i_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
+        if (unlikely(btrfs_ino(inode) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
                 err = btrfs_unlink_subvol(trans, root, dir,
                                           BTRFS_I(inode)->location.objectid,
                                           dentry->d_name.name,
@@ -3299,6 +3306,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
         int encoding;
         int ret;
         int err = 0;
+        u64 ino = btrfs_ino(inode);
 
         BUG_ON(new_size > 0 && min_type != BTRFS_EXTENT_DATA_KEY);
 
@@ -3309,7 +3317,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
         BUG_ON(!path);
         path->reada = -1;
 
-        key.objectid = inode->i_ino;
+        key.objectid = ino;
         key.offset = (u64)-1;
         key.type = (u8)-1;
 
@@ -3337,7 +3345,7 @@ search_again:
                 found_type = btrfs_key_type(&found_key);
                 encoding = 0;
 
-                if (found_key.objectid != inode->i_ino)
+                if (found_key.objectid != ino)
                         break;
 
                 if (found_type < min_type)
@@ -3456,7 +3464,7 @@ delete:
                         ret = btrfs_free_extent(trans, root, extent_start,
                                                 extent_num_bytes, 0,
                                                 btrfs_header_owner(leaf),
-                                                inode->i_ino, extent_offset);
+                                                ino, extent_offset);
                         BUG_ON(ret);
                 }
 
@@ -3655,7 +3663,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size)
                                 break;
 
                         err = btrfs_insert_file_extent(trans, root,
-                                        inode->i_ino, cur_offset, 0,
+                                        btrfs_ino(inode), cur_offset, 0,
                                         0, hole_size, 0, hole_size,
                                         0, 0, 0);
                         if (err)
@@ -3812,7 +3820,7 @@ void btrfs_evict_inode(struct inode *inode)
 
         if (!(root == root->fs_info->tree_root ||
               root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID))
-                btrfs_return_ino(root, inode->i_ino);
+                btrfs_return_ino(root, btrfs_ino(inode));
 
         nr = trans->blocks_used;
         btrfs_end_transaction(trans, root);
@@ -3839,7 +3847,7 @@ static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
         path = btrfs_alloc_path();
         BUG_ON(!path);
 
-        di = btrfs_lookup_dir_item(NULL, root, path, dir->i_ino, name,
+        di = btrfs_lookup_dir_item(NULL, root, path, btrfs_ino(dir), name,
                                     namelen, 0);
         if (IS_ERR(di))
                 ret = PTR_ERR(di);
@@ -3892,7 +3900,7 @@ static int fixup_tree_root_location(struct btrfs_root *root,
 
         leaf = path->nodes[0];
         ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref);
-        if (btrfs_root_ref_dirid(leaf, ref) != dir->i_ino ||
+        if (btrfs_root_ref_dirid(leaf, ref) != btrfs_ino(dir) ||
             btrfs_root_ref_name_len(leaf, ref) != dentry->d_name.len)
                 goto out;
 
@@ -3931,6 +3939,7 @@ static void inode_tree_add(struct inode *inode)
         struct btrfs_inode *entry;
         struct rb_node **p;
         struct rb_node *parent;
+        u64 ino = btrfs_ino(inode);
 again:
         p = &root->inode_tree.rb_node;
         parent = NULL;
@@ -3943,9 +3952,9 @@ again:
                 parent = *p;
                 entry = rb_entry(parent, struct btrfs_inode, rb_node);
 
-                if (inode->i_ino < entry->vfs_inode.i_ino)
+                if (ino < btrfs_ino(&entry->vfs_inode))
                         p = &parent->rb_left;
-                else if (inode->i_ino > entry->vfs_inode.i_ino)
+                else if (ino > btrfs_ino(&entry->vfs_inode))
                         p = &parent->rb_right;
                 else {
                         WARN_ON(!(entry->vfs_inode.i_state &
@@ -4009,9 +4018,9 @@ again:
                 prev = node;
                 entry = rb_entry(node, struct btrfs_inode, rb_node);
 
-                if (objectid < entry->vfs_inode.i_ino)
+                if (objectid < btrfs_ino(&entry->vfs_inode))
                         node = node->rb_left;
-                else if (objectid > entry->vfs_inode.i_ino)
+                else if (objectid > btrfs_ino(&entry->vfs_inode))
                         node = node->rb_right;
                 else
                         break;
@@ -4019,7 +4028,7 @@ again:
         if (!node) {
                 while (prev) {
                         entry = rb_entry(prev, struct btrfs_inode, rb_node);
-                        if (objectid <= entry->vfs_inode.i_ino) {
+                        if (objectid <= btrfs_ino(&entry->vfs_inode)) {
                                 node = prev;
                                 break;
                         }
@@ -4028,7 +4037,7 @@ again:
         }
         while (node) {
                 entry = rb_entry(node, struct btrfs_inode, rb_node);
-                objectid = entry->vfs_inode.i_ino + 1;
+                objectid = btrfs_ino(&entry->vfs_inode) + 1;
                 inode = igrab(&entry->vfs_inode);
                 if (inode) {
                         spin_unlock(&root->inode_lock);
@@ -4066,7 +4075,7 @@ static int btrfs_init_locked_inode(struct inode *inode, void *p)
 static int btrfs_find_actor(struct inode *inode, void *opaque)
 {
         struct btrfs_iget_args *args = opaque;
-        return args->ino == inode->i_ino &&
+        return args->ino == btrfs_ino(inode) &&
                 args->root == BTRFS_I(inode)->root;
 }
 
@@ -4244,9 +4253,7 @@ static int btrfs_real_readdir(struct file *filp, void *dirent,
 
         /* special case for "." */
         if (filp->f_pos == 0) {
-                over = filldir(dirent, ".", 1,
-                               1, inode->i_ino,
-                               DT_DIR);
+                over = filldir(dirent, ".", 1, 1, btrfs_ino(inode), DT_DIR);
                 if (over)
                         return 0;
                 filp->f_pos = 1;
@@ -4265,7 +4272,7 @@ static int btrfs_real_readdir(struct file *filp, void *dirent,
 
         btrfs_set_key_type(&key, key_type);
         key.offset = filp->f_pos;
-        key.objectid = inode->i_ino;
+        key.objectid = btrfs_ino(inode);
 
         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
         if (ret < 0)
@@ -4420,8 +4427,9 @@ void btrfs_dirty_inode(struct inode *inode)
                 if (IS_ERR(trans)) {
                         if (printk_ratelimit()) {
                                 printk(KERN_ERR "btrfs: fail to "
-                                       "dirty  inode %lu error %ld\n",
-                                       inode->i_ino, PTR_ERR(trans));
+                                       "dirty  inode %llu error %ld\n",
+                                       (unsigned long long)btrfs_ino(inode),
+                                       PTR_ERR(trans));
                         }
                         return;
                 }
@@ -4431,8 +4439,9 @@ void btrfs_dirty_inode(struct inode *inode)
                 if (ret) {
                         if (printk_ratelimit()) {
                                 printk(KERN_ERR "btrfs: fail to "
-                                       "dirty  inode %lu error %d\n",
-                                       inode->i_ino, ret);
+                                       "dirty  inode %llu error %d\n",
+                                       (unsigned long long)btrfs_ino(inode),
+                                       ret);
                         }
                 }
         }
@@ -4452,7 +4461,7 @@ static int btrfs_set_inode_index_count(struct inode *inode)
         struct extent_buffer *leaf;
         int ret;
 
-        key.objectid = inode->i_ino;
+        key.objectid = btrfs_ino(inode);
         btrfs_set_key_type(&key, BTRFS_DIR_INDEX_KEY);
         key.offset = (u64)-1;
 
@@ -4484,7 +4493,7 @@ static int btrfs_set_inode_index_count(struct inode *inode)
         leaf = path->nodes[0];
         btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 
-        if (found_key.objectid != inode->i_ino ||
+        if (found_key.objectid != btrfs_ino(inode) ||
             btrfs_key_type(&found_key) != BTRFS_DIR_INDEX_KEY) {
                 BTRFS_I(inode)->index_cnt = 2;
                 goto out;
@@ -4657,29 +4666,29 @@ int btrfs_add_link(struct btrfs_trans_handle *trans,
         int ret = 0;
         struct btrfs_key key;
         struct btrfs_root *root = BTRFS_I(parent_inode)->root;
+        u64 ino = btrfs_ino(inode);
+        u64 parent_ino = btrfs_ino(parent_inode);
 
-        if (unlikely(inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)) {
+        if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
                 memcpy(&key, &BTRFS_I(inode)->root->root_key, sizeof(key));
         } else {
-                key.objectid = inode->i_ino;
+                key.objectid = ino;
                 btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
                 key.offset = 0;
         }
 
-        if (unlikely(inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)) {
+        if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) {
                 ret = btrfs_add_root_ref(trans, root->fs_info->tree_root,
                                          key.objectid, root->root_key.objectid,
-                                         parent_inode->i_ino,
-                                         index, name, name_len);
+                                         parent_ino, index, name, name_len);
         } else if (add_backref) {
-                ret = btrfs_insert_inode_ref(trans, root,
-                                             name, name_len, inode->i_ino,
-                                             parent_inode->i_ino, index);
+                ret = btrfs_insert_inode_ref(trans, root, name, name_len, ino,
+                                             parent_ino, index);
         }
 
         if (ret == 0) {
                 ret = btrfs_insert_dir_item(trans, root, name, name_len,
-                                            parent_inode->i_ino, &key,
+                                            parent_ino, &key,
                                             btrfs_inode_type(inode), index);
                 BUG_ON(ret);
 
@@ -4738,7 +4747,7 @@ static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
                 goto out_unlock;
 
         inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
-                                dentry->d_name.len, dir->i_ino, objectid,
+                                dentry->d_name.len, btrfs_ino(dir), objectid,
                                 BTRFS_I(dir)->block_group, mode, &index);
         err = PTR_ERR(inode);
         if (IS_ERR(inode))
@@ -4800,7 +4809,7 @@ static int btrfs_create(struct inode *dir, struct dentry *dentry,
                 goto out_unlock;
 
         inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
-                                dentry->d_name.len, dir->i_ino, objectid,
+                                dentry->d_name.len, btrfs_ino(dir), objectid,
                                 BTRFS_I(dir)->block_group, mode, &index);
         err = PTR_ERR(inode);
         if (IS_ERR(inode))
@@ -4928,7 +4937,7 @@ static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
                 goto out_fail;
 
         inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
-                                dentry->d_name.len, dir->i_ino, objectid,
+                                dentry->d_name.len, btrfs_ino(dir), objectid,
                                 BTRFS_I(dir)->block_group, S_IFDIR | mode,
                                 &index);
         if (IS_ERR(inode)) {
@@ -5049,7 +5058,7 @@ struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
         u64 bytenr;
         u64 extent_start = 0;
         u64 extent_end = 0;
-        u64 objectid = inode->i_ino;
+        u64 objectid = btrfs_ino(inode);
         u32 found_type;
         struct btrfs_path *path = NULL;
         struct btrfs_root *root = BTRFS_I(inode)->root;
@@ -5557,7 +5566,7 @@ static noinline int can_nocow_odirect(struct btrfs_trans_handle *trans,
         if (!path)
                 return -ENOMEM;
 
-        ret = btrfs_lookup_file_extent(trans, root, path, inode->i_ino,
+        ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(inode),
                                        offset, 0);
         if (ret < 0)
                 goto out;
@@ -5574,7 +5583,7 @@ static noinline int can_nocow_odirect(struct btrfs_trans_handle *trans,
         ret = 0;
         leaf = path->nodes[0];
         btrfs_item_key_to_cpu(leaf, &key, slot);
-        if (key.objectid != inode->i_ino ||
+        if (key.objectid != btrfs_ino(inode) ||
             key.type != BTRFS_EXTENT_DATA_KEY) {
                 /* not our file or wrong item type, must cow */
                 goto out;
@@ -5608,7 +5617,7 @@ static noinline int can_nocow_odirect(struct btrfs_trans_handle *trans,
          * look for other files referencing this extent, if we
          * find any we must cow
          */
-        if (btrfs_cross_ref_exist(trans, root, inode->i_ino,
+        if (btrfs_cross_ref_exist(trans, root, btrfs_ino(inode),
                                   key.offset - backref_offset, disk_bytenr))
                 goto out;
 
@@ -5798,9 +5807,10 @@ static void btrfs_endio_direct_read(struct bio *bio, int err)
 
                         flush_dcache_page(bvec->bv_page);
                         if (csum != *private) {
-                                printk(KERN_ERR "btrfs csum failed ino %lu off"
+                                printk(KERN_ERR "btrfs csum failed ino %llu off"
                                       " %llu csum %u private %u\n",
-                                      inode->i_ino, (unsigned long long)start,
+                                      (unsigned long long)btrfs_ino(inode),
+                                      (unsigned long long)start,
                                       csum, *private);
                                 err = -EIO;
                         }
@@ -5947,9 +5957,9 @@ static void btrfs_end_dio_bio(struct bio *bio, int err)
         struct btrfs_dio_private *dip = bio->bi_private;
 
         if (err) {
-                printk(KERN_ERR "btrfs direct IO failed ino %lu rw %lu "
+                printk(KERN_ERR "btrfs direct IO failed ino %llu rw %lu "
                       "sector %#Lx len %u err no %d\n",
-                      dip->inode->i_ino, bio->bi_rw,
+                      (unsigned long long)btrfs_ino(dip->inode), bio->bi_rw,
                       (unsigned long long)bio->bi_sector, bio->bi_size, err);
                 dip->errors = 1;
 
@@ -6859,8 +6869,8 @@ void btrfs_destroy_inode(struct inode *inode)
 
         spin_lock(&root->orphan_lock);
         if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
-                printk(KERN_INFO "BTRFS: inode %lu still on the orphan list\n",
-                       inode->i_ino);
+                printk(KERN_INFO "BTRFS: inode %llu still on the orphan list\n",
+                       (unsigned long long)btrfs_ino(inode));
                 list_del_init(&BTRFS_I(inode)->i_orphan);
         }
         spin_unlock(&root->orphan_lock);
@@ -6999,16 +7009,17 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         u64 index = 0;
         u64 root_objectid;
         int ret;
+        u64 old_ino = btrfs_ino(old_inode);
 
-        if (new_dir->i_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
+        if (btrfs_ino(new_dir) == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)
                 return -EPERM;
 
         /* we only allow rename subvolume link between subvolumes */
-        if (old_inode->i_ino != BTRFS_FIRST_FREE_OBJECTID && root != dest)
+        if (old_ino != BTRFS_FIRST_FREE_OBJECTID && root != dest)
                 return -EXDEV;
 
-        if (old_inode->i_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID ||
-            (new_inode && new_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID))
+        if (old_ino == BTRFS_EMPTY_SUBVOL_DIR_OBJECTID ||
+            (new_inode && btrfs_ino(new_inode) == BTRFS_FIRST_FREE_OBJECTID))
                 return -ENOTEMPTY;
 
         if (S_ISDIR(old_inode->i_mode) && new_inode &&
@@ -7024,7 +7035,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 filemap_flush(old_inode->i_mapping);
 
         /* close the racy window with snapshot create/destroy ioctl */
-        if (old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
+        if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
                 down_read(&root->fs_info->subvol_sem);
         /*
          * We want to reserve the absolute worst case amount of items.  So if
@@ -7049,15 +7060,15 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         if (ret)
                 goto out_fail;
 
-        if (unlikely(old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)) {
+        if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
                 /* force full log commit if subvolume involved. */
                 root->fs_info->last_trans_log_full_commit = trans->transid;
         } else {
                 ret = btrfs_insert_inode_ref(trans, dest,
                                              new_dentry->d_name.name,
                                              new_dentry->d_name.len,
-                                             old_inode->i_ino,
-                                             new_dir->i_ino, index);
+                                             old_ino,
+                                             btrfs_ino(new_dir), index);
                 if (ret)
                         goto out_fail;
                 /*
@@ -7073,10 +7084,8 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
          * make sure the inode gets flushed if it is replacing
          * something.
          */
-        if (new_inode && new_inode->i_size &&
-            old_inode && S_ISREG(old_inode->i_mode)) {
+        if (new_inode && new_inode->i_size && S_ISREG(old_inode->i_mode))
                 btrfs_add_ordered_operation(trans, root, old_inode);
-        }
 
         old_dir->i_ctime = old_dir->i_mtime = ctime;
         new_dir->i_ctime = new_dir->i_mtime = ctime;
@@ -7085,7 +7094,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         if (old_dentry->d_parent != new_dentry->d_parent)
                 btrfs_record_unlink_dir(trans, old_dir, old_inode, 1);
 
-        if (unlikely(old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)) {
+        if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
                 root_objectid = BTRFS_I(old_inode)->root->root_key.objectid;
                 ret = btrfs_unlink_subvol(trans, root, old_dir, root_objectid,
                                         old_dentry->d_name.name,
@@ -7102,7 +7111,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 
         if (new_inode) {
                 new_inode->i_ctime = CURRENT_TIME;
-                if (unlikely(new_inode->i_ino ==
+                if (unlikely(btrfs_ino(new_inode) ==
                              BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
                         root_objectid = BTRFS_I(new_inode)->location.objectid;
                         ret = btrfs_unlink_subvol(trans, dest, new_dir,
@@ -7130,7 +7139,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                              new_dentry->d_name.len, 0, index);
         BUG_ON(ret);
 
-        if (old_inode->i_ino != BTRFS_FIRST_FREE_OBJECTID) {
+        if (old_ino != BTRFS_FIRST_FREE_OBJECTID) {
                 struct dentry *parent = dget_parent(new_dentry);
                 btrfs_log_new_name(trans, old_inode, old_dir, parent);
                 dput(parent);
@@ -7139,7 +7148,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 out_fail:
         btrfs_end_transaction_throttle(trans, root);
 out_notrans:
-        if (old_inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
+        if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
                 up_read(&root->fs_info->subvol_sem);
 
         return ret;
@@ -7284,7 +7293,7 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
                 goto out_unlock;
 
         inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
-                                dentry->d_name.len, dir->i_ino, objectid,
+                                dentry->d_name.len, btrfs_ino(dir), objectid,
                                 BTRFS_I(dir)->block_group, S_IFLNK|S_IRWXUGO,
                                 &index);
         err = PTR_ERR(inode);
@@ -7315,7 +7324,7 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
 
         path = btrfs_alloc_path();
         BUG_ON(!path);
-        key.objectid = inode->i_ino;
+        key.objectid = btrfs_ino(inode);
         key.offset = 0;
         btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
         datasize = btrfs_file_extent_calc_inline_size(name_len);