| blob | 51e77d72068af0ba3f9ffdfd624409c00d51978e |
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/highmem.h>
9 #include <linux/time.h>
10 #include <linux/init.h>
11 #include <linux/string.h>
12 #include <linux/backing-dev.h>
13 #include <linux/mpage.h>
14 #include <linux/falloc.h>
15 #include <linux/swap.h>
16 #include <linux/writeback.h>
17 #include <linux/compat.h>
18 #include <linux/slab.h>
19 #include <linux/btrfs.h>
20 #include <linux/uio.h>
21 #include <linux/iversion.h>
34 /*
35 * when auto defrag is enabled we
36 * queue up these defrag structs to remember which
37 * inodes need defragging passes
38 */
41 /* objectid */
42 u64 ino;
43 /*
44 * transid where the defrag was added, we search for
45 * extents newer than this
46 */
47 u64 transid;
49 /* root objectid */
50 u64 root;
52 /* last offset we were able to defrag */
53 u64 last_offset;
55 /* if we've wrapped around back to zero once already */
57 };
61 {
70 else
72 }
74 /* pop a record for an inode into the defrag tree. The lock
75 * must be held already
76 *
77 * If you're inserting a record for an older transid than an
78 * existing record, the transid already in the tree is lowered
79 *
80 * If an existing record is found the defrag item you
81 * pass in is freed
82 */
85 {
103 /* if we're reinserting an entry for
104 * an old defrag run, make sure to
105 * lower the transid of our existing record
106 */
112 }
113 }
118 }
121 {
129 }
131 /*
132 * insert a defrag record for this inode if auto defrag is
133 * enabled
134 */
137 {
141 u64 transid;
152 else
165 /*
166 * If we set IN_DEFRAG flag and evict the inode from memory,
167 * and then re-read this inode, this new inode doesn't have
168 * IN_DEFRAG flag. At the case, we may find the existed defrag.
169 */
175 }
178 }
180 /*
181 * Requeue the defrag object. If there is a defrag object that points to
182 * the same inode in the tree, we will merge them together (by
183 * __btrfs_add_inode_defrag()) and free the one that we want to requeue.
184 */
187 {
194 /*
195 * Here we don't check the IN_DEFRAG flag, because we need merge
196 * them together.
197 */
204 out:
206 }
208 /*
209 * pick the defragable inode that we want, if it doesn't exist, we will get
210 * the next one.
211 */
214 {
235 else
237 }
243 else
245 }
246 out:
251 }
254 {
268 }
270 }
272 #define BTRFS_DEFRAG_BATCH 1024
276 {
285 /* get the inode */
296 }
305 }
308 /* do a chunk of defrag */
316 BTRFS_DEFRAG_BATCH);
318 /*
319 * if we filled the whole defrag batch, there
320 * must be more work to do. Queue this defrag
321 * again
322 */
327 /*
328 * we didn't fill our defrag batch, but
329 * we didn't start at zero. Make sure we loop
330 * around to the start of the file.
331 */
337 }
341 cleanup:
345 }
347 /*
348 * run through the list of inodes in the FS that need
349 * defragging
350 */
352 {
359 /* Pause the auto defragger. */
367 /* find an inode to defrag */
369 first_ino);
377 }
378 }
384 }
387 /*
388 * during unmount, we use the transaction_wait queue to
389 * wait for the defragger to stop
390 */
393 }
395 /* simple helper to fault in pages and copy. This should go away
396 * and be replaced with calls into generic code.
397 */
401 {
411 /*
412 * Copy data from userspace to the current page
413 */
416 /* Flush processor's dcache for this page */
419 /*
420 * if we get a partial write, we can end up with
421 * partially up to date pages. These add
422 * a lot of complexity, so make sure they don't
423 * happen by forcing this copy to be retried.
424 *
425 * The rest of the btrfs_file_write code will fall
426 * back to page at a time copies after we return 0.
427 */
435 /* Return to btrfs_file_write_iter to fault page */
442 pg++;
444 }
445 }
447 }
449 /*
450 * unlocks pages after btrfs_file_write is done with them
451 */
453 {
456 /* page checked is some magic around finding pages that
457 * have been modified without going through btrfs_set_page_dirty
458 * clear it here. There should be no need to mark the pages
459 * accessed as prepare_pages should have marked them accessed
460 * in prepare_pages via find_or_create_page()
461 */
465 }
466 }
472 {
479 u64 em_len;
498 EXTENT_DELALLOC_NEW,
500 next:
505 }
507 }
509 /*
510 * after copy_from_user, pages need to be dirtied and we need to make
511 * sure holes are created between the current EOF and the start of
512 * any next extents (if required).
513 *
514 * this also makes the decision about creating an inline extent vs
515 * doing real data extents, marking pages dirty and delalloc as required.
516 */
520 {
524 u64 num_bytes;
525 u64 start_pos;
526 u64 end_of_last_block;
540 /*
541 * There can't be any extents following eof in this case
542 * so just set the delalloc new bit for the range
543 * directly.
544 */
548 start_pos,
552 }
553 }
565 }
567 /*
568 * we've only changed i_size in ram, and we haven't updated
569 * the disk i_size. There is no need to log the inode
570 * at this time.
571 */
575 }
577 /*
578 * this drops all the extents in the cache that intersect the range
579 * [start, end]. Existing extents are split as required.
580 */
583 {
589 u64 gen;
600 }
617 }
625 }
632 }
650 else
661 }
671 }
696 }
703 }
707 modified);
710 modified);
712 }
715 }
716 next:
721 /* once for us */
723 /* once for the tree*/
725 }
730 }
732 /*
733 * this is very complex, but the basic idea is to drop all extents
734 * in the range start - end. hint_block is filled in with a block number
735 * that would be a good hint to the block allocator for this file.
736 *
737 * If an extent intersects the range but is not entirely inside the range
738 * it is either truncated or split. Anything entirely inside the range
739 * is deleted from the tree.
740 */
746 u32 extent_item_size,
748 {
791 }
793 leafs_visited++;
794 next_slot:
804 }
805 leafs_visited++;
808 }
819 }
839 /* can't happen */
841 }
843 /*
844 * Don't skip extent items representing 0 byte lengths. They
845 * used to be created (bug) if while punching holes we hit
846 * -ENOSPC condition. So if we find one here, just ensure we
847 * delete it, otherwise we would insert a new file extent item
848 * with the same key (offset) as that 0 bytes length file
849 * extent item in the call to setup_items_for_insert() later
850 * in this function.
851 */
855 }
860 }
868 }
870 /*
871 * | - range to drop - |
872 * | -------- extent -------- |
873 */
879 }
888 }
914 }
916 }
917 /*
918 * From here on out we will have actually dropped something, so
919 * last_end can be updated.
920 */
923 /*
924 * | ---- range to drop ----- |
925 * | -------- extent -------- |
926 */
931 }
945 }
948 /*
949 * | ---- range to drop ----- |
950 * | -------- extent -------- |
951 */
957 }
969 }
971 /*
972 * | ---- range to drop ----- |
973 * | ------ extent ------ |
974 */
976 delete_extent_item:
982 del_nr++;
983 }
996 extent_offset);
1000 }
1008 }
1011 del_nr);
1015 }
1022 }
1025 }
1028 /*
1029 * Set path->slots[0] to first slot, so that after the delete
1030 * if items are move off from our leaf to its immediate left or
1031 * right neighbor leafs, we end up with a correct and adjusted
1032 * path->slots[0] for our insertion (if replace_extent != 0).
1033 */
1038 }
1041 /*
1042 * If btrfs_del_items() was called, it might have deleted a leaf, in
1043 * which case it unlocked our path, so check path->locks[0] matches a
1044 * write lock.
1045 */
1061 }
1064 extent_item_size,
1068 }
1075 }
1080 {
1091 }
1096 {
1099 u64 extent_end;
1124 }
1126 /*
1127 * Mark extent in the range start - end as written.
1128 *
1129 * This changes extent type from 'pre-allocated' to 'regular'. If only
1130 * part of extent is marked as written, the extent will be split into
1131 * two or three.
1132 */
1135 {
1143 u64 bytenr;
1144 u64 num_bytes;
1145 u64 extent_end;
1146 u64 orig_offset;
1147 u64 other_start;
1148 u64 other_end;
1149 u64 split;
1159 again:
1179 }
1186 }
1192 }
1223 }
1224 }
1252 }
1253 }
1264 }
1268 }
1292 }
1301 }
1304 }
1306 }
1316 }
1319 del_nr++;
1326 }
1327 }
1336 }
1339 del_nr++;
1346 }
1347 }
1352 BTRFS_FILE_EXTENT_REG);
1359 BTRFS_FILE_EXTENT_REG);
1369 }
1370 }
1371 out:
1374 }
1376 /*
1377 * on error we return an unlocked page and the error value
1378 * on success we return a locked page and 0
1379 */
1383 {
1395 }
1399 }
1400 }
1402 }
1404 /*
1405 * this just gets pages into the page cache and locks them down.
1406 */
1410 {
1418 again:
1425 }
1429 force_uptodate);
1438 }
1441 }
1443 }
1446 fail:
1450 faili--;
1451 }
1454 }
1456 /*
1457 * This function locks the extent and properly waits for data=ordered extents
1458 * to finish before allowing the pages to be modified if need.
1459 *
1460 * The return value:
1461 * 1 - the extent is locked
1462 * 0 - the extent is not locked, and everything is OK
1463 * -EAGAIN - need re-prepare the pages
1464 * the other < 0 number - Something wrong happens
1465 */
1472 {
1474 u64 start_pos;
1475 u64 last_pos;
1480 last_pos = start_pos
1488 cached_state);
1499 }
1504 }
1514 }
1521 }
1524 }
1528 {
1533 u64 num_bytes;
1550 }
1554 }
1565 }
1570 }
1574 loff_t pos)
1575 {
1583 u64 lockstart;
1584 u64 lockend;
1604 offset);
1606 PAGE_SIZE);
1616 /*
1617 * Fault pages before locking them in prepare_pages
1618 * to avoid recursive lock
1619 */
1623 }
1631 write_bytes);
1634 BTRFS_INODE_PREALLOC)) &&
1637 /*
1638 * For nodata cow case, no need to reserve
1639 * data space.
1640 */
1642 /*
1643 * our prealloc extent may be smaller than
1644 * write_bytes, so scale down.
1645 */
1647 PAGE_SIZE);
1649 sector_offset,
1653 }
1654 }
1658 reserve_bytes);
1663 write_bytes);
1664 else
1667 }
1670 again:
1671 /*
1672 * This is going to setup the pages array with the number of
1673 * pages we want, so we don't really need to worry about the
1674 * contents of pages from loop to loop
1675 */
1678 force_page_uptodate);
1683 }
1696 }
1705 /*
1706 * if we have trouble faulting in the pages, fall
1707 * back to one page at a time
1708 */
1719 PAGE_SIZE);
1720 }
1723 /* release everything except the sectors we dirtied */
1730 u64 __pos;
1738 }
1739 }
1755 }
1771 }
1783 }
1796 }
1797 }
1801 }
1804 {
1808 ssize_t written;
1809 ssize_t written_buffered;
1810 loff_t endbyte;
1823 }
1824 /*
1825 * Ensure all data is persisted. We want the next direct IO read to be
1826 * able to read what was just written.
1827 */
1839 out:
1841 }
1844 {
1859 }
1863 {
1868 u64 start_pos;
1869 u64 end_pos;
1872 ssize_t err;
1873 loff_t pos;
1875 loff_t oldsize;
1886 }
1892 }
1896 /*
1897 * We will allocate space in case nodatacow is not set,
1898 * so bail
1899 */
1901 BTRFS_INODE_PREALLOC)) ||
1905 }
1906 }
1913 }
1915 /*
1916 * If BTRFS flips readonly due to some impossible error
1917 * (fs_info->fs_state now has BTRFS_SUPER_FLAG_ERROR),
1918 * although we have opened a file as writable, we have
1919 * to stop this write operation to ensure FS consistency.
1920 */
1925 }
1927 /*
1928 * We reserve space for updating the inode when we reserve space for the
1929 * extent we are going to write, so we will enospc out there. We don't
1930 * need to start yet another transaction to update the inode as we will
1931 * update the inode when we finish writing whatever data we write.
1932 */
1938 /* Expand hole size to cover write data, preventing empty gap */
1945 }
1948 }
1962 }
1966 /*
1967 * We also have to set last_sub_trans to the current log transid,
1968 * otherwise subsequent syncs to a file that's been synced in this
1969 * transaction will appear to have already occurred.
1970 */
1979 out:
1982 }
1985 {
1993 /*
1994 * ordered_data_close is set by settattr when we are about to truncate
1995 * a file from a non-zero size to a zero size. This tries to
1996 * flush down new bytes that may have been written if the
1997 * application were using truncate to replace a file in place.
1998 */
2003 }
2006 {
2010 /*
2011 * This is only called in fsync, which would do synchronous writes, so
2012 * a plug can merge adjacent IOs as much as possible. Esp. in case of
2013 * multiple disks using raid profile, a large IO can be split to
2014 * several segments of stripe length (currently 64K).
2015 */
2023 }
2025 /*
2026 * fsync call for both files and directories. This logs the inode into
2027 * the tree log instead of forcing full commits whenever possible.
2028 *
2029 * It needs to call filemap_fdatawait so that all ordered extent updates are
2030 * in the metadata btree are up to date for copying to the log.
2031 *
2032 * It drops the inode mutex before doing the tree log commit. This is an
2033 * important optimization for directories because holding the mutex prevents
2034 * new operations on the dir while we write to disk.
2035 */
2037 {
2046 u64 len;
2048 /*
2049 * The range length can be represented by u64, we have to do the typecasts
2050 * to avoid signed overflow if it's [0, LLONG_MAX] eg. from fsync()
2051 */
2057 /*
2058 * We write the dirty pages in the range and wait until they complete
2059 * out of the ->i_mutex. If so, we can flush the dirty pages by
2060 * multi-task, and make the performance up. See
2061 * btrfs_wait_ordered_range for an explanation of the ASYNC check.
2062 */
2071 /*
2072 * We might have have had more pages made dirty after calling
2073 * start_ordered_ops and before acquiring the inode's i_mutex.
2074 */
2076 /*
2077 * For a full sync, we need to make sure any ordered operations
2078 * start and finish before we start logging the inode, so that
2079 * all extents are persisted and the respective file extent
2080 * items are in the fs/subvol btree.
2081 */
2084 /*
2085 * Start any new ordered operations before starting to log the
2086 * inode. We will wait for them to finish in btrfs_sync_log().
2087 *
2088 * Right before acquiring the inode's mutex, we might have new
2089 * writes dirtying pages, which won't immediately start the
2090 * respective ordered operations - that is done through the
2091 * fill_delalloc callbacks invoked from the writepage and
2092 * writepages address space operations. So make sure we start
2093 * all ordered operations before starting to log our inode. Not
2094 * doing this means that while logging the inode, writeback
2095 * could start and invoke writepage/writepages, which would call
2096 * the fill_delalloc callbacks (cow_file_range,
2097 * submit_compressed_extents). These callbacks add first an
2098 * extent map to the modified list of extents and then create
2099 * the respective ordered operation, which means in
2100 * tree-log.c:btrfs_log_inode() we might capture all existing
2101 * ordered operations (with btrfs_get_logged_extents()) before
2102 * the fill_delalloc callback adds its ordered operation, and by
2103 * the time we visit the modified list of extent maps (with
2104 * btrfs_log_changed_extents()), we see and process the extent
2105 * map they created. We then use the extent map to construct a
2106 * file extent item for logging without waiting for the
2107 * respective ordered operation to finish - this file extent
2108 * item points to a disk location that might not have yet been
2109 * written to, containing random data - so after a crash a log
2110 * replay will make our inode have file extent items that point
2111 * to disk locations containing invalid data, as we returned
2112 * success to userspace without waiting for the respective
2113 * ordered operation to finish, because it wasn't captured by
2114 * btrfs_get_logged_extents().
2115 */
2117 }
2121 }
2124 /*
2125 * If the last transaction that changed this file was before the current
2126 * transaction and we have the full sync flag set in our inode, we can
2127 * bail out now without any syncing.
2128 *
2129 * Note that we can't bail out if the full sync flag isn't set. This is
2130 * because when the full sync flag is set we start all ordered extents
2131 * and wait for them to fully complete - when they complete they update
2132 * the inode's last_trans field through:
2133 *
2134 * btrfs_finish_ordered_io() ->
2135 * btrfs_update_inode_fallback() ->
2136 * btrfs_update_inode() ->
2137 * btrfs_set_inode_last_trans()
2138 *
2139 * So we are sure that last_trans is up to date and can do this check to
2140 * bail out safely. For the fast path, when the full sync flag is not
2141 * set in our inode, we can not do it because we start only our ordered
2142 * extents and don't wait for them to complete (that is when
2143 * btrfs_finish_ordered_io runs), so here at this point their last_trans
2144 * value might be less than or equals to fs_info->last_trans_committed,
2145 * and setting a speculative last_trans for an inode when a buffered
2146 * write is made (such as fs_info->generation + 1 for example) would not
2147 * be reliable since after setting the value and before fsync is called
2148 * any number of transactions can start and commit (transaction kthread
2149 * commits the current transaction periodically), and a transaction
2150 * commit does not start nor waits for ordered extents to complete.
2151 */
2159 /*
2160 * We've had everything committed since the last time we were
2161 * modified so clear this flag in case it was set for whatever
2162 * reason, it's no longer relevant.
2163 */
2166 /*
2167 * An ordered extent might have started before and completed
2168 * already with io errors, in which case the inode was not
2169 * updated and we end up here. So check the inode's mapping
2170 * for any errors that might have happened since we last
2171 * checked called fsync.
2172 */
2176 }
2178 /*
2179 * We use start here because we will need to wait on the IO to complete
2180 * in btrfs_sync_log, which could require joining a transaction (for
2181 * example checking cross references in the nocow path). If we use join
2182 * here we could get into a situation where we're waiting on IO to
2183 * happen that is blocked on a transaction trying to commit. With start
2184 * we inc the extwriter counter, so we wait for all extwriters to exit
2185 * before we start blocking join'ers. This comment is to keep somebody
2186 * from thinking they are super smart and changing this to
2187 * btrfs_join_transaction *cough*Josef*cough*.
2188 */
2194 }
2199 /* Fallthrough and commit/free transaction. */
2201 }
2203 /* we've logged all the items and now have a consistent
2204 * version of the file in the log. It is possible that
2205 * someone will come in and modify the file, but that's
2206 * fine because the log is consistent on disk, and we
2207 * have references to all of the file's extents
2208 *
2209 * It is possible that someone will come in and log the
2210 * file again, but that will end up using the synchronization
2211 * inside btrfs_sync_log to keep things safe.
2212 */
2215 /*
2216 * If any of the ordered extents had an error, just return it to user
2217 * space, so that the application knows some writes didn't succeed and
2218 * can take proper action (retry for e.g.). Blindly committing the
2219 * transaction in this case, would fool userspace that everything was
2220 * successful. And we also want to make sure our log doesn't contain
2221 * file extent items pointing to extents that weren't fully written to -
2222 * just like in the non fast fsync path, where we check for the ordered
2223 * operation's error flag before writing to the log tree and return -EIO
2224 * if any of them had this flag set (btrfs_wait_ordered_range) -
2225 * therefore we need to check for errors in the ordered operations,
2226 * which are indicated by ctx.io_err.
2227 */
2232 }
2240 }
2241 }
2247 }
2248 }
2252 }
2253 out:
2259 }
2265 };
2268 {
2278 }
2282 {
2307 }
2312 {
2331 /*
2332 * We should have dropped this offset, so if we find it then
2333 * something has gone horribly wrong.
2334 */
2338 }
2342 u64 num_bytes;
2354 }
2357 u64 num_bytes;
2364 offset;
2370 }
2378 out:
2408 }
2411 }
2413 /*
2414 * Find a hole extent on given inode and change start/len to the end of hole
2415 * extent.(hole/vacuum extent whose em->start <= start &&
2416 * em->start + em->len > start)
2417 * When a hole extent is found, return 1 and modify start/len.
2418 */
2420 {
2431 /* Hole or vacuum extent(only exists in no-hole mode) */
2437 }
2440 }
2446 {
2454 cached_state);
2457 /*
2458 * We need to make sure we have no ordered extents in this range
2459 * and nobody raced in and read a page in this range, if we did
2460 * we need to try again.
2461 */
2470 }
2479 }
2481 }
2484 {
2491 u64 lockstart;
2492 u64 lockend;
2493 u64 tail_start;
2494 u64 tail_len;
2496 u64 cur_offset;
2498 u64 drop_end;
2504 u64 ino_size;
2518 /* Already in a large hole */
2521 }
2528 /*
2529 * We needn't truncate any block which is beyond the end of the file
2530 * because we are sure there is no data there.
2531 */
2532 /*
2533 * Only do this if we are in the same block and we aren't doing the
2534 * entire block.
2535 */
2542 }
2544 }
2546 /* zero back part of the first block */
2553 }
2554 }
2556 /* Check the aligned pages after the first unaligned page,
2557 * if offset != orig_start, which means the first unaligned page
2558 * including several following pages are already in holes,
2559 * the extra check can be skipped */
2561 /* after truncate page, check hole again */
2570 }
2572 }
2574 /* Check the tail unaligned part is in a hole */
2582 /* zero the front end of the last page */
2590 }
2591 }
2592 }
2597 }
2604 }
2610 }
2616 }
2620 /*
2621 * 1 - update the inode
2622 * 1 - removing the extents in the range
2623 * 1 - adding the hole extent if no_holes isn't set
2624 */
2630 }
2652 /*
2653 * If we failed then we didn't insert our hole
2654 * entries for the area we dropped, so now the
2655 * fs is corrupted, so we must abort the
2656 * transaction.
2657 */
2661 }
2662 }
2670 }
2680 }
2693 }
2694 }
2699 }
2702 /*
2703 * If we are using the NO_HOLES feature we might have had already an
2704 * hole that overlaps a part of the region [lockstart, lockend] and
2705 * ends at (or beyond) lockend. Since we have no file extent items to
2706 * represent holes, drop_end can be less than lockend and so we must
2707 * make sure we have an extent map representing the existing hole (the
2708 * call to __btrfs_drop_extents() might have dropped the existing extent
2709 * map representing the existing hole), otherwise the fast fsync path
2710 * will not record the existence of the hole region
2711 * [existing_hole_start, lockend].
2712 */
2715 /*
2716 * Don't insert file hole extent item if it's for a range beyond eof
2717 * (because it's useless) or if it represents a 0 bytes range (when
2718 * cur_offset == drop_end).
2719 */
2724 /* Same comment as above. */
2728 }
2729 }
2731 out_trans:
2743 out_free:
2746 out:
2749 out_only_mutex:
2751 /*
2752 * If we only end up zeroing part of a page, we still need to
2753 * update the inode item, so that all the time fields are
2754 * updated as well as the necessary btrfs inode in memory fields
2755 * for detecting, at fsync time, if the inode isn't yet in the
2756 * log tree or it's there but not up to date.
2757 */
2764 }
2765 }
2770 }
2772 /* Helper structure to record which range is already reserved */
2775 u64 start;
2776 u64 len;
2777 };
2779 /*
2780 * Helper function to add falloc range
2781 *
2782 * Caller should have locked the larger range of extent containing
2783 * [start, len)
2784 */
2786 {
2793 /*
2794 * As fallocate iterate by bytenr order, we only need to check
2795 * the last range.
2796 */
2801 }
2802 insert:
2810 }
2815 {
2835 }
2841 };
2844 u64 offset)
2845 {
2859 else
2864 }
2867 loff_t offset,
2868 loff_t len,
2870 {
2889 }
2891 /*
2892 * Avoid hole punching and extent allocation for some cases. More cases
2893 * could be considered, but these are unlikely common and we keep things
2894 * as simple as possible for now. Also, intentionally, if the target
2895 * range contains one or more prealloc extents together with regular
2896 * extents and holes, we drop all the existing extents and allocate a
2897 * new prealloc extent, so that we get a larger contiguous disk extent.
2898 */
2904 /*
2905 * The whole range is already a prealloc extent,
2906 * do nothing except updating the inode's i_size if
2907 * needed.
2908 */
2911 mode);
2913 }
2914 /*
2915 * Part of the range is already a prealloc extent, so operate
2916 * only on the remaining part of the range.
2917 */
2923 }
2933 }
2938 mode);
2940 }
2947 mode);
2949 }
2954 }
2959 /*
2960 * For unaligned ranges, check the pages at the boundaries, they might
2961 * map to an extent, in which case we need to partially zero them, or
2962 * they might map to a hole, in which case we need our allocation range
2963 * to cover them.
2964 */
2978 }
2979 }
2995 }
2996 }
2998 reserve_space:
3006 bytes_to_reserve);
3024 /* btrfs_prealloc_file_range releases reserved space on error */
3028 }
3029 }
3031 out:
3038 }
3042 {
3049 u64 cur_offset;
3050 u64 last_byte;
3051 u64 alloc_start;
3052 u64 alloc_end;
3054 u64 locked_end;
3064 /* Make sure we aren't being give some crap mode */
3066 FALLOC_FL_ZERO_RANGE))
3072 /*
3073 * Only trigger disk allocation, don't trigger qgroup reserve
3074 *
3075 * For qgroup space, it will be checked later.
3076 */
3082 }
3090 }
3092 /*
3093 * TODO: Move these two operations after we have checked
3094 * accurate reserved space, or fallocate can still fail but
3095 * with page truncated or size expanded.
3096 *
3097 * But that's a minor problem and won't do much harm BTW.
3098 */
3101 alloc_start);
3105 /*
3106 * If we are fallocating from the end of the file onward we
3107 * need to zero out the end of the block if i_size lands in the
3108 * middle of a block.
3109 */
3113 }
3115 /*
3116 * wait for ordered IO before we have any locks. We'll loop again
3117 * below with the locks held.
3118 */
3128 }
3134 /* the extent lock is ordered inside the running
3135 * transaction
3136 */
3148 /*
3149 * we can't wait on the range with the transaction
3150 * running or with the extent lock held
3151 */
3160 }
3161 }
3163 /* First, check if we exceed the qgroup limit */
3171 }
3183 }
3189 }
3191 /*
3192 * Do not need to reserve unwritten extent for this
3193 * range, free reserved data space first, otherwise
3194 * it'll result in false ENOSPC error.
3195 */
3198 }
3201 }
3203 /*
3204 * If ret is still 0, means we're OK to fallocate.
3205 * Or just cleanup the list and exit.
3206 */
3213 else
3219 }
3223 /*
3224 * We didn't need to allocate any more space, but we still extended the
3225 * size of the file so we need to update i_size and the inode item.
3226 */
3228 out_unlock:
3231 out:
3233 /* Let go of our reservation. */
3239 }
3242 {
3246 u64 lockstart;
3247 u64 lockend;
3248 u64 start;
3249 u64 len;
3255 /*
3256 * *offset can be negative, in this case we start finding DATA/HOLE from
3257 * the very start of the file.
3258 */
3266 lockend--;
3279 }
3294 }
3299 else
3301 }
3305 }
3308 {
3323 }
3329 }
3330 }
3333 out:
3336 }
3339 {
3342 }
3355 #ifdef CONFIG_COMPAT
3357 #endif
3360 };
3363 {
3365 }
3368 {
3371 SLAB_MEM_SPREAD,
3372 NULL);
3377 }
3380 {
3383 /*
3384 * So with compression we will find and lock a dirty page and clear the
3385 * first one as dirty, setup an async extent, and immediately return
3386 * with the entire range locked but with nobody actually marked with
3387 * writeback. So we can't just filemap_write_and_wait_range() and
3388 * expect it to work since it will just kick off a thread to do the
3389 * actual work. So we need to call filemap_fdatawrite_range _again_
3390 * since it will wait on the page lock, which won't be unlocked until
3391 * after the pages have been marked as writeback and so we're good to go
3392 * from there. We have to do this otherwise we'll miss the ordered
3393 * extents and that results in badness. Please Josef, do not think you
3394 * know better and pull this out at some point in the future, it is
3395 * right and you are wrong.
3396 */
3403 }