| blob | 098bb8f690c992e1ebd01270f49ff2d37e6658bd |
1 /*
2 * Copyright (C) 2007 Oracle. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public
6 * License v2 as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public
14 * License along with this program; if not, write to the
15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16 * Boston, MA 021110-1307, USA.
17 */
19 #include <linux/fs.h>
20 #include <linux/pagemap.h>
21 #include <linux/highmem.h>
22 #include <linux/time.h>
23 #include <linux/init.h>
24 #include <linux/string.h>
25 #include <linux/backing-dev.h>
26 #include <linux/mpage.h>
27 #include <linux/falloc.h>
28 #include <linux/swap.h>
29 #include <linux/writeback.h>
30 #include <linux/statfs.h>
31 #include <linux/compat.h>
32 #include <linux/slab.h>
33 #include <linux/btrfs.h>
34 #include <linux/uio.h>
46 /*
47 * when auto defrag is enabled we
48 * queue up these defrag structs to remember which
49 * inodes need defragging passes
50 */
53 /* objectid */
54 u64 ino;
55 /*
56 * transid where the defrag was added, we search for
57 * extents newer than this
58 */
59 u64 transid;
61 /* root objectid */
62 u64 root;
64 /* last offset we were able to defrag */
65 u64 last_offset;
67 /* if we've wrapped around back to zero once already */
69 };
73 {
82 else
84 }
86 /* pop a record for an inode into the defrag tree. The lock
87 * must be held already
88 *
89 * If you're inserting a record for an older transid than an
90 * existing record, the transid already in the tree is lowered
91 *
92 * If an existing record is found the defrag item you
93 * pass in is freed
94 */
97 {
115 /* if we're reinserting an entry for
116 * an old defrag run, make sure to
117 * lower the transid of our existing record
118 */
124 }
125 }
130 }
133 {
141 }
143 /*
144 * insert a defrag record for this inode if auto defrag is
145 * enabled
146 */
149 {
152 u64 transid;
163 else
176 /*
177 * If we set IN_DEFRAG flag and evict the inode from memory,
178 * and then re-read this inode, this new inode doesn't have
179 * IN_DEFRAG flag. At the case, we may find the existed defrag.
180 */
186 }
189 }
191 /*
192 * Requeue the defrag object. If there is a defrag object that points to
193 * the same inode in the tree, we will merge them together (by
194 * __btrfs_add_inode_defrag()) and free the one that we want to requeue.
195 */
198 {
205 /*
206 * Here we don't check the IN_DEFRAG flag, because we need merge
207 * them together.
208 */
215 out:
217 }
219 /*
220 * pick the defragable inode that we want, if it doesn't exist, we will get
221 * the next one.
222 */
225 {
246 else
248 }
254 else
256 }
257 out:
262 }
265 {
279 }
281 }
283 #define BTRFS_DEFRAG_BATCH 1024
287 {
296 /* get the inode */
307 }
316 }
319 /* do a chunk of defrag */
327 BTRFS_DEFRAG_BATCH);
329 /*
330 * if we filled the whole defrag batch, there
331 * must be more work to do. Queue this defrag
332 * again
333 */
338 /*
339 * we didn't fill our defrag batch, but
340 * we didn't start at zero. Make sure we loop
341 * around to the start of the file.
342 */
348 }
352 cleanup:
356 }
358 /*
359 * run through the list of inodes in the FS that need
360 * defragging
361 */
363 {
370 /* Pause the auto defragger. */
378 /* find an inode to defrag */
380 first_ino);
388 }
389 }
395 }
398 /*
399 * during unmount, we use the transaction_wait queue to
400 * wait for the defragger to stop
401 */
404 }
406 /* simple helper to fault in pages and copy. This should go away
407 * and be replaced with calls into generic code.
408 */
412 {
422 /*
423 * Copy data from userspace to the current page
424 */
427 /* Flush processor's dcache for this page */
430 /*
431 * if we get a partial write, we can end up with
432 * partially up to date pages. These add
433 * a lot of complexity, so make sure they don't
434 * happen by forcing this copy to be retried.
435 *
436 * The rest of the btrfs_file_write code will fall
437 * back to page at a time copies after we return 0.
438 */
446 /* Return to btrfs_file_write_iter to fault page */
453 pg++;
455 }
456 }
458 }
460 /*
461 * unlocks pages after btrfs_file_write is done with them
462 */
464 {
467 /* page checked is some magic around finding pages that
468 * have been modified without going through btrfs_set_page_dirty
469 * clear it here. There should be no need to mark the pages
470 * accessed as prepare_pages should have marked them accessed
471 * in prepare_pages via find_or_create_page()
472 */
476 }
477 }
479 /*
480 * after copy_from_user, pages need to be dirtied and we need to make
481 * sure holes are created between the current EOF and the start of
482 * any next extents (if required).
483 *
484 * this also makes the decision about creating an inline extent vs
485 * doing real data extents, marking pages dirty and delalloc as required.
486 */
491 {
494 u64 num_bytes;
495 u64 start_pos;
496 u64 end_of_last_block;
505 cached);
514 }
516 /*
517 * we've only changed i_size in ram, and we haven't updated
518 * the disk i_size. There is no need to log the inode
519 * at this time.
520 */
524 }
526 /*
527 * this drops all the extents in the cache that intersect the range
528 * [start, end]. Existing extents are split as required.
529 */
532 {
538 u64 gen;
549 }
566 }
574 }
581 }
599 else
610 }
620 }
645 }
652 }
656 modified);
659 modified);
661 }
664 }
665 next:
670 /* once for us */
672 /* once for the tree*/
674 }
679 }
681 /*
682 * this is very complex, but the basic idea is to drop all extents
683 * in the range start - end. hint_block is filled in with a block number
684 * that would be a good hint to the block allocator for this file.
685 *
686 * If an extent intersects the range but is not entirely inside the range
687 * it is either truncated or split. Anything entirely inside the range
688 * is deleted from the tree.
689 */
695 u32 extent_item_size,
697 {
738 }
740 leafs_visited++;
741 next_slot:
751 }
752 leafs_visited++;
755 }
766 }
786 /* can't happen */
788 }
790 /*
791 * Don't skip extent items representing 0 byte lengths. They
792 * used to be created (bug) if while punching holes we hit
793 * -ENOSPC condition. So if we find one here, just ensure we
794 * delete it, otherwise we would insert a new file extent item
795 * with the same key (offset) as that 0 bytes length file
796 * extent item in the call to setup_items_for_insert() later
797 * in this function.
798 */
805 }
813 }
815 /*
816 * | - range to drop - |
817 * | -------- extent -------- |
818 */
824 }
833 }
859 }
861 }
862 /*
863 * | ---- range to drop ----- |
864 * | -------- extent -------- |
865 */
870 }
884 }
887 /*
888 * | ---- range to drop ----- |
889 * | -------- extent -------- |
890 */
896 }
908 }
910 /*
911 * | ---- range to drop ----- |
912 * | ------ extent ------ |
913 */
915 delete_extent_item:
921 del_nr++;
922 }
935 extent_offset);
939 }
947 }
950 del_nr);
954 }
961 }
964 }
967 /*
968 * Set path->slots[0] to first slot, so that after the delete
969 * if items are move off from our leaf to its immediate left or
970 * right neighbor leafs, we end up with a correct and adjusted
971 * path->slots[0] for our insertion (if replace_extent != 0).
972 */
977 }
980 /*
981 * If btrfs_del_items() was called, it might have deleted a leaf, in
982 * which case it unlocked our path, so check path->locks[0] matches a
983 * write lock.
984 */
1000 }
1003 extent_item_size,
1007 }
1014 }
1019 {
1030 }
1035 {
1038 u64 extent_end;
1063 }
1065 /*
1066 * Mark extent in the range start - end as written.
1067 *
1068 * This changes extent type from 'pre-allocated' to 'regular'. If only
1069 * part of extent is marked as written, the extent will be split into
1070 * two or three.
1071 */
1074 {
1081 u64 bytenr;
1082 u64 num_bytes;
1083 u64 extent_end;
1084 u64 orig_offset;
1085 u64 other_start;
1086 u64 other_end;
1087 u64 split;
1097 again:
1116 BTRFS_FILE_EXTENT_PREALLOC);
1149 }
1150 }
1178 }
1179 }
1190 }
1194 }
1223 }
1225 }
1235 }
1238 del_nr++;
1243 }
1252 }
1255 del_nr++;
1260 }
1265 BTRFS_FILE_EXTENT_REG);
1272 BTRFS_FILE_EXTENT_REG);
1282 }
1283 }
1284 out:
1287 }
1289 /*
1290 * on error we return an unlocked page and the error value
1291 * on success we return a locked page and 0
1292 */
1296 {
1308 }
1312 }
1313 }
1315 }
1317 /*
1318 * this just gets pages into the page cache and locks them down.
1319 */
1323 {
1331 again:
1338 }
1342 force_uptodate);
1351 }
1354 }
1356 }
1359 fail:
1363 faili--;
1364 }
1367 }
1369 /*
1370 * This function locks the extent and properly waits for data=ordered extents
1371 * to finish before allowing the pages to be modified if need.
1372 *
1373 * The return value:
1374 * 1 - the extent is locked
1375 * 0 - the extent is not locked, and everything is OK
1376 * -EAGAIN - need re-prepare the pages
1377 * the other < 0 number - Something wrong happens
1378 */
1384 {
1385 u64 start_pos;
1386 u64 last_pos;
1408 }
1412 }
1423 }
1430 }
1433 }
1437 {
1441 u64 num_bytes;
1457 }
1461 }
1471 }
1476 }
1480 loff_t pos)
1481 {
1487 u64 lockstart;
1488 u64 lockend;
1508 offset);
1510 PAGE_CACHE_SIZE);
1517 /*
1518 * Fault pages before locking them in prepare_pages
1519 * to avoid recursive lock
1520 */
1524 }
1529 BTRFS_INODE_PREALLOC)) {
1534 /*
1535 * For nodata cow case, no need to reserve
1536 * data space.
1537 */
1539 /*
1540 * our prealloc extent may be smaller than
1541 * write_bytes, so scale down.
1542 */
1544 PAGE_CACHE_SIZE);
1547 }
1548 }
1553 reserve_metadata:
1558 write_bytes);
1559 else
1562 }
1566 again:
1567 /*
1568 * This is going to setup the pages array with the number of
1569 * pages we want, so we don't really need to worry about the
1570 * contents of pages from loop to loop
1571 */
1574 force_page_uptodate);
1588 }
1592 /*
1593 * if we have trouble faulting in the pages, fall
1594 * back to one page at a time
1595 */
1605 PAGE_CACHE_SIZE);
1606 }
1608 /*
1609 * If we had a short copy we need to release the excess delaloc
1610 * bytes we reserved. We need to increment outstanding_extents
1611 * because btrfs_delalloc_release_space will decrement it, but
1612 * we still have an outstanding extent for the chunk we actually
1613 * managed to copy.
1614 */
1617 PAGE_CACHE_SHIFT;
1622 }
1625 release_bytes);
1627 u64 __pos;
1632 release_bytes);
1633 }
1634 }
1641 NULL);
1645 GFP_NOFS);
1649 }
1664 }
1676 }
1686 }
1687 }
1690 }
1694 loff_t pos)
1695 {
1698 ssize_t written;
1699 ssize_t written_buffered;
1700 loff_t endbyte;
1713 }
1714 /*
1715 * Ensure all data is persisted. We want the next direct IO read to be
1716 * able to read what was just written.
1717 */
1729 out:
1731 }
1734 {
1749 }
1753 {
1757 u64 start_pos;
1758 u64 end_pos;
1761 ssize_t err;
1762 loff_t pos;
1770 }
1777 }
1779 /*
1780 * If BTRFS flips readonly due to some impossible error
1781 * (fs_info->fs_state now has BTRFS_SUPER_FLAG_ERROR),
1782 * although we have opened a file as writable, we have
1783 * to stop this write operation to ensure FS consistency.
1784 */
1789 }
1791 /*
1792 * We reserve space for updating the inode when we reserve space for the
1793 * extent we are going to write, so we will enospc out there. We don't
1794 * need to start yet another transaction to update the inode as we will
1795 * update the inode when we finish writing whatever data we write.
1796 */
1803 /* Expand hole size to cover write data, preventing empty gap */
1809 }
1810 }
1821 }
1825 /*
1826 * We also have to set last_sub_trans to the current log transid,
1827 * otherwise subsequent syncs to a file that's been synced in this
1828 * transaction will appear to have already occured.
1829 */
1837 }
1841 out:
1844 }
1847 {
1850 /*
1851 * ordered_data_close is set by settattr when we are about to truncate
1852 * a file from a non-zero size to a zero size. This tries to
1853 * flush down new bytes that may have been written if the
1854 * application were using truncate to replace a file in place.
1855 */
1860 }
1863 {
1871 }
1873 /*
1874 * fsync call for both files and directories. This logs the inode into
1875 * the tree log instead of forcing full commits whenever possible.
1876 *
1877 * It needs to call filemap_fdatawait so that all ordered extent updates are
1878 * in the metadata btree are up to date for copying to the log.
1879 *
1880 * It drops the inode mutex before doing the tree log commit. This is an
1881 * important optimization for directories because holding the mutex prevents
1882 * new operations on the dir while we write to disk.
1883 */
1885 {
1893 u64 len;
1895 /*
1896 * The range length can be represented by u64, we have to do the typecasts
1897 * to avoid signed overflow if it's [0, LLONG_MAX] eg. from fsync()
1898 */
1902 /*
1903 * We write the dirty pages in the range and wait until they complete
1904 * out of the ->i_mutex. If so, we can flush the dirty pages by
1905 * multi-task, and make the performance up. See
1906 * btrfs_wait_ordered_range for an explanation of the ASYNC check.
1907 */
1916 /*
1917 * We might have have had more pages made dirty after calling
1918 * start_ordered_ops and before acquiring the inode's i_mutex.
1919 */
1921 /*
1922 * For a full sync, we need to make sure any ordered operations
1923 * start and finish before we start logging the inode, so that
1924 * all extents are persisted and the respective file extent
1925 * items are in the fs/subvol btree.
1926 */
1929 /*
1930 * Start any new ordered operations before starting to log the
1931 * inode. We will wait for them to finish in btrfs_sync_log().
1932 *
1933 * Right before acquiring the inode's mutex, we might have new
1934 * writes dirtying pages, which won't immediately start the
1935 * respective ordered operations - that is done through the
1936 * fill_delalloc callbacks invoked from the writepage and
1937 * writepages address space operations. So make sure we start
1938 * all ordered operations before starting to log our inode. Not
1939 * doing this means that while logging the inode, writeback
1940 * could start and invoke writepage/writepages, which would call
1941 * the fill_delalloc callbacks (cow_file_range,
1942 * submit_compressed_extents). These callbacks add first an
1943 * extent map to the modified list of extents and then create
1944 * the respective ordered operation, which means in
1945 * tree-log.c:btrfs_log_inode() we might capture all existing
1946 * ordered operations (with btrfs_get_logged_extents()) before
1947 * the fill_delalloc callback adds its ordered operation, and by
1948 * the time we visit the modified list of extent maps (with
1949 * btrfs_log_changed_extents()), we see and process the extent
1950 * map they created. We then use the extent map to construct a
1951 * file extent item for logging without waiting for the
1952 * respective ordered operation to finish - this file extent
1953 * item points to a disk location that might not have yet been
1954 * written to, containing random data - so after a crash a log
1955 * replay will make our inode have file extent items that point
1956 * to disk locations containing invalid data, as we returned
1957 * success to userspace without waiting for the respective
1958 * ordered operation to finish, because it wasn't captured by
1959 * btrfs_get_logged_extents().
1960 */
1962 }
1966 }
1969 /*
1970 * If the last transaction that changed this file was before the current
1971 * transaction and we have the full sync flag set in our inode, we can
1972 * bail out now without any syncing.
1973 *
1974 * Note that we can't bail out if the full sync flag isn't set. This is
1975 * because when the full sync flag is set we start all ordered extents
1976 * and wait for them to fully complete - when they complete they update
1977 * the inode's last_trans field through:
1978 *
1979 * btrfs_finish_ordered_io() ->
1980 * btrfs_update_inode_fallback() ->
1981 * btrfs_update_inode() ->
1982 * btrfs_set_inode_last_trans()
1983 *
1984 * So we are sure that last_trans is up to date and can do this check to
1985 * bail out safely. For the fast path, when the full sync flag is not
1986 * set in our inode, we can not do it because we start only our ordered
1987 * extents and don't wait for them to complete (that is when
1988 * btrfs_finish_ordered_io runs), so here at this point their last_trans
1989 * value might be less than or equals to fs_info->last_trans_committed,
1990 * and setting a speculative last_trans for an inode when a buffered
1991 * write is made (such as fs_info->generation + 1 for example) would not
1992 * be reliable since after setting the value and before fsync is called
1993 * any number of transactions can start and commit (transaction kthread
1994 * commits the current transaction periodically), and a transaction
1995 * commit does not start nor waits for ordered extents to complete.
1996 */
2003 /*
2004 * We'v had everything committed since the last time we were
2005 * modified so clear this flag in case it was set for whatever
2006 * reason, it's no longer relevant.
2007 */
2012 }
2014 /*
2015 * ok we haven't committed the transaction yet, lets do a commit
2016 */
2020 /*
2021 * We use start here because we will need to wait on the IO to complete
2022 * in btrfs_sync_log, which could require joining a transaction (for
2023 * example checking cross references in the nocow path). If we use join
2024 * here we could get into a situation where we're waiting on IO to
2025 * happen that is blocked on a transaction trying to commit. With start
2026 * we inc the extwriter counter, so we wait for all extwriters to exit
2027 * before we start blocking join'ers. This comment is to keep somebody
2028 * from thinking they are super smart and changing this to
2029 * btrfs_join_transaction *cough*Josef*cough*.
2030 */
2036 }
2043 /* Fallthrough and commit/free transaction. */
2045 }
2047 /* we've logged all the items and now have a consistent
2048 * version of the file in the log. It is possible that
2049 * someone will come in and modify the file, but that's
2050 * fine because the log is consistent on disk, and we
2051 * have references to all of the file's extents
2052 *
2053 * It is possible that someone will come in and log the
2054 * file again, but that will end up using the synchronization
2055 * inside btrfs_sync_log to keep things safe.
2056 */
2059 /*
2060 * If any of the ordered extents had an error, just return it to user
2061 * space, so that the application knows some writes didn't succeed and
2062 * can take proper action (retry for e.g.). Blindly committing the
2063 * transaction in this case, would fool userspace that everything was
2064 * successful. And we also want to make sure our log doesn't contain
2065 * file extent items pointing to extents that weren't fully written to -
2066 * just like in the non fast fsync path, where we check for the ordered
2067 * operation's error flag before writing to the log tree and return -EIO
2068 * if any of them had this flag set (btrfs_wait_ordered_range) -
2069 * therefore we need to check for errors in the ordered operations,
2070 * which are indicated by ctx.io_err.
2071 */
2076 }
2084 }
2085 }
2091 }
2092 }
2096 }
2097 out:
2099 }
2105 };
2108 {
2118 }
2122 {
2147 }
2151 {
2174 u64 num_bytes;
2186 }
2189 u64 num_bytes;
2196 offset;
2202 }
2211 out:
2242 }
2245 }
2247 /*
2248 * Find a hole extent on given inode and change start/len to the end of hole
2249 * extent.(hole/vacuum extent whose em->start <= start &&
2250 * em->start + em->len > start)
2251 * When a hole extent is found, return 1 and modify start/len.
2252 */
2254 {
2262 else
2265 }
2267 /* Hole or vacuum extent(only exists in no-hole mode) */
2273 }
2276 }
2279 {
2285 u64 lockstart;
2286 u64 lockend;
2287 u64 tail_start;
2288 u64 tail_len;
2290 u64 cur_offset;
2292 u64 drop_end;
2298 u64 ino_size;
2312 /* Already in a large hole */
2315 }
2323 /*
2324 * We needn't truncate any page which is beyond the end of the file
2325 * because we are sure there is no data there.
2326 */
2327 /*
2328 * Only do this if we are in the same page and we aren't doing the
2329 * entire page.
2330 */
2337 }
2339 }
2341 /* zero back part of the first page */
2348 }
2349 }
2351 /* Check the aligned pages after the first unaligned page,
2352 * if offset != orig_start, which means the first unaligned page
2353 * including serveral following pages are already in holes,
2354 * the extra check can be skipped */
2356 /* after truncate page, check hole again */
2365 }
2367 }
2369 /* Check the tail unaligned part is in a hole */
2377 /* zero the front end of the last page */
2384 }
2385 }
2386 }
2391 }
2402 /*
2403 * We need to make sure we have no ordered extents in this range
2404 * and nobody raced in and read a page in this range, if we did
2405 * we need to try again.
2406 */
2414 }
2424 }
2425 }
2431 }
2437 }
2441 /*
2442 * 1 - update the inode
2443 * 1 - removing the extents in the range
2444 * 1 - adding the hole extent if no_holes isn't set
2445 */
2451 }
2454 min_size);
2471 drop_end);
2475 }
2476 }
2484 }
2494 }
2507 }
2508 }
2513 }
2516 /*
2517 * If we are using the NO_HOLES feature we might have had already an
2518 * hole that overlaps a part of the region [lockstart, lockend] and
2519 * ends at (or beyond) lockend. Since we have no file extent items to
2520 * represent holes, drop_end can be less than lockend and so we must
2521 * make sure we have an extent map representing the existing hole (the
2522 * call to __btrfs_drop_extents() might have dropped the existing extent
2523 * map representing the existing hole), otherwise the fast fsync path
2524 * will not record the existence of the hole region
2525 * [existing_hole_start, lockend].
2526 */
2529 /*
2530 * Don't insert file hole extent item if it's for a range beyond eof
2531 * (because it's useless) or if it represents a 0 bytes range (when
2532 * cur_offset == drop_end).
2533 */
2539 }
2540 }
2542 out_trans:
2554 out_free:
2557 out:
2560 out_only_mutex:
2562 /*
2563 * If we only end up zeroing part of a page, we still need to
2564 * update the inode item, so that all the time fields are
2565 * updated as well as the necessary btrfs inode in memory fields
2566 * for detecting, at fsync time, if the inode isn't yet in the
2567 * log tree or it's there but not up to date.
2568 */
2575 }
2576 }
2581 }
2583 /* Helper structure to record which range is already reserved */
2586 u64 start;
2587 u64 len;
2588 };
2590 /*
2591 * Helper function to add falloc range
2592 *
2593 * Caller should have locked the larger range of extent containing
2594 * [start, len)
2595 */
2597 {
2604 /*
2605 * As fallocate iterate by bytenr order, we only need to check
2606 * the last range.
2607 */
2612 }
2613 insert:
2621 }
2625 {
2631 u64 cur_offset;
2632 u64 last_byte;
2633 u64 alloc_start;
2634 u64 alloc_end;
2636 u64 locked_end;
2645 /* Make sure we aren't being give some crap mode */
2652 /*
2653 * Only trigger disk allocation, don't trigger qgroup reserve
2654 *
2655 * For qgroup space, it will be checked later.
2656 */
2666 /*
2667 * TODO: Move these two operations after we have checked
2668 * accurate reserved space, or fallocate can still fail but
2669 * with page truncated or size expanded.
2670 *
2671 * But that's a minor problem and won't do much harm BTW.
2672 */
2675 alloc_start);
2679 /*
2680 * If we are fallocating from the end of the file onward we
2681 * need to zero out the end of the page if i_size lands in the
2682 * middle of a page.
2683 */
2687 }
2689 /*
2690 * wait for ordered IO before we have any locks. We'll loop again
2691 * below with the locks held.
2692 */
2702 /* the extent lock is ordered inside the running
2703 * transaction
2704 */
2716 /*
2717 * we can't wait on the range with the transaction
2718 * running or with the extent lock held
2719 */
2728 }
2729 }
2731 /* First, check if we exceed the qgroup limit */
2740 else
2743 }
2755 }
2760 }
2765 }
2767 /*
2768 * If ret is still 0, means we're OK to fallocate.
2769 * Or just cleanup the list and exit.
2770 */
2779 }
2788 /*
2789 * We didn't need to allocate any more space, but we
2790 * still extended the size of the file so we need to
2791 * update i_size and the inode item.
2792 */
2803 else
2805 }
2806 }
2807 out_unlock:
2810 out:
2811 /*
2812 * As we waited the extent range, the data_rsv_map must be empty
2813 * in the range, as written data range will be released from it.
2814 * And for prealloacted extent, it will also be released when
2815 * its metadata is written.
2816 * So this is completely used as cleanup.
2817 */
2820 /* Let go of our reservation. */
2824 }
2827 {
2831 u64 lockstart;
2832 u64 lockend;
2833 u64 start;
2834 u64 len;
2840 /*
2841 * *offset can be negative, in this case we start finding DATA/HOLE from
2842 * the very start of the file.
2843 */
2850 lockend--;
2862 }
2877 }
2882 else
2884 }
2888 }
2891 {
2906 }
2912 }
2913 }
2916 out:
2919 }
2932 #ifdef CONFIG_COMPAT
2934 #endif
2938 };
2941 {
2944 }
2947 {
2951 NULL);
2956 }
2959 {
2962 /*
2963 * So with compression we will find and lock a dirty page and clear the
2964 * first one as dirty, setup an async extent, and immediately return
2965 * with the entire range locked but with nobody actually marked with
2966 * writeback. So we can't just filemap_write_and_wait_range() and
2967 * expect it to work since it will just kick off a thread to do the
2968 * actual work. So we need to call filemap_fdatawrite_range _again_
2969 * since it will wait on the page lock, which won't be unlocked until
2970 * after the pages have been marked as writeback and so we're good to go
2971 * from there. We have to do this otherwise we'll miss the ordered
2972 * extents and that results in badness. Please Josef, do not think you
2973 * know better and pull this out at some point in the future, it is
2974 * right and you are wrong.
2975 */
2982 }