blob: 3286a6e47ff014ed236ef5103e7e27db330a2725 [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{
Jeff Mahoney3cdde222016-06-09 21:38:35 -0400135 if (!btrfs_test_opt(root->fs_info, AUTO_DEFRAG))
Miao Xie8ddc4732012-11-26 09:25:38 +0000136 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,
Qu Wenruoba8b04c2016-07-19 16:50:36 +0800506 cached, 0);
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) {
Jeff Mahoney66642832016-06-10 18:19:25 -0400953 btrfs_abort_transaction(trans, 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)
Jeff Mahoney66642832016-06-10 18:19:25 -0400977 btrfs_abort_transaction(trans, 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]);
Josef Bacik9c8e63d2016-09-02 15:40:06 -04001113 if (key.objectid != ino ||
1114 key.type != BTRFS_EXTENT_DATA_KEY) {
1115 ret = -EINVAL;
1116 btrfs_abort_transaction(trans, ret);
1117 goto out;
1118 }
Yan Zhengd899e052008-10-30 14:25:28 -04001119 fi = btrfs_item_ptr(leaf, path->slots[0],
1120 struct btrfs_file_extent_item);
Josef Bacik9c8e63d2016-09-02 15:40:06 -04001121 if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_PREALLOC) {
1122 ret = -EINVAL;
1123 btrfs_abort_transaction(trans, ret);
1124 goto out;
1125 }
Yan Zhengd899e052008-10-30 14:25:28 -04001126 extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
Josef Bacik9c8e63d2016-09-02 15:40:06 -04001127 if (key.offset > start || extent_end < end) {
1128 ret = -EINVAL;
1129 btrfs_abort_transaction(trans, ret);
1130 goto out;
1131 }
Yan Zhengd899e052008-10-30 14:25:28 -04001132
1133 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1134 num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001135 orig_offset = key.offset - btrfs_file_extent_offset(leaf, fi);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001136 memcpy(&new_key, &key, sizeof(new_key));
1137
1138 if (start == key.offset && end < extent_end) {
1139 other_start = 0;
1140 other_end = start;
1141 if (extent_mergeable(leaf, path->slots[0] - 1,
Li Zefan33345d012011-04-20 10:31:50 +08001142 ino, bytenr, orig_offset,
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001143 &other_start, &other_end)) {
1144 new_key.offset = end;
Daniel Dresslerb7a03652014-11-12 13:43:09 +09001145 btrfs_set_item_key_safe(root->fs_info, path, &new_key);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001146 fi = btrfs_item_ptr(leaf, path->slots[0],
1147 struct btrfs_file_extent_item);
Josef Bacik224ecce2012-08-16 16:32:06 -04001148 btrfs_set_file_extent_generation(leaf, fi,
1149 trans->transid);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001150 btrfs_set_file_extent_num_bytes(leaf, fi,
1151 extent_end - end);
1152 btrfs_set_file_extent_offset(leaf, fi,
1153 end - orig_offset);
1154 fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
1155 struct btrfs_file_extent_item);
Josef Bacik224ecce2012-08-16 16:32:06 -04001156 btrfs_set_file_extent_generation(leaf, fi,
1157 trans->transid);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001158 btrfs_set_file_extent_num_bytes(leaf, fi,
1159 end - other_start);
1160 btrfs_mark_buffer_dirty(leaf);
1161 goto out;
1162 }
1163 }
1164
1165 if (start > key.offset && end == extent_end) {
1166 other_start = end;
1167 other_end = 0;
1168 if (extent_mergeable(leaf, path->slots[0] + 1,
Li Zefan33345d012011-04-20 10:31:50 +08001169 ino, bytenr, orig_offset,
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001170 &other_start, &other_end)) {
1171 fi = btrfs_item_ptr(leaf, path->slots[0],
1172 struct btrfs_file_extent_item);
1173 btrfs_set_file_extent_num_bytes(leaf, fi,
1174 start - key.offset);
Josef Bacik224ecce2012-08-16 16:32:06 -04001175 btrfs_set_file_extent_generation(leaf, fi,
1176 trans->transid);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001177 path->slots[0]++;
1178 new_key.offset = start;
Daniel Dresslerb7a03652014-11-12 13:43:09 +09001179 btrfs_set_item_key_safe(root->fs_info, path, &new_key);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001180
1181 fi = btrfs_item_ptr(leaf, path->slots[0],
1182 struct btrfs_file_extent_item);
Josef Bacik224ecce2012-08-16 16:32:06 -04001183 btrfs_set_file_extent_generation(leaf, fi,
1184 trans->transid);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001185 btrfs_set_file_extent_num_bytes(leaf, fi,
1186 other_end - start);
1187 btrfs_set_file_extent_offset(leaf, fi,
1188 start - orig_offset);
1189 btrfs_mark_buffer_dirty(leaf);
1190 goto out;
1191 }
1192 }
Yan Zhengd899e052008-10-30 14:25:28 -04001193
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001194 while (start > key.offset || end < extent_end) {
1195 if (key.offset == start)
1196 split = end;
Yan Zhengd899e052008-10-30 14:25:28 -04001197
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001198 new_key.offset = split;
1199 ret = btrfs_duplicate_item(trans, root, path, &new_key);
1200 if (ret == -EAGAIN) {
David Sterbab3b4aa72011-04-21 01:20:15 +02001201 btrfs_release_path(path);
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001202 goto again;
Yan Zhengd899e052008-10-30 14:25:28 -04001203 }
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001204 if (ret < 0) {
Jeff Mahoney66642832016-06-10 18:19:25 -04001205 btrfs_abort_transaction(trans, ret);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001206 goto out;
1207 }
Yan Zhengd899e052008-10-30 14:25:28 -04001208
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001209 leaf = path->nodes[0];
1210 fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
Yan Zhengd899e052008-10-30 14:25:28 -04001211 struct btrfs_file_extent_item);
Josef Bacik224ecce2012-08-16 16:32:06 -04001212 btrfs_set_file_extent_generation(leaf, fi, trans->transid);
Yan Zhengd899e052008-10-30 14:25:28 -04001213 btrfs_set_file_extent_num_bytes(leaf, fi,
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001214 split - key.offset);
1215
1216 fi = btrfs_item_ptr(leaf, path->slots[0],
1217 struct btrfs_file_extent_item);
1218
Josef Bacik224ecce2012-08-16 16:32:06 -04001219 btrfs_set_file_extent_generation(leaf, fi, trans->transid);
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001220 btrfs_set_file_extent_offset(leaf, fi, split - orig_offset);
1221 btrfs_set_file_extent_num_bytes(leaf, fi,
1222 extent_end - split);
Yan Zhengd899e052008-10-30 14:25:28 -04001223 btrfs_mark_buffer_dirty(leaf);
1224
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001225 ret = btrfs_inc_extent_ref(trans, root, bytenr, num_bytes, 0,
1226 root->root_key.objectid,
Filipe Mananab06c4bf2015-10-23 07:52:54 +01001227 ino, orig_offset);
Josef Bacik9c8e63d2016-09-02 15:40:06 -04001228 if (ret) {
1229 btrfs_abort_transaction(trans, ret);
1230 goto out;
1231 }
Yan Zhengd899e052008-10-30 14:25:28 -04001232
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001233 if (split == start) {
1234 key.offset = start;
1235 } else {
Josef Bacik9c8e63d2016-09-02 15:40:06 -04001236 if (start != key.offset) {
1237 ret = -EINVAL;
1238 btrfs_abort_transaction(trans, ret);
1239 goto out;
1240 }
Yan Zhengd899e052008-10-30 14:25:28 -04001241 path->slots[0]--;
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001242 extent_end = end;
Yan Zhengd899e052008-10-30 14:25:28 -04001243 }
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001244 recow = 1;
Yan Zhengd899e052008-10-30 14:25:28 -04001245 }
1246
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001247 other_start = end;
1248 other_end = 0;
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001249 if (extent_mergeable(leaf, path->slots[0] + 1,
Li Zefan33345d012011-04-20 10:31:50 +08001250 ino, bytenr, orig_offset,
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001251 &other_start, &other_end)) {
1252 if (recow) {
David Sterbab3b4aa72011-04-21 01:20:15 +02001253 btrfs_release_path(path);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001254 goto again;
1255 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001256 extent_end = other_end;
1257 del_slot = path->slots[0] + 1;
1258 del_nr++;
1259 ret = btrfs_free_extent(trans, root, bytenr, num_bytes,
1260 0, root->root_key.objectid,
Filipe Mananab06c4bf2015-10-23 07:52:54 +01001261 ino, orig_offset);
Josef Bacik9c8e63d2016-09-02 15:40:06 -04001262 if (ret) {
1263 btrfs_abort_transaction(trans, ret);
1264 goto out;
1265 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001266 }
1267 other_start = 0;
1268 other_end = start;
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001269 if (extent_mergeable(leaf, path->slots[0] - 1,
Li Zefan33345d012011-04-20 10:31:50 +08001270 ino, bytenr, orig_offset,
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001271 &other_start, &other_end)) {
1272 if (recow) {
David Sterbab3b4aa72011-04-21 01:20:15 +02001273 btrfs_release_path(path);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001274 goto again;
1275 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001276 key.offset = other_start;
1277 del_slot = path->slots[0];
1278 del_nr++;
1279 ret = btrfs_free_extent(trans, root, bytenr, num_bytes,
1280 0, root->root_key.objectid,
Filipe Mananab06c4bf2015-10-23 07:52:54 +01001281 ino, orig_offset);
Josef Bacik9c8e63d2016-09-02 15:40:06 -04001282 if (ret) {
1283 btrfs_abort_transaction(trans, ret);
1284 goto out;
1285 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001286 }
1287 if (del_nr == 0) {
Shaohua Li3f6fae92010-02-11 07:43:00 +00001288 fi = btrfs_item_ptr(leaf, path->slots[0],
1289 struct btrfs_file_extent_item);
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001290 btrfs_set_file_extent_type(leaf, fi,
1291 BTRFS_FILE_EXTENT_REG);
Josef Bacik224ecce2012-08-16 16:32:06 -04001292 btrfs_set_file_extent_generation(leaf, fi, trans->transid);
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001293 btrfs_mark_buffer_dirty(leaf);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001294 } else {
Shaohua Li3f6fae92010-02-11 07:43:00 +00001295 fi = btrfs_item_ptr(leaf, del_slot - 1,
1296 struct btrfs_file_extent_item);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001297 btrfs_set_file_extent_type(leaf, fi,
1298 BTRFS_FILE_EXTENT_REG);
Josef Bacik224ecce2012-08-16 16:32:06 -04001299 btrfs_set_file_extent_generation(leaf, fi, trans->transid);
Yan, Zheng6c7d54a2010-01-15 08:43:09 +00001300 btrfs_set_file_extent_num_bytes(leaf, fi,
1301 extent_end - key.offset);
1302 btrfs_mark_buffer_dirty(leaf);
1303
1304 ret = btrfs_del_items(trans, root, path, del_slot, del_nr);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001305 if (ret < 0) {
Jeff Mahoney66642832016-06-10 18:19:25 -04001306 btrfs_abort_transaction(trans, ret);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01001307 goto out;
1308 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001309 }
Yan, Zheng920bbbf2009-11-12 09:34:08 +00001310out:
Yan Zhengd899e052008-10-30 14:25:28 -04001311 btrfs_free_path(path);
1312 return 0;
1313}
1314
Chris Mason39279cc2007-06-12 06:35:45 -04001315/*
Chris Masonb1bf8622011-02-28 09:52:08 -05001316 * on error we return an unlocked page and the error value
1317 * on success we return a locked page and 0
1318 */
Chris Masonbb1591b42015-12-14 15:40:44 -08001319static int prepare_uptodate_page(struct inode *inode,
1320 struct page *page, u64 pos,
Josef Bacikb63164292011-09-30 15:23:54 -04001321 bool force_uptodate)
Chris Masonb1bf8622011-02-28 09:52:08 -05001322{
1323 int ret = 0;
1324
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001325 if (((pos & (PAGE_SIZE - 1)) || force_uptodate) &&
Josef Bacikb63164292011-09-30 15:23:54 -04001326 !PageUptodate(page)) {
Chris Masonb1bf8622011-02-28 09:52:08 -05001327 ret = btrfs_readpage(NULL, page);
1328 if (ret)
1329 return ret;
1330 lock_page(page);
1331 if (!PageUptodate(page)) {
1332 unlock_page(page);
1333 return -EIO;
1334 }
Chris Masonbb1591b42015-12-14 15:40:44 -08001335 if (page->mapping != inode->i_mapping) {
1336 unlock_page(page);
1337 return -EAGAIN;
1338 }
Chris Masonb1bf8622011-02-28 09:52:08 -05001339 }
1340 return 0;
1341}
1342
1343/*
Miao Xie376cc682013-12-10 19:25:04 +08001344 * this just gets pages into the page cache and locks them down.
Chris Mason39279cc2007-06-12 06:35:45 -04001345 */
Miao Xieb37392e2013-12-10 19:25:03 +08001346static noinline int prepare_pages(struct inode *inode, struct page **pages,
1347 size_t num_pages, loff_t pos,
1348 size_t write_bytes, bool force_uptodate)
Chris Mason39279cc2007-06-12 06:35:45 -04001349{
1350 int i;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001351 unsigned long index = pos >> PAGE_SHIFT;
Josef Bacik3b16a4e2011-09-21 15:05:58 -04001352 gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping);
Filipe David Borba Mananafc28b622013-12-13 19:39:34 +00001353 int err = 0;
Miao Xie376cc682013-12-10 19:25:04 +08001354 int faili;
Chris Mason8c2383c2007-06-18 09:57:58 -04001355
Chris Mason39279cc2007-06-12 06:35:45 -04001356 for (i = 0; i < num_pages; i++) {
Chris Masonbb1591b42015-12-14 15:40:44 -08001357again:
Josef Bacika94733d2011-07-11 10:47:06 -04001358 pages[i] = find_or_create_page(inode->i_mapping, index + i,
Johannes Weinere3a41a52012-01-10 15:07:55 -08001359 mask | __GFP_WRITE);
Chris Mason39279cc2007-06-12 06:35:45 -04001360 if (!pages[i]) {
Chris Masonb1bf8622011-02-28 09:52:08 -05001361 faili = i - 1;
1362 err = -ENOMEM;
1363 goto fail;
1364 }
1365
1366 if (i == 0)
Chris Masonbb1591b42015-12-14 15:40:44 -08001367 err = prepare_uptodate_page(inode, pages[i], pos,
Josef Bacikb63164292011-09-30 15:23:54 -04001368 force_uptodate);
Chris Masonbb1591b42015-12-14 15:40:44 -08001369 if (!err && i == num_pages - 1)
1370 err = prepare_uptodate_page(inode, pages[i],
Josef Bacikb63164292011-09-30 15:23:54 -04001371 pos + write_bytes, false);
Chris Masonb1bf8622011-02-28 09:52:08 -05001372 if (err) {
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001373 put_page(pages[i]);
Chris Masonbb1591b42015-12-14 15:40:44 -08001374 if (err == -EAGAIN) {
1375 err = 0;
1376 goto again;
1377 }
Chris Masonb1bf8622011-02-28 09:52:08 -05001378 faili = i - 1;
1379 goto fail;
Chris Mason39279cc2007-06-12 06:35:45 -04001380 }
Chris Masonccd467d2007-06-28 15:57:36 -04001381 wait_on_page_writeback(pages[i]);
Chris Mason39279cc2007-06-12 06:35:45 -04001382 }
Chris Masone6dcd2d2008-07-17 12:53:50 -04001383
Chris Mason39279cc2007-06-12 06:35:45 -04001384 return 0;
Chris Masonb1bf8622011-02-28 09:52:08 -05001385fail:
1386 while (faili >= 0) {
1387 unlock_page(pages[faili]);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001388 put_page(pages[faili]);
Chris Masonb1bf8622011-02-28 09:52:08 -05001389 faili--;
1390 }
1391 return err;
1392
Chris Mason39279cc2007-06-12 06:35:45 -04001393}
1394
Miao Xie376cc682013-12-10 19:25:04 +08001395/*
1396 * This function locks the extent and properly waits for data=ordered extents
1397 * to finish before allowing the pages to be modified if need.
1398 *
1399 * The return value:
1400 * 1 - the extent is locked
1401 * 0 - the extent is not locked, and everything is OK
1402 * -EAGAIN - need re-prepare the pages
1403 * the other < 0 number - Something wrong happens
1404 */
1405static noinline int
1406lock_and_cleanup_extent_if_need(struct inode *inode, struct page **pages,
1407 size_t num_pages, loff_t pos,
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301408 size_t write_bytes,
Miao Xie376cc682013-12-10 19:25:04 +08001409 u64 *lockstart, u64 *lockend,
1410 struct extent_state **cached_state)
1411{
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301412 struct btrfs_root *root = BTRFS_I(inode)->root;
Miao Xie376cc682013-12-10 19:25:04 +08001413 u64 start_pos;
1414 u64 last_pos;
1415 int i;
1416 int ret = 0;
1417
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301418 start_pos = round_down(pos, root->sectorsize);
1419 last_pos = start_pos
1420 + round_up(pos + write_bytes - start_pos, root->sectorsize) - 1;
Miao Xie376cc682013-12-10 19:25:04 +08001421
1422 if (start_pos < inode->i_size) {
1423 struct btrfs_ordered_extent *ordered;
1424 lock_extent_bits(&BTRFS_I(inode)->io_tree,
David Sterbaff13db42015-12-03 14:30:40 +01001425 start_pos, last_pos, cached_state);
Miao Xieb88935b2014-03-06 13:54:58 +08001426 ordered = btrfs_lookup_ordered_range(inode, start_pos,
1427 last_pos - start_pos + 1);
Miao Xie376cc682013-12-10 19:25:04 +08001428 if (ordered &&
1429 ordered->file_offset + ordered->len > start_pos &&
1430 ordered->file_offset <= last_pos) {
Miao Xie376cc682013-12-10 19:25:04 +08001431 unlock_extent_cached(&BTRFS_I(inode)->io_tree,
1432 start_pos, last_pos,
1433 cached_state, GFP_NOFS);
1434 for (i = 0; i < num_pages; i++) {
1435 unlock_page(pages[i]);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001436 put_page(pages[i]);
Miao Xie376cc682013-12-10 19:25:04 +08001437 }
Miao Xieb88935b2014-03-06 13:54:58 +08001438 btrfs_start_ordered_extent(inode, ordered, 1);
1439 btrfs_put_ordered_extent(ordered);
1440 return -EAGAIN;
Miao Xie376cc682013-12-10 19:25:04 +08001441 }
1442 if (ordered)
1443 btrfs_put_ordered_extent(ordered);
1444
1445 clear_extent_bit(&BTRFS_I(inode)->io_tree, start_pos,
1446 last_pos, EXTENT_DIRTY | EXTENT_DELALLOC |
1447 EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
1448 0, 0, cached_state, GFP_NOFS);
1449 *lockstart = start_pos;
1450 *lockend = last_pos;
1451 ret = 1;
1452 }
1453
1454 for (i = 0; i < num_pages; i++) {
1455 if (clear_page_dirty_for_io(pages[i]))
1456 account_page_redirty(pages[i]);
1457 set_page_extent_mapped(pages[i]);
1458 WARN_ON(!PageLocked(pages[i]));
1459 }
1460
1461 return ret;
1462}
1463
Josef Bacik7ee9e442013-06-21 16:37:03 -04001464static noinline int check_can_nocow(struct inode *inode, loff_t pos,
1465 size_t *write_bytes)
1466{
Josef Bacik7ee9e442013-06-21 16:37:03 -04001467 struct btrfs_root *root = BTRFS_I(inode)->root;
1468 struct btrfs_ordered_extent *ordered;
1469 u64 lockstart, lockend;
1470 u64 num_bytes;
1471 int ret;
1472
Filipe Manana9ea24bb2014-10-29 11:57:59 +00001473 ret = btrfs_start_write_no_snapshoting(root);
Miao Xie8257b2d2014-03-06 13:38:19 +08001474 if (!ret)
1475 return -ENOSPC;
1476
Josef Bacik7ee9e442013-06-21 16:37:03 -04001477 lockstart = round_down(pos, root->sectorsize);
Miao Xiec9339562014-02-27 13:58:04 +08001478 lockend = round_up(pos + *write_bytes, root->sectorsize) - 1;
Josef Bacik7ee9e442013-06-21 16:37:03 -04001479
1480 while (1) {
1481 lock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend);
1482 ordered = btrfs_lookup_ordered_range(inode, lockstart,
1483 lockend - lockstart + 1);
1484 if (!ordered) {
1485 break;
1486 }
1487 unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend);
1488 btrfs_start_ordered_extent(inode, ordered, 1);
1489 btrfs_put_ordered_extent(ordered);
1490 }
1491
Josef Bacik7ee9e442013-06-21 16:37:03 -04001492 num_bytes = lockend - lockstart + 1;
Josef Bacik00361582013-08-14 14:02:47 -04001493 ret = can_nocow_extent(inode, lockstart, &num_bytes, NULL, NULL, NULL);
Josef Bacik7ee9e442013-06-21 16:37:03 -04001494 if (ret <= 0) {
1495 ret = 0;
Filipe Manana9ea24bb2014-10-29 11:57:59 +00001496 btrfs_end_write_no_snapshoting(root);
Josef Bacik7ee9e442013-06-21 16:37:03 -04001497 } else {
Miao Xiec9339562014-02-27 13:58:04 +08001498 *write_bytes = min_t(size_t, *write_bytes ,
1499 num_bytes - pos + lockstart);
Josef Bacik7ee9e442013-06-21 16:37:03 -04001500 }
1501
1502 unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, lockend);
1503
1504 return ret;
1505}
1506
Josef Bacikd0215f32011-01-25 14:57:24 -05001507static noinline ssize_t __btrfs_buffered_write(struct file *file,
1508 struct iov_iter *i,
1509 loff_t pos)
Josef Bacik4b46fce2010-05-23 11:00:55 -04001510{
Al Viro496ad9a2013-01-23 17:07:38 -05001511 struct inode *inode = file_inode(file);
Josef Bacik11c65dc2010-05-23 11:07:21 -04001512 struct btrfs_root *root = BTRFS_I(inode)->root;
Josef Bacik11c65dc2010-05-23 11:07:21 -04001513 struct page **pages = NULL;
Miao Xie376cc682013-12-10 19:25:04 +08001514 struct extent_state *cached_state = NULL;
Josef Bacik7ee9e442013-06-21 16:37:03 -04001515 u64 release_bytes = 0;
Miao Xie376cc682013-12-10 19:25:04 +08001516 u64 lockstart;
1517 u64 lockend;
Josef Bacikd0215f32011-01-25 14:57:24 -05001518 size_t num_written = 0;
1519 int nrptrs;
Tsutomu Itohc9149232011-03-30 00:57:23 +00001520 int ret = 0;
Josef Bacik7ee9e442013-06-21 16:37:03 -04001521 bool only_release_metadata = false;
Josef Bacikb63164292011-09-30 15:23:54 -04001522 bool force_page_uptodate = false;
Miao Xie376cc682013-12-10 19:25:04 +08001523 bool need_unlock;
Chris Masoncb843a62008-10-03 12:30:02 -04001524
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001525 nrptrs = min(DIV_ROUND_UP(iov_iter_count(i), PAGE_SIZE),
1526 PAGE_SIZE / (sizeof(struct page *)));
Wu Fengguang142349f2011-12-16 12:32:57 -05001527 nrptrs = min(nrptrs, current->nr_dirtied_pause - current->nr_dirtied);
1528 nrptrs = max(nrptrs, 8);
David Sterba31e818f2015-02-20 18:00:26 +01001529 pages = kmalloc_array(nrptrs, sizeof(struct page *), GFP_KERNEL);
Josef Bacikd0215f32011-01-25 14:57:24 -05001530 if (!pages)
1531 return -ENOMEM;
Chris Masonab93dbe2009-10-01 12:29:10 -04001532
Josef Bacikd0215f32011-01-25 14:57:24 -05001533 while (iov_iter_count(i) > 0) {
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001534 size_t offset = pos & (PAGE_SIZE - 1);
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301535 size_t sector_offset;
Josef Bacikd0215f32011-01-25 14:57:24 -05001536 size_t write_bytes = min(iov_iter_count(i),
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001537 nrptrs * (size_t)PAGE_SIZE -
Chris Mason8c2383c2007-06-18 09:57:58 -04001538 offset);
David Sterbaed6078f2014-06-05 01:59:57 +02001539 size_t num_pages = DIV_ROUND_UP(write_bytes + offset,
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001540 PAGE_SIZE);
Josef Bacik7ee9e442013-06-21 16:37:03 -04001541 size_t reserve_bytes;
Josef Bacikd0215f32011-01-25 14:57:24 -05001542 size_t dirty_pages;
1543 size_t copied;
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301544 size_t dirty_sectors;
1545 size_t num_sectors;
Chris Mason39279cc2007-06-12 06:35:45 -04001546
Chris Mason8c2383c2007-06-18 09:57:58 -04001547 WARN_ON(num_pages > nrptrs);
Chris Mason1832a6d2007-12-21 16:27:21 -05001548
Xin Zhong914ee292010-12-09 09:30:14 +00001549 /*
1550 * Fault pages before locking them in prepare_pages
1551 * to avoid recursive lock
1552 */
Josef Bacikd0215f32011-01-25 14:57:24 -05001553 if (unlikely(iov_iter_fault_in_readable(i, write_bytes))) {
Xin Zhong914ee292010-12-09 09:30:14 +00001554 ret = -EFAULT;
Josef Bacikd0215f32011-01-25 14:57:24 -05001555 break;
Xin Zhong914ee292010-12-09 09:30:14 +00001556 }
1557
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301558 sector_offset = pos & (root->sectorsize - 1);
1559 reserve_bytes = round_up(write_bytes + sector_offset,
1560 root->sectorsize);
Qu Wenruod9d8b2a2015-09-08 17:22:43 +08001561
Josef Bacikc6887cd2016-03-25 13:26:00 -04001562 ret = btrfs_check_data_free_space(inode, pos, write_bytes);
1563 if (ret < 0) {
1564 if ((BTRFS_I(inode)->flags & (BTRFS_INODE_NODATACOW |
1565 BTRFS_INODE_PREALLOC)) &&
1566 check_can_nocow(inode, pos, &write_bytes) > 0) {
1567 /*
1568 * For nodata cow case, no need to reserve
1569 * data space.
1570 */
1571 only_release_metadata = true;
1572 /*
1573 * our prealloc extent may be smaller than
1574 * write_bytes, so scale down.
1575 */
1576 num_pages = DIV_ROUND_UP(write_bytes + offset,
1577 PAGE_SIZE);
1578 reserve_bytes = round_up(write_bytes +
1579 sector_offset,
1580 root->sectorsize);
1581 } else {
1582 break;
1583 }
Josef Bacik7ee9e442013-06-21 16:37:03 -04001584 }
Zhao Lei4da2e262016-01-06 18:24:43 +08001585
Josef Bacik7ee9e442013-06-21 16:37:03 -04001586 ret = btrfs_delalloc_reserve_metadata(inode, reserve_bytes);
1587 if (ret) {
1588 if (!only_release_metadata)
Qu Wenruo7cf5b972015-09-08 17:25:55 +08001589 btrfs_free_reserved_data_space(inode, pos,
1590 write_bytes);
Miao Xie8257b2d2014-03-06 13:38:19 +08001591 else
Filipe Manana9ea24bb2014-10-29 11:57:59 +00001592 btrfs_end_write_no_snapshoting(root);
Josef Bacik7ee9e442013-06-21 16:37:03 -04001593 break;
1594 }
1595
1596 release_bytes = reserve_bytes;
Miao Xie376cc682013-12-10 19:25:04 +08001597 need_unlock = false;
1598again:
Josef Bacik4a640012011-01-25 15:10:08 -05001599 /*
1600 * This is going to setup the pages array with the number of
1601 * pages we want, so we don't really need to worry about the
1602 * contents of pages from loop to loop
1603 */
Miao Xieb37392e2013-12-10 19:25:03 +08001604 ret = prepare_pages(inode, pages, num_pages,
1605 pos, write_bytes,
Josef Bacikb63164292011-09-30 15:23:54 -04001606 force_page_uptodate);
Josef Bacik7ee9e442013-06-21 16:37:03 -04001607 if (ret)
Josef Bacikd0215f32011-01-25 14:57:24 -05001608 break;
Chris Mason39279cc2007-06-12 06:35:45 -04001609
Miao Xie376cc682013-12-10 19:25:04 +08001610 ret = lock_and_cleanup_extent_if_need(inode, pages, num_pages,
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301611 pos, write_bytes, &lockstart,
1612 &lockend, &cached_state);
Miao Xie376cc682013-12-10 19:25:04 +08001613 if (ret < 0) {
1614 if (ret == -EAGAIN)
1615 goto again;
1616 break;
1617 } else if (ret > 0) {
1618 need_unlock = true;
1619 ret = 0;
1620 }
1621
Zhao Leiee22f0c2016-01-06 18:47:31 +08001622 copied = btrfs_copy_from_user(pos, write_bytes, pages, i);
Chris Masonb1bf8622011-02-28 09:52:08 -05001623
Chris Mason56244ef2016-05-16 09:21:01 -07001624 num_sectors = BTRFS_BYTES_TO_BLKS(root->fs_info,
1625 reserve_bytes);
1626 dirty_sectors = round_up(copied + sector_offset,
1627 root->sectorsize);
1628 dirty_sectors = BTRFS_BYTES_TO_BLKS(root->fs_info,
1629 dirty_sectors);
1630
Chris Masonb1bf8622011-02-28 09:52:08 -05001631 /*
1632 * if we have trouble faulting in the pages, fall
1633 * back to one page at a time
1634 */
1635 if (copied < write_bytes)
1636 nrptrs = 1;
1637
Josef Bacikb63164292011-09-30 15:23:54 -04001638 if (copied == 0) {
1639 force_page_uptodate = true;
Chris Mason56244ef2016-05-16 09:21:01 -07001640 dirty_sectors = 0;
Chris Masonb1bf8622011-02-28 09:52:08 -05001641 dirty_pages = 0;
Josef Bacikb63164292011-09-30 15:23:54 -04001642 } else {
1643 force_page_uptodate = false;
David Sterbaed6078f2014-06-05 01:59:57 +02001644 dirty_pages = DIV_ROUND_UP(copied + offset,
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001645 PAGE_SIZE);
Josef Bacikb63164292011-09-30 15:23:54 -04001646 }
Xin Zhong914ee292010-12-09 09:30:14 +00001647
Josef Bacikd0215f32011-01-25 14:57:24 -05001648 /*
1649 * If we had a short copy we need to release the excess delaloc
1650 * bytes we reserved. We need to increment outstanding_extents
Chris Mason56244ef2016-05-16 09:21:01 -07001651 * because btrfs_delalloc_release_space and
1652 * btrfs_delalloc_release_metadata will decrement it, but
Josef Bacikd0215f32011-01-25 14:57:24 -05001653 * we still have an outstanding extent for the chunk we actually
1654 * managed to copy.
1655 */
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301656 if (num_sectors > dirty_sectors) {
Chris Mason8b8b08c2016-07-19 05:52:36 -07001657
1658 /* release everything except the sectors we dirtied */
1659 release_bytes -= dirty_sectors <<
1660 root->fs_info->sb->s_blocksize_bits;
1661
Josef Bacik9e0baf62011-07-15 15:16:44 +00001662 if (copied > 0) {
1663 spin_lock(&BTRFS_I(inode)->lock);
1664 BTRFS_I(inode)->outstanding_extents++;
1665 spin_unlock(&BTRFS_I(inode)->lock);
1666 }
Qu Wenruo485290a2015-10-29 17:28:46 +08001667 if (only_release_metadata) {
Josef Bacik7ee9e442013-06-21 16:37:03 -04001668 btrfs_delalloc_release_metadata(inode,
1669 release_bytes);
Qu Wenruo485290a2015-10-29 17:28:46 +08001670 } else {
1671 u64 __pos;
1672
1673 __pos = round_down(pos, root->sectorsize) +
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001674 (dirty_pages << PAGE_SHIFT);
Qu Wenruo485290a2015-10-29 17:28:46 +08001675 btrfs_delalloc_release_space(inode, __pos,
Josef Bacik7ee9e442013-06-21 16:37:03 -04001676 release_bytes);
Qu Wenruo485290a2015-10-29 17:28:46 +08001677 }
Xin Zhong914ee292010-12-09 09:30:14 +00001678 }
1679
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301680 release_bytes = round_up(copied + sector_offset,
1681 root->sectorsize);
Miao Xie376cc682013-12-10 19:25:04 +08001682
1683 if (copied > 0)
Josef Bacikbe1a12a2011-04-06 13:05:22 -04001684 ret = btrfs_dirty_pages(root, inode, pages,
1685 dirty_pages, pos, copied,
1686 NULL);
Miao Xie376cc682013-12-10 19:25:04 +08001687 if (need_unlock)
1688 unlock_extent_cached(&BTRFS_I(inode)->io_tree,
1689 lockstart, lockend, &cached_state,
1690 GFP_NOFS);
Miao Xief1de9682014-01-09 10:06:10 +08001691 if (ret) {
1692 btrfs_drop_pages(pages, num_pages);
Miao Xie376cc682013-12-10 19:25:04 +08001693 break;
Miao Xief1de9682014-01-09 10:06:10 +08001694 }
Chris Mason39279cc2007-06-12 06:35:45 -04001695
Josef Bacik7ee9e442013-06-21 16:37:03 -04001696 release_bytes = 0;
Miao Xie8257b2d2014-03-06 13:38:19 +08001697 if (only_release_metadata)
Filipe Manana9ea24bb2014-10-29 11:57:59 +00001698 btrfs_end_write_no_snapshoting(root);
Miao Xie8257b2d2014-03-06 13:38:19 +08001699
Josef Bacik7ee9e442013-06-21 16:37:03 -04001700 if (only_release_metadata && copied > 0) {
David Sterbaf64c7b12015-02-24 19:07:26 +01001701 lockstart = round_down(pos, root->sectorsize);
Chandan Rajendra2e78c922016-01-21 15:55:53 +05301702 lockend = round_up(pos + copied, root->sectorsize) - 1;
Josef Bacik7ee9e442013-06-21 16:37:03 -04001703
1704 set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
1705 lockend, EXTENT_NORESERVE, NULL,
1706 NULL, GFP_NOFS);
1707 only_release_metadata = false;
1708 }
1709
Miao Xief1de9682014-01-09 10:06:10 +08001710 btrfs_drop_pages(pages, num_pages);
1711
Josef Bacikd0215f32011-01-25 14:57:24 -05001712 cond_resched();
1713
Namjae Jeond0e1d662012-12-11 16:00:21 -08001714 balance_dirty_pages_ratelimited(inode->i_mapping);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001715 if (dirty_pages < (root->nodesize >> PAGE_SHIFT) + 1)
Liu Bob53d3f52012-11-14 14:34:34 +00001716 btrfs_btree_balance_dirty(root);
Chris Mason39279cc2007-06-12 06:35:45 -04001717
Xin Zhong914ee292010-12-09 09:30:14 +00001718 pos += copied;
1719 num_written += copied;
Chris Mason39279cc2007-06-12 06:35:45 -04001720 }
Chris Mason5b92ee72008-01-03 13:46:11 -05001721
Chris Mason8c2383c2007-06-18 09:57:58 -04001722 kfree(pages);
Josef Bacikd0215f32011-01-25 14:57:24 -05001723
Josef Bacik7ee9e442013-06-21 16:37:03 -04001724 if (release_bytes) {
Miao Xie8257b2d2014-03-06 13:38:19 +08001725 if (only_release_metadata) {
Filipe Manana9ea24bb2014-10-29 11:57:59 +00001726 btrfs_end_write_no_snapshoting(root);
Josef Bacik7ee9e442013-06-21 16:37:03 -04001727 btrfs_delalloc_release_metadata(inode, release_bytes);
Miao Xie8257b2d2014-03-06 13:38:19 +08001728 } else {
Chandan Rajendraa2af23b2016-04-04 02:53:06 +05301729 btrfs_delalloc_release_space(inode,
1730 round_down(pos, root->sectorsize),
1731 release_bytes);
Miao Xie8257b2d2014-03-06 13:38:19 +08001732 }
Josef Bacik7ee9e442013-06-21 16:37:03 -04001733 }
1734
Josef Bacikd0215f32011-01-25 14:57:24 -05001735 return num_written ? num_written : ret;
1736}
1737
Christoph Hellwig1af5bb42016-04-07 08:51:56 -07001738static ssize_t __btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
Josef Bacikd0215f32011-01-25 14:57:24 -05001739{
1740 struct file *file = iocb->ki_filp;
Filipe Manana728404d2014-10-10 09:43:11 +01001741 struct inode *inode = file_inode(file);
Christoph Hellwig1af5bb42016-04-07 08:51:56 -07001742 loff_t pos = iocb->ki_pos;
Josef Bacikd0215f32011-01-25 14:57:24 -05001743 ssize_t written;
1744 ssize_t written_buffered;
1745 loff_t endbyte;
1746 int err;
1747
Christoph Hellwig1af5bb42016-04-07 08:51:56 -07001748 written = generic_file_direct_write(iocb, from);
Josef Bacikd0215f32011-01-25 14:57:24 -05001749
Al Viro0c949332014-03-22 06:51:37 -04001750 if (written < 0 || !iov_iter_count(from))
Josef Bacikd0215f32011-01-25 14:57:24 -05001751 return written;
1752
1753 pos += written;
Al Viro0ae5e4d2014-03-03 22:09:39 -05001754 written_buffered = __btrfs_buffered_write(file, from, pos);
Josef Bacikd0215f32011-01-25 14:57:24 -05001755 if (written_buffered < 0) {
1756 err = written_buffered;
1757 goto out;
1758 }
Filipe Manana075bdbd2014-10-09 21:18:55 +01001759 /*
1760 * Ensure all data is persisted. We want the next direct IO read to be
1761 * able to read what was just written.
1762 */
Josef Bacikd0215f32011-01-25 14:57:24 -05001763 endbyte = pos + written_buffered - 1;
Filipe Manana728404d2014-10-10 09:43:11 +01001764 err = btrfs_fdatawrite_range(inode, pos, endbyte);
Filipe Manana075bdbd2014-10-09 21:18:55 +01001765 if (err)
1766 goto out;
Filipe Manana728404d2014-10-10 09:43:11 +01001767 err = filemap_fdatawait_range(inode->i_mapping, pos, endbyte);
Josef Bacikd0215f32011-01-25 14:57:24 -05001768 if (err)
1769 goto out;
1770 written += written_buffered;
Al Viro867c4f92014-02-11 19:31:06 -05001771 iocb->ki_pos = pos + written_buffered;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001772 invalidate_mapping_pages(file->f_mapping, pos >> PAGE_SHIFT,
1773 endbyte >> PAGE_SHIFT);
Josef Bacikd0215f32011-01-25 14:57:24 -05001774out:
1775 return written ? written : err;
1776}
1777
Josef Bacik6c760c02012-11-09 10:53:21 -05001778static void update_time_for_write(struct inode *inode)
1779{
1780 struct timespec now;
1781
1782 if (IS_NOCMTIME(inode))
1783 return;
1784
Deepa Dinamanic2050a42016-09-14 07:48:06 -07001785 now = current_time(inode);
Josef Bacik6c760c02012-11-09 10:53:21 -05001786 if (!timespec_equal(&inode->i_mtime, &now))
1787 inode->i_mtime = now;
1788
1789 if (!timespec_equal(&inode->i_ctime, &now))
1790 inode->i_ctime = now;
1791
1792 if (IS_I_VERSION(inode))
1793 inode_inc_iversion(inode);
1794}
1795
Al Virob30ac0f2014-04-03 14:29:04 -04001796static ssize_t btrfs_file_write_iter(struct kiocb *iocb,
1797 struct iov_iter *from)
Josef Bacikd0215f32011-01-25 14:57:24 -05001798{
1799 struct file *file = iocb->ki_filp;
Al Viro496ad9a2013-01-23 17:07:38 -05001800 struct inode *inode = file_inode(file);
Josef Bacikd0215f32011-01-25 14:57:24 -05001801 struct btrfs_root *root = BTRFS_I(inode)->root;
Miao Xie0c1a98c2011-09-11 10:52:24 -04001802 u64 start_pos;
Qu Wenruo3ac0d7b2014-03-27 02:51:58 +00001803 u64 end_pos;
Josef Bacikd0215f32011-01-25 14:57:24 -05001804 ssize_t num_written = 0;
Josef Bacikb812ce22012-11-16 13:56:32 -05001805 bool sync = (file->f_flags & O_DSYNC) || IS_SYNC(file->f_mapping->host);
Al Viro3309dd02015-04-09 12:55:47 -04001806 ssize_t err;
1807 loff_t pos;
1808 size_t count;
Chandan Rajendra27772b62016-01-21 15:56:03 +05301809 loff_t oldsize;
1810 int clean_page = 0;
Josef Bacikd0215f32011-01-25 14:57:24 -05001811
Al Viro59551022016-01-22 15:40:57 -05001812 inode_lock(inode);
Al Viro3309dd02015-04-09 12:55:47 -04001813 err = generic_write_checks(iocb, from);
1814 if (err <= 0) {
Al Viro59551022016-01-22 15:40:57 -05001815 inode_unlock(inode);
Al Viro3309dd02015-04-09 12:55:47 -04001816 return err;
1817 }
Josef Bacikd0215f32011-01-25 14:57:24 -05001818
Christoph Hellwigde1414a2015-01-14 10:42:36 +01001819 current->backing_dev_info = inode_to_bdi(inode);
Jan Kara5fa8e0a2015-05-21 16:05:53 +02001820 err = file_remove_privs(file);
Josef Bacikd0215f32011-01-25 14:57:24 -05001821 if (err) {
Al Viro59551022016-01-22 15:40:57 -05001822 inode_unlock(inode);
Josef Bacikd0215f32011-01-25 14:57:24 -05001823 goto out;
1824 }
1825
1826 /*
1827 * If BTRFS flips readonly due to some impossible error
1828 * (fs_info->fs_state now has BTRFS_SUPER_FLAG_ERROR),
1829 * although we have opened a file as writable, we have
1830 * to stop this write operation to ensure FS consistency.
1831 */
Miao Xie87533c42013-01-29 10:14:48 +00001832 if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
Al Viro59551022016-01-22 15:40:57 -05001833 inode_unlock(inode);
Josef Bacikd0215f32011-01-25 14:57:24 -05001834 err = -EROFS;
1835 goto out;
1836 }
1837
Josef Bacik6c760c02012-11-09 10:53:21 -05001838 /*
1839 * We reserve space for updating the inode when we reserve space for the
1840 * extent we are going to write, so we will enospc out there. We don't
1841 * need to start yet another transaction to update the inode as we will
1842 * update the inode when we finish writing whatever data we write.
1843 */
1844 update_time_for_write(inode);
Josef Bacikd0215f32011-01-25 14:57:24 -05001845
Al Viro3309dd02015-04-09 12:55:47 -04001846 pos = iocb->ki_pos;
1847 count = iov_iter_count(from);
Miao Xie0c1a98c2011-09-11 10:52:24 -04001848 start_pos = round_down(pos, root->sectorsize);
Chandan Rajendra27772b62016-01-21 15:56:03 +05301849 oldsize = i_size_read(inode);
1850 if (start_pos > oldsize) {
Qu Wenruo3ac0d7b2014-03-27 02:51:58 +00001851 /* Expand hole size to cover write data, preventing empty gap */
Qu Wenruoc5f7d0b2014-04-15 10:41:00 +08001852 end_pos = round_up(pos + count, root->sectorsize);
Chandan Rajendra27772b62016-01-21 15:56:03 +05301853 err = btrfs_cont_expand(inode, oldsize, end_pos);
Miao Xie0c1a98c2011-09-11 10:52:24 -04001854 if (err) {
Al Viro59551022016-01-22 15:40:57 -05001855 inode_unlock(inode);
Miao Xie0c1a98c2011-09-11 10:52:24 -04001856 goto out;
1857 }
Chandan Rajendra27772b62016-01-21 15:56:03 +05301858 if (start_pos > round_up(oldsize, root->sectorsize))
1859 clean_page = 1;
Miao Xie0c1a98c2011-09-11 10:52:24 -04001860 }
1861
Josef Bacikb812ce22012-11-16 13:56:32 -05001862 if (sync)
1863 atomic_inc(&BTRFS_I(inode)->sync_writers);
1864
Al Viro2ba48ce2015-04-09 13:52:01 -04001865 if (iocb->ki_flags & IOCB_DIRECT) {
Christoph Hellwig1af5bb42016-04-07 08:51:56 -07001866 num_written = __btrfs_direct_write(iocb, from);
Josef Bacikd0215f32011-01-25 14:57:24 -05001867 } else {
Al Virob30ac0f2014-04-03 14:29:04 -04001868 num_written = __btrfs_buffered_write(file, from, pos);
Josef Bacikd0215f32011-01-25 14:57:24 -05001869 if (num_written > 0)
Al Viro867c4f92014-02-11 19:31:06 -05001870 iocb->ki_pos = pos + num_written;
Chandan Rajendra27772b62016-01-21 15:56:03 +05301871 if (clean_page)
1872 pagecache_isize_extended(inode, oldsize,
1873 i_size_read(inode));
Josef Bacikd0215f32011-01-25 14:57:24 -05001874 }
1875
Al Viro59551022016-01-22 15:40:57 -05001876 inode_unlock(inode);
Chris Mason2ff3e9b2007-10-29 14:36:41 -04001877
Chris Mason5a3f23d2009-03-31 13:27:11 -04001878 /*
Josef Bacik6c760c02012-11-09 10:53:21 -05001879 * We also have to set last_sub_trans to the current log transid,
1880 * otherwise subsequent syncs to a file that's been synced in this
Adam Buchbinderbb7ab3b2016-03-04 11:23:12 -08001881 * transaction will appear to have already occurred.
Chris Mason5a3f23d2009-03-31 13:27:11 -04001882 */
Filipe Manana2f2ff0e2015-03-20 17:19:46 +00001883 spin_lock(&BTRFS_I(inode)->lock);
Josef Bacik6c760c02012-11-09 10:53:21 -05001884 BTRFS_I(inode)->last_sub_trans = root->log_transid;
Filipe Manana2f2ff0e2015-03-20 17:19:46 +00001885 spin_unlock(&BTRFS_I(inode)->lock);
Christoph Hellwige2592212016-04-07 08:52:01 -07001886 if (num_written > 0)
1887 num_written = generic_write_sync(iocb, num_written);
Miao Xie0a3404d2013-01-28 12:34:55 +00001888
Josef Bacikb812ce22012-11-16 13:56:32 -05001889 if (sync)
1890 atomic_dec(&BTRFS_I(inode)->sync_writers);
Miao Xie0a3404d2013-01-28 12:34:55 +00001891out:
Chris Mason39279cc2007-06-12 06:35:45 -04001892 current->backing_dev_info = NULL;
Chris Mason39279cc2007-06-12 06:35:45 -04001893 return num_written ? num_written : err;
1894}
1895
Chris Masond3977122009-01-05 21:25:51 -05001896int btrfs_release_file(struct inode *inode, struct file *filp)
Mingminge1b81e62008-05-27 10:55:43 -04001897{
Sage Weil6bf13c02008-06-10 10:07:39 -04001898 if (filp->private_data)
1899 btrfs_ioctl_trans_end(filp);
Chris Masonf6dc45c2014-08-20 07:15:33 -07001900 /*
1901 * ordered_data_close is set by settattr when we are about to truncate
1902 * a file from a non-zero size to a zero size. This tries to
1903 * flush down new bytes that may have been written if the
1904 * application were using truncate to replace a file in place.
1905 */
1906 if (test_and_clear_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
1907 &BTRFS_I(inode)->runtime_flags))
1908 filemap_flush(inode->i_mapping);
Mingminge1b81e62008-05-27 10:55:43 -04001909 return 0;
1910}
1911
Filipe Manana669249e2014-09-02 11:09:58 +01001912static int start_ordered_ops(struct inode *inode, loff_t start, loff_t end)
1913{
1914 int ret;
1915
1916 atomic_inc(&BTRFS_I(inode)->sync_writers);
Filipe Manana728404d2014-10-10 09:43:11 +01001917 ret = btrfs_fdatawrite_range(inode, start, end);
Filipe Manana669249e2014-09-02 11:09:58 +01001918 atomic_dec(&BTRFS_I(inode)->sync_writers);
1919
1920 return ret;
1921}
1922
Chris Masond352ac62008-09-29 15:18:18 -04001923/*
1924 * fsync call for both files and directories. This logs the inode into
1925 * the tree log instead of forcing full commits whenever possible.
1926 *
1927 * It needs to call filemap_fdatawait so that all ordered extent updates are
1928 * in the metadata btree are up to date for copying to the log.
1929 *
1930 * It drops the inode mutex before doing the tree log commit. This is an
1931 * important optimization for directories because holding the mutex prevents
1932 * new operations on the dir while we write to disk.
1933 */
Josef Bacik02c24a82011-07-16 20:44:56 -04001934int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
Chris Mason39279cc2007-06-12 06:35:45 -04001935{
Filipe Mananade17e792016-03-30 19:03:13 -04001936 struct dentry *dentry = file_dentry(file);
David Howells2b0143b2015-03-17 22:25:59 +00001937 struct inode *inode = d_inode(dentry);
Chris Mason39279cc2007-06-12 06:35:45 -04001938 struct btrfs_root *root = BTRFS_I(inode)->root;
Chris Mason39279cc2007-06-12 06:35:45 -04001939 struct btrfs_trans_handle *trans;
Miao Xie8b050d32014-02-20 18:08:58 +08001940 struct btrfs_log_ctx ctx;
1941 int ret = 0;
Josef Bacik2ab28f32012-10-12 15:27:49 -04001942 bool full_sync = 0;
David Sterba9dcbeed2015-11-09 11:44:45 +01001943 u64 len;
Chris Mason39279cc2007-06-12 06:35:45 -04001944
David Sterba9dcbeed2015-11-09 11:44:45 +01001945 /*
1946 * The range length can be represented by u64, we have to do the typecasts
1947 * to avoid signed overflow if it's [0, LLONG_MAX] eg. from fsync()
1948 */
1949 len = (u64)end - (u64)start + 1;
liubo1abe9b82011-03-24 11:18:59 +00001950 trace_btrfs_sync_file(file, datasync);
Chris Mason257c62e2009-10-13 13:21:08 -04001951
Miao Xie90abccf2012-09-13 04:53:47 -06001952 /*
1953 * We write the dirty pages in the range and wait until they complete
1954 * out of the ->i_mutex. If so, we can flush the dirty pages by
Josef Bacik2ab28f32012-10-12 15:27:49 -04001955 * multi-task, and make the performance up. See
1956 * btrfs_wait_ordered_range for an explanation of the ASYNC check.
Miao Xie90abccf2012-09-13 04:53:47 -06001957 */
Filipe Manana669249e2014-09-02 11:09:58 +01001958 ret = start_ordered_ops(inode, start, end);
Miao Xie90abccf2012-09-13 04:53:47 -06001959 if (ret)
1960 return ret;
1961
Al Viro59551022016-01-22 15:40:57 -05001962 inode_lock(inode);
Miao Xie2ecb7922012-09-06 04:04:27 -06001963 atomic_inc(&root->log_batch);
Josef Bacik2ab28f32012-10-12 15:27:49 -04001964 full_sync = test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
1965 &BTRFS_I(inode)->runtime_flags);
Filipe Manana669249e2014-09-02 11:09:58 +01001966 /*
1967 * We might have have had more pages made dirty after calling
1968 * start_ordered_ops and before acquiring the inode's i_mutex.
1969 */
Josef Bacik0ef8b722013-10-25 16:13:35 -04001970 if (full_sync) {
Filipe Manana669249e2014-09-02 11:09:58 +01001971 /*
1972 * For a full sync, we need to make sure any ordered operations
1973 * start and finish before we start logging the inode, so that
1974 * all extents are persisted and the respective file extent
1975 * items are in the fs/subvol btree.
1976 */
Filipe Mananab659ef02015-03-31 14:16:52 +01001977 ret = btrfs_wait_ordered_range(inode, start, len);
Filipe Manana669249e2014-09-02 11:09:58 +01001978 } else {
1979 /*
1980 * Start any new ordered operations before starting to log the
1981 * inode. We will wait for them to finish in btrfs_sync_log().
1982 *
1983 * Right before acquiring the inode's mutex, we might have new
1984 * writes dirtying pages, which won't immediately start the
1985 * respective ordered operations - that is done through the
1986 * fill_delalloc callbacks invoked from the writepage and
1987 * writepages address space operations. So make sure we start
1988 * all ordered operations before starting to log our inode. Not
1989 * doing this means that while logging the inode, writeback
1990 * could start and invoke writepage/writepages, which would call
1991 * the fill_delalloc callbacks (cow_file_range,
1992 * submit_compressed_extents). These callbacks add first an
1993 * extent map to the modified list of extents and then create
1994 * the respective ordered operation, which means in
1995 * tree-log.c:btrfs_log_inode() we might capture all existing
1996 * ordered operations (with btrfs_get_logged_extents()) before
1997 * the fill_delalloc callback adds its ordered operation, and by
1998 * the time we visit the modified list of extent maps (with
1999 * btrfs_log_changed_extents()), we see and process the extent
2000 * map they created. We then use the extent map to construct a
2001 * file extent item for logging without waiting for the
2002 * respective ordered operation to finish - this file extent
2003 * item points to a disk location that might not have yet been
2004 * written to, containing random data - so after a crash a log
2005 * replay will make our inode have file extent items that point
2006 * to disk locations containing invalid data, as we returned
2007 * success to userspace without waiting for the respective
2008 * ordered operation to finish, because it wasn't captured by
2009 * btrfs_get_logged_extents().
2010 */
2011 ret = start_ordered_ops(inode, start, end);
2012 }
2013 if (ret) {
Al Viro59551022016-01-22 15:40:57 -05002014 inode_unlock(inode);
Filipe Manana669249e2014-09-02 11:09:58 +01002015 goto out;
Josef Bacik0ef8b722013-10-25 16:13:35 -04002016 }
Miao Xie2ecb7922012-09-06 04:04:27 -06002017 atomic_inc(&root->log_batch);
Chris Mason257c62e2009-10-13 13:21:08 -04002018
Chris Mason39279cc2007-06-12 06:35:45 -04002019 /*
Filipe Manana3a8b36f2015-03-01 20:36:00 +00002020 * If the last transaction that changed this file was before the current
2021 * transaction and we have the full sync flag set in our inode, we can
2022 * bail out now without any syncing.
2023 *
2024 * Note that we can't bail out if the full sync flag isn't set. This is
2025 * because when the full sync flag is set we start all ordered extents
2026 * and wait for them to fully complete - when they complete they update
2027 * the inode's last_trans field through:
2028 *
2029 * btrfs_finish_ordered_io() ->
2030 * btrfs_update_inode_fallback() ->
2031 * btrfs_update_inode() ->
2032 * btrfs_set_inode_last_trans()
2033 *
2034 * So we are sure that last_trans is up to date and can do this check to
2035 * bail out safely. For the fast path, when the full sync flag is not
2036 * set in our inode, we can not do it because we start only our ordered
2037 * extents and don't wait for them to complete (that is when
2038 * btrfs_finish_ordered_io runs), so here at this point their last_trans
2039 * value might be less than or equals to fs_info->last_trans_committed,
2040 * and setting a speculative last_trans for an inode when a buffered
2041 * write is made (such as fs_info->generation + 1 for example) would not
2042 * be reliable since after setting the value and before fsync is called
2043 * any number of transactions can start and commit (transaction kthread
2044 * commits the current transaction periodically), and a transaction
2045 * commit does not start nor waits for ordered extents to complete.
Chris Mason257c62e2009-10-13 13:21:08 -04002046 */
Josef Bacika4abeea2011-04-11 17:25:13 -04002047 smp_mb();
Josef Bacik22ee6982012-05-29 16:57:49 -04002048 if (btrfs_inode_in_log(inode, root->fs_info->generation) ||
Filipe Mananaaffc0ff2016-02-24 07:35:05 +00002049 (full_sync && BTRFS_I(inode)->last_trans <=
2050 root->fs_info->last_trans_committed) ||
2051 (!btrfs_have_ordered_extents_in_range(inode, start, len) &&
2052 BTRFS_I(inode)->last_trans
2053 <= root->fs_info->last_trans_committed)) {
Josef Bacik5dc562c2012-08-17 13:14:17 -04002054 /*
Nicholas D Steeves01327612016-05-19 21:18:45 -04002055 * We've had everything committed since the last time we were
Josef Bacik5dc562c2012-08-17 13:14:17 -04002056 * modified so clear this flag in case it was set for whatever
2057 * reason, it's no longer relevant.
2058 */
2059 clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
2060 &BTRFS_I(inode)->runtime_flags);
Filipe Manana0596a902016-06-14 14:18:27 +01002061 /*
2062 * An ordered extent might have started before and completed
2063 * already with io errors, in which case the inode was not
2064 * updated and we end up here. So check the inode's mapping
2065 * flags for any errors that might have happened while doing
2066 * writeback of file data.
2067 */
Miklos Szeredif0312212016-09-16 12:44:21 +02002068 ret = filemap_check_errors(inode->i_mapping);
Al Viro59551022016-01-22 15:40:57 -05002069 inode_unlock(inode);
Josef Bacik15ee9bc2007-08-10 16:22:09 -04002070 goto out;
2071 }
Josef Bacik15ee9bc2007-08-10 16:22:09 -04002072
2073 /*
Chris Masona52d9a82007-08-27 16:49:44 -04002074 * ok we haven't committed the transaction yet, lets do a commit
2075 */
Dan Carpenter6f902af2010-05-29 09:49:07 +00002076 if (file->private_data)
Sage Weil6bf13c02008-06-10 10:07:39 -04002077 btrfs_ioctl_trans_end(file);
2078
Josef Bacik5039edd2014-01-15 13:34:13 -05002079 /*
2080 * We use start here because we will need to wait on the IO to complete
2081 * in btrfs_sync_log, which could require joining a transaction (for
2082 * example checking cross references in the nocow path). If we use join
2083 * here we could get into a situation where we're waiting on IO to
2084 * happen that is blocked on a transaction trying to commit. With start
2085 * we inc the extwriter counter, so we wait for all extwriters to exit
2086 * before we start blocking join'ers. This comment is to keep somebody
2087 * from thinking they are super smart and changing this to
2088 * btrfs_join_transaction *cough*Josef*cough*.
2089 */
Yan, Zhenga22285a2010-05-16 10:48:46 -04002090 trans = btrfs_start_transaction(root, 0);
2091 if (IS_ERR(trans)) {
2092 ret = PTR_ERR(trans);
Al Viro59551022016-01-22 15:40:57 -05002093 inode_unlock(inode);
Chris Mason39279cc2007-06-12 06:35:45 -04002094 goto out;
2095 }
Josef Bacik5039edd2014-01-15 13:34:13 -05002096 trans->sync = true;
Chris Masone02119d2008-09-05 16:13:11 -04002097
Filipe Manana28a23592016-08-23 21:13:51 +01002098 btrfs_init_log_ctx(&ctx, inode);
Miao Xie8b050d32014-02-20 18:08:58 +08002099
Filipe Manana49dae1b2014-09-06 22:34:39 +01002100 ret = btrfs_log_dentry_safe(trans, root, dentry, start, end, &ctx);
Josef Bacik02c24a82011-07-16 20:44:56 -04002101 if (ret < 0) {
Filipe David Borba Mananaa0634be2013-09-11 20:36:44 +01002102 /* Fallthrough and commit/free transaction. */
2103 ret = 1;
Josef Bacik02c24a82011-07-16 20:44:56 -04002104 }
Chris Mason49eb7e42008-09-11 15:53:12 -04002105
2106 /* we've logged all the items and now have a consistent
2107 * version of the file in the log. It is possible that
2108 * someone will come in and modify the file, but that's
2109 * fine because the log is consistent on disk, and we
2110 * have references to all of the file's extents
2111 *
2112 * It is possible that someone will come in and log the
2113 * file again, but that will end up using the synchronization
2114 * inside btrfs_sync_log to keep things safe.
2115 */
Al Viro59551022016-01-22 15:40:57 -05002116 inode_unlock(inode);
Chris Mason49eb7e42008-09-11 15:53:12 -04002117
Filipe Manana8407f552014-09-05 15:14:39 +01002118 /*
2119 * If any of the ordered extents had an error, just return it to user
2120 * space, so that the application knows some writes didn't succeed and
2121 * can take proper action (retry for e.g.). Blindly committing the
2122 * transaction in this case, would fool userspace that everything was
2123 * successful. And we also want to make sure our log doesn't contain
2124 * file extent items pointing to extents that weren't fully written to -
2125 * just like in the non fast fsync path, where we check for the ordered
2126 * operation's error flag before writing to the log tree and return -EIO
2127 * if any of them had this flag set (btrfs_wait_ordered_range) -
2128 * therefore we need to check for errors in the ordered operations,
2129 * which are indicated by ctx.io_err.
2130 */
2131 if (ctx.io_err) {
2132 btrfs_end_transaction(trans, root);
2133 ret = ctx.io_err;
2134 goto out;
2135 }
2136
Chris Mason257c62e2009-10-13 13:21:08 -04002137 if (ret != BTRFS_NO_LOG_SYNC) {
Josef Bacik0ef8b722013-10-25 16:13:35 -04002138 if (!ret) {
Miao Xie8b050d32014-02-20 18:08:58 +08002139 ret = btrfs_sync_log(trans, root, &ctx);
Josef Bacik0ef8b722013-10-25 16:13:35 -04002140 if (!ret) {
Chris Mason257c62e2009-10-13 13:21:08 -04002141 ret = btrfs_end_transaction(trans, root);
Josef Bacik0ef8b722013-10-25 16:13:35 -04002142 goto out;
Josef Bacik2ab28f32012-10-12 15:27:49 -04002143 }
Chris Mason257c62e2009-10-13 13:21:08 -04002144 }
Josef Bacik0ef8b722013-10-25 16:13:35 -04002145 if (!full_sync) {
David Sterba9dcbeed2015-11-09 11:44:45 +01002146 ret = btrfs_wait_ordered_range(inode, start, len);
Filipe Mananab05fd872014-05-29 23:31:39 +01002147 if (ret) {
2148 btrfs_end_transaction(trans, root);
Josef Bacik0ef8b722013-10-25 16:13:35 -04002149 goto out;
Filipe Mananab05fd872014-05-29 23:31:39 +01002150 }
Josef Bacik0ef8b722013-10-25 16:13:35 -04002151 }
2152 ret = btrfs_commit_transaction(trans, root);
Chris Mason257c62e2009-10-13 13:21:08 -04002153 } else {
2154 ret = btrfs_end_transaction(trans, root);
Chris Masone02119d2008-09-05 16:13:11 -04002155 }
Chris Mason39279cc2007-06-12 06:35:45 -04002156out:
Roel Kluin014e4ac2010-01-29 10:42:11 +00002157 return ret > 0 ? -EIO : ret;
Chris Mason39279cc2007-06-12 06:35:45 -04002158}
2159
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +04002160static const struct vm_operations_struct btrfs_file_vm_ops = {
Chris Mason92fee662007-07-25 12:31:35 -04002161 .fault = filemap_fault,
Kirill A. Shutemovf1820362014-04-07 15:37:19 -07002162 .map_pages = filemap_map_pages,
Chris Mason9ebefb182007-06-15 13:50:00 -04002163 .page_mkwrite = btrfs_page_mkwrite,
2164};
2165
2166static int btrfs_file_mmap(struct file *filp, struct vm_area_struct *vma)
2167{
Miao Xie058a4572010-05-20 07:21:50 +00002168 struct address_space *mapping = filp->f_mapping;
2169
2170 if (!mapping->a_ops->readpage)
2171 return -ENOEXEC;
2172
Chris Mason9ebefb182007-06-15 13:50:00 -04002173 file_accessed(filp);
Miao Xie058a4572010-05-20 07:21:50 +00002174 vma->vm_ops = &btrfs_file_vm_ops;
Miao Xie058a4572010-05-20 07:21:50 +00002175
Chris Mason9ebefb182007-06-15 13:50:00 -04002176 return 0;
2177}
2178
Josef Bacik2aaa6652012-08-29 14:27:18 -04002179static int hole_mergeable(struct inode *inode, struct extent_buffer *leaf,
2180 int slot, u64 start, u64 end)
2181{
2182 struct btrfs_file_extent_item *fi;
2183 struct btrfs_key key;
2184
2185 if (slot < 0 || slot >= btrfs_header_nritems(leaf))
2186 return 0;
2187
2188 btrfs_item_key_to_cpu(leaf, &key, slot);
2189 if (key.objectid != btrfs_ino(inode) ||
2190 key.type != BTRFS_EXTENT_DATA_KEY)
2191 return 0;
2192
2193 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
2194
2195 if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
2196 return 0;
2197
2198 if (btrfs_file_extent_disk_bytenr(leaf, fi))
2199 return 0;
2200
2201 if (key.offset == end)
2202 return 1;
2203 if (key.offset + btrfs_file_extent_num_bytes(leaf, fi) == start)
2204 return 1;
2205 return 0;
2206}
2207
2208static int fill_holes(struct btrfs_trans_handle *trans, struct inode *inode,
2209 struct btrfs_path *path, u64 offset, u64 end)
2210{
2211 struct btrfs_root *root = BTRFS_I(inode)->root;
2212 struct extent_buffer *leaf;
2213 struct btrfs_file_extent_item *fi;
2214 struct extent_map *hole_em;
2215 struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
2216 struct btrfs_key key;
2217 int ret;
2218
Josef Bacik16e75492013-10-22 12:18:51 -04002219 if (btrfs_fs_incompat(root->fs_info, NO_HOLES))
2220 goto out;
2221
Josef Bacik2aaa6652012-08-29 14:27:18 -04002222 key.objectid = btrfs_ino(inode);
2223 key.type = BTRFS_EXTENT_DATA_KEY;
2224 key.offset = offset;
2225
Josef Bacik2aaa6652012-08-29 14:27:18 -04002226 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2227 if (ret < 0)
2228 return ret;
2229 BUG_ON(!ret);
2230
2231 leaf = path->nodes[0];
2232 if (hole_mergeable(inode, leaf, path->slots[0]-1, offset, end)) {
2233 u64 num_bytes;
2234
2235 path->slots[0]--;
2236 fi = btrfs_item_ptr(leaf, path->slots[0],
2237 struct btrfs_file_extent_item);
2238 num_bytes = btrfs_file_extent_num_bytes(leaf, fi) +
2239 end - offset;
2240 btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
2241 btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
2242 btrfs_set_file_extent_offset(leaf, fi, 0);
2243 btrfs_mark_buffer_dirty(leaf);
2244 goto out;
2245 }
2246
chandan1707e262014-07-01 12:04:28 +05302247 if (hole_mergeable(inode, leaf, path->slots[0], offset, end)) {
Josef Bacik2aaa6652012-08-29 14:27:18 -04002248 u64 num_bytes;
2249
Josef Bacik2aaa6652012-08-29 14:27:18 -04002250 key.offset = offset;
Daniel Dresslerb7a03652014-11-12 13:43:09 +09002251 btrfs_set_item_key_safe(root->fs_info, path, &key);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002252 fi = btrfs_item_ptr(leaf, path->slots[0],
2253 struct btrfs_file_extent_item);
2254 num_bytes = btrfs_file_extent_num_bytes(leaf, fi) + end -
2255 offset;
2256 btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
2257 btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
2258 btrfs_set_file_extent_offset(leaf, fi, 0);
2259 btrfs_mark_buffer_dirty(leaf);
2260 goto out;
2261 }
2262 btrfs_release_path(path);
2263
2264 ret = btrfs_insert_file_extent(trans, root, btrfs_ino(inode), offset,
2265 0, 0, end - offset, 0, end - offset,
2266 0, 0, 0);
2267 if (ret)
2268 return ret;
2269
2270out:
2271 btrfs_release_path(path);
2272
2273 hole_em = alloc_extent_map();
2274 if (!hole_em) {
2275 btrfs_drop_extent_cache(inode, offset, end - 1, 0);
2276 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
2277 &BTRFS_I(inode)->runtime_flags);
2278 } else {
2279 hole_em->start = offset;
2280 hole_em->len = end - offset;
Josef Bacikcc95bef2013-04-04 14:31:27 -04002281 hole_em->ram_bytes = hole_em->len;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002282 hole_em->orig_start = offset;
2283
2284 hole_em->block_start = EXTENT_MAP_HOLE;
2285 hole_em->block_len = 0;
Josef Bacikb4939682012-12-03 10:31:19 -05002286 hole_em->orig_block_len = 0;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002287 hole_em->bdev = root->fs_info->fs_devices->latest_bdev;
2288 hole_em->compress_type = BTRFS_COMPRESS_NONE;
2289 hole_em->generation = trans->transid;
2290
2291 do {
2292 btrfs_drop_extent_cache(inode, offset, end - 1, 0);
2293 write_lock(&em_tree->lock);
Josef Bacik09a2a8f92013-04-05 16:51:15 -04002294 ret = add_extent_mapping(em_tree, hole_em, 1);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002295 write_unlock(&em_tree->lock);
2296 } while (ret == -EEXIST);
2297 free_extent_map(hole_em);
2298 if (ret)
2299 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
2300 &BTRFS_I(inode)->runtime_flags);
2301 }
2302
2303 return 0;
2304}
2305
Qu Wenruod7781542014-05-30 15:16:10 +08002306/*
2307 * Find a hole extent on given inode and change start/len to the end of hole
2308 * extent.(hole/vacuum extent whose em->start <= start &&
2309 * em->start + em->len > start)
2310 * When a hole extent is found, return 1 and modify start/len.
2311 */
2312static int find_first_non_hole(struct inode *inode, u64 *start, u64 *len)
2313{
2314 struct extent_map *em;
2315 int ret = 0;
2316
2317 em = btrfs_get_extent(inode, NULL, 0, *start, *len, 0);
2318 if (IS_ERR_OR_NULL(em)) {
2319 if (!em)
2320 ret = -ENOMEM;
2321 else
2322 ret = PTR_ERR(em);
2323 return ret;
2324 }
2325
2326 /* Hole or vacuum extent(only exists in no-hole mode) */
2327 if (em->block_start == EXTENT_MAP_HOLE) {
2328 ret = 1;
2329 *len = em->start + em->len > *start + *len ?
2330 0 : *start + *len - em->start - em->len;
2331 *start = em->start + em->len;
2332 }
2333 free_extent_map(em);
2334 return ret;
2335}
2336
Josef Bacik2aaa6652012-08-29 14:27:18 -04002337static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
2338{
2339 struct btrfs_root *root = BTRFS_I(inode)->root;
2340 struct extent_state *cached_state = NULL;
2341 struct btrfs_path *path;
2342 struct btrfs_block_rsv *rsv;
2343 struct btrfs_trans_handle *trans;
Qu Wenruod7781542014-05-30 15:16:10 +08002344 u64 lockstart;
2345 u64 lockend;
2346 u64 tail_start;
2347 u64 tail_len;
2348 u64 orig_start = offset;
2349 u64 cur_offset;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002350 u64 min_size = btrfs_calc_trunc_metadata_size(root, 1);
2351 u64 drop_end;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002352 int ret = 0;
2353 int err = 0;
Alexandru Moise6e4d6fa2015-09-22 21:00:07 +00002354 unsigned int rsv_count;
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302355 bool same_block;
Josef Bacik16e75492013-10-22 12:18:51 -04002356 bool no_holes = btrfs_fs_incompat(root->fs_info, NO_HOLES);
Filipe Mananaa1a50f62014-04-26 01:35:31 +01002357 u64 ino_size;
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302358 bool truncated_block = false;
Filipe Mananae8c1c762015-02-15 22:38:54 +00002359 bool updated_inode = false;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002360
Josef Bacik0ef8b722013-10-25 16:13:35 -04002361 ret = btrfs_wait_ordered_range(inode, offset, len);
2362 if (ret)
2363 return ret;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002364
Al Viro59551022016-01-22 15:40:57 -05002365 inode_lock(inode);
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302366 ino_size = round_up(inode->i_size, root->sectorsize);
Qu Wenruod7781542014-05-30 15:16:10 +08002367 ret = find_first_non_hole(inode, &offset, &len);
2368 if (ret < 0)
2369 goto out_only_mutex;
2370 if (ret && !len) {
2371 /* Already in a large hole */
2372 ret = 0;
2373 goto out_only_mutex;
2374 }
2375
Qu Wenruo51f395a2014-08-08 13:06:20 +08002376 lockstart = round_up(offset, BTRFS_I(inode)->root->sectorsize);
Qu Wenruod7781542014-05-30 15:16:10 +08002377 lockend = round_down(offset + len,
2378 BTRFS_I(inode)->root->sectorsize) - 1;
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302379 same_block = (BTRFS_BYTES_TO_BLKS(root->fs_info, offset))
2380 == (BTRFS_BYTES_TO_BLKS(root->fs_info, offset + len - 1));
Miao Xie7426cc02012-12-05 10:54:52 +00002381 /*
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302382 * We needn't truncate any block which is beyond the end of the file
Miao Xie7426cc02012-12-05 10:54:52 +00002383 * because we are sure there is no data there.
2384 */
Josef Bacik2aaa6652012-08-29 14:27:18 -04002385 /*
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302386 * Only do this if we are in the same block and we aren't doing the
2387 * entire block.
Josef Bacik2aaa6652012-08-29 14:27:18 -04002388 */
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302389 if (same_block && len < root->sectorsize) {
Filipe Mananae8c1c762015-02-15 22:38:54 +00002390 if (offset < ino_size) {
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302391 truncated_block = true;
2392 ret = btrfs_truncate_block(inode, offset, len, 0);
Filipe Mananae8c1c762015-02-15 22:38:54 +00002393 } else {
2394 ret = 0;
2395 }
Qu Wenruod7781542014-05-30 15:16:10 +08002396 goto out_only_mutex;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002397 }
2398
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302399 /* zero back part of the first block */
Filipe Manana12870f12014-02-15 15:55:58 +00002400 if (offset < ino_size) {
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302401 truncated_block = true;
2402 ret = btrfs_truncate_block(inode, offset, 0, 0);
Miao Xie7426cc02012-12-05 10:54:52 +00002403 if (ret) {
Al Viro59551022016-01-22 15:40:57 -05002404 inode_unlock(inode);
Miao Xie7426cc02012-12-05 10:54:52 +00002405 return ret;
2406 }
Josef Bacik2aaa6652012-08-29 14:27:18 -04002407 }
2408
Qu Wenruod7781542014-05-30 15:16:10 +08002409 /* Check the aligned pages after the first unaligned page,
2410 * if offset != orig_start, which means the first unaligned page
Nicholas D Steeves01327612016-05-19 21:18:45 -04002411 * including several following pages are already in holes,
Qu Wenruod7781542014-05-30 15:16:10 +08002412 * the extra check can be skipped */
2413 if (offset == orig_start) {
2414 /* after truncate page, check hole again */
2415 len = offset + len - lockstart;
2416 offset = lockstart;
2417 ret = find_first_non_hole(inode, &offset, &len);
2418 if (ret < 0)
2419 goto out_only_mutex;
2420 if (ret && !len) {
2421 ret = 0;
2422 goto out_only_mutex;
2423 }
2424 lockstart = offset;
2425 }
2426
2427 /* Check the tail unaligned part is in a hole */
2428 tail_start = lockend + 1;
2429 tail_len = offset + len - tail_start;
2430 if (tail_len) {
2431 ret = find_first_non_hole(inode, &tail_start, &tail_len);
2432 if (unlikely(ret < 0))
2433 goto out_only_mutex;
2434 if (!ret) {
2435 /* zero the front end of the last page */
2436 if (tail_start + tail_len < ino_size) {
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302437 truncated_block = true;
2438 ret = btrfs_truncate_block(inode,
2439 tail_start + tail_len,
2440 0, 1);
Qu Wenruod7781542014-05-30 15:16:10 +08002441 if (ret)
2442 goto out_only_mutex;
Qu Wenruo51f395a2014-08-08 13:06:20 +08002443 }
Miao Xie00612802012-12-05 10:54:12 +00002444 }
Josef Bacik2aaa6652012-08-29 14:27:18 -04002445 }
2446
2447 if (lockend < lockstart) {
Filipe Mananae8c1c762015-02-15 22:38:54 +00002448 ret = 0;
2449 goto out_only_mutex;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002450 }
2451
2452 while (1) {
2453 struct btrfs_ordered_extent *ordered;
2454
2455 truncate_pagecache_range(inode, lockstart, lockend);
2456
2457 lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
David Sterbaff13db42015-12-03 14:30:40 +01002458 &cached_state);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002459 ordered = btrfs_lookup_first_ordered_extent(inode, lockend);
2460
2461 /*
2462 * We need to make sure we have no ordered extents in this range
2463 * and nobody raced in and read a page in this range, if we did
2464 * we need to try again.
2465 */
2466 if ((!ordered ||
Filipe David Borba Manana6126e3c2013-11-19 16:19:24 +00002467 (ordered->file_offset + ordered->len <= lockstart ||
Josef Bacik2aaa6652012-08-29 14:27:18 -04002468 ordered->file_offset > lockend)) &&
Alex Gartrellfc4adbf2014-05-20 13:07:56 -07002469 !btrfs_page_exists_in_range(inode, lockstart, lockend)) {
Josef Bacik2aaa6652012-08-29 14:27:18 -04002470 if (ordered)
2471 btrfs_put_ordered_extent(ordered);
2472 break;
2473 }
2474 if (ordered)
2475 btrfs_put_ordered_extent(ordered);
2476 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart,
2477 lockend, &cached_state, GFP_NOFS);
Josef Bacik0ef8b722013-10-25 16:13:35 -04002478 ret = btrfs_wait_ordered_range(inode, lockstart,
2479 lockend - lockstart + 1);
2480 if (ret) {
Al Viro59551022016-01-22 15:40:57 -05002481 inode_unlock(inode);
Josef Bacik0ef8b722013-10-25 16:13:35 -04002482 return ret;
2483 }
Josef Bacik2aaa6652012-08-29 14:27:18 -04002484 }
2485
2486 path = btrfs_alloc_path();
2487 if (!path) {
2488 ret = -ENOMEM;
2489 goto out;
2490 }
2491
Miao Xie66d8f3d2012-09-06 04:02:28 -06002492 rsv = btrfs_alloc_block_rsv(root, BTRFS_BLOCK_RSV_TEMP);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002493 if (!rsv) {
2494 ret = -ENOMEM;
2495 goto out_free;
2496 }
2497 rsv->size = btrfs_calc_trunc_metadata_size(root, 1);
2498 rsv->failfast = 1;
2499
2500 /*
2501 * 1 - update the inode
2502 * 1 - removing the extents in the range
Josef Bacik16e75492013-10-22 12:18:51 -04002503 * 1 - adding the hole extent if no_holes isn't set
Josef Bacik2aaa6652012-08-29 14:27:18 -04002504 */
Josef Bacik16e75492013-10-22 12:18:51 -04002505 rsv_count = no_holes ? 2 : 3;
2506 trans = btrfs_start_transaction(root, rsv_count);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002507 if (IS_ERR(trans)) {
2508 err = PTR_ERR(trans);
2509 goto out_free;
2510 }
2511
2512 ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv, rsv,
Josef Bacik25d609f2016-03-25 13:25:48 -04002513 min_size, 0);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002514 BUG_ON(ret);
2515 trans->block_rsv = rsv;
2516
Qu Wenruod7781542014-05-30 15:16:10 +08002517 cur_offset = lockstart;
2518 len = lockend - cur_offset;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002519 while (cur_offset < lockend) {
2520 ret = __btrfs_drop_extents(trans, root, inode, path,
2521 cur_offset, lockend + 1,
Filipe David Borba Manana1acae572014-01-07 11:42:27 +00002522 &drop_end, 1, 0, 0, NULL);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002523 if (ret != -ENOSPC)
2524 break;
2525
2526 trans->block_rsv = &root->fs_info->trans_block_rsv;
2527
Filipe Manana12870f12014-02-15 15:55:58 +00002528 if (cur_offset < ino_size) {
2529 ret = fill_holes(trans, inode, path, cur_offset,
2530 drop_end);
2531 if (ret) {
2532 err = ret;
2533 break;
2534 }
Josef Bacik2aaa6652012-08-29 14:27:18 -04002535 }
2536
2537 cur_offset = drop_end;
2538
2539 ret = btrfs_update_inode(trans, root, inode);
2540 if (ret) {
2541 err = ret;
2542 break;
2543 }
2544
Josef Bacik2aaa6652012-08-29 14:27:18 -04002545 btrfs_end_transaction(trans, root);
Liu Bob53d3f52012-11-14 14:34:34 +00002546 btrfs_btree_balance_dirty(root);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002547
Josef Bacik16e75492013-10-22 12:18:51 -04002548 trans = btrfs_start_transaction(root, rsv_count);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002549 if (IS_ERR(trans)) {
2550 ret = PTR_ERR(trans);
2551 trans = NULL;
2552 break;
2553 }
2554
2555 ret = btrfs_block_rsv_migrate(&root->fs_info->trans_block_rsv,
Josef Bacik25d609f2016-03-25 13:25:48 -04002556 rsv, min_size, 0);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002557 BUG_ON(ret); /* shouldn't happen */
2558 trans->block_rsv = rsv;
Qu Wenruod7781542014-05-30 15:16:10 +08002559
2560 ret = find_first_non_hole(inode, &cur_offset, &len);
2561 if (unlikely(ret < 0))
2562 break;
2563 if (ret && !len) {
2564 ret = 0;
2565 break;
2566 }
Josef Bacik2aaa6652012-08-29 14:27:18 -04002567 }
2568
2569 if (ret) {
2570 err = ret;
2571 goto out_trans;
2572 }
2573
2574 trans->block_rsv = &root->fs_info->trans_block_rsv;
Filipe Mananafc19c5e2014-04-29 13:18:40 +01002575 /*
Filipe Manana2959a322015-11-02 12:32:44 +00002576 * If we are using the NO_HOLES feature we might have had already an
2577 * hole that overlaps a part of the region [lockstart, lockend] and
2578 * ends at (or beyond) lockend. Since we have no file extent items to
2579 * represent holes, drop_end can be less than lockend and so we must
2580 * make sure we have an extent map representing the existing hole (the
2581 * call to __btrfs_drop_extents() might have dropped the existing extent
2582 * map representing the existing hole), otherwise the fast fsync path
2583 * will not record the existence of the hole region
2584 * [existing_hole_start, lockend].
2585 */
2586 if (drop_end <= lockend)
2587 drop_end = lockend + 1;
2588 /*
Filipe Mananafc19c5e2014-04-29 13:18:40 +01002589 * Don't insert file hole extent item if it's for a range beyond eof
2590 * (because it's useless) or if it represents a 0 bytes range (when
2591 * cur_offset == drop_end).
2592 */
2593 if (cur_offset < ino_size && cur_offset < drop_end) {
Filipe Manana12870f12014-02-15 15:55:58 +00002594 ret = fill_holes(trans, inode, path, cur_offset, drop_end);
2595 if (ret) {
2596 err = ret;
2597 goto out_trans;
2598 }
Josef Bacik2aaa6652012-08-29 14:27:18 -04002599 }
2600
2601out_trans:
2602 if (!trans)
2603 goto out_free;
2604
Tsutomu Itohe1f57902012-11-08 04:47:33 +00002605 inode_inc_iversion(inode);
Deepa Dinamanic2050a42016-09-14 07:48:06 -07002606 inode->i_mtime = inode->i_ctime = current_time(inode);
Tsutomu Itohe1f57902012-11-08 04:47:33 +00002607
Josef Bacik2aaa6652012-08-29 14:27:18 -04002608 trans->block_rsv = &root->fs_info->trans_block_rsv;
2609 ret = btrfs_update_inode(trans, root, inode);
Filipe Mananae8c1c762015-02-15 22:38:54 +00002610 updated_inode = true;
Josef Bacik2aaa6652012-08-29 14:27:18 -04002611 btrfs_end_transaction(trans, root);
Liu Bob53d3f52012-11-14 14:34:34 +00002612 btrfs_btree_balance_dirty(root);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002613out_free:
2614 btrfs_free_path(path);
2615 btrfs_free_block_rsv(root, rsv);
2616out:
2617 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
2618 &cached_state, GFP_NOFS);
Qu Wenruod7781542014-05-30 15:16:10 +08002619out_only_mutex:
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302620 if (!updated_inode && truncated_block && !ret && !err) {
Filipe Mananae8c1c762015-02-15 22:38:54 +00002621 /*
2622 * If we only end up zeroing part of a page, we still need to
2623 * update the inode item, so that all the time fields are
2624 * updated as well as the necessary btrfs inode in memory fields
2625 * for detecting, at fsync time, if the inode isn't yet in the
2626 * log tree or it's there but not up to date.
2627 */
2628 trans = btrfs_start_transaction(root, 1);
2629 if (IS_ERR(trans)) {
2630 err = PTR_ERR(trans);
2631 } else {
2632 err = btrfs_update_inode(trans, root, inode);
2633 ret = btrfs_end_transaction(trans, root);
2634 }
2635 }
Al Viro59551022016-01-22 15:40:57 -05002636 inode_unlock(inode);
Josef Bacik2aaa6652012-08-29 14:27:18 -04002637 if (ret && !err)
2638 err = ret;
2639 return err;
2640}
2641
Qu Wenruo14524a82015-09-08 17:22:44 +08002642/* Helper structure to record which range is already reserved */
2643struct falloc_range {
2644 struct list_head list;
2645 u64 start;
2646 u64 len;
2647};
2648
2649/*
2650 * Helper function to add falloc range
2651 *
2652 * Caller should have locked the larger range of extent containing
2653 * [start, len)
2654 */
2655static int add_falloc_range(struct list_head *head, u64 start, u64 len)
2656{
2657 struct falloc_range *prev = NULL;
2658 struct falloc_range *range = NULL;
2659
2660 if (list_empty(head))
2661 goto insert;
2662
2663 /*
2664 * As fallocate iterate by bytenr order, we only need to check
2665 * the last range.
2666 */
2667 prev = list_entry(head->prev, struct falloc_range, list);
2668 if (prev->start + prev->len == start) {
2669 prev->len += len;
2670 return 0;
2671 }
2672insert:
David Sterba32fc9322016-02-11 14:25:38 +01002673 range = kmalloc(sizeof(*range), GFP_KERNEL);
Qu Wenruo14524a82015-09-08 17:22:44 +08002674 if (!range)
2675 return -ENOMEM;
2676 range->start = start;
2677 range->len = len;
2678 list_add_tail(&range->list, head);
2679 return 0;
2680}
2681
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002682static long btrfs_fallocate(struct file *file, int mode,
2683 loff_t offset, loff_t len)
2684{
Al Viro496ad9a2013-01-23 17:07:38 -05002685 struct inode *inode = file_inode(file);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002686 struct extent_state *cached_state = NULL;
Qu Wenruo14524a82015-09-08 17:22:44 +08002687 struct falloc_range *range;
2688 struct falloc_range *tmp;
2689 struct list_head reserve_list;
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002690 u64 cur_offset;
2691 u64 last_byte;
2692 u64 alloc_start;
2693 u64 alloc_end;
2694 u64 alloc_hint = 0;
2695 u64 locked_end;
Qu Wenruo14524a82015-09-08 17:22:44 +08002696 u64 actual_end = 0;
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002697 struct extent_map *em;
Miao Xie797f4272012-11-28 10:28:07 +00002698 int blocksize = BTRFS_I(inode)->root->sectorsize;
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002699 int ret;
2700
Miao Xie797f4272012-11-28 10:28:07 +00002701 alloc_start = round_down(offset, blocksize);
2702 alloc_end = round_up(offset + len, blocksize);
Wang Xiaoguang18513092016-07-25 15:51:40 +08002703 cur_offset = alloc_start;
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002704
Josef Bacik2aaa6652012-08-29 14:27:18 -04002705 /* Make sure we aren't being give some crap mode */
2706 if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002707 return -EOPNOTSUPP;
2708
Josef Bacik2aaa6652012-08-29 14:27:18 -04002709 if (mode & FALLOC_FL_PUNCH_HOLE)
2710 return btrfs_punch_hole(inode, offset, len);
2711
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002712 /*
Qu Wenruo14524a82015-09-08 17:22:44 +08002713 * Only trigger disk allocation, don't trigger qgroup reserve
2714 *
2715 * For qgroup space, it will be checked later.
Chris Masond98456f2012-01-31 20:27:41 -05002716 */
Qu Wenruo14524a82015-09-08 17:22:44 +08002717 ret = btrfs_alloc_data_chunk_ondemand(inode, alloc_end - alloc_start);
2718 if (ret < 0)
Chris Masond98456f2012-01-31 20:27:41 -05002719 return ret;
2720
Al Viro59551022016-01-22 15:40:57 -05002721 inode_lock(inode);
Davide Italiano2a162ce2015-04-06 22:09:15 -07002722
2723 if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + len > inode->i_size) {
2724 ret = inode_newsize_ok(inode, offset + len);
2725 if (ret)
2726 goto out;
2727 }
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002728
Qu Wenruo14524a82015-09-08 17:22:44 +08002729 /*
2730 * TODO: Move these two operations after we have checked
2731 * accurate reserved space, or fallocate can still fail but
2732 * with page truncated or size expanded.
2733 *
2734 * But that's a minor problem and won't do much harm BTW.
2735 */
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002736 if (alloc_start > inode->i_size) {
Josef Bacika41ad392011-01-31 15:30:16 -05002737 ret = btrfs_cont_expand(inode, i_size_read(inode),
2738 alloc_start);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002739 if (ret)
2740 goto out;
Qu Wenruo0f6925f2015-10-14 15:26:13 +08002741 } else if (offset + len > inode->i_size) {
Josef Bacika71754f2013-06-17 17:14:39 -04002742 /*
2743 * If we are fallocating from the end of the file onward we
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302744 * need to zero out the end of the block if i_size lands in the
2745 * middle of a block.
Josef Bacika71754f2013-06-17 17:14:39 -04002746 */
Chandan Rajendra9703fef2016-01-21 15:55:56 +05302747 ret = btrfs_truncate_block(inode, inode->i_size, 0, 0);
Josef Bacika71754f2013-06-17 17:14:39 -04002748 if (ret)
2749 goto out;
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002750 }
2751
Josef Bacika71754f2013-06-17 17:14:39 -04002752 /*
2753 * wait for ordered IO before we have any locks. We'll loop again
2754 * below with the locks held.
2755 */
Josef Bacik0ef8b722013-10-25 16:13:35 -04002756 ret = btrfs_wait_ordered_range(inode, alloc_start,
2757 alloc_end - alloc_start);
2758 if (ret)
2759 goto out;
Josef Bacika71754f2013-06-17 17:14:39 -04002760
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002761 locked_end = alloc_end - 1;
2762 while (1) {
2763 struct btrfs_ordered_extent *ordered;
2764
2765 /* the extent lock is ordered inside the running
2766 * transaction
2767 */
2768 lock_extent_bits(&BTRFS_I(inode)->io_tree, alloc_start,
David Sterbaff13db42015-12-03 14:30:40 +01002769 locked_end, &cached_state);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002770 ordered = btrfs_lookup_first_ordered_extent(inode,
2771 alloc_end - 1);
2772 if (ordered &&
2773 ordered->file_offset + ordered->len > alloc_start &&
2774 ordered->file_offset < alloc_end) {
2775 btrfs_put_ordered_extent(ordered);
2776 unlock_extent_cached(&BTRFS_I(inode)->io_tree,
2777 alloc_start, locked_end,
David Sterba32fc9322016-02-11 14:25:38 +01002778 &cached_state, GFP_KERNEL);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002779 /*
2780 * we can't wait on the range with the transaction
2781 * running or with the extent lock held
2782 */
Josef Bacik0ef8b722013-10-25 16:13:35 -04002783 ret = btrfs_wait_ordered_range(inode, alloc_start,
2784 alloc_end - alloc_start);
2785 if (ret)
2786 goto out;
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002787 } else {
2788 if (ordered)
2789 btrfs_put_ordered_extent(ordered);
2790 break;
2791 }
2792 }
2793
Qu Wenruo14524a82015-09-08 17:22:44 +08002794 /* First, check if we exceed the qgroup limit */
2795 INIT_LIST_HEAD(&reserve_list);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002796 while (1) {
2797 em = btrfs_get_extent(inode, NULL, 0, cur_offset,
2798 alloc_end - cur_offset, 0);
Jeff Mahoney79787ea2012-03-12 16:03:00 +01002799 if (IS_ERR_OR_NULL(em)) {
2800 if (!em)
2801 ret = -ENOMEM;
2802 else
2803 ret = PTR_ERR(em);
2804 break;
2805 }
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002806 last_byte = min(extent_map_end(em), alloc_end);
Josef Bacikf1e490a2011-08-18 10:36:39 -04002807 actual_end = min_t(u64, extent_map_end(em), offset + len);
Miao Xie797f4272012-11-28 10:28:07 +00002808 last_byte = ALIGN(last_byte, blocksize);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002809 if (em->block_start == EXTENT_MAP_HOLE ||
2810 (cur_offset >= inode->i_size &&
2811 !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) {
Qu Wenruo14524a82015-09-08 17:22:44 +08002812 ret = add_falloc_range(&reserve_list, cur_offset,
2813 last_byte - cur_offset);
2814 if (ret < 0) {
2815 free_extent_map(em);
2816 break;
Filipe Manana3d850dd2015-03-12 23:23:13 +00002817 }
Qu Wenruo14524a82015-09-08 17:22:44 +08002818 ret = btrfs_qgroup_reserve_data(inode, cur_offset,
2819 last_byte - cur_offset);
2820 if (ret < 0)
2821 break;
Wang Xiaoguang18513092016-07-25 15:51:40 +08002822 } else {
2823 /*
2824 * Do not need to reserve unwritten extent for this
2825 * range, free reserved data space first, otherwise
2826 * it'll result in false ENOSPC error.
2827 */
2828 btrfs_free_reserved_data_space(inode, cur_offset,
2829 last_byte - cur_offset);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002830 }
2831 free_extent_map(em);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002832 cur_offset = last_byte;
Qu Wenruo14524a82015-09-08 17:22:44 +08002833 if (cur_offset >= alloc_end)
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002834 break;
Qu Wenruo14524a82015-09-08 17:22:44 +08002835 }
2836
2837 /*
2838 * If ret is still 0, means we're OK to fallocate.
2839 * Or just cleanup the list and exit.
2840 */
2841 list_for_each_entry_safe(range, tmp, &reserve_list, list) {
2842 if (!ret)
2843 ret = btrfs_prealloc_file_range(inode, mode,
2844 range->start,
Fabian Frederick61604a22017-02-27 14:28:32 -08002845 range->len, i_blocksize(inode),
Qu Wenruo14524a82015-09-08 17:22:44 +08002846 offset + len, &alloc_hint);
Wang Xiaoguang18513092016-07-25 15:51:40 +08002847 else
2848 btrfs_free_reserved_data_space(inode, range->start,
2849 range->len);
Qu Wenruo14524a82015-09-08 17:22:44 +08002850 list_del(&range->list);
2851 kfree(range);
2852 }
2853 if (ret < 0)
2854 goto out_unlock;
2855
2856 if (actual_end > inode->i_size &&
2857 !(mode & FALLOC_FL_KEEP_SIZE)) {
2858 struct btrfs_trans_handle *trans;
2859 struct btrfs_root *root = BTRFS_I(inode)->root;
2860
2861 /*
2862 * We didn't need to allocate any more space, but we
2863 * still extended the size of the file so we need to
2864 * update i_size and the inode item.
2865 */
2866 trans = btrfs_start_transaction(root, 1);
2867 if (IS_ERR(trans)) {
2868 ret = PTR_ERR(trans);
2869 } else {
Deepa Dinamanic2050a42016-09-14 07:48:06 -07002870 inode->i_ctime = current_time(inode);
Qu Wenruo14524a82015-09-08 17:22:44 +08002871 i_size_write(inode, actual_end);
2872 btrfs_ordered_update_i_size(inode, actual_end, NULL);
2873 ret = btrfs_update_inode(trans, root, inode);
2874 if (ret)
2875 btrfs_end_transaction(trans, root);
2876 else
2877 ret = btrfs_end_transaction(trans, root);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002878 }
2879 }
Qu Wenruo14524a82015-09-08 17:22:44 +08002880out_unlock:
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002881 unlock_extent_cached(&BTRFS_I(inode)->io_tree, alloc_start, locked_end,
David Sterba32fc9322016-02-11 14:25:38 +01002882 &cached_state, GFP_KERNEL);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002883out:
Al Viro59551022016-01-22 15:40:57 -05002884 inode_unlock(inode);
Chris Masond98456f2012-01-31 20:27:41 -05002885 /* Let go of our reservation. */
Wang Xiaoguang18513092016-07-25 15:51:40 +08002886 if (ret != 0)
2887 btrfs_free_reserved_data_space(inode, alloc_start,
2888 alloc_end - cur_offset);
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002889 return ret;
2890}
2891
Andrew Morton965c8e52012-12-17 15:59:39 -08002892static int find_desired_extent(struct inode *inode, loff_t *offset, int whence)
Josef Bacikb2675152011-07-18 13:21:36 -04002893{
2894 struct btrfs_root *root = BTRFS_I(inode)->root;
Josef Bacik7f4ca372013-10-18 11:44:46 -04002895 struct extent_map *em = NULL;
Josef Bacikb2675152011-07-18 13:21:36 -04002896 struct extent_state *cached_state = NULL;
Liu Bo4d1a40c2014-09-16 17:49:30 +08002897 u64 lockstart;
2898 u64 lockend;
2899 u64 start;
2900 u64 len;
Josef Bacikb2675152011-07-18 13:21:36 -04002901 int ret = 0;
2902
Josef Bacikb2675152011-07-18 13:21:36 -04002903 if (inode->i_size == 0)
2904 return -ENXIO;
2905
Liu Bo4d1a40c2014-09-16 17:49:30 +08002906 /*
2907 * *offset can be negative, in this case we start finding DATA/HOLE from
2908 * the very start of the file.
2909 */
2910 start = max_t(loff_t, 0, *offset);
2911
2912 lockstart = round_down(start, root->sectorsize);
2913 lockend = round_up(i_size_read(inode), root->sectorsize);
2914 if (lockend <= lockstart)
2915 lockend = lockstart + root->sectorsize;
2916 lockend--;
2917 len = lockend - lockstart + 1;
2918
David Sterbaff13db42015-12-03 14:30:40 +01002919 lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
Jeff Mahoneyd0082372012-03-01 14:57:19 +01002920 &cached_state);
Josef Bacikb2675152011-07-18 13:21:36 -04002921
Josef Bacik7f4ca372013-10-18 11:44:46 -04002922 while (start < inode->i_size) {
Josef Bacikb2675152011-07-18 13:21:36 -04002923 em = btrfs_get_extent_fiemap(inode, NULL, 0, start, len, 0);
2924 if (IS_ERR(em)) {
Jeff Liu6af021d2012-02-09 14:25:50 +08002925 ret = PTR_ERR(em);
Josef Bacik7f4ca372013-10-18 11:44:46 -04002926 em = NULL;
Josef Bacikb2675152011-07-18 13:21:36 -04002927 break;
2928 }
2929
Josef Bacik7f4ca372013-10-18 11:44:46 -04002930 if (whence == SEEK_HOLE &&
2931 (em->block_start == EXTENT_MAP_HOLE ||
2932 test_bit(EXTENT_FLAG_PREALLOC, &em->flags)))
2933 break;
2934 else if (whence == SEEK_DATA &&
2935 (em->block_start != EXTENT_MAP_HOLE &&
2936 !test_bit(EXTENT_FLAG_PREALLOC, &em->flags)))
2937 break;
Josef Bacikb2675152011-07-18 13:21:36 -04002938
2939 start = em->start + em->len;
Josef Bacikb2675152011-07-18 13:21:36 -04002940 free_extent_map(em);
Josef Bacik7f4ca372013-10-18 11:44:46 -04002941 em = NULL;
Josef Bacikb2675152011-07-18 13:21:36 -04002942 cond_resched();
2943 }
Josef Bacik7f4ca372013-10-18 11:44:46 -04002944 free_extent_map(em);
2945 if (!ret) {
2946 if (whence == SEEK_DATA && start >= inode->i_size)
2947 ret = -ENXIO;
2948 else
2949 *offset = min_t(loff_t, start, inode->i_size);
2950 }
Josef Bacikb2675152011-07-18 13:21:36 -04002951 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
2952 &cached_state, GFP_NOFS);
2953 return ret;
2954}
2955
Andrew Morton965c8e52012-12-17 15:59:39 -08002956static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence)
Josef Bacikb2675152011-07-18 13:21:36 -04002957{
2958 struct inode *inode = file->f_mapping->host;
2959 int ret;
2960
Al Viro59551022016-01-22 15:40:57 -05002961 inode_lock(inode);
Andrew Morton965c8e52012-12-17 15:59:39 -08002962 switch (whence) {
Josef Bacikb2675152011-07-18 13:21:36 -04002963 case SEEK_END:
2964 case SEEK_CUR:
Andrew Morton965c8e52012-12-17 15:59:39 -08002965 offset = generic_file_llseek(file, offset, whence);
Josef Bacikb2675152011-07-18 13:21:36 -04002966 goto out;
2967 case SEEK_DATA:
2968 case SEEK_HOLE:
Jeff Liu48802c82011-09-18 10:34:02 -04002969 if (offset >= i_size_read(inode)) {
Al Viro59551022016-01-22 15:40:57 -05002970 inode_unlock(inode);
Jeff Liu48802c82011-09-18 10:34:02 -04002971 return -ENXIO;
2972 }
2973
Andrew Morton965c8e52012-12-17 15:59:39 -08002974 ret = find_desired_extent(inode, &offset, whence);
Josef Bacikb2675152011-07-18 13:21:36 -04002975 if (ret) {
Al Viro59551022016-01-22 15:40:57 -05002976 inode_unlock(inode);
Josef Bacikb2675152011-07-18 13:21:36 -04002977 return ret;
2978 }
2979 }
2980
Jie Liu46a1c2c2013-06-25 12:02:13 +08002981 offset = vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
Josef Bacikb2675152011-07-18 13:21:36 -04002982out:
Al Viro59551022016-01-22 15:40:57 -05002983 inode_unlock(inode);
Josef Bacikb2675152011-07-18 13:21:36 -04002984 return offset;
2985}
2986
Alexey Dobriyan828c0952009-10-01 15:43:56 -07002987const struct file_operations btrfs_file_operations = {
Josef Bacikb2675152011-07-18 13:21:36 -04002988 .llseek = btrfs_file_llseek,
Al Viroaad4f8b2014-04-02 14:33:16 -04002989 .read_iter = generic_file_read_iter,
Chris Masone9906a92007-12-14 12:56:58 -05002990 .splice_read = generic_file_splice_read,
Al Virob30ac0f2014-04-03 14:29:04 -04002991 .write_iter = btrfs_file_write_iter,
Chris Mason9ebefb182007-06-15 13:50:00 -04002992 .mmap = btrfs_file_mmap,
Chris Mason39279cc2007-06-12 06:35:45 -04002993 .open = generic_file_open,
Mingminge1b81e62008-05-27 10:55:43 -04002994 .release = btrfs_release_file,
Chris Mason39279cc2007-06-12 06:35:45 -04002995 .fsync = btrfs_sync_file,
Christoph Hellwig2fe17c12011-01-14 13:07:43 +01002996 .fallocate = btrfs_fallocate,
Christoph Hellwig34287aa2007-09-14 10:22:47 -04002997 .unlocked_ioctl = btrfs_ioctl,
Chris Mason39279cc2007-06-12 06:35:45 -04002998#ifdef CONFIG_COMPAT
Luke Dashjr4c63c242015-10-29 08:22:21 +00002999 .compat_ioctl = btrfs_compat_ioctl,
Chris Mason39279cc2007-06-12 06:35:45 -04003000#endif
Zach Brown3db11b22015-11-10 16:53:32 -05003001 .copy_file_range = btrfs_copy_file_range,
Christoph Hellwig04b38d62015-12-03 12:59:50 +01003002 .clone_file_range = btrfs_clone_file_range,
Darrick J. Wong2b3909f2015-12-19 00:56:05 -08003003 .dedupe_file_range = btrfs_dedupe_file_range,
Chris Mason39279cc2007-06-12 06:35:45 -04003004};
Miao Xie9247f312012-11-26 09:24:43 +00003005
3006void btrfs_auto_defrag_exit(void)
3007{
Kinglong Mee5598e902016-01-29 21:36:35 +08003008 kmem_cache_destroy(btrfs_inode_defrag_cachep);
Miao Xie9247f312012-11-26 09:24:43 +00003009}
3010
3011int btrfs_auto_defrag_init(void)
3012{
3013 btrfs_inode_defrag_cachep = kmem_cache_create("btrfs_inode_defrag",
3014 sizeof(struct inode_defrag), 0,
Nikolay Borisovfba4b692016-06-23 21:17:08 +03003015 SLAB_MEM_SPREAD,
Miao Xie9247f312012-11-26 09:24:43 +00003016 NULL);
3017 if (!btrfs_inode_defrag_cachep)
3018 return -ENOMEM;
3019
3020 return 0;
3021}
Filipe Manana728404d2014-10-10 09:43:11 +01003022
3023int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end)
3024{
3025 int ret;
3026
3027 /*
3028 * So with compression we will find and lock a dirty page and clear the
3029 * first one as dirty, setup an async extent, and immediately return
3030 * with the entire range locked but with nobody actually marked with
3031 * writeback. So we can't just filemap_write_and_wait_range() and
3032 * expect it to work since it will just kick off a thread to do the
3033 * actual work. So we need to call filemap_fdatawrite_range _again_
3034 * since it will wait on the page lock, which won't be unlocked until
3035 * after the pages have been marked as writeback and so we're good to go
3036 * from there. We have to do this otherwise we'll miss the ordered
3037 * extents and that results in badness. Please Josef, do not think you
3038 * know better and pull this out at some point in the future, it is
3039 * right and you are wrong.
3040 */
3041 ret = filemap_fdatawrite_range(inode->i_mapping, start, end);
3042 if (!ret && test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
3043 &BTRFS_I(inode)->runtime_flags))
3044 ret = filemap_fdatawrite_range(inode->i_mapping, start, end);
3045
3046 return ret;
3047}