~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/btrfs/file.c

Version: ~ [ linux-5.15-rc5 ] ~ [ linux-5.14.11 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.72 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.152 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.210 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.250 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.286 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.288 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * Copyright (C) 2007 Oracle.  All rights reserved.
  4  */
  5 
  6 #include <linux/fs.h>
  7 #include <linux/pagemap.h>
  8 #include <linux/time.h>
  9 #include <linux/init.h>
 10 #include <linux/string.h>
 11 #include <linux/backing-dev.h>
 12 #include <linux/falloc.h>
 13 #include <linux/writeback.h>
 14 #include <linux/compat.h>
 15 #include <linux/slab.h>
 16 #include <linux/btrfs.h>
 17 #include <linux/uio.h>
 18 #include <linux/iversion.h>
 19 #include "ctree.h"
 20 #include "disk-io.h"
 21 #include "transaction.h"
 22 #include "btrfs_inode.h"
 23 #include "print-tree.h"
 24 #include "tree-log.h"
 25 #include "locking.h"
 26 #include "volumes.h"
 27 #include "qgroup.h"
 28 #include "compression.h"
 29 
 30 static struct kmem_cache *btrfs_inode_defrag_cachep;
 31 /*
 32  * when auto defrag is enabled we
 33  * queue up these defrag structs to remember which
 34  * inodes need defragging passes
 35  */
 36 struct inode_defrag {
 37         struct rb_node rb_node;
 38         /* objectid */
 39         u64 ino;
 40         /*
 41          * transid where the defrag was added, we search for
 42          * extents newer than this
 43          */
 44         u64 transid;
 45 
 46         /* root objectid */
 47         u64 root;
 48 
 49         /* last offset we were able to defrag */
 50         u64 last_offset;
 51 
 52         /* if we've wrapped around back to zero once already */
 53         int cycled;
 54 };
 55 
 56 static int __compare_inode_defrag(struct inode_defrag *defrag1,
 57                                   struct inode_defrag *defrag2)
 58 {
 59         if (defrag1->root > defrag2->root)
 60                 return 1;
 61         else if (defrag1->root < defrag2->root)
 62                 return -1;
 63         else if (defrag1->ino > defrag2->ino)
 64                 return 1;
 65         else if (defrag1->ino < defrag2->ino)
 66                 return -1;
 67         else
 68                 return 0;
 69 }
 70 
 71 /* pop a record for an inode into the defrag tree.  The lock
 72  * must be held already
 73  *
 74  * If you're inserting a record for an older transid than an
 75  * existing record, the transid already in the tree is lowered
 76  *
 77  * If an existing record is found the defrag item you
 78  * pass in is freed
 79  */
 80 static int __btrfs_add_inode_defrag(struct btrfs_inode *inode,
 81                                     struct inode_defrag *defrag)
 82 {
 83         struct btrfs_fs_info *fs_info = inode->root->fs_info;
 84         struct inode_defrag *entry;
 85         struct rb_node **p;
 86         struct rb_node *parent = NULL;
 87         int ret;
 88 
 89         p = &fs_info->defrag_inodes.rb_node;
 90         while (*p) {
 91                 parent = *p;
 92                 entry = rb_entry(parent, struct inode_defrag, rb_node);
 93 
 94                 ret = __compare_inode_defrag(defrag, entry);
 95                 if (ret < 0)
 96                         p = &parent->rb_left;
 97                 else if (ret > 0)
 98                         p = &parent->rb_right;
 99                 else {
100                         /* if we're reinserting an entry for
101                          * an old defrag run, make sure to
102                          * lower the transid of our existing record
103                          */
104                         if (defrag->transid < entry->transid)
105                                 entry->transid = defrag->transid;
106                         if (defrag->last_offset > entry->last_offset)
107                                 entry->last_offset = defrag->last_offset;
108                         return -EEXIST;
109                 }
110         }
111         set_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags);
112         rb_link_node(&defrag->rb_node, parent, p);
113         rb_insert_color(&defrag->rb_node, &fs_info->defrag_inodes);
114         return 0;
115 }
116 
117 static inline int __need_auto_defrag(struct btrfs_fs_info *fs_info)
118 {
119         if (!btrfs_test_opt(fs_info, AUTO_DEFRAG))
120                 return 0;
121 
122         if (btrfs_fs_closing(fs_info))
123                 return 0;
124 
125         return 1;
126 }
127 
128 /*
129  * insert a defrag record for this inode if auto defrag is
130  * enabled
131  */
132 int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
133                            struct btrfs_inode *inode)
134 {
135         struct btrfs_root *root = inode->root;
136         struct btrfs_fs_info *fs_info = root->fs_info;
137         struct inode_defrag *defrag;
138         u64 transid;
139         int ret;
140 
141         if (!__need_auto_defrag(fs_info))
142                 return 0;
143 
144         if (test_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags))
145                 return 0;
146 
147         if (trans)
148                 transid = trans->transid;
149         else
150                 transid = inode->root->last_trans;
151 
152         defrag = kmem_cache_zalloc(btrfs_inode_defrag_cachep, GFP_NOFS);
153         if (!defrag)
154                 return -ENOMEM;
155 
156         defrag->ino = btrfs_ino(inode);
157         defrag->transid = transid;
158         defrag->root = root->root_key.objectid;
159 
160         spin_lock(&fs_info->defrag_inodes_lock);
161         if (!test_bit(BTRFS_INODE_IN_DEFRAG, &inode->runtime_flags)) {
162                 /*
163                  * If we set IN_DEFRAG flag and evict the inode from memory,
164                  * and then re-read this inode, this new inode doesn't have
165                  * IN_DEFRAG flag. At the case, we may find the existed defrag.
166                  */
167                 ret = __btrfs_add_inode_defrag(inode, defrag);
168                 if (ret)
169                         kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
170         } else {
171                 kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
172         }
173         spin_unlock(&fs_info->defrag_inodes_lock);
174         return 0;
175 }
176 
177 /*
178  * Requeue the defrag object. If there is a defrag object that points to
179  * the same inode in the tree, we will merge them together (by
180  * __btrfs_add_inode_defrag()) and free the one that we want to requeue.
181  */
182 static void btrfs_requeue_inode_defrag(struct btrfs_inode *inode,
183                                        struct inode_defrag *defrag)
184 {
185         struct btrfs_fs_info *fs_info = inode->root->fs_info;
186         int ret;
187 
188         if (!__need_auto_defrag(fs_info))
189                 goto out;
190 
191         /*
192          * Here we don't check the IN_DEFRAG flag, because we need merge
193          * them together.
194          */
195         spin_lock(&fs_info->defrag_inodes_lock);
196         ret = __btrfs_add_inode_defrag(inode, defrag);
197         spin_unlock(&fs_info->defrag_inodes_lock);
198         if (ret)
199                 goto out;
200         return;
201 out:
202         kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
203 }
204 
205 /*
206  * pick the defragable inode that we want, if it doesn't exist, we will get
207  * the next one.
208  */
209 static struct inode_defrag *
210 btrfs_pick_defrag_inode(struct btrfs_fs_info *fs_info, u64 root, u64 ino)
211 {
212         struct inode_defrag *entry = NULL;
213         struct inode_defrag tmp;
214         struct rb_node *p;
215         struct rb_node *parent = NULL;
216         int ret;
217 
218         tmp.ino = ino;
219         tmp.root = root;
220 
221         spin_lock(&fs_info->defrag_inodes_lock);
222         p = fs_info->defrag_inodes.rb_node;
223         while (p) {
224                 parent = p;
225                 entry = rb_entry(parent, struct inode_defrag, rb_node);
226 
227                 ret = __compare_inode_defrag(&tmp, entry);
228                 if (ret < 0)
229                         p = parent->rb_left;
230                 else if (ret > 0)
231                         p = parent->rb_right;
232                 else
233                         goto out;
234         }
235 
236         if (parent && __compare_inode_defrag(&tmp, entry) > 0) {
237                 parent = rb_next(parent);
238                 if (parent)
239                         entry = rb_entry(parent, struct inode_defrag, rb_node);
240                 else
241                         entry = NULL;
242         }
243 out:
244         if (entry)
245                 rb_erase(parent, &fs_info->defrag_inodes);
246         spin_unlock(&fs_info->defrag_inodes_lock);
247         return entry;
248 }
249 
250 void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info)
251 {
252         struct inode_defrag *defrag;
253         struct rb_node *node;
254 
255         spin_lock(&fs_info->defrag_inodes_lock);
256         node = rb_first(&fs_info->defrag_inodes);
257         while (node) {
258                 rb_erase(node, &fs_info->defrag_inodes);
259                 defrag = rb_entry(node, struct inode_defrag, rb_node);
260                 kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
261 
262                 cond_resched_lock(&fs_info->defrag_inodes_lock);
263 
264                 node = rb_first(&fs_info->defrag_inodes);
265         }
266         spin_unlock(&fs_info->defrag_inodes_lock);
267 }
268 
269 #define BTRFS_DEFRAG_BATCH      1024
270 
271 static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info,
272                                     struct inode_defrag *defrag)
273 {
274         struct btrfs_root *inode_root;
275         struct inode *inode;
276         struct btrfs_key key;
277         struct btrfs_ioctl_defrag_range_args range;
278         int num_defrag;
279         int index;
280         int ret;
281 
282         /* get the inode */
283         key.objectid = defrag->root;
284         key.type = BTRFS_ROOT_ITEM_KEY;
285         key.offset = (u64)-1;
286 
287         index = srcu_read_lock(&fs_info->subvol_srcu);
288 
289         inode_root = btrfs_read_fs_root_no_name(fs_info, &key);
290         if (IS_ERR(inode_root)) {
291                 ret = PTR_ERR(inode_root);
292                 goto cleanup;
293         }
294 
295         key.objectid = defrag->ino;
296         key.type = BTRFS_INODE_ITEM_KEY;
297         key.offset = 0;
298         inode = btrfs_iget(fs_info->sb, &key, inode_root, NULL);
299         if (IS_ERR(inode)) {
300                 ret = PTR_ERR(inode);
301                 goto cleanup;
302         }
303         srcu_read_unlock(&fs_info->subvol_srcu, index);
304 
305         /* do a chunk of defrag */
306         clear_bit(BTRFS_INODE_IN_DEFRAG, &BTRFS_I(inode)->runtime_flags);
307         memset(&range, 0, sizeof(range));
308         range.len = (u64)-1;
309         range.start = defrag->last_offset;
310 
311         sb_start_write(fs_info->sb);
312         num_defrag = btrfs_defrag_file(inode, NULL, &range, defrag->transid,
313                                        BTRFS_DEFRAG_BATCH);
314         sb_end_write(fs_info->sb);
315         /*
316          * if we filled the whole defrag batch, there
317          * must be more work to do.  Queue this defrag
318          * again
319          */
320         if (num_defrag == BTRFS_DEFRAG_BATCH) {
321                 defrag->last_offset = range.start;
322                 btrfs_requeue_inode_defrag(BTRFS_I(inode), defrag);
323         } else if (defrag->last_offset && !defrag->cycled) {
324                 /*
325                  * we didn't fill our defrag batch, but
326                  * we didn't start at zero.  Make sure we loop
327                  * around to the start of the file.
328                  */
329                 defrag->last_offset = 0;
330                 defrag->cycled = 1;
331                 btrfs_requeue_inode_defrag(BTRFS_I(inode), defrag);
332         } else {
333                 kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
334         }
335 
336         iput(inode);
337         return 0;
338 cleanup:
339         srcu_read_unlock(&fs_info->subvol_srcu, index);
340         kmem_cache_free(btrfs_inode_defrag_cachep, defrag);
341         return ret;
342 }
343 
344 /*
345  * run through the list of inodes in the FS that need
346  * defragging
347  */
348 int btrfs_run_defrag_inodes(struct btrfs_fs_info *fs_info)
349 {
350         struct inode_defrag *defrag;
351         u64 first_ino = 0;
352         u64 root_objectid = 0;
353 
354         atomic_inc(&fs_info->defrag_running);
355         while (1) {
356                 /* Pause the auto defragger. */
357                 if (test_bit(BTRFS_FS_STATE_REMOUNTING,
358                              &fs_info->fs_state))
359                         break;
360 
361                 if (!__need_auto_defrag(fs_info))
362                         break;
363 
364                 /* find an inode to defrag */
365                 defrag = btrfs_pick_defrag_inode(fs_info, root_objectid,
366                                                  first_ino);
367                 if (!defrag) {
368                         if (root_objectid || first_ino) {
369                                 root_objectid = 0;
370                                 first_ino = 0;
371                                 continue;
372                         } else {
373                                 break;
374                         }
375                 }
376 
377                 first_ino = defrag->ino + 1;
378                 root_objectid = defrag->root;
379 
380                 __btrfs_run_defrag_inode(fs_info, defrag);
381         }
382         atomic_dec(&fs_info->defrag_running);
383 
384         /*
385          * during unmount, we use the transaction_wait queue to
386          * wait for the defragger to stop
387          */
388         wake_up(&fs_info->transaction_wait);
389         return 0;
390 }
391 
392 /* simple helper to fault in pages and copy.  This should go away
393  * and be replaced with calls into generic code.
394  */
395 static noinline int btrfs_copy_from_user(loff_t pos, size_t write_bytes,
396                                          struct page **prepared_pages,
397                                          struct iov_iter *i)
398 {
399         size_t copied = 0;
400         size_t total_copied = 0;
401         int pg = 0;
402         int offset = offset_in_page(pos);
403 
404         while (write_bytes > 0) {
405                 size_t count = min_t(size_t,
406                                      PAGE_SIZE - offset, write_bytes);
407                 struct page *page = prepared_pages[pg];
408                 /*
409                  * Copy data from userspace to the current page
410                  */
411                 copied = iov_iter_copy_from_user_atomic(page, i, offset, count);
412 
413                 /* Flush processor's dcache for this page */
414                 flush_dcache_page(page);
415 
416                 /*
417                  * if we get a partial write, we can end up with
418                  * partially up to date pages.  These add
419                  * a lot of complexity, so make sure they don't
420                  * happen by forcing this copy to be retried.
421                  *
422                  * The rest of the btrfs_file_write code will fall
423                  * back to page at a time copies after we return 0.
424                  */
425                 if (!PageUptodate(page) && copied < count)
426                         copied = 0;
427 
428                 iov_iter_advance(i, copied);
429                 write_bytes -= copied;
430                 total_copied += copied;
431 
432                 /* Return to btrfs_file_write_iter to fault page */
433                 if (unlikely(copied == 0))
434                         break;
435 
436                 if (copied < PAGE_SIZE - offset) {
437                         offset += copied;
438                 } else {
439                         pg++;
440                         offset = 0;
441                 }
442         }
443         return total_copied;
444 }
445 
446 /*
447  * unlocks pages after btrfs_file_write is done with them
448  */
449 static void btrfs_drop_pages(struct page **pages, size_t num_pages)
450 {
451         size_t i;
452         for (i = 0; i < num_pages; i++) {
453                 /* page checked is some magic around finding pages that
454                  * have been modified without going through btrfs_set_page_dirty
455                  * clear it here. There should be no need to mark the pages
456                  * accessed as prepare_pages should have marked them accessed
457                  * in prepare_pages via find_or_create_page()
458                  */
459                 ClearPageChecked(pages[i]);
460                 unlock_page(pages[i]);
461                 put_page(pages[i]);
462         }
463 }
464 
465 static int btrfs_find_new_delalloc_bytes(struct btrfs_inode *inode,
466                                          const u64 start,
467                                          const u64 len,
468                                          struct extent_state **cached_state)
469 {
470         u64 search_start = start;
471         const u64 end = start + len - 1;
472 
473         while (search_start < end) {
474                 const u64 search_len = end - search_start + 1;
475                 struct extent_map *em;
476                 u64 em_len;
477                 int ret = 0;
478 
479                 em = btrfs_get_extent(inode, NULL, 0, search_start,
480                                       search_len, 0);
481                 if (IS_ERR(em))
482                         return PTR_ERR(em);
483 
484                 if (em->block_start != EXTENT_MAP_HOLE)
485                         goto next;
486 
487                 em_len = em->len;
488                 if (em->start < search_start)
489                         em_len -= search_start - em->start;
490                 if (em_len > search_len)
491                         em_len = search_len;
492 
493                 ret = set_extent_bit(&inode->io_tree, search_start,
494                                      search_start + em_len - 1,
495                                      EXTENT_DELALLOC_NEW,
496                                      NULL, cached_state, GFP_NOFS);
497 next:
498                 search_start = extent_map_end(em);
499                 free_extent_map(em);
500                 if (ret)
501                         return ret;
502         }
503         return 0;
504 }
505 
506 /*
507  * after copy_from_user, pages need to be dirtied and we need to make
508  * sure holes are created between the current EOF and the start of
509  * any next extents (if required).
510  *
511  * this also makes the decision about creating an inline extent vs
512  * doing real data extents, marking pages dirty and delalloc as required.
513  */
514 int btrfs_dirty_pages(struct inode *inode, struct page **pages,
515                       size_t num_pages, loff_t pos, size_t write_bytes,
516                       struct extent_state **cached)
517 {
518         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
519         int err = 0;
520         int i;
521         u64 num_bytes;
522         u64 start_pos;
523         u64 end_of_last_block;
524         u64 end_pos = pos + write_bytes;
525         loff_t isize = i_size_read(inode);
526         unsigned int extra_bits = 0;
527 
528         start_pos = pos & ~((u64) fs_info->sectorsize - 1);
529         num_bytes = round_up(write_bytes + pos - start_pos,
530                              fs_info->sectorsize);
531 
532         end_of_last_block = start_pos + num_bytes - 1;
533 
534         /*
535          * The pages may have already been dirty, clear out old accounting so
536          * we can set things up properly
537          */
538         clear_extent_bit(&BTRFS_I(inode)->io_tree, start_pos, end_of_last_block,
539                          EXTENT_DIRTY | EXTENT_DELALLOC |
540                          EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG, 0, 0, cached);
541 
542         if (!btrfs_is_free_space_inode(BTRFS_I(inode))) {
543                 if (start_pos >= isize &&
544                     !(BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC)) {
545                         /*
546                          * There can't be any extents following eof in this case
547                          * so just set the delalloc new bit for the range
548                          * directly.
549                          */
550                         extra_bits |= EXTENT_DELALLOC_NEW;
551                 } else {
552                         err = btrfs_find_new_delalloc_bytes(BTRFS_I(inode),
553                                                             start_pos,
554                                                             num_bytes, cached);
555                         if (err)
556                                 return err;
557                 }
558         }
559 
560         err = btrfs_set_extent_delalloc(inode, start_pos, end_of_last_block,
561                                         extra_bits, cached, 0);
562         if (err)
563                 return err;
564 
565         for (i = 0; i < num_pages; i++) {
566                 struct page *p = pages[i];
567                 SetPageUptodate(p);
568                 ClearPageChecked(p);
569                 set_page_dirty(p);
570         }
571 
572         /*
573          * we've only changed i_size in ram, and we haven't updated
574          * the disk i_size.  There is no need to log the inode
575          * at this time.
576          */
577         if (end_pos > isize)
578                 i_size_write(inode, end_pos);
579         return 0;
580 }
581 
582 /*
583  * this drops all the extents in the cache that intersect the range
584  * [start, end].  Existing extents are split as required.
585  */
586 void btrfs_drop_extent_cache(struct btrfs_inode *inode, u64 start, u64 end,
587                              int skip_pinned)
588 {
589         struct extent_map *em;
590         struct extent_map *split = NULL;
591         struct extent_map *split2 = NULL;
592         struct extent_map_tree *em_tree = &inode->extent_tree;
593         u64 len = end - start + 1;
594         u64 gen;
595         int ret;
596         int testend = 1;
597         unsigned long flags;
598         int compressed = 0;
599         bool modified;
600 
601         WARN_ON(end < start);
602         if (end == (u64)-1) {
603                 len = (u64)-1;
604                 testend = 0;
605         }
606         while (1) {
607                 int no_splits = 0;
608 
609                 modified = false;
610                 if (!split)
611                         split = alloc_extent_map();
612                 if (!split2)
613                         split2 = alloc_extent_map();
614                 if (!split || !split2)
615                         no_splits = 1;
616 
617                 write_lock(&em_tree->lock);
618                 em = lookup_extent_mapping(em_tree, start, len);
619                 if (!em) {
620                         write_unlock(&em_tree->lock);
621                         break;
622                 }
623                 flags = em->flags;
624                 gen = em->generation;
625                 if (skip_pinned && test_bit(EXTENT_FLAG_PINNED, &em->flags)) {
626                         if (testend && em->start + em->len >= start + len) {
627                                 free_extent_map(em);
628                                 write_unlock(&em_tree->lock);
629                                 break;
630                         }
631                         start = em->start + em->len;
632                         if (testend)
633                                 len = start + len - (em->start + em->len);
634                         free_extent_map(em);
635                         write_unlock(&em_tree->lock);
636                         continue;
637                 }
638                 compressed = test_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
639                 clear_bit(EXTENT_FLAG_PINNED, &em->flags);
640                 clear_bit(EXTENT_FLAG_LOGGING, &flags);
641                 modified = !list_empty(&em->list);
642                 if (no_splits)
643                         goto next;
644 
645                 if (em->start < start) {
646                         split->start = em->start;
647                         split->len = start - em->start;
648 
649                         if (em->block_start < EXTENT_MAP_LAST_BYTE) {
650                                 split->orig_start = em->orig_start;
651                                 split->block_start = em->block_start;
652 
653                                 if (compressed)
654                                         split->block_len = em->block_len;
655                                 else
656                                         split->block_len = split->len;
657                                 split->orig_block_len = max(split->block_len,
658                                                 em->orig_block_len);
659                                 split->ram_bytes = em->ram_bytes;
660                         } else {
661                                 split->orig_start = split->start;
662                                 split->block_len = 0;
663                                 split->block_start = em->block_start;
664                                 split->orig_block_len = 0;
665                                 split->ram_bytes = split->len;
666                         }
667 
668                         split->generation = gen;
669                         split->bdev = em->bdev;
670                         split->flags = flags;
671                         split->compress_type = em->compress_type;
672                         replace_extent_mapping(em_tree, em, split, modified);
673                         free_extent_map(split);
674                         split = split2;
675                         split2 = NULL;
676                 }
677                 if (testend && em->start + em->len > start + len) {
678                         u64 diff = start + len - em->start;
679 
680                         split->start = start + len;
681                         split->len = em->start + em->len - (start + len);
682                         split->bdev = em->bdev;
683                         split->flags = flags;
684                         split->compress_type = em->compress_type;
685                         split->generation = gen;
686 
687                         if (em->block_start < EXTENT_MAP_LAST_BYTE) {
688                                 split->orig_block_len = max(em->block_len,
689                                                     em->orig_block_len);
690 
691                                 split->ram_bytes = em->ram_bytes;
692                                 if (compressed) {
693                                         split->block_len = em->block_len;
694                                         split->block_start = em->block_start;
695                                         split->orig_start = em->orig_start;
696                                 } else {
697                                         split->block_len = split->len;
698                                         split->block_start = em->block_start
699                                                 + diff;
700                                         split->orig_start = em->orig_start;
701                                 }
702                         } else {
703                                 split->ram_bytes = split->len;
704                                 split->orig_start = split->start;
705                                 split->block_len = 0;
706                                 split->block_start = em->block_start;
707                                 split->orig_block_len = 0;
708                         }
709 
710                         if (extent_map_in_tree(em)) {
711                                 replace_extent_mapping(em_tree, em, split,
712                                                        modified);
713                         } else {
714                                 ret = add_extent_mapping(em_tree, split,
715                                                          modified);
716                                 ASSERT(ret == 0); /* Logic error */
717                         }
718                         free_extent_map(split);
719                         split = NULL;
720                 }
721 next:
722                 if (extent_map_in_tree(em))
723                         remove_extent_mapping(em_tree, em);
724                 write_unlock(&em_tree->lock);
725 
726                 /* once for us */
727                 free_extent_map(em);
728                 /* once for the tree*/
729                 free_extent_map(em);
730         }
731         if (split)
732                 free_extent_map(split);
733         if (split2)
734                 free_extent_map(split2);
735 }
736 
737 /*
738  * this is very complex, but the basic idea is to drop all extents
739  * in the range start - end.  hint_block is filled in with a block number
740  * that would be a good hint to the block allocator for this file.
741  *
742  * If an extent intersects the range but is not entirely inside the range
743  * it is either truncated or split.  Anything entirely inside the range
744  * is deleted from the tree.
745  */
746 int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
747                          struct btrfs_root *root, struct inode *inode,
748                          struct btrfs_path *path, u64 start, u64 end,
749                          u64 *drop_end, int drop_cache,
750                          int replace_extent,
751                          u32 extent_item_size,
752                          int *key_inserted)
753 {
754         struct btrfs_fs_info *fs_info = root->fs_info;
755         struct extent_buffer *leaf;
756         struct btrfs_file_extent_item *fi;
757         struct btrfs_ref ref = { 0 };
758         struct btrfs_key key;
759         struct btrfs_key new_key;
760         u64 ino = btrfs_ino(BTRFS_I(inode));
761         u64 search_start = start;
762         u64 disk_bytenr = 0;
763         u64 num_bytes = 0;
764         u64 extent_offset = 0;
765         u64 extent_end = 0;
766         u64 last_end = start;
767         int del_nr = 0;
768         int del_slot = 0;
769         int extent_type;
770         int recow;
771         int ret;
772         int modify_tree = -1;
773         int update_refs;
774         int found = 0;
775         int leafs_visited = 0;
776 
777         if (drop_cache)
778                 btrfs_drop_extent_cache(BTRFS_I(inode), start, end - 1, 0);
779 
780         if (start >= BTRFS_I(inode)->disk_i_size && !replace_extent)
781                 modify_tree = 0;
782 
783         update_refs = (test_bit(BTRFS_ROOT_REF_COWS, &root->state) ||
784                        root == fs_info->tree_root);
785         while (1) {
786                 recow = 0;
787                 ret = btrfs_lookup_file_extent(trans, root, path, ino,
788                                                search_start, modify_tree);
789                 if (ret < 0)
790                         break;
791                 if (ret > 0 && path->slots[0] > 0 && search_start == start) {
792                         leaf = path->nodes[0];
793                         btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1);
794                         if (key.objectid == ino &&
795                             key.type == BTRFS_EXTENT_DATA_KEY)
796                                 path->slots[0]--;
797                 }
798                 ret = 0;
799                 leafs_visited++;
800 next_slot:
801                 leaf = path->nodes[0];
802                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
803                         BUG_ON(del_nr > 0);
804                         ret = btrfs_next_leaf(root, path);
805                         if (ret < 0)
806                                 break;
807                         if (ret > 0) {
808                                 ret = 0;
809                                 break;
810                         }
811                         leafs_visited++;
812                         leaf = path->nodes[0];
813                         recow = 1;
814                 }
815 
816                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
817 
818                 if (key.objectid > ino)
819                         break;
820                 if (WARN_ON_ONCE(key.objectid < ino) ||
821                     key.type < BTRFS_EXTENT_DATA_KEY) {
822                         ASSERT(del_nr == 0);
823                         path->slots[0]++;
824                         goto next_slot;
825                 }
826                 if (key.type > BTRFS_EXTENT_DATA_KEY || key.offset >= end)
827                         break;
828 
829                 fi = btrfs_item_ptr(leaf, path->slots[0],
830                                     struct btrfs_file_extent_item);
831                 extent_type = btrfs_file_extent_type(leaf, fi);
832 
833                 if (extent_type == BTRFS_FILE_EXTENT_REG ||
834                     extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
835                         disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
836                         num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
837                         extent_offset = btrfs_file_extent_offset(leaf, fi);
838                         extent_end = key.offset +
839                                 btrfs_file_extent_num_bytes(leaf, fi);
840                 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
841                         extent_end = key.offset +
842                                 btrfs_file_extent_ram_bytes(leaf, fi);
843                 } else {
844                         /* can't happen */
845                         BUG();
846                 }
847 
848                 /*
849                  * Don't skip extent items representing 0 byte lengths. They
850                  * used to be created (bug) if while punching holes we hit
851                  * -ENOSPC condition. So if we find one here, just ensure we
852                  * delete it, otherwise we would insert a new file extent item
853                  * with the same key (offset) as that 0 bytes length file
854                  * extent item in the call to setup_items_for_insert() later
855                  * in this function.
856                  */
857                 if (extent_end == key.offset && extent_end >= search_start) {
858                         last_end = extent_end;
859                         goto delete_extent_item;
860                 }
861 
862                 if (extent_end <= search_start) {
863                         path->slots[0]++;
864                         goto next_slot;
865                 }
866 
867                 found = 1;
868                 search_start = max(key.offset, start);
869                 if (recow || !modify_tree) {
870                         modify_tree = -1;
871                         btrfs_release_path(path);
872                         continue;
873                 }
874 
875                 /*
876                  *     | - range to drop - |
877                  *  | -------- extent -------- |
878                  */
879                 if (start > key.offset && end < extent_end) {
880                         BUG_ON(del_nr > 0);
881                         if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
882                                 ret = -EOPNOTSUPP;
883                                 break;
884                         }
885 
886                         memcpy(&new_key, &key, sizeof(new_key));
887                         new_key.offset = start;
888                         ret = btrfs_duplicate_item(trans, root, path,
889                                                    &new_key);
890                         if (ret == -EAGAIN) {
891                                 btrfs_release_path(path);
892                                 continue;
893                         }
894                         if (ret < 0)
895                                 break;
896 
897                         leaf = path->nodes[0];
898                         fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
899                                             struct btrfs_file_extent_item);
900                         btrfs_set_file_extent_num_bytes(leaf, fi,
901                                                         start - key.offset);
902 
903                         fi = btrfs_item_ptr(leaf, path->slots[0],
904                                             struct btrfs_file_extent_item);
905 
906                         extent_offset += start - key.offset;
907                         btrfs_set_file_extent_offset(leaf, fi, extent_offset);
908                         btrfs_set_file_extent_num_bytes(leaf, fi,
909                                                         extent_end - start);
910                         btrfs_mark_buffer_dirty(leaf);
911 
912                         if (update_refs && disk_bytenr > 0) {
913                                 btrfs_init_generic_ref(&ref,
914                                                 BTRFS_ADD_DELAYED_REF,
915                                                 disk_bytenr, num_bytes, 0);
916                                 btrfs_init_data_ref(&ref,
917                                                 root->root_key.objectid,
918                                                 new_key.objectid,
919                                                 start - extent_offset);
920                                 ret = btrfs_inc_extent_ref(trans, &ref);
921                                 BUG_ON(ret); /* -ENOMEM */
922                         }
923                         key.offset = start;
924                 }
925                 /*
926                  * From here on out we will have actually dropped something, so
927                  * last_end can be updated.
928                  */
929                 last_end = extent_end;
930 
931                 /*
932                  *  | ---- range to drop ----- |
933                  *      | -------- extent -------- |
934                  */
935                 if (start <= key.offset && end < extent_end) {
936                         if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
937                                 ret = -EOPNOTSUPP;
938                                 break;
939                         }
940 
941                         memcpy(&new_key, &key, sizeof(new_key));
942                         new_key.offset = end;
943                         btrfs_set_item_key_safe(fs_info, path, &new_key);
944 
945                         extent_offset += end - key.offset;
946                         btrfs_set_file_extent_offset(leaf, fi, extent_offset);
947                         btrfs_set_file_extent_num_bytes(leaf, fi,
948                                                         extent_end - end);
949                         btrfs_mark_buffer_dirty(leaf);
950                         if (update_refs && disk_bytenr > 0)
951                                 inode_sub_bytes(inode, end - key.offset);
952                         break;
953                 }
954 
955                 search_start = extent_end;
956                 /*
957                  *       | ---- range to drop ----- |
958                  *  | -------- extent -------- |
959                  */
960                 if (start > key.offset && end >= extent_end) {
961                         BUG_ON(del_nr > 0);
962                         if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
963                                 ret = -EOPNOTSUPP;
964                                 break;
965                         }
966 
967                         btrfs_set_file_extent_num_bytes(leaf, fi,
968                                                         start - key.offset);
969                         btrfs_mark_buffer_dirty(leaf);
970                         if (update_refs && disk_bytenr > 0)
971                                 inode_sub_bytes(inode, extent_end - start);
972                         if (end == extent_end)
973                                 break;
974 
975                         path->slots[0]++;
976                         goto next_slot;
977                 }
978 
979                 /*
980                  *  | ---- range to drop ----- |
981                  *    | ------ extent ------ |
982                  */
983                 if (start <= key.offset && end >= extent_end) {
984 delete_extent_item:
985                         if (del_nr == 0) {
986                                 del_slot = path->slots[0];
987                                 del_nr = 1;
988                         } else {
989                                 BUG_ON(del_slot + del_nr != path->slots[0]);
990                                 del_nr++;
991                         }
992 
993                         if (update_refs &&
994                             extent_type == BTRFS_FILE_EXTENT_INLINE) {
995                                 inode_sub_bytes(inode,
996                                                 extent_end - key.offset);
997                                 extent_end = ALIGN(extent_end,
998                                                    fs_info->sectorsize);
999                         } else if (update_refs && disk_bytenr > 0) {
1000                                 btrfs_init_generic_ref(&ref,
1001                                                 BTRFS_DROP_DELAYED_REF,
1002                                                 disk_bytenr, num_bytes, 0);
1003                                 btrfs_init_data_ref(&ref,
1004                                                 root->root_key.objectid,
1005                                                 key.objectid,
1006                                                 key.offset - extent_offset);
1007                                 ret = btrfs_free_extent(trans, &ref);
1008                                 BUG_ON(ret); /* -ENOMEM */
1009                                 inode_sub_bytes(inode,
1010                                                 extent_end - key.offset);
1011                         }
1012 
1013                         if (end == extent_end)
1014                                 break;
1015 
1016                         if (path->slots[0] + 1 < btrfs_header_nritems(leaf)) {
1017                                 path->slots[0]++;
1018                                 goto next_slot;
1019                         }
1020 
1021                         ret = btrfs_del_items(trans, root, path, del_slot,
1022                                               del_nr);
1023                         if (ret) {
1024                                 btrfs_abort_transaction(trans, ret);
1025                                 break;
1026                         }
1027 
1028                         del_nr = 0;
1029                         del_slot = 0;
1030 
1031                         btrfs_release_path(path);
1032                         continue;
1033                 }
1034 
1035                 BUG();
1036         }
1037 
1038         if (!ret && del_nr > 0) {
1039                 /*
1040                  * Set path->slots[0] to first slot, so that after the delete
1041                  * if items are move off from our leaf to its immediate left or
1042                  * right neighbor leafs, we end up with a correct and adjusted
1043                  * path->slots[0] for our insertion (if replace_extent != 0).
1044                  */
1045                 path->slots[0] = del_slot;
1046                 ret = btrfs_del_items(trans, root, path, del_slot, del_nr);
1047                 if (ret)
1048                         btrfs_abort_transaction(trans, ret);
1049         }
1050 
1051         leaf = path->nodes[0];
1052         /*
1053          * If btrfs_del_items() was called, it might have deleted a leaf, in
1054          * which case it unlocked our path, so check path->locks[0] matches a
1055          * write lock.
1056          */
1057         if (!ret && replace_extent && leafs_visited == 1 &&
1058             (path->locks[0] == BTRFS_WRITE_LOCK_BLOCKING ||
1059              path->locks[0] == BTRFS_WRITE_LOCK) &&
1060             btrfs_leaf_free_space(leaf) >=
1061             sizeof(struct btrfs_item) + extent_item_size) {
1062 
1063                 key.objectid = ino;
1064                 key.type = BTRFS_EXTENT_DATA_KEY;
1065                 key.offset = start;
1066                 if (!del_nr && path->slots[0] < btrfs_header_nritems(leaf)) {
1067                         struct btrfs_key slot_key;
1068 
1069                         btrfs_item_key_to_cpu(leaf, &slot_key, path->slots[0]);
1070                         if (btrfs_comp_cpu_keys(&key, &slot_key) > 0)
1071                                 path->slots[0]++;
1072                 }
1073                 setup_items_for_insert(root, path, &key,
1074                                        &extent_item_size,
1075                                        extent_item_size,
1076                                        sizeof(struct btrfs_item) +
1077                                        extent_item_size, 1);
1078                 *key_inserted = 1;
1079         }
1080 
1081         if (!replace_extent || !(*key_inserted))
1082                 btrfs_release_path(path);
1083         if (drop_end)
1084                 *drop_end = found ? min(end, last_end) : end;
1085         return ret;
1086 }
1087 
1088 int btrfs_drop_extents(struct btrfs_trans_handle *trans,
1089                        struct btrfs_root *root, struct inode *inode, u64 start,
1090                        u64 end, int drop_cache)
1091 {
1092         struct btrfs_path *path;
1093         int ret;
1094 
1095         path = btrfs_alloc_path();
1096         if (!path)
1097                 return -ENOMEM;
1098         ret = __btrfs_drop_extents(trans, root, inode, path, start, end, NULL,
1099                                    drop_cache, 0, 0, NULL);
1100         btrfs_free_path(path);
1101         return ret;
1102 }
1103 
1104 static int extent_mergeable(struct extent_buffer *leaf, int slot,
1105                             u64 objectid, u64 bytenr, u64 orig_offset,
1106                             u64 *start, u64 *end)
1107 {
1108         struct btrfs_file_extent_item *fi;
1109         struct btrfs_key key;
1110         u64 extent_end;
1111 
1112         if (slot < 0 || slot >= btrfs_header_nritems(leaf))
1113                 return 0;
1114 
1115         btrfs_item_key_to_cpu(leaf, &key, slot);
1116         if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY)
1117                 return 0;
1118 
1119         fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
1120         if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG ||
1121             btrfs_file_extent_disk_bytenr(leaf, fi) != bytenr ||
1122             btrfs_file_extent_offset(leaf, fi) != key.offset - orig_offset ||
1123             btrfs_file_extent_compression(leaf, fi) ||
1124             btrfs_file_extent_encryption(leaf, fi) ||
1125             btrfs_file_extent_other_encoding(leaf, fi))
1126                 return 0;
1127 
1128         extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
1129         if ((*start && *start != key.offset) || (*end && *end != extent_end))
1130                 return 0;
1131 
1132         *start = key.offset;
1133         *end = extent_end;
1134         return 1;
1135 }
1136 
1137 /*
1138  * Mark extent in the range start - end as written.
1139  *
1140  * This changes extent type from 'pre-allocated' to 'regular'. If only
1141  * part of extent is marked as written, the extent will be split into
1142  * two or three.
1143  */
1144 int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
1145                               struct btrfs_inode *inode, u64 start, u64 end)
1146 {
1147         struct btrfs_fs_info *fs_info = trans->fs_info;
1148         struct btrfs_root *root = inode->root;
1149         struct extent_buffer *leaf;
1150         struct btrfs_path *path;
1151         struct btrfs_file_extent_item *fi;
1152         struct btrfs_ref ref = { 0 };
1153         struct btrfs_key key;
1154         struct btrfs_key new_key;
1155         u64 bytenr;
1156         u64 num_bytes;
1157         u64 extent_end;
1158         u64 orig_offset;
1159         u64 other_start;
1160         u64 other_end;
1161         u64 split;
1162         int del_nr = 0;
1163         int del_slot = 0;
1164         int recow;
1165         int ret;
1166         u64 ino = btrfs_ino(inode);
1167 
1168         path = btrfs_alloc_path();
1169         if (!path)
1170                 return -ENOMEM;
1171 again:
1172         recow = 0;
1173         split = start;
1174         key.objectid = ino;
1175         key.type = BTRFS_EXTENT_DATA_KEY;
1176         key.offset = split;
1177 
1178         ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1179         if (ret < 0)
1180                 goto out;
1181         if (ret > 0 && path->slots[0] > 0)
1182                 path->slots[0]--;
1183 
1184         leaf = path->nodes[0];
1185         btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1186         if (key.objectid != ino ||
1187             key.type != BTRFS_EXTENT_DATA_KEY) {
1188                 ret = -EINVAL;
1189                 btrfs_abort_transaction(trans, ret);
1190                 goto out;
1191         }
1192         fi = btrfs_item_ptr(leaf, path->slots[0],
1193                             struct btrfs_file_extent_item);
1194         if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_PREALLOC) {
1195                 ret = -EINVAL;
1196                 btrfs_abort_transaction(trans, ret);
1197                 goto out;
1198         }
1199         extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
1200         if (key.offset > start || extent_end < end) {
1201                 ret = -EINVAL;
1202                 btrfs_abort_transaction(trans, ret);
1203                 goto out;
1204         }
1205 
1206         bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1207         num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
1208         orig_offset = key.offset - btrfs_file_extent_offset(leaf, fi);
1209         memcpy(&new_key, &key, sizeof(new_key));
1210 
1211         if (start == key.offset && end < extent_end) {
1212                 other_start = 0;
1213                 other_end = start;
1214                 if (extent_mergeable(leaf, path->slots[0] - 1,
1215                                      ino, bytenr, orig_offset,
1216                                      &other_start, &other_end)) {
1217                         new_key.offset = end;
1218                         btrfs_set_item_key_safe(fs_info, path, &new_key);
1219                         fi = btrfs_item_ptr(leaf, path->slots[0],
1220                                             struct btrfs_file_extent_item);
1221                         btrfs_set_file_extent_generation(leaf, fi,
1222                                                          trans->transid);
1223                         btrfs_set_file_extent_num_bytes(leaf, fi,
1224                                                         extent_end - end);
1225                         btrfs_set_file_extent_offset(leaf, fi,
1226                                                      end - orig_offset);
1227                         fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
1228                                             struct btrfs_file_extent_item);
1229                         btrfs_set_file_extent_generation(leaf, fi,
1230                                                          trans->transid);
1231                         btrfs_set_file_extent_num_bytes(leaf, fi,
1232                                                         end - other_start);
1233                         btrfs_mark_buffer_dirty(leaf);
1234                         goto out;
1235                 }
1236         }
1237 
1238         if (start > key.offset && end == extent_end) {
1239                 other_start = end;
1240                 other_end = 0;
1241                 if (extent_mergeable(leaf, path->slots[0] + 1,
1242                                      ino, bytenr, orig_offset,
1243                                      &other_start, &other_end)) {
1244                         fi = btrfs_item_ptr(leaf, path->slots[0],
1245                                             struct btrfs_file_extent_item);
1246                         btrfs_set_file_extent_num_bytes(leaf, fi,
1247                                                         start - key.offset);
1248                         btrfs_set_file_extent_generation(leaf, fi,
1249                                                          trans->transid);
1250                         path->slots[0]++;
1251                         new_key.offset = start;
1252                         btrfs_set_item_key_safe(fs_info, path, &new_key);
1253 
1254                         fi = btrfs_item_ptr(leaf, path->slots[0],
1255                                             struct btrfs_file_extent_item);
1256                         btrfs_set_file_extent_generation(leaf, fi,
1257                                                          trans->transid);
1258                         btrfs_set_file_extent_num_bytes(leaf, fi,
1259                                                         other_end - start);
1260                         btrfs_set_file_extent_offset(leaf, fi,
1261                                                      start - orig_offset);
1262                         btrfs_mark_buffer_dirty(leaf);
1263                         goto out;
1264                 }
1265         }
1266 
1267         while (start > key.offset || end < extent_end) {
1268                 if (key.offset == start)
1269                         split = end;
1270 
1271                 new_key.offset = split;
1272                 ret = btrfs_duplicate_item(trans, root, path, &new_key);
1273                 if (ret == -EAGAIN) {
1274                         btrfs_release_path(path);
1275                         goto again;
1276                 }
1277                 if (ret < 0) {
1278                         btrfs_abort_transaction(trans, ret);
1279                         goto out;
1280                 }
1281 
1282                 leaf = path->nodes[0];
1283                 fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
1284                                     struct btrfs_file_extent_item);
1285                 btrfs_set_file_extent_generation(leaf, fi, trans->transid);
1286                 btrfs_set_file_extent_num_bytes(leaf, fi,
1287                                                 split - key.offset);
1288 
1289                 fi = btrfs_item_ptr(leaf, path->slots[0],
1290                                     struct btrfs_file_extent_item);
1291 
1292                 btrfs_set_file_extent_generation(leaf, fi, trans->transid);
1293                 btrfs_set_file_extent_offset(leaf, fi, split - orig_offset);
1294                 btrfs_set_file_extent_num_bytes(leaf, fi,
1295                                                 extent_end - split);
1296                 btrfs_mark_buffer_dirty(leaf);
1297 
1298                 btrfs_init_generic_ref(&ref, BTRFS_ADD_DELAYED_REF, bytenr,
1299                                        num_bytes, 0);
1300                 btrfs_init_data_ref(&ref, root->root_key.objectid, ino,
1301                                     orig_offset);
1302                 ret = btrfs_inc_extent_ref(trans, &ref);
1303                 if (ret) {
1304                         btrfs_abort_transaction(trans, ret);
1305                         goto out;
1306                 }
1307 
1308                 if (split == start) {
1309                         key.offset = start;
1310                 } else {
1311                         if (start != key.offset) {
1312                                 ret = -EINVAL;
1313                                 btrfs_abort_transaction(trans, ret);
1314                                 goto out;
1315                         }
1316                         path->slots[0]--;
1317                         extent_end = end;
1318                 }
1319                 recow = 1;
1320         }
1321 
1322         other_start = end;
1323         other_end = 0;
1324         btrfs_init_generic_ref(&ref, BTRFS_DROP_DELAYED_REF, bytenr,
1325                                num_bytes, 0);
1326         btrfs_init_data_ref(&ref, root->root_key.objectid, ino, orig_offset);
1327         if (extent_mergeable(leaf, path->slots[0] + 1,
1328                              ino, bytenr, orig_offset,
1329                              &other_start, &other_end)) {
1330                 if (recow) {
1331                         btrfs_release_path(path);
1332                         goto again;
1333                 }
1334                 extent_end = other_end;
1335                 del_slot = path->slots[0] + 1;
1336                 del_nr++;
1337                 ret = btrfs_free_extent(trans, &ref);
1338                 if (ret) {
1339                         btrfs_abort_transaction(trans, ret);
1340                         goto out;
1341                 }
1342         }
1343         other_start = 0;
1344         other_end = start;
1345         if (extent_mergeable(leaf, path->slots[0] - 1,
1346                              ino, bytenr, orig_offset,
1347                              &other_start, &other_end)) {
1348                 if (recow) {
1349                         btrfs_release_path(path);
1350                         goto again;
1351                 }
1352                 key.offset = other_start;
1353                 del_slot = path->slots[0];
1354                 del_nr++;
1355                 ret = btrfs_free_extent(trans, &ref);
1356                 if (ret) {
1357                         btrfs_abort_transaction(trans, ret);
1358                         goto out;
1359                 }
1360         }
1361         if (del_nr == 0) {
1362                 fi = btrfs_item_ptr(leaf, path->slots[0],
1363                            struct btrfs_file_extent_item);
1364                 btrfs_set_file_extent_type(leaf, fi,
1365                                            BTRFS_FILE_EXTENT_REG);
1366                 btrfs_set_file_extent_generation(leaf, fi, trans->transid);
1367                 btrfs_mark_buffer_dirty(leaf);
1368         } else {
1369                 fi = btrfs_item_ptr(leaf, del_slot - 1,
1370                            struct btrfs_file_extent_item);
1371                 btrfs_set_file_extent_type(leaf, fi,
1372                                            BTRFS_FILE_EXTENT_REG);
1373                 btrfs_set_file_extent_generation(leaf, fi, trans->transid);
1374                 btrfs_set_file_extent_num_bytes(leaf, fi,
1375                                                 extent_end - key.offset);
1376                 btrfs_mark_buffer_dirty(leaf);
1377 
1378                 ret = btrfs_del_items(trans, root, path, del_slot, del_nr);
1379                 if (ret < 0) {
1380                         btrfs_abort_transaction(trans, ret);
1381                         goto out;
1382                 }
1383         }
1384 out:
1385         btrfs_free_path(path);
1386         return 0;
1387 }
1388 
1389 /*
1390  * on error we return an unlocked page and the error value
1391  * on success we return a locked page and 0
1392  */
1393 static int prepare_uptodate_page(struct inode *inode,
1394                                  struct page *page, u64 pos,
1395                                  bool force_uptodate)
1396 {
1397         int ret = 0;
1398 
1399         if (((pos & (PAGE_SIZE - 1)) || force_uptodate) &&
1400             !PageUptodate(page)) {
1401                 ret = btrfs_readpage(NULL, page);
1402                 if (ret)
1403                         return ret;
1404                 lock_page(page);
1405                 if (!PageUptodate(page)) {
1406                         unlock_page(page);
1407                         return -EIO;
1408                 }
1409                 if (page->mapping != inode->i_mapping) {
1410                         unlock_page(page);
1411                         return -EAGAIN;
1412                 }
1413         }
1414         return 0;
1415 }
1416 
1417 /*
1418  * this just gets pages into the page cache and locks them down.
1419  */
1420 static noinline int prepare_pages(struct inode *inode, struct page **pages,
1421                                   size_t num_pages, loff_t pos,
1422                                   size_t write_bytes, bool force_uptodate)
1423 {
1424         int i;
1425         unsigned long index = pos >> PAGE_SHIFT;
1426         gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping);
1427         int err = 0;
1428         int faili;
1429 
1430         for (i = 0; i < num_pages; i++) {
1431 again:
1432                 pages[i] = find_or_create_page(inode->i_mapping, index + i,
1433                                                mask | __GFP_WRITE);
1434                 if (!pages[i]) {
1435                         faili = i - 1;
1436                         err = -ENOMEM;
1437                         goto fail;
1438                 }
1439 
1440                 if (i == 0)
1441                         err = prepare_uptodate_page(inode, pages[i], pos,
1442                                                     force_uptodate);
1443                 if (!err && i == num_pages - 1)
1444                         err = prepare_uptodate_page(inode, pages[i],
1445                                                     pos + write_bytes, false);
1446                 if (err) {
1447                         put_page(pages[i]);
1448                         if (err == -EAGAIN) {
1449                                 err = 0;
1450                                 goto again;
1451                         }
1452                         faili = i - 1;
1453                         goto fail;
1454                 }
1455                 wait_on_page_writeback(pages[i]);
1456         }
1457 
1458         return 0;
1459 fail:
1460         while (faili >= 0) {
1461                 unlock_page(pages[faili]);
1462                 put_page(pages[faili]);
1463                 faili--;
1464         }
1465         return err;
1466 
1467 }
1468 
1469 /*
1470  * This function locks the extent and properly waits for data=ordered extents
1471  * to finish before allowing the pages to be modified if need.
1472  *
1473  * The return value:
1474  * 1 - the extent is locked
1475  * 0 - the extent is not locked, and everything is OK
1476  * -EAGAIN - need re-prepare the pages
1477  * the other < 0 number - Something wrong happens
1478  */
1479 static noinline int
1480 lock_and_cleanup_extent_if_need(struct btrfs_inode *inode, struct page **pages,
1481                                 size_t num_pages, loff_t pos,
1482                                 size_t write_bytes,
1483                                 u64 *lockstart, u64 *lockend,
1484                                 struct extent_state **cached_state)
1485 {
1486         struct btrfs_fs_info *fs_info = inode->root->fs_info;
1487         u64 start_pos;
1488         u64 last_pos;
1489         int i;
1490         int ret = 0;
1491 
1492         start_pos = round_down(pos, fs_info->sectorsize);
1493         last_pos = start_pos
1494                 + round_up(pos + write_bytes - start_pos,
1495                            fs_info->sectorsize) - 1;
1496 
1497         if (start_pos < inode->vfs_inode.i_size) {
1498                 struct btrfs_ordered_extent *ordered;
1499 
1500                 lock_extent_bits(&inode->io_tree, start_pos, last_pos,
1501                                 cached_state);
1502                 ordered = btrfs_lookup_ordered_range(inode, start_pos,
1503                                                      last_pos - start_pos + 1);
1504                 if (ordered &&
1505                     ordered->file_offset + ordered->len > start_pos &&
1506                     ordered->file_offset <= last_pos) {
1507                         unlock_extent_cached(&inode->io_tree, start_pos,
1508                                         last_pos, cached_state);
1509                         for (i = 0; i < num_pages; i++) {
1510                                 unlock_page(pages[i]);
1511                                 put_page(pages[i]);
1512                         }
1513                         btrfs_start_ordered_extent(&inode->vfs_inode,
1514                                         ordered, 1);
1515                         btrfs_put_ordered_extent(ordered);
1516                         return -EAGAIN;
1517                 }
1518                 if (ordered)
1519                         btrfs_put_ordered_extent(ordered);
1520 
1521                 *lockstart = start_pos;
1522                 *lockend = last_pos;
1523                 ret = 1;
1524         }
1525 
1526         /*
1527          * It's possible the pages are dirty right now, but we don't want
1528          * to clean them yet because copy_from_user may catch a page fault
1529          * and we might have to fall back to one page at a time.  If that
1530          * happens, we'll unlock these pages and we'd have a window where
1531          * reclaim could sneak in and drop the once-dirty page on the floor
1532          * without writing it.
1533          *
1534          * We have the pages locked and the extent range locked, so there's
1535          * no way someone can start IO on any dirty pages in this range.
1536          *
1537          * We'll call btrfs_dirty_pages() later on, and that will flip around
1538          * delalloc bits and dirty the pages as required.
1539          */
1540         for (i = 0; i < num_pages; i++) {
1541                 set_page_extent_mapped(pages[i]);
1542                 WARN_ON(!PageLocked(pages[i]));
1543         }
1544 
1545         return ret;
1546 }
1547 
1548 static noinline int check_can_nocow(struct btrfs_inode *inode, loff_t pos,
1549                                     size_t *write_bytes)
1550 {
1551         struct btrfs_fs_info *fs_info = inode->root->fs_info;
1552         struct btrfs_root *root = inode->root;
1553         struct btrfs_ordered_extent *ordered;
1554         u64 lockstart, lockend;
1555         u64 num_bytes;
1556         int ret;
1557 
1558         ret = btrfs_start_write_no_snapshotting(root);
1559         if (!ret)
1560                 return -ENOSPC;
1561 
1562         lockstart = round_down(pos, fs_info->sectorsize);
1563         lockend = round_up(pos + *write_bytes,
1564                            fs_info->sectorsize) - 1;
1565 
1566         while (1) {
1567                 lock_extent(&inode->io_tree, lockstart, lockend);
1568                 ordered = btrfs_lookup_ordered_range(inode, lockstart,
1569                                                      lockend - lockstart + 1);
1570                 if (!ordered) {
1571                         break;
1572                 }
1573                 unlock_extent(&inode->io_tree, lockstart, lockend);
1574                 btrfs_start_ordered_extent(&inode->vfs_inode, ordered, 1);
1575                 btrfs_put_ordered_extent(ordered);
1576         }
1577 
1578         num_bytes = lockend - lockstart + 1;
1579         ret = can_nocow_extent(&inode->vfs_inode, lockstart, &num_bytes,
1580                         NULL, NULL, NULL);
1581         if (ret <= 0) {
1582                 ret = 0;
1583                 btrfs_end_write_no_snapshotting(root);
1584         } else {
1585                 *write_bytes = min_t(size_t, *write_bytes ,
1586                                      num_bytes - pos + lockstart);
1587         }
1588 
1589         unlock_extent(&inode->io_tree, lockstart, lockend);
1590 
1591         return ret;
1592 }
1593 
1594 static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,
1595                                                struct iov_iter *i)
1596 {
1597         struct file *file = iocb->ki_filp;
1598         loff_t pos = iocb->ki_pos;
1599         struct inode *inode = file_inode(file);
1600         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
1601         struct btrfs_root *root = BTRFS_I(inode)->root;
1602         struct page **pages = NULL;
1603         struct extent_state *cached_state = NULL;
1604         struct extent_changeset *data_reserved = NULL;
1605         u64 release_bytes = 0;
1606         u64 lockstart;
1607         u64 lockend;
1608         size_t num_written = 0;
1609         int nrptrs;
1610         int ret = 0;
1611         bool only_release_metadata = false;
1612         bool force_page_uptodate = false;
1613 
1614         nrptrs = min(DIV_ROUND_UP(iov_iter_count(i), PAGE_SIZE),
1615                         PAGE_SIZE / (sizeof(struct page *)));
1616         nrptrs = min(nrptrs, current->nr_dirtied_pause - current->nr_dirtied);
1617         nrptrs = max(nrptrs, 8);
1618         pages = kmalloc_array(nrptrs, sizeof(struct page *), GFP_KERNEL);
1619         if (!pages)
1620                 return -ENOMEM;
1621 
1622         while (iov_iter_count(i) > 0) {
1623                 size_t offset = offset_in_page(pos);
1624                 size_t sector_offset;
1625                 size_t write_bytes = min(iov_iter_count(i),
1626                                          nrptrs * (size_t)PAGE_SIZE -
1627                                          offset);
1628                 size_t num_pages = DIV_ROUND_UP(write_bytes + offset,
1629                                                 PAGE_SIZE);
1630                 size_t reserve_bytes;
1631                 size_t dirty_pages;
1632                 size_t copied;
1633                 size_t dirty_sectors;
1634                 size_t num_sectors;
1635                 int extents_locked;
1636 
1637                 WARN_ON(num_pages > nrptrs);
1638 
1639                 /*
1640                  * Fault pages before locking them in prepare_pages
1641                  * to avoid recursive lock
1642                  */
1643                 if (unlikely(iov_iter_fault_in_readable(i, write_bytes))) {
1644                         ret = -EFAULT;
1645                         break;
1646                 }
1647 
1648                 sector_offset = pos & (fs_info->sectorsize - 1);
1649                 reserve_bytes = round_up(write_bytes + sector_offset,
1650                                 fs_info->sectorsize);
1651 
1652                 extent_changeset_release(data_reserved);
1653                 ret = btrfs_check_data_free_space(inode, &data_reserved, pos,
1654                                                   write_bytes);
1655                 if (ret < 0) {
1656                         if ((BTRFS_I(inode)->flags & (BTRFS_INODE_NODATACOW |
1657                                                       BTRFS_INODE_PREALLOC)) &&
1658                             check_can_nocow(BTRFS_I(inode), pos,
1659                                         &write_bytes) > 0) {
1660                                 /*
1661                                  * For nodata cow case, no need to reserve
1662                                  * data space.
1663                                  */
1664                                 only_release_metadata = true;
1665                                 /*
1666                                  * our prealloc extent may be smaller than
1667                                  * write_bytes, so scale down.
1668                                  */
1669                                 num_pages = DIV_ROUND_UP(write_bytes + offset,
1670                                                          PAGE_SIZE);
1671                                 reserve_bytes = round_up(write_bytes +
1672                                                          sector_offset,
1673                                                          fs_info->sectorsize);
1674                         } else {
1675                                 break;
1676                         }
1677                 }
1678 
1679                 WARN_ON(reserve_bytes == 0);
1680                 ret = btrfs_delalloc_reserve_metadata(BTRFS_I(inode),
1681                                 reserve_bytes);
1682                 if (ret) {
1683                         if (!only_release_metadata)
1684                                 btrfs_free_reserved_data_space(inode,
1685                                                 data_reserved, pos,
1686                                                 write_bytes);
1687                         else
1688                                 btrfs_end_write_no_snapshotting(root);
1689                         break;
1690                 }
1691 
1692                 release_bytes = reserve_bytes;
1693 again:
1694                 /*
1695                  * This is going to setup the pages array with the number of
1696                  * pages we want, so we don't really need to worry about the
1697                  * contents of pages from loop to loop
1698                  */
1699                 ret = prepare_pages(inode, pages, num_pages,
1700                                     pos, write_bytes,
1701                                     force_page_uptodate);
1702                 if (ret) {
1703                         btrfs_delalloc_release_extents(BTRFS_I(inode),
1704                                                        reserve_bytes, true);
1705                         break;
1706                 }
1707 
1708                 extents_locked = lock_and_cleanup_extent_if_need(
1709                                 BTRFS_I(inode), pages,
1710                                 num_pages, pos, write_bytes, &lockstart,
1711                                 &lockend, &cached_state);
1712                 if (extents_locked < 0) {
1713                         if (extents_locked == -EAGAIN)
1714                                 goto again;
1715                         btrfs_delalloc_release_extents(BTRFS_I(inode),
1716                                                        reserve_bytes, true);
1717                         ret = extents_locked;
1718                         break;
1719                 }
1720 
1721                 copied = btrfs_copy_from_user(pos, write_bytes, pages, i);
1722 
1723                 num_sectors = BTRFS_BYTES_TO_BLKS(fs_info, reserve_bytes);
1724                 dirty_sectors = round_up(copied + sector_offset,
1725                                         fs_info->sectorsize);
1726                 dirty_sectors = BTRFS_BYTES_TO_BLKS(fs_info, dirty_sectors);
1727 
1728                 /*
1729                  * if we have trouble faulting in the pages, fall
1730                  * back to one page at a time
1731                  */
1732                 if (copied < write_bytes)
1733                         nrptrs = 1;
1734 
1735                 if (copied == 0) {
1736                         force_page_uptodate = true;
1737                         dirty_sectors = 0;
1738                         dirty_pages = 0;
1739                 } else {
1740                         force_page_uptodate = false;
1741                         dirty_pages = DIV_ROUND_UP(copied + offset,
1742                                                    PAGE_SIZE);
1743                 }
1744 
1745                 if (num_sectors > dirty_sectors) {
1746                         /* release everything except the sectors we dirtied */
1747                         release_bytes -= dirty_sectors <<
1748                                                 fs_info->sb->s_blocksize_bits;
1749                         if (only_release_metadata) {
1750                                 btrfs_delalloc_release_metadata(BTRFS_I(inode),
1751                                                         release_bytes, true);
1752                         } else {
1753                                 u64 __pos;
1754 
1755                                 __pos = round_down(pos,
1756                                                    fs_info->sectorsize) +
1757                                         (dirty_pages << PAGE_SHIFT);
1758                                 btrfs_delalloc_release_space(inode,
1759                                                 data_reserved, __pos,
1760                                                 release_bytes, true);
1761                         }
1762                 }
1763 
1764                 release_bytes = round_up(copied + sector_offset,
1765                                         fs_info->sectorsize);
1766 
1767                 if (copied > 0)
1768                         ret = btrfs_dirty_pages(inode, pages, dirty_pages,
1769                                                 pos, copied, &cached_state);
1770                 if (extents_locked)
1771                         unlock_extent_cached(&BTRFS_I(inode)->io_tree,
1772                                              lockstart, lockend, &cached_state);
1773                 btrfs_delalloc_release_extents(BTRFS_I(inode), reserve_bytes,
1774                                                true);
1775                 if (ret) {
1776                         btrfs_drop_pages(pages, num_pages);
1777                         break;
1778                 }
1779 
1780                 release_bytes = 0;
1781                 if (only_release_metadata)
1782                         btrfs_end_write_no_snapshotting(root);
1783 
1784                 if (only_release_metadata && copied > 0) {
1785                         lockstart = round_down(pos,
1786                                                fs_info->sectorsize);
1787                         lockend = round_up(pos + copied,
1788                                            fs_info->sectorsize) - 1;
1789 
1790                         set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart,
1791                                        lockend, EXTENT_NORESERVE, NULL,
1792                                        NULL, GFP_NOFS);
1793                         only_release_metadata = false;
1794                 }
1795 
1796                 btrfs_drop_pages(pages, num_pages);
1797 
1798                 cond_resched();
1799 
1800                 balance_dirty_pages_ratelimited(inode->i_mapping);
1801                 if (dirty_pages < (fs_info->nodesize >> PAGE_SHIFT) + 1)
1802                         btrfs_btree_balance_dirty(fs_info);
1803 
1804                 pos += copied;
1805                 num_written += copied;
1806         }
1807 
1808         kfree(pages);
1809 
1810         if (release_bytes) {
1811                 if (only_release_metadata) {
1812                         btrfs_end_write_no_snapshotting(root);
1813                         btrfs_delalloc_release_metadata(BTRFS_I(inode),
1814                                         release_bytes, true);
1815                 } else {
1816                         btrfs_delalloc_release_space(inode, data_reserved,
1817                                         round_down(pos, fs_info->sectorsize),
1818                                         release_bytes, true);
1819                 }
1820         }
1821 
1822         extent_changeset_free(data_reserved);
1823         return num_written ? num_written : ret;
1824 }
1825 
1826 static ssize_t __btrfs_direct_write(struct kiocb *iocb, struct iov_iter *from)
1827 {
1828         struct file *file = iocb->ki_filp;
1829         struct inode *inode = file_inode(file);
1830         loff_t pos;
1831         ssize_t written;
1832         ssize_t written_buffered;
1833         loff_t endbyte;
1834         int err;
1835 
1836         written = generic_file_direct_write(iocb, from);
1837 
1838         if (written < 0 || !iov_iter_count(from))
1839                 return written;
1840 
1841         pos = iocb->ki_pos;
1842         written_buffered = btrfs_buffered_write(iocb, from);
1843         if (written_buffered < 0) {
1844                 err = written_buffered;
1845                 goto out;
1846         }
1847         /*
1848          * Ensure all data is persisted. We want the next direct IO read to be
1849          * able to read what was just written.
1850          */
1851         endbyte = pos + written_buffered - 1;
1852         err = btrfs_fdatawrite_range(inode, pos, endbyte);
1853         if (err)
1854                 goto out;
1855         err = filemap_fdatawait_range(inode->i_mapping, pos, endbyte);
1856         if (err)
1857                 goto out;
1858         written += written_buffered;
1859         iocb->ki_pos = pos + written_buffered;
1860         invalidate_mapping_pages(file->f_mapping, pos >> PAGE_SHIFT,
1861                                  endbyte >> PAGE_SHIFT);
1862 out:
1863         return written ? written : err;
1864 }
1865 
1866 static void update_time_for_write(struct inode *inode)
1867 {
1868         struct timespec64 now;
1869 
1870         if (IS_NOCMTIME(inode))
1871                 return;
1872 
1873         now = current_time(inode);
1874         if (!timespec64_equal(&inode->i_mtime, &now))
1875                 inode->i_mtime = now;
1876 
1877         if (!timespec64_equal(&inode->i_ctime, &now))
1878                 inode->i_ctime = now;
1879 
1880         if (IS_I_VERSION(inode))
1881                 inode_inc_iversion(inode);
1882 }
1883 
1884 static ssize_t btrfs_file_write_iter(struct kiocb *iocb,
1885                                     struct iov_iter *from)
1886 {
1887         struct file *file = iocb->ki_filp;
1888         struct inode *inode = file_inode(file);
1889         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
1890         struct btrfs_root *root = BTRFS_I(inode)->root;
1891         u64 start_pos;
1892         u64 end_pos;
1893         ssize_t num_written = 0;
1894         bool sync = (file->f_flags & O_DSYNC) || IS_SYNC(file->f_mapping->host);
1895         ssize_t err;
1896         loff_t pos;
1897         size_t count = iov_iter_count(from);
1898         loff_t oldsize;
1899         int clean_page = 0;
1900 
1901         if (!(iocb->ki_flags & IOCB_DIRECT) &&
1902             (iocb->ki_flags & IOCB_NOWAIT))
1903                 return -EOPNOTSUPP;
1904 
1905         if (!inode_trylock(inode)) {
1906                 if (iocb->ki_flags & IOCB_NOWAIT)
1907                         return -EAGAIN;
1908                 inode_lock(inode);
1909         }
1910 
1911         err = generic_write_checks(iocb, from);
1912         if (err <= 0) {
1913                 inode_unlock(inode);
1914                 return err;
1915         }
1916 
1917         pos = iocb->ki_pos;
1918         if (iocb->ki_flags & IOCB_NOWAIT) {
1919                 /*
1920                  * We will allocate space in case nodatacow is not set,
1921                  * so bail
1922                  */
1923                 if (!(BTRFS_I(inode)->flags & (BTRFS_INODE_NODATACOW |
1924                                               BTRFS_INODE_PREALLOC)) ||
1925                     check_can_nocow(BTRFS_I(inode), pos, &count) <= 0) {
1926                         inode_unlock(inode);
1927                         return -EAGAIN;
1928                 }
1929         }
1930 
1931         current->backing_dev_info = inode_to_bdi(inode);
1932         err = file_remove_privs(file);
1933         if (err) {
1934                 inode_unlock(inode);
1935                 goto out;
1936         }
1937 
1938         /*
1939          * If BTRFS flips readonly due to some impossible error
1940          * (fs_info->fs_state now has BTRFS_SUPER_FLAG_ERROR),
1941          * although we have opened a file as writable, we have
1942          * to stop this write operation to ensure FS consistency.
1943          */
1944         if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
1945                 inode_unlock(inode);
1946                 err = -EROFS;
1947                 goto out;
1948         }
1949 
1950         /*
1951          * We reserve space for updating the inode when we reserve space for the
1952          * extent we are going to write, so we will enospc out there.  We don't
1953          * need to start yet another transaction to update the inode as we will
1954          * update the inode when we finish writing whatever data we write.
1955          */
1956         update_time_for_write(inode);
1957 
1958         start_pos = round_down(pos, fs_info->sectorsize);
1959         oldsize = i_size_read(inode);
1960         if (start_pos > oldsize) {
1961                 /* Expand hole size to cover write data, preventing empty gap */
1962                 end_pos = round_up(pos + count,
1963                                    fs_info->sectorsize);
1964                 err = btrfs_cont_expand(inode, oldsize, end_pos);
1965                 if (err) {
1966                         inode_unlock(inode);
1967                         goto out;
1968                 }
1969                 if (start_pos > round_up(oldsize, fs_info->sectorsize))
1970                         clean_page = 1;
1971         }
1972 
1973         if (sync)
1974                 atomic_inc(&BTRFS_I(inode)->sync_writers);
1975 
1976         if (iocb->ki_flags & IOCB_DIRECT) {
1977                 num_written = __btrfs_direct_write(iocb, from);
1978         } else {
1979                 num_written = btrfs_buffered_write(iocb, from);
1980                 if (num_written > 0)
1981                         iocb->ki_pos = pos + num_written;
1982                 if (clean_page)
1983                         pagecache_isize_extended(inode, oldsize,
1984                                                 i_size_read(inode));
1985         }
1986 
1987         inode_unlock(inode);
1988 
1989         /*
1990          * We also have to set last_sub_trans to the current log transid,
1991          * otherwise subsequent syncs to a file that's been synced in this
1992          * transaction will appear to have already occurred.
1993          */
1994         spin_lock(&BTRFS_I(inode)->lock);
1995         BTRFS_I(inode)->last_sub_trans = root->log_transid;
1996         spin_unlock(&BTRFS_I(inode)->lock);
1997         if (num_written > 0)
1998                 num_written = generic_write_sync(iocb, num_written);
1999 
2000         if (sync)
2001                 atomic_dec(&BTRFS_I(inode)->sync_writers);
2002 out:
2003         current->backing_dev_info = NULL;
2004         return num_written ? num_written : err;
2005 }
2006 
2007 int btrfs_release_file(struct inode *inode, struct file *filp)
2008 {
2009         struct btrfs_file_private *private = filp->private_data;
2010 
2011         if (private && private->filldir_buf)
2012                 kfree(private->filldir_buf);
2013         kfree(private);
2014         filp->private_data = NULL;
2015 
2016         /*
2017          * ordered_data_close is set by setattr when we are about to truncate
2018          * a file from a non-zero size to a zero size.  This tries to
2019          * flush down new bytes that may have been written if the
2020          * application were using truncate to replace a file in place.
2021          */
2022         if (test_and_clear_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
2023                                &BTRFS_I(inode)->runtime_flags))
2024                         filemap_flush(inode->i_mapping);
2025         return 0;
2026 }
2027 
2028 static int start_ordered_ops(struct inode *inode, loff_t start, loff_t end)
2029 {
2030         int ret;
2031         struct blk_plug plug;
2032 
2033         /*
2034          * This is only called in fsync, which would do synchronous writes, so
2035          * a plug can merge adjacent IOs as much as possible.  Esp. in case of
2036          * multiple disks using raid profile, a large IO can be split to
2037          * several segments of stripe length (currently 64K).
2038          */
2039         blk_start_plug(&plug);
2040         atomic_inc(&BTRFS_I(inode)->sync_writers);
2041         ret = btrfs_fdatawrite_range(inode, start, end);
2042         atomic_dec(&BTRFS_I(inode)->sync_writers);
2043         blk_finish_plug(&plug);
2044 
2045         return ret;
2046 }
2047 
2048 /*
2049  * fsync call for both files and directories.  This logs the inode into
2050  * the tree log instead of forcing full commits whenever possible.
2051  *
2052  * It needs to call filemap_fdatawait so that all ordered extent updates are
2053  * in the metadata btree are up to date for copying to the log.
2054  *
2055  * It drops the inode mutex before doing the tree log commit.  This is an
2056  * important optimization for directories because holding the mutex prevents
2057  * new operations on the dir while we write to disk.
2058  */
2059 int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
2060 {
2061         struct dentry *dentry = file_dentry(file);
2062         struct inode *inode = d_inode(dentry);
2063         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
2064         struct btrfs_root *root = BTRFS_I(inode)->root;
2065         struct btrfs_trans_handle *trans;
2066         struct btrfs_log_ctx ctx;
2067         int ret = 0, err;
2068         u64 len;
2069 
2070         /*
2071          * If the inode needs a full sync, make sure we use a full range to
2072          * avoid log tree corruption, due to hole detection racing with ordered
2073          * extent completion for adjacent ranges, and assertion failures during
2074          * hole detection.
2075          */
2076         if (test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
2077                      &BTRFS_I(inode)->runtime_flags)) {
2078                 start = 0;
2079                 end = LLONG_MAX;
2080         }
2081 
2082         /*
2083          * The range length can be represented by u64, we have to do the typecasts
2084          * to avoid signed overflow if it's [0, LLONG_MAX] eg. from fsync()
2085          */
2086         len = (u64)end - (u64)start + 1;
2087         trace_btrfs_sync_file(file, datasync);
2088 
2089         btrfs_init_log_ctx(&ctx, inode);
2090 
2091         /*
2092          * We write the dirty pages in the range and wait until they complete
2093          * out of the ->i_mutex. If so, we can flush the dirty pages by
2094          * multi-task, and make the performance up.  See
2095          * btrfs_wait_ordered_range for an explanation of the ASYNC check.
2096          */
2097         ret = start_ordered_ops(inode, start, end);
2098         if (ret)
2099                 goto out;
2100 
2101         inode_lock(inode);
2102 
2103         /*
2104          * We take the dio_sem here because the tree log stuff can race with
2105          * lockless dio writes and get an extent map logged for an extent we
2106          * never waited on.  We need it this high up for lockdep reasons.
2107          */
2108         down_write(&BTRFS_I(inode)->dio_sem);
2109 
2110         atomic_inc(&root->log_batch);
2111 
2112         /*
2113          * Before we acquired the inode's lock, someone may have dirtied more
2114          * pages in the target range. We need to make sure that writeback for
2115          * any such pages does not start while we are logging the inode, because
2116          * if it does, any of the following might happen when we are not doing a
2117          * full inode sync:
2118          *
2119          * 1) We log an extent after its writeback finishes but before its
2120          *    checksums are added to the csum tree, leading to -EIO errors
2121          *    when attempting to read the extent after a log replay.
2122          *
2123          * 2) We can end up logging an extent before its writeback finishes.
2124          *    Therefore after the log replay we will have a file extent item
2125          *    pointing to an unwritten extent (and no data checksums as well).
2126          *
2127          * So trigger writeback for any eventual new dirty pages and then we
2128          * wait for all ordered extents to complete below.
2129          */
2130         ret = start_ordered_ops(inode, start, end);
2131         if (ret) {
2132                 inode_unlock(inode);
2133                 goto out;
2134         }
2135 
2136         /*
2137          * We have to do this here to avoid the priority inversion of waiting on
2138          * IO of a lower priority task while holding a transaction open.
2139          */
2140         ret = btrfs_wait_ordered_range(inode, start, len);
2141         if (ret) {
2142                 up_write(&BTRFS_I(inode)->dio_sem);
2143                 inode_unlock(inode);
2144                 goto out;
2145         }
2146         atomic_inc(&root->log_batch);
2147 
2148         smp_mb();
2149         if (btrfs_inode_in_log(BTRFS_I(inode), fs_info->generation) ||
2150             BTRFS_I(inode)->last_trans <= fs_info->last_trans_committed) {
2151                 /*
2152                  * We've had everything committed since the last time we were
2153                  * modified so clear this flag in case it was set for whatever
2154                  * reason, it's no longer relevant.
2155                  */
2156                 clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
2157                           &BTRFS_I(inode)->runtime_flags);
2158                 /*
2159                  * An ordered extent might have started before and completed
2160                  * already with io errors, in which case the inode was not
2161                  * updated and we end up here. So check the inode's mapping
2162                  * for any errors that might have happened since we last
2163                  * checked called fsync.
2164                  */
2165                 ret = filemap_check_wb_err(inode->i_mapping, file->f_wb_err);
2166                 up_write(&BTRFS_I(inode)->dio_sem);
2167                 inode_unlock(inode);
2168                 goto out;
2169         }
2170 
2171         /*
2172          * We use start here because we will need to wait on the IO to complete
2173          * in btrfs_sync_log, which could require joining a transaction (for
2174          * example checking cross references in the nocow path).  If we use join
2175          * here we could get into a situation where we're waiting on IO to
2176          * happen that is blocked on a transaction trying to commit.  With start
2177          * we inc the extwriter counter, so we wait for all extwriters to exit
2178          * before we start blocking joiners.  This comment is to keep somebody
2179          * from thinking they are super smart and changing this to
2180          * btrfs_join_transaction *cough*Josef*cough*.
2181          */
2182         trans = btrfs_start_transaction(root, 0);
2183         if (IS_ERR(trans)) {
2184                 ret = PTR_ERR(trans);
2185                 up_write(&BTRFS_I(inode)->dio_sem);
2186                 inode_unlock(inode);
2187                 goto out;
2188         }
2189 
2190         ret = btrfs_log_dentry_safe(trans, dentry, start, end, &ctx);
2191         if (ret < 0) {
2192                 /* Fallthrough and commit/free transaction. */
2193                 ret = 1;
2194         }
2195 
2196         /* we've logged all the items and now have a consistent
2197          * version of the file in the log.  It is possible that
2198          * someone will come in and modify the file, but that's
2199          * fine because the log is consistent on disk, and we
2200          * have references to all of the file's extents
2201          *
2202          * It is possible that someone will come in and log the
2203          * file again, but that will end up using the synchronization
2204          * inside btrfs_sync_log to keep things safe.
2205          */
2206         up_write(&BTRFS_I(inode)->dio_sem);
2207         inode_unlock(inode);
2208 
2209         if (ret != BTRFS_NO_LOG_SYNC) {
2210                 if (!ret) {
2211                         ret = btrfs_sync_log(trans, root, &ctx);
2212                         if (!ret) {
2213                                 ret = btrfs_end_transaction(trans);
2214                                 goto out;
2215                         }
2216                 }
2217                 ret = btrfs_commit_transaction(trans);
2218         } else {
2219                 ret = btrfs_end_transaction(trans);
2220         }
2221 out:
2222         ASSERT(list_empty(&ctx.list));
2223         err = file_check_and_advance_wb_err(file);
2224         if (!ret)
2225                 ret = err;
2226         return ret > 0 ? -EIO : ret;
2227 }
2228 
2229 static const struct vm_operations_struct btrfs_file_vm_ops = {
2230         .fault          = filemap_fault,
2231         .map_pages      = filemap_map_pages,
2232         .page_mkwrite   = btrfs_page_mkwrite,
2233 };
2234 
2235 static int btrfs_file_mmap(struct file  *filp, struct vm_area_struct *vma)
2236 {
2237         struct address_space *mapping = filp->f_mapping;
2238 
2239         if (!mapping->a_ops->readpage)
2240                 return -ENOEXEC;
2241 
2242         file_accessed(filp);
2243         vma->vm_ops = &btrfs_file_vm_ops;
2244 
2245         return 0;
2246 }
2247 
2248 static int hole_mergeable(struct btrfs_inode *inode, struct extent_buffer *leaf,
2249                           int slot, u64 start, u64 end)
2250 {
2251         struct btrfs_file_extent_item *fi;
2252         struct btrfs_key key;
2253 
2254         if (slot < 0 || slot >= btrfs_header_nritems(leaf))
2255                 return 0;
2256 
2257         btrfs_item_key_to_cpu(leaf, &key, slot);
2258         if (key.objectid != btrfs_ino(inode) ||
2259             key.type != BTRFS_EXTENT_DATA_KEY)
2260                 return 0;
2261 
2262         fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
2263 
2264         if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
2265                 return 0;
2266 
2267         if (btrfs_file_extent_disk_bytenr(leaf, fi))
2268                 return 0;
2269 
2270         if (key.offset == end)
2271                 return 1;
2272         if (key.offset + btrfs_file_extent_num_bytes(leaf, fi) == start)
2273                 return 1;
2274         return 0;
2275 }
2276 
2277 static int fill_holes(struct btrfs_trans_handle *trans,
2278                 struct btrfs_inode *inode,
2279                 struct btrfs_path *path, u64 offset, u64 end)
2280 {
2281         struct btrfs_fs_info *fs_info = trans->fs_info;
2282         struct btrfs_root *root = inode->root;
2283         struct extent_buffer *leaf;
2284         struct btrfs_file_extent_item *fi;
2285         struct extent_map *hole_em;
2286         struct extent_map_tree *em_tree = &inode->extent_tree;
2287         struct btrfs_key key;
2288         int ret;
2289 
2290         if (btrfs_fs_incompat(fs_info, NO_HOLES))
2291                 goto out;
2292 
2293         key.objectid = btrfs_ino(inode);
2294         key.type = BTRFS_EXTENT_DATA_KEY;
2295         key.offset = offset;
2296 
2297         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
2298         if (ret <= 0) {
2299                 /*
2300                  * We should have dropped this offset, so if we find it then
2301                  * something has gone horribly wrong.
2302                  */
2303                 if (ret == 0)
2304                         ret = -EINVAL;
2305                 return ret;
2306         }
2307 
2308         leaf = path->nodes[0];
2309         if (hole_mergeable(inode, leaf, path->slots[0] - 1, offset, end)) {
2310                 u64 num_bytes;
2311 
2312                 path->slots[0]--;
2313                 fi = btrfs_item_ptr(leaf, path->slots[0],
2314                                     struct btrfs_file_extent_item);
2315                 num_bytes = btrfs_file_extent_num_bytes(leaf, fi) +
2316                         end - offset;
2317                 btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
2318                 btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
2319                 btrfs_set_file_extent_offset(leaf, fi, 0);
2320                 btrfs_mark_buffer_dirty(leaf);
2321                 goto out;
2322         }
2323 
2324         if (hole_mergeable(inode, leaf, path->slots[0], offset, end)) {
2325                 u64 num_bytes;
2326 
2327                 key.offset = offset;
2328                 btrfs_set_item_key_safe(fs_info, path, &key);
2329                 fi = btrfs_item_ptr(leaf, path->slots[0],
2330                                     struct btrfs_file_extent_item);
2331                 num_bytes = btrfs_file_extent_num_bytes(leaf, fi) + end -
2332                         offset;
2333                 btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
2334                 btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
2335                 btrfs_set_file_extent_offset(leaf, fi, 0);
2336                 btrfs_mark_buffer_dirty(leaf);
2337                 goto out;
2338         }
2339         btrfs_release_path(path);
2340 
2341         ret = btrfs_insert_file_extent(trans, root, btrfs_ino(inode),
2342                         offset, 0, 0, end - offset, 0, end - offset, 0, 0, 0);
2343         if (ret)
2344                 return ret;
2345 
2346 out:
2347         btrfs_release_path(path);
2348 
2349         hole_em = alloc_extent_map();
2350         if (!hole_em) {
2351                 btrfs_drop_extent_cache(inode, offset, end - 1, 0);
2352                 set_bit(BTRFS_INODE_NEEDS_FULL_SYNC, &inode->runtime_flags);
2353         } else {
2354                 hole_em->start = offset;
2355                 hole_em->len = end - offset;
2356                 hole_em->ram_bytes = hole_em->len;
2357                 hole_em->orig_start = offset;
2358 
2359                 hole_em->block_start = EXTENT_MAP_HOLE;
2360                 hole_em->block_len = 0;
2361                 hole_em->orig_block_len = 0;
2362                 hole_em->bdev = fs_info->fs_devices->latest_bdev;
2363                 hole_em->compress_type = BTRFS_COMPRESS_NONE;
2364                 hole_em->generation = trans->transid;
2365 
2366                 do {
2367                         btrfs_drop_extent_cache(inode, offset, end - 1, 0);
2368                         write_lock(&em_tree->lock);
2369                         ret = add_extent_mapping(em_tree, hole_em, 1);
2370                         write_unlock(&em_tree->lock);
2371                 } while (ret == -EEXIST);
2372                 free_extent_map(hole_em);
2373                 if (ret)
2374                         set_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
2375                                         &inode->runtime_flags);
2376         }
2377 
2378         return 0;
2379 }
2380 
2381 /*
2382  * Find a hole extent on given inode and change start/len to the end of hole
2383  * extent.(hole/vacuum extent whose em->start <= start &&
2384  *         em->start + em->len > start)
2385  * When a hole extent is found, return 1 and modify start/len.
2386  */
2387 static int find_first_non_hole(struct inode *inode, u64 *start, u64 *len)
2388 {
2389         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
2390         struct extent_map *em;
2391         int ret = 0;
2392 
2393         em = btrfs_get_extent(BTRFS_I(inode), NULL, 0,
2394                               round_down(*start, fs_info->sectorsize),
2395                               round_up(*len, fs_info->sectorsize), 0);
2396         if (IS_ERR(em))
2397                 return PTR_ERR(em);
2398 
2399         /* Hole or vacuum extent(only exists in no-hole mode) */
2400         if (em->block_start == EXTENT_MAP_HOLE) {
2401                 ret = 1;
2402                 *len = em->start + em->len > *start + *len ?
2403                        0 : *start + *len - em->start - em->len;
2404                 *start = em->start + em->len;
2405         }
2406         free_extent_map(em);
2407         return ret;
2408 }
2409 
2410 static int btrfs_punch_hole_lock_range(struct inode *inode,
2411                                        const u64 lockstart,
2412                                        const u64 lockend,
2413                                        struct extent_state **cached_state)
2414 {
2415         while (1) {
2416                 struct btrfs_ordered_extent *ordered;
2417                 int ret;
2418 
2419                 truncate_pagecache_range(inode, lockstart, lockend);
2420 
2421                 lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
2422                                  cached_state);
2423                 ordered = btrfs_lookup_first_ordered_extent(inode, lockend);
2424 
2425                 /*
2426                  * We need to make sure we have no ordered extents in this range
2427                  * and nobody raced in and read a page in this range, if we did
2428                  * we need to try again.
2429                  */
2430                 if ((!ordered ||
2431                     (ordered->file_offset + ordered->len <= lockstart ||
2432                      ordered->file_offset > lockend)) &&
2433                      !filemap_range_has_page(inode->i_mapping,
2434                                              lockstart, lockend)) {
2435                         if (ordered)
2436                                 btrfs_put_ordered_extent(ordered);
2437                         break;
2438                 }
2439                 if (ordered)
2440                         btrfs_put_ordered_extent(ordered);
2441                 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart,
2442                                      lockend, cached_state);
2443                 ret = btrfs_wait_ordered_range(inode, lockstart,
2444                                                lockend - lockstart + 1);
2445                 if (ret)
2446                         return ret;
2447         }
2448         return 0;
2449 }
2450 
2451 static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
2452 {
2453         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
2454         struct btrfs_root *root = BTRFS_I(inode)->root;
2455         struct extent_state *cached_state = NULL;
2456         struct btrfs_path *path;
2457         struct btrfs_block_rsv *rsv;
2458         struct btrfs_trans_handle *trans;
2459         u64 lockstart;
2460         u64 lockend;
2461         u64 tail_start;
2462         u64 tail_len;
2463         u64 orig_start = offset;
2464         u64 cur_offset;
2465         u64 min_size = btrfs_calc_trans_metadata_size(fs_info, 1);
2466         u64 drop_end;
2467         int ret = 0;
2468         int err = 0;
2469         unsigned int rsv_count;
2470         bool same_block;
2471         bool no_holes = btrfs_fs_incompat(fs_info, NO_HOLES);
2472         u64 ino_size;
2473         bool truncated_block = false;
2474         bool updated_inode = false;
2475 
2476         ret = btrfs_wait_ordered_range(inode, offset, len);
2477         if (ret)
2478                 return ret;
2479 
2480         inode_lock(inode);
2481         ino_size = round_up(inode->i_size, fs_info->sectorsize);
2482         ret = find_first_non_hole(inode, &offset, &len);
2483         if (ret < 0)
2484                 goto out_only_mutex;
2485         if (ret && !len) {
2486                 /* Already in a large hole */
2487                 ret = 0;
2488                 goto out_only_mutex;
2489         }
2490 
2491         lockstart = round_up(offset, btrfs_inode_sectorsize(inode));
2492         lockend = round_down(offset + len,
2493                              btrfs_inode_sectorsize(inode)) - 1;
2494         same_block = (BTRFS_BYTES_TO_BLKS(fs_info, offset))
2495                 == (BTRFS_BYTES_TO_BLKS(fs_info, offset + len - 1));
2496         /*
2497          * We needn't truncate any block which is beyond the end of the file
2498          * because we are sure there is no data there.
2499          */
2500         /*
2501          * Only do this if we are in the same block and we aren't doing the
2502          * entire block.
2503          */
2504         if (same_block && len < fs_info->sectorsize) {
2505                 if (offset < ino_size) {
2506                         truncated_block = true;
2507                         ret = btrfs_truncate_block(inode, offset, len, 0);
2508                 } else {
2509                         ret = 0;
2510                 }
2511                 goto out_only_mutex;
2512         }
2513 
2514         /* zero back part of the first block */
2515         if (offset < ino_size) {
2516                 truncated_block = true;
2517                 ret = btrfs_truncate_block(inode, offset, 0, 0);
2518                 if (ret) {
2519                         inode_unlock(inode);
2520                         return ret;
2521                 }
2522         }
2523 
2524         /* Check the aligned pages after the first unaligned page,
2525          * if offset != orig_start, which means the first unaligned page
2526          * including several following pages are already in holes,
2527          * the extra check can be skipped */
2528         if (offset == orig_start) {
2529                 /* after truncate page, check hole again */
2530                 len = offset + len - lockstart;
2531                 offset = lockstart;
2532                 ret = find_first_non_hole(inode, &offset, &len);
2533                 if (ret < 0)
2534                         goto out_only_mutex;
2535                 if (ret && !len) {
2536                         ret = 0;
2537                         goto out_only_mutex;
2538                 }
2539                 lockstart = offset;
2540         }
2541 
2542         /* Check the tail unaligned part is in a hole */
2543         tail_start = lockend + 1;
2544         tail_len = offset + len - tail_start;
2545         if (tail_len) {
2546                 ret = find_first_non_hole(inode, &tail_start, &tail_len);
2547                 if (unlikely(ret < 0))
2548                         goto out_only_mutex;
2549                 if (!ret) {
2550                         /* zero the front end of the last page */
2551                         if (tail_start + tail_len < ino_size) {
2552                                 truncated_block = true;
2553                                 ret = btrfs_truncate_block(inode,
2554                                                         tail_start + tail_len,
2555                                                         0, 1);
2556                                 if (ret)
2557                                         goto out_only_mutex;
2558                         }
2559                 }
2560         }
2561 
2562         if (lockend < lockstart) {
2563                 ret = 0;
2564                 goto out_only_mutex;
2565         }
2566 
2567         ret = btrfs_punch_hole_lock_range(inode, lockstart, lockend,
2568                                           &cached_state);
2569         if (ret)
2570                 goto out_only_mutex;
2571 
2572         path = btrfs_alloc_path();
2573         if (!path) {
2574                 ret = -ENOMEM;
2575                 goto out;
2576         }
2577 
2578         rsv = btrfs_alloc_block_rsv(fs_info, BTRFS_BLOCK_RSV_TEMP);
2579         if (!rsv) {
2580                 ret = -ENOMEM;
2581                 goto out_free;
2582         }
2583         rsv->size = btrfs_calc_trans_metadata_size(fs_info, 1);
2584         rsv->failfast = 1;
2585 
2586         /*
2587          * 1 - update the inode
2588          * 1 - removing the extents in the range
2589          * 1 - adding the hole extent if no_holes isn't set
2590          */
2591         rsv_count = no_holes ? 2 : 3;
2592         trans = btrfs_start_transaction(root, rsv_count);
2593         if (IS_ERR(trans)) {
2594                 err = PTR_ERR(trans);
2595                 goto out_free;
2596         }
2597 
2598         ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv, rsv,
2599                                       min_size, false);
2600         BUG_ON(ret);
2601         trans->block_rsv = rsv;
2602 
2603         cur_offset = lockstart;
2604         len = lockend - cur_offset;
2605         while (cur_offset < lockend) {
2606                 ret = __btrfs_drop_extents(trans, root, inode, path,
2607                                            cur_offset, lockend + 1,
2608                                            &drop_end, 1, 0, 0, NULL);
2609                 if (ret != -ENOSPC)
2610                         break;
2611 
2612                 trans->block_rsv = &fs_info->trans_block_rsv;
2613 
2614                 if (cur_offset < drop_end && cur_offset < ino_size) {
2615                         ret = fill_holes(trans, BTRFS_I(inode), path,
2616                                         cur_offset, drop_end);
2617                         if (ret) {
2618                                 /*
2619                                  * If we failed then we didn't insert our hole
2620                                  * entries for the area we dropped, so now the
2621                                  * fs is corrupted, so we must abort the
2622                                  * transaction.
2623                                  */
2624                                 btrfs_abort_transaction(trans, ret);
2625                                 err = ret;
2626                                 break;
2627                         }
2628                 }
2629 
2630                 cur_offset = drop_end;
2631 
2632                 ret = btrfs_update_inode(trans, root, inode);
2633                 if (ret) {
2634                         err = ret;
2635                         break;
2636                 }
2637 
2638                 btrfs_end_transaction(trans);
2639                 btrfs_btree_balance_dirty(fs_info);
2640 
2641                 trans = btrfs_start_transaction(root, rsv_count);
2642                 if (IS_ERR(trans)) {
2643                         ret = PTR_ERR(trans);
2644                         trans = NULL;
2645                         break;
2646                 }
2647 
2648                 ret = btrfs_block_rsv_migrate(&fs_info->trans_block_rsv,
2649                                               rsv, min_size, false);
2650                 BUG_ON(ret);    /* shouldn't happen */
2651                 trans->block_rsv = rsv;
2652 
2653                 ret = find_first_non_hole(inode, &cur_offset, &len);
2654                 if (unlikely(ret < 0))
2655                         break;
2656                 if (ret && !len) {
2657                         ret = 0;
2658                         break;
2659                 }
2660         }
2661 
2662         if (ret) {
2663                 err = ret;
2664                 goto out_trans;
2665         }
2666 
2667         trans->block_rsv = &fs_info->trans_block_rsv;
2668         /*
2669          * If we are using the NO_HOLES feature we might have had already an
2670          * hole that overlaps a part of the region [lockstart, lockend] and
2671          * ends at (or beyond) lockend. Since we have no file extent items to
2672          * represent holes, drop_end can be less than lockend and so we must
2673          * make sure we have an extent map representing the existing hole (the
2674          * call to __btrfs_drop_extents() might have dropped the existing extent
2675          * map representing the existing hole), otherwise the fast fsync path
2676          * will not record the existence of the hole region
2677          * [existing_hole_start, lockend].
2678          */
2679         if (drop_end <= lockend)
2680                 drop_end = lockend + 1;
2681         /*
2682          * Don't insert file hole extent item if it's for a range beyond eof
2683          * (because it's useless) or if it represents a 0 bytes range (when
2684          * cur_offset == drop_end).
2685          */
2686         if (cur_offset < ino_size && cur_offset < drop_end) {
2687                 ret = fill_holes(trans, BTRFS_I(inode), path,
2688                                 cur_offset, drop_end);
2689                 if (ret) {
2690                         /* Same comment as above. */
2691                         btrfs_abort_transaction(trans, ret);
2692                         err = ret;
2693                         goto out_trans;
2694                 }
2695         }
2696 
2697 out_trans:
2698         if (!trans)
2699                 goto out_free;
2700 
2701         inode_inc_iversion(inode);
2702         inode->i_mtime = inode->i_ctime = current_time(inode);
2703 
2704         trans->block_rsv = &fs_info->trans_block_rsv;
2705         ret = btrfs_update_inode(trans, root, inode);
2706         updated_inode = true;
2707         btrfs_end_transaction(trans);
2708         btrfs_btree_balance_dirty(fs_info);
2709 out_free:
2710         btrfs_free_path(path);
2711         btrfs_free_block_rsv(fs_info, rsv);
2712 out:
2713         unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
2714                              &cached_state);
2715 out_only_mutex:
2716         if (!updated_inode && truncated_block && !ret && !err) {
2717                 /*
2718                  * If we only end up zeroing part of a page, we still need to
2719                  * update the inode item, so that all the time fields are
2720                  * updated as well as the necessary btrfs inode in memory fields
2721                  * for detecting, at fsync time, if the inode isn't yet in the
2722                  * log tree or it's there but not up to date.
2723                  */
2724                 struct timespec64 now = current_time(inode);
2725 
2726                 inode_inc_iversion(inode);
2727                 inode->i_mtime = now;
2728                 inode->i_ctime = now;
2729                 trans = btrfs_start_transaction(root, 1);
2730                 if (IS_ERR(trans)) {
2731                         err = PTR_ERR(trans);
2732                 } else {
2733                         err = btrfs_update_inode(trans, root, inode);
2734                         ret = btrfs_end_transaction(trans);
2735                 }
2736         }
2737         inode_unlock(inode);
2738         if (ret && !err)
2739                 err = ret;
2740         return err;
2741 }
2742 
2743 /* Helper structure to record which range is already reserved */
2744 struct falloc_range {
2745         struct list_head list;
2746         u64 start;
2747         u64 len;
2748 };
2749 
2750 /*
2751  * Helper function to add falloc range
2752  *
2753  * Caller should have locked the larger range of extent containing
2754  * [start, len)
2755  */
2756 static int add_falloc_range(struct list_head *head, u64 start, u64 len)
2757 {
2758         struct falloc_range *prev = NULL;
2759         struct falloc_range *range = NULL;
2760 
2761         if (list_empty(head))
2762                 goto insert;
2763 
2764         /*
2765          * As fallocate iterate by bytenr order, we only need to check
2766          * the last range.
2767          */
2768         prev = list_entry(head->prev, struct falloc_range, list);
2769         if (prev->start + prev->len == start) {
2770                 prev->len += len;
2771                 return 0;
2772         }
2773 insert:
2774         range = kmalloc(sizeof(*range), GFP_KERNEL);
2775         if (!range)
2776                 return -ENOMEM;
2777         range->start = start;
2778         range->len = len;
2779         list_add_tail(&range->list, head);
2780         return 0;
2781 }
2782 
2783 static int btrfs_fallocate_update_isize(struct inode *inode,
2784                                         const u64 end,
2785                                         const int mode)
2786 {
2787         struct btrfs_trans_handle *trans;
2788         struct btrfs_root *root = BTRFS_I(inode)->root;
2789         int ret;
2790         int ret2;
2791 
2792         if (mode & FALLOC_FL_KEEP_SIZE || end <= i_size_read(inode))
2793                 return 0;
2794 
2795         trans = btrfs_start_transaction(root, 1);
2796         if (IS_ERR(trans))
2797                 return PTR_ERR(trans);
2798 
2799         inode->i_ctime = current_time(inode);
2800         i_size_write(inode, end);
2801         btrfs_ordered_update_i_size(inode, end, NULL);
2802         ret = btrfs_update_inode(trans, root, inode);
2803         ret2 = btrfs_end_transaction(trans);
2804 
2805         return ret ? ret : ret2;
2806 }
2807 
2808 enum {
2809         RANGE_BOUNDARY_WRITTEN_EXTENT = 0,
2810         RANGE_BOUNDARY_PREALLOC_EXTENT = 1,
2811         RANGE_BOUNDARY_HOLE = 2,
2812 };
2813 
2814 static int btrfs_zero_range_check_range_boundary(struct inode *inode,
2815                                                  u64 offset)
2816 {
2817         const u64 sectorsize = btrfs_inode_sectorsize(inode);
2818         struct extent_map *em;
2819         int ret;
2820 
2821         offset = round_down(offset, sectorsize);
2822         em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0);
2823         if (IS_ERR(em))
2824                 return PTR_ERR(em);
2825 
2826         if (em->block_start == EXTENT_MAP_HOLE)
2827                 ret = RANGE_BOUNDARY_HOLE;
2828         else if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
2829                 ret = RANGE_BOUNDARY_PREALLOC_EXTENT;
2830         else
2831                 ret = RANGE_BOUNDARY_WRITTEN_EXTENT;
2832 
2833         free_extent_map(em);
2834         return ret;
2835 }
2836 
2837 static int btrfs_zero_range(struct inode *inode,
2838                             loff_t offset,
2839                             loff_t len,
2840                             const int mode)
2841 {
2842         struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
2843         struct extent_map *em;
2844         struct extent_changeset *data_reserved = NULL;
2845         int ret;
2846         u64 alloc_hint = 0;
2847         const u64 sectorsize = btrfs_inode_sectorsize(inode);
2848         u64 alloc_start = round_down(offset, sectorsize);
2849         u64 alloc_end = round_up(offset + len, sectorsize);
2850         u64 bytes_to_reserve = 0;
2851         bool space_reserved = false;
2852 
2853         inode_dio_wait(inode);
2854 
2855         em = btrfs_get_extent(BTRFS_I(inode), NULL, 0,
2856                               alloc_start, alloc_end - alloc_start, 0);
2857         if (IS_ERR(em)) {
2858                 ret = PTR_ERR(em);
2859                 goto out;
2860         }
2861 
2862         /*
2863          * Avoid hole punching and extent allocation for some cases. More cases
2864          * could be considered, but these are unlikely common and we keep things
2865          * as simple as possible for now. Also, intentionally, if the target
2866          * range contains one or more prealloc extents together with regular
2867          * extents and holes, we drop all the existing extents and allocate a
2868          * new prealloc extent, so that we get a larger contiguous disk extent.
2869          */
2870         if (em->start <= alloc_start &&
2871             test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
2872                 const u64 em_end = em->start + em->len;
2873 
2874                 if (em_end >= offset + len) {
2875                         /*
2876                          * The whole range is already a prealloc extent,
2877                          * do nothing except updating the inode's i_size if
2878                          * needed.
2879                          */
2880                         free_extent_map(em);
2881                         ret = btrfs_fallocate_update_isize(inode, offset + len,
2882                                                            mode);
2883                         goto out;
2884                 }
2885                 /*
2886                  * Part of the range is already a prealloc extent, so operate
2887                  * only on the remaining part of the range.
2888                  */
2889                 alloc_start = em_end;
2890                 ASSERT(IS_ALIGNED(alloc_start, sectorsize));
2891                 len = offset + len - alloc_start;
2892                 offset = alloc_start;
2893                 alloc_hint = em->block_start + em->len;
2894         }
2895         free_extent_map(em);
2896 
2897         if (BTRFS_BYTES_TO_BLKS(fs_info, offset) ==
2898             BTRFS_BYTES_TO_BLKS(fs_info, offset + len - 1)) {
2899                 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0,
2900                                       alloc_start, sectorsize, 0);
2901                 if (IS_ERR(em)) {
2902                         ret = PTR_ERR(em);
2903                         goto out;
2904                 }
2905 
2906                 if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) {
2907                         free_extent_map(em);
2908                         ret = btrfs_fallocate_update_isize(inode, offset + len,
2909                                                            mode);
2910                         goto out;
2911                 }
2912                 if (len < sectorsize && em->block_start != EXTENT_MAP_HOLE) {
2913                         free_extent_map(em);
2914                         ret = btrfs_truncate_block(inode, offset, len, 0);
2915                         if (!ret)
2916                                 ret = btrfs_fallocate_update_isize(inode,
2917                                                                    offset + len,
2918                                                                    mode);
2919                         return ret;
2920                 }
2921                 free_extent_map(em);
2922                 alloc_start = round_down(offset, sectorsize);
2923                 alloc_end = alloc_start + sectorsize;
2924                 goto reserve_space;
2925         }
2926 
2927         alloc_start = round_up(offset, sectorsize);
2928         alloc_end = round_down(offset + len, sectorsize);
2929 
2930         /*
2931          * For unaligned ranges, check the pages at the boundaries, they might
2932          * map to an extent, in which case we need to partially zero them, or
2933          * they might map to a hole, in which case we need our allocation range
2934          * to cover them.
2935          */
2936         if (!IS_ALIGNED(offset, sectorsize)) {
2937                 ret = btrfs_zero_range_check_range_boundary(inode, offset);
2938                 if (ret < 0)
2939                         goto out;
2940                 if (ret == RANGE_BOUNDARY_HOLE) {
2941                         alloc_start = round_down(offset, sectorsize);
2942                         ret = 0;
2943                 } else if (ret == RANGE_BOUNDARY_WRITTEN_EXTENT) {
2944                         ret = btrfs_truncate_block(inode, offset, 0, 0);
2945                         if (ret)
2946                                 goto out;
2947                 } else {
2948                         ret = 0;
2949                 }
2950         }
2951 
2952         if (!IS_ALIGNED(offset + len, sectorsize)) {
2953                 ret = btrfs_zero_range_check_range_boundary(inode,
2954                                                             offset + len);
2955                 if (ret < 0)
2956                         goto out;
2957                 if (ret == RANGE_BOUNDARY_HOLE) {
2958                         alloc_end = round_up(offset + len, sectorsize);
2959                         ret = 0;
2960                 } else if (ret == RANGE_BOUNDARY_WRITTEN_EXTENT) {
2961                         ret = btrfs_truncate_block(inode, offset + len, 0, 1);
2962                         if (ret)
2963                                 goto out;
2964                 } else {
2965                         ret = 0;
2966                 }
2967         }
2968 
2969 reserve_space:
2970         if (alloc_start < alloc_end) {
2971                 struct extent_state *cached_state = NULL;
2972                 const u64 lockstart = alloc_start;
2973                 const u64 lockend = alloc_end - 1;
2974 
2975                 bytes_to_reserve = alloc_end - alloc_start;
2976                 ret = btrfs_alloc_data_chunk_ondemand(BTRFS_I(inode),
2977                                                       bytes_to_reserve);
2978                 if (ret < 0)
2979                         goto out;
2980                 space_reserved = true;
2981                 ret = btrfs_qgroup_reserve_data(inode, &data_reserved,
2982                                                 alloc_start, bytes_to_reserve);
2983                 if (ret)
2984                         goto out;
2985                 ret = btrfs_punch_hole_lock_range(inode, lockstart, lockend,
2986                                                   &cached_state);
2987                 if (ret)
2988                         goto out;
2989                 ret = btrfs_prealloc_file_range(inode, mode, alloc_start,
2990                                                 alloc_end - alloc_start,
2991                                                 i_blocksize(inode),
2992                                                 offset + len, &alloc_hint);
2993                 unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart,
2994                                      lockend, &cached_state);
2995                 /* btrfs_prealloc_file_range releases reserved space on error */
2996                 if (ret) {
2997                         space_reserved = false;
2998                         goto out;
2999                 }
3000         }
3001         ret = btrfs_fallocate_update_isize(inode, offset + len, mode);
3002  out:
3003         if (ret && space_reserved)
3004                 btrfs_free_reserved_data_space(inode, data_reserved,
3005                                                alloc_start, bytes_to_reserve);
3006         extent_changeset_free(data_reserved);
3007 
3008         return ret;
3009 }
3010 
3011 static long btrfs_fallocate(struct file *file, int mode,
3012                             loff_t offset, loff_t len)
3013 {
3014         struct inode *inode = file_inode(file);
3015         struct extent_state *cached_state = NULL;
3016         struct extent_changeset *data_reserved = NULL;
3017         struct falloc_range *range;
3018         struct falloc_range *tmp;
3019         struct list_head reserve_list;
3020         u64 cur_offset;
3021         u64 last_byte;
3022         u64 alloc_start;
3023         u64 alloc_end;
3024         u64 alloc_hint = 0;
3025         u64 locked_end;
3026         u64 actual_end = 0;
3027         struct extent_map *em;
3028         int blocksize = btrfs_inode_sectorsize(inode);
3029         int ret;
3030 
3031         alloc_start = round_down(offset, blocksize);
3032         alloc_end = round_up(offset + len, blocksize);
3033         cur_offset = alloc_start;
3034 
3035         /* Make sure we aren't being give some crap mode */
3036         if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE |
3037                      FALLOC_FL_ZERO_RANGE))
3038                 return -EOPNOTSUPP;
3039 
3040         if (mode & FALLOC_FL_PUNCH_HOLE)
3041                 return btrfs_punch_hole(inode, offset, len);
3042 
3043         /*
3044          * Only trigger disk allocation, don't trigger qgroup reserve
3045          *
3046          * For qgroup space, it will be checked later.
3047          */
3048         if (!(mode & FALLOC_FL_ZERO_RANGE)) {
3049                 ret = btrfs_alloc_data_chunk_ondemand(BTRFS_I(inode),
3050                                                       alloc_end - alloc_start);
3051                 if (ret < 0)
3052                         return ret;
3053         }
3054 
3055         inode_lock(inode);
3056 
3057         if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + len > inode->i_size) {
3058                 ret = inode_newsize_ok(inode, offset + len);
3059                 if (ret)
3060                         goto out;
3061         }
3062 
3063         /*
3064          * TODO: Move these two operations after we have checked
3065          * accurate reserved space, or fallocate can still fail but
3066          * with page truncated or size expanded.
3067          *
3068          * But that's a minor problem and won't do much harm BTW.
3069          */
3070         if (alloc_start > inode->i_size) {
3071                 ret = btrfs_cont_expand(inode, i_size_read(inode),
3072                                         alloc_start);
3073                 if (ret)
3074                         goto out;
3075         } else if (offset + len > inode->i_size) {
3076                 /*
3077                  * If we are fallocating from the end of the file onward we
3078                  * need to zero out the end of the block if i_size lands in the
3079                  * middle of a block.
3080                  */
3081                 ret = btrfs_truncate_block(inode, inode->i_size, 0, 0);
3082                 if (ret)
3083                         goto out;
3084         }
3085 
3086         /*
3087          * wait for ordered IO before we have any locks.  We'll loop again
3088          * below with the locks held.
3089          */
3090         ret = btrfs_wait_ordered_range(inode, alloc_start,
3091                                        alloc_end - alloc_start);
3092         if (ret)
3093                 goto out;
3094 
3095         if (mode & FALLOC_FL_ZERO_RANGE) {
3096                 ret = btrfs_zero_range(inode, offset, len, mode);
3097                 inode_unlock(inode);
3098                 return ret;
3099         }
3100 
3101         locked_end = alloc_end - 1;
3102         while (1) {
3103                 struct btrfs_ordered_extent *ordered;
3104 
3105                 /* the extent lock is ordered inside the running
3106                  * transaction
3107                  */
3108                 lock_extent_bits(&BTRFS_I(inode)->io_tree, alloc_start,
3109                                  locked_end, &cached_state);
3110                 ordered = btrfs_lookup_first_ordered_extent(inode, locked_end);
3111 
3112                 if (ordered &&
3113                     ordered->file_offset + ordered->len > alloc_start &&
3114                     ordered->file_offset < alloc_end) {
3115                         btrfs_put_ordered_extent(ordered);
3116                         unlock_extent_cached(&BTRFS_I(inode)->io_tree,
3117                                              alloc_start, locked_end,
3118                                              &cached_state);
3119                         /*
3120                          * we can't wait on the range with the transaction
3121                          * running or with the extent lock held
3122                          */
3123                         ret = btrfs_wait_ordered_range(inode, alloc_start,
3124                                                        alloc_end - alloc_start);
3125                         if (ret)
3126                                 goto out;
3127                 } else {
3128                         if (ordered)
3129                                 btrfs_put_ordered_extent(ordered);
3130                         break;
3131                 }
3132         }
3133 
3134         /* First, check if we exceed the qgroup limit */
3135         INIT_LIST_HEAD(&reserve_list);
3136         while (cur_offset < alloc_end) {
3137                 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, cur_offset,
3138                                       alloc_end - cur_offset, 0);
3139                 if (IS_ERR(em)) {
3140                         ret = PTR_ERR(em);
3141                         break;
3142                 }
3143                 last_byte = min(extent_map_end(em), alloc_end);
3144                 actual_end = min_t(u64, extent_map_end(em), offset + len);
3145                 last_byte = ALIGN(last_byte, blocksize);
3146                 if (em->block_start == EXTENT_MAP_HOLE ||
3147                     (cur_offset >= inode->i_size &&
3148                      !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) {
3149                         ret = add_falloc_range(&reserve_list, cur_offset,
3150                                                last_byte - cur_offset);
3151                         if (ret < 0) {
3152                                 free_extent_map(em);
3153                                 break;
3154                         }
3155                         ret = btrfs_qgroup_reserve_data(inode, &data_reserved,
3156                                         cur_offset, last_byte - cur_offset);
3157                         if (ret < 0) {
3158                                 cur_offset = last_byte;
3159                                 free_extent_map(em);
3160                                 break;
3161                         }
3162                 } else {
3163                         /*
3164                          * Do not need to reserve unwritten extent for this
3165                          * range, free reserved data space first, otherwise
3166                          * it'll result in false ENOSPC error.
3167                          */
3168                         btrfs_free_reserved_data_space(inode, data_reserved,
3169                                         cur_offset, last_byte - cur_offset);
3170                 }
3171                 free_extent_map(em);
3172                 cur_offset = last_byte;
3173         }
3174 
3175         /*
3176          * If ret is still 0, means we're OK to fallocate.
3177          * Or just cleanup the list and exit.
3178          */
3179         list_for_each_entry_safe(range, tmp, &reserve_list, list) {
3180                 if (!ret)
3181                         ret = btrfs_prealloc_file_range(inode, mode,
3182                                         range->start,
3183                                         range->len, i_blocksize(inode),
3184                                         offset + len, &alloc_hint);
3185                 else
3186                         btrfs_free_reserved_data_space(inode,
3187                                         data_reserved, range->start,
3188                                         range->len);
3189                 list_del(&range->list);
3190                 kfree(range);
3191         }
3192         if (ret < 0)
3193                 goto out_unlock;
3194 
3195         /*
3196          * We didn't need to allocate any more space, but we still extended the
3197          * size of the file so we need to update i_size and the inode item.
3198          */
3199         ret = btrfs_fallocate_update_isize(inode, actual_end, mode);
3200 out_unlock:
3201         unlock_extent_cached(&BTRFS_I(inode)->io_tree, alloc_start, locked_end,
3202                              &cached_state);
3203 out:
3204         inode_unlock(inode);
3205         /* Let go of our reservation. */
3206         if (ret != 0 && !(mode & FALLOC_FL_ZERO_RANGE))
3207                 btrfs_free_reserved_data_space(inode, data_reserved,
3208                                 cur_offset, alloc_end - cur_offset);
3209         extent_changeset_free(data_reserved);
3210         return ret;
3211 }
3212 
3213 static int find_desired_extent(struct inode *inode, loff_t *offset, int whence)
3214 {
3215         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
3216         struct extent_map *em = NULL;
3217         struct extent_state *cached_state = NULL;
3218         u64 lockstart;
3219         u64 lockend;
3220         u64 start;
3221         u64 len;
3222         int ret = 0;
3223 
3224         if (inode->i_size == 0)
3225                 return -ENXIO;
3226 
3227         /*
3228          * *offset can be negative, in this case we start finding DATA/HOLE from
3229          * the very start of the file.
3230          */
3231         start = max_t(loff_t, 0, *offset);
3232 
3233         lockstart = round_down(start, fs_info->sectorsize);
3234         lockend = round_up(i_size_read(inode),
3235                            fs_info->sectorsize);
3236         if (lockend <= lockstart)
3237                 lockend = lockstart + fs_info->sectorsize;
3238         lockend--;
3239         len = lockend - lockstart + 1;
3240 
3241         lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend,
3242                          &cached_state);
3243 
3244         while (start < inode->i_size) {
3245                 em = btrfs_get_extent_fiemap(BTRFS_I(inode), start, len);
3246                 if (IS_ERR(em)) {
3247                         ret = PTR_ERR(em);
3248                         em = NULL;
3249                         break;
3250                 }
3251 
3252                 if (whence == SEEK_HOLE &&
3253                     (em->block_start == EXTENT_MAP_HOLE ||
3254                      test_bit(EXTENT_FLAG_PREALLOC, &em->flags)))
3255                         break;
3256                 else if (whence == SEEK_DATA &&
3257                            (em->block_start != EXTENT_MAP_HOLE &&
3258                             !test_bit(EXTENT_FLAG_PREALLOC, &em->flags)))
3259                         break;
3260 
3261                 start = em->start + em->len;
3262                 free_extent_map(em);
3263                 em = NULL;
3264                 cond_resched();
3265         }
3266         free_extent_map(em);
3267         if (!ret) {
3268                 if (whence == SEEK_DATA && start >= inode->i_size)
3269                         ret = -ENXIO;
3270                 else
3271                         *offset = min_t(loff_t, start, inode->i_size);
3272         }
3273         unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
3274                              &cached_state);
3275         return ret;
3276 }
3277 
3278 static loff_t btrfs_file_llseek(struct file *file, loff_t offset, int whence)
3279 {
3280         struct inode *inode = file->f_mapping->host;
3281         int ret;
3282 
3283         inode_lock(inode);
3284         switch (whence) {
3285         case SEEK_END:
3286         case SEEK_CUR:
3287                 offset = generic_file_llseek(file, offset, whence);
3288                 goto out;
3289         case SEEK_DATA:
3290         case SEEK_HOLE:
3291                 if (offset >= i_size_read(inode)) {
3292                         inode_unlock(inode);
3293                         return -ENXIO;
3294                 }
3295 
3296                 ret = find_desired_extent(inode, &offset, whence);
3297                 if (ret) {
3298                         inode_unlock(inode);
3299                         return ret;
3300                 }
3301         }
3302 
3303         offset = vfs_setpos(file, offset, inode->i_sb->s_maxbytes);
3304 out:
3305         inode_unlock(inode);
3306         return offset;
3307 }
3308 
3309 static int btrfs_file_open(struct inode *inode, struct file *filp)
3310 {
3311         filp->f_mode |= FMODE_NOWAIT;
3312         return generic_file_open(inode, filp);
3313 }
3314 
3315 const struct file_operations btrfs_file_operations = {
3316         .llseek         = btrfs_file_llseek,
3317         .read_iter      = generic_file_read_iter,
3318         .splice_read    = generic_file_splice_read,
3319         .write_iter     = btrfs_file_write_iter,
3320         .mmap           = btrfs_file_mmap,
3321         .open           = btrfs_file_open,
3322         .release        = btrfs_release_file,
3323         .fsync          = btrfs_sync_file,
3324         .fallocate      = btrfs_fallocate,
3325         .unlocked_ioctl = btrfs_ioctl,
3326 #ifdef CONFIG_COMPAT
3327         .compat_ioctl   = btrfs_compat_ioctl,
3328 #endif
3329         .remap_file_range = btrfs_remap_file_range,
3330 };
3331 
3332 void __cold btrfs_auto_defrag_exit(void)
3333 {
3334         kmem_cache_destroy(btrfs_inode_defrag_cachep);
3335 }
3336 
3337 int __init btrfs_auto_defrag_init(void)
3338 {
3339         btrfs_inode_defrag_cachep = kmem_cache_create("btrfs_inode_defrag",
3340                                         sizeof(struct inode_defrag), 0,
3341                                         SLAB_MEM_SPREAD,
3342                                         NULL);
3343         if (!btrfs_inode_defrag_cachep)
3344                 return -ENOMEM;
3345 
3346         return 0;
3347 }
3348 
3349 int btrfs_fdatawrite_range(struct inode *inode, loff_t start, loff_t end)
3350 {
3351         int ret;
3352 
3353         /*
3354          * So with compression we will find and lock a dirty page and clear the
3355          * first one as dirty, setup an async extent, and immediately return
3356          * with the entire range locked but with nobody actually marked with
3357          * writeback.  So we can't just filemap_write_and_wait_range() and
3358          * expect it to work since it will just kick off a thread to do the
3359          * actual work.  So we need to call filemap_fdatawrite_range _again_
3360          * since it will wait on the page lock, which won't be unlocked until
3361          * after the pages have been marked as writeback and so we're good to go
3362          * from there.  We have to do this otherwise we'll miss the ordered
3363          * extents and that results in badness.  Please Josef, do not think you
3364          * know better and pull this out at some point in the future, it is
3365          * right and you are wrong.
3366          */
3367         ret = filemap_fdatawrite_range(inode->i_mapping, start, end);
3368         if (!ret && test_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,
3369                              &BTRFS_I(inode)->runtime_flags))
3370                 ret = filemap_fdatawrite_range(inode->i_mapping, start, end);
3371 
3372         return ret;
3373 }
3374 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp