| blob | eb1bac7c8553c7a4172735027765bf16619e9d00 |
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>
46 /*
47 * when auto defrag is enabled we
48 * queue up these defrag structs to remember which
49 * inodes need defragging passes
50 */
53 /* objectid */
54 u64 ino;
55 /*
56 * transid where the defrag was added, we search for
57 * extents newer than this
58 */
59 u64 transid;
61 /* root objectid */
62 u64 root;
64 /* last offset we were able to defrag */
65 u64 last_offset;
67 /* if we've wrapped around back to zero once already */
69 };
73 {
82 else
84 }
86 /* pop a record for an inode into the defrag tree. The lock
87 * must be held already
88 *
89 * If you're inserting a record for an older transid than an
90 * existing record, the transid already in the tree is lowered
91 *
92 * If an existing record is found the defrag item you
93 * pass in is freed
94 */
97 {
115 /* if we're reinserting an entry for
116 * an old defrag run, make sure to
117 * lower the transid of our existing record
118 */
124 }
125 }
130 }
133 {
141 }
143 /*
144 * insert a defrag record for this inode if auto defrag is
145 * enabled
146 */
149 {
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 }
484 {
491 u64 em_len;
510 EXTENT_DELALLOC_NEW,
512 next:
517 }
519 }
521 /*
522 * after copy_from_user, pages need to be dirtied and we need to make
523 * sure holes are created between the current EOF and the start of
524 * any next extents (if required).
525 *
526 * this also makes the decision about creating an inline extent vs
527 * doing real data extents, marking pages dirty and delalloc as required.
528 */
532 {
536 u64 num_bytes;
537 u64 start_pos;
538 u64 end_of_last_block;
552 /*
553 * There can't be any extents following eof in this case
554 * so just set the delalloc new bit for the range
555 * directly.
556 */
560 start_pos,
564 }
565 }
577 }
579 /*
580 * we've only changed i_size in ram, and we haven't updated
581 * the disk i_size. There is no need to log the inode
582 * at this time.
583 */
587 }
589 /*
590 * this drops all the extents in the cache that intersect the range
591 * [start, end]. Existing extents are split as required.
592 */
595 {
601 u64 gen;
612 }
629 }
637 }
644 }
662 else
673 }
683 }
708 }
715 }
719 modified);
722 modified);
724 }
727 }
728 next:
733 /* once for us */
735 /* once for the tree*/
737 }
742 }
744 /*
745 * this is very complex, but the basic idea is to drop all extents
746 * in the range start - end. hint_block is filled in with a block number
747 * that would be a good hint to the block allocator for this file.
748 *
749 * If an extent intersects the range but is not entirely inside the range
750 * it is either truncated or split. Anything entirely inside the range
751 * is deleted from the tree.
752 */
758 u32 extent_item_size,
760 {
803 }
805 leafs_visited++;
806 next_slot:
816 }
817 leafs_visited++;
820 }
831 }
851 /* can't happen */
853 }
855 /*
856 * Don't skip extent items representing 0 byte lengths. They
857 * used to be created (bug) if while punching holes we hit
858 * -ENOSPC condition. So if we find one here, just ensure we
859 * delete it, otherwise we would insert a new file extent item
860 * with the same key (offset) as that 0 bytes length file
861 * extent item in the call to setup_items_for_insert() later
862 * in this function.
863 */
867 }
872 }
880 }
882 /*
883 * | - range to drop - |
884 * | -------- extent -------- |
885 */
891 }
900 }
926 }
928 }
929 /*
930 * From here on out we will have actually dropped something, so
931 * last_end can be updated.
932 */
935 /*
936 * | ---- range to drop ----- |
937 * | -------- extent -------- |
938 */
943 }
957 }
960 /*
961 * | ---- range to drop ----- |
962 * | -------- extent -------- |
963 */
969 }
981 }
983 /*
984 * | ---- range to drop ----- |
985 * | ------ extent ------ |
986 */
988 delete_extent_item:
994 del_nr++;
995 }
1008 extent_offset);
1012 }
1020 }
1023 del_nr);
1027 }
1034 }
1037 }
1040 /*
1041 * Set path->slots[0] to first slot, so that after the delete
1042 * if items are move off from our leaf to its immediate left or
1043 * right neighbor leafs, we end up with a correct and adjusted
1044 * path->slots[0] for our insertion (if replace_extent != 0).
1045 */
1050 }
1053 /*
1054 * If btrfs_del_items() was called, it might have deleted a leaf, in
1055 * which case it unlocked our path, so check path->locks[0] matches a
1056 * write lock.
1057 */
1073 }
1076 extent_item_size,
1080 }
1087 }
1092 {
1103 }
1108 {
1111 u64 extent_end;
1136 }
1138 /*
1139 * Mark extent in the range start - end as written.
1140 *
1141 * This changes extent type from 'pre-allocated' to 'regular'. If only
1142 * part of extent is marked as written, the extent will be split into
1143 * two or three.
1144 */
1147 {
1155 u64 bytenr;
1156 u64 num_bytes;
1157 u64 extent_end;
1158 u64 orig_offset;
1159 u64 other_start;
1160 u64 other_end;
1161 u64 split;
1171 again:
1191 }
1198 }
1204 }
1235 }
1236 }
1264 }
1265 }
1276 }
1280 }
1304 }
1313 }
1316 }
1318 }
1328 }
1331 del_nr++;
1338 }
1339 }
1348 }
1351 del_nr++;
1358 }
1359 }
1364 BTRFS_FILE_EXTENT_REG);
1371 BTRFS_FILE_EXTENT_REG);
1381 }
1382 }
1383 out:
1386 }
1388 /*
1389 * on error we return an unlocked page and the error value
1390 * on success we return a locked page and 0
1391 */
1395 {
1407 }
1411 }
1412 }
1414 }
1416 /*
1417 * this just gets pages into the page cache and locks them down.
1418 */
1422 {
1430 again:
1437 }
1441 force_uptodate);
1450 }
1453 }
1455 }
1458 fail:
1462 faili--;
1463 }
1466 }
1468 /*
1469 * This function locks the extent and properly waits for data=ordered extents
1470 * to finish before allowing the pages to be modified if need.
1471 *
1472 * The return value:
1473 * 1 - the extent is locked
1474 * 0 - the extent is not locked, and everything is OK
1475 * -EAGAIN - need re-prepare the pages
1476 * the other < 0 number - Something wrong happens
1477 */
1484 {
1486 u64 start_pos;
1487 u64 last_pos;
1492 last_pos = start_pos
1500 cached_state);
1511 }
1516 }
1526 }
1533 }
1536 }
1540 {
1545 u64 num_bytes;
1562 }
1566 }
1577 }
1582 }
1586 loff_t pos)
1587 {
1595 u64 lockstart;
1596 u64 lockend;
1616 offset);
1618 PAGE_SIZE);
1628 /*
1629 * Fault pages before locking them in prepare_pages
1630 * to avoid recursive lock
1631 */
1635 }
1643 write_bytes);
1646 BTRFS_INODE_PREALLOC)) &&
1649 /*
1650 * For nodata cow case, no need to reserve
1651 * data space.
1652 */
1654 /*
1655 * our prealloc extent may be smaller than
1656 * write_bytes, so scale down.
1657 */
1659 PAGE_SIZE);
1661 sector_offset,
1665 }
1666 }
1670 reserve_bytes);
1675 write_bytes);
1676 else
1679 }
1682 again:
1683 /*
1684 * This is going to setup the pages array with the number of
1685 * pages we want, so we don't really need to worry about the
1686 * contents of pages from loop to loop
1687 */
1690 force_page_uptodate);
1693 reserve_bytes);
1695 }
1705 reserve_bytes);
1708 }
1717 /*
1718 * if we have trouble faulting in the pages, fall
1719 * back to one page at a time
1720 */
1731 PAGE_SIZE);
1732 }
1735 /* release everything except the sectors we dirtied */
1740 release_bytes);
1742 u64 __pos;
1749 release_bytes);
1750 }
1751 }
1762 GFP_NOFS);
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 {
2028 }
2030 /*
2031 * fsync call for both files and directories. This logs the inode into
2032 * the tree log instead of forcing full commits whenever possible.
2033 *
2034 * It needs to call filemap_fdatawait so that all ordered extent updates are
2035 * in the metadata btree are up to date for copying to the log.
2036 *
2037 * It drops the inode mutex before doing the tree log commit. This is an
2038 * important optimization for directories because holding the mutex prevents
2039 * new operations on the dir while we write to disk.
2040 */
2042 {
2051 u64 len;
2053 /*
2054 * The range length can be represented by u64, we have to do the typecasts
2055 * to avoid signed overflow if it's [0, LLONG_MAX] eg. from fsync()
2056 */
2062 /*
2063 * We write the dirty pages in the range and wait until they complete
2064 * out of the ->i_mutex. If so, we can flush the dirty pages by
2065 * multi-task, and make the performance up. See
2066 * btrfs_wait_ordered_range for an explanation of the ASYNC check.
2067 */
2076 /*
2077 * We might have have had more pages made dirty after calling
2078 * start_ordered_ops and before acquiring the inode's i_mutex.
2079 */
2081 /*
2082 * For a full sync, we need to make sure any ordered operations
2083 * start and finish before we start logging the inode, so that
2084 * all extents are persisted and the respective file extent
2085 * items are in the fs/subvol btree.
2086 */
2089 /*
2090 * Start any new ordered operations before starting to log the
2091 * inode. We will wait for them to finish in btrfs_sync_log().
2092 *
2093 * Right before acquiring the inode's mutex, we might have new
2094 * writes dirtying pages, which won't immediately start the
2095 * respective ordered operations - that is done through the
2096 * fill_delalloc callbacks invoked from the writepage and
2097 * writepages address space operations. So make sure we start
2098 * all ordered operations before starting to log our inode. Not
2099 * doing this means that while logging the inode, writeback
2100 * could start and invoke writepage/writepages, which would call
2101 * the fill_delalloc callbacks (cow_file_range,
2102 * submit_compressed_extents). These callbacks add first an
2103 * extent map to the modified list of extents and then create
2104 * the respective ordered operation, which means in
2105 * tree-log.c:btrfs_log_inode() we might capture all existing
2106 * ordered operations (with btrfs_get_logged_extents()) before
2107 * the fill_delalloc callback adds its ordered operation, and by
2108 * the time we visit the modified list of extent maps (with
2109 * btrfs_log_changed_extents()), we see and process the extent
2110 * map they created. We then use the extent map to construct a
2111 * file extent item for logging without waiting for the
2112 * respective ordered operation to finish - this file extent
2113 * item points to a disk location that might not have yet been
2114 * written to, containing random data - so after a crash a log
2115 * replay will make our inode have file extent items that point
2116 * to disk locations containing invalid data, as we returned
2117 * success to userspace without waiting for the respective
2118 * ordered operation to finish, because it wasn't captured by
2119 * btrfs_get_logged_extents().
2120 */
2122 }
2126 }
2129 /*
2130 * If the last transaction that changed this file was before the current
2131 * transaction and we have the full sync flag set in our inode, we can
2132 * bail out now without any syncing.
2133 *
2134 * Note that we can't bail out if the full sync flag isn't set. This is
2135 * because when the full sync flag is set we start all ordered extents
2136 * and wait for them to fully complete - when they complete they update
2137 * the inode's last_trans field through:
2138 *
2139 * btrfs_finish_ordered_io() ->
2140 * btrfs_update_inode_fallback() ->
2141 * btrfs_update_inode() ->
2142 * btrfs_set_inode_last_trans()
2143 *
2144 * So we are sure that last_trans is up to date and can do this check to
2145 * bail out safely. For the fast path, when the full sync flag is not
2146 * set in our inode, we can not do it because we start only our ordered
2147 * extents and don't wait for them to complete (that is when
2148 * btrfs_finish_ordered_io runs), so here at this point their last_trans
2149 * value might be less than or equals to fs_info->last_trans_committed,
2150 * and setting a speculative last_trans for an inode when a buffered
2151 * write is made (such as fs_info->generation + 1 for example) would not
2152 * be reliable since after setting the value and before fsync is called
2153 * any number of transactions can start and commit (transaction kthread
2154 * commits the current transaction periodically), and a transaction
2155 * commit does not start nor waits for ordered extents to complete.
2156 */
2164 /*
2165 * We've had everything committed since the last time we were
2166 * modified so clear this flag in case it was set for whatever
2167 * reason, it's no longer relevant.
2168 */
2171 /*
2172 * An ordered extent might have started before and completed
2173 * already with io errors, in which case the inode was not
2174 * updated and we end up here. So check the inode's mapping
2175 * for any errors that might have happened since we last
2176 * checked called fsync.
2177 */
2181 }
2183 /*
2184 * ok we haven't committed the transaction yet, lets do a commit
2185 */
2189 /*
2190 * We use start here because we will need to wait on the IO to complete
2191 * in btrfs_sync_log, which could require joining a transaction (for
2192 * example checking cross references in the nocow path). If we use join
2193 * here we could get into a situation where we're waiting on IO to
2194 * happen that is blocked on a transaction trying to commit. With start
2195 * we inc the extwriter counter, so we wait for all extwriters to exit
2196 * before we start blocking join'ers. This comment is to keep somebody
2197 * from thinking they are super smart and changing this to
2198 * btrfs_join_transaction *cough*Josef*cough*.
2199 */
2205 }
2210 /* Fallthrough and commit/free transaction. */
2212 }
2214 /* we've logged all the items and now have a consistent
2215 * version of the file in the log. It is possible that
2216 * someone will come in and modify the file, but that's
2217 * fine because the log is consistent on disk, and we
2218 * have references to all of the file's extents
2219 *
2220 * It is possible that someone will come in and log the
2221 * file again, but that will end up using the synchronization
2222 * inside btrfs_sync_log to keep things safe.
2223 */
2226 /*
2227 * If any of the ordered extents had an error, just return it to user
2228 * space, so that the application knows some writes didn't succeed and
2229 * can take proper action (retry for e.g.). Blindly committing the
2230 * transaction in this case, would fool userspace that everything was
2231 * successful. And we also want to make sure our log doesn't contain
2232 * file extent items pointing to extents that weren't fully written to -
2233 * just like in the non fast fsync path, where we check for the ordered
2234 * operation's error flag before writing to the log tree and return -EIO
2235 * if any of them had this flag set (btrfs_wait_ordered_range) -
2236 * therefore we need to check for errors in the ordered operations,
2237 * which are indicated by ctx.io_err.
2238 */
2243 }
2251 }
2252 }
2258 }
2259 }
2263 }
2264 out:
2270 }
2276 };
2279 {
2289 }
2293 {
2318 }
2323 {
2342 /*
2343 * We should have dropped this offset, so if we find it then
2344 * something has gone horribly wrong.
2345 */
2349 }
2353 u64 num_bytes;
2365 }
2368 u64 num_bytes;
2375 offset;
2381 }
2389 out:
2419 }
2422 }
2424 /*
2425 * Find a hole extent on given inode and change start/len to the end of hole
2426 * extent.(hole/vacuum extent whose em->start <= start &&
2427 * em->start + em->len > start)
2428 * When a hole extent is found, return 1 and modify start/len.
2429 */
2431 {
2442 /* Hole or vacuum extent(only exists in no-hole mode) */
2448 }
2451 }
2454 {
2461 u64 lockstart;
2462 u64 lockend;
2463 u64 tail_start;
2464 u64 tail_len;
2466 u64 cur_offset;
2468 u64 drop_end;
2474 u64 ino_size;
2488 /* Already in a large hole */
2491 }
2498 /*
2499 * We needn't truncate any block which is beyond the end of the file
2500 * because we are sure there is no data there.
2501 */
2502 /*
2503 * Only do this if we are in the same block and we aren't doing the
2504 * entire block.
2505 */
2512 }
2514 }
2516 /* zero back part of the first block */
2523 }
2524 }
2526 /* Check the aligned pages after the first unaligned page,
2527 * if offset != orig_start, which means the first unaligned page
2528 * including several following pages are already in holes,
2529 * the extra check can be skipped */
2531 /* after truncate page, check hole again */
2540 }
2542 }
2544 /* Check the tail unaligned part is in a hole */
2552 /* zero the front end of the last page */
2560 }
2561 }
2562 }
2567 }
2578 /*
2579 * We need to make sure we have no ordered extents in this range
2580 * and nobody raced in and read a page in this range, if we did
2581 * we need to try again.
2582 */
2590 }
2600 }
2601 }
2607 }
2613 }
2617 /*
2618 * 1 - update the inode
2619 * 1 - removing the extents in the range
2620 * 1 - adding the hole extent if no_holes isn't set
2621 */
2627 }
2649 /*
2650 * If we failed then we didn't insert our hole
2651 * entries for the area we dropped, so now the
2652 * fs is corrupted, so we must abort the
2653 * transaction.
2654 */
2658 }
2659 }
2667 }
2677 }
2690 }
2691 }
2696 }
2699 /*
2700 * If we are using the NO_HOLES feature we might have had already an
2701 * hole that overlaps a part of the region [lockstart, lockend] and
2702 * ends at (or beyond) lockend. Since we have no file extent items to
2703 * represent holes, drop_end can be less than lockend and so we must
2704 * make sure we have an extent map representing the existing hole (the
2705 * call to __btrfs_drop_extents() might have dropped the existing extent
2706 * map representing the existing hole), otherwise the fast fsync path
2707 * will not record the existence of the hole region
2708 * [existing_hole_start, lockend].
2709 */
2712 /*
2713 * Don't insert file hole extent item if it's for a range beyond eof
2714 * (because it's useless) or if it represents a 0 bytes range (when
2715 * cur_offset == drop_end).
2716 */
2721 /* Same comment as above. */
2725 }
2726 }
2728 out_trans:
2740 out_free:
2743 out:
2746 out_only_mutex:
2748 /*
2749 * If we only end up zeroing part of a page, we still need to
2750 * update the inode item, so that all the time fields are
2751 * updated as well as the necessary btrfs inode in memory fields
2752 * for detecting, at fsync time, if the inode isn't yet in the
2753 * log tree or it's there but not up to date.
2754 */
2761 }
2762 }
2767 }
2769 /* Helper structure to record which range is already reserved */
2772 u64 start;
2773 u64 len;
2774 };
2776 /*
2777 * Helper function to add falloc range
2778 *
2779 * Caller should have locked the larger range of extent containing
2780 * [start, len)
2781 */
2783 {
2790 /*
2791 * As fallocate iterate by bytenr order, we only need to check
2792 * the last range.
2793 */
2798 }
2799 insert:
2807 }
2811 {
2818 u64 cur_offset;
2819 u64 last_byte;
2820 u64 alloc_start;
2821 u64 alloc_end;
2823 u64 locked_end;
2833 /* Make sure we aren't being give some crap mode */
2840 /*
2841 * Only trigger disk allocation, don't trigger qgroup reserve
2842 *
2843 * For qgroup space, it will be checked later.
2844 */
2856 }
2858 /*
2859 * TODO: Move these two operations after we have checked
2860 * accurate reserved space, or fallocate can still fail but
2861 * with page truncated or size expanded.
2862 *
2863 * But that's a minor problem and won't do much harm BTW.
2864 */
2867 alloc_start);
2871 /*
2872 * If we are fallocating from the end of the file onward we
2873 * need to zero out the end of the block if i_size lands in the
2874 * middle of a block.
2875 */
2879 }
2881 /*
2882 * wait for ordered IO before we have any locks. We'll loop again
2883 * below with the locks held.
2884 */
2894 /* the extent lock is ordered inside the running
2895 * transaction
2896 */
2908 /*
2909 * we can't wait on the range with the transaction
2910 * running or with the extent lock held
2911 */
2920 }
2921 }
2923 /* First, check if we exceed the qgroup limit */
2931 }
2943 }
2949 }
2951 /*
2952 * Do not need to reserve unwritten extent for this
2953 * range, free reserved data space first, otherwise
2954 * it'll result in false ENOSPC error.
2955 */
2958 }
2963 }
2965 /*
2966 * If ret is still 0, means we're OK to fallocate.
2967 * Or just cleanup the list and exit.
2968 */
2975 else
2981 }
2990 /*
2991 * We didn't need to allocate any more space, but we
2992 * still extended the size of the file so we need to
2993 * update i_size and the inode item.
2994 */
3005 else
3007 }
3008 }
3009 out_unlock:
3012 out:
3014 /* Let go of our reservation. */
3020 }
3023 {
3027 u64 lockstart;
3028 u64 lockend;
3029 u64 start;
3030 u64 len;
3036 /*
3037 * *offset can be negative, in this case we start finding DATA/HOLE from
3038 * the very start of the file.
3039 */
3047 lockend--;
3060 }
3075 }
3080 else
3082 }
3086 }
3089 {
3104 }
3110 }
3111 }
3114 out:
3117 }
3120 {
3123 }
3136 #ifdef CONFIG_COMPAT
3138 #endif
3141 };
3144 {
3146 }
3149 {
3152 SLAB_MEM_SPREAD,
3153 NULL);
3158 }
3161 {
3164 /*
3165 * So with compression we will find and lock a dirty page and clear the
3166 * first one as dirty, setup an async extent, and immediately return
3167 * with the entire range locked but with nobody actually marked with
3168 * writeback. So we can't just filemap_write_and_wait_range() and
3169 * expect it to work since it will just kick off a thread to do the
3170 * actual work. So we need to call filemap_fdatawrite_range _again_
3171 * since it will wait on the page lock, which won't be unlocked until
3172 * after the pages have been marked as writeback and so we're good to go
3173 * from there. We have to do this otherwise we'll miss the ordered
3174 * extents and that results in badness. Please Josef, do not think you
3175 * know better and pull this out at some point in the future, it is
3176 * right and you are wrong.
3177 */
3184 }