| blob | a16da274c9aad052ff24d9f2139c8511e15a9445 |
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (C) 2007 Oracle. All rights reserved.
4 */
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>
32 /*
33 * when auto defrag is enabled we
34 * queue up these defrag structs to remember which
35 * inodes need defragging passes
36 */
39 /* objectid */
40 u64 ino;
41 /*
42 * transid where the defrag was added, we search for
43 * extents newer than this
44 */
45 u64 transid;
47 /* root objectid */
48 u64 root;
50 /* last offset we were able to defrag */
51 u64 last_offset;
53 /* if we've wrapped around back to zero once already */
55 };
59 {
68 else
70 }
72 /* pop a record for an inode into the defrag tree. The lock
73 * must be held already
74 *
75 * If you're inserting a record for an older transid than an
76 * existing record, the transid already in the tree is lowered
77 *
78 * If an existing record is found the defrag item you
79 * pass in is freed
80 */
83 {
101 /* if we're reinserting an entry for
102 * an old defrag run, make sure to
103 * lower the transid of our existing record
104 */
110 }
111 }
116 }
119 {
127 }
129 /*
130 * insert a defrag record for this inode if auto defrag is
131 * enabled
132 */
135 {
139 u64 transid;
150 else
163 /*
164 * If we set IN_DEFRAG flag and evict the inode from memory,
165 * and then re-read this inode, this new inode doesn't have
166 * IN_DEFRAG flag. At the case, we may find the existed defrag.
167 */
173 }
176 }
178 /*
179 * Requeue the defrag object. If there is a defrag object that points to
180 * the same inode in the tree, we will merge them together (by
181 * __btrfs_add_inode_defrag()) and free the one that we want to requeue.
182 */
185 {
192 /*
193 * Here we don't check the IN_DEFRAG flag, because we need merge
194 * them together.
195 */
202 out:
204 }
206 /*
207 * pick the defragable inode that we want, if it doesn't exist, we will get
208 * the next one.
209 */
212 {
233 else
235 }
241 else
243 }
244 out:
249 }
252 {
266 }
268 }
270 #define BTRFS_DEFRAG_BATCH 1024
274 {
283 /* get the inode */
294 }
303 }
306 /* do a chunk of defrag */
314 BTRFS_DEFRAG_BATCH);
316 /*
317 * if we filled the whole defrag batch, there
318 * must be more work to do. Queue this defrag
319 * again
320 */
325 /*
326 * we didn't fill our defrag batch, but
327 * we didn't start at zero. Make sure we loop
328 * around to the start of the file.
329 */
335 }
339 cleanup:
343 }
345 /*
346 * run through the list of inodes in the FS that need
347 * defragging
348 */
350 {
357 /* Pause the auto defragger. */
365 /* find an inode to defrag */
367 first_ino);
375 }
376 }
382 }
385 /*
386 * during unmount, we use the transaction_wait queue to
387 * wait for the defragger to stop
388 */
391 }
393 /* simple helper to fault in pages and copy. This should go away
394 * and be replaced with calls into generic code.
395 */
399 {
409 /*
410 * Copy data from userspace to the current page
411 */
414 /* Flush processor's dcache for this page */
417 /*
418 * if we get a partial write, we can end up with
419 * partially up to date pages. These add
420 * a lot of complexity, so make sure they don't
421 * happen by forcing this copy to be retried.
422 *
423 * The rest of the btrfs_file_write code will fall
424 * back to page at a time copies after we return 0.
425 */
433 /* Return to btrfs_file_write_iter to fault page */
440 pg++;
442 }
443 }
445 }
447 /*
448 * unlocks pages after btrfs_file_write is done with them
449 */
451 {
454 /* page checked is some magic around finding pages that
455 * have been modified without going through btrfs_set_page_dirty
456 * clear it here. There should be no need to mark the pages
457 * accessed as prepare_pages should have marked them accessed
458 * in prepare_pages via find_or_create_page()
459 */
463 }
464 }
470 {
477 u64 em_len;
495 EXTENT_DELALLOC_NEW,
497 next:
502 }
504 }
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 */
517 {
521 u64 num_bytes;
522 u64 start_pos;
523 u64 end_of_last_block;
534 /*
535 * The pages may have already been dirty, clear out old accounting so
536 * we can set things up properly
537 */
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 */
553 start_pos,
557 }
558 }
570 }
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 */
580 }
582 /*
583 * this drops all the extents in the cache that intersect the range
584 * [start, end]. Existing extents are split as required.
585 */
588 {
594 u64 gen;
605 }
622 }
630 }
637 }
655 else
666 }
675 }
699 }
706 }
710 modified);
713 modified);
715 }
718 }
719 next:
724 /* once for us */
726 /* once for the tree*/
728 }
733 }
735 /*
736 * this is very complex, but the basic idea is to drop all extents
737 * in the range start - end. hint_block is filled in with a block number
738 * that would be a good hint to the block allocator for this file.
739 *
740 * If an extent intersects the range but is not entirely inside the range
741 * it is either truncated or split. Anything entirely inside the range
742 * is deleted from the tree.
743 */
749 u32 extent_item_size,
751 {
795 }
797 leafs_visited++;
798 next_slot:
808 }
809 leafs_visited++;
812 }
823 }
842 /* can't happen */
844 }
846 /*
847 * Don't skip extent items representing 0 byte lengths. They
848 * used to be created (bug) if while punching holes we hit
849 * -ENOSPC condition. So if we find one here, just ensure we
850 * delete it, otherwise we would insert a new file extent item
851 * with the same key (offset) as that 0 bytes length file
852 * extent item in the call to setup_items_for_insert() later
853 * in this function.
854 */
858 }
863 }
871 }
873 /*
874 * | - range to drop - |
875 * | -------- extent -------- |
876 */
882 }
891 }
912 BTRFS_ADD_DELAYED_REF,
920 }
922 }
923 /*
924 * From here on out we will have actually dropped something, so
925 * last_end can be updated.
926 */
929 /*
930 * | ---- range to drop ----- |
931 * | -------- extent -------- |
932 */
937 }
951 }
954 /*
955 * | ---- range to drop ----- |
956 * | -------- extent -------- |
957 */
963 }
975 }
977 /*
978 * | ---- range to drop ----- |
979 * | ------ extent ------ |
980 */
982 delete_extent_item:
988 del_nr++;
989 }
999 BTRFS_DROP_DELAYED_REF,
1009 }
1017 }
1020 del_nr);
1024 }
1031 }
1034 }
1037 /*
1038 * Set path->slots[0] to first slot, so that after the delete
1039 * if items are move off from our leaf to its immediate left or
1040 * right neighbor leafs, we end up with a correct and adjusted
1041 * path->slots[0] for our insertion (if replace_extent != 0).
1042 */
1047 }
1050 /*
1051 * If btrfs_del_items() was called, it might have deleted a leaf, in
1052 * which case it unlocked our path, so check path->locks[0] matches a
1053 * write lock.
1054 */
1070 }
1073 extent_item_size,
1077 }
1084 }
1089 {
1100 }
1105 {
1108 u64 extent_end;
1133 }
1135 /*
1136 * Mark extent in the range start - end as written.
1137 *
1138 * This changes extent type from 'pre-allocated' to 'regular'. If only
1139 * part of extent is marked as written, the extent will be split into
1140 * two or three.
1141 */
1144 {
1153 u64 bytenr;
1154 u64 num_bytes;
1155 u64 extent_end;
1156 u64 orig_offset;
1157 u64 other_start;
1158 u64 other_end;
1159 u64 split;
1169 again:
1189 }
1196 }
1202 }
1233 }
1234 }
1262 }
1263 }
1274 }
1278 }
1299 orig_offset);
1304 }
1313 }
1316 }
1318 }
1331 }
1334 del_nr++;
1339 }
1340 }
1349 }
1352 del_nr++;
1357 }
1358 }
1363 BTRFS_FILE_EXTENT_REG);
1370 BTRFS_FILE_EXTENT_REG);
1380 }
1381 }
1382 out:
1385 }
1387 /*
1388 * on error we return an unlocked page and the error value
1389 * on success we return a locked page and 0
1390 */
1394 {
1406 }
1410 }
1411 }
1413 }
1415 /*
1416 * this just gets pages into the page cache and locks them down.
1417 */
1421 {
1429 again:
1436 }
1440 force_uptodate);
1449 }
1452 }
1454 }
1457 fail:
1461 faili--;
1462 }
1465 }
1467 /*
1468 * This function locks the extent and properly waits for data=ordered extents
1469 * to finish before allowing the pages to be modified if need.
1470 *
1471 * The return value:
1472 * 1 - the extent is locked
1473 * 0 - the extent is not locked, and everything is OK
1474 * -EAGAIN - need re-prepare the pages
1475 * the other < 0 number - Something wrong happens
1476 */
1483 {
1485 u64 start_pos;
1486 u64 last_pos;
1491 last_pos = start_pos
1499 cached_state);
1510 }
1515 }
1522 }
1524 /*
1525 * It's possible the pages are dirty right now, but we don't want
1526 * to clean them yet because copy_from_user may catch a page fault
1527 * and we might have to fall back to one page at a time. If that
1528 * happens, we'll unlock these pages and we'd have a window where
1529 * reclaim could sneak in and drop the once-dirty page on the floor
1530 * without writing it.
1531 *
1532 * We have the pages locked and the extent range locked, so there's
1533 * no way someone can start IO on any dirty pages in this range.
1534 *
1535 * We'll call btrfs_dirty_pages() later on, and that will flip around
1536 * delalloc bits and dirty the pages as required.
1537 */
1541 }
1544 }
1548 {
1552 u64 num_bytes;
1575 }
1580 }
1584 {
1593 u64 lockstart;
1594 u64 lockend;
1615 offset);
1617 PAGE_SIZE);
1627 /*
1628 * Fault pages before locking them in prepare_pages
1629 * to avoid recursive lock
1630 */
1634 }
1643 write_bytes);
1646 BTRFS_INODE_PREALLOC)) &&
1649 /*
1650 * For nodata cow case, no need to reserve
1651 * data space.
1652 */
1654 /*
1655 * our prealloc extent may be smaller than
1656 * write_bytes, so scale down.
1657 */
1659 PAGE_SIZE);
1661 sector_offset,
1665 }
1666 }
1670 reserve_bytes);
1675 write_bytes);
1676 else
1679 }
1682 again:
1683 /*
1684 * This is going to setup the pages array with the number of
1685 * pages we want, so we don't really need to worry about the
1686 * contents of pages from loop to loop
1687 */
1690 force_page_uptodate);
1693 reserve_bytes);
1695 }
1705 reserve_bytes);
1708 }
1717 /*
1718 * if we have trouble faulting in the pages, fall
1719 * back to one page at a time
1720 */
1731 PAGE_SIZE);
1732 }
1735 /* release everything except the sectors we dirtied */
1742 u64 __pos;
1750 }
1751 }
1760 /*
1761 * If we have not locked the extent range, because the range's
1762 * start offset is >= i_size, we might still have a non-NULL
1763 * cached extent state, acquired while marking the extent range
1764 * as delalloc through btrfs_dirty_pages(). Therefore free any
1765 * possible cached extent state to avoid a memory leak.
1766 */
1770 else
1777 }
1792 }
1804 }
1817 }
1818 }
1822 }
1825 {
1828 loff_t pos;
1829 ssize_t written;
1830 ssize_t written_buffered;
1831 loff_t endbyte;
1844 }
1845 /*
1846 * Ensure all data is persisted. We want the next direct IO read to be
1847 * able to read what was just written.
1848 */
1860 out:
1862 }
1865 {
1880 }
1884 {
1889 u64 start_pos;
1890 u64 end_pos;
1893 ssize_t err;
1894 loff_t pos;
1896 loff_t oldsize;
1908 }
1914 }
1919 /*
1920 * We will allocate space in case nodatacow is not set,
1921 * so bail
1922 */
1924 BTRFS_INODE_PREALLOC)) ||
1928 }
1929 }
1936 }
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 */
1948 }
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 */
1961 /* Expand hole size to cover write data, preventing empty gap */
1968 }
1971 }
1985 }
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 */
2002 out:
2005 }
2008 {
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 */
2026 }
2029 {
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 */
2046 }
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 */
2060 {
2073 /*
2074 * We write the dirty pages in the range and wait until they complete
2075 * out of the ->i_mutex. If so, we can flush the dirty pages by
2076 * multi-task, and make the performance up. See
2077 * btrfs_wait_ordered_range for an explanation of the ASYNC check.
2078 */
2085 /*
2086 * We take the dio_sem here because the tree log stuff can race with
2087 * lockless dio writes and get an extent map logged for an extent we
2088 * never waited on. We need it this high up for lockdep reasons.
2089 */
2094 /*
2095 * If the inode needs a full sync, make sure we use a full range to
2096 * avoid log tree corruption, due to hole detection racing with ordered
2097 * extent completion for adjacent ranges, and assertion failures during
2098 * hole detection. Do this while holding the inode lock, to avoid races
2099 * with other tasks.
2100 */
2105 }
2107 /*
2108 * Before we acquired the inode's lock, someone may have dirtied more
2109 * pages in the target range. We need to make sure that writeback for
2110 * any such pages does not start while we are logging the inode, because
2111 * if it does, any of the following might happen when we are not doing a
2112 * full inode sync:
2113 *
2114 * 1) We log an extent after its writeback finishes but before its
2115 * checksums are added to the csum tree, leading to -EIO errors
2116 * when attempting to read the extent after a log replay.
2117 *
2118 * 2) We can end up logging an extent before its writeback finishes.
2119 * Therefore after the log replay we will have a file extent item
2120 * pointing to an unwritten extent (and no data checksums as well).
2121 *
2122 * So trigger writeback for any eventual new dirty pages and then we
2123 * wait for all ordered extents to complete below.
2124 */
2129 }
2131 /*
2132 * We have to do this here to avoid the priority inversion of waiting on
2133 * IO of a lower priority task while holding a transaction open.
2134 *
2135 * Also, the range length can be represented by u64, we have to do the
2136 * typecasts to avoid signed overflow if it's [0, LLONG_MAX].
2137 */
2143 }
2149 /*
2150 * We've had everything committed since the last time we were
2151 * modified so clear this flag in case it was set for whatever
2152 * reason, it's no longer relevant.
2153 */
2156 /*
2157 * An ordered extent might have started before and completed
2158 * already with io errors, in which case the inode was not
2159 * updated and we end up here. So check the inode's mapping
2160 * for any errors that might have happened since we last
2161 * checked called fsync.
2162 */
2167 }
2169 /*
2170 * We use start here because we will need to wait on the IO to complete
2171 * in btrfs_sync_log, which could require joining a transaction (for
2172 * example checking cross references in the nocow path). If we use join
2173 * here we could get into a situation where we're waiting on IO to
2174 * happen that is blocked on a transaction trying to commit. With start
2175 * we inc the extwriter counter, so we wait for all extwriters to exit
2176 * before we start blocking joiners. This comment is to keep somebody
2177 * from thinking they are super smart and changing this to
2178 * btrfs_join_transaction *cough*Josef*cough*.
2179 */
2186 }
2190 /* Fallthrough and commit/free transaction. */
2192 }
2194 /* we've logged all the items and now have a consistent
2195 * version of the file in the log. It is possible that
2196 * someone will come in and modify the file, but that's
2197 * fine because the log is consistent on disk, and we
2198 * have references to all of the file's extents
2199 *
2200 * It is possible that someone will come in and log the
2201 * file again, but that will end up using the synchronization
2202 * inside btrfs_sync_log to keep things safe.
2203 */
2213 }
2214 }
2218 }
2219 out:
2225 }
2231 };
2234 {
2244 }
2248 {
2273 }
2278 {
2297 /*
2298 * We should have dropped this offset, so if we find it then
2299 * something has gone horribly wrong.
2300 */
2304 }
2308 u64 num_bytes;
2320 }
2323 u64 num_bytes;
2330 offset;
2336 }
2344 out:
2373 }
2376 }
2378 /*
2379 * Find a hole extent on given inode and change start/len to the end of hole
2380 * extent.(hole/vacuum extent whose em->start <= start &&
2381 * em->start + em->len > start)
2382 * When a hole extent is found, return 1 and modify start/len.
2383 */
2385 {
2396 /* Hole or vacuum extent(only exists in no-hole mode) */
2402 }
2405 }
2411 {
2419 cached_state);
2422 /*
2423 * We need to make sure we have no ordered extents in this range
2424 * and nobody raced in and read a page in this range, if we did
2425 * we need to try again.
2426 */
2435 }
2444 }
2446 }
2453 {
2461 u64 ref_offset;
2489 /* If it's a hole, nothing more needs to be done. */
2503 }
2505 /*
2506 * The respective range must have been previously locked, as well as the inode.
2507 * The end offset is inclusive (last byte of the range).
2508 * @clone_info is NULL for fallocate's hole punching and non-NULL for extent
2509 * cloning.
2510 * When cloning, we don't want to end up in a state where we dropped extents
2511 * without inserting a new one, so we must abort the transaction to avoid a
2512 * corruption.
2513 */
2518 {
2526 u64 cur_offset;
2527 u64 drop_end;
2538 }
2542 /*
2543 * 1 - update the inode
2544 * 1 - removing the extents in the range
2545 * 1 - adding the hole extent if no_holes isn't set or if we are cloning
2546 * an extent
2547 */
2550 else
2558 }
2571 /*
2572 * When cloning we want to avoid transaction aborts when
2573 * nothing was done and we are attempting to clone parts
2574 * of inline extents, in such cases -EOPNOTSUPP is
2575 * returned by __btrfs_drop_extents() without having
2576 * changed anything in the file.
2577 */
2581 }
2590 /*
2591 * If we failed then we didn't insert our hole
2592 * entries for the area we dropped, so now the
2593 * fs is corrupted, so we must abort the
2594 * transaction.
2595 */
2598 }
2599 }
2609 }
2613 }
2629 }
2643 }
2644 }
2645 }
2647 /*
2648 * If we were cloning, force the next fsync to be a full one since we
2649 * we replaced (or just dropped in the case of cloning holes when
2650 * NO_HOLES is enabled) extents and extent maps.
2651 * This is for the sake of simplicity, and cloning into files larger
2652 * than 16Mb would force the full fsync any way (when
2653 * try_release_extent_mapping() is invoked during page cache truncation.
2654 */
2663 /*
2664 * If we are using the NO_HOLES feature we might have had already an
2665 * hole that overlaps a part of the region [lockstart, lockend] and
2666 * ends at (or beyond) lockend. Since we have no file extent items to
2667 * represent holes, drop_end can be less than lockend and so we must
2668 * make sure we have an extent map representing the existing hole (the
2669 * call to __btrfs_drop_extents() might have dropped the existing extent
2670 * map representing the existing hole), otherwise the fast fsync path
2671 * will not record the existence of the hole region
2672 * [existing_hole_start, lockend].
2673 */
2676 /*
2677 * Don't insert file hole extent item if it's for a range beyond eof
2678 * (because it's useless) or if it represents a 0 bytes range (when
2679 * cur_offset == drop_end).
2680 */
2685 /* Same comment as above. */
2688 }
2689 }
2696 }
2697 }
2699 out_trans:
2706 else
2708 out_free:
2710 out:
2712 }
2715 {
2721 u64 lockstart;
2722 u64 lockend;
2723 u64 tail_start;
2724 u64 tail_len;
2728 u64 ino_size;
2742 /* Already in a large hole */
2745 }
2752 /*
2753 * We needn't truncate any block which is beyond the end of the file
2754 * because we are sure there is no data there.
2755 */
2756 /*
2757 * Only do this if we are in the same block and we aren't doing the
2758 * entire block.
2759 */
2766 }
2768 }
2770 /* zero back part of the first block */
2777 }
2778 }
2780 /* Check the aligned pages after the first unaligned page,
2781 * if offset != orig_start, which means the first unaligned page
2782 * including several following pages are already in holes,
2783 * the extra check can be skipped */
2785 /* after truncate page, check hole again */
2794 }
2796 }
2798 /* Check the tail unaligned part is in a hole */
2806 /* zero the front end of the last page */
2814 }
2815 }
2816 }
2821 }
2832 }
2847 out:
2850 out_only_mutex:
2852 /*
2853 * If we only end up zeroing part of a page, we still need to
2854 * update the inode item, so that all the time fields are
2855 * updated as well as the necessary btrfs inode in memory fields
2856 * for detecting, at fsync time, if the inode isn't yet in the
2857 * log tree or it's there but not up to date.
2858 */
2874 }
2875 }
2878 }
2880 /* Helper structure to record which range is already reserved */
2883 u64 start;
2884 u64 len;
2885 };
2887 /*
2888 * Helper function to add falloc range
2889 *
2890 * Caller should have locked the larger range of extent containing
2891 * [start, len)
2892 */
2894 {
2901 /*
2902 * As fallocate iterate by bytenr order, we only need to check
2903 * the last range.
2904 */
2909 }
2910 insert:
2918 }
2923 {
2943 }
2946 RANGE_BOUNDARY_WRITTEN_EXTENT,
2947 RANGE_BOUNDARY_PREALLOC_EXTENT,
2948 RANGE_BOUNDARY_HOLE,
2949 };
2952 u64 offset)
2953 {
2967 else
2972 }
2975 loff_t offset,
2976 loff_t len,
2978 {
2997 }
2999 /*
3000 * Avoid hole punching and extent allocation for some cases. More cases
3001 * could be considered, but these are unlikely common and we keep things
3002 * as simple as possible for now. Also, intentionally, if the target
3003 * range contains one or more prealloc extents together with regular
3004 * extents and holes, we drop all the existing extents and allocate a
3005 * new prealloc extent, so that we get a larger contiguous disk extent.
3006 */
3012 /*
3013 * The whole range is already a prealloc extent,
3014 * do nothing except updating the inode's i_size if
3015 * needed.
3016 */
3019 mode);
3021 }
3022 /*
3023 * Part of the range is already a prealloc extent, so operate
3024 * only on the remaining part of the range.
3025 */
3031 }
3037 sectorsize);
3041 }
3046 mode);
3048 }
3055 mode);
3057 }
3062 }
3067 /*
3068 * For unaligned ranges, check the pages at the boundaries, they might
3069 * map to an extent, in which case we need to partially zero them, or
3070 * they might map to a hole, in which case we need our allocation range
3071 * to cover them.
3072 */
3086 }
3087 }
3103 }
3104 }
3106 reserve_space:
3114 bytes_to_reserve);
3132 /* btrfs_prealloc_file_range releases reserved space on error */
3136 }
3137 }
3139 out:
3146 }
3150 {
3157 u64 cur_offset;
3158 u64 last_byte;
3159 u64 alloc_start;
3160 u64 alloc_end;
3162 u64 locked_end;
3172 /* Make sure we aren't being give some crap mode */
3174 FALLOC_FL_ZERO_RANGE))
3180 /*
3181 * Only trigger disk allocation, don't trigger qgroup reserve
3182 *
3183 * For qgroup space, it will be checked later.
3184 */
3190 }
3198 }
3200 /*
3201 * TODO: Move these two operations after we have checked
3202 * accurate reserved space, or fallocate can still fail but
3203 * with page truncated or size expanded.
3204 *
3205 * But that's a minor problem and won't do much harm BTW.
3206 */
3209 alloc_start);
3213 /*
3214 * If we are fallocating from the end of the file onward we
3215 * need to zero out the end of the block if i_size lands in the
3216 * middle of a block.
3217 */
3221 }
3223 /*
3224 * wait for ordered IO before we have any locks. We'll loop again
3225 * below with the locks held.
3226 */
3236 }
3242 /* the extent lock is ordered inside the running
3243 * transaction
3244 */
3256 /*
3257 * we can't wait on the range with the transaction
3258 * running or with the extent lock held
3259 */
3268 }
3269 }
3271 /* First, check if we exceed the qgroup limit */
3279 }
3291 }
3298 }
3300 /*
3301 * Do not need to reserve unwritten extent for this
3302 * range, free reserved data space first, otherwise
3303 * it'll result in false ENOSPC error.
3304 */
3307 }
3310 }
3312 /*
3313 * If ret is still 0, means we're OK to fallocate.
3314 * Or just cleanup the list and exit.
3315 */
3322 else
3328 }
3332 /*
3333 * We didn't need to allocate any more space, but we still extended the
3334 * size of the file so we need to update i_size and the inode item.
3335 */
3337 out_unlock:
3340 out:
3342 /* Let go of our reservation. */
3348 }
3352 {
3357 u64 lockstart;
3358 u64 lockend;
3359 u64 start;
3360 u64 len;
3366 /*
3367 * offset can be negative, in this case we start finding DATA/HOLE from
3368 * the very start of the file.
3369 */
3376 lockend--;
3388 }
3403 }
3412 else
3414 }
3417 }
3420 {
3432 }
3438 }
3441 {
3444 }
3457 #ifdef CONFIG_COMPAT
3459 #endif
3461 };
3464 {
3466 }
3469 {
3472 SLAB_MEM_SPREAD,
3473 NULL);
3478 }
3481 {
3484 /*
3485 * So with compression we will find and lock a dirty page and clear the
3486 * first one as dirty, setup an async extent, and immediately return
3487 * with the entire range locked but with nobody actually marked with
3488 * writeback. So we can't just filemap_write_and_wait_range() and
3489 * expect it to work since it will just kick off a thread to do the
3490 * actual work. So we need to call filemap_fdatawrite_range _again_
3491 * since it will wait on the page lock, which won't be unlocked until
3492 * after the pages have been marked as writeback and so we're good to go
3493 * from there. We have to do this otherwise we'll miss the ordered
3494 * extents and that results in badness. Please Josef, do not think you
3495 * know better and pull this out at some point in the future, it is
3496 * right and you are wrong.
3497 */
3504 }