blob: 8d7b5a45c00523f4ca7ee5d58810b9d571ad4148 [file] [log] [blame]
Chris Mason6cbd5572007-06-12 09:07:21 -04001/*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
18
Chris Mason39279cc2007-06-12 06:35:45 -040019#include <linux/fs.h>
20#include <linux/pagemap.h>
21#include <linux/highmem.h>
22#include <linux/time.h>
23#include <linux/init.h>
24#include <linux/string.h>
Chris Mason39279cc2007-06-12 06:35:45 -040025#include <linux/backing-dev.h>
26#include <linux/mpage.h>
Christoph Hellwig2fe17c12011-01-14 13:07:43 +010027#include <linux/falloc.h>
Chris Mason39279cc2007-06-12 06:35:45 -040028#include <linux/swap.h>
29#include <linux/writeback.h>
30#include <linux/statfs.h>
31#include <linux/compat.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090032#include <linux/slab.h>
Filipe Brandenburger55e301f2013-01-29 06:04:50 +000033#include <linux/btrfs.h>
Christoph Hellwige2e40f22015-02-22 08:58:50 -080034#include <linux/uio.h>
Chris Mason39279cc2007-06-12 06:35:45 -040035#include "ctree.h"
36#include "disk-io.h"
37#include "transaction.h"
38#include "btrfs_inode.h"
Chris Mason39279cc2007-06-12 06:35:45 -040039#include "print-tree.h"
Chris Masone02119d2008-09-05 16:13:11 -040040#include "tree-log.h"
41#include "locking.h"
Josef Bacik2aaa6652012-08-29 14:27:18 -040042#include "volumes.h"
Josef Bacikfcebe452014-05-13 17:30:47 -070043#include "qgroup.h"
Anand Jainebb87652016-03-10 17:26:59 +080044#include "compression.h"
Chris Mason39279cc2007-06-12 06:35:45 -040045
Miao Xie9247f312012-11-26 09:24:43 +000046static struct kmem_cache *btrfs_inode_defrag_cachep;
Chris Mason4cb53002011-05-24 15:35:30 -040047/*
48 * when auto defrag is enabled we
49 * queue up these defrag structs to remember which
50 * inodes need defragging passes
51 */
52struct inode_defrag {
53 struct rb_node rb_node;
54 /* objectid */
55 u64 ino;
56 /*
57 * transid where the defrag was added, we search for
58 * extents newer than this
59 */
60 u64 transid;
61
62 /* root objectid */
63 u64 root;
64
65 /* last offset we were able to defrag */
66 u64 last_offset;
67
68 /* if we've wrapped around back to zero once already */
69 int cycled;
70};
71
Miao Xie762f2262012-05-24 18:58:27 +080072static int __compare_inode_defrag(struct inode_defrag *defrag1,
73 struct inode_defrag *defrag2)
74{
75 if (defrag1->root > defrag2->root)
76 return 1;
77 else if (defrag1->root < defrag2->root)
78 return -1;
79 else if (defrag1->ino > defrag2->ino)
80 return 1;
81 else if (defrag1->ino < defrag2->ino)
82 return -1;
83 else
84 return 0;
85}
86
Chris Mason4cb53002011-05-24 15:35:30 -040087/* pop a record for an inode into the defrag tree. The lock
88 * must be held already
89 *
90 * If you're inserting a record for an older transid than an
91 * existing record, the transid already in the tree is lowered
92 *
93 * If an existing record is found the defrag item you
94 * pass in is freed
95 */
Miao Xie8ddc4732012-11-26 09:25:38 +000096static int __btrfs_add_inode_defrag(struct inode *inode,
Chris Mason4cb53002011-05-24 15:35:30 -040097 struct inode_defrag *defrag)
98{
99 struct btrfs_root *root = BTRFS_I(inode)->root;
100 struct inode_defrag *entry;
101 struct rb_node **p;
102 struct rb_node *parent = NULL;
Miao Xie762f2262012-05-24 18:58:27 +0800103 int ret;
Chris Mason4cb53002011-05-24 15:35:30 -0400104
105 p = &root->fs_info->defrag_inodes.rb_node;
106 while (*p) {
107 parent = *p;
108 entry = rb_entry(parent, struct inode_defrag, rb_node);
109
Miao Xie762f2262012-05-24 18:58:27 +0800110 ret = __compare_inode_defrag(defrag, entry);
111 if (ret < 0)
Chris Mason4cb53002011-05-24 15:35:30 -0400112 p = &parent->rb_left;
Miao Xie762f2262012-05-24 18:58:27 +0800113 else if (ret > 0)
Chris Mason4cb53002011-05-24 15:35:30 -0400114 p = &parent->rb_right;
115 else {
116 /* if we're reinserting an entry for
117 * an old defrag run, make sure to
118 * lower the transid of our existing record
119 */
120 if (defrag->transid < entry->transid)
121 entry->transid = defrag->transid;
122 if (defrag->last_offset > entry->last_offset)
123 entry->last_offset = defrag->last_offset;
Miao Xie8ddc4732012-11-26 09:25:38 +0000124 return -EEXIST;
Chris Mason4cb53002011-05-24 15:35:30 -0400125 }
126 }
Josef Bacik72ac3c02012-05-23 14:13:11 -0400127 set_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags);
Chris Mason4cb53002011-05-24 15:35:30 -0400128 rb_link_node(&defrag->rb_node, parent, p);
129 rb_insert_color(&defrag->rb_node, &root->fs_info->defrag_inodes);
Miao Xie8ddc4732012-11-26 09:25:38 +0000130 return 0;
131}
Chris Mason4cb53002011-05-24 15:35:30 -0400132
Miao Xie8ddc4732012-11-26 09:25:38 +0000133static inline int __need_auto_defrag(struct btrfs_root *root)
134{
135 if (!btrfs_test_opt(root, AUTO_DEFRAG))
136 return 0;
Chris Mason4cb53002011-05-24 15:35:30 -0400137
Miao Xie8ddc4732012-11-26 09:25:38 +0000138 if (btrfs_fs_closing(root->fs_info))
139 return 0;
140
141 return 1;
Chris Mason4cb53002011-05-24 15:35:30 -0400142}
143
144/*
145 * insert a defrag record for this inode if auto defrag is
146 * enabled
147 */
148int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
149 struct inode *inode)
150{
151 struct btrfs_root *root = BTRFS_I(inode)->root;
152 struct inode_defrag *defrag;
Chris Mason4cb53002011-05-24 15:35:30 -0400153 u64 transid;
Miao Xie8ddc4732012-11-26 09:25:38 +0000154 int ret;
Chris Mason4cb53002011-05-24 15:35:30 -0400155
Miao Xie8ddc4732012-11-26 09:25:38 +0000156 if (!__need_auto_defrag(root))
Chris Mason4cb53002011-05-24 15:35:30 -0400157 return 0;
158
Josef Bacik72ac3c02012-05-23 14:13:11 -0400159 if (test_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags))
Chris Mason4cb53002011-05-24 15:35:30 -0400160 return 0;
161
162 if (trans)
163 transid = trans->transid;
164 else
165 transid = BTRFS_I(inode)->root->last_trans;
166
Miao Xie9247f312012-11-26 09:24:43 +0000167 defrag = kmem_cache_zalloc(btrfs_inode_defrag_cachep, GFP_NOFS);
Chris Mason4cb53002011-05-24 15:35:30 -0400168 if (!defrag)
169 return -ENOMEM;
170
David Sterbaa4689d22011-05-31 17:08:14 +0000171 defrag->ino = btrfs_ino(inode);
Chris Mason4cb53002011-05-24 15:35:30 -0400172 defrag->transid = transid;
173 defrag->root = root->root_key.objectid;
174
175 spin_lock(&root->fs_info->defrag_inodes_lock);
Miao Xie8ddc4732012-11-26 09:25:38 +0000176 if (!test_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags)) {
177 /*
178 * If we set IN_DEFRAG flag and evict the inode from memory,
179 * and then re-read this inode, this new inode doesn't have
180 * IN_DEFRAG flag. At the case, we may find the existed defrag.
181 */
182 ret = __btrfs_add_inode_defrag(inode, defrag);
183 if (ret)
184 kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
185 } else {
Miao Xie9247f312012-11-26 09:24:43 +0000186 kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
Miao Xie8ddc4732012-11-26 09:25:38 +0000187 }
Chris Mason4cb53002011-05-24 15:35:30 -0400188 spin_unlock(&root->fs_info->defrag_inodes_lock);
Wanlong Gaoa0f98dd2011-07-18 12:19:35 +0000189 return 0;
Chris Mason4cb53002011-05-24 15:35:30 -0400190}
191
192/*
Miao Xie8ddc4732012-11-26 09:25:38 +0000193 * Requeue the defrag object. If there is a defrag object that points to
194 * the same inode in the tree, we will merge them together (by
195 * __btrfs_add_inode_defrag()) and free the one that we want to requeue.
Chris Mason4cb53002011-05-24 15:35:30 -0400196 */
Eric Sandeen48a3b632013-04-25 20:41:01 +0000197static void btrfs_requeue_inode_defrag(struct inode *inode,
198 struct inode_defrag *defrag)
Miao Xie8ddc4732012-11-26 09:25:38 +0000199{
200 struct btrfs_root *root = BTRFS_I(inode)->root;
201 int ret;
202
203 if (!__need_auto_defrag(root))
204 goto out;
205
206 /*
207 * Here we don't check the IN_DEFRAG flag, because we need merge
208 * them together.
209 */
210 spin_lock(&root->fs_info->defrag_inodes_lock);
211 ret = __btrfs_add_inode_defrag(inode, defrag);
212 spin_unlock(&root->fs_info->defrag_inodes_lock);
213 if (ret)
214 goto out;
215 return;
216out:
217 kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
218}
219
220/*
Miao Xie26176e72012-11-26 09:26:20 +0000221 * pick the defragable inode that we want, if it doesn't exist, we will get
222 * the next one.
Chris Mason4cb53002011-05-24 15:35:30 -0400223 */
Miao Xie26176e72012-11-26 09:26:20 +0000224static struct inode_defrag *
225btrfs_pick_defrag_inode(struct btrfs_fs_info *fs_info, u64 root, u64 ino)
Chris Mason4cb53002011-05-24 15:35:30 -0400226{
227 struct inode_defrag *entry = NULL;
Miao Xie762f2262012-05-24 18:58:27 +0800228 struct inode_defrag tmp;
Chris Mason4cb53002011-05-24 15:35:30 -0400229 struct rb_node *p;
230 struct rb_node *parent = NULL;
Miao Xie762f2262012-05-24 18:58:27 +0800231 int ret;
232
233 tmp.ino = ino;
234 tmp.root = root;
Chris Mason4cb53002011-05-24 15:35:30 -0400235
Miao Xie26176e72012-11-26 09:26:20 +0000236 spin_lock(&fs_info->defrag_inodes_lock);
237 p = fs_info->defrag_inodes.rb_node;
Chris Mason4cb53002011-05-24 15:35:30 -0400238 while (p) {
239 parent = p;
240 entry = rb_entry(parent, struct inode_defrag, rb_node);
241
Miao Xie762f2262012-05-24 18:58:27 +0800242 ret = __compare_inode_defrag(&tmp, entry);
243 if (ret < 0)
Chris Mason4cb53002011-05-24 15:35:30 -0400244 p = parent->rb_left;
Miao Xie762f2262012-05-24 18:58:27 +0800245 else if (ret > 0)
Chris Mason4cb53002011-05-24 15:35:30 -0400246 p = parent->rb_right;
247 else
Miao Xie26176e72012-11-26 09:26:20 +0000248 goto out;
Chris Mason4cb53002011-05-24 15:35:30 -0400249 }
250
Miao Xie26176e72012-11-26 09:26:20 +0000251 if (parent && __compare_inode_defrag(&tmp, entry) > 0) {
252 parent = rb_next(parent);
253 if (parent)
Chris Mason4cb53002011-05-24 15:35:30 -0400254 entry = rb_entry(parent, struct inode_defrag, rb_node);
Miao Xie26176e72012-11-26 09:26:20 +0000255 else
256 entry = NULL;
Chris Mason4cb53002011-05-24 15:35:30 -0400257 }
Miao Xie26176e72012-11-26 09:26:20 +0000258out:
259 if (entry)
260 rb_erase(parent, &fs_info->defrag_inodes);
261 spin_unlock(&fs_info->defrag_inodes_lock);
262 return entry;
263}
264
265void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info)
266{
267 struct inode_defrag *defrag;
268 struct rb_node *node;
269
270 spin_lock(&fs_info->defrag_inodes_lock);
271 node = rb_first(&fs_info->defrag_inodes);
272 while (node) {
273 rb_erase(node, &fs_info->defrag_inodes);
274 defrag = rb_entry(node, struct inode_defrag, rb_node);
275 kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
276
David Sterba351810c2015-01-08 15:20:54 +0100277 cond_resched_lock(&fs_info->defrag_inodes_lock);
Miao Xie26176e72012-11-26 09:26:20 +0000278
279 node = rb_first(&fs_info->defrag_inodes);
280 }
281 spin_unlock(&fs_info->defrag_inodes_lock);
282}
283
284#define BTRFS_DEFRAG_BATCH 1024
285
286static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info,
287 struct inode_defrag *defrag)
288{
289 struct btrfs_root *inode_root;
290 struct inode *inode;
291 struct btrfs_key key;
292 struct btrfs_ioctl_defrag_range_args range;
293 int num_defrag;
Liu Bo6f1c3602013-01-29 03:22:10 +0000294 int index;
295 int ret;
Miao Xie26176e72012-11-26 09:26:20 +0000296
297 /* get the inode */
298 key.objectid = defrag->root;
David Sterba962a2982014-06-04 18:41:45 +0200299 key.type = BTRFS_ROOT_ITEM_KEY;
Miao Xie26176e72012-11-26 09:26:20 +0000300 key.offset = (u64)-1;
Liu Bo6f1c3602013-01-29 03:22:10 +0000301
302 index = srcu_read_lock(&fs_info->subvol_srcu);
303
Miao Xie26176e72012-11-26 09:26:20 +0000304 inode_root = btrfs_read_fs_root_no_name(fs_info, &key);
305 if (IS_ERR(inode_root)) {
Liu Bo6f1c3602013-01-29 03:22:10 +0000306 ret = PTR_ERR(inode_root);
307 goto cleanup;
308 }
Miao Xie26176e72012-11-26 09:26:20 +0000309
310 key.objectid = defrag->ino;
David Sterba962a2982014-06-04 18:41:45 +0200311 key.type = BTRFS_INODE_ITEM_KEY;
Miao Xie26176e72012-11-26 09:26:20 +0000312 key.offset = 0;
313 inode = btrfs_iget(fs_info->sb, &key, inode_root, NULL);
314 if (IS_ERR(inode)) {
Liu Bo6f1c3602013-01-29 03:22:10 +0000315 ret = PTR_ERR(inode);
316 goto cleanup;
Miao Xie26176e72012-11-26 09:26:20 +0000317 }
Liu Bo6f1c3602013-01-29 03:22:10 +0000318 srcu_read_unlock(&fs_info->subvol_srcu, index);
Miao Xie26176e72012-11-26 09:26:20 +0000319
320 /* do a chunk of defrag */
321 clear_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags);
322 memset(&range, 0, sizeof(range));
323 range.len = (u64)-1;
324 range.start = defrag->last_offset;
Miao Xieb66f00d2012-11-26 09:27:29 +0000325
326 sb_start_write(fs_info->sb);
Miao Xie26176e72012-11-26 09:26:20 +0000327 num_defrag = btrfs_defrag_file(inode, NULL, &range, defrag->transid,
328 BTRFS_DEFRAG_BATCH);
Miao Xieb66f00d2012-11-26 09:27:29 +0000329 sb_end_write(fs_info->sb);
Miao Xie26176e72012-11-26 09:26:20 +0000330 /*
331 * if we filled the whole defrag batch, there
332 * must be more work to do. Queue this defrag
333 * again
334 */
335 if (num_defrag == BTRFS_DEFRAG_BATCH) {
336 defrag->last_offset = range.start;
337 btrfs_requeue_inode_defrag(inode, defrag);
338 } else if (defrag->last_offset && !defrag->cycled) {
339 /*
340 * we didn't fill our defrag batch, but
341 * we didn't start at zero. Make sure we loop
342 * around to the start of the file.
343 */
344 defrag->last_offset = 0;
345 defrag->cycled = 1;
346 btrfs_requeue_inode_defrag(inode, defrag);
347 } else {
348 kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
349 }
350
351 iput(inode);
352 return 0;
Liu Bo6f1c3602013-01-29 03:22:10 +0000353cleanup:
354 srcu_read_unlock(&fs_info->subvol_srcu, index);
355 kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
356 return ret;
Chris Mason4cb53002011-05-24 15:35:30 -0400357}
358
359/*
360 * run through the list of inodes in the FS that need
361 * defragging
362 */
363int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info)
364{
365 struct inode_defrag *defrag;
Chris Mason4cb53002011-05-24 15:35:30 -0400366 u64 first_ino = 0;
Miao Xie762f2262012-05-24 18:58:27 +0800367 u64 root_objectid = 0;
Chris Mason4cb53002011-05-24 15:35:30 -0400368
369 atomic_inc(&fs_info->defrag_running);
Dulshani Gunawardhana67871252013-10-31 10:33:04 +0530370 while (1) {
Miao Xiedc81cdc2013-02-20 23:32:52 -0700371 /* Pause the auto defragger. */
372 if (test_bit(BTRFS_FS_STATE_REMOUNTING,
373 &fs_info->fs_state))
374 break;
375
Miao Xie26176e72012-11-26 09:26:20 +0000376 if (!__need_auto_defrag(fs_info->tree_root))
377 break;
Chris Mason4cb53002011-05-24 15:35:30 -0400378
379 /* find an inode to defrag */
Miao Xie26176e72012-11-26 09:26:20 +0000380 defrag = btrfs_pick_defrag_inode(fs_info, root_objectid,
381 first_ino);
Chris Mason4cb53002011-05-24 15:35:30 -0400382 if (!defrag) {
Miao Xie26176e72012-11-26 09:26:20 +0000383 if (root_objectid || first_ino) {
Miao Xie762f2262012-05-24 18:58:27 +0800384 root_objectid = 0;
Chris Mason4cb53002011-05-24 15:35:30 -0400385 first_ino = 0;
386 continue;
387 } else {
388 break;
389 }
390 }
391
Chris Mason4cb53002011-05-24 15:35:30 -0400392 first_ino = defrag->ino + 1;
Miao Xie762f2262012-05-24 18:58:27 +0800393 root_objectid = defrag->root;
Chris Mason4cb53002011-05-24 15:35:30 -0400394
Miao Xie26176e72012-11-26 09:26:20 +0000395 __btrfs_run_defrag_inode(fs_info, defrag);
Chris Mason4cb53002011-05-24 15:35:30 -0400396 }
Chris Mason4cb53002011-05-24 15:35:30 -0400397 atomic_dec(&fs_info->defrag_running);
398
399 /*
400 * during unmount, we use the transaction_wait queue to
401 * wait for the defragger to stop
402 */
403 wake_up(&fs_info->transaction_wait);
404 return 0;
405}
Chris Mason39279cc2007-06-12 06:35:45 -0400406
Chris Masond352ac62008-09-29 15:18:18 -0400407/* simple helper to fault in pages and copy. This should go away
408 * and be replaced with calls into generic code.
409 */
Zhao Leiee22f0c2016-01-06 18:47:31 +0800410static noinline int btrfs_copy_from_user(loff_t pos, size_t write_bytes,
Chris Masona1b32a52008-09-05 16:09:51 -0400411 struct page **prepared_pages,
Josef Bacik11c65dc2010-05-23 11:07:21 -0400412 struct iov_iter *i)
Chris Mason39279cc2007-06-12 06:35:45 -0400413{
Xin Zhong914ee292010-12-09 09:30:14 +0000414 size_t copied = 0;
Josef Bacikd0215f32011-01-25 14:57:24 -0500415 size_t total_copied = 0;
Josef Bacik11c65dc2010-05-23 11:07:21 -0400416 int pg = 0;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300417 int offset = pos & (PAGE_SIZE - 1);
Chris Mason39279cc2007-06-12 06:35:45 -0400418
Josef Bacik11c65dc2010-05-23 11:07:21 -0400419 while (write_bytes > 0) {
Chris Mason39279cc2007-06-12 06:35:45 -0400420 size_t count = min_t(size_t,
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300421 PAGE_SIZE - offset, write_bytes);
Josef Bacik11c65dc2010-05-23 11:07:21 -0400422 struct page *page = prepared_pages[pg];
Xin Zhong914ee292010-12-09 09:30:14 +0000423 /*
424 * Copy data from userspace to the current page
Xin Zhong914ee292010-12-09 09:30:14 +0000425 */
Xin Zhong914ee292010-12-09 09:30:14 +0000426 copied = iov_iter_copy_from_user_atomic(page, i, offset, count);
Josef Bacik11c65dc2010-05-23 11:07:21 -0400427
Chris Mason39279cc2007-06-12 06:35:45 -0400428 /* Flush processor's dcache for this page */
429 flush_dcache_page(page);
Chris Mason31339ac2011-03-07 11:10:24 -0500430
431 /*
432 * if we get a partial write, we can end up with
433 * partially up to date pages. These add
434 * a lot of complexity, so make sure they don't
435 * happen by forcing this copy to be retried.
436 *
437 * The rest of the btrfs_file_write code will fall
438 * back to page at a time copies after we return 0.
439 */
440 if (!PageUptodate(page) && copied < count)
441 copied = 0;
442
Josef Bacik11c65dc2010-05-23 11:07:21 -0400443 iov_iter_advance(i, copied);
444 write_bytes -= copied;
Xin Zhong914ee292010-12-09 09:30:14 +0000445 total_copied += copied;
Chris Mason39279cc2007-06-12 06:35:45 -0400446
Al Virob30ac0f2014-04-03 14:29:04 -0400447 /* Return to btrfs_file_write_iter to fault page */
Josef Bacik9f570b82011-01-25 12:42:37 -0500448 if (unlikely(copied == 0))
Xin Zhong914ee292010-12-09 09:30:14 +0000449 break;
Josef Bacik11c65dc2010-05-23 11:07:21 -0400450
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300451 if (copied < PAGE_SIZE - offset) {
Josef Bacik11c65dc2010-05-23 11:07:21 -0400452 offset += copied;
453 } else {
454 pg++;
455 offset = 0;
456 }
Chris Mason39279cc2007-06-12 06:35:45 -0400457 }
Xin Zhong914ee292010-12-09 09:30:14 +0000458 return total_copied;
Chris Mason39279cc2007-06-12 06:35:45 -0400459}
460
Chris Masond352ac62008-09-29 15:18:18 -0400461/*
462 * unlocks pages after btrfs_file_write is done with them
463 */
Eric Sandeen48a3b632013-04-25 20:41:01 +0000464static void btrfs_drop_pages(struct page **pages, size_t num_pages)
Chris Mason39279cc2007-06-12 06:35:45 -0400465{
466 size_t i;
467 for (i = 0; i < num_pages; i++) {
Chris Masond352ac62008-09-29 15:18:18 -0400468 /* page checked is some magic around finding pages that
469 * have been modified without going through btrfs_set_page_dirty
Mel Gorman2457aec2014-06-04 16:10:31 -0700470 * clear it here. There should be no need to mark the pages
471 * accessed as prepare_pages should have marked them accessed
472 * in prepare_pages via find_or_create_page()
Chris Masond352ac62008-09-29 15:18:18 -0400473 */
Chris Mason4a096752008-07-21 10:29:44 -0400474 ClearPageChecked(pages[i]);
Chris Mason39279cc2007-06-12 06:35:45 -0400475 unlock_page(pages[i]);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300476 put_page(pages[i]);
Chris Mason39279cc2007-06-12 06:35:45 -0400477 }
478}
479
Chris Masond352ac62008-09-29 15:18:18 -0400480/*
481 * after copy_from_user, pages need to be dirtied and we need to make
482 * sure holes are created between the current EOF and the start of
483 * any next extents (if required).
484 *
485 * this also makes the decision about creating an inline extent vs
486 * doing real data extents, marking pages dirty and delalloc as required.
487 */
Josef Bacikbe1a12a2011-04-06 13:05:22 -0400488int btrfs_dirty_pages(struct btrfs_root *root, struct inode *inode,
Eric Sandeen48a3b632013-04-25 20:41:01 +0000489 struct page **pages, size_t num_pages,
490 loff_t pos, size_t write_bytes,
491 struct extent_state **cached)
Chris Mason39279cc2007-06-12 06:35:45 -0400492{
Chris Mason39279cc2007-06-12 06:35:45 -0400493 int err = 0;
Chris Masona52d9a82007-08-27 16:49:44 -0400494 int i;
Chris Masondb945352007-10-15 16:15:53 -0400495 u64 num_bytes;
Chris Masona52d9a82007-08-27 16:49:44 -0400496 u64 start_pos;
497 u64 end_of_last_block;
498 u64 end_pos = pos + write_bytes;
499 loff_t isize = i_size_read(inode);
Chris Mason39279cc2007-06-12 06:35:45 -0400500
Chris Mason5f39d392007-10-15 16:14:19 -0400501 start_pos = pos & ~((u64)root->sectorsize - 1);
Chandan Rajendra2e78c922016-01-21 15:55:53 +0530502 num_bytes = round_up(write_bytes + pos - start_pos, root->sectorsize);
Chris Mason39279cc2007-06-12 06:35:45 -0400503
Chris Masondb945352007-10-15 16:15:53 -0400504 end_of_last_block = start_pos + num_bytes - 1;
Josef Bacik2ac55d42010-02-03 19:33:23 +0000505 err = btrfs_set_extent_delalloc(inode, start_pos, end_of_last_block,
Josef Bacikbe1a12a2011-04-06 13:05:22 -0400506 cached);
Josef Bacikd0215f32011-01-25 14:57:24 -0500507 if (err)
508 return err;
Josef Bacik9ed74f22009-09-11 16:12:44 -0400509
Chris Masonc8b97812008-10-29 14:49:59 -0400510 for (i = 0; i < num_pages; i++) {
511 struct page *p = pages[i];
512 SetPageUptodate(p);
513 ClearPageChecked(p);
514 set_page_dirty(p);
Chris Masona52d9a82007-08-27 16:49:44 -0400515 }
Josef Bacik9f570b82011-01-25 12:42:37 -0500516
517 /*
518 * we've only changed i_size in ram, and we haven't updated
519 * the disk i_size. There is no need to log the inode
520 * at this time.
521 */
522 if (end_pos > isize)
Chris Masona52d9a82007-08-27 16:49:44 -0400523 i_size_write(inode, end_pos);
Yan, Zhenga22285a2010-05-16 10:48:46 -0400524 return 0;
Chris Mason39279cc2007-06-12 06:35:45 -0400525}
526
Chris Masond352ac62008-09-29 15:18:18 -0400527/*
528 * this drops all the extents in the cache that intersect the range
529 * [start, end]. Existing extents are split as required.
530 */
Josef Bacik7014cdb2012-08-30 20:06:49 -0400531void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
532 int skip_pinned)
Chris Masona52d9a82007-08-27 16:49:44 -0400533{
534 struct extent_map *em;
Chris Mason3b951512008-04-17 11:29:12 -0400535 struct extent_map *split = NULL;
536 struct extent_map *split2 = NULL;
Chris Masona52d9a82007-08-27 16:49:44 -0400537 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
Yan39b56372008-02-15 10:40:50 -0500538 u64 len = end - start + 1;
Josef Bacik5dc562c2012-08-17 13:14:17 -0400539 u64 gen;
Chris Mason3b951512008-04-17 11:29:12 -0400540 int ret;
541 int testend = 1;
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400542 unsigned long flags;
Chris Masonc8b97812008-10-29 14:49:59 -0400543 int compressed = 0;
Josef Bacik09a2a8f92013-04-05 16:51:15 -0400544 bool modified;
Chris Masona52d9a82007-08-27 16:49:44 -0400545
Chris Masone6dcd2d2008-07-17 12:53:50 -0400546 WARN_ON(end < start);
Chris Mason3b951512008-04-17 11:29:12 -0400547 if (end == (u64)-1) {
Yan39b56372008-02-15 10:40:50 -0500548 len = (u64)-1;
Chris Mason3b951512008-04-17 11:29:12 -0400549 testend = 0;
550 }
Chris Masond3977122009-01-05 21:25:51 -0500551 while (1) {
Josef Bacik7014cdb2012-08-30 20:06:49 -0400552 int no_splits = 0;
553
Josef Bacik09a2a8f92013-04-05 16:51:15 -0400554 modified = false;
Chris Mason3b951512008-04-17 11:29:12 -0400555 if (!split)
David Sterba172ddd62011-04-21 00:48:27 +0200556 split = alloc_extent_map();
Chris Mason3b951512008-04-17 11:29:12 -0400557 if (!split2)
David Sterba172ddd62011-04-21 00:48:27 +0200558 split2 = alloc_extent_map();
Josef Bacik7014cdb2012-08-30 20:06:49 -0400559 if (!split || !split2)
560 no_splits = 1;
Chris Mason3b951512008-04-17 11:29:12 -0400561
Chris Mason890871b2009-09-02 16:24:52 -0400562 write_lock(&em_tree->lock);
Yan39b56372008-02-15 10:40:50 -0500563 em = lookup_extent_mapping(em_tree, start, len);
Chris Masond1310b22008-01-24 16:13:08 -0500564 if (!em) {
Chris Mason890871b2009-09-02 16:24:52 -0400565 write_unlock(&em_tree->lock);
Chris Masona52d9a82007-08-27 16:49:44 -0400566 break;
Chris Masond1310b22008-01-24 16:13:08 -0500567 }
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400568 flags = em->flags;
Josef Bacik5dc562c2012-08-17 13:14:17 -0400569 gen = em->generation;
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400570 if (skip_pinned && test_bit(EXTENT_FLAG_PINNED, &em->flags)) {
Yan, Zheng55ef6892009-11-12 09:36:44 +0000571 if (testend && em->start + em->len >= start + len) {
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400572 free_extent_map(em);
Chris Masona1ed8352009-09-11 12:27:37 -0400573 write_unlock(&em_tree->lock);
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400574 break;
575 }
Yan, Zheng55ef6892009-11-12 09:36:44 +0000576 start = em->start + em->len;
577 if (testend)
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400578 len = start + len - (em->start + em->len);
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400579 free_extent_map(em);
Chris Masona1ed8352009-09-11 12:27:37 -0400580 write_unlock(&em_tree->lock);
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400581 continue;
582 }
Chris Masonc8b97812008-10-29 14:49:59 -0400583 compressed = test_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
Chris Mason3ce7e672008-07-31 15:42:54 -0400584 clear_bit(EXTENT_FLAG_PINNED, &em->flags);
Liu Bo3b277592013-03-15 08:46:39 -0600585 clear_bit(EXTENT_FLAG_LOGGING, &flags);
Josef Bacik09a2a8f92013-04-05 16:51:15 -0400586 modified = !list_empty(&em->list);
Josef Bacik7014cdb2012-08-30 20:06:49 -0400587 if (no_splits)
588 goto next;
Chris Mason3b951512008-04-17 11:29:12 -0400589
Josef Bacikee20a982013-07-11 10:34:59 -0400590 if (em->start < start) {
Chris Mason3b951512008-04-17 11:29:12 -0400591 split->start = em->start;
592 split->len = start - em->start;
Chris Masonc8b97812008-10-29 14:49:59 -0400593
Josef Bacikee20a982013-07-11 10:34:59 -0400594 if (em->block_start < EXTENT_MAP_LAST_BYTE) {
595 split->orig_start = em->orig_start;
596 split->block_start = em->block_start;
597
598 if (compressed)
599 split->block_len = em->block_len;
600 else
601 split->block_len = split->len;
602 split->orig_block_len = max(split->block_len,
603 em->orig_block_len);
604 split->ram_bytes = em->ram_bytes;
605 } else {
606 split->orig_start = split->start;
607 split->block_len = 0;
608 split->block_start = em->block_start;
609 split->orig_block_len = 0;
610 split->ram_bytes = split->len;
611 }
612
Josef Bacik5dc562c2012-08-17 13:14:17 -0400613 split->generation = gen;
Chris Mason3b951512008-04-17 11:29:12 -0400614 split->bdev = em->bdev;
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400615 split->flags = flags;
Li Zefan261507a02010-12-17 14:21:50 +0800616 split->compress_type = em->compress_type;
Filipe Manana176840b2014-02-25 14:15:13 +0000617 replace_extent_mapping(em_tree, em, split, modified);
Chris Mason3b951512008-04-17 11:29:12 -0400618 free_extent_map(split);
619 split = split2;
620 split2 = NULL;
621 }
Josef Bacikee20a982013-07-11 10:34:59 -0400622 if (testend && em->start + em->len > start + len) {
Chris Mason3b951512008-04-17 11:29:12 -0400623 u64 diff = start + len - em->start;
624
625 split->start = start + len;
626 split->len = em->start + em->len - (start + len);
627 split->bdev = em->bdev;
Zheng Yan5b21f2e2008-09-26 10:05:38 -0400628 split->flags = flags;
Li Zefan261507a02010-12-17 14:21:50 +0800629 split->compress_type = em->compress_type;
Josef Bacik5dc562c2012-08-17 13:14:17 -0400630 split->generation = gen;
Chris Mason3b951512008-04-17 11:29:12 -0400631
Josef Bacikee20a982013-07-11 10:34:59 -0400632 if (em->block_start < EXTENT_MAP_LAST_BYTE) {
633 split->orig_block_len = max(em->block_len,
634 em->orig_block_len);
635
636 split->ram_bytes = em->ram_bytes;
637 if (compressed) {
638 split->block_len = em->block_len;
639 split->block_start = em->block_start;
640 split->orig_start = em->orig_start;
641 } else {
642 split->block_len = split->len;
643 split->block_start = em->block_start
644 + diff;
645 split->orig_start = em->orig_start;
646 }
Chris Masonc8b97812008-10-29 14:49:59 -0400647 } else {
Josef Bacikee20a982013-07-11 10:34:59 -0400648 split->ram_bytes = split->len;
649 split->orig_start = split->start;
650 split->block_len = 0;
651 split->block_start = em->block_start;
652 split->orig_block_len = 0;
Chris Masonc8b97812008-10-29 14:49:59 -0400653 }
Chris Mason3b951512008-04-17 11:29:12 -0400654
Filipe Manana176840b2014-02-25 14:15:13 +0000655 if (extent_map_in_tree(em)) {
656 replace_extent_mapping(em_tree, em, split,
657 modified);
658 } else {
659 ret = add_extent_mapping(em_tree, split,
660 modified);
661 ASSERT(ret == 0); /* Logic error */
662 }
Chris Mason3b951512008-04-17 11:29:12 -0400663 free_extent_map(split);
664 split = NULL;
665 }
Josef Bacik7014cdb2012-08-30 20:06:49 -0400666next:
Filipe Manana176840b2014-02-25 14:15:13 +0000667 if (extent_map_in_tree(em))
668 remove_extent_mapping(em_tree, em);
Chris Mason890871b2009-09-02 16:24:52 -0400669 write_unlock(&em_tree->lock);
Chris Masond1310b22008-01-24 16:13:08 -0500670
Chris Masona52d9a82007-08-27 16:49:44 -0400671 /* once for us */
672 free_extent_map(em);
673 /* once for the tree*/
674 free_extent_map(em);
675 }
Chris Mason3b951512008-04-17 11:29:12 -0400676 if (split)
677 free_extent_map(split);
678 if (split2)
679 free_extent_map(split2);
Chris Masona52d9a82007-08-27 16:49:44 -0400680}
681
Chris Mason39279cc2007-06-12 06:35:45 -0400682/*
683 * this is very complex, but the basic idea is to drop all extents
684 * in the range start - end. hint_block is filled in with a block number
685 * that would be a good hint to the block allocator for this file.
686 *
687 * If an extent intersects the range but is not entirely inside the range
688 * it is either truncated or split. Anything entirely inside the range
689 * is deleted from the tree.
690 */
Josef Bacik5dc562c2012-08-17 13:14:17 -0400691int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
692 struct btrfs_root *root, struct inode *inode,
693 struct btrfs_path *path, u64 start, u64 end,
Filipe David Borba Manana1acae572014-01-07 11:42:27 +0000694 u64 *drop_end, int drop_cache,
695 int replace_extent,
696 u32 extent_item_size,
697 int *key_inserted)
Chris Mason39279cc2007-06-12 06:35:45 -0400698{
Chris Mason00f5c792007-11-30 10:09:33 -0500699 struct extent_buffer *leaf;
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000700 struct btrfs_file_extent_item *fi;
Chris Mason00f5c792007-11-30 10:09:33 -0500701 struct btrfs_key key;
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000702 struct btrfs_key new_key;
Li Zefan33345d012011-04-20 10:31:50 +0800703 u64 ino = btrfs_ino(inode);
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000704 u64 search_start = start;
705 u64 disk_bytenr = 0;
706 u64 num_bytes = 0;
707 u64 extent_offset = 0;
708 u64 extent_end = 0;
709 int del_nr = 0;
710 int del_slot = 0;
711 int extent_type;
Chris Masonccd467d2007-06-28 15:57:36 -0400712 int recow;
Chris Mason00f5c792007-11-30 10:09:33 -0500713 int ret;
Chris Masondc7fdde2012-04-27 14:31:29 -0400714 int modify_tree = -1;
Miao Xie27cdeb72014-04-02 19:51:05 +0800715 int update_refs;
Josef Bacikc3308f82012-09-14 14:51:22 -0400716 int found = 0;
Filipe David Borba Manana1acae572014-01-07 11:42:27 +0000717 int leafs_visited = 0;
Chris Mason39279cc2007-06-12 06:35:45 -0400718
Chris Masona1ed8352009-09-11 12:27:37 -0400719 if (drop_cache)
720 btrfs_drop_extent_cache(inode, start, end - 1, 0);
Chris Masona52d9a82007-08-27 16:49:44 -0400721
Filipe David Borba Mananad5f37522014-02-09 23:45:12 +0000722 if (start >= BTRFS_I(inode)->disk_i_size && !replace_extent)
Chris Masondc7fdde2012-04-27 14:31:29 -0400723 modify_tree = 0;
724
Miao Xie27cdeb72014-04-02 19:51:05 +0800725 update_refs = (test_bit(BTRFS_ROOT_REF_COWS, &root->state) ||
726 root == root->fs_info->tree_root);
Chris Masond3977122009-01-05 21:25:51 -0500727 while (1) {
Chris Masonccd467d2007-06-28 15:57:36 -0400728 recow = 0;
Li Zefan33345d012011-04-20 10:31:50 +0800729 ret = btrfs_lookup_file_extent(trans, root, path, ino,
Chris Masondc7fdde2012-04-27 14:31:29 -0400730 search_start, modify_tree);
Chris Mason39279cc2007-06-12 06:35:45 -0400731 if (ret < 0)
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000732 break;
733 if (ret > 0 && path->slots[0] > 0 && search_start == start) {
734 leaf = path->nodes[0];
735 btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1);
Li Zefan33345d012011-04-20 10:31:50 +0800736 if (key.objectid == ino &&
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000737 key.type == BTRFS_EXTENT_DATA_KEY)
738 path->slots[0]--;
Chris Mason39279cc2007-06-12 06:35:45 -0400739 }
Chris Mason8c2383c2007-06-18 09:57:58 -0400740 ret = 0;
Filipe David Borba Manana1acae572014-01-07 11:42:27 +0000741 leafs_visited++;
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000742next_slot:
743 leaf = path->nodes[0];
744 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
745 BUG_ON(del_nr > 0);
746 ret = btrfs_next_leaf(root, path);
747 if (ret < 0)
748 break;
749 if (ret > 0) {
750 ret = 0;
751 break;
Chris Mason8c2383c2007-06-18 09:57:58 -0400752 }
Filipe David Borba Manana1acae572014-01-07 11:42:27 +0000753 leafs_visited++;
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000754 leaf = path->nodes[0];
755 recow = 1;
756 }
757
758 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
Filipe Mananaaeafbf82015-11-06 13:33:33 +0000759
760 if (key.objectid > ino)
761 break;
762 if (WARN_ON_ONCE(key.objectid < ino) ||
763 key.type < BTRFS_EXTENT_DATA_KEY) {
764 ASSERT(del_nr == 0);
765 path->slots[0]++;
766 goto next_slot;
767 }
768 if (key.type > BTRFS_EXTENT_DATA_KEY || key.offset >= end)
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000769 break;
770
771 fi = btrfs_item_ptr(leaf, path->slots[0],
772 struct btrfs_file_extent_item);
773 extent_type = btrfs_file_extent_type(leaf, fi);
774
775 if (extent_type == BTRFS_FILE_EXTENT_REG ||
776 extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
777 disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
778 num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
779 extent_offset = btrfs_file_extent_offset(leaf, fi);
780 extent_end = key.offset +
781 btrfs_file_extent_num_bytes(leaf, fi);
782 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
783 extent_end = key.offset +
Chris Mason514ac8a2014-01-03 21:07:00 -0800784 btrfs_file_extent_inline_len(leaf,
785 path->slots[0], fi);
Chris Mason8c2383c2007-06-18 09:57:58 -0400786 } else {
Filipe Mananaaeafbf82015-11-06 13:33:33 +0000787 /* can't happen */
788 BUG();
Chris Mason39279cc2007-06-12 06:35:45 -0400789 }
790
Filipe Mananafc19c5e2014-04-29 13:18:40 +0100791 /*
792 * Don't skip extent items representing 0 byte lengths. They
793 * used to be created (bug) if while punching holes we hit
794 * -ENOSPC condition. So if we find one here, just ensure we
795 * delete it, otherwise we would insert a new file extent item
796 * with the same key (offset) as that 0 bytes length file
797 * extent item in the call to setup_items_for_insert() later
798 * in this function.
799 */
800 if (extent_end == key.offset && extent_end >= search_start)
801 goto delete_extent_item;
802
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000803 if (extent_end <= search_start) {
804 path->slots[0]++;
Chris Mason8c2383c2007-06-18 09:57:58 -0400805 goto next_slot;
Chris Mason39279cc2007-06-12 06:35:45 -0400806 }
807
Josef Bacikc3308f82012-09-14 14:51:22 -0400808 found = 1;
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000809 search_start = max(key.offset, start);
Chris Masondc7fdde2012-04-27 14:31:29 -0400810 if (recow || !modify_tree) {
811 modify_tree = -1;
David Sterbab3b4aa72011-04-21 01:20:15 +0200812 btrfs_release_path(path);
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000813 continue;
Chris Mason39279cc2007-06-12 06:35:45 -0400814 }
Chris Mason771ed682008-11-06 22:02:51 -0500815
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000816 /*
817 * | - range to drop - |
818 * | -------- extent -------- |
819 */
820 if (start > key.offset && end < extent_end) {
821 BUG_ON(del_nr > 0);
Liu Bo00fdf132014-03-10 18:56:07 +0800822 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
David Sterba3f9e3df2014-04-15 18:50:17 +0200823 ret = -EOPNOTSUPP;
Liu Bo00fdf132014-03-10 18:56:07 +0800824 break;
825 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000826
827 memcpy(&new_key, &key, sizeof(new_key));
828 new_key.offset = start;
829 ret = btrfs_duplicate_item(trans, root, path,
830 &new_key);
831 if (ret == -EAGAIN) {
David Sterbab3b4aa72011-04-21 01:20:15 +0200832 btrfs_release_path(path);
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000833 continue;
834 }
835 if (ret < 0)
836 break;
Chris Mason8c2383c2007-06-18 09:57:58 -0400837
Chris Mason5f39d392007-10-15 16:14:19 -0400838 leaf = path->nodes[0];
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000839 fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
840 struct btrfs_file_extent_item);
841 btrfs_set_file_extent_num_bytes(leaf, fi,
842 start - key.offset);
Chris Mason39279cc2007-06-12 06:35:45 -0400843
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000844 fi = btrfs_item_ptr(leaf, path->slots[0],
845 struct btrfs_file_extent_item);
Chris Masonc8b97812008-10-29 14:49:59 -0400846
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000847 extent_offset += start - key.offset;
848 btrfs_set_file_extent_offset(leaf, fi, extent_offset);
849 btrfs_set_file_extent_num_bytes(leaf, fi,
850 extent_end - start);
851 btrfs_mark_buffer_dirty(leaf);
Chris Masondb945352007-10-15 16:15:53 -0400852
Josef Bacik5dc562c2012-08-17 13:14:17 -0400853 if (update_refs && disk_bytenr > 0) {
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000854 ret = btrfs_inc_extent_ref(trans, root,
855 disk_bytenr, num_bytes, 0,
856 root->root_key.objectid,
857 new_key.objectid,
Filipe Mananab06c4bf2015-10-23 07:52:54 +0100858 start - extent_offset);
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100859 BUG_ON(ret); /* -ENOMEM */
Zheng Yan31840ae2008-09-23 13:14:14 -0400860 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000861 key.offset = start;
862 }
863 /*
864 * | ---- range to drop ----- |
865 * | -------- extent -------- |
866 */
867 if (start <= key.offset && end < extent_end) {
Liu Bo00fdf132014-03-10 18:56:07 +0800868 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
David Sterba3f9e3df2014-04-15 18:50:17 +0200869 ret = -EOPNOTSUPP;
Liu Bo00fdf132014-03-10 18:56:07 +0800870 break;
871 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000872
873 memcpy(&new_key, &key, sizeof(new_key));
874 new_key.offset = end;
Daniel Dresslerb7a03652014-11-12 13:43:09 +0900875 btrfs_set_item_key_safe(root->fs_info, path, &new_key);
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000876
877 extent_offset += end - key.offset;
878 btrfs_set_file_extent_offset(leaf, fi, extent_offset);
879 btrfs_set_file_extent_num_bytes(leaf, fi,
880 extent_end - end);
881 btrfs_mark_buffer_dirty(leaf);
Josef Bacik26714852012-08-29 12:24:27 -0400882 if (update_refs && disk_bytenr > 0)
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000883 inode_sub_bytes(inode, end - key.offset);
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000884 break;
Zheng Yan31840ae2008-09-23 13:14:14 -0400885 }
886
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000887 search_start = extent_end;
888 /*
889 * | ---- range to drop ----- |
890 * | -------- extent -------- |
891 */
892 if (start > key.offset && end >= extent_end) {
893 BUG_ON(del_nr > 0);
Liu Bo00fdf132014-03-10 18:56:07 +0800894 if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
David Sterba3f9e3df2014-04-15 18:50:17 +0200895 ret = -EOPNOTSUPP;
Liu Bo00fdf132014-03-10 18:56:07 +0800896 break;
897 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000898
899 btrfs_set_file_extent_num_bytes(leaf, fi,
900 start - key.offset);
901 btrfs_mark_buffer_dirty(leaf);
Josef Bacik26714852012-08-29 12:24:27 -0400902 if (update_refs && disk_bytenr > 0)
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000903 inode_sub_bytes(inode, extent_end - start);
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000904 if (end == extent_end)
905 break;
906
907 path->slots[0]++;
908 goto next_slot;
Chris Mason39279cc2007-06-12 06:35:45 -0400909 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000910
911 /*
912 * | ---- range to drop ----- |
913 * | ------ extent ------ |
914 */
915 if (start <= key.offset && end >= extent_end) {
Filipe Mananafc19c5e2014-04-29 13:18:40 +0100916delete_extent_item:
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000917 if (del_nr == 0) {
918 del_slot = path->slots[0];
919 del_nr = 1;
920 } else {
921 BUG_ON(del_slot + del_nr != path->slots[0]);
922 del_nr++;
923 }
924
Josef Bacik5dc562c2012-08-17 13:14:17 -0400925 if (update_refs &&
926 extent_type == BTRFS_FILE_EXTENT_INLINE) {
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000927 inode_sub_bytes(inode,
928 extent_end - key.offset);
929 extent_end = ALIGN(extent_end,
930 root->sectorsize);
Josef Bacik5dc562c2012-08-17 13:14:17 -0400931 } else if (update_refs && disk_bytenr > 0) {
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000932 ret = btrfs_free_extent(trans, root,
933 disk_bytenr, num_bytes, 0,
934 root->root_key.objectid,
935 key.objectid, key.offset -
Filipe Mananab06c4bf2015-10-23 07:52:54 +0100936 extent_offset);
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100937 BUG_ON(ret); /* -ENOMEM */
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000938 inode_sub_bytes(inode,
939 extent_end - key.offset);
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000940 }
941
942 if (end == extent_end)
943 break;
944
945 if (path->slots[0] + 1 < btrfs_header_nritems(leaf)) {
946 path->slots[0]++;
947 goto next_slot;
948 }
949
950 ret = btrfs_del_items(trans, root, path, del_slot,
951 del_nr);
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100952 if (ret) {
953 btrfs_abort_transaction(trans, root, ret);
Josef Bacik5dc562c2012-08-17 13:14:17 -0400954 break;
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100955 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000956
957 del_nr = 0;
958 del_slot = 0;
959
David Sterbab3b4aa72011-04-21 01:20:15 +0200960 btrfs_release_path(path);
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000961 continue;
962 }
963
964 BUG_ON(1);
Chris Mason39279cc2007-06-12 06:35:45 -0400965 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000966
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100967 if (!ret && del_nr > 0) {
Filipe David Borba Manana1acae572014-01-07 11:42:27 +0000968 /*
969 * Set path->slots[0] to first slot, so that after the delete
970 * if items are move off from our leaf to its immediate left or
971 * right neighbor leafs, we end up with a correct and adjusted
Filipe David Borba Mananad5f37522014-02-09 23:45:12 +0000972 * path->slots[0] for our insertion (if replace_extent != 0).
Filipe David Borba Manana1acae572014-01-07 11:42:27 +0000973 */
974 path->slots[0] = del_slot;
Yan, Zheng920bbbf2009-11-12 09:34:08 +0000975 ret = btrfs_del_items(trans, root, path, del_slot, del_nr);
Jeff Mahoney79787ea2012-03-12 16:03:00 +0100976 if (ret)
977 btrfs_abort_transaction(trans, root, ret);
Filipe David Borba Mananad5f37522014-02-09 23:45:12 +0000978 }
Filipe David Borba Manana1acae572014-01-07 11:42:27 +0000979
Filipe David Borba Mananad5f37522014-02-09 23:45:12 +0000980 leaf = path->nodes[0];
981 /*
982 * If btrfs_del_items() was called, it might have deleted a leaf, in
983 * which case it unlocked our path, so check path->locks[0] matches a
984 * write lock.
985 */
986 if (!ret && replace_extent && leafs_visited == 1 &&
987 (path->locks[0] == BTRFS_WRITE_LOCK_BLOCKING ||
988 path->locks[0] == BTRFS_WRITE_LOCK) &&
989 btrfs_leaf_free_space(root, leaf) >=
990 sizeof(struct btrfs_item) + extent_item_size) {
Filipe David Borba Manana1acae572014-01-07 11:42:27 +0000991
Filipe David Borba Mananad5f37522014-02-09 23:45:12 +0000992 key.objectid = ino;
993 key.type = BTRFS_EXTENT_DATA_KEY;
994 key.offset = start;
995 if (!del_nr && path->slots[0] < btrfs_header_nritems(leaf)) {
996 struct btrfs_key slot_key;
997
998 btrfs_item_key_to_cpu(leaf, &slot_key, path->slots[0]);
999 if (btrfs_comp_cpu_keys(&key, &slot_key) > 0)
1000 path->slots[0]++;
Filipe David Borba Manana1acae572014-01-07 11:42:27 +00001001 }
Filipe David Borba Mananad5f37522014-02-09 23:45:12 +00001002 setup_items_for_insert(root, path, &key,
1003 &extent_item_size,
1004 extent_item_size,
1005 sizeof(struct btrfs_item) +
1006 extent_item_size, 1);
1007 *key_inserted = 1;
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001008 }
1009
Filipe David Borba Manana1acae572014-01-07 11:42:27 +00001010 if (!replace_extent || !(*key_inserted))
1011 btrfs_release_path(path);
Josef Bacik2aaa6652012-08-29 14:27:18 -04001012 if (drop_end)
Josef Bacikc3308f82012-09-14 14:51:22 -04001013 *drop_end = found ? min(end, extent_end) : end;
Josef Bacik5dc562c2012-08-17 13:14:17 -04001014 return ret;
1015}
1016
1017int btrfs_drop_extents(struct btrfs_trans_handle *trans,
1018 struct btrfs_root *root, struct inode *inode, u64 start,
Josef Bacik26714852012-08-29 12:24:27 -04001019 u64 end, int drop_cache)
Josef Bacik5dc562c2012-08-17 13:14:17 -04001020{
1021 struct btrfs_path *path;
1022 int ret;
1023
1024 path = btrfs_alloc_path();
1025 if (!path)
1026 return -ENOMEM;
Josef Bacik2aaa6652012-08-29 14:27:18 -04001027 ret = __btrfs_drop_extents(trans, root, inode, path, start, end, NULL,
Filipe David Borba Manana1acae572014-01-07 11:42:27 +00001028 drop_cache, 0, 0, NULL);
Chris Mason39279cc2007-06-12 06:35:45 -04001029 btrfs_free_path(path);
1030 return ret;
1031}
1032
Yan Zhengd899e052008-10-30 14:25:28 -04001033static int extent_mergeable(struct extent_buffer *leaf, int slot,
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001034 u64 objectid, u64 bytenr, u64 orig_offset,
1035 u64 *start, u64 *end)
Yan Zhengd899e052008-10-30 14:25:28 -04001036{
1037 struct btrfs_file_extent_item *fi;
1038 struct btrfs_key key;
1039 u64 extent_end;
1040
1041 if (slot < 0 || slot >= btrfs_header_nritems(leaf))
1042 return 0;
1043
1044 btrfs_item_key_to_cpu(leaf, &key, slot);
1045 if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY)
1046 return 0;
1047
1048 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
1049 if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG ||
1050 btrfs_file_extent_disk_bytenr(leaf, fi) != bytenr ||
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001051 btrfs_file_extent_offset(leaf, fi) != key.offset - orig_offset ||
Yan Zhengd899e052008-10-30 14:25:28 -04001052 btrfs_file_extent_compression(leaf, fi) ||
1053 btrfs_file_extent_encryption(leaf, fi) ||
1054 btrfs_file_extent_other_encoding(leaf, fi))
1055 return 0;
1056
1057 extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
1058 if ((*start && *start != key.offset) || (*end && *end != extent_end))
1059 return 0;
1060
1061 *start = key.offset;
1062 *end = extent_end;
1063 return 1;
1064}
1065
1066/*
1067 * Mark extent in the range start - end as written.
1068 *
1069 * This changes extent type from 'pre-allocated' to 'regular'. If only
1070 * part of extent is marked as written, the extent will be split into
1071 * two or three.
1072 */
1073int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
Yan Zhengd899e052008-10-30 14:25:28 -04001074 struct inode *inode, u64 start, u64 end)
1075{
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001076 struct btrfs_root *root = BTRFS_I(inode)->root;
Yan Zhengd899e052008-10-30 14:25:28 -04001077 struct extent_buffer *leaf;
1078 struct btrfs_path *path;
1079 struct btrfs_file_extent_item *fi;
1080 struct btrfs_key key;
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001081 struct btrfs_key new_key;
Yan Zhengd899e052008-10-30 14:25:28 -04001082 u64 bytenr;
1083 u64 num_bytes;
1084 u64 extent_end;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001085 u64 orig_offset;
Yan Zhengd899e052008-10-30 14:25:28 -04001086 u64 other_start;
1087 u64 other_end;
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001088 u64 split;
1089 int del_nr = 0;
1090 int del_slot = 0;
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001091 int recow;
Yan Zhengd899e052008-10-30 14:25:28 -04001092 int ret;
Li Zefan33345d012011-04-20 10:31:50 +08001093 u64 ino = btrfs_ino(inode);
Yan Zhengd899e052008-10-30 14:25:28 -04001094
Yan Zhengd899e052008-10-30 14:25:28 -04001095 path = btrfs_alloc_path();
Mark Fashehd8926bb2011-07-13 10:38:47 -07001096 if (!path)
1097 return -ENOMEM;
Yan Zhengd899e052008-10-30 14:25:28 -04001098again:
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001099 recow = 0;
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001100 split = start;
Li Zefan33345d012011-04-20 10:31:50 +08001101 key.objectid = ino;
Yan Zhengd899e052008-10-30 14:25:28 -04001102 key.type = BTRFS_EXTENT_DATA_KEY;
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001103 key.offset = split;
Yan Zhengd899e052008-10-30 14:25:28 -04001104
1105 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
Josef Bacik41415732011-03-16 13:59:32 -04001106 if (ret < 0)
1107 goto out;
Yan Zhengd899e052008-10-30 14:25:28 -04001108 if (ret > 0 && path->slots[0] > 0)
1109 path->slots[0]--;
1110
1111 leaf = path->nodes[0];
1112 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
Li Zefan33345d012011-04-20 10:31:50 +08001113 BUG_ON(key.objectid != ino || key.type != BTRFS_EXTENT_DATA_KEY);
Yan Zhengd899e052008-10-30 14:25:28 -04001114 fi = btrfs_item_ptr(leaf, path->slots[0],
1115 struct btrfs_file_extent_item);
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001116 BUG_ON(btrfs_file_extent_type(leaf, fi) !=
1117 BTRFS_FILE_EXTENT_PREALLOC);
Yan Zhengd899e052008-10-30 14:25:28 -04001118 extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
1119 BUG_ON(key.offset > start || extent_end < end);
1120
1121 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1122 num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001123 orig_offset = key.offset - btrfs_file_extent_offset(leaf, fi);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001124 memcpy(&new_key, &key, sizeof(new_key));
1125
1126 if (start == key.offset && end < extent_end) {
1127 other_start = 0;
1128 other_end = start;
1129 if (extent_mergeable(leaf, path->slots[0] - 1,
Li Zefan33345d012011-04-20 10:31:50 +08001130 ino, bytenr, orig_offset,
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001131 &other_start, &other_end)) {
1132 new_key.offset = end;
Daniel Dresslerb7a03652014-11-12 13:43:09 +09001133 btrfs_set_item_key_safe(root->fs_info, path, &new_key);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001134 fi = btrfs_item_ptr(leaf, path->slots[0],
1135 struct btrfs_file_extent_item);
Josef Bacik224ecce2012-08-16 16:32:06 -04001136 btrfs_set_file_extent_generation(leaf, fi,
1137 trans->transid);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001138 btrfs_set_file_extent_num_bytes(leaf, fi,
1139 extent_end - end);
1140 btrfs_set_file_extent_offset(leaf, fi,
1141 end - orig_offset);
1142 fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
1143 struct btrfs_file_extent_item);
Josef Bacik224ecce2012-08-16 16:32:06 -04001144 btrfs_set_file_extent_generation(leaf, fi,
1145 trans->transid);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001146 btrfs_set_file_extent_num_bytes(leaf, fi,
1147 end - other_start);
1148 btrfs_mark_buffer_dirty(leaf);
1149 goto out;
1150 }
1151 }
1152
1153 if (start > key.offset && end == extent_end) {
1154 other_start = end;
1155 other_end = 0;
1156 if (extent_mergeable(leaf, path->slots[0] + 1,
Li Zefan33345d012011-04-20 10:31:50 +08001157 ino, bytenr, orig_offset,
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001158 &other_start, &other_end)) {
1159 fi = btrfs_item_ptr(leaf, path->slots[0],
1160 struct btrfs_file_extent_item);
1161 btrfs_set_file_extent_num_bytes(leaf, fi,
1162 start - key.offset);
Josef Bacik224ecce2012-08-16 16:32:06 -04001163 btrfs_set_file_extent_generation(leaf, fi,
1164 trans->transid);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001165 path->slots[0]++;
1166 new_key.offset = start;
Daniel Dresslerb7a03652014-11-12 13:43:09 +09001167 btrfs_set_item_key_safe(root->fs_info, path, &new_key);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001168
1169 fi = btrfs_item_ptr(leaf, path->slots[0],
1170 struct btrfs_file_extent_item);
Josef Bacik224ecce2012-08-16 16:32:06 -04001171 btrfs_set_file_extent_generation(leaf, fi,
1172 trans->transid);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001173 btrfs_set_file_extent_num_bytes(leaf, fi,
1174 other_end - start);
1175 btrfs_set_file_extent_offset(leaf, fi,
1176 start - orig_offset);
1177 btrfs_mark_buffer_dirty(leaf);
1178 goto out;
1179 }
1180 }
Yan Zhengd899e052008-10-30 14:25:28 -04001181
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001182 while (start > key.offset || end < extent_end) {
1183 if (key.offset == start)
1184 split = end;
Yan Zhengd899e052008-10-30 14:25:28 -04001185
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001186 new_key.offset = split;
1187 ret = btrfs_duplicate_item(trans, root, path, &new_key);
1188 if (ret == -EAGAIN) {
David Sterbab3b4aa72011-04-21 01:20:15 +02001189 btrfs_release_path(path);
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001190 goto again;
Yan Zhengd899e052008-10-30 14:25:28 -04001191 }
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001192 if (ret < 0) {
1193 btrfs_abort_transaction(trans, root, ret);
1194 goto out;
1195 }
Yan Zhengd899e052008-10-30 14:25:28 -04001196
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001197 leaf = path->nodes[0];
1198 fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
Yan Zhengd899e052008-10-30 14:25:28 -04001199 struct btrfs_file_extent_item);
Josef Bacik224ecce2012-08-16 16:32:06 -04001200 btrfs_set_file_extent_generation(leaf, fi, trans->transid);
Yan Zhengd899e052008-10-30 14:25:28 -04001201 btrfs_set_file_extent_num_bytes(leaf, fi,
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001202 split - key.offset);
1203
1204 fi = btrfs_item_ptr(leaf, path->slots[0],
1205 struct btrfs_file_extent_item);
1206
Josef Bacik224ecce2012-08-16 16:32:06 -04001207 btrfs_set_file_extent_generation(leaf, fi, trans->transid);
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001208 btrfs_set_file_extent_offset(leaf, fi, split - orig_offset);
1209 btrfs_set_file_extent_num_bytes(leaf, fi,
1210 extent_end - split);
Yan Zhengd899e052008-10-30 14:25:28 -04001211 btrfs_mark_buffer_dirty(leaf);
1212
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001213 ret = btrfs_inc_extent_ref(trans, root, bytenr, num_bytes, 0,
1214 root->root_key.objectid,
Filipe Mananab06c4bf2015-10-23 07:52:54 +01001215 ino, orig_offset);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001216 BUG_ON(ret); /* -ENOMEM */
Yan Zhengd899e052008-10-30 14:25:28 -04001217
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001218 if (split == start) {
1219 key.offset = start;
1220 } else {
1221 BUG_ON(start != key.offset);
Yan Zhengd899e052008-10-30 14:25:28 -04001222 path->slots[0]--;
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001223 extent_end = end;
Yan Zhengd899e052008-10-30 14:25:28 -04001224 }
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001225 recow = 1;
Yan Zhengd899e052008-10-30 14:25:28 -04001226 }
1227
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001228 other_start = end;
1229 other_end = 0;
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001230 if (extent_mergeable(leaf, path->slots[0] + 1,
Li Zefan33345d012011-04-20 10:31:50 +08001231 ino, bytenr, orig_offset,
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001232 &other_start, &other_end)) {
1233 if (recow) {
David Sterbab3b4aa72011-04-21 01:20:15 +02001234 btrfs_release_path(path);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001235 goto again;
1236 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001237 extent_end = other_end;
1238 del_slot = path->slots[0] + 1;
1239 del_nr++;
1240 ret = btrfs_free_extent(trans, root, bytenr, num_bytes,
1241 0, root->root_key.objectid,
Filipe Mananab06c4bf2015-10-23 07:52:54 +01001242 ino, orig_offset);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001243 BUG_ON(ret); /* -ENOMEM */
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001244 }
1245 other_start = 0;
1246 other_end = start;
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001247 if (extent_mergeable(leaf, path->slots[0] - 1,
Li Zefan33345d012011-04-20 10:31:50 +08001248 ino, bytenr, orig_offset,
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001249 &other_start, &other_end)) {
1250 if (recow) {
David Sterbab3b4aa72011-04-21 01:20:15 +02001251 btrfs_release_path(path);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001252 goto again;
1253 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001254 key.offset = other_start;
1255 del_slot = path->slots[0];
1256 del_nr++;
1257 ret = btrfs_free_extent(trans, root, bytenr, num_bytes,
1258 0, root->root_key.objectid,
Filipe Mananab06c4bf2015-10-23 07:52:54 +01001259 ino, orig_offset);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001260 BUG_ON(ret); /* -ENOMEM */
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001261 }
1262 if (del_nr == 0) {
Shaohua Li3f6fae92010-02-11 07:43:00 +00001263 fi = btrfs_item_ptr(leaf, path->slots[0],
1264 struct btrfs_file_extent_item);
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001265 btrfs_set_file_extent_type(leaf, fi,
1266 BTRFS_FILE_EXTENT_REG);
Josef Bacik224ecce2012-08-16 16:32:06 -04001267 btrfs_set_file_extent_generation(leaf, fi, trans->transid);
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001268 btrfs_mark_buffer_dirty(leaf);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001269 } else {
Shaohua Li3f6fae92010-02-11 07:43:00 +00001270 fi = btrfs_item_ptr(leaf, del_slot - 1,
1271 struct btrfs_file_extent_item);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001272 btrfs_set_file_extent_type(leaf, fi,
1273 BTRFS_FILE_EXTENT_REG);
Josef Bacik224ecce2012-08-16 16:32:06 -04001274 btrfs_set_file_extent_generation(leaf, fi, trans->transid);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001275 btrfs_set_file_extent_num_bytes(leaf, fi,
1276 extent_end - key.offset);
1277 btrfs_mark_buffer_dirty(leaf);
1278
1279 ret = btrfs_del_items(trans, root, path, del_slot, del_nr);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001280 if (ret < 0) {
1281 btrfs_abort_transaction(trans, root, ret);
1282 goto out;
1283 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001284 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001285out:
Yan Zhengd899e052008-10-30 14:25:28 -04001286 btrfs_free_path(path);
1287 return 0;
1288}
1289
Chris Mason39279cc2007-06-12 06:35:45 -04001290/*
Chris Masonb1bf8622011-02-28 09:52:08 -05001291 * on error we return an unlocked page and the error value
1292 * on success we return a locked page and 0
1293 */
Chris Masonbb1591b42015-12-14 15:40:44 -08001294static int prepare_uptodate_page(struct inode *inode,
1295 struct page *page, u64 pos,
Josef Bacikb63164292011-09-30 15:23:54 -04001296 bool force_uptodate)
Chris Masonb1bf8622011-02-28 09:52:08 -05001297{
1298 int ret = 0;
1299
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001300 if (((pos & (PAGE_SIZE - 1)) || force_uptodate) &&
Josef Bacikb63164292011-09-30 15:23:54 -04001301 !PageUptodate(page)) {
Chris Masonb1bf8622011-02-28 09:52:08 -05001302 ret = btrfs_readpage(NULL, page);
1303 if (ret)
1304 return ret;
1305 lock_page(page);
1306 if (!PageUptodate(page)) {
1307 unlock_page(page);
1308 return -EIO;
1309 }
Chris Masonbb1591b42015-12-14 15:40:44 -08001310 if (page->mapping != inode->i_mapping) {
1311 unlock_page(page);
1312 return -EAGAIN;
1313 }
Chris Masonb1bf8622011-02-28 09:52:08 -05001314 }
1315 return 0;
1316}
1317
1318/*
Miao Xie376cc682013-12-10 19:25:04 +08001319 * this just gets pages into the page cache and locks them down.
Chris Mason39279cc2007-06-12 06:35:45 -04001320 */
Miao Xieb37392e2013-12-10 19:25:03 +08001321static noinline int prepare_pages(struct inode *inode, struct page **pages,
1322 size_t num_pages, loff_t pos,
1323 size_t write_bytes, bool force_uptodate)
Chris Mason39279cc2007-06-12 06:35:45 -04001324{
1325 int i;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001326 unsigned long index = pos >> PAGE_SHIFT;
Josef Bacik3b16a4e2011-09-21 15:05:58 -04001327 gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping);
Filipe David Borba Mananafc28b622013-12-13 19:39:34 +00001328 int err = 0;
Miao Xie376cc682013-12-10 19:25:04 +08001329 int faili;
Chris Mason8c2383c2007-06-18 09:57:58 -04001330
Chris Mason39279cc2007-06-12 06:35:45 -04001331 for (i = 0; i < num_pages; i++) {
Chris Masonbb1591b42015-12-14 15:40:44 -08001332again:
Josef Bacika94733d2011-07-11 10:47:06 -04001333 pages[i] = find_or_create_page(inode->i_mapping, index + i,
Johannes Weinere3a41a52012-01-10 15:07:55 -08001334 mask | __GFP_WRITE);
Chris Mason39279cc2007-06-12 06:35:45 -04001335 if (!pages[i]) {
Chris Masonb1bf8622011-02-28 09:52:08 -05001336 faili = i - 1;
1337 err = -ENOMEM;
1338 goto fail;
1339 }
1340
1341 if (i == 0)
Chris Masonbb1591b42015-12-14 15:40:44 -08001342 err = prepare_uptodate_page(inode, pages[i], pos,
Josef Bacikb63164292011-09-30 15:23:54 -04001343 force_uptodate);
Chris Masonbb1591b42015-12-14 15:40:44 -08001344 if (!err && i == num_pages - 1)
1345 err = prepare_uptodate_page(inode, pages[i],
Josef Bacikb63164292011-09-30 15:23:54 -04001346 pos + write_bytes, false);
Chris Masonb1bf8622011-02-28 09:52:08 -05001347 if (err) {
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001348 put_page(pages[i]);
Chris Masonbb1591b42015-12-14 15:40:44 -08001349 if (err == -EAGAIN) {
1350 err = 0;
1351 goto again;
1352 }
Chris Masonb1bf8622011-02-28 09:52:08 -05001353 faili = i - 1;
1354 goto fail;
Chris Mason39279cc2007-06-12 06:35:45 -04001355 }
Chris Masonccd467d2007-06-28 15:57:36 -04001356 wait_on_page_writeback(pages[i]);
Chris Mason39279cc2007-06-12 06:35:45 -04001357 }
Chris Masone6dcd2d2008-07-17 12:53:50 -04001358
Chris Mason39279cc2007-06-12 06:35:45 -04001359 return 0;
Chris Masonb1bf8622011-02-28 09:52:08 -05001360fail:
1361 while (faili >= 0) {
1362 unlock_page(pages[faili]);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001363 put_page(pages[faili]);
Chris Masonb1bf8622011-02-28 09:52:08 -05001364 faili--;
1365 }
1366 return err;
1367
Chris Mason39279cc2007-06-12 06:35:45 -04001368}
1369
Miao Xie376cc682013-12-10 19:25:04 +08001370/*
1371 * This function locks the extent and properly waits for data=ordered extents
1372 * to finish before allowing the pages to be modified if need.
1373 *
1374 * The return value:
1375 * 1 - the extent is locked
1376 * 0 - the extent is not locked, and everything is OK
1377 * -EAGAIN - need re-prepare the pages
1378 * the other < 0 number - Something wrong happens
1379 */
1380static noinline int
1381lock_and_cleanup_extent_if_need(struct inode *inode, struct page **pages,
1382 size_t num_pages, loff_t pos,
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301383 size_t write_bytes,
Miao Xie376cc682013-12-10 19:25:04 +08001384 u64 *lockstart, u64 *lockend,
1385 struct extent_state **cached_state)
1386{
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301387 struct btrfs_root *root = BTRFS_I(inode)->root;
Miao Xie376cc682013-12-10 19:25:04 +08001388 u64 start_pos;
1389 u64 last_pos;
1390 int i;
1391 int ret = 0;
1392
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301393 start_pos = round_down(pos, root->sectorsize);
1394 last_pos = start_pos
1395 + round_up(pos + write_bytes - start_pos, root->sectorsize) - 1;
Miao Xie376cc682013-12-10 19:25:04 +08001396
1397 if (start_pos < inode->i_size) {
1398 struct btrfs_ordered_extent *ordered;
1399 lock_extent_bits(&BTRFS_I(inode)->io_tree,
David Sterbaff13db42015-12-03 14:30:40 +01001400 start_pos, last_pos, cached_state);
Miao Xieb88935b2014-03-06 13:54:58 +08001401 ordered = btrfs_lookup_ordered_range(inode, start_pos,
1402 last_pos - start_pos + 1);
Miao Xie376cc682013-12-10 19:25:04 +08001403 if (ordered &&
1404 ordered->file_offset + ordered->len > start_pos &&
1405 ordered->file_offset <= last_pos) {
Miao Xie376cc682013-12-10 19:25:04 +08001406 unlock_extent_cached(&BTRFS_I(inode)->io_tree,
1407 start_pos, last_pos,
1408 cached_state, GFP_NOFS);
1409 for (i = 0; i < num_pages; i++) {
1410 unlock_page(pages[i]);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001411 put_page(pages[i]);
Miao Xie376cc682013-12-10 19:25:04 +08001412 }
Miao Xieb88935b2014-03-06 13:54:58 +08001413 btrfs_start_ordered_extent(inode, ordered, 1);
1414 btrfs_put_ordered_extent(ordered);
1415 return -EAGAIN;
Miao Xie376cc682013-12-10 19:25:04 +08001416 }
1417 if (ordered)
1418 btrfs_put_ordered_extent(ordered);
1419
1420 clear_extent_bit(&BTRFS_I(inode)->io_tree, start_pos,
1421 last_pos, EXTENT_DIRTY | EXTENT_DELALLOC |
1422 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
1423 0, 0, cached_state, GFP_NOFS);
1424 *lockstart = start_pos;
1425 *lockend = last_pos;
1426 ret = 1;
1427 }
1428
1429 for (i = 0; i < num_pages; i++) {
1430 if (clear_page_dirty_for_io(pages[i]))
1431 account_page_redirty(pages[i]);
1432 set_page_extent_mapped(pages[i]);
1433 WARN_ON(!PageLocked(pages[i]));
1434 }
1435
1436 return ret;
1437}
1438
Josef Bacik7ee9e442013-06-21 16:37:03 -04001439static noinline int check_can_nocow(struct inode *inode, loff_t pos,
1440 size_t *write_bytes)
1441{
Josef Bacik7ee9e442013-06-21 16:37:03 -04001442 struct btrfs_root *root = BTRFS_I(inode)->root;
1443 struct btrfs_ordered_extent *ordered;
1444 u64 lockstart, lockend;
1445 u64 num_bytes;
1446 int ret;
1447
Filipe Manana9ea24bb2014-10-29 11:57:59 +00001448 ret = btrfs_start_write_no_snapshoting(root);
Miao Xie8257b2d2014-03-06 13:38:19 +08001449 if (!ret)
1450 return -ENOSPC;
1451
Josef Bacik7ee9e442013-06-21 16:37:03 -04001452 lockstart = round_down(pos, root->sectorsize);
Miao Xiec9339562014-02-27 13:58:04 +08001453 lockend = round_up(pos + *write_bytes, root->sectorsize) - 1;
Josef Bacik7ee9e442013-06-21 16:37:03 -04001454
1455 while (1) {
1456 lock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend);
1457 ordered = btrfs_lookup_ordered_range(inode, lockstart,
1458 lockend - lockstart + 1);
1459 if (!ordered) {
1460 break;
1461 }
1462 unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend);
1463 btrfs_start_ordered_extent(inode, ordered, 1);
1464 btrfs_put_ordered_extent(ordered);
1465 }
1466
Josef Bacik7ee9e442013-06-21 16:37:03 -04001467 num_bytes = lockend - lockstart + 1;
Josef Bacik00361582013-08-14 14:02:47 -04001468 ret = can_nocow_extent(inode, lockstart, &num_bytes, NULL, NULL, NULL);
Josef Bacik7ee9e442013-06-21 16:37:03 -04001469 if (ret <= 0) {
1470 ret = 0;
Filipe Manana9ea24bb2014-10-29 11:57:59 +00001471 btrfs_end_write_no_snapshoting(root);
Josef Bacik7ee9e442013-06-21 16:37:03 -04001472 } else {
Miao Xiec9339562014-02-27 13:58:04 +08001473 *write_bytes = min_t(size_t, *write_bytes ,
1474 num_bytes - pos + lockstart);
Josef Bacik7ee9e442013-06-21 16:37:03 -04001475 }
1476
1477 unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend);
1478
1479 return ret;
1480}
1481
Josef Bacikd0215f32011-01-25 14:57:24 -05001482static noinline ssize_t __btrfs_buffered_write(struct file *file,
1483 struct iov_iter *i,
1484 loff_t pos)
Josef Bacik4b46fce2010-05-23 11:00:55 -04001485{
Al Viro496ad9a2013-01-23 17:07:38 -05001486 struct inode *inode = file_inode(file);
Josef Bacik11c65dc2010-05-23 11:07:21 -04001487 struct btrfs_root *root = BTRFS_I(inode)->root;
Josef Bacik11c65dc2010-05-23 11:07:21 -04001488 struct page **pages = NULL;
Miao Xie376cc682013-12-10 19:25:04 +08001489 struct extent_state *cached_state = NULL;
Josef Bacik7ee9e442013-06-21 16:37:03 -04001490 u64 release_bytes = 0;
Miao Xie376cc682013-12-10 19:25:04 +08001491 u64 lockstart;
1492 u64 lockend;
Josef Bacikd0215f32011-01-25 14:57:24 -05001493 size_t num_written = 0;
1494 int nrptrs;
Tsutomu Itohc9149232011-03-30 00:57:23 +00001495 int ret = 0;
Josef Bacik7ee9e442013-06-21 16:37:03 -04001496 bool only_release_metadata = false;
Josef Bacikb63164292011-09-30 15:23:54 -04001497 bool force_page_uptodate = false;
Miao Xie376cc682013-12-10 19:25:04 +08001498 bool need_unlock;
Chris Masoncb843a62008-10-03 12:30:02 -04001499
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001500 nrptrs = min(DIV_ROUND_UP(iov_iter_count(i), PAGE_SIZE),
1501 PAGE_SIZE / (sizeof(struct page *)));
Wu Fengguang142349f2011-12-16 12:32:57 -05001502 nrptrs = min(nrptrs, current->nr_dirtied_pause - current->nr_dirtied);
1503 nrptrs = max(nrptrs, 8);
David Sterba31e818f2015-02-20 18:00:26 +01001504 pages = kmalloc_array(nrptrs, sizeof(struct page *), GFP_KERNEL);
Josef Bacikd0215f32011-01-25 14:57:24 -05001505 if (!pages)
1506 return -ENOMEM;
Chris Masonab93dbe2009-10-01 12:29:10 -04001507
Josef Bacikd0215f32011-01-25 14:57:24 -05001508 while (iov_iter_count(i) > 0) {
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001509 size_t offset = pos & (PAGE_SIZE - 1);
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301510 size_t sector_offset;
Josef Bacikd0215f32011-01-25 14:57:24 -05001511 size_t write_bytes = min(iov_iter_count(i),
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001512 nrptrs * (size_t)PAGE_SIZE -
Chris Mason8c2383c2007-06-18 09:57:58 -04001513 offset);
David Sterbaed6078f2014-06-05 01:59:57 +02001514 size_t num_pages = DIV_ROUND_UP(write_bytes + offset,
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001515 PAGE_SIZE);
Josef Bacik7ee9e442013-06-21 16:37:03 -04001516 size_t reserve_bytes;
Josef Bacikd0215f32011-01-25 14:57:24 -05001517 size_t dirty_pages;
1518 size_t copied;
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301519 size_t dirty_sectors;
1520 size_t num_sectors;
Chris Mason39279cc2007-06-12 06:35:45 -04001521
Chris Mason8c2383c2007-06-18 09:57:58 -04001522 WARN_ON(num_pages > nrptrs);
Chris Mason1832a6d2007-12-21 16:27:21 -05001523
Xin Zhong914ee292010-12-09 09:30:14 +00001524 /*
1525 * Fault pages before locking them in prepare_pages
1526 * to avoid recursive lock
1527 */
Josef Bacikd0215f32011-01-25 14:57:24 -05001528 if (unlikely(iov_iter_fault_in_readable(i, write_bytes))) {
Xin Zhong914ee292010-12-09 09:30:14 +00001529 ret = -EFAULT;
Josef Bacikd0215f32011-01-25 14:57:24 -05001530 break;
Xin Zhong914ee292010-12-09 09:30:14 +00001531 }
1532
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301533 sector_offset = pos & (root->sectorsize - 1);
1534 reserve_bytes = round_up(write_bytes + sector_offset,
1535 root->sectorsize);
Qu Wenruod9d8b2a2015-09-08 17:22:43 +08001536
Zhao Lei4da2e262016-01-06 18:24:43 +08001537 if ((BTRFS_I(inode)->flags & (BTRFS_INODE_NODATACOW |
1538 BTRFS_INODE_PREALLOC)) &&
1539 check_can_nocow(inode, pos, &write_bytes) > 0) {
1540 /*
1541 * For nodata cow case, no need to reserve
1542 * data space.
1543 */
1544 only_release_metadata = true;
1545 /*
1546 * our prealloc extent may be smaller than
1547 * write_bytes, so scale down.
1548 */
1549 num_pages = DIV_ROUND_UP(write_bytes + offset,
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001550 PAGE_SIZE);
David Sterbafa695b02016-02-26 15:38:34 +01001551 reserve_bytes = round_up(write_bytes + sector_offset,
1552 root->sectorsize);
Zhao Lei4da2e262016-01-06 18:24:43 +08001553 goto reserve_metadata;
Josef Bacik7ee9e442013-06-21 16:37:03 -04001554 }
Zhao Lei4da2e262016-01-06 18:24:43 +08001555
Qu Wenruo7cf5b972015-09-08 17:25:55 +08001556 ret = btrfs_check_data_free_space(inode, pos, write_bytes);
Qu Wenruod9d8b2a2015-09-08 17:22:43 +08001557 if (ret < 0)
Josef Bacikd0215f32011-01-25 14:57:24 -05001558 break;
Chris Mason1832a6d2007-12-21 16:27:21 -05001559
Qu Wenruod9d8b2a2015-09-08 17:22:43 +08001560reserve_metadata:
Josef Bacik7ee9e442013-06-21 16:37:03 -04001561 ret = btrfs_delalloc_reserve_metadata(inode, reserve_bytes);
1562 if (ret) {
1563 if (!only_release_metadata)
Qu Wenruo7cf5b972015-09-08 17:25:55 +08001564 btrfs_free_reserved_data_space(inode, pos,
1565 write_bytes);
Miao Xie8257b2d2014-03-06 13:38:19 +08001566 else
Filipe Manana9ea24bb2014-10-29 11:57:59 +00001567 btrfs_end_write_no_snapshoting(root);
Josef Bacik7ee9e442013-06-21 16:37:03 -04001568 break;
1569 }
1570
1571 release_bytes = reserve_bytes;
Miao Xie376cc682013-12-10 19:25:04 +08001572 need_unlock = false;
1573again:
Josef Bacik4a640012011-01-25 15:10:08 -05001574 /*
1575 * This is going to setup the pages array with the number of
1576 * pages we want, so we don't really need to worry about the
1577 * contents of pages from loop to loop
1578 */
Miao Xieb37392e2013-12-10 19:25:03 +08001579 ret = prepare_pages(inode, pages, num_pages,
1580 pos, write_bytes,
Josef Bacikb63164292011-09-30 15:23:54 -04001581 force_page_uptodate);
Josef Bacik7ee9e442013-06-21 16:37:03 -04001582 if (ret)
Josef Bacikd0215f32011-01-25 14:57:24 -05001583 break;
Chris Mason39279cc2007-06-12 06:35:45 -04001584
Miao Xie376cc682013-12-10 19:25:04 +08001585 ret = lock_and_cleanup_extent_if_need(inode, pages, num_pages,
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301586 pos, write_bytes, &lockstart,
1587 &lockend, &cached_state);
Miao Xie376cc682013-12-10 19:25:04 +08001588 if (ret < 0) {
1589 if (ret == -EAGAIN)
1590 goto again;
1591 break;
1592 } else if (ret > 0) {
1593 need_unlock = true;
1594 ret = 0;
1595 }
1596
Zhao Leiee22f0c2016-01-06 18:47:31 +08001597 copied = btrfs_copy_from_user(pos, write_bytes, pages, i);
Chris Masonb1bf8622011-02-28 09:52:08 -05001598
1599 /*
1600 * if we have trouble faulting in the pages, fall
1601 * back to one page at a time
1602 */
1603 if (copied < write_bytes)
1604 nrptrs = 1;
1605
Josef Bacikb63164292011-09-30 15:23:54 -04001606 if (copied == 0) {
1607 force_page_uptodate = true;
Chris Masonb1bf8622011-02-28 09:52:08 -05001608 dirty_pages = 0;
Josef Bacikb63164292011-09-30 15:23:54 -04001609 } else {
1610 force_page_uptodate = false;
David Sterbaed6078f2014-06-05 01:59:57 +02001611 dirty_pages = DIV_ROUND_UP(copied + offset,
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001612 PAGE_SIZE);
Josef Bacikb63164292011-09-30 15:23:54 -04001613 }
Xin Zhong914ee292010-12-09 09:30:14 +00001614
Josef Bacikd0215f32011-01-25 14:57:24 -05001615 /*
1616 * If we had a short copy we need to release the excess delaloc
1617 * bytes we reserved. We need to increment outstanding_extents
1618 * because btrfs_delalloc_release_space will decrement it, but
1619 * we still have an outstanding extent for the chunk we actually
1620 * managed to copy.
1621 */
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301622 num_sectors = BTRFS_BYTES_TO_BLKS(root->fs_info,
1623 reserve_bytes);
1624 dirty_sectors = round_up(copied + sector_offset,
1625 root->sectorsize);
1626 dirty_sectors = BTRFS_BYTES_TO_BLKS(root->fs_info,
1627 dirty_sectors);
1628
1629 if (num_sectors > dirty_sectors) {
1630 release_bytes = (write_bytes - copied)
1631 & ~((u64)root->sectorsize - 1);
Josef Bacik9e0baf62011-07-15 15:16:44 +00001632 if (copied > 0) {
1633 spin_lock(&BTRFS_I(inode)->lock);
1634 BTRFS_I(inode)->outstanding_extents++;
1635 spin_unlock(&BTRFS_I(inode)->lock);
1636 }
Qu Wenruo485290a2015-10-29 17:28:46 +08001637 if (only_release_metadata) {
Josef Bacik7ee9e442013-06-21 16:37:03 -04001638 btrfs_delalloc_release_metadata(inode,
1639 release_bytes);
Qu Wenruo485290a2015-10-29 17:28:46 +08001640 } else {
1641 u64 __pos;
1642
1643 __pos = round_down(pos, root->sectorsize) +
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001644 (dirty_pages << PAGE_SHIFT);
Qu Wenruo485290a2015-10-29 17:28:46 +08001645 btrfs_delalloc_release_space(inode, __pos,
Josef Bacik7ee9e442013-06-21 16:37:03 -04001646 release_bytes);
Qu Wenruo485290a2015-10-29 17:28:46 +08001647 }
Xin Zhong914ee292010-12-09 09:30:14 +00001648 }
1649
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301650 release_bytes = round_up(copied + sector_offset,
1651 root->sectorsize);
Miao Xie376cc682013-12-10 19:25:04 +08001652
1653 if (copied > 0)
Josef Bacikbe1a12a2011-04-06 13:05:22 -04001654 ret = btrfs_dirty_pages(root, inode, pages,
1655 dirty_pages, pos, copied,
1656 NULL);
Miao Xie376cc682013-12-10 19:25:04 +08001657 if (need_unlock)
1658 unlock_extent_cached(&BTRFS_I(inode)->io_tree,
1659 lockstart, lockend, &cached_state,
1660 GFP_NOFS);
Miao Xief1de9682014-01-09 10:06:10 +08001661 if (ret) {
1662 btrfs_drop_pages(pages, num_pages);
Miao Xie376cc682013-12-10 19:25:04 +08001663 break;
Miao Xief1de9682014-01-09 10:06:10 +08001664 }
Chris Mason39279cc2007-06-12 06:35:45 -04001665
Josef Bacik7ee9e442013-06-21 16:37:03 -04001666 release_bytes = 0;
Miao Xie8257b2d2014-03-06 13:38:19 +08001667 if (only_release_metadata)
Filipe Manana9ea24bb2014-10-29 11:57:59 +00001668 btrfs_end_write_no_snapshoting(root);
Miao Xie8257b2d2014-03-06 13:38:19 +08001669
Josef Bacik7ee9e442013-06-21 16:37:03 -04001670 if (only_release_metadata && copied > 0) {
David Sterbaf64c7b12015-02-24 19:07:26 +01001671 lockstart = round_down(pos, root->sectorsize);
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301672 lockend = round_up(pos + copied, root->sectorsize) - 1;
Josef Bacik7ee9e442013-06-21 16:37:03 -04001673
1674 set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
1675 lockend, EXTENT_NORESERVE, NULL,
1676 NULL, GFP_NOFS);
1677 only_release_metadata = false;
1678 }
1679
Miao Xief1de9682014-01-09 10:06:10 +08001680 btrfs_drop_pages(pages, num_pages);
1681
Josef Bacikd0215f32011-01-25 14:57:24 -05001682 cond_resched();
1683
Namjae Jeond0e1d662012-12-11 16:00:21 -08001684 balance_dirty_pages_ratelimited(inode->i_mapping);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001685 if (dirty_pages < (root->nodesize >> PAGE_SHIFT) + 1)
Liu Bob53d3f52012-11-14 14:34:34 +00001686 btrfs_btree_balance_dirty(root);
Chris Mason39279cc2007-06-12 06:35:45 -04001687
Xin Zhong914ee292010-12-09 09:30:14 +00001688 pos += copied;
1689 num_written += copied;
Chris Mason39279cc2007-06-12 06:35:45 -04001690 }
Chris Mason5b92ee72008-01-03 13:46:11 -05001691
Chris Mason8c2383c2007-06-18 09:57:58 -04001692 kfree(pages);
Josef Bacikd0215f32011-01-25 14:57:24 -05001693
Josef Bacik7ee9e442013-06-21 16:37:03 -04001694 if (release_bytes) {
Miao Xie8257b2d2014-03-06 13:38:19 +08001695 if (only_release_metadata) {
Filipe Manana9ea24bb2014-10-29 11:57:59 +00001696 btrfs_end_write_no_snapshoting(root);
Josef Bacik7ee9e442013-06-21 16:37:03 -04001697 btrfs_delalloc_release_metadata(inode, release_bytes);
Miao Xie8257b2d2014-03-06 13:38:19 +08001698 } else {
Qu Wenruo7cf5b972015-09-08 17:25:55 +08001699 btrfs_delalloc_release_space(inode, pos, release_bytes);
Miao Xie8257b2d2014-03-06 13:38:19 +08001700 }
Josef Bacik7ee9e442013-06-21 16:37:03 -04001701 }
1702
Josef Bacikd0215f32011-01-25 14:57:24 -05001703 return num_written ? num_written : ret;
1704}
1705
1706static ssize_t __btrfs_direct_write(struct kiocb *iocb,
Al Viro0ae5e4d2014-03-03 22:09:39 -05001707 struct iov_iter *from,
Al Viro0c949332014-03-22 06:51:37 -04001708 loff_t pos)
Josef Bacikd0215f32011-01-25 14:57:24 -05001709{
1710 struct file *file = iocb->ki_filp;
Filipe Manana728404d2014-10-10 09:43:11 +01001711 struct inode *inode = file_inode(file);
Josef Bacikd0215f32011-01-25 14:57:24 -05001712 ssize_t written;
1713 ssize_t written_buffered;
1714 loff_t endbyte;
1715 int err;
1716
Al Viro0c949332014-03-22 06:51:37 -04001717 written = generic_file_direct_write(iocb, from, pos);
Josef Bacikd0215f32011-01-25 14:57:24 -05001718
Al Viro0c949332014-03-22 06:51:37 -04001719 if (written < 0 || !iov_iter_count(from))
Josef Bacikd0215f32011-01-25 14:57:24 -05001720 return written;
1721
1722 pos += written;
Al Viro0ae5e4d2014-03-03 22:09:39 -05001723 written_buffered = __btrfs_buffered_write(file, from, pos);
Josef Bacikd0215f32011-01-25 14:57:24 -05001724 if (written_buffered < 0) {
1725 err = written_buffered;
1726 goto out;
1727 }
Filipe Manana075bdbd2014-10-09 21:18:55 +01001728 /*
1729 * Ensure all data is persisted. We want the next direct IO read to be
1730 * able to read what was just written.
1731 */
Josef Bacikd0215f32011-01-25 14:57:24 -05001732 endbyte = pos + written_buffered - 1;
Filipe Manana728404d2014-10-10 09:43:11 +01001733 err = btrfs_fdatawrite_range(inode, pos, endbyte);
Filipe Manana075bdbd2014-10-09 21:18:55 +01001734 if (err)
1735 goto out;
Filipe Manana728404d2014-10-10 09:43:11 +01001736 err = filemap_fdatawait_range(inode->i_mapping, pos, endbyte);
Josef Bacikd0215f32011-01-25 14:57:24 -05001737 if (err)
1738 goto out;
1739 written += written_buffered;
Al Viro867c4f92014-02-11 19:31:06 -05001740 iocb->ki_pos = pos + written_buffered;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001741 invalidate_mapping_pages(file->f_mapping, pos >> PAGE_SHIFT,
1742 endbyte >> PAGE_SHIFT);
Josef Bacikd0215f32011-01-25 14:57:24 -05001743out:
1744 return written ? written : err;
1745}
1746
Josef Bacik6c760c02012-11-09 10:53:21 -05001747static void update_time_for_write(struct inode *inode)
1748{
1749 struct timespec now;
1750
1751 if (IS_NOCMTIME(inode))
1752 return;
1753
1754 now = current_fs_time(inode->i_sb);
1755 if (!timespec_equal(&inode->i_mtime, &now))
1756 inode->i_mtime = now;
1757
1758 if (!timespec_equal(&inode->i_ctime, &now))
1759 inode->i_ctime = now;
1760
1761 if (IS_I_VERSION(inode))
1762 inode_inc_iversion(inode);
1763}
1764
Al Virob30ac0f2014-04-03 14:29:04 -04001765static ssize_t btrfs_file_write_iter(struct kiocb *iocb,
1766 struct iov_iter *from)
Josef Bacikd0215f32011-01-25 14:57:24 -05001767{
1768 struct file *file = iocb->ki_filp;
Al Viro496ad9a2013-01-23 17:07:38 -05001769 struct inode *inode = file_inode(file);
Josef Bacikd0215f32011-01-25 14:57:24 -05001770 struct btrfs_root *root = BTRFS_I(inode)->root;
Miao Xie0c1a98c2011-09-11 10:52:24 -04001771 u64 start_pos;
Qu Wenruo3ac0d7b2014-03-27 02:51:58 +00001772 u64 end_pos;
Josef Bacikd0215f32011-01-25 14:57:24 -05001773 ssize_t num_written = 0;
Josef Bacikb812ce22012-11-16 13:56:32 -05001774 bool sync = (file->f_flags & O_DSYNC) || IS_SYNC(file->f_mapping->host);
Al Viro3309dd02015-04-09 12:55:47 -04001775 ssize_t err;
1776 loff_t pos;
1777 size_t count;
Chandan Rajendra27772b62016-01-21 15:56:03 +05301778 loff_t oldsize;
1779 int clean_page = 0;
Josef Bacikd0215f32011-01-25 14:57:24 -05001780
Al Viro59551022016-01-22 15:40:57 -05001781 inode_lock(inode);
Al Viro3309dd02015-04-09 12:55:47 -04001782 err = generic_write_checks(iocb, from);
1783 if (err <= 0) {
Al Viro59551022016-01-22 15:40:57 -05001784 inode_unlock(inode);
Al Viro3309dd02015-04-09 12:55:47 -04001785 return err;
1786 }
Josef Bacikd0215f32011-01-25 14:57:24 -05001787
Christoph Hellwigde1414a2015-01-14 10:42:36 +01001788 current->backing_dev_info = inode_to_bdi(inode);
Jan Kara5fa8e0a2015-05-21 16:05:53 +02001789 err = file_remove_privs(file);
Josef Bacikd0215f32011-01-25 14:57:24 -05001790 if (err) {
Al Viro59551022016-01-22 15:40:57 -05001791 inode_unlock(inode);
Josef Bacikd0215f32011-01-25 14:57:24 -05001792 goto out;
1793 }
1794
1795 /*
1796 * If BTRFS flips readonly due to some impossible error
1797 * (fs_info->fs_state now has BTRFS_SUPER_FLAG_ERROR),
1798 * although we have opened a file as writable, we have
1799 * to stop this write operation to ensure FS consistency.
1800 */
Miao Xie87533c42013-01-29 10:14:48 +00001801 if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
Al Viro59551022016-01-22 15:40:57 -05001802 inode_unlock(inode);
Josef Bacikd0215f32011-01-25 14:57:24 -05001803 err = -EROFS;
1804 goto out;
1805 }
1806
Josef Bacik6c760c02012-11-09 10:53:21 -05001807 /*
1808 * We reserve space for updating the inode when we reserve space for the
1809 * extent we are going to write, so we will enospc out there. We don't
1810 * need to start yet another transaction to update the inode as we will
1811 * update the inode when we finish writing whatever data we write.
1812 */
1813 update_time_for_write(inode);
Josef Bacikd0215f32011-01-25 14:57:24 -05001814
Al Viro3309dd02015-04-09 12:55:47 -04001815 pos = iocb->ki_pos;
1816 count = iov_iter_count(from);
Miao Xie0c1a98c2011-09-11 10:52:24 -04001817 start_pos = round_down(pos, root->sectorsize);
Chandan Rajendra27772b62016-01-21 15:56:03 +05301818 oldsize = i_size_read(inode);
1819 if (start_pos > oldsize) {
Qu Wenruo3ac0d7b2014-03-27 02:51:58 +00001820 /* Expand hole size to cover write data, preventing empty gap */
Qu Wenruoc5f7d0b2014-04-15 10:41:00 +08001821 end_pos = round_up(pos + count, root->sectorsize);
Chandan Rajendra27772b62016-01-21 15:56:03 +05301822 err = btrfs_cont_expand(inode, oldsize, end_pos);
Miao Xie0c1a98c2011-09-11 10:52:24 -04001823 if (err) {
Al Viro59551022016-01-22 15:40:57 -05001824 inode_unlock(inode);
Miao Xie0c1a98c2011-09-11 10:52:24 -04001825 goto out;
1826 }
Chandan Rajendra27772b62016-01-21 15:56:03 +05301827 if (start_pos > round_up(oldsize, root->sectorsize))
1828 clean_page = 1;
Miao Xie0c1a98c2011-09-11 10:52:24 -04001829 }
1830
Josef Bacikb812ce22012-11-16 13:56:32 -05001831 if (sync)
1832 atomic_inc(&BTRFS_I(inode)->sync_writers);
1833
Al Viro2ba48ce2015-04-09 13:52:01 -04001834 if (iocb->ki_flags & IOCB_DIRECT) {
Al Virob30ac0f2014-04-03 14:29:04 -04001835 num_written = __btrfs_direct_write(iocb, from, pos);
Josef Bacikd0215f32011-01-25 14:57:24 -05001836 } else {
Al Virob30ac0f2014-04-03 14:29:04 -04001837 num_written = __btrfs_buffered_write(file, from, pos);
Josef Bacikd0215f32011-01-25 14:57:24 -05001838 if (num_written > 0)
Al Viro867c4f92014-02-11 19:31:06 -05001839 iocb->ki_pos = pos + num_written;
Chandan Rajendra27772b62016-01-21 15:56:03 +05301840 if (clean_page)
1841 pagecache_isize_extended(inode, oldsize,
1842 i_size_read(inode));
Josef Bacikd0215f32011-01-25 14:57:24 -05001843 }
1844
Al Viro59551022016-01-22 15:40:57 -05001845 inode_unlock(inode);
Chris Mason2ff3e9b2007-10-29 14:36:41 -04001846
Chris Mason5a3f23d2009-03-31 13:27:11 -04001847 /*
Josef Bacik6c760c02012-11-09 10:53:21 -05001848 * We also have to set last_sub_trans to the current log transid,
1849 * otherwise subsequent syncs to a file that's been synced in this
Adam Buchbinderbb7ab3b2016-03-04 11:23:12 -08001850 * transaction will appear to have already occurred.
Chris Mason5a3f23d2009-03-31 13:27:11 -04001851 */
Filipe Manana2f2ff0e2015-03-20 17:19:46 +00001852 spin_lock(&BTRFS_I(inode)->lock);
Josef Bacik6c760c02012-11-09 10:53:21 -05001853 BTRFS_I(inode)->last_sub_trans = root->log_transid;
Filipe Manana2f2ff0e2015-03-20 17:19:46 +00001854 spin_unlock(&BTRFS_I(inode)->lock);
Christoph Hellwig02afc272013-09-04 15:04:40 +02001855 if (num_written > 0) {
Josef Bacikd0215f32011-01-25 14:57:24 -05001856 err = generic_write_sync(file, pos, num_written);
Dan Carpenter45d4f852014-04-03 14:47:17 -07001857 if (err < 0)
Chris Mason2ff3e9b2007-10-29 14:36:41 -04001858 num_written = err;
1859 }
Miao Xie0a3404d2013-01-28 12:34:55 +00001860
Josef Bacikb812ce22012-11-16 13:56:32 -05001861 if (sync)
1862 atomic_dec(&BTRFS_I(inode)->sync_writers);
Miao Xie0a3404d2013-01-28 12:34:55 +00001863out:
Chris Mason39279cc2007-06-12 06:35:45 -04001864 current->backing_dev_info = NULL;
Chris Mason39279cc2007-06-12 06:35:45 -04001865 return num_written ? num_written : err;
1866}
1867
Chris Masond3977122009-01-05 21:25:51 -05001868int btrfs_release_file(struct inode *inode, struct file *filp)
Mingminge1b81e62008-05-27 10:55:43 -04001869{
Sage Weil6bf13c02008-06-10 10:07:39 -04001870 if (filp->private_data)
1871 btrfs_ioctl_trans_end(filp);
Chris Masonf6dc45c2014-08-20 07:15:33 -07001872 /*
1873 * ordered_data_close is set by settattr when we are about to truncate
1874 * a file from a non-zero size to a zero size. This tries to
1875 * flush down new bytes that may have been written if the
1876 * application were using truncate to replace a file in place.
1877 */
1878 if (test_and_clear_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
1879 &BTRFS_I(inode)->runtime_flags))
1880 filemap_flush(inode->i_mapping);
Mingminge1b81e62008-05-27 10:55:43 -04001881 return 0;
1882}
1883
Filipe Manana669249e2014-09-02 11:09:58 +01001884static int start_ordered_ops(struct inode *inode, loff_t start, loff_t end)
1885{
1886 int ret;
1887
1888 atomic_inc(&BTRFS_I(inode)->sync_writers);
Filipe Manana728404d2014-10-10 09:43:11 +01001889 ret = btrfs_fdatawrite_range(inode, start, end);
Filipe Manana669249e2014-09-02 11:09:58 +01001890 atomic_dec(&BTRFS_I(inode)->sync_writers);
1891
1892 return ret;
1893}
1894
Chris Masond352ac62008-09-29 15:18:18 -04001895/*
1896 * fsync call for both files and directories. This logs the inode into
1897 * the tree log instead of forcing full commits whenever possible.
1898 *
1899 * It needs to call filemap_fdatawait so that all ordered extent updates are
1900 * in the metadata btree are up to date for copying to the log.
1901 *
1902 * It drops the inode mutex before doing the tree log commit. This is an
1903 * important optimization for directories because holding the mutex prevents
1904 * new operations on the dir while we write to disk.
1905 */
Josef Bacik02c24a82011-07-16 20:44:56 -04001906int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
Chris Mason39279cc2007-06-12 06:35:45 -04001907{
Filipe Mananade17e792016-03-30 19:03:13 -04001908 struct dentry *dentry = file_dentry(file);
David Howells2b0143b2015-03-17 22:25:59 +00001909 struct inode *inode = d_inode(dentry);
Chris Mason39279cc2007-06-12 06:35:45 -04001910 struct btrfs_root *root = BTRFS_I(inode)->root;
Chris Mason39279cc2007-06-12 06:35:45 -04001911 struct btrfs_trans_handle *trans;
Miao Xie8b050d32014-02-20 18:08:58 +08001912 struct btrfs_log_ctx ctx;
1913 int ret = 0;
Josef Bacik2ab28f32012-10-12 15:27:49 -04001914 bool full_sync = 0;
David Sterba9dcbeed2015-11-09 11:44:45 +01001915 u64 len;
Chris Mason39279cc2007-06-12 06:35:45 -04001916
David Sterba9dcbeed2015-11-09 11:44:45 +01001917 /*
1918 * The range length can be represented by u64, we have to do the typecasts
1919 * to avoid signed overflow if it's [0, LLONG_MAX] eg. from fsync()
1920 */
1921 len = (u64)end - (u64)start + 1;
liubo1abe9b82011-03-24 11:18:59 +00001922 trace_btrfs_sync_file(file, datasync);
Chris Mason257c62e2009-10-13 13:21:08 -04001923
Miao Xie90abccf2012-09-13 04:53:47 -06001924 /*
1925 * We write the dirty pages in the range and wait until they complete
1926 * out of the ->i_mutex. If so, we can flush the dirty pages by
Josef Bacik2ab28f32012-10-12 15:27:49 -04001927 * multi-task, and make the performance up. See
1928 * btrfs_wait_ordered_range for an explanation of the ASYNC check.
Miao Xie90abccf2012-09-13 04:53:47 -06001929 */
Filipe Manana669249e2014-09-02 11:09:58 +01001930 ret = start_ordered_ops(inode, start, end);
Miao Xie90abccf2012-09-13 04:53:47 -06001931 if (ret)
1932 return ret;
1933
Al Viro59551022016-01-22 15:40:57 -05001934 inode_lock(inode);
Miao Xie2ecb7922012-09-06 04:04:27 -06001935 atomic_inc(&root->log_batch);
Josef Bacik2ab28f32012-10-12 15:27:49 -04001936 full_sync = test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
1937 &BTRFS_I(inode)->runtime_flags);
Filipe Manana669249e2014-09-02 11:09:58 +01001938 /*
1939 * We might have have had more pages made dirty after calling
1940 * start_ordered_ops and before acquiring the inode's i_mutex.
1941 */
Josef Bacik0ef8b722013-10-25 16:13:35 -04001942 if (full_sync) {
Filipe Manana669249e2014-09-02 11:09:58 +01001943 /*
1944 * For a full sync, we need to make sure any ordered operations
1945 * start and finish before we start logging the inode, so that
1946 * all extents are persisted and the respective file extent
1947 * items are in the fs/subvol btree.
1948 */
Filipe Mananab659ef02015-03-31 14:16:52 +01001949 ret = btrfs_wait_ordered_range(inode, start, len);
Filipe Manana669249e2014-09-02 11:09:58 +01001950 } else {
1951 /*
1952 * Start any new ordered operations before starting to log the
1953 * inode. We will wait for them to finish in btrfs_sync_log().
1954 *
1955 * Right before acquiring the inode's mutex, we might have new
1956 * writes dirtying pages, which won't immediately start the
1957 * respective ordered operations - that is done through the
1958 * fill_delalloc callbacks invoked from the writepage and
1959 * writepages address space operations. So make sure we start
1960 * all ordered operations before starting to log our inode. Not
1961 * doing this means that while logging the inode, writeback
1962 * could start and invoke writepage/writepages, which would call
1963 * the fill_delalloc callbacks (cow_file_range,
1964 * submit_compressed_extents). These callbacks add first an
1965 * extent map to the modified list of extents and then create
1966 * the respective ordered operation, which means in
1967 * tree-log.c:btrfs_log_inode() we might capture all existing
1968 * ordered operations (with btrfs_get_logged_extents()) before
1969 * the fill_delalloc callback adds its ordered operation, and by
1970 * the time we visit the modified list of extent maps (with
1971 * btrfs_log_changed_extents()), we see and process the extent
1972 * map they created. We then use the extent map to construct a
1973 * file extent item for logging without waiting for the
1974 * respective ordered operation to finish - this file extent
1975 * item points to a disk location that might not have yet been
1976 * written to, containing random data - so after a crash a log
1977 * replay will make our inode have file extent items that point
1978 * to disk locations containing invalid data, as we returned
1979 * success to userspace without waiting for the respective
1980 * ordered operation to finish, because it wasn't captured by
1981 * btrfs_get_logged_extents().
1982 */
1983 ret = start_ordered_ops(inode, start, end);
1984 }
1985 if (ret) {
Al Viro59551022016-01-22 15:40:57 -05001986 inode_unlock(inode);
Filipe Manana669249e2014-09-02 11:09:58 +01001987 goto out;
Josef Bacik0ef8b722013-10-25 16:13:35 -04001988 }
Miao Xie2ecb7922012-09-06 04:04:27 -06001989 atomic_inc(&root->log_batch);
Chris Mason257c62e2009-10-13 13:21:08 -04001990
Chris Mason39279cc2007-06-12 06:35:45 -04001991 /*
Filipe Manana3a8b36f2015-03-01 20:36:00 +00001992 * If the last transaction that changed this file was before the current
1993 * transaction and we have the full sync flag set in our inode, we can
1994 * bail out now without any syncing.
1995 *
1996 * Note that we can't bail out if the full sync flag isn't set. This is
1997 * because when the full sync flag is set we start all ordered extents
1998 * and wait for them to fully complete - when they complete they update
1999 * the inode's last_trans field through:
2000 *
2001 * btrfs_finish_ordered_io() ->
2002 * btrfs_update_inode_fallback() ->
2003 * btrfs_update_inode() ->
2004 * btrfs_set_inode_last_trans()
2005 *
2006 * So we are sure that last_trans is up to date and can do this check to
2007 * bail out safely. For the fast path, when the full sync flag is not
2008 * set in our inode, we can not do it because we start only our ordered
2009 * extents and don't wait for them to complete (that is when
2010 * btrfs_finish_ordered_io runs), so here at this point their last_trans
2011 * value might be less than or equals to fs_info->last_trans_committed,
2012 * and setting a speculative last_trans for an inode when a buffered
2013 * write is made (such as fs_info->generation + 1 for example) would not
2014 * be reliable since after setting the value and before fsync is called
2015 * any number of transactions can start and commit (transaction kthread
2016 * commits the current transaction periodically), and a transaction
2017 * commit does not start nor waits for ordered extents to complete.
Chris Mason257c62e2009-10-13 13:21:08 -04002018 */
Josef Bacika4abeea2011-04-11 17:25:13 -04002019 smp_mb();
Josef Bacik22ee6982012-05-29 16:57:49 -04002020 if (btrfs_inode_in_log(inode, root->fs_info->generation) ||
Filipe Mananaaffc0ff2016-02-24 07:35:05 +00002021 (full_sync && BTRFS_I(inode)->last_trans <=
2022 root->fs_info->last_trans_committed) ||
2023 (!btrfs_have_ordered_extents_in_range(inode, start, len) &&
2024 BTRFS_I(inode)->last_trans
2025 <= root->fs_info->last_trans_committed)) {
Josef Bacik5dc562c2012-08-17 13:14:17 -04002026 /*
2027 * We'v had everything committed since the last time we were
2028 * modified so clear this flag in case it was set for whatever
2029 * reason, it's no longer relevant.
2030 */
2031 clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
2032 &BTRFS_I(inode)->runtime_flags);
Al Viro59551022016-01-22 15:40:57 -05002033 inode_unlock(inode);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04002034 goto out;
2035 }
Josef Bacik15ee9bc2007-08-10 16:22:09 -04002036
2037 /*
Chris Masona52d9a82007-08-27 16:49:44 -04002038 * ok we haven't committed the transaction yet, lets do a commit
2039 */
Dan Carpenter6f902af2010-05-29 09:49:07 +00002040 if (file->private_data)
Sage Weil6bf13c02008-06-10 10:07:39 -04002041 btrfs_ioctl_trans_end(file);
2042
Josef Bacik5039edd2014-01-15 13:34:13 -05002043 /*
2044 * We use start here because we will need to wait on the IO to complete
2045 * in btrfs_sync_log, which could require joining a transaction (for
2046 * example checking cross references in the nocow path). If we use join
2047 * here we could get into a situation where we're waiting on IO to
2048 * happen that is blocked on a transaction trying to commit. With start
2049 * we inc the extwriter counter, so we wait for all extwriters to exit
2050 * before we start blocking join'ers. This comment is to keep somebody
2051 * from thinking they are super smart and changing this to
2052 * btrfs_join_transaction *cough*Josef*cough*.
2053 */
Yan, Zhenga22285a2010-05-16 10:48:46 -04002054 trans = btrfs_start_transaction(root, 0);
2055 if (IS_ERR(trans)) {
2056 ret = PTR_ERR(trans);
Al Viro59551022016-01-22 15:40:57 -05002057 inode_unlock(inode);
Chris Mason39279cc2007-06-12 06:35:45 -04002058 goto out;
2059 }
Josef Bacik5039edd2014-01-15 13:34:13 -05002060 trans->sync = true;
Chris Masone02119d2008-09-05 16:13:11 -04002061
Miao Xie8b050d32014-02-20 18:08:58 +08002062 btrfs_init_log_ctx(&ctx);
2063
Filipe Manana49dae1b2014-09-06 22:34:39 +01002064 ret = btrfs_log_dentry_safe(trans, root, dentry, start, end, &ctx);
Josef Bacik02c24a82011-07-16 20:44:56 -04002065 if (ret < 0) {
Filipe David Borba Mananaa0634be2013-09-11 20:36:44 +01002066 /* Fallthrough and commit/free transaction. */
2067 ret = 1;
Josef Bacik02c24a82011-07-16 20:44:56 -04002068 }
Chris Mason49eb7e42008-09-11 15:53:12 -04002069
2070 /* we've logged all the items and now have a consistent
2071 * version of the file in the log. It is possible that
2072 * someone will come in and modify the file, but that's
2073 * fine because the log is consistent on disk, and we
2074 * have references to all of the file's extents
2075 *
2076 * It is possible that someone will come in and log the
2077 * file again, but that will end up using the synchronization
2078 * inside btrfs_sync_log to keep things safe.
2079 */
Al Viro59551022016-01-22 15:40:57 -05002080 inode_unlock(inode);
Chris Mason49eb7e42008-09-11 15:53:12 -04002081
Filipe Manana8407f552014-09-05 15:14:39 +01002082 /*
2083 * If any of the ordered extents had an error, just return it to user
2084 * space, so that the application knows some writes didn't succeed and
2085 * can take proper action (retry for e.g.). Blindly committing the
2086 * transaction in this case, would fool userspace that everything was
2087 * successful. And we also want to make sure our log doesn't contain
2088 * file extent items pointing to extents that weren't fully written to -
2089 * just like in the non fast fsync path, where we check for the ordered
2090 * operation's error flag before writing to the log tree and return -EIO
2091 * if any of them had this flag set (btrfs_wait_ordered_range) -
2092 * therefore we need to check for errors in the ordered operations,
2093 * which are indicated by ctx.io_err.
2094 */
2095 if (ctx.io_err) {
2096 btrfs_end_transaction(trans, root);
2097 ret = ctx.io_err;
2098 goto out;
2099 }
2100
Chris Mason257c62e2009-10-13 13:21:08 -04002101 if (ret != BTRFS_NO_LOG_SYNC) {
Josef Bacik0ef8b722013-10-25 16:13:35 -04002102 if (!ret) {
Miao Xie8b050d32014-02-20 18:08:58 +08002103 ret = btrfs_sync_log(trans, root, &ctx);
Josef Bacik0ef8b722013-10-25 16:13:35 -04002104 if (!ret) {
Chris Mason257c62e2009-10-13 13:21:08 -04002105 ret = btrfs_end_transaction(trans, root);
Josef Bacik0ef8b722013-10-25 16:13:35 -04002106 goto out;
Josef Bacik2ab28f32012-10-12 15:27:49 -04002107 }
Chris Mason257c62e2009-10-13 13:21:08 -04002108 }
Josef Bacik0ef8b722013-10-25 16:13:35 -04002109 if (!full_sync) {
David Sterba9dcbeed2015-11-09 11:44:45 +01002110 ret = btrfs_wait_ordered_range(inode, start, len);
Filipe Mananab05fd872014-05-29 23:31:39 +01002111 if (ret) {
2112 btrfs_end_transaction(trans, root);
Josef Bacik0ef8b722013-10-25 16:13:35 -04002113 goto out;
Filipe Mananab05fd872014-05-29 23:31:39 +01002114 }
Josef Bacik0ef8b722013-10-25 16:13:35 -04002115 }
2116 ret = btrfs_commit_transaction(trans, root);
Chris Mason257c62e2009-10-13 13:21:08 -04002117 } else {
2118 ret = btrfs_end_transaction(trans, root);
Chris Masone02119d2008-09-05 16:13:11 -04002119 }
Chris Mason39279cc2007-06-12 06:35:45 -04002120out:
Roel Kluin014e4ac2010-01-29 10:42:11 +00002121 return ret > 0 ? -EIO : ret;
Chris Mason39279cc2007-06-12 06:35:45 -04002122}
2123
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +04002124static const struct vm_operations_struct btrfs_file_vm_ops = {
Chris Mason92fee662007-07-25 12:31:35 -04002125 .fault = filemap_fault,
Kirill A. Shutemovf1820362014-04-07 15:37:19 -07002126 .map_pages = filemap_map_pages,
Chris Mason9ebefb182007-06-15 13:50:00 -04002127 .page_mkwrite = btrfs_page_mkwrite,
2128};
2129
2130static int btrfs_file_mmap(struct file *filp, struct vm_area_struct *vma)
2131{
Miao Xie058a4572010-05-20 07:21:50 +00002132 struct address_space *mapping = filp->f_mapping;
2133
2134 if (!mapping->a_ops->readpage)
2135 return -ENOEXEC;
2136
Chris Mason9ebefb182007-06-15 13:50:00 -04002137 file_accessed(filp);
Miao Xie058a4572010-05-20 07:21:50 +00002138 vma->vm_ops = &btrfs_file_vm_ops;
Miao Xie058a4572010-05-20 07:21:50 +00002139
Chris Mason9ebefb182007-06-15 13:50:00 -04002140 return 0;
2141}
2142
Josef Bacik2aaa6652012-08-29 14:27:18 -04002143static int hole_mergeable(struct inode *inode, struct extent_buffer *leaf,
2144 int slot, u64 start, u64 end)
2145{
2146 struct btrfs_file_extent_item *fi;
2147 struct btrfs_key key;
2148
2149 if (slot < 0 || slot >= btrfs_header_nritems(leaf))
2150 return 0;
2151
2152 btrfs_item_key_to_cpu(leaf, &key, slot);
2153 if (key.objectid != btrfs_ino(inode) ||
2154 key.type != BTRFS_EXTENT_DATA_KEY)
2155 return 0;
2156
2157 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
2158
2159 if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
2160 return 0;
2161
2162 if (btrfs_file_extent_disk_bytenr(leaf, fi))
2163 return 0;
2164
2165 if (key.offset == end)
2166 return 1;
2167 if (key.offset + btrfs_file_extent_num_bytes(leaf, fi) == start)
2168 return 1;
2169 return 0;
2170}
2171
2172static int fill_holes(struct btrfs_trans_handle *trans, struct inode *inode,
2173 struct btrfs_path *path, u64 offset, u64 end)
2174{
2175 struct btrfs_root *root = BTRFS_I(inode)->root;
2176 struct extent_buffer *leaf;
2177 struct btrfs_file_extent_item *fi;
2178 struct extent_map *hole_em;
2179 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
2180 struct btrfs_key key;
2181 int ret;
2182
Josef Bacik16e75492013-10-22 12:18:51 -04002183 if (btrfs_fs_incompat(root->fs_info, NO_HOLES))
2184 goto out;
2185
Josef Bacik2aaa6652012-08-29 14:27:18 -04002186 key.objectid = btrfs_ino(inode);
2187 key.type = BTRFS_EXTENT_DATA_KEY;
2188 key.offset = offset;
2189
Josef Bacik2aaa6652012-08-29 14:27:18 -04002190 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2191 if (ret < 0)
2192 return ret;
2193 BUG_ON(!ret);
2194
2195 leaf = path->nodes[0];
2196 if (hole_mergeable(inode, leaf, path->slots[0]-1, offset, end)) {
2197 u64 num_bytes;
2198
2199 path->slots[0]--;
2200 fi = btrfs_item_ptr(leaf, path->slots[0],
2201 struct btrfs_file_extent_item);
2202 num_bytes = btrfs_file_extent_num_bytes(leaf, fi) +
2203 end - offset;
2204 btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
2205 btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
2206 btrfs_set_file_extent_offset(leaf, fi, 0);
2207 btrfs_mark_buffer_dirty(leaf);
2208 goto out;
2209 }
2210
chandan1707e262014-07-01 12:04:28 +05302211 if (hole_mergeable(inode, leaf, path->slots[0], offset, end)) {
Josef Bacik2aaa6652012-08-29 14:27:18 -04002212 u64 num_bytes;
2213
Josef Bacik2aaa6652012-08-29 14:27:18 -04002214 key.offset = offset;
Daniel Dresslerb7a03652014-11-12 13:43:09 +09002215 btrfs_set_item_key_safe(root->fs_info, path, &key);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002216 fi = btrfs_item_ptr(leaf, path->slots[0],
2217 struct btrfs_file_extent_item);
2218 num_bytes = btrfs_file_extent_num_bytes(leaf, fi) + end -
2219 offset;
2220 btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
2221 btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
2222 btrfs_set_file_extent_offset(leaf, fi, 0);
2223 btrfs_mark_buffer_dirty(leaf);
2224 goto out;
2225 }
2226 btrfs_release_path(path);
2227
2228 ret = btrfs_insert_file_extent(trans, root, btrfs_ino(inode), offset,
2229 0, 0, end - offset, 0, end - offset,
2230 0, 0, 0);
2231 if (ret)
2232 return ret;
2233
2234out:
2235 btrfs_release_path(path);
2236
2237 hole_em = alloc_extent_map();
2238 if (!hole_em) {
2239 btrfs_drop_extent_cache(inode, offset, end - 1, 0);
2240 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
2241 &BTRFS_I(inode)->runtime_flags);
2242 } else {
2243 hole_em->start = offset;
2244 hole_em->len = end - offset;
Josef Bacikcc95bef2013-04-04 14:31:27 -04002245 hole_em->ram_bytes = hole_em->len;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002246 hole_em->orig_start = offset;
2247
2248 hole_em->block_start = EXTENT_MAP_HOLE;
2249 hole_em->block_len = 0;
Josef Bacikb4939682012-12-03 10:31:19 -05002250 hole_em->orig_block_len = 0;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002251 hole_em->bdev = root->fs_info->fs_devices->latest_bdev;
2252 hole_em->compress_type = BTRFS_COMPRESS_NONE;
2253 hole_em->generation = trans->transid;
2254
2255 do {
2256 btrfs_drop_extent_cache(inode, offset, end - 1, 0);
2257 write_lock(&em_tree->lock);
Josef Bacik09a2a8f92013-04-05 16:51:15 -04002258 ret = add_extent_mapping(em_tree, hole_em, 1);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002259 write_unlock(&em_tree->lock);
2260 } while (ret == -EEXIST);
2261 free_extent_map(hole_em);
2262 if (ret)
2263 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
2264 &BTRFS_I(inode)->runtime_flags);
2265 }
2266
2267 return 0;
2268}
2269
Qu Wenruod7781542014-05-30 15:16:10 +08002270/*
2271 * Find a hole extent on given inode and change start/len to the end of hole
2272 * extent.(hole/vacuum extent whose em->start <= start &&
2273 * em->start + em->len > start)
2274 * When a hole extent is found, return 1 and modify start/len.
2275 */
2276static int find_first_non_hole(struct inode *inode, u64 *start, u64 *len)
2277{
2278 struct extent_map *em;
2279 int ret = 0;
2280
2281 em = btrfs_get_extent(inode, NULL, 0, *start, *len, 0);
2282 if (IS_ERR_OR_NULL(em)) {
2283 if (!em)
2284 ret = -ENOMEM;
2285 else
2286 ret = PTR_ERR(em);
2287 return ret;
2288 }
2289
2290 /* Hole or vacuum extent(only exists in no-hole mode) */
2291 if (em->block_start == EXTENT_MAP_HOLE) {
2292 ret = 1;
2293 *len = em->start + em->len > *start + *len ?
2294 0 : *start + *len - em->start - em->len;
2295 *start = em->start + em->len;
2296 }
2297 free_extent_map(em);
2298 return ret;
2299}
2300
Josef Bacik2aaa6652012-08-29 14:27:18 -04002301static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
2302{
2303 struct btrfs_root *root = BTRFS_I(inode)->root;
2304 struct extent_state *cached_state = NULL;
2305 struct btrfs_path *path;
2306 struct btrfs_block_rsv *rsv;
2307 struct btrfs_trans_handle *trans;
Qu Wenruod7781542014-05-30 15:16:10 +08002308 u64 lockstart;
2309 u64 lockend;
2310 u64 tail_start;
2311 u64 tail_len;
2312 u64 orig_start = offset;
2313 u64 cur_offset;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002314 u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
2315 u64 drop_end;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002316 int ret = 0;
2317 int err = 0;
Alexandru Moise6e4d6fa2015-09-22 21:00:07 +00002318 unsigned int rsv_count;
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302319 bool same_block;
Josef Bacik16e75492013-10-22 12:18:51 -04002320 bool no_holes = btrfs_fs_incompat(root->fs_info, NO_HOLES);
Filipe Mananaa1a50f62014-04-26 01:35:31 +01002321 u64 ino_size;
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302322 bool truncated_block = false;
Filipe Mananae8c1c762015-02-15 22:38:54 +00002323 bool updated_inode = false;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002324
Josef Bacik0ef8b722013-10-25 16:13:35 -04002325 ret = btrfs_wait_ordered_range(inode, offset, len);
2326 if (ret)
2327 return ret;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002328
Al Viro59551022016-01-22 15:40:57 -05002329 inode_lock(inode);
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302330 ino_size = round_up(inode->i_size, root->sectorsize);
Qu Wenruod7781542014-05-30 15:16:10 +08002331 ret = find_first_non_hole(inode, &offset, &len);
2332 if (ret < 0)
2333 goto out_only_mutex;
2334 if (ret && !len) {
2335 /* Already in a large hole */
2336 ret = 0;
2337 goto out_only_mutex;
2338 }
2339
Qu Wenruo51f395a2014-08-08 13:06:20 +08002340 lockstart = round_up(offset, BTRFS_I(inode)->root->sectorsize);
Qu Wenruod7781542014-05-30 15:16:10 +08002341 lockend = round_down(offset + len,
2342 BTRFS_I(inode)->root->sectorsize) - 1;
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302343 same_block = (BTRFS_BYTES_TO_BLKS(root->fs_info, offset))
2344 == (BTRFS_BYTES_TO_BLKS(root->fs_info, offset + len - 1));
Miao Xie7426cc02012-12-05 10:54:52 +00002345 /*
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302346 * We needn't truncate any block which is beyond the end of the file
Miao Xie7426cc02012-12-05 10:54:52 +00002347 * because we are sure there is no data there.
2348 */
Josef Bacik2aaa6652012-08-29 14:27:18 -04002349 /*
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302350 * Only do this if we are in the same block and we aren't doing the
2351 * entire block.
Josef Bacik2aaa6652012-08-29 14:27:18 -04002352 */
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302353 if (same_block && len < root->sectorsize) {
Filipe Mananae8c1c762015-02-15 22:38:54 +00002354 if (offset < ino_size) {
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302355 truncated_block = true;
2356 ret = btrfs_truncate_block(inode, offset, len, 0);
Filipe Mananae8c1c762015-02-15 22:38:54 +00002357 } else {
2358 ret = 0;
2359 }
Qu Wenruod7781542014-05-30 15:16:10 +08002360 goto out_only_mutex;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002361 }
2362
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302363 /* zero back part of the first block */
Filipe Manana12870f12014-02-15 15:55:58 +00002364 if (offset < ino_size) {
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302365 truncated_block = true;
2366 ret = btrfs_truncate_block(inode, offset, 0, 0);
Miao Xie7426cc02012-12-05 10:54:52 +00002367 if (ret) {
Al Viro59551022016-01-22 15:40:57 -05002368 inode_unlock(inode);
Miao Xie7426cc02012-12-05 10:54:52 +00002369 return ret;
2370 }
Josef Bacik2aaa6652012-08-29 14:27:18 -04002371 }
2372
Qu Wenruod7781542014-05-30 15:16:10 +08002373 /* Check the aligned pages after the first unaligned page,
2374 * if offset != orig_start, which means the first unaligned page
2375 * including serveral following pages are already in holes,
2376 * the extra check can be skipped */
2377 if (offset == orig_start) {
2378 /* after truncate page, check hole again */
2379 len = offset + len - lockstart;
2380 offset = lockstart;
2381 ret = find_first_non_hole(inode, &offset, &len);
2382 if (ret < 0)
2383 goto out_only_mutex;
2384 if (ret && !len) {
2385 ret = 0;
2386 goto out_only_mutex;
2387 }
2388 lockstart = offset;
2389 }
2390
2391 /* Check the tail unaligned part is in a hole */
2392 tail_start = lockend + 1;
2393 tail_len = offset + len - tail_start;
2394 if (tail_len) {
2395 ret = find_first_non_hole(inode, &tail_start, &tail_len);
2396 if (unlikely(ret < 0))
2397 goto out_only_mutex;
2398 if (!ret) {
2399 /* zero the front end of the last page */
2400 if (tail_start + tail_len < ino_size) {
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302401 truncated_block = true;
2402 ret = btrfs_truncate_block(inode,
2403 tail_start + tail_len,
2404 0, 1);
Qu Wenruod7781542014-05-30 15:16:10 +08002405 if (ret)
2406 goto out_only_mutex;
Qu Wenruo51f395a2014-08-08 13:06:20 +08002407 }
Miao Xie00612802012-12-05 10:54:12 +00002408 }
Josef Bacik2aaa6652012-08-29 14:27:18 -04002409 }
2410
2411 if (lockend < lockstart) {
Filipe Mananae8c1c762015-02-15 22:38:54 +00002412 ret = 0;
2413 goto out_only_mutex;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002414 }
2415
2416 while (1) {
2417 struct btrfs_ordered_extent *ordered;
2418
2419 truncate_pagecache_range(inode, lockstart, lockend);
2420
2421 lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
David Sterbaff13db42015-12-03 14:30:40 +01002422 &cached_state);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002423 ordered = btrfs_lookup_first_ordered_extent(inode, lockend);
2424
2425 /*
2426 * We need to make sure we have no ordered extents in this range
2427 * and nobody raced in and read a page in this range, if we did
2428 * we need to try again.
2429 */
2430 if ((!ordered ||
Filipe David Borba Manana6126e3c2013-11-19 16:19:24 +00002431 (ordered->file_offset + ordered->len <= lockstart ||
Josef Bacik2aaa6652012-08-29 14:27:18 -04002432 ordered->file_offset > lockend)) &&
Alex Gartrellfc4adbf2014-05-20 13:07:56 -07002433 !btrfs_page_exists_in_range(inode, lockstart, lockend)) {
Josef Bacik2aaa6652012-08-29 14:27:18 -04002434 if (ordered)
2435 btrfs_put_ordered_extent(ordered);
2436 break;
2437 }
2438 if (ordered)
2439 btrfs_put_ordered_extent(ordered);
2440 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart,
2441 lockend, &cached_state, GFP_NOFS);
Josef Bacik0ef8b722013-10-25 16:13:35 -04002442 ret = btrfs_wait_ordered_range(inode, lockstart,
2443 lockend - lockstart + 1);
2444 if (ret) {
Al Viro59551022016-01-22 15:40:57 -05002445 inode_unlock(inode);
Josef Bacik0ef8b722013-10-25 16:13:35 -04002446 return ret;
2447 }
Josef Bacik2aaa6652012-08-29 14:27:18 -04002448 }
2449
2450 path = btrfs_alloc_path();
2451 if (!path) {
2452 ret = -ENOMEM;
2453 goto out;
2454 }
2455
Miao Xie66d8f3d2012-09-06 04:02:28 -06002456 rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002457 if (!rsv) {
2458 ret = -ENOMEM;
2459 goto out_free;
2460 }
2461 rsv->size = btrfs_calc_trunc_metadata_size(root, 1);
2462 rsv->failfast = 1;
2463
2464 /*
2465 * 1 - update the inode
2466 * 1 - removing the extents in the range
Josef Bacik16e75492013-10-22 12:18:51 -04002467 * 1 - adding the hole extent if no_holes isn't set
Josef Bacik2aaa6652012-08-29 14:27:18 -04002468 */
Josef Bacik16e75492013-10-22 12:18:51 -04002469 rsv_count = no_holes ? 2 : 3;
2470 trans = btrfs_start_transaction(root, rsv_count);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002471 if (IS_ERR(trans)) {
2472 err = PTR_ERR(trans);
2473 goto out_free;
2474 }
2475
2476 ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv, rsv,
2477 min_size);
2478 BUG_ON(ret);
2479 trans->block_rsv = rsv;
2480
Qu Wenruod7781542014-05-30 15:16:10 +08002481 cur_offset = lockstart;
2482 len = lockend - cur_offset;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002483 while (cur_offset < lockend) {
2484 ret = __btrfs_drop_extents(trans, root, inode, path,
2485 cur_offset, lockend + 1,
Filipe David Borba Manana1acae572014-01-07 11:42:27 +00002486 &drop_end, 1, 0, 0, NULL);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002487 if (ret != -ENOSPC)
2488 break;
2489
2490 trans->block_rsv = &root->fs_info->trans_block_rsv;
2491
Filipe Manana12870f12014-02-15 15:55:58 +00002492 if (cur_offset < ino_size) {
2493 ret = fill_holes(trans, inode, path, cur_offset,
2494 drop_end);
2495 if (ret) {
2496 err = ret;
2497 break;
2498 }
Josef Bacik2aaa6652012-08-29 14:27:18 -04002499 }
2500
2501 cur_offset = drop_end;
2502
2503 ret = btrfs_update_inode(trans, root, inode);
2504 if (ret) {
2505 err = ret;
2506 break;
2507 }
2508
Josef Bacik2aaa6652012-08-29 14:27:18 -04002509 btrfs_end_transaction(trans, root);
Liu Bob53d3f52012-11-14 14:34:34 +00002510 btrfs_btree_balance_dirty(root);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002511
Josef Bacik16e75492013-10-22 12:18:51 -04002512 trans = btrfs_start_transaction(root, rsv_count);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002513 if (IS_ERR(trans)) {
2514 ret = PTR_ERR(trans);
2515 trans = NULL;
2516 break;
2517 }
2518
2519 ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv,
2520 rsv, min_size);
2521 BUG_ON(ret); /* shouldn't happen */
2522 trans->block_rsv = rsv;
Qu Wenruod7781542014-05-30 15:16:10 +08002523
2524 ret = find_first_non_hole(inode, &cur_offset, &len);
2525 if (unlikely(ret < 0))
2526 break;
2527 if (ret && !len) {
2528 ret = 0;
2529 break;
2530 }
Josef Bacik2aaa6652012-08-29 14:27:18 -04002531 }
2532
2533 if (ret) {
2534 err = ret;
2535 goto out_trans;
2536 }
2537
2538 trans->block_rsv = &root->fs_info->trans_block_rsv;
Filipe Mananafc19c5e2014-04-29 13:18:40 +01002539 /*
Filipe Manana2959a322015-11-02 12:32:44 +00002540 * If we are using the NO_HOLES feature we might have had already an
2541 * hole that overlaps a part of the region [lockstart, lockend] and
2542 * ends at (or beyond) lockend. Since we have no file extent items to
2543 * represent holes, drop_end can be less than lockend and so we must
2544 * make sure we have an extent map representing the existing hole (the
2545 * call to __btrfs_drop_extents() might have dropped the existing extent
2546 * map representing the existing hole), otherwise the fast fsync path
2547 * will not record the existence of the hole region
2548 * [existing_hole_start, lockend].
2549 */
2550 if (drop_end <= lockend)
2551 drop_end = lockend + 1;
2552 /*
Filipe Mananafc19c5e2014-04-29 13:18:40 +01002553 * Don't insert file hole extent item if it's for a range beyond eof
2554 * (because it's useless) or if it represents a 0 bytes range (when
2555 * cur_offset == drop_end).
2556 */
2557 if (cur_offset < ino_size && cur_offset < drop_end) {
Filipe Manana12870f12014-02-15 15:55:58 +00002558 ret = fill_holes(trans, inode, path, cur_offset, drop_end);
2559 if (ret) {
2560 err = ret;
2561 goto out_trans;
2562 }
Josef Bacik2aaa6652012-08-29 14:27:18 -04002563 }
2564
2565out_trans:
2566 if (!trans)
2567 goto out_free;
2568
Tsutomu Itohe1f57902012-11-08 04:47:33 +00002569 inode_inc_iversion(inode);
Deepa Dinamani04b285f2016-02-06 23:57:21 -08002570 inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb);
Tsutomu Itohe1f57902012-11-08 04:47:33 +00002571
Josef Bacik2aaa6652012-08-29 14:27:18 -04002572 trans->block_rsv = &root->fs_info->trans_block_rsv;
2573 ret = btrfs_update_inode(trans, root, inode);
Filipe Mananae8c1c762015-02-15 22:38:54 +00002574 updated_inode = true;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002575 btrfs_end_transaction(trans, root);
Liu Bob53d3f52012-11-14 14:34:34 +00002576 btrfs_btree_balance_dirty(root);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002577out_free:
2578 btrfs_free_path(path);
2579 btrfs_free_block_rsv(root, rsv);
2580out:
2581 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
2582 &cached_state, GFP_NOFS);
Qu Wenruod7781542014-05-30 15:16:10 +08002583out_only_mutex:
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302584 if (!updated_inode && truncated_block && !ret && !err) {
Filipe Mananae8c1c762015-02-15 22:38:54 +00002585 /*
2586 * If we only end up zeroing part of a page, we still need to
2587 * update the inode item, so that all the time fields are
2588 * updated as well as the necessary btrfs inode in memory fields
2589 * for detecting, at fsync time, if the inode isn't yet in the
2590 * log tree or it's there but not up to date.
2591 */
2592 trans = btrfs_start_transaction(root, 1);
2593 if (IS_ERR(trans)) {
2594 err = PTR_ERR(trans);
2595 } else {
2596 err = btrfs_update_inode(trans, root, inode);
2597 ret = btrfs_end_transaction(trans, root);
2598 }
2599 }
Al Viro59551022016-01-22 15:40:57 -05002600 inode_unlock(inode);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002601 if (ret && !err)
2602 err = ret;
2603 return err;
2604}
2605
Qu Wenruo14524a82015-09-08 17:22:44 +08002606/* Helper structure to record which range is already reserved */
2607struct falloc_range {
2608 struct list_head list;
2609 u64 start;
2610 u64 len;
2611};
2612
2613/*
2614 * Helper function to add falloc range
2615 *
2616 * Caller should have locked the larger range of extent containing
2617 * [start, len)
2618 */
2619static int add_falloc_range(struct list_head *head, u64 start, u64 len)
2620{
2621 struct falloc_range *prev = NULL;
2622 struct falloc_range *range = NULL;
2623
2624 if (list_empty(head))
2625 goto insert;
2626
2627 /*
2628 * As fallocate iterate by bytenr order, we only need to check
2629 * the last range.
2630 */
2631 prev = list_entry(head->prev, struct falloc_range, list);
2632 if (prev->start + prev->len == start) {
2633 prev->len += len;
2634 return 0;
2635 }
2636insert:
David Sterba32fc9322016-02-11 14:25:38 +01002637 range = kmalloc(sizeof(*range), GFP_KERNEL);
Qu Wenruo14524a82015-09-08 17:22:44 +08002638 if (!range)
2639 return -ENOMEM;
2640 range->start = start;
2641 range->len = len;
2642 list_add_tail(&range->list, head);
2643 return 0;
2644}
2645
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002646static long btrfs_fallocate(struct file *file, int mode,
2647 loff_t offset, loff_t len)
2648{
Al Viro496ad9a2013-01-23 17:07:38 -05002649 struct inode *inode = file_inode(file);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002650 struct extent_state *cached_state = NULL;
Qu Wenruo14524a82015-09-08 17:22:44 +08002651 struct falloc_range *range;
2652 struct falloc_range *tmp;
2653 struct list_head reserve_list;
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002654 u64 cur_offset;
2655 u64 last_byte;
2656 u64 alloc_start;
2657 u64 alloc_end;
2658 u64 alloc_hint = 0;
2659 u64 locked_end;
Qu Wenruo14524a82015-09-08 17:22:44 +08002660 u64 actual_end = 0;
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002661 struct extent_map *em;
Miao Xie797f4272012-11-28 10:28:07 +00002662 int blocksize = BTRFS_I(inode)->root->sectorsize;
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002663 int ret;
2664
Miao Xie797f4272012-11-28 10:28:07 +00002665 alloc_start = round_down(offset, blocksize);
2666 alloc_end = round_up(offset + len, blocksize);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002667
Josef Bacik2aaa6652012-08-29 14:27:18 -04002668 /* Make sure we aren't being give some crap mode */
2669 if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002670 return -EOPNOTSUPP;
2671
Josef Bacik2aaa6652012-08-29 14:27:18 -04002672 if (mode & FALLOC_FL_PUNCH_HOLE)
2673 return btrfs_punch_hole(inode, offset, len);
2674
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002675 /*
Qu Wenruo14524a82015-09-08 17:22:44 +08002676 * Only trigger disk allocation, don't trigger qgroup reserve
2677 *
2678 * For qgroup space, it will be checked later.
Chris Masond98456f2012-01-31 20:27:41 -05002679 */
Qu Wenruo14524a82015-09-08 17:22:44 +08002680 ret = btrfs_alloc_data_chunk_ondemand(inode, alloc_end - alloc_start);
2681 if (ret < 0)
Chris Masond98456f2012-01-31 20:27:41 -05002682 return ret;
2683
Al Viro59551022016-01-22 15:40:57 -05002684 inode_lock(inode);
Davide Italiano2a162ce2015-04-06 22:09:15 -07002685
2686 if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + len > inode->i_size) {
2687 ret = inode_newsize_ok(inode, offset + len);
2688 if (ret)
2689 goto out;
2690 }
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002691
Qu Wenruo14524a82015-09-08 17:22:44 +08002692 /*
2693 * TODO: Move these two operations after we have checked
2694 * accurate reserved space, or fallocate can still fail but
2695 * with page truncated or size expanded.
2696 *
2697 * But that's a minor problem and won't do much harm BTW.
2698 */
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002699 if (alloc_start > inode->i_size) {
Josef Bacika41ad392011-01-31 15:30:16 -05002700 ret = btrfs_cont_expand(inode, i_size_read(inode),
2701 alloc_start);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002702 if (ret)
2703 goto out;
Qu Wenruo0f6925f2015-10-14 15:26:13 +08002704 } else if (offset + len > inode->i_size) {
Josef Bacika71754f2013-06-17 17:14:39 -04002705 /*
2706 * If we are fallocating from the end of the file onward we
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302707 * need to zero out the end of the block if i_size lands in the
2708 * middle of a block.
Josef Bacika71754f2013-06-17 17:14:39 -04002709 */
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302710 ret = btrfs_truncate_block(inode, inode->i_size, 0, 0);
Josef Bacika71754f2013-06-17 17:14:39 -04002711 if (ret)
2712 goto out;
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002713 }
2714
Josef Bacika71754f2013-06-17 17:14:39 -04002715 /*
2716 * wait for ordered IO before we have any locks. We'll loop again
2717 * below with the locks held.
2718 */
Josef Bacik0ef8b722013-10-25 16:13:35 -04002719 ret = btrfs_wait_ordered_range(inode, alloc_start,
2720 alloc_end - alloc_start);
2721 if (ret)
2722 goto out;
Josef Bacika71754f2013-06-17 17:14:39 -04002723
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002724 locked_end = alloc_end - 1;
2725 while (1) {
2726 struct btrfs_ordered_extent *ordered;
2727
2728 /* the extent lock is ordered inside the running
2729 * transaction
2730 */
2731 lock_extent_bits(&BTRFS_I(inode)->io_tree, alloc_start,
David Sterbaff13db42015-12-03 14:30:40 +01002732 locked_end, &cached_state);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002733 ordered = btrfs_lookup_first_ordered_extent(inode,
2734 alloc_end - 1);
2735 if (ordered &&
2736 ordered->file_offset + ordered->len > alloc_start &&
2737 ordered->file_offset < alloc_end) {
2738 btrfs_put_ordered_extent(ordered);
2739 unlock_extent_cached(&BTRFS_I(inode)->io_tree,
2740 alloc_start, locked_end,
David Sterba32fc9322016-02-11 14:25:38 +01002741 &cached_state, GFP_KERNEL);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002742 /*
2743 * we can't wait on the range with the transaction
2744 * running or with the extent lock held
2745 */
Josef Bacik0ef8b722013-10-25 16:13:35 -04002746 ret = btrfs_wait_ordered_range(inode, alloc_start,
2747 alloc_end - alloc_start);
2748 if (ret)
2749 goto out;
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002750 } else {
2751 if (ordered)
2752 btrfs_put_ordered_extent(ordered);
2753 break;
2754 }
2755 }
2756
Qu Wenruo14524a82015-09-08 17:22:44 +08002757 /* First, check if we exceed the qgroup limit */
2758 INIT_LIST_HEAD(&reserve_list);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002759 cur_offset = alloc_start;
2760 while (1) {
2761 em = btrfs_get_extent(inode, NULL, 0, cur_offset,
2762 alloc_end - cur_offset, 0);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01002763 if (IS_ERR_OR_NULL(em)) {
2764 if (!em)
2765 ret = -ENOMEM;
2766 else
2767 ret = PTR_ERR(em);
2768 break;
2769 }
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002770 last_byte = min(extent_map_end(em), alloc_end);
Josef Bacikf1e490a2011-08-18 10:36:39 -04002771 actual_end = min_t(u64, extent_map_end(em), offset + len);
Miao Xie797f4272012-11-28 10:28:07 +00002772 last_byte = ALIGN(last_byte, blocksize);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002773 if (em->block_start == EXTENT_MAP_HOLE ||
2774 (cur_offset >= inode->i_size &&
2775 !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) {
Qu Wenruo14524a82015-09-08 17:22:44 +08002776 ret = add_falloc_range(&reserve_list, cur_offset,
2777 last_byte - cur_offset);
2778 if (ret < 0) {
2779 free_extent_map(em);
2780 break;
Filipe Manana3d850dd2015-03-12 23:23:13 +00002781 }
Qu Wenruo14524a82015-09-08 17:22:44 +08002782 ret = btrfs_qgroup_reserve_data(inode, cur_offset,
2783 last_byte - cur_offset);
2784 if (ret < 0)
2785 break;
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002786 }
2787 free_extent_map(em);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002788 cur_offset = last_byte;
Qu Wenruo14524a82015-09-08 17:22:44 +08002789 if (cur_offset >= alloc_end)
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002790 break;
Qu Wenruo14524a82015-09-08 17:22:44 +08002791 }
2792
2793 /*
2794 * If ret is still 0, means we're OK to fallocate.
2795 * Or just cleanup the list and exit.
2796 */
2797 list_for_each_entry_safe(range, tmp, &reserve_list, list) {
2798 if (!ret)
2799 ret = btrfs_prealloc_file_range(inode, mode,
2800 range->start,
2801 range->len, 1 << inode->i_blkbits,
2802 offset + len, &alloc_hint);
2803 list_del(&range->list);
2804 kfree(range);
2805 }
2806 if (ret < 0)
2807 goto out_unlock;
2808
2809 if (actual_end > inode->i_size &&
2810 !(mode & FALLOC_FL_KEEP_SIZE)) {
2811 struct btrfs_trans_handle *trans;
2812 struct btrfs_root *root = BTRFS_I(inode)->root;
2813
2814 /*
2815 * We didn't need to allocate any more space, but we
2816 * still extended the size of the file so we need to
2817 * update i_size and the inode item.
2818 */
2819 trans = btrfs_start_transaction(root, 1);
2820 if (IS_ERR(trans)) {
2821 ret = PTR_ERR(trans);
2822 } else {
Deepa Dinamani04b285f2016-02-06 23:57:21 -08002823 inode->i_ctime = current_fs_time(inode->i_sb);
Qu Wenruo14524a82015-09-08 17:22:44 +08002824 i_size_write(inode, actual_end);
2825 btrfs_ordered_update_i_size(inode, actual_end, NULL);
2826 ret = btrfs_update_inode(trans, root, inode);
2827 if (ret)
2828 btrfs_end_transaction(trans, root);
2829 else
2830 ret = btrfs_end_transaction(trans, root);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002831 }
2832 }
Qu Wenruo14524a82015-09-08 17:22:44 +08002833out_unlock:
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002834 unlock_extent_cached(&BTRFS_I(inode)->io_tree, alloc_start, locked_end,
David Sterba32fc9322016-02-11 14:25:38 +01002835 &cached_state, GFP_KERNEL);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002836out:
Qu Wenruo14524a82015-09-08 17:22:44 +08002837 /*
2838 * As we waited the extent range, the data_rsv_map must be empty
2839 * in the range, as written data range will be released from it.
2840 * And for prealloacted extent, it will also be released when
2841 * its metadata is written.
2842 * So this is completely used as cleanup.
2843 */
2844 btrfs_qgroup_free_data(inode, alloc_start, alloc_end - alloc_start);
Al Viro59551022016-01-22 15:40:57 -05002845 inode_unlock(inode);
Chris Masond98456f2012-01-31 20:27:41 -05002846 /* Let go of our reservation. */
Qu Wenruo7cf5b972015-09-08 17:25:55 +08002847 btrfs_free_reserved_data_space(inode, alloc_start,
2848 alloc_end - alloc_start);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002849 return ret;
2850}
2851
Andrew Morton965c8e52012-12-17 15:59:39 -08002852static int find_desired_extent(struct inode *inode, loff_t *offset, int whence)
Josef Bacikb2675152011-07-18 13:21:36 -04002853{
2854 struct btrfs_root *root = BTRFS_I(inode)->root;
Josef Bacik7f4ca372013-10-18 11:44:46 -04002855 struct extent_map *em = NULL;
Josef Bacikb2675152011-07-18 13:21:36 -04002856 struct extent_state *cached_state = NULL;
Liu Bo4d1a40c2014-09-16 17:49:30 +08002857 u64 lockstart;
2858 u64 lockend;
2859 u64 start;
2860 u64 len;
Josef Bacikb2675152011-07-18 13:21:36 -04002861 int ret = 0;
2862
Josef Bacikb2675152011-07-18 13:21:36 -04002863 if (inode->i_size == 0)
2864 return -ENXIO;
2865
Liu Bo4d1a40c2014-09-16 17:49:30 +08002866 /*
2867 * *offset can be negative, in this case we start finding DATA/HOLE from
2868 * the very start of the file.
2869 */
2870 start = max_t(loff_t, 0, *offset);
2871
2872 lockstart = round_down(start, root->sectorsize);
2873 lockend = round_up(i_size_read(inode), root->sectorsize);
2874 if (lockend <= lockstart)
2875 lockend = lockstart + root->sectorsize;
2876 lockend--;
2877 len = lockend - lockstart + 1;
2878
David Sterbaff13db42015-12-03 14:30:40 +01002879 lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
Jeff Mahoneyd0082372012-03-01 14:57:19 +01002880 &cached_state);
Josef Bacikb2675152011-07-18 13:21:36 -04002881
Josef Bacik7f4ca372013-10-18 11:44:46 -04002882 while (start < inode->i_size) {
Josef Bacikb2675152011-07-18 13:21:36 -04002883 em = btrfs_get_extent_fiemap(inode, NULL, 0, start, len, 0);
2884 if (IS_ERR(em)) {
Jeff Liu6af021d2012-02-09 14:25:50 +08002885 ret = PTR_ERR(em);
Josef Bacik7f4ca372013-10-18 11:44:46 -04002886 em = NULL;
Josef Bacikb2675152011-07-18 13:21:36 -04002887 break;
2888 }
2889
Josef Bacik7f4ca372013-10-18 11:44:46 -04002890 if (whence == SEEK_HOLE &&
2891 (em->block_start == EXTENT_MAP_HOLE ||
2892 test_bit(EXTENT_FLAG_PREALLOC, &em->flags)))
2893 break;
2894 else if (whence == SEEK_DATA &&
2895 (em->block_start != EXTENT_MAP_HOLE &&
2896 !test_bit(EXTENT_FLAG_PREALLOC, &em->flags)))
2897 break;
Josef Bacikb2675152011-07-18 13:21:36 -04002898
2899 start = em->start + em->len;
Josef Bacikb2675152011-07-18 13:21:36 -04002900 free_extent_map(em);
Josef Bacik7f4ca372013-10-18 11:44:46 -04002901 em = NULL;
Josef Bacikb2675152011-07-18 13:21:36 -04002902 cond_resched();
2903 }
Josef Bacik7f4ca372013-10-18 11:44:46 -04002904 free_extent_map(em);
2905 if (!ret) {
2906 if (whence == SEEK_DATA && start >= inode->i_size)
2907 ret = -ENXIO;
2908 else
2909 *offset = min_t(loff_t, start, inode->i_size);
2910 }
Josef Bacikb2675152011-07-18 13:21:36 -04002911 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
2912 &cached_state, GFP_NOFS);
2913 return ret;
2914}
2915
Andrew Morton965c8e52012-12-17 15:59:39 -08002916static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence)
Josef Bacikb2675152011-07-18 13:21:36 -04002917{
2918 struct inode *inode = file->f_mapping->host;
2919 int ret;
2920
Al Viro59551022016-01-22 15:40:57 -05002921 inode_lock(inode);
Andrew Morton965c8e52012-12-17 15:59:39 -08002922 switch (whence) {
Josef Bacikb2675152011-07-18 13:21:36 -04002923 case SEEK_END:
2924 case SEEK_CUR:
Andrew Morton965c8e52012-12-17 15:59:39 -08002925 offset = generic_file_llseek(file, offset, whence);
Josef Bacikb2675152011-07-18 13:21:36 -04002926 goto out;
2927 case SEEK_DATA:
2928 case SEEK_HOLE:
Jeff Liu48802c82011-09-18 10:34:02 -04002929 if (offset >= i_size_read(inode)) {
Al Viro59551022016-01-22 15:40:57 -05002930 inode_unlock(inode);
Jeff Liu48802c82011-09-18 10:34:02 -04002931 return -ENXIO;
2932 }
2933
Andrew Morton965c8e52012-12-17 15:59:39 -08002934 ret = find_desired_extent(inode, &offset, whence);
Josef Bacikb2675152011-07-18 13:21:36 -04002935 if (ret) {
Al Viro59551022016-01-22 15:40:57 -05002936 inode_unlock(inode);
Josef Bacikb2675152011-07-18 13:21:36 -04002937 return ret;
2938 }
2939 }
2940
Jie Liu46a1c2c2013-06-25 12:02:13 +08002941 offset = vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
Josef Bacikb2675152011-07-18 13:21:36 -04002942out:
Al Viro59551022016-01-22 15:40:57 -05002943 inode_unlock(inode);
Josef Bacikb2675152011-07-18 13:21:36 -04002944 return offset;
2945}
2946
Alexey Dobriyan828c0952009-10-01 15:43:56 -07002947const struct file_operations btrfs_file_operations = {
Josef Bacikb2675152011-07-18 13:21:36 -04002948 .llseek = btrfs_file_llseek,
Al Viroaad4f8b2014-04-02 14:33:16 -04002949 .read_iter = generic_file_read_iter,
Chris Masone9906a92007-12-14 12:56:58 -05002950 .splice_read = generic_file_splice_read,
Al Virob30ac0f2014-04-03 14:29:04 -04002951 .write_iter = btrfs_file_write_iter,
Chris Mason9ebefb182007-06-15 13:50:00 -04002952 .mmap = btrfs_file_mmap,
Chris Mason39279cc2007-06-12 06:35:45 -04002953 .open = generic_file_open,
Mingminge1b81e62008-05-27 10:55:43 -04002954 .release = btrfs_release_file,
Chris Mason39279cc2007-06-12 06:35:45 -04002955 .fsync = btrfs_sync_file,
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002956 .fallocate = btrfs_fallocate,
Christoph Hellwig34287aa2007-09-14 10:22:47 -04002957 .unlocked_ioctl = btrfs_ioctl,
Chris Mason39279cc2007-06-12 06:35:45 -04002958#ifdef CONFIG_COMPAT
Christoph Hellwig34287aa2007-09-14 10:22:47 -04002959 .compat_ioctl = btrfs_ioctl,
Chris Mason39279cc2007-06-12 06:35:45 -04002960#endif
Zach Brown3db11b22015-11-10 16:53:32 -05002961 .copy_file_range = btrfs_copy_file_range,
Christoph Hellwig04b38d62015-12-03 12:59:50 +01002962 .clone_file_range = btrfs_clone_file_range,
Darrick J. Wong2b3909f2015-12-19 00:56:05 -08002963 .dedupe_file_range = btrfs_dedupe_file_range,
Chris Mason39279cc2007-06-12 06:35:45 -04002964};
Miao Xie9247f312012-11-26 09:24:43 +00002965
2966void btrfs_auto_defrag_exit(void)
2967{
Kinglong Mee5598e902016-01-29 21:36:35 +08002968 kmem_cache_destroy(btrfs_inode_defrag_cachep);
Miao Xie9247f312012-11-26 09:24:43 +00002969}
2970
2971int btrfs_auto_defrag_init(void)
2972{
2973 btrfs_inode_defrag_cachep = kmem_cache_create("btrfs_inode_defrag",
2974 sizeof(struct inode_defrag), 0,
2975 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD,
2976 NULL);
2977 if (!btrfs_inode_defrag_cachep)
2978 return -ENOMEM;
2979
2980 return 0;
2981}
Filipe Manana728404d2014-10-10 09:43:11 +01002982
2983int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end)
2984{
2985 int ret;
2986
2987 /*
2988 * So with compression we will find and lock a dirty page and clear the
2989 * first one as dirty, setup an async extent, and immediately return
2990 * with the entire range locked but with nobody actually marked with
2991 * writeback. So we can't just filemap_write_and_wait_range() and
2992 * expect it to work since it will just kick off a thread to do the
2993 * actual work. So we need to call filemap_fdatawrite_range _again_
2994 * since it will wait on the page lock, which won't be unlocked until
2995 * after the pages have been marked as writeback and so we're good to go
2996 * from there. We have to do this otherwise we'll miss the ordered
2997 * extents and that results in badness. Please Josef, do not think you
2998 * know better and pull this out at some point in the future, it is
2999 * right and you are wrong.
3000 */
3001 ret = filemap_fdatawrite_range(inode->i_mapping, start, end);
3002 if (!ret && test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
3003 &BTRFS_I(inode)->runtime_flags))
3004 ret = filemap_fdatawrite_range(inode->i_mapping, start, end);
3005
3006 return ret;
3007}