1 files changed, 58 insertions, 5 deletions

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 678154d4b78f..d20dbbe214e5 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -2458,13 +2458,41 @@ static int replay_one_buffer(struct btrfs_root *log, struct extent_buffer *eb,
                         if (ret)
                                 break;
 
-                        /* for regular files, make sure corresponding
-                         * orphan item exist. extents past the new EOF
-                         * will be truncated later by orphan cleanup.
+                        /*
+                         * Before replaying extents, truncate the inode to its
+                         * size. We need to do it now and not after log replay
+                         * because before an fsync we can have prealloc extents
+                         * added beyond the inode's i_size. If we did it after,
+                         * through orphan cleanup for example, we would drop
+                         * those prealloc extents just after replaying them.
                          */
                         if (S_ISREG(mode)) {
-                                ret = insert_orphan_item(wc->trans, root,
-                                                         key.objectid);
+                                struct inode *inode;
+                                u64 from;
+
+                                inode = read_one_inode(root, key.objectid);
+                                if (!inode) {
+                                        ret = -EIO;
+                                        break;
+                                }
+                                from = ALIGN(i_size_read(inode),
+                                             root->fs_info->sectorsize);
+                                ret = btrfs_drop_extents(wc->trans, root, inode,
+                                                         from, (u64)-1, 1);
+                                /*
+                                 * If the nlink count is zero here, the iput
+                                 * will free the inode.  We bump it to make
+                                 * sure it doesn't get freed until the link
+                                 * count fixup is done.
+                                 */
+                                if (!ret) {
+                                        if (inode->i_nlink == 0)
+                                                inc_nlink(inode);
+                                        /* Update link count and nbytes. */
+                                        ret = btrfs_update_inode(wc->trans,
+                                                                 root, inode);
+                                }
+                                iput(inode);
                                 if (ret)
                                         break;
                         }
@@ -4359,6 +4387,31 @@ static int btrfs_log_changed_extents(struct btrfs_trans_handle *trans,
                 num++;
         }
 
+        /*
+         * Add all prealloc extents beyond the inode's i_size to make sure we
+         * don't lose them after doing a fast fsync and replaying the log.
+         */
+        if (inode->flags & BTRFS_INODE_PREALLOC) {
+                struct rb_node *node;
+
+                for (node = rb_last(&tree->map); node; node = rb_prev(node)) {
+                        em = rb_entry(node, struct extent_map, rb_node);
+                        if (em->start < i_size_read(&inode->vfs_inode))
+                                break;
+                        if (!list_empty(&em->list))
+                                continue;
+                        /* Same as above loop. */
+                        if (++num > 32768) {
+                                list_del_init(&tree->modified_extents);
+                                ret = -EFBIG;
+                                goto process;
+                        }
+                        refcount_inc(&em->refs);
+                        set_bit(EXTENT_FLAG_LOGGING, &em->flags);
+                        list_add_tail(&em->list, &extents);
+                }
+        }
+
         list_sort(NULL, &extents, extent_cmp);
         btrfs_get_logged_extents(inode, logged_list, logged_start, logged_end);
         /*