btrfs_drop_extents: make sure the item is getting smaller before truncate

[~andy/linux] / fs / btrfs / file.c

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index abdd9caad94ec57f745061ff9116911c25ee835f..b0d637787264a16bc32cbd386749c69ebda1c93f 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -115,8 +115,20 @@ static int insert_inline_extent(struct btrfs_trans_handle *trans,
                goto fail;
        }
        if (ret == 1) {
+               struct btrfs_key found_key;
+
+               if (path->slots[0] == 0)
+                       goto insert;
+
                path->slots[0]--;
                leaf = path->nodes[0];
+               btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
+
+               if (found_key.objectid != inode->i_ino)
+                       goto insert;
+
+               if (found_key.type != BTRFS_EXTENT_DATA_KEY)
+                       goto insert;
                ei = btrfs_item_ptr(leaf, path->slots[0],
                                    struct btrfs_file_extent_item);
 
@@ -152,6 +164,7 @@ static int insert_inline_extent(struct btrfs_trans_handle *trans,
                        ret = btrfs_search_slot(trans, root, &key, path,
                                                offset + size - found_end, 1);
                        BUG_ON(ret != 0);
+
                        ret = btrfs_extend_item(trans, root, path,
                                                offset + size - found_end);
                        if (ret) {
@@ -226,9 +239,8 @@ static int dirty_and_release_pages(struct btrfs_trans_handle *trans,
        u64 start_pos;
        u64 end_of_last_block;
        u64 end_pos = pos + write_bytes;
-       u32 inline_size;
+       u64 inline_size;
        loff_t isize = i_size_read(inode);
-
        em = alloc_extent_map(GFP_NOFS);
        if (!em)
                return -ENOMEM;
@@ -292,7 +304,7 @@ static int dirty_and_release_pages(struct btrfs_trans_handle *trans,
         */
        inline_size = end_pos;
        if (isize >= BTRFS_MAX_INLINE_DATA_SIZE(root) ||
-           inline_size > 8192 ||
+           inline_size > 32768 ||
            inline_size >= BTRFS_MAX_INLINE_DATA_SIZE(root)) {
                u64 last_end;
 
@@ -312,12 +324,14 @@ static int dirty_and_release_pages(struct btrfs_trans_handle *trans,
                aligned_end = (pos + write_bytes + root->sectorsize - 1) &
                        ~((u64)root->sectorsize - 1);
                err = btrfs_drop_extents(trans, root, inode, start_pos,
-                                        aligned_end, end_pos, &hint_byte);
+                                        aligned_end, aligned_end, &hint_byte);
                if (err)
                        goto failed;
+               if (isize > inline_size)
+                       inline_size = min_t(u64, isize, aligned_end);
+               inline_size -= start_pos;
                err = insert_inline_extent(trans, root, inode, start_pos,
-                                          end_pos - start_pos, pages, 0,
-                                          num_pages);
+                                          inline_size, pages, 0, num_pages);
                BUG_ON(err);
        }
        if (end_pos > isize) {
@@ -363,23 +377,23 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end)
  */
 int btrfs_drop_extents(struct btrfs_trans_handle *trans,
                       struct btrfs_root *root, struct inode *inode,
-                      u64 start, u64 end, u64 inline_end, u64 *hint_byte)
+                      u64 start, u64 end, u64 inline_limit, u64 *hint_byte)
 {
-       int ret;
-       struct btrfs_key key;
+       u64 extent_end = 0;
+       u64 search_start = start;
        struct extent_buffer *leaf;
-       int slot;
        struct btrfs_file_extent_item *extent;
-       u64 extent_end = 0;
-       int keep;
-       struct btrfs_file_extent_item old;
        struct btrfs_path *path;
-       u64 search_start = start;
+       struct btrfs_key key;
+       struct btrfs_file_extent_item old;
+       int keep;
+       int slot;
        int bookend;
        int found_type;
        int found_extent;
        int found_inline;
        int recow;
+       int ret;
 
        btrfs_drop_extent_cache(inode, start, end - 1);
 
@@ -425,6 +439,12 @@ next_slot:
                                                struct btrfs_file_extent_item);
                        found_type = btrfs_file_extent_type(leaf, extent);
                        if (found_type == BTRFS_FILE_EXTENT_REG) {
+                               extent_end =
+                                    btrfs_file_extent_disk_bytenr(leaf,
+                                                                  extent);
+                               if (extent_end)
+                                       *hint_byte = extent_end;
+
                                extent_end = key.offset +
                                     btrfs_file_extent_num_bytes(leaf, extent);
                                found_extent = 1;
@@ -456,13 +476,14 @@ next_slot:
                        goto next_slot;
                }
 
-               /* FIXME, there's only one inline extent allowed right now */
                if (found_inline) {
                        u64 mask = root->sectorsize - 1;
                        search_start = (extent_end + mask) & ~mask;
                } else
                        search_start = extent_end;
-
+               if (end < extent_end && start > key.offset && found_inline) {
+                       *hint_byte = EXTENT_MAP_INLINE;
+               }
                if (end < extent_end && end >= key.offset) {
                        if (found_extent) {
                                u64 disk_bytenr =
@@ -479,8 +500,10 @@ next_slot:
                                        BUG_ON(ret);
                                }
                        }
-                       if (!found_inline)
-                               bookend = 1;
+                       bookend = 1;
+                       if (found_inline && start <= key.offset &&
+                           inline_limit < extent_end)
+                               keep = 1;
                }
                /* truncate existing extent */
                if (start > key.offset) {
@@ -503,14 +526,14 @@ next_slot:
                                btrfs_set_file_extent_num_bytes(leaf, extent,
                                                                new_num);
                                btrfs_mark_buffer_dirty(leaf);
-                       } else if (end > extent_end &&
-                                  key.offset < inline_end &&
-                                  inline_end < extent_end) {
+                       } else if (key.offset < inline_limit &&
+                                  (end > extent_end) &&
+                                  (inline_limit < extent_end)) {
                                u32 new_size;
                                new_size = btrfs_file_extent_calc_inline_size(
-                                                  inline_end - key.offset);
+                                                  inline_limit - key.offset);
                                btrfs_truncate_item(trans, root, path,
-                                                   new_size);
+                                                   new_size, 1);
                        }
                }
                /* delete the entire extent */
@@ -551,6 +574,13 @@ next_slot:
                        if (!bookend)
                                continue;
                }
+               if (bookend && found_inline && start <= key.offset &&
+                   inline_limit < extent_end && key.offset <= inline_limit) {
+                       u32 new_size;
+                       new_size = btrfs_file_extent_calc_inline_size(
+                                                  extent_end - inline_limit);
+                       btrfs_truncate_item(trans, root, path, new_size, 0);
+               }
                /* create bookend, splitting the extent in two */
                if (bookend && found_extent) {
                        struct btrfs_key ins;
@@ -737,7 +767,8 @@ static ssize_t btrfs_file_write(struct file *file, const char __user *buf,
                num_written += write_bytes;
 
                balance_dirty_pages_ratelimited_nr(inode->i_mapping, num_pages);
-               btrfs_btree_balance_dirty(root, 1);
+               if (num_pages < (root->leafsize >> PAGE_CACHE_SHIFT) + 1)
+                       btrfs_btree_balance_dirty(root, 1);
                cond_resched();
        }
        mutex_unlock(&inode->i_mutex);