| blob | 41ab9073d1d4220efd68859a2c023c85f6a5393c |
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/compat.h>
31 #include <linux/slab.h>
32 #include <linux/btrfs.h>
33 #include <linux/uio.h>
34 #include <linux/iversion.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 {
154 u64 transid;
165 else
178 /*
179 * If we set IN_DEFRAG flag and evict the inode from memory,
180 * and then re-read this inode, this new inode doesn't have
181 * IN_DEFRAG flag. At the case, we may find the existed defrag.
182 */
188 }
191 }
193 /*
194 * Requeue the defrag object. If there is a defrag object that points to
195 * the same inode in the tree, we will merge them together (by
196 * __btrfs_add_inode_defrag()) and free the one that we want to requeue.
197 */
200 {
207 /*
208 * Here we don't check the IN_DEFRAG flag, because we need merge
209 * them together.
210 */
217 out:
219 }
221 /*
222 * pick the defragable inode that we want, if it doesn't exist, we will get
223 * the next one.
224 */
227 {
248 else
250 }
256 else
258 }
259 out:
264 }
267 {
281 }
283 }
285 #define BTRFS_DEFRAG_BATCH 1024
289 {
298 /* get the inode */
309 }
318 }
321 /* do a chunk of defrag */
329 BTRFS_DEFRAG_BATCH);
331 /*
332 * if we filled the whole defrag batch, there
333 * must be more work to do. Queue this defrag
334 * again
335 */
340 /*
341 * we didn't fill our defrag batch, but
342 * we didn't start at zero. Make sure we loop
343 * around to the start of the file.
344 */
350 }
354 cleanup:
358 }
360 /*
361 * run through the list of inodes in the FS that need
362 * defragging
363 */
365 {
372 /* Pause the auto defragger. */
380 /* find an inode to defrag */
382 first_ino);
390 }
391 }
397 }
400 /*
401 * during unmount, we use the transaction_wait queue to
402 * wait for the defragger to stop
403 */
406 }
408 /* simple helper to fault in pages and copy. This should go away
409 * and be replaced with calls into generic code.
410 */
414 {
424 /*
425 * Copy data from userspace to the current page
426 */
429 /* Flush processor's dcache for this page */
432 /*
433 * if we get a partial write, we can end up with
434 * partially up to date pages. These add
435 * a lot of complexity, so make sure they don't
436 * happen by forcing this copy to be retried.
437 *
438 * The rest of the btrfs_file_write code will fall
439 * back to page at a time copies after we return 0.
440 */
448 /* Return to btrfs_file_write_iter to fault page */
455 pg++;
457 }
458 }
460 }
462 /*
463 * unlocks pages after btrfs_file_write is done with them
464 */
466 {
469 /* page checked is some magic around finding pages that
470 * have been modified without going through btrfs_set_page_dirty
471 * clear it here. There should be no need to mark the pages
472 * accessed as prepare_pages should have marked them accessed
473 * in prepare_pages via find_or_create_page()
474 */
478 }
479 }
485 {
492 u64 em_len;
511 EXTENT_DELALLOC_NEW,
513 next:
518 }
520 }
522 /*
523 * after copy_from_user, pages need to be dirtied and we need to make
524 * sure holes are created between the current EOF and the start of
525 * any next extents (if required).
526 *
527 * this also makes the decision about creating an inline extent vs
528 * doing real data extents, marking pages dirty and delalloc as required.
529 */
533 {
537 u64 num_bytes;
538 u64 start_pos;
539 u64 end_of_last_block;
553 /*
554 * There can't be any extents following eof in this case
555 * so just set the delalloc new bit for the range
556 * directly.
557 */
561 start_pos,
565 }
566 }
578 }
580 /*
581 * we've only changed i_size in ram, and we haven't updated
582 * the disk i_size. There is no need to log the inode
583 * at this time.
584 */
588 }
590 /*
591 * this drops all the extents in the cache that intersect the range
592 * [start, end]. Existing extents are split as required.
593 */
596 {
602 u64 gen;
613 }
630 }
638 }
645 }
663 else
674 }
684 }
709 }
716 }
720 modified);
723 modified);
725 }
728 }
729 next:
734 /* once for us */
736 /* once for the tree*/
738 }
743 }
745 /*
746 * this is very complex, but the basic idea is to drop all extents
747 * in the range start - end. hint_block is filled in with a block number
748 * that would be a good hint to the block allocator for this file.
749 *
750 * If an extent intersects the range but is not entirely inside the range
751 * it is either truncated or split. Anything entirely inside the range
752 * is deleted from the tree.
753 */
759 u32 extent_item_size,
761 {
804 }
806 leafs_visited++;
807 next_slot:
817 }
818 leafs_visited++;
821 }
832 }
852 /* can't happen */
854 }
856 /*
857 * Don't skip extent items representing 0 byte lengths. They
858 * used to be created (bug) if while punching holes we hit
859 * -ENOSPC condition. So if we find one here, just ensure we
860 * delete it, otherwise we would insert a new file extent item
861 * with the same key (offset) as that 0 bytes length file
862 * extent item in the call to setup_items_for_insert() later
863 * in this function.
864 */
868 }
873 }
881 }
883 /*
884 * | - range to drop - |
885 * | -------- extent -------- |
886 */
892 }
901 }
927 }
929 }
930 /*
931 * From here on out we will have actually dropped something, so
932 * last_end can be updated.
933 */
936 /*
937 * | ---- range to drop ----- |
938 * | -------- extent -------- |
939 */
944 }
958 }
961 /*
962 * | ---- range to drop ----- |
963 * | -------- extent -------- |
964 */
970 }
982 }
984 /*
985 * | ---- range to drop ----- |
986 * | ------ extent ------ |
987 */
989 delete_extent_item:
995 del_nr++;
996 }
1009 extent_offset);
1013 }
1021 }
1024 del_nr);
1028 }
1035 }
1038 }
1041 /*
1042 * Set path->slots[0] to first slot, so that after the delete
1043 * if items are move off from our leaf to its immediate left or
1044 * right neighbor leafs, we end up with a correct and adjusted
1045 * path->slots[0] for our insertion (if replace_extent != 0).
1046 */
1051 }
1054 /*
1055 * If btrfs_del_items() was called, it might have deleted a leaf, in
1056 * which case it unlocked our path, so check path->locks[0] matches a
1057 * write lock.
1058 */
1074 }
1077 extent_item_size,
1081 }
1088 }
1093 {
1104 }
1109 {
1112 u64 extent_end;
1137 }
1139 /*
1140 * Mark extent in the range start - end as written.
1141 *
1142 * This changes extent type from 'pre-allocated' to 'regular'. If only
1143 * part of extent is marked as written, the extent will be split into
1144 * two or three.
1145 */
1148 {
1156 u64 bytenr;
1157 u64 num_bytes;
1158 u64 extent_end;
1159 u64 orig_offset;
1160 u64 other_start;
1161 u64 other_end;
1162 u64 split;
1172 again:
1192 }
1199 }
1205 }
1236 }
1237 }
1265 }
1266 }
1277 }
1281 }
1305 }
1314 }
1317 }
1319 }
1329 }
1332 del_nr++;
1339 }
1340 }
1349 }
1352 del_nr++;
1359 }
1360 }
1365 BTRFS_FILE_EXTENT_REG);
1372 BTRFS_FILE_EXTENT_REG);
1382 }
1383 }
1384 out:
1387 }
1389 /*
1390 * on error we return an unlocked page and the error value
1391 * on success we return a locked page and 0
1392 */
1396 {
1408 }
1412 }
1413 }
1415 }
1417 /*
1418 * this just gets pages into the page cache and locks them down.
1419 */
1423 {
1431 again:
1438 }
1442 force_uptodate);
1451 }
1454 }
1456 }
1459 fail:
1463 faili--;
1464 }
1467 }
1469 /*
1470 * This function locks the extent and properly waits for data=ordered extents
1471 * to finish before allowing the pages to be modified if need.
1472 *
1473 * The return value:
1474 * 1 - the extent is locked
1475 * 0 - the extent is not locked, and everything is OK
1476 * -EAGAIN - need re-prepare the pages
1477 * the other < 0 number - Something wrong happens
1478 */
1485 {
1487 u64 start_pos;
1488 u64 last_pos;
1493 last_pos = start_pos
1501 cached_state);
1512 }
1517 }
1527 }
1534 }
1537 }
1541 {
1546 u64 num_bytes;
1563 }
1567 }
1578 }
1583 }
1587 loff_t pos)
1588 {
1596 u64 lockstart;
1597 u64 lockend;
1617 offset);
1619 PAGE_SIZE);
1629 /*
1630 * Fault pages before locking them in prepare_pages
1631 * to avoid recursive lock
1632 */
1636 }
1644 write_bytes);
1647 BTRFS_INODE_PREALLOC)) &&
1650 /*
1651 * For nodata cow case, no need to reserve
1652 * data space.
1653 */
1655 /*
1656 * our prealloc extent may be smaller than
1657 * write_bytes, so scale down.
1658 */
1660 PAGE_SIZE);
1662 sector_offset,
1666 }
1667 }
1671 reserve_bytes);
1676 write_bytes);
1677 else
1680 }
1683 again:
1684 /*
1685 * This is going to setup the pages array with the number of
1686 * pages we want, so we don't really need to worry about the
1687 * contents of pages from loop to loop
1688 */
1691 force_page_uptodate);
1694 reserve_bytes);
1696 }
1706 reserve_bytes);
1709 }
1718 /*
1719 * if we have trouble faulting in the pages, fall
1720 * back to one page at a time
1721 */
1732 PAGE_SIZE);
1733 }
1736 /* release everything except the sectors we dirtied */
1741 release_bytes);
1743 u64 __pos;
1750 release_bytes);
1751 }
1752 }
1767 }
1783 }
1795 }
1803 release_bytes);
1807 release_bytes);
1808 }
1809 }
1813 }
1816 {
1820 ssize_t written;
1821 ssize_t written_buffered;
1822 loff_t endbyte;
1835 }
1836 /*
1837 * Ensure all data is persisted. We want the next direct IO read to be
1838 * able to read what was just written.
1839 */
1851 out:
1853 }
1856 {
1871 }
1875 {
1880 u64 start_pos;
1881 u64 end_pos;
1884 ssize_t err;
1885 loff_t pos;
1887 loff_t oldsize;
1898 }
1904 }
1908 /*
1909 * We will allocate space in case nodatacow is not set,
1910 * so bail
1911 */
1913 BTRFS_INODE_PREALLOC)) ||
1917 }
1918 }
1925 }
1927 /*
1928 * If BTRFS flips readonly due to some impossible error
1929 * (fs_info->fs_state now has BTRFS_SUPER_FLAG_ERROR),
1930 * although we have opened a file as writable, we have
1931 * to stop this write operation to ensure FS consistency.
1932 */
1937 }
1939 /*
1940 * We reserve space for updating the inode when we reserve space for the
1941 * extent we are going to write, so we will enospc out there. We don't
1942 * need to start yet another transaction to update the inode as we will
1943 * update the inode when we finish writing whatever data we write.
1944 */
1950 /* Expand hole size to cover write data, preventing empty gap */
1957 }
1960 }
1974 }
1978 /*
1979 * We also have to set last_sub_trans to the current log transid,
1980 * otherwise subsequent syncs to a file that's been synced in this
1981 * transaction will appear to have already occurred.
1982 */
1991 out:
1994 }
1997 {
2007 /*
2008 * ordered_data_close is set by settattr when we are about to truncate
2009 * a file from a non-zero size to a zero size. This tries to
2010 * flush down new bytes that may have been written if the
2011 * application were using truncate to replace a file in place.
2012 */
2017 }
2020 {
2024 /*
2025 * This is only called in fsync, which would do synchronous writes, so
2026 * a plug can merge adjacent IOs as much as possible. Esp. in case of
2027 * multiple disks using raid profile, a large IO can be split to
2028 * several segments of stripe length (currently 64K).
2029 */
2037 }
2039 /*
2040 * fsync call for both files and directories. This logs the inode into
2041 * the tree log instead of forcing full commits whenever possible.
2042 *
2043 * It needs to call filemap_fdatawait so that all ordered extent updates are
2044 * in the metadata btree are up to date for copying to the log.
2045 *
2046 * It drops the inode mutex before doing the tree log commit. This is an
2047 * important optimization for directories because holding the mutex prevents
2048 * new operations on the dir while we write to disk.
2049 */
2051 {
2060 u64 len;
2062 /*
2063 * The range length can be represented by u64, we have to do the typecasts
2064 * to avoid signed overflow if it's [0, LLONG_MAX] eg. from fsync()
2065 */
2071 /*
2072 * We write the dirty pages in the range and wait until they complete
2073 * out of the ->i_mutex. If so, we can flush the dirty pages by
2074 * multi-task, and make the performance up. See
2075 * btrfs_wait_ordered_range for an explanation of the ASYNC check.
2076 */
2085 /*
2086 * We might have have had more pages made dirty after calling
2087 * start_ordered_ops and before acquiring the inode's i_mutex.
2088 */
2090 /*
2091 * For a full sync, we need to make sure any ordered operations
2092 * start and finish before we start logging the inode, so that
2093 * all extents are persisted and the respective file extent
2094 * items are in the fs/subvol btree.
2095 */
2098 /*
2099 * Start any new ordered operations before starting to log the
2100 * inode. We will wait for them to finish in btrfs_sync_log().
2101 *
2102 * Right before acquiring the inode's mutex, we might have new
2103 * writes dirtying pages, which won't immediately start the
2104 * respective ordered operations - that is done through the
2105 * fill_delalloc callbacks invoked from the writepage and
2106 * writepages address space operations. So make sure we start
2107 * all ordered operations before starting to log our inode. Not
2108 * doing this means that while logging the inode, writeback
2109 * could start and invoke writepage/writepages, which would call
2110 * the fill_delalloc callbacks (cow_file_range,
2111 * submit_compressed_extents). These callbacks add first an
2112 * extent map to the modified list of extents and then create
2113 * the respective ordered operation, which means in
2114 * tree-log.c:btrfs_log_inode() we might capture all existing
2115 * ordered operations (with btrfs_get_logged_extents()) before
2116 * the fill_delalloc callback adds its ordered operation, and by
2117 * the time we visit the modified list of extent maps (with
2118 * btrfs_log_changed_extents()), we see and process the extent
2119 * map they created. We then use the extent map to construct a
2120 * file extent item for logging without waiting for the
2121 * respective ordered operation to finish - this file extent
2122 * item points to a disk location that might not have yet been
2123 * written to, containing random data - so after a crash a log
2124 * replay will make our inode have file extent items that point
2125 * to disk locations containing invalid data, as we returned
2126 * success to userspace without waiting for the respective
2127 * ordered operation to finish, because it wasn't captured by
2128 * btrfs_get_logged_extents().
2129 */
2131 }
2135 }
2138 /*
2139 * If the last transaction that changed this file was before the current
2140 * transaction and we have the full sync flag set in our inode, we can
2141 * bail out now without any syncing.
2142 *
2143 * Note that we can't bail out if the full sync flag isn't set. This is
2144 * because when the full sync flag is set we start all ordered extents
2145 * and wait for them to fully complete - when they complete they update
2146 * the inode's last_trans field through:
2147 *
2148 * btrfs_finish_ordered_io() ->
2149 * btrfs_update_inode_fallback() ->
2150 * btrfs_update_inode() ->
2151 * btrfs_set_inode_last_trans()
2152 *
2153 * So we are sure that last_trans is up to date and can do this check to
2154 * bail out safely. For the fast path, when the full sync flag is not
2155 * set in our inode, we can not do it because we start only our ordered
2156 * extents and don't wait for them to complete (that is when
2157 * btrfs_finish_ordered_io runs), so here at this point their last_trans
2158 * value might be less than or equals to fs_info->last_trans_committed,
2159 * and setting a speculative last_trans for an inode when a buffered
2160 * write is made (such as fs_info->generation + 1 for example) would not
2161 * be reliable since after setting the value and before fsync is called
2162 * any number of transactions can start and commit (transaction kthread
2163 * commits the current transaction periodically), and a transaction
2164 * commit does not start nor waits for ordered extents to complete.
2165 */
2173 /*
2174 * We've had everything committed since the last time we were
2175 * modified so clear this flag in case it was set for whatever
2176 * reason, it's no longer relevant.
2177 */
2180 /*
2181 * An ordered extent might have started before and completed
2182 * already with io errors, in which case the inode was not
2183 * updated and we end up here. So check the inode's mapping
2184 * for any errors that might have happened since we last
2185 * checked called fsync.
2186 */
2190 }
2192 /*
2193 * ok we haven't committed the transaction yet, lets do a commit
2194 */
2198 /*
2199 * We use start here because we will need to wait on the IO to complete
2200 * in btrfs_sync_log, which could require joining a transaction (for
2201 * example checking cross references in the nocow path). If we use join
2202 * here we could get into a situation where we're waiting on IO to
2203 * happen that is blocked on a transaction trying to commit. With start
2204 * we inc the extwriter counter, so we wait for all extwriters to exit
2205 * before we start blocking join'ers. This comment is to keep somebody
2206 * from thinking they are super smart and changing this to
2207 * btrfs_join_transaction *cough*Josef*cough*.
2208 */
2214 }
2219 /* Fallthrough and commit/free transaction. */
2221 }
2223 /* we've logged all the items and now have a consistent
2224 * version of the file in the log. It is possible that
2225 * someone will come in and modify the file, but that's
2226 * fine because the log is consistent on disk, and we
2227 * have references to all of the file's extents
2228 *
2229 * It is possible that someone will come in and log the
2230 * file again, but that will end up using the synchronization
2231 * inside btrfs_sync_log to keep things safe.
2232 */
2235 /*
2236 * If any of the ordered extents had an error, just return it to user
2237 * space, so that the application knows some writes didn't succeed and
2238 * can take proper action (retry for e.g.). Blindly committing the
2239 * transaction in this case, would fool userspace that everything was
2240 * successful. And we also want to make sure our log doesn't contain
2241 * file extent items pointing to extents that weren't fully written to -
2242 * just like in the non fast fsync path, where we check for the ordered
2243 * operation's error flag before writing to the log tree and return -EIO
2244 * if any of them had this flag set (btrfs_wait_ordered_range) -
2245 * therefore we need to check for errors in the ordered operations,
2246 * which are indicated by ctx.io_err.
2247 */
2252 }
2260 }
2261 }
2267 }
2268 }
2272 }
2273 out:
2279 }
2285 };
2288 {
2298 }
2302 {
2327 }
2332 {
2351 /*
2352 * We should have dropped this offset, so if we find it then
2353 * something has gone horribly wrong.
2354 */
2358 }
2362 u64 num_bytes;
2374 }
2377 u64 num_bytes;
2384 offset;
2390 }
2398 out:
2428 }
2431 }
2433 /*
2434 * Find a hole extent on given inode and change start/len to the end of hole
2435 * extent.(hole/vacuum extent whose em->start <= start &&
2436 * em->start + em->len > start)
2437 * When a hole extent is found, return 1 and modify start/len.
2438 */
2440 {
2451 /* Hole or vacuum extent(only exists in no-hole mode) */
2457 }
2460 }
2466 {
2474 cached_state);
2477 /*
2478 * We need to make sure we have no ordered extents in this range
2479 * and nobody raced in and read a page in this range, if we did
2480 * we need to try again.
2481 */
2489 }
2498 }
2500 }
2503 {
2510 u64 lockstart;
2511 u64 lockend;
2512 u64 tail_start;
2513 u64 tail_len;
2515 u64 cur_offset;
2517 u64 drop_end;
2523 u64 ino_size;
2537 /* Already in a large hole */
2540 }
2547 /*
2548 * We needn't truncate any block which is beyond the end of the file
2549 * because we are sure there is no data there.
2550 */
2551 /*
2552 * Only do this if we are in the same block and we aren't doing the
2553 * entire block.
2554 */
2561 }
2563 }
2565 /* zero back part of the first block */
2572 }
2573 }
2575 /* Check the aligned pages after the first unaligned page,
2576 * if offset != orig_start, which means the first unaligned page
2577 * including several following pages are already in holes,
2578 * the extra check can be skipped */
2580 /* after truncate page, check hole again */
2589 }
2591 }
2593 /* Check the tail unaligned part is in a hole */
2601 /* zero the front end of the last page */
2609 }
2610 }
2611 }
2616 }
2623 }
2629 }
2635 }
2639 /*
2640 * 1 - update the inode
2641 * 1 - removing the extents in the range
2642 * 1 - adding the hole extent if no_holes isn't set
2643 */
2649 }
2671 /*
2672 * If we failed then we didn't insert our hole
2673 * entries for the area we dropped, so now the
2674 * fs is corrupted, so we must abort the
2675 * transaction.
2676 */
2680 }
2681 }
2689 }
2699 }
2712 }
2713 }
2718 }
2721 /*
2722 * If we are using the NO_HOLES feature we might have had already an
2723 * hole that overlaps a part of the region [lockstart, lockend] and
2724 * ends at (or beyond) lockend. Since we have no file extent items to
2725 * represent holes, drop_end can be less than lockend and so we must
2726 * make sure we have an extent map representing the existing hole (the
2727 * call to __btrfs_drop_extents() might have dropped the existing extent
2728 * map representing the existing hole), otherwise the fast fsync path
2729 * will not record the existence of the hole region
2730 * [existing_hole_start, lockend].
2731 */
2734 /*
2735 * Don't insert file hole extent item if it's for a range beyond eof
2736 * (because it's useless) or if it represents a 0 bytes range (when
2737 * cur_offset == drop_end).
2738 */
2743 /* Same comment as above. */
2747 }
2748 }
2750 out_trans:
2762 out_free:
2765 out:
2768 out_only_mutex:
2770 /*
2771 * If we only end up zeroing part of a page, we still need to
2772 * update the inode item, so that all the time fields are
2773 * updated as well as the necessary btrfs inode in memory fields
2774 * for detecting, at fsync time, if the inode isn't yet in the
2775 * log tree or it's there but not up to date.
2776 */
2783 }
2784 }
2789 }
2791 /* Helper structure to record which range is already reserved */
2794 u64 start;
2795 u64 len;
2796 };
2798 /*
2799 * Helper function to add falloc range
2800 *
2801 * Caller should have locked the larger range of extent containing
2802 * [start, len)
2803 */
2805 {
2812 /*
2813 * As fallocate iterate by bytenr order, we only need to check
2814 * the last range.
2815 */
2820 }
2821 insert:
2829 }
2834 {
2854 }
2860 };
2863 u64 offset)
2864 {
2878 else
2883 }
2886 loff_t offset,
2887 loff_t len,
2889 {
2908 }
2910 /*
2911 * Avoid hole punching and extent allocation for some cases. More cases
2912 * could be considered, but these are unlikely common and we keep things
2913 * as simple as possible for now. Also, intentionally, if the target
2914 * range contains one or more prealloc extents together with regular
2915 * extents and holes, we drop all the existing extents and allocate a
2916 * new prealloc extent, so that we get a larger contiguous disk extent.
2917 */
2923 /*
2924 * The whole range is already a prealloc extent,
2925 * do nothing except updating the inode's i_size if
2926 * needed.
2927 */
2930 mode);
2932 }
2933 /*
2934 * Part of the range is already a prealloc extent, so operate
2935 * only on the remaining part of the range.
2936 */
2942 }
2952 }
2957 mode);
2959 }
2966 mode);
2968 }
2973 }
2978 /*
2979 * For unaligned ranges, check the pages at the boundaries, they might
2980 * map to an extent, in which case we need to partially zero them, or
2981 * they might map to a hole, in which case we need our allocation range
2982 * to cover them.
2983 */
2997 }
2998 }
3014 }
3015 }
3017 reserve_space:
3025 bytes_to_reserve);
3043 /* btrfs_prealloc_file_range releases reserved space on error */
3047 }
3048 }
3050 out:
3057 }
3061 {
3068 u64 cur_offset;
3069 u64 last_byte;
3070 u64 alloc_start;
3071 u64 alloc_end;
3073 u64 locked_end;
3083 /* Make sure we aren't being give some crap mode */
3085 FALLOC_FL_ZERO_RANGE))
3091 /*
3092 * Only trigger disk allocation, don't trigger qgroup reserve
3093 *
3094 * For qgroup space, it will be checked later.
3095 */
3101 }
3109 }
3111 /*
3112 * TODO: Move these two operations after we have checked
3113 * accurate reserved space, or fallocate can still fail but
3114 * with page truncated or size expanded.
3115 *
3116 * But that's a minor problem and won't do much harm BTW.
3117 */
3120 alloc_start);
3124 /*
3125 * If we are fallocating from the end of the file onward we
3126 * need to zero out the end of the block if i_size lands in the
3127 * middle of a block.
3128 */
3132 }
3134 /*
3135 * wait for ordered IO before we have any locks. We'll loop again
3136 * below with the locks held.
3137 */
3147 }
3153 /* the extent lock is ordered inside the running
3154 * transaction
3155 */
3167 /*
3168 * we can't wait on the range with the transaction
3169 * running or with the extent lock held
3170 */
3179 }
3180 }
3182 /* First, check if we exceed the qgroup limit */
3190 }
3202 }
3208 }
3210 /*
3211 * Do not need to reserve unwritten extent for this
3212 * range, free reserved data space first, otherwise
3213 * it'll result in false ENOSPC error.
3214 */
3217 }
3220 }
3222 /*
3223 * If ret is still 0, means we're OK to fallocate.
3224 * Or just cleanup the list and exit.
3225 */
3232 else
3238 }
3242 /*
3243 * We didn't need to allocate any more space, but we still extended the
3244 * size of the file so we need to update i_size and the inode item.
3245 */
3247 out_unlock:
3250 out:
3252 /* Let go of our reservation. */
3258 }
3261 {
3265 u64 lockstart;
3266 u64 lockend;
3267 u64 start;
3268 u64 len;
3274 /*
3275 * *offset can be negative, in this case we start finding DATA/HOLE from
3276 * the very start of the file.
3277 */
3285 lockend--;
3298 }
3313 }
3318 else
3320 }
3324 }
3327 {
3342 }
3348 }
3349 }
3352 out:
3355 }
3358 {
3361 }
3374 #ifdef CONFIG_COMPAT
3376 #endif
3379 };
3382 {
3384 }
3387 {
3390 SLAB_MEM_SPREAD,
3391 NULL);
3396 }
3399 {
3402 /*
3403 * So with compression we will find and lock a dirty page and clear the
3404 * first one as dirty, setup an async extent, and immediately return
3405 * with the entire range locked but with nobody actually marked with
3406 * writeback. So we can't just filemap_write_and_wait_range() and
3407 * expect it to work since it will just kick off a thread to do the
3408 * actual work. So we need to call filemap_fdatawrite_range _again_
3409 * since it will wait on the page lock, which won't be unlocked until
3410 * after the pages have been marked as writeback and so we're good to go
3411 * from there. We have to do this otherwise we'll miss the ordered
3412 * extents and that results in badness. Please Josef, do not think you
3413 * know better and pull this out at some point in the future, it is
3414 * right and you are wrong.
3415 */
3422 }