| blob | 3a14c87d9c92a21997dc4469f8f27f68546cc96a |
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>
47 /*
48 * when auto defrag is enabled we
49 * queue up these defrag structs to remember which
50 * inodes need defragging passes
51 */
54 /* objectid */
55 u64 ino;
56 /*
57 * transid where the defrag was added, we search for
58 * extents newer than this
59 */
60 u64 transid;
62 /* root objectid */
63 u64 root;
65 /* last offset we were able to defrag */
66 u64 last_offset;
68 /* if we've wrapped around back to zero once already */
70 };
74 {
83 else
85 }
87 /* pop a record for an inode into the defrag tree. The lock
88 * must be held already
89 *
90 * If you're inserting a record for an older transid than an
91 * existing record, the transid already in the tree is lowered
92 *
93 * If an existing record is found the defrag item you
94 * pass in is freed
95 */
98 {
116 /* if we're reinserting an entry for
117 * an old defrag run, make sure to
118 * lower the transid of our existing record
119 */
125 }
126 }
131 }
134 {
142 }
144 /*
145 * insert a defrag record for this inode if auto defrag is
146 * enabled
147 */
150 {
153 u64 transid;
164 else
177 /*
178 * If we set IN_DEFRAG flag and evict the inode from memory,
179 * and then re-read this inode, this new inode doesn't have
180 * IN_DEFRAG flag. At the case, we may find the existed defrag.
181 */
187 }
190 }
192 /*
193 * Requeue the defrag object. If there is a defrag object that points to
194 * the same inode in the tree, we will merge them together (by
195 * __btrfs_add_inode_defrag()) and free the one that we want to requeue.
196 */
199 {
206 /*
207 * Here we don't check the IN_DEFRAG flag, because we need merge
208 * them together.
209 */
216 out:
218 }
220 /*
221 * pick the defragable inode that we want, if it doesn't exist, we will get
222 * the next one.
223 */
226 {
247 else
249 }
255 else
257 }
258 out:
263 }
266 {
280 }
282 }
284 #define BTRFS_DEFRAG_BATCH 1024
288 {
297 /* get the inode */
308 }
317 }
320 /* do a chunk of defrag */
328 BTRFS_DEFRAG_BATCH);
330 /*
331 * if we filled the whole defrag batch, there
332 * must be more work to do. Queue this defrag
333 * again
334 */
339 /*
340 * we didn't fill our defrag batch, but
341 * we didn't start at zero. Make sure we loop
342 * around to the start of the file.
343 */
349 }
353 cleanup:
357 }
359 /*
360 * run through the list of inodes in the FS that need
361 * defragging
362 */
364 {
371 /* Pause the auto defragger. */
379 /* find an inode to defrag */
381 first_ino);
389 }
390 }
396 }
399 /*
400 * during unmount, we use the transaction_wait queue to
401 * wait for the defragger to stop
402 */
405 }
407 /* simple helper to fault in pages and copy. This should go away
408 * and be replaced with calls into generic code.
409 */
413 {
423 /*
424 * Copy data from userspace to the current page
425 */
428 /* Flush processor's dcache for this page */
431 /*
432 * if we get a partial write, we can end up with
433 * partially up to date pages. These add
434 * a lot of complexity, so make sure they don't
435 * happen by forcing this copy to be retried.
436 *
437 * The rest of the btrfs_file_write code will fall
438 * back to page at a time copies after we return 0.
439 */
447 /* Return to btrfs_file_write_iter to fault page */
454 pg++;
456 }
457 }
459 }
461 /*
462 * unlocks pages after btrfs_file_write is done with them
463 */
465 {
468 /* page checked is some magic around finding pages that
469 * have been modified without going through btrfs_set_page_dirty
470 * clear it here. There should be no need to mark the pages
471 * accessed as prepare_pages should have marked them accessed
472 * in prepare_pages via find_or_create_page()
473 */
477 }
478 }
480 /*
481 * after copy_from_user, pages need to be dirtied and we need to make
482 * sure holes are created between the current EOF and the start of
483 * any next extents (if required).
484 *
485 * this also makes the decision about creating an inline extent vs
486 * doing real data extents, marking pages dirty and delalloc as required.
487 */
492 {
495 u64 num_bytes;
496 u64 start_pos;
497 u64 end_of_last_block;
515 }
517 /*
518 * we've only changed i_size in ram, and we haven't updated
519 * the disk i_size. There is no need to log the inode
520 * at this time.
521 */
525 }
527 /*
528 * this drops all the extents in the cache that intersect the range
529 * [start, end]. Existing extents are split as required.
530 */
533 {
539 u64 gen;
550 }
567 }
575 }
582 }
600 else
611 }
621 }
646 }
653 }
657 modified);
660 modified);
662 }
665 }
666 next:
671 /* once for us */
673 /* once for the tree*/
675 }
680 }
682 /*
683 * this is very complex, but the basic idea is to drop all extents
684 * in the range start - end. hint_block is filled in with a block number
685 * that would be a good hint to the block allocator for this file.
686 *
687 * If an extent intersects the range but is not entirely inside the range
688 * it is either truncated or split. Anything entirely inside the range
689 * is deleted from the tree.
690 */
696 u32 extent_item_size,
698 {
739 }
741 leafs_visited++;
742 next_slot:
752 }
753 leafs_visited++;
756 }
767 }
787 /* can't happen */
789 }
791 /*
792 * Don't skip extent items representing 0 byte lengths. They
793 * used to be created (bug) if while punching holes we hit
794 * -ENOSPC condition. So if we find one here, just ensure we
795 * delete it, otherwise we would insert a new file extent item
796 * with the same key (offset) as that 0 bytes length file
797 * extent item in the call to setup_items_for_insert() later
798 * in this function.
799 */
806 }
814 }
816 /*
817 * | - range to drop - |
818 * | -------- extent -------- |
819 */
825 }
834 }
860 }
862 }
863 /*
864 * | ---- range to drop ----- |
865 * | -------- extent -------- |
866 */
871 }
885 }
888 /*
889 * | ---- range to drop ----- |
890 * | -------- extent -------- |
891 */
897 }
909 }
911 /*
912 * | ---- range to drop ----- |
913 * | ------ extent ------ |
914 */
916 delete_extent_item:
922 del_nr++;
923 }
936 extent_offset);
940 }
948 }
951 del_nr);
955 }
962 }
965 }
968 /*
969 * Set path->slots[0] to first slot, so that after the delete
970 * if items are move off from our leaf to its immediate left or
971 * right neighbor leafs, we end up with a correct and adjusted
972 * path->slots[0] for our insertion (if replace_extent != 0).
973 */
978 }
981 /*
982 * If btrfs_del_items() was called, it might have deleted a leaf, in
983 * which case it unlocked our path, so check path->locks[0] matches a
984 * write lock.
985 */
1001 }
1004 extent_item_size,
1008 }
1015 }
1020 {
1031 }
1036 {
1039 u64 extent_end;
1064 }
1066 /*
1067 * Mark extent in the range start - end as written.
1068 *
1069 * This changes extent type from 'pre-allocated' to 'regular'. If only
1070 * part of extent is marked as written, the extent will be split into
1071 * two or three.
1072 */
1075 {
1082 u64 bytenr;
1083 u64 num_bytes;
1084 u64 extent_end;
1085 u64 orig_offset;
1086 u64 other_start;
1087 u64 other_end;
1088 u64 split;
1098 again:
1118 }
1125 }
1131 }
1162 }
1163 }
1191 }
1192 }
1203 }
1207 }
1231 }
1240 }
1243 }
1245 }
1255 }
1258 del_nr++;
1265 }
1266 }
1275 }
1278 del_nr++;
1285 }
1286 }
1291 BTRFS_FILE_EXTENT_REG);
1298 BTRFS_FILE_EXTENT_REG);
1308 }
1309 }
1310 out:
1313 }
1315 /*
1316 * on error we return an unlocked page and the error value
1317 * on success we return a locked page and 0
1318 */
1322 {
1334 }
1338 }
1339 }
1341 }
1343 /*
1344 * this just gets pages into the page cache and locks them down.
1345 */
1349 {
1357 again:
1364 }
1368 force_uptodate);
1377 }
1380 }
1382 }
1385 fail:
1389 faili--;
1390 }
1393 }
1395 /*
1396 * This function locks the extent and properly waits for data=ordered extents
1397 * to finish before allowing the pages to be modified if need.
1398 *
1399 * The return value:
1400 * 1 - the extent is locked
1401 * 0 - the extent is not locked, and everything is OK
1402 * -EAGAIN - need re-prepare the pages
1403 * the other < 0 number - Something wrong happens
1404 */
1411 {
1413 u64 start_pos;
1414 u64 last_pos;
1419 last_pos = start_pos
1437 }
1441 }
1452 }
1459 }
1462 }
1466 {
1470 u64 num_bytes;
1486 }
1490 }
1500 }
1505 }
1509 loff_t pos)
1510 {
1516 u64 lockstart;
1517 u64 lockend;
1538 offset);
1540 PAGE_SIZE);
1549 /*
1550 * Fault pages before locking them in prepare_pages
1551 * to avoid recursive lock
1552 */
1556 }
1565 BTRFS_INODE_PREALLOC)) &&
1567 /*
1568 * For nodata cow case, no need to reserve
1569 * data space.
1570 */
1572 /*
1573 * our prealloc extent may be smaller than
1574 * write_bytes, so scale down.
1575 */
1577 PAGE_SIZE);
1579 sector_offset,
1583 }
1584 }
1590 write_bytes);
1591 else
1594 }
1598 again:
1599 /*
1600 * This is going to setup the pages array with the number of
1601 * pages we want, so we don't really need to worry about the
1602 * contents of pages from loop to loop
1603 */
1606 force_page_uptodate);
1620 }
1625 reserve_bytes);
1629 dirty_sectors);
1631 /*
1632 * if we have trouble faulting in the pages, fall
1633 * back to one page at a time
1634 */
1645 PAGE_SIZE);
1646 }
1648 /*
1649 * If we had a short copy we need to release the excess delaloc
1650 * bytes we reserved. We need to increment outstanding_extents
1651 * because btrfs_delalloc_release_space and
1652 * btrfs_delalloc_release_metadata will decrement it, but
1653 * we still have an outstanding extent for the chunk we actually
1654 * managed to copy.
1655 */
1658 /* release everything except the sectors we dirtied */
1666 }
1669 release_bytes);
1671 u64 __pos;
1676 release_bytes);
1677 }
1678 }
1686 NULL);
1690 GFP_NOFS);
1694 }
1708 }
1720 }
1731 release_bytes);
1732 }
1733 }
1736 }
1739 {
1743 ssize_t written;
1744 ssize_t written_buffered;
1745 loff_t endbyte;
1758 }
1759 /*
1760 * Ensure all data is persisted. We want the next direct IO read to be
1761 * able to read what was just written.
1762 */
1774 out:
1776 }
1779 {
1794 }
1798 {
1802 u64 start_pos;
1803 u64 end_pos;
1806 ssize_t err;
1807 loff_t pos;
1809 loff_t oldsize;
1817 }
1824 }
1826 /*
1827 * If BTRFS flips readonly due to some impossible error
1828 * (fs_info->fs_state now has BTRFS_SUPER_FLAG_ERROR),
1829 * although we have opened a file as writable, we have
1830 * to stop this write operation to ensure FS consistency.
1831 */
1836 }
1838 /*
1839 * We reserve space for updating the inode when we reserve space for the
1840 * extent we are going to write, so we will enospc out there. We don't
1841 * need to start yet another transaction to update the inode as we will
1842 * update the inode when we finish writing whatever data we write.
1843 */
1851 /* Expand hole size to cover write data, preventing empty gap */
1857 }
1860 }
1874 }
1878 /*
1879 * We also have to set last_sub_trans to the current log transid,
1880 * otherwise subsequent syncs to a file that's been synced in this
1881 * transaction will appear to have already occurred.
1882 */
1891 out:
1894 }
1897 {
1900 /*
1901 * ordered_data_close is set by settattr when we are about to truncate
1902 * a file from a non-zero size to a zero size. This tries to
1903 * flush down new bytes that may have been written if the
1904 * application were using truncate to replace a file in place.
1905 */
1910 }
1913 {
1921 }
1923 /*
1924 * fsync call for both files and directories. This logs the inode into
1925 * the tree log instead of forcing full commits whenever possible.
1926 *
1927 * It needs to call filemap_fdatawait so that all ordered extent updates are
1928 * in the metadata btree are up to date for copying to the log.
1929 *
1930 * It drops the inode mutex before doing the tree log commit. This is an
1931 * important optimization for directories because holding the mutex prevents
1932 * new operations on the dir while we write to disk.
1933 */
1935 {
1943 u64 len;
1945 /*
1946 * The range length can be represented by u64, we have to do the typecasts
1947 * to avoid signed overflow if it's [0, LLONG_MAX] eg. from fsync()
1948 */
1952 /*
1953 * We write the dirty pages in the range and wait until they complete
1954 * out of the ->i_mutex. If so, we can flush the dirty pages by
1955 * multi-task, and make the performance up. See
1956 * btrfs_wait_ordered_range for an explanation of the ASYNC check.
1957 */
1966 /*
1967 * We might have have had more pages made dirty after calling
1968 * start_ordered_ops and before acquiring the inode's i_mutex.
1969 */
1971 /*
1972 * For a full sync, we need to make sure any ordered operations
1973 * start and finish before we start logging the inode, so that
1974 * all extents are persisted and the respective file extent
1975 * items are in the fs/subvol btree.
1976 */
1979 /*
1980 * Start any new ordered operations before starting to log the
1981 * inode. We will wait for them to finish in btrfs_sync_log().
1982 *
1983 * Right before acquiring the inode's mutex, we might have new
1984 * writes dirtying pages, which won't immediately start the
1985 * respective ordered operations - that is done through the
1986 * fill_delalloc callbacks invoked from the writepage and
1987 * writepages address space operations. So make sure we start
1988 * all ordered operations before starting to log our inode. Not
1989 * doing this means that while logging the inode, writeback
1990 * could start and invoke writepage/writepages, which would call
1991 * the fill_delalloc callbacks (cow_file_range,
1992 * submit_compressed_extents). These callbacks add first an
1993 * extent map to the modified list of extents and then create
1994 * the respective ordered operation, which means in
1995 * tree-log.c:btrfs_log_inode() we might capture all existing
1996 * ordered operations (with btrfs_get_logged_extents()) before
1997 * the fill_delalloc callback adds its ordered operation, and by
1998 * the time we visit the modified list of extent maps (with
1999 * btrfs_log_changed_extents()), we see and process the extent
2000 * map they created. We then use the extent map to construct a
2001 * file extent item for logging without waiting for the
2002 * respective ordered operation to finish - this file extent
2003 * item points to a disk location that might not have yet been
2004 * written to, containing random data - so after a crash a log
2005 * replay will make our inode have file extent items that point
2006 * to disk locations containing invalid data, as we returned
2007 * success to userspace without waiting for the respective
2008 * ordered operation to finish, because it wasn't captured by
2009 * btrfs_get_logged_extents().
2010 */
2012 }
2016 }
2019 /*
2020 * If the last transaction that changed this file was before the current
2021 * transaction and we have the full sync flag set in our inode, we can
2022 * bail out now without any syncing.
2023 *
2024 * Note that we can't bail out if the full sync flag isn't set. This is
2025 * because when the full sync flag is set we start all ordered extents
2026 * and wait for them to fully complete - when they complete they update
2027 * the inode's last_trans field through:
2028 *
2029 * btrfs_finish_ordered_io() ->
2030 * btrfs_update_inode_fallback() ->
2031 * btrfs_update_inode() ->
2032 * btrfs_set_inode_last_trans()
2033 *
2034 * So we are sure that last_trans is up to date and can do this check to
2035 * bail out safely. For the fast path, when the full sync flag is not
2036 * set in our inode, we can not do it because we start only our ordered
2037 * extents and don't wait for them to complete (that is when
2038 * btrfs_finish_ordered_io runs), so here at this point their last_trans
2039 * value might be less than or equals to fs_info->last_trans_committed,
2040 * and setting a speculative last_trans for an inode when a buffered
2041 * write is made (such as fs_info->generation + 1 for example) would not
2042 * be reliable since after setting the value and before fsync is called
2043 * any number of transactions can start and commit (transaction kthread
2044 * commits the current transaction periodically), and a transaction
2045 * commit does not start nor waits for ordered extents to complete.
2046 */
2054 /*
2055 * We've had everything committed since the last time we were
2056 * modified so clear this flag in case it was set for whatever
2057 * reason, it's no longer relevant.
2058 */
2061 /*
2062 * An ordered extent might have started before and completed
2063 * already with io errors, in which case the inode was not
2064 * updated and we end up here. So check the inode's mapping
2065 * flags for any errors that might have happened while doing
2066 * writeback of file data.
2067 */
2071 }
2073 /*
2074 * ok we haven't committed the transaction yet, lets do a commit
2075 */
2079 /*
2080 * We use start here because we will need to wait on the IO to complete
2081 * in btrfs_sync_log, which could require joining a transaction (for
2082 * example checking cross references in the nocow path). If we use join
2083 * here we could get into a situation where we're waiting on IO to
2084 * happen that is blocked on a transaction trying to commit. With start
2085 * we inc the extwriter counter, so we wait for all extwriters to exit
2086 * before we start blocking join'ers. This comment is to keep somebody
2087 * from thinking they are super smart and changing this to
2088 * btrfs_join_transaction *cough*Josef*cough*.
2089 */
2095 }
2102 /* Fallthrough and commit/free transaction. */
2104 }
2106 /* we've logged all the items and now have a consistent
2107 * version of the file in the log. It is possible that
2108 * someone will come in and modify the file, but that's
2109 * fine because the log is consistent on disk, and we
2110 * have references to all of the file's extents
2111 *
2112 * It is possible that someone will come in and log the
2113 * file again, but that will end up using the synchronization
2114 * inside btrfs_sync_log to keep things safe.
2115 */
2118 /*
2119 * If any of the ordered extents had an error, just return it to user
2120 * space, so that the application knows some writes didn't succeed and
2121 * can take proper action (retry for e.g.). Blindly committing the
2122 * transaction in this case, would fool userspace that everything was
2123 * successful. And we also want to make sure our log doesn't contain
2124 * file extent items pointing to extents that weren't fully written to -
2125 * just like in the non fast fsync path, where we check for the ordered
2126 * operation's error flag before writing to the log tree and return -EIO
2127 * if any of them had this flag set (btrfs_wait_ordered_range) -
2128 * therefore we need to check for errors in the ordered operations,
2129 * which are indicated by ctx.io_err.
2130 */
2135 }
2143 }
2144 }
2150 }
2151 }
2155 }
2156 out:
2158 }
2164 };
2167 {
2177 }
2181 {
2206 }
2210 {
2233 u64 num_bytes;
2245 }
2248 u64 num_bytes;
2255 offset;
2261 }
2270 out:
2301 }
2304 }
2306 /*
2307 * Find a hole extent on given inode and change start/len to the end of hole
2308 * extent.(hole/vacuum extent whose em->start <= start &&
2309 * em->start + em->len > start)
2310 * When a hole extent is found, return 1 and modify start/len.
2311 */
2313 {
2321 else
2324 }
2326 /* Hole or vacuum extent(only exists in no-hole mode) */
2332 }
2335 }
2338 {
2344 u64 lockstart;
2345 u64 lockend;
2346 u64 tail_start;
2347 u64 tail_len;
2349 u64 cur_offset;
2351 u64 drop_end;
2357 u64 ino_size;
2371 /* Already in a large hole */
2374 }
2381 /*
2382 * We needn't truncate any block which is beyond the end of the file
2383 * because we are sure there is no data there.
2384 */
2385 /*
2386 * Only do this if we are in the same block and we aren't doing the
2387 * entire block.
2388 */
2395 }
2397 }
2399 /* zero back part of the first block */
2406 }
2407 }
2409 /* Check the aligned pages after the first unaligned page,
2410 * if offset != orig_start, which means the first unaligned page
2411 * including several following pages are already in holes,
2412 * the extra check can be skipped */
2414 /* after truncate page, check hole again */
2423 }
2425 }
2427 /* Check the tail unaligned part is in a hole */
2435 /* zero the front end of the last page */
2443 }
2444 }
2445 }
2450 }
2461 /*
2462 * We need to make sure we have no ordered extents in this range
2463 * and nobody raced in and read a page in this range, if we did
2464 * we need to try again.
2465 */
2473 }
2483 }
2484 }
2490 }
2496 }
2500 /*
2501 * 1 - update the inode
2502 * 1 - removing the extents in the range
2503 * 1 - adding the hole extent if no_holes isn't set
2504 */
2510 }
2530 drop_end);
2534 }
2535 }
2543 }
2553 }
2566 }
2567 }
2572 }
2575 /*
2576 * If we are using the NO_HOLES feature we might have had already an
2577 * hole that overlaps a part of the region [lockstart, lockend] and
2578 * ends at (or beyond) lockend. Since we have no file extent items to
2579 * represent holes, drop_end can be less than lockend and so we must
2580 * make sure we have an extent map representing the existing hole (the
2581 * call to __btrfs_drop_extents() might have dropped the existing extent
2582 * map representing the existing hole), otherwise the fast fsync path
2583 * will not record the existence of the hole region
2584 * [existing_hole_start, lockend].
2585 */
2588 /*
2589 * Don't insert file hole extent item if it's for a range beyond eof
2590 * (because it's useless) or if it represents a 0 bytes range (when
2591 * cur_offset == drop_end).
2592 */
2598 }
2599 }
2601 out_trans:
2613 out_free:
2616 out:
2619 out_only_mutex:
2621 /*
2622 * If we only end up zeroing part of a page, we still need to
2623 * update the inode item, so that all the time fields are
2624 * updated as well as the necessary btrfs inode in memory fields
2625 * for detecting, at fsync time, if the inode isn't yet in the
2626 * log tree or it's there but not up to date.
2627 */
2634 }
2635 }
2640 }
2642 /* Helper structure to record which range is already reserved */
2645 u64 start;
2646 u64 len;
2647 };
2649 /*
2650 * Helper function to add falloc range
2651 *
2652 * Caller should have locked the larger range of extent containing
2653 * [start, len)
2654 */
2656 {
2663 /*
2664 * As fallocate iterate by bytenr order, we only need to check
2665 * the last range.
2666 */
2671 }
2672 insert:
2680 }
2684 {
2690 u64 cur_offset;
2691 u64 last_byte;
2692 u64 alloc_start;
2693 u64 alloc_end;
2695 u64 locked_end;
2705 /* Make sure we aren't being give some crap mode */
2712 /*
2713 * Only trigger disk allocation, don't trigger qgroup reserve
2714 *
2715 * For qgroup space, it will be checked later.
2716 */
2727 }
2729 /*
2730 * TODO: Move these two operations after we have checked
2731 * accurate reserved space, or fallocate can still fail but
2732 * with page truncated or size expanded.
2733 *
2734 * But that's a minor problem and won't do much harm BTW.
2735 */
2738 alloc_start);
2742 /*
2743 * If we are fallocating from the end of the file onward we
2744 * need to zero out the end of the block if i_size lands in the
2745 * middle of a block.
2746 */
2750 }
2752 /*
2753 * wait for ordered IO before we have any locks. We'll loop again
2754 * below with the locks held.
2755 */
2765 /* the extent lock is ordered inside the running
2766 * transaction
2767 */
2779 /*
2780 * we can't wait on the range with the transaction
2781 * running or with the extent lock held
2782 */
2791 }
2792 }
2794 /* First, check if we exceed the qgroup limit */
2802 else
2805 }
2817 }
2823 /*
2824 * Do not need to reserve unwritten extent for this
2825 * range, free reserved data space first, otherwise
2826 * it'll result in false ENOSPC error.
2827 */
2830 }
2835 }
2837 /*
2838 * If ret is still 0, means we're OK to fallocate.
2839 * Or just cleanup the list and exit.
2840 */
2847 else
2852 }
2861 /*
2862 * We didn't need to allocate any more space, but we
2863 * still extended the size of the file so we need to
2864 * update i_size and the inode item.
2865 */
2876 else
2878 }
2879 }
2880 out_unlock:
2883 out:
2885 /* Let go of our reservation. */
2890 }
2893 {
2897 u64 lockstart;
2898 u64 lockend;
2899 u64 start;
2900 u64 len;
2906 /*
2907 * *offset can be negative, in this case we start finding DATA/HOLE from
2908 * the very start of the file.
2909 */
2916 lockend--;
2928 }
2943 }
2948 else
2950 }
2954 }
2957 {
2972 }
2978 }
2979 }
2982 out:
2985 }
2998 #ifdef CONFIG_COMPAT
3000 #endif
3004 };
3007 {
3009 }
3012 {
3015 SLAB_MEM_SPREAD,
3016 NULL);
3021 }
3024 {
3027 /*
3028 * So with compression we will find and lock a dirty page and clear the
3029 * first one as dirty, setup an async extent, and immediately return
3030 * with the entire range locked but with nobody actually marked with
3031 * writeback. So we can't just filemap_write_and_wait_range() and
3032 * expect it to work since it will just kick off a thread to do the
3033 * actual work. So we need to call filemap_fdatawrite_range _again_
3034 * since it will wait on the page lock, which won't be unlocked until
3035 * after the pages have been marked as writeback and so we're good to go
3036 * from there. We have to do this otherwise we'll miss the ordered
3037 * extents and that results in badness. Please Josef, do not think you
3038 * know better and pull this out at some point in the future, it is
3039 * right and you are wrong.
3040 */
3047 }