| blob | dc1841855a69abf770445f81ba8f54926d474936 |
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (C) 2007 Oracle. All rights reserved.
4 */
6 #include <linux/fs.h>
7 #include <linux/pagemap.h>
8 #include <linux/time.h>
9 #include <linux/init.h>
10 #include <linux/string.h>
11 #include <linux/backing-dev.h>
12 #include <linux/falloc.h>
13 #include <linux/writeback.h>
14 #include <linux/compat.h>
15 #include <linux/slab.h>
16 #include <linux/btrfs.h>
17 #include <linux/uio.h>
18 #include <linux/iversion.h>
31 /*
32 * when auto defrag is enabled we
33 * queue up these defrag structs to remember which
34 * inodes need defragging passes
35 */
38 /* objectid */
39 u64 ino;
40 /*
41 * transid where the defrag was added, we search for
42 * extents newer than this
43 */
44 u64 transid;
46 /* root objectid */
47 u64 root;
49 /* last offset we were able to defrag */
50 u64 last_offset;
52 /* if we've wrapped around back to zero once already */
54 };
58 {
67 else
69 }
71 /* pop a record for an inode into the defrag tree. The lock
72 * must be held already
73 *
74 * If you're inserting a record for an older transid than an
75 * existing record, the transid already in the tree is lowered
76 *
77 * If an existing record is found the defrag item you
78 * pass in is freed
79 */
82 {
100 /* if we're reinserting an entry for
101 * an old defrag run, make sure to
102 * lower the transid of our existing record
103 */
109 }
110 }
115 }
118 {
126 }
128 /*
129 * insert a defrag record for this inode if auto defrag is
130 * enabled
131 */
134 {
138 u64 transid;
149 else
162 /*
163 * If we set IN_DEFRAG flag and evict the inode from memory,
164 * and then re-read this inode, this new inode doesn't have
165 * IN_DEFRAG flag. At the case, we may find the existed defrag.
166 */
172 }
175 }
177 /*
178 * Requeue the defrag object. If there is a defrag object that points to
179 * the same inode in the tree, we will merge them together (by
180 * __btrfs_add_inode_defrag()) and free the one that we want to requeue.
181 */
184 {
191 /*
192 * Here we don't check the IN_DEFRAG flag, because we need merge
193 * them together.
194 */
201 out:
203 }
205 /*
206 * pick the defragable inode that we want, if it doesn't exist, we will get
207 * the next one.
208 */
211 {
232 else
234 }
240 else
242 }
243 out:
248 }
251 {
265 }
267 }
269 #define BTRFS_DEFRAG_BATCH 1024
273 {
282 /* get the inode */
293 }
302 }
305 /* do a chunk of defrag */
313 BTRFS_DEFRAG_BATCH);
315 /*
316 * if we filled the whole defrag batch, there
317 * must be more work to do. Queue this defrag
318 * again
319 */
324 /*
325 * we didn't fill our defrag batch, but
326 * we didn't start at zero. Make sure we loop
327 * around to the start of the file.
328 */
334 }
338 cleanup:
342 }
344 /*
345 * run through the list of inodes in the FS that need
346 * defragging
347 */
349 {
356 /* Pause the auto defragger. */
364 /* find an inode to defrag */
366 first_ino);
374 }
375 }
381 }
384 /*
385 * during unmount, we use the transaction_wait queue to
386 * wait for the defragger to stop
387 */
390 }
392 /* simple helper to fault in pages and copy. This should go away
393 * and be replaced with calls into generic code.
394 */
398 {
408 /*
409 * Copy data from userspace to the current page
410 */
413 /* Flush processor's dcache for this page */
416 /*
417 * if we get a partial write, we can end up with
418 * partially up to date pages. These add
419 * a lot of complexity, so make sure they don't
420 * happen by forcing this copy to be retried.
421 *
422 * The rest of the btrfs_file_write code will fall
423 * back to page at a time copies after we return 0.
424 */
432 /* Return to btrfs_file_write_iter to fault page */
439 pg++;
441 }
442 }
444 }
446 /*
447 * unlocks pages after btrfs_file_write is done with them
448 */
450 {
453 /* page checked is some magic around finding pages that
454 * have been modified without going through btrfs_set_page_dirty
455 * clear it here. There should be no need to mark the pages
456 * accessed as prepare_pages should have marked them accessed
457 * in prepare_pages via find_or_create_page()
458 */
462 }
463 }
469 {
476 u64 em_len;
495 EXTENT_DELALLOC_NEW,
497 next:
502 }
504 }
506 /*
507 * after copy_from_user, pages need to be dirtied and we need to make
508 * sure holes are created between the current EOF and the start of
509 * any next extents (if required).
510 *
511 * this also makes the decision about creating an inline extent vs
512 * doing real data extents, marking pages dirty and delalloc as required.
513 */
517 {
521 u64 num_bytes;
522 u64 start_pos;
523 u64 end_of_last_block;
534 /*
535 * The pages may have already been dirty, clear out old accounting so
536 * we can set things up properly
537 */
545 /*
546 * There can't be any extents following eof in this case
547 * so just set the delalloc new bit for the range
548 * directly.
549 */
553 start_pos,
557 }
558 }
570 }
572 /*
573 * we've only changed i_size in ram, and we haven't updated
574 * the disk i_size. There is no need to log the inode
575 * at this time.
576 */
580 }
582 /*
583 * this drops all the extents in the cache that intersect the range
584 * [start, end]. Existing extents are split as required.
585 */
588 {
594 u64 gen;
605 }
622 }
630 }
637 }
655 else
666 }
676 }
701 }
708 }
712 modified);
715 modified);
717 }
720 }
721 next:
726 /* once for us */
728 /* once for the tree*/
730 }
735 }
737 /*
738 * this is very complex, but the basic idea is to drop all extents
739 * in the range start - end. hint_block is filled in with a block number
740 * that would be a good hint to the block allocator for this file.
741 *
742 * If an extent intersects the range but is not entirely inside the range
743 * it is either truncated or split. Anything entirely inside the range
744 * is deleted from the tree.
745 */
751 u32 extent_item_size,
753 {
796 }
798 leafs_visited++;
799 next_slot:
809 }
810 leafs_visited++;
813 }
824 }
843 /* can't happen */
845 }
847 /*
848 * Don't skip extent items representing 0 byte lengths. They
849 * used to be created (bug) if while punching holes we hit
850 * -ENOSPC condition. So if we find one here, just ensure we
851 * delete it, otherwise we would insert a new file extent item
852 * with the same key (offset) as that 0 bytes length file
853 * extent item in the call to setup_items_for_insert() later
854 * in this function.
855 */
859 }
864 }
872 }
874 /*
875 * | - range to drop - |
876 * | -------- extent -------- |
877 */
883 }
892 }
918 }
920 }
921 /*
922 * From here on out we will have actually dropped something, so
923 * last_end can be updated.
924 */
927 /*
928 * | ---- range to drop ----- |
929 * | -------- extent -------- |
930 */
935 }
949 }
952 /*
953 * | ---- range to drop ----- |
954 * | -------- extent -------- |
955 */
961 }
973 }
975 /*
976 * | ---- range to drop ----- |
977 * | ------ extent ------ |
978 */
980 delete_extent_item:
986 del_nr++;
987 }
1000 extent_offset);
1004 }
1012 }
1015 del_nr);
1019 }
1026 }
1029 }
1032 /*
1033 * Set path->slots[0] to first slot, so that after the delete
1034 * if items are move off from our leaf to its immediate left or
1035 * right neighbor leafs, we end up with a correct and adjusted
1036 * path->slots[0] for our insertion (if replace_extent != 0).
1037 */
1042 }
1045 /*
1046 * If btrfs_del_items() was called, it might have deleted a leaf, in
1047 * which case it unlocked our path, so check path->locks[0] matches a
1048 * write lock.
1049 */
1065 }
1068 extent_item_size,
1072 }
1079 }
1084 {
1095 }
1100 {
1103 u64 extent_end;
1128 }
1130 /*
1131 * Mark extent in the range start - end as written.
1132 *
1133 * This changes extent type from 'pre-allocated' to 'regular'. If only
1134 * part of extent is marked as written, the extent will be split into
1135 * two or three.
1136 */
1139 {
1147 u64 bytenr;
1148 u64 num_bytes;
1149 u64 extent_end;
1150 u64 orig_offset;
1151 u64 other_start;
1152 u64 other_end;
1153 u64 split;
1163 again:
1183 }
1190 }
1196 }
1227 }
1228 }
1256 }
1257 }
1268 }
1272 }
1296 }
1305 }
1308 }
1310 }
1320 }
1323 del_nr++;
1330 }
1331 }
1340 }
1343 del_nr++;
1350 }
1351 }
1356 BTRFS_FILE_EXTENT_REG);
1363 BTRFS_FILE_EXTENT_REG);
1373 }
1374 }
1375 out:
1378 }
1380 /*
1381 * on error we return an unlocked page and the error value
1382 * on success we return a locked page and 0
1383 */
1387 {
1399 }
1403 }
1404 }
1406 }
1408 /*
1409 * this just gets pages into the page cache and locks them down.
1410 */
1414 {
1422 again:
1429 }
1433 force_uptodate);
1442 }
1445 }
1447 }
1450 fail:
1454 faili--;
1455 }
1458 }
1460 /*
1461 * This function locks the extent and properly waits for data=ordered extents
1462 * to finish before allowing the pages to be modified if need.
1463 *
1464 * The return value:
1465 * 1 - the extent is locked
1466 * 0 - the extent is not locked, and everything is OK
1467 * -EAGAIN - need re-prepare the pages
1468 * the other < 0 number - Something wrong happens
1469 */
1476 {
1478 u64 start_pos;
1479 u64 last_pos;
1484 last_pos = start_pos
1492 cached_state);
1503 }
1508 }
1515 }
1517 /*
1518 * It's possible the pages are dirty right now, but we don't want
1519 * to clean them yet because copy_from_user may catch a page fault
1520 * and we might have to fall back to one page at a time. If that
1521 * happens, we'll unlock these pages and we'd have a window where
1522 * reclaim could sneak in and drop the once-dirty page on the floor
1523 * without writing it.
1524 *
1525 * We have the pages locked and the extent range locked, so there's
1526 * no way someone can start IO on any dirty pages in this range.
1527 *
1528 * We'll call btrfs_dirty_pages() later on, and that will flip around
1529 * delalloc bits and dirty the pages as required.
1530 */
1534 }
1537 }
1541 {
1546 u64 num_bytes;
1563 }
1567 }
1578 }
1583 }
1587 {
1596 u64 lockstart;
1597 u64 lockend;
1618 offset);
1620 PAGE_SIZE);
1630 /*
1631 * Fault pages before locking them in prepare_pages
1632 * to avoid recursive lock
1633 */
1637 }
1646 write_bytes);
1649 BTRFS_INODE_PREALLOC)) &&
1652 /*
1653 * For nodata cow case, no need to reserve
1654 * data space.
1655 */
1657 /*
1658 * our prealloc extent may be smaller than
1659 * write_bytes, so scale down.
1660 */
1662 PAGE_SIZE);
1664 sector_offset,
1668 }
1669 }
1673 reserve_bytes);
1678 write_bytes);
1679 else
1682 }
1685 again:
1686 /*
1687 * This is going to setup the pages array with the number of
1688 * pages we want, so we don't really need to worry about the
1689 * contents of pages from loop to loop
1690 */
1693 force_page_uptodate);
1696 reserve_bytes);
1698 }
1708 reserve_bytes);
1711 }
1720 /*
1721 * if we have trouble faulting in the pages, fall
1722 * back to one page at a time
1723 */
1734 PAGE_SIZE);
1735 }
1738 /* release everything except the sectors we dirtied */
1745 u64 __pos;
1753 }
1754 }
1763 /*
1764 * If we have not locked the extent range, because the range's
1765 * start offset is >= i_size, we might still have a non-NULL
1766 * cached extent state, acquired while marking the extent range
1767 * as delalloc through btrfs_dirty_pages(). Therefore free any
1768 * possible cached extent state to avoid a memory leak.
1769 */
1773 else
1780 }
1795 }
1807 }
1820 }
1821 }
1825 }
1828 {
1831 loff_t pos;
1832 ssize_t written;
1833 ssize_t written_buffered;
1834 loff_t endbyte;
1847 }
1848 /*
1849 * Ensure all data is persisted. We want the next direct IO read to be
1850 * able to read what was just written.
1851 */
1863 out:
1865 }
1868 {
1883 }
1887 {
1892 u64 start_pos;
1893 u64 end_pos;
1896 ssize_t err;
1897 loff_t pos;
1899 loff_t oldsize;
1911 }
1917 }
1922 /*
1923 * We will allocate space in case nodatacow is not set,
1924 * so bail
1925 */
1927 BTRFS_INODE_PREALLOC)) ||
1931 }
1932 }
1939 }
1941 /*
1942 * If BTRFS flips readonly due to some impossible error
1943 * (fs_info->fs_state now has BTRFS_SUPER_FLAG_ERROR),
1944 * although we have opened a file as writable, we have
1945 * to stop this write operation to ensure FS consistency.
1946 */
1951 }
1953 /*
1954 * We reserve space for updating the inode when we reserve space for the
1955 * extent we are going to write, so we will enospc out there. We don't
1956 * need to start yet another transaction to update the inode as we will
1957 * update the inode when we finish writing whatever data we write.
1958 */
1964 /* Expand hole size to cover write data, preventing empty gap */
1971 }
1974 }
1988 }
1992 /*
1993 * We also have to set last_sub_trans to the current log transid,
1994 * otherwise subsequent syncs to a file that's been synced in this
1995 * transaction will appear to have already occurred.
1996 */
2005 out:
2008 }
2011 {
2019 /*
2020 * ordered_data_close is set by settattr when we are about to truncate
2021 * a file from a non-zero size to a zero size. This tries to
2022 * flush down new bytes that may have been written if the
2023 * application were using truncate to replace a file in place.
2024 */
2029 }
2032 {
2036 /*
2037 * This is only called in fsync, which would do synchronous writes, so
2038 * a plug can merge adjacent IOs as much as possible. Esp. in case of
2039 * multiple disks using raid profile, a large IO can be split to
2040 * several segments of stripe length (currently 64K).
2041 */
2049 }
2051 /*
2052 * fsync call for both files and directories. This logs the inode into
2053 * the tree log instead of forcing full commits whenever possible.
2054 *
2055 * It needs to call filemap_fdatawait so that all ordered extent updates are
2056 * in the metadata btree are up to date for copying to the log.
2057 *
2058 * It drops the inode mutex before doing the tree log commit. This is an
2059 * important optimization for directories because holding the mutex prevents
2060 * new operations on the dir while we write to disk.
2061 */
2063 {
2076 /*
2077 * Set the range to full if the NO_HOLES feature is not enabled.
2078 * This is to avoid missing file extent items representing holes after
2079 * replaying the log.
2080 */
2084 }
2086 /*
2087 * We write the dirty pages in the range and wait until they complete
2088 * out of the ->i_mutex. If so, we can flush the dirty pages by
2089 * multi-task, and make the performance up. See
2090 * btrfs_wait_ordered_range for an explanation of the ASYNC check.
2091 */
2098 /*
2099 * We take the dio_sem here because the tree log stuff can race with
2100 * lockless dio writes and get an extent map logged for an extent we
2101 * never waited on. We need it this high up for lockdep reasons.
2102 */
2107 /*
2108 * If the inode needs a full sync, make sure we use a full range to
2109 * avoid log tree corruption, due to hole detection racing with ordered
2110 * extent completion for adjacent ranges, and assertion failures during
2111 * hole detection. Do this while holding the inode lock, to avoid races
2112 * with other tasks.
2113 */
2118 }
2120 /*
2121 * Before we acquired the inode's lock, someone may have dirtied more
2122 * pages in the target range. We need to make sure that writeback for
2123 * any such pages does not start while we are logging the inode, because
2124 * if it does, any of the following might happen when we are not doing a
2125 * full inode sync:
2126 *
2127 * 1) We log an extent after its writeback finishes but before its
2128 * checksums are added to the csum tree, leading to -EIO errors
2129 * when attempting to read the extent after a log replay.
2130 *
2131 * 2) We can end up logging an extent before its writeback finishes.
2132 * Therefore after the log replay we will have a file extent item
2133 * pointing to an unwritten extent (and no data checksums as well).
2134 *
2135 * So trigger writeback for any eventual new dirty pages and then we
2136 * wait for all ordered extents to complete below.
2137 */
2143 }
2145 /*
2146 * We have to do this here to avoid the priority inversion of waiting on
2147 * IO of a lower priority task while holding a transaciton open.
2148 *
2149 * Also, the range length can be represented by u64, we have to do the
2150 * typecasts to avoid signed overflow if it's [0, LLONG_MAX].
2151 */
2157 }
2163 /*
2164 * We've had everything committed since the last time we were
2165 * modified so clear this flag in case it was set for whatever
2166 * reason, it's no longer relevant.
2167 */
2170 /*
2171 * An ordered extent might have started before and completed
2172 * already with io errors, in which case the inode was not
2173 * updated and we end up here. So check the inode's mapping
2174 * for any errors that might have happened since we last
2175 * checked called fsync.
2176 */
2181 }
2183 /*
2184 * We use start here because we will need to wait on the IO to complete
2185 * in btrfs_sync_log, which could require joining a transaction (for
2186 * example checking cross references in the nocow path). If we use join
2187 * here we could get into a situation where we're waiting on IO to
2188 * happen that is blocked on a transaction trying to commit. With start
2189 * we inc the extwriter counter, so we wait for all extwriters to exit
2190 * before we start blocking join'ers. This comment is to keep somebody
2191 * from thinking they are super smart and changing this to
2192 * btrfs_join_transaction *cough*Josef*cough*.
2193 */
2200 }
2205 /* Fallthrough and commit/free transaction. */
2207 }
2209 /* we've logged all the items and now have a consistent
2210 * version of the file in the log. It is possible that
2211 * someone will come in and modify the file, but that's
2212 * fine because the log is consistent on disk, and we
2213 * have references to all of the file's extents
2214 *
2215 * It is possible that someone will come in and log the
2216 * file again, but that will end up using the synchronization
2217 * inside btrfs_sync_log to keep things safe.
2218 */
2222 /*
2223 * If any of the ordered extents had an error, just return it to user
2224 * space, so that the application knows some writes didn't succeed and
2225 * can take proper action (retry for e.g.). Blindly committing the
2226 * transaction in this case, would fool userspace that everything was
2227 * successful. And we also want to make sure our log doesn't contain
2228 * file extent items pointing to extents that weren't fully written to -
2229 * just like in the non fast fsync path, where we check for the ordered
2230 * operation's error flag before writing to the log tree and return -EIO
2231 * if any of them had this flag set (btrfs_wait_ordered_range) -
2232 * therefore we need to check for errors in the ordered operations,
2233 * which are indicated by ctx.io_err.
2234 */
2239 }
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 }
2608 }
2614 }
2618 /*
2619 * 1 - update the inode
2620 * 1 - removing the extents in the range
2621 * 1 - adding the hole extent if no_holes isn't set
2622 */
2628 }
2650 /*
2651 * If we failed then we didn't insert our hole
2652 * entries for the area we dropped, so now the
2653 * fs is corrupted, so we must abort the
2654 * transaction.
2655 */
2659 }
2660 }
2668 }
2678 }
2691 }
2692 }
2697 }
2700 /*
2701 * If we are using the NO_HOLES feature we might have had already an
2702 * hole that overlaps a part of the region [lockstart, lockend] and
2703 * ends at (or beyond) lockend. Since we have no file extent items to
2704 * represent holes, drop_end can be less than lockend and so we must
2705 * make sure we have an extent map representing the existing hole (the
2706 * call to __btrfs_drop_extents() might have dropped the existing extent
2707 * map representing the existing hole), otherwise the fast fsync path
2708 * will not record the existence of the hole region
2709 * [existing_hole_start, lockend].
2710 */
2713 /*
2714 * Don't insert file hole extent item if it's for a range beyond eof
2715 * (because it's useless) or if it represents a 0 bytes range (when
2716 * cur_offset == drop_end).
2717 */
2722 /* Same comment as above. */
2726 }
2727 }
2729 out_trans:
2741 out_free:
2744 out:
2747 out_only_mutex:
2749 /*
2750 * If we only end up zeroing part of a page, we still need to
2751 * update the inode item, so that all the time fields are
2752 * updated as well as the necessary btrfs inode in memory fields
2753 * for detecting, at fsync time, if the inode isn't yet in the
2754 * log tree or it's there but not up to date.
2755 */
2767 }
2768 }
2773 }
2775 /* Helper structure to record which range is already reserved */
2778 u64 start;
2779 u64 len;
2780 };
2782 /*
2783 * Helper function to add falloc range
2784 *
2785 * Caller should have locked the larger range of extent containing
2786 * [start, len)
2787 */
2789 {
2796 /*
2797 * As fallocate iterate by bytenr order, we only need to check
2798 * the last range.
2799 */
2804 }
2805 insert:
2813 }
2818 {
2838 }
2844 };
2847 u64 offset)
2848 {
2862 else
2867 }
2870 loff_t offset,
2871 loff_t len,
2873 {
2892 }
2894 /*
2895 * Avoid hole punching and extent allocation for some cases. More cases
2896 * could be considered, but these are unlikely common and we keep things
2897 * as simple as possible for now. Also, intentionally, if the target
2898 * range contains one or more prealloc extents together with regular
2899 * extents and holes, we drop all the existing extents and allocate a
2900 * new prealloc extent, so that we get a larger contiguous disk extent.
2901 */
2907 /*
2908 * The whole range is already a prealloc extent,
2909 * do nothing except updating the inode's i_size if
2910 * needed.
2911 */
2914 mode);
2916 }
2917 /*
2918 * Part of the range is already a prealloc extent, so operate
2919 * only on the remaining part of the range.
2920 */
2926 }
2936 }
2941 mode);
2943 }
2950 mode);
2952 }
2957 }
2962 /*
2963 * For unaligned ranges, check the pages at the boundaries, they might
2964 * map to an extent, in which case we need to partially zero them, or
2965 * they might map to a hole, in which case we need our allocation range
2966 * to cover them.
2967 */
2981 }
2982 }
2998 }
2999 }
3001 reserve_space:
3009 bytes_to_reserve);
3027 /* btrfs_prealloc_file_range releases reserved space on error */
3031 }
3032 }
3034 out:
3041 }
3045 {
3052 u64 cur_offset;
3053 u64 last_byte;
3054 u64 alloc_start;
3055 u64 alloc_end;
3057 u64 locked_end;
3067 /* Make sure we aren't being give some crap mode */
3069 FALLOC_FL_ZERO_RANGE))
3075 /*
3076 * Only trigger disk allocation, don't trigger qgroup reserve
3077 *
3078 * For qgroup space, it will be checked later.
3079 */
3085 }
3093 }
3095 /*
3096 * TODO: Move these two operations after we have checked
3097 * accurate reserved space, or fallocate can still fail but
3098 * with page truncated or size expanded.
3099 *
3100 * But that's a minor problem and won't do much harm BTW.
3101 */
3104 alloc_start);
3108 /*
3109 * If we are fallocating from the end of the file onward we
3110 * need to zero out the end of the block if i_size lands in the
3111 * middle of a block.
3112 */
3116 }
3118 /*
3119 * wait for ordered IO before we have any locks. We'll loop again
3120 * below with the locks held.
3121 */
3131 }
3137 /* the extent lock is ordered inside the running
3138 * transaction
3139 */
3151 /*
3152 * we can't wait on the range with the transaction
3153 * running or with the extent lock held
3154 */
3163 }
3164 }
3166 /* First, check if we exceed the qgroup limit */
3174 }
3186 }
3193 }
3195 /*
3196 * Do not need to reserve unwritten extent for this
3197 * range, free reserved data space first, otherwise
3198 * it'll result in false ENOSPC error.
3199 */
3202 }
3205 }
3207 /*
3208 * If ret is still 0, means we're OK to fallocate.
3209 * Or just cleanup the list and exit.
3210 */
3217 else
3223 }
3227 /*
3228 * We didn't need to allocate any more space, but we still extended the
3229 * size of the file so we need to update i_size and the inode item.
3230 */
3232 out_unlock:
3235 out:
3237 /* Let go of our reservation. */
3243 }
3246 {
3250 u64 lockstart;
3251 u64 lockend;
3252 u64 start;
3253 u64 len;
3259 /*
3260 * *offset can be negative, in this case we start finding DATA/HOLE from
3261 * the very start of the file.
3262 */
3270 lockend--;
3283 }
3298 }
3303 else
3305 }
3309 }
3312 {
3327 }
3333 }
3334 }
3337 out:
3340 }
3343 {
3346 }
3359 #ifdef CONFIG_COMPAT
3361 #endif
3364 };
3367 {
3369 }
3372 {
3375 SLAB_MEM_SPREAD,
3376 NULL);
3381 }
3384 {
3387 /*
3388 * So with compression we will find and lock a dirty page and clear the
3389 * first one as dirty, setup an async extent, and immediately return
3390 * with the entire range locked but with nobody actually marked with
3391 * writeback. So we can't just filemap_write_and_wait_range() and
3392 * expect it to work since it will just kick off a thread to do the
3393 * actual work. So we need to call filemap_fdatawrite_range _again_
3394 * since it will wait on the page lock, which won't be unlocked until
3395 * after the pages have been marked as writeback and so we're good to go
3396 * from there. We have to do this otherwise we'll miss the ordered
3397 * extents and that results in badness. Please Josef, do not think you
3398 * know better and pull this out at some point in the future, it is
3399 * right and you are wrong.
3400 */
3407 }