| blob | 2be00e873e92a3183e142eebf010de3514475252 |
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;
537 /*
538 * There can't be any extents following eof in this case
539 * so just set the delalloc new bit for the range
540 * directly.
541 */
545 start_pos,
549 }
550 }
562 }
564 /*
565 * we've only changed i_size in ram, and we haven't updated
566 * the disk i_size. There is no need to log the inode
567 * at this time.
568 */
572 }
574 /*
575 * this drops all the extents in the cache that intersect the range
576 * [start, end]. Existing extents are split as required.
577 */
580 {
586 u64 gen;
597 }
614 }
622 }
629 }
647 else
658 }
668 }
693 }
700 }
704 modified);
707 modified);
709 }
712 }
713 next:
718 /* once for us */
720 /* once for the tree*/
722 }
727 }
729 /*
730 * this is very complex, but the basic idea is to drop all extents
731 * in the range start - end. hint_block is filled in with a block number
732 * that would be a good hint to the block allocator for this file.
733 *
734 * If an extent intersects the range but is not entirely inside the range
735 * it is either truncated or split. Anything entirely inside the range
736 * is deleted from the tree.
737 */
743 u32 extent_item_size,
745 {
788 }
790 leafs_visited++;
791 next_slot:
801 }
802 leafs_visited++;
805 }
816 }
835 /* can't happen */
837 }
839 /*
840 * Don't skip extent items representing 0 byte lengths. They
841 * used to be created (bug) if while punching holes we hit
842 * -ENOSPC condition. So if we find one here, just ensure we
843 * delete it, otherwise we would insert a new file extent item
844 * with the same key (offset) as that 0 bytes length file
845 * extent item in the call to setup_items_for_insert() later
846 * in this function.
847 */
851 }
856 }
864 }
866 /*
867 * | - range to drop - |
868 * | -------- extent -------- |
869 */
875 }
884 }
910 }
912 }
913 /*
914 * From here on out we will have actually dropped something, so
915 * last_end can be updated.
916 */
919 /*
920 * | ---- range to drop ----- |
921 * | -------- extent -------- |
922 */
927 }
941 }
944 /*
945 * | ---- range to drop ----- |
946 * | -------- extent -------- |
947 */
953 }
965 }
967 /*
968 * | ---- range to drop ----- |
969 * | ------ extent ------ |
970 */
972 delete_extent_item:
978 del_nr++;
979 }
992 extent_offset);
996 }
1004 }
1007 del_nr);
1011 }
1018 }
1021 }
1024 /*
1025 * Set path->slots[0] to first slot, so that after the delete
1026 * if items are move off from our leaf to its immediate left or
1027 * right neighbor leafs, we end up with a correct and adjusted
1028 * path->slots[0] for our insertion (if replace_extent != 0).
1029 */
1034 }
1037 /*
1038 * If btrfs_del_items() was called, it might have deleted a leaf, in
1039 * which case it unlocked our path, so check path->locks[0] matches a
1040 * write lock.
1041 */
1057 }
1060 extent_item_size,
1064 }
1071 }
1076 {
1087 }
1092 {
1095 u64 extent_end;
1120 }
1122 /*
1123 * Mark extent in the range start - end as written.
1124 *
1125 * This changes extent type from 'pre-allocated' to 'regular'. If only
1126 * part of extent is marked as written, the extent will be split into
1127 * two or three.
1128 */
1131 {
1139 u64 bytenr;
1140 u64 num_bytes;
1141 u64 extent_end;
1142 u64 orig_offset;
1143 u64 other_start;
1144 u64 other_end;
1145 u64 split;
1155 again:
1175 }
1182 }
1188 }
1219 }
1220 }
1248 }
1249 }
1260 }
1264 }
1288 }
1297 }
1300 }
1302 }
1312 }
1315 del_nr++;
1322 }
1323 }
1332 }
1335 del_nr++;
1342 }
1343 }
1348 BTRFS_FILE_EXTENT_REG);
1355 BTRFS_FILE_EXTENT_REG);
1365 }
1366 }
1367 out:
1370 }
1372 /*
1373 * on error we return an unlocked page and the error value
1374 * on success we return a locked page and 0
1375 */
1379 {
1391 }
1395 }
1396 }
1398 }
1400 /*
1401 * this just gets pages into the page cache and locks them down.
1402 */
1406 {
1414 again:
1421 }
1425 force_uptodate);
1434 }
1437 }
1439 }
1442 fail:
1446 faili--;
1447 }
1450 }
1452 /*
1453 * This function locks the extent and properly waits for data=ordered extents
1454 * to finish before allowing the pages to be modified if need.
1455 *
1456 * The return value:
1457 * 1 - the extent is locked
1458 * 0 - the extent is not locked, and everything is OK
1459 * -EAGAIN - need re-prepare the pages
1460 * the other < 0 number - Something wrong happens
1461 */
1468 {
1470 u64 start_pos;
1471 u64 last_pos;
1476 last_pos = start_pos
1484 cached_state);
1495 }
1500 }
1510 }
1517 }
1520 }
1524 {
1529 u64 num_bytes;
1546 }
1550 }
1561 }
1566 }
1570 {
1580 u64 lockstart;
1581 u64 lockend;
1601 offset);
1603 PAGE_SIZE);
1613 /*
1614 * Fault pages before locking them in prepare_pages
1615 * to avoid recursive lock
1616 */
1620 }
1628 write_bytes);
1631 BTRFS_INODE_PREALLOC)) &&
1634 /*
1635 * For nodata cow case, no need to reserve
1636 * data space.
1637 */
1639 /*
1640 * our prealloc extent may be smaller than
1641 * write_bytes, so scale down.
1642 */
1644 PAGE_SIZE);
1646 sector_offset,
1650 }
1651 }
1655 reserve_bytes);
1660 write_bytes);
1661 else
1664 }
1667 again:
1668 /*
1669 * This is going to setup the pages array with the number of
1670 * pages we want, so we don't really need to worry about the
1671 * contents of pages from loop to loop
1672 */
1675 force_page_uptodate);
1680 }
1693 }
1702 /*
1703 * if we have trouble faulting in the pages, fall
1704 * back to one page at a time
1705 */
1716 PAGE_SIZE);
1717 }
1720 /* release everything except the sectors we dirtied */
1727 u64 __pos;
1735 }
1736 }
1752 }
1768 }
1780 }
1793 }
1794 }
1798 }
1801 {
1804 loff_t pos;
1805 ssize_t written;
1806 ssize_t written_buffered;
1807 loff_t endbyte;
1820 }
1821 /*
1822 * Ensure all data is persisted. We want the next direct IO read to be
1823 * able to read what was just written.
1824 */
1836 out:
1838 }
1841 {
1856 }
1860 {
1865 u64 start_pos;
1866 u64 end_pos;
1869 ssize_t err;
1870 loff_t pos;
1872 loff_t oldsize;
1883 }
1889 }
1893 /*
1894 * We will allocate space in case nodatacow is not set,
1895 * so bail
1896 */
1898 BTRFS_INODE_PREALLOC)) ||
1902 }
1903 }
1910 }
1912 /*
1913 * If BTRFS flips readonly due to some impossible error
1914 * (fs_info->fs_state now has BTRFS_SUPER_FLAG_ERROR),
1915 * although we have opened a file as writable, we have
1916 * to stop this write operation to ensure FS consistency.
1917 */
1922 }
1924 /*
1925 * We reserve space for updating the inode when we reserve space for the
1926 * extent we are going to write, so we will enospc out there. We don't
1927 * need to start yet another transaction to update the inode as we will
1928 * update the inode when we finish writing whatever data we write.
1929 */
1935 /* Expand hole size to cover write data, preventing empty gap */
1942 }
1945 }
1959 }
1963 /*
1964 * We also have to set last_sub_trans to the current log transid,
1965 * otherwise subsequent syncs to a file that's been synced in this
1966 * transaction will appear to have already occurred.
1967 */
1976 out:
1979 }
1982 {
1990 /*
1991 * ordered_data_close is set by settattr when we are about to truncate
1992 * a file from a non-zero size to a zero size. This tries to
1993 * flush down new bytes that may have been written if the
1994 * application were using truncate to replace a file in place.
1995 */
2000 }
2003 {
2007 /*
2008 * This is only called in fsync, which would do synchronous writes, so
2009 * a plug can merge adjacent IOs as much as possible. Esp. in case of
2010 * multiple disks using raid profile, a large IO can be split to
2011 * several segments of stripe length (currently 64K).
2012 */
2020 }
2022 /*
2023 * fsync call for both files and directories. This logs the inode into
2024 * the tree log instead of forcing full commits whenever possible.
2025 *
2026 * It needs to call filemap_fdatawait so that all ordered extent updates are
2027 * in the metadata btree are up to date for copying to the log.
2028 *
2029 * It drops the inode mutex before doing the tree log commit. This is an
2030 * important optimization for directories because holding the mutex prevents
2031 * new operations on the dir while we write to disk.
2032 */
2034 {
2042 u64 len;
2044 /*
2045 * The range length can be represented by u64, we have to do the typecasts
2046 * to avoid signed overflow if it's [0, LLONG_MAX] eg. from fsync()
2047 */
2053 /*
2054 * We write the dirty pages in the range and wait until they complete
2055 * out of the ->i_mutex. If so, we can flush the dirty pages by
2056 * multi-task, and make the performance up. See
2057 * btrfs_wait_ordered_range for an explanation of the ASYNC check.
2058 */
2066 /*
2067 * We have to do this here to avoid the priority inversion of waiting on
2068 * IO of a lower priority task while holding a transaciton open.
2069 */
2074 }
2080 /*
2081 * We've had everything committed since the last time we were
2082 * modified so clear this flag in case it was set for whatever
2083 * reason, it's no longer relevant.
2084 */
2087 /*
2088 * An ordered extent might have started before and completed
2089 * already with io errors, in which case the inode was not
2090 * updated and we end up here. So check the inode's mapping
2091 * for any errors that might have happened since we last
2092 * checked called fsync.
2093 */
2097 }
2099 /*
2100 * We use start here because we will need to wait on the IO to complete
2101 * in btrfs_sync_log, which could require joining a transaction (for
2102 * example checking cross references in the nocow path). If we use join
2103 * here we could get into a situation where we're waiting on IO to
2104 * happen that is blocked on a transaction trying to commit. With start
2105 * we inc the extwriter counter, so we wait for all extwriters to exit
2106 * before we start blocking join'ers. This comment is to keep somebody
2107 * from thinking they are super smart and changing this to
2108 * btrfs_join_transaction *cough*Josef*cough*.
2109 */
2115 }
2120 /* Fallthrough and commit/free transaction. */
2122 }
2124 /* we've logged all the items and now have a consistent
2125 * version of the file in the log. It is possible that
2126 * someone will come in and modify the file, but that's
2127 * fine because the log is consistent on disk, and we
2128 * have references to all of the file's extents
2129 *
2130 * It is possible that someone will come in and log the
2131 * file again, but that will end up using the synchronization
2132 * inside btrfs_sync_log to keep things safe.
2133 */
2136 /*
2137 * If any of the ordered extents had an error, just return it to user
2138 * space, so that the application knows some writes didn't succeed and
2139 * can take proper action (retry for e.g.). Blindly committing the
2140 * transaction in this case, would fool userspace that everything was
2141 * successful. And we also want to make sure our log doesn't contain
2142 * file extent items pointing to extents that weren't fully written to -
2143 * just like in the non fast fsync path, where we check for the ordered
2144 * operation's error flag before writing to the log tree and return -EIO
2145 * if any of them had this flag set (btrfs_wait_ordered_range) -
2146 * therefore we need to check for errors in the ordered operations,
2147 * which are indicated by ctx.io_err.
2148 */
2153 }
2161 }
2162 }
2166 }
2167 out:
2173 }
2179 };
2182 {
2192 }
2196 {
2221 }
2226 {
2245 /*
2246 * We should have dropped this offset, so if we find it then
2247 * something has gone horribly wrong.
2248 */
2252 }
2256 u64 num_bytes;
2268 }
2271 u64 num_bytes;
2278 offset;
2284 }
2292 out:
2322 }
2325 }
2327 /*
2328 * Find a hole extent on given inode and change start/len to the end of hole
2329 * extent.(hole/vacuum extent whose em->start <= start &&
2330 * em->start + em->len > start)
2331 * When a hole extent is found, return 1 and modify start/len.
2332 */
2334 {
2345 /* Hole or vacuum extent(only exists in no-hole mode) */
2351 }
2354 }
2360 {
2368 cached_state);
2371 /*
2372 * We need to make sure we have no ordered extents in this range
2373 * and nobody raced in and read a page in this range, if we did
2374 * we need to try again.
2375 */
2384 }
2393 }
2395 }
2398 {
2405 u64 lockstart;
2406 u64 lockend;
2407 u64 tail_start;
2408 u64 tail_len;
2410 u64 cur_offset;
2412 u64 drop_end;
2418 u64 ino_size;
2432 /* Already in a large hole */
2435 }
2442 /*
2443 * We needn't truncate any block which is beyond the end of the file
2444 * because we are sure there is no data there.
2445 */
2446 /*
2447 * Only do this if we are in the same block and we aren't doing the
2448 * entire block.
2449 */
2456 }
2458 }
2460 /* zero back part of the first block */
2467 }
2468 }
2470 /* Check the aligned pages after the first unaligned page,
2471 * if offset != orig_start, which means the first unaligned page
2472 * including several following pages are already in holes,
2473 * the extra check can be skipped */
2475 /* after truncate page, check hole again */
2484 }
2486 }
2488 /* Check the tail unaligned part is in a hole */
2496 /* zero the front end of the last page */
2504 }
2505 }
2506 }
2511 }
2518 }
2524 }
2530 }
2534 /*
2535 * 1 - update the inode
2536 * 1 - removing the extents in the range
2537 * 1 - adding the hole extent if no_holes isn't set
2538 */
2544 }
2566 /*
2567 * If we failed then we didn't insert our hole
2568 * entries for the area we dropped, so now the
2569 * fs is corrupted, so we must abort the
2570 * transaction.
2571 */
2575 }
2576 }
2584 }
2594 }
2607 }
2608 }
2613 }
2616 /*
2617 * If we are using the NO_HOLES feature we might have had already an
2618 * hole that overlaps a part of the region [lockstart, lockend] and
2619 * ends at (or beyond) lockend. Since we have no file extent items to
2620 * represent holes, drop_end can be less than lockend and so we must
2621 * make sure we have an extent map representing the existing hole (the
2622 * call to __btrfs_drop_extents() might have dropped the existing extent
2623 * map representing the existing hole), otherwise the fast fsync path
2624 * will not record the existence of the hole region
2625 * [existing_hole_start, lockend].
2626 */
2629 /*
2630 * Don't insert file hole extent item if it's for a range beyond eof
2631 * (because it's useless) or if it represents a 0 bytes range (when
2632 * cur_offset == drop_end).
2633 */
2638 /* Same comment as above. */
2642 }
2643 }
2645 out_trans:
2657 out_free:
2660 out:
2663 out_only_mutex:
2665 /*
2666 * If we only end up zeroing part of a page, we still need to
2667 * update the inode item, so that all the time fields are
2668 * updated as well as the necessary btrfs inode in memory fields
2669 * for detecting, at fsync time, if the inode isn't yet in the
2670 * log tree or it's there but not up to date.
2671 */
2678 }
2679 }
2684 }
2686 /* Helper structure to record which range is already reserved */
2689 u64 start;
2690 u64 len;
2691 };
2693 /*
2694 * Helper function to add falloc range
2695 *
2696 * Caller should have locked the larger range of extent containing
2697 * [start, len)
2698 */
2700 {
2707 /*
2708 * As fallocate iterate by bytenr order, we only need to check
2709 * the last range.
2710 */
2715 }
2716 insert:
2724 }
2729 {
2749 }
2755 };
2758 u64 offset)
2759 {
2773 else
2778 }
2781 loff_t offset,
2782 loff_t len,
2784 {
2803 }
2805 /*
2806 * Avoid hole punching and extent allocation for some cases. More cases
2807 * could be considered, but these are unlikely common and we keep things
2808 * as simple as possible for now. Also, intentionally, if the target
2809 * range contains one or more prealloc extents together with regular
2810 * extents and holes, we drop all the existing extents and allocate a
2811 * new prealloc extent, so that we get a larger contiguous disk extent.
2812 */
2818 /*
2819 * The whole range is already a prealloc extent,
2820 * do nothing except updating the inode's i_size if
2821 * needed.
2822 */
2825 mode);
2827 }
2828 /*
2829 * Part of the range is already a prealloc extent, so operate
2830 * only on the remaining part of the range.
2831 */
2837 }
2847 }
2852 mode);
2854 }
2861 mode);
2863 }
2868 }
2873 /*
2874 * For unaligned ranges, check the pages at the boundaries, they might
2875 * map to an extent, in which case we need to partially zero them, or
2876 * they might map to a hole, in which case we need our allocation range
2877 * to cover them.
2878 */
2892 }
2893 }
2909 }
2910 }
2912 reserve_space:
2920 bytes_to_reserve);
2938 /* btrfs_prealloc_file_range releases reserved space on error */
2942 }
2943 }
2945 out:
2952 }
2956 {
2963 u64 cur_offset;
2964 u64 last_byte;
2965 u64 alloc_start;
2966 u64 alloc_end;
2968 u64 locked_end;
2978 /* Make sure we aren't being give some crap mode */
2980 FALLOC_FL_ZERO_RANGE))
2986 /*
2987 * Only trigger disk allocation, don't trigger qgroup reserve
2988 *
2989 * For qgroup space, it will be checked later.
2990 */
2996 }
3004 }
3006 /*
3007 * TODO: Move these two operations after we have checked
3008 * accurate reserved space, or fallocate can still fail but
3009 * with page truncated or size expanded.
3010 *
3011 * But that's a minor problem and won't do much harm BTW.
3012 */
3015 alloc_start);
3019 /*
3020 * If we are fallocating from the end of the file onward we
3021 * need to zero out the end of the block if i_size lands in the
3022 * middle of a block.
3023 */
3027 }
3029 /*
3030 * wait for ordered IO before we have any locks. We'll loop again
3031 * below with the locks held.
3032 */
3042 }
3048 /* the extent lock is ordered inside the running
3049 * transaction
3050 */
3062 /*
3063 * we can't wait on the range with the transaction
3064 * running or with the extent lock held
3065 */
3074 }
3075 }
3077 /* First, check if we exceed the qgroup limit */
3085 }
3097 }
3103 }
3105 /*
3106 * Do not need to reserve unwritten extent for this
3107 * range, free reserved data space first, otherwise
3108 * it'll result in false ENOSPC error.
3109 */
3112 }
3115 }
3117 /*
3118 * If ret is still 0, means we're OK to fallocate.
3119 * Or just cleanup the list and exit.
3120 */
3127 else
3133 }
3137 /*
3138 * We didn't need to allocate any more space, but we still extended the
3139 * size of the file so we need to update i_size and the inode item.
3140 */
3142 out_unlock:
3145 out:
3147 /* Let go of our reservation. */
3153 }
3156 {
3160 u64 lockstart;
3161 u64 lockend;
3162 u64 start;
3163 u64 len;
3169 /*
3170 * *offset can be negative, in this case we start finding DATA/HOLE from
3171 * the very start of the file.
3172 */
3180 lockend--;
3193 }
3208 }
3213 else
3215 }
3219 }
3222 {
3237 }
3243 }
3244 }
3247 out:
3250 }
3253 {
3256 }
3269 #ifdef CONFIG_COMPAT
3271 #endif
3274 };
3277 {
3279 }
3282 {
3285 SLAB_MEM_SPREAD,
3286 NULL);
3291 }
3294 {
3297 /*
3298 * So with compression we will find and lock a dirty page and clear the
3299 * first one as dirty, setup an async extent, and immediately return
3300 * with the entire range locked but with nobody actually marked with
3301 * writeback. So we can't just filemap_write_and_wait_range() and
3302 * expect it to work since it will just kick off a thread to do the
3303 * actual work. So we need to call filemap_fdatawrite_range _again_
3304 * since it will wait on the page lock, which won't be unlocked until
3305 * after the pages have been marked as writeback and so we're good to go
3306 * from there. We have to do this otherwise we'll miss the ordered
3307 * extents and that results in badness. Please Josef, do not think you
3308 * know better and pull this out at some point in the future, it is
3309 * right and you are wrong.
3310 */
3317 }