int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
                         struct btrfs_root *root, struct inode *inode,
                         struct btrfs_path *path, u64 start, u64 end,
-                        u64 *hint_byte, int drop_cache);
+                        int drop_cache);
 int btrfs_drop_extents(struct btrfs_trans_handle *trans,
                       struct btrfs_root *root, struct inode *inode, u64 start,
-                      u64 end, u64 *hint_byte, int drop_cache);
+                      u64 end, int drop_cache);
 int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
                              struct inode *inode, u64 start, u64 end);
 int btrfs_release_file(struct inode *inode, struct file *file);
 
 int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
                         struct btrfs_root *root, struct inode *inode,
                         struct btrfs_path *path, u64 start, u64 end,
-                        u64 *hint_byte, int drop_cache)
+                        int drop_cache)
 {
        struct extent_buffer *leaf;
        struct btrfs_file_extent_item *fi;
                                                new_key.objectid,
                                                start - extent_offset, 0);
                                BUG_ON(ret); /* -ENOMEM */
-                               *hint_byte = disk_bytenr;
                        }
                        key.offset = start;
                }
                        btrfs_set_file_extent_num_bytes(leaf, fi,
                                                        extent_end - end);
                        btrfs_mark_buffer_dirty(leaf);
-                       if (update_refs && disk_bytenr > 0) {
+                       if (update_refs && disk_bytenr > 0)
                                inode_sub_bytes(inode, end - key.offset);
-                               *hint_byte = disk_bytenr;
-                       }
                        break;
                }
 
                        btrfs_set_file_extent_num_bytes(leaf, fi,
                                                        start - key.offset);
                        btrfs_mark_buffer_dirty(leaf);
-                       if (update_refs && disk_bytenr > 0) {
+                       if (update_refs && disk_bytenr > 0)
                                inode_sub_bytes(inode, extent_end - start);
-                               *hint_byte = disk_bytenr;
-                       }
                        if (end == extent_end)
                                break;
 
                                BUG_ON(ret); /* -ENOMEM */
                                inode_sub_bytes(inode,
                                                extent_end - key.offset);
-                               *hint_byte = disk_bytenr;
                        }
 
                        if (end == extent_end)
 
 int btrfs_drop_extents(struct btrfs_trans_handle *trans,
                       struct btrfs_root *root, struct inode *inode, u64 start,
-                      u64 end, u64 *hint_byte, int drop_cache)
+                      u64 end, int drop_cache)
 {
        struct btrfs_path *path;
        int ret;
        if (!path)
                return -ENOMEM;
        ret = __btrfs_drop_extents(trans, root, inode, path, start, end,
-                                  hint_byte, drop_cache);
+                                  drop_cache);
        btrfs_free_path(path);
        return ret;
 }
 
        u64 inline_len = actual_end - start;
        u64 aligned_end = (end + root->sectorsize - 1) &
                        ~((u64)root->sectorsize - 1);
-       u64 hint_byte;
        u64 data_len = inline_len;
        int ret;
 
                return 1;
        }
 
-       ret = btrfs_drop_extents(trans, root, inode, start, aligned_end,
-                                &hint_byte, 1);
+       ret = btrfs_drop_extents(trans, root, inode, start, aligned_end, 1);
        if (ret)
                return ret;
 
        struct btrfs_path *path;
        struct extent_buffer *leaf;
        struct btrfs_key ins;
-       u64 hint;
        int ret;
 
        path = btrfs_alloc_path();
         * with the others.
         */
        ret = btrfs_drop_extents(trans, root, inode, file_pos,
-                                file_pos + num_bytes,
-                                &hint, 0);
+                                file_pos + num_bytes, 0);
        if (ret)
                goto out;
 
                last_byte = (last_byte + mask) & ~mask;
                if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
                        struct extent_map *hole_em;
-                       u64 hint_byte = 0;
                        hole_size = last_byte - cur_offset;
 
                        trans = btrfs_start_transaction(root, 3);
 
                        err = btrfs_drop_extents(trans, root, inode,
                                                 cur_offset,
-                                                cur_offset + hole_size,
-                                                &hint_byte, 1);
+                                                cur_offset + hole_size, 1);
                        if (err) {
                                btrfs_abort_transaction(trans, root, err);
                                btrfs_end_transaction(trans, root);
 
        int ret;
        u64 len = olen;
        u64 bs = root->fs_info->sb->s_blocksize;
-       u64 hint_byte;
 
        /*
         * TODO:
                                ret = btrfs_drop_extents(trans, root, inode,
                                                         new_key.offset,
                                                         new_key.offset + datal,
-                                                        &hint_byte, 1);
+                                                        1);
                                if (ret) {
                                        btrfs_abort_transaction(trans, root,
                                                                ret);
                                ret = btrfs_drop_extents(trans, root, inode,
                                                         new_key.offset,
                                                         new_key.offset + datal,
-                                                        &hint_byte, 1);
+                                                        1);
                                if (ret) {
                                        btrfs_abort_transaction(trans, root,
                                                                ret);
 
        int found_type;
        u64 mask = root->sectorsize - 1;
        u64 extent_end;
-       u64 alloc_hint;
        u64 start = key->offset;
        u64 saved_nbytes;
        struct btrfs_file_extent_item *item;
 
        saved_nbytes = inode_get_bytes(inode);
        /* drop any overlapping extents */
-       ret = btrfs_drop_extents(trans, root, inode, start, extent_end,
-                                &alloc_hint, 1);
+       ret = btrfs_drop_extents(trans, root, inode, start, extent_end, 1);
        BUG_ON(ret);
 
        if (found_type == BTRFS_FILE_EXTENT_REG ||
        int ret;
 
        if (BTRFS_I(inode)->logged_trans == trans->transid) {
-               u64 tmp;
                ret = __btrfs_drop_extents(trans, log, inode, dst_path, start,
-                                          start + len, &tmp, 0);
+                                          start + len, 0);
                if (ret)
                        return ret;
        }