| blob | 27c93b5f029df92b17c22456c0bfe7a5a3fa085c |
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
4 * Copyright (c) 2016-2018 Christoph Hellwig.
5 * All Rights Reserved.
6 */
7 #include <linux/iomap.h>
35 #define XFS_WRITEIO_ALIGN(mp,off) (((off) >> mp->m_writeio_log) \
36 << mp->m_writeio_log)
38 void
43 {
56 else
58 }
63 }
65 static void
69 xfs_fileoff_t offset_fsb,
70 xfs_fileoff_t end_fsb)
71 {
78 }
80 xfs_extlen_t
83 xfs_extlen_t extsize)
84 {
89 /*
90 * Round up the allocation request to a stripe unit
91 * (m_dalign) boundary if the file size is >= stripe unit
92 * size, and we are allocating past the allocation eof.
93 *
94 * If mounted with the "-o swalloc" option the alignment is
95 * increased from the strip unit size to the stripe width.
96 */
104 }
106 /*
107 * Always round up the allocation request to an extent boundary
108 * (when file on a real-time subvolume or has di_extsize hint).
109 */
113 else
115 }
118 }
120 STATIC int
123 xfs_extlen_t extsize,
125 {
137 }
139 }
141 STATIC int
145 {
147 "Access to block zero in inode %llu "
148 "start_block: %llx start_off: %llx "
156 }
158 int
161 xfs_off_t offset,
165 {
167 xfs_fileoff_t offset_fsb;
168 xfs_fileoff_t last_fsb;
170 xfs_extlen_t extsz;
190 /*
191 * Assert that the in-core extent list is present since this can
192 * call xfs_iread_extents() and we only have the ilock shared.
193 * This should be safe because the lock was held around a bmapi
194 * call in the caller and we only need it to access the in-core
195 * list.
196 */
198 XFS_IFEXTENTS);
207 }
221 }
223 /*
224 * Drop the shared lock acquired by the caller, attach the dquot if
225 * necessary and move on to transaction setup.
226 */
232 /*
233 * For DAX, we do not allocate unwritten extents, but instead we zero
234 * the block before we commit the transaction. Ideally we'd like to do
235 * this outside the transaction context, but if we commit and then crash
236 * we may not have zeroed the blocks and this will be exposed on
237 * recovery of the allocation. Hence we must zero before commit.
238 *
239 * Further, if we are mapping unwritten extents here, we need to zero
240 * and convert them to written so that we don't need an unwritten extent
241 * callback for DAX. This also means that we need to be able to dip into
242 * the reserve block pool for bmbt block allocation if there is no space
243 * left but we need to do unwritten extent conversion.
244 */
250 }
251 }
266 /*
267 * From this point onwards we overwrite the imap pointer that the
268 * caller gave to us.
269 */
276 /*
277 * Complete the transaction
278 */
283 /*
284 * Copy any maps to caller's array and return any error.
285 */
289 }
294 out_unlock:
298 out_res_cancel:
300 out_trans_cancel:
303 }
305 STATIC bool
309 xfs_fsblock_t alloc_blocks)
310 {
316 /* no hi watermark, no throttle */
320 /* under the lo watermark, no throttle */
325 }
327 STATIC void
334 {
339 /* no dq, or over hi wmark, squash the prealloc completely */
344 }
353 }
358 /* only overwrite the throttle values if we are more aggressive */
362 }
363 }
365 /*
366 * If we are doing a write at the end of the file and there are no allocations
367 * past this one, then extend the allocation out to the file system's write
368 * iosize.
369 *
370 * If we don't have a user specified preallocation size, dynamically increase
371 * the preallocation size as the size of the file grows. Cap the maximum size
372 * at a single extent or less if the filesystem is near full. The closer the
373 * filesystem is to full, the smaller the maximum prealocation.
374 *
375 * As an exception we don't do any preallocation at all if the file is smaller
376 * than the minimum preallocation and we are using the default dynamic
377 * preallocation scheme, as it is likely this is the only write to the file that
378 * is going to be done.
379 *
380 * We clean up any extra space left over when the file is closed in
381 * xfs_inactive().
382 */
383 STATIC xfs_fsblock_t
386 loff_t offset,
387 loff_t count,
389 {
396 xfs_fsblock_t qblocks;
407 /*
408 * If an explicit allocsize is set, the file is small, or we
409 * are writing behind a hole, then use the minimum prealloc:
410 */
417 /*
418 * Determine the initial size of the preallocation. We are beyond the
419 * current EOF here, but we need to take into account whether this is
420 * a sparse write or an extending write when determining the
421 * preallocation size. Hence we need to look up the extent that ends
422 * at the current write offset and use the result to determine the
423 * preallocation size.
424 *
425 * If the extent is a hole, then preallocation is essentially disabled.
426 * Otherwise we take the size of the preceding data extent as the basis
427 * for the preallocation size. If the size of the extent is greater than
428 * half the maximum extent length, then use the current offset as the
429 * basis. This ensures that for large files the preallocation size
430 * always extends to MAXEXTLEN rather than falling short due to things
431 * like stripe unit/width alignment of real extents.
432 */
435 else
441 /*
442 * MAXEXTLEN is not a power of two value but we round the prealloc down
443 * to the nearest power of two value after throttling. To prevent the
444 * round down from unconditionally reducing the maximum supported prealloc
445 * size, we round up first, apply appropriate throttling, round down and
446 * cap the value to MAXEXTLEN.
447 */
449 alloc_blocks);
455 shift++;
457 shift++;
459 shift++;
461 shift++;
462 }
464 /*
465 * Check each quota to cap the prealloc size, provide a shift value to
466 * throttle with and adjust amount of available space.
467 */
478 /*
479 * The final prealloc size is set to the minimum of free space available
480 * in each of the quotas and the overall filesystem.
481 *
482 * The shift throttle value is set to the maximum value as determined by
483 * the global low free space values and per-quota low free space values.
484 */
490 /*
491 * rounddown_pow_of_two() returns an undefined result if we pass in
492 * alloc_blocks = 0.
493 */
499 /*
500 * If we are still trying to allocate more space than is
501 * available, squash the prealloc hard. This can happen if we
502 * have a large file on a small filesystem and the above
503 * lowspace thresholds are smaller than MAXEXTLEN.
504 */
507 check_writeio:
513 }
515 static int
518 loff_t offset,
519 loff_t count,
522 {
527 xfs_fileoff_t maxbytes_fsb =
529 xfs_fileoff_t end_fsb;
547 }
555 }
564 /*
565 * For reflink files we may need a delalloc reservation when
566 * overwriting shared extents. This includes zeroing of
567 * existing extents that contain data.
568 */
576 }
580 }
585 }
591 /*
592 * We cap the maximum length we map here to MAX_WRITEBACK_PAGES pages
593 * to keep the chunks of work done where somewhat symmetric with the
594 * work writeback does. This is a completely arbitrary number pulled
595 * out of thin air as a best guess for initial testing.
596 *
597 * Note that the values needs to be less than 32-bits wide until
598 * the lower level functions are updated.
599 */
607 xfs_extlen_t align;
608 xfs_off_t end_offset;
609 xfs_fileoff_t p_end_fsb;
613 prealloc_blocks;
622 }
623 }
625 retry:
628 eof);
634 /* retry without any preallocation */
639 }
640 /*FALLTHRU*/
643 }
645 /*
646 * Flag newly allocated delalloc blocks with IOMAP_F_NEW so we punch
647 * them out if the write happens to fail.
648 */
651 done:
659 }
663 out_unlock:
666 }
668 /*
669 * Pass in a delayed allocate extent, convert it to real extents;
670 * return to the caller the extent we create which maps on top of
671 * the originating callers request.
672 *
673 * Called without a lock on the inode.
674 *
675 * We no longer bother to look at the incoming map - all we have to
676 * guarantee is that whatever we allocate fills the required range.
677 */
678 int
682 xfs_off_t offset,
685 {
690 xfs_filblks_t count_fsb;
700 /*
701 * Make sure that the dquots are there.
702 */
714 /*
715 * Set up a transaction with which to allocate the
716 * backing store for the file. Do allocations in a
717 * loop until we get some space in the range we are
718 * interested in. The other space that might be allocated
719 * is in the delayed allocation extent on which we sit
720 * but before our buffer starts.
721 */
725 /*
726 * We have already reserved space for the extent and any
727 * indirect blocks when creating the delalloc extent,
728 * there is no need to reserve space in this transaction
729 * again.
730 */
739 /*
740 * it is possible that the extents have changed since
741 * we did the read call as we dropped the ilock for a
742 * while. We have to be careful about truncates or hole
743 * punchs here - we are not allowed to allocate
744 * non-delalloc blocks here.
745 *
746 * The only protection against truncation is the pages
747 * for the range we are being asked to convert are
748 * locked and hence a truncate will block on them
749 * first.
750 *
751 * As a result, if we go beyond the range we really
752 * need and hit an delalloc extent boundary followed by
753 * a hole while we have excess blocks in the map, we
754 * will fill the hole incorrectly and overrun the
755 * transaction reservation.
756 *
757 * Using a single map prevents this as we are forced to
758 * check each map we look for overlap with the desired
759 * range and abort as soon as we find it. Also, given
760 * that we only return a single map, having one beyond
761 * what we can return is probably a bit silly.
762 *
763 * We also need to check that we don't go beyond EOF;
764 * this is a truncate optimisation as a truncate sets
765 * the new file size before block on the pages we
766 * currently have locked under writeback. Because they
767 * are about to be tossed, we don't need to write them
768 * back....
769 */
773 XFS_DATA_FORK);
783 }
784 }
786 /*
787 * From this point onwards we overwrite the imap
788 * pointer that the caller gave to us.
789 */
803 }
805 /*
806 * See if we were able to allocate an extent that
807 * covers at least part of the callers request
808 */
817 }
819 /*
820 * So far we have not mapped the requested part of the
821 * file, just surrounding data, try again.
822 */
825 }
827 trans_cancel:
829 error0:
832 }
834 int
837 xfs_off_t offset,
838 xfs_off_t count,
840 {
842 xfs_fileoff_t offset_fsb;
843 xfs_filblks_t count_fsb;
844 xfs_filblks_t numblks_fsb;
847 xfs_bmbt_irec_t imap;
849 xfs_fsize_t i_size;
850 uint resblks;
859 /*
860 * Reserve enough blocks in this transaction for two complete extent
861 * btree splits. We may be converting the middle part of an unwritten
862 * extent and in this case we will insert two new extents in the btree
863 * each of which could cause a full split.
864 *
865 * This reservation amount will be used in the first call to
866 * xfs_bmbt_split() to select an AG with enough space to satisfy the
867 * rest of the operation.
868 */
872 /*
873 * Set up a transaction to convert the range of extents
874 * from unwritten to real. Do allocations in a loop until
875 * we have covered the range passed in.
876 *
877 * Note that we can't risk to recursing back into the filesystem
878 * here as we might be asked to write out the same inode that we
879 * complete here and might deadlock on the iolock.
880 */
889 /*
890 * Modify the unwritten extent state of the buffer.
891 */
899 /*
900 * Log the updated inode size as we go. We have to be careful
901 * to only log it up to the actual write offset if it is
902 * halfway into a block.
903 */
913 }
924 /*
925 * The numblks_fsb value should always get
926 * smaller, otherwise the loop is stuck.
927 */
930 }
937 error_on_bmapi_transaction:
941 }
948 {
953 }
959 {
963 }
965 static int
970 {
974 /*
975 * COW writes may allocate delalloc space or convert unwritten COW
976 * extents, so we need to make sure to take the lock exclusively here.
977 */
979 /*
980 * FIXME: It could still overwrite on unshared extents and not
981 * need allocation.
982 */
986 }
988 /*
989 * Extents not yet cached requires exclusive access, don't block. This
990 * is an opencoded xfs_ilock_data_map_shared() call but with
991 * non-blocking behaviour.
992 */
997 }
999 relock:
1005 }
1007 /*
1008 * The reflink iflag could have changed since the earlier unlocked
1009 * check, so if we got ILOCK_SHARED for a write and but we're now a
1010 * reflink inode we have to switch to ILOCK_EXCL and relock.
1011 */
1016 }
1020 }
1022 static int
1025 loff_t offset,
1026 loff_t length,
1029 {
1043 /* Reserve delalloc blocks for regular writeback. */
1045 iomap);
1046 }
1048 /*
1049 * Lock the inode in the manner required for the specified operation and
1050 * check for as many conditions that would result in blocking as
1051 * possible. This removes most of the non-blocking checks from the
1052 * mapping code below.
1053 */
1070 /* Trim the mapping to the nearest shared extent boundary. */
1074 }
1076 /* Non-modifying mapping requested, so we are done */
1080 /*
1081 * Break shared extents if necessary. Checks for non-blocking IO have
1082 * been done up front, so we don't need to do them here.
1083 */
1085 /* if zeroing doesn't need COW allocation, then we are done. */
1091 /* may drop and re-acquire the ilock */
1100 }
1104 }
1106 /* Don't need to allocate over holes when doing zeroing operations. */
1113 /* If nowait is set bail since we are going to make allocations. */
1117 }
1119 /*
1120 * We cap the maximum length we map to a sane size to keep the chunks
1121 * of work done where somewhat symmetric with the work writeback does.
1122 * This is a completely arbitrary number pulled out of thin air as a
1123 * best guess for initial testing.
1124 *
1125 * Note that the values needs to be less than 32-bits wide until the
1126 * lower level functions are updated.
1127 */
1130 /*
1131 * xfs_iomap_write_direct() expects the shared lock. It is unlocked on
1132 * return.
1133 */
1137 nimaps);
1144 out_finish:
1155 out_found:
1161 out_unlock:
1164 }
1166 static int
1169 loff_t offset,
1170 loff_t length,
1171 ssize_t written,
1173 {
1175 xfs_fileoff_t start_fsb;
1176 xfs_fileoff_t end_fsb;
1179 /*
1180 * Behave as if the write failed if drop writes is enabled. Set the NEW
1181 * flag to force delalloc cleanup.
1182 */
1186 }
1188 /*
1189 * start_fsb refers to the first unused block after a short write. If
1190 * nothing was written, round offset down to point at the first block in
1191 * the range.
1192 */
1195 else
1199 /*
1200 * Trim delalloc blocks if they were allocated by this write and we
1201 * didn't manage to write the whole range.
1202 *
1203 * We don't need to care about racing delalloc as we hold i_mutex
1204 * across the reserve/allocate/unreserve calls. If there are delalloc
1205 * blocks in the range, they are ours.
1206 */
1217 }
1218 }
1221 }
1223 static int
1226 loff_t offset,
1227 loff_t length,
1228 ssize_t written,
1231 {
1236 }
1241 };
1243 static int
1246 loff_t offset,
1247 loff_t length,
1250 {
1264 /* if there are no attribute fork or extents, return ENOENT */
1268 }
1273 out_unlock:
1279 }
1282 }
1286 };