1 files changed, 170 insertions, 57 deletions

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 4205ba752d40..8e686a427ce2 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -309,10 +309,6 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info,
                 ret = PTR_ERR(inode_root);
                 goto cleanup;
         }
-        if (btrfs_root_refs(&inode_root->root_item) == 0) {
-                ret = -ENOENT;
-                goto cleanup;
-        }
 
         key.objectid = defrag->ino;
         btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY);
@@ -600,20 +596,29 @@ void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                 if (no_splits)
                         goto next;
 
-                if (em->block_start < EXTENT_MAP_LAST_BYTE &&
-                    em->start < start) {
+                if (em->start < start) {
                         split->start = em->start;
                         split->len = start - em->start;
-                        split->orig_start = em->orig_start;
-                        split->block_start = em->block_start;
 
-                        if (compressed)
-                                split->block_len = em->block_len;
-                        else
-                                split->block_len = split->len;
-                        split->ram_bytes = em->ram_bytes;
-                        split->orig_block_len = max(split->block_len,
-                                                    em->orig_block_len);
+                        if (em->block_start < EXTENT_MAP_LAST_BYTE) {
+                                split->orig_start = em->orig_start;
+                                split->block_start = em->block_start;
+
+                                if (compressed)
+                                        split->block_len = em->block_len;
+                                else
+                                        split->block_len = split->len;
+                                split->orig_block_len = max(split->block_len,
+                                                em->orig_block_len);
+                                split->ram_bytes = em->ram_bytes;
+                        } else {
+                                split->orig_start = split->start;
+                                split->block_len = 0;
+                                split->block_start = em->block_start;
+                                split->orig_block_len = 0;
+                                split->ram_bytes = split->len;
+                        }
+
                         split->generation = gen;
                         split->bdev = em->bdev;
                         split->flags = flags;
@@ -624,8 +629,7 @@ void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                         split = split2;
                         split2 = NULL;
                 }
-                if (em->block_start < EXTENT_MAP_LAST_BYTE &&
-                    testend && em->start + em->len > start + len) {
+                if (testend && em->start + em->len > start + len) {
                         u64 diff = start + len - em->start;
 
                         split->start = start + len;
@@ -634,18 +638,28 @@ void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                         split->flags = flags;
                         split->compress_type = em->compress_type;
                         split->generation = gen;
-                        split->orig_block_len = max(em->block_len,
+
+                        if (em->block_start < EXTENT_MAP_LAST_BYTE) {
+                                split->orig_block_len = max(em->block_len,
                                                     em->orig_block_len);
-                        split->ram_bytes = em->ram_bytes;
 
-                        if (compressed) {
-                                split->block_len = em->block_len;
-                                split->block_start = em->block_start;
-                                split->orig_start = em->orig_start;
+                                split->ram_bytes = em->ram_bytes;
+                                if (compressed) {
+                                        split->block_len = em->block_len;
+                                        split->block_start = em->block_start;
+                                        split->orig_start = em->orig_start;
+                                } else {
+                                        split->block_len = split->len;
+                                        split->block_start = em->block_start
+                                                + diff;
+                                        split->orig_start = em->orig_start;
+                                }
                         } else {
-                                split->block_len = split->len;
-                                split->block_start = em->block_start + diff;
-                                split->orig_start = em->orig_start;
+                                split->ram_bytes = split->len;
+                                split->orig_start = split->start;
+                                split->block_len = 0;
+                                split->block_start = em->block_start;
+                                split->orig_block_len = 0;
                         }
 
                         ret = add_extent_mapping(em_tree, split, modified);
@@ -1317,6 +1331,56 @@ fail:
 
 }
 
+static noinline int check_can_nocow(struct inode *inode, loff_t pos,
+                                    size_t *write_bytes)
+{
+        struct btrfs_trans_handle *trans;
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        struct btrfs_ordered_extent *ordered;
+        u64 lockstart, lockend;
+        u64 num_bytes;
+        int ret;
+
+        lockstart = round_down(pos, root->sectorsize);
+        lockend = lockstart + round_up(*write_bytes, root->sectorsize) - 1;
+
+        while (1) {
+                lock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend);
+                ordered = btrfs_lookup_ordered_range(inode, lockstart,
+                                                     lockend - lockstart + 1);
+                if (!ordered) {
+                        break;
+                }
+                unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend);
+                btrfs_start_ordered_extent(inode, ordered, 1);
+                btrfs_put_ordered_extent(ordered);
+        }
+
+        trans = btrfs_join_transaction(root);
+        if (IS_ERR(trans)) {
+                unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend);
+                return PTR_ERR(trans);
+        }
+
+        num_bytes = lockend - lockstart + 1;
+        ret = can_nocow_extent(trans, inode, lockstart, &num_bytes, NULL, NULL,
+                               NULL);
+        btrfs_end_transaction(trans, root);
+        if (ret <= 0) {
+                ret = 0;
+        } else {
+                clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend,
+                                 EXTENT_DIRTY | EXTENT_DELALLOC |
+                                 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 0, 0,
+                                 NULL, GFP_NOFS);
+                *write_bytes = min_t(size_t, *write_bytes, num_bytes);
+        }
+
+        unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend);
+
+        return ret;
+}
+
 static noinline ssize_t __btrfs_buffered_write(struct file *file,
                                                struct iov_iter *i,
                                                loff_t pos)
@@ -1324,10 +1388,12 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
         struct inode *inode = file_inode(file);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct page **pages = NULL;
+        u64 release_bytes = 0;
         unsigned long first_index;
         size_t num_written = 0;
         int nrptrs;
         int ret = 0;
+        bool only_release_metadata = false;
         bool force_page_uptodate = false;
 
         nrptrs = min((iov_iter_count(i) + PAGE_CACHE_SIZE - 1) /
@@ -1348,6 +1414,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
                                          offset);
                 size_t num_pages = (write_bytes + offset +
                                     PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+                size_t reserve_bytes;
                 size_t dirty_pages;
                 size_t copied;
 
@@ -1362,11 +1429,41 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
                         break;
                 }
 
-                ret = btrfs_delalloc_reserve_space(inode,
-                                        num_pages << PAGE_CACHE_SHIFT);
+                reserve_bytes = num_pages << PAGE_CACHE_SHIFT;
+                ret = btrfs_check_data_free_space(inode, reserve_bytes);
+                if (ret == -ENOSPC &&
+                    (BTRFS_I(inode)->flags & (BTRFS_INODE_NODATACOW |
+                                              BTRFS_INODE_PREALLOC))) {
+                        ret = check_can_nocow(inode, pos, &write_bytes);
+                        if (ret > 0) {
+                                only_release_metadata = true;
+                                /*
+                                 * our prealloc extent may be smaller than
+                                 * write_bytes, so scale down.
+                                 */
+                                num_pages = (write_bytes + offset +
+                                             PAGE_CACHE_SIZE - 1) >>
+                                        PAGE_CACHE_SHIFT;
+                                reserve_bytes = num_pages << PAGE_CACHE_SHIFT;
+                                ret = 0;
+                        } else {
+                                ret = -ENOSPC;
+                        }
+                }
+
                 if (ret)
                         break;
 
+                ret = btrfs_delalloc_reserve_metadata(inode, reserve_bytes);
+                if (ret) {
+                        if (!only_release_metadata)
+                                btrfs_free_reserved_data_space(inode,
+                                                               reserve_bytes);
+                        break;
+                }
+
+                release_bytes = reserve_bytes;
+
                 /*
                  * This is going to setup the pages array with the number of
                  * pages we want, so we don't really need to worry about the
@@ -1375,11 +1472,8 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
                 ret = prepare_pages(root, file, pages, num_pages,
                                     pos, first_index, write_bytes,
                                     force_page_uptodate);
-                if (ret) {
-                        btrfs_delalloc_release_space(inode,
-                                        num_pages << PAGE_CACHE_SHIFT);
+                if (ret)
                         break;
-                }
 
                 copied = btrfs_copy_from_user(pos, num_pages,
                                            write_bytes, pages, i);
@@ -1409,30 +1503,46 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
                  * managed to copy.
                  */
                 if (num_pages > dirty_pages) {
+                        release_bytes = (num_pages - dirty_pages) <<
+                                PAGE_CACHE_SHIFT;
                         if (copied > 0) {
                                 spin_lock(&BTRFS_I(inode)->lock);
                                 BTRFS_I(inode)->outstanding_extents++;
                                 spin_unlock(&BTRFS_I(inode)->lock);
                         }
-                        btrfs_delalloc_release_space(inode,
-                                        (num_pages - dirty_pages) <<
-                                        PAGE_CACHE_SHIFT);
+                        if (only_release_metadata)
+                                btrfs_delalloc_release_metadata(inode,
+                                                                release_bytes);
+                        else
+                                btrfs_delalloc_release_space(inode,
+                                                             release_bytes);
                 }
 
+                release_bytes = dirty_pages << PAGE_CACHE_SHIFT;
                 if (copied > 0) {
                         ret = btrfs_dirty_pages(root, inode, pages,
                                                 dirty_pages, pos, copied,
                                                 NULL);
                         if (ret) {
-                                btrfs_delalloc_release_space(inode,
-                                        dirty_pages << PAGE_CACHE_SHIFT);
                                 btrfs_drop_pages(pages, num_pages);
                                 break;
                         }
                 }
 
+                release_bytes = 0;
                 btrfs_drop_pages(pages, num_pages);
 
+                if (only_release_metadata && copied > 0) {
+                        u64 lockstart = round_down(pos, root->sectorsize);
+                        u64 lockend = lockstart +
+                                (dirty_pages << PAGE_CACHE_SHIFT) - 1;
+
+                        set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
+                                       lockend, EXTENT_NORESERVE, NULL,
+                                       NULL, GFP_NOFS);
+                        only_release_metadata = false;
+                }
+
                 cond_resched();
 
                 balance_dirty_pages_ratelimited(inode->i_mapping);
@@ -1445,6 +1555,13 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
 
         kfree(pages);
 
+        if (release_bytes) {
+                if (only_release_metadata)
+                        btrfs_delalloc_release_metadata(inode, release_bytes);
+                else
+                        btrfs_delalloc_release_space(inode, release_bytes);
+        }
+
         return num_written ? num_written : ret;
 }
 
@@ -2175,12 +2292,6 @@ static long btrfs_fallocate(struct file *file, int mode,
                         goto out_reserve_fail;
         }
 
-        /*
-         * wait for ordered IO before we have any locks.  We'll loop again
-         * below with the locks held.
-         */
-        btrfs_wait_ordered_range(inode, alloc_start, alloc_end - alloc_start);
-
         mutex_lock(&inode->i_mutex);
         ret = inode_newsize_ok(inode, alloc_end);
         if (ret)
@@ -2191,8 +2302,23 @@ static long btrfs_fallocate(struct file *file, int mode,
                                         alloc_start);
                 if (ret)
                         goto out;
+        } else {
+                /*
+                 * If we are fallocating from the end of the file onward we
+                 * need to zero out the end of the page if i_size lands in the
+                 * middle of a page.
+                 */
+                ret = btrfs_truncate_page(inode, inode->i_size, 0, 0);
+                if (ret)
+                        goto out;
         }
 
+        /*
+         * wait for ordered IO before we have any locks.  We'll loop again
+         * below with the locks held.
+         */
+        btrfs_wait_ordered_range(inode, alloc_start, alloc_end - alloc_start);
+
         locked_end = alloc_end - 1;
         while (1) {
                 struct btrfs_ordered_extent *ordered;
@@ -2425,20 +2551,7 @@ static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence)
                 }
         }
 
-        if (offset < 0 && !(file->f_mode & FMODE_UNSIGNED_OFFSET)) {
-                offset = -EINVAL;
-                goto out;
-        }
-        if (offset > inode->i_sb->s_maxbytes) {
-                offset = -EINVAL;
-                goto out;
-        }
-
-        /* Special lock needed here? */
-        if (offset != file->f_pos) {
-                file->f_pos = offset;
-                file->f_version = 0;
-        }
+        offset = vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
 out:
         mutex_unlock(&inode->i_mutex);
         return offset;