diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 86e84a8579e3..7ce3f83c5dd6 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1011,9 +1011,16 @@ void btrfs_unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
 	spin_lock(&em_tree->lock);
 	em = lookup_extent_mapping(em_tree, offset, PAGE_CACHE_SIZE);
 	spin_unlock(&em_tree->lock);
-	if (!em)
+	if (!em) {
+		__unplug_io_fn(bdi, page);
 		return;
+	}
 
+	if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
+		free_extent_map(em);
+		__unplug_io_fn(bdi, page);
+		return;
+	}
 	offset = offset - em->start;
 	btrfs_unplug_page(&BTRFS_I(inode)->root->fs_info->mapping_tree,
 			  em->block_start + offset, page);
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 9965993748d0..e3547a992d5c 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -1949,18 +1949,18 @@ printk("2bad mapping end %Lu cur %Lu\n", end, cur);
 							  cur + iosize - 1);
 		}
 		if (!ret) {
-			unsigned long nr = (last_byte >> PAGE_CACHE_SHIFT) + 1;
-			nr -= page->index;
+			unsigned long pnr = (last_byte >> PAGE_CACHE_SHIFT) + 1;
+			pnr -= page->index;
 			ret = submit_extent_page(READ, tree, page,
 					 sector, iosize, page_offset,
-					 bdev, bio, nr,
+					 bdev, bio, pnr,
 					 end_bio_extent_readpage, mirror_num);
+			nr++;
 		}
 		if (ret)
 			SetPageError(page);
 		cur = cur + iosize;
 		page_offset += iosize;
-		nr++;
 	}
 	if (!nr) {
 		if (!PageError(page))
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 28e667052ec3..0e90315ea803 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -611,22 +611,25 @@ int btrfs_readpage_io_hook(struct page *page, u64 start, u64 end)
 	    btrfs_test_flag(inode, NODATASUM))
 		return 0;
 
+	/*
+	 * It is possible there is an ordered extent that has
+	 * not yet finished for this range in the file.  If so,
+	 * that extent will have a csum cached, and it will insert
+	 * the sum after all the blocks in the extent are fully
+	 * on disk.  So, look for an ordered extent and use the
+	 * sum if found.  We have to do this before looking in the
+	 * btree because csum items are pre-inserted based on
+	 * the file size.  btrfs_lookup_csum might find an item
+	 * that still hasn't been fully filled.
+	 */
+	ret = btrfs_find_ordered_sum(inode, start, &csum);
+	if (ret == 0)
+		goto found;
+
+	ret = 0;
 	path = btrfs_alloc_path();
-	mutex_lock(&BTRFS_I(inode)->csum_mutex);
 	item = btrfs_lookup_csum(NULL, root, path, inode->i_ino, start, 0);
 	if (IS_ERR(item)) {
-		/*
-		 * It is possible there is an ordered extent that has
-		 * not yet finished for this range in the file.  If so,
-		 * that extent will have a csum cached, and it will insert
-		 * the sum after all the blocks in the extent are fully
-		 * on disk.  So, look for an ordered extent and use the
-		 * sum if found.
-		 */
-		ret = btrfs_find_ordered_sum(inode, start, &csum);
-		if (ret == 0)
-			goto found;
-
 		ret = PTR_ERR(item);
 		/* a csum that isn't present is a preallocated region. */
 		if (ret == -ENOENT || ret == -EFBIG)
@@ -641,7 +644,6 @@ int btrfs_readpage_io_hook(struct page *page, u64 start, u64 end)
 found:
 	set_state_private(io_tree, start, csum);
 out:
-	mutex_unlock(&BTRFS_I(inode)->csum_mutex);
 	if (path)
 		btrfs_free_path(path);
 	return ret;
@@ -1375,7 +1377,7 @@ again:
 		}
 		if (!PageUptodate(page)) {
 			ret = -EIO;
-			goto out;
+			goto out_unlock;
 		}
 	}
 	wait_on_page_writeback(page);
@@ -1406,6 +1408,7 @@ again:
 	set_page_dirty(page);
 	unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
 
+out_unlock:
 	unlock_page(page);
 	page_cache_release(page);
 out:
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index b695f5b29c45..e42fd233e04c 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -557,6 +557,7 @@ int btrfs_find_ordered_sum(struct inode *inode, u64 offset, u32 *sum)
 	}
 out:
 	mutex_unlock(&tree->mutex);
+	btrfs_put_ordered_extent(ordered);
 	return ret;
 }