| blob | b5c5da215d051e2d3ef13673917b2f86b042edc8 |
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 }
480 /*
481 * after copy_from_user, pages need to be dirtied and we need to make
482 * sure holes are created between the current EOF and the start of
483 * any next extents (if required).
484 *
485 * this also makes the decision about creating an inline extent vs
486 * doing real data extents, marking pages dirty and delalloc as required.
487 */
491 {
495 u64 num_bytes;
496 u64 start_pos;
497 u64 end_of_last_block;
516 }
518 /*
519 * we've only changed i_size in ram, and we haven't updated
520 * the disk i_size. There is no need to log the inode
521 * at this time.
522 */
526 }
528 /*
529 * this drops all the extents in the cache that intersect the range
530 * [start, end]. Existing extents are split as required.
531 */
534 {
540 u64 gen;
551 }
568 }
576 }
583 }
601 else
612 }
622 }
647 }
654 }
658 modified);
661 modified);
663 }
666 }
667 next:
672 /* once for us */
674 /* once for the tree*/
676 }
681 }
683 /*
684 * this is very complex, but the basic idea is to drop all extents
685 * in the range start - end. hint_block is filled in with a block number
686 * that would be a good hint to the block allocator for this file.
687 *
688 * If an extent intersects the range but is not entirely inside the range
689 * it is either truncated or split. Anything entirely inside the range
690 * is deleted from the tree.
691 */
697 u32 extent_item_size,
699 {
742 }
744 leafs_visited++;
745 next_slot:
755 }
756 leafs_visited++;
759 }
770 }
790 /* can't happen */
792 }
794 /*
795 * Don't skip extent items representing 0 byte lengths. They
796 * used to be created (bug) if while punching holes we hit
797 * -ENOSPC condition. So if we find one here, just ensure we
798 * delete it, otherwise we would insert a new file extent item
799 * with the same key (offset) as that 0 bytes length file
800 * extent item in the call to setup_items_for_insert() later
801 * in this function.
802 */
806 }
811 }
819 }
821 /*
822 * | - range to drop - |
823 * | -------- extent -------- |
824 */
830 }
839 }
865 }
867 }
868 /*
869 * From here on out we will have actually dropped something, so
870 * last_end can be updated.
871 */
874 /*
875 * | ---- range to drop ----- |
876 * | -------- extent -------- |
877 */
882 }
896 }
899 /*
900 * | ---- range to drop ----- |
901 * | -------- extent -------- |
902 */
908 }
920 }
922 /*
923 * | ---- range to drop ----- |
924 * | ------ extent ------ |
925 */
927 delete_extent_item:
933 del_nr++;
934 }
947 extent_offset);
951 }
959 }
962 del_nr);
966 }
973 }
976 }
979 /*
980 * Set path->slots[0] to first slot, so that after the delete
981 * if items are move off from our leaf to its immediate left or
982 * right neighbor leafs, we end up with a correct and adjusted
983 * path->slots[0] for our insertion (if replace_extent != 0).
984 */
989 }
992 /*
993 * If btrfs_del_items() was called, it might have deleted a leaf, in
994 * which case it unlocked our path, so check path->locks[0] matches a
995 * write lock.
996 */
1012 }
1015 extent_item_size,
1019 }
1026 }
1031 {
1042 }
1047 {
1050 u64 extent_end;
1075 }
1077 /*
1078 * Mark extent in the range start - end as written.
1079 *
1080 * This changes extent type from 'pre-allocated' to 'regular'. If only
1081 * part of extent is marked as written, the extent will be split into
1082 * two or three.
1083 */
1086 {
1094 u64 bytenr;
1095 u64 num_bytes;
1096 u64 extent_end;
1097 u64 orig_offset;
1098 u64 other_start;
1099 u64 other_end;
1100 u64 split;
1110 again:
1130 }
1137 }
1143 }
1174 }
1175 }
1203 }
1204 }
1215 }
1219 }
1243 }
1252 }
1255 }
1257 }
1267 }
1270 del_nr++;
1277 }
1278 }
1287 }
1290 del_nr++;
1297 }
1298 }
1303 BTRFS_FILE_EXTENT_REG);
1310 BTRFS_FILE_EXTENT_REG);
1320 }
1321 }
1322 out:
1325 }
1327 /*
1328 * on error we return an unlocked page and the error value
1329 * on success we return a locked page and 0
1330 */
1334 {
1346 }
1350 }
1351 }
1353 }
1355 /*
1356 * this just gets pages into the page cache and locks them down.
1357 */
1361 {
1369 again:
1376 }
1380 force_uptodate);
1389 }
1392 }
1394 }
1397 fail:
1401 faili--;
1402 }
1405 }
1407 /*
1408 * This function locks the extent and properly waits for data=ordered extents
1409 * to finish before allowing the pages to be modified if need.
1410 *
1411 * The return value:
1412 * 1 - the extent is locked
1413 * 0 - the extent is not locked, and everything is OK
1414 * -EAGAIN - need re-prepare the pages
1415 * the other < 0 number - Something wrong happens
1416 */
1423 {
1425 u64 start_pos;
1426 u64 last_pos;
1431 last_pos = start_pos
1450 }
1454 }
1465 }
1472 }
1475 }
1479 {
1484 u64 num_bytes;
1501 }
1505 }
1515 }
1520 }
1524 loff_t pos)
1525 {
1532 u64 lockstart;
1533 u64 lockend;
1554 offset);
1556 PAGE_SIZE);
1565 /*
1566 * Fault pages before locking them in prepare_pages
1567 * to avoid recursive lock
1568 */
1572 }
1581 BTRFS_INODE_PREALLOC)) &&
1583 /*
1584 * For nodata cow case, no need to reserve
1585 * data space.
1586 */
1588 /*
1589 * our prealloc extent may be smaller than
1590 * write_bytes, so scale down.
1591 */
1593 PAGE_SIZE);
1595 sector_offset,
1599 }
1600 }
1606 write_bytes);
1607 else
1610 }
1614 again:
1615 /*
1616 * This is going to setup the pages array with the number of
1617 * pages we want, so we don't really need to worry about the
1618 * contents of pages from loop to loop
1619 */
1622 force_page_uptodate);
1636 }
1645 /*
1646 * if we have trouble faulting in the pages, fall
1647 * back to one page at a time
1648 */
1659 PAGE_SIZE);
1660 }
1662 /*
1663 * If we had a short copy we need to release the excess delaloc
1664 * bytes we reserved. We need to increment outstanding_extents
1665 * because btrfs_delalloc_release_space and
1666 * btrfs_delalloc_release_metadata will decrement it, but
1667 * we still have an outstanding extent for the chunk we actually
1668 * managed to copy.
1669 */
1671 /* release everything except the sectors we dirtied */
1678 }
1681 release_bytes);
1683 u64 __pos;
1689 release_bytes);
1690 }
1691 }
1702 GFP_NOFS);
1706 }
1722 }
1734 }
1745 release_bytes);
1746 }
1747 }
1750 }
1753 {
1757 ssize_t written;
1758 ssize_t written_buffered;
1759 loff_t endbyte;
1772 }
1773 /*
1774 * Ensure all data is persisted. We want the next direct IO read to be
1775 * able to read what was just written.
1776 */
1788 out:
1790 }
1793 {
1808 }
1812 {
1817 u64 start_pos;
1818 u64 end_pos;
1821 ssize_t err;
1822 loff_t pos;
1824 loff_t oldsize;
1832 }
1839 }
1841 /*
1842 * If BTRFS flips readonly due to some impossible error
1843 * (fs_info->fs_state now has BTRFS_SUPER_FLAG_ERROR),
1844 * although we have opened a file as writable, we have
1845 * to stop this write operation to ensure FS consistency.
1846 */
1851 }
1853 /*
1854 * We reserve space for updating the inode when we reserve space for the
1855 * extent we are going to write, so we will enospc out there. We don't
1856 * need to start yet another transaction to update the inode as we will
1857 * update the inode when we finish writing whatever data we write.
1858 */
1866 /* Expand hole size to cover write data, preventing empty gap */
1873 }
1876 }
1890 }
1894 /*
1895 * We also have to set last_sub_trans to the current log transid,
1896 * otherwise subsequent syncs to a file that's been synced in this
1897 * transaction will appear to have already occurred.
1898 */
1907 out:
1910 }
1913 {
1916 /*
1917 * ordered_data_close is set by settattr when we are about to truncate
1918 * a file from a non-zero size to a zero size. This tries to
1919 * flush down new bytes that may have been written if the
1920 * application were using truncate to replace a file in place.
1921 */
1926 }
1929 {
1937 }
1939 /*
1940 * fsync call for both files and directories. This logs the inode into
1941 * the tree log instead of forcing full commits whenever possible.
1942 *
1943 * It needs to call filemap_fdatawait so that all ordered extent updates are
1944 * in the metadata btree are up to date for copying to the log.
1945 *
1946 * It drops the inode mutex before doing the tree log commit. This is an
1947 * important optimization for directories because holding the mutex prevents
1948 * new operations on the dir while we write to disk.
1949 */
1951 {
1960 u64 len;
1962 /*
1963 * The range length can be represented by u64, we have to do the typecasts
1964 * to avoid signed overflow if it's [0, LLONG_MAX] eg. from fsync()
1965 */
1969 /*
1970 * We write the dirty pages in the range and wait until they complete
1971 * out of the ->i_mutex. If so, we can flush the dirty pages by
1972 * multi-task, and make the performance up. See
1973 * btrfs_wait_ordered_range for an explanation of the ASYNC check.
1974 */
1983 /*
1984 * We might have have had more pages made dirty after calling
1985 * start_ordered_ops and before acquiring the inode's i_mutex.
1986 */
1988 /*
1989 * For a full sync, we need to make sure any ordered operations
1990 * start and finish before we start logging the inode, so that
1991 * all extents are persisted and the respective file extent
1992 * items are in the fs/subvol btree.
1993 */
1996 /*
1997 * Start any new ordered operations before starting to log the
1998 * inode. We will wait for them to finish in btrfs_sync_log().
1999 *
2000 * Right before acquiring the inode's mutex, we might have new
2001 * writes dirtying pages, which won't immediately start the
2002 * respective ordered operations - that is done through the
2003 * fill_delalloc callbacks invoked from the writepage and
2004 * writepages address space operations. So make sure we start
2005 * all ordered operations before starting to log our inode. Not
2006 * doing this means that while logging the inode, writeback
2007 * could start and invoke writepage/writepages, which would call
2008 * the fill_delalloc callbacks (cow_file_range,
2009 * submit_compressed_extents). These callbacks add first an
2010 * extent map to the modified list of extents and then create
2011 * the respective ordered operation, which means in
2012 * tree-log.c:btrfs_log_inode() we might capture all existing
2013 * ordered operations (with btrfs_get_logged_extents()) before
2014 * the fill_delalloc callback adds its ordered operation, and by
2015 * the time we visit the modified list of extent maps (with
2016 * btrfs_log_changed_extents()), we see and process the extent
2017 * map they created. We then use the extent map to construct a
2018 * file extent item for logging without waiting for the
2019 * respective ordered operation to finish - this file extent
2020 * item points to a disk location that might not have yet been
2021 * written to, containing random data - so after a crash a log
2022 * replay will make our inode have file extent items that point
2023 * to disk locations containing invalid data, as we returned
2024 * success to userspace without waiting for the respective
2025 * ordered operation to finish, because it wasn't captured by
2026 * btrfs_get_logged_extents().
2027 */
2029 }
2033 }
2036 /*
2037 * If the last transaction that changed this file was before the current
2038 * transaction and we have the full sync flag set in our inode, we can
2039 * bail out now without any syncing.
2040 *
2041 * Note that we can't bail out if the full sync flag isn't set. This is
2042 * because when the full sync flag is set we start all ordered extents
2043 * and wait for them to fully complete - when they complete they update
2044 * the inode's last_trans field through:
2045 *
2046 * btrfs_finish_ordered_io() ->
2047 * btrfs_update_inode_fallback() ->
2048 * btrfs_update_inode() ->
2049 * btrfs_set_inode_last_trans()
2050 *
2051 * So we are sure that last_trans is up to date and can do this check to
2052 * bail out safely. For the fast path, when the full sync flag is not
2053 * set in our inode, we can not do it because we start only our ordered
2054 * extents and don't wait for them to complete (that is when
2055 * btrfs_finish_ordered_io runs), so here at this point their last_trans
2056 * value might be less than or equals to fs_info->last_trans_committed,
2057 * and setting a speculative last_trans for an inode when a buffered
2058 * write is made (such as fs_info->generation + 1 for example) would not
2059 * be reliable since after setting the value and before fsync is called
2060 * any number of transactions can start and commit (transaction kthread
2061 * commits the current transaction periodically), and a transaction
2062 * commit does not start nor waits for ordered extents to complete.
2063 */
2071 /*
2072 * We've had everything committed since the last time we were
2073 * modified so clear this flag in case it was set for whatever
2074 * reason, it's no longer relevant.
2075 */
2078 /*
2079 * An ordered extent might have started before and completed
2080 * already with io errors, in which case the inode was not
2081 * updated and we end up here. So check the inode's mapping
2082 * flags for any errors that might have happened while doing
2083 * writeback of file data.
2084 */
2088 }
2090 /*
2091 * ok we haven't committed the transaction yet, lets do a commit
2092 */
2096 /*
2097 * We use start here because we will need to wait on the IO to complete
2098 * in btrfs_sync_log, which could require joining a transaction (for
2099 * example checking cross references in the nocow path). If we use join
2100 * here we could get into a situation where we're waiting on IO to
2101 * happen that is blocked on a transaction trying to commit. With start
2102 * we inc the extwriter counter, so we wait for all extwriters to exit
2103 * before we start blocking join'ers. This comment is to keep somebody
2104 * from thinking they are super smart and changing this to
2105 * btrfs_join_transaction *cough*Josef*cough*.
2106 */
2112 }
2119 /* Fallthrough and commit/free transaction. */
2121 }
2123 /* we've logged all the items and now have a consistent
2124 * version of the file in the log. It is possible that
2125 * someone will come in and modify the file, but that's
2126 * fine because the log is consistent on disk, and we
2127 * have references to all of the file's extents
2128 *
2129 * It is possible that someone will come in and log the
2130 * file again, but that will end up using the synchronization
2131 * inside btrfs_sync_log to keep things safe.
2132 */
2135 /*
2136 * If any of the ordered extents had an error, just return it to user
2137 * space, so that the application knows some writes didn't succeed and
2138 * can take proper action (retry for e.g.). Blindly committing the
2139 * transaction in this case, would fool userspace that everything was
2140 * successful. And we also want to make sure our log doesn't contain
2141 * file extent items pointing to extents that weren't fully written to -
2142 * just like in the non fast fsync path, where we check for the ordered
2143 * operation's error flag before writing to the log tree and return -EIO
2144 * if any of them had this flag set (btrfs_wait_ordered_range) -
2145 * therefore we need to check for errors in the ordered operations,
2146 * which are indicated by ctx.io_err.
2147 */
2152 }
2160 }
2161 }
2167 }
2168 }
2172 }
2173 out:
2175 }
2181 };
2184 {
2194 }
2198 {
2223 }
2227 {
2246 /*
2247 * We should have dropped this offset, so if we find it then
2248 * something has gone horribly wrong.
2249 */
2253 }
2257 u64 num_bytes;
2269 }
2272 u64 num_bytes;
2279 offset;
2285 }
2294 out:
2325 }
2328 }
2330 /*
2331 * Find a hole extent on given inode and change start/len to the end of hole
2332 * extent.(hole/vacuum extent whose em->start <= start &&
2333 * em->start + em->len > start)
2334 * When a hole extent is found, return 1 and modify start/len.
2335 */
2337 {
2345 else
2348 }
2350 /* Hole or vacuum extent(only exists in no-hole mode) */
2356 }
2359 }
2362 {
2369 u64 lockstart;
2370 u64 lockend;
2371 u64 tail_start;
2372 u64 tail_len;
2374 u64 cur_offset;
2376 u64 drop_end;
2382 u64 ino_size;
2396 /* Already in a large hole */
2399 }
2406 /*
2407 * We needn't truncate any block which is beyond the end of the file
2408 * because we are sure there is no data there.
2409 */
2410 /*
2411 * Only do this if we are in the same block and we aren't doing the
2412 * entire block.
2413 */
2420 }
2422 }
2424 /* zero back part of the first block */
2431 }
2432 }
2434 /* Check the aligned pages after the first unaligned page,
2435 * if offset != orig_start, which means the first unaligned page
2436 * including several following pages are already in holes,
2437 * the extra check can be skipped */
2439 /* after truncate page, check hole again */
2448 }
2450 }
2452 /* Check the tail unaligned part is in a hole */
2460 /* zero the front end of the last page */
2468 }
2469 }
2470 }
2475 }
2486 /*
2487 * We need to make sure we have no ordered extents in this range
2488 * and nobody raced in and read a page in this range, if we did
2489 * we need to try again.
2490 */
2498 }
2508 }
2509 }
2515 }
2521 }
2525 /*
2526 * 1 - update the inode
2527 * 1 - removing the extents in the range
2528 * 1 - adding the hole extent if no_holes isn't set
2529 */
2535 }
2555 drop_end);
2557 /*
2558 * If we failed then we didn't insert our hole
2559 * entries for the area we dropped, so now the
2560 * fs is corrupted, so we must abort the
2561 * transaction.
2562 */
2566 }
2567 }
2575 }
2585 }
2598 }
2599 }
2604 }
2607 /*
2608 * If we are using the NO_HOLES feature we might have had already an
2609 * hole that overlaps a part of the region [lockstart, lockend] and
2610 * ends at (or beyond) lockend. Since we have no file extent items to
2611 * represent holes, drop_end can be less than lockend and so we must
2612 * make sure we have an extent map representing the existing hole (the
2613 * call to __btrfs_drop_extents() might have dropped the existing extent
2614 * map representing the existing hole), otherwise the fast fsync path
2615 * will not record the existence of the hole region
2616 * [existing_hole_start, lockend].
2617 */
2620 /*
2621 * Don't insert file hole extent item if it's for a range beyond eof
2622 * (because it's useless) or if it represents a 0 bytes range (when
2623 * cur_offset == drop_end).
2624 */
2628 /* Same comment as above. */
2632 }
2633 }
2635 out_trans:
2647 out_free:
2650 out:
2653 out_only_mutex:
2655 /*
2656 * If we only end up zeroing part of a page, we still need to
2657 * update the inode item, so that all the time fields are
2658 * updated as well as the necessary btrfs inode in memory fields
2659 * for detecting, at fsync time, if the inode isn't yet in the
2660 * log tree or it's there but not up to date.
2661 */
2668 }
2669 }
2674 }
2676 /* Helper structure to record which range is already reserved */
2679 u64 start;
2680 u64 len;
2681 };
2683 /*
2684 * Helper function to add falloc range
2685 *
2686 * Caller should have locked the larger range of extent containing
2687 * [start, len)
2688 */
2690 {
2697 /*
2698 * As fallocate iterate by bytenr order, we only need to check
2699 * the last range.
2700 */
2705 }
2706 insert:
2714 }
2718 {
2724 u64 cur_offset;
2725 u64 last_byte;
2726 u64 alloc_start;
2727 u64 alloc_end;
2729 u64 locked_end;
2739 /* Make sure we aren't being give some crap mode */
2746 /*
2747 * Only trigger disk allocation, don't trigger qgroup reserve
2748 *
2749 * For qgroup space, it will be checked later.
2750 */
2761 }
2763 /*
2764 * TODO: Move these two operations after we have checked
2765 * accurate reserved space, or fallocate can still fail but
2766 * with page truncated or size expanded.
2767 *
2768 * But that's a minor problem and won't do much harm BTW.
2769 */
2772 alloc_start);
2776 /*
2777 * If we are fallocating from the end of the file onward we
2778 * need to zero out the end of the block if i_size lands in the
2779 * middle of a block.
2780 */
2784 }
2786 /*
2787 * wait for ordered IO before we have any locks. We'll loop again
2788 * below with the locks held.
2789 */
2799 /* the extent lock is ordered inside the running
2800 * transaction
2801 */
2813 /*
2814 * we can't wait on the range with the transaction
2815 * running or with the extent lock held
2816 */
2825 }
2826 }
2828 /* First, check if we exceed the qgroup limit */
2836 else
2839 }
2851 }
2857 /*
2858 * Do not need to reserve unwritten extent for this
2859 * range, free reserved data space first, otherwise
2860 * it'll result in false ENOSPC error.
2861 */
2864 }
2869 }
2871 /*
2872 * If ret is still 0, means we're OK to fallocate.
2873 * Or just cleanup the list and exit.
2874 */
2881 else
2886 }
2895 /*
2896 * We didn't need to allocate any more space, but we
2897 * still extended the size of the file so we need to
2898 * update i_size and the inode item.
2899 */
2910 else
2912 }
2913 }
2914 out_unlock:
2917 out:
2919 /* Let go of our reservation. */
2924 }
2927 {
2931 u64 lockstart;
2932 u64 lockend;
2933 u64 start;
2934 u64 len;
2940 /*
2941 * *offset can be negative, in this case we start finding DATA/HOLE from
2942 * the very start of the file.
2943 */
2951 lockend--;
2963 }
2978 }
2983 else
2985 }
2989 }
2992 {
3007 }
3013 }
3014 }
3017 out:
3020 }
3033 #ifdef CONFIG_COMPAT
3035 #endif
3038 };
3041 {
3043 }
3046 {
3049 SLAB_MEM_SPREAD,
3050 NULL);
3055 }
3058 {
3061 /*
3062 * So with compression we will find and lock a dirty page and clear the
3063 * first one as dirty, setup an async extent, and immediately return
3064 * with the entire range locked but with nobody actually marked with
3065 * writeback. So we can't just filemap_write_and_wait_range() and
3066 * expect it to work since it will just kick off a thread to do the
3067 * actual work. So we need to call filemap_fdatawrite_range _again_
3068 * since it will wait on the page lock, which won't be unlocked until
3069 * after the pages have been marked as writeback and so we're good to go
3070 * from there. We have to do this otherwise we'll miss the ordered
3071 * extents and that results in badness. Please Josef, do not think you
3072 * know better and pull this out at some point in the future, it is
3073 * right and you are wrong.
3074 */
3081 }